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

package/src/adapters/drizzle.ts

@@ -1,326 +1,139 @@
-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 { createDatabasePlugin } from "@hot-updater/plugin-core";
 import {
-  and,
-  asc,
-  desc,
-  eq,
-  gt,
-  gte,
-  inArray,
-  isNotNull,
-  isNull,
-  lt,
-  lte,
-} from "drizzle-orm";
-import type { SQLWrapper } from "drizzle-orm";
+  createDatabasePluginAdapter,
+  type DatabasePluginImplementation,
+  type TransactionDatabasePluginImplementation,
+} from "@hot-updater/plugin-core/internal";
 
-import {
-  bundleToPatchRows,
-  bundleToRow,
-  type BundlePatchRow,
-  type BundleRow,
-  rowToBundle,
-} from "../db/bundleRows";
 import {
   getHotUpdaterSchemaVersion,
   hotUpdaterSchema,
 } from "../db/schema/registry";
 import { generateDrizzleSchema } from "../db/schemaGenerators";
 import type {
-  DatabasePluginFactory,
+  DatabaseAdapterWithCapabilities,
   ORMProvider,
-  ORMSQLProvider,
   SchemaGenerator,
 } from "../db/types";
-import {
-  createLazyDB,
-  type DrizzleDB,
-  type DrizzleTable,
-} from "./drizzleLazyDB";
+import { createDrizzleCrud } from "./drizzleCrud";
+import { createLazyDB } from "./drizzleLazyDB";
+
+export type DrizzleProvider = Exclude<
+  ORMProvider,
+  "cockroachdb" | "mongodb" | "mssql"
+>;
 
 export interface DrizzleConfig {
   readonly db: unknown | (() => unknown | Promise<unknown>);
-  readonly provider: Exclude<ORMProvider, "cockroachdb" | "mongodb" | "mssql">;
+  readonly provider: DrizzleProvider;
   readonly schema?: Record<string, unknown>;
+  readonly transaction?: boolean;
 }
 
-const getTable = (db: DrizzleDB, name: string) => {
-  const table = db._.fullSchema[name];
-  if (!table) throw new Error(`Drizzle schema is missing table "${name}".`);
-  return table;
-};
-
-const column = (table: DrizzleTable, name: string): SQLWrapper =>
-  table[name] as SQLWrapper;
-
-const buildWhere = (
-  table: DrizzleTable,
-  where: DatabaseBundleQueryWhere | undefined,
-) => {
-  const conditions = [];
-  if (where?.channel !== undefined)
-    conditions.push(eq(column(table, "channel"), where.channel));
-  if (where?.platform !== undefined)
-    conditions.push(eq(column(table, "platform"), where.platform));
-  if (where?.enabled !== undefined)
-    conditions.push(eq(column(table, "enabled"), where.enabled));
-  if (where?.fingerprintHash !== undefined) {
-    conditions.push(
-      where.fingerprintHash === null
-        ? isNull(column(table, "fingerprint_hash"))
-        : eq(column(table, "fingerprint_hash"), where.fingerprintHash),
-    );
-  }
-  if (where?.targetAppVersion !== undefined) {
-    conditions.push(
-      where.targetAppVersion === null
-        ? isNull(column(table, "target_app_version"))
-        : eq(column(table, "target_app_version"), where.targetAppVersion),
-    );
-  }
-  if (where?.targetAppVersionIn) {
-    conditions.push(
-      inArray(column(table, "target_app_version"), where.targetAppVersionIn),
-    );
-  }
-  if (where?.targetAppVersionNotNull) {
-    conditions.push(isNotNull(column(table, "target_app_version")));
-  }
-  if (where?.id?.eq) conditions.push(eq(column(table, "id"), where.id.eq));
-  if (where?.id?.gt) conditions.push(gt(column(table, "id"), where.id.gt));
-  if (where?.id?.gte) conditions.push(gte(column(table, "id"), where.id.gte));
-  if (where?.id?.lt) conditions.push(lt(column(table, "id"), where.id.lt));
-  if (where?.id?.lte) conditions.push(lte(column(table, "id"), where.id.lte));
-  if (where?.id?.in) conditions.push(inArray(column(table, "id"), where.id.in));
-  return conditions.length > 0 ? and(...conditions) : undefined;
-};
-
-const createDrizzlePlugin = createDatabasePlugin<DrizzleConfig>({
-  name: "drizzle",
-  factory: (config) => {
-    const db = createLazyDB(config);
-    const bundles = getTable(db, "bundles");
-    const patches = getTable(db, "bundle_patches");
-    const runInTransaction = async <T>(
-      operation: (activeDB: DrizzleDB) => Promise<T>,
-    ) => {
-      if (typeof db.transaction !== "function") return operation(db);
-      return db.transaction(operation);
-    };
-    const fetchPatchMap = async (bundleIds: readonly string[]) => {
-      const patchMap = new Map<string, BundlePatchRow[]>();
-      if (bundleIds.length === 0) return patchMap;
-      const rows = await db.query["bundle_patches"]?.findMany({
-        where: inArray(column(patches, "bundle_id"), [...bundleIds]),
-        orderBy: [asc(column(patches, "order_index"))],
-      });
-      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);
+const createImplementation = (
+  config: DrizzleConfig,
+): DatabasePluginImplementation => {
+  const db = createLazyDB(config);
+  const crud = createDrizzleCrud(db, config.provider);
+  const transaction = db.transaction?.bind(db);
+  return {
+    ...crud,
+    deleteChannel: (input) => {
+      if (transaction === undefined) {
+        throw new Error(
+          "Drizzle channel deletion requires transaction support.",
+        );
       }
-      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"])) ?? []),
+      return transaction((transactionDatabase) =>
+        createDrizzleCrud(transactionDatabase, config.provider).deleteChannel(
+          input,
+        ),
       );
-    };
-    const upsertBundle = async (activeDB: DrizzleDB, bundle: Bundle) => {
-      const row = bundleToRow(bundle);
-      const current = await activeDB.query["bundles"]?.findFirst({
-        where: eq(column(bundles, "id"), bundle.id),
-      });
-      if (current) {
-        await activeDB
-          .update(bundles)
-          .set(row)
-          .where(eq(column(bundles, "id"), bundle.id));
-      } else {
-        const inserted = activeDB.insert(bundles).values(row);
-        if (inserted.execute) await inserted.execute();
-        else await inserted;
-      }
-      await activeDB
-        .delete(patches)
-        .where(eq(column(patches, "bundle_id"), bundle.id));
-      const patchRows = bundleToPatchRows(bundle);
-      if (patchRows.length > 0) {
-        const inserted = activeDB.insert(patches).values(patchRows);
-        if (inserted.execute) await inserted.execute();
-        else await inserted;
-      }
-    };
-    return {
-      async getBundleById(bundleId) {
-        const row = await db.query["bundles"]?.findFirst({
-          where: eq(column(bundles, "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 offset = options.offset ?? 0;
-        const orderBy = options.orderBy ?? { field: "id", direction: "desc" };
-        const where = buildWhere(bundles, options.where);
-        const total = await db.$count(bundles, where);
-        const rows = await db.query["bundles"]?.findMany({
-          where,
-          orderBy: [
-            orderBy.direction === "asc"
-              ? asc(column(bundles, "id"))
-              : desc(column(bundles, "id")),
-          ],
-          limit: options.limit,
-          offset,
-        });
-        const dataRows = rows ?? [];
-        const patchMap = await fetchPatchMap(
-          dataRows.map((row) => String(row["id"])),
-        );
-        return {
-          data: dataRows.map((row) =>
-            rowToBundle(
-              row as BundleRow,
-              patchMap.get(String(row["id"])) ?? [],
+    },
+    ...(transaction
+      ? {
+          delete: (input: Parameters<typeof crud.delete>[0]) =>
+            transaction((transactionDatabase) =>
+              createDrizzleCrud(transactionDatabase, config.provider).delete(
+                input,
+              ),
             ),
-          ),
-          pagination: calculatePagination(total, {
-            limit: options.limit,
-            offset,
-          }),
-        };
-      },
-      async getUpdateInfo(args, context) {
-        if (args._updateStrategy === "appVersion") {
-          const channel = args.channel ?? "production";
-          const minBundleId = args.minBundleId ?? NIL_UUID;
-          const rows = await db.query["bundles"]?.findMany({
-            columns: { target_app_version: true },
-            where: buildWhere(bundles, {
-              enabled: true,
-              platform: args.platform,
-              channel,
-              id: { gte: minBundleId },
-              targetAppVersionNotNull: true,
-            }),
-          });
-
-          const targetAppVersions = Array.from(
-            new Set(
-              (rows ?? [])
-                .map((row) => row["target_app_version"])
-                .filter(
-                  (value): value is string =>
-                    typeof value === "string" && value.length > 0,
-                ),
+        }
+      : {}),
+    ...(transaction
+      ? {
+          transaction: async <TResult>(
+            callback: (
+              transaction: TransactionDatabasePluginImplementation,
+            ) => Promise<TResult>,
+          ): Promise<TResult> =>
+            transaction((transaction) =>
+              callback(createDrizzleCrud(transaction, config.provider)),
             ),
-          );
-          const compatibleAppVersions = filterCompatibleAppVersions(
-            targetAppVersions,
-            args.appVersion,
-          );
-          const updateRows =
-            compatibleAppVersions.length > 0
-              ? await db.query["bundles"]?.findMany({
-                  where: buildWhere(bundles, {
-                    enabled: true,
-                    platform: args.platform,
-                    channel,
-                    id: { gte: minBundleId },
-                    targetAppVersionIn: compatibleAppVersions,
-                  }),
-                  orderBy: [desc(column(bundles, "id"))],
-                })
-              : [];
-
-          return resolveUpdateInfoFromBundles({
-            args: { ...args, channel, minBundleId },
-            bundles: await mapRowsToBundles(updateRows ?? []),
-            context,
-          });
         }
+      : {}),
+  };
+};
 
-        const channel = args.channel ?? "production";
-        const minBundleId = args.minBundleId ?? NIL_UUID;
-        const rows = await db.query["bundles"]?.findMany({
-          where: buildWhere(bundles, {
-            enabled: true,
-            platform: args.platform,
-            channel,
-            id: { gte: minBundleId },
-            fingerprintHash: args.fingerprintHash,
-          }),
-          orderBy: [desc(column(bundles, "id"))],
-        });
-
-        return resolveUpdateInfoFromBundles({
-          args: { ...args, channel, minBundleId },
-          bundles: await mapRowsToBundles(rows ?? []),
-          context,
-        });
+export const drizzleAdapter = (
+  config: DrizzleConfig,
+): DatabaseAdapterWithCapabilities => {
+  let adapter: ReturnType<typeof createDatabasePluginAdapter> | undefined;
+  const getAdapter = () => {
+    adapter ??= createDatabasePluginAdapter(
+      "drizzle",
+      createImplementation(config),
+    );
+    return adapter;
+  };
+  const plugin = createDatabasePlugin({
+    name: "drizzle",
+    models: {
+      bundles: {
+        findById: (id) => getAdapter().models.bundles.findById(id),
+        findMany: (query) => getAdapter().models.bundles.findMany(query),
+        count: (where) => getAdapter().models.bundles.count(where),
       },
-      async getChannels() {
-        const rows = await db.query["bundles"]?.findMany({
-          columns: { channel: true },
-          orderBy: [asc(column(bundles, "channel"))],
-        });
-        return Array.from(
-          new Set((rows ?? []).map((row) => String(row["channel"]))),
-        );
+      bundlePatches: {
+        findByBundleIds: (bundleIds) =>
+          getAdapter().models.bundlePatches.findByBundleIds(bundleIds),
       },
-      async commitBundle({ changedSets }) {
-        await runInTransaction(async (activeDB) => {
-          for (const change of changedSets) {
-            if (change.operation === "delete") {
-              await activeDB
-                .delete(patches)
-                .where(eq(column(patches, "bundle_id"), change.data.id));
-              await activeDB
-                .delete(patches)
-                .where(eq(column(patches, "base_bundle_id"), change.data.id));
-              await activeDB
-                .delete(bundles)
-                .where(eq(column(bundles, "id"), change.data.id));
-              continue;
-            }
-            await upsertBundle(activeDB, change.data);
-          }
-        });
+      releases: {
+        findById: (id) => getAdapter().models.releases.findById(id),
+        findMany: (input) => getAdapter().models.releases.findMany(input),
+        findManyByScope: (input) =>
+          getAdapter().models.releases.findManyByScope(input),
       },
-    };
-  },
-});
-
-export const drizzleAdapter = (
-  config: DrizzleConfig,
-): DatabasePluginFactory => {
-  return Object.assign(createDrizzlePlugin(config), {
+      releaseCatalogs: {
+        findByScopeKey: (scopeKey) =>
+          getAdapter().models.releaseCatalogs.findByScopeKey(scopeKey),
+        findMany: (input) =>
+          getAdapter().models.releaseCatalogs.findMany(input),
+      },
+      channels: {
+        insert: (input) => getAdapter().models.channels.insert(input),
+        list: (input) => getAdapter().models.channels.list(input),
+        delete: (input) => getAdapter().models.channels.delete(input),
+      },
+      analytics: {
+        append: (row) => getAdapter().models.analytics.append(row),
+        scan: (input) => getAdapter().models.analytics.scan(input),
+      },
+      apiKeys: {
+        create: (row) => getAdapter().models.apiKeys.create(row),
+        findByHash: (hash) => getAdapter().models.apiKeys.findByHash(hash),
+        list: () => getAdapter().models.apiKeys.list(),
+        revoke: (input) => getAdapter().models.apiKeys.revoke(input),
+      },
+    },
+    commit: (input) => getAdapter().commit(input),
+  });
+  return Object.assign(plugin, {
     adapterName: "drizzle",
     provider: config.provider,
     generateSchema: (version: Parameters<SchemaGenerator>[0]) => ({
       code: generateDrizzleSchema(
-        config.provider as ORMSQLProvider,
+        config.provider,
         version === "latest"
           ? hotUpdaterSchema
           : getHotUpdaterSchemaVersion(version),