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

package/src/adapters/kyselyQuery.ts

@@ -0,0 +1,128 @@
+import type {
+  DatabaseModel,
+  DatabaseWhere,
+} from "@hot-updater/plugin-core/internal";
+import { sql, type RawBuilder } from "kysely";
+
+import type { ORMSQLProvider } from "../db/types";
+import { escapeGlobPattern, escapeLikePattern } from "./databasePluginUtils";
+
+class InvalidDatabasePredicateError extends Error {
+  readonly name = "InvalidDatabasePredicateError";
+}
+
+const stringPredicate = (
+  provider: ORMSQLProvider,
+  field: string,
+  operator: "contains" | "ends_with" | "starts_with",
+  value: string,
+  insensitive: boolean,
+): RawBuilder<boolean> => {
+  const column = sql.ref(field);
+  if (provider === "sqlite" && !insensitive) {
+    const literal = escapeGlobPattern(value);
+    const pattern =
+      operator === "contains"
+        ? `*${literal}*`
+        : operator === "starts_with"
+          ? `${literal}*`
+          : `*${literal}`;
+    return sql<boolean>`${column} glob ${pattern}`;
+  }
+
+  const literal = escapeLikePattern(value);
+  const pattern =
+    operator === "contains"
+      ? `%${literal}%`
+      : operator === "starts_with"
+        ? `${literal}%`
+        : `%${literal}`;
+  if (insensitive) {
+    return sql<boolean>`lower(${column}) like lower(${pattern}) escape '\\'`;
+  }
+  if (provider === "mysql") {
+    return sql<boolean>`binary ${column} like binary ${pattern} escape '\\'`;
+  }
+  return sql<boolean>`${column} like ${pattern} escape '\\'`;
+};
+
+const predicate = <TModel extends DatabaseModel>(
+  provider: ORMSQLProvider,
+  condition: DatabaseWhere<TModel>,
+): RawBuilder<boolean> => {
+  const column = sql.ref(condition.field);
+  const operator = condition.operator ?? "eq";
+  switch (operator) {
+    case "eq":
+    case "ne": {
+      if (condition.value === null) {
+        return operator === "eq"
+          ? sql<boolean>`${column} is null`
+          : sql<boolean>`${column} is not null`;
+      }
+      const insensitive =
+        "mode" in condition && condition.mode === "insensitive";
+      if (insensitive) {
+        return operator === "eq"
+          ? sql<boolean>`lower(${column}) = lower(${condition.value})`
+          : sql<boolean>`lower(${column}) <> lower(${condition.value})`;
+      }
+      return operator === "eq"
+        ? sql<boolean>`${column} = ${condition.value}`
+        : sql<boolean>`${column} <> ${condition.value}`;
+    }
+    case "gt":
+      return sql<boolean>`${column} > ${condition.value}`;
+    case "gte":
+      return sql<boolean>`${column} >= ${condition.value}`;
+    case "lt":
+      return sql<boolean>`${column} < ${condition.value}`;
+    case "lte":
+      return sql<boolean>`${column} <= ${condition.value}`;
+    case "in":
+    case "not_in": {
+      if (!Array.isArray(condition.value)) {
+        throw new InvalidDatabasePredicateError();
+      }
+      if (operator === "in") {
+        return condition.value.length === 0
+          ? sql<boolean>`false`
+          : sql<boolean>`${column} in (${sql.join(condition.value)})`;
+      }
+      return condition.value.length === 0
+        ? sql<boolean>`true`
+        : sql<boolean>`${column} not in (${sql.join(condition.value)})`;
+    }
+    case "contains":
+    case "starts_with":
+    case "ends_with": {
+      if (typeof condition.value !== "string") {
+        throw new InvalidDatabasePredicateError();
+      }
+      return stringPredicate(
+        provider,
+        condition.field,
+        operator,
+        condition.value,
+        "mode" in condition && condition.mode === "insensitive",
+      );
+    }
+  }
+};
+
+export const buildKyselyWhere = <TModel extends DatabaseModel>(
+  provider: ORMSQLProvider,
+  where: readonly DatabaseWhere<TModel>[] | undefined,
+): RawBuilder<boolean> | undefined => {
+  const [first, ...rest] = where ?? [];
+  if (first === undefined) return undefined;
+  let expression = predicate(provider, first);
+  for (const condition of rest) {
+    const next = predicate(provider, condition);
+    expression =
+      condition.connector === "OR"
+        ? sql<boolean>`(${expression} or ${next})`
+        : sql<boolean>`(${expression} and ${next})`;
+  }
+  return expression;
+};

package/src/adapters/mongodb.spec.ts

@@ -0,0 +1,141 @@
+import { createDatabaseClient } from "@hot-updater/plugin-core";
+import { describe, expect, it } from "vitest";
+
+import {
+  createBundlePatchRowFixture,
+  createBundleRowFixture,
+} from "../../../test-utils/src/databaseTestFixtures";
+import { setupDatabasePluginTestSuite } from "../../../test-utils/src/setupDatabasePluginTestSuite";
+import { mongoAdapter } from "./mongodb";
+import { createMongoBundleWhere } from "./mongodbQuery";
+import { createMongoTestHarness } from "./mongodbTestClient";
+
+const harness = createMongoTestHarness();
+
+setupDatabasePluginTestSuite({
+  name: "mongoAdapter v2",
+  migrate: () => undefined,
+  createPlugin: () =>
+    mongoAdapter({ client: harness.client, transactions: true }),
+  reset: () => harness.reset(),
+  dispose: () => harness.close(),
+});
+
+describe("mongoAdapter capabilities", () => {
+  it("returns an adapter without an unsafe atomic-batch fallback", () => {
+    const plugin = mongoAdapter({ client: harness.client });
+    expect(plugin.name).toBe("mongodb");
+    expect(plugin.adapterName).toBe("mongodb");
+    expect(plugin.provider).toBe("mongodb");
+    expect(Reflect.has(plugin, "transaction")).toBe(false);
+  });
+
+  it("rejects a cross-table commit when transactions are disabled", async () => {
+    const plugin = mongoAdapter({ client: harness.client });
+    const owner = createBundleRowFixture("970");
+    const patch = createBundlePatchRowFixture(
+      "971",
+      owner.id,
+      createBundleRowFixture("972").id,
+    );
+
+    await expect(
+      plugin.commit({
+        changes: [
+          {
+            model: "bundles",
+            operation: "insert",
+            row: owner,
+          },
+          {
+            model: "bundlePatches",
+            operation: "insert",
+            row: patch,
+          },
+        ],
+      }),
+    ).rejects.toMatchObject({ name: "DatabaseAtomicCommitUnsupportedError" });
+  });
+
+  it("recovers a tombstoned bundle when an aggregate delete is retried", async () => {
+    harness.reset();
+    const client = createDatabaseClient(
+      mongoAdapter({ client: harness.client }),
+    );
+    const bundle = {
+      id: "bundle-retry",
+      platform: "ios" as const,
+      fileHash: "bundle-retry-hash",
+      gitCommitHash: null,
+      storageUri: "storage://bundle-retry",
+      archiveByteSize: 3_000_000_001,
+    };
+    await client.insertBundle(bundle);
+
+    harness.failNextBundleTombstone();
+    await expect(client.deleteBundleById(bundle.id)).rejects.toThrow(
+      "injected tombstone failure",
+    );
+    await expect(client.deleteBundleById(bundle.id)).resolves.toBeUndefined();
+    await expect(client.insertBundle(bundle)).resolves.toBeUndefined();
+    await expect(client.getBundleById(bundle.id)).resolves.toMatchObject({
+      id: bundle.id,
+      fileHash: bundle.fileHash,
+      storageUri: bundle.storageUri,
+    });
+  });
+});
+
+describe("MongoDB low-level predicate translation", () => {
+  it("composes connectors left to right", () => {
+    expect(
+      createMongoBundleWhere([
+        { field: "id", value: "first" },
+        { field: "id", value: "second", connector: "OR" },
+        { field: "platform", value: "ios", connector: "AND" },
+      ]),
+    ).toEqual({
+      $and: [
+        {
+          $or: [
+            { $expr: { $eq: ["$id", { $literal: "first" }] } },
+            { $expr: { $eq: ["$id", { $literal: "second" }] } },
+          ],
+        },
+        { $expr: { $eq: ["$platform", { $literal: "ios" }] } },
+      ],
+    });
+  });
+
+  it("escapes insensitive string patterns", () => {
+    expect(
+      createMongoBundleWhere([
+        {
+          field: "storage_uri",
+          operator: "contains",
+          value: "release.*",
+          mode: "insensitive",
+        },
+      ]),
+    ).toEqual({
+      $expr: {
+        $regexMatch: {
+          input: { $ifNull: ["$storage_uri", ""] },
+          regex: { $literal: "release\\.\\*" },
+          options: "i",
+        },
+      },
+    });
+  });
+
+  it("preserves empty set semantics", () => {
+    expect(
+      createMongoBundleWhere([{ field: "id", operator: "in", value: [] }]),
+    ).toEqual({ $expr: { $in: ["$id", { $literal: [] }] } });
+    expect(
+      createMongoBundleWhere([{ field: "id", operator: "not_in", value: [] }]),
+    ).toEqual({
+      $expr: { $not: [{ $in: ["$id", { $literal: [] }] }] },
+    });
+  });
+});

package/src/adapters/mongodb.ts

@@ -1,302 +1,74 @@
-import { NIL_UUID } from "@hot-updater/core";
-import type {
-  Bundle,
-  DatabaseBundleQueryOptions,
-  DatabaseBundleQueryWhere,
-} from "@hot-updater/plugin-core";
+import { createDatabasePlugin } from "@hot-updater/plugin-core";
 import {
-  calculatePagination,
-  createDatabasePlugin,
-  filterCompatibleAppVersions,
-  resolveUpdateInfoFromBundles,
-} from "@hot-updater/plugin-core";
-import type { ClientSession, Collection, Filter, MongoClient } from "mongodb";
+  createDatabasePluginAdapter,
+  type DatabasePluginImplementation,
+  type TransactionDatabasePluginImplementation,
+} from "@hot-updater/plugin-core/internal";
+import type { ClientSession, MongoClient } from "mongodb";
 
-import {
-  bundleToPatchRows,
-  bundleToRow,
-  type BundlePatchRow,
-  type BundleRow,
-  rowToBundle,
-} from "../db/bundleRows";
 import { createMongoMigrator } from "../db/fixedMigrator";
-import type { DatabasePluginFactory } from "../db/types";
+import type { DatabaseAdapterWithCapabilities } from "../db/types";
+import { createMongoCollections } from "./mongodbCollections";
+import { createMongoReads } from "./mongodbReads";
+import { createMongoWrites } from "./mongodbWrites";
 
 export interface MongoDBConfig {
   readonly client: MongoClient;
+  readonly transactions?: boolean;
 }
 
-const mongoWhere = (
-  where: DatabaseBundleQueryWhere | undefined,
-): Filter<BundleRow> => {
-  const baseFilter: Filter<BundleRow> = {
-    ...(where?.channel !== undefined ? { channel: where.channel } : {}),
-    ...(where?.platform !== undefined ? { platform: where.platform } : {}),
-    ...(where?.enabled !== undefined ? { enabled: where.enabled } : {}),
-    ...(where?.fingerprintHash !== undefined
-      ? where.fingerprintHash === null
-        ? { fingerprint_hash: { $in: [null, ""] } }
-        : { fingerprint_hash: where.fingerprintHash }
-      : {}),
-    ...(where?.id
-      ? {
-          id: {
-            ...(where.id.eq !== undefined ? { $eq: where.id.eq } : {}),
-            ...(where.id.gt !== undefined ? { $gt: where.id.gt } : {}),
-            ...(where.id.gte !== undefined ? { $gte: where.id.gte } : {}),
-            ...(where.id.lt !== undefined ? { $lt: where.id.lt } : {}),
-            ...(where.id.lte !== undefined ? { $lte: where.id.lte } : {}),
-            ...(where.id.in !== undefined ? { $in: where.id.in } : {}),
-          },
-        }
-      : {}),
+const createMongoImplementation = (
+  client: MongoClient,
+  session?: ClientSession,
+): DatabasePluginImplementation => {
+  const collections = createMongoCollections(client);
+  return {
+    ...createMongoWrites(collections, session),
+    ...createMongoReads(collections, session),
   };
-  const targetAppVersionFilters: Filter<BundleRow>[] = [];
-  if (where?.targetAppVersion !== undefined) {
-    targetAppVersionFilters.push(
-      where.targetAppVersion === null
-        ? { target_app_version: { $in: [null, ""] } }
-        : { target_app_version: where.targetAppVersion },
-    );
-  }
-  if (where?.targetAppVersionIn) {
-    targetAppVersionFilters.push({
-      target_app_version: { $in: where.targetAppVersionIn },
-    });
-  }
-  if (where?.targetAppVersionNotNull) {
-    targetAppVersionFilters.push({
-      target_app_version: { $exists: true, $nin: [null, ""] },
-    });
-  }
-
-  const filters = [
-    ...(Object.keys(baseFilter).length > 0 ? [baseFilter] : []),
-    ...targetAppVersionFilters,
-  ];
-  if (filters.length === 0) return {};
-  if (filters.length === 1) return filters[0] ?? {};
-  return { $and: filters };
 };
 
-const createMongoPlugin = createDatabasePlugin<MongoDBConfig>({
-  name: "mongodb",
-  factory: ({ client }) => {
-    const db = client.db();
-    const bundles = db.collection<BundleRow>("bundles");
-    const patches = db.collection<BundlePatchRow>("bundle_patches");
-    const fetchPatchMap = async (bundleIds: readonly string[]) => {
-      const patchMap = new Map<string, BundlePatchRow[]>();
-      if (bundleIds.length === 0) return patchMap;
-      const rows = await patches
-        .find({ bundle_id: { $in: [...bundleIds] } })
-        .sort({ order_index: 1 })
-        .toArray();
-      for (const row of rows) {
-        const current = patchMap.get(row.bundle_id) ?? [];
-        current.push(row);
-        patchMap.set(row.bundle_id, current);
-      }
-      return patchMap;
-    };
-    const mapRowsToBundles = async (
-      rows: readonly BundleRow[],
-    ): Promise<Bundle[]> => {
-      const patchMap = await fetchPatchMap(rows.map((row) => row.id));
-      return rows.map((row) => rowToBundle(row, patchMap.get(row.id) ?? []));
-    };
-    const isTransactionUnsupported = (error: unknown): boolean =>
-      error instanceof Error &&
-      /Transaction numbers are only allowed|replica set member or mongos|Transaction API error/i.test(
-        error.message,
-      );
-    const runInTransaction = async <T>(
-      operation: (session: ClientSession | undefined) => Promise<T>,
-    ) => {
-      if (typeof client.startSession !== "function") {
-        return operation(undefined);
-      }
-      const session = client.startSession();
-      try {
-        if (typeof session.withTransaction !== "function") {
-          return await operation(session);
-        }
-        let result: T | undefined;
-        await session.withTransaction(async () => {
-          result = await operation(session);
-        });
-        return result as T;
-      } catch (error) {
-        if (isTransactionUnsupported(error)) {
-          return operation(undefined);
-        }
-        throw error;
-      } finally {
-        await session.endSession();
-      }
-    };
-    const replaceBundle = async (
-      bundle: Bundle,
-      session: ClientSession | undefined,
-    ) => {
-      const row = bundleToRow(bundle);
-      await bundles.updateOne(
-        { id: bundle.id },
-        { $set: row },
-        { session, upsert: true },
-      );
-      await patches.deleteMany({ bundle_id: bundle.id }, { session });
-      const patchRows = bundleToPatchRows(bundle);
-      if (patchRows.length > 0)
-        await patches.insertMany(patchRows, { session });
-    };
-    const deleteByBundleId = async (
-      collection: Collection<BundlePatchRow>,
-      field: "bundle_id" | "base_bundle_id",
-      bundleId: string,
-      session: ClientSession | undefined,
-    ) => {
-      await collection.deleteMany({ [field]: bundleId }, { session });
-    };
-    return {
-      async getBundleById(bundleId) {
-        const row = await bundles.findOne({ id: bundleId });
-        if (!row) return null;
-        const patchMap = await fetchPatchMap([bundleId]);
-        return rowToBundle(row, patchMap.get(bundleId) ?? []);
-      },
-      async getBundles(
-        options: DatabaseBundleQueryOptions & { offset?: number },
-      ) {
-        const offset = options.offset ?? 0;
-        const orderBy = options.orderBy ?? { field: "id", direction: "desc" };
-        const where = mongoWhere(options.where);
-        const [total, rows] = await Promise.all([
-          bundles.countDocuments(where),
-          bundles
-            .find(where)
-            .sort({ id: orderBy.direction === "asc" ? 1 : -1 })
-            .skip(offset)
-            .limit(options.limit)
-            .toArray(),
-        ]);
-        const patchMap = await fetchPatchMap(rows.map((row) => row.id));
-        return {
-          data: rows.map((row) => rowToBundle(row, patchMap.get(row.id) ?? [])),
-          pagination: calculatePagination(total, {
-            limit: options.limit,
-            offset,
-          }),
-        };
-      },
-      async getUpdateInfo(args, context) {
-        if (args._updateStrategy === "appVersion") {
-          const channel = args.channel ?? "production";
-          const minBundleId = args.minBundleId ?? NIL_UUID;
-          const rows = await bundles
-            .find({
-              enabled: true,
-              platform: args.platform,
-              channel,
-              id: { $gte: minBundleId },
-              target_app_version: { $exists: true, $nin: [null, ""] },
-            })
-            .project<{ target_app_version?: string | null }>({
-              target_app_version: 1,
-            })
-            .toArray();
-
-          const targetAppVersions = Array.from(
-            new Set(
-              rows
-                .map((row) => row.target_app_version)
-                .filter(
-                  (value): value is string =>
-                    typeof value === "string" && value.length > 0,
-                ),
-            ),
-          );
-          const compatibleAppVersions = filterCompatibleAppVersions(
-            targetAppVersions,
-            args.appVersion,
-          );
-          const updateRows =
-            compatibleAppVersions.length > 0
-              ? await bundles
-                  .find({
-                    enabled: true,
-                    platform: args.platform,
-                    channel,
-                    id: { $gte: minBundleId },
-                    target_app_version: { $in: compatibleAppVersions },
-                  })
-                  .sort({ id: -1 })
-                  .toArray()
-              : [];
-
-          return resolveUpdateInfoFromBundles({
-            args: { ...args, channel, minBundleId },
-            bundles: await mapRowsToBundles(updateRows),
-            context,
-          });
-        }
-
-        const channel = args.channel ?? "production";
-        const minBundleId = args.minBundleId ?? NIL_UUID;
-        const rows = await bundles
-          .find({
-            enabled: true,
-            platform: args.platform,
-            channel,
-            id: { $gte: minBundleId },
-            fingerprint_hash: args.fingerprintHash,
-          })
-          .sort({ id: -1 })
-          .toArray();
-
-        return resolveUpdateInfoFromBundles({
-          args: { ...args, channel, minBundleId },
-          bundles: await mapRowsToBundles(rows),
-          context,
-        });
-      },
-      async getChannels() {
-        const channels = await bundles.distinct("channel");
-        return channels
-          .filter((channel): channel is string => typeof channel === "string")
-          .sort((left, right) => left.localeCompare(right));
-      },
-      async commitBundle({ changedSets }) {
-        await runInTransaction(async (session) => {
-          for (const change of changedSets) {
-            if (change.operation === "delete") {
-              await deleteByBundleId(
-                patches,
-                "bundle_id",
-                change.data.id,
-                session,
-              );
-              await deleteByBundleId(
-                patches,
-                "base_bundle_id",
-                change.data.id,
-                session,
-              );
-              await bundles.deleteMany({ id: change.data.id }, { session });
-              continue;
-            }
-            await replaceBundle(change.data, session);
-          }
-        });
-      },
-    };
-  },
+const createTransactionalMongoImplementation = (
+  client: MongoClient,
+): DatabasePluginImplementation => ({
+  ...createMongoImplementation(client),
+  deleteChannel: (input) =>
+    client.withSession((session) =>
+      session.withTransaction(() =>
+        createMongoImplementation(client, session).deleteChannel(input),
+      ),
+    ),
+  transaction: <TResult>(
+    callback: (
+      transaction: TransactionDatabasePluginImplementation,
+    ) => Promise<TResult>,
+  ): Promise<TResult> =>
+    client.withSession((session) =>
+      session.withTransaction(() =>
+        callback(createMongoImplementation(client, session)),
+      ),
+    ),
 });
 
-export const mongoAdapter = (config: MongoDBConfig): DatabasePluginFactory => {
-  return Object.assign(createMongoPlugin(config), {
-    adapterName: "mongodb",
-    provider: "mongodb" as const,
-    createMigrator: () => createMongoMigrator(config.client),
-  });
+export const mongoAdapter = (
+  config: MongoDBConfig,
+): DatabaseAdapterWithCapabilities => {
+  const adapter = createDatabasePluginAdapter(
+    "mongodb",
+    config.transactions === true
+      ? createTransactionalMongoImplementation(config.client)
+      : createMongoImplementation(config.client),
+  );
+  return Object.assign(
+    createDatabasePlugin({
+      name: "mongodb",
+      models: adapter.models,
+      commit: adapter.commit,
+    }),
+    {
+      adapterName: "mongodb",
+      provider: "mongodb" as const,
+      createMigrator: () => createMongoMigrator(config.client),
+    },
+  );
 };

package/src/adapters/mongodbCollections.ts

@@ -0,0 +1,62 @@
+import type {
+  BundleEventRow,
+  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 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"),
+    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 };