deepspace 0.3.2 → 0.3.4

package/dist/worker.d.ts

@@ -2832,8 +2832,9 @@ declare const COST_RATES: {
  * `[[d1_databases]]` bindings.
  *
  * The auto-provisioner gives apps an empty D1; the app needs to create its
- * own tables before using them. This helper runs ordered SQL fragments under
- * a `PRAGMA user_version` gate so re-running is a no-op:
+ * own tables before using them. This helper runs ordered SQL fragments and
+ * tracks which have applied via a `_dpc_migrations` meta-table so re-running
+ * is a no-op:
  *
  * ```ts
  * import { runMigrations } from 'deepspace/worker'
@@ -2844,16 +2845,28 @@ declare const COST_RATES: {
  * ])
  * ```
  *
- * Each entry in the array is one migration. The runner reads the database's
- * current `user_version`, applies migrations from that index onward, and
- * advances the version. Adding a new migration means appending to the array;
- * never reorder or delete entries.
+ * **SQL formatting requirement:** D1's `exec()` is single-line-per-statement.
+ * Each migration string can hold multiple statements separated by `;`, but
+ * every statement must fit on one line. Multi-line statements (column lists
+ * across newlines) fail with `D1_EXEC_ERROR: incomplete input`. If you need
+ * complex migrations, write each statement on its own line within the string.
+ *
+ * Each entry in the array is one migration. The runner records the index of
+ * each successfully-applied migration in `_dpc_migrations`; subsequent calls
+ * skip rows already recorded. Adding a new migration means appending to the
+ * array; never reorder or delete entries.
+ *
+ * Why a meta-table instead of `PRAGMA user_version`: D1's SQLite authorizer
+ * rejects PRAGMA writes with `SQLITE_AUTH`, even though the same statements
+ * work in raw SQLite. A real table works on any D1 database and stays a
+ * trivial bootstrap (one CREATE TABLE IF NOT EXISTS).
  *
  * Concurrency: D1 serializes statements per database, but two simultaneous
- * `runMigrations` callers could race on the read-then-write of `user_version`.
- * In practice apps invoke this at module/DO startup which is single-threaded
- * per worker isolate; the worst case across isolates is a CREATE TABLE
- * IF NOT EXISTS-equivalent failure — caught and reported with context.
+ * `runMigrations` callers could race the same migration index. The duplicate
+ * INSERT collides on the primary key and the second caller sees the failure
+ * — but the migration itself uses `IF NOT EXISTS` so the schema is correct
+ * either way. Apps invoke this at startup which is single-threaded per
+ * worker isolate; the cross-isolate race is rare and self-healing.
  *
  * This is the simplest possible migration story (option 1 in
  * docs/proposals/binding-auto-provisioning.md). Apps that outgrow it can
@@ -2861,7 +2874,7 @@ declare const COST_RATES: {
  * helper.
  */
 interface RunMigrationsResult {
-    /** Version before this run started. */
+    /** Version before this run started. Equals the count of migrations already applied. */
     fromVersion: number;
     /** Version after migrations applied. Equals fromVersion if nothing ran. */
     toVersion: number;
@@ -2872,8 +2885,8 @@ interface RunMigrationsResult {
  * Apply ordered SQL migrations to a D1 database. Idempotent: the next call
  * with the same array is a no-op until the array grows.
  *
- * Throws on any individual migration failure. The user_version is only
- * advanced after a migration succeeds, so a partial failure leaves a
+ * Throws on any individual migration failure. The migrations meta-row is
+ * only inserted after a migration succeeds, so a partial failure leaves a
  * recoverable state — fix the SQL, redeploy, and the failed migration runs
  * on next startup.
  */

package/dist/worker.js

@@ -6117,9 +6117,12 @@ var COST_RATES = {
 };
 
 // src/server/utils/d1-migrations.ts
+var META_TABLE = "_dpc_migrations";
+var META_BOOTSTRAP_SQL = `CREATE TABLE IF NOT EXISTS ${META_TABLE} (idx INTEGER PRIMARY KEY, applied_at TEXT NOT NULL);`;
 async function runMigrations(db, migrations) {
-  const versionRow = await db.prepare("PRAGMA user_version").first();
-  const fromVersion = versionRow?.user_version ?? 0;
+  await db.exec(META_BOOTSTRAP_SQL);
+  const row = await db.prepare(`SELECT COUNT(*) AS n FROM ${META_TABLE}`).first();
+  const fromVersion = row?.n ?? 0;
   if (fromVersion >= migrations.length) {
     return { fromVersion, toVersion: fromVersion, applied: 0 };
   }
@@ -6130,10 +6133,10 @@ async function runMigrations(db, migrations) {
       await db.exec(sql);
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
-      throw new Error(`Migration ${i} failed (db at user_version=${current}): ${msg}`);
+      throw new Error(`Migration ${i} failed (db at version=${current}): ${msg}`);
     }
+    await db.prepare(`INSERT INTO ${META_TABLE} (idx, applied_at) VALUES (?, ?)`).bind(i, (/* @__PURE__ */ new Date()).toISOString()).run();
     current = i + 1;
-    await db.exec(`PRAGMA user_version = ${current}`);
   }
   return { fromVersion, toVersion: current, applied: current - fromVersion };
 }