@hot-updater/cloudflare 1.0.0-rc.5 → 1.0.0

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

@@ -1,190 +0,0 @@
-import {
-  type Bundle,
-  createReleaseCatalogScopeKey,
-  encodeChannelKey,
-} from "@hot-updater/core";
-import {
-  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 } from "vitest";
-
-import { d1Database } from "../../src/worker";
-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;
-    BUCKET_NAME: string;
-    STORAGE_DOWNLOAD_URL_SIGNING_KEY: string;
-  }
-}
-
-const PUBLIC_BASE_URL = "https://updates.example.com";
-const API_KEY = "AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQE";
-
-const toRuntimeBundle = (bundle: Bundle): Bundle => {
-  return {
-    ...bundle,
-    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)) {
-    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,
-        },
-      ],
-    });
-  }
-};
-
-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();
-  });
-
-  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",
-        fileHash: "hash",
-        gitCommitHash: null,
-        storageUri: "storage://unused",
-        archiveByteSize: 3_000_000_001,
-      },
-    ]);
-
-    const unauthorized = await worker.fetch(
-      new Request(
-        `${PUBLIC_BASE_URL}/release-catalogs/app-version/ios/cHJvZHVjdGlvbg/1.0.0`,
-      ),
-      env,
-    );
-    expect(unauthorized.status).toBe(401);
-
-    const response = await worker.fetch(
-      new Request(
-        `${PUBLIC_BASE_URL}/release-catalogs/app-version/ios/cHJvZHVjdGlvbg/1.0.0`,
-        { headers: { "x-api-key": API_KEY } },
-      ),
-      env,
-    );
-
-    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}/api/check-update`),
-      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}/admin/bundles`),
-      env,
-    );
-
-    expect(response.status).toBe(404);
-    await expect(response.json()).resolves.toEqual({
-      error: "Not found",
-    });
-  });
-});

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

@@ -1,73 +0,0 @@
-import { env } from "cloudflare:test";
-import { expect, inject, it } from "vitest";
-
-import { d1Database } from "../../src/worker";
-
-it("pages sparse movements beyond 50,000 reports through ordered native index ranges", async () => {
-  await env.DB.prepare(inject("prepareSql")).run();
-  await env.DB.prepare(`
-    WITH RECURSIVE reports(n) AS (
-      SELECT 1 UNION ALL SELECT n + 1 FROM reports WHERE n < 60000
-    )
-    INSERT INTO bundle_events (
-      id, type, install_id, from_bundle_id, to_bundle_id, platform,
-      app_version, channel, cohort, update_strategy, received_at_ms
-    )
-    SELECT '00000000-0000-7000-8000-' || printf('%012d', n),
-      CASE n % 800 WHEN 0 THEN 'UPDATE_APPLIED' WHEN 1 THEN 'RECOVERED' ELSE 'UNCHANGED' END,
-      'sparse-movement-install',
-      CASE WHEN n % 800 IN (0, 1) THEN '00000000-0000-7000-8000-000000001001' ELSE NULL END,
-      '00000000-0000-7000-8000-000000001002', 'ios', '1.0.0', 'production', '0',
-      CASE WHEN n % 800 IN (0, 1) THEN 'appVersion' ELSE NULL END,
-      n / 2
-    FROM reports
-  `).run();
-
-  const queries: { sql: string; params: readonly unknown[] }[] = [];
-  const plugin = d1Database({
-    prepare(sql) {
-      return {
-        bind(...params) {
-          queries.push({ sql, params });
-          return env.DB.prepare(sql).bind(...params);
-        },
-      };
-    },
-    batch: () =>
-      Promise.reject(new Error("Unexpected write in movement query")),
-  });
-  const input = {
-    filter: {
-      kind: "installationMovement",
-      installId: "sparse-movement-install",
-    },
-    beforeReceivedAtMs: 30001,
-    limit: 101,
-  } as const;
-  const first = await plugin.models.insights.listEvents(input);
-  expect(first).toHaveLength(101);
-  const last = first[first.length - 1]!;
-  const second = await plugin.models.insights.listEvents({
-    ...input,
-    after: { receivedAtMs: last.received_at_ms, id: last.id },
-  });
-  expect(second).toHaveLength(49);
-  const expected = Array.from({ length: 60000 }, (_, index) => index + 1)
-    .filter((index) => index % 800 === 0 || index % 800 === 1)
-    .reverse()
-    .map(
-      (index) => `00000000-0000-7000-8000-${String(index).padStart(12, "0")}`,
-    );
-  expect([...first, ...second].map(({ id }) => id)).toEqual(expected);
-  expect(queries.length).toBeLessThanOrEqual(6);
-  for (const { sql, params } of queries) {
-    expect(sql).toContain("LIMIT");
-    expect(params[params.length - 1]).toBe("0");
-    const plan = await env.DB.prepare(`EXPLAIN QUERY PLAN ${sql}`)
-      .bind(...params)
-      .all<{ detail: string }>();
-    const details = plan.results.map(({ detail }) => detail).join("\n");
-    expect(details).toContain("bundle_events_install_idx");
-    expect(details).not.toContain("TEMP B-TREE");
-  }
-});

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

@@ -1,59 +0,0 @@
-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/src/testWorker.ts

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