@hot-updater/server 0.28.0 → 0.29.0

package/src/db/ormCore.ts

@@ -7,43 +7,176 @@ import type {
   Platform,
   UpdateInfo,
 } from "@hot-updater/core";
-import { NIL_UUID } from "@hot-updater/core";
-import { filterCompatibleAppVersions } from "@hot-updater/plugin-core";
+import {
+  DEFAULT_ROLLOUT_COHORT_COUNT,
+  isCohortEligibleForUpdate,
+  NIL_UUID,
+} from "@hot-updater/core";
+import type {
+  DatabaseBundleQueryOptions,
+  DatabaseBundleQueryWhere,
+  HotUpdaterContext,
+} from "@hot-updater/plugin-core";
+import { semverSatisfies } from "@hot-updater/plugin-core";
 import type { InferFumaDB } from "fumadb";
 import { fumadb } from "fumadb";
 import type { FumaDBAdapter } from "fumadb/adapters";
 import { calculatePagination } from "../calculatePagination";
 import { v0_21_0 } from "../schema/v0_21_0";
+import { v0_29_0 } from "../schema/v0_29_0";
 import type { PaginationInfo } from "../types";
 import type { DatabaseAPI } from "./types";
 
+const parseTargetCohorts = (value: unknown): string[] | null => {
+  if (!value) return null;
+  if (Array.isArray(value)) {
+    return value.filter((v): v is string => typeof v === "string");
+  }
+  if (typeof value === "string") {
+    try {
+      const parsed = JSON.parse(value) as unknown;
+      if (Array.isArray(parsed)) {
+        return parsed.filter((v): v is string => typeof v === "string");
+      }
+    } catch {
+      return null;
+    }
+  }
+  return null;
+};
+
+const schemas: [typeof v0_21_0, typeof v0_29_0] = [v0_21_0, v0_29_0];
+
+const getLastItem = <T extends unknown[]>(
+  items: T,
+): T extends [...infer _, infer Last] ? Last : never =>
+  items.at(-1) as T extends [...infer _, infer Last] ? Last : never;
+
 export const HotUpdaterDB = fumadb({
   namespace: "hot_updater",
-  schemas: [v0_21_0],
+  schemas,
 });
-
 export type HotUpdaterClient = InferFumaDB<typeof HotUpdaterDB>;
 
 export type Migrator = ReturnType<HotUpdaterClient["createMigrator"]>;
 
-export function createOrmDatabaseCore({
+export function createOrmDatabaseCore<TContext = unknown>({
   database,
   resolveFileUrl,
 }: {
   database: FumaDBAdapter;
-  resolveFileUrl: (storageUri: string | null) => Promise<string | null>;
+  resolveFileUrl: (
+    storageUri: string | null,
+    context?: HotUpdaterContext<TContext>,
+  ) => Promise<string | null>;
 }): {
-  api: DatabaseAPI;
+  api: DatabaseAPI<TContext>;
   adapterName: string;
   createMigrator: () => Migrator;
   generateSchema: HotUpdaterClient["generateSchema"];
 } {
   const client = HotUpdaterDB.client(database);
+  const UPDATE_CHECK_PAGE_SIZE = 100;
+  const isMongoAdapter = client.adapter.name.toLowerCase().includes("mongodb");
+
+  const ensureORM = async () => {
+    const latestSchema = getLastItem(schemas);
+    const lastSchemaVersion = latestSchema.version;
+
+    try {
+      const migrator = client.createMigrator();
+      const currentVersion = await migrator.getVersion();
+
+      if (currentVersion === undefined) {
+        throw new Error(
+          "Database is not initialized. Please run 'npx hot-updater migrate' to set up the database schema.",
+        );
+      }
+
+      if (currentVersion !== lastSchemaVersion) {
+        throw new Error(
+          `Database schema version mismatch. Expected version ${lastSchemaVersion}, but database is on version ${currentVersion}. ` +
+            "Please run 'npx hot-updater migrate' to update your database schema.",
+        );
+      }
+
+      return client.orm(lastSchemaVersion);
+    } catch (error) {
+      if (
+        error instanceof Error &&
+        error.message.includes("doesn't support migration")
+      ) {
+        return client.orm(lastSchemaVersion);
+      }
+      throw error;
+    }
+  };
+
+  const buildBundleWhere = (where?: DatabaseBundleQueryWhere) => (b: any) => {
+    if (where?.id?.in && where.id.in.length === 0) {
+      return false;
+    }
+
+    if (where?.targetAppVersionIn && where.targetAppVersionIn.length === 0) {
+      return false;
+    }
+
+    const conditions = [];
+
+    if (where?.channel !== undefined) {
+      conditions.push(b("channel", "=", where.channel));
+    }
+    if (where?.platform !== undefined) {
+      conditions.push(b("platform", "=", where.platform));
+    }
+    if (where?.enabled !== undefined) {
+      conditions.push(b("enabled", "=", where.enabled));
+    }
+    if (where?.id?.eq !== undefined) {
+      conditions.push(b("id", "=", where.id.eq));
+    }
+    if (where?.id?.gt !== undefined) {
+      conditions.push(b("id", ">", where.id.gt));
+    }
+    if (where?.id?.gte !== undefined) {
+      conditions.push(b("id", ">=", where.id.gte));
+    }
+    if (where?.id?.lt !== undefined) {
+      conditions.push(b("id", "<", where.id.lt));
+    }
+    if (where?.id?.lte !== undefined) {
+      conditions.push(b("id", "<=", where.id.lte));
+    }
+    if (where?.id?.in) {
+      conditions.push(b("id", "in", where.id.in));
+    }
+    if (where?.targetAppVersionNotNull) {
+      conditions.push(b.isNotNull("target_app_version"));
+    }
+    if (where?.targetAppVersion !== undefined) {
+      conditions.push(
+        where.targetAppVersion === null
+          ? b.isNull("target_app_version")
+          : b("target_app_version", "=", where.targetAppVersion),
+      );
+    }
+    if (where?.targetAppVersionIn) {
+      conditions.push(b("target_app_version", "in", where.targetAppVersionIn));
+    }
+    if (where?.fingerprintHash !== undefined) {
+      conditions.push(
+        where.fingerprintHash === null
+          ? b.isNull("fingerprint_hash")
+          : b("fingerprint_hash", "=", where.fingerprintHash),
+      );
+    }
+
+    return conditions.length > 0 ? b.and(...conditions) : true;
+  };
 
-  const api: DatabaseAPI = {
+  const api: DatabaseAPI<TContext> = {
     async getBundleById(id: string): Promise<Bundle | null> {
-      const version = await client.version();
-      const orm = client.orm(version);
+      const orm = await ensureORM();
       const result = await orm.findFirst("bundles", {
         select: [
           "id",
@@ -58,6 +191,8 @@ export function createOrmDatabaseCore({
           "target_app_version",
           "fingerprint_hash",
           "metadata",
+          "rollout_cohort_count",
+          "target_cohorts",
         ],
         where: (b) => b("id", "=", id),
       });
@@ -74,13 +209,15 @@ export function createOrmDatabaseCore({
         storageUri: result.storage_uri,
         targetAppVersion: result.target_app_version ?? null,
         fingerprintHash: result.fingerprint_hash ?? null,
+        rolloutCohortCount:
+          result.rollout_cohort_count ?? DEFAULT_ROLLOUT_COHORT_COUNT,
+        targetCohorts: parseTargetCohorts(result.target_cohorts),
       };
       return bundle;
     },
 
     async getUpdateInfo(args: GetBundlesArgs): Promise<UpdateInfo | null> {
-      const version = await client.version();
-      const orm = client.orm(version);
+      const orm = await ensureORM();
 
       type UpdateSelectRow = {
         id: string;
@@ -88,6 +225,10 @@ export function createOrmDatabaseCore({
         message: string | null;
         storage_uri: string | null;
         file_hash: string;
+        rollout_cohort_count?: number | null;
+        target_cohorts?: unknown | null;
+        target_app_version?: string | null;
+        fingerprint_hash?: string | null;
       };
 
       const toUpdateInfo = (
@@ -112,167 +253,225 @@ export function createOrmDatabaseCore({
         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 isEligibleForUpdate = (
+        row: UpdateSelectRow,
+        cohort: string | undefined,
+      ): boolean => {
+        return isCohortEligibleForUpdate(
+          row.id,
+          cohort,
+          row.rollout_cohort_count ?? null,
+          parseTargetCohorts(row.target_cohorts),
         );
+      };
 
-        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;
+      const findUpdateInfoByScanning = async ({
+        args,
+        where,
+        isCandidate,
+      }: {
+        args: AppVersionGetBundlesArgs | FingerprintGetBundlesArgs;
+        where: DatabaseBundleQueryWhere;
+        isCandidate: (row: UpdateSelectRow) => boolean;
+      }): Promise<UpdateInfo | null> => {
+        if (isMongoAdapter) {
+          const rows = await orm.findMany("bundles", {
+            select: [
+              "id",
+              "should_force_update",
+              "message",
+              "storage_uri",
+              "file_hash",
+              "rollout_cohort_count",
+              "target_cohorts",
+              "target_app_version",
+              "fingerprint_hash",
+            ],
+            where: buildBundleWhere(where),
+          });
+
+          rows.sort((a, b) => b.id.localeCompare(a.id));
+
+          for (const row of rows) {
+            if (!isCandidate(row)) {
+              continue;
+            }
+
+            if (args.bundleId === NIL_UUID) {
+              if (isEligibleForUpdate(row, args.cohort)) {
+                return toUpdateInfo(row, "UPDATE");
+              }
+              continue;
+            }
+
+            const compareResult = row.id.localeCompare(args.bundleId);
+
+            if (compareResult > 0) {
+              if (isEligibleForUpdate(row, args.cohort)) {
+                return toUpdateInfo(row, "UPDATE");
+              }
+              continue;
+            }
+
+            if (compareResult === 0) {
+              if (isEligibleForUpdate(row, args.cohort)) {
+                return null;
+              }
+              continue;
+            }
+
+            return toUpdateInfo(row, "ROLLBACK");
+          }
 
-        if (bundleId === NIL_UUID) {
-          if (latestCandidate && latestCandidate.id !== bundleId) {
-            return toUpdateInfo(latestCandidate, "UPDATE");
+          if (args.bundleId === NIL_UUID) {
+            return null;
           }
-          return null;
-        }
 
-        if (currentBundle) {
           if (
-            latestCandidate &&
-            latestCandidate.id.localeCompare(currentBundle.id) > 0
+            args.minBundleId &&
+            args.bundleId.localeCompare(args.minBundleId) <= 0
           ) {
-            return toUpdateInfo(latestCandidate, "UPDATE");
+            return null;
           }
-          return null;
+
+          return INIT_BUNDLE_ROLLBACK_UPDATE_INFO;
         }
 
-        if (updateCandidate) {
-          return toUpdateInfo(updateCandidate, "UPDATE");
+        let offset = 0;
+
+        while (true) {
+          const rows = await orm.findMany("bundles", {
+            select: [
+              "id",
+              "should_force_update",
+              "message",
+              "storage_uri",
+              "file_hash",
+              "rollout_cohort_count",
+              "target_cohorts",
+              "target_app_version",
+              "fingerprint_hash",
+            ],
+            where: buildBundleWhere(where),
+            orderBy: [["id", "desc"]],
+            limit: UPDATE_CHECK_PAGE_SIZE,
+            offset,
+          });
+
+          for (const row of rows) {
+            if (!isCandidate(row)) {
+              continue;
+            }
+
+            if (args.bundleId === NIL_UUID) {
+              if (isEligibleForUpdate(row, args.cohort)) {
+                return toUpdateInfo(row, "UPDATE");
+              }
+              continue;
+            }
+
+            const compareResult = row.id.localeCompare(args.bundleId);
+
+            if (compareResult > 0) {
+              if (isEligibleForUpdate(row, args.cohort)) {
+                return toUpdateInfo(row, "UPDATE");
+              }
+              continue;
+            }
+
+            if (compareResult === 0) {
+              if (isEligibleForUpdate(row, args.cohort)) {
+                return null;
+              }
+              continue;
+            }
+
+            return toUpdateInfo(row, "ROLLBACK");
+          }
+
+          if (rows.length < UPDATE_CHECK_PAGE_SIZE) {
+            break;
+          }
+
+          offset += UPDATE_CHECK_PAGE_SIZE;
         }
-        if (rollbackCandidate) {
-          return toUpdateInfo(rollbackCandidate, "ROLLBACK");
+
+        if (args.bundleId === NIL_UUID) {
+          return null;
         }
 
-        if (minBundleId && bundleId.localeCompare(minBundleId) <= 0) {
+        if (
+          args.minBundleId &&
+          args.bundleId.localeCompare(args.minBundleId) <= 0
+        ) {
           return null;
         }
+
         return INIT_BUNDLE_ROLLBACK_UPDATE_INFO;
       };
 
+      const appVersionStrategy = async ({
+        platform,
+        appVersion,
+        bundleId,
+        minBundleId = NIL_UUID,
+        channel = "production",
+        cohort,
+      }: AppVersionGetBundlesArgs): Promise<UpdateInfo | null> => {
+        return findUpdateInfoByScanning({
+          args: {
+            _updateStrategy: "appVersion",
+            platform,
+            appVersion,
+            bundleId,
+            minBundleId,
+            channel,
+            cohort,
+          },
+          where: {
+            enabled: true,
+            platform,
+            channel,
+            id: {
+              gte: minBundleId,
+            },
+            targetAppVersionNotNull: true,
+          },
+          isCandidate: (row) =>
+            !!row.target_app_version &&
+            semverSatisfies(row.target_app_version, appVersion),
+        });
+      };
+
       const fingerprintStrategy = async ({
         platform,
         fingerprintHash,
         bundleId,
         minBundleId = NIL_UUID,
         channel = "production",
+        cohort,
       }: 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),
-            ),
+        return findUpdateInfoByScanning({
+          args: {
+            _updateStrategy: "fingerprint",
+            platform,
+            fingerprintHash,
+            bundleId,
+            minBundleId,
+            channel,
+            cohort,
+          },
+          where: {
+            enabled: true,
+            platform,
+            channel,
+            id: {
+              gte: minBundleId,
+            },
+            fingerprintHash,
+          },
+          isCandidate: (row) => row.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") {
@@ -286,92 +485,117 @@ export function createOrmDatabaseCore({
 
     async getAppUpdateInfo(
       args: GetBundlesArgs,
+      context?: HotUpdaterContext<TContext>,
     ): 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);
+      const fileUrl = await resolveFileUrl(storageUri ?? null, context);
       return { ...rest, fileUrl };
     },
 
     async getChannels(): Promise<string[]> {
-      const version = await client.version();
-      const orm = client.orm(version);
+      const orm = await ensureORM();
       const rows = await orm.findMany("bundles", {
         select: ["channel"],
+        orderBy: [["channel", "asc"]],
       });
       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;
+    async getBundles(
+      options: DatabaseBundleQueryOptions,
+    ): Promise<{ data: Bundle[]; pagination: PaginationInfo }> {
+      const orm = await ensureORM();
+      const { where, limit, offset, orderBy } = 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 total = await orm.count("bundles", {
+        where: buildBundleWhere(where),
       });
 
-      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);
+      const selectedColumns: Array<
+        | "id"
+        | "platform"
+        | "should_force_update"
+        | "enabled"
+        | "file_hash"
+        | "git_commit_hash"
+        | "message"
+        | "channel"
+        | "storage_uri"
+        | "target_app_version"
+        | "fingerprint_hash"
+        | "metadata"
+        | "rollout_cohort_count"
+        | "target_cohorts"
+      > = [
+        "id",
+        "platform",
+        "should_force_update",
+        "enabled",
+        "file_hash",
+        "git_commit_hash",
+        "message",
+        "channel",
+        "storage_uri",
+        "target_app_version",
+        "fingerprint_hash",
+        "metadata",
+        "rollout_cohort_count",
+        "target_cohorts",
+      ];
+
+      const rows = isMongoAdapter
+        ? (
+            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,
+          });
+
+      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 {
-        data: sliced,
+        data,
         pagination: calculatePagination(total, { limit, offset }),
       };
     },
 
     async insertBundle(bundle: Bundle): Promise<void> {
-      const version = await client.version();
-      const orm = client.orm(version);
+      const orm = await ensureORM();
       const values = {
         id: bundle.id,
         platform: bundle.platform,
@@ -385,6 +609,9 @@ export function createOrmDatabaseCore({
         target_app_version: bundle.targetAppVersion,
         fingerprint_hash: bundle.fingerprintHash,
         metadata: bundle.metadata ?? {},
+        rollout_cohort_count:
+          bundle.rolloutCohortCount ?? DEFAULT_ROLLOUT_COHORT_COUNT,
+        target_cohorts: bundle.targetCohorts ?? null,
       };
       const { id, ...updateValues } = values;
       await orm.upsert("bundles", {
@@ -398,8 +625,7 @@ export function createOrmDatabaseCore({
       bundleId: string,
       newBundle: Partial<Bundle>,
     ): Promise<void> {
-      const version = await client.version();
-      const orm = client.orm(version);
+      const orm = await ensureORM();
       const current = await this.getBundleById(bundleId);
       if (!current) throw new Error("targetBundleId not found");
       const merged: Bundle = { ...current, ...newBundle };
@@ -416,6 +642,9 @@ export function createOrmDatabaseCore({
         target_app_version: merged.targetAppVersion,
         fingerprint_hash: merged.fingerprintHash,
         metadata: merged.metadata ?? {},
+        rollout_cohort_count:
+          merged.rolloutCohortCount ?? DEFAULT_ROLLOUT_COHORT_COUNT,
+        target_cohorts: merged.targetCohorts ?? null,
       };
       const { id: id2, ...updateValues2 } = values;
       await orm.upsert("bundles", {
@@ -426,8 +655,7 @@ export function createOrmDatabaseCore({
     },
 
     async deleteBundleById(bundleId: string): Promise<void> {
-      const version = await client.version();
-      const orm = client.orm(version);
+      const orm = await ensureORM();
       await orm.deleteMany("bundles", { where: (b) => b("id", "=", bundleId) });
     },
   };