@hot-updater/server 0.36.7 → 1.0.0-rc.0

package/src/adapters/prismaQuery.ts

@@ -0,0 +1,129 @@
+import { DatabasePluginInputError } from "@hot-updater/plugin-core";
+import type {
+  DatabaseModel,
+  DatabaseOrderBy,
+  DatabaseSortBy,
+  DatabaseWhere,
+} from "@hot-updater/plugin-core/internal";
+
+import type { ORMProvider } from "../db/types";
+
+export type PrismaQuery = Readonly<Record<string, unknown>>;
+type AnyDatabaseWhere = {
+  readonly [TModel in DatabaseModel]: DatabaseWhere<TModel>;
+}[DatabaseModel];
+type AnyDatabaseSortBy = {
+  readonly [TModel in DatabaseModel]: DatabaseSortBy<TModel>;
+}[DatabaseModel];
+type AnyDatabaseOrderBy = {
+  readonly [TModel in DatabaseModel]: DatabaseOrderBy<TModel>;
+}[DatabaseModel];
+
+const stringFilter = (
+  operator: "contains" | "ends_with" | "starts_with",
+  value: string,
+  mode: "default" | undefined,
+): PrismaQuery => {
+  const key =
+    operator === "starts_with"
+      ? "startsWith"
+      : operator === "ends_with"
+        ? "endsWith"
+        : "contains";
+  return {
+    [key]: value,
+    ...(mode ? { mode } : {}),
+  };
+};
+
+const SQL_PATTERN_METACHARACTERS = /[%_\\]/u;
+const MONGODB_PATTERN_METACHARACTERS = /[.*+?^${}()|[\]\\]/u;
+
+const prismaMode = (
+  mode: "insensitive" | "sensitive" | undefined,
+  provider: ORMProvider,
+): "default" | undefined => {
+  if (
+    mode === "insensitive" ||
+    (mode === "sensitive" && provider !== "postgresql")
+  ) {
+    throw new DatabasePluginInputError("invalid-operation");
+  }
+  return mode === "sensitive" ? "default" : undefined;
+};
+
+const assertLiteralPattern = (value: string, provider: ORMProvider): void => {
+  const pattern =
+    provider === "mongodb"
+      ? MONGODB_PATTERN_METACHARACTERS
+      : SQL_PATTERN_METACHARACTERS;
+  if (pattern.test(value)) {
+    throw new DatabasePluginInputError("invalid-operation");
+  }
+};
+
+const predicate = (
+  where: AnyDatabaseWhere,
+  provider: ORMProvider,
+): PrismaQuery => {
+  const mode = prismaMode("mode" in where ? where.mode : undefined, provider);
+  switch (where.operator) {
+    case undefined:
+    case "eq":
+      return {
+        [where.field]: mode ? { equals: where.value, mode } : where.value,
+      };
+    case "ne":
+      return {
+        [where.field]: {
+          not: where.value,
+          ...(mode ? { mode } : {}),
+        },
+      };
+    case "gt":
+    case "gte":
+    case "lt":
+    case "lte":
+      return { [where.field]: { [where.operator]: where.value } };
+    case "in":
+      return { [where.field]: { in: where.value } };
+    case "not_in":
+      return { [where.field]: { notIn: where.value } };
+    case "contains":
+    case "starts_with":
+    case "ends_with": {
+      assertLiteralPattern(where.value, provider);
+      return {
+        [where.field]: stringFilter(where.operator, where.value, mode),
+      };
+    }
+  }
+};
+
+export const createPrismaWhere = (
+  where: readonly AnyDatabaseWhere[] | undefined,
+  provider: ORMProvider,
+): PrismaQuery => {
+  const items = where ?? [];
+  const first = items[0];
+  if (first === undefined) return {};
+
+  let result = predicate(first, provider);
+  for (const item of items.slice(1)) {
+    result = {
+      [item.connector === "OR" ? "OR" : "AND"]: [
+        result,
+        predicate(item, provider),
+      ],
+    };
+  }
+  return result;
+};
+
+export const createPrismaOrderBy = (
+  orderBy: AnyDatabaseOrderBy | readonly AnyDatabaseSortBy[] | undefined,
+): PrismaQuery | PrismaQuery[] | undefined => {
+  if (orderBy === undefined) return undefined;
+  const clauses = Array.isArray(orderBy) ? orderBy : [orderBy];
+  return clauses.map((clause) => ({ [clause.field]: clause.direction }));
+};

package/src/adapters/prismaRows.spec.ts

@@ -0,0 +1,98 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  createBundlePatchRowFixture,
+  createBundleEventRowFixture,
+  createBundleRowFixture,
+} from "../../../test-utils/src/databaseTestFixtures";
+import {
+  parsePrismaBundleEventRow,
+  parsePrismaBundleRow,
+  parsePrismaPatchRow,
+} from "./prismaRows";
+
+describe("parsePrismaBundleRow", () => {
+  it.each([null, [], "metadata"])(
+    "rejects non-object metadata from Prisma",
+    (metadata) => {
+      expect(() =>
+        parsePrismaBundleRow({
+          ...createBundleRowFixture("invalid-metadata"),
+          metadata,
+        }),
+      ).toThrow("Invalid Prisma plugin state");
+    },
+  );
+
+  it("preserves safe archive sizes above 2 GiB", () => {
+    expect(parsePrismaBundleRow(createBundleRowFixture("large"))).toMatchObject(
+      { archive_byte_size: 3_000_000_001 },
+    );
+  });
+
+  it.each([-1, 1.5, Number.MAX_SAFE_INTEGER + 1, Number.NaN])(
+    "rejects invalid archive size %s",
+    (archiveByteSize) => {
+      expect(() =>
+        parsePrismaBundleRow({
+          ...createBundleRowFixture("invalid-size"),
+          archive_byte_size: archiveByteSize,
+        }),
+      ).toThrow("Invalid Prisma plugin state");
+    },
+  );
+});
+
+describe("parsePrismaPatchRow", () => {
+  const row = createBundlePatchRowFixture("large", "bundle", "base");
+
+  it("preserves safe patch sizes above 2 GiB", () => {
+    expect(parsePrismaPatchRow(row)).toMatchObject({
+      byte_size: 3_000_000_002,
+    });
+  });
+
+  it.each([-1, 1.5, Number.MAX_SAFE_INTEGER + 1, Number.NaN])(
+    "rejects invalid patch size %s",
+    (patchByteSize) => {
+      expect(() =>
+        parsePrismaPatchRow({ ...row, byte_size: patchByteSize }),
+      ).toThrow("Invalid Prisma plugin state");
+    },
+  );
+});
+
+describe("parsePrismaBundleEventRow", () => {
+  it("preserves explicit null Release ids", () => {
+    expect(
+      parsePrismaBundleEventRow(createBundleEventRowFixture("1", 1)),
+    ).toMatchObject({ from_release_id: null, to_release_id: null });
+  });
+
+  it.each(["from_release_id", "to_release_id"])(
+    "rejects an omitted field: %s",
+    (field) => {
+      const row: Record<string, unknown> = {
+        ...createBundleEventRowFixture("1", 1),
+      };
+      delete row[field];
+
+      expect(() => parsePrismaBundleEventRow(row)).toThrow(
+        "Invalid Prisma plugin state",
+      );
+    },
+  );
+
+  it.each([
+    { from_bundle_id: null },
+    { to_bundle_id: null },
+    { type: "UNCHANGED", from_bundle_id: "bundle-old", update_strategy: null },
+  ])("rejects an invalid direction shape", (overrides) => {
+    expect(() =>
+      parsePrismaBundleEventRow({
+        ...createBundleEventRowFixture("1", 1),
+        ...overrides,
+      }),
+    ).toThrow("Invalid Prisma plugin state");
+  });
+});

package/src/adapters/prismaRows.ts

@@ -0,0 +1,301 @@
+import type {
+  BundleEventRow,
+  BundlePatchRow,
+  BundleRow,
+  ChannelRow,
+  ApiKeyRow,
+  ReleaseCatalogRow,
+  ReleaseRow,
+} from "@hot-updater/plugin-core";
+import { isDatabaseMetadataObject } from "@hot-updater/plugin-core";
+import type { DatabaseModel } from "@hot-updater/plugin-core/internal";
+
+import type { PrismaQuery } from "./prismaQuery";
+
+export type PrismaDelegate = {
+  readonly count: (args?: PrismaQuery) => Promise<number>;
+  readonly create: (args: PrismaQuery) => Promise<unknown>;
+  readonly deleteMany: (args?: PrismaQuery) => Promise<unknown>;
+  readonly findFirst: (args?: PrismaQuery) => Promise<unknown>;
+  readonly findMany: (args?: PrismaQuery) => Promise<readonly unknown[]>;
+  readonly update: (args: PrismaQuery) => Promise<unknown>;
+  readonly updateMany?: (args: PrismaQuery) => Promise<unknown>;
+  readonly upsert: (args: PrismaQuery) => Promise<unknown>;
+};
+
+export class PrismaAdapterError extends Error {
+  readonly name = "PrismaAdapterError";
+
+  constructor(readonly reason: string) {
+    super(`Invalid Prisma plugin state: ${reason}`);
+  }
+}
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === "object" && value !== null;
+
+const hasDelegateMethods = (value: unknown): value is PrismaDelegate =>
+  isRecord(value) &&
+  typeof value["count"] === "function" &&
+  typeof value["create"] === "function" &&
+  typeof value["deleteMany"] === "function" &&
+  typeof value["findFirst"] === "function" &&
+  typeof value["findMany"] === "function" &&
+  typeof value["update"] === "function" &&
+  typeof value["upsert"] === "function";
+
+const modelDelegates = {
+  bundles: "bundles",
+  bundle_patches: "bundle_patches",
+  bundle_events: "bundle_events",
+  channels: "channels",
+  api_keys: "api_keys",
+  releases: "releases",
+  release_catalogs: "release_catalogs",
+} as const satisfies Record<DatabaseModel, string>;
+
+export const getPrismaDelegate = (
+  client: object,
+  model: DatabaseModel,
+): PrismaDelegate => {
+  const delegate = Object.entries(client).find(
+    ([key]) => key === modelDelegates[model],
+  )?.[1];
+  if (delegate === undefined)
+    throw new PrismaAdapterError(`missing model delegate "${model}"`);
+  if (!hasDelegateMethods(delegate)) {
+    throw new PrismaAdapterError(`invalid model delegate "${model}"`);
+  }
+  return delegate;
+};
+
+const readString = (row: Record<string, unknown>, field: string): string => {
+  const value = row[field];
+  if (typeof value !== "string") {
+    throw new PrismaAdapterError(`expected string field "${field}"`);
+  }
+  return value;
+};
+
+const readNullableString = (
+  row: Record<string, unknown>,
+  field: string,
+): string | null => {
+  const value = row[field];
+  if (value === null) return null;
+  if (typeof value !== "string") {
+    throw new PrismaAdapterError(`expected nullable string field "${field}"`);
+  }
+  return value;
+};
+
+const readByteSize = (row: Record<string, unknown>, field: string): number => {
+  const value = row[field];
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
+    throw new PrismaAdapterError(`expected byte-size field "${field}"`);
+  }
+  return value;
+};
+
+export const parsePrismaBundleRow = (value: unknown): BundleRow => {
+  if (!isRecord(value)) throw new PrismaAdapterError("invalid bundle row");
+  const platform = value["platform"];
+  if (platform !== "android" && platform !== "ios") {
+    throw new PrismaAdapterError('expected platform "android" or "ios"');
+  }
+  const metadata = value["metadata"];
+  if (!isDatabaseMetadataObject(metadata)) {
+    throw new PrismaAdapterError("invalid metadata field");
+  }
+  return {
+    id: readString(value, "id"),
+    platform,
+    file_hash: readString(value, "file_hash"),
+    git_commit_hash: readNullableString(value, "git_commit_hash"),
+    storage_uri: readString(value, "storage_uri"),
+    archive_byte_size: readByteSize(value, "archive_byte_size"),
+    metadata,
+    manifest_storage_uri: readNullableString(value, "manifest_storage_uri"),
+    manifest_file_hash: readNullableString(value, "manifest_file_hash"),
+    asset_base_storage_uri: readNullableString(value, "asset_base_storage_uri"),
+  };
+};
+
+export const parsePrismaChannelRow = (value: unknown): ChannelRow => {
+  if (!isRecord(value)) throw new PrismaAdapterError("invalid channel row");
+  return {
+    id: readString(value, "id"),
+    name: readString(value, "name"),
+  };
+};
+
+export const parsePrismaPatchRow = (value: unknown): BundlePatchRow => {
+  if (!isRecord(value)) throw new PrismaAdapterError("invalid patch row");
+  const orderIndex = value["order_index"];
+  if (typeof orderIndex !== "number") {
+    throw new PrismaAdapterError("invalid patch order_index field");
+  }
+  return {
+    id: readString(value, "id"),
+    bundle_id: readString(value, "bundle_id"),
+    base_bundle_id: readString(value, "base_bundle_id"),
+    base_file_hash: readString(value, "base_file_hash"),
+    patch_file_hash: readString(value, "patch_file_hash"),
+    patch_storage_uri: readString(value, "patch_storage_uri"),
+    byte_size: readByteSize(value, "byte_size"),
+    order_index: orderIndex,
+  };
+};
+
+const readNumber = (row: Record<string, unknown>, field: string): number => {
+  const value = row[field];
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new PrismaAdapterError(`expected number field "${field}"`);
+  }
+  return value;
+};
+
+export const parsePrismaBundleEventRow = (value: unknown): BundleEventRow => {
+  if (!isRecord(value)) throw new PrismaAdapterError("invalid event row");
+  const type = readString(value, "type");
+  const platform = readString(value, "platform");
+  const fromBundleId = readNullableString(value, "from_bundle_id");
+  const updateStrategy = readNullableString(value, "update_strategy");
+  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 PrismaAdapterError("invalid event shape");
+  }
+  return {
+    id: readString(value, "id"),
+    type,
+    install_id: readString(value, "install_id"),
+    user_id: readNullableString(value, "user_id"),
+    username: readNullableString(value, "username"),
+    from_release_id: readNullableString(value, "from_release_id"),
+    from_bundle_id: fromBundleId,
+    to_release_id: readNullableString(value, "to_release_id"),
+    to_bundle_id: readString(value, "to_bundle_id"),
+    platform,
+    app_version: readString(value, "app_version"),
+    channel: readString(value, "channel"),
+    cohort: readString(value, "cohort"),
+    update_strategy: updateStrategy,
+    fingerprint_hash: readNullableString(value, "fingerprint_hash"),
+    sdk_version: readNullableString(value, "sdk_version"),
+    received_at_ms: readNumber(value, "received_at_ms"),
+  } as BundleEventRow;
+};
+
+export const parsePrismaApiKeyRow = (value: unknown): ApiKeyRow => {
+  if (!isRecord(value)) {
+    throw new PrismaAdapterError("invalid API key row");
+  }
+  const role = readString(value, "role");
+  if (role !== "client") {
+    throw new PrismaAdapterError("invalid API key role");
+  }
+  const revokedAt = value["revoked_at_ms"];
+  return {
+    id: readString(value, "id"),
+    hash: readString(value, "hash"),
+    name: readString(value, "name"),
+    prefix: readString(value, "prefix"),
+    role,
+    created_at_ms: readNumber(value, "created_at_ms"),
+    revoked_at_ms:
+      revokedAt === null ? null : readNumber(value, "revoked_at_ms"),
+  };
+};
+
+export const parsePrismaReleaseRow = (value: unknown): ReleaseRow => {
+  if (!isRecord(value)) throw new PrismaAdapterError("invalid Release row");
+  const platform = readString(value, "platform");
+  const kind = readString(value, "kind");
+  const strategy = readString(value, "strategy");
+  const operation = readString(value, "operation");
+  const targetCohorts = value["target_cohorts"];
+  if (
+    (platform !== "ios" && platform !== "android") ||
+    (kind !== "BUNDLE" && kind !== "EMBEDDED") ||
+    (strategy !== "APP_VERSION" && strategy !== "FINGERPRINT") ||
+    (operation !== "DEPLOY" &&
+      operation !== "PROMOTE" &&
+      operation !== "ROLLBACK") ||
+    !Array.isArray(targetCohorts) ||
+    !targetCohorts.every((cohort) => typeof cohort === "string")
+  ) {
+    throw new PrismaAdapterError("invalid Release fields");
+  }
+  const enabled = value["enabled"];
+  const shouldForceUpdate = value["should_force_update"];
+  if (typeof enabled !== "boolean" || typeof shouldForceUpdate !== "boolean") {
+    throw new PrismaAdapterError("invalid Release policy fields");
+  }
+  return {
+    bundle_id: readNullableString(value, "bundle_id"),
+    channel_id: readString(value, "channel_id"),
+    created_at_ms: readNumber(value, "created_at_ms"),
+    enabled,
+    fingerprint_hash: readNullableString(value, "fingerprint_hash"),
+    id: readString(value, "id"),
+    kind,
+    message: readNullableString(value, "message"),
+    operation,
+    platform,
+    revision: readNumber(value, "revision"),
+    rollout_cohort_count: readNumber(value, "rollout_cohort_count"),
+    scope_key: readString(value, "scope_key"),
+    should_force_update: shouldForceUpdate,
+    source_release_id: readNullableString(value, "source_release_id"),
+    strategy,
+    target_app_version: readNullableString(value, "target_app_version"),
+    target_cohorts: targetCohorts,
+    updated_at_ms: readNumber(value, "updated_at_ms"),
+  };
+};
+
+export const parsePrismaReleaseCatalogRow = (
+  value: unknown,
+): ReleaseCatalogRow => {
+  if (!isRecord(value)) throw new PrismaAdapterError("invalid catalog row");
+  const platform = readString(value, "platform");
+  const strategy = readString(value, "strategy");
+  const isTombstone = value["is_tombstone"];
+  if (
+    (platform !== "ios" && platform !== "android") ||
+    (strategy !== "APP_VERSION" && strategy !== "FINGERPRINT") ||
+    typeof isTombstone !== "boolean"
+  ) {
+    throw new PrismaAdapterError("invalid catalog fields");
+  }
+  return {
+    catalog_id: readString(value, "catalog_id"),
+    byte_size: readNumber(value, "byte_size"),
+    catalog_hash: readString(value, "catalog_hash"),
+    channel_id: readString(value, "channel_id"),
+    channel_key: readString(value, "channel_key"),
+    fingerprint_hash: readNullableString(value, "fingerprint_hash"),
+    generation: readNumber(value, "generation"),
+    is_tombstone: isTombstone,
+    payload: readString(value, "payload"),
+    platform,
+    scope_key: readString(value, "scope_key"),
+    strategy,
+    updated_at_ms: readNumber(value, "updated_at_ms"),
+  };
+};
+
+export const parsePrismaRows = <TRow>(
+  rows: readonly unknown[],
+  parse: (value: unknown) => TRow,
+): TRow[] => rows.map(parse);