sdk

type ApplyOptions struct {
	// DryRun skips applying changes and only computes the diff.
	DryRun bool
	Actor  string
}

type AutoLabelResolverOptions struct {
	HTTP *HTTPLabelRules
	GRPC *GRPCLabelRules
	JWT  *JWTLabelRules
	Ctx  *CtxValueRules
	Hint *SelectionHint
}

type Connector func(ctx context.Context, driver, dsnOrURL string) (*sql.DB, error)

type CtxValueRules struct {
	KeyMap map[any]string // context key -> label name
	Fixed  map[string]string
}

type DBConfig struct {
	Driver      string // mysql|postgres|mongo
	DSN         string
	Schema      string
	TablePrefix string
}

type DiffReport struct {
	// Added is the number of newly created fields.
	Added int
	// Deleted is the number of removed fields.
	Deleted int
	// Updated is the number of modified fields.
	Updated int
}

type DisplayMeta = registry.DisplayMeta

type DisplayOptions = registry.DisplayOption

type EqExpr struct{ Label, Value string }

type ErrorClassifier func(error) (transient bool, retryable bool)

type FailoverPolicy struct {
	Enabled           bool
	MaxAttempts       int
	BaseBackoff       time.Duration
	MaxBackoff        time.Duration
	JitterRatio       float64
	OpenAfterFailures int
	OpenDuration      time.Duration
	HalfOpenProbe     int
	PreferOnFail      *SelectionHint
	AllowWriteRetry   bool
}

type FieldDef = registry.FieldMeta

type FieldDiff struct {
	Name      string
	MetaDef   FieldDef
	TargetDef FieldDef
	Reason    string
}

type FieldMeta = registry.FieldMeta

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

type GRPCLabelRules struct {
	MetaMap map[string]string // metadata key -> label name
	Fixed   map[string]string
}

type HTTPLabelRules struct {
	HeaderMap map[string]string // header name -> label name
	Fixed     map[string]string
}

type HasExpr struct{ Label string }

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

type InExpr struct {
	Label  string
	Values []string
}

type JWTLabelRules struct {
	ClaimMap map[string]string // claim name -> label name
	Fixed    map[string]string
}

type LabelExpr interface {
	Eval(has func(label string) bool) bool
}

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

type NotExpr struct{ Label string }

type Query struct {
	AND []LabelExpr
	OR  [][]LabelExpr
}

type ReadSource int

type ReconcileReport struct {
	MissingInTarget []FieldDef
	MissingInMeta   []FieldDef
	Mismatched      []FieldDiff
}

type ScanResult = schema.ScanResult

type SelectionHint struct {
	Strategy    SelectionStrategy
	PreferLabel string
	HashSource  string
}

type SelectionStrategy int

type Service interface {
	// Scan reads schema information from the database.
	Scan(ctx context.Context, cfg DBConfig) ([]registry.FieldMeta, error)
	// Export dumps registry metadata as YAML.
	Export(ctx context.Context, cfg DBConfig) ([]byte, error)
	// Apply updates the registry based on the provided YAML.
	Apply(ctx context.Context, cfg DBConfig, yaml []byte, opts ApplyOptions) (DiffReport, error)
	// MigrateRegistry upgrades or downgrades the registry schema.
	MigrateRegistry(ctx context.Context, cfg DBConfig, target int) error
	// RegistryVersion returns the current registry schema version.
	RegistryVersion(ctx context.Context, cfg DBConfig) (int, error)
	// ListCustomFields returns custom field metadata.
	ListCustomFields(ctx context.Context, dbID int64, table string) ([]registry.FieldMeta, error)
	// CreateCustomField inserts a new field into the registry.
	CreateCustomField(ctx context.Context, fm registry.FieldMeta) error
	// UpdateCustomField modifies an existing field.
	UpdateCustomField(ctx context.Context, fm registry.FieldMeta) error
	// DeleteCustomField removes a field from the registry.
	DeleteCustomField(ctx context.Context, table, column string) error
	// ReconcileCustomFields compares metadata between target and MetaDB and optionally repairs discrepancies.
	ReconcileCustomFields(ctx context.Context, dbID int64, table string, repair bool) (*ReconcileReport, error)
	// StartTargetWatcher periodically fetches target configurations from a provider.
	StartTargetWatcher(ctx context.Context, p TargetProvider, interval time.Duration) (stop func())
}

type ServiceConfig struct {
	Logger          *zap.SugaredLogger
	PluginDir       string
	PluginPublicKey string
	PluginEnabled   *bool
	Recorder        *audit.Recorder
	Notifier        notifier.Broker

	// Default connection for monitored databases. Kept for backward
	// compatibility.
	DB     *sql.DB
	Driver string
	Schema string

	// Optional separate connection for metadata storage. When omitted,
	// the above DB/Driver/Schema values are used.
	MetaDB     *sql.DB
	MetaDriver string
	MetaSchema string

	// Target databases for monitoring. If empty, the default DB/Driver/
	// Schema fields represent the only target.
	Targets []TargetConfig

	// TargetResolver selects a target based on the request context. When
	// nil, operations fall back to the default target.
	TargetResolver TargetResolver

	// TargetResolverV2 returns either a direct key or a query. When both
	// V1 and V2 are provided, V2 takes precedence.
	TargetResolverV2 TargetResolverV2

	// DefaultStrategy determines how to choose among multiple candidates
	// returned by a query. The zero value means SelectFirst.
	DefaultStrategy SelectionStrategy

	// DefaultPreferLabel is used when DefaultStrategy is SelectPreferLabel
	// and no hint is supplied.
	DefaultPreferLabel string

	// Connector creates new DB connections. When nil, a default
	// implementation based on sql.Open and PingContext is used.
	Connector Connector

	// Failover controls retry and circuit breaker behavior.
	Failover FailoverPolicy

	// ErrorClassifier distinguishes transient errors for retry decisions.
	ErrorClassifier ErrorClassifier

	// ReadSource selects where to read custom field metadata from.
	ReadSource ReadSource
}

type Snapshot struct {
	ID      int64
	Semver  string
	TakenAt time.Time
	Author  string
}

type SnapshotClient interface {
	List(ctx context.Context, tenant string) ([]Snapshot, error)
	Create(ctx context.Context, tenant, bump, msg string) (Snapshot, error)
	Apply(ctx context.Context, tenant, ver string) error
	Diff(ctx context.Context, tenant, from, to string) (string, error)
}

type TargetConfig struct {
	Key    string // unique identifier like "tenant:foo" or "db:orders"
	Driver string
	Schema string
	Labels []string // optional tags such as "tenant:foo" or "region:tokyo"

	// Physical connection information (hot reload target).
	DSN          string
	MaxOpenConns int
	MaxIdleConns int
	ConnMaxIdle  time.Duration
	ConnMaxLife  time.Duration

	// Backward compatibility: pre-established connection. Connections
	// provided via DB are not subject to hot reload.
	DB *sql.DB
}

type TargetConn struct {
	DB      *sql.DB
	Driver  string
	Schema  string
	Dialect ormdriver.Dialect
	Labels  map[string]struct{}
}

type TargetDecision struct {
	Key   string
	Query *Query
	Hint  *SelectionHint
}

type TargetProvider interface {
	Fetch(ctx context.Context) (cfgs map[string]TargetConfig, defaultKey string, version string, err error)
}

type TargetRegistry interface {
	Register(ctx context.Context, key string, cfg TargetConfig, mk Connector) error
	Unregister(key string) error
	Update(ctx context.Context, key string, cfg TargetConfig, mk Connector) error
	ReplaceAll(ctx context.Context, cfgs map[string]TargetConfig, mk Connector, defaultKey string) error
	Snapshot() map[string]TargetConn
	Get(key string) (TargetConn, bool)
	Default() (TargetConn, bool)
	SetDefault(key string)
	Keys() []string
	FindByLabel(label string) []string
	FindAllByLabels(labels ...string) []string
	FindAnyByLabels(labels ...string) []string
	FindByQuery(q Query) []string
	ForEachByQuery(q Query, fn func(key string, t TargetConn) error) error
}

type TargetResolver func(ctx context.Context) (key string, ok bool)

type TargetResolverV2 func(ctx context.Context) (TargetDecision, bool)

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

type TenantIDKey struct{}