@hot-updater/cloudflare 0.30.12 → 0.31.1

package/src/cloudflareWorkerDatabase.ts

@@ -1,6 +1,10 @@
 import {
   DEFAULT_ROLLOUT_COHORT_COUNT,
-  type SnakeCaseBundle,
+  getAssetBaseStorageUri,
+  getBundlePatches,
+  getManifestFileHash,
+  getManifestStorageUri,
+  stripBundleArtifactMetadata,
 } from "@hot-updater/core";
 import type {
   Bundle,
@@ -48,6 +52,36 @@ interface BuildQueryResult {
   params: unknown[];
 }
 
+interface D1WorkerBundleRow {
+  id: string;
+  channel: string;
+  enabled: number | boolean;
+  should_force_update: number | boolean;
+  file_hash: string;
+  git_commit_hash: string | null;
+  message: string | null;
+  platform: "ios" | "android";
+  target_app_version: string | null;
+  storage_uri: string;
+  fingerprint_hash: string | null;
+  metadata: unknown;
+  manifest_storage_uri?: string | null;
+  manifest_file_hash?: string | null;
+  asset_base_storage_uri?: string | null;
+  rollout_cohort_count: number | null;
+  target_cohorts: string | null;
+}
+
+interface D1WorkerBundlePatchRow {
+  id: string;
+  bundle_id: string;
+  base_bundle_id: string;
+  base_file_hash: string;
+  patch_file_hash: string;
+  patch_storage_uri: string;
+  order_index: number | null;
+}
+
 function buildWhereClause(
   conditions: QueryConditions | undefined,
 ): BuildQueryResult {
@@ -168,7 +202,54 @@ function parseTargetCohorts(value: unknown): string[] | null {
   return null;
 }
 
-function transformRowToBundle(row: SnakeCaseBundle): Bundle {
+const parseMetadata = (value: unknown): Bundle["metadata"] => {
+  if (!value) return undefined;
+  if (typeof value === "string") {
+    try {
+      return parseMetadata(JSON.parse(value) as unknown);
+    } catch {
+      return undefined;
+    }
+  }
+  return typeof value === "object" && !Array.isArray(value)
+    ? (value as Bundle["metadata"])
+    : undefined;
+};
+
+const buildBundlePatchId = (bundleId: string, baseBundleId: string) =>
+  `${bundleId}:${baseBundleId}`;
+
+const bundleToPatchRows = (bundle: Bundle): D1WorkerBundlePatchRow[] =>
+  getBundlePatches(bundle).map((patch, index) => ({
+    id: buildBundlePatchId(bundle.id, patch.baseBundleId),
+    bundle_id: bundle.id,
+    base_bundle_id: patch.baseBundleId,
+    base_file_hash: patch.baseFileHash,
+    patch_file_hash: patch.patchFileHash,
+    patch_storage_uri: patch.patchStorageUri,
+    order_index: index,
+  }));
+
+function transformRowToBundle(
+  row: D1WorkerBundleRow,
+  patchRows: D1WorkerBundlePatchRow[] = [],
+): Bundle {
+  const rawMetadata = parseMetadata(row.metadata);
+  const patches = patchRows
+    .slice()
+    .sort(
+      (left, right) =>
+        (left.order_index ?? 0) - (right.order_index ?? 0) ||
+        left.base_bundle_id.localeCompare(right.base_bundle_id),
+    )
+    .map((patch) => ({
+      baseBundleId: patch.base_bundle_id,
+      baseFileHash: patch.base_file_hash,
+      patchFileHash: patch.patch_file_hash,
+      patchStorageUri: patch.patch_storage_uri,
+    }));
+  const primaryPatch = patches[0] ?? null;
+
   return {
     id: row.id,
     channel: row.channel,
@@ -181,7 +262,15 @@ function transformRowToBundle(row: SnakeCaseBundle): Bundle {
     targetAppVersion: row.target_app_version,
     storageUri: row.storage_uri,
     fingerprintHash: row.fingerprint_hash,
-    metadata: row?.metadata ? JSON.parse(row.metadata as string) : {},
+    metadata: stripBundleArtifactMetadata(rawMetadata),
+    manifestStorageUri: row.manifest_storage_uri ?? null,
+    manifestFileHash: row.manifest_file_hash ?? null,
+    assetBaseStorageUri: row.asset_base_storage_uri ?? null,
+    patches,
+    patchBaseBundleId: primaryPatch?.baseBundleId ?? null,
+    patchBaseFileHash: primaryPatch?.baseFileHash ?? null,
+    patchFileHash: primaryPatch?.patchFileHash ?? null,
+    patchStorageUri: primaryPatch?.patchStorageUri ?? null,
     rolloutCohortCount:
       (row.rollout_cohort_count as number | null) ??
       DEFAULT_ROLLOUT_COHORT_COUNT,
@@ -236,12 +325,43 @@ export const d1WorkerDatabase = <
         return result ?? null;
       };
 
+      const getPatchMap = async (
+        bundleIds: string[],
+        context?: HotUpdaterContext<TContext>,
+      ) => {
+        const patchMap = new Map<string, D1WorkerBundlePatchRow[]>();
+
+        if (bundleIds.length === 0) {
+          return patchMap;
+        }
+
+        const placeholders = bundleIds.map(() => "?").join(", ");
+        const rows = await queryAll<D1WorkerBundlePatchRow>(
+          `
+            SELECT *
+            FROM bundle_patches
+            WHERE bundle_id IN (${placeholders})
+            ORDER BY order_index ASC, base_bundle_id ASC
+          `,
+          bundleIds,
+          context,
+        );
+
+        for (const row of rows) {
+          const current = patchMap.get(row.bundle_id) ?? [];
+          current.push(row);
+          patchMap.set(row.bundle_id, current);
+        }
+
+        return patchMap;
+      };
+
       const queryBundlesForUpdateInfo = async (
         conditions: QueryConditions,
         context?: HotUpdaterContext<TContext>,
       ): Promise<Bundle[]> => {
         const { sql: whereClause, params } = buildWhereClause(conditions);
-        const rows = await queryAll<SnakeCaseBundle>(
+        const rows = await queryAll<D1WorkerBundleRow>(
           `
             SELECT * FROM bundles
             ${whereClause}
@@ -249,8 +369,14 @@ export const d1WorkerDatabase = <
           params,
           context,
         );
+        const patchMap = await getPatchMap(
+          rows.map((row) => row.id),
+          context,
+        );
 
-        return rows.map(transformRowToBundle);
+        return rows.map((row) =>
+          transformRowToBundle(row, patchMap.get(row.id)),
+        );
       };
 
       const getTargetAppVersionsForUpdateInfo = async (
@@ -324,13 +450,16 @@ export const d1WorkerDatabase = <
         }),
 
         async getBundleById(bundleId, context) {
-          const row = await queryFirst<SnakeCaseBundle>(
-            "SELECT * FROM bundles WHERE id = ? LIMIT 1",
-            [bundleId],
-            context,
-          );
+          const [row, patchMap] = await Promise.all([
+            queryFirst<D1WorkerBundleRow>(
+              "SELECT * FROM bundles WHERE id = ? LIMIT 1",
+              [bundleId],
+              context,
+            ),
+            getPatchMap([bundleId], context),
+          ]);
 
-          return row ? transformRowToBundle(row) : null;
+          return row ? transformRowToBundle(row, patchMap.get(bundleId)) : null;
         },
 
         async getBundles(options, context) {
@@ -352,13 +481,19 @@ export const d1WorkerDatabase = <
           );
           const total = countRows[0]?.total ?? 0;
 
-          const rows = await queryAll<SnakeCaseBundle>(
+          const rows = await queryAll<D1WorkerBundleRow>(
             `SELECT * FROM bundles${whereClause} ${orderSql} LIMIT ? OFFSET ?`,
             [...params, limit, offset],
             context,
           );
 
-          const bundles = rows.map(transformRowToBundle);
+          const patchMap = await getPatchMap(
+            rows.map((row) => row.id),
+            context,
+          );
+          const bundles = rows.map((row) =>
+            transformRowToBundle(row, patchMap.get(row.id)),
+          );
 
           const paginationOptions: PaginationOptions = { limit, offset };
           return {
@@ -385,6 +520,14 @@ export const d1WorkerDatabase = <
 
           for (const operation of changedSets) {
             if (operation.operation === "delete") {
+              await db
+                .prepare("DELETE FROM bundle_patches WHERE bundle_id = ?")
+                .bind(operation.data.id)
+                .run();
+              await db
+                .prepare("DELETE FROM bundle_patches WHERE base_bundle_id = ?")
+                .bind(operation.data.id)
+                .run();
               await db
                 .prepare("DELETE FROM bundles WHERE id = ?")
                 .bind(operation.data.id)
@@ -408,10 +551,13 @@ export const d1WorkerDatabase = <
                   storage_uri,
                   fingerprint_hash,
                   metadata,
+                  manifest_storage_uri,
+                  manifest_file_hash,
+                  asset_base_storage_uri,
                   rollout_cohort_count,
                   target_cohorts
                 )
-                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
               `)
               .bind(
                 bundle.id,
@@ -425,13 +571,50 @@ export const d1WorkerDatabase = <
                 bundle.targetAppVersion,
                 bundle.storageUri,
                 bundle.fingerprintHash,
-                JSON.stringify(bundle.metadata ?? {}),
+                JSON.stringify(
+                  stripBundleArtifactMetadata(bundle.metadata) ?? {},
+                ),
+                getManifestStorageUri(bundle),
+                getManifestFileHash(bundle),
+                getAssetBaseStorageUri(bundle),
                 bundle.rolloutCohortCount ?? DEFAULT_ROLLOUT_COHORT_COUNT,
                 bundle.targetCohorts
                   ? JSON.stringify(bundle.targetCohorts)
                   : null,
               )
               .run();
+
+            await db
+              .prepare("DELETE FROM bundle_patches WHERE bundle_id = ?")
+              .bind(bundle.id)
+              .run();
+
+            const patchRows = bundleToPatchRows(bundle);
+            for (const patchRow of patchRows) {
+              await db
+                .prepare(`
+                  INSERT OR REPLACE INTO bundle_patches (
+                    id,
+                    bundle_id,
+                    base_bundle_id,
+                    base_file_hash,
+                    patch_file_hash,
+                    patch_storage_uri,
+                    order_index
+                  )
+                  VALUES (?, ?, ?, ?, ?, ?, ?)
+                `)
+                .bind(
+                  patchRow.id,
+                  patchRow.bundle_id,
+                  patchRow.base_bundle_id,
+                  patchRow.base_file_hash,
+                  patchRow.patch_file_hash,
+                  patchRow.patch_storage_uri,
+                  patchRow.order_index ?? 0,
+                )
+                .run();
+            }
           }
         },
       };

package/src/d1Database.spec.ts

@@ -20,12 +20,26 @@ type D1Row = {
   storage_uri: string;
   fingerprint_hash: string | null;
   metadata: string;
+  manifest_storage_uri?: string | null;
+  manifest_file_hash?: string | null;
+  asset_base_storage_uri?: string | null;
   rollout_cohort_count: number | null;
   target_cohorts: string | null;
 };
 
-const { rows } = vi.hoisted(() => ({
+type D1PatchRow = {
+  id: string;
+  bundle_id: string;
+  base_bundle_id: string;
+  base_file_hash: string;
+  patch_file_hash: string;
+  patch_storage_uri: string;
+  order_index: number | null;
+};
+
+const { rows, patchRows } = vi.hoisted(() => ({
   rows: new Map<string, D1Row>(),
+  patchRows: new Map<string, D1PatchRow>(),
 }));
 
 vi.mock("pg-minify", () => ({
@@ -170,6 +184,25 @@ vi.mock("cloudflare", () => ({
             return createPage(row ? [row] : []);
           }
 
+          if (
+            normalizedSql.startsWith(
+              "select * from bundle_patches where bundle_id in",
+            )
+          ) {
+            const selectedBundleIds = new Set(
+              params.map((value) => String(value)),
+            );
+            const result = Array.from(patchRows.values())
+              .filter((row) => selectedBundleIds.has(row.bundle_id))
+              .sort(
+                (a, b) =>
+                  Number(a.order_index ?? 0) - Number(b.order_index ?? 0) ||
+                  a.base_bundle_id.localeCompare(b.base_bundle_id),
+              );
+
+            return createPage(result);
+          }
+
           if (normalizedSql.startsWith("select * from bundles")) {
             const { filteredRows, index } = getFilteredRows(sql, params);
             const limit = Number(params[index] ?? filteredRows.length);
@@ -214,6 +247,34 @@ vi.mock("cloudflare", () => ({
             return createPage([]);
           }
 
+          if (
+            normalizedSql.startsWith(
+              "delete from bundle_patches where bundle_id = ?",
+            )
+          ) {
+            const bundleId = String(params[0]);
+            for (const [id, row] of patchRows.entries()) {
+              if (row.bundle_id === bundleId) {
+                patchRows.delete(id);
+              }
+            }
+            return createPage([]);
+          }
+
+          if (
+            normalizedSql.startsWith(
+              "delete from bundle_patches where base_bundle_id = ?",
+            )
+          ) {
+            const baseBundleId = String(params[0]);
+            for (const [id, row] of patchRows.entries()) {
+              if (row.base_bundle_id === baseBundleId) {
+                patchRows.delete(id);
+              }
+            }
+            return createPage([]);
+          }
+
           if (normalizedSql.startsWith("insert or replace into bundles")) {
             const row: D1Row = {
               id: params[0],
@@ -228,13 +289,32 @@ vi.mock("cloudflare", () => ({
               storage_uri: params[9],
               fingerprint_hash: params[10],
               metadata: params[11],
-              rollout_cohort_count: params[12],
-              target_cohorts: params[13],
+              manifest_storage_uri: params[12],
+              manifest_file_hash: params[13],
+              asset_base_storage_uri: params[14],
+              rollout_cohort_count: params[15],
+              target_cohorts: params[16],
             };
             rows.set(row.id, row);
             return createPage([]);
           }
 
+          if (
+            normalizedSql.startsWith("insert or replace into bundle_patches")
+          ) {
+            const row: D1PatchRow = {
+              id: params[0],
+              bundle_id: params[1],
+              base_bundle_id: params[2],
+              base_file_hash: params[3],
+              patch_file_hash: params[4],
+              patch_storage_uri: params[5],
+              order_index: Number(params[6] ?? 0),
+            };
+            patchRows.set(row.id, row);
+            return createPage([]);
+          }
+
           throw new Error(`Unsupported SQL in D1 mock: ${sql}`);
         },
       },
@@ -247,6 +327,7 @@ describe("d1Database plugin", () => {
 
   beforeEach(() => {
     rows.clear();
+    patchRows.clear();
     plugin = d1Database({
       databaseId: "test-db-id",
       accountId: "test-account-id",
@@ -279,6 +360,7 @@ describe("d1Database plugin", () => {
   setupGetUpdateInfoTestSuite({
     getUpdateInfo: async (bundles, args) => {
       rows.clear();
+      patchRows.clear();
 
       for (const bundle of bundles) {
         await plugin.appendBundle(bundle);