@hot-updater/cloudflare 0.36.6 → 1.0.0-rc.0

package/worker/src/index.integration.spec.ts

@@ -1,25 +1,17 @@
 import {
-  getBundlePatches,
   type Bundle,
-  type GetBundlesArgs,
-  NIL_UUID,
+  createReleaseCatalogScopeKey,
+  encodeChannelKey,
 } from "@hot-updater/core";
-import { signToken } from "@hot-updater/js";
 import {
-  setupBsdiffManifestUpdateInfoTestSuite,
-  setupGetUpdateInfoTestSuite,
-} from "@hot-updater/test-utils";
+  commitReleaseCatalogMutations,
+  createUUIDv7,
+} from "@hot-updater/plugin-core";
+import { createHotUpdater, registerApiKey } from "@hot-updater/server";
 import { env } from "cloudflare:test";
-import {
-  beforeAll,
-  beforeEach,
-  describe,
-  expect,
-  inject,
-  it,
-  vi,
-} from "vitest";
+import { beforeAll, beforeEach, describe, expect, inject, it } from "vitest";
 
+import { d1Database } from "../../src/worker";
 import worker, { HOT_UPDATER_BASE_PATH } from "./index";
 
 declare module "vitest" {
@@ -32,333 +24,149 @@ declare module "cloudflare:test" {
   interface ProvidedEnv {
     DB: D1Database;
     BUCKET: R2Bucket;
-    JWT_SECRET: string;
+    BUCKET_NAME: string;
+    STORAGE_DOWNLOAD_URL_SIGNING_KEY: string;
   }
 }
 
 const PUBLIC_BASE_URL = "https://updates.example.com";
-
-const sqlString = (value: string) => `'${value.replaceAll("'", "''")}'`;
-
-const createInsertBundleQuery = (bundle: Bundle) => {
-  const rolloutCohortCount = bundle.rolloutCohortCount ?? 1000;
-  const targetCohorts = bundle.targetCohorts
-    ? sqlString(JSON.stringify(bundle.targetCohorts))
-    : "null";
-  const metadata = sqlString(JSON.stringify(bundle.metadata ?? {}));
-
-  return `
-    INSERT INTO bundles (
-      id, file_hash, platform, target_app_version,
-      should_force_update, enabled, git_commit_hash, message, channel,
-      storage_uri, fingerprint_hash, metadata, manifest_storage_uri,
-      manifest_file_hash, asset_base_storage_uri, rollout_cohort_count,
-      target_cohorts
-    ) VALUES (
-      ${sqlString(bundle.id)},
-      ${sqlString(bundle.fileHash)},
-      ${sqlString(bundle.platform)},
-      ${bundle.targetAppVersion ? sqlString(bundle.targetAppVersion) : "null"},
-      ${bundle.shouldForceUpdate},
-      ${bundle.enabled},
-      ${bundle.gitCommitHash ? sqlString(bundle.gitCommitHash) : "null"},
-      ${bundle.message ? sqlString(bundle.message) : "null"},
-      ${sqlString(bundle.channel)},
-      ${bundle.storageUri ? sqlString(bundle.storageUri) : "null"},
-      ${bundle.fingerprintHash ? sqlString(bundle.fingerprintHash) : "null"},
-      ${metadata},
-      ${bundle.manifestStorageUri ? sqlString(bundle.manifestStorageUri) : "null"},
-      ${bundle.manifestFileHash ? sqlString(bundle.manifestFileHash) : "null"},
-      ${bundle.assetBaseStorageUri ? sqlString(bundle.assetBaseStorageUri) : "null"},
-      ${rolloutCohortCount},
-      ${targetCohorts}
-    ) ON CONFLICT(id) DO UPDATE SET
-      file_hash = excluded.file_hash,
-      platform = excluded.platform,
-      target_app_version = excluded.target_app_version,
-      should_force_update = excluded.should_force_update,
-      enabled = excluded.enabled,
-      git_commit_hash = excluded.git_commit_hash,
-      message = excluded.message,
-      channel = excluded.channel,
-      storage_uri = excluded.storage_uri,
-      fingerprint_hash = excluded.fingerprint_hash,
-      metadata = excluded.metadata,
-      manifest_storage_uri = excluded.manifest_storage_uri,
-      manifest_file_hash = excluded.manifest_file_hash,
-      asset_base_storage_uri = excluded.asset_base_storage_uri,
-      rollout_cohort_count = excluded.rollout_cohort_count,
-      target_cohorts = excluded.target_cohorts;
-  `;
-};
-
-const createInsertBundlePatchQueries = (bundle: Bundle) =>
-  getBundlePatches(bundle).map(
-    (patch, index) => `
-    INSERT INTO bundle_patches (
-      id,
-      bundle_id,
-      base_bundle_id,
-      base_file_hash,
-      patch_file_hash,
-      patch_storage_uri,
-      order_index
-    ) VALUES (
-      ${sqlString(`${bundle.id}:${patch.baseBundleId}`)},
-      ${sqlString(bundle.id)},
-      ${sqlString(patch.baseBundleId)},
-      ${sqlString(patch.baseFileHash)},
-      ${sqlString(patch.patchFileHash)},
-      ${sqlString(patch.patchStorageUri)},
-      ${index}
-    ) ON CONFLICT(id) DO UPDATE SET
-      bundle_id = excluded.bundle_id,
-      base_bundle_id = excluded.base_bundle_id,
-      base_file_hash = excluded.base_file_hash,
-      patch_file_hash = excluded.patch_file_hash,
-      patch_storage_uri = excluded.patch_storage_uri,
-      order_index = excluded.order_index;
-  `,
-  );
+const API_KEY = "AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQE";
 
 const toRuntimeBundle = (bundle: Bundle): Bundle => {
   return {
     ...bundle,
-    storageUri: `r2://bundles/${bundle.id}/bundle.zip`,
+    storageUri: `r2://${env.BUCKET_NAME}/${bundle.id}/bundle.zip`,
   };
 };
 
 const seedBundles = async (bundles: Bundle[]) => {
+  const database = d1Database(env.DB);
+  const seedHotUpdater = createHotUpdater({
+    database,
+    clientAccess: { type: "public" },
+  });
   for (const bundle of bundles.map(toRuntimeBundle)) {
-    await env.DB.prepare(createInsertBundleQuery(bundle)).run();
-    for (const patchSql of createInsertBundlePatchQueries(bundle)) {
-      await env.DB.prepare(patchSql).run();
+    const existing = await seedHotUpdater.getBundleById(bundle.id);
+    if (existing === null) {
+      await seedHotUpdater.insertBundle(bundle);
+    } else {
+      await seedHotUpdater.updateBundleById(bundle.id, bundle);
     }
+    const channelName = "production";
+    const channelKey = encodeChannelKey(channelName);
+    const channel = (
+      await database.models.channels.insert({
+        row: { id: `channel:${channelKey}`, name: channelName },
+        onConflict: "returnExisting",
+      })
+    ).row;
+    const scopeKey = createReleaseCatalogScopeKey({
+      channelKey,
+      platform: bundle.platform,
+      strategy: "APP_VERSION",
+    });
+    const now = Date.now();
+    const releaseId = createUUIDv7();
+    await commitReleaseCatalogMutations({
+      database,
+      mutations: [
+        {
+          mutation: {
+            operation: "insert",
+            row: {
+              bundle_id: bundle.id,
+              channel_id: channel.id,
+              created_at_ms: now,
+              enabled: true,
+              fingerprint_hash: null,
+              id: releaseId,
+              kind: "BUNDLE",
+              message: "hello",
+              operation: "DEPLOY",
+              platform: bundle.platform,
+              revision: 1,
+              rollout_cohort_count: 1_000,
+              scope_key: scopeKey,
+              should_force_update: false,
+              source_release_id: null,
+              strategy: "APP_VERSION",
+              target_app_version: "1.0",
+              target_cohorts: [],
+              updated_at_ms: now,
+            },
+          },
+          scope: {
+            channelId: channel.id,
+            channelName,
+            fingerprintHash: null,
+            platform: bundle.platform,
+            scopeKey,
+            strategy: "APP_VERSION",
+          },
+          updatedAtMs: now,
+        },
+      ],
+    });
   }
 };
 
-const putR2Object = async (key: string, value: string, contentType: string) => {
-  await env.BUCKET.put(key, value, {
-    httpMetadata: {
-      contentType,
-    },
-  });
-};
-
-const createCanonicalPath = (args: GetBundlesArgs) => {
-  const channel = args.channel ?? "production";
-  const minBundleId = args.minBundleId ?? NIL_UUID;
-  const cohortSegment = args.cohort
-    ? `/${encodeURIComponent(args.cohort)}`
-    : "";
-
-  if (args._updateStrategy === "appVersion") {
-    return `${HOT_UPDATER_BASE_PATH}/app-version/${encodeURIComponent(args.platform)}/${encodeURIComponent(args.appVersion)}/${encodeURIComponent(channel)}/${encodeURIComponent(minBundleId)}/${encodeURIComponent(args.bundleId)}${cohortSegment}`;
-  }
-
-  return `${HOT_UPDATER_BASE_PATH}/fingerprint/${encodeURIComponent(args.platform)}/${encodeURIComponent(args.fingerprintHash)}/${encodeURIComponent(channel)}/${encodeURIComponent(minBundleId)}/${encodeURIComponent(args.bundleId)}${cohortSegment}`;
-};
-
 describe.sequential("cloudflare worker runtime acceptance", () => {
   beforeAll(async () => {
     await env.DB.prepare(inject("prepareSql")).run();
+    const database = d1Database(env.DB);
+    await registerApiKey({
+      apiKey: API_KEY,
+      apiKeys: database.models.apiKeys,
+      name: "Runtime acceptance",
+    });
   });
 
   beforeEach(async () => {
     await env.DB.prepare("DELETE FROM bundle_patches").run();
+    await env.DB.prepare("DELETE FROM release_catalogs").run();
+    await env.DB.prepare("DELETE FROM releases").run();
     await env.DB.prepare("DELETE FROM bundles").run();
+    await env.DB.prepare("DELETE FROM channels").run();
   });
 
-  const requestUpdateInfo = async (args: GetBundlesArgs) => {
-    const response = await worker.fetch(
-      new Request(`${PUBLIC_BASE_URL}${createCanonicalPath(args)}`),
-      env,
-    );
-
-    return (await response.json()) as any;
-  };
-
-  const getUpdateInfo = async (bundles: Bundle[], args: GetBundlesArgs) => {
-    await seedBundles(bundles);
-
-    return requestUpdateInfo(args);
-  };
-
-  setupGetUpdateInfoTestSuite({
-    getUpdateInfo,
-    manifestArtifacts: {
-      prepareArtifacts: async (fixture) => {
-        await Promise.all([
-          putR2Object(
-            `${fixture.currentBundleId}/manifest.json`,
-            JSON.stringify(fixture.currentManifest),
-            "application/json",
-          ),
-          putR2Object(
-            `${fixture.nextBundleId}/manifest.json`,
-            JSON.stringify(fixture.nextManifest),
-            "application/json",
-          ),
-        ]);
-
-        vi.stubGlobal(
-          "fetch",
-          vi.fn<typeof fetch>(async () => {
-            return new Response("worker subrequest failed", { status: 502 });
-          }),
-        );
-
-        return {
-          cleanup: () => {
-            vi.unstubAllGlobals();
-          },
-          currentArtifacts: {
-            assetBaseStorageUri: `r2://bundles/${fixture.currentBundleId}/files`,
-            manifestFileHash: "sig:manifest-current",
-            manifestStorageUri: `r2://bundles/${fixture.currentBundleId}/manifest.json`,
-          },
-          nextArtifacts: {
-            assetBaseStorageUri: `r2://bundles/${fixture.nextBundleId}/files`,
-            manifestFileHash: "sig:manifest-next",
-            manifestStorageUri: `r2://bundles/${fixture.nextBundleId}/manifest.json`,
-          },
-        };
-      },
-      expectFileUrl: (fileUrl, fixture) => {
-        expect(fileUrl).toContain(
-          `/bundles/${fixture.nextBundleId}/files/${fixture.changedAssetPath}`,
-        );
-      },
-      expectManifestUrl: (manifestUrl, fixture) => {
-        expect(manifestUrl).toContain(`/${fixture.nextBundleId}/manifest.json`);
-      },
-    },
-  });
-
-  setupBsdiffManifestUpdateInfoTestSuite({
-    seedBundles,
-    getUpdateInfo: requestUpdateInfo,
-    prepareArtifacts: async (fixture) => {
-      await Promise.all([
-        putR2Object(
-          `${fixture.currentBundleId}/manifest.json`,
-          JSON.stringify(fixture.currentManifest),
-          "application/json",
-        ),
-        putR2Object(
-          `${fixture.nextBundleId}/manifest.json`,
-          JSON.stringify(fixture.nextManifest),
-          "application/json",
-        ),
-        putR2Object(
-          fixture.patchPath,
-          "patch-bytes",
-          "application/octet-stream",
-        ),
-        putR2Object(
-          `${fixture.currentBundleId}/bundle.zip`,
-          "zip",
-          "application/zip",
-        ),
-        putR2Object(
-          `${fixture.nextBundleId}/bundle.zip`,
-          "zip",
-          "application/zip",
-        ),
-      ]);
-
-      vi.stubGlobal(
-        "fetch",
-        vi.fn<typeof fetch>(async () => {
-          return new Response("worker subrequest failed", { status: 502 });
-        }),
-      );
-
-      return {
-        cleanup: () => {
-          vi.unstubAllGlobals();
-        },
-        currentArtifacts: {
-          assetBaseStorageUri: `r2://bundles/${fixture.currentBundleId}/files`,
-          manifestFileHash: "sig:manifest-current",
-          manifestStorageUri: `r2://bundles/${fixture.currentBundleId}/manifest.json`,
-        },
-        nextArtifacts: {
-          assetBaseStorageUri: `r2://bundles/${fixture.nextBundleId}/files`,
-          manifestFileHash: "sig:manifest-next",
-          manifestStorageUri: `r2://bundles/${fixture.nextBundleId}/manifest.json`,
-          patches: [
-            {
-              baseBundleId: fixture.currentBundleId,
-              baseFileHash: "hash-old-bundle",
-              patchFileHash: "hash-bsdiff",
-              patchStorageUri: `r2://bundles/${fixture.patchPath}`,
-            },
-          ],
-        },
-      };
-    },
-    expectPatchUrl: (patchUrl, fixture) => {
-      expect(patchUrl).toContain(`/bundles/${fixture.patchPath}`);
-    },
-  });
-
-  it("serves canonical routes from the worker entrypoint", async () => {
+  it("serves unversioned Release Catalog routes from the worker entrypoint", async () => {
+    expect(HOT_UPDATER_BASE_PATH).toBe("/");
     await seedBundles([
       {
         id: "00000000-0000-0000-0000-000000000001",
         platform: "ios",
-        targetAppVersion: "1.0",
-        shouldForceUpdate: false,
-        enabled: true,
         fileHash: "hash",
         gitCommitHash: null,
-        message: "hello",
-        channel: "production",
         storageUri: "storage://unused",
-        fingerprintHash: null,
+        archiveByteSize: 3_000_000_001,
       },
     ]);
 
-    const response = await worker.fetch(
+    const unauthorized = await worker.fetch(
       new Request(
-        `${PUBLIC_BASE_URL}${createCanonicalPath({
-          appVersion: "1.0",
-          bundleId: NIL_UUID,
-          platform: "ios",
-          _updateStrategy: "appVersion",
-        })}`,
+        `${PUBLIC_BASE_URL}/release-catalogs/app-version/ios/cHJvZHVjdGlvbg/1.0.0`,
       ),
       env,
     );
-
-    await expect(response.json()).resolves.toMatchObject({
-      id: "00000000-0000-0000-0000-000000000001",
-      status: "UPDATE",
-    });
-  });
-
-  it("serves signed R2 URLs for percent-encoded object keys", async () => {
-    const encodedKey = "bundles/assets/bootsplash/logo-ios%402x.png";
-    await putR2Object(
-      "assets/bootsplash/logo-ios@2x.png",
-      "asset",
-      "text/plain",
-    );
-    const token = await signToken(encodedKey, env.JWT_SECRET);
+    expect(unauthorized.status).toBe(401);
 
     const response = await worker.fetch(
-      new Request(`${PUBLIC_BASE_URL}/${encodedKey}?token=${token}`),
+      new Request(
+        `${PUBLIC_BASE_URL}/release-catalogs/app-version/ios/cHJvZHVjdGlvbg/1.0.0`,
+        { headers: { "x-api-key": API_KEY } },
+      ),
       env,
     );
 
-    expect(response.status).toBe(200);
-    await expect(response.text()).resolves.toBe("asset");
+    await expect(response.json()).resolves.toMatchObject({
+      catalogId: expect.stringMatching(/^[0-9a-f-]{36}$/),
+      releases: [{ bundleId: "00000000-0000-0000-0000-000000000001" }],
+    });
   });
 
   it("does not support the legacy exact path", async () => {
     const response = await worker.fetch(
-      new Request(`${PUBLIC_BASE_URL}${HOT_UPDATER_BASE_PATH}`),
+      new Request(`${PUBLIC_BASE_URL}/api/check-update`),
       env,
     );
 
@@ -370,7 +178,7 @@ describe.sequential("cloudflare worker runtime acceptance", () => {
 
   it("does not expose management routes from the worker entrypoint", async () => {
     const response = await worker.fetch(
-      new Request(`${PUBLIC_BASE_URL}${HOT_UPDATER_BASE_PATH}/api/bundles`),
+      new Request(`${PUBLIC_BASE_URL}/admin/bundles`),
       env,
     );
 

package/worker/src/index.ts

@@ -1,89 +1,37 @@
-import { decodeStorageObjectKey } from "@hot-updater/plugin-core";
 import { createHotUpdater } from "@hot-updater/server";
+import { env } from "cloudflare:workers";
 import { Hono } from "hono";
 
-import {
-  d1Database,
-  type RequestEnvContext,
-  r2Storage,
-  verifyJwtSignedUrl,
-} from "../../src/worker";
+import { d1Database, r2Storage } from "../../src/worker";
 
 export type CloudflareWorkerEnv = {
   DB: {
+    batch: D1Database["batch"];
     prepare: D1Database["prepare"];
   };
   BUCKET: R2Bucket;
-  JWT_SECRET: string;
+  BUCKET_NAME: string;
+  STORAGE_DOWNLOAD_URL_SIGNING_KEY: string;
 };
 
-export const HOT_UPDATER_BASE_PATH = "/api/check-update";
-
-const resolveRequestOrigin = (context?: RequestEnvContext) => {
-  const request = context?.request;
-
-  if (!request) {
-    throw new Error(
-      "r2WorkerStorage requires a request to resolve publicBaseUrl.",
-    );
-  }
-
-  return new URL(request.url).origin;
-};
+export const HOT_UPDATER_BASE_PATH = "/";
 
 const hotUpdater = createHotUpdater({
-  database: d1Database(),
-  storages: [
+  database: d1Database(env.DB),
+  clientAccess: { type: "api-key" },
+  storage: [
     r2Storage({
-      publicBaseUrl: resolveRequestOrigin,
+      bucket: env.BUCKET,
+      bucketName: env.BUCKET_NAME,
+      downloadUrlSigningKey: env.STORAGE_DOWNLOAD_URL_SIGNING_KEY,
     }),
   ],
-  basePath: HOT_UPDATER_BASE_PATH,
-  routes: {
-    updateCheck: true,
-    bundles: false,
-  },
 });
 
 const app = new Hono<{ Bindings: CloudflareWorkerEnv }>();
 
-app.mount(
-  HOT_UPDATER_BASE_PATH,
-  (request: Request, env: CloudflareWorkerEnv) => {
-    return hotUpdater.handler(request, {
-      request,
-      env,
-    });
-  },
-  {
-    optionHandler: (c) => [c.env],
-  },
+app.mount(HOT_UPDATER_BASE_PATH, (request: Request) =>
+  hotUpdater.handlers.client(request),
 );
 
-app.get("*", async (c) => {
-  const result = await verifyJwtSignedUrl({
-    path: new URL(c.req.url).pathname,
-    token: c.req.query("token"),
-    jwtSecret: c.env.JWT_SECRET,
-    handler: async (storageUri) => {
-      const [, ...key] = decodeStorageObjectKey(storageUri).split("/");
-      const object = await c.env.BUCKET.get(key.join("/"));
-      if (!object) {
-        return null;
-      }
-
-      return {
-        body: object.body,
-        contentType: object.httpMetadata?.contentType,
-      };
-    },
-  });
-
-  if (result.status !== 200) {
-    return c.json({ error: result.error }, result.status);
-  }
-
-  return c.body(result.responseBody, 200, result.responseHeaders);
-});
-
 export default app;

package/worker/src/storagePlugin.integration.spec.ts

@@ -0,0 +1,59 @@
+import { env } from "cloudflare:test";
+import { afterEach, describe, expect, it } from "vitest";
+
+import { r2Storage } from "../../src/worker";
+
+const UNKNOWN_LENGTH_KEY = "storage-tests/unknown-length.txt";
+const KNOWN_LENGTH_KEY = "storage-tests/known-length.txt";
+
+const createChunkedBody = (...chunks: string[]) =>
+  new ReadableStream<Uint8Array>({
+    start(controller) {
+      for (const chunk of chunks) {
+        controller.enqueue(new TextEncoder().encode(chunk));
+      }
+      controller.close();
+    },
+  });
+
+const createStorage = () =>
+  r2Storage({
+    bucket: env.BUCKET,
+    bucketName: env.BUCKET_NAME,
+    downloadUrlSigningKey: env.STORAGE_DOWNLOAD_URL_SIGNING_KEY,
+  });
+
+afterEach(async () => {
+  await env.BUCKET.delete([UNKNOWN_LENGTH_KEY, KNOWN_LENGTH_KEY]);
+});
+
+describe("Cloudflare Worker R2 storage uploads", () => {
+  it("writes exact bytes from an unknown-length stream", async () => {
+    const storage = createStorage();
+
+    await storage.put({
+      key: UNKNOWN_LENGTH_KEY,
+      body: createChunkedBody("unknown", "-length"),
+      contentType: "text/plain",
+    });
+
+    await expect(
+      env.BUCKET.get(UNKNOWN_LENGTH_KEY).then((item) => item?.text()),
+    ).resolves.toBe("unknown-length");
+  });
+
+  it("streams known-length bytes through FixedLengthStream", async () => {
+    const storage = createStorage();
+
+    await storage.put({
+      key: KNOWN_LENGTH_KEY,
+      body: createChunkedBody("known", "-length"),
+      contentLength: 12,
+      contentType: "text/plain",
+    });
+
+    await expect(
+      env.BUCKET.get(KNOWN_LENGTH_KEY).then((item) => item?.text()),
+    ).resolves.toBe("known-length");
+  });
+});

package/worker/wrangler.json

@@ -2,8 +2,11 @@
   "$schema": "node_modules/wrangler/config-schema.json",
   "name": "hot-updater",
   "main": "./dist/index.js",
-  "compatibility_date": "2025-01-24",
+  "compatibility_date": "2026-08-13",
   "compatibility_flags": ["nodejs_compat"],
+  "cache": {
+    "enabled": true
+  },
   "observability": {
     "enabled": true
   },
@@ -20,6 +23,6 @@
     }
   ],
   "vars": {
-    "JWT_SECRET": "USER_JWT_SECRET"
+    "BUCKET_NAME": "user-buckets"
   }
 }