controlplane

type AppliedSet struct {
	Versions    []int64
	Repeatables map[string]string
}

type ApplyRequest struct {
	RunID    string
	Target   string
	DSN      string
	Plans    []engine.Plan
	Opts     engine.Options
	Progress func(engine.StatementEvent)
	Record   Recorder
}

type AuditEntry struct {
	ID     int64
	At     time.Time
	Actor  string
	Action string
	RunID  string
	Target string
	Detail string
}

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

type Checkpoint struct {
	Version int64
	Name    string
	Through int64
	Covers  []string
	Body    string
}

type Checkpointer struct {
	Expander *Expander
	// contains filtered or unexported fields
}

type Config struct {
	Holder            string
	TTL               time.Duration
	Interval          time.Duration
	MaxAttempts       int
	MaxConcurrentRuns int
	RunTimeout        time.Duration
	Jitter            func() float64
}

type CredentialStore struct {
	Name     string
	Address  string
	Role     string
	Mount    string
	TokenEnv string
	Targets  int
}

type DiffBase int

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

type Direct struct{}

type Divergence struct {
	Adopt       []string
	Conflicting []string
	Unknown     []string
	Withdrawn   []string
}

type Drift struct {
	Target  string
	Drifted bool
	Diff    string
}

type DriftEvent struct {
	ID         int64
	Target     string
	Diff       string
	DetectedAt time.Time
	ResolvedAt *time.Time
}

type DriftMonitor struct {
	Metrics           *metrics.Metrics
	PlanRetention     time.Duration
	DeliveryRetention time.Duration
	// contains filtered or unexported fields
}

type Engine interface {
	Apply(ctx context.Context, req ApplyRequest) error
	MarkApplied(ctx context.Context, dsn string, migs []engine.Migration) ([]engine.Migration, error)
	Snapshot(ctx context.Context, dsn string, scope engine.SnapshotScope) (engine.Schema, error)
	Applied(ctx context.Context, dsn string) ([]engine.Applied, []engine.Repeatable, error)
	Journal(ctx context.Context, dsn string, version int64, repeatable string) ([]engine.JournalRun, error)
	Observe(ctx context.Context, dsn string, scope engine.SnapshotScope) (Observation, error)
	DataLoss(ctx context.Context, dsn string, drops []engine.Drop) ([]engine.Loss, error)
}

type ExpandContract struct{}

type Expander struct {
	KeepOld   bool
	BatchSize int
}

type Expansion struct {
	ID        string               `json:"id"`
	UpSQL     string               `json:"up_sql"`
	DownSQL   string               `json:"down_sql"`
	DownHeld  string               `json:"down_held_sql,omitempty"`
	Phase     []string             `json:"phase"`
	Batches   []*engine.BatchSpec  `json:"batches,omitempty"`
	Asserts   []*engine.AssertSpec `json:"asserts,omitempty"`
	Notes     []string             `json:"notes,omitempty"`
	Retired   []RetiredColumn      `json:"retired,omitempty"`
	Unretired []RetiredColumn      `json:"unretired,omitempty"`
	Lines     []string             `json:"lines,omitempty"`
	Hash      string               `json:"hash"`
}

type Fleet struct {
	Targets    []string
	Migrations []FleetMigration
}

type FleetFilter struct {
	Targets       []string
	FromVersion   int64
	ToVersion     int64
	NotEverywhere bool
	In            string
	NotIn         string
}

type FleetGap struct {
	Target        string
	NewestVersion int64
	Behind        bool
	Holds         bool
	OtherChecksum string
}

type FleetMigration struct {
	Migration  string
	Version    int64
	Name       string
	Repeatable bool
	Checkpoint bool
	Checksum   string
	On         []FleetOn
	Missing    []FleetGap
	Divergent  bool
}

type FleetOn struct {
	Target      string
	AppliedAt   time.Time
	RunID       string
	CollapsedBy string
}

type GitHubRun struct {
	RunID        string
	Repository   string
	RepositoryID int64
	Installation int64
	PullRequest  int
	Head         string
	Command      string
	Target       string
	Marker       string
	Format       string
	CheckRun     int64
	State        string
	Reverts      string
}

type HistoryChange struct {
	Version    int64
	Name       string
	Repeatable bool
	At         time.Time
	RunID      string
}

type HistoryMigration struct {
	ID        string
	UpSQL     string
	DownSQL   string
	Expansion *Expansion
}

type HistoryReplayer interface {
	Validate(ctx context.Context, target string, plans []engine.Plan, searchPath string) (Validation, error)
	Replay(ctx context.Context, conn engine.DB, target, searchPath string, plans []engine.Plan) error
}

type HistoryRun struct {
	Migrations []HistoryMigration
}

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

type LedgerEntry struct {
	RunID     string
	AppliedAt time.Time
	Applied   bool
	Adopted   bool
	Expansion *Expansion
	UpSQL     string
	DownSQL   string
}

type MigrationAttempt struct {
	engine.JournalRun
	Statements []MigrationStatement
}

type MigrationJournal struct {
	Target       string
	Migration    string
	Attempts     []MigrationAttempt
	RunID        string
	AppliedAt    time.Time
	Adopted      bool
	RecordedOnly bool
	Unreachable  string
	BodiesSwept  bool
}

type MigrationStatement struct {
	engine.JournalStatement
	SQL      string
	NoTx     bool
	Verifier string
	Outcome  string
}

type Observation struct {
	Applied     []engine.Applied
	Repeatables []engine.Repeatable
	Definition  string
	Fingerprint string
	SearchPath  string
	At          time.Time
	Ignored     []engine.Adopted
}

type PGEngine struct {
	Metrics *metrics.Metrics
	Log     *slog.Logger
}

type Plan struct {
	ID                string
	Target            string
	Key               string
	Rollout           string
	State             string
	HistoryHash       string
	Applied           []engine.Applied
	Repeatables       []engine.Repeatable
	SchemaFingerprint string
	SchemaDefinition  string
	SearchPath        string
	Drift             string
	Migrations        []PlanMigration
	Validated         bool
	Acked             []string
	AllowOutOfOrder   bool
	CreatedBy         string
	Source            string
	CreatedAt         time.Time
	RunID             string
	SupersededBy      string
	Expansions        map[string]Expansion
}

type PlanAssert struct {
	Op    string `json:"op"`
	Kind  string `json:"kind"`
	Value string `json:"value"`
}

type PlanBatch struct {
	Key   string `json:"key"`
	Kind  string `json:"kind"`
	Size  int    `json:"size"`
	Pause string `json:"pause,omitempty"`
}

type PlanDiff struct {
	Added   []HistoryChange
	Removed []HistoryChange
	Schema  []string
	Path    string
}

type PlanHazard struct {
	Code      string `json:"code"`
	Detail    string `json:"detail"`
	Recipe    string `json:"recipe,omitempty"`
	Object    string `json:"object,omitempty"`
	Attribute string `json:"attribute,omitempty"`
}

type PlanMigration struct {
	Version    int64           `json:"version"`
	Name       string          `json:"name"`
	Repeatable bool            `json:"repeatable,omitempty"`
	Checksum   string          `json:"checksum"`
	Applied    bool            `json:"applied"`
	Phase      string          `json:"phase"`
	Statements []PlanStatement `json:"statements"`

	AlreadyApplied bool   `json:"already_applied,omitempty"`
	Effect         string `json:"effect,omitempty"`
	Note           string `json:"note,omitempty"`
	Withheld       bool   `json:"withheld,omitempty"`

	Changes []engine.ObjectChange `json:"changes,omitempty"`

	// Stored inverted: a plan written before the field existed keeps counting every hazard rather than none.
	Skipped bool `json:"skipped,omitempty"`

	Checkpoint bool  `json:"checkpoint,omitempty"`
	Through    int64 `json:"collapses_through,omitempty"`

	Directives []string `json:"directives,omitempty"`
	Expanded   bool     `json:"expanded,omitempty"`
	Notes      []string `json:"notes,omitempty"`
	Expansion  string   `json:"expansion,omitempty"`
}

type PlanRequired struct {
	Target  string
	Key     string
	Pending []engine.Migration
	Nearest []Plan
}

type PlanStale struct {
	Plan   Plan
	Reason string
	Diff   PlanDiff
	Hint   string
}

type PlanStatement struct {
	SQL     string       `json:"sql"`
	NoTx    bool         `json:"no_tx,omitempty"`
	Phase   string       `json:"phase,omitempty"`
	Batch   *PlanBatch   `json:"batch,omitempty"`
	Assert  *PlanAssert  `json:"assert,omitempty"`
	Hazards []PlanHazard `json:"hazards,omitempty"`
}

type Pool interface {
	Exec(ctx context.Context, sql string, args ...any) (pgconn.CommandTag, error)
	Query(ctx context.Context, sql string, args ...any) (pgx.Rows, error)
	QueryRow(ctx context.Context, sql string, args ...any) pgx.Row
	Begin(ctx context.Context) (pgx.Tx, error)
}

type Provenance struct {
	CreatedBy string
	Source    string
}

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

type Recorder func(ctx context.Context, res engine.Result) error

type RetiredColumn struct {
	Schema  string `json:"schema"`
	Table   string `json:"table"`
	Column  string `json:"column"`
	Retires string `json:"retires"`
}

type RevertPlan struct {
	Run     Run
	Applied []RunMigration
	Plans   []engine.Plan
	Newer   bool
}

type RolloutPolicy interface {
	Split(plans []engine.Plan) (expand, contract []engine.Plan)
}

type Run struct {
	ID         string
	Seq        int64
	Target     string
	State      string
	Error      string
	Attempts   int
	Rollout    string
	Phase      string
	Reverts    string
	Kind       string
	Timeouts   Timeouts
	Provenance Provenance
	PlanID     string
	Retries    int
	NotBefore  *time.Time
	CreatedAt  time.Time
	FinishedAt *time.Time
	Progress   *RunProgress
	Expansions map[string]Expansion
}

type RunMigration struct {
	Migration  string
	AppliedAt  time.Time
	RevertedBy string
	Held       bool
	Adopted    bool
	Expansion  *Expansion
}

type RunProgress struct {
	Migration string `json:"migration"`
	Statement int    `json:"statement"`
	Phase     string `json:"phase,omitempty"`
	RowsDone  int64  `json:"rows_done,omitempty"`
	RowsTotal int64  `json:"rows_total,omitempty"`
	Batches   int    `json:"batches,omitempty"`
}

type Scheduler struct {
	Metrics  *metrics.Metrics
	Notifier notify.Notifier
	// contains filtered or unexported fields
}

type SchemaDiff struct {
	Observed          Observation
	UpSQL             string
	DownSQL           string
	Drift             []string
	Retained          []string
	RepeatableObjects []string
}

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

type ScratchFinding struct {
	Fatal  bool
	Detail string
}

type Snapshot struct {
	Target      string
	Fingerprint string
	Definition  string
	RunID       string
	TakenAt     time.Time
}

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

type TargetRegistration struct {
	Name                string
	Provider            string
	CredentialStore     string
	VaultPath           string
	VaultTemplate       string
	SecretPath          string
	DSNRegistered       bool
	Timeouts            Timeouts
	SearchPath          string
	RequirePlan         bool
	KeepOld             bool
	IgnoreAdoptedTables bool
	GitHubRepositories  []string
}

type TargetStatus struct {
	Target      string
	Provider    string
	Timeouts    Timeouts
	SearchPath  string
	Applied     []engine.Applied
	Repeatables []engine.Repeatable
	LastRun     *Run
	Snapshot    *Snapshot
	OpenDrift   bool
	Unreachable string
}

type TargetSummary struct {
	TargetRegistration
	LastRun         *Run
	AttentionRuns   int
	UnresolvedDrift bool
	ReadyPlans      int
	AppliedCount    int
}

type Timeouts struct {
	Lock      string
	Statement string
}

type Validation struct {
	Base         string
	Effects      [][]string
	Fingerprints []string
	Changes      [][]engine.ObjectChange
	Expansions   map[string]Expansion
	Plans        []engine.Plan
	Replayed     int
	Collapsed    int
}

type Validator struct {
	Expander *Expander
	// contains filtered or unexported fields
}