@coffre/db 0.1.10 → 0.1.12

package/src/baseline.ts

@@ -1,5 +1,5 @@
 import { execFileSync } from 'node:child_process';
-import { readFile, rm, writeFile } from 'node:fs/promises';
+import { readFile } from 'node:fs/promises';
 import { fileURLToPath } from 'node:url';
 
 import {
@@ -15,17 +15,15 @@ import * as postgres from './schema.ts';
 import * as sqlite from './schema.sqlite.ts';
 
 /**
- * coffre has never been deployed, so there is no database to upgrade: each
- * engine has one migration, its baseline, and a schema change regenerates it
- * rather than adding a second. After the first deployment, changes become new
- * migrations and this goes.
+ * Applied migrations are immutable. Schema changes append a migration to
+ * each engine's journal; custom safety checks belong in that new migration.
  *
  * A baseline is baseline/<engine>.sql with its `-- @schema` line replaced by
  * the tables drizzle-kit generates from that engine's schema. The template
  * holds what a schema cannot say: the audit chain's first rows, and the
  * Postgres runtime role and its grants.
  *
- * `pnpm db:generate` runs this file and rewrites the baselines that are stale.
+ * `pnpm db:generate` runs this file and appends pending schema changes.
  */
 
 export const ENGINES: readonly Engine[] = ['postgres', 'sqlite'];
@@ -63,13 +61,13 @@ async function pending(engine: Engine): Promise<string[]> {
   }
 }
 
-/** Why the engine's baseline is out of date: empty when it is not. */
+/** Why the migration tree is out of date: empty when it matches the schema. */
 export async function staleness(engine: Engine): Promise<string[]> {
   const tags = await journal(engine).then(
     (entries) => entries.map((entry) => entry.tag),
     () => [],
   );
-  if (tags.length !== 1 || tags[0] !== TAG) return [`expected only ${TAG}, found [${tags.join(', ')}]`];
+  if (tags[0] !== TAG) return [`expected the immutable ${TAG} first`];
   const reasons = await pending(engine);
   const { head, tail } = await template(engine);
   const baseline = await readFile(`${migrationsFolder(engine)}/${TAG}.sql`, 'utf8');
@@ -77,28 +75,22 @@ export async function staleness(engine: Engine): Promise<string[]> {
   return reasons;
 }
 
-async function regenerate(engine: Engine): Promise<void> {
-  const folder = migrationsFolder(engine);
-  await rm(folder, { recursive: true, force: true });
+function generate(engine: Engine): void {
   execFileSync(
     `${packageRoot}node_modules/.bin/drizzle-kit`,
-    ['generate', '--config', `drizzle.${engine}.config.ts`, '--name', 'baseline'],
+    ['generate', '--config', `drizzle.${engine}.config.ts`, '--name', process.argv[2] ?? 'schema'],
     { cwd: here, stdio: 'inherit' },
   );
-  const tables = (await readFile(`${folder}/${TAG}.sql`, 'utf8')).trimEnd();
-  const breakpoint = tables.endsWith('--> statement-breakpoint') ? '' : '--> statement-breakpoint';
-  const { head, tail } = await template(engine);
-  await writeFile(`${folder}/${TAG}.sql`, `${head}${tables}${breakpoint}\n${tail}`);
 }
 
 if (process.argv[1] === fileURLToPath(import.meta.url)) {
   for (const engine of ENGINES) {
     const reasons = await staleness(engine);
     if (reasons.length === 0) {
-      console.log(`${engine}: the baseline is up to date`);
+      console.log(`${engine}: the migration tree is up to date`);
       continue;
     }
-    console.log(`${engine}: regenerating the baseline (${reasons.length} change${reasons.length === 1 ? '' : 's'})`);
-    await regenerate(engine);
+    console.log(`${engine}: appending a migration (${reasons.length} change${reasons.length === 1 ? '' : 's'})`);
+    generate(engine);
   }
 }

package/src/database.ts

@@ -1,3 +1,5 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+
 import { getTableName, is, Table } from 'drizzle-orm';
 import { drizzle, type NodePgDatabase } from 'drizzle-orm/node-postgres';
 import type pg from 'pg';
@@ -27,8 +29,67 @@ export type PoolLike = pg.Pool | {
   connect: () => Promise<Pick<pg.PoolClient, 'query'> & { release: () => void }>;
 };
 
+/**
+ * A query made on the database from inside one of its own transactions,
+ * rather than through the transaction. With one connection per call, as on
+ * Workers, it would wait for the transaction, which waits for it: a call
+ * Cloudflare cancels as hung, and nothing says why. So it is refused at
+ * once, with this, wherever the database runs.
+ */
+export class QueryOutsideTransaction extends Error {
+  constructor() {
+    super('query outside its transaction: use tx. A query on the database inside one of its own transactions waits for that transaction, which waits for it');
+    this.name = 'QueryOutsideTransaction';
+  }
+}
+
+/** The transaction a flow of work runs inside, with the pool it holds, while it is open. */
+const inside = new AsyncLocalStorage<{ pool: PoolLike; open: boolean }>();
+
+/**
+ * `pool`, refusing a query or a transaction asked from inside a transaction
+ * it is already running. Work from any other flow, a concurrent request's,
+ * or what the transaction left running after it ended, goes on as before.
+ */
+function guarded(pool: PoolLike): PoolLike {
+  return new Proxy(pool, {
+    get(target, key) {
+      const value: unknown = Reflect.get(target, key, target);
+      if (typeof value !== 'function') return value;
+      if (key !== 'query' && key !== 'connect') return value.bind(target);
+      return (...args: unknown[]) => {
+        const open = inside.getStore();
+        if (open?.open === true && open.pool === target) throw new QueryOutsideTransaction();
+        return (value as (...args: unknown[]) => unknown).apply(target, args);
+      };
+    },
+  });
+}
+
+/** The refusal `error` is, or was caused by. */
+function brokenRule(error: unknown): QueryOutsideTransaction | undefined {
+  for (let cause = error; cause instanceof Error; cause = cause.cause) {
+    if (cause instanceof QueryOutsideTransaction) return cause;
+  }
+  return undefined;
+}
+
 export function createDatabase(pool: PoolLike): Database {
-  return trackCommits(drizzle(pool as pg.Pool, { schema }));
+  const db = drizzle(guarded(pool) as pg.Pool, { schema });
+  // Each transaction's work runs knowing which one it is in, until the transaction ends.
+  const run = db.transaction.bind(db);
+  db.transaction = (async (work, config) => {
+    const open = { pool, open: true };
+    try {
+      return await run((tx) => inside.run(open, () => work(tx)), config);
+    } catch (error) {
+      // Drizzle wraps what a query throws: the rule broken is what to say.
+      throw brokenRule(error) ?? error;
+    } finally {
+      open.open = false;
+    }
+  }) as Database['transaction'];
+  return trackCommits(db);
 }
 
 /**

package/src/migrations/postgres/0001_remove_syncs.sql

@@ -0,0 +1,13 @@
+-- Stop old app instances before upgrading. Never silently discard a configured
+-- destination, including archived ones. Keep the audit and sealed legacy rows.
+LOCK TABLE syncs, sync_keys IN ACCESS EXCLUSIVE MODE;
+--> statement-breakpoint
+DO $$ BEGIN
+  IF EXISTS (SELECT 1 FROM syncs) OR EXISTS (SELECT 1 FROM sync_keys) THEN
+    RAISE EXCEPTION 'syncs are removed: migrate destinations to service tokens, back up and clear syncs and sync_keys before upgrading';
+  END IF;
+END $$;
+--> statement-breakpoint
+DROP TABLE sync_keys;
+--> statement-breakpoint
+DROP TABLE syncs;