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

package/src/d1Database.spec.ts

@@ -1,178 +0,0 @@
-import { beforeEach, expect, it, vi } from "vitest";
-
-import { d1Database } from "./d1Database";
-
-type RecordedQuery = {
-  readonly sql: string;
-  readonly params: readonly string[];
-};
-
-const state = vi.hoisted<{
-  batches: RecordedQuery[][];
-  queries: RecordedQuery[];
-  results: unknown[];
-}>(() => ({ batches: [], queries: [], results: [] }));
-
-const bundleD1Row = {
-  id: "bundle-1",
-  platform: "ios",
-  file_hash: "hash",
-  git_commit_hash: null,
-  storage_uri: "storage://bundle",
-  archive_byte_size: 3_000_000_001,
-  metadata: '{"version":1}',
-  manifest_storage_uri: null,
-  manifest_file_hash: null,
-  asset_base_storage_uri: null,
-} as const;
-
-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[];
-                }[];
-              },
-        ) => {
-          if ("batch" in input) {
-            state.batches.push(
-              input.batch.map(({ sql, params }) => ({
-                sql,
-                params: params ?? [],
-              })),
-            );
-          } else {
-            state.queries.push({
-              sql: input.sql,
-              params: input.params ?? [],
-            });
-          }
-          return {
-            async *iterPages() {
-              yield {
-                result:
-                  "batch" in input
-                    ? input.batch.map(() => ({ results: [] }))
-                    : [{ results: state.results }],
-              };
-            },
-          };
-        },
-      },
-    };
-  },
-}));
-
-beforeEach(() => {
-  state.batches.length = 0;
-  state.queries.length = 0;
-  state.results.length = 0;
-});
-
-it("queries bundles through domain filters", async () => {
-  state.results.push(bundleD1Row);
-  const plugin = d1Database({
-    accountId: "account",
-    cloudflareApiToken: "token",
-    databaseId: "database",
-  });
-
-  const rows = await plugin.models.bundles.findMany({
-    where: { platform: "ios", id: { gte: "bundle-1" } },
-    orderBy: { field: "id", direction: "desc" },
-    limit: 10,
-    offset: 0,
-  });
-
-  expect(rows).toEqual([
-    {
-      ...bundleD1Row,
-      metadata: { version: 1 },
-    },
-  ]);
-  expect(state.queries[0]?.sql).toContain("platform = json_extract(?, '$')");
-  expect(state.queries[0]?.sql).toContain("id >= json_extract(?, '$')");
-  expect(state.queries[0]?.sql).toContain("ORDER BY id DESC");
-});
-
-it("lists normalized channels without scanning bundles", async () => {
-  state.results.push({ id: "channel-production", name: "production" });
-  const plugin = d1Database({
-    accountId: "account",
-    cloudflareApiToken: "token",
-    databaseId: "database",
-  });
-
-  await expect(plugin.models.channels.list({})).resolves.toEqual({
-    channels: [{ id: "channel-production", name: "production" }],
-  });
-
-  expect(state.queries[0]?.params).toEqual(["100", "0"]);
-  expect(state.queries[0]?.sql).toBe(
-    "SELECT * FROM channels ORDER BY name ASC LIMIT json_extract(?, '$') OFFSET json_extract(?, '$')",
-  );
-  expect(state.queries[0]?.sql).not.toContain("bundles");
-});
-
-it("counts domain-filtered bundle rows in SQL", async () => {
-  state.results.push({ count: 3 });
-  const plugin = d1Database({
-    accountId: "account",
-    cloudflareApiToken: "token",
-    databaseId: "database",
-  });
-
-  await plugin.models.bundles.count({
-    platform: "ios",
-  });
-
-  expect(state.queries[0]?.sql).toContain(
-    "SELECT COUNT(*) AS count FROM bundles",
-  );
-  expect(state.queries[0]?.sql).toContain("platform = json_extract(?, '$')");
-});
-
-it("sends parameterized commits through the D1 batch body", async () => {
-  const plugin = d1Database({
-    accountId: "account",
-    cloudflareApiToken: "token",
-    databaseId: "database",
-  });
-
-  await expect(
-    plugin.commit({
-      changes: [
-        {
-          model: "channels",
-          operation: "insert",
-          row: {
-            id: "00000000-0000-0000-0000-000000000001",
-            name: "production",
-          },
-          onConflict: "ignore",
-        },
-        {
-          model: "channels",
-          operation: "insert",
-          row: {
-            id: "00000000-0000-0000-0000-000000000002",
-            name: "beta",
-          },
-          onConflict: "ignore",
-        },
-      ],
-    }),
-  ).resolves.toEqual({ committed: true });
-
-  expect(state.batches).toHaveLength(1);
-  expect(state.batches[0]).toHaveLength(2);
-  expect(state.batches[0]?.[0]?.params.length).toBeGreaterThan(0);
-  expect(state.batches[0]?.[1]?.params.length).toBeGreaterThan(0);
-});

package/src/d1Implementation.spec.ts

@@ -1,252 +0,0 @@
-import { expect, it } from "vitest";
-
-import { createD1Implementation, type D1Statement } from "./d1Implementation";
-
-it("guards every write and reports the missing change index", async () => {
-  let recorded: readonly D1Statement[] = [];
-  const implementation = createD1Implementation({
-    query: () => Promise.reject(new Error("unexpected standalone query")),
-    async batch(statements) {
-      recorded = statements;
-      return statements.map((_, index) =>
-        index === 0 ? [{ id: "bundle-1" }] : [],
-      );
-    },
-  });
-
-  const result = await implementation.commit?.({
-    changes: [
-      {
-        model: "bundles",
-        operation: "update",
-        where: { id: "bundle-1" },
-        update: { metadata: { app_version: "1.0.0" } },
-      },
-      {
-        model: "apiKeys",
-        operation: "update",
-        where: { id: "missing-key" },
-        update: { revokedAtMs: 1 },
-      },
-    ],
-  });
-
-  expect(result).toEqual({
-    committed: false,
-    conflict: { changeIndex: 1, reason: "not_found" },
-  });
-  expect(recorded.slice(0, 2).map(({ sql }) => sql)).toEqual([
-    "SELECT id FROM bundles WHERE id = json_extract(?, '$') LIMIT 1",
-    "SELECT id FROM api_keys WHERE id = json_extract(?, '$') LIMIT 1",
-  ]);
-  expect(recorded.slice(2)).toHaveLength(2);
-  for (const statement of recorded.slice(2)) {
-    expect(statement.sql).toContain("SELECT 1 FROM json_each(?) AS required");
-    expect(statement.params).toContain(
-      JSON.stringify([
-        { model: "bundles", id: "bundle-1" },
-        { model: "api_keys", id: "missing-key" },
-      ]),
-    );
-  }
-});
-
-it("aborts an atomic commit when a Release expectation changes after preflight", async () => {
-  let queryCount = 0;
-  const implementation = createD1Implementation({
-    async query(sql) {
-      expect(sql).toContain("SELECT revision FROM releases");
-      queryCount += 1;
-      return [{ revision: queryCount }];
-    },
-    async batch(statements) {
-      expect(statements[0]?.sql).toContain(
-        "HOT_UPDATER_COMMIT_EXPECTATION_CONFLICT",
-      );
-      expect(
-        statements.some(({ sql }) => sql.includes("UPDATE releases")),
-      ).toBe(true);
-      throw new Error("D1_ERROR: malformed JSON");
-    },
-  });
-
-  await expect(
-    implementation.commit?.({
-      changes: [
-        {
-          model: "releases",
-          operation: "update",
-          where: { id: "release-1" },
-          update: { revision: 2 },
-        },
-      ],
-      expectations: [{ id: "release-1", model: "releases", revision: 1 }],
-    }),
-  ).resolves.toEqual({
-    committed: false,
-    conflict: {
-      actualVersion: 2,
-      changeIndex: -1,
-      expectedVersion: 1,
-      key: "release-1",
-      model: "releases",
-      reason: "version_conflict",
-    },
-  });
-});
-
-it("maps idempotent Channel inserts to the normalized table", async () => {
-  let recorded: readonly D1Statement[] = [];
-  const implementation = createD1Implementation({
-    query: () => Promise.reject(new Error("unexpected standalone query")),
-    async batch(statements) {
-      recorded = statements;
-      return statements.map(() => []);
-    },
-  });
-
-  await expect(
-    implementation.commit?.({
-      changes: [
-        {
-          model: "channels",
-          operation: "insert",
-          row: { id: "candidate", name: "production" },
-          onConflict: "ignore",
-        },
-      ],
-    }),
-  ).resolves.toEqual({ committed: true });
-
-  expect(recorded).toHaveLength(1);
-  expect(recorded[0]?.sql).toContain("INSERT INTO channels (id, name)");
-  expect(recorded[0]?.sql).toContain("ON CONFLICT(name) DO NOTHING");
-});
-
-it("persists required archive and patch byte sizes", async () => {
-  let recorded: readonly D1Statement[] = [];
-  const implementation = createD1Implementation({
-    query: () => Promise.reject(new Error("unexpected standalone query")),
-    async batch(statements) {
-      recorded = statements;
-      return statements.map(() => []);
-    },
-  });
-  const bundle = {
-    id: "bundle-1",
-    platform: "ios" as const,
-    file_hash: "bundle-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,
-  };
-
-  await expect(
-    implementation.commit?.({
-      changes: [
-        { model: "bundles", operation: "insert", row: bundle },
-        {
-          model: "bundlePatches",
-          operation: "insert",
-          row: {
-            id: "patch-1",
-            bundle_id: bundle.id,
-            base_bundle_id: bundle.id,
-            base_file_hash: "base-hash",
-            patch_file_hash: "patch-hash",
-            patch_storage_uri: "storage://patch",
-            byte_size: 3_000_000_002,
-            order_index: 0,
-          },
-        },
-      ],
-    }),
-  ).resolves.toEqual({ committed: true });
-
-  expect(recorded[0]?.sql).toContain("archive_byte_size");
-  expect(recorded[0]?.params).toContain("3000000001");
-  expect(recorded[1]?.sql).toContain("byte_size");
-  expect(recorded[1]?.params).toContain("3000000002");
-});
-
-it("returns the canonical Channel row after a concurrent name conflict", async () => {
-  const implementation = createD1Implementation({
-    query: () => Promise.reject(new Error("unexpected standalone query")),
-    async batch(statements) {
-      expect(statements[0]?.sql).toContain("ON CONFLICT(name) DO NOTHING");
-      expect(statements[1]?.sql).toBe(
-        "SELECT id, name FROM channels WHERE name = json_extract(?, '$') LIMIT 1",
-      );
-      return [[], [{ id: "canonical", name: "production" }]];
-    },
-  });
-
-  await expect(
-    implementation.insertChannel({
-      row: { id: "losing-candidate", name: "production" },
-      onConflict: "returnExisting",
-    }),
-  ).resolves.toEqual({
-    row: { id: "canonical", name: "production" },
-    inserted: false,
-  });
-});
-
-it("deletes an empty Channel and distinguishes missing and referenced rows", async () => {
-  const results = [
-    [[{ id: "empty" }], [], [{ id: "empty" }]],
-    [[], [], []],
-    [[{ id: "active" }], [{ id: "release" }], []],
-  ];
-  const implementation = createD1Implementation({
-    query: () => Promise.reject(new Error("unexpected standalone query")),
-    async batch(statements) {
-      expect(statements[2]?.sql).toContain(
-        "DELETE FROM channels WHERE id = json_extract(?, '$') AND NOT EXISTS",
-      );
-      return results.shift() ?? [];
-    },
-  });
-
-  await expect(implementation.deleteChannel({ id: "empty" })).resolves.toEqual({
-    deleted: true,
-  });
-  await expect(
-    implementation.deleteChannel({ id: "missing" }),
-  ).resolves.toEqual({ deleted: false, reason: "not_found" });
-  await expect(implementation.deleteChannel({ id: "active" })).resolves.toEqual(
-    { deleted: false, reason: "not_empty" },
-  );
-});
-
-it("guards a generic Channel delete and reports a referenced conflict", async () => {
-  let recorded: readonly D1Statement[] = [];
-  const implementation = createD1Implementation({
-    query: () => Promise.reject(new Error("unexpected standalone query")),
-    async batch(statements) {
-      recorded = statements;
-      return [[{ id: "bundle" }], []];
-    },
-  });
-
-  await expect(
-    implementation.commit?.({
-      changes: [
-        {
-          model: "channels",
-          operation: "delete",
-          where: { id: "active" },
-        },
-      ],
-    }),
-  ).resolves.toEqual({
-    committed: false,
-    conflict: { changeIndex: 0, reason: "referenced" },
-  });
-  expect(recorded[1]?.sql).toContain("DELETE FROM channels");
-  expect(recorded[1]?.sql).toContain("NOT EXISTS");
-});