internal

type BatchResponse struct {
	Status  string `json:"status"`
	Message string `json:"message"`
}

type Bookmark struct {
	Cursor string `json:"last_record"`
}

type Catalog struct {
	Streams []Stream `json:"streams,omitempty"`
}

type DiscoverSettings struct {
	AutoSelectTables      bool
	ExcludedTables        []string
	UseIncrementalSync    bool
	TreatTinyIntAsBoolean bool
}

type ImportBatch struct {
	// The name of the destination table the data is being pushed to.
	// Table names must be unique in each destination schema, or loading issues will occur.
	Table string `json:"table_name"`

	// A Schema object containing the JSON schema describing the record(s) in the Message object’s data property.
	// Records must conform to this schema or an error will be returned when the request is sent.
	Schema StreamSchema `json:"schema"`

	// An array of Message objects, each representing a record to be upserted into the table.
	Messages []ImportMessage `json:"messages"`

	// An array of strings representing the Primary Key fields in the source table.
	// Each field in the list must be the name of a top-level property defined in the Schema object.
	// Primary Key fields cannot be contained in an object or an array.
	PrimaryKeys []string `json:"key_names"`
}

type ImportMessage struct {
	// This will always be upsert.
	Action string `json:"action"`

	// An integer that tells the Import API the order in which
	// data points in the request body should be considered for loading.
	// This data will be stored in the destination table in the _sdc_sequence column.
	EmittedAt int64 `json:"sequence"`

	// The record to be upserted into a table.
	// The record data must conform to the JSON schema contained in the request’s Schema object.
	Data map[string]interface{} `json:"data"`
}

type Logger interface {
	Log(message string)
	Info(message string)
	Error(message string)
	Schema(Catalog) error
	StreamSchema(Stream) error
	Record(Record, Stream) error
	State(State) error
	Flush(Stream) error
}

type Metadata struct {
	Metadata NodeMetadata `json:"metadata"`
}

type MetadataCollection []Metadata

type NodeMetadata struct {
	// Either true or false. Indicates that this node in the schema has been selected by the user for replication.
	Selected bool `json:"selected"`

	// Either FULL_TABLE, INCREMENTAL, or LOG_BASED. The replication method to use for a stream.
	ReplicationMethod string `json:"replication-method,omitempty"`

	// The name of a property in the source to use as a "bookmark".
	// For example, this will often be an "updated-at" field or an auto-incrementing primary key (requires replication-method).
	ReplicationKey string `json:"replication-key,omitempty"`

	// Either available, automatic, or unsupported.
	// 1. "available" means the field is available for selection,
	// and the tap will only emit values for that field if it is marked with "selected": true.
	// 2. "automatic" means that the tap will emit values for the field.
	// 3. "unsupported" means that the field exists in the source data but the tap is unable to provide it.
	Inclusion string `json:"inclusion,omitempty"`

	// Either true or false.
	// Indicates if a node in the schema should be replicated if
	// a user has not expressed any opinion on whether or not to replicate it.
	SelectedByDefault bool `json:"selected-by-default,omitempty"`

	// List of the fields that could be used as replication keys.
	ValidReplicationKeys []string `json:"valid-replication-keys,omitempty"`

	// Used to force the replication method to either FULL_TABLE or INCREMENTAL.
	ForcedReplicationMethod string `json:"forced-replication-method,omitempty"`

	// List of key properties for a database table.
	TableKeyProperties []string `json:"table-key-properties,omitempty"`

	// The name of the stream.
	SchemaName string `json:"schema-name,omitempty"`

	// Either true or false. Indicates whether a stream corresponds to a database view.
	IsView bool `json:"is-view,omitempty"`

	// Name of database.
	DatabaseName string `json:"database-name,omitempty"`

	// Represents the datatype of a database column.
	SqlDataType string `json:"sql-datatype,omitempty"`

	// The breadcrumb object defines the path into the schema to the node to which the metadata belongs.
	//  Metadata for a stream will have an empty breadcrumb.
	// example for a stream: "breadcrumb": []
	// example for a property: "breadcrumb": ["properties", "id"]
	BreadCrumb []string `json:"breadcrumb"`
}

type OnCursor func(*psdbconnect.TableCursor) error

type OnResult func(*sqltypes.Result) error

type PlanetScaleDatabase interface {
	CanConnect(ctx context.Context, ps PlanetScaleSource) error
	Read(ctx context.Context, params ReadParams) (*SerializedCursor, error)
	Close() error
}

type PlanetScaleEdgeDatabase struct {
	Logger Logger
	Mysql  PlanetScaleEdgeMysqlAccess
	// contains filtered or unexported fields
}

type PlanetScaleEdgeMysqlAccess interface {
	PingContext(context.Context, PlanetScaleSource) error
	GetTableNames(context.Context, PlanetScaleSource) ([]string, error)
	GetTableSchema(context.Context, PlanetScaleSource, string, bool) (map[string]StreamProperty, error)
	GetTablePrimaryKeys(context.Context, PlanetScaleSource, string) ([]string, error)
	GetVitessShards(ctx context.Context, psc PlanetScaleSource) ([]string, error)
	GetVitessTablets(ctx context.Context, psc PlanetScaleSource) ([]VitessTablet, error)
	Close() error
}

type PlanetScaleSource struct {
	Host     string `json:"host"`
	Database string `json:"database"`
	Username string `json:"username"`
	Password string `json:"password"`
	Shards   string `json:"shards"`
}

type ReadParams struct {
	Source            PlanetScaleSource
	Table             Stream
	LastKnownPosition *psdbconnect.TableCursor
	Columns           []string
	OnResult          OnResult
	OnCursor          OnCursor
	TabletType        psdbconnect.TabletType
	Cells             []string
}

type Record struct {
	// a constant with value "Record"
	Type string `json:"type"`

	// The string name of the stream
	Stream string `json:"stream"`

	// The time this record was observed in the source.
	// This should be an RFC3339 formatted date-time, like "2017-11-20T16:45:33.000Z".
	TimeExtracted string `json:"time_extracted"`

	// A JSON map containing a streamed data point
	Data map[string]interface{} `json:"record"`
}

type RecordWriter interface {
	Flush(stream Stream) error
	Record(record Record, stream Stream) error
	State(state State) error
}

type SerializedCursor struct {
	Cursor string `json:"cursor"`
}

type ShardStates struct {
	Shards map[string]*SerializedCursor `json:"shards"`
}

type State struct {
	Streams map[string]ShardStates `json:"bookmarks"`
}

type StateMessage struct {
	Type  string `json:"type"`
	Value State  `json:"value"`
}

type StatusLogger interface {
	Log(message string)
	Info(message string)
	Error(message string)
}

type Stream struct {
	// Type is a constant of value "SCHEMA"
	Type string `json:"type"`

	// The name of the stream.
	Name string `json:"stream"`

	// The unique identifier for the stream.
	// This is allowed to be different from the name of the stream
	// in order to allow for sources that have duplicate stream names.
	ID string `json:"tap_stream_id"`

	// The JSON schema for the stream.
	Schema StreamSchema `json:"schema"`

	// For a database source, the name of the table.
	TableName string `json:"table-name"`

	// Each piece of metadata has the following canonical shape:
	//{
	//  "metadata" : {
	//    "selected" : true,
	//    "some-other-metadata" : "whatever"
	//  },
	//  "breadcrumb" : ["properties", "some-field-name"]
	//}
	Metadata MetadataCollection `json:"metadata"`

	// A list of strings indicating which properties make up the primary key for this stream.
	// Each item in the list must be the name of a top-level property defined in the schema
	KeyProperties []string `json:"key_properties"`

	// A list of strings indicating which properties the tap is using as bookmarks.
	// Each item in the list must be the name of a top-level property defined in the schema.
	CursorProperties []string `json:"bookmark_properties"`
}

type StreamProperty struct {
	Types        []string `json:"type"`
	CustomFormat string   `json:"format,omitempty"`
}

type StreamSchema struct {
	Type                    []string                  `json:"type"`
	HasAdditionalProperties bool                      `json:"additionalProperties"`
	Properties              map[string]StreamProperty `json:"properties"`
}

type VitessTablet struct {
	Cell                 string
	Keyspace             string
	Shard                string
	TabletType           string
	State                string
	Alias                string
	Hostname             string
	PrimaryTermStartTime string
}

type WrappedState struct {
	Value State `json:"value"`
}