@hot-updater/server 0.27.1 → 0.29.0

package/src/db/ormUpdateCheck.bench.ts

@@ -0,0 +1,261 @@
+import { PGlite } from "@electric-sql/pglite";
+import { Kysely } from "kysely";
+import { PGliteDialect } from "kysely-pglite-dialect";
+import { bench, describe } from "vitest";
+import { filterCompatibleAppVersions } from "../../../../plugins/plugin-core/src";
+import type {
+  AppVersionGetBundlesArgs,
+  Platform,
+  UpdateInfo,
+} from "../../../core/src";
+import {
+  DEFAULT_ROLLOUT_COHORT_COUNT,
+  isCohortEligibleForUpdate,
+  NIL_UUID,
+} from "../../../core/src";
+import { kyselyAdapter } from "../adapters/kysely";
+import { createOrmDatabaseCore } from "./ormCore";
+
+const BUNDLE_COUNT = 8_000;
+const BENCH_APP_VERSION = "1.0.0";
+const BENCH_PLATFORM = "ios" as const;
+const BENCH_CHANNEL = "production";
+
+interface BenchBundleRow {
+  id: string;
+  platform: Platform;
+  should_force_update: boolean;
+  enabled: boolean;
+  file_hash: string;
+  git_commit_hash: string;
+  message: string;
+  channel: string;
+  storage_uri: string;
+  target_app_version: string | null;
+  fingerprint_hash: string | null;
+  metadata: Record<string, unknown>;
+  rollout_cohort_count: number | null;
+  target_cohorts: string[] | null;
+}
+
+const createBundleRow = (index: number): BenchBundleRow => ({
+  id: `00000000-0000-0000-0000-${String(index).padStart(12, "0")}`,
+  platform: BENCH_PLATFORM,
+  should_force_update: false,
+  enabled: true,
+  file_hash: `hash-${index}`,
+  git_commit_hash: `commit-${index}`,
+  message: `bundle-${index}`,
+  channel: BENCH_CHANNEL,
+  storage_uri: `s3://bench/bundles/${index}.zip`,
+  target_app_version: "*",
+  fingerprint_hash: `fingerprint-${index % 10}`,
+  metadata: { index },
+  rollout_cohort_count: DEFAULT_ROLLOUT_COHORT_COUNT,
+  target_cohorts: null,
+});
+
+interface BenchDatabase {
+  bundles: BenchBundleRow;
+}
+
+const parseTargetCohorts = (value: unknown): string[] | null => {
+  if (!value) return null;
+  if (Array.isArray(value)) {
+    return value.filter((entry): entry is string => typeof entry === "string");
+  }
+  if (typeof value === "string") {
+    try {
+      const parsed = JSON.parse(value) as unknown;
+      if (Array.isArray(parsed)) {
+        return parsed.filter(
+          (entry): entry is string => typeof entry === "string",
+        );
+      }
+    } catch {
+      return null;
+    }
+  }
+  return null;
+};
+
+const oldOrmCoreGetUpdateInfo = async (
+  db: Kysely<BenchDatabase>,
+  args: AppVersionGetBundlesArgs,
+): Promise<UpdateInfo | null> => {
+  const toUpdateInfo = (
+    row: {
+      id: string;
+      should_force_update: boolean;
+      message: string | null;
+      storage_uri: string | null;
+      file_hash: string;
+    },
+    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 isEligibleForUpdate = (
+    row: {
+      id: string;
+      rollout_cohort_count?: number | null;
+      target_cohorts?: unknown | null;
+    },
+    cohort: string | undefined,
+  ) => {
+    return isCohortEligibleForUpdate(
+      row.id,
+      cohort,
+      row.rollout_cohort_count ?? null,
+      parseTargetCohorts(row.target_cohorts),
+    );
+  };
+
+  const versionRows = await db
+    .selectFrom("bundles")
+    .select("target_app_version")
+    .where("platform", "=", args.platform)
+    .execute();
+
+  const allTargetVersions = Array.from(
+    new Set(
+      versionRows
+        .map((row) => row.target_app_version)
+        .filter((value): value is string => Boolean(value)),
+    ),
+  );
+
+  const compatibleVersions = filterCompatibleAppVersions(
+    allTargetVersions,
+    args.appVersion,
+  );
+
+  const baseRows =
+    compatibleVersions.length === 0
+      ? []
+      : await db
+          .selectFrom("bundles")
+          .select([
+            "id",
+            "should_force_update",
+            "message",
+            "storage_uri",
+            "file_hash",
+            "rollout_cohort_count",
+            "target_cohorts",
+            "target_app_version",
+          ])
+          .where("enabled", "=", true)
+          .where("platform", "=", args.platform)
+          .where("id", ">=", args.minBundleId ?? NIL_UUID)
+          .where("channel", "=", args.channel ?? BENCH_CHANNEL)
+          .where("target_app_version", "is not", null)
+          .execute();
+
+  const candidates = baseRows
+    .filter((row) =>
+      row.target_app_version
+        ? compatibleVersions.includes(row.target_app_version)
+        : false,
+    )
+    .sort((a, b) => b.id.localeCompare(a.id));
+
+  const updateCandidate =
+    candidates.find(
+      (row) =>
+        row.id.localeCompare(args.bundleId) > 0 &&
+        isEligibleForUpdate(row, args.cohort),
+    ) ?? null;
+
+  if (args.bundleId === NIL_UUID) {
+    return updateCandidate ? toUpdateInfo(updateCandidate, "UPDATE") : null;
+  }
+
+  const currentBundle = candidates.find((row) => row.id === args.bundleId);
+  const currentBundleEligible = currentBundle
+    ? isEligibleForUpdate(currentBundle, args.cohort)
+    : false;
+  const rollbackCandidate =
+    candidates.find((row) => row.id.localeCompare(args.bundleId) < 0) ?? null;
+
+  if (currentBundleEligible) {
+    return updateCandidate ? toUpdateInfo(updateCandidate, "UPDATE") : null;
+  }
+  if (updateCandidate) {
+    return toUpdateInfo(updateCandidate, "UPDATE");
+  }
+  if (rollbackCandidate) {
+    return toUpdateInfo(rollbackCandidate, "ROLLBACK");
+  }
+  if (args.minBundleId && args.bundleId.localeCompare(args.minBundleId) <= 0) {
+    return null;
+  }
+  return {
+    id: NIL_UUID,
+    message: null,
+    shouldForceUpdate: true,
+    status: "ROLLBACK",
+    storageUri: null,
+    fileHash: null,
+  };
+};
+
+const pg = new PGlite();
+const kysely = new Kysely<BenchDatabase>({ dialect: new PGliteDialect(pg) });
+const ormCore = createOrmDatabaseCore({
+  database: kyselyAdapter({
+    db: kysely,
+    provider: "postgresql",
+  }),
+  resolveFileUrl: async () => null,
+});
+
+const migration = await ormCore.createMigrator().migrateToLatest({
+  mode: "from-schema",
+  updateSettings: true,
+});
+await migration.execute();
+
+const rows = Array.from({ length: BUNDLE_COUNT }, (_, index) =>
+  createBundleRow(index + 1),
+);
+
+for (let index = 0; index < rows.length; index += 500) {
+  await kysely
+    .insertInto("bundles")
+    .values(rows.slice(index, index + 500))
+    .execute();
+}
+
+describe("orm update check benchmark", () => {
+  const args: AppVersionGetBundlesArgs = {
+    _updateStrategy: "appVersion",
+    appVersion: BENCH_APP_VERSION,
+    bundleId: NIL_UUID,
+    platform: BENCH_PLATFORM,
+    channel: BENCH_CHANNEL,
+  };
+
+  bench(
+    "ormCore legacy appVersion scan",
+    async () => {
+      await oldOrmCoreGetUpdateInfo(kysely, args);
+    },
+    { warmupIterations: 3, iterations: 15 },
+  );
+
+  bench(
+    "ormCore current paged appVersion scan",
+    async () => {
+      await ormCore.api.getUpdateInfo(args);
+    },
+    { warmupIterations: 3, iterations: 15 },
+  );
+});

package/src/db/pluginCore.ts

@@ -1,104 +1,353 @@
 import type {
   AppUpdateInfo,
+  AppVersionGetBundlesArgs,
   Bundle,
+  FingerprintGetBundlesArgs,
   GetBundlesArgs,
+  Platform,
   UpdateInfo,
 } from "@hot-updater/core";
-import { getUpdateInfo as getUpdateInfoJS } from "@hot-updater/js";
-import type { DatabasePlugin } from "@hot-updater/plugin-core";
+import { isCohortEligibleForUpdate, NIL_UUID } from "@hot-updater/core";
+import {
+  type DatabaseBundleQueryOptions,
+  type DatabaseBundleQueryOrder,
+  type DatabaseBundleQueryWhere,
+  type DatabasePlugin,
+  type HotUpdaterContext,
+  semverSatisfies,
+} from "@hot-updater/plugin-core";
 import type { DatabaseAPI } from "./types";
 
-export function createPluginDatabaseCore(
-  plugin: DatabasePlugin,
-  resolveFileUrl: (storageUri: string | null) => Promise<string | null>,
+const PAGE_SIZE = 100;
+
+const DESC_ORDER = { field: "id", direction: "desc" } as const;
+
+const bundleMatchesQueryWhere = (
+  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 sortBundles = (
+  bundles: Bundle[],
+  orderBy: DatabaseBundleQueryOrder | undefined,
+) => {
+  const direction = orderBy?.direction ?? "desc";
+  return bundles.slice().sort((a, b) => {
+    const result = a.id.localeCompare(b.id);
+    return direction === "asc" ? result : -result;
+  });
+};
+
+const makeResponse = (
+  bundle: Bundle,
+  status: "UPDATE" | "ROLLBACK",
+): UpdateInfo => ({
+  id: bundle.id,
+  message: bundle.message,
+  shouldForceUpdate: status === "ROLLBACK" ? true : bundle.shouldForceUpdate,
+  status,
+  storageUri: bundle.storageUri,
+  fileHash: bundle.fileHash,
+});
+
+const INIT_BUNDLE_ROLLBACK_UPDATE_INFO: UpdateInfo = {
+  message: null,
+  id: NIL_UUID,
+  shouldForceUpdate: true,
+  status: "ROLLBACK",
+  storageUri: null,
+  fileHash: null,
+};
+
+export function createPluginDatabaseCore<TContext = unknown>(
+  plugin: DatabasePlugin<TContext>,
+  resolveFileUrl: (
+    storageUri: string | null,
+    context?: HotUpdaterContext<TContext>,
+  ) => Promise<string | null>,
 ): {
-  api: DatabaseAPI;
+  api: DatabaseAPI<TContext>;
   adapterName: string;
   createMigrator: () => never;
   generateSchema: () => never;
 } {
-  const api: DatabaseAPI = {
-    async getBundleById(id: string): Promise<Bundle | null> {
-      return plugin.getBundleById(id);
-    },
+  const getSortedBundlePage = async (
+    options: DatabaseBundleQueryOptions,
+    context?: HotUpdaterContext<TContext>,
+  ): Promise<Awaited<ReturnType<DatabasePlugin<TContext>["getBundles"]>>> => {
+    const result = await plugin.getBundles(
+      {
+        ...options,
+        orderBy: options.orderBy ?? DESC_ORDER,
+      },
+      context,
+    );
+
+    return {
+      ...result,
+      data: sortBundles(result.data, options.orderBy ?? DESC_ORDER),
+    };
+  };
+
+  const isEligibleForUpdate = (
+    bundle: Bundle,
+    cohort: string | undefined,
+  ): boolean => {
+    return isCohortEligibleForUpdate(
+      bundle.id,
+      cohort,
+      bundle.rolloutCohortCount,
+      bundle.targetCohorts,
+    );
+  };
+
+  const findUpdateInfoByScanning = async ({
+    args,
+    queryWhere,
+    isCandidate,
+    context,
+  }: {
+    args: AppVersionGetBundlesArgs | FingerprintGetBundlesArgs;
+    queryWhere: DatabaseBundleQueryWhere;
+    isCandidate: (bundle: Bundle) => boolean;
+    context?: HotUpdaterContext<TContext>;
+  }): Promise<UpdateInfo | null> => {
+    let offset = 0;
+
+    while (true) {
+      const { data, pagination } = await getSortedBundlePage(
+        {
+          where: queryWhere,
+          limit: PAGE_SIZE,
+          offset,
+          orderBy: DESC_ORDER,
+        },
+        context,
+      );
+
+      for (const bundle of data) {
+        if (
+          !bundleMatchesQueryWhere(bundle, queryWhere) ||
+          !isCandidate(bundle)
+        ) {
+          continue;
+        }
+
+        if (args.bundleId === NIL_UUID) {
+          if (isEligibleForUpdate(bundle, args.cohort)) {
+            return makeResponse(bundle, "UPDATE");
+          }
+          continue;
+        }
+
+        const compareResult = bundle.id.localeCompare(args.bundleId);
 
-    async getUpdateInfo(args: GetBundlesArgs): Promise<UpdateInfo | null> {
-      const where: { channel?: string; platform?: string } = {};
+        if (compareResult > 0) {
+          if (isEligibleForUpdate(bundle, args.cohort)) {
+            return makeResponse(bundle, "UPDATE");
+          }
+          continue;
+        }
 
-      if ("platform" in args && args.platform) {
-        where.platform = args.platform;
+        if (compareResult === 0) {
+          if (isEligibleForUpdate(bundle, args.cohort)) {
+            return null;
+          }
+          continue;
+        }
+
+        return makeResponse(bundle, "ROLLBACK");
+      }
+
+      if (!pagination.hasNextPage) {
+        break;
       }
 
-      const channel =
-        "channel" in args && args.channel ? args.channel : "production";
-      where.channel = channel;
+      offset += PAGE_SIZE;
+    }
+
+    if (args.bundleId === NIL_UUID) {
+      return null;
+    }
+
+    if (
+      args.minBundleId &&
+      args.bundleId.localeCompare(args.minBundleId) <= 0
+    ) {
+      return null;
+    }
+
+    return INIT_BUNDLE_ROLLBACK_UPDATE_INFO;
+  };
+
+  const getBaseWhere = ({
+    platform,
+    channel,
+    minBundleId,
+  }: {
+    platform: Platform;
+    channel: string;
+    minBundleId: string;
+  }): DatabaseBundleQueryWhere => ({
+    platform,
+    channel,
+    enabled: true,
+    id: {
+      gte: minBundleId,
+    },
+  });
+
+  const api: DatabaseAPI<TContext> = {
+    async getBundleById(
+      id: string,
+      context?: HotUpdaterContext<TContext>,
+    ): Promise<Bundle | null> {
+      return plugin.getBundleById(id, context);
+    },
 
-      const { pagination } = await plugin.getBundles({
-        where,
-        limit: 1,
-        offset: 0,
+    async getUpdateInfo(
+      args: GetBundlesArgs,
+      context?: HotUpdaterContext<TContext>,
+    ): Promise<UpdateInfo | null> {
+      const channel = args.channel ?? "production";
+      const minBundleId = args.minBundleId ?? NIL_UUID;
+      const baseWhere = getBaseWhere({
+        platform: args.platform,
+        channel,
+        minBundleId,
       });
 
-      if (pagination.total === 0) {
-        return getUpdateInfoJS([], args);
+      if (args._updateStrategy === "fingerprint") {
+        return findUpdateInfoByScanning({
+          args,
+          queryWhere: {
+            ...baseWhere,
+            fingerprintHash: args.fingerprintHash,
+          },
+          context,
+          isCandidate: (bundle) => {
+            return (
+              bundle.enabled &&
+              bundle.platform === args.platform &&
+              bundle.channel === channel &&
+              bundle.id.localeCompare(minBundleId) >= 0 &&
+              bundle.fingerprintHash === args.fingerprintHash
+            );
+          },
+        });
       }
 
-      const { data } = await plugin.getBundles({
-        where,
-        limit: pagination.total,
-        offset: 0,
+      return findUpdateInfoByScanning({
+        args,
+        queryWhere: {
+          ...baseWhere,
+        },
+        context,
+        isCandidate: (bundle) => {
+          return (
+            bundle.enabled &&
+            bundle.platform === args.platform &&
+            bundle.channel === channel &&
+            bundle.id.localeCompare(minBundleId) >= 0 &&
+            !!bundle.targetAppVersion &&
+            semverSatisfies(bundle.targetAppVersion, args.appVersion)
+          );
+        },
       });
-
-      const bundles = data;
-      return getUpdateInfoJS(bundles, args);
     },
 
     async getAppUpdateInfo(
       args: GetBundlesArgs,
+      context?: HotUpdaterContext<TContext>,
     ): Promise<AppUpdateInfo | null> {
-      const info = await this.getUpdateInfo(args);
+      const info = await this.getUpdateInfo(args, context);
       if (!info) {
         return null;
       }
       const { storageUri, ...rest } = info as UpdateInfo & {
         storageUri: string | null;
       };
-      const fileUrl = await resolveFileUrl(storageUri ?? null);
+      const fileUrl = await resolveFileUrl(storageUri ?? null, context);
       return { ...rest, fileUrl };
     },
 
-    async getChannels(): Promise<string[]> {
-      return plugin.getChannels();
+    async getChannels(
+      context?: HotUpdaterContext<TContext>,
+    ): Promise<string[]> {
+      return plugin.getChannels(context);
     },
 
-    async getBundles(options: {
-      where?: { channel?: string; platform?: string };
-      limit: number;
-      offset: number;
-    }) {
-      return plugin.getBundles(options);
+    async getBundles(options, context?: HotUpdaterContext<TContext>) {
+      return plugin.getBundles(options, context);
     },
 
-    async insertBundle(bundle: Bundle): Promise<void> {
-      await plugin.appendBundle(bundle);
-      await plugin.commitBundle();
+    async insertBundle(
+      bundle: Bundle,
+      context?: HotUpdaterContext<TContext>,
+    ): Promise<void> {
+      await plugin.appendBundle(bundle, context);
+      await plugin.commitBundle(context);
     },
 
     async updateBundleById(
       bundleId: string,
       newBundle: Partial<Bundle>,
+      context?: HotUpdaterContext<TContext>,
     ): Promise<void> {
-      await plugin.updateBundle(bundleId, newBundle);
-      await plugin.commitBundle();
+      await plugin.updateBundle(bundleId, newBundle, context);
+      await plugin.commitBundle(context);
     },
 
-    async deleteBundleById(bundleId: string): Promise<void> {
-      const bundle = await plugin.getBundleById(bundleId);
+    async deleteBundleById(
+      bundleId: string,
+      context?: HotUpdaterContext<TContext>,
+    ): Promise<void> {
+      const bundle = await plugin.getBundleById(bundleId, context);
       if (!bundle) {
         return;
       }
-      await plugin.deleteBundle(bundle);
-      await plugin.commitBundle();
+      await plugin.deleteBundle(bundle, context);
+      await plugin.commitBundle(context);
     },
   };