supaschema 0.1.0-rc.1

package/dist/diff-score.js

@@ -0,0 +1,339 @@
+import { asRecord, astStatements, functionIdentity, qualifiedName, rangeVarName, readArray, readString, stringValue, } from "./sql/ast.js";
+import { objectKey } from "./sql/identifiers.js";
+import { parseSqlAst } from "./sql/parser.js";
+const unclassified = { destructive: false, keys: [] };
+export async function scoreDiffOutput(sql, manifest) {
+    const emittedKeys = new Set();
+    const destructiveKeys = new Set();
+    let classifiedStatements = 0;
+    const classify = async (text) => {
+        const parsed = await parseSqlAst(text, "diff-score");
+        if (parsed.ast === undefined) {
+            return;
+        }
+        for (const statement of astStatements(parsed.ast, text)) {
+            const classified = statementKeys(statement.tag, statement.node);
+            if (classified === "do-block") {
+                for (const segment of doBlockStatements(statement.node)) {
+                    await classify(segment);
+                }
+                continue;
+            }
+            if (classified.keys.length === 0) {
+                continue;
+            }
+            classifiedStatements += 1;
+            for (const key of classified.keys) {
+                emittedKeys.add(key);
+                if (classified.destructive) {
+                    destructiveKeys.add(key);
+                }
+            }
+        }
+    };
+    await classify(sql);
+    const manifestKeys = new Set(manifest.map((entry) => entry.key));
+    const missed = [...manifestKeys].filter((key) => !emittedKeys.has(key)).sort();
+    const excess = [...emittedKeys]
+        .filter((key) => !manifestKeys.has(key) || destructiveKeys.has(key))
+        .sort();
+    const matched = manifestKeys.size - missed.length;
+    const recall = manifestKeys.size === 0 ? 1 : matched / manifestKeys.size;
+    const precision = emittedKeys.size === 0 ? 1 : (emittedKeys.size - excess.length) / emittedKeys.size;
+    const f1 = recall + precision === 0 ? 0 : (2 * recall * precision) / (recall + precision);
+    return { classifiedStatements, excess, f1, matched, missed, precision, recall };
+}
+function keysOf(keys, destructive = false) {
+    return { destructive, keys };
+}
+function statementKeys(tag, statementNode) {
+    const node = asRecord(statementNode[tag]) ?? {};
+    switch (tag) {
+        case "DoStmt":
+            return "do-block";
+        case "CreateStmt": {
+            const name = rangeVarName(node.relation);
+            return name ? keysOf([objectKey({ kind: "table", ...name })]) : unclassified;
+        }
+        case "CreateTableAsStmt": {
+            const name = rangeVarName(asRecord(node.into)?.rel);
+            const kind = readString(node.objtype) === "OBJECT_MATVIEW" ? "materialized-view" : "table";
+            return name ? keysOf([objectKey({ kind, ...name })]) : unclassified;
+        }
+        case "RefreshMatViewStmt": {
+            const name = rangeVarName(node.relation);
+            return name ? keysOf([objectKey({ kind: "materialized-view", ...name })]) : unclassified;
+        }
+        case "AlterTableStmt":
+            return keysOf(alterTableKeys(node));
+        case "IndexStmt": {
+            const table = rangeVarName(node.relation);
+            const index = readString(node.idxname);
+            return table && index
+                ? keysOf([
+                    objectKey({ kind: "index", name: index, schema: table.schema, table: table.name }),
+                ])
+                : unclassified;
+        }
+        case "CreateFunctionStmt": {
+            const identity = functionIdentity(node.funcname, node.parameters);
+            return identity ? keysOf([objectKey({ kind: "function", ...identity })]) : unclassified;
+        }
+        case "ViewStmt": {
+            const name = rangeVarName(node.view);
+            return name ? keysOf([objectKey({ kind: "view", ...name })]) : unclassified;
+        }
+        case "CreatePolicyStmt": {
+            const table = rangeVarName(node.table);
+            const policy = readString(node.policy_name);
+            return table && policy
+                ? keysOf([
+                    objectKey({ kind: "policy", name: policy, schema: table.schema, table: table.name }),
+                ])
+                : unclassified;
+        }
+        case "AlterEnumStmt": {
+            const name = qualifiedName(node.typeName);
+            return name ? keysOf([objectKey({ kind: "enum", ...name })]) : unclassified;
+        }
+        case "CreateEnumStmt": {
+            const name = qualifiedName(node.typeName);
+            return name ? keysOf([objectKey({ kind: "enum", ...name })]) : unclassified;
+        }
+        case "CreateTrigStmt": {
+            const table = rangeVarName(node.relation);
+            const trigger = readString(node.trigname);
+            return table && trigger
+                ? keysOf([
+                    objectKey({ kind: "trigger", name: trigger, schema: table.schema, table: table.name }),
+                ])
+                : unclassified;
+        }
+        case "DropStmt":
+            return keysOf(dropKeys(node), dataBearingDropTypes.has(readString(node.removeType) ?? ""));
+        default:
+            return unclassified;
+    }
+}
+function alterTableKeys(node) {
+    const table = rangeVarName(node.relation);
+    if (!table) {
+        return [];
+    }
+    const keys = [];
+    for (const item of readArray(node.cmds)) {
+        const command = asRecord(asRecord(item)?.AlterTableCmd);
+        const subtype = readString(command?.subtype);
+        if (subtype === "AT_AddConstraint") {
+            const name = readString(asRecord(asRecord(command?.def)?.Constraint)?.conname);
+            if (name) {
+                keys.push(objectKey({ kind: "constraint", name, schema: table.schema, table: table.name }));
+                continue;
+            }
+        }
+        if (subtype === "AT_EnableRowSecurity" || subtype === "AT_DisableRowSecurity") {
+            keys.push(objectKey({ kind: "rls", name: table.name, schema: table.schema, table: table.name }));
+            continue;
+        }
+        keys.push(objectKey({ kind: "table", ...table }));
+    }
+    return [...new Set(keys)];
+}
+const dataBearingDropTypes = new Set([
+    "OBJECT_DOMAIN",
+    "OBJECT_MATVIEW",
+    "OBJECT_SCHEMA",
+    "OBJECT_SEQUENCE",
+    "OBJECT_TABLE",
+    "OBJECT_TYPE",
+]);
+const plainDropKinds = new Map([
+    ["OBJECT_INDEX", "index"],
+    ["OBJECT_MATVIEW", "materialized-view"],
+    ["OBJECT_SCHEMA", "schema"],
+    ["OBJECT_SEQUENCE", "sequence"],
+    ["OBJECT_TABLE", "table"],
+    ["OBJECT_VIEW", "view"],
+]);
+const tableScopedDropKinds = new Map([
+    ["OBJECT_POLICY", "policy"],
+    ["OBJECT_TRIGGER", "trigger"],
+]);
+const typeDropKinds = new Map([
+    ["OBJECT_DOMAIN", "domain"],
+    ["OBJECT_TYPE", "enum"],
+]);
+function dropKeys(node) {
+    const removeType = readString(node.removeType) ?? "";
+    const keys = [];
+    for (const object of readArray(node.objects)) {
+        const plainKind = plainDropKinds.get(removeType);
+        if (plainKind) {
+            const parts = objectNameParts(object);
+            const name = parts.at(-1);
+            if (name && removeType === "OBJECT_SCHEMA") {
+                keys.push(objectKey({ kind: plainKind, name }));
+            }
+            else if (name) {
+                const schema = parts.length > 1 ? (parts.at(-2) ?? "public") : "public";
+                keys.push(objectKey({ kind: plainKind, name, schema }));
+            }
+            continue;
+        }
+        const tableScopedKind = tableScopedDropKinds.get(removeType);
+        if (tableScopedKind) {
+            const parts = objectNameParts(object);
+            const name = parts.at(-1);
+            const table = parts.at(-2);
+            if (name && table) {
+                keys.push(objectKey({
+                    kind: tableScopedKind,
+                    name,
+                    schema: parts.length > 2 ? (parts.at(-3) ?? "public") : "public",
+                    table,
+                }));
+            }
+            continue;
+        }
+        const typeKind = typeDropKinds.get(removeType);
+        if (typeKind) {
+            const name = qualifiedName(asRecord(asRecord(object)?.TypeName)?.names);
+            if (name) {
+                keys.push(objectKey({ kind: typeKind, ...name }));
+            }
+            continue;
+        }
+        if (removeType === "OBJECT_FUNCTION" || removeType === "OBJECT_PROCEDURE") {
+            const name = qualifiedName(asRecord(asRecord(object)?.ObjectWithArgs)?.objname);
+            if (name) {
+                keys.push(objectKey({ kind: "function", ...name }));
+            }
+        }
+    }
+    return keys;
+}
+function objectNameParts(object) {
+    return readArray(asRecord(object)?.List ? asRecord(asRecord(object)?.List)?.items : object)
+        .map((item) => stringValue(item))
+        .filter((item) => item !== undefined);
+}
+function doBlockStatements(statementNode) {
+    const node = asRecord(statementNode.DoStmt);
+    for (const item of readArray(node?.args)) {
+        const defElem = asRecord(asRecord(item)?.DefElem);
+        if (readString(defElem?.defname) !== "as") {
+            continue;
+        }
+        const body = stringValue(defElem?.arg);
+        return body ? guardedBodySegments(body) : [];
+    }
+    return [];
+}
+function guardedBodySegments(body) {
+    const thenOffsets = keywordOffsets(body, "then");
+    const endIfOffsets = keywordOffsets(body, "end").filter((offset) => nextKeywordIs(body, offset + "end".length, "if"));
+    const segments = [];
+    let cursor = -1;
+    for (const endIf of endIfOffsets) {
+        const start = thenOffsets.find((offset) => offset > cursor && offset < endIf);
+        if (start === undefined) {
+            continue;
+        }
+        segments.push(body.slice(start + "then".length, endIf));
+        cursor = endIf;
+    }
+    if (segments.length > 0) {
+        return segments;
+    }
+    const begin = keywordOffsets(body, "begin").at(0);
+    const lastEnd = keywordOffsets(body, "end").at(-1);
+    if (begin !== undefined && lastEnd !== undefined && lastEnd > begin) {
+        return [body.slice(begin + "begin".length, lastEnd)];
+    }
+    return [body];
+}
+const whitespaceChars = " \t\n\r";
+function nextKeywordIs(text, from, word) {
+    let index = from;
+    while (index < text.length && whitespaceChars.includes(text[index] ?? "")) {
+        index += 1;
+    }
+    return isKeywordAt(text, index, word);
+}
+function isKeywordAt(text, offset, word) {
+    if (text.slice(offset, offset + word.length).toLowerCase() !== word) {
+        return false;
+    }
+    return !(isWordChar(text[offset - 1]) || isWordChar(text[offset + word.length]));
+}
+function isWordChar(char) {
+    if (char === undefined) {
+        return false;
+    }
+    return ((char >= "a" && char <= "z") ||
+        (char >= "A" && char <= "Z") ||
+        (char >= "0" && char <= "9") ||
+        char === "_");
+}
+function keywordOffsets(text, word) {
+    const offsets = [];
+    let index = 0;
+    while (index < text.length) {
+        const char = text[index] ?? "";
+        const next = text[index + 1] ?? "";
+        if (char === "-" && next === "-") {
+            const lineEnd = text.indexOf("\n", index);
+            index = lineEnd === -1 ? text.length : lineEnd + 1;
+            continue;
+        }
+        if (char === "/" && next === "*") {
+            const blockEnd = text.indexOf("*/", index + 2);
+            index = blockEnd === -1 ? text.length : blockEnd + 2;
+            continue;
+        }
+        if (char === "'" || char === '"') {
+            index = skipQuoted(text, index, char);
+            continue;
+        }
+        if (char === "$") {
+            const skipped = skipDollarQuoted(text, index);
+            if (skipped > index) {
+                index = skipped;
+                continue;
+            }
+        }
+        if (isKeywordAt(text, index, word)) {
+            offsets.push(index);
+            index += word.length;
+            continue;
+        }
+        index += 1;
+    }
+    return offsets;
+}
+function skipQuoted(text, from, quote) {
+    let index = from + 1;
+    while (index < text.length) {
+        if (text[index] === quote) {
+            if (text[index + 1] === quote) {
+                index += 2;
+                continue;
+            }
+            return index + 1;
+        }
+        index += 1;
+    }
+    return text.length;
+}
+function skipDollarQuoted(text, from) {
+    let tagEnd = from + 1;
+    while (tagEnd < text.length && (isWordChar(text[tagEnd]) || text[tagEnd] === "$")) {
+        if (text[tagEnd] === "$") {
+            const tag = text.slice(from, tagEnd + 1);
+            const close = text.indexOf(tag, tagEnd + 1);
+            return close === -1 ? text.length : close + tag.length;
+        }
+        tagEnd += 1;
+    }
+    return from;
+}

package/dist/doctor.d.ts

@@ -0,0 +1,17 @@
+import type { SupaschemaConfig } from "./config.js";
+export interface DoctorCheck {
+    detail: string;
+    name: string;
+    status: "pass" | "fail" | "skip";
+}
+export interface DoctorReport {
+    checks: DoctorCheck[];
+    healthy: boolean;
+}
+export declare function runDoctor(config: SupaschemaConfig, options?: {
+    configPath?: string;
+    cwd?: string;
+    databaseUrl?: string;
+}): Promise<DoctorReport>;
+export declare function renderDoctorReport(report: DoctorReport): string;
+//# sourceMappingURL=doctor.d.ts.map

package/dist/doctor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"doctor.d.ts","sourceRoot":"","sources":["../src/doctor.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAKpD,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC;CAClC;AAED,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,WAAW,EAAE,CAAC;IACtB,OAAO,EAAE,OAAO,CAAC;CAClB;AAID,wBAAsB,SAAS,CAC7B,MAAM,EAAE,gBAAgB,EACxB,OAAO,GAAE;IAAE,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAAO,GACxE,OAAO,CAAC,YAAY,CAAC,CAkGvB;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM,CAO/D"}

package/dist/doctor.js

@@ -0,0 +1,110 @@
+import { access } from "node:fs/promises";
+import { resolve } from "node:path";
+import { Client } from "pg";
+import { resolveDatabaseUrl, resolveSupabaseLocalDatabaseUrl } from "./database-url.js";
+import { migrationsStatus } from "./migrations-status.js";
+import { parseSqlAst } from "./sql/parser.js";
+const minimumNodeMajor = 22;
+export async function runDoctor(config, options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const checks = [];
+    const nodeMajor = Number(process.versions.node.split(".")[0]);
+    checks.push({
+        detail: `running ${process.versions.node}, requires >=${minimumNodeMajor}`,
+        name: "node version",
+        status: nodeMajor >= minimumNodeMajor ? "pass" : "fail",
+    });
+    try {
+        const parsed = await parseSqlAst("SELECT 1");
+        checks.push({
+            detail: parsed.ast !== undefined ? "libpg-query WASM parser loaded" : "parser returned no AST",
+            name: "sql parser",
+            status: parsed.ast !== undefined ? "pass" : "fail",
+        });
+    }
+    catch (error) {
+        checks.push({ detail: errorMessage(error), name: "sql parser", status: "fail" });
+    }
+    checks.push({
+        detail: options.configPath ?? "defaults (no config file found is fine)",
+        name: "config",
+        status: "pass",
+    });
+    const explicit = options.databaseUrl;
+    const resolved = resolveDatabaseUrl(explicit);
+    const lane = explicit
+        ? "explicit --database-url"
+        : process.env.SUPASCHEMA_DATABASE_URL
+            ? "SUPASCHEMA_DATABASE_URL"
+            : resolveSupabaseLocalDatabaseUrl()
+                ? "supabase/config.toml auto-discovery"
+                : "none";
+    checks.push({
+        detail: resolved ? `resolved via ${lane}` : "no URL resolves; database commands will skip",
+        name: "database url",
+        status: resolved ? "pass" : "skip",
+    });
+    if (resolved) {
+        const client = new Client({ connectionString: resolved });
+        try {
+            await client.connect();
+            const capability = await client.query("SELECT (rolcreatedb OR rolsuper) AS can_create FROM pg_catalog.pg_roles WHERE rolname = current_user");
+            checks.push({ detail: "SELECT 1 succeeded", name: "database reachable", status: "pass" });
+            const canCreate = capability.rows[0]?.can_create === true;
+            checks.push({
+                detail: canCreate
+                    ? "role can CREATE DATABASE (verify/corpus will work)"
+                    : "role lacks CREATEDB; verify/corpus need a stronger role",
+                name: "createdb capability",
+                status: canCreate ? "pass" : "fail",
+            });
+        }
+        catch (error) {
+            checks.push({ detail: errorMessage(error), name: "database reachable", status: "fail" });
+        }
+        finally {
+            await client.end().catch(() => undefined);
+        }
+    }
+    const migrationsDir = resolve(cwd, "supabase/migrations");
+    const hasMigrationsDir = await access(migrationsDir)
+        .then(() => true)
+        .catch(() => false);
+    if (hasMigrationsDir && resolved) {
+        const { report } = await migrationsStatus({ databaseUrl: resolved, directory: migrationsDir });
+        const broken = report.ghosts.length + report.outOfOrder.length;
+        checks.push({
+            detail: `${report.applied.length} applied, ${report.pending.length} pending, ${report.ghosts.length} ghosts, ${report.outOfOrder.length} out-of-order`,
+            name: "migrations history",
+            status: broken === 0 ? "pass" : "fail",
+        });
+    }
+    else {
+        checks.push({
+            detail: hasMigrationsDir ? "no database to compare against" : `${migrationsDir} not found`,
+            name: "migrations history",
+            status: "skip",
+        });
+    }
+    const tree = config.schemaPaths[0] ?? "supabase/schemas";
+    const hasTree = await access(resolve(cwd, tree))
+        .then(() => true)
+        .catch(() => false);
+    checks.push({
+        detail: hasTree ? `${tree} exists` : `${tree} not found (set schemaPaths in config)`,
+        name: "declarative tree",
+        status: hasTree ? "pass" : "skip",
+    });
+    return { checks, healthy: checks.every((item) => item.status !== "fail") };
+}
+export function renderDoctorReport(report) {
+    const lines = report.checks.map((item) => {
+        const badge = item.status === "pass" ? "PASS" : item.status === "fail" ? "FAIL" : "SKIP";
+        return `${badge}  ${item.name}: ${item.detail}`;
+    });
+    lines.push(report.healthy ? "doctor: healthy" : "doctor: issues found");
+    return `${lines.join("\n")}\n`;
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/hash.d.ts

@@ -0,0 +1,7 @@
+import type { SchemaModel, SchemaObject } from "./core.js";
+export declare const MODEL_FORMAT_VERSION = 2;
+export declare function sha256(value: string): string;
+export declare function stableJson(value: unknown): string;
+export declare function fingerprintObjects(objects: SchemaObject[]): string;
+export declare function fingerprintModel(model: SchemaModel): string;
+//# sourceMappingURL=hash.d.ts.map

package/dist/hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../src/hash.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAI3D,eAAO,MAAM,oBAAoB,IAAI,CAAC;AAEtC,wBAAgB,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAE5C;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAEjD;AAED,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,YAAY,EAAE,GAAG,MAAM,CAKlE;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,WAAW,GAAG,MAAM,CAE3D"}

package/dist/hash.js

@@ -0,0 +1,34 @@
+import { createHash } from "node:crypto";
+export const MODEL_FORMAT_VERSION = 2;
+export function sha256(value) {
+    return createHash("sha256").update(value).digest("hex");
+}
+export function stableJson(value) {
+    return JSON.stringify(sortJson(value));
+}
+export function fingerprintObjects(objects) {
+    const payload = objects
+        .map((object) => ({ hash: object.hash, key: object.key }))
+        .sort((left, right) => left.key.localeCompare(right.key));
+    return sha256(stableJson(payload));
+}
+export function fingerprintModel(model) {
+    return fingerprintObjects(model.objects);
+}
+function sortJson(value) {
+    if (Array.isArray(value)) {
+        return value.map(sortJson);
+    }
+    if (value && typeof value === "object") {
+        return Object.fromEntries(Object.entries(value)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([key, child]) => [key, sortJson(child)]));
+    }
+    if (value === null ||
+        typeof value === "boolean" ||
+        typeof value === "number" ||
+        typeof value === "string") {
+        return value;
+    }
+    return String(value);
+}

package/dist/index.d.ts

@@ -0,0 +1,24 @@
+export type { AuditFinding, AuditReport } from "./audit.js";
+export { auditModel, renderAuditReport } from "./audit.js";
+export { extractCatalogModel } from "./catalog.js";
+export { checkMigrationSql } from "./check.js";
+export { defaultConfig, loadConfig, resolveConfig, supaschemaConfigSchema } from "./config.js";
+export type { CheckOptions, Diagnostic, DiagnosticSeverity, ExtractOptions, MigrationOperation, MigrationOperationKind, MigrationPlan, ObjectKind, ObjectRef, RenameHint, RenderOptions, SchemaModel, SchemaObject, SupaschemaConfig, SupaschemaHints, TableColumn, VerifyMigrationOptions, } from "./core.js";
+export type { CorpusOptions, CorpusReport } from "./corpus.js";
+export { renderCorpusReport, runCorpus } from "./corpus.js";
+export { resolveDatabaseUrl, resolveSupabaseLocalDatabaseUrl } from "./database-url.js";
+export { applyMigrationSql, applySql, assertLocalDatabaseUrl, catalogFingerprint, createTemporaryDatabases, databaseUrlWithDatabase, dropTemporaryDatabases, tempDatabaseName, withTemporaryDatabases, } from "./db-admin.js";
+export type { MigrationLineage } from "./lineage.js";
+export { latestLineage, lineageLine, parseLineage } from "./lineage.js";
+export type { MigrationsStatusOptions, MigrationsStatusReport } from "./migrations-status.js";
+export { migrationsStatus, renderMigrationsStatus } from "./migrations-status.js";
+export { planSchemaDiff } from "./planner.js";
+export { renderMigration, renderMigrationSplit } from "./render.js";
+export { extractSourceModel } from "./source.js";
+export type { SyncOptions, SyncResult } from "./sync.js";
+export { syncMigrations } from "./sync.js";
+export { generateDatabaseTypes } from "./typegen.js";
+export { generateZodSchemas } from "./typegen-zod.js";
+export { runConfiguredValidators } from "./validators.js";
+export { verifyMigration } from "./verify.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAC5D,OAAO,EAAE,UAAU,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAC3D,OAAO,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AACnD,OAAO,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAC/C,OAAO,EAAE,aAAa,EAAE,UAAU,EAAE,aAAa,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAC/F,YAAY,EACV,YAAY,EACZ,UAAU,EACV,kBAAkB,EAClB,cAAc,EACd,kBAAkB,EAClB,sBAAsB,EACtB,aAAa,EACb,UAAU,EACV,SAAS,EACT,UAAU,EACV,aAAa,EACb,WAAW,EACX,YAAY,EACZ,gBAAgB,EAChB,eAAe,EACf,WAAW,EACX,sBAAsB,GACvB,MAAM,WAAW,CAAC;AACnB,YAAY,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC/D,OAAO,EAAE,kBAAkB,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAC5D,OAAO,EAAE,kBAAkB,EAAE,+BAA+B,EAAE,MAAM,mBAAmB,CAAC;AACxF,OAAO,EACL,iBAAiB,EACjB,QAAQ,EACR,sBAAsB,EACtB,kBAAkB,EAClB,wBAAwB,EACxB,uBAAuB,EACvB,sBAAsB,EACtB,gBAAgB,EAChB,sBAAsB,GACvB,MAAM,eAAe,CAAC;AACvB,YAAY,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AACrD,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AACxE,YAAY,EAAE,uBAAuB,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAC;AAC9F,OAAO,EAAE,gBAAgB,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAC;AAClF,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,EAAE,eAAe,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AACpE,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACjD,YAAY,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AACzD,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAC3C,OAAO,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AACrD,OAAO,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AACtD,OAAO,EAAE,uBAAuB,EAAE,MAAM,iBAAiB,CAAC;AAC1D,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC"}

package/dist/index.js

@@ -0,0 +1,17 @@
+export { auditModel, renderAuditReport } from "./audit.js";
+export { extractCatalogModel } from "./catalog.js";
+export { checkMigrationSql } from "./check.js";
+export { defaultConfig, loadConfig, resolveConfig, supaschemaConfigSchema } from "./config.js";
+export { renderCorpusReport, runCorpus } from "./corpus.js";
+export { resolveDatabaseUrl, resolveSupabaseLocalDatabaseUrl } from "./database-url.js";
+export { applyMigrationSql, applySql, assertLocalDatabaseUrl, catalogFingerprint, createTemporaryDatabases, databaseUrlWithDatabase, dropTemporaryDatabases, tempDatabaseName, withTemporaryDatabases, } from "./db-admin.js";
+export { latestLineage, lineageLine, parseLineage } from "./lineage.js";
+export { migrationsStatus, renderMigrationsStatus } from "./migrations-status.js";
+export { planSchemaDiff } from "./planner.js";
+export { renderMigration, renderMigrationSplit } from "./render.js";
+export { extractSourceModel } from "./source.js";
+export { syncMigrations } from "./sync.js";
+export { generateDatabaseTypes } from "./typegen.js";
+export { generateZodSchemas } from "./typegen-zod.js";
+export { runConfiguredValidators } from "./validators.js";
+export { verifyMigration } from "./verify.js";

package/dist/lineage.d.ts

@@ -0,0 +1,23 @@
+import type { MigrationPlan } from "./core.js";
+export interface MigrationLineage {
+    file: string;
+    from: string;
+    to: string;
+}
+export declare function lineageLine(plan: MigrationPlan): string;
+/**
+ * Parses the machine-readable lineage marker supaschema embeds in every
+ * rendered migration header. Hand-authored migrations have no marker and are
+ * invisible to the chain gate by design.
+ */
+export declare function parseLineage(content: string): {
+    from: string;
+    to: string;
+} | undefined;
+/**
+ * Finds the newest supaschema-generated migration in a directory by filename
+ * order (timestamped names sort chronologically). Returns undefined when no
+ * lineage-bearing migration exists, which disables the chain gate.
+ */
+export declare function latestLineage(directory: string): Promise<MigrationLineage | undefined>;
+//# sourceMappingURL=lineage.d.ts.map

package/dist/lineage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lineage.d.ts","sourceRoot":"","sources":["../src/lineage.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAE/C,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;CACZ;AAKD,wBAAgB,WAAW,CAAC,IAAI,EAAE,aAAa,GAAG,MAAM,CAEvD;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAmBtF;AAED;;;;GAIG;AACH,wBAAsB,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,GAAG,SAAS,CAAC,CAsB5F"}

package/dist/lineage.js

@@ -0,0 +1,61 @@
+import { readdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+const lineagePrefix = "-- supaschema: lineage ";
+const headerByteLimit = 4096;
+export function lineageLine(plan) {
+    return `${lineagePrefix}from=${plan.fromFingerprint} to=${plan.toFingerprint}`;
+}
+/**
+ * Parses the machine-readable lineage marker supaschema embeds in every
+ * rendered migration header. Hand-authored migrations have no marker and are
+ * invisible to the chain gate by design.
+ */
+export function parseLineage(content) {
+    for (const line of content.split("\n")) {
+        if (!line.startsWith(lineagePrefix)) {
+            continue;
+        }
+        const fields = new Map();
+        for (const token of line.slice(lineagePrefix.length).trim().split(/\s+/)) {
+            const separator = token.indexOf("=");
+            if (separator > 0) {
+                fields.set(token.slice(0, separator), token.slice(separator + 1));
+            }
+        }
+        const from = fields.get("from");
+        const to = fields.get("to");
+        if (from && to) {
+            return { from, to };
+        }
+    }
+    return undefined;
+}
+/**
+ * Finds the newest supaschema-generated migration in a directory by filename
+ * order (timestamped names sort chronologically). Returns undefined when no
+ * lineage-bearing migration exists, which disables the chain gate.
+ */
+export async function latestLineage(directory) {
+    let entries;
+    try {
+        entries = (await readdir(directory, { withFileTypes: true }))
+            .filter((entry) => entry.isFile() && entry.name.endsWith(".sql"))
+            .map((entry) => entry.name)
+            .sort((left, right) => right.localeCompare(left));
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+            return undefined;
+        }
+        throw error;
+    }
+    for (const name of entries) {
+        const path = join(directory, name);
+        const content = await readFile(path, "utf8");
+        const lineage = parseLineage(content.slice(0, headerByteLimit));
+        if (lineage) {
+            return { file: path, from: lineage.from, to: lineage.to };
+        }
+    }
+    return undefined;
+}