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

package/src/adapters/mongodbRows.ts

@@ -0,0 +1,118 @@
+import {
+  isDatabaseMetadataObject,
+  type BundlePatchRow,
+  type BundleRow,
+  type ChannelRow,
+} from "@hot-updater/plugin-core";
+
+export class MongoAdapterDataError extends Error {
+  readonly name = "MongoAdapterDataError";
+
+  constructor(readonly source: string) {
+    super(`Invalid MongoDB plugin data at "${source}".`);
+  }
+}
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === "object" && value !== null && !Array.isArray(value);
+
+const record = (value: unknown, source: string): Record<string, unknown> => {
+  if (!isRecord(value)) {
+    throw new MongoAdapterDataError(source);
+  }
+  return value;
+};
+
+const string = (value: unknown, source: string): string => {
+  if (typeof value !== "string") throw new MongoAdapterDataError(source);
+  return value;
+};
+
+const nullableString = (value: unknown, source: string): string | null => {
+  if (value === null || value === undefined) return null;
+  return string(value, source);
+};
+
+const integer = (
+  value: unknown,
+  source: string,
+  maximum = Number.POSITIVE_INFINITY,
+): number => {
+  if (
+    typeof value !== "number" ||
+    !Number.isInteger(value) ||
+    value < 0 ||
+    value > maximum
+  ) {
+    throw new MongoAdapterDataError(source);
+  }
+  return value;
+};
+
+const platform = (value: unknown, source: string): "android" | "ios" => {
+  if (value !== "android" && value !== "ios") {
+    throw new MongoAdapterDataError(source);
+  }
+  return value;
+};
+
+const metadata = (value: unknown, source: string) => {
+  if (!isDatabaseMetadataObject(value)) {
+    throw new MongoAdapterDataError(source);
+  }
+  return value;
+};
+
+export const parseMongoBundleRow = (
+  value: unknown,
+  source = "bundles",
+): BundleRow => {
+  const input = record(value, source);
+  return {
+    id: string(input["id"], source),
+    platform: platform(input["platform"], source),
+    file_hash: string(input["file_hash"], source),
+    git_commit_hash: nullableString(input["git_commit_hash"], source),
+    storage_uri: string(input["storage_uri"], source),
+    archive_byte_size: integer(
+      input["archive_byte_size"],
+      source,
+      Number.MAX_SAFE_INTEGER,
+    ),
+    metadata: metadata(input["metadata"], source),
+    manifest_storage_uri: nullableString(input["manifest_storage_uri"], source),
+    manifest_file_hash: nullableString(input["manifest_file_hash"], source),
+    asset_base_storage_uri: nullableString(
+      input["asset_base_storage_uri"],
+      source,
+    ),
+  };
+};
+
+export const parseMongoChannelRow = (
+  value: unknown,
+  source = "channels",
+): ChannelRow => {
+  const input = record(value, source);
+  return {
+    id: string(input["id"], source),
+    name: string(input["name"], source),
+  };
+};
+
+export const parseMongoPatchRow = (
+  value: unknown,
+  source = "bundle_patches",
+): BundlePatchRow => {
+  const input = record(value, source);
+  return {
+    id: string(input["id"], source),
+    bundle_id: string(input["bundle_id"], source),
+    base_bundle_id: string(input["base_bundle_id"], source),
+    base_file_hash: string(input["base_file_hash"], source),
+    patch_file_hash: string(input["patch_file_hash"], source),
+    patch_storage_uri: string(input["patch_storage_uri"], source),
+    byte_size: integer(input["byte_size"], source, Number.MAX_SAFE_INTEGER),
+    order_index: integer(input["order_index"], source),
+  };
+};

package/src/adapters/mongodbTestClient.ts

@@ -0,0 +1,342 @@
+import type { BundlePatchRow, BundleRow } from "@hot-updater/plugin-core";
+import type { ClientSession } from "mongodb";
+import { MongoClient } from "mongodb";
+
+import {
+  matchesMongoTestFilter,
+  type MongoTestRow,
+  sortMongoTestRows,
+} from "./mongodbTestFilter";
+
+type Tables = {
+  bundle_patches: MongoTestRow[];
+  bundles: MongoTestRow[];
+  bundle_events: MongoTestRow[];
+  channels: MongoTestRow[];
+  api_keys: MongoTestRow[];
+  releases: MongoTestRow[];
+  release_catalogs: MongoTestRow[];
+};
+
+type FindOptions = { readonly projection?: unknown };
+type UpdateInput =
+  | { readonly $set: Readonly<Record<string, unknown>> }
+  | { readonly $setOnInsert: MongoTestRow };
+type MongoTestHooks = {
+  beforeBundlePatchInsert?: () => Promise<void>;
+  failNextBundleTombstone: boolean;
+  operationCount: number;
+};
+
+class MongoTestConstraintError extends Error {
+  readonly name = "MongoTestConstraintError";
+}
+
+class MongoTestCursor {
+  private offset = 0;
+  private maximum = Number.POSITIVE_INFINITY;
+  private sortSpecification: unknown;
+
+  constructor(
+    private readonly rows: MongoTestRow[],
+    private readonly projection?: unknown,
+  ) {}
+
+  limit(value: number): this {
+    this.maximum = value;
+    return this;
+  }
+
+  project(): this {
+    return this;
+  }
+
+  skip(value: number): this {
+    this.offset = value;
+    return this;
+  }
+
+  sort(value: unknown): this {
+    this.sortSpecification = value;
+    return this;
+  }
+
+  async toArray(): Promise<MongoTestRow[]> {
+    const rows = sortMongoTestRows(this.rows, this.sortSpecification);
+    return structuredClone(
+      rows
+        .slice(this.offset, this.offset + this.maximum)
+        .map((row) => projectMongoTestRow(row, this.projection)),
+    );
+  }
+}
+
+const projectMongoTestRow = (
+  row: MongoTestRow,
+  projection: unknown,
+): MongoTestRow => {
+  if (typeof projection !== "object" || projection === null) return row;
+  const projected = structuredClone(row);
+  for (const field of Object.keys(projected)) {
+    if (Reflect.get(projection, field) === 0) {
+      Reflect.deleteProperty(projected, field);
+    }
+  }
+  return projected;
+};
+
+const createCollection = (
+  tables: Tables,
+  model: keyof Tables,
+  hooks: MongoTestHooks,
+) => ({
+  countDocuments: async (filter?: unknown): Promise<number> => {
+    hooks.operationCount += 1;
+    return tables[model].filter((row) => matchesMongoTestFilter(row, filter))
+      .length;
+  },
+  deleteMany: async (filter?: unknown): Promise<void> => {
+    hooks.operationCount += 1;
+    tables[model] = tables[model].filter(
+      (row) => !matchesMongoTestFilter(row, filter),
+    );
+  },
+  distinct: async (field: string, filter?: unknown): Promise<unknown[]> => {
+    hooks.operationCount += 1;
+    return Array.from(
+      new Set(
+        tables[model]
+          .filter((row) => matchesMongoTestFilter(row, filter))
+          .map((row) => Reflect.get(row, field)),
+      ),
+    );
+  },
+  find: (filter?: unknown, options?: FindOptions): MongoTestCursor => {
+    hooks.operationCount += 1;
+    return new MongoTestCursor(
+      tables[model].filter((row) => matchesMongoTestFilter(row, filter)),
+      options?.projection,
+    );
+  },
+  findOne: async (
+    filter?: unknown,
+    options?: FindOptions,
+  ): Promise<MongoTestRow | null> => {
+    hooks.operationCount += 1;
+    const row = tables[model].find((candidate) =>
+      matchesMongoTestFilter(candidate, filter),
+    );
+    return row === undefined
+      ? null
+      : structuredClone(projectMongoTestRow(row, options?.projection));
+  },
+  findOneAndUpdate: async (
+    filter: unknown,
+    update: UpdateInput,
+  ): Promise<MongoTestRow | null> => {
+    hooks.operationCount += 1;
+    const index = tables[model].findIndex((row) =>
+      matchesMongoTestFilter(row, filter),
+    );
+    const current = tables[model][index];
+    if (current === undefined) return null;
+    if (!("$set" in update)) {
+      throw new MongoTestConstraintError("findOneAndUpdate requires $set");
+    }
+    const updated = { ...current, ...update.$set } as MongoTestRow;
+    tables[model][index] = updated;
+    return structuredClone(updated);
+  },
+  insertOne: async (row: MongoTestRow): Promise<void> => {
+    hooks.operationCount += 1;
+    if (model === "bundle_patches") await hooks.beforeBundlePatchInsert?.();
+    const key = "id" in row ? row.id : row.scope_key;
+    if (
+      tables[model].some((candidate) =>
+        "id" in candidate ? candidate.id === key : candidate.scope_key === key,
+      )
+    ) {
+      throw new MongoTestConstraintError("duplicate id");
+    }
+    if (
+      model === "channels" &&
+      "name" in row &&
+      tables.channels.some(
+        (candidate) => "name" in candidate && candidate.name === row.name,
+      )
+    ) {
+      throw new MongoTestConstraintError("duplicate channel name");
+    }
+    if (
+      model === "api_keys" &&
+      "hash" in row &&
+      tables.api_keys.some(
+        (candidate) => "hash" in candidate && candidate.hash === row.hash,
+      )
+    ) {
+      throw new MongoTestConstraintError("duplicate hash");
+    }
+    tables[model].push(structuredClone(row));
+  },
+  updateMany: async (filter: unknown, update: UpdateInput): Promise<void> => {
+    hooks.operationCount += 1;
+    const values = "$set" in update ? update.$set : {};
+    tables[model] = tables[model].map((row) =>
+      matchesMongoTestFilter(row, filter)
+        ? ({ ...row, ...values } as MongoTestRow)
+        : row,
+    );
+    if (model === "bundles" && hooks.failNextBundleTombstone) {
+      hooks.failNextBundleTombstone = false;
+      throw new MongoTestConstraintError("injected tombstone failure");
+    }
+  },
+  updateOne: async (
+    filter: unknown,
+    update: UpdateInput,
+    options?: { readonly upsert?: boolean },
+  ): Promise<{ matchedCount: number; upsertedCount: number }> => {
+    hooks.operationCount += 1;
+    const index = tables[model].findIndex((row) =>
+      matchesMongoTestFilter(row, filter),
+    );
+    if (index >= 0) {
+      if ("$set" in update) {
+        tables[model][index] = {
+          ...tables[model][index],
+          ...update.$set,
+        } as MongoTestRow;
+      }
+      return { matchedCount: 1, upsertedCount: 0 };
+    }
+    if (options?.upsert === true && "$setOnInsert" in update) {
+      const key =
+        "id" in update.$setOnInsert
+          ? update.$setOnInsert.id
+          : update.$setOnInsert.scope_key;
+      if (
+        tables[model].some((row) =>
+          "id" in row ? row.id === key : row.scope_key === key,
+        )
+      ) {
+        throw new MongoTestConstraintError("duplicate id");
+      }
+      tables[model].push(structuredClone(update.$setOnInsert));
+      return { matchedCount: 0, upsertedCount: 1 };
+    }
+    return { matchedCount: 0, upsertedCount: 0 };
+  },
+});
+
+const createDatabase = (tables: Tables, hooks: MongoTestHooks) => ({
+  collection: (name: string) => {
+    switch (name) {
+      case "bundles":
+        return createCollection(tables, "bundles", hooks);
+      case "bundle_patches":
+        return createCollection(tables, "bundle_patches", hooks);
+      case "bundle_events":
+        return createCollection(tables, "bundle_events", hooks);
+      case "channels":
+        return createCollection(tables, "channels", hooks);
+      case "api_keys":
+        return createCollection(tables, "api_keys", hooks);
+      case "releases":
+        return createCollection(tables, "releases", hooks);
+      case "release_catalogs":
+        return createCollection(tables, "release_catalogs", hooks);
+      default:
+        throw new MongoTestConstraintError(`unknown collection: ${name}`);
+    }
+  },
+});
+
+export const createMongoTestHarness = () => {
+  const tables: Tables = {
+    bundle_patches: [],
+    bundles: [],
+    bundle_events: [],
+    channels: [],
+    api_keys: [],
+    releases: [],
+    release_catalogs: [],
+  };
+  const hooks: MongoTestHooks = {
+    failNextBundleTombstone: false,
+    operationCount: 0,
+  };
+  let activeTables = tables;
+  let transactionQueue = Promise.resolve();
+  const client = new MongoClient("mongodb://127.0.0.1:27017/hot_updater_test");
+  Object.defineProperty(client, "db", {
+    value: () => createDatabase(activeTables, hooks),
+  });
+  Object.defineProperty(client, "withSession", {
+    value: async (
+      callback: (session: ClientSession) => Promise<unknown>,
+    ): Promise<unknown> => {
+      const session = {
+        withTransaction: async (transaction: () => Promise<unknown>) => {
+          const previous = transactionQueue;
+          let release!: () => void;
+          transactionQueue = new Promise<void>((resolve) => {
+            release = resolve;
+          });
+          await previous;
+          try {
+            const staged = structuredClone(tables);
+            activeTables = staged;
+            const result = await transaction();
+            tables.bundle_patches = staged.bundle_patches;
+            tables.bundles = staged.bundles;
+            tables.bundle_events = staged.bundle_events;
+            tables.channels = staged.channels;
+            tables.api_keys = staged.api_keys;
+            tables.releases = staged.releases;
+            tables.release_catalogs = staged.release_catalogs;
+            return result;
+          } finally {
+            activeTables = tables;
+            release();
+          }
+        },
+      } as unknown as ClientSession;
+      return callback(session);
+    },
+  });
+  return {
+    client,
+    close: () => client.close(),
+    reset: (): void => {
+      hooks.failNextBundleTombstone = false;
+      hooks.operationCount = 0;
+      transactionQueue = Promise.resolve();
+      tables.bundle_patches = [];
+      tables.bundles = [];
+      tables.bundle_events = [];
+      tables.channels = [];
+      tables.api_keys = [];
+      tables.releases = [];
+      tables.release_catalogs = [];
+    },
+    getOperationCount: (): number => hooks.operationCount,
+    setBeforeBundlePatchInsert: (
+      hook: MongoTestHooks["beforeBundlePatchInsert"],
+    ): void => {
+      hooks.beforeBundlePatchInsert = hook;
+    },
+    failNextBundleTombstone: (): void => {
+      hooks.failNextBundleTombstone = true;
+    },
+    setBundleField: (id: string, field: string, value: unknown): void => {
+      const row = tables.bundles.find(
+        (candidate) => "id" in candidate && candidate.id === id,
+      );
+      if (row === undefined) throw new MongoTestConstraintError("missing row");
+      Reflect.set(row, field, value);
+    },
+  };
+};
+
+export type MongoTestBundleRow = BundleRow;
+export type MongoTestBundlePatchRow = BundlePatchRow;

package/src/adapters/mongodbTestFilter.ts

@@ -0,0 +1,166 @@
+import type {
+  BundleEventRow,
+  BundlePatchRow,
+  BundleRow,
+  ChannelRow,
+  ApiKeyRow,
+  ReleaseCatalogRow,
+  ReleaseRow,
+} from "@hot-updater/plugin-core";
+
+export type MongoTestRow =
+  | BundleEventRow
+  | BundlePatchRow
+  | BundleRow
+  | ChannelRow
+  | ApiKeyRow
+  | ReleaseRow
+  | ReleaseCatalogRow;
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === "object" && value !== null;
+
+export const readMongoTestField = (row: MongoTestRow, field: string): unknown =>
+  Object.entries(row).find(([key]) => key === field)?.[1];
+
+const compare = (left: unknown, right: unknown): number => {
+  if (typeof left === "number" && typeof right === "number") {
+    return left - right;
+  }
+  if (typeof left === "string" && typeof right === "string") {
+    return left.localeCompare(right);
+  }
+  return 0;
+};
+
+const resolveExpression = (row: MongoTestRow, expression: unknown): unknown => {
+  if (typeof expression === "string" && expression.startsWith("$")) {
+    return readMongoTestField(row, expression.slice(1));
+  }
+  if (Array.isArray(expression)) {
+    return expression.map((item) => resolveExpression(row, item));
+  }
+  if (!isRecord(expression)) return expression;
+  if ("$literal" in expression) return expression["$literal"];
+  if ("$ifNull" in expression && Array.isArray(expression["$ifNull"])) {
+    const [value, fallback] = expression["$ifNull"];
+    const resolved = resolveExpression(row, value);
+    return resolved === null || resolved === undefined
+      ? resolveExpression(row, fallback)
+      : resolved;
+  }
+  if ("$toLower" in expression) {
+    const value = resolveExpression(row, expression["$toLower"]);
+    return typeof value === "string" ? value.toLocaleLowerCase() : value;
+  }
+  for (const operator of ["$eq", "$ne", "$gt", "$gte", "$lt", "$lte"]) {
+    const operands = expression[operator];
+    if (!Array.isArray(operands)) continue;
+    const [left, right] = operands.map((item) => resolveExpression(row, item));
+    switch (operator) {
+      case "$eq":
+        return Object.is(left, right);
+      case "$ne":
+        return !Object.is(left, right);
+      case "$gt":
+        return compare(left, right) > 0;
+      case "$gte":
+        return compare(left, right) >= 0;
+      case "$lt":
+        return compare(left, right) < 0;
+      case "$lte":
+        return compare(left, right) <= 0;
+    }
+  }
+  if ("$in" in expression && Array.isArray(expression["$in"])) {
+    const [value, candidates] = expression["$in"].map((item) =>
+      resolveExpression(row, item),
+    );
+    return (
+      Array.isArray(candidates) &&
+      candidates.some((candidate) => Object.is(candidate, value))
+    );
+  }
+  if ("$not" in expression && Array.isArray(expression["$not"])) {
+    return !resolveExpression(row, expression["$not"][0]);
+  }
+  const regexMatch = expression["$regexMatch"];
+  if (isRecord(regexMatch)) {
+    const input = resolveExpression(row, regexMatch["input"]);
+    const regex = resolveExpression(row, regexMatch["regex"]);
+    const options = regexMatch["options"];
+    return (
+      typeof input === "string" &&
+      typeof regex === "string" &&
+      new RegExp(regex, options === "i" ? "i" : undefined).test(input)
+    );
+  }
+  return expression;
+};
+
+const matchesField = (current: unknown, condition: unknown): boolean => {
+  if (!isRecord(condition)) return Object.is(current, condition);
+  if (typeof condition["$exists"] === "boolean") {
+    return condition["$exists"] ? current !== undefined : current === undefined;
+  }
+  if (Array.isArray(condition["$in"])) {
+    return condition["$in"].some((item) => Object.is(item, current));
+  }
+  if ("$ne" in condition && Object.is(current, condition["$ne"])) {
+    return false;
+  }
+  if ("$gte" in condition && compare(current, condition["$gte"]) < 0) {
+    return false;
+  }
+  if ("$gt" in condition && compare(current, condition["$gt"]) <= 0) {
+    return false;
+  }
+  if ("$lte" in condition && compare(current, condition["$lte"]) > 0) {
+    return false;
+  }
+  if ("$lt" in condition && compare(current, condition["$lt"]) >= 0) {
+    return false;
+  }
+  return true;
+};
+
+export const matchesMongoTestFilter = (
+  row: MongoTestRow,
+  filter: unknown,
+): boolean => {
+  if (!isRecord(filter)) return true;
+  if ("$expr" in filter)
+    return Boolean(resolveExpression(row, filter["$expr"]));
+  const conjunction = filter["$and"];
+  if (Array.isArray(conjunction)) {
+    return conjunction.every((item) => matchesMongoTestFilter(row, item));
+  }
+  const disjunction = filter["$or"];
+  if (Array.isArray(disjunction)) {
+    return disjunction.some((item) => matchesMongoTestFilter(row, item));
+  }
+  return Object.entries(filter).every(([field, condition]) =>
+    matchesField(readMongoTestField(row, field), condition),
+  );
+};
+
+export const sortMongoTestRows = (
+  rows: MongoTestRow[],
+  sort: unknown,
+): MongoTestRow[] => {
+  if (!isRecord(sort)) return rows;
+  const entries = Object.entries(sort);
+  if (entries.length === 0) return rows;
+  return rows.toSorted((left, right) => {
+    for (const [field, direction] of entries) {
+      const result = compare(
+        readMongoTestField(left, field),
+        readMongoTestField(right, field),
+      );
+      if (result !== 0) {
+        return direction === -1 ? -result : result;
+      }
+    }
+    return 0;
+  });
+};