@hot-updater/cloudflare 1.1.3 → 1.2.0-rc.0

package/src/d1Database.ts

@@ -1,86 +1,46 @@
-import {
-  coreSettings,
-  coreTarget,
-  type SqlStatement,
-} from "@hot-updater/plugin-core";
+import { coreSettings, coreTarget } from "@hot-updater/plugin-core";
 import type {
   SchemaGenerator,
   ToolingDatabase,
 } from "@hot-updater/plugin-core";
-import Cloudflare from "cloudflare";
 
-import {
-  createD1Database,
-  D1ExecutionError,
-  type D1ResultLike,
-  toSqlResult,
-} from "./d1Executor";
+import { createD1Database } from "./d1Executor";
+import { type D1RestConfig, d1RestRunner } from "./d1Rest";
 import { d1SchemaSql } from "./d1Schema";
 
 export { D1ExecutionError } from "./d1Executor";
 
-export interface D1DatabaseConfig {
-  readonly databaseId: string;
-  readonly accountId: string;
-  readonly cloudflareApiToken: string;
-}
+export type D1DatabaseConfig = D1RestConfig;
 
-/** The REST API binds text: each value goes as JSON and is read back with `json_extract`. */
-const encode = ({ sql, params }: SqlStatement) => ({
-  // A function, since `$'` in a replacement string means "the rest of the input".
-  sql: sql.replaceAll("?", () => "json_extract(?, '$')"),
-  params: params.map((value) => JSON.stringify(value ?? null)),
-});
+/**
+ * The resource this database reaches, without credentials, under the key
+ * `hot-updater doctor` reads to tell the database `hot-updater init` saved
+ * from another (a convention CLAUDE.md documents).
+ */
+const DATABASE_TARGET = Symbol.for("@hot-updater/database-target");
+
+/** `target` under {@link DATABASE_TARGET}, to spread into the database. */
+const marked = (target: string) => ({ [DATABASE_TARGET]: target });
 
 /**
  * Hot Updater's database on D1 through the Cloudflare REST API, for the CLI
  * and console. `hot-updater db generate` writes a D1 migration of the built-in
  * tables and the server's plugin tables to `migrations`, and
- * `hot-updater db migrate` applies them through the API.
+ * `hot-updater db migrate` applies them through the API. The managed
+ * database migrates with the Worker's migrations when `hot-updater init` runs
+ * again.
  */
-export const d1Database = (config: D1DatabaseConfig): ToolingDatabase => {
-  const cloudflare = new Cloudflare({
-    apiToken: config.cloudflareApiToken,
-  });
-  const execute = async (statements: readonly SqlStatement[]) => {
-    const [first] = statements;
-    if (first === undefined) return [];
-    const body =
-      statements.length === 1
-        ? { account_id: config.accountId, ...encode(first) }
-        : { account_id: config.accountId, batch: statements.map(encode) };
-    // cloudflare@4 predates the D1 REST API's parameterized batch body type.
-    const page = await cloudflare.d1.database.query(
-      config.databaseId,
-      body as unknown as Parameters<typeof cloudflare.d1.database.query>[1],
-    );
-    const results = [];
-    for await (const resultPage of page.iterPages()) {
-      for (const result of resultPage.result) {
-        results.push(toSqlResult(result as D1ResultLike));
-      }
+export const d1Database = (config: D1DatabaseConfig): ToolingDatabase => ({
+  ...createD1Database(d1RestRunner(config)),
+  ...marked(`d1/${config.databaseId}`),
+  generateSchema: ((version, _name, target = coreTarget) => {
+    if (version !== "latest" && version !== coreSettings["schema.core"]) {
+      throw new Error(`Invalid version ${version}`);
     }
-    if (results.length !== statements.length) throw new D1ExecutionError();
-    return results;
-  };
-  return {
-    ...createD1Database({
-      query: async (statement) => (await execute([statement]))[0]!,
-      batch: execute,
-    }),
-    generateSchema: ((version, _name, target = coreTarget) => {
-      if (version !== "latest" && version !== coreSettings["schema.core"]) {
-        throw new Error(`Invalid version ${version}`);
-      }
-      // Wrangler applies migrations in the order of their leading numbers.
-      const timestamp = new Date()
-        .toISOString()
-        .replace(/\D/g, "")
-        .slice(0, 14);
-      return {
-        code: d1SchemaSql(target),
-        path: `migrations/${timestamp}_hot-updater.sql`,
-      };
-    }) satisfies SchemaGenerator,
-  };
-};
+    const timestamp = new Date().toISOString().replace(/\D/g, "").slice(0, 14);
+    return {
+      code: d1SchemaSql(target),
+      path: `migrations/${timestamp}_hot-updater.sql`,
+    };
+  }) satisfies SchemaGenerator,
+});

package/src/d1Rest.ts

@@ -0,0 +1,54 @@
+import type { SqlResult, SqlStatement } from "@hot-updater/plugin-core";
+import Cloudflare from "cloudflare";
+
+import { D1ExecutionError, type D1ResultLike, toSqlResult } from "./d1Executor";
+
+export interface D1RestConfig {
+  readonly databaseId: string;
+  readonly accountId: string;
+  readonly cloudflareApiToken: string;
+}
+
+/** The REST API binds text: each value goes as JSON and is read back with `json_extract`. */
+const encode = ({ sql, params }: SqlStatement) => ({
+  // A function, since `$'` in a replacement string means "the rest of the input".
+  sql: sql.replaceAll("?", () => "json_extract(?, '$')"),
+  params: params.map((value) => JSON.stringify(value ?? null)),
+});
+
+/**
+ * Statements on a D1 database through the Cloudflare REST API: one at a
+ * time, or a batch D1 runs in one transaction.
+ */
+export const d1RestRunner = (config: D1RestConfig) => {
+  const cloudflare = new Cloudflare({
+    apiToken: config.cloudflareApiToken,
+  });
+  const batch = async (
+    statements: readonly SqlStatement[],
+  ): Promise<SqlResult[]> => {
+    const [first] = statements;
+    if (first === undefined) return [];
+    const body =
+      statements.length === 1
+        ? { account_id: config.accountId, ...encode(first) }
+        : { account_id: config.accountId, batch: statements.map(encode) };
+    // cloudflare@4 predates the D1 REST API's parameterized batch body type.
+    const page = await cloudflare.d1.database.query(
+      config.databaseId,
+      body as unknown as Parameters<typeof cloudflare.d1.database.query>[1],
+    );
+    const results = [];
+    for await (const resultPage of page.iterPages()) {
+      for (const result of resultPage.result) {
+        results.push(toSqlResult(result as D1ResultLike));
+      }
+    }
+    if (results.length !== statements.length) throw new D1ExecutionError();
+    return results;
+  };
+  return {
+    query: async (statement: SqlStatement) => (await batch([statement]))[0]!,
+    batch,
+  };
+};

package/src/d1Schema.ts

@@ -19,8 +19,38 @@ export const d1SchemaStatements = ({
   ...generateEngineSql("sqlite", schema, settings),
 ];
 
+const HEADER = "-- HotUpdater.schema\n\n";
+
+const toSql = (statements: readonly string[]) =>
+  `${HEADER}${statements.map((statement) => `${statement};`).join("\n\n")}\n`;
+
 /** The schema as a D1 migration, which `wrangler d1 migrations apply` runs. */
 export const d1SchemaSql = (target?: ToolingTarget): string =>
-  `-- HotUpdater.schema\n\n${d1SchemaStatements(target)
-    .map((statement) => `${statement};`)
-    .join("\n\n")}\n`;
+  toSql(d1SchemaStatements(target));
+
+/** The statements of a migration `d1SchemaSql` or `d1MigrationSql` wrote. */
+export const d1MigrationStatements = (sql: string): string[] =>
+  sql
+    .replace(HEADER, "")
+    .split(";\n\n")
+    .map((statement) => statement.replace(/;\n$/u, "").trim())
+    .filter((statement) => statement !== "");
+
+/**
+ * A managed D1 migration after the first: each statement of the target's
+ * schema that no earlier migration ran, then every settings row, so the
+ * migration is never empty and the fence passes once it ran. Shipped
+ * migrations are frozen; a schema change goes into the next one.
+ */
+export const d1MigrationSql = (
+  target: ToolingTarget,
+  earlier: readonly string[],
+): string => {
+  const statements = d1SchemaStatements(target);
+  const settings = Object.keys(target.settings).length;
+  const ran = new Set(earlier.flatMap(d1MigrationStatements));
+  return toSql([
+    ...statements.slice(0, -settings).filter((sql) => !ran.has(sql)),
+    ...statements.slice(-settings),
+  ]);
+};

package/worker/dist/README.md

@@ -1 +1 @@
-This folder contains the built output assets for the worker "hot-updater" generated at 2026-10-26T01:16:59.468Z.
+This folder contains the built output assets for the worker "hot-updater" generated at 2026-10-27T15:32:58.641Z.