data

type CheckError struct {
	Unclassified []string // table.column without a rule (e.g. new after a migration)
	Stale        []string // rules for tables or columns that no longer exist
	Proposed     []string // rules data classify proposed and nobody confirmed yet
	Invalid      []string // rules that do not fit the column (type, NOT NULL, references)
	Schema       []string // schema objects with personal-looking literals nobody confirmed
}

type Classification struct {
	Tables      []TableProposal
	Stale       []Ref
	Unconfirmed []Ref
	// Schema proposes confirming what the detector finds in schema objects;
	// StaleSchema are confirmations for objects where it finds nothing now.
	Schema      []SchemaFinding
	StaleSchema []string
}

type Column struct {
	Name      string
	Type      string // as the server names it: varchar(255), jsonb, int(10) unsigned…
	Category  string
	Nullable  bool
	Generated bool // computed by the server: never written
	Unique    bool // alone in a unique index or the primary key
	// Collation decides which values are equal (MySQL: every text column;
	// PostgreSQL: one other than the type's default). Replaced values that
	// are equal under it get stand-ins that are equal under it.
	Collation string
	// contains filtered or unexported fields
}

type ColumnProposal struct {
	Column string
	Rule   *ColumnRule
}

type ColumnReport struct {
	Name    string `json:"name"`
	Rule    string `json:"rule"`                     // keep, file, serialized-php or the strategy
	Values  int64  `json:"values"`                   // values that are not NULL
	Parts   int64  `json:"parts,omitempty"`          // personal parts replaced in free text, HTML or JSON
	Unknown int64  `json:"unknown_format,omitempty"` // password hashes of no known format, made unusable
}

type ColumnRule struct {
	Kind     string            `yaml:"kind"`
	Strategy string            `yaml:"strategy,omitempty"`
	Paths    map[string]string `yaml:"paths,omitempty"`   // json: JSON path glob → strategy (or keep)
	Other    string            `yaml:"other,omitempty"`   // json: strings under no path; default free-text
	Action   string            `yaml:"action,omitempty"`  // serialized-php: empty-table (default) or null
	Options  map[string]string `yaml:"options,omitempty"` // file: passed to the FilePlaceholder
	Reason   string            `yaml:"reason,omitempty"`
	Proposed bool              `yaml:"proposed,omitempty"` // written by data classify; a person removes it
}

type Database struct {
	Driver string // mysql (MariaDB too) or postgres
	// DSN reaches the server: mysql://user:pass@host:port/ or the Go driver's
	// own form for MySQL, a postgres:// URL for PostgreSQL. Its database part
	// is ignored (for PostgreSQL it is the database that creates and drops
	// the target, default postgres).
	DSN  string
	Name string // the database
	// Dial, when set, makes every connection to the server: only to an
	// allowed host (dbx.AllowDial). A staging database made from the
	// target keeps it.
	Dial dbx.DialFunc
}

type FilePlaceholder interface {
	Placeholder(ctx context.Context, f FileValue) (string, error)
}

type FileValue struct {
	Table, Column string
	Path          string            // the original value of the column
	Options       map[string]string // the rule's options from classify.yaml
}

type Filter interface {
	// Where is an SQL condition on the rows of a table, ANDed to the read.
	Where(t *Table) string
	// Keep decides about one row after the read; values as text, nil for NULL.
	// It may set values to nil (data subset nulls references that leave the
	// sample) before the row is replaced.
	Keep(t *Table, cols []*Column, row [][]byte) bool
}

type ForeignKey struct {
	Name       string
	Table      string
	Columns    []string
	RefTable   string
	RefColumns []string
}

type Options struct {
	Source Database // only read, in one read-only snapshot
	// Target is written under a staging name and takes its own name when
	// the run and Verify have passed; nil writes no database. It must be
	// another database than the source (told apart by the servers'
	// identities) and, when it holds objects, one DriftGate wrote.
	Target *Database
	// Replace allows dropping a target database DriftGate wrote that
	// already holds objects.
	Replace bool
	Dump    io.Writer // the deterministic SQL dump; nil writes none
	// Verify checks the output before it is made: the target database under
	// its staging name (nil without a target) and the dump, written and
	// flushed. An error leaves the target as it was and is returned as is.
	Verify func(ctx context.Context, staging *Database) error
	// Index, when not nil, is filled with what data verify looks for, in
	// the run's own pass over the original personal values of the source:
	// Verify with VerifyOptions.Index then reads the source no more.
	Index  *VerifyIndex
	Rules  *Rules
	Key    []byte // the project key; the replacement key is derived from it
	Files  FilePlaceholder
	PII    *pii.Detector // finds personal parts of free text; nil: the default detector
	Filter Filter
	// BatchRows is the most rows per INSERT (default 500); a statement also
	// ends after about 1 MiB.
	BatchRows int
	Log       io.Writer // progress, one line per table; never values
}

type PersonalValue struct {
	Table, Column string
	// Kind is the strategy of a whole value (universal, email, token,
	// password, null, empty), or for a part of free text, HTML, JSON or
	// serialized PHP the detector's kind (email, phone, jmbg, card, iban) or
	// the strategy of its JSON path.
	Kind  string
	Value string
	// Category is the category of the column (CatText, CatNumeric…); a
	// number inside a JSON value is CatNumeric.
	Category string
	// contains filtered or unexported fields
}

type Ref struct{ Table, Column string }

type Reference struct {
	From string `yaml:"from"`
	To   string `yaml:"to,omitempty"` // omitted: From is a foreign key of the database
	// When limits a declared reference to rows whose columns have these
	// values (a polymorphic type column: commentable_type: App\Models\Post).
	When     map[string]string `yaml:"when,omitempty"`
	Nullable string            `yaml:"nullable,omitempty"` // pull or null; default subset.nullable
}

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

type Report struct {
	Driver  string        `json:"driver"`
	Tables  []TableReport `json:"tables"`
	Rows    int64         `json:"rows"`
	Seconds float64       `json:"seconds"`
	// LeftOut are views and other statements left out because they need a
	// table that is skipped.
	LeftOut []string `json:"left_out,omitempty"`
}

type Rules struct {
	Version int                   `yaml:"version"`
	Tables  map[string]*TableRule `yaml:"tables"`
	// Subset chooses the rows of data subset; data anonymize copies every row.
	Subset *SubsetRules `yaml:"subset,omitempty"`
	// Schema confirms what the detector finds in schema objects (comments,
	// defaults, views, triggers, functions, checks), which are copied as
	// they are: by object, the kinds a person checked and found not personal
	// (a shared mailbox in a default). Anything else found stops a run.
	Schema map[string]*SchemaRule `yaml:"schema,omitempty"`
}

type SampleReport struct {
	Total    int64 `json:"total"`    // rows in the source
	Roots    int64 `json:"roots"`    // rows the sample started from
	Followed int64 `json:"followed"` // rows that reference followed rows of a parent
	Parents  int64 `json:"parents"`  // rows taken in only because kept rows reference them
	// Nulled are references set to NULL: their row is outside the sample
	// (nullable null) or in a table without rows.
	Nulled int64 `json:"nulled,omitempty"`
	// Dangling are references to rows that are not in the source either
	// (declared references without a foreign key); copied as they are.
	Dangling int64 `json:"dangling,omitempty"`
}

type SampleRule struct {
	Mode    string  `yaml:"-"`                 // all or none (the one-word form)
	Rows    int     `yaml:"rows,omitempty"`    // at most this many roots
	Percent float64 `yaml:"percent,omitempty"` // roots: this share of the rows, chosen by a hash of the primary key
	Where   string  `yaml:"where,omitempty"`   // roots: rows matching this SQL condition
	Order   string  `yaml:"order,omitempty"`   // latest (default) or first, by primary key
	// Follow lists parent tables: the rows of this table that reference
	// their roots or followed rows are kept too (a user's orders).
	Follow []string `yaml:"follow,omitempty"`
	// PerParent is the most followed rows per parent row (by Order); 0 is all.
	PerParent int `yaml:"per_parent,omitempty"`
}

type Schema struct {
	Driver string
	Tables []*Table
	// contains filtered or unexported fields
}

type SchemaFinding struct {
	Object string
	Kinds  []string
	Reason string
}

type SchemaRule struct {
	Kinds    []string `yaml:"kinds"`
	Reason   string   `yaml:"reason,omitempty"`
	Proposed bool     `yaml:"proposed,omitempty"`
}

type Stmt struct {
	SQL      string
	Compound bool
	// contains filtered or unexported fields
}

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

type SubsetRules struct {
	// Nullable is the default for nullable references whose row is outside
	// the sample: pull (default) or null.
	Nullable string `yaml:"nullable,omitempty"`
	// Tables chooses rows per table. A table not listed has only the rows
	// other kept rows reference.
	Tables map[string]*SampleRule `yaml:"tables,omitempty"`
	// References are declared for an application without foreign keys
	// (polymorphic columns too), or change the nullable rule of a foreign key.
	References []*Reference `yaml:"references,omitempty"`
}

type Table struct {
	Name        string // as in classify.yaml: the table, or schema.table outside PostgreSQL's public schema
	Columns     []*Column
	PrimaryKey  []string
	ForeignKeys []ForeignKey
	// contains filtered or unexported fields
}

type TableProposal struct {
	Table   string
	New     bool   // the table has no rule at all
	Action  string // proposed table action; "" copies
	Reason  string
	Columns []ColumnProposal // in the order of the table
}

type TableReport struct {
	Name    string         `json:"name"`
	Action  string         `json:"action"` // copy, empty, skip, or emptied (a serialized PHP column)
	Rows    int64          `json:"rows"`
	Columns []ColumnReport `json:"columns,omitempty"`
	Sample  *SampleReport  `json:"sample,omitempty"` // data subset
}

type TableRule struct {
	Action   string                 `yaml:"action,omitempty"`
	Reason   string                 `yaml:"reason,omitempty"`
	Proposed bool                   `yaml:"proposed,omitempty"`
	Columns  map[string]*ColumnRule `yaml:"columns,omitempty"`
}

type VerifyFinding struct {
	Check  string `json:"check"`  // detector or leak
	Output string `json:"output"` // "database <name>" or "dump"
	Table  string `json:"table"`  // "(schema)" for a statement of a dump that holds no rows
	Column string `json:"column,omitempty"`
	// Kind is the detector's kind (email, phone, jmbg, card, iban), or for
	// the leak check the kind of the original value (its strategy, or the
	// detector's kind for a part of free text), with "/word" for one word of
	// a name.
	Kind   string   `json:"kind"`
	Origin string   `json:"origin,omitempty"` // leak: the table.column the original value comes from
	Values int64    `json:"values"`           // output values with it
	Rows   []string `json:"rows,omitempty"`   // up to five: the primary key when it is numeric, else #n in key order
}

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

type VerifyOptions struct {
	Source Database  // the original, read in one snapshot: its personal values are looked for
	Target *Database // an output database to check; nil checks none
	Dump   io.Reader // an output dump to check; nil checks none
	Rules  *Rules
	Key    []byte        // the project key the output was made with
	PII    *pii.Detector // nil: the default detector
	// Index, filled by Anonymize (Options.Index) under the same key, holds
	// the original values to look for: the source is not read again, and
	// the originals are those of the snapshot the output was copied from.
	// The detector is the one Anonymize used.
	Index *VerifyIndex
	Log   io.Writer
}

type VerifyReport struct {
	Originals int64           `json:"originals"` // distinct original values the leak check looked for
	Values    int64           `json:"values"`    // output values scanned
	Seconds   float64         `json:"seconds"`
	Findings  []VerifyFinding `json:"findings"`
}