@hot-updater/cloudflare 1.0.0-rc.18 → 1.0.0-rc.21

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

@@ -1,318 +0,0 @@
-import type {
-  DeployReleasePolicy,
-  EngineDatabase,
-  StoragePlugin,
-} from "@hot-updater/plugin-core";
-import { createHotUpdater } from "@hot-updater/server";
-import { isMultiIndex, toolingTargetOf } from "@hot-updater/server/database";
-import {
-  createInsightsModel,
-  insights,
-} from "@hot-updater/server/plugins/insights";
-import {
-  createBundleEventRowFixture,
-  insightsTestSuite,
-} from "@hot-updater/server/plugins/insights/testing";
-import {
-  createHandlerHttpTestClient,
-  setupDatabaseTestSuite,
-} from "@hot-updater/test-utils";
-import { env } from "cloudflare:test";
-import {
-  afterAll,
-  beforeAll,
-  beforeEach,
-  describe,
-  expect,
-  inject,
-  it,
-  vi,
-} from "vitest";
-
-import {
-  createBundleFixture,
-  createBundleRowFixture,
-} from "../../../../packages/test-utils/src/databaseTestFixtures";
-import { d1Database } from "../../src/d1Database";
-import { plugins } from "../../src/plugins";
-import { d1Database as d1RuntimeDatabase } from "../../src/worker";
-
-const state = vi.hoisted<{ db: D1Database | undefined }>(() => ({
-  db: undefined,
-}));
-
-class D1TestStateError extends Error {
-  readonly name = "D1TestStateError";
-}
-
-const getDb = (): D1Database => {
-  if (state.db === undefined) {
-    throw new D1TestStateError();
-  }
-  return state.db;
-};
-
-vi.mock("cloudflare", () => ({
-  default: class MockCloudflare {
-    readonly d1 = {
-      database: {
-        query: async (
-          _databaseId: string,
-          input:
-            | { readonly sql: string; readonly params?: readonly string[] }
-            | {
-                readonly batch: readonly {
-                  readonly sql: string;
-                  readonly params?: readonly string[];
-                }[];
-              },
-        ) => {
-          const statements =
-            "batch" in input
-              ? input.batch.map(({ sql, params }) =>
-                  getDb()
-                    .prepare(sql)
-                    .bind(...(params ?? [])),
-                )
-              : (() => {
-                  const params = input.params ?? [];
-                  let paramOffset = 0;
-                  return input.sql
-                    .split(";")
-                    .map((sql) => sql.trim())
-                    .filter(Boolean)
-                    .map((sql) => {
-                      const paramCount = sql.match(/\?/g)?.length ?? 0;
-                      const statement = getDb()
-                        .prepare(sql)
-                        .bind(
-                          ...params.slice(
-                            paramOffset,
-                            paramOffset + paramCount,
-                          ),
-                        );
-                      paramOffset += paramCount;
-                      return statement;
-                    });
-                })();
-          const results = await getDb().batch(statements);
-          return {
-            async *iterPages() {
-              yield { result: results };
-            },
-          };
-        },
-      },
-    };
-  },
-}));
-
-/** Every data table of the managed server's migration: each model's table and the index tables of its multi-valued indexes. */
-const dataTables = toolingTargetOf(plugins).schema.tables.flatMap((table) => [
-  table.name,
-  ...table.indexes
-    .filter((index) => isMultiIndex(table, index))
-    .map((index) => `${table.name}__${index.name}`),
-]);
-
-/** Empties every data table; the settings rows stay. */
-const reset = async (): Promise<void> => {
-  await getDb().batch(
-    dataTables.map((name) => getDb().prepare(`DELETE FROM "${name}"`)),
-  );
-};
-
-/**
- * A public server with Insights on `database`, as the suite serves it. The
- * specs here reach core and the Insights API through it.
- */
-const serve = (options: {
-  readonly database: EngineDatabase;
-  readonly storage?: readonly StoragePlugin[];
-}) =>
-  createHotUpdater({
-    ...options,
-    plugins: [insights()],
-    clientAccess: "public",
-  });
-
-const release = (channel: string, enabled: boolean): DeployReleasePolicy => ({
-  channel,
-  enabled,
-  fingerprintHash: null,
-  message: null,
-  shouldForceUpdate: false,
-  targetAppVersion: "1.0.0",
-});
-
-setupDatabaseTestSuite({
-  createHttpClient: (options) =>
-    createHandlerHttpTestClient(serve(options).handlers),
-  plugins: [
-    insightsTestSuite({
-      createModel: (database: EngineDatabase) =>
-        createInsightsModel(serve({ database }).api.insights),
-    }),
-  ],
-  name: "cloudflare d1 http",
-  migrate: async () => {
-    state.db = env.DB;
-    await getDb().prepare(inject("prepareSql")).run();
-  },
-  createDatabase: () =>
-    d1Database({
-      accountId: "account-id",
-      cloudflareApiToken: "api-token",
-      databaseId: "database-id",
-    }),
-  reset,
-  dispose: () => undefined,
-});
-
-setupDatabaseTestSuite({
-  createHttpClient: (options) =>
-    createHandlerHttpTestClient(serve(options).handlers),
-  plugins: [
-    insightsTestSuite({
-      createModel: (database: EngineDatabase) =>
-        createInsightsModel(serve({ database }).api.insights),
-    }),
-  ],
-  name: "cloudflare worker d1",
-  migrate: () => undefined,
-  createDatabase: () => d1RuntimeDatabase(env.DB),
-  reset,
-  dispose: () => {
-    state.db = undefined;
-  },
-});
-
-describe.each([
-  {
-    name: "cloudflare d1 http",
-    createDatabase: () =>
-      d1Database({
-        accountId: "account-id",
-        cloudflareApiToken: "api-token",
-        databaseId: "database-id",
-      }),
-  },
-  {
-    name: "cloudflare worker d1",
-    createDatabase: () => d1RuntimeDatabase(env.DB),
-  },
-])("$name Channel deletion", ({ createDatabase }) => {
-  beforeAll(() => {
-    state.db = env.DB;
-  });
-
-  beforeEach(async () => {
-    await reset();
-  });
-
-  afterAll(() => {
-    state.db = undefined;
-  });
-
-  it("deletes only empty channels", async () => {
-    const { core } = serve({ database: createDatabase() });
-    const channel = await core.ensureChannel("empty");
-
-    await expect(core.deleteChannel(channel.id)).resolves.toEqual({
-      deleted: true,
-    });
-    await expect(core.deleteChannel(channel.id)).resolves.toEqual({
-      deleted: false,
-      reason: "not_found",
-    });
-  });
-
-  it("keeps failed event inserts invisible, then safely retries", async () => {
-    const model = createInsightsModel(
-      serve({ database: createDatabase() }).api.insights,
-    );
-    const event = createBundleEventRowFixture("9101", 100);
-    const input = { event };
-    await env.DB.prepare(`
-      CREATE TRIGGER fail_insights_event BEFORE INSERT ON bundle_events
-      BEGIN SELECT RAISE(ABORT, 'injected event failure'); END;
-    `).run();
-    try {
-      // The engine reports a failed batch as ambiguous, with D1's error as its cause.
-      await expect(model.recordEvent(input)).rejects.toMatchObject({
-        cause: { message: expect.stringContaining("injected event failure") },
-      });
-      expect(
-        (await env.DB.prepare("SELECT * FROM bundle_events").all()).results,
-      ).toEqual([]);
-      await expect(
-        model.findLatestEvents({ installId: event.install_id }),
-      ).resolves.toEqual([]);
-    } finally {
-      await env.DB.prepare("DROP TRIGGER fail_insights_event").run();
-    }
-    await env.DB.prepare(`
-      CREATE TRIGGER fail_insights_head BEFORE INSERT ON bundle_event_heads
-      BEGIN SELECT RAISE(ABORT, 'injected head failure'); END;
-    `).run();
-    try {
-      // The engine reports a failed batch as ambiguous, with D1's error as its cause.
-      await expect(model.recordEvent(input)).rejects.toMatchObject({
-        cause: { message: expect.stringContaining("injected head failure") },
-      });
-      expect(
-        (await env.DB.prepare("SELECT * FROM bundle_events").all()).results,
-      ).toEqual([]);
-      expect(
-        (await env.DB.prepare("SELECT * FROM bundle_event_heads").all())
-          .results,
-      ).toEqual([]);
-    } finally {
-      await env.DB.prepare("DROP TRIGGER fail_insights_head").run();
-    }
-    await model.recordEvent(input);
-    await model.recordEvent(input);
-    await expect(
-      model.findLatestEvents({ installId: event.install_id }),
-    ).resolves.toEqual([input.event]);
-    expect(
-      (await env.DB.prepare("SELECT id FROM bundle_events").all()).results,
-    ).toEqual([{ id: event.id }]);
-  });
-
-  it("refuses to delete a channel while a Release uses it", async () => {
-    const { core } = serve({ database: createDatabase() });
-    const channel = await core.ensureChannel("active");
-    const bundle = createBundleFixture("902");
-    await core.deploy([{ bundle, release: release(channel.name, true) }]);
-
-    await expect(core.deleteChannel(channel.id)).resolves.toEqual({
-      deleted: false,
-      reason: "not_empty",
-    });
-    await expect(core.listChannels()).resolves.toEqual([channel]);
-    await expect(core.getBundle(bundle.id)).resolves.toMatchObject({
-      bundle: createBundleRowFixture("902"),
-    });
-  });
-
-  it("deletes a channel once its last Release is deleted", async () => {
-    const { core } = serve({ database: createDatabase() });
-    const channel = await core.ensureChannel("retired");
-    const bundle = createBundleFixture("903");
-    const [deployed] = await core.deploy([
-      { bundle, release: release(channel.name, false) },
-    ]);
-    const releaseId = deployed!.release!.id;
-
-    await core.deleteRelease({ releaseId });
-    await expect(core.deleteChannel(channel.id)).resolves.toEqual({
-      deleted: true,
-    });
-    await expect(core.getRelease(releaseId)).resolves.toBeNull();
-    await expect(core.getBundle(bundle.id)).resolves.toMatchObject({
-      bundle: createBundleRowFixture("903"),
-    });
-    await expect(core.listChannels()).resolves.toEqual([]);
-  });
-});

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

@@ -1,182 +0,0 @@
-import type { Bundle } from "@hot-updater/core";
-import { createHotUpdater } from "@hot-updater/server";
-import { createBundleEventRowFixture } from "@hot-updater/server/plugins/insights/testing";
-import { env } from "cloudflare:test";
-import { beforeAll, beforeEach, describe, expect, inject, it } from "vitest";
-
-import { d1Database, plugins } 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,
-    manifestStorageUri: `r2://${env.BUCKET_NAME}/${bundle.id}/manifest.json`,
-    assetBaseStorageUri: `r2://${env.BUCKET_NAME}/assets`,
-  };
-};
-
-/** A server on the test database with the plugins the Worker runs. */
-const createSeedServer = () =>
-  createHotUpdater({ database: d1Database(env.DB), plugins });
-
-const seedBundles = async (bundles: Bundle[]) => {
-  const { core } = createSeedServer();
-  // A deploy publishes into each scope at most once, so each bundle deploys alone.
-  for (const bundle of bundles) {
-    await core.deploy([
-      {
-        bundle: toRuntimeBundle(bundle),
-        release: {
-          channel: "production",
-          enabled: true,
-          fingerprintHash: null,
-          message: "hello",
-          shouldForceUpdate: false,
-          targetAppVersion: "1.0",
-        },
-      },
-    ]);
-  }
-};
-
-describe.sequential("cloudflare worker runtime acceptance", () => {
-  beforeAll(async () => {
-    await env.DB.prepare(inject("prepareSql")).run();
-    await createSeedServer().api.apiKeys.register({
-      apiKey: API_KEY,
-      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();
-    await env.DB.prepare("DELETE FROM bundle_totals").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",
-        gitCommitHash: null,
-        manifestStorageUri: "storage://unused/manifest.json",
-        manifestFileHash: "manifest-hash",
-        assetBaseStorageUri: "storage://assets",
-      },
-    ]);
-
-    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",
-    });
-  });
-
-  it("deletes rows past their retention after a write, with no cron trigger", async () => {
-    const day = 86_400_000;
-    const expired = createBundleEventRowFixture("9701", Date.now() - 100 * day);
-    await createSeedServer().api.insights.recordEvent(expired);
-    // The seed servers' writes hold the hourly lease; release it.
-    await env.DB.prepare(
-      "DELETE FROM private_hot_updater_settings WHERE key = 'retention.nextPassAt'",
-    ).run();
-
-    const reported = await worker.fetch(
-      new Request(`${PUBLIC_BASE_URL}/events`, {
-        method: "POST",
-        headers: { "content-type": "application/json", "x-api-key": API_KEY },
-        body: JSON.stringify({
-          appVersion: "1.0",
-          channel: "production",
-          cohort: "default",
-          fingerprintHash: null,
-          fromBundleId: null,
-          fromReleaseId: null,
-          installId: "install-9702",
-          platform: "ios",
-          toBundleId: "00000000-0000-7000-8000-000000009702",
-          toReleaseId: null,
-          type: "UNCHANGED",
-          updateStrategy: null,
-        }),
-      }),
-      env,
-    );
-    expect(reported.status).toBe(204);
-
-    const ids = async (table: string, column: string) =>
-      (
-        await env.DB.prepare(
-          `SELECT ${column} AS id FROM ${table} ORDER BY ${column}`,
-        ).all<{ id: string }>()
-      ).results.map(({ id }) => id);
-    // Events are kept 90 days; an installation's latest event, 13 months.
-    await expect(ids("bundle_events", "id")).resolves.not.toContain(expired.id);
-    await expect(ids("bundle_event_heads", "install_id")).resolves.toEqual([
-      expired.install_id,
-      "install-9702",
-    ]);
-  });
-});

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

@@ -1,89 +0,0 @@
-import { createHotUpdater } from "@hot-updater/server";
-import { insights } from "@hot-updater/server/plugins/insights";
-import { createBundleEventRowFixture } from "@hot-updater/server/plugins/insights/testing";
-import { env } from "cloudflare:test";
-import { expect, inject, it } from "vitest";
-
-import { createBundleFixture } from "../../../../packages/test-utils/src/databaseTestFixtures";
-import { d1Database } from "../../src/worker";
-
-it("reads only through declared indexes on D1, never a full scan or a sort", async () => {
-  await env.DB.prepare(inject("prepareSql")).run();
-  /** Each operation's reads, in the order the operations ran. */
-  const reads = new Map<
-    string,
-    { readonly sql: string; readonly params: readonly unknown[] }[]
-  >();
-  let operation = "";
-  const { core, api } = createHotUpdater({
-    database: d1Database({
-      prepare(sql) {
-        return {
-          bind(...params) {
-            if (/^\s*SELECT\b/iu.test(sql)) {
-              reads.get(operation)!.push({ sql, params });
-            }
-            return env.DB.prepare(sql).bind(...params);
-          },
-        };
-      },
-      batch: (statements) => env.DB.batch(statements as D1PreparedStatement[]),
-    }),
-    plugins: [insights()],
-    clientAccess: "public",
-  });
-  /** Runs `run`, recording the reads it makes under `name`. */
-  const measure = async <T>(name: string, run: () => Promise<T>) => {
-    operation = name;
-    reads.set(name, []);
-    return run();
-  };
-
-  const event = createBundleEventRowFixture("11", 100);
-  await measure("ensureChannel", () => core.ensureChannel("production"));
-  const [deployed] = await measure("deploy", () =>
-    core.deploy([
-      {
-        bundle: createBundleFixture("1"),
-        release: {
-          channel: "production",
-          enabled: true,
-          fingerprintHash: null,
-          message: null,
-          shouldForceUpdate: false,
-          targetAppVersion: "1.0.0",
-        },
-      },
-    ]),
-  );
-  await measure("insights.recordEvent", () => api.insights.recordEvent(event));
-  await measure("getRelease", () => core.getRelease(deployed!.release!.id));
-  await measure("listChannels", () => core.listChannels());
-  await measure("insights.findLatestEvents", () =>
-    api.insights.findLatestEvents({ installId: event.install_id }),
-  );
-  await measure("insights.countLatestEvents", () =>
-    api.insights.countLatestEvents({
-      platform: event.platform,
-      channel: event.channel,
-      sinceMs: 0,
-    }),
-  );
-
-  for (const [name, statements] of reads) {
-    expect(statements.length, name).toBeGreaterThan(0);
-    for (const { sql, params } of statements) {
-      const plan = await env.DB.prepare(`EXPLAIN QUERY PLAN ${sql}`)
-        .bind(...params)
-        .all<{ detail: string }>();
-      const details = plan.results.map(({ detail }) => detail);
-      expect(
-        details.filter((detail) => /^SCAN \S+$/u.test(detail)),
-        `${name}: ${sql}`,
-      ).toEqual([]);
-      expect(details.join("\n"), `${name}: ${sql}`).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");
-  },
-};