supaschema 0.1.0-rc.1

package/dist/benchmark-fixtures.js

@@ -0,0 +1,201 @@
+import { objectKey } from "./sql/identifiers.js";
+export function realisticFixtureManifest(tableCount) {
+    const entries = [
+        { change: "create", key: objectKey({ kind: "table", name: "audit_events", schema: "app" }) },
+        {
+            change: "create",
+            key: objectKey({
+                kind: "constraint",
+                name: "audit_events_pkey",
+                schema: "app",
+                table: "audit_events",
+            }),
+        },
+        {
+            change: "create",
+            key: objectKey({
+                kind: "constraint",
+                name: "audit_events_tenant_id_fkey",
+                schema: "app",
+                table: "audit_events",
+            }),
+        },
+        {
+            change: "create",
+            key: objectKey({
+                kind: "index",
+                name: "audit_events_tenant_id_idx",
+                schema: "app",
+                table: "audit_events",
+            }),
+        },
+        {
+            change: "create",
+            key: objectKey({
+                kind: "rls",
+                name: "audit_events",
+                schema: "app",
+                table: "audit_events",
+            }),
+        },
+        {
+            change: "create",
+            key: objectKey({
+                kind: "policy",
+                name: "audit_events_select",
+                schema: "app",
+                table: "audit_events",
+            }),
+        },
+        { change: "change", key: objectKey({ kind: "enum", name: "entity_status", schema: "app" }) },
+        {
+            change: "create",
+            key: objectKey({
+                kind: "index",
+                name: "entity_001_active_name_idx",
+                schema: "app",
+                table: "entity_001",
+            }),
+        },
+        {
+            change: "change",
+            key: objectKey({
+                kind: "policy",
+                name: "entity_002_select",
+                schema: "app",
+                table: "entity_002",
+            }),
+        },
+        { change: "change", key: objectKey({ kind: "view", name: "entity_005_names", schema: "app" }) },
+        {
+            change: "change",
+            key: objectKey({
+                kind: "function",
+                name: "entity_009_count",
+                schema: "app",
+                signature: "bigint",
+            }),
+        },
+    ];
+    for (let index = 1; index < tableCount; index += 1) {
+        if (index % 3 === 1) {
+            const table = `entity_${String(index).padStart(3, "0")}`;
+            entries.push({
+                change: "change",
+                key: objectKey({ kind: "table", name: table, schema: "app" }),
+            });
+        }
+    }
+    return entries;
+}
+export function makeRealisticSqlFixture(tableCount) {
+    if (tableCount < 12) {
+        throw new Error("realistic fixture needs at least 12 tables");
+    }
+    const preamble = (enumValues) => [
+        "CREATE SCHEMA app;",
+        "CREATE EXTENSION pgcrypto WITH SCHEMA public;",
+        "CREATE EXTENSION pg_trgm WITH SCHEMA public;",
+        `CREATE TYPE app.entity_status AS ENUM (${enumValues.map((value) => `'${value}'`).join(", ")});`,
+        "CREATE DOMAIN app.email_address AS text CHECK (VALUE ~ '@');",
+        `CREATE FUNCTION app.set_updated_at()
+RETURNS trigger
+LANGUAGE plpgsql
+AS $$
+BEGIN
+  NEW.updated_at := now();
+  RETURN NEW;
+END
+$$;`,
+        `CREATE TABLE app.tenants (
+  id bigint GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,
+  name text NOT NULL,
+  status app.entity_status DEFAULT 'active'::app.entity_status NOT NULL,
+  contact_email app.email_address,
+  created_at timestamptz DEFAULT now() NOT NULL,
+  updated_at timestamptz DEFAULT now() NOT NULL
+);`,
+        "CREATE TRIGGER tenants_updated_at BEFORE UPDATE ON app.tenants FOR EACH ROW EXECUTE FUNCTION app.set_updated_at();",
+    ];
+    const from = preamble(["active", "inactive"]);
+    const to = preamble(["active", "inactive", "archived"]);
+    for (let index = 1; index < tableCount; index += 1) {
+        from.push(...entityStatements(index, false));
+        to.push(...entityStatements(index, true));
+    }
+    to.push(`CREATE TABLE app.audit_events (
+  id bigint GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,
+  tenant_id bigint NOT NULL,
+  action text NOT NULL,
+  recorded_at timestamptz DEFAULT now() NOT NULL
+);`, "ALTER TABLE app.audit_events ADD CONSTRAINT audit_events_tenant_id_fkey FOREIGN KEY (tenant_id) REFERENCES app.tenants (id);", "CREATE INDEX audit_events_tenant_id_idx ON app.audit_events (tenant_id);", "ALTER TABLE app.audit_events ENABLE ROW LEVEL SECURITY;", `CREATE POLICY audit_events_select ON app.audit_events FOR SELECT TO public USING (${tenantPredicate()});`);
+    return { from: from.join("\n\n"), to: to.join("\n\n") };
+}
+function entityStatements(index, mutated) {
+    const table = `entity_${String(index).padStart(3, "0")}`;
+    const qualified = `app.${table}`;
+    // Added columns go last so ALTER TABLE ADD COLUMN reproduces the same
+    // catalog column order as applying the target tree directly.
+    const externalRef = mutated && index % 3 === 1 ? ",\n  external_ref text DEFAULT ''::text NOT NULL" : "";
+    const statements = [
+        `CREATE TABLE ${qualified} (
+  id bigint GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,
+  tenant_id bigint NOT NULL,
+  name text NOT NULL,
+  status app.entity_status DEFAULT 'active'::app.entity_status NOT NULL,
+  payload jsonb DEFAULT '{}'::jsonb NOT NULL,
+  created_at timestamptz DEFAULT now() NOT NULL,
+  updated_at timestamptz DEFAULT now() NOT NULL${externalRef}
+);`,
+        `ALTER TABLE ${qualified} ADD CONSTRAINT ${table}_tenant_id_fkey FOREIGN KEY (tenant_id) REFERENCES app.tenants (id);`,
+        `CREATE INDEX ${table}_tenant_id_idx ON ${qualified} (tenant_id);`,
+        `ALTER TABLE ${qualified} ENABLE ROW LEVEL SECURITY;`,
+        `CREATE POLICY ${table}_select ON ${qualified} FOR SELECT TO public USING (${selectPredicate(index, mutated)});`,
+        `CREATE POLICY ${table}_insert ON ${qualified} FOR INSERT TO public WITH CHECK (${tenantPredicate()});`,
+        `CREATE TRIGGER ${table}_updated_at BEFORE UPDATE ON ${qualified} FOR EACH ROW EXECUTE FUNCTION app.set_updated_at();`,
+    ];
+    if (mutated && index === 1) {
+        statements.push(`CREATE INDEX ${table}_active_name_idx ON ${qualified} (name) WHERE status = 'active'::app.entity_status;`);
+    }
+    if (index % 5 === 0) {
+        statements.push(`GRANT SELECT ON ${qualified} TO PUBLIC;`);
+    }
+    if (index % 10 === 5) {
+        const statusColumn = mutated && index === 5 ? ",\n  e.status" : "";
+        statements.push(`CREATE VIEW app.${table}_names AS
+SELECT e.id,
+  e.name,
+  t.name AS tenant_name${statusColumn}
+FROM ${qualified} e
+JOIN app.tenants t ON t.id = e.tenant_id;`);
+    }
+    if (index % 25 === 7) {
+        statements.push(`CREATE MATERIALIZED VIEW app.${table}_stats AS SELECT count(*) AS total FROM ${qualified};`);
+    }
+    if (index % 20 === 9) {
+        const body = mutated && index === 9
+            ? `SELECT count(id) FROM ${qualified} WHERE tenant_id = target_tenant`
+            : `SELECT count(*) FROM ${qualified} WHERE tenant_id = target_tenant`;
+        statements.push(`CREATE FUNCTION app.${table}_count(target_tenant bigint)
+RETURNS bigint
+LANGUAGE sql
+STABLE
+AS $$
+  ${body}
+$$;`);
+    }
+    if (index % 15 === 3) {
+        const suffix = mutated && index === 3 ? " (audited)" : "";
+        statements.push(`COMMENT ON TABLE ${qualified} IS 'Entity ${table} records${suffix}';`);
+    }
+    return statements;
+}
+function selectPredicate(index, mutated) {
+    if (mutated && index === 2) {
+        return `${tenantPredicate()} AND status <> 'inactive'::app.entity_status`;
+    }
+    return tenantPredicate();
+}
+function tenantPredicate() {
+    return "tenant_id = (current_setting('app.tenant_id', true))::bigint";
+}

package/dist/benchmark.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=benchmark.d.ts.map

package/dist/benchmark.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"benchmark.d.ts","sourceRoot":"","sources":["../src/benchmark.ts"],"names":[],"mappings":""}

package/dist/benchmark.js

@@ -0,0 +1,308 @@
+import { mkdir, mkdtemp, readdir, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { extname, join } from "node:path";
+import { performance } from "node:perf_hooks";
+import { makeRealisticSqlFixture } from "./benchmark-fixtures.js";
+import { resolveDatabaseUrl } from "./database-url.js";
+import { applyMigrationSql, applySql, databasePair, withTemporaryDatabases } from "./db-admin.js";
+import { formatDiagnostics } from "./diagnostics.js";
+import { fingerprintObjects } from "./hash.js";
+import { planSchemaDiff } from "./planner.js";
+import { renderMigration } from "./render.js";
+import { extractSourceModel } from "./source.js";
+import { extractObjectsFromSql } from "./sql/extract.js";
+import { verifyMigration } from "./verify.js";
+const fastIterations = Number(process.env.SUPASCHEMA_BENCHMARK_ITERATIONS ?? "5");
+const databaseIterations = Number(process.env.SUPASCHEMA_DATABASE_BENCHMARK_ITERATIONS ?? "3");
+const xlTables = numberEnv("SUPASCHEMA_XL_TABLES", 1000);
+const xxlTables = numberEnv("SUPASCHEMA_XXL_TABLES", 2500);
+const thresholds = {
+    catalogSnapshotDiff: numberEnv("SUPASCHEMA_CATALOG_BENCHMARK_MS", 2000),
+    dumpDiff: numberEnv("SUPASCHEMA_DUMP_BENCHMARK_MS", 2000),
+    endToEndMigration: numberEnv("SUPASCHEMA_END_TO_END_BENCHMARK_MS", 10000),
+    endToEndMigrationLarge: numberEnv("SUPASCHEMA_END_TO_END_LARGE_BENCHMARK_MS", 60000),
+    endToEndMigrationXl: numberEnv("SUPASCHEMA_END_TO_END_XL_BENCHMARK_MS", 120000),
+    endToEndMigrationXxl: numberEnv("SUPASCHEMA_END_TO_END_XXL_BENCHMARK_MS", 300000),
+    largeInMemoryDiff: numberEnv("SUPASCHEMA_LARGE_BENCHMARK_MS", 10000),
+    liveCatalogDiff: numberEnv("SUPASCHEMA_LIVE_CATALOG_BENCHMARK_MS", 10000),
+    liveCatalogDiffXl: numberEnv("SUPASCHEMA_LIVE_CATALOG_XL_BENCHMARK_MS", 60000),
+    liveCatalogDiffXxl: numberEnv("SUPASCHEMA_LIVE_CATALOG_XXL_BENCHMARK_MS", 120000),
+    noDriftDiff: numberEnv("SUPASCHEMA_NO_DRIFT_BENCHMARK_MS", 10000),
+    realisticTreeDiff: numberEnv("SUPASCHEMA_REALISTIC_BENCHMARK_MS", 10000),
+    replayVerification: numberEnv("SUPASCHEMA_VERIFY_BENCHMARK_MS", 30000),
+    shadowRoundTripDiff: numberEnv("SUPASCHEMA_SHADOW_BENCHMARK_MS", 30000),
+    sourceTreeDiff: numberEnv("SUPASCHEMA_BENCHMARK_MS", 2000),
+};
+const tempRoot = await mkdtemp(join(tmpdir(), "supaschema-benchmark-"));
+try {
+    const basicSources = {
+        from: "dir:tests/fixtures/basic/from",
+        to: "dir:tests/fixtures/basic/to",
+    };
+    const addColumnSources = {
+        from: "dir:tests/fixtures/add-column/from",
+        to: "dir:tests/fixtures/add-column/to",
+    };
+    const basicSql = {
+        from: await readSqlDirectory("tests/fixtures/basic/from"),
+        to: await readSqlDirectory("tests/fixtures/basic/to"),
+    };
+    const addColumnSql = {
+        from: await readSqlDirectory("tests/fixtures/add-column/from"),
+        to: await readSqlDirectory("tests/fixtures/add-column/to"),
+    };
+    const dumpSources = await writeDumpSources(basicSql);
+    const catalogSources = await writeCatalogSources(basicSources);
+    const realisticSql = makeRealisticSqlFixture(60);
+    const largeSql = makeRealisticSqlFixture(250);
+    const xlSql = makeRealisticSqlFixture(xlTables);
+    const xxlSql = makeRealisticSqlFixture(xxlTables);
+    const realisticTreeSources = await writeTreeSources("realistic", realisticSql);
+    const largeTreeSources = await writeTreeSources("large", largeSql);
+    const xlTreeSources = await writeTreeSources("xl", xlSql);
+    const xxlTreeSources = await writeTreeSources("xxl", xxlSql);
+    const databaseUrl = process.env.SUPASCHEMA_BENCHMARK_DATABASE_URL ?? resolveDatabaseUrl();
+    const results = {
+        catalogSnapshotDiff: await benchmarkDiffSources("catalogSnapshotDiff", thresholds.catalogSnapshotDiff, fastIterations, catalogSources),
+        database: {
+            endToEndMigration: await benchmarkEndToEndMigration("endToEndMigration", thresholds.endToEndMigration, databaseUrl, addColumnSources, addColumnSql),
+            endToEndMigrationLarge: await benchmarkEndToEndMigration("endToEndMigrationLarge", thresholds.endToEndMigrationLarge, databaseUrl, largeTreeSources, largeSql),
+            endToEndMigrationXl: await benchmarkEndToEndMigration("endToEndMigrationXl", thresholds.endToEndMigrationXl, databaseUrl, xlTreeSources, xlSql),
+            endToEndMigrationXxl: await benchmarkEndToEndMigration("endToEndMigrationXxl", thresholds.endToEndMigrationXxl, databaseUrl, xxlTreeSources, xxlSql),
+            liveCatalogDiff: await benchmarkLiveCatalogDiff("liveCatalogDiff", thresholds.liveCatalogDiff, databaseUrl, realisticSql),
+            liveCatalogDiffXl: await benchmarkLiveCatalogDiff("liveCatalogDiffXl", thresholds.liveCatalogDiffXl, databaseUrl, xlSql),
+            liveCatalogDiffXxl: await benchmarkLiveCatalogDiff("liveCatalogDiffXxl", thresholds.liveCatalogDiffXxl, databaseUrl, xxlSql),
+            replayVerification: await benchmarkReplayVerification(databaseUrl, addColumnSources),
+            shadowRoundTripDiff: await benchmarkShadowRoundTripDiff(databaseUrl, realisticSql),
+        },
+        dumpDiff: await benchmarkDiffSources("dumpDiff", thresholds.dumpDiff, fastIterations, dumpSources),
+        largeInMemoryDiff: await runBenchmark("largeInMemoryDiff", thresholds.largeInMemoryDiff, fastIterations, async () => {
+            const from = await modelFromSql("large:from", largeSql.from);
+            const to = await modelFromSql("large:to", largeSql.to);
+            diffModels("largeInMemoryDiff", from, to);
+        }),
+        noDriftDiff: await runBenchmark("noDriftDiff", thresholds.noDriftDiff, fastIterations, async () => {
+            const from = await extractSourceModel(realisticTreeSources.from);
+            const to = await extractSourceModel(realisticTreeSources.from);
+            const plan = diffModels("noDriftDiff", from, to);
+            if (plan.operations.length > 0) {
+                throw new Error(`noDriftDiff expected an empty plan for identical sources, found ${plan.operations.length} operations`);
+            }
+        }),
+        realisticTreeDiff: await benchmarkDiffSources("realisticTreeDiff", thresholds.realisticTreeDiff, fastIterations, realisticTreeSources),
+        sourceTreeDiff: await benchmarkDiffSources("sourceTreeDiff", thresholds.sourceTreeDiff, fastIterations, basicSources),
+    };
+    process.stdout.write(JSON.stringify(results, null, 2));
+    process.stdout.write("\n");
+}
+finally {
+    await rm(tempRoot, { force: true, recursive: true });
+}
+async function benchmarkDiffSources(name, thresholdMs, iterations, sources) {
+    return runBenchmark(name, thresholdMs, iterations, async () => {
+        const from = await extractSourceModel(sources.from);
+        const to = await extractSourceModel(sources.to);
+        diffModels(name, from, to);
+    });
+}
+async function benchmarkLiveCatalogDiff(name, thresholdMs, databaseUrl, sql) {
+    if (!databaseUrl) {
+        return skippedDatabaseBenchmark(thresholdMs);
+    }
+    return withTemporaryDatabases(databaseUrl, 2, async (databaseUrls) => {
+        const [fromUrl, toUrl] = databasePair(databaseUrls);
+        await applySql(fromUrl, sql.from);
+        await applySql(toUrl, sql.to);
+        return benchmarkDiffSources(name, thresholdMs, databaseIterations, {
+            from: `database:${fromUrl}`,
+            to: `database:${toUrl}`,
+        });
+    });
+}
+async function benchmarkReplayVerification(databaseUrl, sources) {
+    if (!databaseUrl) {
+        return skippedDatabaseBenchmark(thresholds.replayVerification);
+    }
+    const migrationPath = join(tempRoot, "add-column.sql");
+    const from = await extractSourceModel(sources.from);
+    const to = await extractSourceModel(sources.to);
+    const plan = diffModels("replayVerification:plan", from, to);
+    await writeFile(migrationPath, renderMigration(plan), "utf8");
+    return runBenchmark("replayVerification", thresholds.replayVerification, databaseIterations, async () => {
+        const diagnostics = await verifyMigration({
+            databaseUrl,
+            from: sources.from,
+            migrationPath,
+            to: sources.to,
+        });
+        assertNoErrors("replayVerification", diagnostics);
+    });
+}
+async function benchmarkEndToEndMigration(name, thresholdMs, databaseUrl, sources, sql) {
+    if (!databaseUrl) {
+        return skippedDatabaseBenchmark(thresholdMs);
+    }
+    return withTemporaryDatabases(databaseUrl, 1, async (targetUrls) => {
+        const [targetUrl] = targetUrls;
+        if (!targetUrl) {
+            throw new Error("expected a temporary target database");
+        }
+        await applySql(targetUrl, sql.to);
+        const target = await extractSourceModel(`database:${targetUrl}`);
+        assertNoErrors(`${name}:target`, target.diagnostics);
+        return runMeasuredBenchmark(name, thresholdMs, databaseIterations, async () => withTemporaryDatabases(databaseUrl, 1, async (migrationUrls) => {
+            const [migrationUrl] = migrationUrls;
+            if (!migrationUrl) {
+                throw new Error("expected a temporary migration database");
+            }
+            await applySql(migrationUrl, sql.from);
+            const started = performance.now();
+            const from = await extractSourceModel(sources.from);
+            const to = await extractSourceModel(sources.to);
+            assertNoErrors(`${name}:from`, from.diagnostics);
+            assertNoErrors(`${name}:to`, to.diagnostics);
+            const plan = planSchemaDiff(from, to);
+            assertNoErrors(`${name}:plan`, plan.diagnostics);
+            await applyMigrationSql(migrationUrl, renderMigration(plan));
+            const elapsedMs = performance.now() - started;
+            const applied = await extractSourceModel(`database:${migrationUrl}`);
+            assertNoErrors(`${name}:applied`, applied.diagnostics);
+            if (applied.fingerprint !== target.fingerprint) {
+                throw new Error(`${name} migrated catalog fingerprint does not match target: migration=${applied.fingerprint} target=${target.fingerprint}`);
+            }
+            return elapsedMs;
+        }));
+    });
+}
+async function benchmarkShadowRoundTripDiff(databaseUrl, sql) {
+    if (!databaseUrl) {
+        return skippedDatabaseBenchmark(thresholds.shadowRoundTripDiff);
+    }
+    return runBenchmark("shadowRoundTripDiff", thresholds.shadowRoundTripDiff, databaseIterations, async () => {
+        await withTemporaryDatabases(databaseUrl, 2, async (databaseUrls) => {
+            const [fromUrl, toUrl] = databasePair(databaseUrls);
+            await applySql(fromUrl, sql.from);
+            await applySql(toUrl, sql.to);
+            const from = await extractSourceModel(`database:${fromUrl}`);
+            const to = await extractSourceModel(`database:${toUrl}`);
+            diffModels("shadowRoundTripDiff", from, to);
+        });
+    });
+}
+async function runBenchmark(name, thresholdMs, iterations, action) {
+    return runMeasuredBenchmark(name, thresholdMs, iterations, async () => {
+        const start = performance.now();
+        await action();
+        return performance.now() - start;
+    });
+}
+async function runMeasuredBenchmark(name, thresholdMs, iterations, measure) {
+    const timings = [];
+    for (let index = 0; index < iterations; index += 1) {
+        timings.push(await measure());
+    }
+    const warm = timings.slice(1);
+    const maxWarm = Math.max(...(warm.length > 0 ? warm : timings));
+    if (maxWarm > thresholdMs) {
+        throw new Error(`${name} warm benchmark exceeded ${thresholdMs}ms`);
+    }
+    return {
+        maxWarmMs: Math.round(maxWarm),
+        status: "passed",
+        thresholdMs,
+        timingsMs: timings.map((value) => Math.round(value)),
+    };
+}
+function diffModels(name, from, to) {
+    assertNoErrors(`${name}:from`, from.diagnostics);
+    assertNoErrors(`${name}:to`, to.diagnostics);
+    const plan = planSchemaDiff(from, to);
+    assertNoErrors(`${name}:plan`, plan.diagnostics);
+    renderMigration(plan);
+    return plan;
+}
+async function modelFromSql(source, sql) {
+    const extracted = await extractObjectsFromSql(sql, {
+        config: { adapter: "postgres" },
+        file: `${source}.sql`,
+    });
+    return {
+        diagnostics: extracted.diagnostics,
+        fingerprint: fingerprintObjects(extracted.objects),
+        objects: extracted.objects,
+        source,
+    };
+}
+async function writeDumpSources(sql) {
+    const fromPath = join(tempRoot, "from.dump.sql");
+    const toPath = join(tempRoot, "to.dump.sql");
+    await writeFile(fromPath, sql.from, "utf8");
+    await writeFile(toPath, sql.to, "utf8");
+    return {
+        from: `dump:${fromPath}`,
+        to: `dump:${toPath}`,
+    };
+}
+async function writeTreeSources(label, sql) {
+    const fromDirectory = join(tempRoot, `${label}-from`);
+    const toDirectory = join(tempRoot, `${label}-to`);
+    await mkdir(fromDirectory, { recursive: true });
+    await mkdir(toDirectory, { recursive: true });
+    await writeFile(join(fromDirectory, "001_app.sql"), sql.from, "utf8");
+    await writeFile(join(toDirectory, "001_app.sql"), sql.to, "utf8");
+    return {
+        from: `dir:${fromDirectory}`,
+        to: `dir:${toDirectory}`,
+    };
+}
+async function writeCatalogSources(sources) {
+    const from = await extractSourceModel(sources.from);
+    const to = await extractSourceModel(sources.to);
+    const fromPath = join(tempRoot, "from.catalog.json");
+    const toPath = join(tempRoot, "to.catalog.json");
+    await writeFile(fromPath, `${JSON.stringify(from, null, 2)}\n`, "utf8");
+    await writeFile(toPath, `${JSON.stringify(to, null, 2)}\n`, "utf8");
+    return {
+        from: `catalog:${fromPath}`,
+        to: `catalog:${toPath}`,
+    };
+}
+async function readSqlDirectory(root) {
+    const files = [];
+    async function walk(directory) {
+        const entries = await readdir(directory, { withFileTypes: true });
+        for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
+            const path = join(directory, entry.name);
+            if (entry.isDirectory()) {
+                await walk(path);
+                continue;
+            }
+            if (entry.isFile() && extname(entry.name) === ".sql") {
+                files.push(path);
+            }
+        }
+    }
+    await walk(root);
+    const chunks = [];
+    for (const file of files.sort()) {
+        chunks.push(await readFile(file, "utf8"));
+    }
+    return chunks.join("\n\n");
+}
+function assertNoErrors(name, diagnostics) {
+    const errors = diagnostics.filter((item) => item.severity === "error");
+    if (errors.length > 0) {
+        throw new Error(`${name} produced diagnostics:\n${formatDiagnostics(errors)}`);
+    }
+}
+function skippedDatabaseBenchmark(thresholdMs) {
+    return {
+        reason: "set SUPASCHEMA_BENCHMARK_DATABASE_URL to a disposable PostgreSQL admin URL",
+        status: "skipped",
+        thresholdMs,
+    };
+}
+function numberEnv(name, fallback) {
+    const raw = process.env[name];
+    return raw === undefined ? fallback : Number(raw);
+}

package/dist/catalog-comments.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 collectComments(pool: CatalogQuery): Promise<SchemaObject[]>;
+export {};
+//# sourceMappingURL=catalog-comments.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"catalog-comments.d.ts","sourceRoot":"","sources":["../src/catalog-comments.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAK9C,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;AAgBF,wBAAsB,eAAe,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC,CAYjF"}