@intentius/chant-lexicon-sql 0.0.0-stage → 0.112.0

package/dist/postgres/migrate/carry.d.ts

@@ -0,0 +1,196 @@
+/**
+ * What uses the migrated column, carried over to the new one (#3322).
+ *
+ * An index, a constraint or a view on the column binds the column by its
+ * attribute number, not its name, so a swap of names at the switch would
+ * leave it on the old column, and the contract could not drop that column
+ * while something uses it. Each is made again on the new column before the
+ * switch, under a working name, and the switch swaps the names:
+ *
+ * | On the old column | Before the switch | In the switch's transaction |
+ * |---|---|---|
+ * | an index | `CREATE INDEX CONCURRENTLY` on the new column | the old one dropped (a type change) or kept as `<name>__chant_old` (a rename), the new one renamed to the name |
+ * | a primary key or unique constraint | its unique index built `CONCURRENTLY` | the old constraint dropped (or a rename's unique one kept as `__chant_old`), `ADD CONSTRAINT ... USING INDEX` |
+ * | a check or foreign key, this table's or another's that references the column | added `NOT VALID`, then `VALIDATE` | the old one dropped, the new one renamed to the name |
+ * | a view (and the views that read it) | nothing | dropped, then created again from its declaration once the columns are swapped, with its grants and owner |
+ *
+ * `CREATE INDEX CONCURRENTLY` reads the table without blocking writes, and
+ * `VALIDATE CONSTRAINT` holds SHARE UPDATE EXCLUSIVE, so both run while the
+ * application keeps writing; the dual-write trigger keeps the new column
+ * equal to the old one, so the index and the constraints hold the same rows
+ * as the old ones. A foreign key from another table is added against the
+ * new column's working unique index, which the switch then attaches to the
+ * key constraint. Everything in the switch changes only the catalog.
+ *
+ * Working objects carry chant's trailer with `migration=<key>` and
+ * `role=carry`, so the catalog read leaves them out of plans until the
+ * switch, and onFailure drops them (`./steps.ts`). The switch gives each its
+ * old comment back.
+ *
+ * Names: a type change keeps every name. A rename keeps a name the
+ * declaration does not give otherwise, except one Postgres made from the
+ * old column (`users_email_key` becomes `users_login_key`); a key, foreign
+ * key or index the build declares on the new column takes the declared name.
+ *
+ * Refused, each named with what to do: exclusion constraints and constraint
+ * triggers (no `USING INDEX` form), materialized views (made again only by
+ * a full scan in the switch), rules, triggers, policies and statistics on the
+ * column, a generated column computed from it, an INVALID index on it, a view
+ * the build does not declare, a view something other than a view depends on.
+ */
+import type { OwnershipMarker } from "@intentius/chant/ownership";
+import type { PostgresClient } from "../live/client.js";
+import { type Token } from "../tokens.js";
+import { type DeclaredPgObject } from "../apply/statements.js";
+import type { ColumnDef } from "../entities.js";
+import { type MigrationNames } from "./names.js";
+export type CarriedKind = "index" | "key" | "check" | "foreign-key";
+/** One index or constraint on the old column, and how it is made on the new one. */
+export interface CarriedObject {
+    kind: CarriedKind;
+    /** Its name now. */
+    name: string;
+    /** The table it is on, quoted and qualified (the referencing table for a foreign key). */
+    table: string;
+    /** The same, as `schema.table`, for messages. */
+    tableName: string;
+    tableOid: string;
+    /** The schema an index lives in (its table's). */
+    schema: string;
+    /** Its name on the new column until the switch. */
+    working: string;
+    /** Its name after the switch. */
+    target: string;
+    /**
+     * What makes the working object: for an index or a key, the `CREATE INDEX
+     * CONCURRENTLY` statement; for a check or a foreign key, the constraint's
+     * body (`CHECK (...)`, `FOREIGN KEY ... REFERENCES ...`), added `NOT VALID`.
+     */
+    definition: string;
+    /** A key: `PRIMARY KEY` or `UNIQUE`, and its deferral. */
+    primary?: boolean;
+    deferral?: string;
+    /** A constraint: validated on the server, so validated on the new column before the switch. */
+    validated: boolean;
+    comment?: string;
+    /** A key: the comment of its index. */
+    indexComment?: string;
+    replicaIdentity?: boolean;
+    clustered?: boolean;
+}
+/** A view on the old column (or on such a view), made again at the switch from its declaration. */
+export interface CarriedView {
+    /** `schema.name`. */
+    name: string;
+    /** Quoted and qualified. */
+    ident: string;
+    materialized: false;
+    /** How many views lie between it and the table: dropped deepest first, created shallowest first. */
+    depth: number;
+    declared: DeclaredPgObject;
+    owner: string;
+    grants: Array<{
+        grantee: string;
+        privilege: string;
+        grantable: boolean;
+    }>;
+}
+/** The sequence that belongs to the column: its identity's, or a `serial` column's. A type change moves it to the new column at the switch. */
+export interface ColumnSequence {
+    kind: "identity" | "serial";
+    schema: string;
+    name: string;
+    /** Quoted and qualified. */
+    ident: string;
+}
+export interface Dependents {
+    carried: CarriedObject[];
+    views: CarriedView[];
+    sequence?: ColumnSequence;
+    /** What the Op does not carry, each as a sentence naming the object. */
+    refused: string[];
+}
+/** The working name of a carried object, and the name a rename keeps the old one under. */
+export declare const carriedWorkingName: (name: string) => string;
+export declare const carriedOldName: (name: string) => string;
+/**
+ * `sql` with every reference to the column `from` replaced by `to`: an
+ * identifier token naming it, not a qualifier (`x.`), a qualified name's
+ * last part, a function's name, a cast's type or an access method. Within
+ * `[start, end)` token indexes when given.
+ */
+export declare function replaceColumn(sql: string, from: string, to: string, range?: (tokens: readonly Token[]) => Array<[number, number]>): string;
+/** A foreign key's body with the column replaced on the side(s) that are the migrated table. */
+export declare function replaceInForeignKey(def: string, from: string, to: string, sides: {
+    local: boolean;
+    referenced: boolean;
+}): string;
+/**
+ * `CREATE [UNIQUE] INDEX <name> ON ...` as `pg_get_indexdef` prints it, as
+ * the `CONCURRENTLY` build of `working` on the new column.
+ */
+export declare function carriedIndexStatement(def: string, working: string, from: string, to: string): string;
+/**
+ * The name Postgres gives an object it names after its columns
+ * (`users_email_key`, `orders_user_id_fkey`, `users_email_idx`), when `name`
+ * is that name for the old columns: the same name for the new ones. Only a
+ * name that fits untruncated; any other name is kept.
+ */
+export declare function renamedDefault(name: string, table: string, oldCols: readonly string[], newCols: readonly string[], suffix: string): string | undefined;
+interface DiscoverInput {
+    client: PostgresClient;
+    names: MigrationNames;
+    oid: string;
+    attnum: number;
+    /** Every object the build declares: views are made again from theirs, and a declared name wins on a rename. */
+    objects: readonly DeclaredPgObject[];
+    /** The declared table. */
+    declared: DeclaredPgObject;
+    defaultSchema: string;
+    /** The table is partitioned: its indexes cannot be built CONCURRENTLY, nor its keys attached USING INDEX. */
+    partitioned?: boolean;
+}
+/** What uses the column the values come from, sorted into what the Op carries over and what it refuses. */
+export declare function discoverDependents(input: DiscoverInput): Promise<Dependents>;
+/** `ALTER TABLE ... ADD CONSTRAINT <working> <body> NOT VALID`: a check or foreign key on the new column. */
+export declare const addCarriedConstraint: (c: CarriedObject) => string;
+/**
+ * The switch's statements for the carried objects, around the swap of the
+ * columns: `before` drops the views and swaps every index and constraint;
+ * `after` creates the views again from their declarations once the column
+ * they read has its name.
+ *
+ * Foreign keys that reference the column go first: the old key constraint
+ * cannot be dropped while one depends on its index.
+ */
+export declare function carriedSwitchStatements(carried: readonly CarriedObject[], views: readonly CarriedView[], change: "rename" | "type", oldComment: (c: CarriedObject) => string, marker: OwnershipMarker | undefined): {
+    before: string[];
+    after: string[];
+};
+/** What the gate binds about the carried objects: each one's kind, names and definition, and each view. */
+export declare function carriedSubject(d: Pick<Dependents, "carried" | "views" | "sequence">): unknown;
+/** Whether a declared column is NOT NULL once it is switched: declared so, an identity column, or part of a carried primary key. */
+export declare const requiresNotNull: (column: ColumnDef, carried: readonly CarriedObject[]) => boolean;
+/** The integer type of each `serial` spelling: what the column holds, and the sequence's type. */
+export declare const SERIAL_TYPES: Readonly<Record<string, string>>;
+/** A declared column's type as the server holds it: a `serial` spelling is its integer type. */
+export declare const storedType: (type: string | undefined) => string | undefined;
+/** How far a carried object's working copy has got on the server. */
+export interface CarriedState {
+    /** The working object is there. */
+    present: boolean;
+    /** An index: valid (its CONCURRENTLY build finished). A constraint: validated. */
+    ready: boolean;
+    /** It carries this migration's trailer; an index built and killed before its comment is adopted when its definition is the one expected. */
+    marked: boolean;
+}
+/**
+ * The working copies of the carried objects on the server, by working name.
+ * One under a working name that is somebody else's is refused, as for the
+ * other working objects (`./observe.ts`).
+ */
+export declare function carriedStates(client: PostgresClient, carried: readonly CarriedObject[], ours: (comment: string | undefined) => "ours" | "theirs" | "none", refuse: (what: string) => never): Promise<Map<string, CarriedState>>;
+/** The carried objects whose working copy is not there, not marked, or not yet valid. */
+export declare const carriedNotReady: (carried: readonly CarriedObject[], states: ReadonlyMap<string, CarriedState>) => CarriedObject[];
+export {};
+//# sourceMappingURL=carry.d.ts.map

package/dist/postgres/migrate/carry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"carry.d.ts","sourceRoot":"","sources":["../../../src/postgres/migrate/carry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAElE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AACrD,OAAO,EAAgB,KAAK,KAAK,EAAE,MAAM,WAAW,CAAC;AAErD,OAAO,EAAyB,KAAK,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AACnF,OAAO,KAAK,EAAE,SAAS,EAAyB,MAAM,aAAa,CAAC;AAGpE,OAAO,EAAU,KAAK,cAAc,EAAE,MAAM,SAAS,CAAC;AAEtD,MAAM,MAAM,WAAW,GAAG,OAAO,GAAG,KAAK,GAAG,OAAO,GAAG,aAAa,CAAC;AAEpE,oFAAoF;AACpF,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,WAAW,CAAC;IAClB,oBAAoB;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,0FAA0F;IAC1F,KAAK,EAAE,MAAM,CAAC;IACd,iDAAiD;IACjD,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,kDAAkD;IAClD,MAAM,EAAE,MAAM,CAAC;IACf,mDAAmD;IACnD,OAAO,EAAE,MAAM,CAAC;IAChB,iCAAiC;IACjC,MAAM,EAAE,MAAM,CAAC;IACf;;;;OAIG;IACH,UAAU,EAAE,MAAM,CAAC;IACnB,0DAA0D;IAC1D,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,+FAA+F;IAC/F,SAAS,EAAE,OAAO,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,uCAAuC;IACvC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,mGAAmG;AACnG,MAAM,WAAW,WAAW;IAC1B,qBAAqB;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,4BAA4B;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,KAAK,CAAC;IACpB,oGAAoG;IACpG,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,KAAK,CAAC;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;CAC3E;AAED,+IAA+I;AAC/I,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,UAAU,GAAG,QAAQ,CAAC;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,4BAA4B;IAC5B,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,aAAa,EAAE,CAAC;IACzB,KAAK,EAAE,WAAW,EAAE,CAAC;IACrB,QAAQ,CAAC,EAAE,cAAc,CAAC;IAC1B,wEAAwE;IACxE,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED,2FAA2F;AAC3F,eAAO,MAAM,kBAAkB,GAAI,MAAM,MAAM,KAAG,MAAsC,CAAC;AACzF,eAAO,MAAM,cAAc,GAAI,MAAM,MAAM,KAAG,MAAsC,CAAC;AAErF;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,CAAC,MAAM,EAAE,SAAS,KAAK,EAAE,KAAK,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAAG,MAAM,CAmB1I;AAoBD,gGAAgG;AAChG,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,UAAU,EAAE,OAAO,CAAA;CAAE,GAAG,MAAM,CAKjI;AAKD;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAIpG;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,MAAM,EAAE,EAAE,OAAO,EAAE,SAAS,MAAM,EAAE,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAKtJ;AAID,UAAU,aAAa;IACrB,MAAM,EAAE,cAAc,CAAC;IACvB,KAAK,EAAE,cAAc,CAAC;IACtB,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,+GAA+G;IAC/G,OAAO,EAAE,SAAS,gBAAgB,EAAE,CAAC;IACrC,0BAA0B;IAC1B,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,aAAa,EAAE,MAAM,CAAC;IACtB,6GAA6G;IAC7G,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAMD,2GAA2G;AAC3G,wBAAsB,kBAAkB,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,UAAU,CAAC,CAmRlF;AAID,6GAA6G;AAC7G,eAAO,MAAM,oBAAoB,GAAI,GAAG,aAAa,KAAG,MAAoG,CAAC;AAK7J;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,SAAS,aAAa,EAAE,EACjC,KAAK,EAAE,SAAS,WAAW,EAAE,EAC7B,MAAM,EAAE,QAAQ,GAAG,MAAM,EACzB,UAAU,EAAE,CAAC,CAAC,EAAE,aAAa,KAAK,MAAM,EACxC,MAAM,EAAE,eAAe,GAAG,SAAS,GAClC;IAAE,MAAM,EAAE,MAAM,EAAE,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAA;CAAE,CAyCvC;AAED,2GAA2G;AAC3G,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,CAAC,UAAU,EAAE,SAAS,GAAG,OAAO,GAAG,UAAU,CAAC,GAAG,OAAO,CAM7F;AAED,oIAAoI;AACpI,eAAO,MAAM,eAAe,GAAI,QAAQ,SAAS,EAAE,SAAS,SAAS,aAAa,EAAE,KAAG,OAC2F,CAAC;AAEnL,kGAAkG;AAClG,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAOzD,CAAC;AAEF,gGAAgG;AAChG,eAAO,MAAM,UAAU,GAAI,MAAM,MAAM,GAAG,SAAS,KAAG,MAAM,GAAG,SAAkH,CAAC;AAElL,qEAAqE;AACrE,MAAM,WAAW,YAAY;IAC3B,mCAAmC;IACnC,OAAO,EAAE,OAAO,CAAC;IACjB,kFAAkF;IAClF,KAAK,EAAE,OAAO,CAAC;IACf,4IAA4I;IAC5I,MAAM,EAAE,OAAO,CAAC;CACjB;AAED;;;;GAIG;AACH,wBAAsB,aAAa,CACjC,MAAM,EAAE,cAAc,EACtB,OAAO,EAAE,SAAS,aAAa,EAAE,EACjC,IAAI,EAAE,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,KAAK,MAAM,GAAG,QAAQ,GAAG,MAAM,EACjE,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,KAAK,GAC9B,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC,CAiCpC;AAED,yFAAyF;AACzF,eAAO,MAAM,eAAe,GAAI,SAAS,SAAS,aAAa,EAAE,EAAE,QAAQ,WAAW,CAAC,MAAM,EAAE,YAAY,CAAC,KAAG,aAAa,EAIxH,CAAC"}

package/dist/postgres/migrate/handoff.d.ts

@@ -0,0 +1,46 @@
+/**
+ * How a Postgres plan hands an expand-and-contract change to the migration
+ * Op (#3281), as the ClickHouse plan hands a rebuild to its Op (#3250).
+ *
+ * `chant sql plan`, `chant sql diff`, the `classify-change` MCP tool and the
+ * applier refuse an expand-and-contract change in place. For a column
+ * rename (SQLPG205) and a type change across kinds (SQLPG208) what they hand
+ * on is a `PostgresMigrationOp` declaration per column, ready to put in an
+ * `*.op.ts` file, reviewed in the pull request like the schema change it
+ * carries out. The Op's own Plan phase classifies the change again against
+ * the server. The other expand-and-contract rules (a NOT NULL column with no
+ * default, partitioning, an object rename, a view's columns, enum labels, a
+ * domain's type, an object's kind) have no Op yet, and get none.
+ *
+ * Nothing is written for the user. The hand-off's shape is the shared
+ * core's (`../../core/handoff.ts`).
+ */
+import { type MigrationOpSuggestion } from "../../core/handoff.js";
+import type { PgChange } from "../plan/diff.js";
+import type { PgDiffObject } from "../plan/schema.js";
+export interface PostgresMigrationOpSuggestion extends MigrationOpSuggestion {
+    /** `schema.table`, the Op's `table`. */
+    table: string;
+    /** The declared column, the Op's `column`. */
+    column: string;
+    /** The rule the Op makes the change for. */
+    rule: "SQLPG205" | "SQLPG208";
+}
+/** The rules a refused change is handed to the Op for. */
+export declare const HANDED_OFF: Set<string>;
+/** The table and column a refused change is about, when the Op makes it. */
+export declare function migrationTarget(c: PgChange, declared: Pick<PgDiffObject, "kind" | "schema" | "name"> | undefined, defaultSchema?: string): {
+    table: string;
+    column: string;
+} | undefined;
+/** The Op's declaration for one column. */
+export declare function migrationDeclaration(name: string, env: string, table: string, column: string): string;
+/**
+ * One suggestion per column the diff refuses for a rename or a type change
+ * across kinds. `declared` maps the diff's object keys to the declared
+ * definitions.
+ */
+export declare function migrationOpSuggestions(refused: readonly PgChange[], declared: ReadonlyMap<string, PgDiffObject>, env: string, defaultSchema?: string): PostgresMigrationOpSuggestion[];
+/** The suggestions as text, for the report. */
+export declare function renderMigrationOpSuggestions(ops: readonly PostgresMigrationOpSuggestion[]): string[];
+//# sourceMappingURL=handoff.d.ts.map

package/dist/postgres/migrate/handoff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handoff.d.ts","sourceRoot":"","sources":["../../../src/postgres/migrate/handoff.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EAAuC,KAAK,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AACrG,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAC7C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAEnD,MAAM,WAAW,6BAA8B,SAAQ,qBAAqB;IAC1E,wCAAwC;IACxC,KAAK,EAAE,MAAM,CAAC;IACd,8CAA8C;IAC9C,MAAM,EAAE,MAAM,CAAC;IACf,4CAA4C;IAC5C,IAAI,EAAE,UAAU,GAAG,UAAU,CAAC;CAC/B;AAED,0DAA0D;AAC1D,eAAO,MAAM,UAAU,aAAoC,CAAC;AAI5D,4EAA4E;AAC5E,wBAAgB,eAAe,CAAC,CAAC,EAAE,QAAQ,EAAE,QAAQ,EAAE,IAAI,CAAC,YAAY,EAAE,MAAM,GAAG,QAAQ,GAAG,MAAM,CAAC,GAAG,SAAS,EAAE,aAAa,SAAW,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAK1L;AAED,2CAA2C;AAC3C,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAErG;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,SAAS,QAAQ,EAAE,EAAE,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,YAAY,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,aAAa,SAAW,GAAG,6BAA6B,EAAE,CAaxL;AAED,+CAA+C;AAC/C,wBAAgB,4BAA4B,CAAC,GAAG,EAAE,SAAS,6BAA6B,EAAE,GAAG,MAAM,EAAE,CAEpG"}

package/dist/postgres/migrate/names.d.ts

@@ -0,0 +1,55 @@
+/**
+ * The names an expand-and-contract migration of one column uses (#3281), and
+ * the trailer that marks its working objects.
+ *
+ * A migration is keyed by `<schema>.<table>.<column>`, the column as the
+ * build declares it. Its working objects are:
+ *
+ * - the new column: the declared name for a rename (`login`), or
+ *   `<column>__chant_new` for a type change, until the switch;
+ * - the old column after the switch: the old name for a rename (`email`,
+ *   still written by the dual-write trigger), or `<column>__chant_old` for a
+ *   type change (no longer written);
+ * - the dual-write trigger `<column>__chant_sync` on the table and its
+ *   function `<table>__<column>__chant_sync` in the table's schema;
+ * - the check `<new>__chant_nn` that proves NOT NULL before it is set.
+ *
+ * Each carries chant's ownership trailer (`../../core/ownership.ts`) with
+ * `migration=<key>` and its role in its comment. The catalog read
+ * (`../live/catalog.ts`) leaves out a column or a constraint whose comment
+ * carries the `migration` key, so a plan, an import and a prune see the table
+ * as it was before the migration until the switch, and as declared after it.
+ */
+/** The trailer key on a migration's working objects. */
+export declare const MIGRATION_TRAILER_KEY = "migration";
+/** A name Postgres keeps whole: `base`, or its first bytes and a short hash of all of it when it is longer than 63 bytes. */
+export declare function pgName(base: string): string;
+/** What the migration changes about the column. */
+export type MigrationChange = "rename" | "type";
+export interface MigrationNames {
+    /** `<schema>.<table>.<column>`: the migration's identity. */
+    key: string;
+    schema: string;
+    table: string;
+    /** The column as declared. */
+    column: string;
+    change: MigrationChange;
+    /** The column the values come from: the old name for a rename, the column itself for a type change. */
+    source: string;
+    /** The column being filled until the switch. */
+    newColumn: string;
+    /** The old column's name after the switch. */
+    oldColumn: string;
+    trigger: string;
+    /** The trigger function's name, unqualified. */
+    fn: string;
+    /** The check that proves the new column NOT NULL before SET NOT NULL. */
+    check: string;
+    /** Quoted, qualified: the table and the function. */
+    qualifiedTable: string;
+    qualifiedFn: string;
+}
+export declare function migrationNames(schema: string, table: string, column: string, change: MigrationChange, source: string): MigrationNames;
+/** A quoted column name. */
+export declare const col: (name: string) => string;
+//# sourceMappingURL=names.d.ts.map

package/dist/postgres/migrate/names.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"names.d.ts","sourceRoot":"","sources":["../../../src/postgres/migrate/names.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAKH,wDAAwD;AACxD,eAAO,MAAM,qBAAqB,cAAc,CAAC;AAKjD,6HAA6H;AAC7H,wBAAgB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAM3C;AAED,mDAAmD;AACnD,MAAM,MAAM,eAAe,GAAG,QAAQ,GAAG,MAAM,CAAC;AAEhD,MAAM,WAAW,cAAc;IAC7B,6DAA6D;IAC7D,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,8BAA8B;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,eAAe,CAAC;IACxB,uGAAuG;IACvG,MAAM,EAAE,MAAM,CAAC;IACf,gDAAgD;IAChD,SAAS,EAAE,MAAM,CAAC;IAClB,8CAA8C;IAC9C,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,gDAAgD;IAChD,EAAE,EAAE,MAAM,CAAC;IACX,yEAAyE;IACzE,KAAK,EAAE,MAAM,CAAC;IACd,qDAAqD;IACrD,cAAc,EAAE,MAAM,CAAC;IACvB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,EAAE,MAAM,GAAG,cAAc,CAkBrI;AAKD,4BAA4B;AAC5B,eAAO,MAAM,GAAG,GAAI,MAAM,MAAM,KAAG,MAA0B,CAAC"}

package/dist/postgres/migrate/observe.d.ts

@@ -0,0 +1,139 @@
+/**
+ * The expand-and-contract migration's view of the server (#3281): which
+ * column of which table is migrated, how far the migration has got, and
+ * what it will do.
+ *
+ * Every step of the Op re-observes from here rather than trusting what an
+ * earlier run or step said, so the Op converges: run it again after a crash,
+ * a gate or an approval, and each step finds its work done or still to do.
+ * The progress is read off the table itself: its columns, the dual-write
+ * trigger and its function, and the NOT NULL check, each carrying chant's
+ * trailer with `migration=<key>` and a role (`./names.ts`).
+ *
+ * The change is found the way `chant sql plan` finds it: the declared table
+ * against what the catalog read prints (`../plan/commands.ts`), which leaves
+ * the working columns out. So the plan shows the change refused until the
+ * switch, and the declaration held after it.
+ *
+ * States:
+ *
+ * - `migrate`: the declared column differs from the server's by a rename
+ *   (SQLPG205) or a type change (SQLPG207, SQLPG208), and the switch has not
+ *   run.
+ * - `switched`: the switch ran; the old column is kept until its date.
+ * - `done`: the server holds the declared column and nothing of the
+ *   migration is left.
+ *
+ * Anything else is refused with a {@link MigrationRefusal}, naming what to
+ * do: a table that is not there, a partition (run it on the partitioned
+ * table) or an inheritance tree; no primary key to batch by; a column in the
+ * partition key; a generated column; a column change the Op does not make
+ * (a rename and a type change at once, a rename of a column with a default
+ * or a sequence); something that uses the column and is
+ * not carried over to the new one (`./carry.ts`: indexes, key, check and
+ * foreign key constraints and declared views are); a publication that sends
+ * it; a working object chant did not make.
+ */
+import type { OwnershipMarker } from "@intentius/chant/ownership";
+import type { PostgresClient } from "../live/client.js";
+import type { PostgresTarget } from "../live/bind.js";
+import type { PgChange } from "../plan/diff.js";
+import type { ColumnDef } from "../entities.js";
+import type { DeclaredPgObject } from "../apply/statements.js";
+import { MIGRATION_TRAILER_KEY, type MigrationNames } from "./names.js";
+import { type PublicationHit } from "./replication.js";
+import { type KeyColumn } from "./batches.js";
+import { type CarriedObject, type CarriedState, type CarriedView, type ColumnSequence } from "./carry.js";
+/** A refusal: the migration cannot start, or cannot go on, for a reason a person has to act on. */
+export declare class MigrationRefusal extends Error {
+    constructor(message: string);
+}
+/** The rules the Op makes: a rename, and a type change with or without a rewrite in place. */
+export declare const MIGRATION_RULES: Set<string>;
+/** One column as the catalog holds it. */
+export interface ServerColumn {
+    attnum: number;
+    name: string;
+    type: string;
+    notNull: boolean;
+    default?: string;
+    comment?: string;
+    generated: boolean;
+    identity: boolean;
+    /** The trailer pairs of its comment, when it is a working column. */
+    pairs?: Map<string, string>;
+}
+/** A working object other than a column: the trigger, its function, the check. */
+export interface WorkingObject {
+    name: string;
+    comment?: string;
+    pairs?: Map<string, string>;
+}
+export interface MigrationObservation {
+    state: "migrate" | "switched" | "done";
+    names: MigrationNames;
+    declared: DeclaredPgObject;
+    /** The declared column. */
+    column: ColumnDef;
+    /** The table's oid. */
+    oid: string;
+    /** Its primary key, which the backfill batches by: `id`, or `(tenant_id, id)`. */
+    batchKey: string;
+    /** The primary key's columns, in its order (`./batches.ts`). */
+    keyColumns: KeyColumn[];
+    /** The indexes and constraints on the old column, carried over to the new one before the switch (`./carry.ts`). */
+    carried: CarriedObject[];
+    /** Their working copies on the server, by working name. */
+    carriedStates: Map<string, CarriedState>;
+    /** The views that read the old column, made again at the switch. */
+    views: CarriedView[];
+    /** The sequence that gives the old column its values (identity or serial), moved to the new column at the switch. */
+    sequence?: ColumnSequence;
+    /** The table is partitioned: every step runs on it, and its partitions follow. */
+    partitioned: boolean;
+    columns: Map<string, ServerColumn>;
+    /** The column the values come from, while there is one. */
+    source?: ServerColumn;
+    newColumn?: ServerColumn;
+    old?: ServerColumn;
+    trigger?: WorkingObject;
+    fn?: WorkingObject;
+    check?: WorkingObject & {
+        validated: boolean;
+    };
+    /** The changes the classifier reports for the column. */
+    changes: PgChange[];
+    /** The expression the new column's value is computed with, over the old row's columns. */
+    expression: string;
+    publications: PublicationHit[];
+    major: number;
+}
+export interface ObserveInput {
+    client: PostgresClient;
+    target: PostgresTarget;
+    declared: DeclaredPgObject;
+    column: string;
+    marker?: OwnershipMarker;
+    /** Every object the build declares; the views the switch makes again come from here. Default: the table alone. */
+    objects?: readonly DeclaredPgObject[];
+    /** The type change's expression, over the old row's columns. Default: `CAST(<column> AS <declared type>)`. */
+    using?: string;
+    /** The major the build targets; the server's own wins. */
+    major?: number;
+}
+/** The declared table with the given key (`schema.table`) or export name, or a refusal naming what is declared. */
+export declare function declaredTable(declared: readonly DeclaredPgObject[], key: string): DeclaredPgObject;
+/** The server's major, from `server_version_num`. */
+export declare function serverMajor(client: PostgresClient): Promise<number>;
+/** Observe the migration of the declared table's column on the server. */
+export declare function observeMigration(input: ObserveInput): Promise<MigrationObservation>;
+/**
+ * What the migration will do, independent of how far it has got: the
+ * change, the column on both sides, the expression, the batch key. The
+ * Plan phase publishes its digest; the gate binds a digest of this and the
+ * verification.
+ */
+export declare function migrationPlanSubject(o: MigrationObservation): Record<string, unknown>;
+export declare const migrationPlanDigest: (o: MigrationObservation) => string;
+export { MIGRATION_TRAILER_KEY };
+//# sourceMappingURL=observe.d.ts.map

package/dist/postgres/migrate/observe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"observe.d.ts","sourceRoot":"","sources":["../../../src/postgres/migrate/observe.ts"],"names":[],"mappings":"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"}

package/dist/postgres/migrate/op.d.ts

@@ -0,0 +1,128 @@
+/**
+ * `PostgresMigrationOp` (#3281): the column change Postgres cannot make in
+ * place without breaking readers (a rename, SQLPG205; a type change across
+ * kinds, SQLPG208), run as expand and contract in a gated composite Op. A
+ * type change within a kind that rewrites the table under ACCESS EXCLUSIVE
+ * (SQLPG207) can run as the same Op, which fills the new column in batches
+ * instead.
+ *
+ *     export const { op } = PostgresMigrationOp({
+ *       name: "migrate-app-users-login",
+ *       env: "prod",
+ *       table: "app.users",
+ *       column: "login",
+ *     });
+ *
+ * | Phase | Step |
+ * |---|---|
+ * | Build | `chant build` (`build: false` skips it) |
+ * | Plan | classify the column's change against the server; refuse what the Op does not make |
+ * | Expand | add the new column, nullable, no default (a catalog change) |
+ * | Dual write | a trigger that keeps the new column written: computed from the old one for a type change, both ways for a rename |
+ * | Backfill | `UPDATE` per key range, each batch with its receipt in its own transaction, under `lock_timeout`, pausing while a replica is behind |
+ * | Carry over | each index on the old column built again on the new one `CONCURRENTLY`, each check and foreign key (another table's too) added `NOT VALID` and validated (`./carry.ts`) |
+ * | Verify | rows, mismatches and checksums of the new column against the old |
+ * | Approve | a gate bound to the plan and the verified new column |
+ * | Switch | NOT NULL proven by a validated check; then one short transaction: a type change swaps the columns by name, a rename finishes the new column; the carried indexes and constraints take their names (keys `USING INDEX`), and the views that read the column are made again from their declarations |
+ * | Retain | the old column, until `retain` has passed |
+ * | Approve contract | a gate bound to that old column |
+ * | Contract | drop the old column (and a rename's trigger) once its date has passed |
+ * | onFailure | drop what the expand added: the trigger, its function, the check, the new column, the receipts |
+ *
+ * Run it until it is done: each run goes as far as the next gate. Every step
+ * re-reads the server, so a run after a gate, a crash or an approval picks up
+ * where the last stopped. A run killed during the backfill (Ctrl-C, a lost
+ * machine) is not a failure, runs no onFailure, and the next run resumes the
+ * backfill from its receipts; a step that fails runs onFailure, and the next
+ * run starts again from a new column.
+ */
+import { type GateApproval } from "@intentius/chant/op";
+import type { OpResource } from "@intentius/chant/op";
+export interface PostgresMigrationOpConfig {
+    /** Op name (kebab-case). */
+    name: string;
+    /** The chant environment: selects `sql.profiles.<env>`. */
+    env: string;
+    /** The table, `schema.name` as the server knows it (or its export name). */
+    table: string;
+    /** The column as the build declares it: the new name for a rename. */
+    column: string;
+    /**
+     * A type change: the SQL expression that computes the new value from the
+     * old row's columns, as `ALTER COLUMN ... TYPE ... USING` takes it. Default:
+     * `CAST(<column> AS <declared type>)`. The backfill, the dual-write trigger
+     * and the verification all use it.
+     */
+    using?: string;
+    /** The build output the declaration is read from. Default: `dist/schema.json`. */
+    output?: string;
+    /** Project directory to build. Default: `.`. */
+    path?: string;
+    /** Run `chant build` first (the project's `build` script). Default: true. */
+    build?: boolean;
+    /** How long the old column is kept after the switch, as a duration (`7d`, `36h`). Default: `7d`. */
+    retain?: string;
+    /**
+     * Rows per batch: the width of a batch's range of a primary key of one
+     * integer column, or how many keys lie between two recorded boundaries of
+     * any other key (uuid, text, several columns). Default: 1000.
+     */
+    batchSize?: number;
+    /**
+     * Pause the backfill while a replica's replay lag is above `max`, for up to
+     * `wait` at a time. Default: `{ max: "10s", wait: "30m" }`. `false` turns
+     * the check off.
+     */
+    replicationLag?: {
+        max?: string;
+        wait?: string;
+    } | false;
+    /** `lock_timeout` for every statement, in ms. Default: the profile's `lockTimeoutMs`, else 5000. */
+    lockTimeoutMs?: number;
+    /** `statement_timeout` for every statement but the scans (validation, verification), in ms. Default: the profile's `statementTimeoutMs`, else 60000. */
+    statementTimeoutMs?: number;
+    /** The gate before the switch. Default name `approve-<name>`. */
+    gate?: {
+        gate?: string;
+        timeout?: string;
+        description?: string;
+        /** Quorum, roles and a policy (#2508). With a policy, the verification's counts are added to its context. */
+        approval?: GateApproval;
+    };
+    /** The gate before the old column is dropped. Default name `approve-<name>-contract`. */
+    contractGate?: {
+        gate?: string;
+        timeout?: string;
+        description?: string;
+    };
+    /** One attempt of the backfill step. Default: `6h`, the longest a step may run. */
+    backfillTimeout?: string;
+    /** Ownership stack. Default: `ownership.stack` in `chant.config.ts`. */
+    stack?: string;
+    /** Ownership env. Default: `ownership.env` in `chant.config.ts`. */
+    ownershipEnv?: string;
+}
+export interface PostgresMigrationOpResources {
+    op: InstanceType<typeof OpResource>;
+}
+/** The arguments every migration activity takes. */
+export interface PostgresMigrationArgs {
+    table: string;
+    column: string;
+    buildPath: string;
+    environment?: string;
+    using?: string;
+    retain?: string;
+    batchSize?: number;
+    replicationLag?: {
+        max?: string;
+        wait?: string;
+    } | false;
+    lockTimeoutMs?: number;
+    statementTimeoutMs?: number;
+    stack?: string;
+    ownershipEnv?: string;
+    cwd?: string;
+}
+export declare function PostgresMigrationOp(config: PostgresMigrationOpConfig): PostgresMigrationOpResources;
+//# sourceMappingURL=op.d.ts.map

package/dist/postgres/migrate/op.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"op.d.ts","sourceRoot":"","sources":["../../../src/postgres/migrate/op.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAEH,OAAO,EAAyC,KAAK,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAC/F,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAItD,MAAM,WAAW,yBAAyB;IACxC,4BAA4B;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,2DAA2D;IAC3D,GAAG,EAAE,MAAM,CAAC;IACZ,4EAA4E;IAC5E,KAAK,EAAE,MAAM,CAAC;IACd,sEAAsE;IACtE,MAAM,EAAE,MAAM,CAAC;IACf;;;;;OAKG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,kFAAkF;IAClF,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,gDAAgD;IAChD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,6EAA6E;IAC7E,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,oGAAoG;IACpG,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;OAIG;IACH,cAAc,CAAC,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,KAAK,CAAC;IACzD,oGAAoG;IACpG,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,wJAAwJ;IACxJ,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,iEAAiE;IACjE,IAAI,CAAC,EAAE;QACL,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,6GAA6G;QAC7G,QAAQ,CAAC,EAAE,YAAY,CAAC;KACzB,CAAC;IACF,yFAAyF;IACzF,YAAY,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACzE,mFAAmF;IACnF,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,wEAAwE;IACxE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,oEAAoE;IACpE,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,4BAA4B;IAC3C,EAAE,EAAE,YAAY,CAAC,OAAO,UAAU,CAAC,CAAC;CACrC;AAED,oDAAoD;AACpD,MAAM,WAAW,qBAAqB;IACpC,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,cAAc,CAAC,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,KAAK,CAAC;IACzD,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAID,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,yBAAyB,GAAG,4BAA4B,CAoHnG"}