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

package/src/r2WorkerStorage.spec.ts

@@ -1,184 +0,0 @@
-import { afterEach, describe, expect, it, vi } from "vitest";
-
-import { r2WorkerStorage } from "./r2WorkerStorage";
-
-const createBucket = (
-  get: ReturnType<typeof vi.fn>,
-  overrides: Partial<R2Bucket> = {},
-) =>
-  ({
-    get,
-    head: vi.fn(),
-    put: vi.fn(),
-    delete: vi.fn(),
-    list: vi.fn(),
-    ...overrides,
-  }) as unknown as R2Bucket;
-
-describe("r2WorkerStorage", () => {
-  afterEach(() => {
-    vi.unstubAllGlobals();
-  });
-
-  it("reads bytes from the R2 binding captured by the implementation", async () => {
-    const get = vi.fn(async (key: string) => ({
-      body: new Response(`text:${key}`).body,
-      httpEtag: '"etag"',
-      size: `text:${key}`.length,
-      writeHttpMetadata: vi.fn(),
-    }));
-    const storage = r2WorkerStorage({
-      bucket: createBucket(get),
-      bucketName: "bundles",
-      downloadUrlSigningKey: "test-signing-key",
-    });
-
-    const { response } = await storage.get({
-      storageUri: "r2://bundles/app/manifest.json",
-    });
-
-    expect(await response?.text()).toBe("text:app/manifest.json");
-    expect(get).toHaveBeenCalledWith("app/manifest.json");
-  });
-
-  it("rejects URIs owned by a different R2 binding", async () => {
-    const get = vi.fn();
-    const storage = r2WorkerStorage({
-      bucket: createBucket(get),
-      bucketName: "bundles",
-      downloadUrlSigningKey: "test-signing-key",
-    });
-
-    await expect(
-      storage.get({ storageUri: "r2://other/app/manifest.json" }),
-    ).rejects.toThrow(
-      'Bucket name mismatch: expected "bundles", but found "other".',
-    );
-    expect(get).not.toHaveBeenCalled();
-  });
-
-  it("writes and deletes the exact object key through the R2 binding", async () => {
-    let uploaded = "";
-    const put = vi.fn(async (_key: string, body: Uint8Array) => {
-      uploaded = new TextDecoder().decode(body);
-      return null;
-    });
-    const bucket = createBucket(vi.fn(), {
-      put: put as unknown as R2Bucket["put"],
-    });
-    const storage = r2WorkerStorage({
-      bucket,
-      bucketName: "bundles",
-      downloadUrlSigningKey: "test-signing-key",
-    });
-
-    await storage.put({
-      key: "releases/bundle.zip",
-      body: new Response("bundle").body!,
-      contentType: "application/zip",
-    });
-    await expect(
-      storage.delete({
-        storageUri: "r2://bundles/releases/bundle.zip",
-      }),
-    ).resolves.toEqual({
-      deleted: true,
-    });
-
-    expect(bucket.put).toHaveBeenCalledWith(
-      "releases/bundle.zip",
-      expect.any(Uint8Array),
-      {
-        httpMetadata: {
-          cacheControl: "max-age=31536000",
-          contentType: "application/zip",
-        },
-      },
-    );
-    expect(uploaded).toBe("bundle");
-    expect(bucket.delete).toHaveBeenCalledWith("releases/bundle.zip");
-  });
-
-  it("round-trips reserved characters without changing the R2 binding key", async () => {
-    const bucket = createBucket(vi.fn());
-    const storage = r2WorkerStorage({
-      bucket,
-      bucketName: "bundles",
-      downloadUrlSigningKey: "test-signing-key",
-    });
-    const key = "릴리스 folder/logo@2x #100%/bundle.zip";
-
-    const uploaded = await storage.put({
-      key,
-      body: new Response("bundle").body!,
-      contentType: "application/zip",
-    });
-    expect(uploaded.storageUri).toContain("logo%402x");
-    await storage.delete({ storageUri: uploaded.storageUri });
-    await storage.delete({ storageUri: uploaded.storageUri });
-
-    expect(bucket.put).toHaveBeenCalledWith(
-      key,
-      expect.any(Uint8Array),
-      expect.any(Object),
-    );
-    expect(bucket.delete).toHaveBeenNthCalledWith(1, key);
-    expect(bucket.delete).toHaveBeenNthCalledWith(2, key);
-  });
-
-  it("uses a fixed-length stream when the upload length is known", async () => {
-    const expectedLengths: number[] = [];
-    class TestFixedLengthStream extends TransformStream<
-      Uint8Array,
-      Uint8Array
-    > {
-      constructor(expectedLength: number) {
-        super();
-        expectedLengths.push(expectedLength);
-      }
-    }
-    vi.stubGlobal("FixedLengthStream", TestFixedLengthStream);
-    let uploaded = "";
-    const put = vi.fn(
-      async (_key: string, body: ReadableStream<Uint8Array>) => {
-        uploaded = await new Response(body).text();
-        return null;
-      },
-    );
-    const storage = r2WorkerStorage({
-      bucket: createBucket(vi.fn(), {
-        put: put as unknown as R2Bucket["put"],
-      }),
-      bucketName: "bundles",
-      downloadUrlSigningKey: "test-signing-key",
-    });
-
-    await storage.put({
-      key: "releases/bundle.zip",
-      body: new Response("bundle").body!,
-      contentLength: 6,
-      contentType: "application/zip",
-    });
-
-    expect(expectedLengths).toEqual([6]);
-    expect(uploaded).toBe("bundle");
-  });
-
-  it("returns a stable signed download path for private R2 objects", async () => {
-    const storage = r2WorkerStorage({
-      bucket: createBucket(vi.fn()),
-      bucketName: "bundles",
-      downloadUrlSigningKey: "test-signing-key",
-    });
-
-    const first = await storage.getDownloadUrl({
-      storageUri: "r2://bundles/releases/bundle.zip",
-    });
-    const second = await storage.getDownloadUrl({
-      storageUri: "r2://bundles/releases/bundle.zip",
-    });
-
-    expect(first).toEqual(second);
-    expect(first.url).toMatch(/^\/storage\//);
-  });
-});

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,59 +0,0 @@
-import { createDatabaseCoreApi } from "@hot-updater/server/db";
-import { expect, it } from "vitest";
-
-import {
-  createBundleFixture,
-  createBundleRowFixture,
-} from "../../../../packages/test-utils/src/databaseTestFixtures";
-import { createD1TestDatabase } from "../d1TestDatabase";
-import { d1Database } from "./d1Database";
-
-it("reads through the binding's statements and writes each change as one batch", async () => {
-  const database = createD1TestDatabase();
-  const calls = { all: 0, batch: 0 };
-  const core = createDatabaseCoreApi(
-    d1Database({
-      prepare: (sql) => ({
-        bind: (...params) => ({
-          sql,
-          params,
-          all: async () => {
-            calls.all += 1;
-            return database.run(sql, params);
-          },
-        }),
-      }),
-      batch: async (statements) => {
-        calls.batch += 1;
-        return database.batch(
-          statements as unknown as {
-            sql: string;
-            params: readonly unknown[];
-          }[],
-        );
-      },
-    }),
-  );
-  const bundle = createBundleFixture("1");
-  await core.ensureChannel("production");
-  await core.deploy([
-    {
-      bundle,
-      release: {
-        channel: "production",
-        enabled: true,
-        fingerprintHash: null,
-        message: null,
-        shouldForceUpdate: false,
-        targetAppVersion: "1.0.0",
-      },
-    },
-  ]);
-  await expect(core.getBundle(bundle.id)).resolves.toEqual({
-    bundle: createBundleRowFixture("1"),
-    patches: [],
-    childCount: 0,
-  });
-  expect(calls.batch).toBe(2);
-  expect(calls.all).toBeGreaterThan(0);
-});

package/worker/src/d1.conformance.integration.spec.ts

@@ -1,53 +0,0 @@
-import {
-  coreSettings,
-  createTableStatements,
-  isMultiIndex,
-  type PhysicalTable,
-  SETTINGS_TABLE,
-  WRITE_GUARD_TABLE,
-} from "@hot-updater/server/database";
-import { settingsStatements } from "@hot-updater/server/db";
-import { env } from "cloudflare:test";
-
-// Not the package index: it loads Node-only helpers workerd lacks.
-import { setupDatabaseAdapterConformanceSuite } from "../../../../packages/test-utils/src/setupDatabaseAdapterConformanceSuite";
-import { D1_MAX_OPS } from "../../src/d1Executor";
-import { d1Database } from "../../src/worker";
-
-/** Drops the tables and their index tables from the D1 binding. */
-const drop = async (tables: readonly PhysicalTable[]) => {
-  await env.DB.batch(
-    tables
-      .flatMap((table) => [
-        table.name,
-        ...table.indexes
-          .filter((index) => isMultiIndex(table, index))
-          .map((index) => `${table.name}__${index.name}`),
-      ])
-      .map((name) => env.DB.prepare(`DROP TABLE IF EXISTS "${name}"`)),
-  );
-};
-
-/**
- * The adapter the worker's `d1Database` returns on the D1 binding, schema
- * fence included: each test creates the conformance tables, the batch guard,
- * and the settings rows the fence checks, and drops them after. D1 has no
- * native pages.
- */
-setupDatabaseAdapterConformanceSuite({
-  name: "d1 (workerd)",
-  maxOps: D1_MAX_OPS,
-  createAdapter: async ({ tables }) => {
-    const created = [...tables, SETTINGS_TABLE, WRITE_GUARD_TABLE];
-    await env.DB.batch(
-      [
-        ...createTableStatements("sqlite", created),
-        ...settingsStatements("sqlite", coreSettings),
-      ].map((sql) => env.DB.prepare(sql)),
-    );
-    return {
-      adapter: d1Database(env.DB).adapter,
-      cleanup: () => drop(created),
-    };
-  },
-});

package/worker/src/d1.readBudgets.integration.spec.ts

@@ -1,85 +0,0 @@
-import { toolingTargetOf } from "@hot-updater/server/database";
-import {
-  createMeasuredDatabase,
-  targetBaseCandidateKey,
-} from "@hot-updater/server/db";
-import { apiKeys } from "@hot-updater/server/plugins/api-keys";
-import { insights } from "@hot-updater/server/plugins/insights";
-import { env } from "cloudflare:test";
-import { inject } from "vitest";
-
-// From source: the package root also loads Node-only helpers workerd lacks.
-import { setupReadBudgetTestSuite } from "../../../../packages/test-utils/src/setupReadBudgetTestSuite";
-import type { RowsExamined } from "../../../../packages/test-utils/src/sqlRowsExamined";
-import { d1Database, type D1Like } from "../../src/worker";
-
-/**
- * The binding, and D1's `rows_read` for each SELECT it runs outside a batch
- * while counting: the reads of the SQL core. D1 reads a batch get's key list
- * and a multi-valued index's own table beside each row it returns, and one
- * row past the end of a range.
- */
-const rowsRead = (database: D1Database) => {
-  const statements = new WeakMap<object, D1PreparedStatement>();
-  let counting = false;
-  let read = 0;
-  const binding: D1Like = {
-    prepare: (sql) => ({
-      bind: (...params) => {
-        const statement = database.prepare(sql).bind(...params);
-        const bound = {
-          all: async () => {
-            const result = await statement.all();
-            if (counting && /^\s*SELECT\b/iu.test(sql)) {
-              read += result.meta.rows_read;
-            }
-            return result;
-          },
-        };
-        statements.set(bound, statement);
-        return bound;
-      },
-    }),
-    batch: (bound) =>
-      database.batch(bound.map((statement) => statements.get(statement)!)),
-  };
-  const examined: RowsExamined = {
-    reset() {
-      counting = true;
-      read = 0;
-    },
-    async total() {
-      counting = false;
-      return read;
-    },
-    perRow: 2,
-    perRead: 1,
-  };
-  return { binding, examined };
-};
-
-/**
- * The worker's `d1Database` on the D1 binding. Its schema fence reads the
- * settings rows the migration writes once, while the suite seeds.
- */
-setupReadBudgetTestSuite({
-  name: "d1 (workerd)",
-  server: {
-    createMeasuredDatabase,
-    toolingTargetOf,
-    plugins: [insights(), apiKeys()],
-    targetBaseCandidateKey,
-  },
-  createAdapter: async () => {
-    const [migration] = inject("d1Migrations");
-    // `exec` runs one statement per line, and a comment line is not one.
-    await env.DB.exec(
-      migration!.sql
-        .split("\n")
-        .filter((line) => line.trim() !== "" && !line.startsWith("--"))
-        .join("\n"),
-    );
-    const { binding, examined } = rowsRead(env.DB);
-    return { adapter: d1Database(binding).adapter, examined };
-  },
-});

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

@@ -1,101 +0,0 @@
-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 } from "@hot-updater/server/plugins/insights/testing";
-import { env } from "cloudflare:test";
-import { expect, inject, it } from "vitest";
-
-import { plugins } from "../../src/plugins";
-import { d1Database } from "../../src/worker";
-
-declare module "vitest" {
-  export interface ProvidedContext {
-    d1Migrations: readonly {
-      readonly name: string;
-      readonly sql: string;
-    }[];
-  }
-}
-
-/** 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}`),
-]);
-
-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 every table, the batch guard, and the settings the fence checks", async () => {
-  const [migration] = inject("d1Migrations");
-  // `exec` runs one statement per line, and a comment line is not one.
-  await env.DB.exec(
-    migration!.sql
-      .split("\n")
-      .filter((line) => line.trim() !== "" && !line.startsWith("--"))
-      .join("\n"),
-  );
-  const tables = (
-    await env.DB.prepare(
-      "SELECT name FROM sqlite_schema WHERE type = 'table' AND name NOT LIKE 'sqlite_%' AND name NOT LIKE '_cf_%'",
-    ).all<{ name: string }>()
-  ).results.map(({ name }) => name);
-  expect(tables.toSorted()).toEqual(
-    ["_hu_write", "private_hot_updater_settings", ...dataTables].toSorted(),
-  );
-  const settings = await env.DB.prepare(
-    "SELECT key, value FROM private_hot_updater_settings ORDER BY key",
-  ).all<{ key: string; value: string }>();
-  expect(settings.results.map(({ key }) => key)).toEqual([
-    "schema.apiKeys",
-    "schema.core",
-    "schema.engine",
-    "schema.insights",
-  ]);
-});
-
-it("returns canonical downloaded and applied events from the initialized D1 schema", async () => {
-  const model = createInsightsModel(
-    createHotUpdater({
-      database: d1Database(env.DB),
-      plugins: [insights()],
-      clientAccess: "public",
-    }).api.insights,
-  );
-  const download = {
-    ...createBundleEventRowFixture("9601", 100),
-    type: "UPDATE_DOWNLOADED" as const,
-    from_bundle_id: "00000000-0000-7000-8000-000000001001",
-    metadata: {
-      ...createBundleEventRowFixture("9601", 100).metadata,
-      update_strategy: "appVersion" as const,
-    },
-  };
-  await model.recordEvent({ event: download });
-  await expect(
-    model.findLatestEvents({
-      installId: download.install_id,
-    }),
-  ).resolves.toEqual([download]);
-  const applied = {
-    ...download,
-    id: createBundleEventRowFixture("9602", 200).id,
-    type: "UPDATE_APPLIED" as const,
-    received_at_ms: 200,
-  };
-  await model.recordEvent({ event: applied });
-  await model.recordEvent({ event: download });
-  await expect(
-    model.findLatestEvents({
-      installId: download.install_id,
-    }),
-  ).resolves.toEqual([applied]);
-});