db

type AfterCreateHook interface {
	AfterCreate() error
}

type AfterDeleteHook interface {
	AfterDelete() error
}

type AfterUpdateHook interface {
	AfterUpdate(prev interface{}) error
}

type BeforeCreateHook interface {
	BeforeCreate() error
}

type BeforeDeleteHook interface {
	BeforeDelete() error
}

type BeforeUpdateHook interface {
	BeforeUpdate(prev interface{}) error
}

type Config struct {
	// DataDir is the base directory for data storage
	DataDir string

	// UserDataDir is the directory for per-user SQLite databases.
	// Defaults to DataDir/users.
	//
	// There is no OrgDataDir counterpart: an org's file is placed by
	// hanzoai/namespace under DataDir (namespace.Path → DataDir/orgs/<slug>/…),
	// which is the ONE layout every Hanzo service renders. This field survives
	// only because namespace has no layout for a user, so the per-user tree stays
	// commerce's own — see tenantNamespace in encryption.go.
	UserDataDir string

	// MasterKey is the 32-byte at-rest encryption master key, supplied by the
	// EMBEDDER. When non-nil it is used verbatim and COMMERCE_KMS_MASTER_KEY is
	// never read.
	//
	// It exists so a host that already holds a master key does not have to mint a
	// SECOND one and hand it over through the environment. cloud embeds commerce
	// in its own process and already resolves a 32-byte KEK
	// (CLOUD_KMS_MASTER_KEY_REF); making commerce reach independently for an env
	// var meant two keys, two KMS paths and two sync objects for one process —
	// and when the second was never provisioned, commerce refused to boot, Mount
	// never published its handler, and every balance read in the fleet failed.
	// The embedder passing what it already has is one key, one source, and a
	// dependency the type system can see.
	//
	// nil ⇒ unchanged: ResolveMasterKey reads the env, which remains the
	// standalone deployment's path.
	MasterKey []byte

	// MaxOpenTenants bounds how many per-tenant stores are open at once; the
	// least recently used idle one is closed to stay under it.
	// Defaults to defaultMaxOpenTenants.
	MaxOpenTenants int

	// TenantIdleTTL closes a per-tenant store untouched for this long, even
	// below MaxOpenTenants. Defaults to defaultTenantIdleTTL; negative disables.
	TenantIdleTTL time.Duration

	// DatastoreDSN is the connection string for Hanzo Datastore (DATASTORE_URL)
	DatastoreDSN string

	// EnableDatastore enables the Hanzo Datastore layer
	EnableDatastore bool

	// EnableVectorSearch enables sqlite-vec for vector embeddings
	EnableVectorSearch bool

	// VectorDimensions is the default dimension for vector embeddings
	VectorDimensions int

	// SQLite configuration
	SQLite SQLiteConfig

	// Datastore configuration (Hanzo Datastore)
	Datastore DatastoreConfig

	// IsDev enables development mode logging
	IsDev bool
}

type Cursor interface {
	String() string
}

type DB interface {
	// Core operations
	Get(ctx context.Context, key Key, dst interface{}) error
	Put(ctx context.Context, key Key, src interface{}) (Key, error)
	Delete(ctx context.Context, key Key) error

	// Batch operations
	GetMulti(ctx context.Context, keys []Key, dst interface{}) error
	PutMulti(ctx context.Context, keys []Key, src interface{}) ([]Key, error)
	DeleteMulti(ctx context.Context, keys []Key) error

	// Query
	Query(kind string) Query

	// Vector search (sqlite-vec)
	VectorSearch(ctx context.Context, opts *VectorSearchOptions) ([]VectorResult, error)
	PutVector(ctx context.Context, kind string, id string, vector []float32, metadata map[string]interface{}) error

	// Key management
	NewKey(kind string, stringID string, intID int64, parent Key) Key
	NewIncompleteKey(kind string, parent Key) Key
	AllocateIDs(kind string, parent Key, n int) ([]Key, error)

	// Transactions
	RunInTransaction(ctx context.Context, fn func(tx Transaction) error, opts *TransactionOptions) error

	// Lifecycle
	Close() error

	// Tenant info
	TenantID() string
	TenantType() string
}

type Datastore interface {
	// Query executes datastore queries
	Query(ctx context.Context, query string, args ...interface{}) (DatastoreRows, error)

	// Select scans results into a destination slice
	Select(ctx context.Context, dest interface{}, query string, args ...interface{}) error

	// Exec executes a non-query statement
	Exec(ctx context.Context, query string, args ...interface{}) error

	// Batch insert for high-throughput data ingestion
	PrepareBatch(ctx context.Context, query string) (DatastoreBatch, error)

	// AsyncInsert for fire-and-forget event logging
	AsyncInsert(ctx context.Context, query string, wait bool, args ...interface{}) error

	// Close closes the datastore connection
	Close() error
}

type DatastoreBatch interface {
	Append(v ...interface{}) error
	AppendStruct(v interface{}) error
	Flush() error
	Send() error
	Abort() error
	Rows() int
	Close() error
}

type DatastoreConfig struct {
	// MaxOpenConns for parallel queries
	MaxOpenConns int

	// MaxIdleConns for connection pooling
	MaxIdleConns int

	// ConnMaxLifetime for connection recycling
	ConnMaxLifetime time.Duration

	// Compression method (lz4, zstd, etc.)
	Compression string

	// QueryTimeout for datastore queries
	QueryTimeout time.Duration
}

type DatastoreRows interface {
	Next() bool
	Scan(dest ...interface{}) error
	ScanStruct(dest interface{}) error
	Columns() []string
	Close() error
	Err() error
}

type Entity interface {
	// Kind returns the entity kind/table name
	Kind() string
}

type IsolationLevel int

type Iterator interface {
	Next(dst interface{}) (Key, error)
	Cursor() (Cursor, error)
}

type Key interface {
	// Kind returns the entity kind/table name
	Kind() string

	// StringID returns the string identifier (if any)
	StringID() string

	// IntID returns the integer identifier (if any)
	IntID() int64

	// Parent returns the parent key (for hierarchical keys)
	Parent() Key

	// Namespace returns the namespace/tenant
	Namespace() string

	// Incomplete returns true if this key needs an ID assigned
	Incomplete() bool

	// Encode returns an encoded string representation
	Encode() string

	// Equal checks if two keys are the same
	Equal(other Key) bool
}

type Kind interface {
	Kind() string
}

type Layer int

type Manager struct {
	// contains filtered or unexported fields
}

type Model struct {

	// Parent key for hierarchical data
	Parent Key `json:"-"`

	// Common fields
	ID        string    `json:"id,omitempty"`
	CreatedAt time.Time `json:"createdAt,omitempty"`
	UpdatedAt time.Time `json:"updatedAt,omitempty"`
	Deleted   bool      `json:"deleted,omitempty"`

	// Version for optimistic locking
	Version int64 `json:"version,omitempty"`

	// Namespace/tenant for multi-tenancy
	Namespace_ string `json:"-"`

	// Flag for mock mode (testing)
	Mock bool `json:"-"`

	// Flag for string-based keys vs auto-generated
	UseStringKey bool `json:"-"`
	// contains filtered or unexported fields
}

type NoOpDatastore struct{}

type PostgresDB struct {
	// contains filtered or unexported fields
}

type PostgresDBConfig struct {
	// DSN is the connection string
	// Format: postgres://user:pass@host:port/dbname?sslmode=disable
	DSN string

	// Config for connection pool
	MaxOpenConns    int
	MaxIdleConns    int
	ConnMaxLifetime time.Duration
	ConnMaxIdleTime time.Duration

	// QueryTimeout for queries
	QueryTimeout time.Duration

	// TenantID for multi-tenant isolation
	TenantID string

	// TenantType is "user" or "org"
	TenantType string

	// Schema for tenant isolation (optional)
	// If set, uses PostgreSQL schemas for multi-tenancy
	Schema string

	// EnableVectorSearch enables pgvector extension
	EnableVectorSearch bool

	// VectorDimensions for embeddings
	VectorDimensions int
}

type Query interface {
	// Filtering
	Filter(filterStr string, value interface{}) Query
	FilterField(fieldPath string, op string, value interface{}) Query

	// Ordering
	Order(fieldPath string) Query
	OrderDesc(fieldPath string) Query

	// Pagination
	Limit(limit int) Query
	Offset(offset int) Query

	// Projection
	Project(fieldNames ...string) Query
	Distinct() Query

	// Ancestor queries (for hierarchical data)
	Ancestor(ancestor Key) Query

	// Execution
	GetAll(ctx context.Context, dst interface{}) ([]Key, error)
	First(ctx context.Context, dst interface{}) (Key, error)
	Count(ctx context.Context) (int, error)
	Keys(ctx context.Context) ([]Key, error)
	Run(ctx context.Context) Iterator

	// Cursors for pagination
	Start(cursor Cursor) Query
	End(cursor Cursor) Query
}

type SQLiteConfig struct {
	// MaxOpenConns for concurrent reads
	MaxOpenConns int

	// MaxIdleConns for connection pooling
	MaxIdleConns int

	// BusyTimeout in milliseconds before giving up on locked DB
	BusyTimeout int

	// JournalMode (WAL recommended for concurrency)
	JournalMode string

	// Synchronous mode (NORMAL for balance of safety/speed)
	Synchronous string

	// CacheSize in KB (negative = KB, positive = pages)
	CacheSize int

	// QueryTimeout for SELECT queries
	QueryTimeout time.Duration
}

type SQLiteDB struct {
	// contains filtered or unexported fields
}

type SQLiteDBConfig struct {
	// Path to the SQLite database file
	Path string

	// Config for SQLite options
	Config SQLiteConfig

	// EnableVectorSearch enables sqlite-vec extension
	EnableVectorSearch bool

	// VectorDimensions for embeddings
	VectorDimensions int

	// TenantID for this database (userID or orgID)
	TenantID string

	// TenantType is "user" or "org"
	TenantType string

	// MasterKey is the 32-byte KMS-sourced master key. When non-nil the file is
	// opened SQLCipher-encrypted at rest, under a key DERIVED from it and this
	// tenant's namespace (cek.DeriveKey). Nil means unencrypted (dev/CI). Set once
	// by the Manager from COMMERCE_KMS_MASTER_KEY — see encryption.go.
	MasterKey []byte
}

type SyncConfig struct {
	// Enabled turns on datastore sync
	Enabled bool

	// BatchSize is the number of records to batch before sending
	BatchSize int

	// FlushInterval is how often to flush partial batches
	FlushInterval time.Duration

	// Kinds specifies which entity kinds to sync (empty = all)
	Kinds []string

	// AsyncInsert uses ClickHouse async insert for fire-and-forget
	AsyncInsert bool
}

type Syncable interface {
	Entity

	// SyncToDatastore returns true if this entity should be synced
	SyncToDatastore() bool
}

type Syncer struct {
	// contains filtered or unexported fields
}

type Transaction interface {
	Get(key Key, dst interface{}) error
	Put(key Key, src interface{}) (Key, error)
	Delete(key Key) error
	Query(kind string) Query
}

type TransactionOptions struct {
	// ReadOnly indicates this is a read-only transaction
	ReadOnly bool

	// MaxAttempts for retries on conflict
	MaxAttempts int

	// Isolation level (for SQL databases)
	Isolation IsolationLevel
}

type Validator interface {
	Validate() error
}

type VectorResult struct {
	// ID is the entity identifier
	ID string

	// Score is the similarity score (0-1, higher is more similar)
	Score float32

	// Metadata is additional data stored with the vector
	Metadata map[string]interface{}
}

type VectorSearchOptions struct {
	// Kind is the entity type to search
	Kind string

	// Vector is the query vector
	Vector []float32

	// Limit is the maximum number of results
	Limit int

	// MinScore filters results below this similarity score
	MinScore float32

	// Filters are additional SQL conditions
	Filters map[string]interface{}
}