@hot-updater/server 0.21.10 → 0.21.11

package/src/db/index.spec.ts

@@ -4,7 +4,6 @@ import { r2Storage } from "@hot-updater/cloudflare";
 import type { Bundle, GetBundlesArgs, UpdateInfo } from "@hot-updater/core";
 import { NIL_UUID } from "@hot-updater/core";
 import { firebaseStorage } from "@hot-updater/firebase";
-import { kyselyAdapter } from "@hot-updater/server/adapters/kysely";
 import { supabaseStorage } from "@hot-updater/supabase";
 import { setupGetUpdateInfoTestSuite } from "@hot-updater/test-utils";
 import { Kysely } from "kysely";
@@ -19,6 +18,7 @@ import {
   it,
   vi,
 } from "vitest";
+import { kyselyAdapter } from "../adapters/kysely";
 import { createHotUpdater } from "./index";
 
 describe("server/db hotUpdater getUpdateInfo (PGlite + Kysely)", async () => {
@@ -88,6 +88,104 @@ describe("server/db hotUpdater getUpdateInfo (PGlite + Kysely)", async () => {
 
   setupGetUpdateInfoTestSuite({ getUpdateInfo });
 
+  describe("getBundleById", () => {
+    it("should retrieve bundle by id without Prisma validation errors", async () => {
+      const bundle: Bundle = {
+        id: "00000000-0000-0000-0000-000000000010",
+        platform: "ios",
+        shouldForceUpdate: false,
+        enabled: true,
+        fileHash: "test-hash",
+        gitCommitHash: null,
+        message: "Test bundle for getBundleById",
+        channel: "production",
+        storageUri: "s3://test-bucket/test.zip",
+        targetAppVersion: "1.0.0",
+        fingerprintHash: null,
+      };
+
+      await hotUpdater.insertBundle(bundle);
+
+      // This should not throw a Prisma validation error
+      const retrieved = await hotUpdater.getBundleById(bundle.id);
+
+      expect(retrieved).not.toBeNull();
+      expect(retrieved?.id).toBe(bundle.id);
+      expect(retrieved?.platform).toBe(bundle.platform);
+      expect(retrieved?.fileHash).toBe(bundle.fileHash);
+    });
+
+    it("should return null for non-existent bundle id", async () => {
+      const retrieved = await hotUpdater.getBundleById(
+        "99999999-9999-9999-9999-999999999999",
+      );
+
+      expect(retrieved).toBeNull();
+    });
+  });
+
+  describe("getChannels", () => {
+    it("should retrieve all unique channels without Prisma validation errors", async () => {
+      const bundles: Bundle[] = [
+        {
+          id: "00000000-0000-0000-0000-000000000020",
+          platform: "ios",
+          shouldForceUpdate: false,
+          enabled: true,
+          fileHash: "hash1",
+          gitCommitHash: null,
+          message: "Bundle 1",
+          channel: "production",
+          storageUri: "s3://test/1.zip",
+          targetAppVersion: "1.0.0",
+          fingerprintHash: null,
+        },
+        {
+          id: "00000000-0000-0000-0000-000000000021",
+          platform: "android",
+          shouldForceUpdate: false,
+          enabled: true,
+          fileHash: "hash2",
+          gitCommitHash: null,
+          message: "Bundle 2",
+          channel: "staging",
+          storageUri: "s3://test/2.zip",
+          targetAppVersion: "1.0.0",
+          fingerprintHash: null,
+        },
+        {
+          id: "00000000-0000-0000-0000-000000000022",
+          platform: "ios",
+          shouldForceUpdate: false,
+          enabled: true,
+          fileHash: "hash3",
+          gitCommitHash: null,
+          message: "Bundle 3",
+          channel: "production",
+          storageUri: "s3://test/3.zip",
+          targetAppVersion: "1.0.0",
+          fingerprintHash: null,
+        },
+      ];
+
+      for (const bundle of bundles) {
+        await hotUpdater.insertBundle(bundle);
+      }
+
+      // This should not throw a Prisma validation error
+      const channels = await hotUpdater.getChannels();
+
+      expect(channels).toHaveLength(2);
+      expect(channels).toContain("production");
+      expect(channels).toContain("staging");
+    });
+
+    it("should return empty array when no bundles exist", async () => {
+      const channels = await hotUpdater.getChannels();
+      expect(channels).toEqual([]);
+    });
+  });
+
   describe("getAppUpdateInfo with storage plugins", () => {
     beforeEach(() => {
       // Fix time for deterministic signed URLs

package/src/db/index.ts

@@ -1,59 +1,34 @@
-import type {
-  AppUpdateInfo,
-  AppVersionGetBundlesArgs,
-  Bundle,
-  FingerprintGetBundlesArgs,
-  GetBundlesArgs,
-  Platform,
-  UpdateInfo,
-} from "@hot-updater/core";
-import { NIL_UUID } from "@hot-updater/core";
 import type { StoragePlugin } from "@hot-updater/plugin-core";
-import { filterCompatibleAppVersions } from "@hot-updater/plugin-core";
-import type { InferFumaDB } from "fumadb";
-import { fumadb } from "fumadb";
-import { calculatePagination } from "../calculatePagination";
 import { createHandler } from "../handler";
-import { v0_21_0 } from "../schema/v0_21_0";
-import type { PaginationInfo } from "../types";
-
-export const HotUpdaterDB = fumadb({
-  namespace: "hot_updater",
-  schemas: [v0_21_0],
-});
-
-export type HotUpdaterClient = InferFumaDB<typeof HotUpdaterDB>;
-
-export type DatabaseAdapter = Parameters<typeof HotUpdaterDB.client>[0];
-
-export interface DatabaseAPI {
-  getBundleById(id: string): Promise<Bundle | null>;
-  getUpdateInfo(args: GetBundlesArgs): Promise<UpdateInfo | null>;
-  getAppUpdateInfo(args: GetBundlesArgs): Promise<AppUpdateInfo | null>;
-  getChannels(): Promise<string[]>;
-  getBundles(options: {
-    where?: { channel?: string; platform?: string };
-    limit: number;
-    offset: number;
-  }): Promise<{ data: Bundle[]; pagination: PaginationInfo }>;
-  insertBundle(bundle: Bundle): Promise<void>;
-  updateBundleById(bundleId: string, newBundle: Partial<Bundle>): Promise<void>;
-  deleteBundleById(bundleId: string): Promise<void>;
-}
+import {
+  createOrmDatabaseCore,
+  type HotUpdaterClient,
+  type Migrator,
+} from "./ormCore";
+import { createPluginDatabaseCore } from "./pluginCore";
+import {
+  type DatabaseAdapter,
+  type DatabaseAPI,
+  isDatabasePlugin,
+  isDatabasePluginFactory,
+  type StoragePluginFactory,
+} from "./types";
+
+export type { HotUpdaterClient, Migrator } from "./ormCore";
+export { HotUpdaterDB } from "./ormCore";
+
+type OrmCore = ReturnType<typeof createOrmDatabaseCore>;
+type PluginCore = ReturnType<typeof createPluginDatabaseCore>;
+type HotUpdaterCoreInternal = OrmCore | PluginCore;
 
 export type HotUpdaterAPI = DatabaseAPI & {
   handler: (request: Request) => Promise<Response>;
-
   adapterName: string;
   createMigrator: () => Migrator;
   generateSchema: HotUpdaterClient["generateSchema"];
 };
 
-export type Migrator = ReturnType<HotUpdaterClient["createMigrator"]>;
-
-export type StoragePluginFactory = (args: { cwd: string }) => StoragePlugin;
-
-export interface HotUpdaterOptions {
+interface HotUpdaterOptions {
   database: DatabaseAdapter;
   storagePlugins?: (StoragePlugin | StoragePluginFactory)[];
   basePath?: string;
@@ -61,12 +36,9 @@ export interface HotUpdaterOptions {
 }
 
 export function createHotUpdater(options: HotUpdaterOptions): HotUpdaterAPI {
-  const client = HotUpdaterDB.client(options.database);
-  const cwd = options.cwd ?? process.cwd();
-
   // Initialize storage plugins - call factories if they are functions
   const storagePlugins = (options?.storagePlugins ?? []).map((plugin) =>
-    typeof plugin === "function" ? plugin({ cwd }) : plugin,
+    typeof plugin === "function" ? plugin() : plugin,
   );
 
   const resolveFileUrl = async (
@@ -92,408 +64,28 @@ export function createHotUpdater(options: HotUpdaterOptions): HotUpdaterAPI {
     return fileUrl;
   };
 
-  const api = {
-    async getBundleById(id: string): Promise<Bundle | null> {
-      const version = await client.version();
-      const orm = client.orm(version);
-      const result = await orm.findFirst("bundles", {
-        select: [
-          "id",
-          "platform",
-          "should_force_update",
-          "enabled",
-          "file_hash",
-          "git_commit_hash",
-          "message",
-          "channel",
-          "storage_uri",
-          "target_app_version",
-          "fingerprint_hash",
-          "metadata",
-        ],
-        where: (b) => b.and(b.isNotNull("id"), b("id", "=", id)),
-      });
-      if (!result) return null;
-      const bundle: Bundle = {
-        id: result.id,
-        platform: result.platform as Platform,
-        shouldForceUpdate: Boolean(result.should_force_update),
-        enabled: Boolean(result.enabled),
-        fileHash: result.file_hash,
-        gitCommitHash: result.git_commit_hash ?? null,
-        message: result.message ?? null,
-        channel: result.channel,
-        storageUri: result.storage_uri,
-        targetAppVersion: result.target_app_version ?? null,
-        fingerprintHash: result.fingerprint_hash ?? null,
-      };
-      return bundle;
-    },
-    async getUpdateInfo(args: GetBundlesArgs): Promise<UpdateInfo | null> {
-      const version = await client.version();
-      const orm = client.orm(version);
-
-      type UpdateSelectRow = {
-        id: string;
-        should_force_update: boolean;
-        message: string | null;
-        storage_uri: string | null;
-        file_hash: string;
-      };
-
-      const toUpdateInfo = (
-        row: UpdateSelectRow,
-        status: "UPDATE" | "ROLLBACK",
-      ): UpdateInfo => ({
-        id: row.id,
-        shouldForceUpdate:
-          status === "ROLLBACK" ? true : Boolean(row.should_force_update),
-        message: row.message ?? null,
-        status,
-        storageUri: row.storage_uri ?? null,
-        fileHash: row.file_hash ?? null,
-      });
-
-      const INIT_BUNDLE_ROLLBACK_UPDATE_INFO: UpdateInfo = {
-        id: NIL_UUID,
-        message: null,
-        shouldForceUpdate: true,
-        status: "ROLLBACK",
-        storageUri: null,
-        fileHash: null,
-      };
-
-      const appVersionStrategy = async ({
-        platform,
-        appVersion,
-        bundleId,
-        minBundleId = NIL_UUID,
-        channel = "production",
-      }: AppVersionGetBundlesArgs): Promise<UpdateInfo | null> => {
-        const versionRows = await orm.findMany("bundles", {
-          select: ["target_app_version"],
-          where: (b) => b.and(b("platform", "=", platform)),
-        });
-        const allTargetVersions = Array.from(
-          new Set(
-            (versionRows ?? [])
-              .map((r) => r.target_app_version)
-              .filter((v): v is string => Boolean(v)),
-          ),
-        );
-        const compatibleVersions = filterCompatibleAppVersions(
-          allTargetVersions,
-          appVersion,
-        );
-
-        const baseRows =
-          compatibleVersions.length === 0
-            ? []
-            : await orm.findMany("bundles", {
-                select: [
-                  "id",
-                  "should_force_update",
-                  "message",
-                  "storage_uri",
-                  "file_hash",
-                  "channel",
-                  "target_app_version",
-                  "enabled",
-                ],
-                where: (b) =>
-                  b.and(
-                    b("enabled", "=", true),
-                    b("platform", "=", platform),
-                    b("id", ">=", minBundleId ?? NIL_UUID),
-                    b("channel", "=", channel),
-                    b.isNotNull("target_app_version"),
-                  ),
-              });
-
-        const candidates = (baseRows ?? []).filter((r) =>
-          r.target_app_version
-            ? compatibleVersions.includes(r.target_app_version)
-            : false,
-        );
-
-        const byIdDesc = (a: { id: string }, b: { id: string }) =>
-          b.id.localeCompare(a.id);
-        const sorted = (candidates ?? []).slice().sort(byIdDesc);
-
-        const latestCandidate = sorted[0] ?? null;
-        const currentBundle = sorted.find((b) => b.id === bundleId);
-        const updateCandidate =
-          sorted.find((b) => b.id.localeCompare(bundleId) > 0) ?? null;
-        const rollbackCandidate =
-          sorted.find((b) => b.id.localeCompare(bundleId) < 0) ?? null;
-
-        if (bundleId === NIL_UUID) {
-          if (latestCandidate && latestCandidate.id !== bundleId) {
-            return toUpdateInfo(latestCandidate, "UPDATE");
-          }
-          return null;
-        }
-
-        if (currentBundle) {
-          if (
-            latestCandidate &&
-            latestCandidate.id.localeCompare(currentBundle.id) > 0
-          ) {
-            return toUpdateInfo(latestCandidate, "UPDATE");
-          }
-          return null;
-        }
-
-        if (updateCandidate) {
-          return toUpdateInfo(updateCandidate, "UPDATE");
-        }
-        if (rollbackCandidate) {
-          return toUpdateInfo(rollbackCandidate, "ROLLBACK");
-        }
+  let core: HotUpdaterCoreInternal;
 
-        if (minBundleId && bundleId.localeCompare(minBundleId) <= 0) {
-          return null;
-        }
-        return INIT_BUNDLE_ROLLBACK_UPDATE_INFO;
-      };
+  const database = options.database;
 
-      const fingerprintStrategy = async ({
-        platform,
-        fingerprintHash,
-        bundleId,
-        minBundleId = NIL_UUID,
-        channel = "production",
-      }: FingerprintGetBundlesArgs): Promise<UpdateInfo | null> => {
-        const candidates = await orm.findMany("bundles", {
-          select: [
-            "id",
-            "should_force_update",
-            "message",
-            "storage_uri",
-            "file_hash",
-            "channel",
-            "fingerprint_hash",
-            "enabled",
-          ],
-          where: (b) =>
-            b.and(
-              b("enabled", "=", true),
-              b("platform", "=", platform),
-              b("id", ">=", minBundleId ?? NIL_UUID),
-              b("channel", "=", channel),
-              b("fingerprint_hash", "=", fingerprintHash),
-            ),
-        });
-
-        const byIdDesc = (a: { id: string }, b: { id: string }) =>
-          b.id.localeCompare(a.id);
-        const sorted = (candidates ?? []).slice().sort(byIdDesc);
-
-        const latestCandidate = sorted[0] ?? null;
-        const currentBundle = sorted.find((b) => b.id === bundleId);
-        const updateCandidate =
-          sorted.find((b) => b.id.localeCompare(bundleId) > 0) ?? null;
-        const rollbackCandidate =
-          sorted.find((b) => b.id.localeCompare(bundleId) < 0) ?? null;
-
-        if (bundleId === NIL_UUID) {
-          if (latestCandidate && latestCandidate.id !== bundleId) {
-            return toUpdateInfo(latestCandidate, "UPDATE");
-          }
-          return null;
-        }
-
-        if (currentBundle) {
-          if (
-            latestCandidate &&
-            latestCandidate.id.localeCompare(currentBundle.id) > 0
-          ) {
-            return toUpdateInfo(latestCandidate, "UPDATE");
-          }
-          return null;
-        }
-
-        if (updateCandidate) {
-          return toUpdateInfo(updateCandidate, "UPDATE");
-        }
-        if (rollbackCandidate) {
-          return toUpdateInfo(rollbackCandidate, "ROLLBACK");
-        }
-
-        if (minBundleId && bundleId.localeCompare(minBundleId) <= 0) {
-          return null;
-        }
-        return INIT_BUNDLE_ROLLBACK_UPDATE_INFO;
-      };
-
-      if (args._updateStrategy === "appVersion") {
-        return appVersionStrategy(args);
-      }
-      if (args._updateStrategy === "fingerprint") {
-        return fingerprintStrategy(args);
-      }
-      return null;
-    },
-
-    async getAppUpdateInfo(
-      args: GetBundlesArgs,
-    ): Promise<AppUpdateInfo | null> {
-      const info = await this.getUpdateInfo(args);
-      if (!info) return null;
-      const { storageUri, ...rest } = info as UpdateInfo & {
-        storageUri: string | null;
-      };
-      const fileUrl = await resolveFileUrl(storageUri ?? null);
-      return { ...rest, fileUrl };
-    },
-
-    async getChannels(): Promise<string[]> {
-      const version = await client.version();
-      const orm = client.orm(version);
-      const rows = await orm.findMany("bundles", {
-        select: ["channel"],
-        where: (b) => b.isNotNull("channel"),
-      });
-      const set = new Set(rows?.map((r) => r.channel) ?? []);
-      return Array.from(set);
-    },
-
-    async getBundles(options: {
-      where?: { channel?: string; platform?: string };
-      limit: number;
-      offset: number;
-    }): Promise<{ data: Bundle[]; pagination: PaginationInfo }> {
-      const version = await client.version();
-      const orm = client.orm(version);
-      const { where, limit, offset } = options;
-
-      const rows = await orm.findMany("bundles", {
-        select: [
-          "id",
-          "platform",
-          "should_force_update",
-          "enabled",
-          "file_hash",
-          "git_commit_hash",
-          "message",
-          "channel",
-          "storage_uri",
-          "target_app_version",
-          "fingerprint_hash",
-          "metadata",
-        ],
-        where: (b) => {
-          const conditions = [];
-          if (where?.channel) {
-            conditions.push(b("channel", "=", where.channel));
-          }
-          if (where?.platform) {
-            conditions.push(b("platform", "=", where.platform));
-          }
-          return conditions.length > 0 ? b.and(...conditions) : true;
-        },
-      });
-
-      const all: Bundle[] = rows
-        .map(
-          (r): Bundle => ({
-            id: r.id,
-            platform: r.platform as Platform,
-            shouldForceUpdate: Boolean(r.should_force_update),
-            enabled: Boolean(r.enabled),
-            fileHash: r.file_hash,
-            gitCommitHash: r.git_commit_hash ?? null,
-            message: r.message ?? null,
-            channel: r.channel,
-            storageUri: r.storage_uri,
-            targetAppVersion: r.target_app_version ?? null,
-            fingerprintHash: r.fingerprint_hash ?? null,
-          }),
-        )
-        .sort((a, b) => b.id.localeCompare(a.id));
-
-      const total = all.length;
-      const sliced = all.slice(offset, offset + limit);
-
-      return {
-        data: sliced,
-        pagination: calculatePagination(total, { limit, offset }),
-      };
-    },
-
-    async insertBundle(bundle: Bundle): Promise<void> {
-      const version = await client.version();
-      const orm = client.orm(version);
-      const values = {
-        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: bundle.metadata ?? {},
-      };
-      const { id, ...updateValues } = values;
-      await orm.upsert("bundles", {
-        where: (b) => b("id", "=", id),
-        create: values,
-        update: updateValues,
-      });
-    },
-
-    async updateBundleById(
-      bundleId: string,
-      newBundle: Partial<Bundle>,
-    ): Promise<void> {
-      const version = await client.version();
-      const orm = client.orm(version);
-      const current = await this.getBundleById(bundleId);
-      if (!current) throw new Error("targetBundleId not found");
-      const merged: Bundle = { ...current, ...newBundle };
-      const values = {
-        id: merged.id,
-        platform: merged.platform,
-        should_force_update: merged.shouldForceUpdate,
-        enabled: merged.enabled,
-        file_hash: merged.fileHash,
-        git_commit_hash: merged.gitCommitHash,
-        message: merged.message,
-        channel: merged.channel,
-        storage_uri: merged.storageUri,
-        target_app_version: merged.targetAppVersion,
-        fingerprint_hash: merged.fingerprintHash,
-        metadata: merged.metadata ?? {},
-      };
-      const { id: id2, ...updateValues2 } = values;
-      await orm.upsert("bundles", {
-        where: (b) => b("id", "=", id2),
-        create: values,
-        update: updateValues2,
-      });
-    },
-
-    async deleteBundleById(bundleId: string): Promise<void> {
-      const version = await client.version();
-      const orm = client.orm(version);
-      await orm.deleteMany("bundles", { where: (b) => b("id", "=", bundleId) });
-    },
-  };
+  if (isDatabasePluginFactory(database) || isDatabasePlugin(database)) {
+    const plugin = isDatabasePluginFactory(database) ? database() : database;
+    core = createPluginDatabaseCore(plugin, resolveFileUrl);
+  } else {
+    core = createOrmDatabaseCore({
+      database,
+      resolveFileUrl,
+    });
+  }
 
   return {
-    ...api,
+    ...core.api,
     handler: createHandler(
-      api,
+      core.api,
       options?.basePath ? { basePath: options.basePath } : {},
     ),
-
-    // private method
-    adapterName: client.adapter.name,
-    createMigrator: () => client.createMigrator(),
-    generateSchema: client.generateSchema,
+    adapterName: core.adapterName,
+    createMigrator: core.createMigrator,
+    generateSchema: core.generateSchema,
   };
 }