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

package/src/adapters/prisma.ts

@@ -1,340 +1,465 @@
-import { NIL_UUID } from "@hot-updater/core";
-import type {
-  Bundle,
-  DatabaseBundleQueryOptions,
-  DatabaseBundleQueryWhere,
-} from "@hot-updater/plugin-core";
 import {
-  calculatePagination,
   createDatabasePlugin,
-  filterCompatibleAppVersions,
-  resolveUpdateInfoFromBundles,
+  DatabasePluginInputError,
 } from "@hot-updater/plugin-core";
-
 import {
-  bundleToPatchRows,
-  bundleToRow,
-  type BundlePatchRow,
-  type BundleRow,
-  rowToBundle,
-} from "../db/bundleRows";
+  createDatabasePluginAdapter,
+  type DatabaseImplementationResult,
+  type DatabasePluginImplementation,
+  type FindManyDatabaseImplementationInput,
+  type TransactionDatabasePluginImplementation,
+} from "@hot-updater/plugin-core/internal";
+
 import {
   getHotUpdaterSchemaVersion,
   hotUpdaterSchema,
 } from "../db/schema/registry";
 import { generatePrismaSchema } from "../db/schemaGenerators";
 import type {
-  DatabasePluginFactory,
+  DatabaseAdapterWithCapabilities,
   ORMProvider,
+  ORMSQLProvider,
   SchemaGenerator,
 } from "../db/types";
+import {
+  isChannelDeleteReferencedError,
+  translateChannelDeleteError,
+} from "./databaseConstraintErrors";
+import { hasNullOrderOverrides, sortRowsByOrder } from "./databasePluginUtils";
+import { createPrismaOrderBy, createPrismaWhere } from "./prismaQuery";
+import {
+  getPrismaDelegate,
+  parsePrismaBundleEventRow,
+  parsePrismaBundleRow,
+  parsePrismaChannelRow,
+  parsePrismaApiKeyRow,
+  parsePrismaPatchRow,
+  parsePrismaReleaseCatalogRow,
+  parsePrismaReleaseRow,
+  parsePrismaRows,
+  PrismaAdapterError,
+} from "./prismaRows";
 
 type PrismaRelationMode = "prisma" | "foreign-keys";
 
-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 PrismaTransactionOptions = {
+  readonly isolationLevel: "Serializable";
 };
 
-type PrismaClient = Record<string, unknown> & {
-  readonly $transaction?: <T>(
-    operation: (tx: Record<string, unknown>) => Promise<T>,
-  ) => Promise<T>;
+type PrismaTransactionClient = object & {
+  readonly $transaction: <TResult>(
+    callback: (client: object) => Promise<TResult>,
+    options?: PrismaTransactionOptions,
+  ) => Promise<TResult>;
 };
 
 export interface PrismaConfig {
   readonly prisma: object;
-  readonly provider: ORMProvider;
+  readonly provider: ORMSQLProvider;
   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 hasCallbackTransaction = (
+  client: object,
+): client is PrismaTransactionClient =>
+  "$transaction" in client && typeof client.$transaction === "function";
+
+const runPrismaTransaction = <TResult>(
+  client: PrismaTransactionClient,
+  isolationLevel: "default" | "serializable",
+  callback: (client: object) => Promise<TResult>,
+): Promise<TResult> => {
+  const execute = () =>
+    isolationLevel === "serializable"
+      ? client.$transaction(callback, { isolationLevel: "Serializable" })
+      : client.$transaction(callback);
+  if (isolationLevel === "default") return execute();
+
+  return (async () => {
+    for (let attempt = 0; ; attempt += 1) {
+      try {
+        return await execute();
+      } catch (error) {
+        if (
+          attempt >= 2 ||
+          typeof error !== "object" ||
+          error === null ||
+          !("code" in error) ||
+          error.code !== "P2034"
+        ) {
+          throw error;
+        }
+      }
+    }
+  })();
 };
 
-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}".`);
+const assertPrismaProvider = (provider: ORMProvider): void => {
+  if (provider === "mongodb") {
+    throw new PrismaAdapterError(
+      "Prisma adapter does not support MongoDB; use mongodbAdapter instead",
+    );
   }
-  return delegate as PrismaDelegate;
 };
 
-const prismaWhere = (where: DatabaseBundleQueryWhere | undefined) => {
-  const targetAppVersionFilters = [];
-  if (where?.targetAppVersion !== undefined) {
-    targetAppVersionFilters.push({
-      target_app_version: where.targetAppVersion,
-    });
+const findMany = async (
+  client: object,
+  input: FindManyDatabaseImplementationInput,
+  provider: ORMSQLProvider,
+): Promise<readonly DatabaseImplementationResult[]> => {
+  if (input.distinctOn !== undefined) {
+    throw new DatabasePluginInputError("invalid-operation");
   }
-  if (where?.targetAppVersionIn) {
-    targetAppVersionFilters.push({
-      target_app_version: { in: where.targetAppVersionIn },
-    });
-  }
-  if (where?.targetAppVersionNotNull) {
-    targetAppVersionFilters.push({
-      target_app_version: { not: null },
-    });
+  const rawOrderBy = input.orderBy;
+  const orderBy = createPrismaOrderBy(rawOrderBy);
+  const shouldSortInMemory =
+    rawOrderBy !== undefined && hasNullOrderOverrides(rawOrderBy);
+  const rows = shouldSortInMemory
+    ? sortRowsByOrder(
+        (await getPrismaDelegate(client, input.model).findMany({
+          where: createPrismaWhere(input.where, provider),
+        })) as Record<string, unknown>[],
+        rawOrderBy,
+      ).slice(input.offset, input.offset + input.limit)
+    : await getPrismaDelegate(client, input.model).findMany({
+        where: createPrismaWhere(input.where, provider),
+        ...(orderBy ? { orderBy } : {}),
+        skip: input.offset,
+        take: input.limit,
+      });
+  switch (input.model) {
+    case "bundles":
+      return parsePrismaRows(rows, parsePrismaBundleRow);
+    case "bundle_patches":
+      return parsePrismaRows(rows, parsePrismaPatchRow);
+    case "bundle_events":
+      return parsePrismaRows(rows, parsePrismaBundleEventRow);
+    case "channels":
+      return parsePrismaRows(rows, parsePrismaChannelRow);
+    case "api_keys":
+      return parsePrismaRows(rows, parsePrismaApiKeyRow);
+    case "releases":
+      return parsePrismaRows(rows, parsePrismaReleaseRow);
+    case "release_catalogs":
+      return parsePrismaRows(rows, parsePrismaReleaseCatalogRow);
   }
+};
 
-  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 assertPatchReferences = async (
+  client: object,
+  bundleId: string,
+  baseBundleId: string,
+): Promise<void> => {
+  const ids = Array.from(new Set([bundleId, baseBundleId]));
+  const count = await getPrismaDelegate(client, "bundles").count({
+    where: { id: { in: ids } },
+  });
+  if (count !== ids.length) {
+    throw new PrismaAdapterError("patch references a missing bundle");
+  }
 };
 
-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);
+const createCrudImplementation = (
+  client: object,
+  provider: ORMSQLProvider,
+  relationMode: PrismaRelationMode,
+): TransactionDatabasePluginImplementation &
+  Pick<DatabasePluginImplementation, "deleteChannel" | "insertChannel"> => ({
+  deleteChannel: async ({ id }) => {
+    const channels = getPrismaDelegate(client, "channels");
+    const existing = await channels.findFirst({ where: { id } });
+    if (existing === null) return { deleted: false, reason: "not_found" };
+    const referencedReleases = await getPrismaDelegate(
+      client,
+      "releases",
+    ).count({ where: { channel_id: id } });
+    if (referencedReleases > 0) {
+      return { deleted: false, reason: "not_empty" };
+    }
+    try {
+      await channels.deleteMany({ where: { id } });
+    } catch (error) {
+      if (isChannelDeleteReferencedError(error)) {
+        return { deleted: false, reason: "not_empty" };
       }
-      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" },
+      throw error;
+    }
+    return { deleted: true };
+  },
+  insertChannel: async (input) => {
+    const delegate = getPrismaDelegate(client, "channels");
+    const existing = await delegate.findFirst({
+      where: { name: input.row.name },
+    });
+    if (existing !== null) {
+      return { row: parsePrismaChannelRow(existing), inserted: false };
+    }
+    const row = parsePrismaChannelRow(
+      await delegate.upsert({
+        where: { name: input.row.name },
+        create: input.row,
+        update: {},
+      }),
+    );
+    return { row, inserted: row.id === input.row.id };
+  },
+  create: async (input) => {
+    if (input.model === "bundle_patches") {
+      await assertPatchReferences(
+        client,
+        input.data.bundle_id,
+        input.data.base_bundle_id,
+      );
+    }
+    const delegate = getPrismaDelegate(client, input.model);
+    let row: unknown;
+    if (input.onConflict === "ignore") {
+      const where =
+        input.model === "channels"
+          ? { name: input.data.name }
+          : { hash: input.data.hash };
+      row = await delegate.upsert({
+        where,
+        create: input.data,
+        update: {},
       });
-      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"])),
+    } else {
+      row = await delegate.create({ data: input.data });
+    }
+    switch (input.model) {
+      case "bundles":
+        return parsePrismaBundleRow(row);
+      case "bundle_patches":
+        return parsePrismaPatchRow(row);
+      case "bundle_events":
+        return parsePrismaBundleEventRow(row);
+      case "channels":
+        return parsePrismaChannelRow(row);
+      case "api_keys":
+        return parsePrismaApiKeyRow(row);
+      case "releases":
+        return parsePrismaReleaseRow(row);
+      case "release_catalogs":
+        return parsePrismaReleaseCatalogRow(row);
+    }
+  },
+  update: async (input) => {
+    const id = input.where[0]?.value;
+    if (typeof id !== "string") {
+      throw new PrismaAdapterError(
+        `${input.model} update requires a string id`,
       );
-      return rows.map((row) =>
-        rowToBundle(row as BundleRow, patchMap.get(String(row["id"])) ?? []),
+    }
+    if (input.model === "api_keys") {
+      const delegate = getPrismaDelegate(client, "api_keys");
+      const current = await delegate.findFirst({ where: { id } });
+      if (current === null) return null;
+      await delegate.update({ where: { id }, data: input.update });
+      const stored = await delegate.findFirst({ where: { id } });
+      return stored === null ? null : parsePrismaApiKeyRow(stored);
+    }
+    if (input.model === "releases") {
+      const delegate = getPrismaDelegate(client, "releases");
+      const current = await delegate.findFirst({ where: { id } });
+      if (current === null) return null;
+      await delegate.update({ where: { id }, data: input.update });
+      const stored = await delegate.findFirst({ where: { id } });
+      return stored === null ? null : parsePrismaReleaseRow(stored);
+    }
+    if (input.model === "release_catalogs") {
+      const delegate = getPrismaDelegate(client, "release_catalogs");
+      const current = await delegate.findFirst({ where: { scope_key: id } });
+      if (current === null) return null;
+      await delegate.update({ where: { scope_key: id }, data: input.update });
+      const stored = await delegate.findFirst({ where: { scope_key: id } });
+      return stored === null ? null : parsePrismaReleaseCatalogRow(stored);
+    }
+    const delegate = getPrismaDelegate(client, "bundles");
+    if (delegate.updateMany === undefined) {
+      throw new PrismaAdapterError(
+        'model delegate "bundles" requires updateMany',
+      );
+    }
+    const current = await delegate.findFirst({ where: { id } });
+    if (current === null) return null;
+    await delegate.updateMany({
+      where: { id },
+      data: input.update,
+    });
+    const stored = await delegate.findFirst({ where: { id } });
+    if (stored === null) return null;
+    return parsePrismaBundleRow(stored);
+  },
+  delete: async (input) => {
+    if (input.model === "bundles" && relationMode === "prisma") {
+      const rows = await getPrismaDelegate(client, "bundles").findMany({
+        where: createPrismaWhere(input.where, provider),
+      });
+      const ids = parsePrismaRows(rows, parsePrismaBundleRow).map(
+        ({ id }) => 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,
+      if (ids.length === 0) return;
+      await getPrismaDelegate(client, "bundle_patches").deleteMany({
+        where: {
+          OR: [{ bundle_id: { in: ids } }, { base_bundle_id: { in: ids } }],
+        },
       });
-      await patches.deleteMany({ where: { bundle_id: id } });
-      const patchRows = bundleToPatchRows(bundle);
-      if (patchRows.length > 0) {
-        await patches.createMany({ data: patchRows });
+    }
+    try {
+      await getPrismaDelegate(client, input.model).deleteMany({
+        where: createPrismaWhere(input.where, provider),
+      });
+    } catch (error) {
+      if (input.model === "channels") {
+        translateChannelDeleteError(error);
       }
-    };
-    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);
-          }
-        });
-      },
-    };
+      throw error;
+    }
+  },
+  count: async (input) => {
+    if (input.distinct !== undefined) {
+      throw new DatabasePluginInputError("invalid-operation");
+    }
+    return getPrismaDelegate(client, input.model).count({
+      where: createPrismaWhere(input.where, provider),
+    });
   },
+  findOne: async (input) => {
+    const row = await getPrismaDelegate(client, input.model).findFirst({
+      where: createPrismaWhere(input.where, provider),
+    });
+    if (row === null) return null;
+    switch (input.model) {
+      case "bundles":
+        return parsePrismaBundleRow(row);
+      case "bundle_patches":
+        return parsePrismaPatchRow(row);
+      case "channels":
+        return parsePrismaChannelRow(row);
+      case "api_keys":
+        return parsePrismaApiKeyRow(row);
+      case "releases":
+        return parsePrismaReleaseRow(row);
+      case "release_catalogs":
+        return parsePrismaReleaseCatalogRow(row);
+    }
+  },
+  findMany: (input) => findMany(client, input, provider),
 });
 
-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),
+const createPrismaImplementation = (
+  client: object,
+  relationMode: PrismaRelationMode,
+  provider: ORMSQLProvider,
+): DatabasePluginImplementation => {
+  const crud = createCrudImplementation(client, provider, relationMode);
+  const implementation: DatabasePluginImplementation = {
+    ...crud,
+    deleteChannel: (input) => {
+      if (!hasCallbackTransaction(client)) {
+        throw new PrismaAdapterError(
+          "channel deletion requires callback transactions",
+        );
+      }
+      return runPrismaTransaction(client, "serializable", (transactionClient) =>
+        createCrudImplementation(
+          transactionClient,
+          provider,
+          relationMode,
+        ).deleteChannel(input),
+      );
+    },
+    delete: (input) => {
+      if (input.model !== "bundles" || relationMode === "foreign-keys") {
+        return crud.delete(input);
+      }
+      if (!hasCallbackTransaction(client)) {
+        throw new PrismaAdapterError(
+          'relation mode "prisma" requires callback transactions',
+        );
+      }
+      return runPrismaTransaction(client, "serializable", (transactionClient) =>
+        createCrudImplementation(
+          transactionClient,
+          provider,
+          relationMode,
+        ).delete(input),
+      );
+    },
+  };
+  if (relationMode === "prisma" && !hasCallbackTransaction(client)) {
+    throw new PrismaAdapterError(
+      'relation mode "prisma" requires callback transactions',
+    );
+  }
+  if (!hasCallbackTransaction(client)) return implementation;
+  if (relationMode === "prisma") {
+    implementation.create = (input) =>
+      runPrismaTransaction(client, "serializable", (transactionClient) =>
+        createCrudImplementation(
+          transactionClient,
+          provider,
+          relationMode,
+        ).create(input),
+      );
+  }
+  implementation.update = (input) =>
+    runPrismaTransaction(
+      client,
+      relationMode === "prisma" ? "serializable" : "default",
+      (transactionClient) =>
+        createCrudImplementation(
+          transactionClient,
+          provider,
+          relationMode,
+        ).update(input),
+    );
+  return {
+    ...implementation,
+    transaction: (callback) =>
+      runPrismaTransaction(
+        client,
+        "serializable",
+        async (transactionClient) => {
+          return callback(
+            createCrudImplementation(transactionClient, provider, relationMode),
+          );
+        },
       ),
-      path: "./prisma/schema/hot_updater.prisma",
+  };
+};
+
+export const prismaAdapter = (
+  config: PrismaConfig,
+): DatabaseAdapterWithCapabilities => {
+  assertPrismaProvider(config.provider);
+  const adapter = createDatabasePluginAdapter(
+    "prisma",
+    createPrismaImplementation(
+      config.prisma,
+      config.relationMode ?? "foreign-keys",
+      config.provider,
+    ),
+  );
+  return Object.assign(
+    createDatabasePlugin({
+      name: "prisma",
+      models: adapter.models,
+      commit: adapter.commit,
     }),
-  });
+    {
+      adapterName: "prisma",
+      provider: config.provider,
+      generateSchema: ((version) => ({
+        code: generatePrismaSchema(
+          config.provider,
+          version === "latest"
+            ? hotUpdaterSchema
+            : getHotUpdaterSchemaVersion(version),
+        ),
+        path: "./prisma/schema/hot_updater.prisma",
+      })) satisfies SchemaGenerator,
+    },
+  );
 };