supaschema 0.1.0-rc.1

package/dist/catalog-foreign.js

@@ -0,0 +1,114 @@
+import { formatQualifiedName, quoteIdent } from "./sql/identifiers.js";
+import { makeObject } from "./sql/statements.js";
+/**
+ * Whole-object FDW tier: servers and foreign tables are modeled by their
+ * complete definition (no column-level diffing). Server and column options
+ * are reconstructed from catalog option arrays; user mappings are excluded
+ * because they carry credentials.
+ */
+export async function collectForeignObjects(pool) {
+    const objects = [];
+    const wrappers = await pool.query(`
+    select w.fdwname as name,
+           w.fdwhandler::regproc::text as handler,
+           w.fdwvalidator::regproc::text as validator,
+           w.fdwoptions as options
+    from pg_foreign_data_wrapper w
+    where not exists (
+      select 1 from pg_depend d where d.objid = w.oid and d.deptype = 'e'
+    )
+    order by w.fdwname
+  `);
+    for (const row of wrappers.rows) {
+        const clauses = [`CREATE FOREIGN DATA WRAPPER ${quoteIdent(text(row.name))}`];
+        if (row.handler && text(row.handler) !== "-") {
+            clauses.push(`HANDLER ${text(row.handler)}`);
+        }
+        if (row.validator && text(row.validator) !== "-") {
+            clauses.push(`VALIDATOR ${text(row.validator)}`);
+        }
+        const options = optionsClause(row.options);
+        if (options) {
+            clauses.push(options);
+        }
+        objects.push(makeObject({ kind: "foreign-data-wrapper", name: text(row.name) }, clauses.join(" "), 0));
+    }
+    const servers = await pool.query(`
+    select s.srvname as name, w.fdwname as wrapper, s.srvtype as server_type,
+           s.srvversion as server_version, s.srvoptions as options
+    from pg_foreign_server s
+    join pg_foreign_data_wrapper w on w.oid = s.srvfdw
+    order by s.srvname
+  `);
+    for (const row of servers.rows) {
+        const clauses = [`CREATE SERVER ${quoteIdent(text(row.name))}`];
+        if (row.server_type) {
+            clauses.push(`TYPE '${escapeLiteral(text(row.server_type))}'`);
+        }
+        if (row.server_version) {
+            clauses.push(`VERSION '${escapeLiteral(text(row.server_version))}'`);
+        }
+        clauses.push(`FOREIGN DATA WRAPPER ${quoteIdent(text(row.wrapper))}`);
+        const options = optionsClause(row.options);
+        if (options) {
+            clauses.push(options);
+        }
+        objects.push(makeObject({ kind: "foreign-server", name: text(row.name) }, clauses.join(" "), 0));
+    }
+    const tables = await pool.query(`
+    select n.nspname as schema, c.relname as name, s.srvname as server, ft.ftoptions as options,
+           array(
+             select format('%I %s', a.attname, pg_catalog.format_type(a.atttypid, a.atttypmod))
+             from pg_attribute a
+             where a.attrelid = c.oid and a.attnum > 0 and not a.attisdropped
+             order by a.attnum
+           ) as columns
+    from pg_foreign_table ft
+    join pg_class c on c.oid = ft.ftrelid
+    join pg_namespace n on n.oid = c.relnamespace
+    join pg_foreign_server s on s.oid = ft.ftserver
+    where n.nspname !~ '^pg_' and n.nspname <> 'information_schema'
+    order by n.nspname, c.relname
+  `);
+    for (const row of tables.rows) {
+        const schema = text(row.schema);
+        const name = text(row.name);
+        const columns = Array.isArray(row.columns) ? row.columns.map((item) => `  ${text(item)}`) : [];
+        const clauses = [
+            `CREATE FOREIGN TABLE ${formatQualifiedName(schema, name)} (\n${columns.join(",\n")}\n)`,
+            `SERVER ${quoteIdent(text(row.server))}`,
+        ];
+        const options = optionsClause(row.options);
+        if (options) {
+            clauses.push(options);
+        }
+        objects.push(makeObject({ kind: "foreign-table", name, schema }, clauses.join(" "), 0, undefined, {
+            server: text(row.server),
+        }));
+    }
+    return objects;
+}
+function optionsClause(value) {
+    if (!Array.isArray(value) || value.length === 0) {
+        return undefined;
+    }
+    const rendered = value
+        .map((item) => {
+        const raw = text(item);
+        const separator = raw.indexOf("=");
+        if (separator === -1) {
+            return undefined;
+        }
+        const key = raw.slice(0, separator);
+        const optionValue = raw.slice(separator + 1);
+        return `${quoteIdent(key)} '${escapeLiteral(optionValue)}'`;
+    })
+        .filter((item) => item !== undefined);
+    return rendered.length > 0 ? `OPTIONS (${rendered.join(", ")})` : undefined;
+}
+function escapeLiteral(value) {
+    return value.replaceAll("'", "''");
+}
+function text(value) {
+    return typeof value === "string" ? value : String(value);
+}

package/dist/catalog-tables.d.ts

@@ -0,0 +1,9 @@
+import type { SchemaObject } from "./core.js";
+type CatalogQuery = {
+    query: <Row extends Record<string, unknown>>(text: string, values?: unknown[]) => Promise<{
+        rows: Row[];
+    }>;
+};
+export declare function collectTables(pool: CatalogQuery): Promise<SchemaObject[]>;
+export {};
+//# sourceMappingURL=catalog-tables.d.ts.map

package/dist/catalog-tables.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"catalog-tables.d.ts","sourceRoot":"","sources":["../src/catalog-tables.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAe,MAAM,WAAW,CAAC;AAI3D,KAAK,YAAY,GAAG;IAClB,KAAK,EAAE,CAAC,GAAG,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACzC,IAAI,EAAE,MAAM,EACZ,MAAM,CAAC,EAAE,OAAO,EAAE,KACf,OAAO,CAAC;QAAE,IAAI,EAAE,GAAG,EAAE,CAAA;KAAE,CAAC,CAAC;CAC/B,CAAC;AAEF,wBAAsB,aAAa,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC,CA+E/E"}

package/dist/catalog-tables.js

@@ -0,0 +1,114 @@
+import { formatQualifiedName, quoteIdent } from "./sql/identifiers.js";
+import { makeObject } from "./sql/statements.js";
+export async function collectTables(pool) {
+    const tables = await pool.query(`
+    select c.oid::text as oid, n.nspname as schema, c.relname as name
+    from pg_class c
+    join pg_namespace n on n.oid = c.relnamespace
+    where c.relkind in ('r', 'p')
+      and not c.relispartition
+      and n.nspname !~ '^pg_'
+      and n.nspname <> 'information_schema'
+    order by n.nspname, c.relname
+  `);
+    if (tables.rows.length === 0) {
+        return [];
+    }
+    const oids = tables.rows.map((row) => stringValue(row.oid));
+    const [columns, constraints] = await Promise.all([
+        pool.query(`
+        select
+          a.attrelid::text as oid,
+          a.attname as name,
+          format_type(a.atttypid, a.atttypmod) as type,
+          a.attnotnull as not_null,
+          a.attidentity as identity,
+          a.attgenerated as generated,
+          pg_get_expr(d.adbin, d.adrelid) as default_expression
+        from pg_attribute a
+        left join pg_attrdef d on d.adrelid = a.attrelid and d.adnum = a.attnum
+        where a.attrelid = any($1::oid[])
+          and a.attnum > 0
+          and not a.attisdropped
+        order by a.attrelid, a.attnum
+      `, [oids]),
+        pool.query(`
+        select conrelid::text as oid, conname as name, pg_get_constraintdef(oid, true) as definition
+        from pg_constraint
+        where conrelid = any($1::oid[])
+          and contype in ('p', 'u', 'f', 'c', 'x')
+        order by conrelid, conname
+      `, [oids]),
+    ]);
+    const columnsByOid = groupByOid(columns.rows);
+    const constraintsByOid = groupByOid(constraints.rows);
+    const objects = [];
+    for (const table of tables.rows) {
+        const oid = stringValue(table.oid);
+        const columnDefinitions = (columnsByOid.get(oid) ?? []).map(columnFromRow);
+        const lines = columnDefinitions.map((column) => `  ${quoteIdent(column.name)} ${column.definition}`);
+        const schema = stringValue(table.schema);
+        const name = stringValue(table.name);
+        const sql = `CREATE TABLE ${formatQualifiedName(schema, name)} (\n${lines.join(",\n")}\n)`;
+        objects.push(makeObject({ kind: "table", name, schema }, sql, 0, undefined, {
+            columns: columnDefinitions,
+        }));
+        // Constraints are separate identity owners on every lane, so a constraint
+        // declared inline in a source tree and the same constraint read from
+        // pg_constraint compare as the same object instead of changing the table.
+        for (const constraint of constraintsByOid.get(oid) ?? []) {
+            const constraintName = stringValue(constraint.name);
+            const constraintObject = makeObject({ kind: "constraint", name: constraintName, schema, table: name }, `ALTER TABLE ONLY ${formatQualifiedName(schema, name)} ADD CONSTRAINT ${quoteIdent(constraintName)} ${stringValue(constraint.definition)}`, 0, undefined);
+            constraintObject.dependencies.push(`${schema}.${name}`);
+            objects.push(constraintObject);
+        }
+    }
+    return objects;
+}
+function columnFromRow(column) {
+    const identity = stringValue(column.identity);
+    const generated = stringValue(column.generated);
+    const parts = [stringValue(column.type)];
+    if (generated === "s" && column.default_expression) {
+        parts.push(`GENERATED ALWAYS AS (${stringValue(column.default_expression)}) STORED`);
+    }
+    else if (identity === "a") {
+        parts.push("GENERATED ALWAYS AS IDENTITY");
+    }
+    else if (identity === "d") {
+        parts.push("GENERATED BY DEFAULT AS IDENTITY");
+    }
+    else if (column.default_expression) {
+        parts.push(`DEFAULT ${stringValue(column.default_expression)}`);
+    }
+    if (column.not_null) {
+        parts.push("NOT NULL");
+    }
+    const facts = {
+        definition: parts.join(" "),
+        generated: generated === "s",
+        hasDefault: Boolean(column.default_expression) && generated !== "s",
+        hasInlineConstraint: false,
+        identity: identity === "a" || identity === "d",
+        name: stringValue(column.name),
+        notNull: column.not_null === true,
+        type: stringValue(column.type),
+    };
+    if (facts.hasDefault && !facts.identity) {
+        facts.defaultExpression = stringValue(column.default_expression);
+    }
+    return facts;
+}
+function groupByOid(rows) {
+    const groups = new Map();
+    for (const row of rows) {
+        const oid = stringValue(row.oid);
+        const group = groups.get(oid) ?? [];
+        group.push(row);
+        groups.set(oid, group);
+    }
+    return groups;
+}
+function stringValue(value) {
+    return typeof value === "string" ? value : String(value);
+}

package/dist/catalog.d.ts

@@ -0,0 +1,8 @@
+import type { SchemaModel } from "./core.js";
+export interface ExtractCatalogOptions {
+    databaseUrl: string;
+    source?: string;
+    normalize?: boolean;
+}
+export declare function extractCatalogModel(options: ExtractCatalogOptions): Promise<SchemaModel>;
+//# sourceMappingURL=catalog.d.ts.map

package/dist/catalog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"catalog.d.ts","sourceRoot":"","sources":["../src/catalog.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,WAAW,EAAgB,MAAM,WAAW,CAAC;AAQ3D,MAAM,WAAW,qBAAqB;IACpC,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAID,wBAAsB,mBAAmB,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,WAAW,CAAC,CAwD9F"}

package/dist/catalog.js

@@ -0,0 +1,351 @@
+import { Pool } from "pg";
+import { collectComments } from "./catalog-comments.js";
+import { collectDefaultPrivileges, collectGrants, collectSequences, collectTypes, } from "./catalog-extras.js";
+import { collectForeignObjects } from "./catalog-foreign.js";
+import { collectTables } from "./catalog-tables.js";
+import { diagnostic } from "./diagnostics.js";
+import { fingerprintObjects, MODEL_FORMAT_VERSION } from "./hash.js";
+import { suppressDefaultAclImpliedGrants } from "./source-normalize.js";
+import { finalizeObjects } from "./sql/facts.js";
+import { formatQualifiedName, quoteIdent, stripOuterDoubleQuotes } from "./sql/identifiers.js";
+import { makeObject } from "./sql/statements.js";
+export async function extractCatalogModel(options) {
+    // Empty search_path (pg_dump's convention) so pg_get_expr renders every
+    // reference schema-qualified; otherwise the session's search_path decides
+    // whether `auth.uid()` reconstructs as `uid()` and the cross-lane hash
+    // silently diverges from the declarative spelling.
+    const pool = new Pool({
+        connectionString: options.databaseUrl,
+        max: 4,
+        options: "-c search_path=",
+    });
+    pool.on("error", () => { });
+    try {
+        const sections = await Promise.all([
+            collectSection((objects) => appendSchemas(pool, objects, 0)),
+            collectSection((objects) => appendExtensions(pool, objects, 0)),
+            collectTypes(pool),
+            collectSequences(pool),
+            collectTables(pool),
+            collectForeignObjects(pool),
+            collectSection((objects) => appendFunctions(pool, objects, 0)),
+            collectSection((objects) => appendViews(pool, objects, 0)),
+            collectSection((objects) => appendIndexes(pool, objects, 0)),
+            collectSection((objects) => appendTriggers(pool, objects, 0)),
+            collectSection((objects) => appendPoliciesAndRls(pool, objects, 0)),
+            collectGrants(pool),
+            collectDefaultPrivileges(pool),
+            collectComments(pool),
+        ]);
+        const objects = suppressDefaultAclImpliedGrants(sections.flat());
+        objects.forEach((object, index) => {
+            object.ordinal = index;
+        });
+        const diagnostics = await finalizeObjects(objects, {
+            normalize: options.normalize === true,
+        });
+        return {
+            diagnostics,
+            fingerprint: fingerprintObjects(objects),
+            formatVersion: MODEL_FORMAT_VERSION,
+            objects,
+            source: options.source ?? "database",
+        };
+    }
+    catch (error) {
+        return {
+            diagnostics: [
+                diagnostic("SUPA_CATALOG_EXTRACT_FAILED", "error", errorMessage(error), {
+                    hint: "Confirm the database URL is reachable and the role can read pg_catalog.",
+                }),
+            ],
+            fingerprint: fingerprintObjects([]),
+            objects: [],
+            source: options.source ?? "database",
+        };
+    }
+    finally {
+        await pool.end();
+    }
+}
+async function collectSection(section) {
+    const objects = [];
+    await section(objects);
+    return objects;
+}
+async function appendSchemas(pool, objects, ordinal) {
+    // `public` is created by initdb in every database; modeling it as a
+    // droppable object would let a tree that never declares it render
+    // DROP SCHEMA public.
+    const result = await pool.query(`
+    select nspname as name
+    from pg_namespace
+    where nspname !~ '^pg_'
+      and nspname not in ('information_schema', 'public')
+    order by nspname
+  `);
+    for (const row of result.rows) {
+        const name = stringValue(row.name);
+        objects.push(makeObject({ kind: "schema", name }, `CREATE SCHEMA ${quoteIdent(name)}`, ordinal));
+        ordinal += 1;
+    }
+    return ordinal;
+}
+async function appendExtensions(pool, objects, ordinal) {
+    // plpgsql is installed by initdb in every database (same class as the
+    // public schema); modeling it would render DROP EXTENSION plpgsql for any
+    // tree that never declares it.
+    const result = await pool.query(`
+    select e.extname as name, n.nspname as schema
+    from pg_extension e
+    join pg_namespace n on n.oid = e.extnamespace
+    where e.extname <> 'plpgsql'
+    order by e.extname
+  `);
+    for (const row of result.rows) {
+        const name = stringValue(row.name);
+        const schema = stringValue(row.schema);
+        objects.push(makeObject({ kind: "extension", name }, `CREATE EXTENSION ${quoteIdent(name)} WITH SCHEMA ${quoteIdent(schema)}`, ordinal, undefined, { schema }));
+        ordinal += 1;
+    }
+    return ordinal;
+}
+async function appendFunctions(pool, objects, ordinal) {
+    const result = await pool.query(`
+    select
+      n.nspname as schema,
+      p.proname as name,
+      p.prokind as kind,
+      oidvectortypes(p.proargtypes) as args,
+      p.provariadic <> 0 as variadic,
+      pg_get_functiondef(p.oid) as definition
+    from pg_proc p
+    join pg_namespace n on n.oid = p.pronamespace
+    where n.nspname !~ '^pg_'
+      and n.nspname <> 'information_schema'
+      and p.prokind in ('f', 'p')
+    order by n.nspname, p.proname, oidvectortypes(p.proargtypes)
+  `);
+    for (const row of result.rows) {
+        const kind = stringValue(row.kind) === "p" ? "procedure" : "function";
+        objects.push(makeObject({
+            kind,
+            name: stringValue(row.name),
+            schema: stringValue(row.schema),
+            // Routine identity is input argument TYPES only (names are not part
+            // of PostgreSQL overload identity), matching the source lane.
+            signature: functionSignature(stringValue(row.args), row.variadic === true),
+        }, stringValue(row.definition), ordinal));
+        ordinal += 1;
+    }
+    return ordinal;
+}
+// oidvectortypes joins input argument types with ", "; type names contain no
+// commas, so marking the trailing VARIADIC argument by splitting is safe.
+function functionSignature(args, variadic) {
+    if (!variadic || args.length === 0) {
+        return args;
+    }
+    const types = args.split(", ");
+    types[types.length - 1] = `VARIADIC ${types.at(-1)}`;
+    return types.join(", ");
+}
+async function appendViews(pool, objects, ordinal) {
+    const result = await pool.query(`
+    select
+      n.nspname as schema,
+      c.relname as name,
+      c.relkind as relkind,
+      c.reloptions as reloptions,
+      pg_get_viewdef(c.oid, true) as definition
+    from pg_class c
+    join pg_namespace n on n.oid = c.relnamespace
+    where c.relkind in ('v', 'm')
+      and n.nspname !~ '^pg_'
+      and n.nspname <> 'information_schema'
+    order by n.nspname, c.relname
+  `);
+    for (const row of result.rows) {
+        const kind = stringValue(row.relkind) === "m" ? "materialized-view" : "view";
+        const prefix = kind === "materialized-view" ? "CREATE MATERIALIZED VIEW" : "CREATE VIEW";
+        const schema = stringValue(row.schema);
+        const name = stringValue(row.name);
+        const withClause = kind === "view" && reloptionEnabled(row.reloptions, "security_invoker")
+            ? " WITH (security_invoker = true)"
+            : "";
+        objects.push(makeObject({ kind, name, schema }, `${prefix} ${formatQualifiedName(schema, name)}${withClause} AS\n${stringValue(row.definition)}`, ordinal));
+        ordinal += 1;
+    }
+    return ordinal;
+}
+function reloptionEnabled(reloptions, option) {
+    if (!Array.isArray(reloptions)) {
+        return false;
+    }
+    for (const entry of reloptions) {
+        const text = String(entry);
+        const separator = text.indexOf("=");
+        const name = separator === -1 ? text : text.slice(0, separator);
+        if (name.trim().toLowerCase() !== option) {
+            continue;
+        }
+        const value = separator === -1
+            ? "true"
+            : text
+                .slice(separator + 1)
+                .trim()
+                .toLowerCase();
+        return value === "true" || value === "on" || value === "1" || value === "yes";
+    }
+    return false;
+}
+async function appendIndexes(pool, objects, ordinal) {
+    // Constraint-backed indexes (PK/UNIQUE/EXCLUDE) are owned by their
+    // constraint object; emitting them as index objects would double-own them
+    // and plan false index drops against trees that declare the constraint.
+    const result = await pool.query(`
+    select i.schemaname, i.tablename, i.indexname, i.indexdef
+    from pg_indexes i
+    where i.schemaname !~ '^pg_'
+      and i.schemaname <> 'information_schema'
+      and not exists (
+        select 1
+        from pg_constraint con
+        join pg_class ic on ic.oid = con.conindid
+        join pg_namespace icn on icn.oid = ic.relnamespace
+        where icn.nspname = i.schemaname and ic.relname = i.indexname
+      )
+    order by i.schemaname, i.indexname
+  `);
+    for (const row of result.rows) {
+        objects.push(makeObject({
+            kind: "index",
+            name: stringValue(row.indexname),
+            schema: stringValue(row.schemaname),
+            table: stringValue(row.tablename),
+        }, stringValue(row.indexdef), ordinal));
+        ordinal += 1;
+    }
+    return ordinal;
+}
+async function appendTriggers(pool, objects, ordinal) {
+    const result = await pool.query(`
+    select
+      n.nspname as schema,
+      c.relname as table_name,
+      t.tgname as name,
+      pg_get_triggerdef(t.oid, true) as definition
+    from pg_trigger t
+    join pg_class c on c.oid = t.tgrelid
+    join pg_namespace n on n.oid = c.relnamespace
+    where not t.tgisinternal
+      and n.nspname !~ '^pg_'
+      and n.nspname <> 'information_schema'
+    order by n.nspname, c.relname, t.tgname
+  `);
+    for (const row of result.rows) {
+        objects.push(makeObject({
+            kind: "trigger",
+            name: stringValue(row.name),
+            schema: stringValue(row.schema),
+            table: stringValue(row.table_name),
+        }, stringValue(row.definition), ordinal));
+        ordinal += 1;
+    }
+    return ordinal;
+}
+async function appendPoliciesAndRls(pool, objects, ordinal) {
+    const rls = await pool.query(`
+    select n.nspname as schema, c.relname as name, c.relrowsecurity as rls, c.relforcerowsecurity as force
+    from pg_class c
+    join pg_namespace n on n.oid = c.relnamespace
+    where c.relkind in ('r', 'p')
+      and (c.relrowsecurity or c.relforcerowsecurity)
+      and n.nspname !~ '^pg_'
+      and n.nspname <> 'information_schema'
+    order by n.nspname, c.relname
+  `);
+    for (const row of rls.rows) {
+        const schema = stringValue(row.schema);
+        const name = stringValue(row.name);
+        // ENABLE and FORCE are independent facets of one table's RLS state and
+        // share one rls identity; emit both statements so forced tables render
+        // correctly and hash-match a source tree that declares both.
+        const statements = [];
+        if (row.rls) {
+            statements.push(`ALTER TABLE ${formatQualifiedName(schema, name)} ENABLE ROW LEVEL SECURITY`);
+        }
+        if (row.force) {
+            statements.push(`ALTER TABLE ${formatQualifiedName(schema, name)} FORCE ROW LEVEL SECURITY`);
+        }
+        objects.push(makeObject({ kind: "rls", name, schema, table: name }, statements.join(";\n"), ordinal));
+        ordinal += 1;
+    }
+    const policies = await pool.query(`
+    select
+      schemaname as schema,
+      tablename as table_name,
+      policyname as name,
+      permissive,
+      roles,
+      cmd,
+      qual,
+      with_check
+    from pg_policies
+    order by schemaname, tablename, policyname
+  `);
+    for (const row of policies.rows) {
+        const schema = stringValue(row.schema);
+        const table = stringValue(row.table_name);
+        const name = stringValue(row.name);
+        const clauses = [
+            `CREATE POLICY ${quoteIdent(name)} ON ${formatQualifiedName(schema, table)}`,
+            `AS ${stringValue(row.permissive)}`,
+            `FOR ${stringValue(row.cmd)}`,
+            // pg_policies reports PUBLIC as the role name "public"; quoting it
+            // would parse as a named role instead of the ROLESPEC_PUBLIC keyword
+            // and break cross-lane hash parity with `TO PUBLIC` trees.
+            `TO ${normalizePolicyRoles(row.roles)
+                .map((role) => (role === "public" ? "PUBLIC" : quoteIdent(role)))
+                .join(", ")}`,
+        ];
+        if (row.qual) {
+            clauses.push(`USING (${stringValue(row.qual)})`);
+        }
+        if (row.with_check) {
+            clauses.push(`WITH CHECK (${stringValue(row.with_check)})`);
+        }
+        objects.push(makeObject({ kind: "policy", name, schema, table }, clauses.join(" "), ordinal));
+        ordinal += 1;
+    }
+    return ordinal;
+}
+function normalizePolicyRoles(value) {
+    if (Array.isArray(value)) {
+        return value.map(String);
+    }
+    if (typeof value === "string") {
+        const trimmed = value.trim();
+        if (trimmed.startsWith("{") && trimmed.endsWith("}")) {
+            return trimmed
+                .slice(1, -1)
+                .split(",")
+                .map((role) => stripOuterDoubleQuotes(role.trim()))
+                .filter(Boolean);
+        }
+        return trimmed
+            .split(",")
+            .map((role) => role.trim())
+            .filter(Boolean);
+    }
+    return [String(value)];
+}
+function stringValue(value) {
+    return typeof value === "string" ? value : String(value);
+}
+function errorMessage(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return String(error);
+}

package/dist/check-hazards.d.ts

@@ -0,0 +1,7 @@
+import type { Diagnostic, SupaschemaConfig } from "./core.js";
+import type { AstStatement } from "./sql/ast.js";
+export declare function newEnumAdditionState(): Map<string, Set<string>>;
+export declare function recordEnumAdditions(statement: AstStatement, state: Map<string, Set<string>>): void;
+export declare function enumValueUseDiagnostics(statement: AstStatement, state: Map<string, Set<string>>, config: SupaschemaConfig): Diagnostic[];
+export declare function escalateNontransactional(diagnostics: Diagnostic[], config: SupaschemaConfig): Diagnostic[];
+//# sourceMappingURL=check-hazards.d.ts.map

package/dist/check-hazards.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-hazards.d.ts","sourceRoot":"","sources":["../src/check-hazards.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAE9D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAGjD,wBAAgB,oBAAoB,IAAI,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,CAE/D;AAED,wBAAgB,mBAAmB,CACjC,SAAS,EAAE,YAAY,EACvB,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,GAC9B,IAAI,CAeN;AAED,wBAAgB,uBAAuB,CACrC,SAAS,EAAE,YAAY,EACvB,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,EAC/B,MAAM,EAAE,gBAAgB,GACvB,UAAU,EAAE,CAqBd;AA2CD,wBAAgB,wBAAwB,CACtC,WAAW,EAAE,UAAU,EAAE,EACzB,MAAM,EAAE,gBAAgB,GACvB,UAAU,EAAE,CAcd"}