@hot-updater/server 0.31.4 → 0.33.0

package/src/db/pluginCore.spec.ts

@@ -4,6 +4,7 @@ import type {
   DatabasePlugin,
   RequestEnvContext,
 } from "@hot-updater/plugin-core";
+import { createDatabasePluginGetUpdateInfo } from "@hot-updater/plugin-core";
 import { describe, expect, it, vi } from "vitest";
 
 import { createPluginDatabaseCore } from "./pluginCore";
@@ -195,6 +196,448 @@ describe("createPluginDatabaseCore", () => {
     });
   });
 
+  it("uses request bundle identity map for manifest artifact lookups", async () => {
+    const currentBundle = {
+      ...baseBundle,
+      id: "00000000-0000-0000-0000-000000000001",
+      manifestStorageUri: "r2://bucket/current/manifest.json",
+      manifestFileHash: "sig:current-manifest",
+      assetBaseStorageUri: "r2://bucket/current/files",
+    };
+    const targetBundle = {
+      ...baseBundle,
+      id: "00000000-0000-0000-0000-000000000002",
+      fileHash: "hash-2",
+      manifestStorageUri: "r2://bucket/target/manifest.json",
+      manifestFileHash: "sig:target-manifest",
+      assetBaseStorageUri: "r2://bucket/target/files",
+    };
+    const manifests = new Map([
+      [
+        currentBundle.manifestStorageUri,
+        JSON.stringify({
+          bundleId: currentBundle.id,
+          assets: {
+            "index.ios.bundle": {
+              fileHash: "old-bundle-hash",
+            },
+            "shared.png": {
+              fileHash: "same-image-hash",
+            },
+          },
+        }),
+      ],
+      [
+        targetBundle.manifestStorageUri,
+        JSON.stringify({
+          bundleId: targetBundle.id,
+          assets: {
+            "index.ios.bundle": {
+              fileHash: "target-bundle-hash",
+            },
+            "shared.png": {
+              fileHash: "same-image-hash",
+            },
+          },
+        }),
+      ],
+    ]);
+    const getBundleById = vi.fn<DatabasePlugin<TestContext>["getBundleById"]>(
+      async (bundleId) => {
+        if (bundleId === currentBundle.id) return currentBundle;
+        if (bundleId === targetBundle.id) return targetBundle;
+        return null;
+      },
+    );
+    const getUpdateInfo = vi.fn<
+      NonNullable<DatabasePlugin<TestContext>["getUpdateInfo"]>
+    >(async () => ({
+      fileHash: targetBundle.fileHash,
+      id: targetBundle.id,
+      message: targetBundle.message,
+      shouldForceUpdate: targetBundle.shouldForceUpdate,
+      status: "UPDATE",
+      storageUri: targetBundle.storageUri,
+    }));
+
+    const plugin: DatabasePlugin<TestContext> = {
+      name: "identity-map-plugin",
+      async appendBundle() {},
+      async commitBundle() {},
+      async deleteBundle() {},
+      getBundleById,
+      getUpdateInfo,
+      async getBundles() {
+        return {
+          data: [targetBundle],
+          pagination: {
+            currentPage: 1,
+            hasNextPage: false,
+            hasPreviousPage: false,
+            total: 1,
+            totalPages: 1,
+          },
+        };
+      },
+      async getChannels() {
+        return ["production"];
+      },
+      async updateBundle() {},
+    };
+
+    const core = createPluginDatabaseCore(
+      () => plugin,
+      async (storageUri) => {
+        if (!storageUri) return null;
+        const url = new URL(storageUri);
+        return `https://assets.example.com/${url.host}${url.pathname}`;
+      },
+      {
+        readStorageText: async (storageUri) =>
+          manifests.get(storageUri) ?? null,
+      },
+    );
+
+    const updateInfo = await core.api.getAppUpdateInfo({
+      ...updateArgs,
+      bundleId: currentBundle.id,
+    });
+    expect(updateInfo).not.toBeNull();
+    if (!updateInfo) {
+      throw new Error("expected app update info");
+    }
+
+    expect(updateInfo).toMatchObject({
+      changedAssets: {
+        "index.ios.bundle": {
+          file: {
+            compression: "br",
+            url: "https://assets.example.com/bucket/target/files/index.ios.bundle.br",
+          },
+          fileHash: "target-bundle-hash",
+        },
+      },
+      manifestFileHash: "sig:target-manifest",
+      manifestUrl: "https://assets.example.com/bucket/target/manifest.json",
+    });
+    expect(updateInfo.changedAssets).not.toHaveProperty("shared.png");
+    expect(getUpdateInfo).toHaveBeenCalledOnce();
+    expect(getBundleById).toHaveBeenCalledTimes(2);
+    expect(getBundleById).toHaveBeenCalledWith(targetBundle.id, undefined);
+    expect(getBundleById).toHaveBeenCalledWith(currentBundle.id, undefined);
+    expect(Object.keys(updateInfo)).not.toContain("__hotUpdaterBundle");
+    expect(Object.keys(updateInfo)).not.toContain("__hotUpdaterCurrentBundle");
+    expect(JSON.stringify(updateInfo)).not.toContain("__hotUpdaterBundle");
+    expect(JSON.stringify(updateInfo)).not.toContain(
+      "__hotUpdaterCurrentBundle",
+    );
+  });
+
+  it("seeds request bundle identity map from provider update lookups", async () => {
+    const targetBundle = {
+      ...baseBundle,
+      id: "00000000-0000-0000-0000-000000000002",
+      fileHash: "hash-2",
+      manifestStorageUri: "s3://bucket/target/manifest.json",
+      manifestFileHash: "sig:target-manifest",
+      assetBaseStorageUri: "s3://bucket/target/files",
+    };
+    const manifests = new Map([
+      [
+        targetBundle.manifestStorageUri,
+        JSON.stringify({
+          bundleId: targetBundle.id,
+          assets: {
+            "index.ios.bundle": {
+              fileHash: "target-bundle-hash",
+            },
+          },
+        }),
+      ],
+    ]);
+    const getBundleById = vi.fn<DatabasePlugin<TestContext>["getBundleById"]>(
+      async () => {
+        throw new Error("unexpected provider bundle reread");
+      },
+    );
+    const getUpdateInfo = createDatabasePluginGetUpdateInfo<TestContext>({
+      getBundlesByFingerprint: async () => [],
+      getBundlesByTargetAppVersions: async () => [targetBundle],
+      listTargetAppVersions: async () => ["1.0.0"],
+    });
+    const plugin: DatabasePlugin<TestContext> = {
+      name: "seeded-fast-path-plugin",
+      async appendBundle() {},
+      async commitBundle() {},
+      async deleteBundle() {},
+      getBundleById,
+      async getBundles() {
+        return {
+          data: [targetBundle],
+          pagination: {
+            currentPage: 1,
+            hasNextPage: false,
+            hasPreviousPage: false,
+            total: 1,
+            totalPages: 1,
+          },
+        };
+      },
+      getUpdateInfo,
+      async getChannels() {
+        return ["production"];
+      },
+      async updateBundle() {},
+    };
+
+    const core = createPluginDatabaseCore(
+      () => plugin,
+      async (storageUri) => {
+        if (!storageUri) return null;
+        const url = new URL(storageUri);
+        return `https://assets.example.com/${url.host}${url.pathname}`;
+      },
+      {
+        readStorageText: async (storageUri) =>
+          manifests.get(storageUri) ?? null,
+      },
+    );
+    const context: TestContext = {
+      env: {
+        assetHost: "https://assets.example.com",
+      },
+      request: new Request("https://updates.example.com"),
+    };
+
+    const updateInfo = await core.api.getAppUpdateInfo(updateArgs, context);
+
+    expect(updateInfo).toMatchObject({
+      changedAssets: {
+        "index.ios.bundle": {
+          file: {
+            compression: "br",
+            url: "https://assets.example.com/bucket/target/files/index.ios.bundle.br",
+          },
+          fileHash: "target-bundle-hash",
+        },
+      },
+      id: targetBundle.id,
+      manifestFileHash: "sig:target-manifest",
+      manifestUrl: "https://assets.example.com/bucket/target/manifest.json",
+    });
+    expect(getBundleById).not.toHaveBeenCalled();
+  });
+
+  it("does not reread providers for current bundles outside direct update lookup results", async () => {
+    const targetBundle = {
+      ...baseBundle,
+      id: "00000000-0000-0000-0000-000000000003",
+      fileHash: "hash-3",
+      manifestStorageUri: "s3://bucket/target/manifest.json",
+      manifestFileHash: "sig:target-manifest",
+      assetBaseStorageUri: "s3://bucket/target/files",
+    };
+    const manifests = new Map([
+      [
+        targetBundle.manifestStorageUri,
+        JSON.stringify({
+          bundleId: targetBundle.id,
+          assets: {
+            "index.ios.bundle": {
+              fileHash: "target-bundle-hash",
+            },
+            "image.png": {
+              fileHash: "target-image-hash",
+            },
+          },
+        }),
+      ],
+    ]);
+    const getBundleById = vi.fn<DatabasePlugin<TestContext>["getBundleById"]>(
+      async () => {
+        throw new Error("unexpected provider current bundle reread");
+      },
+    );
+    const getUpdateInfo = createDatabasePluginGetUpdateInfo<TestContext>({
+      getBundlesByFingerprint: async () => [],
+      getBundlesByTargetAppVersions: async () => [targetBundle],
+      listTargetAppVersions: async () => ["1.0.0"],
+    });
+    const plugin: DatabasePlugin<TestContext> = {
+      name: "seeded-current-miss-plugin",
+      async appendBundle() {},
+      async commitBundle() {},
+      async deleteBundle() {},
+      getBundleById,
+      async getBundles() {
+        throw new Error("unexpected provider scan");
+      },
+      getUpdateInfo,
+      async getChannels() {
+        return ["production"];
+      },
+      async updateBundle() {},
+    };
+
+    const core = createPluginDatabaseCore(
+      () => plugin,
+      async (storageUri) => {
+        if (!storageUri) return null;
+        const url = new URL(storageUri);
+        return `https://assets.example.com/${url.host}${url.pathname}`;
+      },
+      {
+        readStorageText: async (storageUri) =>
+          manifests.get(storageUri) ?? null,
+      },
+    );
+    const context: TestContext = {
+      env: {
+        assetHost: "https://assets.example.com",
+      },
+      request: new Request("https://updates.example.com"),
+    };
+
+    const updateInfo = await core.api.getAppUpdateInfo(
+      {
+        ...updateArgs,
+        bundleId: "00000000-0000-0000-0000-0000000000aa",
+      },
+      context,
+    );
+
+    expect(updateInfo).toMatchObject({
+      changedAssets: {
+        "image.png": {
+          file: {
+            url: "https://assets.example.com/bucket/target/files/image.png",
+          },
+          fileHash: "target-image-hash",
+        },
+        "index.ios.bundle": {
+          file: {
+            compression: "br",
+            url: "https://assets.example.com/bucket/target/files/index.ios.bundle.br",
+          },
+          fileHash: "target-bundle-hash",
+        },
+      },
+      id: targetBundle.id,
+      manifestFileHash: "sig:target-manifest",
+      manifestUrl: "https://assets.example.com/bucket/target/manifest.json",
+    });
+    expect(getBundleById).not.toHaveBeenCalled();
+  });
+
+  it("resolves manifest changed assets from deterministic content-addressed storage", async () => {
+    const currentBundle = {
+      ...baseBundle,
+      id: "00000000-0000-0000-0000-000000000001",
+      manifestStorageUri: "r2://bucket/current/manifest.json",
+      manifestFileHash: "sig:current-manifest",
+      assetBaseStorageUri: "r2://bucket/assets",
+    };
+    const targetBundle = {
+      ...baseBundle,
+      id: "00000000-0000-0000-0000-000000000002",
+      fileHash: "hash-2",
+      manifestStorageUri: "r2://bucket/target/manifest.json",
+      manifestFileHash: "sig:target-manifest",
+      assetBaseStorageUri: "r2://bucket/assets",
+    };
+    const manifests = new Map([
+      [
+        currentBundle.manifestStorageUri,
+        JSON.stringify({
+          bundleId: currentBundle.id,
+          assets: {
+            "index.ios.bundle": {
+              fileHash: "old-bundle-hash",
+            },
+          },
+        }),
+      ],
+      [
+        targetBundle.manifestStorageUri,
+        JSON.stringify({
+          bundleId: targetBundle.id,
+          assets: {
+            "index.ios.bundle": {
+              fileHash: "new-bundle-hash",
+            },
+          },
+        }),
+      ],
+    ]);
+    const plugin: DatabasePlugin<TestContext> = {
+      name: "content-addressed-manifest-plugin",
+      async appendBundle() {},
+      async commitBundle() {},
+      async deleteBundle() {},
+      async getBundleById(bundleId) {
+        if (bundleId === currentBundle.id) return currentBundle;
+        if (bundleId === targetBundle.id) return targetBundle;
+        return null;
+      },
+      async getUpdateInfo() {
+        return {
+          fileHash: targetBundle.fileHash,
+          id: targetBundle.id,
+          message: targetBundle.message,
+          shouldForceUpdate: targetBundle.shouldForceUpdate,
+          status: "UPDATE",
+          storageUri: targetBundle.storageUri,
+        };
+      },
+      async getBundles() {
+        return {
+          data: [targetBundle],
+          pagination: {
+            currentPage: 1,
+            hasNextPage: false,
+            hasPreviousPage: false,
+            total: 1,
+            totalPages: 1,
+          },
+        };
+      },
+      async getChannels() {
+        return ["production"];
+      },
+      async updateBundle() {},
+    };
+
+    const core = createPluginDatabaseCore(
+      () => plugin,
+      async (storageUri) => {
+        if (!storageUri) return null;
+        const url = new URL(storageUri);
+        return `https://assets.example.com/${url.host}${url.pathname}`;
+      },
+      {
+        readStorageText: async (storageUri) =>
+          manifests.get(storageUri) ?? null,
+      },
+    );
+
+    await expect(
+      core.api.getAppUpdateInfo({
+        ...updateArgs,
+        bundleId: currentBundle.id,
+      }),
+    ).resolves.toMatchObject({
+      changedAssets: {
+        "index.ios.bundle": {
+          file: {
+            compression: "br",
+            url: "https://assets.example.com/bucket/assets/sha256/ne/new-bundle-hash.br",
+          },
+          fileHash: "new-bundle-hash",
+        },
+      },
+    });
+  });
+
   it("falls back to archive metadata when manifest changed assets cannot be resolved", async () => {
     const currentBundle = {
       ...baseBundle,

package/src/db/pluginCore.ts

@@ -13,10 +13,12 @@ import {
   type DatabaseBundleQueryOrder,
   type DatabaseBundleQueryWhere,
   type DatabasePlugin,
+  getRequestUpdateBundleSeeds,
   type HotUpdaterContext,
   semverSatisfies,
 } from "@hot-updater/plugin-core";
 
+import { createRequestBundleIdentityMap } from "./requestBundleIdentityMap";
 import { assertBundlePersistenceConstraints } from "./schemaEnhancements";
 import type { DatabaseAPI } from "./types";
 import { resolveManifestArtifacts } from "./updateArtifacts";
@@ -347,9 +349,7 @@ export function createPluginDatabaseCore<TContext = unknown>(
       if (!info) {
         return null;
       }
-      const { storageUri, ...rest } = info as UpdateInfo & {
-        storageUri: string | null;
-      };
+      const { storageUri, ...rest } = info;
 
       const readStorageText = options?.readStorageText;
       if (info.id === NIL_UUID || !readStorageText) {
@@ -358,12 +358,29 @@ export function createPluginDatabaseCore<TContext = unknown>(
         return baseResponse;
       }
 
+      const requestBundleSeeds = getRequestUpdateBundleSeeds(context);
+      const requestBundles = createRequestBundleIdentityMap({
+        context,
+        loadBundleById: (bundleId, requestContext) =>
+          getPlugin().getBundleById(bundleId, requestContext),
+        seeds: requestBundleSeeds,
+      });
+      const getCurrentBundle = () => {
+        if (args.bundleId === NIL_UUID) {
+          return null;
+        }
+
+        const seededCurrentBundle = requestBundles.peek(args.bundleId);
+        if (seededCurrentBundle || requestBundleSeeds.length > 0) {
+          return seededCurrentBundle;
+        }
+
+        return requestBundles.get(args.bundleId);
+      };
       const [fileUrl, targetBundle, currentBundle] = await Promise.all([
         resolveFileUrl(storageUri ?? null, context),
-        getPlugin().getBundleById(info.id, context),
-        args.bundleId !== NIL_UUID
-          ? getPlugin().getBundleById(args.bundleId, context)
-          : null,
+        requestBundles.get(info.id),
+        getCurrentBundle(),
       ]);
       const baseResponse: AppUpdateAvailableInfo = { ...rest, fileUrl };
       const manifestArtifacts = await resolveManifestArtifacts({
@@ -435,6 +452,45 @@ export function createPluginDatabaseCore<TContext = unknown>(
     },
   };
 
+  Object.defineProperty(api, "diagnostics", {
+    configurable: true,
+    enumerable: true,
+    get(this: DatabaseAPI<TContext>) {
+      const diagnostics = getPlugin().diagnostics;
+      if (!diagnostics) {
+        Object.defineProperty(this, "diagnostics", {
+          configurable: true,
+          enumerable: true,
+          value: undefined,
+        });
+        return undefined;
+      }
+
+      const wrappedDiagnostics: NonNullable<
+        DatabaseAPI<TContext>["diagnostics"]
+      > = {};
+      if (diagnostics.bundleIndex) {
+        wrappedDiagnostics.bundleIndex = {
+          check: (context?: HotUpdaterContext<TContext>) =>
+            getPlugin().diagnostics!.bundleIndex!.check(context),
+          ...(diagnostics.bundleIndex.repair
+            ? {
+                repair: (context?: HotUpdaterContext<TContext>) =>
+                  getPlugin().diagnostics!.bundleIndex!.repair!(context),
+              }
+            : {}),
+        };
+      }
+
+      Object.defineProperty(this, "diagnostics", {
+        configurable: true,
+        enumerable: true,
+        value: wrappedDiagnostics,
+      });
+      return wrappedDiagnostics;
+    },
+  });
+
   return {
     api,
     adapterName: getPlugin().name,

package/src/db/requestBundleIdentityMap.spec.ts

@@ -0,0 +1,56 @@
+import type { Bundle } from "@hot-updater/core";
+import { describe, expect, it, vi } from "vitest";
+
+import { createRequestBundleIdentityMap } from "./requestBundleIdentityMap";
+
+const baseBundle: Bundle = {
+  channel: "production",
+  enabled: true,
+  fileHash: "file-hash",
+  fingerprintHash: null,
+  gitCommitHash: null,
+  id: "00000000-0000-0000-0000-000000000001",
+  message: "bundle",
+  platform: "ios",
+  shouldForceUpdate: false,
+  storageUri: "s3://bucket/bundle.zip",
+  targetAppVersion: "1.0.0",
+};
+
+describe("createRequestBundleIdentityMap", () => {
+  it("returns seeded bundles without loading them again", async () => {
+    const loadBundleById = vi.fn(async () => null);
+    const identityMap = createRequestBundleIdentityMap({
+      loadBundleById,
+      seeds: [baseBundle],
+    });
+
+    await expect(identityMap.get(baseBundle.id)).resolves.toBe(baseBundle);
+    expect(loadBundleById).not.toHaveBeenCalled();
+  });
+
+  it("shares one fallback lookup for repeated bundle reads", async () => {
+    const loadedBundle: Bundle = {
+      ...baseBundle,
+      id: "00000000-0000-0000-0000-000000000002",
+      message: "loaded",
+    };
+    const loadBundleById = vi.fn(async () => loadedBundle);
+    const identityMap = createRequestBundleIdentityMap({
+      loadBundleById,
+      seeds: [],
+    });
+
+    const [first, second] = await Promise.all([
+      identityMap.get(loadedBundle.id),
+      identityMap.get(loadedBundle.id),
+    ]);
+    const third = await identityMap.get(loadedBundle.id);
+
+    expect(first).toBe(loadedBundle);
+    expect(second).toBe(loadedBundle);
+    expect(third).toBe(loadedBundle);
+    expect(loadBundleById).toHaveBeenCalledTimes(1);
+    expect(loadBundleById).toHaveBeenCalledWith(loadedBundle.id, undefined);
+  });
+});

package/src/db/requestBundleIdentityMap.ts

@@ -0,0 +1,61 @@
+import type { Bundle } from "@hot-updater/core";
+import type { HotUpdaterContext } from "@hot-updater/plugin-core";
+
+type LoadBundleById<TContext> = (
+  bundleId: string,
+  context?: HotUpdaterContext<TContext>,
+) => Promise<Bundle | null>;
+
+type RequestBundleIdentityMapOptions<TContext> = {
+  readonly context?: HotUpdaterContext<TContext>;
+  readonly loadBundleById: LoadBundleById<TContext>;
+  readonly seeds: readonly (Bundle | null | undefined)[];
+};
+
+export const createRequestBundleIdentityMap = <TContext = unknown>({
+  context,
+  loadBundleById,
+  seeds,
+}: RequestBundleIdentityMapOptions<TContext>) => {
+  const bundles = new Map<string, Bundle>();
+  const pendingBundles = new Map<string, Promise<Bundle | null>>();
+
+  for (const seed of seeds) {
+    if (seed) {
+      bundles.set(seed.id, seed);
+    }
+  }
+
+  const get = async (bundleId: string): Promise<Bundle | null> => {
+    const cachedBundle = bundles.get(bundleId);
+    if (cachedBundle) {
+      return cachedBundle;
+    }
+
+    const pendingBundle = pendingBundles.get(bundleId);
+    if (pendingBundle) {
+      return pendingBundle;
+    }
+
+    const lookup = loadBundleById(bundleId, context).then(
+      (bundle) => {
+        pendingBundles.delete(bundleId);
+        if (bundle) {
+          bundles.set(bundle.id, bundle);
+        }
+        return bundle;
+      },
+      (error: unknown) => {
+        pendingBundles.delete(bundleId);
+        throw error;
+      },
+    );
+    pendingBundles.set(bundleId, lookup);
+    return lookup;
+  };
+
+  const peek = (bundleId: string): Bundle | null =>
+    bundles.get(bundleId) ?? null;
+
+  return { get, peek };
+};

package/src/db/types.ts

@@ -5,6 +5,7 @@ import type {
   UpdateInfo,
 } from "@hot-updater/core";
 import type {
+  DatabaseDiagnostics,
   DatabaseBundleQueryOptions,
   DatabasePlugin,
   HotUpdaterContext,
@@ -108,6 +109,7 @@ export interface DatabaseAPI<TContext = unknown> {
     bundleId: string,
     context?: HotUpdaterContext<TContext>,
   ): Promise<void>;
+  diagnostics?: DatabaseDiagnostics<TContext>;
 }
 
 export type StoragePluginFactory<TContext = unknown> =