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

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

@@ -0,0 +1,63 @@
+/**
+ * Effect receipts kept in Postgres (#3281): where the expand-and-contract
+ * migration's backfill records which batches it has filled.
+ *
+ * A receipt is the proof that one effect ran, kept where the effect happened
+ * (concepts/effect-receipts.mdx). A batch's effect is "these rows of the
+ * table have the new column filled", so the receipt is a row in the same
+ * database, in the table's own schema:
+ *
+ *     SELECT * FROM app.__chant_receipts
+ *
+ * In the table's schema rather than a `chant_receipts` schema, as #3265 put
+ * the ClickHouse receipts of a Replicated database beside the tables they
+ * witness: whoever can read the table can read its receipts, and a
+ * provider that reserves schemas or limits `CREATE SCHEMA` (#3282) does not
+ * stop the migration. The table's comment carries chant's trailer with the
+ * `receipts` key, so the catalog read leaves it out of plans, import and
+ * prune.
+ *
+ * Postgres adds what ClickHouse could not: the receipt is written in the
+ * batch's own transaction, after its `UPDATE`, and commits with it. The
+ * receipt is still written last and on success only, and a run killed
+ * anywhere leaves either the batch and its receipt or neither, so a resumed
+ * backfill never updates a batch twice. Each expectation is bound to the
+ * table's oid and the new column's attribute number, which a column dropped
+ * by onFailure and added again does not keep, so an old receipt reads as
+ * stale; onFailure and the contract also delete the migration's receipts.
+ *
+ * The store implements the shared core's `SqlReceiptStore`
+ * (`../../core/receipts.ts`) over the migration's own connection. It is not
+ * exported as the `receiptRead` / `receiptWrite` activities, whose names are
+ * global to a run and belong to an aws or k8s project's receipt row.
+ */
+import { type SqlReceiptStore } from "../../core/receipts.js";
+import type { PostgresClient } from "../live/client.js";
+/** The receipts table, in the migrated table's schema. */
+export declare const POSTGRES_RECEIPTS_TABLE = "__chant_receipts";
+export { receiptAddress } from "../../core/receipts.js";
+/** A receipts table chant did not make: a user's table under the same name. */
+export declare class ReceiptsTableConflict extends Error {
+    constructor(schema: string);
+}
+export interface PostgresReceiptStore extends SqlReceiptStore {
+    /** The qualified, quoted table name. */
+    table: string;
+    /** Create the table if it is not there. Outside any transaction the store's caller has open. */
+    ensure(): Promise<void>;
+    /** Delete every receipt whose address starts with `prefix`, and the table once it holds none. */
+    forget(prefix: string): Promise<number>;
+}
+/**
+ * A receipt store in `<schema>.__chant_receipts`, over `client`. `write` runs
+ * on the client as it is, so a write inside the caller's transaction commits
+ * or rolls back with it. `identity` is the project's ownership stack and env,
+ * which every address starts with.
+ */
+export declare function postgresReceiptStore(client: PostgresClient, schema: string, identity: {
+    stack?: string;
+    env?: string;
+}, opts?: {
+    runId?: string;
+}): PostgresReceiptStore;
+//# sourceMappingURL=receipts.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"receipts.d.ts","sourceRoot":"","sources":["../../../src/postgres/migrate/receipts.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAKH,OAAO,EAAkB,KAAK,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAE3E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAErD,0DAA0D;AAC1D,eAAO,MAAM,uBAAuB,qBAAqB,CAAC;AAI1D,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAErD,+EAA+E;AAC/E,qBAAa,qBAAsB,SAAQ,KAAK;gBAClC,MAAM,EAAE,MAAM;CAO3B;AAED,MAAM,WAAW,oBAAqB,SAAQ,eAAe;IAC3D,wCAAwC;IACxC,KAAK,EAAE,MAAM,CAAC;IACd,gGAAgG;IAChG,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACxB,iGAAiG;IACjG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;CACzC;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE;IAAE,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,EAAE,IAAI,GAAE;IAAE,KAAK,CAAC,EAAE,MAAM,CAAA;CAAO,GAAG,oBAAoB,CA4D5K"}

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

@@ -0,0 +1,80 @@
+/**
+ * Replication around an expand-and-contract migration (#3281): the backfill
+ * pauses while a replica is behind, and a table that logical replication
+ * publishes is refused.
+ *
+ * ## Lag
+ *
+ * A backfill writes every row of the table once more, and each batch's WAL
+ * goes to every standby and every logical subscriber. Before each batch the
+ * backfill reads `pg_stat_replication` on the primary
+ * (https://www.postgresql.org/docs/18/monitoring-stats.html#MONITORING-PG-STAT-REPLICATION-VIEW),
+ * one row per WAL sender, and waits while any `replay_lag` is above the
+ * bound, up to a deadline, then stops naming the replica. `replay_lag` is
+ * NULL once a standby has caught up and nothing new is being sent, which is
+ * no lag. No rows means no replicas, and the check passes at once: a single
+ * server, or a managed one whose replicas are not WAL senders (Aurora's
+ * share storage), skips cleanly.
+ *
+ * A role that is neither superuser nor a member of `pg_monitor` sees the
+ * rows with every column but the process's own NULL, so the lag cannot be
+ * read; that stops the backfill with the grant to make, rather than go on
+ * blind. `replicationLag: false` on the Op turns the check off.
+ *
+ * ## Publications
+ *
+ * A logical replication subscriber applies each published row change by
+ * column name, and its own table must have every column the publisher
+ * sends ("Logical Replication", Restrictions and Column Lists,
+ * https://www.postgresql.org/docs/18/logical-replication-col-lists.html).
+ * The expand adds a column, so a publication that sends the whole table
+ * would fail the subscriber's apply at the first backfilled row, and a
+ * rename or a type change would need the same change on the subscriber at
+ * the same moment as the switch. The Plan phase therefore refuses a table a
+ * publication sends the migrated column of, naming each publication. A
+ * publication with a column list (15 and later) that leaves the column out
+ * sends neither it nor the new one, and does not stop the migration.
+ */
+import type { PostgresClient } from "../live/client.js";
+export interface ReplicationLagBound {
+    /** The most a replica may be behind before a batch waits, in ms. */
+    maxLagMs: number;
+    /** How long one wait may last before the backfill stops, in ms. */
+    waitMs: number;
+}
+export declare const DEFAULT_REPLICATION_LAG: ReplicationLagBound;
+/** A replica that stayed behind past the wait, or whose lag this role cannot read. */
+export declare class ReplicationLagError extends Error {
+    constructor(message: string);
+}
+export interface ReplicaLag {
+    /** `application_name`, else the client address, else the process id. */
+    name: string;
+    /** Replay lag in ms; undefined when the role cannot read it. */
+    lagMs?: number;
+}
+/** The WAL senders on this server and how far behind each replica's replay is. */
+export declare function replicaLags(client: Pick<PostgresClient, "query">): Promise<ReplicaLag[]>;
+/**
+ * Wait until every replica is within the bound. Returns how long it waited,
+ * in ms (0 when no replica was behind, or there are none).
+ */
+export declare function waitForReplicas(client: Pick<PostgresClient, "query">, bound: ReplicationLagBound, opts?: {
+    log?: (line: string) => void;
+    signal?: AbortSignal;
+    sleep?: (ms: number, signal?: AbortSignal) => Promise<void>;
+    now?: () => number;
+}): Promise<number>;
+/** One publication that sends the migrated column. */
+export interface PublicationHit {
+    name: string;
+    /** Whether it sends every column (no column list). */
+    allColumns: boolean;
+}
+/**
+ * The publications that send `column` of `schema.table`. On 15 and later a
+ * publication with a column list that leaves the column out is not one;
+ * before 15 there are no column lists, and any publication of the table is.
+ */
+export declare function publicationsOf(client: Pick<PostgresClient, "query">, schema: string, table: string, column: string, major: number): Promise<PublicationHit[]>;
+//# sourceMappingURL=replication.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"replication.d.ts","sourceRoot":"","sources":["../../../src/postgres/migrate/replication.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAErD,MAAM,WAAW,mBAAmB;IAClC,oEAAoE;IACpE,QAAQ,EAAE,MAAM,CAAC;IACjB,mEAAmE;IACnE,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,eAAO,MAAM,uBAAuB,EAAE,mBAA+D,CAAC;AAEtG,sFAAsF;AACtF,qBAAa,mBAAoB,SAAQ,KAAK;gBAChC,OAAO,EAAE,MAAM;CAI5B;AAED,MAAM,WAAW,UAAU;IACzB,wEAAwE;IACxE,IAAI,EAAE,MAAM,CAAC;IACb,gEAAgE;IAChE,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,kFAAkF;AAClF,wBAAsB,WAAW,CAAC,MAAM,EAAE,IAAI,CAAC,cAAc,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC,CAO9F;AAED;;;GAGG;AACH,wBAAsB,eAAe,CACnC,MAAM,EAAE,IAAI,CAAC,cAAc,EAAE,OAAO,CAAC,EACrC,KAAK,EAAE,mBAAmB,EAC1B,IAAI,GAAE;IAAE,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAAC,MAAM,CAAC,EAAE,WAAW,CAAC;IAAC,KAAK,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,MAAM,CAAA;CAAO,GACjJ,OAAO,CAAC,MAAM,CAAC,CA2BjB;AAED,sDAAsD;AACtD,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,sDAAsD;IACtD,UAAU,EAAE,OAAO,CAAC;CACrB;AAED;;;;GAIG;AACH,wBAAsB,cAAc,CAAC,MAAM,EAAE,IAAI,CAAC,cAAc,EAAE,OAAO,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC,CAanK"}

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

@@ -0,0 +1,225 @@
+/**
+ * The expand-and-contract migration's steps (#3281), each one convergent: it
+ * observes the server (`./observe.ts`), does what is left of its own part,
+ * and reports. Running a step twice does what running it once did.
+ *
+ * Every statement runs in a transaction with `lock_timeout` and
+ * `statement_timeout` set by `SET LOCAL`, as the applier's do
+ * (`../apply/apply.ts`), and with the declarations' schema as its
+ * `search_path`. A statement that waits longer than the lock timeout behind
+ * another session gives up instead of queueing every later query behind it,
+ * and its transaction is tried again a few times before the step fails.
+ *
+ * The backfill and the verification are in `./backfill.ts`; the Op that
+ * orders the steps is `./op.ts`.
+ */
+import type { OwnershipMarker } from "@intentius/chant/ownership";
+import { type PostgresClient } from "../live/client.js";
+import type { PostgresTarget } from "../live/bind.js";
+import { type DeclaredPgObject } from "../apply/statements.js";
+import { type MigrationNames } from "./names.js";
+import { type MigrationObservation } from "./observe.js";
+import type { ReplicationLagBound } from "./replication.js";
+/** What every step is given. */
+export interface MigrationRun {
+    client: PostgresClient;
+    target: PostgresTarget;
+    /** The declared table. */
+    declared: DeclaredPgObject;
+    /** Every object the build declares: the switch makes the views that read the column again from theirs. */
+    objects?: readonly DeclaredPgObject[];
+    /** The declared column being migrated. */
+    column: string;
+    /** The type change's expression over the old row's columns. */
+    using?: string;
+    /** This project's ownership marker, stamped on every working object. */
+    marker?: OwnershipMarker;
+    /** The major the build targets. */
+    major?: number;
+    /** The width of one batch's key range. */
+    batchSize: number;
+    /** How long the old column is kept after the switch, in milliseconds. */
+    retainMs: number;
+    /** The bound on replica lag the backfill pauses for, or false for no check. */
+    replicationLag: ReplicationLagBound | false;
+    /** `lock_timeout` for every statement, in ms. */
+    lockTimeoutMs: number;
+    /** `statement_timeout` for a statement that changes only the catalog, in ms. */
+    statementTimeoutMs: number;
+    /** How many times a transaction that hit the lock timeout is tried again. Default: 5. */
+    lockRetries?: number;
+    log: (line: string) => void;
+    signal?: AbortSignal;
+    /** The run's id, recorded on the receipts it writes. */
+    runId?: string;
+}
+export declare const observe: (run: MigrationRun) => Promise<MigrationObservation>;
+/** The server's clock, in milliseconds: the retention is the server's time, not this machine's. */
+export declare function serverNow(client: PostgresClient): Promise<number>;
+/**
+ * Run `body` in one transaction under the run's timeouts (`scan` lifts the
+ * statement timeout, for a statement that reads every row) and the
+ * declarations' schema as `search_path`. A lock timeout rolls it back and
+ * tries again, waiting a little longer each time; any other error rolls it
+ * back and is thrown.
+ */
+export declare function inTransaction<T>(run: MigrationRun, body: (exec: (sql: string, params?: unknown[]) => Promise<Record<string, unknown>[]>) => Promise<T>, opts?: {
+    scan?: boolean;
+}): Promise<T>;
+/**
+ * Run one statement outside any transaction (`CREATE INDEX CONCURRENTLY`,
+ * `DROP INDEX CONCURRENTLY`), with `lock_timeout` and `statement_timeout`
+ * set for the session first (none for a scan). A lock timeout leaves a
+ * `CONCURRENTLY` build's index INVALID: `cleanup` drops it, and the statement
+ * is tried again as a transaction is.
+ */
+export declare function outsideTransaction(run: MigrationRun, sql: string, opts?: {
+    scan?: boolean;
+    cleanup?: () => Promise<void>;
+}): Promise<void>;
+/** A working object's role: the new column, the old one after the switch, the dual write, the NOT NULL proof, a carried index or constraint. */
+export type WorkingRole = "new" | "old" | "dual" | "nn" | "carry";
+/** A working object's comment: a description, then chant's trailer. */
+export declare const workingComment: (names: MigrationNames, marker: OwnershipMarker | undefined, role: WorkingRole, text: string, extra?: Record<string, string>) => string;
+export interface ExpandResult {
+    state: MigrationObservation["state"];
+    /** The column being filled. */
+    column: string;
+    added: boolean;
+}
+/**
+ * Expand: add the new column, nullable and with no default, which changes
+ * only the catalog (SQLPG201), marked as this migration's. Its NOT NULL and
+ * default are set at the switch, once every row has a value.
+ */
+export declare function expand(run: MigrationRun): Promise<ExpandResult>;
+/**
+ * The dual-write trigger function's body.
+ *
+ * A type change: the new column is computed from the row on every insert and
+ * update, with the same expression the backfill uses, so a write the backfill
+ * already passed is not missed. A value the expression cannot convert fails
+ * the write, as the declared column would.
+ *
+ * A rename: both columns are kept equal, each from the other, so old writers
+ * (the old name) and new ones (the new name) both work until the contract.
+ * An insert takes the new column's value when it is given and the old one's
+ * otherwise; an update takes whichever of the two it changed.
+ */
+export declare function dualWriteBody(o: Pick<MigrationObservation, "names" | "expression">): string;
+/** The statements that start the dual write: the function, the trigger, their comments. */
+export declare function dualWriteStatements(o: Pick<MigrationObservation, "names" | "expression">, marker: OwnershipMarker | undefined, defaultSchema: string): string[];
+export interface DualWriteResult {
+    state: MigrationObservation["state"];
+    trigger: string;
+    created: boolean;
+}
+/**
+ * Dual write: the trigger that keeps the new column written from here on.
+ * `CREATE TRIGGER` takes SHARE ROW EXCLUSIVE on the table, which waits for
+ * running writes; the lock timeout bounds that wait.
+ */
+export declare function startDualWrite(run: MigrationRun): Promise<DualWriteResult>;
+export interface CarryResult {
+    state: MigrationObservation["state"];
+    /** Working copies made in this run. */
+    built: number;
+    /** Working copies already there and ready. */
+    ready: number;
+    /** Views the switch makes again. */
+    views: number;
+    /** Each carried object, `<kind> <name> -> <name after the switch>`. */
+    carried: string[];
+}
+/**
+ * Carry over: make each index and constraint on the old column again on the
+ * new one, under a working name (`./carry.ts`). An index (a key's too) is
+ * built `CONCURRENTLY`, outside any transaction, so writes go on; a build
+ * that failed or was killed leaves an INVALID index, which the next run
+ * drops and builds again. A check or a foreign key is added `NOT VALID` with
+ * its comment in one transaction, then validated under SHARE UPDATE
+ * EXCLUSIVE. Runs after the backfill, so every row has its new value.
+ */
+export declare function carryOver(run: MigrationRun): Promise<CarryResult>;
+export interface SwitchResult {
+    state: MigrationObservation["state"];
+    switched: boolean;
+    /** Where the old column is kept, and until when. */
+    oldColumn?: string;
+    retainUntil?: string;
+}
+/**
+ * The statements of the switch's one transaction. A type change swaps the
+ * columns by name, so readers of the column read the new one from the
+ * commit on, and stops writing the old one, which is kept as it was. A
+ * rename has nothing to swap: readers move to the new name in the
+ * application, and the trigger keeps both columns written until the
+ * contract, so a reader still on the old name goes on working.
+ */
+/** Where the old column's sequence stood when the switch took its lock: what the moved identity carries on from. */
+export interface SequenceState {
+    lastValue: string;
+    isCalled: boolean;
+}
+export declare function switchStatements(o: MigrationObservation, marker: OwnershipMarker | undefined, retainUntil: string, sequenceState?: SequenceState): string[];
+/**
+ * Switch, once the gate has approved the verified plan. A declared NOT NULL
+ * is proven first by a check added NOT VALID and then validated, which reads
+ * the table under SHARE UPDATE EXCLUSIVE while reads and writes go on, so
+ * `SET NOT NULL` in the switch is a catalog change (since 12). Then the
+ * switch runs in one short transaction under the lock timeout.
+ */
+export declare function switchColumns(run: MigrationRun): Promise<SwitchResult>;
+export interface RetainResult {
+    state: MigrationObservation["state"];
+    /** `schema.table.column`, the old column while it is kept. */
+    oldColumn?: string;
+    retainUntil?: string;
+    /** The retention date has passed. */
+    due: boolean;
+    /** What the contract gate approves: this old column, by its table's oid and attribute number, and its date. Absent when there is nothing to drop. */
+    contractDigest?: string;
+}
+/** Where the old column is kept and until when, and the digest the contract gate binds. */
+export declare function retainPlan(run: MigrationRun): Promise<RetainResult>;
+export interface ContractResult {
+    state: MigrationObservation["state"];
+    dropped: boolean;
+    oldColumn?: string;
+    retainUntil?: string;
+}
+/** The receipt address prefix of one migration's batches. */
+export declare const batchPrefix: (identity: {
+    stack?: string;
+    env?: string;
+}, key: string) => string;
+export declare const identityOf: (marker: OwnershipMarker | undefined) => {
+    stack?: string;
+    env?: string;
+};
+/**
+ * Contract, once the retention date has passed and the gate approved it:
+ * drop the old column, and for a rename the trigger and function that kept
+ * it written, in one transaction under the lock timeout (`DROP COLUMN` is a
+ * catalog change under ACCESS EXCLUSIVE). The migration's receipts go with
+ * them. Before the date, say until when and drop nothing.
+ */
+export declare function contract(run: MigrationRun): Promise<ContractResult>;
+export interface CompensateResult {
+    dropped: string[];
+}
+/**
+ * onFailure: drop what the expand added, and nothing else: the trigger, its
+ * function, the NOT NULL check, the carried indexes and constraints (another
+ * table's foreign key onto the new column first, which would keep the column
+ * from being dropped) and the new column, each only when its
+ * comment names this migration and its role and carries this project's
+ * marker, and the migration's receipts. After the switch nothing is undone:
+ * the old column is kept (`role=old`) and the next run finishes the
+ * migration; the contract gate decides when the old column goes.
+ *
+ * It reads the server directly rather than through the observation, which
+ * may be what refused and failed the run.
+ */
+export declare function compensate(run: Pick<MigrationRun, "client" | "target" | "declared" | "column" | "marker" | "log" | "signal" | "lockTimeoutMs" | "statementTimeoutMs" | "lockRetries">): Promise<CompensateResult>;
+//# sourceMappingURL=steps.d.ts.map

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

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

package/dist/postgres/overlays/columns.d.ts

@@ -0,0 +1,6 @@
+/** Column clauses: defaults, generated columns and identity. */
+import { arg, type Clause } from "./kinds.js";
+export declare const COLUMN_CLAUSES: Record<string, Clause>;
+/** The options of an identity column's sequence and of `CREATE SEQUENCE`. */
+export declare const SEQUENCE_OPTIONS: Record<string, readonly ReturnType<typeof arg>[]>;
+//# sourceMappingURL=columns.d.ts.map

package/dist/postgres/overlays/columns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"columns.d.ts","sourceRoot":"","sources":["../../../src/postgres/overlays/columns.ts"],"names":[],"mappings":"AAAA,gEAAgE;AAEhE,OAAO,EAAE,GAAG,EAAE,KAAK,MAAM,EAAE,MAAM,SAAS,CAAC;AAE3C,eAAO,MAAM,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAiBjD,CAAC;AAEF,6EAA6E;AAC7E,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,UAAU,CAAC,OAAO,GAAG,CAAC,EAAE,CAS9E,CAAC"}

package/dist/postgres/overlays/constraints.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Constraint grammar: the arguments of each table and column constraint.
+ * `MATCH`, `ON DELETE` and `DEFERRABLE` are grammar, not catalog.
+ */
+import { type Clause } from "./kinds.js";
+export declare const REFERENTIAL_ACTIONS: readonly ["NO ACTION", "RESTRICT", "CASCADE", "SET NULL", "SET DEFAULT"];
+export declare const CONSTRAINTS: Record<string, Clause>;
+//# sourceMappingURL=constraints.d.ts.map

package/dist/postgres/overlays/constraints.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constraints.d.ts","sourceRoot":"","sources":["../../../src/postgres/overlays/constraints.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAO,KAAK,MAAM,EAAE,MAAM,SAAS,CAAC;AAE3C,eAAO,MAAM,mBAAmB,0EAA2E,CAAC;AAO5G,eAAO,MAAM,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAyC9C,CAAC"}

package/dist/postgres/overlays/indexes.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Index clauses. Which access method supports which of them is in the catalog
+ * (`INDEX_METHOD_PROPERTIES`: `can_include`, `can_unique`, ...); the clause
+ * shapes are here.
+ */
+import { type Clause } from "./kinds.js";
+export declare const INDEX_CLAUSES: Record<string, Clause>;
+//# sourceMappingURL=indexes.d.ts.map

package/dist/postgres/overlays/indexes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"indexes.d.ts","sourceRoot":"","sources":["../../../src/postgres/overlays/indexes.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAO,KAAK,MAAM,EAAE,MAAM,SAAS,CAAC;AAE3C,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAkBhD,CAAC"}

package/dist/postgres/overlays/kinds.d.ts

@@ -0,0 +1,48 @@
+/**
+ * What kind of value a clause argument takes. The catalog lists names (types,
+ * access methods, operator classes); it never says that `varchar`'s one
+ * argument is a length or that `ON DELETE` takes one of five actions. The
+ * overlays say that, with these.
+ */
+export type ArgumentKind = 
+/** A column of the table, by name. */
+"column"
+/** Any expression; in an index key or a check, over the table's columns. */
+ | "expression"
+/** A schema-qualified or bare object name. */
+ | "identifier"
+/** A string literal. */
+ | "string"
+/** A numeric literal. */
+ | "number"
+/** A boolean. */
+ | "boolean"
+/** A bare keyword from a fixed set (`values`). */
+ | "keyword"
+/** A column type. */
+ | "type"
+/** A query. */
+ | "query";
+export interface ClauseArgument {
+    name: string;
+    kind: ArgumentKind;
+    optional?: boolean;
+    /** The argument repeats, comma separated. */
+    repeated?: boolean;
+    /** The legal values of a `keyword`. */
+    values?: readonly string[];
+    /** The inclusive range of a `number`. */
+    range?: readonly [number, number];
+}
+/** A clause that is in some majors and not others. A bound outside 14..18 is a mistake generation reports. */
+export interface Versioned {
+    since?: number;
+    until?: number;
+}
+export type Clause = {
+    args: readonly ClauseArgument[];
+    summary: string;
+} & Versioned;
+export declare const arg: (name: string, kind: ArgumentKind, extra?: Partial<Omit<ClauseArgument, "name" | "kind">>) => ClauseArgument;
+export declare const INT_MAX = 2147483647;
+//# sourceMappingURL=kinds.d.ts.map

package/dist/postgres/overlays/kinds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kinds.d.ts","sourceRoot":"","sources":["../../../src/postgres/overlays/kinds.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,MAAM,YAAY;AACtB,sCAAsC;AACpC,QAAQ;AACV,4EAA4E;GAC1E,YAAY;AACd,8CAA8C;GAC5C,YAAY;AACd,wBAAwB;GACtB,QAAQ;AACV,yBAAyB;GACvB,QAAQ;AACV,iBAAiB;GACf,SAAS;AACX,kDAAkD;GAChD,SAAS;AACX,qBAAqB;GACnB,MAAM;AACR,eAAe;GACb,OAAO,CAAC;AAEZ,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,YAAY,CAAC;IACnB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,6CAA6C;IAC7C,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,uCAAuC;IACvC,MAAM,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3B,yCAAyC;IACzC,KAAK,CAAC,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACnC;AAED,8GAA8G;AAC9G,MAAM,WAAW,SAAS;IACxB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,MAAM,MAAM,GAAG;IAAE,IAAI,EAAE,SAAS,cAAc,EAAE,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAAC;AAEtF,eAAO,MAAM,GAAG,GACd,MAAM,MAAM,EACZ,MAAM,YAAY,EAClB,QAAO,OAAO,CAAC,IAAI,CAAC,cAAc,EAAE,MAAM,GAAG,MAAM,CAAC,CAAM,KACzD,cAA4C,CAAC;AAEhD,eAAO,MAAM,OAAO,aAAa,CAAC"}

package/dist/postgres/overlays/partitioning.d.ts

@@ -0,0 +1,5 @@
+/** Partitioning: `PARTITION BY`, partition bounds, `DEFAULT` partitions, `ATTACH` and `DETACH`. */
+import { type Clause } from "./kinds.js";
+export declare const PARTITION_STRATEGIES: readonly ["RANGE", "LIST", "HASH"];
+export declare const PARTITIONING: Record<string, Clause>;
+//# sourceMappingURL=partitioning.d.ts.map

package/dist/postgres/overlays/partitioning.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"partitioning.d.ts","sourceRoot":"","sources":["../../../src/postgres/overlays/partitioning.ts"],"names":[],"mappings":"AAAA,mGAAmG;AAEnG,OAAO,EAAO,KAAK,MAAM,EAAE,MAAM,SAAS,CAAC;AAE3C,eAAO,MAAM,oBAAoB,oCAAqC,CAAC;AAEvE,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAmB/C,CAAC"}

package/dist/postgres/overlays/relations.d.ts

@@ -0,0 +1,6 @@
+/** Table and relation clauses, views, materialized views and sequences. */
+import { type Clause } from "./kinds.js";
+export declare const RELATION_CLAUSES: Record<string, Clause>;
+export declare const VIEW_CLAUSES: Record<string, Clause>;
+export declare const SEQUENCE_CLAUSES: Record<string, Clause>;
+//# sourceMappingURL=relations.d.ts.map

package/dist/postgres/overlays/relations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relations.d.ts","sourceRoot":"","sources":["../../../src/postgres/overlays/relations.ts"],"names":[],"mappings":"AAAA,2EAA2E;AAE3E,OAAO,EAAO,KAAK,MAAM,EAAE,MAAM,SAAS,CAAC;AAE3C,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CASnD,CAAC;AAEF,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAQ/C,CAAC;AAEF,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAGnD,CAAC"}

package/dist/postgres/overlays/storage.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Storage parameters (`WITH (fillfactor = 70)`): the overlay half.
+ *
+ * No catalog table lists them; they are compiled into `reloptions.c`.
+ * Generation probes the server instead: it tries every `pg_settings` name plus
+ * {@link STORAGE_PARAMETER_SEED} as `WITH (name = 1)` on each relation kind
+ * and keeps every name the server does not reject as unrecognized. The probe
+ * yields names only, so the types and ranges are here, and generation fails
+ * when a name the probe found has no entry (a pin move that adds a parameter
+ * has to type it in the same commit) or an entry names nothing the probe found.
+ */
+/** The reloptions that are not `pg_settings` names, so the probe would never try them. */
+export declare const STORAGE_PARAMETER_SEED: readonly string[];
+export type StorageParameterType = {
+    kind: "integer";
+    range: readonly [number, number];
+} | {
+    kind: "real";
+    range: readonly [number, number];
+} | {
+    kind: "boolean";
+} | {
+    kind: "enum";
+    values: readonly string[];
+};
+/** Keyed by parameter name; the same name has the same type on every relation kind that accepts it. */
+export declare const STORAGE_PARAMETER_TYPES: Record<string, StorageParameterType>;
+//# sourceMappingURL=storage.d.ts.map

package/dist/postgres/overlays/storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.d.ts","sourceRoot":"","sources":["../../../src/postgres/overlays/storage.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH,0FAA0F;AAC1F,eAAO,MAAM,sBAAsB,EAAE,SAAS,MAAM,EAUnD,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAC5B;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,KAAK,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,GACrD;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,GAClD;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,GACnB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,CAAC;AAMhD,uGAAuG;AACvG,eAAO,MAAM,uBAAuB,EAAE,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAoCxE,CAAC"}

package/dist/postgres/overlays/type-ddl.d.ts

@@ -0,0 +1,7 @@
+/**
+ * `CREATE TYPE` and `CREATE DOMAIN`: the forms for new types. The catalog lists
+ * the built-ins; the grammar for declaring more is not in it.
+ */
+import { type Clause } from "./kinds.js";
+export declare const TYPE_DDL: Record<string, Clause>;
+//# sourceMappingURL=type-ddl.d.ts.map

package/dist/postgres/overlays/type-ddl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-ddl.d.ts","sourceRoot":"","sources":["../../../src/postgres/overlays/type-ddl.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAO,KAAK,MAAM,EAAE,MAAM,SAAS,CAAC;AAE3C,eAAO,MAAM,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CA8B3C,CAAC"}

package/dist/postgres/overlays/types.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Column type parameters and spellings: the overlay half.
+ *
+ * `pg_type` lists the types and `format_type()` gives each one's SQL spelling
+ * (`int4` is `integer`). The parameters (`varchar(n)`, `numeric(p, s)`,
+ * `timestamp(p)`, `interval` fields) and the spellings no catalog row carries
+ * (`int`, `decimal`, `serial`) are in no catalog table. A type missing here
+ * takes no parameters; generation fails when a key here is not a type at the
+ * pins.
+ */
+import { type ClauseArgument } from "./kinds.js";
+/** Keyed by the canonical SQL name `format_type()` gives. */
+export declare const COLUMN_TYPE_PARAMETERS: Record<string, readonly ClauseArgument[]>;
+/** Spellings that are not `format_type()` output, and the canonical name each stands for. */
+export declare const TYPE_SPELLINGS: Record<string, string>;
+/** Pseudo-types that declare a sequence-backed column; each stands for a type plus a default and a sequence. */
+export declare const SERIAL_TYPES: Record<string, string>;
+/** An array suffix: `integer[]`, `text[3]`, `ARRAY`. Dimensions are documentation only to the server. */
+export declare const ARRAY_SUFFIX: {
+    readonly brackets: "[]";
+    readonly dimensioned: "[n]";
+    readonly keyword: "ARRAY";
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/postgres/overlays/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/postgres/overlays/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAO,KAAK,cAAc,EAAE,MAAM,SAAS,CAAC;AAEnD,6DAA6D;AAC7D,eAAO,MAAM,sBAAsB,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,cAAc,EAAE,CAiB5E,CAAC;AAEF,6FAA6F;AAC7F,eAAO,MAAM,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAWjD,CAAC;AAEF,gHAAgH;AAChH,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAI/C,CAAC;AAEF,yGAAyG;AACzG,eAAO,MAAM,YAAY;;;;CAAoE,CAAC"}