supaschema 0.1.0-rc.1

package/dist/sql/table-constraints.js

@@ -0,0 +1,304 @@
+import { asRecord, rangeVarName, readArray, readNumber, readString, stringList } from "./ast.js";
+import { formatQualifiedName, quoteIdent } from "./identifiers.js";
+import { elementText, findCharOutsideQuotes, findMatchingParen, fromByteString, tableElements, toByteString, } from "./statements.js";
+export function tableConstraintSyntheses(createStmt, sql, byteOffset = 0) {
+    const relation = rangeVarName(createStmt.relation);
+    if (!relation) {
+        return [];
+    }
+    const qualified = formatQualifiedName(relation.schema, relation.name);
+    const bytes = toByteString(sql);
+    const syntheses = [];
+    for (const element of tableElements(createStmt, bytes, byteOffset)) {
+        if (element.isColumn) {
+            syntheses.push(...inlineConstraintSyntheses(element, bytes, byteOffset, relation.name, qualified));
+            continue;
+        }
+        const constraint = element.node;
+        const text = fromByteString(elementText(bytes, element));
+        const conname = readString(constraint.conname);
+        const name = conname ?? defaultConstraintName(relation.name, constraint, []);
+        if (!name) {
+            continue;
+        }
+        const fragment = conname ? text : `CONSTRAINT ${quoteIdent(name)} ${text}`;
+        syntheses.push({ name, sql: `ALTER TABLE ONLY ${qualified} ADD ${fragment}` });
+    }
+    return syntheses;
+}
+/**
+ * Rebuilds the CREATE TABLE statement without its declared constraints so the
+ * table object's SQL matches the columns-only shape the catalog lane emits.
+ * Raw-apply consumers (verify, parity tests) then apply the table once and
+ * each constraint once instead of creating hoisted constraints twice. Returns
+ * undefined when the statement declares no hoistable constraints.
+ */
+export function stripDeclaredConstraints(createStmt, sql, byteOffset = 0) {
+    const relation = asRecord(createStmt.relation);
+    const bytes = toByteString(sql);
+    const elements = tableElements(createStmt, bytes, byteOffset);
+    if (elements.length === 0) {
+        return undefined;
+    }
+    let strippedAny = false;
+    const pieces = [];
+    const primaryColumns = primaryKeyColumns(elements);
+    for (const element of elements) {
+        if (!element.isColumn) {
+            strippedAny = true;
+            continue;
+        }
+        const { piece, stripped } = columnPieceWithoutHoisted(element, bytes, byteOffset);
+        if (stripped) {
+            strippedAny = true;
+        }
+        if (piece.length === 0) {
+            continue;
+        }
+        // A stripped PRIMARY KEY implied NOT NULL on its columns; spell it
+        // explicitly so the rebuilt statement keeps the same column facts. The
+        // AST is authoritative: the piece retains a NOT NULL span exactly when a
+        // CONSTR_NOTNULL constraint exists, because NOT NULL is never hoisted.
+        const columnName = readString(element.node.colname);
+        if (columnName && primaryColumns.has(columnName) && !hasExplicitNotNull(element.node)) {
+            pieces.push(`${piece} NOT NULL`);
+            continue;
+        }
+        pieces.push(piece);
+    }
+    if (!strippedAny || pieces.length === 0) {
+        return undefined;
+    }
+    const relationLocation = (readNumber(relation?.location) ?? 0) - byteOffset;
+    const open = findCharOutsideQuotes(bytes, "(", Math.max(relationLocation, 0));
+    if (open === -1) {
+        return undefined;
+    }
+    const close = findMatchingParen(bytes, open);
+    if (close === -1) {
+        return undefined;
+    }
+    const head = bytes.slice(0, open + 1);
+    const tail = bytes.slice(close);
+    return fromByteString(`${head}\n  ${pieces.join(",\n  ")}\n${tail}`);
+}
+function primaryKeyColumns(elements) {
+    const columns = new Set();
+    for (const element of elements) {
+        if (element.isColumn) {
+            const name = readString(element.node.colname);
+            const hasPrimary = readArray(element.node.constraints).some((item) => readString(asRecord(asRecord(item)?.Constraint)?.contype) === "CONSTR_PRIMARY");
+            if (name && hasPrimary) {
+                columns.add(name);
+            }
+            continue;
+        }
+        if (readString(element.node.contype) === "CONSTR_PRIMARY") {
+            for (const key of stringList(element.node.keys)) {
+                columns.add(key);
+            }
+        }
+    }
+    return columns;
+}
+function hasExplicitNotNull(columnDef) {
+    return readArray(columnDef.constraints).some((item) => readString(asRecord(asRecord(item)?.Constraint)?.contype) === "CONSTR_NOTNULL");
+}
+function columnPieceWithoutHoisted(element, bytes, byteOffset) {
+    const located = locatedInlineConstraints(element, byteOffset);
+    let piece = "";
+    let cursor = element.start;
+    let stripped = false;
+    for (const [index, item] of located.entries()) {
+        const end = located[index + 1]?.location ?? element.end;
+        const contype = readString(item.constraint.contype);
+        if (contype && inlineConstraintTypes.has(contype)) {
+            piece += bytes.slice(cursor, item.location);
+            cursor = end;
+            stripped = true;
+        }
+    }
+    piece += bytes.slice(cursor, element.end);
+    piece = piece.trim();
+    if (piece.endsWith(",")) {
+        piece = piece.slice(0, -1).trimEnd();
+    }
+    return { piece: fromByteString(piece), stripped };
+}
+function inlineConstraintSyntheses(element, bytes, byteOffset, table, qualified) {
+    const column = readString(element.node.colname);
+    if (!column) {
+        return [];
+    }
+    const located = locatedInlineConstraints(element, byteOffset);
+    const syntheses = [];
+    for (const [index, item] of located.entries()) {
+        const contype = readString(item.constraint.contype);
+        if (!contype || !inlineConstraintTypes.has(contype)) {
+            continue;
+        }
+        const end = located[index + 1]?.location ?? element.end;
+        let text = fromByteString(bytes.slice(item.location, end)).trim();
+        if (text.endsWith(",")) {
+            text = text.slice(0, -1).trimEnd();
+        }
+        const conname = readString(item.constraint.conname);
+        if (conname) {
+            // The AST already classified this as a named constraint; scanning only
+            // locates where the `CONSTRAINT <name>` prefix ends so the remainder
+            // fits the table-level template for its type.
+            text = skipConstraintNamePrefix(text);
+        }
+        const name = conname ?? defaultConstraintName(table, item.constraint, [column]);
+        if (!name) {
+            continue;
+        }
+        const body = inlineConstraintBody(contype, column, text);
+        if (!body) {
+            continue;
+        }
+        syntheses.push({
+            name,
+            sql: `ALTER TABLE ONLY ${qualified} ADD CONSTRAINT ${quoteIdent(name)} ${body}`,
+        });
+    }
+    return syntheses;
+}
+/**
+ * Skips a leading `CONSTRAINT <name>` token pair and returns the remainder.
+ * Character scanning only — whether the constraint is named comes from the
+ * AST (`conname`); this mirrors the render-guard keyword scanner in facts.ts.
+ */
+function skipConstraintNamePrefix(text) {
+    let index = skipSqlWhitespace(text, 0);
+    const keywordEnd = index + "CONSTRAINT".length;
+    if (text.slice(index, keywordEnd).toUpperCase() !== "CONSTRAINT") {
+        return text;
+    }
+    index = skipSqlWhitespace(text, keywordEnd);
+    if (text[index] === '"') {
+        index += 1;
+        while (index < text.length) {
+            if (text[index] === '"' && text[index + 1] === '"') {
+                index += 2;
+                continue;
+            }
+            if (text[index] === '"') {
+                index += 1;
+                break;
+            }
+            index += 1;
+        }
+    }
+    else {
+        while (index < text.length && isIdentifierChar(text[index] ?? "")) {
+            index += 1;
+        }
+    }
+    return text.slice(skipSqlWhitespace(text, index));
+}
+function isIdentifierChar(char) {
+    return ((char >= "a" && char <= "z") ||
+        (char >= "A" && char <= "Z") ||
+        (char >= "0" && char <= "9") ||
+        char === "_" ||
+        char === "$");
+}
+function skipSqlWhitespace(text, start) {
+    let index = start;
+    while (index < text.length) {
+        const char = text[index];
+        if (char === " " || char === "\t" || char === "\n" || char === "\r") {
+            index += 1;
+            continue;
+        }
+        break;
+    }
+    return index;
+}
+function locatedInlineConstraints(element, byteOffset) {
+    return readArray(element.node.constraints)
+        .map((item) => asRecord(asRecord(item)?.Constraint))
+        .filter((item) => item !== undefined)
+        .map((constraint) => ({
+        constraint,
+        location: (readNumber(constraint.location) ?? -1) - byteOffset,
+    }))
+        .filter((item) => item.location >= 0)
+        .sort((left, right) => left.location - right.location);
+}
+const inlineConstraintTypes = new Set([
+    "CONSTR_CHECK",
+    "CONSTR_FOREIGN",
+    "CONSTR_PRIMARY",
+    "CONSTR_UNIQUE",
+]);
+function inlineConstraintBody(contype, column, text) {
+    switch (contype) {
+        case "CONSTR_PRIMARY":
+            return `PRIMARY KEY (${quoteIdent(column)})`;
+        case "CONSTR_UNIQUE":
+            return `UNIQUE (${quoteIdent(column)})`;
+        case "CONSTR_CHECK":
+            return text;
+        case "CONSTR_FOREIGN":
+            return `FOREIGN KEY (${quoteIdent(column)}) ${text}`;
+        default:
+            return undefined;
+    }
+}
+function defaultConstraintName(table, constraint, impliedColumns) {
+    const contype = readString(constraint.contype);
+    const keys = stringList(constraint.keys);
+    const fkAttrs = stringList(constraint.fk_attrs);
+    const columns = fkAttrs.length > 0 ? fkAttrs : keys.length > 0 ? keys : impliedColumns;
+    const joined = columns.join("_");
+    switch (contype) {
+        case "CONSTR_PRIMARY":
+            return `${table}_pkey`;
+        case "CONSTR_UNIQUE":
+            return joined ? `${table}_${joined}_key` : undefined;
+        case "CONSTR_FOREIGN":
+            return joined ? `${table}_${joined}_fkey` : undefined;
+        case "CONSTR_CHECK": {
+            // PostgreSQL names a check after its column only when the expression
+            // references exactly one column; otherwise the bare `<table>_check`.
+            const referenced = columns.length > 0 ? columns : expressionColumns(constraint.raw_expr);
+            return referenced.length === 1 ? `${table}_${referenced[0]}_check` : `${table}_check`;
+        }
+        case "CONSTR_EXCLUSION":
+            return joined ? `${table}_${joined}_excl` : undefined;
+        default:
+            return undefined;
+    }
+}
+function expressionColumns(expression) {
+    const columns = new Set();
+    const visit = (value) => {
+        if (Array.isArray(value)) {
+            for (const item of value) {
+                visit(item);
+            }
+            return;
+        }
+        const node = asRecord(value);
+        if (!node) {
+            return;
+        }
+        const columnRef = asRecord(node.ColumnRef);
+        if (columnRef) {
+            const fields = stringList(columnRef.fields);
+            const name = fields.at(-1);
+            if (name) {
+                columns.add(name);
+            }
+        }
+        for (const child of Object.values(node)) {
+            if (child && typeof child === "object") {
+                visit(child);
+            }
+        }
+    };
+    visit(expression);
+    return [...columns];
+}

package/dist/sql/table-shape.d.ts

@@ -0,0 +1,38 @@
+import type { AstNode } from "./ast.js";
+export declare function canonicalColumnType(typeName: unknown): string;
+/**
+ * Canonical table identity for hashing. The raw parse tree differs between a
+ * declarative source ("id bigint PRIMARY KEY") and a catalog reconstruction
+ * ('"id" bigint NOT NULL' plus a separate ADD CONSTRAINT), so the shape
+ * carries columns only: every table constraint — inline, in-CREATE, or
+ * ALTER-declared — is identity-owned by its own `constraint:` object, making
+ * table identity independent of where constraints are declared. Inline and
+ * in-CREATE constraints still apply primary-key-implied NOT NULL to columns
+ * before exclusion.
+ */
+export declare function canonicalTableShape(node: AstNode): Record<string, unknown>;
+/**
+ * A regclass cast's string literal is an identifier reference, and
+ * pg_get_expr renders it unquoted (`ai.seq`) while declarative sources often
+ * quote it (`"ai"."seq"`). Both name the same object, so the canonical shape
+ * stores the unquoted spelling.
+ */
+export declare function canonicalizeRegclassLiterals(node: unknown): unknown;
+/**
+ * Canonical sequence identity: option DefElems normalize to a keyed object
+ * with PostgreSQL's ascending defaults dropped, so a declarative
+ * `START 100 INCREMENT 5` and the catalog reconstruction hash identically
+ * regardless of option order or explicitly-spelled defaults.
+ */
+export declare function canonicalSequenceShape(node: AstNode): Record<string, unknown>;
+/**
+ * Canonical constraint identity shared by every declaration site: an
+ * ALTER TABLE ADD CONSTRAINT statement, an in-CREATE table-level constraint,
+ * an inline column constraint, and a catalog pg_constraint row must all hash
+ * to the same shape for the same table.
+ */
+export declare function canonicalConstraintShape(constraint: AstNode, table: {
+    name: string;
+    schema: string;
+}, impliedColumns?: string[]): Record<string, unknown>;
+//# sourceMappingURL=table-shape.d.ts.map

package/dist/sql/table-shape.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"table-shape.d.ts","sourceRoot":"","sources":["../../src/sql/table-shape.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AAaxC,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,OAAO,GAAG,MAAM,CAmB7D;AAQD;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAuC1E;AAwDD;;;;;GAKG;AACH,wBAAgB,4BAA4B,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAyBnE;AAkCD;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAkD7E;AAuBD;;;;;GAKG;AACH,wBAAgB,wBAAwB,CACtC,UAAU,EAAE,OAAO,EACnB,KAAK,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,EACvC,cAAc,GAAE,MAAM,EAAO,GAC5B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAKzB"}

package/dist/sql/table-shape.js

@@ -0,0 +1,287 @@
+import { asRecord, readArray, readNumber, readString, stringList, typeNameToSql } from "./ast.js";
+import { stripLocations } from "./object-hash.js";
+export function canonicalColumnType(typeName) {
+    const base = typeNameToSql(typeName);
+    const node = asRecord(asRecord(typeName)?.TypeName) ?? asRecord(typeName);
+    const typmods = readArray(node?.typmods)
+        .map((item) => {
+        const constant = asRecord(asRecord(item)?.A_Const);
+        const integer = asRecord(constant?.ival);
+        const value = readNumber(integer?.ival);
+        return value === undefined ? undefined : String(value);
+    })
+        .filter((value) => value !== undefined);
+    if (typmods.length === 0) {
+        return base;
+    }
+    const arrayStart = base.indexOf("[]");
+    if (arrayStart === -1) {
+        return `${base}(${typmods.join(", ")})`;
+    }
+    return `${base.slice(0, arrayStart)}(${typmods.join(", ")})${base.slice(arrayStart)}`;
+}
+/**
+ * Canonical table identity for hashing. The raw parse tree differs between a
+ * declarative source ("id bigint PRIMARY KEY") and a catalog reconstruction
+ * ('"id" bigint NOT NULL' plus a separate ADD CONSTRAINT), so the shape
+ * carries columns only: every table constraint — inline, in-CREATE, or
+ * ALTER-declared — is identity-owned by its own `constraint:` object, making
+ * table identity independent of where constraints are declared. Inline and
+ * in-CREATE constraints still apply primary-key-implied NOT NULL to columns
+ * before exclusion.
+ */
+export function canonicalTableShape(node) {
+    const relation = asRecord(node.relation);
+    const columns = [];
+    const constraints = [];
+    for (const item of readArray(node.tableElts)) {
+        const columnDef = asRecord(asRecord(item)?.ColumnDef);
+        if (columnDef) {
+            columns.push(canonicalColumn(columnDef, constraints));
+            continue;
+        }
+        const constraint = asRecord(asRecord(item)?.Constraint);
+        if (constraint) {
+            constraints.push(canonicalConstraint(constraint, []));
+        }
+    }
+    const primaryColumns = new Set(constraints
+        .filter((constraint) => constraint.type === "CONSTR_PRIMARY")
+        .flatMap((constraint) => constraint.columns));
+    for (const column of columns) {
+        if (primaryColumns.has(column.name)) {
+            column.notNull = true;
+        }
+    }
+    const shape = {
+        columns,
+        relation: {
+            name: readString(relation?.relname) ?? "",
+            persistence: readString(relation?.relpersistence) ?? "p",
+            schema: readString(relation?.schemaname) ?? "public",
+        },
+    };
+    for (const semanticKey of ["inhRelations", "oncommit", "options", "partspec", "tablespacename"]) {
+        if (node[semanticKey] !== undefined && node[semanticKey] !== null) {
+            shape[semanticKey] = stripLocations(node[semanticKey]);
+        }
+    }
+    return shape;
+}
+function canonicalColumn(columnDef, constraints) {
+    const name = readString(columnDef.colname) ?? "";
+    const column = {
+        name,
+        notNull: false,
+        type: canonicalColumnType(columnDef.typeName),
+    };
+    for (const item of readArray(columnDef.constraints)) {
+        const constraint = asRecord(asRecord(item)?.Constraint);
+        const contype = readString(constraint?.contype);
+        if (!constraint || !contype) {
+            continue;
+        }
+        switch (contype) {
+            case "CONSTR_NOTNULL":
+                column.notNull = true;
+                break;
+            case "CONSTR_NULL":
+                break;
+            case "CONSTR_DEFAULT":
+                column.default = canonicalizeRegclassLiterals(stripLocations(unwrapColumnTypeCast(constraint.raw_expr, columnDef.typeName)));
+                break;
+            case "CONSTR_IDENTITY":
+                column.identity = readString(constraint.generated_when) ?? "a";
+                break;
+            case "CONSTR_GENERATED":
+                column.generated = stripLocations(constraint.raw_expr);
+                break;
+            default:
+                constraints.push(canonicalConstraint(constraint, [name]));
+                break;
+        }
+    }
+    return column;
+}
+/**
+ * pg_get_expr renders a column default as `'x'::type` while declarative
+ * sources usually write the bare literal; a cast to the column's own base
+ * type is implied, so it is dropped from the canonical default.
+ */
+function unwrapColumnTypeCast(expression, columnTypeName) {
+    const typeCast = asRecord(asRecord(expression)?.TypeCast);
+    if (!typeCast) {
+        return expression;
+    }
+    if (typeNameToSql(typeCast.typeName) !== typeNameToSql(columnTypeName)) {
+        return expression;
+    }
+    return typeCast.arg;
+}
+/**
+ * A regclass cast's string literal is an identifier reference, and
+ * pg_get_expr renders it unquoted (`ai.seq`) while declarative sources often
+ * quote it (`"ai"."seq"`). Both name the same object, so the canonical shape
+ * stores the unquoted spelling.
+ */
+export function canonicalizeRegclassLiterals(node) {
+    if (Array.isArray(node)) {
+        return node.map((item) => canonicalizeRegclassLiterals(item));
+    }
+    if (typeof node !== "object" || node === null) {
+        return node;
+    }
+    const record = node;
+    const typeCast = asRecord(record.TypeCast);
+    if (typeCast && typeNameToSql(typeCast.typeName) === "regclass") {
+        const constant = asRecord(asRecord(typeCast.arg)?.A_Const);
+        const sval = asRecord(constant?.sval);
+        const literal = readString(sval?.sval);
+        if (literal !== undefined) {
+            // The cast itself is dropped: `'x'::regclass` and bare `'x'` name the
+            // same object inside a default expression, and trees commonly omit the
+            // cast that pg_get_expr always renders.
+            return { A_Const: { ...constant, sval: { sval: unquoteQualifiedName(literal) } } };
+        }
+    }
+    const result = {};
+    for (const [key, value] of Object.entries(record)) {
+        result[key] = canonicalizeRegclassLiterals(value);
+    }
+    return result;
+}
+function unquoteQualifiedName(literal) {
+    const parts = [];
+    let current = "";
+    let quoted = false;
+    for (let index = 0; index < literal.length; index += 1) {
+        const char = literal[index];
+        if (char === '"') {
+            if (quoted && literal[index + 1] === '"') {
+                current += '"';
+                index += 1;
+                continue;
+            }
+            quoted = !quoted;
+            continue;
+        }
+        if (char === "." && !quoted) {
+            parts.push(current);
+            current = "";
+            continue;
+        }
+        current += char;
+    }
+    parts.push(current);
+    return parts.join(".");
+}
+const sequenceTypeMax = new Map([
+    ["bigint", "9223372036854775807"],
+    ["integer", "2147483647"],
+    ["smallint", "32767"],
+]);
+/**
+ * Canonical sequence identity: option DefElems normalize to a keyed object
+ * with PostgreSQL's ascending defaults dropped, so a declarative
+ * `START 100 INCREMENT 5` and the catalog reconstruction hash identically
+ * regardless of option order or explicitly-spelled defaults.
+ */
+export function canonicalSequenceShape(node) {
+    const sequence = asRecord(node.sequence);
+    const shape = {
+        relation: {
+            name: readString(sequence?.relname) ?? "",
+            persistence: readString(sequence?.relpersistence) ?? "p",
+            schema: readString(sequence?.schemaname) ?? "public",
+        },
+    };
+    let dataType = "bigint";
+    const options = new Map();
+    for (const item of readArray(node.options)) {
+        const defElem = asRecord(asRecord(item)?.DefElem);
+        const name = readString(defElem?.defname);
+        if (!name) {
+            continue;
+        }
+        options.set(name, defElem?.arg);
+    }
+    const asType = options.get("as");
+    if (asType !== undefined) {
+        dataType = typeNameToSql(asType);
+    }
+    if (dataType !== "bigint") {
+        shape.as = dataType;
+    }
+    const defaults = new Map([
+        ["cache", "1"],
+        ["increment", "1"],
+        ["maxvalue", sequenceTypeMax.get(dataType) ?? ""],
+        ["minvalue", "1"],
+        ["start", "1"],
+    ]);
+    for (const [name, fallback] of defaults) {
+        const value = sequenceOptionValue(options.get(name));
+        if (value !== undefined && value !== fallback) {
+            shape[name] = value;
+        }
+    }
+    if (sequenceOptionValue(options.get("cycle")) === "true") {
+        shape.cycle = true;
+    }
+    const ownedBy = options.get("owned_by");
+    if (ownedBy !== undefined) {
+        const path = stringList(ownedBy);
+        if (path.length > 0 && path.at(-1) !== "none") {
+            shape.ownedBy = path.join(".");
+        }
+    }
+    return shape;
+}
+function sequenceOptionValue(arg) {
+    if (arg === undefined || arg === null) {
+        return undefined;
+    }
+    const integer = asRecord(asRecord(arg)?.Integer);
+    if (integer) {
+        return String(readNumber(integer.ival) ?? 0);
+    }
+    const float = asRecord(asRecord(arg)?.Float);
+    if (float) {
+        return readString(float.fval);
+    }
+    const boolean = asRecord(asRecord(arg)?.Boolean);
+    if (boolean) {
+        return boolean.boolval === true ? "true" : "false";
+    }
+    return readString(asRecord(asRecord(arg)?.String)?.sval);
+}
+const constraintIdentityKeys = new Set(["conname", "contype", "fk_attrs", "keys", "location"]);
+/**
+ * Canonical constraint identity shared by every declaration site: an
+ * ALTER TABLE ADD CONSTRAINT statement, an in-CREATE table-level constraint,
+ * an inline column constraint, and a catalog pg_constraint row must all hash
+ * to the same shape for the same table.
+ */
+export function canonicalConstraintShape(constraint, table, impliedColumns = []) {
+    return {
+        constraint: canonicalConstraint(constraint, impliedColumns),
+        table,
+    };
+}
+function canonicalConstraint(constraint, impliedColumns) {
+    const keys = stringList(constraint.keys);
+    const fkAttrs = stringList(constraint.fk_attrs);
+    const columns = fkAttrs.length > 0 ? fkAttrs : keys.length > 0 ? keys : impliedColumns;
+    const payload = {};
+    for (const [key, value] of Object.entries(constraint)) {
+        if (constraintIdentityKeys.has(key)) {
+            continue;
+        }
+        payload[key] = stripLocations(value);
+    }
+    return {
+        columns: [...columns],
+        payload,
+        type: readString(constraint.contype) ?? "",
+    };
+}

package/dist/sync.d.ts

@@ -0,0 +1,27 @@
+import type { Diagnostic, SupaschemaConfig } from "./core.js";
+export interface SyncOptions {
+    config?: Partial<SupaschemaConfig>;
+    databaseUrl?: string;
+    directory: string;
+    /** Apply pending migrations to the target via `supabase migration up`. */
+    local?: boolean;
+    /** Push pending migrations to the linked project via `supabase db push`. */
+    remote?: boolean;
+}
+export interface SyncResult {
+    applied: boolean;
+    diagnostics: Diagnostic[];
+    pending: string[];
+    report: string;
+}
+/**
+ * Auto-sync orchestration: supaschema gates, the Supabase CLI applies. Every
+ * pending migration must pass the static replay-safety check before any
+ * runner executes; ghost or out-of-order history refuses outright; and
+ * nothing touches a database unless `local`/`remote` was explicitly chosen —
+ * the default is a dry run that prints exactly what would execute. History
+ * stays runner-owned: supaschema never writes
+ * supabase_migrations.schema_migrations itself.
+ */
+export declare function syncMigrations(options: SyncOptions): Promise<SyncResult>;
+//# sourceMappingURL=sync.d.ts.map

package/dist/sync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync.d.ts","sourceRoot":"","sources":["../src/sync.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAI9D,MAAM,WAAW,WAAW;IAC1B,MAAM,CAAC,EAAE,OAAO,CAAC,gBAAgB,CAAC,CAAC;IACnC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,0EAA0E;IAC1E,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,4EAA4E;IAC5E,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,OAAO,CAAC;IACjB,WAAW,EAAE,UAAU,EAAE,CAAC;IAC1B,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;GAQG;AACH,wBAAsB,cAAc,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,UAAU,CAAC,CAoE9E"}