@coffre/db 0.1.10 → 0.1.12

package/dist/connect.d.ts

@@ -1,4 +1,4 @@
-import { t as Database } from "./database-CWpo5aF0.js";
+import { t as Database } from "./database-CNMfHZwF.js";
 import { Engine } from "./dialect.js";
 import { ClientConfig } from "pg";
 //#region src/postgres.d.ts

package/dist/{database-CWpo5aF0.d.ts → database-CNMfHZwF.d.ts}

@@ -1,4 +1,4 @@
-import { l as schema_d_exports } from "./schema-Cd4WOnB5.js";
+import { l as schema_d_exports } from "./schema-AmvM6w0D.js";
 import { Table } from "drizzle-orm";
 import { NodePgDatabase } from "drizzle-orm/node-postgres";
 import pg from "pg";
@@ -23,6 +23,16 @@ type PoolLike = pg.Pool | {
     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.
+ */
+declare class QueryOutsideTransaction extends Error {
+  constructor();
+}
 declare function createDatabase(pool: PoolLike): Database;
 /**
  * The tables of the database's own dialect: the Postgres ones on Postgres,
@@ -36,4 +46,4 @@ declare function tablesOf(db: Queryable): typeof schema_d_exports;
  */
 declare function own<T extends Table>(db: Queryable, table: T): T;
 //#endregion
-export { createDatabase as a, Transaction as i, PoolLike as n, own as o, Queryable as r, tablesOf as s, Database as t };
+export { Transaction as a, tablesOf as c, Queryable as i, PoolLike as n, createDatabase as o, QueryOutsideTransaction as r, own as s, Database as t };

package/dist/dialect.d.ts

@@ -1,4 +1,4 @@
-import { r as Queryable } from "./database-CWpo5aF0.js";
+import { i as Queryable } from "./database-CNMfHZwF.js";
 import { SQL } from "drizzle-orm";
 import { PgTable } from "drizzle-orm/pg-core";
 //#region src/dialect.d.ts

package/dist/hyperdrive.d.ts

@@ -1,4 +1,4 @@
-import { n as PoolLike } from "./database-CWpo5aF0.js";
+import { n as PoolLike } from "./database-CNMfHZwF.js";
 import pg from "pg";
 //#region src/hyperdrive.d.ts
 /** Postgres through a Hyperdrive binding: `postgres(env.HYPERDRIVE)`. */

package/dist/index.d.ts

@@ -1,3 +1,3 @@
-import { l as schema_d_exports } from "./schema-Cd4WOnB5.js";
-import { a as createDatabase, i as Transaction, n as PoolLike, o as own, r as Queryable, s as tablesOf, t as Database } from "./database-CWpo5aF0.js";
-export { Database, PoolLike, Queryable, Transaction, createDatabase, own, schema_d_exports as schema, tablesOf };
+import { l as schema_d_exports } from "./schema-AmvM6w0D.js";
+import { a as Transaction, c as tablesOf, i as Queryable, n as PoolLike, o as createDatabase, r as QueryOutsideTransaction, s as own, t as Database } from "./database-CNMfHZwF.js";
+export { Database, PoolLike, QueryOutsideTransaction, Queryable, Transaction, createDatabase, own, schema_d_exports as schema, tablesOf };

package/dist/index.js

@@ -1,10 +1,62 @@
 import { n as trackCommits } from "./commits-BuW-NL3n.js";
 import { t as schema_exports } from "./schema.js";
+import { AsyncLocalStorage } from "node:async_hooks";
 import { Table, getTableName, is } from "drizzle-orm";
 import { drizzle } from "drizzle-orm/node-postgres";
 //#region src/database.ts
+/**
+* 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.
+*/
+var QueryOutsideTransaction = class 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`, 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) {
+	return new Proxy(pool, { get(target, key) {
+		const value = Reflect.get(target, key, target);
+		if (typeof value !== "function") return value;
+		if (key !== "query" && key !== "connect") return value.bind(target);
+		return (...args) => {
+			const open = inside.getStore();
+			if (open?.open === true && open.pool === target) throw new QueryOutsideTransaction();
+			return value.apply(target, args);
+		};
+	} });
+}
+/** The refusal `error` is, or was caused by. */
+function brokenRule(error) {
+	for (let cause = error; cause instanceof Error; cause = cause.cause) if (cause instanceof QueryOutsideTransaction) return cause;
+}
 function createDatabase(pool) {
-	return trackCommits(drizzle(pool, { schema: schema_exports }));
+	const db = drizzle(guarded(pool), { schema: schema_exports });
+	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) {
+			throw brokenRule(error) ?? error;
+		} finally {
+			open.open = false;
+		}
+	});
+	return trackCommits(db);
 }
 /**
 * The tables of the database's own dialect: the Postgres ones on Postgres,
@@ -31,4 +83,4 @@ function own(db, table) {
 	return found;
 }
 //#endregion
-export { createDatabase, own, schema_exports as schema, tablesOf };
+export { QueryOutsideTransaction, createDatabase, own, schema_exports as schema, tablesOf };

package/dist/log.d.ts

@@ -1,4 +1,4 @@
-import { i as Transaction } from "./database-CWpo5aF0.js";
+import { a as Transaction } from "./database-CNMfHZwF.js";
 import { LogKey } from "@coffre/core/audit";
 //#region src/log.d.ts
 /**

package/dist/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;