supaschema 0.1.0-rc.1

package/dist/render.js

@@ -0,0 +1,325 @@
+import { resolveConfig } from "./config.js";
+import { lineageLine } from "./lineage.js";
+import { ensureSemicolon, qualifiedRef, qualifiedTableRef, quoteLiteral, renderConstraintGuard, renderDefaultPrivilegeDrop, renderFdwGuard, renderGrantDrop, renderRename, renderTypeGuard, } from "./render-guards.js";
+import { quoteIdent } from "./sql/identifiers.js";
+export function renderMigrationSplit(plan, options = {}) {
+    const concurrent = plan.operations.filter((operation) => !operation.blocked &&
+        operation.ref.kind === "index" &&
+        (operation.after ?? operation.before)?.metadata.concurrent === true);
+    if (concurrent.length === 0) {
+        return { sql: renderMigration(plan, options) };
+    }
+    const transactional = plan.operations.filter((operation) => !concurrent.includes(operation));
+    const sql = renderMigration({ ...plan, operations: transactional }, options);
+    const concurrentBody = concurrent.map((operation) => renderOperation(operation)).join("\n\n");
+    const concurrentSql = `-- supaschema: run each statement outside a transaction block.\n-- CREATE INDEX CONCURRENTLY cannot run inside a transaction.\n${concurrentBody}\n`;
+    return { concurrentSql, sql };
+}
+export function renderMigration(plan, options = {}) {
+    const config = resolveConfig(options.config);
+    const chunks = [];
+    if (options.includeHeader ?? true) {
+        chunks.push(renderHeader(plan, config, options.version));
+    }
+    for (const operation of plan.operations) {
+        if (operation.blocked) {
+            chunks.push(renderBlockedOperation(operation));
+            continue;
+        }
+        chunks.push(renderOperation(operation));
+    }
+    return `${chunks.filter(Boolean).join("\n\n").trim()}\n`;
+}
+function renderHeader(plan, config, version) {
+    const hasConcurrentIndex = plan.operations.some((operation) => operation.ref.kind === "index" &&
+        (operation.after ?? operation.before)?.metadata.concurrent === true);
+    const transaction = hasConcurrentIndex
+        ? "-- supaschema: transaction=false required for concurrent index statements\n"
+        : "";
+    const generator = version ? `supaschema ${version}` : "supaschema";
+    return `${transaction}-- Generated by ${generator}.
+-- From: ${plan.from}
+-- To: ${plan.to}
+-- Operations: ${renderOperationSummary(plan)}
+-- Fingerprint: ${plan.fingerprint}
+${lineageLine(plan)}
+SET lock_timeout = '${config.lockTimeout}';
+SET statement_timeout = '${config.statementTimeout}';`;
+}
+function renderOperationSummary(plan) {
+    if (plan.operations.length === 0) {
+        return "none";
+    }
+    const counts = new Map();
+    for (const operation of plan.operations) {
+        const label = `${operation.kind} ${operation.ref.kind}`;
+        counts.set(label, (counts.get(label) ?? 0) + 1);
+    }
+    return [...counts.entries()]
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([label, count]) => `${count} ${label}`)
+        .join(", ");
+}
+function renderBlockedOperation(operation) {
+    const diagnostics = operation.diagnostics
+        .map((item) => `-- ${item.code}: ${item.message}`)
+        .join("\n");
+    return `-- BLOCKED ${operation.kind} ${operation.key}\n${diagnostics}`;
+}
+function renderOperation(operation) {
+    if (operation.kind === "alter") {
+        return renderAlter(operation);
+    }
+    if (operation.kind === "create") {
+        return renderCreate(requiredAfter(operation));
+    }
+    if (operation.kind === "drop") {
+        return renderDrop(requiredBefore(operation));
+    }
+    if (operation.kind === "rename") {
+        return renderRename(operation);
+    }
+    return renderReplace(operation);
+}
+function renderAlter(operation) {
+    const after = requiredAfter(operation);
+    if (after.ref.kind === "enum") {
+        const addEnumValues = operation.metadata.addEnumValues;
+        if (!Array.isArray(addEnumValues)) {
+            throw new Error(`alter operation ${operation.key} has no addEnumValues metadata`);
+        }
+        return addEnumValues
+            .map((value) => `ALTER TYPE ${qualifiedRef(after.ref)} ADD VALUE IF NOT EXISTS ${quoteLiteral(String(value))};`)
+            .join("\n");
+    }
+    if (after.ref.kind !== "table") {
+        throw new Error(`unsupported alter operation for ${operation.key}`);
+    }
+    const statements = [];
+    const addColumns = Array.isArray(operation.metadata.addColumns)
+        ? operation.metadata.addColumns
+        : [];
+    for (const column of addColumns) {
+        statements.push(renderAddColumn(after, columnFromMetadata(column)));
+    }
+    const alterColumns = Array.isArray(operation.metadata.alterColumns)
+        ? operation.metadata.alterColumns
+        : [];
+    for (const alteration of alterColumns) {
+        statements.push(...renderColumnAlteration(after, alteration));
+    }
+    const dropColumns = Array.isArray(operation.metadata.dropColumns)
+        ? operation.metadata.dropColumns
+        : [];
+    for (const column of dropColumns) {
+        statements.push(`ALTER TABLE ${qualifiedRef(after.ref)} DROP COLUMN IF EXISTS ${quoteIdent(String(column))};`);
+    }
+    if (statements.length === 0) {
+        throw new Error(`alter operation ${operation.key} has no column metadata`);
+    }
+    return statements.join("\n");
+}
+function renderColumnAlteration(table, alteration) {
+    if (!alteration || typeof alteration !== "object") {
+        throw new Error("invalid alter-column metadata");
+    }
+    const record = alteration;
+    const name = typeof record.name === "string" ? record.name : undefined;
+    if (!name) {
+        throw new Error("invalid alter-column metadata");
+    }
+    const prefix = `ALTER TABLE ${qualifiedRef(table.ref)} ALTER COLUMN ${quoteIdent(name)}`;
+    const statements = [];
+    if (typeof record.type === "string") {
+        statements.push(`${prefix} TYPE ${record.type} USING ${quoteIdent(name)}::${record.type};`);
+    }
+    if (record.dropDefault === true) {
+        statements.push(`${prefix} DROP DEFAULT;`);
+    }
+    if (typeof record.setDefault === "string") {
+        statements.push(`${prefix} SET DEFAULT ${record.setDefault};`);
+    }
+    if (record.setNotNull === true) {
+        statements.push(`${prefix} SET NOT NULL;`);
+    }
+    if (record.dropNotNull === true) {
+        statements.push(`${prefix} DROP NOT NULL;`);
+    }
+    return statements;
+}
+function renderReplace(operation) {
+    const before = requiredBefore(operation);
+    const after = requiredAfter(operation);
+    switch (after.ref.kind) {
+        case "function":
+        case "procedure":
+        case "view":
+            if (operation.metadata.routineDropRequired === true ||
+                operation.metadata.viewDropRequired === true) {
+                return `${renderDrop(before)}\n${renderCreate(after)}`;
+            }
+            return renderCreate(after);
+        case "policy":
+        case "trigger":
+            return renderCreate(after);
+        case "index":
+        case "constraint":
+        case "comment":
+            return `${renderDrop(before)}\n${renderCreate(after)}`;
+        case "materialized-view":
+        case "table":
+        case "foreign-data-wrapper":
+        case "foreign-server":
+        case "foreign-table":
+        case "enum":
+        case "type":
+        case "domain":
+        case "sequence":
+        case "rls":
+            return `${renderDrop(before)}\n${renderCreate(after)}`;
+        case "schema":
+        case "extension":
+        case "grant":
+        case "default-privilege":
+            return renderCreate(after);
+    }
+    throw new Error(`unsupported replace operation for ${after.ref.kind}`);
+}
+function renderAddColumn(table, column) {
+    return `ALTER TABLE ${qualifiedRef(table.ref)} ADD COLUMN IF NOT EXISTS ${quoteIdent(column.name)} ${column.definition};`;
+}
+function renderCreate(object) {
+    switch (object.ref.kind) {
+        case "schema":
+        case "extension":
+        case "sequence":
+        case "table":
+        case "foreign-server":
+        case "foreign-table":
+        case "index":
+        case "materialized-view":
+        case "function":
+        case "procedure":
+        case "view":
+            return spliceGuard(object);
+        case "enum":
+        case "type":
+        case "domain":
+            return renderTypeGuard(object);
+        case "foreign-data-wrapper":
+            return renderFdwGuard(object);
+        case "constraint":
+            return renderConstraintGuard(object);
+        case "policy":
+        case "trigger":
+            return `${renderDrop(object)}\n${ensureSemicolon(object.sql)}`;
+        case "rls":
+        case "grant":
+        case "default-privilege":
+        case "comment":
+            return ensureSemicolon(object.sql);
+    }
+    throw new Error(`unsupported create operation for ${object.ref.kind}`);
+}
+const guardInserts = {
+    ifNotExists: "IF NOT EXISTS ",
+    orReplace: "OR REPLACE ",
+};
+/**
+ * Splices the replay guard at the AST-located offset carried in
+ * metadata.render. No regex rewriting: classification and the splice point
+ * both come from extraction-time parse facts.
+ */
+function spliceGuard(object) {
+    const facts = object.metadata.render;
+    if (!facts || typeof facts !== "object") {
+        throw new Error(`object ${object.key} has no render guard facts; re-extract the source model with this supaschema version`);
+    }
+    const record = facts;
+    const guard = record.guard;
+    if (guard !== "ifNotExists" && guard !== "orReplace") {
+        throw new Error(`object ${object.key} has unsupported render guard facts`);
+    }
+    if (record.present === true) {
+        return ensureSemicolon(object.sql);
+    }
+    const offset = record.offset;
+    if (typeof offset !== "number" || offset < 0 || offset > object.sql.length) {
+        throw new Error(`object ${object.key} has no render guard offset; re-extract the source model with this supaschema version`);
+    }
+    return ensureSemicolon(`${object.sql.slice(0, offset)}${guardInserts[guard]}${object.sql.slice(offset)}`);
+}
+function renderDrop(object) {
+    const ref = object.ref;
+    switch (ref.kind) {
+        case "schema":
+            return `DROP SCHEMA IF EXISTS ${quoteIdent(ref.name)};`;
+        case "extension":
+            return `DROP EXTENSION IF EXISTS ${quoteIdent(ref.name)};`;
+        case "table":
+            return `DROP TABLE IF EXISTS ${qualifiedRef(ref)};`;
+        case "foreign-data-wrapper":
+            return `DROP FOREIGN DATA WRAPPER IF EXISTS ${quoteIdent(ref.name)};`;
+        case "foreign-server":
+            return `DROP SERVER IF EXISTS ${quoteIdent(ref.name)};`;
+        case "foreign-table":
+            return `DROP FOREIGN TABLE IF EXISTS ${qualifiedRef(ref)};`;
+        case "sequence":
+            return `DROP SEQUENCE IF EXISTS ${qualifiedRef(ref)};`;
+        case "enum":
+        case "type":
+            return `DROP TYPE IF EXISTS ${qualifiedRef(ref)};`;
+        case "domain":
+            return `DROP DOMAIN IF EXISTS ${qualifiedRef(ref)};`;
+        case "view":
+            return `DROP VIEW IF EXISTS ${qualifiedRef(ref)};`;
+        case "materialized-view":
+            return `DROP MATERIALIZED VIEW IF EXISTS ${qualifiedRef(ref)};`;
+        case "index":
+            return `DROP INDEX IF EXISTS ${qualifiedRef(ref)};`;
+        case "function":
+            return `DROP FUNCTION IF EXISTS ${qualifiedRef(ref)}(${ref.signature ?? ""});`;
+        case "procedure":
+            return `DROP PROCEDURE IF EXISTS ${qualifiedRef(ref)}(${ref.signature ?? ""});`;
+        case "constraint":
+            return `ALTER TABLE ${qualifiedTableRef(ref)} DROP CONSTRAINT IF EXISTS ${quoteIdent(ref.name)};`;
+        case "trigger":
+            return `DROP TRIGGER IF EXISTS ${quoteIdent(ref.name)} ON ${qualifiedTableRef(ref)};`;
+        case "policy":
+            return `DROP POLICY IF EXISTS ${quoteIdent(ref.name)} ON ${qualifiedTableRef(ref)};`;
+        case "rls":
+            return `ALTER TABLE ${qualifiedTableRef(ref)} DISABLE ROW LEVEL SECURITY;`;
+        case "comment":
+            return typeof object.metadata.commentDropSql === "string"
+                ? ensureSemicolon(object.metadata.commentDropSql)
+                : `COMMENT ON ${String(object.metadata.descriptor ?? ref.name)} IS NULL;`;
+        case "grant":
+            return renderGrantDrop(object);
+        case "default-privilege":
+            return renderDefaultPrivilegeDrop(object);
+    }
+    throw new Error(`unsupported drop operation for ${ref.kind}`);
+}
+function columnFromMetadata(value) {
+    if (!value || typeof value !== "object") {
+        throw new Error("invalid add-column metadata");
+    }
+    const name = "name" in value && typeof value.name === "string" ? value.name : undefined;
+    const definition = "definition" in value && typeof value.definition === "string" ? value.definition : undefined;
+    if (!name || !definition) {
+        throw new Error("invalid add-column metadata");
+    }
+    return { definition, name };
+}
+function requiredBefore(operation) {
+    if (!operation.before) {
+        throw new Error(`operation ${operation.key} has no before object`);
+    }
+    return operation.before;
+}
+function requiredAfter(operation) {
+    if (!operation.after) {
+        throw new Error(`operation ${operation.key} has no after object`);
+    }
+    return operation.after;
+}

package/dist/selfcheck.d.ts

@@ -0,0 +1,11 @@
+import type { Diagnostic } from "./core.js";
+export interface SelfCheckOptions {
+    databaseUrl: string;
+}
+export interface SelfCheckResult {
+    checkedObjects: number;
+    diagnostics: Diagnostic[];
+    mismatches: number;
+}
+export declare function selfCheckCatalog(options: SelfCheckOptions): Promise<SelfCheckResult>;
+//# sourceMappingURL=selfcheck.d.ts.map

package/dist/selfcheck.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selfcheck.d.ts","sourceRoot":"","sources":["../src/selfcheck.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAI5C,MAAM,WAAW,gBAAgB;IAC/B,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,eAAe;IAC9B,cAAc,EAAE,MAAM,CAAC;IACvB,WAAW,EAAE,UAAU,EAAE,CAAC;IAC1B,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,wBAAsB,gBAAgB,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,eAAe,CAAC,CA4D1F"}

package/dist/selfcheck.js

@@ -0,0 +1,43 @@
+import { extractCatalogModel } from "./catalog.js";
+import { diagnostic } from "./diagnostics.js";
+import { extractObjectsFromSql } from "./sql/extract.js";
+export async function selfCheckCatalog(options) {
+    const model = await extractCatalogModel({
+        databaseUrl: options.databaseUrl,
+        source: "selfcheck",
+    });
+    const diagnostics = [...model.diagnostics];
+    const script = [...model.objects]
+        .sort((left, right) => left.ordinal - right.ordinal)
+        .map((object) => `${object.sql};`)
+        .join("\n\n");
+    // The reparse uses the plain postgres adapter: managed-schema policy is a
+    // posture concern, not an identity-parity concern.
+    const reparsed = await extractObjectsFromSql(script, {
+        config: { adapter: "postgres" },
+        file: "selfcheck:rendered",
+    });
+    diagnostics.push(...reparsed.diagnostics.filter((item) => item.severity === "error"));
+    const catalogByKey = new Map(model.objects.map((object) => [object.key, object]));
+    const reparsedByKey = new Map(reparsed.objects.map((object) => [object.key, object]));
+    let mismatches = 0;
+    for (const [key, object] of catalogByKey) {
+        const other = reparsedByKey.get(key);
+        if (!other) {
+            mismatches += 1;
+            diagnostics.push(diagnostic("SUPA_SELFCHECK_MISSING", "error", `catalog object ${key} disappeared when its rendered SQL was re-extracted`, { ref: object.ref, statement: object.sql }));
+            continue;
+        }
+        if (other.hash !== object.hash) {
+            mismatches += 1;
+            diagnostics.push(diagnostic("SUPA_SELFCHECK_HASH_MISMATCH", "error", `catalog object ${key} hashes differently after re-extraction; cross-lane identity would report a false change`, { ref: object.ref, statement: object.sql }));
+        }
+    }
+    for (const [key, object] of reparsedByKey) {
+        if (!catalogByKey.has(key)) {
+            mismatches += 1;
+            diagnostics.push(diagnostic("SUPA_SELFCHECK_UNEXPECTED", "error", `re-extraction produced ${key}, which the catalog model does not contain`, { ref: object.ref, statement: object.sql }));
+        }
+    }
+    return { checkedObjects: catalogByKey.size, diagnostics, mismatches };
+}

package/dist/source-normalize.d.ts

@@ -0,0 +1,14 @@
+import type { Diagnostic, SchemaObject } from "./core.js";
+export interface SourceNormalizeOptions {
+    normalize?: boolean;
+}
+export declare function normalizeSourceObjects(objects: SchemaObject[], diagnostics: Diagnostic[], options?: SourceNormalizeOptions): Promise<SchemaObject[]>;
+/**
+ * Postgres applies in-model ALTER DEFAULT PRIVILEGES to every later object,
+ * and the resulting ACL entry is indistinguishable from an explicit GRANT.
+ * A grant fully implied by an in-model default-privilege entry is therefore
+ * suppressed on BOTH lanes (catalog models route through this too): trees
+ * declare the default once, catalogs materialize it per object.
+ */
+export declare function suppressDefaultAclImpliedGrants(objects: SchemaObject[]): SchemaObject[];
+//# sourceMappingURL=source-normalize.d.ts.map

package/dist/source-normalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"source-normalize.d.ts","sourceRoot":"","sources":["../src/source-normalize.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAa1D,MAAM,WAAW,sBAAsB;IACrC,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,wBAAsB,sBAAsB,CAC1C,OAAO,EAAE,YAAY,EAAE,EACvB,WAAW,EAAE,UAAU,EAAE,EACzB,OAAO,GAAE,sBAA2B,GACnC,OAAO,CAAC,YAAY,EAAE,CAAC,CAMzB;AAYD;;;;;;GAMG;AACH,wBAAgB,+BAA+B,CAAC,OAAO,EAAE,YAAY,EAAE,GAAG,YAAY,EAAE,CA2CvF"}