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

package/dist/postgres/parser.d.ts

@@ -0,0 +1,216 @@
+/**
+ * A hand-written, lossless parser for the Postgres statements the dialect
+ * declares (chant #3278, #3279): `CREATE SCHEMA`, `TABLE`, `INDEX`, `VIEW`,
+ * `MATERIALIZED VIEW`, `SEQUENCE`, `TYPE ... AS ENUM`, `DOMAIN`, `EXTENSION`,
+ * and `COMMENT ON` for those objects.
+ *
+ * As for ClickHouse (#3196), statement structure is parsed and expressions are
+ * not: a default, a check, a generated expression, an index element, a
+ * partition bound and a view's query are token spans, verbatim, with the
+ * interpolations inside them recorded. Postgres itself is the backstop.
+ *
+ * What the spike measured as missing is closed here: a column default is a
+ * `b_expr`, so a top-level `IN`, `AND`, `LIKE` or `IS NULL` in it is an error
+ * at that token; `LIKE ... INCLUDING` and `ON COMMIT` take only their own
+ * option words; a storage parameter list (`WITH (fillfactor = 70)`) is parsed
+ * as `name [= value]` items; a type cannot be a reserved word (`a ARRAY[4]`
+ * fails at `ARRAY`); and a range partition bound cannot be empty.
+ *
+ * An interpolation (`ref` token) is accepted wherever a name, a type or an
+ * expression goes. Lint parses with every interpolation still a `ref`.
+ *
+ * Grammar source: the Postgres 18 reference pages for each statement
+ * (sql-createtable, sql-createindex, sql-createview,
+ * sql-creatematerializedview, sql-createsequence, sql-createtype,
+ * sql-createdomain, sql-createextension, sql-createschema, sql-comment) and
+ * `src/backend/parser/gram.y` at `REL_18_6` where a page is silent.
+ */
+import { type Span } from "../core/cursor.js";
+import { SqlSyntaxError, type Token } from "../core/tokens.js";
+export type { Span } from "../core/cursor.js";
+export { SqlSyntaxError };
+/** An identifier as Postgres reads it: an unquoted name folds to lower case, a quoted one is exact. */
+export declare function identValue(t: Token | string): string;
+export interface NameNode {
+    /** The name's pieces, folded. An empty string where a piece is an interpolation. */
+    pieces: string[];
+    span: Span;
+}
+export interface ReferencesNode {
+    table: NameNode;
+    columns: Array<{
+        name: string;
+        span: Span;
+    }>;
+    match?: string;
+    onDelete?: Span;
+    onUpdate?: Span;
+}
+export type ConstraintKind = "PRIMARY KEY" | "UNIQUE" | "CHECK" | "FOREIGN KEY" | "EXCLUDE" | "NOT NULL";
+export interface ConstraintNode {
+    name?: string;
+    kind: ConstraintKind;
+    /** The columns a table constraint is on, by name. */
+    columns: Array<{
+        name: string;
+        span: Span;
+    }>;
+    /** A check's expression, or an exclusion's element list. */
+    expr?: Span;
+    /** An exclusion constraint's access method. */
+    using?: string;
+    /** An exclusion constraint's predicate. */
+    where?: Span;
+    references?: ReferencesNode;
+    nullsNotDistinct?: boolean;
+    /** `INCLUDE (...)`, as written, parentheses excluded. */
+    include?: Span;
+    /** `WITH (...)` storage parameters, as written, parentheses excluded. */
+    with?: Span;
+    deferrable?: boolean;
+    initiallyDeferred?: boolean;
+    notValid?: boolean;
+    noInherit?: boolean;
+    /** `NOT ENFORCED` (Postgres 18). */
+    notEnforced?: boolean;
+    span: Span;
+}
+export interface ColumnNode {
+    name: string;
+    nameSpan: Span;
+    type?: Span;
+    collate?: Span;
+    compression?: Span;
+    storage?: Span;
+    /** `NOT NULL` (true) or `NULL` (false), when written. */
+    notNull?: boolean;
+    /** A name given to the column's NOT NULL constraint (`CONSTRAINT x NOT NULL`). */
+    notNullName?: string;
+    default?: Span;
+    generated?: {
+        kind: "stored" | "virtual" | "identity";
+        expr?: Span;
+        always: boolean;
+        options?: Span;
+    };
+    /** Column constraints other than NOT NULL, NULL, DEFAULT and GENERATED. */
+    constraints: ConstraintNode[];
+}
+export interface TableNode {
+    statement: "table";
+    persistence?: "temporary" | "unlogged";
+    ifNotExists: boolean;
+    name: NameNode;
+    ofType?: NameNode;
+    partitionOf?: NameNode;
+    partitionBound?: Span;
+    columns: ColumnNode[];
+    constraints: ConstraintNode[];
+    like: Span[];
+    inherits?: NameNode[];
+    partitionBy?: Span;
+    using?: Span;
+    with?: Span;
+    onCommit?: Span;
+    tablespace?: Span;
+}
+export interface IndexElement {
+    span: Span;
+    /** When the element is a plain column (a name, then only opclass, collation and ordering words), its name. */
+    column?: string;
+}
+export interface IndexNode {
+    statement: "index";
+    unique: boolean;
+    concurrently: boolean;
+    ifNotExists: boolean;
+    name?: NameNode;
+    only: boolean;
+    table: NameNode;
+    using?: string;
+    elements: IndexElement[];
+    include?: Span;
+    nullsNotDistinct?: boolean;
+    with?: Span;
+    tablespace?: Span;
+    where?: Span;
+}
+export interface ViewNode {
+    statement: "view";
+    materialized: boolean;
+    orReplace: boolean;
+    temporary: boolean;
+    recursive: boolean;
+    ifNotExists: boolean;
+    name: NameNode;
+    columnNames: Array<{
+        name: string;
+        span: Span;
+    }>;
+    using?: Span;
+    with?: Span;
+    tablespace?: Span;
+    query: Span;
+    checkOption?: Span;
+    /** `WITH DATA` (true) or `WITH NO DATA` (false), for a materialized view. */
+    withData?: boolean;
+}
+export interface SequenceNode {
+    statement: "sequence";
+    persistence?: "temporary" | "unlogged";
+    ifNotExists: boolean;
+    name: NameNode;
+    options: Array<{
+        option: string;
+        value?: Span;
+    }>;
+}
+export interface SchemaNode {
+    statement: "schema";
+    ifNotExists: boolean;
+    name?: NameNode;
+    authorization?: Span;
+}
+export interface EnumNode {
+    statement: "enum";
+    name: NameNode;
+    labels: Span[];
+}
+export interface DomainNode {
+    statement: "domain";
+    name: NameNode;
+    type: Span;
+    collate?: Span;
+    default?: Span;
+    notNull?: boolean;
+    checks: Array<{
+        name?: string;
+        expr: Span;
+        notValid?: boolean;
+    }>;
+}
+export interface ExtensionNode {
+    statement: "extension";
+    ifNotExists: boolean;
+    name: NameNode;
+    schema?: Span;
+    version?: Span;
+    cascade: boolean;
+}
+export interface CommentNode {
+    statement: "comment";
+    /** TABLE, COLUMN, INDEX, VIEW, MATERIALIZED VIEW, SEQUENCE, TYPE, DOMAIN, SCHEMA, EXTENSION, CONSTRAINT, DOMAIN CONSTRAINT. */
+    objectType: string;
+    target: NameNode;
+    /** For `COMMENT ON CONSTRAINT c ON [DOMAIN] t`: the table or domain. */
+    on?: NameNode;
+    /** The comment, a string, or undefined for `IS NULL`. */
+    text?: Span;
+}
+export type StatementNode = TableNode | IndexNode | ViewNode | SequenceNode | SchemaNode | EnumNode | DomainNode | ExtensionNode | CommentNode;
+/**
+ * Parse a template: one CREATE, optionally followed by COMMENT ON statements,
+ * separated by `;`. Throws {@link SqlSyntaxError} located in the template.
+ */
+export declare function parseStatements(tokens: Token[]): StatementNode[];
+//# sourceMappingURL=parser.d.ts.map

package/dist/postgres/parser.d.ts.map

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

package/dist/postgres/plan/commands.d.ts

@@ -0,0 +1,61 @@
+/**
+ * `chant sql diff` and `chant sql plan` for Postgres: the classified change
+ * between two builds, or between a build and a live server.
+ *
+ * `diff` is offline and needs no server. `plan` reads the server
+ * `sql.profiles.<env>` binds, and asks it about expressions the rules leave
+ * different (`./server-normalize.ts`). Both exit 2 when a change can only be
+ * made as expand and contract, which a plan refuses, and 0 otherwise.
+ */
+import { type BindOptions, type PostgresTarget } from "../live/bind.js";
+import type { PostgresClient } from "../live/client.js";
+import { readLiveSchema, type LivePgObject } from "../live/catalog.js";
+import { type PgSchemaDiff } from "./diff.js";
+import { type PgSchemaObject } from "./schema.js";
+import { serverNormalized } from "./server-normalize.js";
+export declare function emitPg(diff: PgSchemaDiff, json: boolean, title: string): number;
+/** The major the project declares (`sql.postgresMajor`); undefined is the newest pinned one. */
+export declare function projectMajor(options?: {
+    config?: {
+        sql?: {
+            postgresMajor?: number;
+        };
+    };
+    cwd?: string;
+}): Promise<number | undefined>;
+/**
+ * Offline, the major is the one the builds recorded (`postgresMajor`): the
+ * newer build's, else the older's, so a diff between revisions does not
+ * depend on today's config. `configMajor` (`sql.postgresMajor`) answers for
+ * builds that recorded none.
+ */
+export declare function diffPgBuildFiles(before: string, after: string, configMajor?: number): PgSchemaDiff;
+/** The diff with the migration Op to run for each refused column rename or type change (`../migrate/handoff.ts`). */
+export declare function withMigrationOps(diff: PgSchemaDiff, declared: readonly PgSchemaObject[], env: string, defaultSchema?: string): PgSchemaDiff;
+/** What {@link planAgainstClient} compares and finds: both sides keyed by qualified name, and the classified changes between them. */
+export interface PgServerPlan {
+    /** The declarations, keyed by qualified name, with what the server said about expressions the rules left different. */
+    declared: PgSchemaObject[];
+    /** What the server holds in scope, keyed by qualified name. */
+    live: PgSchemaObject[];
+    /** The same, as the catalog read returned it (comments with their trailers). */
+    liveObjects: LivePgObject[];
+    diff: PgSchemaDiff;
+    /** The major the changes were classified for: the server's, else the one asked for. */
+    major?: number;
+}
+/**
+ * The declared objects (a build's, keyed by export name) against what a
+ * connected server holds: read in the declarations' scope, the server asked
+ * about expressions the rules leave different, then diffed. The plan and the
+ * applier (`../apply/`) share it.
+ */
+export declare function planAgainstClient(client: PostgresClient, target: PostgresTarget, build: readonly PgSchemaObject[], options?: {
+    major?: number;
+    environment?: string;
+    readLive?: typeof readLiveSchema;
+    serverNormalize?: typeof serverNormalized;
+}): Promise<PgServerPlan>;
+/** The declared objects against the server, keys by qualified name and labels with the export name. */
+export declare function planPgAgainstServer(environment: string, buildFile: string, options?: Omit<BindOptions, "environment">): Promise<PgSchemaDiff>;
+//# sourceMappingURL=commands.d.ts.map

package/dist/postgres/plan/commands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commands.d.ts","sourceRoot":"","sources":["../../../src/postgres/plan/commands.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAA+B,KAAK,WAAW,EAAE,KAAK,cAAc,EAAE,MAAM,cAAc,CAAC;AAClG,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AACrD,OAAO,EAAqB,cAAc,EAAE,KAAK,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAEvF,OAAO,EAAiB,KAAK,YAAY,EAAE,MAAM,QAAQ,CAAC;AAE1D,OAAO,EAAmF,KAAK,cAAc,EAAE,MAAM,UAAU,CAAC;AAChI,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAItD,wBAAgB,MAAM,CAAC,IAAI,EAAE,YAAY,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAG/E;AAED,gGAAgG;AAChG,wBAAsB,YAAY,CAAC,OAAO,GAAE;IAAE,MAAM,CAAC,EAAE;QAAE,GAAG,CAAC,EAAE;YAAE,aAAa,CAAC,EAAE,MAAM,CAAA;SAAE,CAAA;KAAE,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAA;CAAO,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAG7I;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,YAAY,CAIlG;AAED,qHAAqH;AACrH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,YAAY,EAAE,QAAQ,EAAE,SAAS,cAAc,EAAE,EAAE,GAAG,EAAE,MAAM,EAAE,aAAa,SAAW,GAAG,YAAY,CAG7I;AAYD,sIAAsI;AACtI,MAAM,WAAW,YAAY;IAC3B,uHAAuH;IACvH,QAAQ,EAAE,cAAc,EAAE,CAAC;IAC3B,+DAA+D;IAC/D,IAAI,EAAE,cAAc,EAAE,CAAC;IACvB,gFAAgF;IAChF,WAAW,EAAE,YAAY,EAAE,CAAC;IAC5B,IAAI,EAAE,YAAY,CAAC;IACnB,uFAAuF;IACvF,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;;GAKG;AACH,wBAAsB,iBAAiB,CACrC,MAAM,EAAE,cAAc,EACtB,MAAM,EAAE,cAAc,EACtB,KAAK,EAAE,SAAS,cAAc,EAAE,EAChC,OAAO,GAAE;IAAE,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,cAAc,CAAC;IAAC,eAAe,CAAC,EAAE,OAAO,gBAAgB,CAAA;CAAO,GAClI,OAAO,CAAC,YAAY,CAAC,CAwBvB;AAED,uGAAuG;AACvG,wBAAsB,mBAAmB,CAAC,WAAW,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,OAAO,GAAE,IAAI,CAAC,WAAW,EAAE,aAAa,CAAM,GAAG,OAAO,CAAC,YAAY,CAAC,CAYvJ"}

package/dist/postgres/plan/deep.d.ts

@@ -0,0 +1,33 @@
+/**
+ * `observeResourcesDeep()` for the Postgres dialect: each declared object's
+ * live definition as a property tree in the declaration's own shape, so
+ * `chant lifecycle diff --live` reports property drift with no false drift.
+ *
+ * The reader parses what the catalog prints for the object (`../live/catalog.ts`)
+ * with the same tag the declaration used, which gives the same props shape.
+ * A field whose canonical form (`./normalize.ts`) equals the declaration's is
+ * written with the declaration's own value, so `timestamptz` and
+ * `timestamp with time zone`, or a constraint the declaration left unnamed and
+ * the name Postgres gave it, do not read as drift; a field that differs keeps
+ * the server's value. `deepNormalizationHooks` prunes what is not a property
+ * of the object (the DDL text, the template source, lineage, reads).
+ */
+import { type DeepObservationResult } from "@intentius/chant/deep-observation";
+import { type BindOptions } from "../live/bind.js";
+import { type LivePgObject } from "../live/catalog.js";
+import { type CanonicalPgObject } from "./normalize.js";
+type Props = Record<string, unknown>;
+/** The props of what the server printed, parsed with the declaration's tag. */
+export declare function liveProps(o: LivePgObject): Props;
+/** The live props, with each field the declaration means the same as written the declaration's way. */
+export declare function inDeclaredVocabulary(declared: Props, live: Props, d: CanonicalPgObject, l: CanonicalPgObject): Props;
+export declare function observeResourcesDeep(options: {
+    environment: string;
+    entityNames: string[];
+    entities: Map<string, {
+        entityType: string;
+        props: Record<string, unknown>;
+    }>;
+} & Omit<BindOptions, "environment">): Promise<DeepObservationResult>;
+export {};
+//# sourceMappingURL=deep.d.ts.map

package/dist/postgres/plan/deep.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deep.d.ts","sourceRoot":"","sources":["../../../src/postgres/plan/deep.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAmB,KAAK,qBAAqB,EAAgC,MAAM,mCAAmC,CAAC;AAE9H,OAAO,EAAyC,KAAK,WAAW,EAAE,MAAM,cAAc,CAAC;AACvF,OAAO,EAA2B,KAAK,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAI7E,OAAO,EAAkD,KAAK,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAErG,KAAK,KAAK,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAcrC,+EAA+E;AAC/E,wBAAgB,SAAS,CAAC,CAAC,EAAE,YAAY,GAAG,KAAK,CAGhD;AA6CD,uGAAuG;AACvG,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,EAAE,iBAAiB,EAAE,CAAC,EAAE,iBAAiB,GAAG,KAAK,CAwCpH;AAED,wBAAsB,oBAAoB,CACxC,OAAO,EAAE;IACP,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,CAAC,CAAC;CAC/E,GAAG,IAAI,CAAC,WAAW,EAAE,aAAa,CAAC,GACnC,OAAO,CAAC,qBAAqB,CAAC,CAwChC"}

package/dist/postgres/plan/diff.d.ts

@@ -0,0 +1,45 @@
+/**
+ * The diff between two Postgres schemas, each change classified by the lock
+ * it takes and whether it reads or rewrites the table (`./rules.ts`).
+ *
+ * Identity, as for ClickHouse (#3237): an object is its export name between
+ * two builds, so a changed SQL name under the same export is a rename;
+ * against a server it is its qualified name, and `-- previously: <old name>`
+ * before the CREATE declares a rename. A column is its name; a column renamed
+ * in place says `-- previously: <old name>` on its line, and without the hint
+ * a drop and an add of the same type in the same place get a hint.
+ *
+ * A constraint the declaration leaves unnamed is matched by what it says, so
+ * the name Postgres gave it is not a change.
+ */
+import { type ChangeSet, type ClassifiedChange } from "../../core/classifier.js";
+import { matchByIdentity } from "../../core/diff.js";
+import { type PgChangeClass, type PgClassifierRuleId } from "./rules.js";
+import { type CanonicalConstraint } from "./normalize.js";
+import type { PgDiffObject, PgSchemaObject } from "./schema.js";
+import type { PostgresMigrationOpSuggestion } from "../migrate/handoff.js";
+/** What the diff needs to know beyond the two schemas: the server's major (`sql.postgresMajor`, else the newest pinned). */
+export interface PgDiffOptions {
+    major?: number;
+}
+export type PgChange = ClassifiedChange<PgClassifierRuleId, PgChangeClass>;
+export interface PgSchemaDiff extends ChangeSet<PgChange> {
+    /** The changes a plan refuses to make in place: expand and contract only. */
+    refused: PgChange[];
+    /** The `PostgresMigrationOp` to run for each refused column rename or type change (#3281). */
+    migrationOps?: PostgresMigrationOpSuggestion[];
+}
+/** The rule adding a constraint falls under. */
+export declare function addConstraintRule(c: CanonicalConstraint): PgClassifierRuleId;
+/**
+ * Classify every change from `before` to `after`. Objects another tool owns
+ * (an ORM's revision table) are never proposed for a drop.
+ */
+/**
+ * Which object of `before` each object of `after` is: by key, else by a
+ * `-- previously:` hint naming the old one. The diff and the applier
+ * (`../apply/`) match the same way.
+ */
+export declare function matchPgObjects(before: readonly PgSchemaObject[], after: readonly PgSchemaObject[]): ReturnType<typeof matchByIdentity<PgDiffObject>>;
+export declare function diffPgSchemas(before: readonly PgSchemaObject[], after: readonly PgSchemaObject[], options?: PgDiffOptions): PgSchemaDiff;
+//# sourceMappingURL=diff.d.ts.map

package/dist/postgres/plan/diff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff.d.ts","sourceRoot":"","sources":["../../../src/postgres/plan/diff.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAoB,KAAK,SAAS,EAAE,KAAK,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAChG,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,EAAuB,KAAK,aAAa,EAAE,KAAK,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAC3F,OAAO,EAAoD,KAAK,mBAAmB,EAAE,MAAM,aAAa,CAAC;AACzG,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAE7D,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,oBAAoB,CAAC;AAExE,4HAA4H;AAC5H,MAAM,WAAW,aAAa;IAC5B,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,MAAM,QAAQ,GAAG,gBAAgB,CAAC,kBAAkB,EAAE,aAAa,CAAC,CAAC;AAE3E,MAAM,WAAW,YAAa,SAAQ,SAAS,CAAC,QAAQ,CAAC;IACvD,6EAA6E;IAC7E,OAAO,EAAE,QAAQ,EAAE,CAAC;IACpB,8FAA8F;IAC9F,YAAY,CAAC,EAAE,6BAA6B,EAAE,CAAC;CAChD;AAqHD,gDAAgD;AAChD,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,mBAAmB,GAAG,kBAAkB,CAa5E;AAiHD;;;GAGG;AACH;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,SAAS,cAAc,EAAE,EAAE,KAAK,EAAE,SAAS,cAAc,EAAE,GAAG,UAAU,CAAC,OAAO,eAAe,CAAC,YAAY,CAAC,CAAC,CASpJ;AAED,wBAAgB,aAAa,CAAC,MAAM,EAAE,SAAS,cAAc,EAAE,EAAE,KAAK,EAAE,SAAS,cAAc,EAAE,EAAE,OAAO,GAAE,aAAkB,GAAG,YAAY,CAuB5I"}

package/dist/postgres/plan/disruption.d.ts

@@ -0,0 +1,14 @@
+/**
+ * `classifyDisruption()` for Postgres: what applying a pending update costs,
+ * from the paths `chant lifecycle plan` reports changed, mapped onto the
+ * classifier's rules (`./rules.ts`). A path alone cannot always say which rule
+ * applies (a column's type change is metadata, a rewrite or expand and
+ * contract depending on both types); those answer `unknown`, and `chant sql
+ * plan` classifies them with both definitions in hand.
+ */
+import type { DisruptionQuery, DisruptionVerdict } from "@intentius/chant/lifecycle/disruption";
+export declare function classifyPgDisruption(options: {
+    environment: string;
+    changes: DisruptionQuery[];
+}): Record<string, DisruptionVerdict>;
+//# sourceMappingURL=disruption.d.ts.map

package/dist/postgres/plan/disruption.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"disruption.d.ts","sourceRoot":"","sources":["../../../src/postgres/plan/disruption.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,uCAAuC,CAAC;AA+BhG,wBAAgB,oBAAoB,CAAC,OAAO,EAAE;IAAE,WAAW,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,eAAe,EAAE,CAAA;CAAE,GAAG,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAWpI"}

package/dist/postgres/plan/normalize.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Normalization: a Postgres object's definition in a form two definitions can
+ * be compared in, so a declaration and what the catalog prints for it are
+ * equal when they mean the same thing (#3279, #3275 question 6).
+ *
+ * The catalog's printers rewrite what they were given. `format_type()` spells
+ * every type its SQL way (`timestamptz` is `timestamp with time zone`,
+ * `int4` is `integer`, `numeric(12, 2)` is `numeric(12,2)`); `pg_get_expr()`
+ * casts every literal (`'placed'::app.order_status`, `0::numeric`, a negative
+ * number as `'-1'::integer`), rewrites `x IN ('a', 'b')` as
+ * `x = ANY (ARRAY['a'::text, 'b'::text])` and parenthesizes a check;
+ * `pg_get_constraintdef()` names every constraint; `pg_get_indexdef()` adds
+ * `USING btree`; with an empty `search_path` every name outside `pg_catalog`
+ * is schema-qualified. Each of those is undone here, on both sides, by rule:
+ *
+ * - an expression compares as its token sequence: whitespace and comments
+ *   left out, unquoted words in lower case, a quoted name that needs no quotes
+ *   written bare, a cast on a literal dropped, a quoted number cast to a
+ *   number read as the number, `IN (literals)` read as `= ANY (ARRAY[...])`,
+ *   and parentheses around the whole of it dropped;
+ * - a type is its `format_type()` spelling, from the pinned catalog's alias
+ *   table; a type outside `pg_catalog` is qualified with the default schema;
+ * - a name with no schema is in the default schema (`public` unless the
+ *   profile says otherwise), as `search_path` would resolve it;
+ * - a constraint the declaration leaves unnamed is matched by what it says,
+ *   not by the name Postgres gave it; a primary key's and an identity
+ *   column's columns are `NOT NULL` whether or not that is written;
+ * - an identity column's or a sequence's options at their defaults are left
+ *   out; storage parameters compare as a map;
+ * - an index's access method defaults to `btree`.
+ *
+ * What the rules cannot see (a view's `SELECT *`, which the server expands, or
+ * an expression it parenthesizes) is asked of the live server itself when a
+ * plan or a deep read has one (`./server-normalize.ts`). Offline, between two
+ * builds, only the rules apply.
+ */
+/** The integer type a serial spelling stands for, or undefined for any other type. */
+export declare const serialBase: (type: string | undefined) => string | undefined;
+/** A qualified name in canonical form: each piece unquoted where it can be, the default schema added to a bare one. */
+export declare function canonicalName(text: string, defaultSchema?: string): string;
+/**
+ * A type as `format_type()` prints it: `int4` and `int` are `integer`,
+ * `timestamptz` is `timestamp with time zone`, `varchar(20)` is
+ * `character varying(20)`, `int[]` is `integer[]`, `numeric(12, 2)` is
+ * `numeric(12,2)`, a type outside `pg_catalog` is schema-qualified.
+ */
+export declare function canonicalType(text: string | undefined, defaultSchema?: string): string | undefined;
+/**
+ * An expression in canonical form: a string of tokens joined by single
+ * spaces. Two expressions that read the same after the rules in this file's
+ * header have the same canonical form.
+ */
+export declare function canonicalExpr(text: string | undefined): string | undefined;
+/** A storage parameter list as a sorted map: `(fillfactor = 70)` and `WITH (fillfactor=70)` are `{ fillfactor: "70" }`. */
+export declare function canonicalOptions(text: string | undefined): Record<string, string> | undefined;
+export interface CanonicalColumn {
+    name: string;
+    position: number;
+    type?: string;
+    notNull: boolean;
+    default?: string;
+    generated?: string;
+    identity?: string;
+    collate?: string;
+    compression?: string;
+    storage?: string;
+    comment?: string;
+}
+export interface CanonicalConstraint {
+    kind: "PRIMARY KEY" | "UNIQUE" | "CHECK" | "FOREIGN KEY" | "EXCLUDE";
+    /** The declared name; undefined when the declaration gave none, so a generated name is not compared. */
+    name?: string;
+    /** What the constraint says, names left out: two with the same body are the same constraint. */
+    body: string;
+    /** Whether the constraint is `NOT VALID`: a validation step, not part of what it says. */
+    notValid?: boolean;
+    comment?: string;
+}
+export type CanonicalKind = "schema" | "table" | "index" | "view" | "materializedView" | "sequence" | "enum" | "domain" | "extension";
+export interface CanonicalPgObject {
+    kind: CanonicalKind;
+    schema?: string;
+    name: string;
+    /** Everything else that is compared, by field, each field canonical. */
+    fields: Record<string, unknown>;
+    columns: CanonicalColumn[];
+    constraints: CanonicalConstraint[];
+}
+/** Identity or sequence options, at their defaults left out, as a sorted `key value` list. */
+export declare function canonicalSequenceOptions(o: {
+    type?: string;
+    increment?: string;
+    minValue?: string | null;
+    maxValue?: string | null;
+    start?: string;
+    cache?: string;
+    cycle?: boolean;
+}, ownerType?: string): string;
+/**
+ * A definition in canonical form. `props` is an entity's props, declared or
+ * parsed from what the server printed; `defaultSchema` qualifies a bare name.
+ */
+export declare function canonicalPgObject(entityType: string, props: Record<string, unknown>, defaultSchema?: string): CanonicalPgObject;
+/** Whether two canonical constraints are the same one: the same body, and the same name when both declare one. */
+export declare function sameConstraint(a: CanonicalConstraint, b: CanonicalConstraint): boolean;
+/** A column without its position, for comparing two columns. */
+export declare const columnShape: ({ position: _p, ...rest }: CanonicalColumn) => string;
+//# sourceMappingURL=normalize.d.ts.map

package/dist/postgres/plan/normalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize.d.ts","sourceRoot":"","sources":["../../../src/postgres/plan/normalize.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAyDH,sFAAsF;AACtF,eAAO,MAAM,UAAU,GAAI,MAAM,MAAM,GAAG,SAAS,KAAG,MAAM,GAAG,SAAiE,CAAC;AAEjI,uHAAuH;AACvH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,aAAa,CAAC,EAAE,MAAM,GAAG,MAAM,CAQ1E;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,EAAE,aAAa,SAAW,GAAG,MAAM,GAAG,SAAS,CAgCpG;AA8CD;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAyB1E;AAmDD,2HAA2H;AAC3H,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAS7F;AAID,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,aAAa,GAAG,QAAQ,GAAG,OAAO,GAAG,aAAa,GAAG,SAAS,CAAC;IACrE,wGAAwG;IACxG,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,gGAAgG;IAChG,IAAI,EAAE,MAAM,CAAC;IACb,0FAA0F;IAC1F,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,MAAM,aAAa,GAAG,QAAQ,GAAG,OAAO,GAAG,OAAO,GAAG,MAAM,GAAG,kBAAkB,GAAG,UAAU,GAAG,MAAM,GAAG,QAAQ,GAAG,WAAW,CAAC;AAEtI,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,aAAa,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,wEAAwE;IACxE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChC,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B,WAAW,EAAE,mBAAmB,EAAE,CAAC;CACpC;AAsBD,8FAA8F;AAC9F,wBAAgB,wBAAwB,CACtC,CAAC,EAAE;IAAE,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,EAC7I,SAAS,CAAC,EAAE,MAAM,GACjB,MAAM,CAiBR;AA6BD;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,aAAa,SAAW,GAAG,iBAAiB,CAyIjI;AAED,kHAAkH;AAClH,wBAAgB,cAAc,CAAC,CAAC,EAAE,mBAAmB,EAAE,CAAC,EAAE,mBAAmB,GAAG,OAAO,CAEtF;AAED,gEAAgE;AAChE,eAAO,MAAM,WAAW,GAAI,2BAA2B,eAAe,KAAG,MAA8B,CAAC"}

package/dist/postgres/plan/report.d.ts

@@ -0,0 +1,6 @@
+/** A Postgres schema diff as text (the shared core's report, with the refusal of expand-and-contract changes). */
+import type { PgSchemaDiff } from "./diff.js";
+export declare function renderPgDiff(diff: PgSchemaDiff, opts?: {
+    title?: string;
+}): string;
+//# sourceMappingURL=report.d.ts.map

package/dist/postgres/plan/report.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"report.d.ts","sourceRoot":"","sources":["../../../src/postgres/plan/report.ts"],"names":[],"mappings":"AAAA,kHAAkH;AAIlH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAG3C,wBAAgB,YAAY,CAAC,IAAI,EAAE,YAAY,EAAE,IAAI,GAAE;IAAE,KAAK,CAAC,EAAE,MAAM,CAAA;CAAO,GAAG,MAAM,CAgBtF"}

package/dist/postgres/plan/rules.d.ts

@@ -0,0 +1,84 @@
+/**
+ * The Postgres change classifier's rules (#3279, #3275 question 3): every way
+ * a declared Postgres object can change, the class of change it is on the
+ * server, and the restriction behind the class, cited from the Postgres 18
+ * documentation (the pinned major), with the differences across the
+ * supported majors 14 to 18 stated where there are any.
+ *
+ * The classes are by the lock a change takes and whether it reads or
+ * rewrites the table ("Explicit Locking", `ALTER TABLE`'s Notes):
+ *
+ * - `metadata`: a catalog change under a brief lock; no row is read or
+ *   written. Most `ALTER TABLE` forms take `ACCESS EXCLUSIVE` even so, which
+ *   queues behind every running query, so the applier (#3280) sets a
+ *   `lock_timeout`.
+ * - `validate`: every row is read to check a constraint, under a lock weaker
+ *   than `ACCESS EXCLUSIVE` (`SHARE UPDATE EXCLUSIVE` for `VALIDATE
+ *   CONSTRAINT`, so reads and writes go on).
+ * - `concurrently`: an index build, which blocks writes for its whole run
+ *   unless it is `CONCURRENTLY`, and `CONCURRENTLY` cannot run inside a
+ *   transaction block.
+ * - `rewrite`: the table is rewritten, or read in full, under `ACCESS
+ *   EXCLUSIVE`, blocking reads and writes for the duration.
+ * - `expand`: no in-place change keeps old readers working (a rename, a type
+ *   change with no cast in place, a change of partitioning): it is made as
+ *   expand and contract, by the migration Op (#3281). A plan refuses it.
+ *
+ * Creating and dropping whole objects are classed `create` and `drop`.
+ */
+import { type ChangeClasses, type ClassifierRule as SqlClassifierRule } from "../../core/classifier.js";
+export type PgChangeClass = "metadata" | "validate" | "concurrently" | "rewrite" | "expand" | "create" | "drop";
+export type PgClassifierRule = SqlClassifierRule<PgChangeClass>;
+export declare const PG_CHANGE_CLASSES: ChangeClasses<PgChangeClass>;
+export declare const PG_CLASSIFIER_RULES: {
+    readonly SQLPG200: PgClassifierRule;
+    readonly SQLPG201: PgClassifierRule;
+    readonly SQLPG202: PgClassifierRule;
+    readonly SQLPG203: PgClassifierRule;
+    readonly SQLPG204: PgClassifierRule;
+    readonly SQLPG205: PgClassifierRule;
+    readonly SQLPG206: PgClassifierRule;
+    readonly SQLPG207: PgClassifierRule;
+    readonly SQLPG208: PgClassifierRule;
+    readonly SQLPG209: PgClassifierRule;
+    readonly SQLPG210: PgClassifierRule;
+    readonly SQLPG211: PgClassifierRule;
+    readonly SQLPG212: PgClassifierRule;
+    readonly SQLPG213: PgClassifierRule;
+    readonly SQLPG214: PgClassifierRule;
+    readonly SQLPG215: PgClassifierRule;
+    readonly SQLPG216: PgClassifierRule;
+    readonly SQLPG217: PgClassifierRule;
+    readonly SQLPG218: PgClassifierRule;
+    readonly SQLPG219: PgClassifierRule;
+    readonly SQLPG220: PgClassifierRule;
+    readonly SQLPG221: PgClassifierRule;
+    readonly SQLPG222: PgClassifierRule;
+    readonly SQLPG223: PgClassifierRule;
+    readonly SQLPG224: PgClassifierRule;
+    readonly SQLPG225: PgClassifierRule;
+    readonly SQLPG226: PgClassifierRule;
+    readonly SQLPG227: PgClassifierRule;
+    readonly SQLPG228: PgClassifierRule;
+    readonly SQLPG229: PgClassifierRule;
+    readonly SQLPG240: PgClassifierRule;
+    readonly SQLPG241: PgClassifierRule;
+    readonly SQLPG242: PgClassifierRule;
+    readonly SQLPG243: PgClassifierRule;
+    readonly SQLPG250: PgClassifierRule;
+    readonly SQLPG251: PgClassifierRule;
+    readonly SQLPG252: PgClassifierRule;
+    readonly SQLPG253: PgClassifierRule;
+    readonly SQLPG260: PgClassifierRule;
+    readonly SQLPG261: PgClassifierRule;
+    readonly SQLPG262: PgClassifierRule;
+    readonly SQLPG263: PgClassifierRule;
+    readonly SQLPG264: PgClassifierRule;
+    readonly SQLPG265: PgClassifierRule;
+    readonly SQLPG266: PgClassifierRule;
+    readonly SQLPG267: PgClassifierRule;
+    readonly SQLPG268: PgClassifierRule;
+    readonly SQLPG270: PgClassifierRule;
+};
+export type PgClassifierRuleId = keyof typeof PG_CLASSIFIER_RULES;
+//# sourceMappingURL=rules.d.ts.map

package/dist/postgres/plan/rules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rules.d.ts","sourceRoot":"","sources":["../../../src/postgres/plan/rules.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,EAAkB,KAAK,aAAa,EAAE,KAAK,cAAc,IAAI,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAErH,MAAM,MAAM,aAAa,GAAG,UAAU,GAAG,UAAU,GAAG,cAAc,GAAG,SAAS,GAAG,QAAQ,GAAG,QAAQ,GAAG,MAAM,CAAC;AAEhH,MAAM,MAAM,gBAAgB,GAAG,iBAAiB,CAAC,aAAa,CAAC,CAAC;AAEhE,eAAO,MAAM,iBAAiB,EAAE,aAAa,CAAC,aAAa,CAY1D,CAAC;AASF,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyNqB,CAAC;AAEtD,MAAM,MAAM,kBAAkB,GAAG,MAAM,OAAO,mBAAmB,CAAC"}