@hot-updater/server 0.30.12 → 0.31.0

package/src/db/updateArtifacts.ts

@@ -0,0 +1,388 @@
+import {
+  getAssetBaseStorageUri,
+  getBundlePatch,
+  getManifestFileHash,
+  getManifestStorageUri,
+  stripBundleArtifactMetadata,
+  type AppUpdateAvailableInfo,
+  type Bundle,
+  type ChangedAsset,
+} from "@hot-updater/core";
+import type { HotUpdaterContext } from "@hot-updater/plugin-core";
+
+type BundleManifest = {
+  bundleId: string;
+  assets: Record<string, { fileHash: string; signature?: string }>;
+};
+
+type ResolveFileUrl<TContext> = (
+  storageUri: string | null,
+  context?: HotUpdaterContext<TContext>,
+) => Promise<string | null>;
+
+type ReadStorageText<TContext> = (
+  storageUri: string,
+  context?: HotUpdaterContext<TContext>,
+) => Promise<string | null>;
+
+const HBC_ASSET_PATH_RE = /\.bundle$/;
+const BR_COMPRESSED_ASSET_PATH_RE = /(^|\/)index\.[^/]+\.bundle$/;
+
+const resolveUniqueHbcAssetPath = (manifest: BundleManifest) => {
+  const candidates = Object.keys(manifest.assets)
+    .sort((left, right) => left.localeCompare(right))
+    .filter((candidate) => HBC_ASSET_PATH_RE.test(candidate));
+
+  return candidates.length === 1 ? candidates[0] : null;
+};
+
+const isBundleManifest = (value: unknown): value is BundleManifest => {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return false;
+  }
+
+  const manifest = value as {
+    bundleId?: unknown;
+    assets?: unknown;
+  };
+
+  if (typeof manifest.bundleId !== "string") {
+    return false;
+  }
+
+  if (!manifest.assets || typeof manifest.assets !== "object") {
+    return false;
+  }
+
+  return Object.values(manifest.assets as Record<string, unknown>).every(
+    (asset) => {
+      if (!asset || typeof asset !== "object" || Array.isArray(asset)) {
+        return false;
+      }
+
+      const manifestAsset = asset as {
+        fileHash?: unknown;
+        signature?: unknown;
+      };
+
+      return (
+        typeof manifestAsset.fileHash === "string" &&
+        (manifestAsset.signature === undefined ||
+          typeof manifestAsset.signature === "string")
+      );
+    },
+  );
+};
+
+const createChildStorageUri = (
+  baseStorageUri: string,
+  relativePath: string,
+) => {
+  const baseUrl = new URL(baseStorageUri);
+  const normalizedBasePath = baseUrl.pathname.replace(/\/+$/, "");
+  const relativeSegments = relativePath
+    .split("/")
+    .filter(Boolean)
+    .map((segment) => encodeURIComponent(segment));
+
+  baseUrl.pathname = `${normalizedBasePath}/${relativeSegments.join("/")}`;
+  return baseUrl.toString();
+};
+
+export const parseBundleMetadata = (
+  value: unknown,
+): Bundle["metadata"] | undefined => {
+  if (!value) {
+    return undefined;
+  }
+
+  let parsedValue: unknown = value;
+
+  if (typeof parsedValue === "string") {
+    try {
+      parsedValue = JSON.parse(parsedValue) as unknown;
+    } catch {
+      return undefined;
+    }
+  }
+
+  if (
+    !parsedValue ||
+    typeof parsedValue !== "object" ||
+    Array.isArray(parsedValue)
+  ) {
+    return undefined;
+  }
+
+  return stripBundleArtifactMetadata(parsedValue as Bundle["metadata"]);
+};
+
+export const parseBundleRawMetadata = (
+  value: unknown,
+): Bundle["metadata"] | undefined => {
+  if (!value) {
+    return undefined;
+  }
+
+  let parsedValue: unknown = value;
+
+  if (typeof parsedValue === "string") {
+    try {
+      parsedValue = JSON.parse(parsedValue) as unknown;
+    } catch {
+      return undefined;
+    }
+  }
+
+  if (
+    !parsedValue ||
+    typeof parsedValue !== "object" ||
+    Array.isArray(parsedValue)
+  ) {
+    return undefined;
+  }
+
+  return parsedValue as Bundle["metadata"];
+};
+
+async function fetchBundleManifest<TContext>(
+  storageUri: string,
+  readStorageText: ReadStorageText<TContext>,
+  resolveFileUrl: ResolveFileUrl<TContext>,
+  context?: HotUpdaterContext<TContext>,
+): Promise<{ fileUrl: string; manifest: BundleManifest } | null> {
+  const [storageText, fileUrl] = await Promise.all([
+    readStorageText(storageUri, context),
+    resolveFileUrl(storageUri, context),
+  ]);
+  if (storageText === null) {
+    return null;
+  }
+
+  let payload: unknown;
+  try {
+    payload = JSON.parse(storageText) as unknown;
+  } catch {
+    return null;
+  }
+
+  if (!isBundleManifest(payload)) {
+    return null;
+  }
+
+  if (!fileUrl) {
+    return null;
+  }
+
+  return {
+    fileUrl,
+    manifest: payload,
+  };
+}
+
+async function resolveChangedAssets<TContext>({
+  assetBaseStorageUri,
+  currentManifest,
+  currentBundle,
+  resolveFileUrl,
+  targetBundle,
+  targetManifest,
+  context,
+}: {
+  assetBaseStorageUri: string;
+  currentManifest: BundleManifest | null;
+  currentBundle: Bundle | null;
+  resolveFileUrl: ResolveFileUrl<TContext>;
+  targetBundle: Bundle | null;
+  targetManifest: BundleManifest;
+  context?: HotUpdaterContext<TContext>;
+}): Promise<Record<string, ChangedAsset> | null> {
+  const patchDescriptor = await resolveHbcPatchDescriptor({
+    currentBundle,
+    resolveFileUrl,
+    targetBundle,
+    targetManifest,
+    context,
+  });
+  const changedEntries = await Promise.all(
+    Object.entries(targetManifest.assets).map(async ([assetPath, asset]) => {
+      const currentAsset = currentManifest?.assets[assetPath];
+      if (currentAsset?.fileHash === asset.fileHash) {
+        return null;
+      }
+
+      const usesBrotliAsset = BR_COMPRESSED_ASSET_PATH_RE.test(assetPath);
+      const downloadPath = usesBrotliAsset ? `${assetPath}.br` : assetPath;
+      const storageUri = createChildStorageUri(
+        assetBaseStorageUri,
+        downloadPath,
+      );
+      const patch =
+        patchDescriptor?.assetPath === assetPath ? patchDescriptor.patch : null;
+
+      let fileUrl: string | null = null;
+      try {
+        fileUrl = await resolveFileUrl(storageUri, context);
+      } catch (error) {
+        if (!patch) {
+          throw error;
+        }
+      }
+
+      if (!fileUrl && !patch) {
+        return false;
+      }
+
+      const changedAsset: ChangedAsset = {
+        fileHash: asset.fileHash,
+      };
+      if (fileUrl) {
+        changedAsset.file = {
+          url: fileUrl,
+        };
+        if (usesBrotliAsset) {
+          changedAsset.file.compression = "br";
+        }
+      }
+      if (patch) {
+        changedAsset.patch = patch;
+      }
+
+      return [assetPath, changedAsset] as const;
+    }),
+  );
+
+  if (changedEntries.some((entry) => entry === false)) {
+    return null;
+  }
+
+  return Object.fromEntries(
+    changedEntries.filter(
+      (entry): entry is readonly [string, ChangedAsset] => entry !== null,
+    ),
+  );
+}
+
+async function resolveHbcPatchDescriptor<TContext>({
+  currentBundle,
+  resolveFileUrl,
+  targetBundle,
+  targetManifest,
+  context,
+}: {
+  currentBundle: Bundle | null;
+  resolveFileUrl: ResolveFileUrl<TContext>;
+  targetBundle: Bundle | null;
+  targetManifest: BundleManifest;
+  context?: HotUpdaterContext<TContext>;
+}): Promise<{
+  assetPath: string;
+  patch: ChangedAsset["patch"];
+} | null> {
+  const matchingPatch =
+    targetBundle && currentBundle
+      ? getBundlePatch(targetBundle, currentBundle.id)
+      : null;
+  const patchAssetPath = resolveUniqueHbcAssetPath(targetManifest);
+
+  if (
+    !currentBundle ||
+    !matchingPatch ||
+    !patchAssetPath ||
+    !matchingPatch.patchStorageUri ||
+    !matchingPatch.patchFileHash ||
+    !matchingPatch.baseFileHash
+  ) {
+    return null;
+  }
+
+  const patchUrl = await resolveFileUrl(matchingPatch.patchStorageUri, context);
+  if (!patchUrl) {
+    return null;
+  }
+
+  return {
+    assetPath: patchAssetPath,
+    patch: {
+      algorithm: "bsdiff",
+      baseBundleId: matchingPatch.baseBundleId,
+      baseFileHash: matchingPatch.baseFileHash,
+      patchFileHash: matchingPatch.patchFileHash,
+      patchUrl,
+    },
+  };
+}
+
+export async function resolveManifestArtifacts<TContext>({
+  currentBundle,
+  resolveFileUrl,
+  readStorageText,
+  targetBundle,
+  context,
+}: {
+  currentBundle: Bundle | null;
+  resolveFileUrl: ResolveFileUrl<TContext>;
+  readStorageText: ReadStorageText<TContext>;
+  targetBundle: Bundle | null;
+  context?: HotUpdaterContext<TContext>;
+}): Promise<Pick<
+  AppUpdateAvailableInfo,
+  "changedAssets" | "manifestFileHash" | "manifestUrl"
+> | null> {
+  const manifestStorageUri = targetBundle
+    ? getManifestStorageUri(targetBundle)
+    : null;
+  const manifestFileHash = targetBundle
+    ? getManifestFileHash(targetBundle)
+    : null;
+  const assetBaseStorageUri = targetBundle
+    ? getAssetBaseStorageUri(targetBundle)
+    : null;
+
+  if (!manifestStorageUri || !manifestFileHash || !assetBaseStorageUri) {
+    return null;
+  }
+
+  const currentManifestStorageUri = currentBundle
+    ? getManifestStorageUri(currentBundle)
+    : null;
+  const [targetManifestResult, currentManifestResult] = await Promise.all([
+    fetchBundleManifest(
+      manifestStorageUri,
+      readStorageText,
+      resolveFileUrl,
+      context,
+    ),
+    currentManifestStorageUri
+      ? fetchBundleManifest(
+          currentManifestStorageUri,
+          readStorageText,
+          resolveFileUrl,
+          context,
+        )
+      : null,
+  ]);
+
+  if (!targetManifestResult) {
+    return null;
+  }
+
+  const changedAssets = await resolveChangedAssets({
+    assetBaseStorageUri,
+    currentManifest: currentManifestResult?.manifest ?? null,
+    currentBundle,
+    resolveFileUrl,
+    targetBundle,
+    targetManifest: targetManifestResult.manifest,
+    context,
+  });
+  if (!changedAssets) {
+    return null;
+  }
+
+  return {
+    changedAssets,
+    manifestFileHash,
+    manifestUrl: targetManifestResult.fileUrl,
+  };
+}

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

@@ -87,6 +87,7 @@ beforeAll(async () => {
 
 afterEach(async () => {
   // Clean up database after each test
+  await db.exec("DELETE FROM bundle_patches");
   await db.exec("DELETE FROM bundles");
 });
 

package/src/handler.spec.ts

@@ -4,6 +4,9 @@ import { describe, expect, it, vi } from "vitest";
 import { createHandler, type HandlerAPI } from "./handler";
 import { HOT_UPDATER_SERVER_VERSION } from "./version";
 
+const NEXT_SDK_VERSION_FOR_TEST = "0.31.0";
+const CURRENT_PACKAGE_SDK_VERSION = "0.30.10";
+
 type TestEnv = {
   tenantId: string;
 };
@@ -83,6 +86,83 @@ describe("createHandler", () => {
     );
   });
 
+  it("keeps legacy no-update responses as null when SDK version is missing", async () => {
+    const api = createApi();
+    api.getAppUpdateInfo.mockResolvedValueOnce(null);
+    const handler = createHandler(api, { basePath: "/hot-updater" });
+
+    const response = await handler(
+      new Request(
+        "http://localhost/hot-updater/app-version/ios/1.0.0/production/default/default",
+      ),
+    );
+
+    expect(response.status).toBe(200);
+    await expect(response.json()).resolves.toBeNull();
+  });
+
+  it("returns UP_TO_DATE for no-update responses from SDK-versioned clients", async () => {
+    const api = createApi();
+    api.getAppUpdateInfo.mockResolvedValueOnce(null);
+    const handler = createHandler(api, { basePath: "/hot-updater" });
+
+    const response = await handler(
+      new Request(
+        "http://localhost/hot-updater/app-version/ios/1.0.0/production/default/default",
+        {
+          headers: {
+            "Hot-Updater-SDK-Version": NEXT_SDK_VERSION_FOR_TEST,
+          },
+        },
+      ),
+    );
+
+    expect(response.status).toBe(200);
+    await expect(response.json()).resolves.toEqual({
+      status: "UP_TO_DATE",
+    });
+  });
+
+  it("keeps no-update responses as null for unsupported SDK versions", async () => {
+    const api = createApi();
+    api.getAppUpdateInfo.mockResolvedValueOnce(null);
+    const handler = createHandler(api, { basePath: "/hot-updater" });
+
+    const response = await handler(
+      new Request(
+        "http://localhost/hot-updater/app-version/ios/1.0.0/production/default/default",
+        {
+          headers: {
+            "Hot-Updater-SDK-Version": CURRENT_PACKAGE_SDK_VERSION,
+          },
+        },
+      ),
+    );
+
+    expect(response.status).toBe(200);
+    await expect(response.json()).resolves.toBeNull();
+  });
+
+  it("keeps no-update responses as null for invalid SDK versions", async () => {
+    const api = createApi();
+    api.getAppUpdateInfo.mockResolvedValueOnce(null);
+    const handler = createHandler(api, { basePath: "/hot-updater" });
+
+    const response = await handler(
+      new Request(
+        "http://localhost/hot-updater/app-version/ios/1.0.0/production/default/default",
+        {
+          headers: {
+            "Hot-Updater-SDK-Version": "invalid",
+          },
+        },
+      ),
+    );
+
+    expect(response.status).toBe(200);
+    await expect(response.json()).resolves.toBeNull();
+  });
+
   it("supports the fingerprint route without a cohort segment", async () => {
     const api = createApi();
     const handler = createHandler(api, { basePath: "/hot-updater" });
@@ -247,6 +327,47 @@ describe("createHandler", () => {
     );
   });
 
+  it("passes advanced bundle filters through to getBundles", async () => {
+    const api = createApi();
+    api.getBundles.mockResolvedValue({
+      data: [testBundle],
+      pagination: {
+        total: 1,
+        hasNextPage: false,
+        hasPreviousPage: false,
+        currentPage: 1,
+        totalPages: 1,
+      },
+    });
+    const handler = createHandler(api, { basePath: "/hot-updater" });
+
+    const response = await handler(
+      new Request(
+        "http://localhost/hot-updater/api/bundles?channel=production&platform=ios&enabled=true&idLt=bundle-9&targetAppVersion=1.0.x&targetAppVersionNotNull=true&fingerprintHash=null&limit=5",
+      ),
+    );
+
+    expect(response.status).toBe(200);
+    expect(api.getBundles).toHaveBeenCalledWith(
+      {
+        where: {
+          channel: "production",
+          platform: "ios",
+          enabled: true,
+          id: {
+            lt: "bundle-9",
+          },
+          targetAppVersion: "1.0.x",
+          targetAppVersionNotNull: true,
+          fingerprintHash: null,
+        },
+        limit: 5,
+        page: undefined,
+      },
+      undefined,
+    );
+  });
+
   it("passes cursor pagination params through to getBundles", async () => {
     const api = createApi();
     api.getBundles.mockResolvedValue({