@hot-updater/server 0.33.2 → 0.35.0

package/src/adapters/prisma.ts

@@ -1,15 +1,340 @@
-import { prismaAdapter as fumadbPrismaAdapter } from "fumadb/adapters/prisma";
+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 { ORMDatabaseAdapter } from "../db/types";
+import {
+  bundleToPatchRows,
+  bundleToRow,
+  type BundlePatchRow,
+  type BundleRow,
+  rowToBundle,
+} from "../db/bundleRows";
+import {
+  getHotUpdaterSchemaVersion,
+  hotUpdaterSchema,
+} from "../db/schema/registry";
+import { generatePrismaSchema } from "../db/schemaGenerators";
+import type {
+  DatabasePluginFactory,
+  ORMProvider,
+  SchemaGenerator,
+} from "../db/types";
 
-export type PrismaConfig = Parameters<typeof fumadbPrismaAdapter>[0];
+type PrismaRelationMode = "prisma" | "foreign-keys";
 
-export const prismaAdapter = (config: PrismaConfig): ORMDatabaseAdapter =>
-  Object.assign(
-    fumadbPrismaAdapter(
-      config as unknown as Parameters<typeof fumadbPrismaAdapter>[0],
-    ) as unknown as ORMDatabaseAdapter,
-    {
-      provider: config.provider,
-    },
-  );
+type PrismaDelegate = {
+  readonly count: (args?: unknown) => Promise<number>;
+  readonly createMany: (args: unknown) => Promise<unknown>;
+  readonly deleteMany: (args?: unknown) => Promise<unknown>;
+  readonly findFirst: (
+    args?: unknown,
+  ) => Promise<Record<string, unknown> | null>;
+  readonly findMany: (args?: unknown) => Promise<Record<string, unknown>[]>;
+  readonly upsert: (args: unknown) => Promise<unknown>;
+};
+
+type PrismaClient = Record<string, unknown> & {
+  readonly $transaction?: <T>(
+    operation: (tx: Record<string, unknown>) => Promise<T>,
+  ) => Promise<T>;
+};
+
+export interface PrismaConfig {
+  readonly prisma: object;
+  readonly provider: ORMProvider;
+  readonly relationMode?: PrismaRelationMode;
+  readonly db?: unknown;
+}
+
+const assertSupportedRelationMode = (
+  relationMode: PrismaRelationMode | undefined,
+) => {
+  if (
+    relationMode &&
+    relationMode !== "prisma" &&
+    relationMode !== "foreign-keys"
+  ) {
+    throw new Error(`Unsupported Prisma relation mode: ${relationMode}`);
+  }
+};
+
+const getDelegate = (
+  prisma: Record<string, unknown>,
+  model: "bundles" | "bundle_patches",
+): PrismaDelegate => {
+  const delegate = prisma[model];
+  if (!delegate || typeof delegate !== "object") {
+    throw new Error(`Prisma client is missing model delegate "${model}".`);
+  }
+  return delegate as PrismaDelegate;
+};
+
+const prismaWhere = (where: DatabaseBundleQueryWhere | undefined) => {
+  const targetAppVersionFilters = [];
+  if (where?.targetAppVersion !== undefined) {
+    targetAppVersionFilters.push({
+      target_app_version: where.targetAppVersion,
+    });
+  }
+  if (where?.targetAppVersionIn) {
+    targetAppVersionFilters.push({
+      target_app_version: { in: where.targetAppVersionIn },
+    });
+  }
+  if (where?.targetAppVersionNotNull) {
+    targetAppVersionFilters.push({
+      target_app_version: { not: null },
+    });
+  }
+
+  return {
+    ...(where?.channel !== undefined ? { channel: where.channel } : {}),
+    ...(where?.platform !== undefined ? { platform: where.platform } : {}),
+    ...(where?.enabled !== undefined ? { enabled: where.enabled } : {}),
+    ...(where?.fingerprintHash !== undefined
+      ? { fingerprint_hash: where.fingerprintHash }
+      : {}),
+    ...(where?.id
+      ? {
+          id: {
+            ...(where.id.eq !== undefined ? { equals: 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 } : {}),
+          },
+        }
+      : {}),
+    ...(targetAppVersionFilters.length > 0
+      ? { AND: targetAppVersionFilters }
+      : {}),
+  };
+};
+
+const createPrismaPlugin = createDatabasePlugin<PrismaConfig>({
+  name: "prisma",
+  factory: (config) => {
+    const prisma = config.prisma as PrismaClient;
+    const runInTransaction = async <T>(
+      operation: (client: Record<string, unknown>) => Promise<T>,
+    ) => {
+      if (typeof prisma.$transaction !== "function") {
+        return operation(prisma);
+      }
+      return prisma.$transaction(operation);
+    };
+    const fetchPatchMap = async (bundleIds: readonly string[]) => {
+      const patches = getDelegate(prisma, "bundle_patches");
+      const patchMap = new Map<string, BundlePatchRow[]>();
+      if (bundleIds.length === 0) return patchMap;
+      const rows = await patches.findMany({
+        where: { bundle_id: { in: [...bundleIds] } },
+        orderBy: { order_index: "asc" },
+      });
+      for (const row of rows) {
+        const patch = row as BundlePatchRow;
+        const current = patchMap.get(patch.bundle_id) ?? [];
+        current.push(patch);
+        patchMap.set(patch.bundle_id, current);
+      }
+      return patchMap;
+    };
+    const mapRowsToBundles = async (
+      rows: readonly Record<string, unknown>[],
+    ): Promise<Bundle[]> => {
+      const patchMap = await fetchPatchMap(
+        rows.map((row) => String(row["id"])),
+      );
+      return rows.map((row) =>
+        rowToBundle(row as BundleRow, patchMap.get(String(row["id"])) ?? []),
+      );
+    };
+    const upsertBundle = async (
+      client: Record<string, unknown>,
+      bundle: Bundle,
+    ) => {
+      const bundles = getDelegate(client, "bundles");
+      const patches = getDelegate(client, "bundle_patches");
+      const row = bundleToRow(bundle);
+      const { id, ...update } = row;
+      await bundles.upsert({
+        where: { id },
+        create: row,
+        update,
+      });
+      await patches.deleteMany({ where: { bundle_id: id } });
+      const patchRows = bundleToPatchRows(bundle);
+      if (patchRows.length > 0) {
+        await patches.createMany({ data: patchRows });
+      }
+    };
+    return {
+      async getBundleById(bundleId) {
+        const bundles = getDelegate(prisma, "bundles");
+        const row = await bundles.findFirst({ where: { id: bundleId } });
+        if (!row) return null;
+        const patchMap = await fetchPatchMap([bundleId]);
+        return rowToBundle(row as BundleRow, patchMap.get(bundleId) ?? []);
+      },
+      async getBundles(
+        options: DatabaseBundleQueryOptions & { offset?: number },
+      ) {
+        const bundles = getDelegate(prisma, "bundles");
+        const offset = options.offset ?? 0;
+        const orderBy = options.orderBy ?? { field: "id", direction: "desc" };
+        const where = prismaWhere(options.where);
+        const [total, rows] = await Promise.all([
+          bundles.count({ where }),
+          bundles.findMany({
+            where,
+            orderBy: { id: orderBy.direction },
+            skip: offset,
+            take: options.limit,
+          }),
+        ]);
+        const patchMap = await fetchPatchMap(
+          rows.map((row) => String(row["id"])),
+        );
+        return {
+          data: rows.map((row) =>
+            rowToBundle(
+              row as BundleRow,
+              patchMap.get(String(row["id"])) ?? [],
+            ),
+          ),
+          pagination: calculatePagination(total, {
+            limit: options.limit,
+            offset,
+          }),
+        };
+      },
+      async getUpdateInfo(args, context) {
+        const bundles = getDelegate(prisma, "bundles");
+
+        if (args._updateStrategy === "appVersion") {
+          const channel = args.channel ?? "production";
+          const minBundleId = args.minBundleId ?? NIL_UUID;
+          const rows = await bundles.findMany({
+            select: { target_app_version: true },
+            where: {
+              enabled: true,
+              platform: args.platform,
+              channel,
+              id: { gte: minBundleId },
+              target_app_version: { not: null },
+            },
+          });
+
+          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 updateBundles =
+            compatibleAppVersions.length > 0
+              ? await bundles
+                  .findMany({
+                    where: {
+                      enabled: true,
+                      platform: args.platform,
+                      channel,
+                      id: { gte: minBundleId },
+                      target_app_version: { in: compatibleAppVersions },
+                    },
+                    orderBy: { id: "desc" },
+                  })
+                  .then(mapRowsToBundles)
+              : [];
+
+          return resolveUpdateInfoFromBundles({
+            args: { ...args, channel, minBundleId },
+            bundles: updateBundles,
+            context,
+          });
+        }
+
+        const channel = args.channel ?? "production";
+        const minBundleId = args.minBundleId ?? NIL_UUID;
+        const rows = await bundles.findMany({
+          where: {
+            enabled: true,
+            platform: args.platform,
+            channel,
+            id: { gte: minBundleId },
+            fingerprint_hash: args.fingerprintHash,
+          },
+          orderBy: { id: "desc" },
+        });
+
+        return resolveUpdateInfoFromBundles({
+          args: { ...args, channel, minBundleId },
+          bundles: await mapRowsToBundles(rows),
+          context,
+        });
+      },
+      async getChannels() {
+        const bundles = getDelegate(prisma, "bundles");
+        const rows = await bundles.findMany({
+          select: { channel: true },
+          orderBy: { channel: "asc" },
+        });
+        return Array.from(new Set(rows.map((row) => String(row["channel"]))));
+      },
+      async commitBundle({ changedSets }) {
+        await runInTransaction(async (client) => {
+          const bundles = getDelegate(client, "bundles");
+          const patches = getDelegate(client, "bundle_patches");
+          for (const change of changedSets) {
+            if (change.operation === "delete") {
+              await patches.deleteMany({
+                where: { bundle_id: change.data.id },
+              });
+              await patches.deleteMany({
+                where: { base_bundle_id: change.data.id },
+              });
+              await bundles.deleteMany({ where: { id: change.data.id } });
+              continue;
+            }
+            await upsertBundle(client, change.data);
+          }
+        });
+      },
+    };
+  },
+});
+
+export const prismaAdapter = (config: PrismaConfig): DatabasePluginFactory => {
+  assertSupportedRelationMode(config.relationMode);
+  return Object.assign(createPrismaPlugin(config), {
+    adapterName: "prisma",
+    provider: config.provider,
+    generateSchema: (version: Parameters<SchemaGenerator>[0]) => ({
+      code: generatePrismaSchema(
+        config.provider,
+        version === "latest"
+          ? hotUpdaterSchema
+          : getHotUpdaterSchemaVersion(version),
+      ),
+      path: "./prisma/schema/hot_updater.prisma",
+    }),
+  });
+};

package/src/createHotUpdaterCore.ts

@@ -0,0 +1,168 @@
+import type {
+  DatabasePlugin,
+  HotUpdaterContext,
+  RuntimeStoragePlugin,
+} from "@hot-updater/plugin-core";
+import { assertRuntimeStoragePlugin } from "@hot-updater/plugin-core";
+
+import { createPluginDatabaseCore } from "./db/pluginCore";
+import { createSchemaReadinessChecker } from "./db/schemaReadiness";
+import {
+  type DatabaseAdapter,
+  type DatabaseAdapterCapabilities,
+  type DatabaseAPI,
+  isDatabasePlugin,
+  isDatabasePluginFactory,
+  type StoragePluginFactory,
+} from "./db/types";
+import { createHandler, type HandlerRoutes } from "./handler";
+import { normalizeBasePath } from "./route";
+import { createStorageAccess } from "./storageAccess";
+
+export type RuntimeHotUpdaterAPI<TContext = unknown> = DatabaseAPI<TContext> & {
+  readonly basePath: string;
+  readonly handler: (
+    request: Request,
+    context?: HotUpdaterContext<TContext>,
+  ) => Promise<Response>;
+  readonly adapterName: string;
+};
+
+export type HotUpdaterAPI<TContext = unknown> = RuntimeHotUpdaterAPI<TContext>;
+
+export interface CreateHotUpdaterOptions<TContext = unknown> {
+  readonly database: DatabaseAdapter<TContext>;
+  readonly storages?: readonly (
+    | RuntimeStoragePlugin<TContext>
+    | StoragePluginFactory<TContext>
+  )[];
+  /**
+   * @deprecated Use `storages` instead. This field will be removed in a future version.
+   */
+  readonly storagePlugins?: readonly (
+    | RuntimeStoragePlugin<TContext>
+    | StoragePluginFactory<TContext>
+  )[];
+  readonly basePath?: string;
+  readonly cwd?: string;
+  readonly routes?: HandlerRoutes;
+}
+
+type PluginDatabaseCore<TContext> = {
+  readonly api: DatabaseAPI<TContext>;
+  readonly adapterName: string;
+  readonly createMigrator: () => never;
+  readonly generateSchema: () => never;
+};
+
+export const hotUpdaterCoreMetadata = Symbol.for(
+  "@hot-updater/server/core-metadata",
+);
+
+export type HotUpdaterCoreMetadata<TContext = unknown> = {
+  readonly adapterCapabilities: DatabaseAdapterCapabilities;
+  readonly core: PluginDatabaseCore<TContext>;
+};
+
+export type HotUpdaterCore<TContext = unknown> = {
+  readonly api: RuntimeHotUpdaterAPI<TContext>;
+  readonly adapterCapabilities: DatabaseAdapterCapabilities;
+  readonly core: PluginDatabaseCore<TContext>;
+};
+
+export function getHotUpdaterCoreMetadata<TContext = unknown>(
+  hotUpdater: RuntimeHotUpdaterAPI<TContext>,
+): HotUpdaterCoreMetadata<TContext> | undefined {
+  return (
+    hotUpdater as RuntimeHotUpdaterAPI<TContext> & {
+      readonly [hotUpdaterCoreMetadata]?: HotUpdaterCoreMetadata<TContext>;
+    }
+  )[hotUpdaterCoreMetadata];
+}
+
+export function createHotUpdaterCore<TContext = unknown>(
+  options: CreateHotUpdaterOptions<TContext>,
+): HotUpdaterCore<TContext> {
+  const database = options.database;
+  const basePath = normalizeBasePath(options.basePath ?? "/api");
+  const storagePlugins = (options.storages ?? options.storagePlugins ?? []).map(
+    (plugin) => {
+      const storagePlugin = typeof plugin === "function" ? plugin() : plugin;
+      assertRuntimeStoragePlugin(storagePlugin);
+      return storagePlugin;
+    },
+  );
+  const { readStorageText, resolveFileUrl } =
+    createStorageAccess(storagePlugins);
+
+  if (!isDatabasePluginFactory(database) && !isDatabasePlugin(database)) {
+    throw new Error("@hot-updater/server only supports database plugins.");
+  }
+
+  const adapterCapabilities = database as DatabaseAdapterCapabilities;
+  const plugin: DatabasePlugin<TContext> = isDatabasePluginFactory(database)
+    ? database()
+    : database;
+  const adapterName = adapterCapabilities.adapterName ?? plugin.name;
+  const assertSchemaReady = createSchemaReadinessChecker(
+    adapterName,
+    adapterCapabilities.createMigrator,
+  );
+  const core = createPluginDatabaseCore<TContext>(
+    () => plugin,
+    resolveFileUrl,
+    isDatabasePluginFactory(database)
+      ? {
+          createMutationPlugin: () => database(),
+          beforeOperation: assertSchemaReady,
+          readStorageText,
+        }
+      : { beforeOperation: assertSchemaReady, readStorageText },
+  );
+
+  const internalHandler = createHandler(core.api, {
+    basePath,
+    routes: options.routes,
+  });
+
+  // Some framework adapters strip the mounted base path or pass extra
+  // bindings/execution context arguments. Ignore those extras here so the
+  // handler can still be mounted directly as a plain Request handler.
+  const handler: RuntimeHotUpdaterAPI<TContext>["handler"] = (
+    request,
+    context,
+    ...extraArgs: unknown[]
+  ) => {
+    if (extraArgs.length > 0) {
+      return internalHandler(request);
+    }
+
+    return internalHandler(request, context);
+  };
+
+  const api = {
+    basePath,
+    adapterName: adapterCapabilities.adapterName ?? core.adapterName,
+    handler,
+  };
+  Object.defineProperties(api, Object.getOwnPropertyDescriptors(core.api));
+  Object.defineProperty(api, hotUpdaterCoreMetadata, {
+    enumerable: false,
+    value: {
+      adapterCapabilities,
+      core,
+    } satisfies HotUpdaterCoreMetadata<TContext>,
+  });
+
+  return {
+    api: api as RuntimeHotUpdaterAPI<TContext>,
+    adapterCapabilities,
+    core,
+  };
+}
+
+export function createHotUpdater<TContext = unknown>(
+  options: CreateHotUpdaterOptions<TContext>,
+): RuntimeHotUpdaterAPI<TContext> {
+  return createHotUpdaterCore(options).api;
+}

package/src/db/bundleRows.ts

@@ -0,0 +1,140 @@
+import type { Bundle, BundlePatchArtifact, Platform } from "@hot-updater/core";
+import {
+  DEFAULT_ROLLOUT_COHORT_COUNT,
+  getAssetBaseStorageUri,
+  getBundlePatches,
+  getManifestFileHash,
+  getManifestStorageUri,
+  stripBundleArtifactMetadata,
+} from "@hot-updater/core";
+
+import { parseBundleMetadata } from "./updateArtifacts";
+
+export type BundleRow = {
+  readonly id: string;
+  readonly platform: string;
+  readonly should_force_update: unknown;
+  readonly enabled: unknown;
+  readonly file_hash: string;
+  readonly git_commit_hash: string | null;
+  readonly message: string | null;
+  readonly channel: string;
+  readonly storage_uri: string;
+  readonly target_app_version: string | null;
+  readonly fingerprint_hash: string | null;
+  readonly metadata?: unknown;
+  readonly manifest_storage_uri?: string | null;
+  readonly manifest_file_hash?: string | null;
+  readonly asset_base_storage_uri?: string | null;
+  readonly rollout_cohort_count?: number | null;
+  readonly target_cohorts?: unknown;
+};
+
+export type BundlePatchRow = {
+  readonly id: string;
+  readonly bundle_id: string;
+  readonly base_bundle_id: string;
+  readonly base_file_hash: string;
+  readonly patch_file_hash: string;
+  readonly patch_storage_uri: string;
+  readonly order_index?: number | null;
+};
+
+const parseTargetCohorts = (value: unknown): string[] | null => {
+  if (!value) return null;
+  if (Array.isArray(value)) {
+    return value.filter((item): item is string => typeof item === "string");
+  }
+  if (typeof value !== "string") return null;
+  try {
+    const parsed = JSON.parse(value) as unknown;
+    return Array.isArray(parsed)
+      ? parsed.filter((item): item is string => typeof item === "string")
+      : null;
+  } catch {
+    return null;
+  }
+};
+
+const buildBundlePatchId = (bundleId: string, baseBundleId: string) =>
+  `${bundleId}:${baseBundleId}`;
+
+export const bundleToRow = (bundle: Bundle): BundleRow => ({
+  id: bundle.id,
+  platform: bundle.platform,
+  should_force_update: bundle.shouldForceUpdate,
+  enabled: bundle.enabled,
+  file_hash: bundle.fileHash,
+  git_commit_hash: bundle.gitCommitHash,
+  message: bundle.message,
+  channel: bundle.channel,
+  storage_uri: bundle.storageUri,
+  target_app_version: bundle.targetAppVersion,
+  fingerprint_hash: bundle.fingerprintHash,
+  metadata: stripBundleArtifactMetadata(bundle.metadata) ?? {},
+  manifest_storage_uri: getManifestStorageUri(bundle),
+  manifest_file_hash: getManifestFileHash(bundle),
+  asset_base_storage_uri: getAssetBaseStorageUri(bundle),
+  rollout_cohort_count:
+    bundle.rolloutCohortCount ?? DEFAULT_ROLLOUT_COHORT_COUNT,
+  target_cohorts: bundle.targetCohorts ?? null,
+});
+
+export const bundleToPatchRows = (bundle: Bundle): BundlePatchRow[] =>
+  getBundlePatches(bundle).map((patch, index) => ({
+    id: buildBundlePatchId(bundle.id, patch.baseBundleId),
+    bundle_id: bundle.id,
+    base_bundle_id: patch.baseBundleId,
+    base_file_hash: patch.baseFileHash,
+    patch_file_hash: patch.patchFileHash,
+    patch_storage_uri: patch.patchStorageUri,
+    order_index: index,
+  }));
+
+const mapPatchRowToPatch = (record: BundlePatchRow): BundlePatchArtifact => ({
+  baseBundleId: record.base_bundle_id,
+  baseFileHash: record.base_file_hash,
+  patchFileHash: record.patch_file_hash,
+  patchStorageUri: record.patch_storage_uri,
+});
+
+export const rowToBundle = (
+  record: BundleRow,
+  patchRecords: readonly BundlePatchRow[] = [],
+): Bundle => {
+  const patches = patchRecords
+    .slice()
+    .sort(
+      (left, right) =>
+        (left.order_index ?? 0) - (right.order_index ?? 0) ||
+        left.base_bundle_id.localeCompare(right.base_bundle_id),
+    )
+    .map(mapPatchRowToPatch);
+  const primaryPatch = patches[0] ?? null;
+
+  return {
+    id: record.id,
+    platform: record.platform as Platform,
+    shouldForceUpdate: Boolean(record.should_force_update),
+    enabled: Boolean(record.enabled),
+    fileHash: record.file_hash,
+    gitCommitHash: record.git_commit_hash ?? null,
+    message: record.message ?? null,
+    channel: record.channel,
+    storageUri: record.storage_uri,
+    targetAppVersion: record.target_app_version ?? null,
+    fingerprintHash: record.fingerprint_hash ?? null,
+    metadata: parseBundleMetadata(record.metadata),
+    manifestStorageUri: record.manifest_storage_uri ?? null,
+    manifestFileHash: record.manifest_file_hash ?? null,
+    assetBaseStorageUri: record.asset_base_storage_uri ?? null,
+    patches,
+    patchBaseBundleId: primaryPatch?.baseBundleId ?? null,
+    patchBaseFileHash: primaryPatch?.baseFileHash ?? null,
+    patchFileHash: primaryPatch?.patchFileHash ?? null,
+    patchStorageUri: primaryPatch?.patchStorageUri ?? null,
+    rolloutCohortCount:
+      record.rollout_cohort_count ?? DEFAULT_ROLLOUT_COHORT_COUNT,
+    targetCohorts: parseTargetCohorts(record.target_cohorts),
+  };
+};