configplan

type Candidate struct {
	Table entity.Entity
	// Configured is the entity of the configuration that reads the table.
	Configured *config.EntityConfig
	// Entity is an entity proposed for the table, named like the
	// configured one if any.
	Entity config.EntityConfig
	// ID identifies the entity: the configured one's when configured.
	ID string
}

type Change struct {
	Kind      string
	Principal string
	Actions   []string
	Mask      string
	// Fields counts the fields a field change touches.
	Fields   int
	Entities []string
}

type Exception struct {
	Kind string
	// Level is block, confirm or info (see levelOf).
	Level string
	// Warning marks exceptions that are not only informative.
	Warning bool
	// Ref is the table, when excluding it is a way out.
	Ref    string
	Entity string
	// Detail names what the exception is about: a name, an action, a field.
	Detail string
}

type FieldRule struct {
	// Columns are glob patterns on column names.
	Columns []string `json:"columns"`
	// Types are glob patterns on column types; empty: any type.
	Types   []string `json:"types,omitempty"`
	Exclude bool     `json:"exclude,omitempty"`
	Mask    string   `json:"mask,omitempty"`
}

type GrantRule struct {
	// Principal is role:<name> or user:<name>; a role is created if needed.
	Principal string   `json:"principal"`
	Actions   []string `json:"actions"`
	// Fields are glob patterns of the fields granted; empty: every field.
	Fields []string `json:"fields,omitempty"`
	// Rows filters the rows granted, as in a grant.
	Rows config.FilterConfig `json:"rows,omitempty"`
}

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

type Input struct {
	// Base is the configuration the plan changes: the console's workspace,
	// or the published configuration.
	Base *config.Config
	// Published tells published tables from those only in Base; nil: none.
	Published *config.Config
	Sources   []Source
	// Denied reports an entity action the serving connections cannot run,
	// with why; nil reports none.
	Denied func(entity, action string) (reason string, denied bool)
	// Review reports every new table a grant covers, as a recurring
	// template's proposal needs.
	Review bool
}

type Objects struct {
	Datasource string
	Schema     string
	Tables     int
	Imported   int
	Changed    int
}

type Plan struct {
	Scope Scope `json:"scope"`
	// Import adds an entity for each table in scope no entity reads.
	Import bool `json:"import,omitempty"`
	// Grants grant actions on the entities of the tables in scope.
	Grants []GrantRule `json:"grants,omitempty"`
	// Fields hide or mask the fields of those entities by column.
	Fields []FieldRule `json:"fields,omitempty"`
	// Sync brings their fields in line with the scanned columns.
	Sync *SyncRule `json:"sync,omitempty"`
	// Exclude leaves tables out of the plan, by Ref.
	Exclude []string `json:"exclude,omitempty"`
	// Names names the entities imported for tables, by Ref.
	Names map[string]string `json:"names,omitempty"`
}

type Proposal struct {
	// Config is Base with the changes applied.
	Config *config.Config
	// Entities are the entities added or changed, in configuration order.
	Entities []config.EntityConfig
	// Added are the IDs of the entities added.
	Added []string
	// Roles and Users are the principals added or changed.
	Roles  map[string]config.RoleDefinition
	Users  map[string]config.UserConfig
	Report Report
}

type Report struct {
	// Matched counts the tables in scope; Excluded those left out of them.
	Matched  int
	Excluded int
	Objects  []Objects
	Changes  []Change
	// Exceptions need a look: they may be excluded or changed.
	Exceptions []Exception
	// Unscanned are the schemas in scope never scanned, by datasource.
	Unscanned map[string][]string
	// ScannedFrom and ScannedTo bound when the tables in scope were scanned;
	// zero when unknown.
	ScannedFrom, ScannedTo time.Time
}

type Row struct {
	Ref        string
	Datasource string
	Table      entity.Entity
	Status     Status
	// Entity is the entity of the base configuration that reads the table.
	Entity *config.EntityConfig
	// Added are columns without a field, Missing fields without a column.
	Added, Missing []string
	// ScannedAt is when the table's schema was scanned; zero when unknown.
	ScannedAt time.Time
}

type Scope struct {
	// Datasources limits the scope to these datasources; empty: all.
	Datasources []string `json:"datasources,omitempty"`
	// Schemas are glob patterns (* and ?) on schema names; empty: all.
	Schemas []string `json:"schemas,omitempty"`
	// Tables are glob patterns on table names; empty: all.
	Tables []string `json:"tables,omitempty"`
	// Search matches a part of the table name or its comment.
	Search string `json:"search,omitempty"`
	// Status limits the scope to tables in these states; empty: all.
	Status []Status `json:"status,omitempty"`
	// Drift limits the scope to configured tables whose columns and fields
	// differ.
	Drift bool `json:"drift,omitempty"`
	// Refs limits the scope to these tables.
	Refs []string `json:"refs,omitempty"`
}

type Source struct {
	Datasource string
	// Catalog holds every scanned schema of the datasource.
	Catalog introspect.Catalog
	// Listed are the schemas the datasource lists; nil when unknown.
	Listed []string
	// Scanned are the schemas scanned.
	Scanned []string
	// ScannedAt is when each scanned schema was scanned.
	ScannedAt map[string]time.Time
}

type Status string

type SyncRule struct {
	Add    bool `json:"add,omitempty"`
	Remove bool `json:"remove,omitempty"`
	// HideNew excludes the fields it adds until they are reviewed.
	HideNew bool `json:"hideNew,omitempty"`
}