@hot-updater/server 1.0.0-rc.2 → 1.0.0-rc.21

package/src/adapters/prisma.ts

@@ -1,565 +0,0 @@
-import {
-  createDatabasePlugin,
-  DatabasePluginInputError,
-  type InsightsRecordInput,
-  type InsightsModel,
-} from "@hot-updater/plugin-core";
-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";
-import {
-  getPrismaDelegate,
-  parsePrismaBundleEventRow,
-  parsePrismaInsightsInstallationRow,
-  parsePrismaBundleRow,
-  parsePrismaChannelRow,
-  parsePrismaApiKeyRow,
-  parsePrismaPatchRow,
-  parsePrismaReleaseCatalogRow,
-  parsePrismaReleaseRow,
-  parsePrismaRows,
-  PrismaAdapterError,
-} from "./prismaRows";
-
-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 interface PrismaConfig {
-  readonly prisma: object;
-  readonly provider: ORMSQLProvider;
-  readonly relationMode?: PrismaRelationMode;
-  readonly db?: unknown;
-}
-
-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>,
-  retryUniqueConflict = false,
-): 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" &&
-            !(retryUniqueConflict && error.code === "P2002"))
-        ) {
-          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 "bundle_installations":
-      return parsePrismaRows(rows, parsePrismaInsightsInstallationRow);
-    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 }
-          : input.model === "api_keys"
-            ? { hash: input.data.hash }
-            : { install_id: input.data.install_id };
-      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 "bundle_installations":
-        return parsePrismaInsightsInstallationRow(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) => {
-    if (input.model === "bundle_installations") {
-      const installId = input.where.find(
-        (item) =>
-          item.field === "install_id" &&
-          (item.operator === undefined || item.operator === "eq") &&
-          typeof item.value === "string",
-      )?.value;
-      if (typeof installId !== "string") {
-        throw new PrismaAdapterError(
-          "bundle_installations update requires install_id",
-        );
-      }
-      const delegate = getPrismaDelegate(client, "bundle_installations");
-      if (delegate.updateMany === undefined) {
-        throw new PrismaAdapterError(
-          'model delegate "bundle_installations" requires updateMany',
-        );
-      }
-      const result = await delegate.updateMany({
-        where: createPrismaWhere(input.where, provider),
-        data: input.update,
-      });
-      if (result.count === 0) return null;
-      const stored = await delegate.findFirst({
-        where: { install_id: installId },
-      });
-      return stored === null
-        ? null
-        : parsePrismaInsightsInstallationRow(stored);
-    }
-    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);
-      case "bundle_installations":
-        return parsePrismaInsightsInstallationRow(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,
-    recordInsights: (input: InsightsRecordInput) => {
-      if (!hasCallbackTransaction(client)) {
-        throw new PrismaAdapterError(
-          "Insights recording requires callback transactions",
-        );
-      }
-      return runPrismaTransaction(
-        client,
-        "serializable",
-        async (transactionClient) => {
-          const events = getPrismaDelegate(transactionClient, "bundle_events");
-          if (
-            (await events.findFirst({ where: { id: input.event.id } })) !== null
-          )
-            return;
-          await events.create({ data: input.event });
-          const installations = getPrismaDelegate(
-            transactionClient,
-            "bundle_installations",
-          );
-          const existing = await installations.findFirst({
-            where: { install_id: input.installation.install_id },
-          });
-          if (existing === null) {
-            await installations.create({ data: input.installation });
-            return;
-          }
-          const current = parsePrismaInsightsInstallationRow(existing);
-          if (
-            current.received_at_ms > input.installation.received_at_ms ||
-            (current.received_at_ms === input.installation.received_at_ms &&
-              current.id >= input.installation.id)
-          )
-            return;
-          await installations.update({
-            where: { install_id: input.installation.install_id },
-            data: input.installation,
-          });
-        },
-        true,
-      );
-    },
-    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,
-    ),
-  );
-  const unsupportedMssqlInsights = async (): Promise<never> => {
-    throw new PrismaAdapterError(
-      "SQL Server Insights is unsupported: string keys pad trailing spaces and do not provide the required exact UTF-8 identity ordering",
-    );
-  };
-  const insights: InsightsModel =
-    config.provider === "mssql"
-      ? {
-          record: unsupportedMssqlInsights,
-          listEvents: unsupportedMssqlInsights,
-          findInstallations: unsupportedMssqlInsights,
-          countInstallations: unsupportedMssqlInsights,
-          countEvents: unsupportedMssqlInsights,
-        }
-      : adapter.models.insights;
-  return Object.assign(
-    createDatabasePlugin({
-      name: "prisma",
-      models: { ...adapter.models, insights },
-      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,
-    },
-  );
-};

package/src/adapters/prismaQuery.ts

@@ -1,129 +0,0 @@
-import { DatabasePluginInputError } from "@hot-updater/plugin-core";
-import type {
-  DatabaseModel,
-  DatabaseOrderBy,
-  DatabaseSortBy,
-  DatabaseWhere,
-} from "@hot-updater/plugin-core/internal";
-
-import type { ORMProvider } from "../db/types";
-
-export type PrismaQuery = Readonly<Record<string, unknown>>;
-type AnyDatabaseWhere = {
-  readonly [TModel in DatabaseModel]: DatabaseWhere<TModel>;
-}[DatabaseModel];
-type AnyDatabaseSortBy = {
-  readonly [TModel in DatabaseModel]: DatabaseSortBy<TModel>;
-}[DatabaseModel];
-type AnyDatabaseOrderBy = {
-  readonly [TModel in DatabaseModel]: DatabaseOrderBy<TModel>;
-}[DatabaseModel];
-
-const stringFilter = (
-  operator: "contains" | "ends_with" | "starts_with",
-  value: string,
-  mode: "default" | undefined,
-): PrismaQuery => {
-  const key =
-    operator === "starts_with"
-      ? "startsWith"
-      : operator === "ends_with"
-        ? "endsWith"
-        : "contains";
-  return {
-    [key]: value,
-    ...(mode ? { mode } : {}),
-  };
-};
-
-const SQL_PATTERN_METACHARACTERS = /[%_\\]/u;
-const MONGODB_PATTERN_METACHARACTERS = /[.*+?^${}()|[\]\\]/u;
-
-const prismaMode = (
-  mode: "insensitive" | "sensitive" | undefined,
-  provider: ORMProvider,
-): "default" | undefined => {
-  if (
-    mode === "insensitive" ||
-    (mode === "sensitive" && provider !== "postgresql")
-  ) {
-    throw new DatabasePluginInputError("invalid-operation");
-  }
-  return mode === "sensitive" ? "default" : undefined;
-};
-
-const assertLiteralPattern = (value: string, provider: ORMProvider): void => {
-  const pattern =
-    provider === "mongodb"
-      ? MONGODB_PATTERN_METACHARACTERS
-      : SQL_PATTERN_METACHARACTERS;
-  if (pattern.test(value)) {
-    throw new DatabasePluginInputError("invalid-operation");
-  }
-};
-
-const predicate = (
-  where: AnyDatabaseWhere,
-  provider: ORMProvider,
-): PrismaQuery => {
-  const mode = prismaMode("mode" in where ? where.mode : undefined, provider);
-  switch (where.operator) {
-    case undefined:
-    case "eq":
-      return {
-        [where.field]: mode ? { equals: where.value, mode } : where.value,
-      };
-    case "ne":
-      return {
-        [where.field]: {
-          not: where.value,
-          ...(mode ? { mode } : {}),
-        },
-      };
-    case "gt":
-    case "gte":
-    case "lt":
-    case "lte":
-      return { [where.field]: { [where.operator]: where.value } };
-    case "in":
-      return { [where.field]: { in: where.value } };
-    case "not_in":
-      return { [where.field]: { notIn: where.value } };
-    case "contains":
-    case "starts_with":
-    case "ends_with": {
-      assertLiteralPattern(where.value, provider);
-      return {
-        [where.field]: stringFilter(where.operator, where.value, mode),
-      };
-    }
-  }
-};
-
-export const createPrismaWhere = (
-  where: readonly AnyDatabaseWhere[] | undefined,
-  provider: ORMProvider,
-): PrismaQuery => {
-  const items = where ?? [];
-  const first = items[0];
-  if (first === undefined) return {};
-
-  let result = predicate(first, provider);
-  for (const item of items.slice(1)) {
-    result = {
-      [item.connector === "OR" ? "OR" : "AND"]: [
-        result,
-        predicate(item, provider),
-      ],
-    };
-  }
-  return result;
-};
-
-export const createPrismaOrderBy = (
-  orderBy: AnyDatabaseOrderBy | readonly AnyDatabaseSortBy[] | undefined,
-): PrismaQuery | PrismaQuery[] | undefined => {
-  if (orderBy === undefined) return undefined;
-  const clauses = Array.isArray(orderBy) ? orderBy : [orderBy];
-  return clauses.map((clause) => ({ [clause.field]: clause.direction }));
-};