@hot-updater/cloudflare 0.36.6 → 1.0.0-rc.0

package/src/d1Query.spec.ts

@@ -0,0 +1,46 @@
+import { expect, it } from "vitest";
+
+import type { D1Executor } from "./d1Implementation";
+import { countD1Rows, D1QueryResultError } from "./d1Query";
+
+const countWithResult = (result: readonly unknown[]): Promise<number> => {
+  const executor: D1Executor = {
+    query: async () => result,
+    batch: async () => [],
+  };
+
+  return countD1Rows(executor, { model: "bundles" });
+};
+
+it("preserves a zero count", async () => {
+  const count = countWithResult([{ count: 0 }]);
+
+  await expect(count).resolves.toBe(0);
+});
+
+it.each([
+  ["a missing first row", []],
+  ["a null first row", [null]],
+  ["a primitive first row", ["invalid"]],
+  ["an array first row", [[0]]],
+  ["a missing count property", [{}]],
+  ["a numeric string count", [{ count: "1" }]],
+  ["a NaN count", [{ count: Number.NaN }]],
+  ["an infinite count", [{ count: Number.POSITIVE_INFINITY }]],
+] as const)("rejects %s", async (_description, rows) => {
+  const count = countWithResult(rows);
+
+  await expect(count).rejects.toBeInstanceOf(D1QueryResultError);
+});
+
+it("includes the malformed count row in the provider error", async () => {
+  const row = { count: "1" };
+
+  const count = countWithResult([row]);
+
+  await expect(count).rejects.toMatchObject({
+    name: "D1QueryResultError",
+    operation: "count",
+    result: row,
+  });
+});

package/src/d1Query.ts

@@ -0,0 +1,89 @@
+import type {
+  CountDatabaseImplementationInput,
+  DatabaseImplementationResult,
+  DatabaseModel,
+  FindManyDatabaseImplementationInput,
+} from "@hot-updater/plugin-core/internal";
+
+import type { D1Executor } from "./d1Implementation";
+import { parseD1Row } from "./d1Rows";
+import { buildD1Order, buildD1Where, encodeD1Values } from "./d1Sql";
+
+export const d1TableNames = {
+  bundles: "bundles",
+  bundle_patches: "bundle_patches",
+  channels: "channels",
+  bundle_events: "bundle_events",
+  api_keys: "api_keys",
+  release_catalogs: "release_catalogs",
+  releases: "releases",
+} as const satisfies Record<DatabaseModel, string>;
+
+export class D1QueryResultError extends Error {
+  readonly name = "D1QueryResultError";
+  readonly operation = "count";
+
+  constructor(readonly result: unknown) {
+    super("D1 count query returned a malformed first row");
+  }
+}
+
+export const countD1Rows = async (
+  executor: D1Executor,
+  input: CountDatabaseImplementationInput,
+): Promise<number> => {
+  const where = buildD1Where(input.where);
+  const table = d1TableNames[input.model];
+  const source =
+    input.distinct === undefined
+      ? `${table}${where.sql}`
+      : `(SELECT DISTINCT ${input.distinct.join(", ")} FROM ${table}${where.sql}) AS distinct_rows`;
+  const rows = await executor.query(
+    `SELECT COUNT(*) AS count FROM ${source}`,
+    where.params,
+  );
+  const row = rows[0];
+  if (typeof row !== "object" || row === null || Array.isArray(row)) {
+    throw new D1QueryResultError(row);
+  }
+  const count = Reflect.get(row, "count");
+  if (typeof count !== "number" || !Number.isFinite(count)) {
+    throw new D1QueryResultError(row);
+  }
+  return count;
+};
+
+export const findManyD1Rows = async (
+  executor: D1Executor,
+  input: FindManyDatabaseImplementationInput,
+): Promise<readonly DatabaseImplementationResult[]> => {
+  const where = buildD1Where(input.where);
+  const orderBy = input.orderBy;
+  const order = buildD1Order(orderBy);
+  const table = d1TableNames[input.model];
+  const source =
+    input.distinctOn === undefined
+      ? `SELECT * FROM ${table}${where.sql}${order}`
+      : `SELECT * FROM (SELECT *, ROW_NUMBER() OVER (PARTITION BY ${input.distinctOn.fields.join(", ")}${order}) AS __hot_updater_rank FROM ${table}${where.sql}) AS distinct_rows WHERE __hot_updater_rank = 1${order}`;
+  const pageParams = encodeD1Values([input.limit, input.offset]);
+  const rows = await executor.query(
+    `${source} LIMIT json_extract(?, '$') OFFSET json_extract(?, '$')`,
+    [...where.params, ...pageParams],
+  );
+  switch (input.model) {
+    case "bundles":
+      return rows.map((row) => parseD1Row("bundles", row));
+    case "bundle_patches":
+      return rows.map((row) => parseD1Row("bundle_patches", row));
+    case "channels":
+      return rows.map((row) => parseD1Row("channels", row));
+    case "bundle_events":
+      return rows.map((row) => parseD1Row("bundle_events", row));
+    case "api_keys":
+      return rows.map((row) => parseD1Row("api_keys", row));
+    case "releases":
+      return rows.map((row) => parseD1Row("releases", row));
+    case "release_catalogs":
+      return rows.map((row) => parseD1Row("release_catalogs", row));
+  }
+};

package/src/d1Rows.spec.ts

@@ -0,0 +1,111 @@
+import { expect, it } from "vitest";
+
+import {
+  createBundleEventRowFixture,
+  createBundlePatchRowFixture,
+} from "../../../packages/test-utils/src/databaseTestFixtures";
+import { parseD1Row } from "./d1Rows";
+
+const bundleD1Row = {
+  id: "bundle-1",
+  platform: "android",
+  file_hash: "hash",
+  git_commit_hash: null,
+  storage_uri: "storage://bundle",
+  archive_byte_size: 3_000_000_001,
+  metadata: '{"build":1}',
+  manifest_storage_uri: null,
+  manifest_file_hash: null,
+  asset_base_storage_uri: null,
+} as const;
+
+it("parses SQLite JSON into an artifact-only Bundle row", () => {
+  const row = parseD1Row("bundles", bundleD1Row);
+
+  expect(row).toMatchObject({
+    metadata: { build: 1 },
+  });
+});
+
+it("defaults a legacy bundle's missing archive byte size", () => {
+  const row: Record<string, unknown> = { ...bundleD1Row };
+  delete row["archive_byte_size"];
+
+  expect(parseD1Row("bundles", row)).toMatchObject({
+    archive_byte_size: 0,
+  });
+});
+
+it("rejects an invalid artifact platform", () => {
+  expect(() =>
+    parseD1Row("bundles", { ...bundleD1Row, platform: "web" }),
+  ).toThrow("D1 returned an invalid bundles row");
+});
+
+it("rejects corrupt SQLite metadata JSON", () => {
+  expect(() =>
+    parseD1Row("bundles", { ...bundleD1Row, metadata: "{" }),
+  ).toThrow("D1 returned an invalid bundles row");
+});
+
+it.each([-1, 1.5, Number.MAX_SAFE_INTEGER + 1, Number.NaN])(
+  "rejects invalid SQLite archive size %s",
+  (archiveByteSize) => {
+    expect(() =>
+      parseD1Row("bundles", {
+        ...bundleD1Row,
+        archive_byte_size: archiveByteSize,
+      }),
+    ).toThrow("D1 returned an invalid bundles row");
+  },
+);
+
+it("preserves SQLite patch sizes above 2 GiB", () => {
+  const patch = createBundlePatchRowFixture("large", "bundle", "base");
+
+  expect(parseD1Row("bundle_patches", patch)).toMatchObject({
+    byte_size: 3_000_000_002,
+  });
+});
+
+it.each(["null", "[]", "1", '"metadata"'])(
+  "rejects non-object SQLite metadata %s",
+  (metadata) => {
+    expect(() => parseD1Row("bundles", { ...bundleD1Row, metadata })).toThrow(
+      "D1 returned an invalid bundles row",
+    );
+  },
+);
+
+it("preserves explicit null Release ids on an Analytics row", () => {
+  expect(
+    parseD1Row("bundle_events", createBundleEventRowFixture("1", 1)),
+  ).toMatchObject({ from_release_id: null, to_release_id: null });
+});
+
+it.each(["from_release_id", "to_release_id"])(
+  "rejects an omitted Analytics field: %s",
+  (field) => {
+    const row: Record<string, unknown> = {
+      ...createBundleEventRowFixture("1", 1),
+    };
+    delete row[field];
+
+    expect(() => parseD1Row("bundle_events", row)).toThrow(
+      "D1 returned an invalid bundle_events row",
+    );
+  },
+);
+
+it.each([
+  { from_bundle_id: null },
+  { to_bundle_id: null },
+  { type: "UNCHANGED", from_bundle_id: "bundle-old", update_strategy: null },
+])("rejects an invalid Analytics direction shape", (overrides) => {
+  expect(() =>
+    parseD1Row("bundle_events", {
+      ...createBundleEventRowFixture("1", 1),
+      ...overrides,
+    }),
+  ).toThrow("D1 returned an invalid bundle_events row");
+});

package/src/d1Rows.ts

@@ -0,0 +1,326 @@
+import type {
+  BundlePatchRow,
+  BundleRow,
+  BundleEventRow,
+  ChannelRow,
+  ApiKeyRow,
+  ReleaseCatalogRow,
+  ReleaseRow,
+} from "@hot-updater/plugin-core";
+import { isDatabaseMetadataObject } from "@hot-updater/plugin-core";
+import type {
+  DatabaseModel,
+  DatabaseRow,
+} from "@hot-updater/plugin-core/internal";
+
+class InvalidD1RowError extends Error {
+  readonly name = "InvalidD1RowError";
+  readonly model: DatabaseModel;
+
+  constructor(model: DatabaseModel) {
+    super(`D1 returned an invalid ${model} row`);
+    this.model = model;
+  }
+}
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === "object" && value !== null && !Array.isArray(value);
+
+const stringValue = (
+  row: Record<string, unknown>,
+  field: string,
+  model: DatabaseModel,
+): string => {
+  const value = row[field];
+  if (typeof value !== "string") throw new InvalidD1RowError(model);
+  return value;
+};
+
+const nullableString = (
+  row: Record<string, unknown>,
+  field: string,
+  model: DatabaseModel,
+): string | null => {
+  const value = row[field];
+  if (value === null) return null;
+  if (typeof value !== "string") throw new InvalidD1RowError(model);
+  return value;
+};
+
+const numberValue = (
+  row: Record<string, unknown>,
+  field: string,
+  model: DatabaseModel,
+): number => {
+  const value = row[field];
+  if (typeof value !== "number") throw new InvalidD1RowError(model);
+  return value;
+};
+
+const byteSizeValue = (
+  row: Record<string, unknown>,
+  field: string,
+  model: DatabaseModel,
+): number => {
+  const value = row[field];
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
+    throw new InvalidD1RowError(model);
+  }
+  return value;
+};
+
+const booleanValue = (
+  row: Record<string, unknown>,
+  field: string,
+  model: DatabaseModel,
+): boolean => {
+  const value = row[field];
+  if (value === true || value === 1) return true;
+  if (value === false || value === 0) return false;
+  throw new InvalidD1RowError(model);
+};
+
+const jsonValue = (value: unknown, model: DatabaseModel): unknown => {
+  if (typeof value !== "string") throw new InvalidD1RowError(model);
+  try {
+    return JSON.parse(value);
+  } catch (error) {
+    if (error instanceof SyntaxError) throw new InvalidD1RowError(model);
+    throw error;
+  }
+};
+
+const metadata = (row: Record<string, unknown>) => {
+  const value = jsonValue(row["metadata"], "bundles");
+  if (!isDatabaseMetadataObject(value)) {
+    throw new InvalidD1RowError("bundles");
+  }
+  return value;
+};
+
+const bundleRow = (row: Record<string, unknown>): BundleRow => {
+  const platform = stringValue(row, "platform", "bundles");
+  if (platform !== "ios" && platform !== "android") {
+    throw new InvalidD1RowError("bundles");
+  }
+  return {
+    id: stringValue(row, "id", "bundles"),
+    platform,
+    file_hash: stringValue(row, "file_hash", "bundles"),
+    git_commit_hash: nullableString(row, "git_commit_hash", "bundles"),
+    storage_uri: stringValue(row, "storage_uri", "bundles"),
+    archive_byte_size:
+      row["archive_byte_size"] === undefined
+        ? 0
+        : byteSizeValue(row, "archive_byte_size", "bundles"),
+    metadata: metadata(row),
+    manifest_storage_uri: nullableString(
+      row,
+      "manifest_storage_uri",
+      "bundles",
+    ),
+    manifest_file_hash: nullableString(row, "manifest_file_hash", "bundles"),
+    asset_base_storage_uri: nullableString(
+      row,
+      "asset_base_storage_uri",
+      "bundles",
+    ),
+  };
+};
+
+const patchRow = (row: Record<string, unknown>): BundlePatchRow => ({
+  id: stringValue(row, "id", "bundle_patches"),
+  bundle_id: stringValue(row, "bundle_id", "bundle_patches"),
+  base_bundle_id: stringValue(row, "base_bundle_id", "bundle_patches"),
+  base_file_hash: stringValue(row, "base_file_hash", "bundle_patches"),
+  patch_file_hash: stringValue(row, "patch_file_hash", "bundle_patches"),
+  patch_storage_uri: stringValue(row, "patch_storage_uri", "bundle_patches"),
+  byte_size: byteSizeValue(row, "byte_size", "bundle_patches"),
+  order_index: numberValue(row, "order_index", "bundle_patches"),
+});
+
+const channelRow = (row: Record<string, unknown>): ChannelRow => ({
+  id: stringValue(row, "id", "channels"),
+  name: stringValue(row, "name", "channels"),
+});
+
+const eventRow = (row: Record<string, unknown>): BundleEventRow => {
+  const type = stringValue(row, "type", "bundle_events");
+  const platform = stringValue(row, "platform", "bundle_events");
+  const fromBundleId = nullableString(row, "from_bundle_id", "bundle_events");
+  const updateStrategy = nullableString(
+    row,
+    "update_strategy",
+    "bundle_events",
+  );
+  if (
+    (platform !== "ios" && platform !== "android") ||
+    !(
+      ((type === "UPDATE_APPLIED" ||
+        type === "RECOVERED" ||
+        type === "RELEASE_ADOPTED") &&
+        typeof fromBundleId === "string" &&
+        (updateStrategy === "fingerprint" ||
+          updateStrategy === "appVersion")) ||
+      (type === "UNCHANGED" && fromBundleId === null && updateStrategy === null)
+    )
+  ) {
+    throw new InvalidD1RowError("bundle_events");
+  }
+  return {
+    id: stringValue(row, "id", "bundle_events"),
+    type,
+    install_id: stringValue(row, "install_id", "bundle_events"),
+    user_id: nullableString(row, "user_id", "bundle_events"),
+    username: nullableString(row, "username", "bundle_events"),
+    from_release_id: nullableString(row, "from_release_id", "bundle_events"),
+    from_bundle_id: fromBundleId,
+    to_release_id: nullableString(row, "to_release_id", "bundle_events"),
+    to_bundle_id: stringValue(row, "to_bundle_id", "bundle_events"),
+    platform,
+    app_version: stringValue(row, "app_version", "bundle_events"),
+    channel: stringValue(row, "channel", "bundle_events"),
+    cohort: stringValue(row, "cohort", "bundle_events"),
+    update_strategy: updateStrategy,
+    fingerprint_hash: nullableString(row, "fingerprint_hash", "bundle_events"),
+    sdk_version: nullableString(row, "sdk_version", "bundle_events"),
+    received_at_ms: numberValue(row, "received_at_ms", "bundle_events"),
+  } as BundleEventRow;
+};
+
+const apiKeyRow = (row: Record<string, unknown>): ApiKeyRow => {
+  const role = stringValue(row, "role", "api_keys");
+  if (role !== "client") throw new InvalidD1RowError("api_keys");
+  const revokedAt = row["revoked_at_ms"];
+  return {
+    id: stringValue(row, "id", "api_keys"),
+    hash: stringValue(row, "hash", "api_keys"),
+    name: stringValue(row, "name", "api_keys"),
+    prefix: stringValue(row, "prefix", "api_keys"),
+    role,
+    created_at_ms: numberValue(row, "created_at_ms", "api_keys"),
+    revoked_at_ms:
+      revokedAt === null ? null : numberValue(row, "revoked_at_ms", "api_keys"),
+  };
+};
+
+const releaseTargetCohorts = (
+  row: Record<string, unknown>,
+): readonly string[] => {
+  const value = jsonValue(row["target_cohorts"], "releases");
+  if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
+    throw new InvalidD1RowError("releases");
+  }
+  return value.filter((item): item is string => typeof item === "string");
+};
+
+const releaseRow = (row: Record<string, unknown>): ReleaseRow => {
+  const platform = stringValue(row, "platform", "releases");
+  const kind = stringValue(row, "kind", "releases");
+  const strategy = stringValue(row, "strategy", "releases");
+  const operation = stringValue(row, "operation", "releases");
+  if (
+    (platform !== "ios" && platform !== "android") ||
+    (kind !== "BUNDLE" && kind !== "EMBEDDED") ||
+    (strategy !== "APP_VERSION" && strategy !== "FINGERPRINT") ||
+    (operation !== "DEPLOY" &&
+      operation !== "PROMOTE" &&
+      operation !== "ROLLBACK")
+  ) {
+    throw new InvalidD1RowError("releases");
+  }
+  return {
+    id: stringValue(row, "id", "releases"),
+    revision: numberValue(row, "revision", "releases"),
+    scope_key: stringValue(row, "scope_key", "releases"),
+    channel_id: stringValue(row, "channel_id", "releases"),
+    platform,
+    kind,
+    bundle_id: nullableString(row, "bundle_id", "releases"),
+    strategy,
+    target_app_version: nullableString(row, "target_app_version", "releases"),
+    fingerprint_hash: nullableString(row, "fingerprint_hash", "releases"),
+    enabled: booleanValue(row, "enabled", "releases"),
+    should_force_update: booleanValue(row, "should_force_update", "releases"),
+    message: nullableString(row, "message", "releases"),
+    rollout_cohort_count: numberValue(row, "rollout_cohort_count", "releases"),
+    target_cohorts: releaseTargetCohorts(row),
+    operation,
+    source_release_id: nullableString(row, "source_release_id", "releases"),
+    created_at_ms: numberValue(row, "created_at_ms", "releases"),
+    updated_at_ms: numberValue(row, "updated_at_ms", "releases"),
+  };
+};
+
+const releaseCatalogRow = (row: Record<string, unknown>): ReleaseCatalogRow => {
+  const platform = stringValue(row, "platform", "release_catalogs");
+  const strategy = stringValue(row, "strategy", "release_catalogs");
+  if (
+    (platform !== "ios" && platform !== "android") ||
+    (strategy !== "APP_VERSION" && strategy !== "FINGERPRINT")
+  ) {
+    throw new InvalidD1RowError("release_catalogs");
+  }
+  return {
+    scope_key: stringValue(row, "scope_key", "release_catalogs"),
+    catalog_id: stringValue(row, "catalog_id", "release_catalogs"),
+    strategy,
+    channel_id: stringValue(row, "channel_id", "release_catalogs"),
+    channel_key: stringValue(row, "channel_key", "release_catalogs"),
+    platform,
+    fingerprint_hash: nullableString(
+      row,
+      "fingerprint_hash",
+      "release_catalogs",
+    ),
+    generation: numberValue(row, "generation", "release_catalogs"),
+    payload: stringValue(row, "payload", "release_catalogs"),
+    catalog_hash: stringValue(row, "catalog_hash", "release_catalogs"),
+    byte_size: numberValue(row, "byte_size", "release_catalogs"),
+    is_tombstone: booleanValue(row, "is_tombstone", "release_catalogs"),
+    updated_at_ms: numberValue(row, "updated_at_ms", "release_catalogs"),
+  };
+};
+
+export function parseD1Row(model: "bundles", value: unknown): BundleRow;
+export function parseD1Row(model: "channels", value: unknown): ChannelRow;
+export function parseD1Row(
+  model: "bundle_patches",
+  value: unknown,
+): BundlePatchRow;
+export function parseD1Row(
+  model: "bundle_events",
+  value: unknown,
+): BundleEventRow;
+export function parseD1Row(model: "api_keys", value: unknown): ApiKeyRow;
+export function parseD1Row(model: "releases", value: unknown): ReleaseRow;
+export function parseD1Row(
+  model: "release_catalogs",
+  value: unknown,
+): ReleaseCatalogRow;
+export function parseD1Row(
+  model: DatabaseModel,
+  value: unknown,
+): DatabaseRow<DatabaseModel>;
+export function parseD1Row(
+  model: DatabaseModel,
+  value: unknown,
+): DatabaseRow<DatabaseModel> {
+  if (!isRecord(value)) throw new InvalidD1RowError(model);
+  switch (model) {
+    case "bundles":
+      return bundleRow(value);
+    case "bundle_patches":
+      return patchRow(value);
+    case "channels":
+      return channelRow(value);
+    case "bundle_events":
+      return eventRow(value);
+    case "api_keys":
+      return apiKeyRow(value);
+    case "releases":
+      return releaseRow(value);
+    case "release_catalogs":
+      return releaseCatalogRow(value);
+  }
+}

package/src/d1Sql.spec.ts

@@ -0,0 +1,30 @@
+import { expect, it } from "vitest";
+
+import { buildD1Where } from "./d1Sql";
+
+it("composes predicates left to right with one json_each bind for sets", () => {
+  const query = buildD1Where([
+    { field: "enabled", value: true },
+    { field: "id", operator: "in", value: ["a", "b"], connector: "OR" },
+    {
+      field: "target_app_version",
+      operator: "ne",
+      value: null,
+      connector: "AND",
+    },
+  ]);
+
+  expect(query.sql).toBe(
+    " WHERE ((enabled = json_extract(?, '$') OR id IN (SELECT value FROM json_each(?))) AND target_app_version IS NOT NULL)",
+  );
+  expect(query.params).toEqual(["true", '["a","b"]']);
+});
+
+it("makes empty inclusion and exclusion predicates deterministic", () => {
+  expect(buildD1Where([{ field: "id", operator: "in", value: [] }]).sql).toBe(
+    " WHERE 1 = 0",
+  );
+  expect(
+    buildD1Where([{ field: "id", operator: "not_in", value: [] }]).sql,
+  ).toBe(" WHERE 1 = 1");
+});