@hot-updater/server 0.27.1 → 0.29.0

package/src/db/pluginUpdateCheck.bench.ts

@@ -0,0 +1,250 @@
+import { bench, describe } from "vitest";
+import type {
+  DatabaseBundleQueryOptions,
+  DatabaseBundleQueryWhere,
+  DatabasePlugin,
+} from "../../../../plugins/plugin-core/src";
+import {
+  calculatePagination,
+  semverSatisfies,
+} from "../../../../plugins/plugin-core/src";
+import type {
+  AppVersionGetBundlesArgs,
+  Bundle,
+  Platform,
+  UpdateInfo,
+} from "../../../core/src";
+import {
+  DEFAULT_ROLLOUT_COHORT_COUNT,
+  isCohortEligibleForUpdate,
+  NIL_UUID,
+} from "../../../core/src";
+import { createPluginDatabaseCore } from "./pluginCore";
+
+const BUNDLE_COUNT = 20_000;
+const BENCH_APP_VERSION = "1.0.0";
+const BENCH_PLATFORM = "ios" as const;
+const BENCH_CHANNEL = "production";
+
+const cloneBundle = (bundle: Bundle): Bundle => ({
+  ...bundle,
+  metadata: bundle.metadata
+    ? structuredClone(bundle.metadata)
+    : bundle.metadata,
+  targetCohorts: bundle.targetCohorts ? [...bundle.targetCohorts] : null,
+});
+
+const bundleMatchesWhere = (
+  bundle: Bundle,
+  where: DatabaseBundleQueryWhere | undefined,
+) => {
+  if (!where) return true;
+  if (where.channel !== undefined && bundle.channel !== where.channel)
+    return false;
+  if (where.platform !== undefined && bundle.platform !== where.platform)
+    return false;
+  if (where.enabled !== undefined && bundle.enabled !== where.enabled)
+    return false;
+  if (where.id?.eq !== undefined && bundle.id !== where.id.eq) return false;
+  if (where.id?.gt !== undefined && bundle.id.localeCompare(where.id.gt) <= 0)
+    return false;
+  if (where.id?.gte !== undefined && bundle.id.localeCompare(where.id.gte) < 0)
+    return false;
+  if (where.id?.lt !== undefined && bundle.id.localeCompare(where.id.lt) >= 0)
+    return false;
+  if (where.id?.lte !== undefined && bundle.id.localeCompare(where.id.lte) > 0)
+    return false;
+  if (where.id?.in && !where.id.in.includes(bundle.id)) return false;
+  if (where.targetAppVersionNotNull && bundle.targetAppVersion === null) {
+    return false;
+  }
+  if (
+    where.targetAppVersion !== undefined &&
+    bundle.targetAppVersion !== where.targetAppVersion
+  ) {
+    return false;
+  }
+  if (
+    where.targetAppVersionIn &&
+    !where.targetAppVersionIn.includes(bundle.targetAppVersion ?? "")
+  ) {
+    return false;
+  }
+  if (
+    where.fingerprintHash !== undefined &&
+    bundle.fingerprintHash !== where.fingerprintHash
+  ) {
+    return false;
+  }
+  return true;
+};
+
+const createBundle = (
+  index: number,
+  {
+    platform = BENCH_PLATFORM,
+    channel = BENCH_CHANNEL,
+    targetAppVersion = "*",
+    enabled = true,
+  }: {
+    platform?: Platform;
+    channel?: string;
+    targetAppVersion?: string | null;
+    enabled?: boolean;
+  } = {},
+): Bundle => ({
+  id: `00000000-0000-0000-0000-${String(index).padStart(12, "0")}`,
+  platform,
+  shouldForceUpdate: false,
+  enabled,
+  fileHash: `hash-${index}`,
+  gitCommitHash: `commit-${index}`,
+  message: `bundle-${index}`,
+  channel,
+  storageUri: `s3://bench/bundles/${index}.zip`,
+  targetAppVersion,
+  fingerprintHash: `fingerprint-${index % 10}`,
+  metadata: { app_version: String(index) },
+  rolloutCohortCount: DEFAULT_ROLLOUT_COHORT_COUNT,
+  targetCohorts: null,
+});
+
+const createBenchPlugin = (bundles: Bundle[]): DatabasePlugin => {
+  const bundlesById = new Map(bundles.map((bundle) => [bundle.id, bundle]));
+
+  const sortByDirection = (direction: "asc" | "desc" | undefined): Bundle[] => {
+    const sorted = bundles.slice().sort((a, b) => a.id.localeCompare(b.id));
+    return direction === "asc" ? sorted : sorted.reverse();
+  };
+
+  return {
+    name: "bench-plugin",
+    async getBundleById(bundleId) {
+      return bundlesById.get(bundleId) ?? null;
+    },
+    async getBundles(options: DatabaseBundleQueryOptions) {
+      const { where, limit, offset, orderBy } = options;
+      const source = sortByDirection(orderBy?.direction);
+      const matched = source.filter((bundle) =>
+        bundleMatchesWhere(bundle, where),
+      );
+      const page = matched.slice(offset, offset + limit).map(cloneBundle);
+
+      return {
+        data: page,
+        pagination: calculatePagination(matched.length, { limit, offset }),
+      };
+    },
+    async getChannels() {
+      return [...new Set(bundles.map((bundle) => bundle.channel))];
+    },
+    async updateBundle() {
+      throw new Error("Not implemented for benchmark");
+    },
+    async appendBundle() {
+      throw new Error("Not implemented for benchmark");
+    },
+    async commitBundle() {},
+    async deleteBundle() {
+      throw new Error("Not implemented for benchmark");
+    },
+  };
+};
+
+const oldPluginCoreGetUpdateInfo = async (
+  plugin: DatabasePlugin,
+  args: AppVersionGetBundlesArgs,
+): Promise<UpdateInfo | null> => {
+  const where: DatabaseBundleQueryWhere = {
+    channel: args.channel ?? BENCH_CHANNEL,
+    platform: args.platform,
+  };
+
+  const { pagination } = await plugin.getBundles({
+    where,
+    limit: 1,
+    offset: 0,
+  });
+
+  if (pagination.total === 0) {
+    return null;
+  }
+
+  const { data } = await plugin.getBundles({
+    where,
+    limit: pagination.total,
+    offset: 0,
+  });
+
+  for (const bundle of data) {
+    if (!bundle.enabled) {
+      continue;
+    }
+    if (bundle.platform !== args.platform) {
+      continue;
+    }
+    if (bundle.channel !== (args.channel ?? BENCH_CHANNEL)) {
+      continue;
+    }
+    if (!bundle.targetAppVersion) {
+      continue;
+    }
+    if (!semverSatisfies(bundle.targetAppVersion, args.appVersion)) {
+      continue;
+    }
+    if (
+      !isCohortEligibleForUpdate(
+        bundle.id,
+        args.cohort,
+        bundle.rolloutCohortCount,
+        bundle.targetCohorts,
+      )
+    ) {
+      continue;
+    }
+
+    return {
+      id: bundle.id,
+      message: bundle.message,
+      shouldForceUpdate: bundle.shouldForceUpdate,
+      status: "UPDATE",
+      storageUri: bundle.storageUri,
+      fileHash: bundle.fileHash,
+    };
+  }
+
+  return null;
+};
+
+describe("plugin update check benchmark", () => {
+  const bundles = Array.from({ length: BUNDLE_COUNT }, (_, index) =>
+    createBundle(index + 1),
+  );
+
+  const args: AppVersionGetBundlesArgs = {
+    _updateStrategy: "appVersion",
+    appVersion: BENCH_APP_VERSION,
+    bundleId: NIL_UUID,
+    platform: BENCH_PLATFORM,
+    channel: BENCH_CHANNEL,
+  };
+
+  const plugin = createBenchPlugin(bundles);
+  const currentApi = createPluginDatabaseCore(plugin, async () => null).api;
+
+  bench(
+    "pluginCore legacy full fetch",
+    async () => {
+      await oldPluginCoreGetUpdateInfo(plugin, args);
+    },
+    { warmupIterations: 5, iterations: 20 },
+  );
+
+  bench(
+    "pluginCore current paged fetch",
+    async () => {
+      await currentApi.getUpdateInfo(args);
+    },
+    { warmupIterations: 5, iterations: 20 },
+  );
+});

package/src/db/types.ts

@@ -4,26 +4,32 @@ import type {
   GetBundlesArgs,
   UpdateInfo,
 } from "@hot-updater/core";
-import type { DatabasePlugin, StoragePlugin } from "@hot-updater/plugin-core";
+import type {
+  DatabaseBundleQueryOptions,
+  DatabasePlugin,
+  HotUpdaterContext,
+  StoragePlugin,
+} from "@hot-updater/plugin-core";
 import type { FumaDBAdapter } from "fumadb/adapters";
 import type { PaginationInfo } from "../types";
 
-export type DatabasePluginFactory = () => DatabasePlugin;
+export type DatabasePluginFactory<TContext = unknown> =
+  () => DatabasePlugin<TContext>;
 
-export type DatabaseAdapter =
+export type DatabaseAdapter<TContext = unknown> =
   | FumaDBAdapter
-  | DatabasePlugin
-  | DatabasePluginFactory;
+  | DatabasePlugin<TContext>
+  | DatabasePluginFactory<TContext>;
 
-export function isDatabasePluginFactory(
-  adapter: DatabaseAdapter,
-): adapter is DatabasePluginFactory {
+export function isDatabasePluginFactory<TContext = unknown>(
+  adapter: DatabaseAdapter<TContext>,
+): adapter is DatabasePluginFactory<TContext> {
   return typeof adapter === "function";
 }
 
-export function isDatabasePlugin(
-  adapter: DatabaseAdapter,
-): adapter is DatabasePlugin {
+export function isDatabasePlugin<TContext = unknown>(
+  adapter: DatabaseAdapter<TContext>,
+): adapter is DatabasePlugin<TContext> {
   return (
     typeof adapter === "object" &&
     adapter !== null &&
@@ -33,25 +39,44 @@ export function isDatabasePlugin(
   );
 }
 
-export function isFumaAdapter(
-  adapter: DatabaseAdapter,
+export function isFumaAdapter<TContext = unknown>(
+  adapter: DatabaseAdapter<TContext>,
 ): adapter is FumaDBAdapter {
   return !isDatabasePluginFactory(adapter) && !isDatabasePlugin(adapter);
 }
 
-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>;
+export interface DatabaseAPI<TContext = unknown> {
+  getBundleById(
+    id: string,
+    context?: HotUpdaterContext<TContext>,
+  ): Promise<Bundle | null>;
+  getUpdateInfo(
+    args: GetBundlesArgs,
+    context?: HotUpdaterContext<TContext>,
+  ): Promise<UpdateInfo | null>;
+  getAppUpdateInfo(
+    args: GetBundlesArgs,
+    context?: HotUpdaterContext<TContext>,
+  ): Promise<AppUpdateInfo | null>;
+  getChannels(context?: HotUpdaterContext<TContext>): Promise<string[]>;
+  getBundles(
+    options: DatabaseBundleQueryOptions,
+    context?: HotUpdaterContext<TContext>,
+  ): Promise<{ data: Bundle[]; pagination: PaginationInfo }>;
+  insertBundle(
+    bundle: Bundle,
+    context?: HotUpdaterContext<TContext>,
+  ): Promise<void>;
+  updateBundleById(
+    bundleId: string,
+    newBundle: Partial<Bundle>,
+    context?: HotUpdaterContext<TContext>,
+  ): Promise<void>;
+  deleteBundleById(
+    bundleId: string,
+    context?: HotUpdaterContext<TContext>,
+  ): Promise<void>;
 }
 
-export type StoragePluginFactory = () => StoragePlugin;
+export type StoragePluginFactory<TContext = unknown> =
+  () => StoragePlugin<TContext>;

package/src/{handler-standalone-integration.spec.ts → handler-standalone.integration.spec.ts}

@@ -1,6 +1,7 @@
 import { PGlite } from "@electric-sql/pglite";
 import type { Bundle } from "@hot-updater/core";
 import { NIL_UUID } from "@hot-updater/core";
+import { createBlobDatabasePlugin } from "@hot-updater/plugin-core";
 import { standaloneRepository } from "@hot-updater/standalone";
 import { Kysely } from "kysely";
 import { PGliteDialect } from "kysely-pglite-dialect";
@@ -71,6 +72,9 @@ beforeAll(async () => {
     http.post(`${baseUrl}/hot-updater/api/bundles`, ({ request }) =>
       handleRequest(request),
     ),
+    http.patch(`${baseUrl}/hot-updater/api/bundles/:id`, ({ request }) =>
+      handleRequest(request),
+    ),
     http.delete(`${baseUrl}/hot-updater/api/bundles/:id`, ({ request }) =>
       handleRequest(request),
     ),
@@ -103,6 +107,27 @@ const createTestBundle = (overrides?: Partial<Bundle>): Bundle => ({
   ...overrides,
 });
 
+const createInMemoryBlobDatabase = (store: Record<string, string>) =>
+  createBlobDatabasePlugin({
+    name: "blob-test",
+    factory: () => ({
+      apiBasePath: "/api/check-update",
+      listObjects: async (prefix: string) =>
+        Object.keys(store).filter((key) => key.startsWith(prefix)),
+      loadObject: async <T>(key: string) => {
+        const value = store[key];
+        return value ? (JSON.parse(value) as T) : null;
+      },
+      uploadObject: async <T>(key: string, data: T) => {
+        store[key] = JSON.stringify(data);
+      },
+      deleteObject: async (key: string) => {
+        delete store[key];
+      },
+      invalidatePaths: async () => {},
+    }),
+  })({});
+
 describe("Handler <-> Standalone Repository Integration", () => {
   it("Real integration: appendBundle + commitBundle → handler POST /bundles", async () => {
     // Create standalone repository pointing to our test server
@@ -314,6 +339,15 @@ describe("Handler <-> Standalone Repository Integration", () => {
           },
         );
       }),
+      http.patch(`${baseUrl}/api/v2/*`, async ({ request }) => {
+        const response = await customApi.handler(request);
+        return HttpResponse.json(
+          (await response.json()) as Record<string, unknown>,
+          {
+            status: response.status,
+          },
+        );
+      }),
     );
 
     // Create standalone repository with matching basePath
@@ -347,4 +381,76 @@ describe("Handler <-> Standalone Repository Integration", () => {
     // Standalone should return null gracefully
     expect(result).toBeNull();
   });
+
+  it("updates targetAppVersion through standalone without creating a duplicate blob entry", async () => {
+    const store: Record<string, string> = {};
+    const blobApi = createHotUpdater({
+      database: createInMemoryBlobDatabase(store),
+      basePath: "/blob-hot-updater",
+    });
+    const handleBlobRequest = async (request: Request) => {
+      const response = await blobApi.handler(request);
+      return HttpResponse.json(
+        (await response.json()) as Record<string, unknown>,
+        {
+          status: response.status,
+          headers: response.headers,
+        },
+      );
+    };
+
+    server.use(
+      http.get(`${baseUrl}/blob-hot-updater/api/bundles`, ({ request }) =>
+        handleBlobRequest(request),
+      ),
+      http.get(`${baseUrl}/blob-hot-updater/api/bundles/:id`, ({ request }) =>
+        handleBlobRequest(request),
+      ),
+      http.post(`${baseUrl}/blob-hot-updater/api/bundles`, ({ request }) =>
+        handleBlobRequest(request),
+      ),
+      http.patch(`${baseUrl}/blob-hot-updater/api/bundles/:id`, ({ request }) =>
+        handleBlobRequest(request),
+      ),
+      http.delete(
+        `${baseUrl}/blob-hot-updater/api/bundles/:id`,
+        ({ request }) => handleBlobRequest(request),
+      ),
+    );
+
+    const repo = standaloneRepository({
+      baseUrl: `${baseUrl}/blob-hot-updater`,
+    })();
+
+    const bundleId = uuidv7();
+    await repo.appendBundle(
+      createTestBundle({
+        id: bundleId,
+        platform: "ios",
+        targetAppVersion: "1.x.x",
+        storageUri: "s3://test-bucket/original.zip",
+      }),
+    );
+    await repo.commitBundle();
+
+    await repo.updateBundle(bundleId, { targetAppVersion: "1.0.2" });
+    await repo.commitBundle();
+
+    const updatedBundle = await repo.getBundleById(bundleId);
+    expect(updatedBundle?.targetAppVersion).toBe("1.0.2");
+
+    expect(store["production/ios/1.x.x/update.json"]).toBeUndefined();
+
+    const nextBundles = JSON.parse(
+      store["production/ios/1.0.2/update.json"] ?? "[]",
+    ) as Bundle[];
+    expect(nextBundles).toHaveLength(1);
+    expect(nextBundles[0]?.id).toBe(bundleId);
+    expect(nextBundles[0]?.targetAppVersion).toBe("1.0.2");
+
+    const targetVersions = JSON.parse(
+      store["production/ios/target-app-versions.json"] ?? "[]",
+    ) as string[];
+    expect(targetVersions).toEqual(["1.0.2"]);
+  });
 });

package/src/handler.spec.ts

@@ -0,0 +1,156 @@
+import { NIL_UUID } from "@hot-updater/core";
+import { describe, expect, it, vi } from "vitest";
+import { createHandler, type HandlerAPI } from "./handler";
+
+type TestEnv = {
+  tenantId: string;
+};
+
+type TestContext = {
+  env: TestEnv;
+};
+
+const createApi = (): HandlerAPI<TestContext> => ({
+  getAppUpdateInfo: vi.fn().mockResolvedValue({
+    fileHash: null,
+    fileUrl: null,
+    id: NIL_UUID,
+    message: null,
+    shouldForceUpdate: true,
+    status: "ROLLBACK",
+  }),
+  getBundleById: vi.fn(),
+  getBundles: vi.fn(),
+  getChannels: vi.fn(),
+  insertBundle: vi.fn(),
+  updateBundleById: vi.fn(),
+  deleteBundleById: vi.fn(),
+});
+
+describe("createHandler", () => {
+  it("supports the app-version route without a cohort segment", async () => {
+    const api = createApi();
+    const handler = createHandler(api, { basePath: "/hot-updater" });
+
+    const response = await handler(
+      new Request(
+        "http://localhost/hot-updater/app-version/ios/1.0.0/production/default/default",
+      ),
+      {
+        env: {
+          tenantId: "tenant-a",
+        },
+      },
+    );
+
+    expect(response.status).toBe(200);
+    expect(api.getAppUpdateInfo).toHaveBeenCalledWith(
+      {
+        _updateStrategy: "appVersion",
+        appVersion: "1.0.0",
+        bundleId: "default",
+        channel: "production",
+        cohort: undefined,
+        minBundleId: "default",
+        platform: "ios",
+      },
+      {
+        env: {
+          tenantId: "tenant-a",
+        },
+      },
+    );
+  });
+
+  it("supports the fingerprint route without a cohort segment", async () => {
+    const api = createApi();
+    const handler = createHandler(api, { basePath: "/hot-updater" });
+
+    const response = await handler(
+      new Request(
+        "http://localhost/hot-updater/fingerprint/android/fingerprint-123/production/default/default",
+      ),
+    );
+
+    expect(response.status).toBe(200);
+    expect(api.getAppUpdateInfo).toHaveBeenCalledWith(
+      {
+        _updateStrategy: "fingerprint",
+        bundleId: "default",
+        channel: "production",
+        cohort: undefined,
+        fingerprintHash: "fingerprint-123",
+        minBundleId: "default",
+        platform: "android",
+      },
+      undefined,
+    );
+  });
+
+  it("can mount only update-check routes", async () => {
+    const api = createApi();
+    const handler = createHandler(api, {
+      basePath: "/hot-updater",
+      routes: {
+        updateCheck: true,
+        bundles: false,
+      },
+    });
+
+    const versionResponse = await handler(
+      new Request("http://localhost/hot-updater/version"),
+    );
+    const bundlesResponse = await handler(
+      new Request("http://localhost/hot-updater/api/bundles"),
+    );
+    const updateResponse = await handler(
+      new Request(
+        "http://localhost/hot-updater/app-version/ios/1.0.0/production/default/default",
+      ),
+    );
+
+    expect(versionResponse.status).toBe(404);
+    expect(bundlesResponse.status).toBe(404);
+    expect(updateResponse.status).toBe(200);
+  });
+
+  it("can mount only bundle routes", async () => {
+    const api = createApi();
+    const handler = createHandler(api, {
+      basePath: "/hot-updater",
+      routes: {
+        updateCheck: false,
+        bundles: true,
+      },
+    });
+
+    const channelsResponse = await handler(
+      new Request("http://localhost/hot-updater/api/bundles/channels"),
+    );
+    const updateResponse = await handler(
+      new Request(
+        "http://localhost/hot-updater/app-version/ios/1.0.0/production/default/default",
+      ),
+    );
+
+    expect(channelsResponse.status).toBe(200);
+    expect(updateResponse.status).toBe(404);
+  });
+
+  it("returns 400 when the platform route parameter is invalid", async () => {
+    const api = createApi();
+    const handler = createHandler(api, { basePath: "/hot-updater" });
+
+    const response = await handler(
+      new Request(
+        "http://localhost/hot-updater/app-version/web/1.0.0/production/default/default",
+      ),
+    );
+
+    await expect(response.json()).resolves.toEqual({
+      error: "Invalid platform: web. Expected 'ios' or 'android'.",
+    });
+    expect(response.status).toBe(400);
+    expect(api.getAppUpdateInfo).not.toHaveBeenCalled();
+  });
+});