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

package/src/adapters/mongodbCollections.ts

@@ -1,67 +0,0 @@
-import type {
-  BundleEventRow,
-  InsightsInstallationRow,
-  BundlePatchRow,
-  BundleRow,
-  ChannelRow,
-  ApiKeyRow,
-  ReleaseCatalogRow,
-  ReleaseRow,
-} from "@hot-updater/plugin-core";
-import type { ClientSession, Collection, MongoClient } from "mongodb";
-
-export class MongoAdapterConstraintError extends Error {
-  readonly name = "MongoAdapterConstraintError";
-
-  constructor(readonly reason: string) {
-    super(`MongoDB adapter constraint failed: ${reason}`);
-  }
-}
-
-export const WITHOUT_MONGO_ID = { _id: 0 } as const;
-export const DELETION_TOKEN_FIELD = "_hot_updater_deletion_token" as const;
-
-export type MongoBundleDocument = BundleRow & {
-  readonly [DELETION_TOKEN_FIELD]?: string;
-};
-
-export const WITHOUT_INTERNAL_FIELDS = {
-  ...WITHOUT_MONGO_ID,
-  [DELETION_TOKEN_FIELD]: 0,
-} as const;
-
-export const activeBundleFilter = (where: object) => ({
-  $and: [where, { [DELETION_TOKEN_FIELD]: { $exists: false } }],
-});
-
-export type MongoCollections = {
-  readonly bundles: Collection<MongoBundleDocument>;
-  readonly bundlePatches: Collection<BundlePatchRow>;
-  readonly bundleEvents: Collection<BundleEventRow>;
-  readonly bundleInstallations: Collection<InsightsInstallationRow>;
-  readonly channels: Collection<ChannelRow>;
-  readonly apiKeys: Collection<ApiKeyRow>;
-  readonly releases: Collection<ReleaseRow>;
-  readonly releaseCatalogs: Collection<ReleaseCatalogRow>;
-};
-
-export const createMongoCollections = (
-  client: MongoClient,
-): MongoCollections => {
-  const database = client.db();
-  return {
-    bundles: database.collection<MongoBundleDocument>("bundles"),
-    bundlePatches: database.collection<BundlePatchRow>("bundle_patches"),
-    bundleEvents: database.collection<BundleEventRow>("bundle_events"),
-    bundleInstallations: database.collection<InsightsInstallationRow>(
-      "bundle_installations",
-    ),
-    channels: database.collection<ChannelRow>("channels"),
-    apiKeys: database.collection<ApiKeyRow>("api_keys"),
-    releases: database.collection<ReleaseRow>("releases"),
-    releaseCatalogs: database.collection<ReleaseCatalogRow>("release_catalogs"),
-  };
-};
-
-export const mongoSessionOptions = (session?: ClientSession) =>
-  session === undefined ? {} : { session };

package/src/adapters/mongodbQuery.ts

@@ -1,255 +0,0 @@
-import type {
-  ApiKeyRow,
-  BundleEventRow,
-  BundlePatchRow,
-  BundleRow,
-  ChannelRow,
-  InsightsInstallationRow,
-  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,
-  toPredicate: (condition: AnyDatabaseWhere) => Document = predicate,
-): Document => {
-  const items = Array.isArray(where) ? where : [];
-  const first = items[0];
-  if (first === undefined) return {};
-
-  let result = toPredicate(first);
-  for (const item of items.slice(1)) {
-    result = {
-      [item.connector === "OR" ? "$or" : "$and"]: [result, toPredicate(item)],
-    };
-  }
-  return result;
-};
-
-// Fixed Insights predicates use native fields so equality/range indexes apply.
-const insightsPredicate = (where: AnyDatabaseWhere): Document => {
-  if ("mode" in where && where.mode === "insensitive") return predicate(where);
-  switch (where.operator) {
-    case undefined:
-    case "eq":
-      return { [where.field]: { $eq: where.value } };
-    case "gt":
-    case "gte":
-    case "lt":
-    case "lte":
-    case "in":
-      return { [where.field]: { [`$${where.operator}`]: where.value } };
-    default:
-      return predicate(where);
-  }
-};
-
-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, insightsPredicate);
-}
-
-export function createMongoInstallationWhere(
-  where: readonly DatabaseWhere<"bundle_installations">[] | undefined,
-): Filter<InsightsInstallationRow>;
-export function createMongoInstallationWhere(
-  where: readonly DatabaseWhere<"bundle_installations">[] | undefined,
-): Document {
-  return createMongoWhereDocument(where, insightsPredicate);
-}
-
-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

@@ -1,380 +0,0 @@
-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,
-  createMongoInstallationWhere,
-  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),
-          collation: { locale: "simple" },
-          readPreference: "primary",
-        })
-        .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),
-            collation: { locale: "simple" },
-            readPreference: "primary",
-          })
-          .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_installations": {
-      const cursor = collections.bundleInstallations
-        .find(createMongoInstallationWhere(input.where), {
-          projection: WITHOUT_MONGO_ID,
-          ...mongoSessionOptions(session),
-          collation: { locale: "simple" },
-          readPreference: "primary",
-        })
-        .skip(input.offset)
-        .limit(input.limit);
-      if (rawOrderBy === undefined) return cursor.toArray();
-      if (needsInMemoryOrder) {
-        const rows = await collections.bundleInstallations
-          .find(createMongoInstallationWhere(input.where), {
-            projection: WITHOUT_MONGO_ID,
-            ...mongoSessionOptions(session),
-            collation: { locale: "simple" },
-            readPreference: "primary",
-          })
-          .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),
-        );
-      case "bundle_installations":
-        return collections.bundleInstallations.countDocuments(
-          createMongoInstallationWhere(input.where),
-          {
-            ...mongoSessionOptions(session),
-            collation: { locale: "simple" },
-            readPreference: "primary",
-            ...(session === undefined
-              ? { readConcern: { level: "snapshot" } }
-              : {}),
-          },
-        );
-      case "bundle_events":
-        return collections.bundleEvents.countDocuments(
-          createMongoEventWhere(input.where),
-          {
-            ...mongoSessionOptions(session),
-            collation: { locale: "simple" },
-            readPreference: "primary",
-            ...(session === undefined
-              ? { readConcern: { level: "snapshot" } }
-              : {}),
-          },
-        );
-    }
-  },
-  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),
-          },
-        );
-      case "bundle_installations":
-        return collections.bundleInstallations.findOne(
-          createMongoInstallationWhere(input.where),
-          {
-            projection: WITHOUT_MONGO_ID,
-            ...mongoSessionOptions(session),
-            collation: { locale: "simple" },
-            readPreference: "primary",
-          },
-        );
-    }
-  },
-  findMany: (input) => {
-    if (input.distinctOn !== undefined) {
-      throw new DatabasePluginInputError("invalid-operation");
-    }
-    return findMongoRows(collections, input, session);
-  },
-});