@hot-updater/server 0.33.2 → 0.35.0

package/src/adapters/kysely.ts

@@ -1,24 +1,359 @@
-import { kyselyAdapter as fumadbKyselyAdapter } from "fumadb/adapters/kysely";
+import { NIL_UUID } from "@hot-updater/core";
+import type {
+  Bundle,
+  DatabaseBundleQueryOptions,
+  DatabaseBundleQueryWhere,
+} from "@hot-updater/plugin-core";
+import {
+  calculatePagination,
+  createDatabasePlugin,
+  filterCompatibleAppVersions,
+  resolveUpdateInfoFromBundles,
+} from "@hot-updater/plugin-core";
+import type { Kysely, Transaction } from "kysely";
 
-import type { ORMDatabaseAdapter } from "../db/types";
+import {
+  bundleToPatchRows,
+  bundleToRow,
+  type BundlePatchRow,
+  type BundleRow,
+  rowToBundle,
+} from "../db/bundleRows";
+import { createKyselyMigrator } from "../db/fixedMigrator";
+import type {
+  DatabasePluginFactory,
+  ORMSQLProvider,
+  RelationMode,
+} from "../db/types";
 
-export type RelationMode = import("fumadb").RelationMode;
-export type SQLProvider = import("fumadb").SQLProvider;
+type KyselySQLProvider = Exclude<ORMSQLProvider, "mssql">;
 
-export interface KyselyConfig<TDatabase extends object = object> {
-  db: TDatabase;
-  provider: SQLProvider;
-  relationMode?: RelationMode;
+export type { RelationMode, KyselySQLProvider as SQLProvider };
+
+interface Database {
+  readonly bundles: BundleRow;
+  readonly bundle_patches: BundlePatchRow;
+  readonly private_hot_updater_settings: {
+    readonly key: string;
+    readonly value: string;
+  };
+}
+
+export interface KyselyAdapterConfig<TDatabase extends object = Database> {
+  readonly db: Kysely<TDatabase>;
+  readonly provider: KyselySQLProvider;
+  readonly relationMode?: RelationMode;
 }
 
+const assertKyselySQLProvider: (
+  provider: ORMSQLProvider,
+) => asserts provider is KyselySQLProvider = (provider) => {
+  if (provider === "mssql") {
+    throw new Error("Kysely adapter does not support provider: mssql.");
+  }
+};
+
+const applyWhere = <T extends object>(
+  query: T,
+  where: DatabaseBundleQueryWhere | undefined,
+): T => {
+  let next = query as {
+    where: (column: string, op: string, value?: unknown) => unknown;
+  };
+  if (where?.channel !== undefined)
+    next = next.where("channel", "=", where.channel) as typeof next;
+  if (where?.platform !== undefined)
+    next = next.where("platform", "=", where.platform) as typeof next;
+  if (where?.enabled !== undefined)
+    next = next.where("enabled", "=", where.enabled) as typeof next;
+  if (where?.fingerprintHash !== undefined) {
+    next =
+      where.fingerprintHash === null
+        ? (next.where("fingerprint_hash", "is", null) as typeof next)
+        : (next.where(
+            "fingerprint_hash",
+            "=",
+            where.fingerprintHash,
+          ) as typeof next);
+  }
+  if (where?.targetAppVersion !== undefined) {
+    next =
+      where.targetAppVersion === null
+        ? (next.where("target_app_version", "is", null) as typeof next)
+        : (next.where(
+            "target_app_version",
+            "=",
+            where.targetAppVersion,
+          ) as typeof next);
+  }
+  if (where?.targetAppVersionIn) {
+    next = next.where(
+      "target_app_version",
+      "in",
+      where.targetAppVersionIn,
+    ) as typeof next;
+  }
+  if (where?.targetAppVersionNotNull) {
+    next = next.where("target_app_version", "is not", null) as typeof next;
+  }
+  if (where?.id?.eq) next = next.where("id", "=", where.id.eq) as typeof next;
+  if (where?.id?.gt) next = next.where("id", ">", where.id.gt) as typeof next;
+  if (where?.id?.gte)
+    next = next.where("id", ">=", where.id.gte) as typeof next;
+  if (where?.id?.lt) next = next.where("id", "<", where.id.lt) as typeof next;
+  if (where?.id?.lte)
+    next = next.where("id", "<=", where.id.lte) as typeof next;
+  if (where?.id?.in) next = next.where("id", "in", where.id.in) as typeof next;
+  return next as T;
+};
+
+const hasEmptySetFilter = (
+  where: DatabaseBundleQueryWhere | undefined,
+): boolean =>
+  where?.targetAppVersionIn?.length === 0 || where?.id?.in?.length === 0;
+
+const toProviderBundleRow = (
+  row: BundleRow,
+  provider: KyselySQLProvider,
+): BundleRow => {
+  if (provider !== "mysql" && provider !== "sqlite") return row;
+  return {
+    ...row,
+    metadata: JSON.stringify(row.metadata ?? {}),
+    target_cohorts:
+      row.target_cohorts === null || row.target_cohorts === undefined
+        ? null
+        : JSON.stringify(row.target_cohorts),
+  };
+};
+
+const createKyselyPlugin = createDatabasePlugin<KyselyAdapterConfig<Database>>({
+  name: "kysely",
+  factory: ({ db, provider }) => {
+    const fetchPatchMap = async (bundleIds: readonly string[]) => {
+      const patchMap = new Map<string, BundlePatchRow[]>();
+      if (bundleIds.length === 0) return patchMap;
+      const rows = await db
+        .selectFrom("bundle_patches")
+        .selectAll()
+        .where("bundle_id", "in", [...bundleIds])
+        .orderBy("order_index", "asc")
+        .execute();
+      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 upsertBundle = async (
+      executor: Kysely<Database> | Transaction<Database>,
+      bundle: Bundle,
+    ) => {
+      const row = toProviderBundleRow(bundleToRow(bundle), provider);
+      const { id: _id, ...updateRow } = row;
+      if (provider === "mysql") {
+        await executor
+          .insertInto("bundles")
+          .values(row)
+          .onDuplicateKeyUpdate(updateRow)
+          .execute();
+      } else {
+        await executor
+          .insertInto("bundles")
+          .values(row)
+          .onConflict((oc) => oc.column("id").doUpdateSet(updateRow))
+          .execute();
+      }
+      await executor
+        .deleteFrom("bundle_patches")
+        .where("bundle_id", "=", bundle.id)
+        .execute();
+      const patches = bundleToPatchRows(bundle);
+      if (patches.length > 0) {
+        await executor.insertInto("bundle_patches").values(patches).execute();
+      }
+    };
+
+    return {
+      async getBundleById(bundleId) {
+        const row = await db
+          .selectFrom("bundles")
+          .selectAll()
+          .where("id", "=", bundleId)
+          .executeTakeFirst();
+        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;
+        if (hasEmptySetFilter(options.where)) {
+          return {
+            data: [],
+            pagination: calculatePagination(0, {
+              limit: options.limit,
+              offset,
+            }),
+          };
+        }
+        const orderBy = options.orderBy ?? { field: "id", direction: "desc" };
+        const countRow = await applyWhere(
+          db.selectFrom("bundles"),
+          options.where,
+        )
+          .select(db.fn.count<number>("id").as("total"))
+          .executeTakeFirst();
+        const total = Number(countRow?.total ?? 0);
+        const rows = await applyWhere(
+          db.selectFrom("bundles").selectAll(),
+          options.where,
+        )
+          .orderBy("id", orderBy.direction)
+          .limit(options.limit)
+          .offset(offset)
+          .execute();
+        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 db
+            .selectFrom("bundles")
+            .select("target_app_version")
+            .where("enabled", "=", true)
+            .where("platform", "=", args.platform)
+            .where("channel", "=", channel)
+            .where("id", ">=", minBundleId)
+            .where("target_app_version", "is not", null)
+            .execute();
+
+          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 bundles =
+            compatibleAppVersions.length > 0
+              ? await db
+                  .selectFrom("bundles")
+                  .selectAll()
+                  .where("enabled", "=", true)
+                  .where("platform", "=", args.platform)
+                  .where("channel", "=", channel)
+                  .where("id", ">=", minBundleId)
+                  .where("target_app_version", "in", compatibleAppVersions)
+                  .orderBy("id", "desc")
+                  .execute()
+                  .then(mapRowsToBundles)
+              : [];
+
+          return resolveUpdateInfoFromBundles({
+            args: { ...args, channel, minBundleId },
+            bundles,
+            context,
+          });
+        }
+
+        const channel = args.channel ?? "production";
+        const minBundleId = args.minBundleId ?? NIL_UUID;
+        const rows = await db
+          .selectFrom("bundles")
+          .selectAll()
+          .where("enabled", "=", true)
+          .where("platform", "=", args.platform)
+          .where("channel", "=", channel)
+          .where("id", ">=", minBundleId)
+          .where("fingerprint_hash", "=", args.fingerprintHash)
+          .orderBy("id", "desc")
+          .execute();
+
+        return resolveUpdateInfoFromBundles({
+          args: { ...args, channel, minBundleId },
+          bundles: await mapRowsToBundles(rows),
+          context,
+        });
+      },
+      async getChannels() {
+        const rows = await db
+          .selectFrom("bundles")
+          .select("channel")
+          .orderBy("channel", "asc")
+          .execute();
+        return Array.from(new Set(rows.map((row) => row.channel)));
+      },
+      async commitBundle({ changedSets }) {
+        await db.transaction().execute(async (tx) => {
+          for (const change of changedSets) {
+            if (change.operation === "delete") {
+              await tx
+                .deleteFrom("bundle_patches")
+                .where("bundle_id", "=", change.data.id)
+                .execute();
+              await tx
+                .deleteFrom("bundle_patches")
+                .where("base_bundle_id", "=", change.data.id)
+                .execute();
+              await tx
+                .deleteFrom("bundles")
+                .where("id", "=", change.data.id)
+                .execute();
+              continue;
+            }
+            await upsertBundle(tx, change.data);
+          }
+        });
+      },
+    };
+  },
+});
+
 export const kyselyAdapter = <TDatabase extends object>(
-  config: KyselyConfig<TDatabase>,
-): ORMDatabaseAdapter =>
-  Object.assign(
-    fumadbKyselyAdapter(
-      config as unknown as Parameters<typeof fumadbKyselyAdapter>[0],
-    ) as unknown as ORMDatabaseAdapter,
+  config: KyselyAdapterConfig<TDatabase>,
+): DatabasePluginFactory => {
+  assertKyselySQLProvider(config.provider);
+  return Object.assign(
+    createKyselyPlugin(config as unknown as KyselyAdapterConfig<Database>),
     {
+      adapterName: "kysely",
       provider: config.provider,
+      createMigrator: () =>
+        createKyselyMigrator({
+          db: config.db as unknown as Kysely<{
+            private_hot_updater_settings: {
+              key: string;
+              value: string;
+            };
+          }>,
+          provider: config.provider,
+          relationMode: config.relationMode,
+        }),
     },
   );
+};

package/src/adapters/mongodb.ts

@@ -1,19 +1,302 @@
-import { mongoAdapter as fumadbMongoAdapter } from "fumadb/adapters/mongodb";
+import { NIL_UUID } from "@hot-updater/core";
+import type {
+  Bundle,
+  DatabaseBundleQueryOptions,
+  DatabaseBundleQueryWhere,
+} from "@hot-updater/plugin-core";
+import {
+  calculatePagination,
+  createDatabasePlugin,
+  filterCompatibleAppVersions,
+  resolveUpdateInfoFromBundles,
+} from "@hot-updater/plugin-core";
+import type { ClientSession, Collection, Filter, MongoClient } from "mongodb";
 
-import type { ORMDatabaseAdapter } from "../db/types";
+import {
+  bundleToPatchRows,
+  bundleToRow,
+  type BundlePatchRow,
+  type BundleRow,
+  rowToBundle,
+} from "../db/bundleRows";
+import { createMongoMigrator } from "../db/fixedMigrator";
+import type { DatabasePluginFactory } from "../db/types";
 
-export interface MongoDBConfig<TClient extends object = object> {
-  client: TClient;
+export interface MongoDBConfig {
+  readonly client: MongoClient;
 }
 
-export const mongoAdapter = <TClient extends object>(
-  options: MongoDBConfig<TClient>,
-): ORMDatabaseAdapter =>
-  Object.assign(
-    fumadbMongoAdapter(
-      options as unknown as Parameters<typeof fumadbMongoAdapter>[0],
-    ) as unknown as ORMDatabaseAdapter,
-    {
-      provider: "mongodb",
-    },
-  );
+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 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);
+          }
+        });
+      },
+    };
+  },
+});
+
+export const mongoAdapter = (config: MongoDBConfig): DatabasePluginFactory => {
+  return Object.assign(createMongoPlugin(config), {
+    adapterName: "mongodb",
+    provider: "mongodb" as const,
+    createMigrator: () => createMongoMigrator(config.client),
+  });
+};