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

package/src/utils/createWrangler.spec.ts

@@ -1,75 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-const mocks = vi.hoisted(() => ({
-  command: vi.fn(),
-  execa: vi.fn(),
-}));
-
-vi.mock("execa", () => ({
-  execa: mocks.execa,
-}));
-
-import { createWrangler } from "./createWrangler";
-
-describe("createWrangler", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    mocks.execa.mockReturnValue(mocks.command);
-    mocks.command.mockResolvedValue({});
-  });
-
-  it("marks replay commands as CI so Wrangler skips nested prompts", async () => {
-    const wrangler = createWrangler({
-      accountId: "account-id",
-      cloudflareApiToken: "api-token",
-      cwd: "/tmp/cloudflare-init",
-      nonInteractive: true,
-      stdio: "inherit",
-    });
-
-    await wrangler("d1", "migrations", "apply", "hot-updater", "--remote");
-
-    expect(mocks.execa).toHaveBeenCalledWith({
-      cwd: "/tmp/cloudflare-init",
-      env: {
-        CI: "true",
-        CLOUDFLARE_ACCOUNT_ID: "account-id",
-        CLOUDFLARE_API_TOKEN: "api-token",
-      },
-      extendsEnv: true,
-      shell: false,
-      stdio: "inherit",
-    });
-    expect(mocks.command).toHaveBeenCalledWith("npx", [
-      "wrangler",
-      "d1",
-      "migrations",
-      "apply",
-      "hot-updater",
-      "--remote",
-    ]);
-  });
-
-  it("passes shell metacharacters as one argument", async () => {
-    const wrangler = createWrangler({
-      accountId: "account-id",
-      cloudflareApiToken: "api-token",
-      cwd: "/tmp/cloudflare-init",
-      stdio: "inherit",
-    });
-
-    await wrangler("deploy", "--name", "safe; printf INJECTED");
-
-    expect(mocks.execa).toHaveBeenCalledWith(
-      expect.objectContaining({
-        shell: false,
-      }),
-    );
-    expect(mocks.command).toHaveBeenCalledWith("npx", [
-      "wrangler",
-      "deploy",
-      "--name",
-      "safe; printf INJECTED",
-    ]);
-  });
-});

package/src/worker/d1Database.spec.ts

@@ -1,69 +0,0 @@
-import { toInsightsInstallationRow } from "@hot-updater/plugin-core";
-import { expect, it } from "vitest";
-
-import { createBundleEventRowFixture } from "../../../../packages/test-utils/src/databaseTestFixtures";
-import { d1Database, type D1Like } from "./d1Database";
-
-const database: D1Like = {
-  prepare: () => ({
-    bind: () => ({
-      all: async () => ({
-        results: [{ id: "channel-production", name: "production" }],
-      }),
-    }),
-  }),
-  batch: async (statements) =>
-    Promise.all(statements.map((item) => item.all())),
-};
-
-it("uses the D1 binding supplied at the Worker composition boundary", async () => {
-  const plugin = d1Database(database);
-
-  expect(plugin.name).toBe("d1Database");
-  expect(Object.keys(plugin.models).sort()).toEqual([
-    "apiKeys",
-    "bundlePatches",
-    "bundles",
-    "channels",
-    "insights",
-    "releaseCatalogs",
-    "releases",
-  ]);
-  await expect(plugin.models.channels.list({})).resolves.toEqual({
-    channels: [{ id: "channel-production", name: "production" }],
-  });
-});
-
-it("does not report a failed D1 query as empty Insights history", async () => {
-  const plugin = d1Database({
-    ...database,
-    prepare: () => ({
-      bind: () => ({ all: async () => ({ success: false, results: [] }) }),
-    }),
-  });
-  await expect(
-    plugin.models.insights.listEvents({
-      filter: { kind: "all" },
-      beforeReceivedAtMs: 100,
-      limit: 10,
-    }),
-  ).rejects.toThrow(
-    "D1 did not successfully execute every requested statement",
-  );
-});
-
-it("rejects an incomplete Insights batch response", async () => {
-  const plugin = d1Database({
-    ...database,
-    batch: async () => [{ success: true, results: [] }],
-  });
-  const event = createBundleEventRowFixture("1", 1);
-  await expect(
-    plugin.models.insights.record({
-      event,
-      installation: toInsightsInstallationRow(event),
-    }),
-  ).rejects.toThrow(
-    "D1 did not successfully execute every requested statement",
-  );
-});

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

@@ -1,191 +0,0 @@
-import { env } from "cloudflare:test";
-import { expect, inject, it } from "vitest";
-
-declare module "vitest" {
-  export interface ProvidedContext {
-    d1Migrations: readonly {
-      readonly name: string;
-      readonly sql: string;
-    }[];
-  }
-}
-
-it("ships a single 1.0.0 initialization migration", () => {
-  expect(inject("d1Migrations").map(({ name }) => name)).toEqual([
-    "0001_hot-updater_1.0.0.sql",
-  ]);
-});
-
-it("creates the current schema with required artifact sizes", async () => {
-  const [createMigration] = inject("d1Migrations");
-  await env.DB.prepare(createMigration!.sql).run();
-  await env.DB.prepare(`
-    INSERT INTO bundles (
-      id, platform, file_hash, storage_uri, archive_byte_size, metadata
-    ) VALUES (
-      '00000000-0000-0000-0000-000000000001', 'ios', 'hash',
-      'storage://bundle', 3000000001, '{}'
-    )
-  `).run();
-  await env.DB.prepare(`
-    INSERT INTO bundle_patches (
-      id, bundle_id, base_bundle_id, base_file_hash, patch_file_hash,
-      patch_storage_uri, byte_size
-    ) VALUES (
-      'patch-1', '00000000-0000-0000-0000-000000000001',
-      '00000000-0000-0000-0000-000000000001', 'base-hash', 'patch-hash',
-      'storage://patch', 3000000002
-    )
-  `).run();
-
-  const tables = await env.DB.prepare(`
-    SELECT name FROM sqlite_master
-    WHERE type = 'table'
-    ORDER BY name
-  `).all<{ name: string }>();
-
-  expect(tables.results.map(({ name }) => name)).toEqual(
-    expect.arrayContaining([
-      "bundle_events",
-      "bundle_installations",
-      "bundle_patches",
-      "bundles",
-      "channels",
-      "api_keys",
-      "private_hot_updater_settings",
-      "release_catalogs",
-      "releases",
-    ]),
-  );
-
-  const version = await env.DB.prepare(
-    "SELECT value FROM private_hot_updater_settings WHERE key = 'schema.core'",
-  ).first<string>("value");
-  expect(version).toBe("1.0.0");
-
-  await env.DB.prepare(
-    "INSERT INTO channels (id, name) VALUES ('channel-1', 'production')",
-  ).run();
-  await env.DB.prepare(`
-    INSERT INTO releases (
-      id, revision, scope_key, channel_id, platform, kind, bundle_id,
-      strategy, target_app_version, fingerprint_hash, enabled,
-      should_force_update, message, rollout_cohort_count, target_cohorts,
-      operation, source_release_id, created_at_ms, updated_at_ms
-    ) VALUES (
-      '00000000-0000-0000-0000-000000000001', 1, 'scope', 'channel-1',
-      'ios', 'BUNDLE', '00000000-0000-0000-0000-000000000001',
-      'APP_VERSION', '1.0.0', NULL, 1, 0, NULL, 1000, '[]',
-      'DEPLOY', NULL, 0, 0
-    )
-  `).run();
-
-  const release = await env.DB.prepare(
-    "SELECT channel_id, bundle_id FROM releases",
-  ).first();
-  expect(release).toEqual({
-    channel_id: "channel-1",
-    bundle_id: "00000000-0000-0000-0000-000000000001",
-  });
-  const sizes = await env.DB.prepare(`
-    SELECT bundle.archive_byte_size, patch.byte_size
-    FROM bundles AS bundle
-    JOIN bundle_patches AS patch ON patch.bundle_id = bundle.id
-  `).first();
-  expect(sizes).toEqual({
-    archive_byte_size: 3_000_000_001,
-    byte_size: 3_000_000_002,
-  });
-
-  await env.DB.prepare(`
-    INSERT INTO bundle_installations (
-      install_id, id, user_id, username, to_bundle_id, type, platform,
-      app_version, channel, cohort, received_at_ms
-    ) VALUES (
-      'install-1', 'event-1', 'user-1', 'Demo User',
-      '00000000-0000-0000-0000-000000000001', 'UPDATE_APPLIED', 'ios',
-      '1.0.0', 'production', 'cohort-1', 100
-    )
-  `).run();
-  await expect(
-    env.DB.prepare(
-      "SELECT install_id, received_at_ms FROM bundle_installations",
-    ).first(),
-  ).resolves.toEqual({ install_id: "install-1", received_at_ms: 100 });
-
-  const installationIndexes = await env.DB.prepare(`
-    SELECT name FROM sqlite_master
-    WHERE type = 'index' AND tbl_name = 'bundle_installations'
-    ORDER BY name
-  `).all<{ name: string }>();
-  expect(installationIndexes.results.map(({ name }) => name)).toEqual(
-    expect.arrayContaining([
-      "bundle_installations_received_at_idx",
-      "bundle_installations_user_id_idx",
-      "bundle_installations_scope_idx",
-      "bundle_installations_bundle_idx",
-    ]),
-  );
-
-  const movementIndex = await env.DB.prepare(
-    "PRAGMA index_info(bundle_events_install_idx)",
-  ).all<{ name: string }>();
-  expect(movementIndex.results.map(({ name }) => name)).toEqual([
-    "install_id",
-    "type",
-    "received_at_ms",
-    "id",
-  ]);
-
-  for (const [direction, type] of [
-    ["from", "RECOVERED"],
-    ["to", "UPDATE_APPLIED"],
-  ]) {
-    const plan = await env.DB.prepare(`
-      EXPLAIN QUERY PLAN SELECT * FROM bundle_events
-      WHERE type = ? AND platform = 'ios' AND channel = 'production'
-        AND ${direction}_bundle_id = ? AND received_at_ms >= 100 AND received_at_ms < 200
-      ORDER BY received_at_ms DESC, id DESC LIMIT 101
-    `)
-      .bind(type, "00000000-0000-0000-0000-000000000001")
-      .all<{ detail: string }>();
-    expect(plan.results.map(({ detail }) => detail).join("\n")).toContain(
-      `bundle_events_${direction}_bundle_idx`,
-    );
-    expect(plan.results.map(({ detail }) => detail).join("\n")).not.toContain(
-      "TEMP B-TREE",
-    );
-  }
-
-  for (const size of [-1, Number.MAX_SAFE_INTEGER + 1, null]) {
-    await expect(
-      env.DB.prepare("UPDATE bundles SET archive_byte_size = ?")
-        .bind(size)
-        .run(),
-    ).rejects.toThrow(/constraint failed/);
-    await expect(
-      env.DB.prepare("UPDATE bundle_patches SET byte_size = ?")
-        .bind(size)
-        .run(),
-    ).rejects.toThrow(/constraint failed/);
-  }
-
-  await expect(
-    env.DB.prepare(`
-      INSERT INTO bundles (id, platform, file_hash, storage_uri)
-      VALUES ('missing-size', 'ios', 'hash', 'storage://bundle')
-    `).run(),
-  ).rejects.toThrow(/NOT NULL constraint failed/);
-  await expect(
-    env.DB.prepare(`
-      INSERT INTO bundle_patches (
-        id, bundle_id, base_bundle_id, base_file_hash, patch_file_hash,
-        patch_storage_uri
-      ) VALUES (
-        'missing-size', '00000000-0000-0000-0000-000000000001',
-        '00000000-0000-0000-0000-000000000001', 'base-hash', 'patch-hash',
-        'storage://patch'
-      )
-    `).run(),
-  ).rejects.toThrow(/NOT NULL constraint failed/);
-});

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

@@ -1,326 +0,0 @@
-import type {
-  BundleRow,
-  ChannelRow,
-  ReleaseRow,
-} from "@hot-updater/plugin-core";
-import { toInsightsInstallationRow } from "@hot-updater/plugin-core";
-import { setupDatabasePluginTestSuite } from "@hot-updater/test-utils";
-import { env } from "cloudflare:test";
-import {
-  afterAll,
-  beforeAll,
-  beforeEach,
-  describe,
-  expect,
-  inject,
-  it,
-  vi,
-} from "vitest";
-
-import { createBundleEventRowFixture } from "../../../../packages/test-utils/src/databaseTestFixtures";
-import { d1Database } from "../../src/d1Database";
-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 };
-            },
-          };
-        },
-      },
-    };
-  },
-}));
-
-const reset = async (): Promise<void> => {
-  await getDb()
-    .prepare(
-      "DELETE FROM bundle_events; DELETE FROM bundle_installations; DELETE FROM api_keys; DELETE FROM bundle_patches; DELETE FROM release_catalogs; DELETE FROM releases; DELETE FROM bundles; DELETE FROM channels;",
-    )
-    .run();
-};
-
-const createChannelRow = (name: string): ChannelRow => ({
-  id: `channel-${name}`,
-  name,
-});
-
-const createBundleRow = (): BundleRow => ({
-  id: "00000000-0000-0000-0000-000000000902",
-  platform: "ios",
-  file_hash: "hash",
-  git_commit_hash: null,
-  storage_uri: "storage://bundle",
-  archive_byte_size: 3_000_000_001,
-  metadata: {},
-  manifest_storage_uri: null,
-  manifest_file_hash: null,
-  asset_base_storage_uri: null,
-});
-
-const createReleaseRow = (
-  channel: ChannelRow,
-  bundle: BundleRow,
-): ReleaseRow => ({
-  id: "00000000-0000-7000-8000-000000000903",
-  revision: 1,
-  scope_key: `v1:test:${channel.name}:ios:app-version`,
-  channel_id: channel.id,
-  platform: bundle.platform,
-  kind: "BUNDLE",
-  bundle_id: bundle.id,
-  strategy: "APP_VERSION",
-  target_app_version: "1.0.0",
-  fingerprint_hash: null,
-  enabled: true,
-  should_force_update: false,
-  message: null,
-  rollout_cohort_count: 1000,
-  target_cohorts: [],
-  operation: "DEPLOY",
-  source_release_id: null,
-  created_at_ms: 100,
-  updated_at_ms: 100,
-});
-
-setupDatabasePluginTestSuite({
-  name: "cloudflare d1 http fixed-model database plugin",
-  migrate: async () => {
-    state.db = env.DB;
-    await getDb().prepare(inject("prepareSql")).run();
-  },
-  createPlugin: () =>
-    d1Database({
-      accountId: "account-id",
-      cloudflareApiToken: "api-token",
-      databaseId: "database-id",
-    }),
-  reset,
-  dispose: () => undefined,
-});
-
-setupDatabasePluginTestSuite({
-  name: "cloudflare worker d1 fixed-model database plugin",
-  migrate: () => undefined,
-  createPlugin: () => d1RuntimeDatabase(env.DB),
-  reset,
-  dispose: () => {
-    state.db = undefined;
-  },
-});
-
-describe.each([
-  {
-    name: "cloudflare d1 http",
-    createPlugin: () =>
-      d1Database({
-        accountId: "account-id",
-        cloudflareApiToken: "api-token",
-        databaseId: "database-id",
-      }),
-  },
-  {
-    name: "cloudflare worker d1",
-    createPlugin: () => d1RuntimeDatabase(env.DB),
-  },
-])("$name Channel deletion", ({ createPlugin }) => {
-  beforeAll(() => {
-    state.db = env.DB;
-  });
-
-  beforeEach(async () => {
-    await reset();
-  });
-
-  afterAll(() => {
-    state.db = undefined;
-  });
-
-  it("deletes only empty channels", async () => {
-    const plugin = createPlugin();
-    const channel = createChannelRow("empty");
-    await plugin.models.channels.insert({
-      row: channel,
-      onConflict: "returnExisting",
-    });
-
-    await expect(
-      plugin.models.channels.delete({ id: channel.id }),
-    ).resolves.toEqual({ deleted: true });
-    await expect(
-      plugin.models.channels.delete({ id: channel.id }),
-    ).resolves.toEqual({ deleted: false, reason: "not_found" });
-  });
-
-  it("rolls back the snapshot when the later event insert fails, then safely retries", async () => {
-    const plugin = createPlugin();
-    const event = createBundleEventRowFixture("9101", 100);
-    const input = { event, installation: toInsightsInstallationRow(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 {
-      await expect(plugin.models.insights.record(input)).rejects.toThrow(
-        "injected event failure",
-      );
-      expect(
-        (await env.DB.prepare("SELECT * FROM bundle_events").all()).results,
-      ).toEqual([]);
-      expect(
-        (await env.DB.prepare("SELECT * FROM bundle_installations").all())
-          .results,
-      ).toEqual([]);
-    } finally {
-      await env.DB.prepare("DROP TRIGGER fail_insights_event").run();
-    }
-    await plugin.models.insights.record(input);
-    await plugin.models.insights.record(input);
-    await expect(
-      plugin.models.insights.findInstallations({ installId: event.install_id }),
-    ).resolves.toEqual([input.installation]);
-    expect(
-      (await env.DB.prepare("SELECT id FROM bundle_events").all()).results,
-    ).toEqual([{ id: event.id }]);
-  });
-
-  it("rejects direct and committed deletion while a Release references the channel", async () => {
-    const plugin = createPlugin();
-    const channel = createChannelRow("active");
-    const bundle = createBundleRow();
-    const release = createReleaseRow(channel, bundle);
-    await plugin.models.channels.insert({
-      row: channel,
-      onConflict: "returnExisting",
-    });
-    await plugin.commit({
-      changes: [
-        { model: "bundles", operation: "insert", row: bundle },
-        { model: "releases", operation: "insert", row: release },
-      ],
-    });
-
-    await expect(
-      plugin.models.channels.delete({ id: channel.id }),
-    ).resolves.toEqual({ deleted: false, reason: "not_empty" });
-    await expect(
-      plugin.commit({
-        changes: [
-          {
-            model: "channels",
-            operation: "delete",
-            where: { id: channel.id },
-          },
-        ],
-      }),
-    ).resolves.toEqual({
-      committed: false,
-      conflict: { changeIndex: 0, reason: "referenced" },
-    });
-    await expect(plugin.models.bundles.findById(bundle.id)).resolves.toEqual(
-      bundle,
-    );
-  });
-
-  it("atomically deletes a Release before deleting its newly empty channel", async () => {
-    const plugin = createPlugin();
-    const channel = createChannelRow("retired");
-    const bundle = createBundleRow();
-    const release = createReleaseRow(channel, bundle);
-    await plugin.models.channels.insert({
-      row: channel,
-      onConflict: "returnExisting",
-    });
-    await plugin.commit({
-      changes: [
-        { model: "bundles", operation: "insert", row: bundle },
-        { model: "releases", operation: "insert", row: release },
-      ],
-    });
-
-    await expect(
-      plugin.commit({
-        changes: [
-          {
-            model: "releases",
-            operation: "delete",
-            where: { id: release.id },
-          },
-          {
-            model: "channels",
-            operation: "delete",
-            where: { id: channel.id },
-          },
-        ],
-      }),
-    ).resolves.toEqual({ committed: true });
-    await expect(
-      plugin.models.releases.findById(release.id),
-    ).resolves.toBeNull();
-    await expect(plugin.models.bundles.findById(bundle.id)).resolves.toEqual(
-      bundle,
-    );
-    await expect(plugin.models.channels.list({})).resolves.toEqual({
-      channels: [],
-    });
-  });
-});