@storyshelf/db-sqlite 0.10.0-next-7fcea06 → 0.10.0-next-a8124f3

package/dist/better-sqlite3.mjs

@@ -37,7 +37,7 @@ function createBetterSqlite3Database(options) {
 	const adapter = createDrizzleAdapter(db, {
 		metadata: {
 			name: "better-sqlite3",
-			version: "0.10.0-next-7fcea06",
+			version: "0.10.0-next-a8124f3",
 			description: "better-sqlite3 database adapter (native + Drizzle)",
 			kind: "better-sqlite3",
 			category: "database"

package/dist/bun-sqlite.mjs

@@ -37,7 +37,7 @@ function createBunSqliteDatabase(options) {
 	const adapter = createDrizzleAdapter(db, {
 		metadata: {
 			name: "Bun SQLite",
-			version: "0.10.0-next-7fcea06",
+			version: "0.10.0-next-a8124f3",
 			description: "Bun SQLite database adapter (bun:sqlite + Drizzle)",
 			kind: "bun-sqlite",
 			category: "database"

package/dist/d1.mjs

@@ -22,7 +22,7 @@ function createD1Database(options) {
 	return createDrizzleAdapter(db, {
 		metadata: {
 			name: "Cloudflare D1",
-			version: "0.10.0-next-7fcea06",
+			version: "0.10.0-next-a8124f3",
 			description: "Cloudflare D1 database adapter (D1 binding + Drizzle)",
 			kind: "d1",
 			category: "database",

package/dist/drizzle-factory.d.mts

@@ -5,7 +5,8 @@ import { DatabaseAdapter, DrizzleAdapterOptions } from "@storyshelf/core/adapter
  * Wrap an adapter with manual BEGIN/COMMIT transactions for synchronous
  * SQLite drivers (better-sqlite3, `bun:sqlite`), whose `transaction()`
  * rejects async callbacks. Statements run on the adapter's own connection,
- * so the open transaction covers them; rollback runs on throw.
+ * so the open transaction covers them; rollback runs on throw. Overlapping calls queue, one
+ * transaction at a time (see `transaction-mutex.ts`).
  *
  * @param adapter - Adapter built by {@link createDrizzleAdapter}.
  * @param exec - Synchronous statement runner on the same connection.

package/dist/drizzle-factory.mjs

@@ -1,45 +1,50 @@
 import "node:path";
 import "node:url";
 import.meta.url;
+import { createNestingGuard } from "./nesting-guard.mjs";
+import { createTransactionMutex } from "./transaction-mutex.mjs";
 import { and, eq, getTableColumns } from "drizzle-orm";
 // src/drizzle-factory.ts
 /**
 * Wrap an adapter with manual BEGIN/COMMIT transactions for synchronous
 * SQLite drivers (better-sqlite3, `bun:sqlite`), whose `transaction()`
 * rejects async callbacks. Statements run on the adapter's own connection,
-* so the open transaction covers them; rollback runs on throw.
+* so the open transaction covers them; rollback runs on throw. Overlapping calls queue, one
+* transaction at a time (see `transaction-mutex.ts`).
 *
 * @param adapter - Adapter built by {@link createDrizzleAdapter}.
 * @param exec - Synchronous statement runner on the same connection.
 * @returns The adapter with `transact` replaced.
 */
 function withManualTransactions(adapter, exec) {
+	const mutex = createTransactionMutex(createNestingGuard());
 	return {
 		...adapter,
-		transact: async (fn) => {
-			const tx = {
-				insert: async (table, values) => await adapter.insert(table, values),
-				update: async (table, id, values) => await adapter.update(table, id, values),
-				get: async (table, id) => await adapter.get(table, id),
-				remove: async (table, id) => {
-					await adapter.remove(table, id);
-				},
-				list: async (table, opts) => await adapter.list(table, opts),
-				count: async (table, where) => await adapter.count(table, where)
-			};
-			exec("BEGIN");
-			try {
-				const result = await fn(tx);
-				exec("COMMIT");
-				return result;
-			} catch (error) {
-				try {
-					exec("ROLLBACK");
-				} catch {}
-				throw error;
-			}
-		}
+		transact: async (fn) => await mutex.run(async () => await runManualTransaction(adapter, exec, fn))
+	};
+}
+async function runManualTransaction(adapter, exec, fn) {
+	const tx = {
+		insert: async (table, values) => await adapter.insert(table, values),
+		update: async (table, id, values) => await adapter.update(table, id, values),
+		get: async (table, id) => await adapter.get(table, id),
+		remove: async (table, id) => {
+			await adapter.remove(table, id);
+		},
+		list: async (table, opts) => await adapter.list(table, opts),
+		count: async (table, where) => await adapter.count(table, where)
 	};
+	exec("BEGIN");
+	try {
+		const result = await fn(tx);
+		exec("COMMIT");
+		return result;
+	} catch (error) {
+		try {
+			exec("ROLLBACK");
+		} catch {}
+		throw error;
+	}
 }
 /** Setup, teardown (once) and health for the adapter; teardown closes the driver a single time. */
 function buildLifecycle(options) {
@@ -65,6 +70,7 @@ function buildLifecycle(options) {
 }
 function createDrizzleAdapter(db, options) {
 	const drizzle = db;
+	const mutex = createTransactionMutex(createNestingGuard());
 	return {
 		metadata: options.metadata,
 		tables: options.tables,
@@ -79,7 +85,7 @@ function createDrizzleAdapter(db, options) {
 		list: async (table, opts = {}) => await listMany(drizzle, table, opts),
 		count: async (table, where) => await drizzle.$count(table, where),
 		all: async (query) => await drizzle.all(query),
-		transact: async (fn) => await drizzle.transaction(async (tx) => await fn(buildTxStore(tx)))
+		transact: async (fn) => await mutex.run(async () => await drizzle.transaction(async (tx) => await fn(buildTxStore(tx))))
 	};
 }
 async function updateWhereOne(drizzle, table, id, values, where) {

package/dist/drizzle-factory.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"drizzle-factory.mjs","names":[],"sources":["../src/drizzle-factory.ts"],"sourcesContent":["/**\n * SQLite Drizzle adapter factory.\n *\n * Builds a {@link DatabaseAdapter} over any SQLite-compatible Drizzle dialect.\n */\n\nimport type {\n  DatabaseAdapter,\n  DrizzleAdapterOptions,\n  ListOptions,\n  TxStore,\n} from \"@storyshelf/core/adapter/database\";\nimport type { SQL, Table } from \"drizzle-orm\";\nimport { and, eq, getTableColumns } from \"drizzle-orm\";\nimport type { AnySQLiteTable, SQLiteColumn } from \"drizzle-orm/sqlite-core\";\n\n/**\n * Wrap an adapter with manual BEGIN/COMMIT transactions for synchronous\n * SQLite drivers (better-sqlite3, `bun:sqlite`), whose `transaction()`\n * rejects async callbacks. Statements run on the adapter's own connection,\n * so the open transaction covers them; rollback runs on throw.\n *\n * @param adapter - Adapter built by {@link createDrizzleAdapter}.\n * @param exec - Synchronous statement runner on the same connection.\n * @returns The adapter with `transact` replaced.\n */\nexport function withManualTransactions(\n  adapter: DatabaseAdapter,\n  exec: (sql: string) => void,\n): DatabaseAdapter {\n  return {\n    ...adapter,\n    transact: async <R>(fn: (tx: TxStore) => Promise<R>): Promise<R> => {\n      const tx: TxStore = {\n        insert: async (table, values) => await adapter.insert(table, values),\n        update: async (table, id, values) => await adapter.update(table, id, values),\n        get: async (table, id) => await adapter.get(table, id),\n        remove: async (table, id) => {\n          await adapter.remove(table, id);\n        },\n        list: async (table, opts) => await adapter.list(table, opts),\n        count: async (table, where) => await adapter.count(table, where),\n      };\n      exec(\"BEGIN\");\n      try {\n        const result = await fn(tx);\n        exec(\"COMMIT\");\n        return result;\n      } catch (error) {\n        try {\n          exec(\"ROLLBACK\");\n        } catch {\n          // already rolled back (e.g. constraint abort) — report the cause\n        }\n        throw error;\n      }\n    },\n  };\n}\n/** Setup, teardown (once) and health for the adapter; teardown closes the driver a single time. */\nfunction buildLifecycle(options: DrizzleAdapterOptions): NonNullable<DatabaseAdapter[\"lifecycle\"]> {\n  let closed = false;\n  return {\n    setup: async () => {\n      await options.migrate();\n    },\n    teardown: async () => {\n      if (closed) {\n        return;\n      }\n      closed = true;\n      await options.close();\n    },\n    health: async () => {\n      if (closed) {\n        return { ok: false, detail: \"database closed\" };\n      }\n      if (options.ping) {\n        await options.ping();\n      }\n      return { ok: true };\n    },\n  };\n}\n\nexport function createDrizzleAdapter(db: unknown, options: DrizzleAdapterOptions): DatabaseAdapter {\n  const drizzle = db as DrizzleLike;\n  return {\n    metadata: options.metadata,\n    tables: options.tables,\n    lifecycle: buildLifecycle(options),\n    insert: async <T extends AnySQLiteTable>(\n      table: T,\n      values: T[\"$inferInsert\"],\n    ): Promise<T[\"$inferSelect\"]> => await insertOne(drizzle, table, values),\n    update: async <T extends AnySQLiteTable>(\n      table: T,\n      id: string,\n      // Homomorphic equivalent of Partial<T[\"$inferInsert\"]>; written out so\n      // the type stays deferred instead of resolving to `{}` under generics.\n      values: { [K in keyof T[\"$inferInsert\"]]?: T[\"$inferInsert\"][K] },\n    ): Promise<T[\"$inferSelect\"]> => await updateOne(drizzle, table, id, values),\n    updateWhere: async <T extends AnySQLiteTable>(\n      table: T,\n      id: string,\n      values: { [K in keyof T[\"$inferInsert\"]]?: T[\"$inferInsert\"][K] },\n      where: SQL,\n    ): Promise<T[\"$inferSelect\"] | null> => await updateWhereOne(drizzle, table, id, values, where),\n    get: async <T extends AnySQLiteTable>(\n      table: T,\n      id: string,\n    ): Promise<T[\"$inferSelect\"] | null> => await getOne(drizzle, table, id),\n    remove: async (table: AnySQLiteTable, id: string): Promise<void> => {\n      await removeOne(drizzle, table, id);\n    },\n    list: async <T extends AnySQLiteTable>(\n      table: T,\n      opts: ListOptions = {},\n    ): Promise<T[\"$inferSelect\"][]> => await listMany(drizzle, table, opts),\n    count: async (table: AnySQLiteTable, where?: SQL): Promise<number> =>\n      await drizzle.$count(table, where),\n    all: async <T>(query: SQL): Promise<T[]> => await drizzle.all(query),\n    transact: async <R>(fn: (tx: TxStore) => Promise<R>): Promise<R> =>\n      await drizzle.transaction(async (tx) => await fn(buildTxStore(tx as DrizzleLike))),\n  };\n}\n\nasync function updateWhereOne<T extends AnySQLiteTable>(\n  drizzle: DrizzleLike,\n  table: T,\n  id: string,\n  values: { [K in keyof T[\"$inferInsert\"]]?: T[\"$inferInsert\"][K] },\n  where: SQL,\n): Promise<T[\"$inferSelect\"] | null> {\n  const updated = (await drizzle\n    .update(table)\n    .set(values)\n    .where(and(eq(idOf(table), id), where) ?? where)\n    .returning()\n    .get()) as T[\"$inferSelect\"] | undefined;\n  return updated ?? (await getOne(drizzle, table, id));\n}\n\nasync function insertOne<T extends Table>(\n  drizzle: DrizzleLike,\n  table: T,\n  values: T[\"$inferInsert\"],\n): Promise<T[\"$inferSelect\"]> {\n  return (await drizzle.insert(table).values(values).returning().get()) as T[\"$inferSelect\"];\n}\n\nasync function updateOne<T extends Table>(\n  drizzle: DrizzleLike,\n  table: T,\n  id: string,\n  values: Partial<T[\"$inferInsert\"]>,\n): Promise<T[\"$inferSelect\"]> {\n  return (await drizzle\n    .update(table)\n    .set(values)\n    .where(eq(idOf(table as AnySQLiteTable), id))\n    .returning()\n    .get()) as T[\"$inferSelect\"];\n}\n\nasync function getOne<T extends Table>(\n  drizzle: DrizzleLike,\n  table: T,\n  id: string,\n): Promise<T[\"$inferSelect\"] | null> {\n  return (\n    ((await drizzle\n      .select()\n      .from(table)\n      .where(eq(idOf(table as AnySQLiteTable), id))\n      .limit(1)\n      .get()) as T[\"$inferSelect\"] | undefined) ?? null\n  );\n}\n\nasync function removeOne(drizzle: DrizzleLike, table: Table, id: string): Promise<void> {\n  await drizzle\n    .delete(table)\n    .where(eq(idOf(table as AnySQLiteTable), id))\n    .run();\n}\n\nasync function listMany<T extends Table>(\n  drizzle: DrizzleLike,\n  table: T,\n  opts: ListOptions = {},\n): Promise<T[\"$inferSelect\"][]> {\n  const query = applyListOptions(drizzle.select().from(table), opts);\n  const rows: unknown = await query.all();\n  return rows as T[\"$inferSelect\"][];\n}\n\n/** The `where`, `orderBy`, `limit` and `offset` the caller asked for, in that order. */\nfunction applyListOptions(query: DrizzleSelectChain, opts: ListOptions): DrizzleSelectChain {\n  let next = query;\n  if (opts.where) {\n    next = next.where(opts.where);\n  }\n  if (opts.orderBy) {\n    next = next.orderBy(opts.orderBy);\n  }\n  if (opts.limit !== undefined) {\n    next = next.limit(opts.limit);\n  }\n  if (opts.offset !== undefined) {\n    next = next.offset(opts.offset);\n  }\n  return next;\n}\n\n/** CRUD subset bound to a transaction handle. */\nfunction buildTxStore(drizzle: DrizzleLike): TxStore {\n  return {\n    insert: async (table, values) => await insertOne(drizzle, table, values as never),\n    update: async (table, id, values) => await updateOne(drizzle, table, id, values as never),\n    get: async (table, id) => await getOne(drizzle, table, id),\n    remove: async (table, id) => {\n      await removeOne(drizzle, table, id);\n    },\n    list: async (table, opts) => await listMany(drizzle, table, opts),\n    count: async (table, where) => await drizzle.$count(table as AnySQLiteTable, where),\n  };\n}\n\n/** A value or a promise of one (sync node:sqlite vs async libSQL drivers). */\ntype MaybePromise<T> = T | Promise<T>;\n\n/** Chainable select surface shared by the sync and async Drizzle dialects. */\ninterface DrizzleSelectChain {\n  where(where: SQL): DrizzleSelectChain;\n  orderBy(order: SQL): DrizzleSelectChain;\n  limit(n: number): DrizzleSelectChain;\n  offset(n: number): DrizzleSelectChain;\n  get(): MaybePromise<unknown>;\n  all(): MaybePromise<unknown[]>;\n}\n\n/**\n * Minimal Drizzle surface consumed by {@link createDrizzleAdapter}. Drivers\n * pass their dialect instance as `unknown`; the cast lives here, once, so\n * driver packages stay fully typed. Covered by the adapter contract tests.\n */\ninterface DrizzleLike {\n  insert(table: AnySQLiteTable): {\n    values(values: unknown): { returning(): { get(): MaybePromise<unknown> } };\n  };\n  update(table: AnySQLiteTable): {\n    set(values: unknown): { where(where: SQL): { returning(): { get(): MaybePromise<unknown> } } };\n  };\n  select(): { from(table: AnySQLiteTable): DrizzleSelectChain };\n  delete(table: AnySQLiteTable): { where(where: SQL): { run(): MaybePromise<unknown> } };\n  $count(table: AnySQLiteTable, where?: SQL): MaybePromise<number>;\n  all<T>(query: SQL): MaybePromise<T[]>;\n  transaction<R>(fn: (tx: unknown) => Promise<R>): Promise<R>;\n}\n\nfunction idOf(table: AnySQLiteTable): SQLiteColumn {\n  const id = getTableColumns(table)[\"id\"];\n  if (!id) {\n    throw new Error(\"Table has no id column\");\n  }\n  return id;\n}\n"],"mappings":"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"}
+{"version":3,"file":"drizzle-factory.mjs","names":[],"sources":["../src/drizzle-factory.ts"],"sourcesContent":["/**\n * SQLite Drizzle adapter factory.\n *\n * Builds a {@link DatabaseAdapter} over any SQLite-compatible Drizzle dialect.\n */\n\nimport type {\n  DatabaseAdapter,\n  DrizzleAdapterOptions,\n  ListOptions,\n  TxStore,\n} from \"@storyshelf/core/adapter/database\";\nimport type { SQL, Table } from \"drizzle-orm\";\nimport { and, eq, getTableColumns } from \"drizzle-orm\";\nimport type { AnySQLiteTable, SQLiteColumn } from \"drizzle-orm/sqlite-core\";\nimport { createNestingGuard } from \"./nesting-guard.ts\";\nimport { createTransactionMutex } from \"./transaction-mutex.ts\";\n\n/**\n * Wrap an adapter with manual BEGIN/COMMIT transactions for synchronous\n * SQLite drivers (better-sqlite3, `bun:sqlite`), whose `transaction()`\n * rejects async callbacks. Statements run on the adapter's own connection,\n * so the open transaction covers them; rollback runs on throw. Overlapping calls queue, one\n * transaction at a time (see `transaction-mutex.ts`).\n *\n * @param adapter - Adapter built by {@link createDrizzleAdapter}.\n * @param exec - Synchronous statement runner on the same connection.\n * @returns The adapter with `transact` replaced.\n */\nexport function withManualTransactions(\n  adapter: DatabaseAdapter,\n  exec: (sql: string) => void,\n): DatabaseAdapter {\n  const mutex = createTransactionMutex(createNestingGuard());\n  return {\n    ...adapter,\n    transact: async <R>(fn: (tx: TxStore) => Promise<R>): Promise<R> =>\n      await mutex.run(async () => await runManualTransaction(adapter, exec, fn)),\n  };\n}\n\nasync function runManualTransaction<R>(\n  adapter: DatabaseAdapter,\n  exec: (sql: string) => void,\n  fn: (tx: TxStore) => Promise<R>,\n): Promise<R> {\n  const tx: TxStore = {\n    insert: async (table, values) => await adapter.insert(table, values),\n    update: async (table, id, values) => await adapter.update(table, id, values),\n    get: async (table, id) => await adapter.get(table, id),\n    remove: async (table, id) => {\n      await adapter.remove(table, id);\n    },\n    list: async (table, opts) => await adapter.list(table, opts),\n    count: async (table, where) => await adapter.count(table, where),\n  };\n  exec(\"BEGIN\");\n  try {\n    const result = await fn(tx);\n    exec(\"COMMIT\");\n    return result;\n  } catch (error) {\n    try {\n      exec(\"ROLLBACK\");\n    } catch {\n      // already rolled back (e.g. constraint abort) — report the cause\n    }\n    throw error;\n  }\n}\n\n/** Setup, teardown (once) and health for the adapter; teardown closes the driver a single time. */\nfunction buildLifecycle(options: DrizzleAdapterOptions): NonNullable<DatabaseAdapter[\"lifecycle\"]> {\n  let closed = false;\n  return {\n    setup: async () => {\n      await options.migrate();\n    },\n    teardown: async () => {\n      if (closed) {\n        return;\n      }\n      closed = true;\n      await options.close();\n    },\n    health: async () => {\n      if (closed) {\n        return { ok: false, detail: \"database closed\" };\n      }\n      if (options.ping) {\n        await options.ping();\n      }\n      return { ok: true };\n    },\n  };\n}\n\nexport function createDrizzleAdapter(db: unknown, options: DrizzleAdapterOptions): DatabaseAdapter {\n  const drizzle = db as DrizzleLike;\n  // The shared connection (or, for a libSQL file, its connection per transaction) cannot overlap\n  // transactions: they queue (see `transaction-mutex.ts`).\n  const mutex = createTransactionMutex(createNestingGuard());\n  return {\n    metadata: options.metadata,\n    tables: options.tables,\n    lifecycle: buildLifecycle(options),\n    insert: async <T extends AnySQLiteTable>(\n      table: T,\n      values: T[\"$inferInsert\"],\n    ): Promise<T[\"$inferSelect\"]> => await insertOne(drizzle, table, values),\n    update: async <T extends AnySQLiteTable>(\n      table: T,\n      id: string,\n      // Homomorphic equivalent of Partial<T[\"$inferInsert\"]>; written out so\n      // the type stays deferred instead of resolving to `{}` under generics.\n      values: { [K in keyof T[\"$inferInsert\"]]?: T[\"$inferInsert\"][K] },\n    ): Promise<T[\"$inferSelect\"]> => await updateOne(drizzle, table, id, values),\n    updateWhere: async <T extends AnySQLiteTable>(\n      table: T,\n      id: string,\n      values: { [K in keyof T[\"$inferInsert\"]]?: T[\"$inferInsert\"][K] },\n      where: SQL,\n    ): Promise<T[\"$inferSelect\"] | null> => await updateWhereOne(drizzle, table, id, values, where),\n    get: async <T extends AnySQLiteTable>(\n      table: T,\n      id: string,\n    ): Promise<T[\"$inferSelect\"] | null> => await getOne(drizzle, table, id),\n    remove: async (table: AnySQLiteTable, id: string): Promise<void> => {\n      await removeOne(drizzle, table, id);\n    },\n    list: async <T extends AnySQLiteTable>(\n      table: T,\n      opts: ListOptions = {},\n    ): Promise<T[\"$inferSelect\"][]> => await listMany(drizzle, table, opts),\n    count: async (table: AnySQLiteTable, where?: SQL): Promise<number> =>\n      await drizzle.$count(table, where),\n    all: async <T>(query: SQL): Promise<T[]> => await drizzle.all(query),\n    transact: async <R>(fn: (tx: TxStore) => Promise<R>): Promise<R> =>\n      await mutex.run(\n        async () =>\n          await drizzle.transaction(async (tx) => await fn(buildTxStore(tx as DrizzleLike))),\n      ),\n  };\n}\n\nasync function updateWhereOne<T extends AnySQLiteTable>(\n  drizzle: DrizzleLike,\n  table: T,\n  id: string,\n  values: { [K in keyof T[\"$inferInsert\"]]?: T[\"$inferInsert\"][K] },\n  where: SQL,\n): Promise<T[\"$inferSelect\"] | null> {\n  const updated = (await drizzle\n    .update(table)\n    .set(values)\n    .where(and(eq(idOf(table), id), where) ?? where)\n    .returning()\n    .get()) as T[\"$inferSelect\"] | undefined;\n  return updated ?? (await getOne(drizzle, table, id));\n}\n\nasync function insertOne<T extends Table>(\n  drizzle: DrizzleLike,\n  table: T,\n  values: T[\"$inferInsert\"],\n): Promise<T[\"$inferSelect\"]> {\n  return (await drizzle.insert(table).values(values).returning().get()) as T[\"$inferSelect\"];\n}\n\nasync function updateOne<T extends Table>(\n  drizzle: DrizzleLike,\n  table: T,\n  id: string,\n  values: Partial<T[\"$inferInsert\"]>,\n): Promise<T[\"$inferSelect\"]> {\n  return (await drizzle\n    .update(table)\n    .set(values)\n    .where(eq(idOf(table as AnySQLiteTable), id))\n    .returning()\n    .get()) as T[\"$inferSelect\"];\n}\n\nasync function getOne<T extends Table>(\n  drizzle: DrizzleLike,\n  table: T,\n  id: string,\n): Promise<T[\"$inferSelect\"] | null> {\n  return (\n    ((await drizzle\n      .select()\n      .from(table)\n      .where(eq(idOf(table as AnySQLiteTable), id))\n      .limit(1)\n      .get()) as T[\"$inferSelect\"] | undefined) ?? null\n  );\n}\n\nasync function removeOne(drizzle: DrizzleLike, table: Table, id: string): Promise<void> {\n  await drizzle\n    .delete(table)\n    .where(eq(idOf(table as AnySQLiteTable), id))\n    .run();\n}\n\nasync function listMany<T extends Table>(\n  drizzle: DrizzleLike,\n  table: T,\n  opts: ListOptions = {},\n): Promise<T[\"$inferSelect\"][]> {\n  const query = applyListOptions(drizzle.select().from(table), opts);\n  const rows: unknown = await query.all();\n  return rows as T[\"$inferSelect\"][];\n}\n\n/** The `where`, `orderBy`, `limit` and `offset` the caller asked for, in that order. */\nfunction applyListOptions(query: DrizzleSelectChain, opts: ListOptions): DrizzleSelectChain {\n  let next = query;\n  if (opts.where) {\n    next = next.where(opts.where);\n  }\n  if (opts.orderBy) {\n    next = next.orderBy(opts.orderBy);\n  }\n  if (opts.limit !== undefined) {\n    next = next.limit(opts.limit);\n  }\n  if (opts.offset !== undefined) {\n    next = next.offset(opts.offset);\n  }\n  return next;\n}\n\n/** CRUD subset bound to a transaction handle. */\nfunction buildTxStore(drizzle: DrizzleLike): TxStore {\n  return {\n    insert: async (table, values) => await insertOne(drizzle, table, values as never),\n    update: async (table, id, values) => await updateOne(drizzle, table, id, values as never),\n    get: async (table, id) => await getOne(drizzle, table, id),\n    remove: async (table, id) => {\n      await removeOne(drizzle, table, id);\n    },\n    list: async (table, opts) => await listMany(drizzle, table, opts),\n    count: async (table, where) => await drizzle.$count(table as AnySQLiteTable, where),\n  };\n}\n\n/** A value or a promise of one (sync node:sqlite vs async libSQL drivers). */\ntype MaybePromise<T> = T | Promise<T>;\n\n/** Chainable select surface shared by the sync and async Drizzle dialects. */\ninterface DrizzleSelectChain {\n  where(where: SQL): DrizzleSelectChain;\n  orderBy(order: SQL): DrizzleSelectChain;\n  limit(n: number): DrizzleSelectChain;\n  offset(n: number): DrizzleSelectChain;\n  get(): MaybePromise<unknown>;\n  all(): MaybePromise<unknown[]>;\n}\n\n/**\n * Minimal Drizzle surface consumed by {@link createDrizzleAdapter}. Drivers\n * pass their dialect instance as `unknown`; the cast lives here, once, so\n * driver packages stay fully typed. Covered by the adapter contract tests.\n */\ninterface DrizzleLike {\n  insert(table: AnySQLiteTable): {\n    values(values: unknown): { returning(): { get(): MaybePromise<unknown> } };\n  };\n  update(table: AnySQLiteTable): {\n    set(values: unknown): { where(where: SQL): { returning(): { get(): MaybePromise<unknown> } } };\n  };\n  select(): { from(table: AnySQLiteTable): DrizzleSelectChain };\n  delete(table: AnySQLiteTable): { where(where: SQL): { run(): MaybePromise<unknown> } };\n  $count(table: AnySQLiteTable, where?: SQL): MaybePromise<number>;\n  all<T>(query: SQL): MaybePromise<T[]>;\n  transaction<R>(fn: (tx: unknown) => Promise<R>): Promise<R>;\n}\n\nfunction idOf(table: AnySQLiteTable): SQLiteColumn {\n  const id = getTableColumns(table)[\"id\"];\n  if (!id) {\n    throw new Error(\"Table has no id column\");\n  }\n  return id;\n}\n"],"mappings":"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"}

package/dist/index.mjs

@@ -29,7 +29,7 @@ function createSqliteDatabase(path) {
 	const adapter = createDrizzleAdapter(db, {
 		metadata: {
 			name: "SQLite",
-			version: "0.10.0-next-7fcea06",
+			version: "0.10.0-next-a8124f3",
 			description: "SQLite database adapter (node:sqlite + Drizzle)",
 			kind: "sqlite",
 			category: "database"

package/dist/nesting-guard.mjs

@@ -0,0 +1,33 @@
+import "node:path";
+import "node:url";
+import.meta.url;
+// src/nesting-guard.ts
+/** `AsyncLocalStorage` where the runtime has it, else undefined. */
+function findScopeStorage() {
+	return (globalThis.process?.getBuiltinModule?.("node:async_hooks"))?.AsyncLocalStorage;
+}
+/** A guard for one adapter; it detects nothing where the runtime has no async context tracking. */
+function createNestingGuard() {
+	const Storage = findScopeStorage();
+	if (Storage === void 0) return {
+		detects: false,
+		inside: () => false,
+		enter: async (body) => await body()
+	};
+	const scopes = new Storage();
+	return {
+		detects: true,
+		inside: () => scopes.getStore()?.open === true,
+		enter: async (body) => {
+			const scope = { open: true };
+			try {
+				return await scopes.run(scope, body);
+			} finally {
+				scope.open = false;
+			}
+		}
+	};
+}
+export { createNestingGuard };
+
+//# sourceMappingURL=nesting-guard.mjs.map

package/dist/nesting-guard.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"nesting-guard.mjs","names":[],"sources":["../src/nesting-guard.ts"],"sourcesContent":["/**\n * Nested-transaction detection (see `transaction-mutex.ts`). It needs async context tracking,\n * which Node and Bun have as `node:async_hooks` and a Cloudflare Worker may not, so the module is\n * looked up at run time with `process.getBuiltinModule` and never imported: where it is missing\n * the guard detects nothing and a nested `transact` waits for the mutex's wait limit instead of failing at once. Importing it\n * statically would stop the D1 entry point from loading in a Worker without Node compatibility.\n */\nimport type { NestingGuard } from \"./transaction-mutex.ts\";\n\n/** The part of `AsyncLocalStorage` the guard uses. */\ninterface ScopeStorage {\n  getStore(): { open: boolean } | undefined;\n  run<R>(store: { open: boolean }, body: () => R): R;\n}\n\ntype ScopeStorageConstructor = new () => ScopeStorage;\n\n/** `AsyncLocalStorage` where the runtime has it, else undefined. */\nfunction findScopeStorage(): ScopeStorageConstructor | undefined {\n  const runtime = (\n    globalThis as {\n      process?: { getBuiltinModule?: (id: string) => unknown };\n    }\n  ).process;\n  const loaded = runtime?.getBuiltinModule?.(\"node:async_hooks\") as\n    | { AsyncLocalStorage?: ScopeStorageConstructor }\n    | undefined;\n  return loaded?.AsyncLocalStorage;\n}\n\n/** A guard for one adapter; it detects nothing where the runtime has no async context tracking. */\nexport function createNestingGuard(): NestingGuard {\n  const Storage = findScopeStorage();\n  if (Storage === undefined) {\n    return { detects: false, inside: () => false, enter: async (body) => await body() };\n  }\n  // Work started inside a body keeps this store after the body ends, so what marks a nested call\n  // is the transaction still being open, not the store being present.\n  const scopes = new Storage();\n  return {\n    detects: true,\n    inside: () => scopes.getStore()?.open === true,\n    enter: async <R>(body: () => Promise<R>): Promise<R> => {\n      const scope = { open: true };\n      try {\n        return await scopes.run(scope, body);\n      } finally {\n        scope.open = false;\n      }\n    },\n  };\n}\n"],"mappings":";;;;;AAkBA,SAAS,mBAAwD;CAS/D,QAPE,WAGA,SACsB,mBAAmB,kBAAkB,EAAA,EAG9C;AACjB;;AAGA,SAAgB,qBAAmC;CACjD,MAAM,UAAU,iBAAiB;CACjC,IAAI,YAAY,KAAA,GACd,OAAO;EAAE,SAAS;EAAO,cAAc;EAAO,OAAO,OAAO,SAAS,MAAM,KAAK;CAAE;CAIpF,MAAM,SAAS,IAAI,QAAQ;CAC3B,OAAO;EACL,SAAS;EACT,cAAc,OAAO,SAAS,CAAC,EAAE,SAAS;EAC1C,OAAO,OAAU,SAAuC;GACtD,MAAM,QAAQ,EAAE,MAAM,KAAK;GAC3B,IAAI;IACF,OAAO,MAAM,OAAO,IAAI,OAAO,IAAI;GACrC,UAAU;IACR,MAAM,OAAO;GACf;EACF;CACF;AACF"}

package/dist/transaction-mutex.mjs

@@ -0,0 +1,61 @@
+import "node:path";
+import "node:url";
+import.meta.url;
+// src/transaction-mutex.ts
+/**
+* How long a transaction waits for its turn where nesting cannot be detected. A nested call there
+* waits for the transaction it sits in, which waits for it; the limit turns that into an error for
+* the nested call, which ends the outer transaction and frees the queue. It only counts the wait
+* for the turn, never a transaction's own run time.
+*/
+const UNGUARDED_WAIT_LIMIT_MS = 3e4;
+const globalSchedule = (fire, ms) => {
+	const timer = setTimeout(fire, ms);
+	return () => {
+		clearTimeout(timer);
+	};
+};
+/** A mutex for one adapter; each adapter instance owns its own. */
+function createTransactionMutex(guard, options = {}) {
+	const limit = options.waitLimitMs ?? (guard.detects ? void 0 : 3e4);
+	let tail = Promise.resolve();
+	return { run: async (body) => {
+		if (guard.inside()) throw new Error("transact was called inside a transaction of the same database; use `tx`");
+		const turn = new Turn();
+		const done = tail.then(async () => {
+			turn.begin();
+			return await guard.enter(body);
+		});
+		tail = done.catch(() => {});
+		return await (limit === void 0 ? done : turn.within(done, limit, options.schedule ?? globalSchedule));
+	} };
+}
+/** One caller's place in the queue: whether its turn has come, and a limit on how long to wait for it. */
+var Turn = class {
+	#started = false;
+	#abandoned = false;
+	/** The turn came: stop if the caller already gave up (the wait limit passed), else go on. */
+	begin() {
+		if (this.#abandoned) throw new Error("transaction gave up waiting for its turn");
+		this.#started = true;
+	}
+	/** `done`, or an error if the turn has not come within `limitMs`. */
+	async within(done, limitMs, schedule) {
+		let cancel;
+		const expired = new Promise((_resolve, reject) => {
+			cancel = schedule(() => {
+				if (this.#started) return;
+				this.#abandoned = true;
+				reject(/* @__PURE__ */ new Error(`transaction waited ${String(limitMs)} ms for the previous one to end; a transaction may have opened another on the same database, use \`tx\` instead`));
+			}, limitMs);
+		});
+		try {
+			return await Promise.race([done, expired]);
+		} finally {
+			cancel?.();
+		}
+	}
+};
+export { UNGUARDED_WAIT_LIMIT_MS, createTransactionMutex };
+
+//# sourceMappingURL=transaction-mutex.mjs.map

package/dist/transaction-mutex.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"transaction-mutex.mjs","names":[],"sources":["../src/transaction-mutex.ts"],"sourcesContent":["/**\n * One transaction at a time per adapter. The built-in SQLite adapters run on a single connection,\n * and SQLite refuses a `BEGIN` inside an open transaction, so two overlapping `transact` calls\n * (the queue's acks, approvals under load) would fail the second one. The mutex makes the second\n * wait for the first to commit or roll back instead.\n *\n * A callback that calls `transact` on the same adapter again could never get the mutex it already\n * holds, which would hang, so every mutex takes a {@link NestingGuard} (`nesting-guard.ts`) that\n * turns that into an immediate error saying to use the `tx` the callback was given, where the\n * runtime can track async context.\n */\n\n/** Marks the code running inside a transaction, so a nested `transact` can be told apart. */\nexport interface NestingGuard {\n  /** Whether the runtime can tell a nested call from an independent one at all. */\n  detects: boolean;\n  /** Run `body` as a transaction; `inside()` is true within it and anything it starts, until it ends. */\n  enter<R>(body: () => Promise<R>): Promise<R>;\n  /** Whether the caller runs inside a transaction that has not ended. */\n  inside(): boolean;\n}\n\n/** Runs transaction bodies one at a time, in the order they asked. */\nexport interface TransactionMutex {\n  run<R>(body: () => Promise<R>): Promise<R>;\n}\n\n/**\n * How long a transaction waits for its turn where nesting cannot be detected. A nested call there\n * waits for the transaction it sits in, which waits for it; the limit turns that into an error for\n * the nested call, which ends the outer transaction and frees the queue. It only counts the wait\n * for the turn, never a transaction's own run time.\n */\nexport const UNGUARDED_WAIT_LIMIT_MS = 30_000;\n\n/** Options of {@link createTransactionMutex}. */\nexport interface TransactionMutexOptions {\n  /** Wait limit in ms; defaults to {@link UNGUARDED_WAIT_LIMIT_MS} when the guard cannot detect, else none. */\n  waitLimitMs?: number;\n  /** Runs `fire` after `ms` and returns what cancels it (default the global timers); tests inject a manual one. */\n  schedule?: (fire: () => void, ms: number) => () => void;\n}\n\nconst globalSchedule = (fire: () => void, ms: number): (() => void) => {\n  const timer = setTimeout(fire, ms);\n  return () => {\n    clearTimeout(timer);\n  };\n};\n\n/** A mutex for one adapter; each adapter instance owns its own. */\nexport function createTransactionMutex(\n  guard: NestingGuard,\n  options: TransactionMutexOptions = {},\n): TransactionMutex {\n  const limit = options.waitLimitMs ?? (guard.detects ? undefined : UNGUARDED_WAIT_LIMIT_MS);\n  let tail: Promise<unknown> = Promise.resolve();\n  return {\n    run: async <R>(body: () => Promise<R>): Promise<R> => {\n      if (guard.inside()) {\n        throw new Error(\"transact was called inside a transaction of the same database; use `tx`\");\n      }\n      const turn = new Turn();\n      const done = tail.then(async () => {\n        turn.begin();\n        return await guard.enter(body);\n      });\n      // The next transaction waits for this one to end either way, never for its error.\n      tail = done.catch(() => {});\n      return await (limit === undefined\n        ? done\n        : turn.within(done, limit, options.schedule ?? globalSchedule));\n    },\n  };\n}\n\n/** One caller's place in the queue: whether its turn has come, and a limit on how long to wait for it. */\nclass Turn {\n  #started = false;\n  #abandoned = false;\n\n  /** The turn came: stop if the caller already gave up (the wait limit passed), else go on. */\n  begin(): void {\n    if (this.#abandoned) {\n      throw new Error(\"transaction gave up waiting for its turn\");\n    }\n    this.#started = true;\n  }\n\n  /** `done`, or an error if the turn has not come within `limitMs`. */\n  async within<R>(\n    done: Promise<R>,\n    limitMs: number,\n    schedule: (fire: () => void, ms: number) => () => void,\n  ): Promise<R> {\n    let cancel: (() => void) | undefined;\n    const expired = new Promise<never>((_resolve, reject) => {\n      cancel = schedule(() => {\n        if (this.#started) return;\n        this.#abandoned = true;\n        reject(\n          new Error(\n            `transaction waited ${String(limitMs)} ms for the previous one to end; a transaction may have opened another on the same database, use \\`tx\\` instead`,\n          ),\n        );\n      }, limitMs);\n    });\n    try {\n      return await Promise.race([done, expired]);\n    } finally {\n      cancel?.();\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;AAiCA,MAAa,0BAA0B;AAUvC,MAAM,kBAAkB,MAAkB,OAA6B;CACrE,MAAM,QAAQ,WAAW,MAAM,EAAE;CACjC,aAAa;EACX,aAAa,KAAK;CACpB;AACF;;AAGA,SAAgB,uBACd,OACA,UAAmC,CAAC,GAClB;CAClB,MAAM,QAAQ,QAAQ,gBAAgB,MAAM,UAAU,KAAA,IAAA;CACtD,IAAI,OAAyB,QAAQ,QAAQ;CAC7C,OAAO,EACL,KAAK,OAAU,SAAuC;EACpD,IAAI,MAAM,OAAO,GACf,MAAM,IAAI,MAAM,yEAAyE;EAE3F,MAAM,OAAO,IAAI,KAAK;EACtB,MAAM,OAAO,KAAK,KAAK,YAAY;GACjC,KAAK,MAAM;GACX,OAAO,MAAM,MAAM,MAAM,IAAI;EAC/B,CAAC;EAED,OAAO,KAAK,YAAY,CAAC,CAAC;EAC1B,OAAO,OAAO,UAAU,KAAA,IACpB,OACA,KAAK,OAAO,MAAM,OAAO,QAAQ,YAAY,cAAc;CACjE,EACF;AACF;;AAGA,IAAM,OAAN,MAAW;CACT,WAAW;CACX,aAAa;;CAGb,QAAc;EACZ,IAAI,KAAK,YACP,MAAM,IAAI,MAAM,0CAA0C;EAE5D,KAAK,WAAW;CAClB;;CAGA,MAAM,OACJ,MACA,SACA,UACY;EACZ,IAAI;EACJ,MAAM,UAAU,IAAI,SAAgB,UAAU,WAAW;GACvD,SAAS,eAAe;IACtB,IAAI,KAAK,UAAU;IACnB,KAAK,aAAa;IAClB,uBACE,IAAI,MACF,sBAAsB,OAAO,OAAO,EAAE,gHACxC,CACF;GACF,GAAG,OAAO;EACZ,CAAC;EACD,IAAI;GACF,OAAO,MAAM,QAAQ,KAAK,CAAC,MAAM,OAAO,CAAC;EAC3C,UAAU;GACR,SAAS;EACX;CACF;AACF"}

package/dist/turso.mjs

@@ -32,7 +32,7 @@ function createTursoDatabase(options) {
 	return createDrizzleAdapter(db, {
 		metadata: {
 			name: "Turso",
-			version: "0.10.0-next-7fcea06",
+			version: "0.10.0-next-a8124f3",
 			description: "Turso/libSQL database adapter",
 			kind: "turso",
 			category: "database"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@storyshelf/db-sqlite",
-  "version": "0.10.0-next-7fcea06",
+  "version": "0.10.0-next-a8124f3",
   "description": "SQLite database adapter for StoryShelf (node:sqlite + Drizzle).",
   "keywords": [
     "database",
@@ -87,7 +87,7 @@
     "prepublishOnly": "nub run build"
   },
   "dependencies": {
-    "@storyshelf/core": "0.10.0-next-7fcea06",
+    "@storyshelf/core": "0.10.0-next-a8124f3",
     "drizzle-orm": "^0.45.4"
   },
   "devDependencies": {