@hot-updater/cloudflare 0.28.0 → 0.29.0

package/worker/migrations/0004_hot-updater_0.29.0.sql

@@ -0,0 +1,11 @@
+-- Migration number: 0004 	 2025-12-21T00:00:00.000Z
+
+-- HotUpdater.bundles
+
+ALTER TABLE bundles ADD COLUMN rollout_cohort_count INTEGER DEFAULT 1000
+  CHECK (rollout_cohort_count >= 0 AND rollout_cohort_count <= 1000);
+
+CREATE INDEX IF NOT EXISTS bundles_rollout_idx ON bundles(rollout_cohort_count);
+
+-- SQLite doesn't have array type, store as JSON text
+ALTER TABLE bundles ADD COLUMN target_cohorts TEXT;

package/worker/src/getUpdateInfo.ts

@@ -0,0 +1,200 @@
+import {
+  type AppVersionGetBundlesArgs,
+  type Bundle,
+  DEFAULT_ROLLOUT_COHORT_COUNT,
+  type FingerprintGetBundlesArgs,
+  type GetBundlesArgs,
+  NIL_UUID,
+} from "@hot-updater/core";
+import {
+  filterCompatibleAppVersions,
+  getUpdateInfo as getUpdateInfoJS,
+} from "@hot-updater/js";
+
+const parseTargetCohorts = (value: string | null): string[] | null => {
+  if (!value) return null;
+  try {
+    const parsed = JSON.parse(value) as unknown;
+    if (Array.isArray(parsed)) {
+      return parsed.filter((v): v is string => typeof v === "string");
+    }
+  } catch {
+    return null;
+  }
+  return null;
+};
+
+type BundleRow = {
+  id: string;
+  platform: Bundle["platform"];
+  should_force_update: number;
+  enabled: number;
+  file_hash: string;
+  git_commit_hash: string | null;
+  message: string | null;
+  channel: string;
+  storage_uri: string;
+  target_app_version: string | null;
+  fingerprint_hash: string | null;
+  rollout_cohort_count: number | null;
+  target_cohorts: string | null;
+};
+
+const convertToBundle = (row: BundleRow): Bundle => ({
+  id: row.id,
+  platform: row.platform,
+  shouldForceUpdate: Boolean(row.should_force_update),
+  enabled: Boolean(row.enabled),
+  fileHash: row.file_hash,
+  gitCommitHash: row.git_commit_hash,
+  message: row.message,
+  channel: row.channel,
+  storageUri: row.storage_uri,
+  targetAppVersion: row.target_app_version,
+  fingerprintHash: row.fingerprint_hash,
+  rolloutCohortCount: row.rollout_cohort_count ?? DEFAULT_ROLLOUT_COHORT_COUNT,
+  targetCohorts: parseTargetCohorts(row.target_cohorts),
+});
+
+const appVersionStrategy = async (
+  DB: D1Database,
+  {
+    platform,
+    appVersion,
+    bundleId,
+    minBundleId = NIL_UUID,
+    channel = "production",
+    cohort,
+  }: AppVersionGetBundlesArgs,
+) => {
+  const appVersionList = await DB.prepare(
+    /* sql */ `
+    SELECT 
+      target_app_version
+    FROM bundles
+    WHERE platform = ?
+      AND channel = ?
+      AND enabled = 1
+      AND id >= ?
+      AND target_app_version IS NOT NULL
+    GROUP BY target_app_version
+  `,
+  )
+    .bind(platform, channel, minBundleId)
+    .all<{ target_app_version: string; count: number }>();
+
+  const targetAppVersionList = filterCompatibleAppVersions(
+    appVersionList.results.map((group) => group.target_app_version),
+    appVersion,
+  );
+
+  if (targetAppVersionList.length === 0) {
+    return getUpdateInfoJS([], {
+      platform,
+      appVersion,
+      bundleId,
+      minBundleId,
+      channel,
+      cohort,
+      _updateStrategy: "appVersion",
+    });
+  }
+
+  const placeholders = targetAppVersionList.map(() => "?").join(", ");
+  const rows = await DB.prepare(
+    /* sql */ `
+    SELECT
+      id,
+      platform,
+      should_force_update,
+      enabled,
+      file_hash,
+      git_commit_hash,
+      message,
+      channel,
+      storage_uri,
+      target_app_version,
+      fingerprint_hash,
+      rollout_cohort_count,
+      target_cohorts
+    FROM bundles
+    WHERE enabled = 1
+      AND platform = ?
+      AND id >= ?
+      AND channel = ?
+      AND target_app_version IN (${placeholders})
+  `,
+  )
+    .bind(platform, minBundleId, channel, ...targetAppVersionList)
+    .all<BundleRow>();
+
+  return getUpdateInfoJS(rows.results.map(convertToBundle), {
+    platform,
+    appVersion,
+    bundleId,
+    minBundleId,
+    channel,
+    cohort,
+    _updateStrategy: "appVersion",
+  });
+};
+
+export const fingerprintStrategy = async (
+  DB: D1Database,
+  {
+    platform,
+    fingerprintHash,
+    bundleId,
+    minBundleId = NIL_UUID,
+    channel = "production",
+    cohort,
+  }: FingerprintGetBundlesArgs,
+) => {
+  const rows = await DB.prepare(
+    /* sql */ `
+    SELECT
+      id,
+      platform,
+      should_force_update,
+      enabled,
+      file_hash,
+      git_commit_hash,
+      message,
+      channel,
+      storage_uri,
+      target_app_version,
+      fingerprint_hash,
+      rollout_cohort_count,
+      target_cohorts
+    FROM bundles
+    WHERE enabled = 1
+      AND platform = ?
+      AND id >= ?
+      AND channel = ?
+      AND fingerprint_hash = ?
+  `,
+  )
+    .bind(platform, minBundleId, channel, fingerprintHash)
+    .all<BundleRow>();
+
+  return getUpdateInfoJS(rows.results.map(convertToBundle), {
+    platform,
+    fingerprintHash,
+    bundleId,
+    minBundleId,
+    channel,
+    cohort,
+    _updateStrategy: "fingerprint",
+  });
+};
+
+export const getUpdateInfo = (DB: D1Database, args: GetBundlesArgs) => {
+  switch (args._updateStrategy) {
+    case "appVersion":
+      return appVersionStrategy(DB, args);
+    case "fingerprint":
+      return fingerprintStrategy(DB, args);
+    default:
+      return null;
+  }
+};

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

@@ -0,0 +1,171 @@
+import { env } from "cloudflare:test";
+import { type Bundle, type GetBundlesArgs, NIL_UUID } from "@hot-updater/core";
+import { setupGetUpdateInfoTestSuite } from "@hot-updater/test-utils";
+import { beforeAll, beforeEach, describe, expect, inject, it } from "vitest";
+import worker, { HOT_UPDATER_BASE_PATH } from "./index";
+
+declare module "vitest" {
+  export interface ProvidedContext {
+    prepareSql: string;
+  }
+}
+
+declare module "cloudflare:test" {
+  interface ProvidedEnv {
+    DB: D1Database;
+    BUCKET: R2Bucket;
+    JWT_SECRET: string;
+  }
+}
+
+const PUBLIC_BASE_URL = "https://updates.example.com";
+
+const createInsertBundleQuery = (bundle: Bundle) => {
+  const rolloutCohortCount = bundle.rolloutCohortCount ?? 1000;
+  const targetCohorts = bundle.targetCohorts
+    ? `'${JSON.stringify(bundle.targetCohorts)}'`
+    : "null";
+
+  return `
+    INSERT INTO bundles (
+      id, file_hash, platform, target_app_version,
+      should_force_update, enabled, git_commit_hash, message, channel,
+      storage_uri, fingerprint_hash, rollout_cohort_count, target_cohorts
+    ) VALUES (
+      '${bundle.id}',
+      '${bundle.fileHash}',
+      '${bundle.platform}',
+      ${bundle.targetAppVersion ? `'${bundle.targetAppVersion}'` : "null"},
+      ${bundle.shouldForceUpdate},
+      ${bundle.enabled},
+      ${bundle.gitCommitHash ? `'${bundle.gitCommitHash}'` : "null"},
+      ${bundle.message ? `'${bundle.message}'` : "null"},
+      '${bundle.channel}',
+      ${bundle.storageUri ? `'${bundle.storageUri}'` : "null"},
+      ${bundle.fingerprintHash ? `'${bundle.fingerprintHash}'` : "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,
+      rollout_cohort_count = excluded.rollout_cohort_count,
+      target_cohorts = excluded.target_cohorts;
+  `;
+};
+
+const toRuntimeBundle = (bundle: Bundle): Bundle => {
+  return {
+    ...bundle,
+    storageUri: `r2://bundles/${bundle.id}/bundle.zip`,
+  };
+};
+
+const seedBundles = async (bundles: Bundle[]) => {
+  for (const bundle of bundles.map(toRuntimeBundle)) {
+    await env.DB.prepare(createInsertBundleQuery(bundle)).run();
+  }
+};
+
+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();
+  });
+
+  beforeEach(async () => {
+    await env.DB.prepare("DELETE FROM bundles").run();
+  });
+
+  const getUpdateInfo = async (bundles: Bundle[], args: GetBundlesArgs) => {
+    await seedBundles(bundles);
+
+    const response = await worker.fetch(
+      new Request(`${PUBLIC_BASE_URL}${createCanonicalPath(args)}`),
+      env,
+    );
+
+    return (await response.json()) as any;
+  };
+
+  setupGetUpdateInfoTestSuite({ getUpdateInfo });
+
+  it("serves canonical routes from the worker entrypoint", async () => {
+    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,
+      },
+    ]);
+
+    const response = await worker.fetch(
+      new Request(
+        `${PUBLIC_BASE_URL}${createCanonicalPath({
+          appVersion: "1.0",
+          bundleId: NIL_UUID,
+          platform: "ios",
+          _updateStrategy: "appVersion",
+        })}`,
+      ),
+      env,
+    );
+
+    await expect(response.json()).resolves.toMatchObject({
+      id: "00000000-0000-0000-0000-000000000001",
+      status: "UPDATE",
+    });
+  });
+
+  it("does not support the legacy exact path", async () => {
+    const response = await worker.fetch(
+      new Request(`${PUBLIC_BASE_URL}${HOT_UPDATER_BASE_PATH}`),
+      env,
+    );
+
+    expect(response.status).toBe(404);
+    await expect(response.json()).resolves.toEqual({
+      error: "Not found",
+    });
+  });
+
+  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`),
+      env,
+    );
+
+    expect(response.status).toBe(404);
+    await expect(response.json()).resolves.toEqual({
+      error: "Not found",
+    });
+  });
+});

package/worker/src/index.ts

@@ -0,0 +1,87 @@
+import { createHotUpdater } from "@hot-updater/server/runtime";
+import { Hono } from "hono";
+import {
+  d1Database,
+  type RequestEnvContext,
+  r2Storage,
+  verifyJwtSignedUrl,
+} from "../../src/worker";
+
+export type CloudflareWorkerEnv = {
+  DB: {
+    prepare: D1Database["prepare"];
+  };
+  BUCKET: R2Bucket;
+  JWT_SECRET: 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;
+};
+
+const hotUpdater = createHotUpdater({
+  database: d1Database(),
+  storages: [
+    r2Storage({
+      publicBaseUrl: resolveRequestOrigin,
+    }),
+  ],
+  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.get("*", async (c) => {
+  const result = await verifyJwtSignedUrl({
+    path: c.req.path,
+    token: c.req.query("token"),
+    jwtSecret: c.env.JWT_SECRET,
+    handler: async (storageUri) => {
+      const [, ...key] = 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/testWorker.ts

@@ -0,0 +1,5 @@
+export default {
+  fetch() {
+    return new Response("ok");
+  },
+};