types

type ActionRow struct {
}

type AdapterType string

type Catalog struct {
	SelectedStreams map[string][]StreamMetadata `json:"selected_streams,omitempty"`
	Streams         []*ConfiguredStream         `json:"streams,omitempty"`
}

type Chunk struct {
	Min any `json:"min"`
	Max any `json:"max"`
}

type ConfiguredStream struct {
	StreamMetadata          StreamMetadata `json:"-"`
	InitialCursorStateValue any            `json:"-"` // Cached initial state value

	Stream *Stream `json:"stream,omitempty"`

	// Column that's being used as cursor; MUST NOT BE mutated
	//
	// Cursor field is used in Incremental and in Mixed type CDC Read where connector uses
	// this field as recovery column incase of some inconsistencies
	CursorField    string   `json:"cursor_field,omitempty"`
	ExcludeColumns []string `json:"exclude_columns,omitempty"` // TODO: Implement excluding columns from fetching
}

type ConnectionStatus string

type DataType string

type GlobalState struct {
	// Global State shared by streams
	State any `json:"state"`
	// Attaching Streams to Global State helps in recognizing the tables that the state belongs to.
	//
	// This results in helping connector determine what streams were synced during the last sync in
	// Group read. and also helps connectors to migrate from incremental to CDC Read without the need to
	// full load with the help of using cursor value and field as recovery cursor for CDC
	Streams *Set[string] `json:"streams"`
}

type Hashable interface {
	Hash() string
}

type Identifier interface {
	ID() string
}

type Iterable interface {
	Next() bool
	Err() error
}

type Log struct {
	Level   string `json:"level,omitempty"`
	Message string `json:"message,omitempty"`
}

type Message struct {
	Type             MessageType            `json:"type"`
	Log              *Log                   `json:"log,omitempty"`
	ConnectionStatus *StatusRow             `json:"connectionStatus,omitempty"`
	State            *State                 `json:"state,omitempty"`
	Catalog          *Catalog               `json:"catalog,omitempty"`
	Action           *ActionRow             `json:"action,omitempty"`
	Spec             map[string]interface{} `json:"spec,omitempty"`
}

type MessageType string

type Property struct {
	Type *Set[DataType] `json:"type,omitempty"`
}

type RawRecord struct {
	Data           map[string]any `parquet:"data,json"`
	OlakeID        string         `parquet:"_olake_id"`
	OlakeTimestamp time.Time      `parquet:"_olake_timestamp"`
	OperationType  string         `parquet:"_op_type"` // "r" for read/backfill, "c" for create, "u" for update, "d" for delete
	CdcTimestamp   time.Time      `parquet:"_cdc_timestamp"`
}

type Record map[string]any

type Set[T comparable] struct {
	// contains filtered or unexported fields
}

type State struct {
	*sync.RWMutex `json:"-"`
	Type          StateType      `json:"type"`
	Global        *GlobalState   `json:"global,omitempty"`
	Streams       []*StreamState `json:"streams,omitempty"` // TODO: make it set
}

type StateInterface interface {
	ResetStreams()
	SetType(typ StateType)
	GetCursor(stream *ConfiguredStream, key string) any
	SetCursor(stream *ConfiguredStream, key, value any)
	GetChunks(stream *ConfiguredStream) *Set[Chunk]
	SetChunks(stream *ConfiguredStream, chunks *Set[Chunk])
	RemoveChunk(stream *ConfiguredStream, chunk Chunk)
	SetGlobal(globalState any, streams ...string)
}

type StateType string

type StatusRow struct {
	Status  ConnectionStatus `json:"status,omitempty"`
	Message string           `json:"message,omitempty"`
}

type Stream struct {
	// Name of the Stream
	Name string `json:"name,omitempty"`
	// Namespace of the Stream, or Database it belongs to
	// helps in identifying collections with same name in different database
	Namespace string `json:"namespace,omitempty"`
	// Possible Schema of the Stream
	Schema *TypeSchema `json:"type_schema,omitempty"`
	// Supported sync modes from driver for the respective Stream
	SupportedSyncModes *Set[SyncMode] `json:"supported_sync_modes,omitempty"`
	// Primary key if available
	SourceDefinedPrimaryKey *Set[string] `json:"source_defined_primary_key,omitempty"`
	// Available cursor fields supported by driver
	AvailableCursorFields *Set[string] `json:"available_cursor_fields,omitempty"`
	// Input of JSON Schema from Client to be parsed by driver
	AdditionalProperties string `json:"additional_properties,omitempty"`
	// Renderable JSON Schema for additional properties supported by respective driver for individual stream
	AdditionalPropertiesSchema schema.JSONSchema `json:"additional_properties_schema,omitempty"`
	SyncMode                   SyncMode          `json:"sync_mode,omitempty"` // Mode being used for syncing data
}

type StreamInterface interface {
	ID() string
	Self() *ConfiguredStream
	Name() string
	Namespace() string
	Schema() *TypeSchema
	GetStream() *Stream
	GetSyncMode() SyncMode
	SupportedSyncModes() *Set[SyncMode]
	Cursor() string
	Validate(source *Stream) error
	NormalizationEnabled() bool
}

type StreamMetadata struct {
	ChunkColumn    string `json:"chunk_column,omitempty"`
	PartitionRegex string `json:"partition_regex"`
	StreamName     string `json:"stream_name"`
	AppendMode     bool   `json:"append_mode,omitempty"`
	Normalization  bool   `json:"normalization" default:"false"`
}

type StreamState struct {
	HoldsValue atomic.Bool `json:"-"` // If State holds some value and should not be excluded during unmarshaling then value true
	Stream     string      `json:"stream"`
	Namespace  string      `json:"namespace"`
	SyncMode   string      `json:"sync_mode"`
	State      sync.Map    `json:"state"`
}

type SyncMode string

type TypeSchema struct {
	Properties sync.Map `json:"-"`
	// contains filtered or unexported fields
}

type WriterConfig struct {
	Type         AdapterType `json:"type"`
	WriterConfig any         `json:"writer"`
}