@hot-updater/server 1.0.0-rc.1 → 1.0.0-rc.16

package/src/adapters/prisma.ts

@@ -1,465 +1,74 @@
+import { createSqlAdapter } from "../database/sql/sqlAdapter";
 import {
-  createDatabasePlugin,
-  DatabasePluginInputError,
-} from "@hot-updater/plugin-core";
+  builtInSettings,
+  builtInTarget,
+  createEngineDatabase,
+} from "../db/builtInDatabase";
 import {
-  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 {
-  DatabaseAdapterWithCapabilities,
-  ORMProvider,
-  ORMSQLProvider,
-  SchemaGenerator,
-} from "../db/types";
-import {
-  isChannelDeleteReferencedError,
-  translateChannelDeleteError,
-} from "./databaseConstraintErrors";
-import { hasNullOrderOverrides, sortRowsByOrder } from "./databasePluginUtils";
-import { createPrismaOrderBy, createPrismaWhere } from "./prismaQuery";
+  generatePrismaEngineSchema,
+  prismaCollationStatements,
+  type PrismaProvider,
+} from "../db/enginePrismaSchema";
+import { createSettingsMigrator } from "../db/settingsMigrator";
+import type { SchemaGenerator, ToolingDatabase } from "../db/types";
 import {
-  getPrismaDelegate,
-  parsePrismaBundleEventRow,
-  parsePrismaBundleRow,
-  parsePrismaChannelRow,
-  parsePrismaApiKeyRow,
-  parsePrismaPatchRow,
-  parsePrismaReleaseCatalogRow,
-  parsePrismaReleaseRow,
-  parsePrismaRows,
-  PrismaAdapterError,
-} from "./prismaRows";
+  prismaExecutor,
+  type PrismaTransactionalClient,
+} from "./prismaExecutor";
+import { checkSqlProvider } from "./sqlProviders";
 
-type PrismaRelationMode = "prisma" | "foreign-keys";
-
-type PrismaTransactionOptions = {
-  readonly isolationLevel: "Serializable";
-};
-
-type PrismaTransactionClient = object & {
-  readonly $transaction: <TResult>(
-    callback: (client: object) => Promise<TResult>,
-    options?: PrismaTransactionOptions,
-  ) => Promise<TResult>;
-};
+export type { PrismaProvider };
 
 export interface PrismaConfig {
+  /** A Prisma client: raw queries and interactive transactions run on it. */
   readonly prisma: object;
-  readonly provider: ORMSQLProvider;
-  readonly relationMode?: PrismaRelationMode;
-  readonly db?: unknown;
+  readonly provider: PrismaProvider;
 }
 
-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 assertPrismaProvider = (provider: ORMProvider): void => {
-  if (provider === "mongodb") {
-    throw new PrismaAdapterError(
-      "Prisma adapter does not support MongoDB; use mongodbAdapter instead",
-    );
-  }
-};
-
-const findMany = async (
-  client: object,
-  input: FindManyDatabaseImplementationInput,
-  provider: ORMSQLProvider,
-): Promise<readonly DatabaseImplementationResult[]> => {
-  if (input.distinctOn !== undefined) {
-    throw new DatabasePluginInputError("invalid-operation");
-  }
-  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);
-  }
-};
-
-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 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" };
-      }
-      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: {},
-      });
-    } 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`,
-      );
-    }
-    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,
-      );
-      if (ids.length === 0) return;
-      await getPrismaDelegate(client, "bundle_patches").deleteMany({
-        where: {
-          OR: [{ bundle_id: { in: ids } }, { base_bundle_id: { in: ids } }],
-        },
-      });
-    }
-    try {
-      await getPrismaDelegate(client, input.model).deleteMany({
-        where: createPrismaWhere(input.where, provider),
-      });
-    } catch (error) {
-      if (input.model === "channels") {
-        translateChannelDeleteError(error);
-      }
-      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),
-});
-
-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),
-          );
-        },
-      ),
-  };
-};
-
-export const prismaAdapter = (
-  config: PrismaConfig,
-): DatabaseAdapterWithCapabilities => {
-  assertPrismaProvider(config.provider);
-  const adapter = createDatabasePluginAdapter(
-    "prisma",
-    createPrismaImplementation(
-      config.prisma,
-      config.relationMode ?? "foreign-keys",
-      config.provider,
-    ),
+/**
+ * Hot Updater's database on a Prisma client: the storage engine through the
+ * shared SQL core, fenced by the schema settings. `db generate` writes the
+ * models Prisma applies; `db migrate` then sets the collations Prisma cannot
+ * declare and writes the settings rows the fence checks.
+ */
+export const prismaAdapter = (config: PrismaConfig): ToolingDatabase => {
+  const provider = checkSqlProvider("prismaAdapter", config.provider);
+  const executor = prismaExecutor(
+    config.prisma as PrismaTransactionalClient,
+    provider,
   );
-  return Object.assign(
-    createDatabasePlugin({
+  return {
+    ...createEngineDatabase({
       name: "prisma",
-      models: adapter.models,
-      commit: adapter.commit,
+      adapter: createSqlAdapter({ executor }),
     }),
-    {
-      adapterName: "prisma",
-      provider: config.provider,
-      generateSchema: ((version) => ({
-        code: generatePrismaSchema(
-          config.provider,
-          version === "latest"
-            ? hotUpdaterSchema
-            : getHotUpdaterSchemaVersion(version),
-        ),
-        path: "./prisma/schema/hot_updater.prisma",
-      })) satisfies SchemaGenerator,
+    provider,
+    generateSchema: ((version, _name, { schema } = builtInTarget) => {
+      if (version !== "latest" && version !== builtInSettings["schema.core"]) {
+        throw new Error(`Invalid version ${version}`);
+      }
+      return {
+        code: generatePrismaEngineSchema(provider, schema),
+        path: "prisma/schema.prisma",
+      };
+    }) satisfies SchemaGenerator,
+    createMigrator: ({ schema, settings } = builtInTarget) => {
+      const collations = prismaCollationStatements(provider, schema);
+      return createSettingsMigrator({
+        adapterName: "prisma",
+        executor,
+        settings,
+        applyTables: "`prisma db push` (or `prisma migrate`)",
+        ...(collations.length === 0
+          ? {}
+          : {
+              fixups: {
+                description:
+                  "Set the collations Prisma cannot declare, so strings compare by their bytes",
+                statements: collations,
+              },
+            }),
+      });
     },
-  );
+  };
 };

package/src/adapters/prismaExecutor.ts

@@ -0,0 +1,107 @@
+import { SETTINGS_TABLE } from "../database/fence";
+import type {
+  SqlConnection,
+  SqlDialect,
+  SqlExecutor,
+} from "../database/sql/sqlAdapter";
+import { quoteSql } from "../database/sql/sqlSchema";
+
+/** The members of a Prisma client, or of its transaction client, the executor uses. */
+export interface PrismaRawClient {
+  $queryRawUnsafe(query: string, ...values: unknown[]): Promise<unknown>;
+  $executeRawUnsafe(query: string, ...values: unknown[]): Promise<number>;
+}
+
+export interface PrismaTransactionalClient extends PrismaRawClient {
+  $transaction<T>(
+    fn: (tx: PrismaRawClient) => Promise<T>,
+    options?: { readonly maxWait?: number; readonly timeout?: number },
+  ): Promise<T>;
+}
+
+/**
+ * Prisma reports a raw query's database error as P2010 with the database's
+ * code in `meta.code`, and a failed transaction as P2034. The error thrown on
+ * carries that code, as the SQL core classifies it, with Prisma's as `cause`.
+ */
+const withDatabaseCode = (dialect: SqlDialect, error: unknown): unknown => {
+  const { code, meta } = (error ?? {}) as {
+    code?: unknown;
+    meta?: { code?: unknown; message?: unknown };
+  };
+  const database =
+    code === "P2034"
+      ? "40001"
+      : meta?.code === undefined
+        ? undefined
+        : String(meta.code);
+  if (database === undefined) return error;
+  return Object.assign(
+    new Error(String(meta?.message ?? (error as Error).message), {
+      cause: error,
+    }),
+    { code: dialect === "sqlite" ? `SQLITE:${database}` : database },
+  );
+};
+
+/** MySQL's ASCII keys are `VarBinary` in Prisma's schema, and read back as bytes. */
+const decoder = new TextDecoder();
+const decodeRow = (row: Record<string, unknown>) => {
+  for (const [column, value] of Object.entries(row)) {
+    if (value instanceof Uint8Array) row[column] = decoder.decode(value);
+  }
+  return row;
+};
+
+const over = (dialect: SqlDialect, client: PrismaRawClient): SqlConnection => ({
+  async execute({ sql, params }) {
+    try {
+      if (/^\s*SELECT\b/iu.test(sql)) {
+        const rows = (await client.$queryRawUnsafe(sql, ...params)) as Record<
+          string,
+          unknown
+        >[];
+        return { rows: rows.map(decodeRow), changes: 0 };
+      }
+      return {
+        rows: [],
+        changes: Number(await client.$executeRawUnsafe(sql, ...params)),
+      };
+    } catch (error) {
+      throw withDatabaseCode(dialect, error);
+    }
+  },
+});
+
+/** Taking the write lock first makes a SQLite transaction behave as BEGIN IMMEDIATE. */
+const writeLock = (dialect: SqlDialect) =>
+  `UPDATE ${quoteSql(dialect, SETTINGS_TABLE.name)} SET ${quoteSql(dialect, "_v")} = ${quoteSql(dialect, "_v")} WHERE 0 = 1`;
+
+/**
+ * The SQL core's executor over a Prisma client, through raw queries and
+ * interactive transactions. A SQLite transaction takes the write lock with
+ * its first statement, as BEGIN IMMEDIATE would.
+ */
+export const prismaExecutor = (
+  client: PrismaTransactionalClient,
+  dialect: SqlDialect,
+): SqlExecutor => ({
+  dialect,
+  ...over(dialect, client),
+  async transaction(fn) {
+    try {
+      return await client.$transaction(
+        async (tx) => {
+          const connection = over(dialect, tx);
+          if (dialect === "sqlite") {
+            await connection.execute({ sql: writeLock(dialect), params: [] });
+          }
+          return fn(connection);
+        },
+        { maxWait: 10_000, timeout: 30_000 },
+      );
+    } catch (error) {
+      throw withDatabaseCode(dialect, error);
+    }
+  },
+});