@hot-updater/server 0.29.4 → 0.29.6

package/src/db/ormCore.ts

@@ -13,6 +13,9 @@ import {
   NIL_UUID,
 } from "@hot-updater/core";
 import type {
+  DatabaseBundleCursor,
+  DatabaseBundleIdFilter,
+  DatabaseBundleQueryOrder,
   DatabaseBundleQueryOptions,
   DatabaseBundleQueryWhere,
   HotUpdaterContext,
@@ -53,6 +56,74 @@ const getLastItem = <T extends unknown[]>(
 ): T extends [...infer _, infer Last] ? Last : never =>
   items.at(-1) as T extends [...infer _, infer Last] ? Last : never;
 
+const DEFAULT_BUNDLE_ORDER = { field: "id", direction: "desc" } as const;
+
+const mergeIdFilter = (
+  base: DatabaseBundleIdFilter | undefined,
+  patch: DatabaseBundleIdFilter,
+): DatabaseBundleIdFilter => ({
+  ...base,
+  ...patch,
+});
+
+const mergeWhereWithIdFilter = (
+  where: DatabaseBundleQueryWhere | undefined,
+  idFilter: DatabaseBundleIdFilter,
+): DatabaseBundleQueryWhere => ({
+  ...where,
+  id: mergeIdFilter(where?.id, idFilter),
+});
+
+const buildCursorPageWhere = (
+  where: DatabaseBundleQueryWhere | undefined,
+  cursor: DatabaseBundleCursor,
+  orderBy: DatabaseBundleQueryOrder,
+): {
+  reverseData: boolean;
+  where: DatabaseBundleQueryWhere;
+  orderBy: DatabaseBundleQueryOrder;
+} => {
+  const direction = orderBy.direction;
+
+  if (cursor.after) {
+    return {
+      reverseData: false,
+      where: mergeWhereWithIdFilter(where, {
+        [direction === "desc" ? "lt" : "gt"]: cursor.after,
+      }),
+      orderBy,
+    };
+  }
+
+  if (cursor.before) {
+    return {
+      reverseData: true,
+      where: mergeWhereWithIdFilter(where, {
+        [direction === "desc" ? "gt" : "lt"]: cursor.before,
+      }),
+      orderBy: {
+        field: orderBy.field,
+        direction: direction === "desc" ? "asc" : "desc",
+      },
+    };
+  }
+
+  return {
+    reverseData: false,
+    where: where ?? {},
+    orderBy,
+  };
+};
+
+const buildCountBeforeWhere = (
+  where: DatabaseBundleQueryWhere | undefined,
+  firstBundleId: string,
+  orderBy: DatabaseBundleQueryOrder,
+): DatabaseBundleQueryWhere =>
+  mergeWhereWithIdFilter(where, {
+    [orderBy.direction === "desc" ? "gt" : "lt"]: firstBundleId,
+  });
+
 export const HotUpdaterDB = fumadb({
   namespace: "hot_updater",
   schemas,
@@ -511,7 +582,12 @@ export function createOrmDatabaseCore<TContext = unknown>({
       options: DatabaseBundleQueryOptions,
     ): Promise<Paginated<Bundle[]>> {
       const orm = await ensureORM();
-      const { where, limit, offset, orderBy } = options;
+      const { where, limit } = options;
+      const orderBy = options.orderBy ?? DEFAULT_BUNDLE_ORDER;
+      const offset =
+        (("offset" in options ? options.offset : undefined) as
+          | number
+          | undefined) ?? 0;
 
       const total = await orm.count("bundles", {
         where: buildBundleWhere(where),
@@ -549,49 +625,129 @@ export function createOrmDatabaseCore<TContext = unknown>({
         "target_cohorts",
       ];
 
-      const rows = isMongoAdapter
-        ? (
-            await orm.findMany("bundles", {
+      const mapRowsToBundles = (rows: any[]): 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,
+            rolloutCohortCount:
+              r.rollout_cohort_count ?? DEFAULT_ROLLOUT_COHORT_COUNT,
+            targetCohorts: parseTargetCohorts(r.target_cohorts),
+          }),
+        );
+
+      const findBundles = async ({
+        where,
+        orderBy,
+        limit,
+        offset,
+      }: {
+        where?: DatabaseBundleQueryWhere;
+        orderBy: DatabaseBundleQueryOrder;
+        limit: number;
+        offset: number;
+      }) => {
+        const rows = isMongoAdapter
+          ? (
+              await orm.findMany("bundles", {
+                select: selectedColumns,
+                where: buildBundleWhere(where),
+              })
+            )
+              .sort((a, b) => {
+                const result = a.id.localeCompare(b.id);
+                return orderBy.direction === "asc" ? result : -result;
+              })
+              .slice(offset, offset + limit)
+          : await orm.findMany("bundles", {
               select: selectedColumns,
               where: buildBundleWhere(where),
-            })
-          )
-            .sort((a, b) => {
-              const direction = orderBy?.direction ?? "desc";
-              const result = a.id.localeCompare(b.id);
-              return direction === "asc" ? result : -result;
-            })
-            .slice(offset, offset + limit)
-        : await orm.findMany("bundles", {
-            select: selectedColumns,
-            where: buildBundleWhere(where),
-            orderBy: [[orderBy?.field ?? "id", orderBy?.direction ?? "desc"]],
-            limit,
-            offset,
-          });
+              orderBy: [[orderBy.field, orderBy.direction]],
+              limit,
+              offset,
+            });
 
-      const data: 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,
-          rolloutCohortCount:
-            r.rollout_cohort_count ?? DEFAULT_ROLLOUT_COHORT_COUNT,
-          targetCohorts: parseTargetCohorts(r.target_cohorts),
-        }),
-      );
+        return mapRowsToBundles(rows);
+      };
+
+      if (!options.cursor?.after && !options.cursor?.before) {
+        const data = await findBundles({
+          where,
+          orderBy,
+          limit,
+          offset,
+        });
+
+        return {
+          data,
+          pagination: {
+            ...calculatePagination(total, { limit, offset }),
+            ...(data.length > 0 && offset + data.length < total
+              ? { nextCursor: data.at(-1)?.id }
+              : {}),
+            ...(data.length > 0 && offset > 0
+              ? { previousCursor: data[0]?.id }
+              : {}),
+          },
+        };
+      }
+
+      const {
+        where: cursorWhere,
+        orderBy: cursorOrderBy,
+        reverseData,
+      } = buildCursorPageWhere(where, options.cursor, orderBy);
+      const cursorPage = await findBundles({
+        where: cursorWhere,
+        orderBy: cursorOrderBy,
+        limit,
+        offset: 0,
+      });
+      const data = reverseData ? cursorPage.slice().reverse() : cursorPage;
+
+      if (data.length === 0) {
+        const emptyStartIndex = options.cursor.after ? total : 0;
+        return {
+          data,
+          pagination: {
+            ...calculatePagination(total, {
+              limit,
+              offset: emptyStartIndex,
+            }),
+            ...(options.cursor.after
+              ? { previousCursor: options.cursor.after }
+              : {}),
+            ...(options.cursor.before
+              ? { nextCursor: options.cursor.before }
+              : {}),
+          },
+        };
+      }
+
+      const startIndex = await orm.count("bundles", {
+        where: buildBundleWhere(
+          buildCountBeforeWhere(where, data[0]!.id, orderBy),
+        ),
+      });
 
       return {
         data,
-        pagination: calculatePagination(total, { limit, offset }),
+        pagination: {
+          ...calculatePagination(total, { limit, offset: startIndex }),
+          ...(startIndex + data.length < total
+            ? { nextCursor: data.at(-1)?.id }
+            : {}),
+          ...(startIndex > 0 ? { previousCursor: data[0]?.id } : {}),
+        },
       };
     },
 

package/src/db/pluginCore.spec.ts

@@ -0,0 +1,172 @@
+import type { Bundle, GetBundlesArgs, UpdateInfo } from "@hot-updater/core";
+import { NIL_UUID } from "@hot-updater/core";
+import type {
+  DatabasePlugin,
+  RequestEnvContext,
+} from "@hot-updater/plugin-core";
+import { describe, expect, it, vi } from "vitest";
+
+import { createPluginDatabaseCore } from "./pluginCore";
+
+const baseBundle: Bundle = {
+  id: "00000000-0000-0000-0000-000000000001",
+  channel: "production",
+  enabled: true,
+  fileHash: "hash-1",
+  fingerprintHash: null,
+  gitCommitHash: null,
+  message: "bundle",
+  platform: "ios",
+  shouldForceUpdate: false,
+  storageUri: "s3://bucket/bundle.zip",
+  targetAppVersion: "1.0.0",
+};
+
+const updateArgs: GetBundlesArgs = {
+  _updateStrategy: "appVersion",
+  appVersion: "1.0.0",
+  bundleId: NIL_UUID,
+  platform: "ios",
+};
+
+type TestContext = RequestEnvContext<{
+  assetHost: string;
+}>;
+
+describe("createPluginDatabaseCore", () => {
+  it("prefers plugin getUpdateInfo fast-path when provided", async () => {
+    const getBundles = vi.fn<DatabasePlugin<TestContext>["getBundles"]>();
+    const expected: UpdateInfo = {
+      fileHash: baseBundle.fileHash,
+      id: baseBundle.id,
+      message: baseBundle.message,
+      shouldForceUpdate: baseBundle.shouldForceUpdate,
+      status: "UPDATE",
+      storageUri: baseBundle.storageUri,
+    };
+    const getUpdateInfo = vi.fn<
+      NonNullable<DatabasePlugin<TestContext>["getUpdateInfo"]>
+    >(async () => expected);
+
+    const plugin: DatabasePlugin<TestContext> = {
+      name: "fast-path-plugin",
+      async appendBundle() {},
+      async commitBundle() {},
+      async deleteBundle() {},
+      async getBundleById() {
+        return null;
+      },
+      getBundles,
+      getUpdateInfo,
+      async getChannels() {
+        return ["production"];
+      },
+      async updateBundle() {},
+    };
+
+    const core = createPluginDatabaseCore(
+      () => plugin,
+      async () => null,
+    );
+    const context: TestContext = {
+      env: {
+        assetHost: "https://assets.example.com",
+      },
+      request: new Request("https://updates.example.com"),
+    };
+
+    await expect(core.api.getUpdateInfo(updateArgs, context)).resolves.toEqual(
+      expected,
+    );
+    expect(getUpdateInfo).toHaveBeenCalledWith(updateArgs, context);
+    expect(getBundles).not.toHaveBeenCalled();
+  });
+
+  it("does not fall back to scanning when plugin getUpdateInfo returns null", async () => {
+    const getBundles = vi.fn<DatabasePlugin["getBundles"]>(async () => ({
+      data: [baseBundle],
+      pagination: {
+        currentPage: 1,
+        hasNextPage: false,
+        hasPreviousPage: false,
+        total: 1,
+        totalPages: 1,
+      },
+    }));
+    const getUpdateInfo = vi.fn<NonNullable<DatabasePlugin["getUpdateInfo"]>>(
+      async () => null,
+    );
+
+    const plugin: DatabasePlugin = {
+      name: "null-fast-path-plugin",
+      async appendBundle() {},
+      async commitBundle() {},
+      async deleteBundle() {},
+      async getBundleById() {
+        return null;
+      },
+      getBundles,
+      getUpdateInfo,
+      async getChannels() {
+        return ["production"];
+      },
+      async updateBundle() {},
+    };
+
+    const core = createPluginDatabaseCore(
+      () => plugin,
+      async () => null,
+    );
+
+    await expect(core.api.getUpdateInfo(updateArgs)).resolves.toBeNull();
+    expect(getUpdateInfo).toHaveBeenCalledWith(updateArgs);
+    expect(getBundles).not.toHaveBeenCalled();
+  });
+
+  it("falls back to scanning when plugin getUpdateInfo is absent", async () => {
+    const latestBundle = {
+      ...baseBundle,
+      id: "00000000-0000-0000-0000-000000000002",
+    };
+    const getBundles = vi.fn<DatabasePlugin["getBundles"]>(async () => ({
+      data: [latestBundle],
+      pagination: {
+        currentPage: 1,
+        hasNextPage: false,
+        hasPreviousPage: false,
+        total: 1,
+        totalPages: 1,
+      },
+    }));
+
+    const plugin: DatabasePlugin = {
+      name: "scan-plugin",
+      async appendBundle() {},
+      async commitBundle() {},
+      async deleteBundle() {},
+      async getBundleById() {
+        return null;
+      },
+      getBundles,
+      async getChannels() {
+        return ["production"];
+      },
+      async updateBundle() {},
+    };
+
+    const core = createPluginDatabaseCore(
+      () => plugin,
+      async () => null,
+    );
+
+    await expect(core.api.getUpdateInfo(updateArgs)).resolves.toEqual({
+      fileHash: latestBundle.fileHash,
+      id: latestBundle.id,
+      message: latestBundle.message,
+      shouldForceUpdate: latestBundle.shouldForceUpdate,
+      status: "UPDATE",
+      storageUri: latestBundle.storageUri,
+    });
+    expect(getBundles).toHaveBeenCalledOnce();
+  });
+});

package/src/db/pluginCore.ts

@@ -172,15 +172,21 @@ export function createPluginDatabaseCore<TContext = unknown>(
     isCandidate: (bundle: Bundle) => boolean;
     context?: HotUpdaterContext<TContext>;
   }): Promise<UpdateInfo | null> => {
-    let offset = 0;
+    let after: string | undefined;
 
     while (true) {
       const { data, pagination } = await getSortedBundlePage(
         {
           where: queryWhere,
           limit: PAGE_SIZE,
-          offset,
           orderBy: DESC_ORDER,
+          ...(after
+            ? {
+                cursor: {
+                  after,
+                },
+              }
+            : {}),
         },
         context,
       );
@@ -223,7 +229,10 @@ export function createPluginDatabaseCore<TContext = unknown>(
         break;
       }
 
-      offset += PAGE_SIZE;
+      after = data.at(-1)?.id;
+      if (!after) {
+        break;
+      }
     }
 
     if (args.bundleId === NIL_UUID) {
@@ -269,6 +278,14 @@ export function createPluginDatabaseCore<TContext = unknown>(
       args: GetBundlesArgs,
       context?: HotUpdaterContext<TContext>,
     ): Promise<UpdateInfo | null> {
+      const plugin = getPlugin();
+      const directGetUpdateInfo = plugin.getUpdateInfo;
+      if (directGetUpdateInfo) {
+        return context === undefined
+          ? await directGetUpdateInfo(args)
+          : await directGetUpdateInfo(args, context);
+      }
+
       const channel = args.channel ?? "production";
       const minBundleId = args.minBundleId ?? NIL_UUID;
       const baseWhere = getBaseWhere({

package/src/db/pluginUpdateCheck.bench.ts

@@ -6,7 +6,7 @@ import type {
   DatabasePlugin,
 } from "../../../../plugins/plugin-core/src";
 import {
-  calculatePagination,
+  paginateBundles,
   semverSatisfies,
 } from "../../../../plugins/plugin-core/src";
 import type {
@@ -124,17 +124,19 @@ const createBenchPlugin = (bundles: Bundle[]): DatabasePlugin => {
       return bundlesById.get(bundleId) ?? null;
     },
     async getBundles(options: DatabaseBundleQueryOptions) {
-      const { where, limit, offset, orderBy } = options;
+      const { where, limit, cursor, 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 }),
-      };
+      const paginated = paginateBundles({
+        bundles: matched.map(cloneBundle),
+        limit,
+        cursor,
+        orderBy,
+      });
+
+      return paginated;
     },
     async getChannels() {
       return [...new Set(bundles.map((bundle) => bundle.channel))];
@@ -164,7 +166,6 @@ const oldPluginCoreGetUpdateInfo = async (
   const { pagination } = await plugin.getBundles({
     where,
     limit: 1,
-    offset: 0,
   });
 
   if (pagination.total === 0) {
@@ -174,7 +175,6 @@ const oldPluginCoreGetUpdateInfo = async (
   const { data } = await plugin.getBundles({
     where,
     limit: pagination.total,
-    offset: 0,
   });
 
   for (const bundle of data) {

package/src/handler-standalone.integration.spec.ts

@@ -234,7 +234,7 @@ describe("Handler <-> Standalone Repository Integration", () => {
     })();
 
     // Get all bundles
-    const result = await repo.getBundles({ limit: 50, offset: 0 });
+    const result = await repo.getBundles({ limit: 50 });
 
     expect(result.data).toHaveLength(3);
     expect(result.pagination.total).toBe(3);
@@ -243,7 +243,6 @@ describe("Handler <-> Standalone Repository Integration", () => {
     const prodResult = await repo.getBundles({
       where: { channel: "production" },
       limit: 50,
-      offset: 0,
     });
 
     expect(prodResult.data).toHaveLength(2);