@pitlane/data-table-d1 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,70 @@
+# @pitlane/data-table-d1
+
+## 0.1.0
+
+Initial release.
+
+- `createD1Database(binding, options?)` wraps a Cloudflare D1 binding in a
+  `Database` from `remix/data-table`. `D1Database` is the subclass it returns
+  and `D1DatabaseDriver` the bare `DatabaseDriver<"sqlite">`, matching the shape
+  of `SqliteDatabase` and `PostgresDatabase`.
+- Exists because `@remix-run/data-table-sqlite` drives a synchronous client —
+  `prepare(sql).all()` returns rows rather than a promise, as `better-sqlite3`
+  and `node:sqlite` do — and D1 is an awaited RPC binding. No adapter bridges
+  that, so a D1 app could not use the SQLite driver at all. The SQL is still
+  SQLite's, so this pairs that compiler with an async driver.
+- Transactions throw by default, naming `d1.batch()` and the opt-in below. D1
+  rejects `BEGIN`, `COMMIT`, and `SAVEPOINT` at the SQL layer, and `batch()`
+  wants every statement up front, which cannot express the interleaved
+  begin/execute/commit a `Database` transaction drives. Capabilities report
+  `savepoints: false` and `transactionalDdl: false` rather than failing
+  mid-write.
+- `transactions: "unsafe-nonatomic"` opts out of that refusal, for callers
+  shared with a backend that does have transactions where running without
+  atomicity beats not running. `transaction()` then runs the callback with each
+  statement committing on its own, so a failure part-way leaves the earlier
+  writes persisted — asserted against real D1, not just described. Rollback
+  stays silent so the callback's own error surfaces instead of an
+  `AggregateError` about an impossible rollback, and nesting still fails in
+  both modes because `savepoints: false` stops it upstream of the driver.
+- `db.batch(statements)` runs statements atomically through D1's `batch()`,
+  which is its one atomic primitive and the reason it cannot back
+  `transaction()`. A failing statement rolls the whole batch back, asserted
+  against real D1. Inputs are `SqlStatement`s from `remix/data-table`'s `sql`
+  tag rather than query-builder calls, because `data-table` exposes no way to
+  build an operation without running it — `create` and `updateMany` execute on
+  call and `Query` has no `toSql()`. The point is that reaching for atomicity
+  no longer means reaching for the raw binding.
+- `wipe()` drops the application's tables, leaving D1's `_cf_*` and SQLite's
+  `sqlite_*` bookkeeping in place. The pragma that permits the drops travels in
+  the same `batch()` as the drops, because it is per-session and D1 gives each
+  statement its own session.
+- `generateD1Migrations()`, from the `@pitlane/data-table-d1/migrations` entry
+  point, compiles `data-table` migrations into the flat `.sql` files Wrangler's
+  D1 migration runner reads. Production migrations then go through Wrangler's
+  own workflow, which is what four apps in the wild had each hand-rolled: two
+  byte-identical copies of one generator, and two more that drifted to 74 and
+  101 lines from a common ancestor. SQL is copied verbatim rather than split
+  into statements, so a semicolon inside a trigger body survives; the output
+  directory is pruned to match the source; and files that are not generated
+  artifacts are left alone. Node-only, and a separate entry point so it stays
+  out of Worker bundles.
+- Raw statements always come back with a rows array. The SQLite driver asks a
+  prepared statement whether it returns columns; D1 exposes no equivalent, and
+  its `all()` carries both `results` and `meta` regardless.
+- `onStatement` reports what each statement cost —
+  `{ kind, table, rowsRead, rowsWritten, durationMs }` — off the `meta` D1
+  already returns. D1 bills on rows read and written and reports analytics per
+  database, so this is the only per-query attribution available, and it costs
+  no extra statement. Observer throws are swallowed, statements that throw are
+  not reported, and figures D1 omits come through as `0` rather than estimated.
+  The idea is [`@pkg/data-table-d1`](https://github.com/sergiodxa/monorepo/tree/main/packages/data-table-d1)'s.
+- The D1 API is declared structurally, so the package pulls in no Cloudflare
+  types and no ambient globals.
+- `src/sql-compiler.ts` is vendored verbatim from
+  `@remix-run/data-table-sqlite@0.6.0` (MIT, Copyright (c) 2025 Shopify Inc.),
+  with only its import specifiers repointed at the public `remix/*` subpaths.
+  Upstream keeps `compileSqliteOperation` internal and publishes no D1 dialect;
+  the file goes away if either changes.
+- Tested against `remix@3.0.0-beta.10`, with the query, write, count, schema and
+  wipe paths exercised inside real workerd through Miniflare.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mark Malstrom
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/LICENSE.remix

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Shopify Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,144 @@
+# @pitlane/data-table-d1
+
+A [Cloudflare D1](https://developers.cloudflare.com/d1/) driver for [Remix 3](https://remix.run)'s `data-table`.
+
+```ts
+import { createD1Database } from "@pitlane/data-table-d1";
+import { env } from "cloudflare:workers";
+
+let db = createD1Database(env.DB);
+
+let post = await db.create(Post, { title: "Hello" }, { returnRow: true });
+let recent = await db.query(Post).orderBy({ createdAt: "desc" }).limit(10).all();
+```
+
+That is a `Database` from `remix/data-table`, so every query, persistence, and migration method behaves exactly as it does on SQLite or Postgres.
+
+## Install
+
+```sh
+npm install @pitlane/data-table-d1
+# or
+vp add @pitlane/data-table-d1
+```
+
+Requires `remix@^3.0.0-beta.10` as a peer. Nothing else: the D1 API is described structurally, so you do not need `@cloudflare/workers-types` unless your own code already does.
+
+## Why this package exists
+
+D1 is SQLite, so the SQL is SQLite's. The execution model is not.
+
+`@remix-run/data-table-sqlite` drives a **synchronous** client — `prepare(sql).all()` returns rows, not a promise, because that is the shape `better-sqlite3` and `node:sqlite` have. D1 is an RPC binding: every call is awaited. No adapter closes that gap, so a D1 app cannot use the SQLite driver at all.
+
+What it can reuse is the SQL. This package pairs the SQLite SQL compiler with a driver written against D1's async prepared-statement API.
+
+## API
+
+### `createD1Database(binding, options?)`
+
+Wraps a D1 binding in a `Database`. `binding` is `env.DB`; `options` takes everything `Database` takes, plus `onStatement`.
+
+### `D1Database`
+
+The `Database` subclass, if you would rather construct it yourself. Same shape as `SqliteDatabase` and `PostgresDatabase`.
+
+### `D1DatabaseDriver`
+
+The bare `DatabaseDriver<"sqlite">`, for handing to `Database` directly or wrapping.
+
+### `D1Binding`
+
+The slice of D1 this package uses: `prepare`, `batch`, `exec`. A real binding satisfies it, and so does a test double.
+
+### `generateD1Migrations(options)`
+
+Compiles `data-table` migrations into the flat `.sql` files Wrangler's D1 migration runner reads, so production migrations go through Wrangler's own workflow instead of a hand-rolled script:
+
+```ts
+import { generateD1Migrations } from "@pitlane/data-table-d1/migrations";
+
+await generateD1Migrations({ to: "db/d1-migrations" });
+```
+
+Reads `db/migrations` unless told otherwise, writes one `<id>_<name>.sql` per migration, and deletes generated files whose migration is gone. SQL is copied verbatim, so semicolons inside trigger bodies survive.
+
+Node-only build tooling, which is why it is a separate entry point. It never enters a Worker bundle.
+
+### `onStatement`
+
+Called after each executed statement with what it cost:
+
+```ts
+let usage = { rowsRead: 0, rowsWritten: 0 };
+
+let db = createD1Database(env.DB, {
+    onStatement({ rowsRead, rowsWritten }) {
+        usage.rowsRead += rowsRead;
+        usage.rowsWritten += rowsWritten;
+    },
+});
+```
+
+D1 bills on rows read and written, and its analytics report per database rather than per query, so this is the only way to attribute cost to the query or the request that caused it. The figures ride on responses the driver already reads, so it costs no extra statement and no extra billable operation.
+
+The report is `{ kind, table, rowsRead, rowsWritten, durationMs }`. It runs once per statement on the hot path, so keep it cheap. Anything it throws is swallowed rather than failing the statement it was measuring. A statement that throws is not reported, because D1 returns no metadata for one and a zeroed entry would read as free. Figures D1 omits come through as `0`, never estimated.
+
+### Reuse the database
+
+A binding is stable for the isolate, so build the database once rather than per request:
+
+```ts
+let db: D1Database | null = null;
+
+export default {
+    fetch(request, env) {
+        db ??= createD1Database(env.DB);
+        // …
+    },
+};
+```
+
+## What D1 cannot do
+
+**Several writes that must commit together** use `db.batch()`, which is D1's one atomic primitive and the reason it cannot back `transaction()`:
+
+```ts
+import { sql } from "remix/data-table";
+
+await db.batch([
+    sql`insert into post (title) values (${title})`,
+    sql`update counter set posts = posts + 1`,
+]);
+```
+
+If any statement fails the whole batch rolls back. They are `SqlStatement`s rather than query-builder calls because `data-table` exposes no way to build an operation without running it; `sql` still parameterises the values, so the raw binding stays out of your application code.
+
+**Transactions throw by default.** D1 rejects `BEGIN`, `COMMIT`, and `SAVEPOINT` at the SQL layer and offers `d1.batch()` instead, which takes every statement up front. That cannot express the interleaved begin/execute/commit a `Database` transaction drives, so the driver reports `savepoints: false` and `transactionalDdl: false` and throws a message pointing at `batch()`. Failing at the call beats failing halfway through a write that cannot be rolled back.
+
+When the caller is shared with a backend that does have transactions, and running without atomicity beats not running at all, opt in:
+
+```ts
+let db = createD1Database(env.DB, { transactions: "unsafe-nonatomic" });
+```
+
+`transaction()` then runs the callback and each statement commits on its own. **A failure part-way leaves the earlier writes persisted**, because there is nothing to roll back — that is the whole of what you are accepting, and the package has a test against real D1 asserting exactly that outcome. Rollback stays silent rather than throwing, so the callback's own error is what surfaces instead of an `AggregateError` about an impossible rollback. Nested transactions still fail in both modes, since `savepoints: false` makes `Database` reject them before the driver is reached.
+
+**`wipe()` drops tables rather than deleting a file.** There is no file. D1's own `_cf_*` bookkeeping and SQLite's `sqlite_*` tables are left alone; dropping either breaks the binding.
+
+Everything else — `returning`, upserts, bulk inserts, migrations, schema inspection — works.
+
+## Prior art
+
+[`@pkg/data-table-d1`](https://github.com/sergiodxa/monorepo/tree/main/packages/data-table-d1) by Sergio Xalambrí solves the same problem, and `onStatement` is its idea. It also takes the other side of the transaction question, running them non-atomically so shared code keeps working; this package makes that the opt-in above rather than the default, on the grounds that a silent loss of atomicity should be something you asked for. It reports `transactionalDdl: true`, where this one keeps it `false` in both modes, since a non-transaction cannot make DDL transactional.
+
+Its sibling [`@pkg/data-table-sqlstorage`](https://github.com/sergiodxa/monorepo/tree/main/packages/data-table-sqlstorage) covers Durable Object SQLite, which is synchronous and does support real transactions.
+
+## Provenance
+
+`src/sql-compiler.ts` is vendored verbatim from [`@remix-run/data-table-sqlite@0.6.0`](https://www.npmjs.com/package/@remix-run/data-table-sqlite) (MIT, Copyright (c) 2025 Shopify Inc.; the licence is in `LICENSE.remix`). Only its two import specifiers changed, from the private `@remix-run/data-table*` package names to the public `remix/*` subpaths, so a future upstream revision diffs cleanly against it.
+
+It is vendored because `@remix-run/data-table-sqlite` exports exactly `createSqliteDatabase` and `SqliteDatabase`. `compileSqliteOperation` is internal, reached by its own driver through a relative import, and there is no `@remix-run/data-table-d1`. If upstream exposes the compiler or ships a D1 dialect, this file goes away.
+
+## License
+
+MIT

package/dist/index.d.mts

@@ -0,0 +1,236 @@
+import { DataManipulationRequest, DataManipulationResult, Database, DatabaseDriver, DatabaseOptions, SqlStatement, TableRef, TransactionOptions, TransactionToken } from "remix/data-table";
+//#region src/d1.d.ts
+/**
+ * The slice of Cloudflare's D1 API this driver uses.
+ *
+ * Declared structurally rather than imported from `@cloudflare/workers-types`,
+ * so the package adds no dependency and no ambient global types to a consumer
+ * that does not already have them. A real `D1Database` binding satisfies it;
+ * so does a test double.
+ */
+interface D1Binding {
+  prepare(query: string): D1PreparedStatement;
+  batch(statements: D1PreparedStatement[]): Promise<D1Result[]>;
+  exec(query: string): Promise<unknown>;
+}
+interface D1PreparedStatement {
+  bind(...values: unknown[]): D1PreparedStatement;
+  all(): Promise<D1Result>;
+}
+interface D1Result {
+  results: Record<string, unknown>[];
+  meta: D1Meta;
+}
+interface D1Meta {
+  /** Rows written by the statement. D1 reports 0 for reads. */
+  changes: number;
+  /** Rowid of the last inserted row, meaningful only after an insert. */
+  last_row_id: number;
+  /** Rows D1 scanned. Billed, and absent on some responses. */
+  rows_read?: number;
+  /** Rows D1 persisted. Billed, and absent on some responses. */
+  rows_written?: number;
+  /** Wall time D1 spent on the statement, in milliseconds. */
+  duration?: number;
+}
+//#endregion
+//#region src/observer.d.ts
+/** What one executed statement cost, as D1 reported it. */
+interface D1StatementReport {
+  /** The operation that produced it: `select`, `insert`, `update`, and so on. */
+  kind: string;
+  /** The table it targeted, absent for a raw statement. */
+  table: string | undefined;
+  /** Rows D1 scanned. `0` when D1 omits the figure, never estimated. */
+  rowsRead: number;
+  /** Rows D1 persisted. `0` when D1 omits the figure, never estimated. */
+  rowsWritten: number;
+  /** Wall time D1 spent, in milliseconds. `0` when D1 omits it. */
+  durationMs: number;
+}
+/**
+ * Called after each statement the driver executes.
+ *
+ * D1 bills on rows read and written, and its analytics report per database
+ * rather than per query, so these numbers are the only way to attribute cost
+ * to the query or the request that caused it. They ride along on responses the
+ * driver already reads, so observing them costs no extra statement and no
+ * extra billable operation.
+ *
+ * It runs on the hot path, once per statement, so keep it cheap.
+ */
+type D1StatementObserver = (report: D1StatementReport) => void;
+//#endregion
+//#region src/driver.d.ts
+/** What one statement in a {@link D1DatabaseDriver.batch} produced. */
+interface D1BatchResult {
+  /** Rows the statement returned. Empty for a write with no `returning`. */
+  rows: Record<string, unknown>[];
+  affectedRows: number;
+  insertId: number;
+}
+/**
+ * How the driver answers a `transaction()` call.
+ *
+ * - `throw` refuses, because D1 cannot honour it. The default.
+ * - `unsafe-nonatomic` accepts and runs each statement immediately, each
+ *   committing on its own. A failure part-way leaves the earlier writes
+ *   persisted, with no rollback. For code shared with a backend that does have
+ *   transactions, where the alternative is not running at all.
+ */
+type D1TransactionMode = "throw" | "unsafe-nonatomic";
+interface D1DriverOptions {
+  onStatement?: D1StatementObserver;
+  transactions?: D1TransactionMode;
+}
+/**
+ * D1 speaks SQLite, so the query surface is the SQLite one. What it does not
+ * have is transactions: `BEGIN`, `COMMIT`, `SAVEPOINT` and friends are
+ * rejected at the SQL layer, and `batch()` is offered instead. `batch()` takes
+ * a prepared array up front, which cannot express the interleaved
+ * begin/execute/commit a `Database` transaction drives, so the capability is
+ * reported as absent rather than faked.
+ *
+ * `savepoints: false` is what makes `Database` reject a nested transaction on
+ * its own, before any savepoint method here can be reached — which holds in
+ * `unsafe-nonatomic` too, where nesting would be even less meaningful.
+ */
+declare const CAPABILITIES: Readonly<{
+  returning: true;
+  savepoints: false;
+  upsert: true;
+  transactionalDdl: false;
+  migrationLock: false;
+}>;
+/**
+ * A `DatabaseDriver` backed by a Cloudflare D1 binding.
+ *
+ * Statements are compiled by the same SQLite compiler `@remix-run/data-table`
+ * uses, then executed through D1's async prepared-statement API. Pass it to
+ * `Database`, or use {@link createD1Database} to get one already wired.
+ */
+declare class D1DatabaseDriver implements DatabaseDriver<"sqlite"> {
+  #private;
+  constructor(d1: D1Binding, options?: D1DriverOptions);
+  get dialect(): "sqlite";
+  get capabilities(): typeof CAPABILITIES;
+  execute(request: DataManipulationRequest): Promise<DataManipulationResult>;
+  executeScript(sql: string, _transaction?: TransactionToken): Promise<void>;
+  hasTable(table: TableRef, _transaction?: TransactionToken): Promise<boolean>;
+  hasColumn(table: TableRef, column: string, _transaction?: TransactionToken): Promise<boolean>;
+  /**
+   * Runs statements together, atomically, through D1's `batch()`.
+   *
+   * This is the answer to "several writes must land together" on a database
+   * with no transactions. `batch()` is D1's only atomic primitive: it takes
+   * every statement up front and commits them as a unit, which is why it
+   * cannot back `transaction()` but can back this.
+   *
+   * Statements are `SqlStatement`s, so `sql` from `remix/data-table`
+   * parameterises them and there is no reaching for the raw binding:
+   *
+   * ```ts
+   * await db.batch([
+   *     sql`insert into post (title) values (${title})`,
+   *     sql`update counter set posts = posts + 1`,
+   * ]);
+   * ```
+   *
+   * @param statements The statements to run, in order.
+   * @returns One result per statement, in the same order.
+   */
+  batch(statements: SqlStatement[]): Promise<D1BatchResult[]>;
+  /**
+   * Drops every table the application owns.
+   *
+   * D1 keeps its own bookkeeping in `_cf_*` tables and SQLite keeps
+   * `sqlite_*`; dropping either breaks the binding, so both are left alone.
+   * There is no file to delete the way the SQLite driver deletes one.
+   */
+  wipe(): Promise<void>;
+  /** A binding is owned by the runtime; there is no connection to release. */
+  close(): void;
+  /**
+   * Opens a transaction, if the caller accepted that it will not be one.
+   *
+   * No `BEGIN` is sent, because D1 rejects it. The token exists so
+   * `Database` has something to carry; statements inside the scope run and
+   * commit exactly as they would outside it.
+   */
+  beginTransaction(_options?: TransactionOptions): Promise<TransactionToken>;
+  /** Nothing to commit: every statement in the scope already did. */
+  commitTransaction(_token: TransactionToken): Promise<void>;
+  /**
+   * Nothing to roll back. This is the cost of `unsafe-nonatomic`, and it is
+   * silent by necessity: `Database` calls this while unwinding a failed
+   * callback, and throwing here would replace the caller's error with an
+   * `AggregateError` about a rollback that was never possible.
+   */
+  rollbackTransaction(_token: TransactionToken): Promise<void>;
+  createSavepoint(_token: TransactionToken, _name: string): Promise<void>;
+  rollbackToSavepoint(_token: TransactionToken, _name: string): Promise<void>;
+  releaseSavepoint(_token: TransactionToken, _name: string): Promise<void>;
+}
+//#endregion
+//#region src/database.d.ts
+interface D1DatabaseOptions extends DatabaseOptions {
+  /**
+   * Called after each statement, with the rows read, rows written, and
+   * duration D1 reported for it. See {@link D1StatementObserver}.
+   */
+  onStatement?: D1StatementObserver;
+  /**
+   * What `transaction()` does. Defaults to `throw`, because D1 has no
+   * transactions; `unsafe-nonatomic` accepts the call and gives up
+   * atomicity. See {@link D1TransactionMode}.
+   */
+  transactions?: D1TransactionMode;
+}
+/**
+ * A `Database` bound to Cloudflare D1.
+ *
+ * The same shape `SqliteDatabase` and `PostgresDatabase` have: a `Database`
+ * subclass that supplies its own driver, so every query, persistence and
+ * migration method comes from `remix/data-table` unchanged.
+ */
+declare class D1Database extends Database<"sqlite"> {
+  #private;
+  constructor(binding: D1Binding, options?: D1DatabaseOptions);
+  /**
+   * Runs statements together, atomically.
+   *
+   * D1 has no transactions, so `transaction()` refuses. `batch()` is what it
+   * offers instead, and this is it without reaching for the raw binding:
+   *
+   * ```ts
+   * import { sql } from "remix/data-table";
+   *
+   * await db.batch([
+   *     sql`insert into post (title) values (${title})`,
+   *     sql`update counter set posts = posts + 1`,
+   * ]);
+   * ```
+   *
+   * The statements are `SqlStatement`s rather than query-builder calls,
+   * because `data-table` exposes no way to build an operation without
+   * running it. `sql` still parameterises the values.
+   */
+  batch(statements: SqlStatement[]): Promise<D1BatchResult[]>;
+}
+/**
+ * Wraps a D1 binding in a `Database`.
+ *
+ * ```ts
+ * import { createD1Database } from "@pitlane/data-table-d1";
+ * import { env } from "cloudflare:workers";
+ *
+ * let db = createD1Database(env.DB);
+ * let posts = await db.query(Post).all();
+ * ```
+ *
+ * @param binding The D1 binding, e.g. `env.DB`.
+ * @param options `Database` options, plus `onStatement` and `transactions`.
+ */
+declare function createD1Database(binding: D1Binding, options?: D1DatabaseOptions): D1Database;
+//#endregion
+export { type D1BatchResult, type D1Binding, D1Database, D1DatabaseDriver, type D1DatabaseOptions, type D1DriverOptions, type D1Meta, type D1PreparedStatement, type D1Result, type D1StatementObserver, type D1StatementReport, type D1TransactionMode, createD1Database };

package/dist/index.mjs

@@ -0,0 +1,495 @@
+import { Database, getTableName, getTablePrimaryKey } from "remix/data-table";
+import { collectColumns, normalizeJoinType, quotePath } from "remix/data-table/sql-helpers";
+//#region src/observer.ts
+/**
+* Reports a statement, absorbing anything the observer throws.
+*
+* Measurement must not be able to fail the thing it measures: a broken
+* observer should cost its own numbers, not the caller's write.
+*/
+function report(observer, kind, table, meta) {
+	if (!observer) return;
+	try {
+		observer({
+			kind,
+			table,
+			rowsRead: meta.rows_read ?? 0,
+			rowsWritten: meta.rows_written ?? 0,
+			durationMs: meta.duration ?? 0
+		});
+	} catch {}
+}
+//#endregion
+//#region src/sql-compiler.ts
+function compileSqliteOperation(operation) {
+	if (operation.kind === "raw") return {
+		text: operation.sql.text,
+		values: [...operation.sql.values]
+	};
+	let context = { values: [] };
+	if (operation.kind === "select") {
+		let selection = "*";
+		if (operation.select !== "*") selection = operation.select.map((field) => quotePath$1(field.column) + " as " + quoteIdentifier$1(field.alias)).join(", ");
+		return {
+			text: "select " + (operation.distinct ? "distinct " : "") + selection + compileFromClause(operation.table, operation.joins, context) + compileWhereClause(operation.where, context) + compileGroupByClause(operation.groupBy) + compileHavingClause(operation.having, context) + compileOrderByClause(operation.orderBy) + compileLimitClause(operation.limit, context) + compileOffsetClause(operation.offset, context),
+			values: context.values
+		};
+	}
+	if (operation.kind === "count" || operation.kind === "exists") {
+		let inner = "select 1" + compileFromClause(operation.table, operation.joins, context) + compileWhereClause(operation.where, context) + compileGroupByClause(operation.groupBy) + compileHavingClause(operation.having, context);
+		return {
+			text: "select count(*) as " + quoteIdentifier$1("count") + " from (" + inner + ") as " + quoteIdentifier$1("__dt_count"),
+			values: context.values
+		};
+	}
+	if (operation.kind === "insert") return compileInsertOperation(operation.table, operation.values, operation.returning, context);
+	if (operation.kind === "insertMany") return compileInsertManyOperation(operation.table, operation.values, operation.returning, context);
+	if (operation.kind === "update") {
+		let columns = Object.keys(operation.changes);
+		return {
+			text: "update " + quotePath$1(getTableName(operation.table)) + " set " + columns.map((column) => quotePath$1(column) + " = " + pushValue(context, operation.changes[column])).join(", ") + compileWhereClause(operation.where, context) + compileReturningClause(operation.returning),
+			values: context.values
+		};
+	}
+	if (operation.kind === "delete") return {
+		text: "delete from " + quotePath$1(getTableName(operation.table)) + compileWhereClause(operation.where, context) + compileReturningClause(operation.returning),
+		values: context.values
+	};
+	if (operation.kind === "upsert") return compileUpsertOperation(operation, context);
+	throw new Error("Unsupported operation kind");
+}
+function compileInsertOperation(table, values, returning, context) {
+	let columns = Object.keys(values);
+	if (columns.length === 0) return {
+		text: "insert into " + quotePath$1(getTableName(table)) + " default values" + compileReturningClause(returning),
+		values: context.values
+	};
+	return {
+		text: "insert into " + quotePath$1(getTableName(table)) + " (" + columns.map((column) => quotePath$1(column)).join(", ") + ") values (" + columns.map((column) => pushValue(context, values[column])).join(", ") + ")" + compileReturningClause(returning),
+		values: context.values
+	};
+}
+function compileInsertManyOperation(table, rows, returning, context) {
+	if (rows.length === 0) return {
+		text: "select 0 where 1 = 0",
+		values: context.values
+	};
+	let columns = collectColumns$1(rows);
+	if (columns.length === 0) return {
+		text: "insert into " + quotePath$1(getTableName(table)) + " default values" + compileReturningClause(returning),
+		values: context.values
+	};
+	return {
+		text: "insert into " + quotePath$1(getTableName(table)) + " (" + columns.map((column) => quotePath$1(column)).join(", ") + ") values " + rows.map((row) => "(" + columns.map((column) => {
+			return pushValue(context, Object.prototype.hasOwnProperty.call(row, column) ? row[column] : null);
+		}).join(", ") + ")").join(", ") + compileReturningClause(returning),
+		values: context.values
+	};
+}
+function compileUpsertOperation(operation, context) {
+	let insertColumns = Object.keys(operation.values);
+	let conflictTarget = operation.conflictTarget ?? [...getTablePrimaryKey(operation.table)];
+	if (insertColumns.length === 0) throw new Error("upsert requires at least one value");
+	let updateValues = operation.update ?? operation.values;
+	let updateColumns = Object.keys(updateValues);
+	let conflictClause = "";
+	if (updateColumns.length === 0) conflictClause = " on conflict (" + conflictTarget.map((column) => quotePath$1(column)).join(", ") + ") do nothing";
+	else conflictClause = " on conflict (" + conflictTarget.map((column) => quotePath$1(column)).join(", ") + ") do update set " + updateColumns.map((column) => quotePath$1(column) + " = " + pushValue(context, updateValues[column])).join(", ");
+	return {
+		text: "insert into " + quotePath$1(getTableName(operation.table)) + " (" + insertColumns.map((column) => quotePath$1(column)).join(", ") + ") values (" + insertColumns.map((column) => pushValue(context, operation.values[column])).join(", ") + ")" + conflictClause + compileReturningClause(operation.returning),
+		values: context.values
+	};
+}
+function compileFromClause(table, joins, context) {
+	let output = " from " + quotePath$1(getTableName(table));
+	for (let join of joins) output += " " + normalizeJoinType$1(join.type) + " join " + quotePath$1(getTableName(join.table)) + " on " + compilePredicate(join.on, context);
+	return output;
+}
+function compileWhereClause(predicates, context) {
+	if (predicates.length === 0) return "";
+	return " where " + predicates.map((predicate) => "(" + compilePredicate(predicate, context) + ")").join(" and ");
+}
+function compileGroupByClause(columns) {
+	if (columns.length === 0) return "";
+	return " group by " + columns.map((column) => quotePath$1(column)).join(", ");
+}
+function compileHavingClause(predicates, context) {
+	if (predicates.length === 0) return "";
+	return " having " + predicates.map((predicate) => "(" + compilePredicate(predicate, context) + ")").join(" and ");
+}
+function compileOrderByClause(orderBy) {
+	if (orderBy.length === 0) return "";
+	return " order by " + orderBy.map((clause) => quotePath$1(clause.column) + " " + clause.direction.toUpperCase()).join(", ");
+}
+function compileLimitClause(limit, context) {
+	if (limit === void 0) return "";
+	return " limit " + pushValue(context, limit);
+}
+function compileOffsetClause(offset, context) {
+	if (offset === void 0) return "";
+	return " offset " + pushValue(context, offset);
+}
+function compileReturningClause(returning) {
+	if (!returning) return "";
+	if (returning === "*") return " returning *";
+	return " returning " + returning.map((column) => quotePath$1(column)).join(", ");
+}
+function compilePredicate(predicate, context) {
+	if (predicate.type === "comparison") {
+		let column = quotePath$1(predicate.column);
+		if (predicate.operator === "eq") {
+			if (predicate.valueType === "value" && (predicate.value === null || predicate.value === void 0)) return column + " is null";
+			let comparisonValue = compileComparisonValue(predicate, context);
+			return column + " = " + comparisonValue;
+		}
+		if (predicate.operator === "ne") {
+			if (predicate.valueType === "value" && (predicate.value === null || predicate.value === void 0)) return column + " is not null";
+			let comparisonValue = compileComparisonValue(predicate, context);
+			return column + " <> " + comparisonValue;
+		}
+		if (predicate.operator === "gt") {
+			let comparisonValue = compileComparisonValue(predicate, context);
+			return column + " > " + comparisonValue;
+		}
+		if (predicate.operator === "gte") {
+			let comparisonValue = compileComparisonValue(predicate, context);
+			return column + " >= " + comparisonValue;
+		}
+		if (predicate.operator === "lt") {
+			let comparisonValue = compileComparisonValue(predicate, context);
+			return column + " < " + comparisonValue;
+		}
+		if (predicate.operator === "lte") {
+			let comparisonValue = compileComparisonValue(predicate, context);
+			return column + " <= " + comparisonValue;
+		}
+		if (predicate.operator === "in" || predicate.operator === "notIn") {
+			let values = Array.isArray(predicate.value) ? predicate.value : [];
+			if (values.length === 0) return predicate.operator === "in" ? "1 = 0" : "1 = 1";
+			let keyword = predicate.operator === "in" ? "in" : "not in";
+			return column + " " + keyword + " (" + values.map((value) => pushValue(context, value)).join(", ") + ")";
+		}
+		if (predicate.operator === "like") {
+			let comparisonValue = compileComparisonValue(predicate, context);
+			return column + " like " + comparisonValue;
+		}
+		if (predicate.operator === "ilike") {
+			let comparisonValue = compileComparisonValue(predicate, context);
+			return "lower(" + column + ") like lower(" + comparisonValue + ")";
+		}
+	}
+	if (predicate.type === "between") return quotePath$1(predicate.column) + " between " + pushValue(context, predicate.lower) + " and " + pushValue(context, predicate.upper);
+	if (predicate.type === "null") return quotePath$1(predicate.column) + (predicate.operator === "isNull" ? " is null" : " is not null");
+	if (predicate.type === "logical") {
+		if (predicate.predicates.length === 0) return predicate.operator === "and" ? "1 = 1" : "1 = 0";
+		let joiner = predicate.operator === "and" ? " and " : " or ";
+		return predicate.predicates.map((child) => "(" + compilePredicate(child, context) + ")").join(joiner);
+	}
+	throw new Error("Unsupported predicate");
+}
+function compileComparisonValue(predicate, context) {
+	if (predicate.valueType === "column") return quotePath$1(predicate.value);
+	return pushValue(context, predicate.value);
+}
+function normalizeJoinType$1(type) {
+	return normalizeJoinType(type);
+}
+function quoteIdentifier$1(value) {
+	return "\"" + value.replace(/"/g, "\"\"") + "\"";
+}
+function quotePath$1(path) {
+	return quotePath(path, quoteIdentifier$1);
+}
+function pushValue(context, value) {
+	context.values.push(normalizeBoundValue(value));
+	return "?";
+}
+function normalizeBoundValue(value) {
+	if (typeof value === "boolean") return value ? 1 : 0;
+	return value;
+}
+function collectColumns$1(rows) {
+	return collectColumns(rows);
+}
+//#endregion
+//#region src/driver.ts
+/**
+* D1 speaks SQLite, so the query surface is the SQLite one. What it does not
+* have is transactions: `BEGIN`, `COMMIT`, `SAVEPOINT` and friends are
+* rejected at the SQL layer, and `batch()` is offered instead. `batch()` takes
+* a prepared array up front, which cannot express the interleaved
+* begin/execute/commit a `Database` transaction drives, so the capability is
+* reported as absent rather than faked.
+*
+* `savepoints: false` is what makes `Database` reject a nested transaction on
+* its own, before any savepoint method here can be reached — which holds in
+* `unsafe-nonatomic` too, where nesting would be even less meaningful.
+*/
+const CAPABILITIES = Object.freeze({
+	returning: true,
+	savepoints: false,
+	upsert: true,
+	transactionalDdl: false,
+	migrationLock: false
+});
+const NO_TRANSACTIONS = "[@pitlane/data-table-d1] D1 rejects SQL transactions and savepoints. Group writes with `d1.batch()`, which is atomic, or model the operation so it does not need one. If the caller is shared with a backend that does have transactions and running without atomicity beats not running, opt in with `createD1Database(env.DB, { transactions: \"unsafe-nonatomic\" })`.";
+const NO_SAVEPOINTS = "[@pitlane/data-table-d1] D1 rejects savepoints, so nested transactions are unavailable whatever `transactions` is set to.";
+/**
+* A `DatabaseDriver` backed by a Cloudflare D1 binding.
+*
+* Statements are compiled by the same SQLite compiler `@remix-run/data-table`
+* uses, then executed through D1's async prepared-statement API. Pass it to
+* `Database`, or use {@link createD1Database} to get one already wired.
+*/
+var D1DatabaseDriver = class {
+	#d1;
+	#onStatement;
+	#transactions;
+	#openedTransactions = 0;
+	constructor(d1, options = {}) {
+		this.#d1 = d1;
+		this.#onStatement = options.onStatement;
+		this.#transactions = options.transactions ?? "throw";
+	}
+	get dialect() {
+		return "sqlite";
+	}
+	get capabilities() {
+		return CAPABILITIES;
+	}
+	async execute(request) {
+		let { operation } = request;
+		if (operation.kind === "insertMany" && operation.values.length === 0) return {
+			affectedRows: 0,
+			insertId: void 0,
+			rows: operation.returning ? [] : void 0
+		};
+		let statement = compileSqliteOperation(operation);
+		let values = statement.values.map((value) => value === void 0 ? null : value);
+		let result = await this.#d1.prepare(statement.text).bind(...values).all();
+		report(this.#onStatement, operation.kind, tableName(operation), result.meta);
+		return readsRows(operation) ? readerResult(operation, result) : writerResult(operation, result.meta);
+	}
+	async executeScript(sql, _transaction) {
+		await this.#d1.exec(sql);
+	}
+	async hasTable(table, _transaction) {
+		let master = table.schema ? `${quoteIdentifier(table.schema)}.sqlite_master` : "sqlite_master";
+		return (await this.#d1.prepare(`select 1 from ${master} where type = ? and name = ? limit 1`).bind("table", table.name).all()).results.length > 0;
+	}
+	async hasColumn(table, column, _transaction) {
+		return (await this.#d1.prepare("select name from pragma_table_info(?)").bind(table.name).all()).results.some((row) => row.name === column);
+	}
+	/**
+	* Runs statements together, atomically, through D1's `batch()`.
+	*
+	* This is the answer to "several writes must land together" on a database
+	* with no transactions. `batch()` is D1's only atomic primitive: it takes
+	* every statement up front and commits them as a unit, which is why it
+	* cannot back `transaction()` but can back this.
+	*
+	* Statements are `SqlStatement`s, so `sql` from `remix/data-table`
+	* parameterises them and there is no reaching for the raw binding:
+	*
+	* ```ts
+	* await db.batch([
+	*     sql`insert into post (title) values (${title})`,
+	*     sql`update counter set posts = posts + 1`,
+	* ]);
+	* ```
+	*
+	* @param statements The statements to run, in order.
+	* @returns One result per statement, in the same order.
+	*/
+	async batch(statements) {
+		if (statements.length === 0) return [];
+		return (await this.#d1.batch(statements.map((statement) => this.#d1.prepare(statement.text).bind(...statement.values.map((value) => value === void 0 ? null : value))))).map((result) => {
+			report(this.#onStatement, "batch", void 0, result.meta);
+			return {
+				rows: result.results.map((row) => ({ ...row })),
+				affectedRows: Number(result.meta.changes),
+				insertId: result.meta.last_row_id
+			};
+		});
+	}
+	/**
+	* Drops every table the application owns.
+	*
+	* D1 keeps its own bookkeeping in `_cf_*` tables and SQLite keeps
+	* `sqlite_*`; dropping either breaks the binding, so both are left alone.
+	* There is no file to delete the way the SQLite driver deletes one.
+	*/
+	async wipe() {
+		let names = (await this.#d1.prepare("select name from sqlite_master where type = 'table' and name not like 'sqlite\\_%' escape '\\' and name not like '\\_cf\\_%' escape '\\'").all()).results.map((row) => String(row.name));
+		if (names.length === 0) return;
+		await this.#d1.batch([this.#d1.prepare("pragma defer_foreign_keys = true"), ...names.map((name) => this.#d1.prepare(`drop table if exists ${quoteIdentifier(name)}`))]);
+	}
+	/** A binding is owned by the runtime; there is no connection to release. */
+	close() {}
+	/**
+	* Opens a transaction, if the caller accepted that it will not be one.
+	*
+	* No `BEGIN` is sent, because D1 rejects it. The token exists so
+	* `Database` has something to carry; statements inside the scope run and
+	* commit exactly as they would outside it.
+	*/
+	async beginTransaction(_options) {
+		if (this.#transactions === "throw") throw new Error(NO_TRANSACTIONS);
+		return { id: `d1-nonatomic-${++this.#openedTransactions}` };
+	}
+	/** Nothing to commit: every statement in the scope already did. */
+	async commitTransaction(_token) {
+		if (this.#transactions === "throw") throw new Error(NO_TRANSACTIONS);
+	}
+	/**
+	* Nothing to roll back. This is the cost of `unsafe-nonatomic`, and it is
+	* silent by necessity: `Database` calls this while unwinding a failed
+	* callback, and throwing here would replace the caller's error with an
+	* `AggregateError` about a rollback that was never possible.
+	*/
+	async rollbackTransaction(_token) {
+		if (this.#transactions === "throw") throw new Error(NO_TRANSACTIONS);
+	}
+	async createSavepoint(_token, _name) {
+		throw new Error(NO_SAVEPOINTS);
+	}
+	async rollbackToSavepoint(_token, _name) {
+		throw new Error(NO_SAVEPOINTS);
+	}
+	async releaseSavepoint(_token, _name) {
+		throw new Error(NO_SAVEPOINTS);
+	}
+};
+/** The table an operation targeted. A raw statement names none. */
+function tableName(operation) {
+	return operation.kind === "raw" ? void 0 : getTableName(operation.table);
+}
+/**
+* Whether the operation's response carries rows.
+*
+* `raw` is the awkward one: the caller's SQL may or may not select anything,
+* and D1 will not say which. Reporting rows costs nothing when there are none,
+* so raw statements always come back with an array.
+*/
+function readsRows(operation) {
+	if (operation.kind === "select" || operation.kind === "count" || operation.kind === "exists") return true;
+	if (operation.kind === "raw") return true;
+	return operation.returning !== void 0;
+}
+function readerResult(operation, result) {
+	let rows = result.results.map((row) => ({ ...row }));
+	if (operation.kind === "count" || operation.kind === "exists") rows = rows.map(normalizeCount);
+	return {
+		rows,
+		affectedRows: isWrite(operation.kind) ? rows.length : void 0,
+		insertId: lastPrimaryKey(operation, rows)
+	};
+}
+function writerResult(operation, meta) {
+	return {
+		affectedRows: isWrite(operation.kind) ? Number(meta.changes) : void 0,
+		insertId: isInsert(operation) && singlePrimaryKey(operation) ? meta.last_row_id : void 0
+	};
+}
+/**
+* `count(*)` arrives as a string or bigint depending on magnitude and driver;
+* callers expect a number.
+*/
+function normalizeCount(row) {
+	let { count } = row;
+	if (typeof count === "bigint") return {
+		...row,
+		count: Number(count)
+	};
+	if (typeof count === "string") {
+		let numeric = Number(count);
+		if (!Number.isNaN(numeric)) return {
+			...row,
+			count: numeric
+		};
+	}
+	return row;
+}
+/** The generated key of the last inserted row, read back out of RETURNING. */
+function lastPrimaryKey(operation, rows) {
+	if (!isInsert(operation)) return void 0;
+	let key = singlePrimaryKey(operation);
+	if (!key) return void 0;
+	return rows[rows.length - 1]?.[key];
+}
+/** A composite key has no single insert id to report. */
+function singlePrimaryKey(operation) {
+	let primaryKey = getTablePrimaryKey(operation.table);
+	return primaryKey.length === 1 ? primaryKey[0] : void 0;
+}
+function isInsert(operation) {
+	return operation.kind === "insert" || operation.kind === "insertMany" || operation.kind === "upsert";
+}
+function isWrite(kind) {
+	return kind === "insert" || kind === "insertMany" || kind === "update" || kind === "delete" || kind === "upsert";
+}
+function quoteIdentifier(value) {
+	return `"${value.replace(/"/g, "\"\"")}"`;
+}
+//#endregion
+//#region src/database.ts
+/**
+* A `Database` bound to Cloudflare D1.
+*
+* The same shape `SqliteDatabase` and `PostgresDatabase` have: a `Database`
+* subclass that supplies its own driver, so every query, persistence and
+* migration method comes from `remix/data-table` unchanged.
+*/
+var D1Database = class extends Database {
+	#driver;
+	constructor(binding, options) {
+		let { onStatement, transactions, ...databaseOptions } = options ?? {};
+		let driver = new D1DatabaseDriver(binding, {
+			onStatement,
+			transactions
+		});
+		super(driver, databaseOptions);
+		this.#driver = driver;
+	}
+	/**
+	* Runs statements together, atomically.
+	*
+	* D1 has no transactions, so `transaction()` refuses. `batch()` is what it
+	* offers instead, and this is it without reaching for the raw binding:
+	*
+	* ```ts
+	* import { sql } from "remix/data-table";
+	*
+	* await db.batch([
+	*     sql`insert into post (title) values (${title})`,
+	*     sql`update counter set posts = posts + 1`,
+	* ]);
+	* ```
+	*
+	* The statements are `SqlStatement`s rather than query-builder calls,
+	* because `data-table` exposes no way to build an operation without
+	* running it. `sql` still parameterises the values.
+	*/
+	batch(statements) {
+		return this.#driver.batch(statements);
+	}
+};
+/**
+* Wraps a D1 binding in a `Database`.
+*
+* ```ts
+* import { createD1Database } from "@pitlane/data-table-d1";
+* import { env } from "cloudflare:workers";
+*
+* let db = createD1Database(env.DB);
+* let posts = await db.query(Post).all();
+* ```
+*
+* @param binding The D1 binding, e.g. `env.DB`.
+* @param options `Database` options, plus `onStatement` and `transactions`.
+*/
+function createD1Database(binding, options) {
+	return new D1Database(binding, options);
+}
+//#endregion
+export { D1Database, D1DatabaseDriver, createD1Database };

package/dist/migrations.d.mts

@@ -0,0 +1,55 @@
+//#region src/migrations.d.ts
+/**
+ * What {@link generateD1Migrations} needs to know.
+ */
+interface GenerateD1MigrationsOptions {
+  /**
+   * Directory holding the `data-table` migrations, one `<id>_<name>/`
+   * directory per migration.
+   *
+   * @default "db/migrations"
+   */
+  from?: string;
+  /**
+   * Where the generated `.sql` files land. Point this at the same directory
+   * as `migrations_dir` in your Wrangler config.
+   */
+  to: string;
+}
+/**
+ * One generated file.
+ */
+interface GeneratedD1Migration {
+  /** Migration id, typically a `YYYYMMDDHHmmss` timestamp. */
+  id: string;
+  /** Migration slug. */
+  name: string;
+  /** Path of the written file, relative to the working directory. */
+  file: string;
+}
+/**
+ * Writes one `<id>_<name>.sql` per migration into `options.to`, then deletes
+ * generated files with no migration behind them, so the output directory is a
+ * pure function of the input one.
+ *
+ * The SQL is copied verbatim. Splitting it into statements is the job of
+ * whatever executes the file, and a splitter naive enough to write here would
+ * corrupt any migration containing a semicolon inside a string literal or a
+ * `begin ... end` trigger body.
+ *
+ * @param options Where to read migrations from, and where to write SQL to.
+ * @returns The generated files, ordered by migration id.
+ * @throws If `options.from` holds no migrations, or one of them has an empty
+ * `up`. Both mean the output directory is about to be wrong, and a migration
+ * runner is the worst place to discover that.
+ *
+ * @example
+ * ```ts
+ * import { generateD1Migrations } from "@pitlane/data-table-d1/migrations";
+ *
+ * await generateD1Migrations({ to: "db/d1-migrations" });
+ * ```
+ */
+declare function generateD1Migrations(options: GenerateD1MigrationsOptions): Promise<GeneratedD1Migration[]>;
+//#endregion
+export { GenerateD1MigrationsOptions, GeneratedD1Migration, generateD1Migrations };

package/dist/migrations.mjs

@@ -0,0 +1,75 @@
+import { mkdir, readdir, unlink, writeFile } from "node:fs/promises";
+import * as path from "node:path";
+import { loadMigrations } from "remix/data-table/migrations/node";
+//#region src/migrations.ts
+/**
+* Compiles `data-table` migrations into the flat `.sql` files Wrangler's D1
+* migration runner reads.
+*
+* Node-only build tooling. Nothing here belongs in a Worker bundle, which is
+* why it is a separate entry point from the driver.
+*
+* @module @pitlane/data-table-d1/migrations
+*/
+/**
+* A generated file, as opposed to a `.gitkeep` or a `README.md` that happens to
+* sit in the same directory. Matches Wrangler's own migration filename shape.
+*/
+const GENERATED = /^\d{4,14}_.+\.sql$/;
+/**
+* Writes one `<id>_<name>.sql` per migration into `options.to`, then deletes
+* generated files with no migration behind them, so the output directory is a
+* pure function of the input one.
+*
+* The SQL is copied verbatim. Splitting it into statements is the job of
+* whatever executes the file, and a splitter naive enough to write here would
+* corrupt any migration containing a semicolon inside a string literal or a
+* `begin ... end` trigger body.
+*
+* @param options Where to read migrations from, and where to write SQL to.
+* @returns The generated files, ordered by migration id.
+* @throws If `options.from` holds no migrations, or one of them has an empty
+* `up`. Both mean the output directory is about to be wrong, and a migration
+* runner is the worst place to discover that.
+*
+* @example
+* ```ts
+* import { generateD1Migrations } from "@pitlane/data-table-d1/migrations";
+*
+* await generateD1Migrations({ to: "db/d1-migrations" });
+* ```
+*/
+async function generateD1Migrations(options) {
+	let from = path.resolve(options.from ?? "db/migrations");
+	let to = path.resolve(options.to);
+	let migrations = await loadMigrations(from);
+	if (migrations.length === 0) throw new Error(`[@pitlane/data-table-d1] no migrations found in ${from}`);
+	await mkdir(to, { recursive: true });
+	let generated = [];
+	for (let migration of migrations) {
+		if (migration.up.trim().length === 0) throw new Error(`[@pitlane/data-table-d1] migration ${migration.id}_${migration.name} has an empty \`up\``);
+		let filename = `${migration.id}_${migration.name}.sql`;
+		let file = path.join(to, filename);
+		await writeFile(file, header(migration.id, migration.name) + migration.up.trimEnd() + "\n");
+		generated.push({
+			id: migration.id,
+			name: migration.name,
+			file: path.relative(process.cwd(), file)
+		});
+	}
+	await pruneStale(to, new Set(generated.map((entry) => path.basename(entry.file))));
+	return generated;
+}
+function header(id, name) {
+	return `-- Generated by @pitlane/data-table-d1 from ${id}_${name}/up.sql.\n-- Do not edit by hand; re-run the generator instead.
+
+`;
+}
+async function pruneStale(directory, keep) {
+	for (let entry of await readdir(directory)) {
+		if (!GENERATED.test(entry) || keep.has(entry)) continue;
+		await unlink(path.join(directory, entry));
+	}
+}
+//#endregion
+export { generateD1Migrations };

package/package.json

@@ -0,0 +1,58 @@
+{
+    "name": "@pitlane/data-table-d1",
+    "version": "0.1.0",
+    "description": "A Cloudflare D1 driver for Remix 3's data-table: SQLite SQL over D1's async prepared-statement binding.",
+    "keywords": [
+        "cloudflare",
+        "d1",
+        "data-table",
+        "pitlane",
+        "remix",
+        "sqlite",
+        "workers"
+    ],
+    "homepage": "https://pitlane.tools/package/data-table-d1/",
+    "bugs": {
+        "url": "https://github.com/pitlane-tools/pitlane/issues"
+    },
+    "license": "MIT",
+    "author": "Mark Malstrom <mark@malstrom.me>",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/pitlane-tools/pitlane.git",
+        "directory": "packages/data-table-d1"
+    },
+    "files": [
+        "dist",
+        "CHANGELOG.md",
+        "LICENSE.remix"
+    ],
+    "type": "module",
+    "types": "./dist/index.d.mts",
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.mts",
+            "import": "./dist/index.mjs"
+        },
+        "./migrations": {
+            "types": "./dist/migrations.d.mts",
+            "import": "./dist/migrations.mjs"
+        }
+    },
+    "scripts": {
+        "prepublishOnly": "vp run build"
+    },
+    "devDependencies": {
+        "@types/node": "^25.5.0",
+        "miniflare": "^4.20260710.0",
+        "remix": "3.0.0-beta.10",
+        "typescript": "^7.0.2",
+        "vite-plus": "^0.2.6"
+    },
+    "peerDependencies": {
+        "remix": "^3.0.0-beta.10"
+    },
+    "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+    }
+}