@hot-updater/server 0.30.11 → 0.31.0

package/src/db/index.ts

@@ -1,11 +1,14 @@
 import type {
   DatabasePlugin,
   HotUpdaterContext,
-  StoragePlugin,
+  RuntimeStoragePlugin,
 } from "@hot-updater/plugin-core";
+import { assertRuntimeStoragePlugin } from "@hot-updater/plugin-core";
 
+export * from "./createBundleDiff";
 import { createHandler, type HandlerRoutes } from "../handler";
 import { normalizeBasePath } from "../route";
+import { createStorageAccess } from "../storageAccess";
 import {
   createOrmDatabaseCore,
   type HotUpdaterClient,
@@ -40,11 +43,17 @@ export interface CreateHotUpdaterOptions<TContext = unknown> {
   /**
    * Storage plugins for handling file uploads and downloads.
    */
-  storages?: (StoragePlugin<TContext> | StoragePluginFactory<TContext>)[];
+  storages?: (
+    | RuntimeStoragePlugin<TContext>
+    | StoragePluginFactory<TContext>
+  )[];
   /**
    * @deprecated Use `storages` instead. This field will be removed in a future version.
    */
-  storagePlugins?: (StoragePlugin<TContext> | StoragePluginFactory<TContext>)[];
+  storagePlugins?: (
+    | RuntimeStoragePlugin<TContext>
+    | StoragePluginFactory<TContext>
+  )[];
   basePath?: string;
   cwd?: string;
   routes?: HandlerRoutes;
@@ -57,39 +66,14 @@ export function createHotUpdater<TContext = unknown>(
 
   // Initialize storage plugins - call factories if they are functions
   const storagePlugins = (options.storages ?? options.storagePlugins ?? []).map(
-    (plugin) => (typeof plugin === "function" ? plugin() : plugin),
+    (plugin) => {
+      const storagePlugin = typeof plugin === "function" ? plugin() : plugin;
+      assertRuntimeStoragePlugin(storagePlugin);
+      return storagePlugin;
+    },
   );
-
-  const resolveStoragePluginUrl = async (
-    storageUri: string | null,
-    context?: HotUpdaterContext<TContext>,
-  ): Promise<string | null> => {
-    if (!storageUri) {
-      return null;
-    }
-    const url = new URL(storageUri);
-    const protocol = url.protocol.replace(":", "");
-    if (protocol === "http" || protocol === "https") {
-      return storageUri;
-    }
-    const plugin = storagePlugins.find((p) => p.supportedProtocol === protocol);
-
-    if (!plugin) {
-      throw new Error(`No storage plugin for protocol: ${protocol}`);
-    }
-    const { fileUrl } = await plugin.getDownloadUrl(storageUri, context);
-    if (!fileUrl) {
-      throw new Error("Storage plugin returned empty fileUrl");
-    }
-    return fileUrl;
-  };
-
-  const resolveFileUrl = async (
-    storageUri: string | null,
-    context?: HotUpdaterContext<TContext>,
-  ) => {
-    return resolveStoragePluginUrl(storageUri, context);
-  };
+  const { readStorageText, resolveFileUrl } =
+    createStorageAccess(storagePlugins);
 
   const database = options.database;
 
@@ -108,12 +92,14 @@ export function createHotUpdater<TContext = unknown>(
             isDatabasePluginFactory(database)
               ? {
                   createMutationPlugin: () => database(),
+                  readStorageText,
                 }
-              : undefined,
+              : { readStorageText },
           );
         })()
       : createOrmDatabaseCore<TContext>({
           database,
+          readStorageText,
           resolveFileUrl,
         });
 

package/src/db/ormCore.ts

@@ -1,16 +1,22 @@
 import type {
-  AppUpdateInfo,
+  AppUpdateAvailableInfo,
   AppVersionGetBundlesArgs,
   Bundle,
+  BundlePatchArtifact,
   FingerprintGetBundlesArgs,
   GetBundlesArgs,
   Platform,
   UpdateInfo,
 } from "@hot-updater/core";
 import {
+  getAssetBaseStorageUri,
+  getBundlePatches,
+  getManifestFileHash,
+  getManifestStorageUri,
   DEFAULT_ROLLOUT_COHORT_COUNT,
   isCohortEligibleForUpdate,
   NIL_UUID,
+  stripBundleArtifactMetadata,
 } from "@hot-updater/core";
 import type {
   DatabaseBundleCursor,
@@ -23,13 +29,26 @@ import type {
 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 { v0_31_0 } from "../schema/v0_31_0";
 import type { Paginated } from "../types";
-import type { DatabaseAPI } from "./types";
+import {
+  assertBundlePersistenceConstraints,
+  enhanceGeneratedSchema,
+  wrapKyselyMigrator,
+} from "./schemaEnhancements";
+import {
+  getSQLProvider,
+  type DatabaseAPI,
+  type ORMDatabaseAdapter,
+} from "./types";
+import {
+  parseBundleMetadata,
+  resolveManifestArtifacts,
+} from "./updateArtifacts";
 
 const parseTargetCohorts = (value: unknown): string[] | null => {
   if (!value) return null;
@@ -49,7 +68,11 @@ const parseTargetCohorts = (value: unknown): string[] | null => {
   return null;
 };
 
-const schemas: [typeof v0_21_0, typeof v0_29_0] = [v0_21_0, v0_29_0];
+const schemas: [typeof v0_21_0, typeof v0_29_0, typeof v0_31_0] = [
+  v0_21_0,
+  v0_29_0,
+  v0_31_0,
+];
 
 const getLastItem = <T extends unknown[]>(
   items: T,
@@ -58,6 +81,70 @@ const getLastItem = <T extends unknown[]>(
 
 const DEFAULT_BUNDLE_ORDER = { field: "id", direction: "desc" } as const;
 
+type BundleRecord = {
+  id: string;
+  platform: string;
+  should_force_update: unknown;
+  enabled: unknown;
+  file_hash: string;
+  git_commit_hash: string | null;
+  message: string | null;
+  channel: string;
+  storage_uri: string;
+  target_app_version: string | null;
+  fingerprint_hash: string | null;
+  metadata?: unknown;
+  manifest_storage_uri?: string | null;
+  manifest_file_hash?: string | null;
+  asset_base_storage_uri?: string | null;
+  rollout_cohort_count?: number | null;
+  target_cohorts?: unknown;
+};
+
+type BundlePatchRecord = {
+  id: string;
+  bundle_id: string;
+  base_bundle_id: string;
+  base_file_hash: string;
+  patch_file_hash: string;
+  patch_storage_uri: string;
+  order_index?: number | null;
+};
+
+const buildBundlePatchId = (bundleId: string, baseBundleId: string) =>
+  `${bundleId}:${baseBundleId}`;
+
+const toBundlePatchRecords = (
+  bundle: Pick<
+    Bundle,
+    | "id"
+    | "patches"
+    | "patchBaseBundleId"
+    | "patchBaseFileHash"
+    | "patchFileHash"
+    | "patchStorageUri"
+    | "metadata"
+  >,
+): BundlePatchRecord[] =>
+  getBundlePatches(bundle).map((patch, index) => ({
+    id: buildBundlePatchId(bundle.id, patch.baseBundleId),
+    bundle_id: bundle.id,
+    base_bundle_id: patch.baseBundleId,
+    base_file_hash: patch.baseFileHash,
+    patch_file_hash: patch.patchFileHash,
+    patch_storage_uri: patch.patchStorageUri,
+    order_index: index,
+  }));
+
+const mapPatchRecordToPatch = (
+  record: BundlePatchRecord,
+): BundlePatchArtifact => ({
+  baseBundleId: record.base_bundle_id,
+  baseFileHash: record.base_file_hash,
+  patchFileHash: record.patch_file_hash,
+  patchStorageUri: record.patch_storage_uri,
+});
+
 const mergeIdFilter = (
   base: DatabaseBundleIdFilter | undefined,
   patch: DatabaseBundleIdFilter,
@@ -135,26 +222,32 @@ export type Migrator = ReturnType<HotUpdaterClient["createMigrator"]>;
 export function createOrmDatabaseCore<TContext = unknown>({
   database,
   resolveFileUrl,
+  readStorageText,
 }: {
-  database: FumaDBAdapter;
+  database: ORMDatabaseAdapter;
   resolveFileUrl: (
     storageUri: string | null,
     context?: HotUpdaterContext<TContext>,
   ) => Promise<string | null>;
+  readStorageText?: (
+    storageUri: string,
+    context?: HotUpdaterContext<TContext>,
+  ) => Promise<string | null>;
 }): {
   api: DatabaseAPI<TContext>;
   adapterName: string;
   createMigrator: () => Migrator;
   generateSchema: HotUpdaterClient["generateSchema"];
 } {
-  const client = HotUpdaterDB.client(database);
+  const client = HotUpdaterDB.client(
+    database as Parameters<typeof HotUpdaterDB.client>[0],
+  );
   const UPDATE_CHECK_PAGE_SIZE = 100;
   const isMongoAdapter = client.adapter.name.toLowerCase().includes("mongodb");
+  const latestSchema = getLastItem(schemas);
+  const lastSchemaVersion = latestSchema.version;
 
   const ensureORM = async () => {
-    const latestSchema = getLastItem(schemas);
-    const lastSchemaVersion = latestSchema.version;
-
     try {
       const migrator = client.createMigrator();
       const currentVersion = await migrator.getVersion();
@@ -246,46 +339,115 @@ export function createOrmDatabaseCore<TContext = unknown>({
     return conditions.length > 0 ? b.and(...conditions) : true;
   };
 
+  const mapBundleRecordToBundle = (
+    record: BundleRecord,
+    patchRecords: BundlePatchRecord[] = [],
+  ): Bundle => {
+    const patches = patchRecords
+      .slice()
+      .sort(
+        (left, right) =>
+          (left.order_index ?? 0) - (right.order_index ?? 0) ||
+          left.base_bundle_id.localeCompare(right.base_bundle_id),
+      )
+      .map(mapPatchRecordToPatch);
+    const primaryPatch = patches[0] ?? null;
+
+    return {
+      id: record.id,
+      platform: record.platform as Platform,
+      shouldForceUpdate: Boolean(record.should_force_update),
+      enabled: Boolean(record.enabled),
+      fileHash: record.file_hash,
+      gitCommitHash: record.git_commit_hash ?? null,
+      message: record.message ?? null,
+      channel: record.channel,
+      storageUri: record.storage_uri,
+      targetAppVersion: record.target_app_version ?? null,
+      fingerprintHash: record.fingerprint_hash ?? null,
+      metadata: parseBundleMetadata(record.metadata),
+      manifestStorageUri: record.manifest_storage_uri ?? null,
+      manifestFileHash: record.manifest_file_hash ?? null,
+      assetBaseStorageUri: record.asset_base_storage_uri ?? null,
+      patches,
+      patchBaseBundleId: primaryPatch?.baseBundleId ?? null,
+      patchBaseFileHash: primaryPatch?.baseFileHash ?? null,
+      patchFileHash: primaryPatch?.patchFileHash ?? null,
+      patchStorageUri: primaryPatch?.patchStorageUri ?? null,
+      rolloutCohortCount:
+        record.rollout_cohort_count ?? DEFAULT_ROLLOUT_COHORT_COUNT,
+      targetCohorts: parseTargetCohorts(record.target_cohorts),
+    };
+  };
+
+  const fetchBundlePatchMap = async (
+    orm: Awaited<ReturnType<typeof ensureORM>>,
+    bundleIds: string[],
+  ): Promise<Map<string, BundlePatchRecord[]>> => {
+    const patchMap = new Map<string, BundlePatchRecord[]>();
+
+    if (bundleIds.length === 0) {
+      return patchMap;
+    }
+
+    const patchRows = await orm.findMany("bundle_patches", {
+      select: [
+        "id",
+        "bundle_id",
+        "base_bundle_id",
+        "base_file_hash",
+        "patch_file_hash",
+        "patch_storage_uri",
+        "order_index",
+      ],
+      where: (b) => b("bundle_id", "in", bundleIds),
+    });
+
+    for (const row of patchRows) {
+      const current = patchMap.get(row.bundle_id) ?? [];
+      current.push(row);
+      patchMap.set(row.bundle_id, current);
+    }
+
+    return patchMap;
+  };
+
+  const fetchBundleById = async (id: string): Promise<Bundle | null> => {
+    const orm = await ensureORM();
+    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",
+        "manifest_storage_uri",
+        "manifest_file_hash",
+        "asset_base_storage_uri",
+        "rollout_cohort_count",
+        "target_cohorts",
+      ],
+      where: (b) => b("id", "=", id),
+    });
+
+    if (!result) {
+      return null;
+    }
+
+    const patchMap = await fetchBundlePatchMap(orm, [id]);
+    return mapBundleRecordToBundle(result, patchMap.get(id) ?? []);
+  };
+
   const api: DatabaseAPI<TContext> = {
     async getBundleById(id: string): Promise<Bundle | null> {
-      const orm = await ensureORM();
-      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",
-          "rollout_cohort_count",
-          "target_cohorts",
-        ],
-        where: (b) => 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,
-        rolloutCohortCount:
-          result.rollout_cohort_count ?? DEFAULT_ROLLOUT_COHORT_COUNT,
-        targetCohorts: parseTargetCohorts(result.target_cohorts),
-      };
-      return bundle;
+      return fetchBundleById(id);
     },
 
     async getUpdateInfo(args: GetBundlesArgs): Promise<UpdateInfo | null> {
@@ -558,14 +720,40 @@ export function createOrmDatabaseCore<TContext = unknown>({
     async getAppUpdateInfo(
       args: GetBundlesArgs,
       context?: HotUpdaterContext<TContext>,
-    ): Promise<AppUpdateInfo | null> {
+    ): Promise<AppUpdateAvailableInfo | 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, context);
-      return { ...rest, fileUrl };
+      if (!readStorageText) {
+        const fileUrl = await resolveFileUrl(storageUri ?? null, context);
+        const baseResponse = { ...rest, fileUrl };
+        return baseResponse;
+      }
+
+      const [fileUrl, currentBundle, targetBundle] = await Promise.all([
+        resolveFileUrl(storageUri ?? null, context),
+        args.bundleId !== NIL_UUID ? fetchBundleById(args.bundleId) : null,
+        info.id !== NIL_UUID ? fetchBundleById(info.id) : null,
+      ]);
+      const baseResponse = { ...rest, fileUrl };
+      const manifestArtifacts = await resolveManifestArtifacts({
+        currentBundle,
+        resolveFileUrl,
+        readStorageText,
+        targetBundle,
+        context,
+      });
+
+      if (!manifestArtifacts) {
+        return baseResponse;
+      }
+
+      return {
+        ...baseResponse,
+        ...manifestArtifacts,
+      };
     },
 
     async getChannels(): Promise<string[]> {
@@ -606,6 +794,9 @@ export function createOrmDatabaseCore<TContext = unknown>({
         | "target_app_version"
         | "fingerprint_hash"
         | "metadata"
+        | "manifest_storage_uri"
+        | "manifest_file_hash"
+        | "asset_base_storage_uri"
         | "rollout_cohort_count"
         | "target_cohorts"
       > = [
@@ -621,30 +812,13 @@ export function createOrmDatabaseCore<TContext = unknown>({
         "target_app_version",
         "fingerprint_hash",
         "metadata",
+        "manifest_storage_uri",
+        "manifest_file_hash",
+        "asset_base_storage_uri",
         "rollout_cohort_count",
         "target_cohorts",
       ];
 
-      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,
@@ -676,7 +850,14 @@ export function createOrmDatabaseCore<TContext = unknown>({
               offset,
             });
 
-        return mapRowsToBundles(rows);
+        const patchMap = await fetchBundlePatchMap(
+          orm,
+          rows.map((row) => row.id),
+        );
+
+        return rows.map((row) =>
+          mapBundleRecordToBundle(row, patchMap.get(row.id) ?? []),
+        );
       };
 
       if (!options.cursor?.after && !options.cursor?.before) {
@@ -752,6 +933,7 @@ export function createOrmDatabaseCore<TContext = unknown>({
     },
 
     async insertBundle(bundle: Bundle): Promise<void> {
+      assertBundlePersistenceConstraints(bundle);
       const orm = await ensureORM();
       const values = {
         id: bundle.id,
@@ -765,7 +947,10 @@ export function createOrmDatabaseCore<TContext = unknown>({
         storage_uri: bundle.storageUri,
         target_app_version: bundle.targetAppVersion,
         fingerprint_hash: bundle.fingerprintHash,
-        metadata: bundle.metadata ?? {},
+        metadata: stripBundleArtifactMetadata(bundle.metadata) ?? {},
+        manifest_storage_uri: getManifestStorageUri(bundle),
+        manifest_file_hash: getManifestFileHash(bundle),
+        asset_base_storage_uri: getAssetBaseStorageUri(bundle),
         rollout_cohort_count:
           bundle.rolloutCohortCount ?? DEFAULT_ROLLOUT_COHORT_COUNT,
         target_cohorts: bundle.targetCohorts ?? null,
@@ -776,6 +961,13 @@ export function createOrmDatabaseCore<TContext = unknown>({
         create: values,
         update: updateValues,
       });
+      await orm.deleteMany("bundle_patches", {
+        where: (b) => b("bundle_id", "=", bundle.id),
+      });
+      const patchValues = toBundlePatchRecords(bundle);
+      if (patchValues.length > 0) {
+        await orm.createMany("bundle_patches", patchValues);
+      }
     },
 
     async updateBundleById(
@@ -786,6 +978,7 @@ export function createOrmDatabaseCore<TContext = unknown>({
       const current = await this.getBundleById(bundleId);
       if (!current) throw new Error("targetBundleId not found");
       const merged: Bundle = { ...current, ...newBundle };
+      assertBundlePersistenceConstraints(merged);
       const values = {
         id: merged.id,
         platform: merged.platform,
@@ -798,7 +991,10 @@ export function createOrmDatabaseCore<TContext = unknown>({
         storage_uri: merged.storageUri,
         target_app_version: merged.targetAppVersion,
         fingerprint_hash: merged.fingerprintHash,
-        metadata: merged.metadata ?? {},
+        metadata: stripBundleArtifactMetadata(merged.metadata) ?? {},
+        manifest_storage_uri: getManifestStorageUri(merged),
+        manifest_file_hash: getManifestFileHash(merged),
+        asset_base_storage_uri: getAssetBaseStorageUri(merged),
         rollout_cohort_count:
           merged.rolloutCohortCount ?? DEFAULT_ROLLOUT_COHORT_COUNT,
         target_cohorts: merged.targetCohorts ?? null,
@@ -809,10 +1005,32 @@ export function createOrmDatabaseCore<TContext = unknown>({
         create: values,
         update: updateValues2,
       });
+      await orm.deleteMany("bundle_patches", {
+        where: (b) => b("bundle_id", "=", merged.id),
+      });
+      const patchValues = toBundlePatchRecords(merged);
+      if (patchValues.length > 0) {
+        await orm.createMany("bundle_patches", patchValues);
+      }
     },
 
     async deleteBundleById(bundleId: string): Promise<void> {
       const orm = await ensureORM();
+      const existingBundle = await orm.findFirst("bundles", {
+        select: ["id"],
+        where: (b) => b("id", "=", bundleId),
+      });
+
+      if (!existingBundle) {
+        return;
+      }
+
+      await orm.deleteMany("bundle_patches", {
+        where: (b) => b("bundle_id", "=", bundleId),
+      });
+      await orm.deleteMany("bundle_patches", {
+        where: (b) => b("base_bundle_id", "=", bundleId),
+      });
       await orm.deleteMany("bundles", { where: (b) => b("id", "=", bundleId) });
     },
   };
@@ -820,7 +1038,22 @@ export function createOrmDatabaseCore<TContext = unknown>({
   return {
     api,
     adapterName: client.adapter.name,
-    createMigrator: () => client.createMigrator(),
-    generateSchema: client.generateSchema,
+    createMigrator: () =>
+      wrapKyselyMigrator(
+        client.createMigrator(),
+        getSQLProvider(database.provider),
+        lastSchemaVersion,
+      ) as Migrator,
+    generateSchema: (version, name) => {
+      const result = client.generateSchema(version, name);
+      return {
+        ...result,
+        code: enhanceGeneratedSchema(
+          client.adapter.name,
+          result.code,
+          database.provider,
+        ),
+      };
+    },
   };
 }