dzql 0.7.0 → 0.9.0

package/src/postgres/cli.ts

@@ -0,0 +1,339 @@
+#!/usr/bin/env bun
+/**
+ * dzql's Postgres commands, as delta's CLI had them: `dzql sql`, `dzql init`
+ * and `dzql migrate` (a postgres:// URL or a PGlite directory). Run through
+ * `dzql <command>` (src/cli/index.ts hands these three here).
+ */
+import { parseArgs } from "node:util";
+import { resolve, basename, join, dirname } from "node:path";
+import { mkdirSync, copyFileSync, existsSync, readFileSync, writeFileSync, statSync } from "node:fs";
+import { generateSql } from "./codegen";
+import { frameworkSqlFiles } from "./bootstrap";
+import { authJwtSqlFile } from "./auth-jwt-sql";
+import type { Schema, DocDef } from "./index";
+
+const PKG_VERSION = (() => {
+  try {
+    return String(JSON.parse(readFileSync(join(import.meta.dir, "..", "..", "package.json"), "utf8")).version ?? "0.0.0");
+  } catch {
+    return "0.0.0";
+  }
+})();
+
+const USAGE =
+    `Usage:\n` +
+    `  dzql sql <module> [--out <file>] [--force] [--schema-export <name>] [--docs-export <name>]\n` +
+    `  dzql init <dir> [--with-auth] [--upgrade]\n` +
+    `  dzql migrate <database> [--app <name>] [--dir <migrations>] [--status] [--json]\n` +
+    `        <database>: a PGlite directory or a postgres:// URL; --dir defaults to ./migrations\n` +
+    `\n` +
+    `Exit codes: 0 done, 1 an error, 2 a bad argument.\n`;
+
+let json = process.argv.includes("--json");
+
+const print = (result: unknown) => process.stdout.write(JSON.stringify(result ?? null, null, json ? undefined : 2) + "\n");
+
+function fail(err: unknown, exit = 1): never {
+  const error = { code: 0, message: err instanceof Error ? err.message : String(err) };
+  process.stderr.write((json ? JSON.stringify({ error }) : `dzql: ${error.message}`) + "\n");
+  process.exit(exit);
+}
+
+function usageError(why: string, show = false): never {
+  if (show && !json) process.stderr.write(USAGE + "\n");
+  fail(why, 2);
+}
+
+// ---------------------------------------------------------------------------
+// Header handling — identifies files written by dzql init (stamped with this
+// package's version) so upgrades can read them back and avoid clobbering
+// user-owned SQL, and a `diff -u` against a later `init --upgrade` shows what changed.
+// ---------------------------------------------------------------------------
+
+// a file `delta init` vendored (stamped @blueshed/delta) is older than any of dzql's: always upgraded
+const HEADER_RE = /^-- @blueshed\/(delta|dzql) ([a-z0-9-]+) v(\d+\.\d+\.\d+)/;
+
+function readHeader(path: string): { pkg: string; kind: string; version: string } | null {
+  if (!existsSync(path)) return null;
+  const first = readFileSync(path, "utf8").split("\n", 1)[0] ?? "";
+  const m = first.match(HEADER_RE);
+  return m ? { pkg: m[1]!, kind: m[2]!, version: m[3]! } : null;
+}
+
+function writeWithHeader(src: string, dest: string, kind: "framework" | "auth-jwt"): void {
+  const header =
+    `-- @blueshed/dzql ${kind} v${PKG_VERSION}\n` +
+    `-- Vendored by 'dzql init'. Safe to read; prefer 'dzql init --upgrade' over hand edits.\n\n`;
+  writeFileSync(dest, header + readFileSync(src, "utf8"));
+}
+
+/**
+ * Back up `dest` to `dest + ".bak"` without destroying a pre-existing backup.
+ * If `dest.bak` already exists, fall back to `.bak.1`, `.bak.2`, … so an
+ * earlier backup the user may still need is preserved. Returns the path the
+ * backup was written to.
+ */
+function backupFile(dest: string): string {
+  let bak = dest + ".bak";
+  if (existsSync(bak)) {
+    let n = 1;
+    while (existsSync(`${dest}.bak.${n}`)) n++;
+    bak = `${dest}.bak.${n}`;
+    process.stderr.write(
+      `Note: ${basename(dest)}.bak already exists; backing up to ${basename(bak)} instead.\n`,
+    );
+  }
+  copyFileSync(dest, bak);
+  return bak;
+}
+
+// ---------------------------------------------------------------------------
+// dzql sql
+// ---------------------------------------------------------------------------
+
+// Stable substring of the codegen header (see codegen.ts:
+// "GENERATED FROM types.ts — DO NOT EDIT"). Matching on the leading words
+// avoids depending on the em-dash byte sequence.
+const GENERATED_MARKER = "GENERATED FROM";
+
+async function cmdSql(modulePath: string | undefined, values: Record<string, unknown>) {
+  if (!modulePath) usageError("sql takes a <module>", true);
+
+  const abs = resolve(process.cwd(), modulePath);
+  let mod: Record<string, unknown>;
+  try {
+    mod = await import(abs);
+  } catch (err) {
+    // Bun surfaces a `ResolveMessage` whose `.message` is a single useful line
+    // (e.g. "Cannot find module '…'") but is fronted by the class-name prefix;
+    // strip it to a clean one-liner instead of dumping the raw object/stack.
+    const raw =
+      err instanceof Error ? err.message.split("\n", 1)[0] : String(err);
+    const reason = raw.replace(/^(ResolveMessage|BuildMessage|Error):\s*/, "");
+    process.stderr.write(`Cannot load module "${modulePath}": ${reason}\n`);
+    process.exit(2);
+  }
+
+  const schemaExport = values["schema-export"] as string;
+  const docsExport = values["docs-export"] as string;
+  const schema = mod[schemaExport] as Schema | undefined;
+  const docs = mod[docsExport] as DocDef[] | undefined;
+
+  if (!schema || typeof schema !== "object" || !("tables" in schema)) {
+    process.stderr.write(
+      `Module at ${modulePath} does not export a Schema as \`${schemaExport}\`.\n` +
+      `Export one with: export const ${schemaExport} = defineSchema({ ... });\n`,
+    );
+    process.exit(2);
+  }
+  if (!Array.isArray(docs)) {
+    process.stderr.write(
+      `Module at ${modulePath} does not export a DocDef[] as \`${docsExport}\`.\n` +
+      `Export one with: export const ${docsExport} = [defineDoc(...), ...];\n`,
+    );
+    process.exit(2);
+  }
+
+  const sql = generateSql(schema, docs);
+  const out = values.out as string | undefined;
+  const force = !!values.force;
+
+  if (out) {
+    const absOut = resolve(out);
+    // Guard: never silently clobber a file we didn't generate. A previously
+    // generated file carries the codegen header marker and is safe to replace;
+    // anything else needs --force.
+    if (existsSync(absOut) && !force) {
+      const existing = readFileSync(absOut, "utf8");
+      if (!existing.includes(GENERATED_MARKER)) {
+        process.stderr.write(
+          `Refusing to overwrite ${out}: it has no generated-file header ` +
+          `(not produced by 'dzql sql').\n` +
+          `Pass --force to overwrite it anyway.\n`,
+        );
+        process.exit(3);
+      }
+      // It's a previously generated file — back it up before replacing.
+      backupFile(absOut);
+    }
+    mkdirSync(dirname(absOut), { recursive: true });
+    await Bun.write(out, sql);
+    process.stderr.write(`Wrote ${out} (${sql.length} bytes)\n`);
+  } else {
+    process.stdout.write(sql);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// dzql init
+// ---------------------------------------------------------------------------
+
+function cmdInit(dir: string | undefined, values: Record<string, unknown>) {
+  if (!dir) usageError("init takes a <dir>", true);
+
+  const absDir = resolve(process.cwd(), dir);
+  mkdirSync(absDir, { recursive: true });
+
+  const upgrade = !!values.upgrade;
+  const plan: { src: string; dest: string; kind: "framework" | "auth-jwt" }[] =
+    frameworkSqlFiles().map((src) => ({ src, dest: join(absDir, basename(src)), kind: "framework" }));
+  if (values["with-auth"]) plan.push({ src: authJwtSqlFile(), dest: join(absDir, "002-users.sql"), kind: "auth-jwt" });
+
+  // On upgrade we refuse to clobber files that don't have our header or that
+  // point to a newer version than we ship. The user either wrote that file
+  // themselves or has downgraded the package.
+  if (upgrade) {
+    const conflicts: string[] = [];
+    for (const { dest } of plan) {
+      if (!existsSync(dest)) continue;
+      const hdr = readHeader(dest);
+      if (!hdr) conflicts.push(`${basename(dest)}: not stamped by dzql init (or delta init)`);
+      else if (hdr.pkg === "dzql" && compareVersion(hdr.version, PKG_VERSION) > 0) {
+        conflicts.push(`${basename(dest)}: has v${hdr.version}, package is v${PKG_VERSION}`);
+      }
+    }
+    if (conflicts.length) {
+      process.stderr.write(
+        `Refusing to upgrade:\n  ${conflicts.join("\n  ")}\n\n` +
+        `Resolve these manually (move or rename the offending files) and rerun.\n`,
+      );
+      process.exit(3);
+    }
+  }
+
+  const created: string[] = [];
+  const upgraded: string[] = [];
+  const unchanged: string[] = [];
+
+  for (const { src, dest, kind } of plan) {
+    if (existsSync(dest)) {
+      const hdr = readHeader(dest);
+      if (!upgrade || (hdr?.pkg === "dzql" && hdr.version === PKG_VERSION)) {
+        unchanged.push(basename(dest));
+        continue;
+      }
+      const bak = backupFile(dest);
+      writeWithHeader(src, dest, kind);
+      upgraded.push(`${basename(dest)} (backup at ${basename(bak)})`);
+    } else {
+      writeWithHeader(src, dest, kind);
+      created.push(basename(dest));
+    }
+  }
+
+  const lines: string[] = [];
+  if (created.length) lines.push("Created:\n  " + created.join("\n  "));
+  if (upgraded.length) lines.push("Upgraded:\n  " + upgraded.join("\n  "));
+  if (unchanged.length) lines.push("Unchanged:\n  " + unchanged.join("\n  "));
+  process.stderr.write((lines.join("\n\n") || "Nothing to do.") + "\n");
+
+  if (created.length || upgraded.length) {
+    process.stderr.write(
+      `\nNext: regenerate your table SQL from types.ts:\n` +
+      `  bunx dzql sql ./types.ts --out ${dir}/003-tables.sql\n`,
+    );
+  }
+}
+
+function compareVersion(a: string, b: string): number {
+  const pa = a.split(".").map(Number);
+  const pb = b.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    const d = (pa[i] ?? 0) - (pb[i] ?? 0);
+    if (d !== 0) return d;
+  }
+  return 0;
+}
+
+// ---------------------------------------------------------------------------
+// dzql migrate
+// ---------------------------------------------------------------------------
+
+/**
+ * Run an app's migrations (`--dir`, default ./migrations, each `NNN-name.ts`
+ * exporting `up`; `--app` names the app when apps share the database) against
+ * its database, or with --status say which ran and which are pending. With no
+ * schema to ask, an app with nothing recorded is new only to a database with
+ * no table but delta's: the app's own start-up, given its schema, knows better.
+ * The database: a postgres:// URL or a PGlite directory that is there (a name
+ * mistyped makes no new database). A SQLite file is delta's own command.
+ */
+async function cmdMigrate(target: string | undefined, values: Record<string, unknown>) {
+  if (!target) usageError("migrate takes a <database>: a PGlite directory or a postgres:// URL", true);
+  const { setLogLevel } = await import("@blueshed/delta/logger");
+  setLogLevel(json ? "silent" : "warn");
+  const dir = resolve(process.cwd(), (values.dir as string | undefined) ?? "migrations");
+  const status = !!values.status;
+  const options = { app: (values.app as string | undefined) ?? "" };
+  const isUrl = /^postgres(ql)?:\/\//.test(target);
+  const path = resolve(process.cwd(), target);
+  if (!isUrl && (!existsSync(path) || !statSync(path).isDirectory())) usageError(`no PGlite database at ${target} (a SQLite file is delta's: bunx @blueshed/delta migrate)`);
+  if (!existsSync(dir)) usageError(`no migrations folder at ${dir} (--dir)`);
+
+  let answer: unknown;
+  const pg = await import("./migrate");
+  let pool: any;
+  if (isUrl) {
+    const { Pool } = await import("pg");
+    pool = new Pool({ connectionString: target });
+  } else {
+    const { openPglite } = await import("./pglite");
+    pool = await openPglite(path);
+  }
+  try {
+    const list = await pg.fromFolder(dir);
+    answer = status ? await pg.migrationStatus(pool, list, options) : await pg.migrate(pool, list, options);
+  } finally { await pool.end(); }
+  if (json) return print(answer);
+  if (status) {
+    const s = answer as import("@blueshed/delta/backend").MigrationStatus;
+    if (s.fresh) process.stdout.write("new database: migrate records every migration as run, and runs none\n");
+    for (const r of s.ran) process.stdout.write(`ran      ${r.id}  ${r.ran_at}\n`);
+    for (const id of s.pending) process.stdout.write(`pending  ${id}\n`);
+    for (const id of s.unknown) process.stdout.write(`unknown  ${id}  (ran here, not in ${dir})\n`);
+    return;
+  }
+  const r = answer as import("@blueshed/delta/backend").MigrateResult;
+  if (r.fresh) process.stdout.write("new database: every migration recorded as run, none run\n");
+  for (const id of r.ran) process.stdout.write(`ran      ${id}\n`);
+  if (!r.fresh && r.ran.length === 0) process.stdout.write("nothing to run\n");
+}
+
+// ---------------------------------------------------------------------------
+// main
+// ---------------------------------------------------------------------------
+
+export async function main(argv: string[]) {
+  let parsed;
+  try { parsed = parseArgs({
+    args: argv,
+    options: {
+      out: { type: "string", short: "o" },
+      force: { type: "boolean", default: false },
+      "schema-export": { type: "string", default: "schema" },
+      "docs-export": { type: "string", default: "docs" },
+      "with-auth": { type: "boolean", default: false },
+      upgrade: { type: "boolean", default: false },
+      json: { type: "boolean", default: false },
+      dir: { type: "string" },
+      app: { type: "string" },
+      status: { type: "boolean", default: false },
+      help: { type: "boolean", short: "h", default: false },
+    },
+    allowPositionals: true,
+    strict: true,
+  }); }
+  catch (err) { usageError((err as Error).message, true); }
+  const { values, positionals } = parsed;
+  json = !!values.json;
+  if (values.help) { process.stdout.write(USAGE); return; }
+  const [cmd, arg] = positionals;
+  switch (cmd) {
+    case "sql":     return cmdSql(arg, values);
+    case "init":    return cmdInit(arg, values);
+    case "migrate": return cmdMigrate(arg, values);
+    default:        usageError(cmd ? `no command ${cmd}` : "a command, please", true);
+  }
+}
+
+if (import.meta.main) main(process.argv.slice(2)).catch((err) => fail(err));

package/src/postgres/codegen.ts

@@ -0,0 +1,175 @@
+/**
+ * Codegen — turn a TypeScript schema (`defineSchema`) and a set of doc
+ * definitions (`defineDoc`) into the SQL that registers both with the
+ * delta-doc framework.
+ *
+ * Output includes:
+ *   - CREATE SEQUENCE / CREATE TABLE (+ current_* view for temporal tables)
+ *   - Helper indexes
+ *   - INSERT INTO _delta_collections (columns_def, parent, temporal, cascade_on)
+ *   - INSERT INTO _delta_docs       (prefix, root_collection, include, scope)
+ *
+ * Everything is idempotent (CREATE … IF NOT EXISTS, ON CONFLICT DO UPDATE),
+ * so the same file can be re-applied to a live database after a schema change.
+ *
+ * Drive it from your project's `types.ts`:
+ *
+ *   import { generateSql } from "@blueshed/delta/postgres";
+ *   import { schema, docs } from "./types";
+ *   await Bun.write("init_db/003-tables.sql", generateSql(schema, docs));
+ *
+ * Or from the bundled CLI:
+ *
+ *   bunx delta sql ./types.ts --out init_db/003-tables.sql
+ */
+import type { Schema, DocDef } from "./schema";
+import { lit, columnSqlType, sqlDefault, findCascadeOn } from "./sql";
+import { defaultForType, q } from "@blueshed/delta/backend";
+import { assertScopeKeys } from "@blueshed/delta/backend";
+import { compileOpens } from "../compile/opens";
+
+export interface GenerateSqlOptions {
+  /** Header comment included at the top of the file. */
+  header?: string;
+  /** Override the regenerate-command hint printed in the header. */
+  regenerate?: string;
+}
+
+export function generateSql(
+  schema: Schema,
+  docs: DocDef[],
+  opts: GenerateSqlOptions = {},
+): string {
+  const today = new Date().toISOString().slice(0, 10);
+  const header =
+    opts.header ?? "GENERATED FROM types.ts — DO NOT EDIT";
+  const regen = opts.regenerate ?? "bunx delta sql ./types.ts";
+
+  const lines: string[] = [
+    "-- =========================================================================",
+    `-- ${header}`,
+    `-- Generated: ${today}`,
+    `-- Regenerate: ${regen}`,
+    "-- =========================================================================",
+    "",
+  ];
+
+  for (const [key, table] of Object.entries(schema.tables)) {
+    const seqName = `seq_${table.name}`;
+    lines.push(`-- ${key}`);
+    lines.push(`CREATE SEQUENCE IF NOT EXISTS ${q(seqName)};`);
+    lines.push("");
+
+    const cols: string[] = [
+      `id BIGINT NOT NULL DEFAULT nextval(${lit(seqName)})`,
+    ];
+    if (table.parent) {
+      cols.push(`${q(table.parent.fkColumn)} BIGINT NOT NULL`);
+    }
+
+    for (const [col, def] of Object.entries(table.columns)) {
+      const sqlType = columnSqlType(def);
+      const notNull = def.nullable ? "" : " NOT NULL";
+      const defaultVal =
+        def.default !== undefined ? ` DEFAULT ${sqlDefault(def.default)}` : "";
+      cols.push(`${q(col)} ${sqlType}${notNull}${defaultVal}`);
+    }
+
+    if (table.temporal) {
+      cols.push("valid_from TIMESTAMPTZ NOT NULL DEFAULT NOW()");
+      cols.push("valid_to TIMESTAMPTZ");
+      cols.push("PRIMARY KEY (id, valid_from)");
+    } else {
+      cols.push("PRIMARY KEY (id)");
+    }
+
+    lines.push(`CREATE TABLE IF NOT EXISTS ${q(table.name)} (`);
+    lines.push(cols.map((c) => `  ${c}`).join(",\n"));
+    lines.push(");");
+    // A column a later schema declares, added to a table made before it (SQLite's migrateSchema): a
+    // no-op on a table just made. Nullable, with its default or its type's, as migrateSchema adds it.
+    if (table.parent) lines.push(`ALTER TABLE ${q(table.name)} ADD COLUMN IF NOT EXISTS ${q(table.parent.fkColumn)} BIGINT;`);
+    for (const [col, def] of Object.entries(table.columns)) {
+      const fill = def.default !== undefined ? def.default : def.nullable ? undefined : defaultForType(def.type);
+      lines.push(`ALTER TABLE ${q(table.name)} ADD COLUMN IF NOT EXISTS ${q(col)} ${columnSqlType(def)}${fill !== undefined ? ` DEFAULT ${sqlDefault(fill)}` : ""};`);
+    }
+    // Own the sequence to the table.id so `TRUNCATE RESTART IDENTITY`
+    // actually resets the counter — without this, re-seeds in tests and
+    // demo scripts drift by the stale sequence value.
+    lines.push(`ALTER SEQUENCE ${q(seqName)} OWNED BY ${q(table.name)}.id;`);
+
+    if (table.temporal) {
+      // security_invoker (Postgres 15+): the view reads as the caller, so the table's RLS holds through it
+      lines.push(
+        `CREATE OR REPLACE VIEW ${q("current_" + table.name)} WITH (security_invoker = true) AS SELECT * FROM ${q(table.name)} WHERE valid_to IS NULL;`,
+      );
+      lines.push(
+        `CREATE INDEX IF NOT EXISTS ${q("idx_" + table.name + "_id_valid")} ON ${q(table.name)} (id, valid_to);`,
+      );
+    }
+    if (table.parent) {
+      lines.push(
+        `CREATE INDEX IF NOT EXISTS ${q("idx_" + table.name + "_" + table.parent.fkColumn)} ON ${q(table.name)} (${q(table.parent.fkColumn)});`,
+      );
+    }
+    lines.push("");
+  }
+
+  // Collection metadata
+  lines.push("-- Collection metadata");
+  for (const [key, table] of Object.entries(schema.tables)) {
+    const cascadeOn = lit(JSON.stringify(findCascadeOn(key, schema)));
+    const colsDef = lit(JSON.stringify(table.columns));
+    const parent = table.parent ? lit(table.parent.collection) : "NULL";
+    const parentFk = table.parent ? lit(table.parent.fkColumn) : "NULL";
+    lines.push(
+      `INSERT INTO _delta_collections (collection_key, table_name, columns_def, parent_collection, parent_fk, temporal, cascade_on)`,
+    );
+    lines.push(
+      `  VALUES (${lit(key)}, ${lit(table.name)}, ${colsDef}, ${parent}, ${parentFk}, ${table.temporal}, ${cascadeOn})`,
+    );
+    lines.push(
+      `  ON CONFLICT (collection_key) DO UPDATE SET table_name = EXCLUDED.table_name, columns_def = EXCLUDED.columns_def,`,
+    );
+    lines.push(
+      `    parent_collection = EXCLUDED.parent_collection, parent_fk = EXCLUDED.parent_fk, temporal = EXCLUDED.temporal, cascade_on = EXCLUDED.cascade_on;`,
+    );
+  }
+  lines.push("");
+
+  // Doc definitions. `implied` is written when a document is implied (and
+  // then for each, so one that stops being implied is reset), and `held` when
+  // one names its columns (todo #70): SQL for an app with neither needs no
+  // framework SQL newer than it.
+  lines.push("-- Doc definitions");
+  const implied = docs.some((d) => d.implied);
+  const held = docs.some((d) => d.columns);
+  for (const doc of docs) assertScopeKeys(doc, schema);   // its scope's keys and the columns it names are its collections' columns
+  for (const doc of docs) {
+    // Build a proper Postgres text[] array literal: each element is wrapped in
+    // double quotes with embedded `"` and `\` backslash-escaped, so a comma or
+    // quote inside a collection key can't corrupt the array.
+    const include = doc.include.length
+      ? lit(
+          `{${doc.include
+            .map((e) => `"${e.replace(/(["\\])/g, "\\$1")}"`)
+            .join(",")}}`,
+        )
+      : "'{}'";
+    const scope = lit(JSON.stringify(doc.scope));
+    lines.push(
+      `INSERT INTO _delta_docs (prefix, root_collection, include, scope${implied ? ", implied" : ""}${held ? ", held" : ""})`,
+    );
+    lines.push(
+      `  VALUES (${lit(doc.prefix)}, ${lit(doc.root)}, ${include}, ${scope}${implied ? `, ${!!doc.implied}` : ""}${held ? `, ${lit(JSON.stringify(doc.columns ?? {}))}` : ""})`,
+    );
+    lines.push(
+      `  ON CONFLICT (prefix) DO UPDATE SET root_collection = EXCLUDED.root_collection, include = EXCLUDED.include, scope = EXCLUDED.scope${implied ? ", implied = EXCLUDED.implied" : ""}${held ? ", held = EXCLUDED.held" : ""};`,
+    );
+  }
+  lines.push("");
+
+  // each document opened by SQL compiled for it (dzql), which docTypeFromDef calls
+  lines.push("", compileOpens(schema, docs));
+  return lines.join("\n");
+}

package/src/postgres/index.ts

@@ -0,0 +1,58 @@
+/**
+ * @blueshed/delta/postgres — Postgres backend for delta-doc.
+ *
+ * Schema + stored functions + LISTEN dispatch. Tables are generated from
+ * a TypeScript schema definition; all mutations go through stored functions
+ * that apply JSON-Patch ops and emit NOTIFY events. The doc-listener fans
+ * those events out to WebSocket subscribers.
+ *
+ *   import {
+ *     defineSchema, defineDoc,
+ *     createDocListener, docTypeFromDef,
+ *   } from "@blueshed/delta/postgres";
+ *
+ * The stored functions are `src/sql/001*.sql`: `applyFramework(pool)` applies
+ * them, or `bunx @blueshed/delta init <dir>` copies them for a migration tool
+ * (plain idempotent SQL; order is alphabetical).
+ */
+
+export {
+  defineSchema,
+  defineDoc,
+  loadDocAt,
+  pruneOpsLog,
+  validateOps,
+} from "./schema";
+export type {
+  ColumnDef,
+  TableDef,
+  Schema,
+  ResolvedTable,
+  DocDef,
+  ValidationError,
+} from "./schema";
+
+export { generateSql } from "./codegen";
+
+export { exportTables, importTables } from "./carry";
+export type { Snapshot } from "@blueshed/delta/backend";
+export type { GenerateSqlOptions } from "./codegen";
+
+export {
+  applyFramework,
+  applySql,
+  frameworkSqlFiles,
+} from "./bootstrap";
+
+export { migrate, migrationStatus, renameColumn, dropColumn, renameTable, fromFolder } from "./migrate";
+export type { Migration, MigrateOptions, MigrateResult, MigrationStatus } from "./migrate";
+
+export { createDocListener, defineCustomDoc } from "./listener";
+export type { CustomDocDef } from "./listener";
+
+export { docTypeFromDef } from "./registry";
+export type { DocType, Writer } from "./registry";
+
+export { withAppAuth } from "./auth";
+export type { DeltaAuth, AuthError, AuthAction } from "./auth";
+export { isAuthError, wireAuth, upgradeWithAuth } from "./auth";