@coffre/db 0.10.1 → 0.10.2

package/dist/dialect.d.ts

@@ -32,6 +32,12 @@ export declare function engineOf(db: Queryable): Engine;
 export declare function forUpdate<Query extends {
   for: (strength: 'update' | 'no key update') => unknown;
 }>(db: Queryable, query: Query, strength?: 'update' | 'no key update'): ReturnType<Query['for']>;
+/**
+ * The rows a hand-written query answers, as the driver gives them: what
+ * Postgres's `execute` and SQLite's `all` each call a result. Column names
+ * are the query's own, unmapped.
+ */
+export declare function rowsOf<Row>(db: Queryable, query: SQL): Promise<Row[]>;
 /** Insert the rows whose unique keys are free; returns how many that was. */
 export declare function insertIfAbsent(db: Queryable, table: Table, rows: object[]): Promise<number>;
 /**

package/dist/dialect.js

@@ -20,6 +20,15 @@ function forUpdate(db, query, strength = "update") {
 	if (engineOf(db) === "sqlite") return query;
 	return query.for(strength);
 }
+/**
+* The rows a hand-written query answers, as the driver gives them: what
+* Postgres's `execute` and SQLite's `all` each call a result. Column names
+* are the query's own, unmapped.
+*/
+async function rowsOf(db, query) {
+	if (engineOf(db) === "postgres") return (await db.execute(query)).rows;
+	return db.all(query);
+}
 /** Insert the rows whose unique keys are free; returns how many that was. */
 async function insertIfAbsent(db, table, rows) {
 	return changedRows(await db.insert(table).values(rows).onConflictDoNothing());
@@ -169,4 +178,4 @@ function canonicalTimestamp(raw) {
 	return `${(/* @__PURE__ */ new Date(Date.UTC(+year, +month - 1, +day, +hour, +minute, +second) - offsetMinutes * 6e4)).toISOString().slice(0, 19)}.${fraction.padEnd(6, "0")}Z`;
 }
 //#endregion
-export { SNAPSHOT, ahead, canonicalTimestamp, changedRows, clock, clockMillis, engineOf, forUpdate, insertIfAbsent, isUniqueViolation, isUnreachable, migrationLedger, tombstone, truth, upsert };
+export { SNAPSHOT, ahead, canonicalTimestamp, changedRows, clock, clockMillis, engineOf, forUpdate, insertIfAbsent, isUniqueViolation, isUnreachable, migrationLedger, rowsOf, tombstone, truth, upsert };

package/dist/log.d.ts

@@ -1,5 +1,5 @@
 import { a as Transaction, i as Queryable } from "./database-DBtn3jqp.js";
-import { SQL } from "drizzle-orm";
+import { Placeholder, SQL } from "drizzle-orm";
 import { LogKey, StoredEntry } from "@coffre/core/audit";
 //#region src/log.d.ts
 /**
@@ -75,7 +75,25 @@ export declare function lockLogHead(tx: Transaction): Promise<{
  * log as it stands, which no other append can change until this one
  * commits. It throws to refuse.
  */
-export declare function appendEntries(tx: Transaction, key: LogKey, entries: readonly NewEntry[], check?: (tx: Transaction) => Promise<void>): Promise<Appended>;
+export declare function appendEntries(tx: Transaction, key: LogKey, entries: readonly NewEntry[], check?: (tx: Transaction) => Promise<void>,
+/**
+ * The head as a statement of the caller's locked it, with the log's last
+ * entry and the clock as that statement read them once it held the lock:
+ * nothing to read again.
+ */
+locked?: HeldHead): Promise<Appended>;
+/** A head locked by a statement of the caller's, and what it read under the lock (`appendEntries`). */
+export type HeldHead = {
+  head: {
+    nextSeq: bigint;
+    headHash: Buffer;
+  };
+  last: {
+    seq: bigint;
+    hash: Buffer;
+  } | null;
+  at: number;
+};
 /** An entry's columns, as the chain's codec reads them (`StoredEntry`). */
 export declare function entryColumns(db: Queryable): {
   seq: import("drizzle-orm/pg-core").PgColumn<{
@@ -492,6 +510,50 @@ export declare function newestVaultEntries(db: Queryable, action: string, limit:
  * of what it says, so its MAC is not checked. One indexed read.
  */
 export declare function newestVaultSeq(db: Queryable, action: string): Promise<bigint | null>;
+/**
+ * `newestVaultSeq`'s query, to run or to read inside another, as a
+ * credential's read takes the newest `policy.change` with it: one rule for
+ * what the newest is, wherever it is read.
+ */
+export declare function newestSeqQuery(db: Queryable, action: string | Placeholder): Omit<import("drizzle-orm/pg-core").PgSelectBase<"audit_log", {
+  seq: import("drizzle-orm/pg-core").PgColumn<{
+    name: "seq";
+    tableName: "audit_log";
+    dataType: "bigint";
+    columnType: "PgBigInt64";
+    data: bigint;
+    driverParam: string;
+    notNull: true;
+    hasDefault: false;
+    isPrimaryKey: true;
+    isAutoincrement: false;
+    hasRuntimeDefault: false;
+    enumValues: undefined;
+    baseColumn: never;
+    identity: undefined;
+    generated: undefined;
+  }, {}, {}>;
+}, "partial", Record<"audit_log", "not-null">, false, "where" | "orderBy" | "limit", {
+  seq: bigint;
+}[], {
+  seq: import("drizzle-orm/pg-core").PgColumn<{
+    name: "seq";
+    tableName: "audit_log";
+    dataType: "bigint";
+    columnType: "PgBigInt64";
+    data: bigint;
+    driverParam: string;
+    notNull: true;
+    hasDefault: false;
+    isPrimaryKey: true;
+    isAutoincrement: false;
+    hasRuntimeDefault: false;
+    enumValues: undefined;
+    baseColumn: never;
+    identity: undefined;
+    generated: undefined;
+  }, {}, {}>;
+}>, "where" | "orderBy" | "limit">;
 /** How many entries in its name the vault reads back, a page at a time, for its own newest of a kind (`newestAuthentic`). */
 export declare const LOOK_BACK: {
   page: number;

package/dist/log.js

@@ -1,5 +1,5 @@
 import { t as afterCommit } from "./commits-BuW-NL3n.js";
-import { clockMillis, forUpdate } from "./dialect.js";
+import { clockMillis, engineOf, forUpdate } from "./dialect.js";
 import { a as prepared, i as tablesOf } from "./database-BadNeeN-.js";
 import { and, asc, count, desc, eq, gt, gte, lt, lte, sql } from "drizzle-orm";
 import { GENESIS_HASH, sealEntry } from "@coffre/core/audit";
@@ -69,13 +69,13 @@ const lockedHead = prepared((db) => {
 * log as it stands, which no other append can change until this one
 * commits. It throws to refuse.
 */
-async function appendEntries(tx, key, entries, check) {
+async function appendEntries(tx, key, entries, check, locked) {
 	if (entries.length === 0) throw new Error("appendEntries called with no entries");
 	const { auditChainHead, auditLog } = tablesOf(tx);
-	const head = await lockLogHead(tx);
+	const head = locked?.head ?? await lockLogHead(tx);
 	await check?.(tx);
-	const [{ now }] = await clockNow(tx);
-	const [last] = await lastEntry(tx);
+	const now = locked?.at ?? (await clockNow(tx))[0].now;
+	const last = locked === void 0 ? (await lastEntry(tx))[0] : locked.last ?? void 0;
 	const expected = last === void 0 ? {
 		nextSeq: 0n,
 		headHash: GENESIS_HASH
@@ -120,11 +120,15 @@ async function appendEntries(tx, key, entries, check) {
 		prevHash = hash;
 		seq += 1n;
 	}
-	await tx.insert(auditLog).values(rows);
-	await tx.update(auditChainHead).set({
-		nextSeq: seq,
-		headHash: prevHash
-	}).where(eq(auditChainHead.onlyRow, true));
+	if (engineOf(tx) === "postgres" && rows.length <= ROWS_AT_ONCE) await tx.execute(sql`WITH appended AS (${tx.insert(auditLog).values(rows).getSQL()})
+      UPDATE audit_chain_head SET next_seq = ${seq}, head_hash = ${prevHash} WHERE only_row`);
+	else {
+		await tx.insert(auditLog).values(rows);
+		await tx.update(auditChainHead).set({
+			nextSeq: seq,
+			headHash: prevHash
+		}).where(eq(auditChainHead.onlyRow, true));
+	}
 	const written = {
 		nextSeq: seq,
 		headHash: prevHash
@@ -136,6 +140,8 @@ async function appendEntries(tx, key, entries, check) {
 		occurredAt: now
 	};
 }
+/** Entries one statement inserts at most, at 21 parameters each: Postgres takes 65,535. */
+const ROWS_AT_ONCE = 3e3;
 const clockNow = prepared((db) => db.select({ now: clockMillis(db) }).from(tablesOf(db).auditChainHead));
 const lastEntry = prepared((db) => {
 	const { auditLog } = tablesOf(db);
@@ -260,10 +266,16 @@ async function newestVaultSeq(db, action) {
 	const [row] = await newestSeq(db, { action });
 	return row?.seq ?? null;
 }
-const newestSeq = prepared((db) => {
+const newestSeq = prepared((db) => newestSeqQuery(db, sql.placeholder("action")));
+/**
+* `newestVaultSeq`'s query, to run or to read inside another, as a
+* credential's read takes the newest `policy.change` with it: one rule for
+* what the newest is, wherever it is read.
+*/
+function newestSeqQuery(db, action) {
 	const { auditLog } = tablesOf(db);
-	return db.select({ seq: auditLog.seq }).from(auditLog).where(and(eq(auditLog.author, "vault"), eq(auditLog.action, sql.placeholder("action")), eq(auditLog.decision, "allow"))).orderBy(desc(auditLog.seq)).limit(1);
-});
+	return db.select({ seq: auditLog.seq }).from(auditLog).where(and(eq(auditLog.author, "vault"), eq(auditLog.action, action), eq(auditLog.decision, "allow"))).orderBy(desc(auditLog.seq)).limit(1);
+}
 /** How many entries in its name the vault reads back, a page at a time, for its own newest of a kind (`newestAuthentic`). */
 const LOOK_BACK = {
 	page: 32,
@@ -294,4 +306,4 @@ async function newestAuthentic(page, check) {
 	return "unreached";
 }
 //#endregion
-export { BATCH_BYTES, LOOK_BACK, LogHeadMismatch, LogRewound, appendEntries, entryColumns, forgetLogHeads, lockLogHead, missingEntry, newestAuthentic, newestVaultEntries, newestVaultSeq, withinBytes };
+export { BATCH_BYTES, LOOK_BACK, LogHeadMismatch, LogRewound, appendEntries, entryColumns, forgetLogHeads, lockLogHead, missingEntry, newestAuthentic, newestSeqQuery, newestVaultEntries, newestVaultSeq, withinBytes };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coffre/db",
-  "version": "0.10.1",
+  "version": "0.10.2",
   "description": "coffre's database: the schema, its migrations and the connections, on Postgres or SQLite.",
   "license": "MIT",
   "repository": {
@@ -79,7 +79,7 @@
     "drizzle-orm": "0.45.2",
     "pg": "8.16.3",
     "pg-connection-string": "2.14.0",
-    "@coffre/core": "0.10.1"
+    "@coffre/core": "0.10.2"
   },
   "devDependencies": {
     "@types/node": "26.1.1",

package/src/dialect.ts

@@ -49,6 +49,16 @@ export function forUpdate<Query extends { for: (strength: 'update' | 'no key upd
   return query.for(strength) as ReturnType<Query['for']>;
 }
 
+/**
+ * The rows a hand-written query answers, as the driver gives them: what
+ * Postgres's `execute` and SQLite's `all` each call a result. Column names
+ * are the query's own, unmapped.
+ */
+export async function rowsOf<Row>(db: Queryable, query: SQL): Promise<Row[]> {
+  if (engineOf(db) === 'postgres') return (await (db as unknown as { execute(query: SQL): Promise<{ rows: Row[] }> }).execute(query)).rows;
+  return (db as unknown as { all<R>(query: SQL): Promise<R[]> }).all<Row>(query);
+}
+
 /** Insert the rows whose unique keys are free; returns how many that was. */
 export async function insertIfAbsent(db: Queryable, table: Table, rows: object[]): Promise<number> {
   return changedRows(await db.insert(table).values(rows as never).onConflictDoNothing());

package/src/log.ts

@@ -1,10 +1,10 @@
 import { GENESIS_HASH, sealEntry, type LogFields, type LogKey, type StoredEntry } from '@coffre/core/audit';
-import { and, asc, count, desc, eq, gt, gte, lt, lte, sql, type SQL } from 'drizzle-orm';
+import { and, asc, count, desc, eq, gt, gte, lt, lte, sql, type Placeholder, type SQL } from 'drizzle-orm';
 
 import { afterCommit } from './commits.ts';
 import { tablesOf, type Queryable, type Transaction } from './database.ts';
 import { prepared } from './prepared.ts';
-import { clockMillis, forUpdate } from './dialect.ts';
+import { clockMillis, engineOf, forUpdate } from './dialect.ts';
 
 /**
  * Appending to the audit log, the one table both the app and the vault
@@ -124,15 +124,21 @@ export async function appendEntries(
   key: LogKey,
   entries: readonly NewEntry[],
   check?: (tx: Transaction) => Promise<void>,
+  /**
+   * The head as a statement of the caller's locked it, with the log's last
+   * entry and the clock as that statement read them once it held the lock:
+   * nothing to read again.
+   */
+  locked?: HeldHead,
 ): Promise<Appended> {
   if (entries.length === 0) throw new Error('appendEntries called with no entries');
   const { auditChainHead, auditLog } = tablesOf(tx);
 
   // Every append queues here, if its transaction has not already.
-  const head = await lockLogHead(tx);
+  const head = locked?.head ?? (await lockLogHead(tx));
   await check?.(tx);
-  const [{ now }] = await clockNow(tx);
-  const [last] = await lastEntry(tx);
+  const now = locked?.at ?? (await clockNow(tx))[0]!.now;
+  const last = locked === undefined ? (await lastEntry(tx))[0] : locked.last ?? undefined;
 
   const expected = last === undefined ? { nextSeq: 0n, headHash: GENESIS_HASH } : { nextSeq: last.seq + 1n, headHash: last.hash };
   if (head.nextSeq !== expected.nextSeq || !head.headHash.equals(expected.headHash)) {
@@ -179,13 +185,25 @@ export async function appendEntries(
     seq += 1n;
   }
 
-  await tx.insert(auditLog).values(rows);
-  await tx.update(auditChainHead).set({ nextSeq: seq, headHash: prevHash }).where(eq(auditChainHead.onlyRow, true));
+  if (engineOf(tx) === 'postgres' && rows.length <= ROWS_AT_ONCE) {
+    // The entries and the head that names the last of them, in one statement.
+    await tx.execute(sql`WITH appended AS (${tx.insert(auditLog).values(rows).getSQL()})
+      UPDATE audit_chain_head SET next_seq = ${seq}, head_hash = ${prevHash} WHERE only_row`);
+  } else {
+    await tx.insert(auditLog).values(rows);
+    await tx.update(auditChainHead).set({ nextSeq: seq, headHash: prevHash }).where(eq(auditChainHead.onlyRow, true));
+  }
   const written = { nextSeq: seq, headHash: prevHash };
   afterCommit(tx, () => remember(key, written));
   return { seqStart: head.nextSeq, ...written, occurredAt: now };
 }
 
+/** A head locked by a statement of the caller's, and what it read under the lock (`appendEntries`). */
+export type HeldHead = { head: { nextSeq: bigint; headHash: Buffer }; last: { seq: bigint; hash: Buffer } | null; at: number };
+
+/** Entries one statement inserts at most, at 21 parameters each: Postgres takes 65,535. */
+const ROWS_AT_ONCE = 3000;
+
 const clockNow = prepared((db) => db.select({ now: clockMillis(db) }).from(tablesOf(db).auditChainHead));
 
 const lastEntry = prepared((db) => {
@@ -325,15 +343,22 @@ export async function newestVaultSeq(db: Queryable, action: string): Promise<big
   return (row?.seq as bigint | undefined) ?? null;
 }
 
-const newestSeq = prepared((db) => {
+const newestSeq = prepared((db) => newestSeqQuery(db, sql.placeholder('action')));
+
+/**
+ * `newestVaultSeq`'s query, to run or to read inside another, as a
+ * credential's read takes the newest `policy.change` with it: one rule for
+ * what the newest is, wherever it is read.
+ */
+export function newestSeqQuery(db: Queryable, action: string | Placeholder) {
   const { auditLog } = tablesOf(db);
   return db
     .select({ seq: auditLog.seq })
     .from(auditLog)
-    .where(and(eq(auditLog.author, 'vault'), eq(auditLog.action, sql.placeholder('action')), eq(auditLog.decision, 'allow')))
+    .where(and(eq(auditLog.author, 'vault'), eq(auditLog.action, action), eq(auditLog.decision, 'allow')))
     .orderBy(desc(auditLog.seq))
     .limit(1);
-});
+}
 
 /** How many entries in its name the vault reads back, a page at a time, for its own newest of a kind (`newestAuthentic`). */
 export const LOOK_BACK = { page: 32, pages: 32 };