@rexezuge/d1 1.0.0 → 1.0.2

package/README.md

@@ -0,0 +1,76 @@
+# @rexezuge/d1
+
+D1 retry engine, error classifier, `BaseDAO`, SQL splitter, and AES-GCM envelope.
+
+Depends on `@rexezuge/errors` (failures surface as `DatabaseError` with the classifier's verdict in `retryable`) and `@rexezuge/shared` (base64 for the crypto envelope).
+
+```bash
+pnpm add @rexezuge/d1
+```
+
+---
+
+## 1. Retry engine
+
+One engine, one schedule — the seven consumer repos each spelled this differently, and divergent schedules were the drift:
+
+```ts
+import { D1_RETRY_DEFAULTS, executeWithRetry } from '@rexezuge/d1';
+
+const row = await executeWithRetry((db) => db.prepare('SELECT * FROM users WHERE id = ?').bind(id).first(), {
+  maxRetries: D1_RETRY_DEFAULTS.maxRetries, // 3, exponential backoff from 100ms via backoffMs()
+});
+```
+
+Both D1 failure shapes are handled: a resolved `success: false` result and a thrown transport error are classified from the message the same way (`isD1ErrorRetryable` / `RETRYABLE_PATTERNS` / `NON_RETRYABLE_PATTERNS`). `BaseDAO` is the intended caller; call it directly only for statements outside a DAO.
+
+## 2. `BaseDAO` and types
+
+```ts
+import { BaseDAO, assertSqlIdentifier } from '@rexezuge/d1';
+
+class UserDAO extends BaseDAO {
+  public getById(id: string) {
+    return this.first('SELECT * FROM users WHERE id = ?', [id]);
+  }
+}
+```
+
+`BaseDAO` wraps every statement in the retry engine. `D1Queryable` / `D1PreparedStatement` / `D1Result` are structural types, so fakes, Miniflare, and real D1 bindings all satisfy them. `assertSqlIdentifier` guards the one thing bindings cannot parameterize — table/column names.
+
+## 3. SQL splitting and schema errors
+
+```ts
+import { executableStatements, isMissingSchemaError, splitSql } from '@rexezuge/d1';
+
+const statements = executableStatements(migrationSql); // trigger-aware; comments/stripped, one batch per file
+try {
+  await dao.get(normalized);
+} catch (error: unknown) {
+  if (isMissingSchemaError(error)) return null; // migration hasn't run — the only safe fall-through
+  throw error; // every other failure is an outage, never a silent null
+}
+```
+
+`splitSql` / `isExecutable` power both migrations and `@rexezuge/tooling`'s integration-migration test helper, so a kit migration and a test suite can never disagree about where one statement ends.
+
+## 4. AES-GCM secrets
+
+```ts
+import { decryptSecret, encryptSecret } from '@rexezuge/d1';
+
+const { ciphertext, iv } = await encryptSecret(clientSecret, env.BACKUP_ENCRYPTION_KEY); // store the pair
+const cleartext = await decryptSecret(ciphertext, iv, env.BACKUP_ENCRYPTION_KEY);
+```
+
+Key material is base64 of exactly 32 bytes; a missing or wrong-sized key throws `AesGcmKeyError` rather than storing the secret in the clear. The IV is random per call — reusing one under a key destroys GCM's guarantees, which is why it is returned alongside the ciphertext instead of being internal.
+
+---
+
+## Verifying this package
+
+```bash
+pnpm --filter @rexezuge/d1 exec tsc -p tsconfig.json
+pnpm --filter @rexezuge/d1 typecheck
+pnpm --filter @rexezuge/d1 test
+```

package/dist/BaseDAO.d.ts

@@ -3,65 +3,53 @@ import type { D1PreparedStatement, D1Queryable, D1Result } from './D1Types';
 /**
  * Canonical DAO base: retry is a policy, methods are a promise.
  *
- * Converged from the nine consumer repos' `BaseDAO`s, which had drifted into
- * seven spellings of the same idea (`withRetry`, `runWithRetry`,
- * `runWriteStatement`, `firstWithRetry`, `allWithRetry`, `runWriteBatch`, plus
- * Mail-Meow's static `findById`). The kit ships one straight-line surface —
- * **clients adapt to these names** — with the non-DAO concerns extracted:
+ * Converged from the nine consumer repos' BaseDAOs. The API is the **sql-first**
+ * shape CalDAV-Bridge and ChordDHT-Tracker used, not the closure-first shape
+ * Durable-DAV's family used: a DAO states its SQL and bindings directly, and
+ * the retry/normalization wrapper is invisible at the call site. The closure
+ * form made every read site pay for a wrapper 90% of them never needed, and
+ * each of the two shapes drifted its own method names (`withRetry` vs
+ * `run(sql, bindings)`); the sql-first form is what survived.
  *
- * - cursor pagination moved to `@rexezuge/shared`'s `CursorCodec` (it is a
- *   codec, not a DAO method);
- * - subrequest accounting became an injected concern, so the seven repos that
- *   never needed it do not inherit it;
- * - retry policy lives in `D1Retry` — one schedule, one classifier, one place
- *   the `Failed to <context>` prefix is added.
- *
- * Identifier safety: `table`/`column` names cannot be bound, so the two methods
- * that interpolate them (`deleteOlderThan`) allow-list each segment against
- * `/^[A-Za-z_][A-Za-z0-9_]*$/`. Everything else in a statement goes through
- * `.bind()`.
+ * Non-DAO concerns stay out: cursor pagination lives in `@rexezuge/shared`
+ * (`CursorCodec`), subrequest accounting is an injectable port. Retry policy
+ * lives in `D1Retry` — one schedule, one classifier, one place the
+ * `Failed to <context>` prefix is added.
  */
 declare abstract class BaseDAO {
     protected readonly database: D1Queryable;
     protected constructor(database: D1Queryable);
+    /** A prepared statement with its bindings applied. Bindings are always parameters, never interpolation. */
+    protected statement(sql: string, bindings?: unknown[]): D1PreparedStatement;
     /**
-     * A mutating statement with retry and a guaranteed `DatabaseError` on
-     * failure. Every write in this layer goes through here: hand-rolling
-     * `.run()` plus `if (!result.success) throw` silently produced
-     * `retryable: false` and skipped the retry entirely — which left the most
-     * failure-sensitive writes with no recovery from a transient D1 lock.
-     */
-    protected run(statement: () => Promise<D1Result>, context: string): Promise<D1Result>;
-    /**
-     * A point read. `first()` resolving to `null` is "no row", a success, not an
-     * error — only a rejected statement is retried and normalized.
+     * Run a statement. D1 reports a constraint violation or a missing table by
+     * returning `success: false` rather than by throwing, so both forms are
+     * normalized to a `DatabaseError` here — ignoring the result form is what
+     * let a `UNIQUE` failure reach a caller as an opaque 500.
      */
-    protected first<T>(statement: () => Promise<T | null>, context: string): Promise<T | null>;
+    protected run(sql: string, bindings?: unknown[]): Promise<D1Result>;
     /**
-     * A list read. `.all()` returning `[]` is a success like `first()`'s `null`.
-     * Separate from `run` because that one is typed for a write's `D1Result`;
-     * a list read had no retry at all in the drifted copies.
+     * Read one row. `first()` resolving to `null` is "no row", a success, not an
+     * error; only a rejected statement is retried and normalized. Callers get
+     * `undefined` — the shape every repo's row check (`row ? … : …`) already
+     * treats as absent, unlike a null.
      */
-    protected all<T>(statement: () => Promise<{
-        results?: T[];
-    }>, context: string): Promise<T[]>;
-    /** A scalar count from a `SELECT count(*) AS count` row; 0 when absent. */
-    protected count(statement: () => Promise<{
-        count: number;
-    } | null>, context: string): Promise<number>;
+    protected first<T>(sql: string, bindings?: unknown[]): Promise<T | undefined>;
+    /** A list read. `.all()` returning `[]` is a success like `first()`'s null. */
+    protected all<T>(sql: string, bindings?: unknown[]): Promise<T[]>;
+    /** A scalar count from a `SELECT count(*)` row; 0 when absent. */
+    protected count(sql: string, bindings?: unknown[]): Promise<number>;
     /**
-     * A batch of prepared statements, retried as a unit and unwrapped to the
-     * per-statement results D1 returns. A single non-success result inside the
-     * batch is what the engine classifies and retries.
+     * A batch of prepared statements — one transaction and one subrequest,
+     * however many statements it carries. Each result is checked, so a single
+     * failure inside the batch raises rather than passing silently.
      */
-    protected batch(statements: D1PreparedStatement[], context: string): Promise<D1Result[]>;
+    protected batch(statements: D1PreparedStatement[]): Promise<D1Result[]>;
     /**
      * Generic batched delete of rows older than a cutoff, in ID order, with
      * retry. Mirrors the per-DAO `DELETE ... WHERE id IN (SELECT ... LIMIT ?)`
-     * pattern that every repo re-implemented per table.
-     *
-     * `timeColumn` is compared against `<` — the cutoff is exclusive, so a
-     * delete never touches a row at exactly the boundary timestamp.
+     * pattern that every repo re-implemented per table. The cutoff is exclusive:
+     * a delete never touches a row at exactly the boundary timestamp.
      */
     protected static deleteOlderThan(db: D1Queryable, table: string, timeColumn: string, cutoff: number | string, limit: number, idColumn: string): Promise<number>;
     /** The retry schedule, for callers that surface it (health checks, tests). */

package/dist/BaseDAO.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BaseDAO.d.ts","sourceRoot":"","sources":["../src/BaseDAO.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,iBAAiB,EAAoB,MAAM,WAAW,CAAC;AAChE,OAAO,KAAK,EAAE,mBAAmB,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAU5E;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,uBAAe,OAAO;IACE,SAAS,CAAC,QAAQ,CAAC,QAAQ,EAAE,WAAW;IAA9D,SAAS,aAAgC,QAAQ,EAAE,WAAW;IAE9D;;;;;;OAMG;cACa,GAAG,CAAC,SAAS,EAAE,MAAM,OAAO,CAAC,QAAQ,CAAC,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC;IAI3F;;;OAGG;cACa,KAAK,CAAC,CAAC,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC;IAQhG;;;;OAIG;cACa,GAAG,CAAC,CAAC,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;QAAE,OAAO,CAAC,EAAE,CAAC,EAAE,CAAA;KAAE,CAAC,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC;IAQlG,2EAA2E;cAC3D,KAAK,CACnB,SAAS,EAAE,MAAM,OAAO,CAAC;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC,EAClD,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,MAAM,CAAC;IAKlB;;;;OAIG;cACa,KAAK,CAAC,UAAU,EAAE,mBAAmB,EAAE,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAC;IAgB9F;;;;;;;OAOG;qBACoB,eAAe,CACpC,EAAE,EAAE,WAAW,EACf,KAAK,EAAE,MAAM,EACb,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,MAAM,GAAG,MAAM,EACvB,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,MAAM,CAAC;IAsBlB,8EAA8E;IAC9E,SAAS,CAAC,MAAM,KAAK,aAAa,IAAI,OAAO,iBAAiB,CAE7D;CACF;AAED;;;;GAIG;AACH,iBAAS,mBAAmB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAI/D;AAED,OAAO,EAAE,OAAO,EAAE,mBAAmB,EAAE,CAAC"}
+{"version":3,"file":"BaseDAO.d.ts","sourceRoot":"","sources":["../src/BaseDAO.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,iBAAiB,EAAoB,MAAM,WAAW,CAAC;AAChE,OAAO,KAAK,EAAE,mBAAmB,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAU5E;;;;;;;;;;;;;;;GAeG;AACH,uBAAe,OAAO;IACE,SAAS,CAAC,QAAQ,CAAC,QAAQ,EAAE,WAAW;IAA9D,SAAS,aAAgC,QAAQ,EAAE,WAAW;IAE9D,2GAA2G;IAC3G,SAAS,CAAC,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,GAAE,OAAO,EAAO,GAAG,mBAAmB;IAI/E;;;;;OAKG;cACa,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,GAAE,OAAO,EAAO,GAAG,OAAO,CAAC,QAAQ,CAAC;IAI7E;;;;;OAKG;cACa,KAAK,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,QAAQ,GAAE,OAAO,EAAO,GAAG,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC;IAQvF,+EAA+E;cAC/D,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,QAAQ,GAAE,OAAO,EAAO,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC;IAQ3E,kEAAkE;cAClD,KAAK,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,GAAE,OAAO,EAAO,GAAG,OAAO,CAAC,MAAM,CAAC;IAK7E;;;;OAIG;cACa,KAAK,CAAC,UAAU,EAAE,mBAAmB,EAAE,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAC;IAa7E;;;;;OAKG;qBACoB,eAAe,CACpC,EAAE,EAAE,WAAW,EACf,KAAK,EAAE,MAAM,EACb,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,MAAM,GAAG,MAAM,EACvB,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,MAAM,CAAC;IAsBlB,8EAA8E;IAC9E,SAAS,CAAC,MAAM,KAAK,aAAa,IAAI,OAAO,iBAAiB,CAE7D;CACF;AAED;;;;GAIG;AACH,iBAAS,mBAAmB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAI/D;AAED,OAAO,EAAE,OAAO,EAAE,mBAAmB,EAAE,CAAC"}

package/dist/BaseDAO.js

@@ -3,94 +3,86 @@ import { D1_RETRY_DEFAULTS, executeWithRetry } from './D1Retry';
 /**
  * Canonical DAO base: retry is a policy, methods are a promise.
  *
- * Converged from the nine consumer repos' `BaseDAO`s, which had drifted into
- * seven spellings of the same idea (`withRetry`, `runWithRetry`,
- * `runWriteStatement`, `firstWithRetry`, `allWithRetry`, `runWriteBatch`, plus
- * Mail-Meow's static `findById`). The kit ships one straight-line surface —
- * **clients adapt to these names** — with the non-DAO concerns extracted:
+ * Converged from the nine consumer repos' BaseDAOs. The API is the **sql-first**
+ * shape CalDAV-Bridge and ChordDHT-Tracker used, not the closure-first shape
+ * Durable-DAV's family used: a DAO states its SQL and bindings directly, and
+ * the retry/normalization wrapper is invisible at the call site. The closure
+ * form made every read site pay for a wrapper 90% of them never needed, and
+ * each of the two shapes drifted its own method names (`withRetry` vs
+ * `run(sql, bindings)`); the sql-first form is what survived.
  *
- * - cursor pagination moved to `@rexezuge/shared`'s `CursorCodec` (it is a
- *   codec, not a DAO method);
- * - subrequest accounting became an injected concern, so the seven repos that
- *   never needed it do not inherit it;
- * - retry policy lives in `D1Retry` — one schedule, one classifier, one place
- *   the `Failed to <context>` prefix is added.
- *
- * Identifier safety: `table`/`column` names cannot be bound, so the two methods
- * that interpolate them (`deleteOlderThan`) allow-list each segment against
- * `/^[A-Za-z_][A-Za-z0-9_]*$/`. Everything else in a statement goes through
- * `.bind()`.
+ * Non-DAO concerns stay out: cursor pagination lives in `@rexezuge/shared`
+ * (`CursorCodec`), subrequest accounting is an injectable port. Retry policy
+ * lives in `D1Retry` — one schedule, one classifier, one place the
+ * `Failed to <context>` prefix is added.
  */
 class BaseDAO {
     database;
     constructor(database) {
         this.database = database;
     }
+    /** A prepared statement with its bindings applied. Bindings are always parameters, never interpolation. */
+    statement(sql, bindings = []) {
+        return bindings.length > 0 ? this.database.prepare(sql).bind(...bindings) : this.database.prepare(sql);
+    }
     /**
-     * A mutating statement with retry and a guaranteed `DatabaseError` on
-     * failure. Every write in this layer goes through here: hand-rolling
-     * `.run()` plus `if (!result.success) throw` silently produced
-     * `retryable: false` and skipped the retry entirely — which left the most
-     * failure-sensitive writes with no recovery from a transient D1 lock.
+     * Run a statement. D1 reports a constraint violation or a missing table by
+     * returning `success: false` rather than by throwing, so both forms are
+     * normalized to a `DatabaseError` here — ignoring the result form is what
+     * let a `UNIQUE` failure reach a caller as an opaque 500.
      */
-    async run(statement, context) {
-        return executeWithRetry(statement, context);
+    async run(sql, bindings = []) {
+        return executeWithRetry(() => this.statement(sql, bindings).run(), 'run statement');
     }
     /**
-     * A point read. `first()` resolving to `null` is "no row", a success, not an
-     * error — only a rejected statement is retried and normalized.
+     * Read one row. `first()` resolving to `null` is "no row", a success, not an
+     * error; only a rejected statement is retried and normalized. Callers get
+     * `undefined` — the shape every repo's row check (`row ? … : …`) already
+     * treats as absent, unlike a null.
      */
-    async first(statement, context) {
+    async first(sql, bindings = []) {
         const envelope = await executeWithRetry(async () => {
-            const value = await statement();
-            return { success: true, value };
-        }, context);
-        return envelope.value;
+            const row = await this.statement(sql, bindings).first();
+            return { success: true, value: row };
+        }, 'read a row');
+        return envelope.value ?? undefined;
     }
-    /**
-     * A list read. `.all()` returning `[]` is a success like `first()`'s `null`.
-     * Separate from `run` because that one is typed for a write's `D1Result`;
-     * a list read had no retry at all in the drifted copies.
-     */
-    async all(statement, context) {
+    /** A list read. `.all()` returning `[]` is a success like `first()`'s null. */
+    async all(sql, bindings = []) {
         const envelope = await executeWithRetry(async () => {
-            const rows = await statement();
+            const rows = await this.statement(sql, bindings).all();
             return { success: true, value: rows.results ?? [] };
-        }, context);
+        }, 'read rows');
         return envelope.value;
     }
-    /** A scalar count from a `SELECT count(*) AS count` row; 0 when absent. */
-    async count(statement, context) {
-        const row = await this.first(statement, context);
+    /** A scalar count from a `SELECT count(*)` row; 0 when absent. */
+    async count(sql, bindings = []) {
+        const row = await this.first(sql, bindings);
         return row?.count ?? 0;
     }
     /**
-     * A batch of prepared statements, retried as a unit and unwrapped to the
-     * per-statement results D1 returns. A single non-success result inside the
-     * batch is what the engine classifies and retries.
+     * A batch of prepared statements — one transaction and one subrequest,
+     * however many statements it carries. Each result is checked, so a single
+     * failure inside the batch raises rather than passing silently.
      */
-    async batch(statements, context) {
+    async batch(statements) {
+        if (statements.length === 0)
+            return [];
         if (this.database.batch === undefined) {
-            throw new DatabaseError(`Batch is not supported for ${context}: the D1 binding exposes no batch()`);
+            throw new DatabaseError('The D1 binding exposes no batch() — a multi-statement transaction is not available here');
         }
         const envelope = await executeWithRetry(async () => {
             const results = await this.database.batch(statements);
             const failed = results.find((result) => !result.success);
-            return {
-                success: failed === undefined,
-                error: failed?.error,
-                value: results,
-            };
-        }, context);
+            return { success: failed === undefined, error: failed?.error, value: results };
+        }, 'run a batch');
         return envelope.value;
     }
     /**
      * Generic batched delete of rows older than a cutoff, in ID order, with
      * retry. Mirrors the per-DAO `DELETE ... WHERE id IN (SELECT ... LIMIT ?)`
-     * pattern that every repo re-implemented per table.
-     *
-     * `timeColumn` is compared against `<` — the cutoff is exclusive, so a
-     * delete never touches a row at exactly the boundary timestamp.
+     * pattern that every repo re-implemented per table. The cutoff is exclusive:
+     * a delete never touches a row at exactly the boundary timestamp.
      */
     static async deleteOlderThan(db, table, timeColumn, cutoff, limit, idColumn) {
         assertSqlIdentifier(table, 'table');

package/dist/BaseDAO.js.map

@@ -1 +1 @@
-{"version":3,"file":"BaseDAO.js","sourceRoot":"","sources":["../src/BaseDAO.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"BaseDAO.js","sourceRoot":"","sources":["../src/BaseDAO.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rexezuge/d1",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "private": false,
   "license": "MIT",
   "repository": {
@@ -25,14 +25,15 @@
     "dist"
   ],
   "dependencies": {
-    "@rexezuge/shared": "1.0.0",
-    "@rexezuge/errors": "1.0.0"
+    "@rexezuge/errors": "1.0.2",
+    "@rexezuge/shared": "1.0.2"
   },
   "devDependencies": {
     "@types/node": "26.6.4",
     "typescript": "6.0.3",
     "vitest": "4.1.11"
   },
+  "description": "D1 retry engine, error classifier, BaseDAO, SQL splitter, and AES-GCM envelope.",
   "scripts": {
     "build": "tsc -p tsconfig.json",
     "typecheck": "tsc -p tsconfig.test.json --noEmit",