supaschema 0.1.0-rc.1

package/benchmarks/plot.js

@@ -0,0 +1,154 @@
+#!/usr/bin/env node
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { basename, join, resolve } from "node:path";
+import { fixtureScale, formatSeconds, groupedStats, isWorkflow, percentile } from "./plot-lib.js";
+import { renderCorrectnessSvg, renderLatencySvg, renderScalingSvg } from "./plot-svg.js";
+
+const jsonInputs = process.argv.slice(2).filter((arg) => arg.endsWith(".json"));
+const dirArgs = process.argv.slice(2).filter((arg) => !arg.endsWith(".json"));
+const inputs = (jsonInputs.length > 0 ? jsonInputs : ["benchmarks/results/comparison.json"]).map(
+  (path) => resolve(path),
+);
+const outputDir = resolve(dirArgs[0] ?? "benchmarks/results");
+const allResults = [];
+const environments = [];
+for (const input of inputs) {
+  const payload = JSON.parse(await readFile(input, "utf8"));
+  allResults.push(...payload.results);
+  environments.push({
+    arch: payload.environment.arch,
+    completedAt: payload.completedAt,
+    fixtures: [...new Set(payload.results.map((item) => item.fixture))].sort(),
+    iterations: payload.environment.iterations,
+    node: payload.environment.node,
+    platform: payload.environment.platform,
+    source: basename(input),
+    toolVersions: payload.environment.toolVersions,
+  });
+}
+const fixtures = [...new Set(allResults.map((item) => item.fixture))].sort(
+  (left, right) =>
+    (fixtureScale[left]?.order ?? 99) - (fixtureScale[right]?.order ?? 99) ||
+    left.localeCompare(right),
+);
+await mkdir(outputDir, { recursive: true });
+const written = [];
+const diffResults = allResults.filter((item) => !isWorkflow(item.adapter));
+const workflowResults = allResults.filter((item) => isWorkflow(item.adapter));
+for (const fixture of fixtures) {
+  const rows = allResults.filter((item) => item.fixture === fixture);
+  const diffRows = diffResults.filter((item) => item.fixture === fixture);
+  const measuredRows = diffRows.filter((item) => !item.skipped && !item.unsupported);
+  const latencyPath = join(outputDir, `${fixture}-latency.svg`);
+  const correctnessPath = join(outputDir, `${fixture}-correctness.svg`);
+  const resultsPath = join(outputDir, `${fixture}-results.json`);
+  if (measuredRows.length > 0) {
+    await writeFile(latencyPath, renderLatencySvg(measuredRows, fixture, environments), "utf8");
+    await writeFile(correctnessPath, renderCorrectnessSvg(diffRows, fixture, environments), "utf8");
+    written.push(latencyPath, correctnessPath);
+  }
+  await writeFile(
+    resultsPath,
+    `${JSON.stringify({ environments, fixture, results: rows }, null, 2)}\n`,
+    "utf8",
+  );
+  written.push(resultsPath);
+}
+const measuredDiffResults = diffResults.filter((item) => !item.skipped && !item.unsupported);
+if (fixtures.length > 1 && measuredDiffResults.length > 0) {
+  const scalingPath = join(outputDir, "scaling-latency.svg");
+  await writeFile(scalingPath, renderScalingSvg(diffResults, fixtures, environments), "utf8");
+  written.push(scalingPath);
+}
+const measuredWorkflowResults = workflowResults.filter(
+  (item) => !item.skipped && !item.unsupported,
+);
+if (fixtures.length > 1 && measuredWorkflowResults.length > 0) {
+  const workflowPath = join(outputDir, "workflow-latency.svg");
+  await writeFile(
+    workflowPath,
+    renderScalingSvg(workflowResults, fixtures, environments, {
+      subtitle:
+        "supaschema: one diff = migration + TS types + Zod · Supabase engines: db diff + apply + gen types · log scale",
+      title: "Full workflow: migration + regenerated types",
+    }),
+    "utf8",
+  );
+  written.push(workflowPath);
+}
+const summaryPath = join(outputDir, "summary.md");
+await writeFile(summaryPath, renderSummaryMarkdown(), "utf8");
+written.push(summaryPath);
+for (const path of written) {
+  process.stdout.write(`${path}\n`);
+}
+
+function renderSummaryMarkdown() {
+  const lines = [
+    "# Comparison Summary",
+    "",
+    "Generated by `npm run bench:plot`. One section per fixture (sample size); scaling ratios compare each tool's median against its own smallest-fixture median, so growth with schema size is the per-tool regression curve. All durations are seconds.",
+    "",
+    "## Source Runs",
+    "",
+  ];
+  for (const env of environments) {
+    lines.push(
+      `- \`${env.source}\`: fixtures ${env.fixtures.join(", ")}; ${env.iterations} iterations; supabase ${env.toolVersions?.supabase ?? "n/a"}; completed ${env.completedAt}`,
+    );
+  }
+  for (const fixture of fixtures) {
+    const rows = allResults.filter(
+      (item) => item.fixture === fixture && !item.skipped && !item.unsupported,
+    );
+    lines.push("", `## Fixture: ${fixture}`, "");
+    lines.push(
+      "| Tool | Mode | Runs | Median | p95 | Applies once | Applies twice | Fully verified | Output F1 |",
+      "| --- | --- | --- | --- | --- | --- | --- | --- | --- |",
+    );
+    for (const group of groupedStats(rows)) {
+      const groupRows = rows.filter((item) => item.adapter === group.label);
+      const mode = groupRows[0]?.mode ?? "";
+      const once = groupRows.filter((item) => item.appliesOnce).length;
+      const twice = groupRows.filter((item) => item.appliesTwice).length;
+      const verified = groupRows.filter((item) => item.matchesTargetFingerprint).length;
+      const scored = groupRows.filter((item) => typeof item.outputF1 === "number");
+      const f1 =
+        scored.length > 0
+          ? (scored.reduce((sum, item) => sum + item.outputF1, 0) / scored.length).toFixed(3)
+          : "—";
+      lines.push(
+        `| ${group.label} | ${mode} | ${groupRows.length} | ${formatSeconds(group.median)} | ${formatSeconds(group.p95)} | ${once}/${groupRows.length} | ${twice}/${groupRows.length} | ${verified}/${groupRows.length} | ${f1} |`,
+      );
+    }
+  }
+  lines.push("", "## Scaling Across Fixtures (median seconds, ratio vs own smallest)", "");
+  const adapters = [...new Set(allResults.map((item) => item.adapter))].sort();
+  lines.push(`| Tool | ${fixtures.join(" | ")} |`, `| --- |${" --- |".repeat(fixtures.length)}`);
+  for (const adapter of adapters) {
+    const medians = fixtures.map((fixture) => {
+      const values = allResults
+        .filter(
+          (item) =>
+            item.adapter === adapter &&
+            item.fixture === fixture &&
+            !item.skipped &&
+            !item.unsupported,
+        )
+        .map((item) => item.elapsedMs);
+      return values.length > 0 ? percentile(values, 0.5) : undefined;
+    });
+    const base = medians.find((value) => value !== undefined && value > 0);
+    const cells = medians.map((value) => {
+      if (value === undefined) {
+        return "—";
+      }
+      return base
+        ? `${formatSeconds(value)} (${(value / base).toFixed(1)}x)`
+        : formatSeconds(value);
+    });
+    lines.push(`| ${adapter} | ${cells.join(" | ")} |`);
+  }
+  lines.push("");
+  return lines.join("\n");
+}

package/benchmarks/tools/bench-all.sh

@@ -0,0 +1,49 @@
+#!/usr/bin/env bash
+set -euo pipefail
+cd "$(dirname "$0")/../.."
+export SUPASCHEMA_COMPARE_DATABASE_URL=${SUPASCHEMA_COMPARE_DATABASE_URL:-postgresql://postgres:postgres@127.0.0.1:54322/postgres}
+export SUPASCHEMA_COMPARE_WARMUPS=1
+export SUPASCHEMA_COMPARE_TIMEOUT_MS=480000
+
+run_small() {
+  SUPASCHEMA_COMPARE_FIXTURES=additive,functions-policies SUPASCHEMA_COMPARE_ITERATIONS=3 \
+    SUPASCHEMA_COMPARE_PORT_BASE=55400 \
+    SUPASCHEMA_COMPARE_OUT=benchmarks/results/comparison.json node benchmarks/compare.js >/dev/null
+  echo "DONE small-fixtures"
+}
+run_realistic() {
+  SUPASCHEMA_COMPARE_FIXTURES=realistic SUPASCHEMA_COMPARE_ITERATIONS=3 \
+    SUPASCHEMA_COMPARE_PORT_BASE=56400 \
+    SUPASCHEMA_COMPARE_OUT=benchmarks/results/comparison-realistic.json node benchmarks/compare.js >/dev/null
+  echo "DONE realistic"
+}
+run_xl() {
+  SUPASCHEMA_COMPARE_XL_TABLES=1000 SUPASCHEMA_COMPARE_FIXTURES=xl SUPASCHEMA_COMPARE_ITERATIONS=3 \
+    SUPASCHEMA_COMPARE_PORT_BASE=57400 \
+    SUPASCHEMA_COMPARE_OUT=benchmarks/results/comparison-xl.json node benchmarks/compare.js >/dev/null
+  echo "DONE xl"
+}
+run_xxl() {
+  SUPASCHEMA_COMPARE_XXL_TABLES=2500 SUPASCHEMA_COMPARE_FIXTURES=xxl SUPASCHEMA_COMPARE_ITERATIONS=1 \
+    SUPASCHEMA_COMPARE_PORT_BASE=58400 \
+    SUPASCHEMA_COMPARE_OUT=benchmarks/results/comparison-xxl.json node benchmarks/compare.js >/dev/null
+  echo "DONE xxl"
+}
+
+if [ "${BENCH_ALL_SEQUENTIAL:-0}" = "1" ]; then
+  run_small
+  run_realistic
+  run_xl
+  run_xxl
+else
+  run_small &
+  run_realistic &
+  run_xl &
+  run_xxl &
+  wait
+fi
+
+node benchmarks/plot.js benchmarks/results/comparison.json benchmarks/results/comparison-realistic.json \
+  benchmarks/results/comparison-xl.json benchmarks/results/comparison-xxl.json >/dev/null
+cp benchmarks/results/*-latency.svg benchmarks/results/*-correctness.svg docs/benchmarks/
+echo "DONE plot-and-charts"

package/benchmarks/tools/build-project-fixture.mjs

@@ -0,0 +1,245 @@
+#!/usr/bin/env node
+import { execFileSync } from "node:child_process";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { Client } from "pg";
+
+const here = dirname(fileURLToPath(import.meta.url));
+const packageRoot = resolve(here, "../..");
+const { resolveDatabaseUrl } = await import(join(packageRoot, "dist/database-url.js"));
+const { extractObjectsFromSql } = await import(join(packageRoot, "dist/sql/extract.js"));
+const { splitSqlStatements } = await import(join(packageRoot, "dist/sql/split.js"));
+
+const usage =
+  "usage: node benchmarks/tools/build-project-fixture.mjs --tree <schemas dir> --out <fixture dir> [--database-url <admin url>]";
+
+const args = parseArgs(process.argv.slice(2));
+const treeRoot = resolve(args.tree ?? "supabase/schemas");
+const outDir = resolve(args.out ?? "benchmarks/fixtures/project");
+const databaseUrl = resolveDatabaseUrl(args["database-url"]);
+if (!databaseUrl) {
+  fail(
+    `${usage}\nno database URL: pass --database-url, set SUPASCHEMA_DATABASE_URL, or run near supabase/config.toml`,
+  );
+}
+
+const phases = [
+  "schema",
+  "types",
+  "tables",
+  "constraints",
+  "functions",
+  "views",
+  "triggers",
+  "policies",
+];
+
+const authStub = `
+CREATE SCHEMA IF NOT EXISTS auth;
+CREATE TABLE IF NOT EXISTS auth.users (
+  id uuid PRIMARY KEY,
+  email text,
+  raw_app_meta_data jsonb,
+  raw_user_meta_data jsonb,
+  created_at timestamptz DEFAULT now()
+);
+CREATE OR REPLACE FUNCTION auth.uid() RETURNS uuid LANGUAGE sql STABLE AS $$
+  SELECT nullif(current_setting('request.jwt.claim.sub', true), '')::uuid
+$$;
+CREATE OR REPLACE FUNCTION auth.role() RETURNS text LANGUAGE sql STABLE AS $$
+  SELECT coalesce(nullif(current_setting('request.jwt.claim.role', true), ''), 'anon')
+$$;
+CREATE OR REPLACE FUNCTION auth.jwt() RETURNS jsonb LANGUAGE sql STABLE AS $$
+  SELECT coalesce(nullif(current_setting('request.jwt.claims', true), ''), '{}')::jsonb
+$$;
+CREATE OR REPLACE FUNCTION auth.email() RETURNS text LANGUAGE sql STABLE AS $$
+  SELECT nullif(current_setting('request.jwt.claim.email', true), '')
+$$;
+`;
+
+const changeSet = `
+CREATE TABLE IF NOT EXISTS public.supaschema_benchmark_probe (
+  id bigint GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,
+  label text NOT NULL,
+  recorded_at timestamptz NOT NULL DEFAULT now()
+);
+CREATE INDEX IF NOT EXISTS supaschema_benchmark_probe_label_idx
+  ON public.supaschema_benchmark_probe (label);
+COMMENT ON TABLE public.supaschema_benchmark_probe IS 'supaschema benchmark change-set probe';
+CREATE OR REPLACE VIEW public.supaschema_benchmark_probe_view AS
+  SELECT id, label FROM public.supaschema_benchmark_probe WHERE id > 0;
+`;
+
+const files = orderedTreeFiles(treeRoot);
+process.stdout.write(`tree files: ${files.length}\n`);
+const rawSql = files.map((file) => readFileSync(file, "utf8")).join("\n");
+const statements = [...splitSqlStatements(authStub), ...splitSqlStatements(rawSql)];
+process.stdout.write(`statements (with auth stub): ${statements.length}\n`);
+
+const firstPass = await fixpointApply(statements);
+const dropped = [...firstPass.dropped];
+process.stdout.write(
+  `single-pass ordering: ${firstPass.ordered.length} statements; dropped: ${dropped.length}\n`,
+);
+
+// Scope the fixture to supaschema's supported DDL surface so every engine in
+// the comparison diffs the same schema. Statements supaschema fails closed on
+// (FDW objects, DO blocks, unmodeled ALTER subtypes, duplicate object
+// identities such as two partial REVOKEs for one grantee) are excluded and
+// logged, then the fixpoint re-runs so dependents drop with them.
+const kept = [];
+const seenKeys = new Set();
+let excluded = 0;
+for (const statement of firstPass.ordered) {
+  const extraction = await extractObjectsFromSql(statement, { config: { adapter: "postgres" } });
+  if (extraction.diagnostics.some((item) => item.severity === "error")) {
+    dropped.push({ error: "supaschema support-matrix exclusion", sql: statement });
+    excluded += 1;
+    continue;
+  }
+  const duplicate = extraction.objects.find((object) => seenKeys.has(object.key));
+  if (duplicate) {
+    dropped.push({ error: `duplicate object identity ${duplicate.key}`, sql: statement });
+    excluded += 1;
+    continue;
+  }
+  for (const object of extraction.objects) {
+    seenKeys.add(object.key);
+  }
+  kept.push(statement);
+}
+process.stdout.write(`support-surface filter: excluded ${excluded} statements\n`);
+let ordered = kept;
+if (excluded > 0) {
+  const secondPass = await fixpointApply(kept);
+  ordered = secondPass.ordered;
+  dropped.push(
+    ...secondPass.dropped.map((entry) => ({
+      error: `orphaned by support-surface filter: ${entry.error}`,
+      sql: entry.sql,
+    })),
+  );
+  process.stdout.write(
+    `post-filter ordering: ${ordered.length} statements; orphaned dependents dropped: ${secondPass.dropped.length}\n`,
+  );
+}
+
+async function fixpointApply(inputStatements) {
+  const admin = new Client({ connectionString: databaseUrl });
+  await admin.connect();
+  const probeDb = `supa_fixture_build_${process.pid}`;
+  await admin.query(`DROP DATABASE IF EXISTS ${probeDb} WITH (FORCE)`);
+  await admin.query(`CREATE DATABASE ${probeDb}`);
+  const probeUrl = new URL(databaseUrl);
+  probeUrl.pathname = `/${probeDb}`;
+  const applied = [];
+  const failed = [];
+  try {
+    const client = new Client({ connectionString: probeUrl.toString() });
+    await client.connect();
+    try {
+      let pending = inputStatements.map((sql) => ({ error: "", sql }));
+      for (let pass = 0; pending.length > 0; pass += 1) {
+        const next = [];
+        for (const entry of pending) {
+          try {
+            await client.query(entry.sql);
+            applied.push(entry.sql);
+          } catch (error) {
+            next.push({ error: error.message, sql: entry.sql });
+          }
+        }
+        if (next.length === pending.length) {
+          failed.push(...next);
+          break;
+        }
+        pending = next;
+        process.stdout.write(
+          `pass ${pass + 1}: ${applied.length} applied, ${pending.length} pending\n`,
+        );
+      }
+    } finally {
+      await client.end();
+    }
+  } finally {
+    await admin.query(`DROP DATABASE IF EXISTS ${probeDb} WITH (FORCE)`);
+    await admin.end();
+  }
+  return { dropped: failed, ordered: applied };
+}
+const droppedClasses = new Map();
+for (const entry of dropped) {
+  const key = entry.error.slice(0, 70);
+  droppedClasses.set(key, (droppedClasses.get(key) ?? 0) + 1);
+}
+for (const [message, count] of [...droppedClasses.entries()].sort((a, b) => b[1] - a[1])) {
+  process.stdout.write(`  dropped ${String(count).padStart(4)} | ${message}\n`);
+}
+
+const fromSql = `${ordered.join(";\n")};\n`;
+const toSql = `${fromSql}\n${changeSet.trim()}\n`;
+mkdirSync(outDir, { recursive: true });
+writeFileSync(join(outDir, "from.sql"), fromSql);
+writeFileSync(join(outDir, "to.sql"), toSql);
+writeFileSync(
+  join(outDir, "fixture.json"),
+  `${JSON.stringify({ supaschemaAdapter: "postgres", schemas: treeSchemas(fromSql) }, null, 2)}\n`,
+);
+writeFileSync(
+  join(outDir, "dropped.log"),
+  dropped.map((entry) => `-- ${entry.error}\n${entry.sql};\n`).join("\n"),
+);
+process.stdout.write(`fixture written to ${outDir}\n`);
+
+function orderedTreeFiles(root) {
+  const list = (predicate) =>
+    execFileSync("find", [root, "-name", "*.sql"], { encoding: "utf8" })
+      .trim()
+      .split("\n")
+      .filter(Boolean)
+      .filter(predicate)
+      .sort();
+  const bootstrap = list((file) => file.includes("_bootstrap"));
+  const phased = phases.flatMap((phase) =>
+    list((file) => !file.includes("_bootstrap") && file.endsWith(`/${phase}.sql`)),
+  );
+  const phaseNames = new Set(phases.map((phase) => `${phase}.sql`));
+  const remainder = list(
+    (file) => !file.includes("_bootstrap") && !phaseNames.has(file.split("/").at(-1) ?? ""),
+  );
+  return [...bootstrap, ...phased, ...remainder];
+}
+
+function treeSchemas(sql) {
+  // `public` always exists and is never CREATE'd, but project objects (and
+  // the benchmark change set) live there.
+  const names = new Set(["public"]);
+  for (const statement of splitSqlStatements(sql)) {
+    const trimmed = statement.replace(/^CREATE SCHEMA (?:IF NOT EXISTS )?/i, "");
+    if (trimmed !== statement) {
+      const name = trimmed.split(/\s/)[0]?.replaceAll('"', "");
+      if (name && !["auth", "extensions", "vault", "graphql", "graphql_public"].includes(name)) {
+        names.add(name);
+      }
+    }
+  }
+  return [...names].sort();
+}
+
+function parseArgs(argv) {
+  const parsed = {};
+  for (let index = 0; index < argv.length; index += 1) {
+    const key = argv[index];
+    if (key?.startsWith("--")) {
+      parsed[key.slice(2)] = argv[index + 1];
+      index += 1;
+    }
+  }
+  return parsed;
+}
+
+function fail(message) {
+  process.stderr.write(`${message}\n`);
+  process.exit(1);
+}

package/benchmarks/tools/compare-db.mjs

@@ -0,0 +1,101 @@
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { Client } from "pg";
+
+const here = dirname(fileURLToPath(import.meta.url));
+const packageRoot = resolve(here, "../..");
+const { quoteIdent } = await import(join(packageRoot, "dist/sql/identifiers.js"));
+const dbAdmin = await import(join(packageRoot, "dist/db-admin.js"));
+
+export const {
+  applyMigrationSql,
+  applySql,
+  assertLocalDatabaseUrl,
+  databaseUrlWithDatabase,
+  dropTemporaryDatabases,
+} = dbAdmin;
+
+export async function createTemporaryDatabases(adminUrl, count, templateName) {
+  return dbAdmin.createTemporaryDatabases(adminUrl, count, {
+    purpose: "compare",
+    ...(templateName ? { templateName } : {}),
+  });
+}
+
+export async function catalogFingerprint(url) {
+  return dbAdmin.catalogFingerprint(url, "bench:catalog");
+}
+
+// The Supabase CLI's diff engines silently omit objects owned by
+// supabase_admin (empty diff, exit 0). After seeding as the admin (which
+// extension creation requires), hand every user-schema object to `role` so
+// the engines can see them.
+export async function transferOwnership(url, role) {
+  const client = new Client({ connectionString: url });
+  const owner = quoteIdent(role);
+  try {
+    await client.connect();
+    const schemas = await client.query(
+      "select nspname from pg_namespace where nspname !~ '^pg_' and nspname not in ('information_schema', 'extensions', 'vault') order by nspname",
+    );
+    for (const { nspname } of schemas.rows) {
+      await client.query(`ALTER SCHEMA ${quoteIdent(nspname)} OWNER TO ${owner}`);
+    }
+    const relations = await client.query(`
+      select n.nspname, c.relname, c.relkind
+      from pg_class c
+      join pg_namespace n on n.oid = c.relnamespace
+      where n.nspname !~ '^pg_' and n.nspname not in ('information_schema', 'extensions', 'vault')
+        and c.relkind in ('r', 'p', 'S', 'v', 'm', 'f')
+        and not exists (select 1 from pg_depend d where d.objid = c.oid and d.deptype in ('e', 'i'))
+      order by n.nspname, c.relname
+    `);
+    const relationKinds = new Map([
+      ["S", "SEQUENCE"],
+      ["f", "FOREIGN TABLE"],
+      ["m", "MATERIALIZED VIEW"],
+      ["p", "TABLE"],
+      ["r", "TABLE"],
+      ["v", "VIEW"],
+    ]);
+    for (const row of relations.rows) {
+      const kind = relationKinds.get(row.relkind);
+      await client.query(
+        `ALTER ${kind} ${quoteIdent(row.nspname)}.${quoteIdent(row.relname)} OWNER TO ${owner}`,
+      );
+    }
+    const routines = await client.query(`
+      select n.nspname, p.proname, p.prokind,
+             pg_get_function_identity_arguments(p.oid) as args
+      from pg_proc p
+      join pg_namespace n on n.oid = p.pronamespace
+      where n.nspname !~ '^pg_' and n.nspname not in ('information_schema', 'extensions', 'vault')
+        and p.prokind in ('f', 'p')
+        and not exists (select 1 from pg_depend d where d.objid = p.oid and d.deptype in ('e', 'i'))
+      order by n.nspname, p.proname
+    `);
+    for (const row of routines.rows) {
+      const kind = row.prokind === "p" ? "PROCEDURE" : "FUNCTION";
+      await client.query(
+        `ALTER ${kind} ${quoteIdent(row.nspname)}.${quoteIdent(row.proname)}(${row.args}) OWNER TO ${owner}`,
+      );
+    }
+    const types = await client.query(`
+      select n.nspname, t.typname, t.typtype
+      from pg_type t
+      join pg_namespace n on n.oid = t.typnamespace
+      where n.nspname !~ '^pg_' and n.nspname not in ('information_schema', 'extensions', 'vault')
+        and t.typtype in ('e', 'd')
+        and not exists (select 1 from pg_depend d where d.objid = t.oid and d.deptype in ('e', 'i'))
+      order by n.nspname, t.typname
+    `);
+    for (const row of types.rows) {
+      const kind = row.typtype === "d" ? "DOMAIN" : "TYPE";
+      await client.query(
+        `ALTER ${kind} ${quoteIdent(row.nspname)}.${quoteIdent(row.typname)} OWNER TO ${owner}`,
+      );
+    }
+  } finally {
+    await client.end().catch(() => undefined);
+  }
+}

package/benchmarks/tools/compare-fixtures.mjs

@@ -0,0 +1,84 @@
+import { mkdir, readdir, readFile, writeFile } from "node:fs/promises";
+import { basename, dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const here = dirname(fileURLToPath(import.meta.url));
+const packageRoot = resolve(here, "../..");
+const { makeRealisticSqlFixture, realisticFixtureManifest } = await import(
+  join(packageRoot, "dist/benchmark-fixtures.js")
+);
+
+export async function discoverFixtures(fixtureRoot) {
+  const entries = await readdir(fixtureRoot, { withFileTypes: true });
+  const fixtures = [];
+  for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
+    if (!entry.isDirectory()) {
+      continue;
+    }
+    fixtures.push(await fixtureFromDirectory(join(fixtureRoot, entry.name), entry.name));
+  }
+
+  const extraDirs = (process.env.SUPASCHEMA_COMPARE_FIXTURE_DIRS ?? "")
+    .split(/[,:]/)
+    .map((value) => value.trim())
+    .filter(Boolean);
+  for (const directory of extraDirs) {
+    fixtures.push(await fixtureFromDirectory(resolve(directory), basename(resolve(directory))));
+  }
+  return fixtures;
+}
+
+async function fixtureFromDirectory(directory, name) {
+  const fixture = {
+    directory,
+    fromSqlPath: join(directory, "from.sql"),
+    name,
+    toDirectory: directory,
+    toSqlPath: join(directory, "to.sql"),
+  };
+  try {
+    const config = JSON.parse(await readFile(join(directory, "fixture.json"), "utf8"));
+    if (Array.isArray(config.schemas) && config.schemas.length > 0) {
+      fixture.schemas = config.schemas.map(String);
+    }
+    if (typeof config.supaschemaAdapter === "string") {
+      fixture.supaschemaAdapter = config.supaschemaAdapter;
+    }
+  } catch {}
+  try {
+    const manifest = JSON.parse(await readFile(join(directory, "manifest.json"), "utf8"));
+    if (Array.isArray(manifest)) {
+      fixture.manifest = manifest;
+    }
+  } catch {}
+  return fixture;
+}
+
+export async function materializeGeneratedFixtures(tempRoot, xlTables, xxlTables = 0) {
+  const generated = [{ name: "realistic", tableCount: 50 }];
+  if (xlTables > 0) {
+    generated.push({ name: "xl", tableCount: xlTables });
+  }
+  if (xxlTables > 0) {
+    generated.push({ name: "xxl", tableCount: xxlTables });
+  }
+  const fixtures = [];
+  for (const { name, tableCount } of generated) {
+    const directory = join(tempRoot, `${name}-fixture`);
+    await mkdir(directory, { recursive: true });
+    const sql = makeRealisticSqlFixture(tableCount);
+    const fromSqlPath = join(directory, "from.sql");
+    const toSqlPath = join(directory, "to.sql");
+    await writeFile(fromSqlPath, sql.from, "utf8");
+    await writeFile(toSqlPath, sql.to, "utf8");
+    fixtures.push({
+      directory,
+      fromSqlPath,
+      manifest: realisticFixtureManifest(tableCount),
+      name,
+      toDirectory: directory,
+      toSqlPath,
+    });
+  }
+  return fixtures;
+}