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

package/src/adapters/mongodbTestFilter.ts

@@ -1,169 +0,0 @@
-import type {
-  BundleEventRow,
-  InsightsInstallationRow,
-  BundlePatchRow,
-  BundleRow,
-  ChannelRow,
-  ApiKeyRow,
-  ReleaseCatalogRow,
-  ReleaseRow,
-} from "@hot-updater/plugin-core";
-
-export type MongoTestRow =
-  | BundleEventRow
-  | InsightsInstallationRow
-  | 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 Buffer.compare(Buffer.from(left), Buffer.from(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 ("$eq" in condition) return Object.is(current, condition["$eq"]);
-  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;
-  });
-};

package/src/adapters/mongodbWrites.ts

@@ -1,287 +0,0 @@
-import type { BundlePatchRow } from "@hot-updater/plugin-core";
-import { createUUIDv7 } from "@hot-updater/plugin-core";
-import type { DatabasePluginImplementation } from "@hot-updater/plugin-core/internal";
-import type { ClientSession, Collection } from "mongodb";
-
-import {
-  activeBundleFilter,
-  DELETION_TOKEN_FIELD,
-  type MongoBundleDocument,
-  type MongoCollections,
-  MongoAdapterConstraintError,
-  mongoSessionOptions,
-  WITHOUT_INTERNAL_FIELDS,
-  WITHOUT_MONGO_ID,
-} from "./mongodbCollections";
-import {
-  createMongoBundleWhere,
-  createMongoChannelWhere,
-  createMongoInstallationWhere,
-  createMongoApiKeyWhere,
-  createMongoPatchWhere,
-  createMongoReleaseCatalogWhere,
-  createMongoReleaseWhere,
-} from "./mongodbQuery";
-
-const assertPatchReferences = async (
-  bundles: Collection<MongoBundleDocument>,
-  patch: BundlePatchRow,
-  session?: ClientSession,
-): Promise<void> => {
-  const ids = Array.from(new Set([patch.bundle_id, patch.base_bundle_id]));
-  const count = await bundles.countDocuments(
-    activeBundleFilter({ id: { $in: ids } }),
-    mongoSessionOptions(session),
-  );
-  if (count !== ids.length) {
-    throw new MongoAdapterConstraintError(
-      `patch "${patch.id}" references a missing bundle`,
-    );
-  }
-};
-
-type MongoWriteImplementation = Pick<
-  DatabasePluginImplementation,
-  "create" | "delete" | "deleteChannel" | "insertChannel" | "update"
->;
-
-export const createMongoWrites = (
-  collections: MongoCollections,
-  session?: ClientSession,
-): MongoWriteImplementation => ({
-  deleteChannel: async ({ id }) => {
-    if (session === undefined) {
-      throw new MongoAdapterConstraintError(
-        "channel deletion requires transaction support",
-      );
-    }
-    const locked = await collections.channels.updateOne(
-      { id },
-      { $set: { id } },
-      mongoSessionOptions(session),
-    );
-    if (locked.matchedCount !== 1) {
-      return { deleted: false, reason: "not_found" };
-    }
-    const referencedReleases = await collections.releases.countDocuments(
-      { channel_id: id },
-      mongoSessionOptions(session),
-    );
-    if (referencedReleases > 0) {
-      return { deleted: false, reason: "not_empty" };
-    }
-    await collections.channels.deleteMany({ id }, mongoSessionOptions(session));
-    return { deleted: true };
-  },
-  insertChannel: async (input) => {
-    const result = await collections.channels.updateOne(
-      { name: input.row.name },
-      { $setOnInsert: input.row },
-      { upsert: true, ...mongoSessionOptions(session) },
-    );
-    const row = await collections.channels.findOne(
-      { name: input.row.name },
-      mongoSessionOptions(session),
-    );
-    if (row === null) {
-      throw new MongoAdapterConstraintError("channels.insert.return-existing");
-    }
-    return { row, inserted: result.upsertedCount === 1 };
-  },
-  create: async (input) => {
-    switch (input.model) {
-      case "bundles":
-        await collections.bundles.insertOne(
-          input.data,
-          mongoSessionOptions(session),
-        );
-        return input.data;
-      case "bundle_patches":
-        await assertPatchReferences(collections.bundles, input.data, session);
-        await collections.bundlePatches.insertOne(
-          input.data,
-          mongoSessionOptions(session),
-        );
-        try {
-          await assertPatchReferences(collections.bundles, input.data, session);
-        } catch (error) {
-          await collections.bundlePatches.deleteMany(
-            { id: input.data.id },
-            mongoSessionOptions(session),
-          );
-          throw error;
-        }
-        return input.data;
-      case "bundle_events":
-        await collections.bundleEvents.insertOne(
-          input.data,
-          mongoSessionOptions(session),
-        );
-        return input.data;
-      case "bundle_installations":
-        if (input.onConflict === "ignore") {
-          await collections.bundleInstallations.updateOne(
-            { install_id: input.data.install_id },
-            { $setOnInsert: input.data },
-            { upsert: true, ...mongoSessionOptions(session) },
-          );
-          return input.data;
-        }
-        await collections.bundleInstallations.insertOne(
-          input.data,
-          mongoSessionOptions(session),
-        );
-        return input.data;
-      case "releases":
-        await collections.releases.insertOne(
-          input.data,
-          mongoSessionOptions(session),
-        );
-        return input.data;
-      case "release_catalogs":
-        await collections.releaseCatalogs.insertOne(
-          input.data,
-          mongoSessionOptions(session),
-        );
-        return input.data;
-      case "api_keys":
-        if (input.onConflict === "ignore") {
-          await collections.apiKeys.updateOne(
-            { hash: input.data.hash },
-            { $setOnInsert: input.data },
-            { upsert: true, ...mongoSessionOptions(session) },
-          );
-          return input.data;
-        }
-        await collections.apiKeys.insertOne(
-          input.data,
-          mongoSessionOptions(session),
-        );
-        return input.data;
-      case "channels":
-        if (input.onConflict === "ignore") {
-          await collections.channels.updateOne(
-            { name: input.data.name },
-            { $setOnInsert: input.data },
-            { upsert: true, ...mongoSessionOptions(session) },
-          );
-          return input.data;
-        }
-        await collections.channels.insertOne(
-          input.data,
-          mongoSessionOptions(session),
-        );
-        return input.data;
-    }
-  },
-  update: async (input) => {
-    if (input.model === "bundle_installations") {
-      return collections.bundleInstallations.findOneAndUpdate(
-        createMongoInstallationWhere(input.where),
-        { $set: input.update },
-        {
-          projection: WITHOUT_MONGO_ID,
-          returnDocument: "after",
-          ...mongoSessionOptions(session),
-        },
-      );
-    }
-    if (input.model === "api_keys") {
-      return collections.apiKeys.findOneAndUpdate(
-        createMongoApiKeyWhere(input.where),
-        { $set: input.update },
-        {
-          projection: WITHOUT_INTERNAL_FIELDS,
-          returnDocument: "after",
-          ...mongoSessionOptions(session),
-        },
-      );
-    }
-    if (input.model === "releases") {
-      return collections.releases.findOneAndUpdate(
-        createMongoReleaseWhere(input.where),
-        { $set: input.update },
-        {
-          projection: WITHOUT_INTERNAL_FIELDS,
-          returnDocument: "after",
-          ...mongoSessionOptions(session),
-        },
-      );
-    }
-    if (input.model === "release_catalogs") {
-      return collections.releaseCatalogs.findOneAndUpdate(
-        createMongoReleaseCatalogWhere(input.where),
-        { $set: input.update },
-        {
-          projection: WITHOUT_INTERNAL_FIELDS,
-          returnDocument: "after",
-          ...mongoSessionOptions(session),
-        },
-      );
-    }
-    return collections.bundles.findOneAndUpdate(
-      activeBundleFilter(createMongoBundleWhere(input.where)),
-      { $set: input.update },
-      {
-        projection: WITHOUT_INTERNAL_FIELDS,
-        returnDocument: "after",
-        ...mongoSessionOptions(session),
-      },
-    );
-  },
-  delete: async (input) => {
-    switch (input.model) {
-      case "bundle_patches":
-        await collections.bundlePatches.deleteMany(
-          createMongoPatchWhere(input.where),
-          mongoSessionOptions(session),
-        );
-        return;
-      case "bundles": {
-        const deletionToken = createUUIDv7();
-        await collections.bundles.updateMany(
-          createMongoBundleWhere(input.where),
-          { $set: { [DELETION_TOKEN_FIELD]: deletionToken } },
-          mongoSessionOptions(session),
-        );
-        const rows = await collections.bundles
-          .find(
-            { [DELETION_TOKEN_FIELD]: deletionToken },
-            {
-              projection: { _id: 0, id: 1 },
-              ...mongoSessionOptions(session),
-            },
-          )
-          .toArray();
-        const ids = rows.map(({ id }) => id);
-        if (ids.length === 0) return;
-        await collections.bundlePatches.deleteMany(
-          {
-            $or: [
-              { bundle_id: { $in: ids } },
-              { base_bundle_id: { $in: ids } },
-            ],
-          },
-          mongoSessionOptions(session),
-        );
-        await collections.bundles.deleteMany(
-          { [DELETION_TOKEN_FIELD]: deletionToken },
-          mongoSessionOptions(session),
-        );
-        return;
-      }
-      case "releases":
-        await collections.releases.deleteMany(
-          createMongoReleaseWhere(input.where),
-          mongoSessionOptions(session),
-        );
-        return;
-      case "channels":
-        await collections.channels.deleteMany(
-          createMongoChannelWhere(input.where),
-          mongoSessionOptions(session),
-        );
-        return;
-    }
-  },
-});