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

package/src/d1Query.spec.ts

@@ -1,46 +0,0 @@
-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

@@ -1,92 +0,0 @@
-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",
-  bundle_installations: "bundle_installations",
-  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 "bundle_installations":
-      return rows.map((row) => parseD1Row("bundle_installations", 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

@@ -1,143 +0,0 @@
-import { expect, it } from "vitest";
-
-import {
-  createBundleEventRowFixture,
-  createBundlePatchRowFixture,
-} from "../../../packages/test-utils/src/databaseTestFixtures";
-import { parseD1Row } from "./d1Rows";
-
-const installationD1Row = {
-  id: "event-1",
-  install_id: "install-1",
-  user_id: "user-1",
-  username: "Demo User",
-  to_bundle_id: "bundle-1",
-  type: "UPDATE_APPLIED",
-  platform: "ios",
-  app_version: "1.0.0",
-  channel: "production",
-  cohort: "cohort-1",
-  received_at_ms: 100,
-} as const;
-
-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 Insights 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 Insights 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 Insights direction shape", (overrides) => {
-  expect(() =>
-    parseD1Row("bundle_events", {
-      ...createBundleEventRowFixture("1", 1),
-      ...overrides,
-    }),
-  ).toThrow("D1 returned an invalid bundle_events row");
-});
-
-it("parses a current Insights installation", () => {
-  expect(parseD1Row("bundle_installations", installationD1Row)).toEqual(
-    installationD1Row,
-  );
-});
-
-it.each([{ type: "UNKNOWN" }, { platform: "web" }])(
-  "rejects an invalid current Insights installation",
-  (overrides) => {
-    expect(() =>
-      parseD1Row("bundle_installations", {
-        ...installationD1Row,
-        ...overrides,
-      }),
-    ).toThrow("D1 returned an invalid bundle_installations row");
-  },
-);

package/src/d1Rows.ts

@@ -1,357 +0,0 @@
-import type {
-  BundlePatchRow,
-  BundleRow,
-  BundleEventRow,
-  ChannelRow,
-  InsightsInstallationRow,
-  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") &&
-        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 installationRow = (
-  row: Record<string, unknown>,
-): InsightsInstallationRow => {
-  const type = stringValue(row, "type", "bundle_installations");
-  const platform = stringValue(row, "platform", "bundle_installations");
-  if (
-    !["UPDATE_APPLIED", "RECOVERED", "UNCHANGED"].includes(type) ||
-    (platform !== "ios" && platform !== "android")
-  ) {
-    throw new InvalidD1RowError("bundle_installations");
-  }
-  return {
-    id: stringValue(row, "id", "bundle_installations"),
-    install_id: stringValue(row, "install_id", "bundle_installations"),
-    user_id: nullableString(row, "user_id", "bundle_installations"),
-    username: nullableString(row, "username", "bundle_installations"),
-    to_bundle_id: stringValue(row, "to_bundle_id", "bundle_installations"),
-    type: type as InsightsInstallationRow["type"],
-    platform,
-    app_version: stringValue(row, "app_version", "bundle_installations"),
-    channel: stringValue(row, "channel", "bundle_installations"),
-    cohort: stringValue(row, "cohort", "bundle_installations"),
-    received_at_ms: numberValue(row, "received_at_ms", "bundle_installations"),
-  };
-};
-
-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: "bundle_installations",
-  value: unknown,
-): InsightsInstallationRow;
-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 "bundle_installations":
-      return installationRow(value);
-    case "api_keys":
-      return apiKeyRow(value);
-    case "releases":
-      return releaseRow(value);
-    case "release_catalogs":
-      return releaseCatalogRow(value);
-  }
-}

package/src/d1Sql.spec.ts

@@ -1,30 +0,0 @@
-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");
-});