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

package/src/adapters/mongodbQuery.ts

@@ -0,0 +1,226 @@
+import type {
+  ApiKeyRow,
+  BundleEventRow,
+  BundlePatchRow,
+  BundleRow,
+  ChannelRow,
+  ReleaseCatalogRow,
+  ReleaseRow,
+} from "@hot-updater/plugin-core";
+import type {
+  DatabaseModel,
+  DatabaseOrderBy,
+  DatabaseWhere,
+} from "@hot-updater/plugin-core/internal";
+import type { Document, Filter, Sort } from "mongodb";
+
+type AnyDatabaseWhere = {
+  readonly [TModel in DatabaseModel]: DatabaseWhere<TModel>;
+}[DatabaseModel];
+type AnyDatabaseOrderBy = {
+  readonly [TModel in DatabaseModel]: DatabaseOrderBy<TModel>;
+}[DatabaseModel];
+
+const escapeRegularExpression = (value: string): string =>
+  value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+
+function literal(value: unknown): Document {
+  return { $literal: value };
+}
+
+const stringExpression = (
+  field: string,
+  operator: "contains" | "ends_with" | "starts_with",
+  value: string,
+  mode: "insensitive" | "sensitive" | undefined,
+): Document => {
+  const escaped = escapeRegularExpression(value);
+  const regex =
+    operator === "starts_with"
+      ? `^${escaped}`
+      : operator === "ends_with"
+        ? `${escaped}$`
+        : escaped;
+  return {
+    $regexMatch: {
+      input: { $ifNull: [`$${field}`, ""] },
+      regex: literal(regex),
+      ...(mode === "insensitive" ? { options: "i" } : {}),
+    },
+  };
+};
+
+const predicate = (where: AnyDatabaseWhere): Document => {
+  const field = `$${where.field}`;
+  switch (where.operator) {
+    case undefined:
+    case "eq":
+      return {
+        $expr:
+          "mode" in where &&
+          where.mode === "insensitive" &&
+          typeof where.value === "string"
+            ? {
+                $eq: [
+                  { $toLower: { $ifNull: [field, ""] } },
+                  literal(where.value.toLocaleLowerCase()),
+                ],
+              }
+            : { $eq: [field, literal(where.value)] },
+      };
+    case "ne": {
+      const comparison =
+        "mode" in where && where.mode === "insensitive"
+          ? {
+              $ne: [
+                { $toLower: { $ifNull: [field, ""] } },
+                literal(where.value.toLocaleLowerCase()),
+              ],
+            }
+          : { $ne: [field, literal(where.value)] };
+      return where.value === null
+        ? { $expr: comparison }
+        : {
+            $and: [{ $expr: { $ne: [field, null] } }, { $expr: comparison }],
+          };
+    }
+    case "gt":
+    case "gte":
+    case "lt":
+    case "lte":
+      return {
+        $and: [
+          { $expr: { $ne: [field, null] } },
+          { $expr: { [`$${where.operator}`]: [field, literal(where.value)] } },
+        ],
+      };
+    case "in":
+      return { $expr: { $in: [field, literal(where.value)] } };
+    case "not_in":
+      return where.value.length === 0
+        ? { $expr: { $not: [{ $in: [field, literal(where.value)] }] } }
+        : {
+            $and: [
+              { $expr: { $ne: [field, null] } },
+              { $expr: { $not: [{ $in: [field, literal(where.value)] }] } },
+            ],
+          };
+    case "contains":
+    case "starts_with":
+    case "ends_with":
+      return {
+        $expr: stringExpression(
+          where.field,
+          where.operator,
+          where.value,
+          where.mode,
+        ),
+      };
+  }
+};
+
+const createMongoWhereDocument = (
+  where: readonly AnyDatabaseWhere[] | undefined,
+): Document => {
+  const items = Array.isArray(where) ? where : [];
+  const first = items[0];
+  if (first === undefined) return {};
+
+  let result = predicate(first);
+  for (const item of items.slice(1)) {
+    result = {
+      [item.connector === "OR" ? "$or" : "$and"]: [result, predicate(item)],
+    };
+  }
+  return result;
+};
+
+export function createMongoBundleWhere(
+  where: readonly DatabaseWhere<"bundles">[] | undefined,
+): Filter<BundleRow>;
+export function createMongoBundleWhere(
+  where: readonly DatabaseWhere<"bundles">[] | undefined,
+): Document {
+  return createMongoWhereDocument(where);
+}
+
+export function createMongoPatchWhere(
+  where: readonly DatabaseWhere<"bundle_patches">[] | undefined,
+): Filter<BundlePatchRow>;
+export function createMongoPatchWhere(
+  where: readonly DatabaseWhere<"bundle_patches">[] | undefined,
+): Document {
+  return createMongoWhereDocument(where);
+}
+
+export function createMongoEventWhere(
+  where: readonly DatabaseWhere<"bundle_events">[] | undefined,
+): Filter<BundleEventRow>;
+export function createMongoEventWhere(
+  where: readonly DatabaseWhere<"bundle_events">[] | undefined,
+): Document {
+  return createMongoWhereDocument(where);
+}
+
+export function createMongoApiKeyWhere(
+  where: readonly DatabaseWhere<"api_keys">[] | undefined,
+): Filter<ApiKeyRow>;
+export function createMongoApiKeyWhere(
+  where: readonly DatabaseWhere<"api_keys">[] | undefined,
+): Document {
+  return createMongoWhereDocument(where);
+}
+
+export function createMongoChannelWhere(
+  where: readonly DatabaseWhere<"channels">[] | undefined,
+): Filter<ChannelRow>;
+export function createMongoChannelWhere(
+  where: readonly DatabaseWhere<"channels">[] | undefined,
+): Document {
+  return createMongoWhereDocument(where);
+}
+
+export function createMongoReleaseWhere(
+  where: readonly DatabaseWhere<"releases">[] | undefined,
+): Filter<ReleaseRow>;
+export function createMongoReleaseWhere(
+  where: readonly DatabaseWhere<"releases">[] | undefined,
+): Document {
+  return createMongoWhereDocument(where);
+}
+
+export function createMongoReleaseCatalogWhere(
+  where: readonly DatabaseWhere<"release_catalogs">[] | undefined,
+): Filter<ReleaseCatalogRow>;
+export function createMongoReleaseCatalogWhere(
+  where: readonly DatabaseWhere<"release_catalogs">[] | undefined,
+): Document {
+  return createMongoWhereDocument(where);
+}
+
+export const createMongoSort = (
+  input:
+    | {
+        readonly orderBy?: AnyDatabaseOrderBy;
+      }
+    | AnyDatabaseOrderBy
+    | undefined,
+): Sort | undefined => {
+  const clauses:
+    | readonly { field: string; direction: "asc" | "desc" }[]
+    | undefined = Array.isArray(input)
+    ? (input as readonly { field: string; direction: "asc" | "desc" }[])
+    : input && "orderBy" in input && Array.isArray(input.orderBy)
+      ? (input.orderBy as readonly {
+          field: string;
+          direction: "asc" | "desc";
+        }[])
+      : undefined;
+  if (clauses === undefined || clauses.length === 0) return undefined;
+  return Object.fromEntries(
+    clauses.map((clause) => [
+      clause.field,
+      clause.direction === "asc" ? 1 : -1,
+    ]),
+  );
+};

package/src/adapters/mongodbReads.ts

@@ -0,0 +1,311 @@
+import { DatabasePluginInputError } from "@hot-updater/plugin-core";
+import type {
+  DatabaseImplementationResult,
+  DatabasePluginImplementation,
+  FindManyDatabaseImplementationInput,
+} from "@hot-updater/plugin-core/internal";
+import type { ClientSession } from "mongodb";
+
+import { hasNullOrderOverrides, sortRowsByOrder } from "./databasePluginUtils";
+import {
+  activeBundleFilter,
+  type MongoCollections,
+  mongoSessionOptions,
+  WITHOUT_INTERNAL_FIELDS,
+  WITHOUT_MONGO_ID,
+} from "./mongodbCollections";
+import {
+  createMongoBundleWhere,
+  createMongoChannelWhere,
+  createMongoApiKeyWhere,
+  createMongoEventWhere,
+  createMongoPatchWhere,
+  createMongoReleaseCatalogWhere,
+  createMongoReleaseWhere,
+  createMongoSort,
+} from "./mongodbQuery";
+
+const findMongoRows = async (
+  collections: MongoCollections,
+  input: FindManyDatabaseImplementationInput,
+  session?: ClientSession,
+): Promise<readonly DatabaseImplementationResult[]> => {
+  if (input.limit === 0) return [];
+  const rawOrderBy = input.orderBy;
+  const needsInMemoryOrder = hasNullOrderOverrides(rawOrderBy);
+  switch (input.model) {
+    case "bundles": {
+      const cursor = collections.bundles
+        .find(activeBundleFilter(createMongoBundleWhere(input.where)), {
+          projection: WITHOUT_INTERNAL_FIELDS,
+          ...mongoSessionOptions(session),
+        })
+        .skip(input.offset)
+        .limit(input.limit);
+      if (rawOrderBy === undefined) return cursor.toArray();
+      if (needsInMemoryOrder) {
+        const rows = await collections.bundles
+          .find(activeBundleFilter(createMongoBundleWhere(input.where)), {
+            projection: WITHOUT_INTERNAL_FIELDS,
+            ...mongoSessionOptions(session),
+          })
+          .toArray();
+        return sortRowsByOrder(rows, rawOrderBy).slice(
+          input.offset,
+          input.offset + input.limit,
+        );
+      }
+      const sort = createMongoSort(input);
+      return sort === undefined
+        ? cursor.toArray()
+        : cursor.sort(sort).toArray();
+    }
+    case "bundle_patches": {
+      const cursor = collections.bundlePatches
+        .find(createMongoPatchWhere(input.where), {
+          projection: WITHOUT_MONGO_ID,
+          ...mongoSessionOptions(session),
+        })
+        .skip(input.offset)
+        .limit(input.limit);
+      if (rawOrderBy === undefined) return cursor.toArray();
+      if (needsInMemoryOrder) {
+        const rows = await collections.bundlePatches
+          .find(createMongoPatchWhere(input.where), {
+            projection: WITHOUT_MONGO_ID,
+            ...mongoSessionOptions(session),
+          })
+          .toArray();
+        return sortRowsByOrder(rows, rawOrderBy).slice(
+          input.offset,
+          input.offset + input.limit,
+        );
+      }
+      const sort = createMongoSort(input);
+      return sort === undefined
+        ? cursor.toArray()
+        : cursor.sort(sort).toArray();
+    }
+    case "bundle_events": {
+      const cursor = collections.bundleEvents
+        .find(createMongoEventWhere(input.where), {
+          projection: WITHOUT_MONGO_ID,
+          ...mongoSessionOptions(session),
+        })
+        .skip(input.offset)
+        .limit(input.limit);
+      if (rawOrderBy === undefined) return cursor.toArray();
+      if (needsInMemoryOrder) {
+        const rows = await collections.bundleEvents
+          .find(createMongoEventWhere(input.where), {
+            projection: WITHOUT_MONGO_ID,
+            ...mongoSessionOptions(session),
+          })
+          .toArray();
+        return sortRowsByOrder(rows, rawOrderBy).slice(
+          input.offset,
+          input.offset + input.limit,
+        );
+      }
+      const sort = createMongoSort(input);
+      return sort === undefined
+        ? cursor.toArray()
+        : cursor.sort(sort).toArray();
+    }
+    case "api_keys": {
+      const cursor = collections.apiKeys
+        .find(createMongoApiKeyWhere(input.where), {
+          projection: WITHOUT_MONGO_ID,
+          ...mongoSessionOptions(session),
+        })
+        .skip(input.offset)
+        .limit(input.limit);
+      if (rawOrderBy === undefined) return cursor.toArray();
+      if (needsInMemoryOrder) {
+        const rows = await collections.apiKeys
+          .find(createMongoApiKeyWhere(input.where), {
+            projection: WITHOUT_MONGO_ID,
+            ...mongoSessionOptions(session),
+          })
+          .toArray();
+        return sortRowsByOrder(rows, rawOrderBy).slice(
+          input.offset,
+          input.offset + input.limit,
+        );
+      }
+      const sort = createMongoSort(input);
+      return sort === undefined
+        ? cursor.toArray()
+        : cursor.sort(sort).toArray();
+    }
+    case "channels": {
+      const cursor = collections.channels
+        .find(createMongoChannelWhere(input.where), {
+          projection: WITHOUT_MONGO_ID,
+          ...mongoSessionOptions(session),
+        })
+        .skip(input.offset)
+        .limit(input.limit);
+      if (rawOrderBy === undefined) return cursor.toArray();
+      if (needsInMemoryOrder) {
+        const rows = await collections.channels
+          .find(createMongoChannelWhere(input.where), {
+            projection: WITHOUT_MONGO_ID,
+            ...mongoSessionOptions(session),
+          })
+          .toArray();
+        return sortRowsByOrder(rows, rawOrderBy).slice(
+          input.offset,
+          input.offset + input.limit,
+        );
+      }
+      const sort = createMongoSort(input);
+      return sort === undefined
+        ? cursor.toArray()
+        : cursor.sort(sort).toArray();
+    }
+    case "releases": {
+      const cursor = collections.releases
+        .find(createMongoReleaseWhere(input.where), {
+          projection: WITHOUT_MONGO_ID,
+          ...mongoSessionOptions(session),
+        })
+        .skip(input.offset)
+        .limit(input.limit);
+      if (rawOrderBy === undefined) return cursor.toArray();
+      if (needsInMemoryOrder) {
+        const rows = await collections.releases
+          .find(createMongoReleaseWhere(input.where), {
+            projection: WITHOUT_MONGO_ID,
+            ...mongoSessionOptions(session),
+          })
+          .toArray();
+        return sortRowsByOrder(rows, rawOrderBy).slice(
+          input.offset,
+          input.offset + input.limit,
+        );
+      }
+      const sort = createMongoSort(input);
+      return sort === undefined
+        ? cursor.toArray()
+        : cursor.sort(sort).toArray();
+    }
+    case "release_catalogs": {
+      const cursor = collections.releaseCatalogs
+        .find(createMongoReleaseCatalogWhere(input.where), {
+          projection: WITHOUT_MONGO_ID,
+          ...mongoSessionOptions(session),
+        })
+        .skip(input.offset)
+        .limit(input.limit);
+      if (rawOrderBy === undefined) return cursor.toArray();
+      if (needsInMemoryOrder) {
+        const rows = await collections.releaseCatalogs
+          .find(createMongoReleaseCatalogWhere(input.where), {
+            projection: WITHOUT_MONGO_ID,
+            ...mongoSessionOptions(session),
+          })
+          .toArray();
+        return sortRowsByOrder(rows, rawOrderBy).slice(
+          input.offset,
+          input.offset + input.limit,
+        );
+      }
+      const sort = createMongoSort(input);
+      return sort === undefined
+        ? cursor.toArray()
+        : cursor.sort(sort).toArray();
+    }
+  }
+};
+
+type MongoReadImplementation = Pick<
+  DatabasePluginImplementation,
+  "count" | "findMany" | "findOne"
+>;
+
+export const createMongoReads = (
+  collections: MongoCollections,
+  session?: ClientSession,
+): MongoReadImplementation => ({
+  count: async (input) => {
+    if (input.distinct !== undefined) {
+      throw new DatabasePluginInputError("invalid-operation");
+    }
+    switch (input.model) {
+      case "bundles":
+        return collections.bundles.countDocuments(
+          activeBundleFilter(createMongoBundleWhere(input.where)),
+          mongoSessionOptions(session),
+        );
+      case "bundle_patches":
+        return collections.bundlePatches.countDocuments(
+          createMongoPatchWhere(input.where),
+          mongoSessionOptions(session),
+        );
+      case "releases":
+        return collections.releases.countDocuments(
+          createMongoReleaseWhere(input.where),
+          mongoSessionOptions(session),
+        );
+    }
+  },
+  findOne: async (input) => {
+    switch (input.model) {
+      case "bundles":
+        return collections.bundles.findOne(
+          activeBundleFilter(createMongoBundleWhere(input.where)),
+          {
+            projection: WITHOUT_INTERNAL_FIELDS,
+            ...mongoSessionOptions(session),
+          },
+        );
+      case "channels":
+        return collections.channels.findOne(
+          createMongoChannelWhere(input.where),
+          {
+            projection: WITHOUT_MONGO_ID,
+            ...mongoSessionOptions(session),
+          },
+        );
+      case "api_keys":
+        return collections.apiKeys.findOne(
+          createMongoApiKeyWhere(input.where),
+          {
+            projection: WITHOUT_MONGO_ID,
+            ...mongoSessionOptions(session),
+          },
+        );
+      case "bundle_patches":
+        return collections.bundlePatches.findOne(
+          createMongoPatchWhere(input.where),
+          {
+            projection: WITHOUT_MONGO_ID,
+            ...mongoSessionOptions(session),
+          },
+        );
+      case "releases":
+        return collections.releases.findOne(
+          createMongoReleaseWhere(input.where),
+          {
+            projection: WITHOUT_MONGO_ID,
+            ...mongoSessionOptions(session),
+          },
+        );
+      case "release_catalogs":
+        return collections.releaseCatalogs.findOne(
+          createMongoReleaseCatalogWhere(input.where),
+          {
+            projection: WITHOUT_MONGO_ID,
+            ...mongoSessionOptions(session),
+          },
+        );
+    }
+  },
+  findMany: (input) => {
+    if (input.distinctOn !== undefined) {
+      throw new DatabasePluginInputError("invalid-operation");
+    }
+    return findMongoRows(collections, input, session);
+  },
+});

package/src/adapters/mongodbRows.spec.ts

@@ -0,0 +1,64 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  createBundlePatchRowFixture,
+  createBundleRowFixture,
+} from "../../../test-utils/src/databaseTestFixtures";
+import { parseMongoBundleRow, parseMongoPatchRow } from "./mongodbRows";
+
+describe("parseMongoBundleRow", () => {
+  it("rejects a missing metadata field", () => {
+    const { metadata: _metadata, ...row } =
+      createBundleRowFixture("missing-metadata");
+
+    expect(() => parseMongoBundleRow(row)).toThrow(
+      "Invalid MongoDB plugin data",
+    );
+  });
+
+  it("rejects explicit null metadata", () => {
+    expect(() =>
+      parseMongoBundleRow({
+        ...createBundleRowFixture("null-metadata"),
+        metadata: null,
+      }),
+    ).toThrow("Invalid MongoDB plugin data");
+  });
+
+  it("preserves safe archive sizes above 2 GiB", () => {
+    expect(parseMongoBundleRow(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(() =>
+        parseMongoBundleRow({
+          ...createBundleRowFixture("invalid-size"),
+          archive_byte_size: archiveByteSize,
+        }),
+      ).toThrow("Invalid MongoDB plugin data");
+    },
+  );
+});
+
+describe("parseMongoPatchRow", () => {
+  const row = createBundlePatchRowFixture("large", "bundle", "base");
+
+  it("preserves safe patch sizes above 2 GiB", () => {
+    expect(parseMongoPatchRow(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(() =>
+        parseMongoPatchRow({ ...row, byte_size: patchByteSize }),
+      ).toThrow("Invalid MongoDB plugin data");
+    },
+  );
+});