@hot-updater/server 0.36.7 → 1.0.0-rc.0

package/src/db/updateArtifacts.ts

@@ -4,33 +4,97 @@ import {
   getManifestFileHash,
   getManifestStorageUri,
   stripBundleArtifactMetadata,
-  type AppUpdateAvailableInfo,
+  type ArtifactInfo,
   type Bundle,
   type ChangedAsset,
 } from "@hot-updater/core";
 import {
   getManifestAssetDownloadPath,
+  isContentAddressedAssetFileHash,
   resolveManifestAssetStorageUri,
-  type HotUpdaterContext,
 } from "@hot-updater/plugin-core";
 
+type BundleManifestAsset = {
+  downloadByteSize?: unknown;
+  downloadFileHash?: unknown;
+  fileHash: string;
+  signature?: string;
+};
+
 type BundleManifest = {
   bundleId: string;
-  assets: Record<string, { fileHash: string; signature?: string }>;
+  assets: Record<string, BundleManifestAsset>;
 };
 
-type ResolveFileUrl<TContext> = (
-  storageUri: string | null,
-  context?: HotUpdaterContext<TContext>,
-) => Promise<string | null>;
+type PlannedFile = {
+  byteSize: number | null;
+  compression?: "br";
+  storageUri: string;
+};
 
-type ReadStorageText<TContext> = (
-  storageUri: string,
-  context?: HotUpdaterContext<TContext>,
-) => Promise<string | null>;
+type PlannedPatch = {
+  baseBundleId: string;
+  baseFileHash: string;
+  byteSize: number | null;
+  patchFileHash: string;
+  storageUri: string;
+};
+
+type PlannedChangedAsset = {
+  assetPath: string;
+  file: PlannedFile;
+  fileHash: string;
+  patch: PlannedPatch | null;
+};
+
+type ManifestArtifactPlan = {
+  allPossibleByteSizesKnown: boolean;
+  changedAssets: PlannedChangedAsset[];
+  manifestByteSize: number | null;
+  minimumDownloadByteSize: number | null;
+};
+
+type ResolvedChangedAssets = {
+  changedAssets: Record<string, ChangedAsset>;
+  primaryByteSizes: Array<number | null>;
+};
+
+type ResolveFileUrl = (storageUri: string | null) => Promise<string | null>;
+
+type ReadStorageText = (storageUri: string) => Promise<string | null>;
 
 const HBC_ASSET_PATH_RE = /\.bundle$/;
 
+const asByteSize = (value: unknown): number | null =>
+  typeof value === "number" && Number.isSafeInteger(value) && value >= 0
+    ? value
+    : null;
+
+const sumByteSizes = (byteSizes: Array<number | null>): number | null => {
+  let total = 0;
+
+  for (const byteSize of byteSizes) {
+    if (byteSize === null || total > Number.MAX_SAFE_INTEGER - byteSize) {
+      return null;
+    }
+    total += byteSize;
+  }
+
+  return total;
+};
+
+const shouldUseArchive = (
+  targetBundle: Bundle,
+  downloadByteSize: number | null,
+) => {
+  const archiveByteSize = asByteSize(targetBundle.archiveByteSize);
+  return (
+    archiveByteSize !== null &&
+    downloadByteSize !== null &&
+    downloadByteSize >= archiveByteSize
+  );
+};
+
 const resolveUniqueHbcAssetPath = (manifest: BundleManifest) => {
   const candidates = Object.keys(manifest.assets)
     .sort((left, right) => left.localeCompare(right))
@@ -133,16 +197,14 @@ export const parseBundleRawMetadata = (
   return parsedValue as Bundle["metadata"];
 };
 
-async function fetchBundleManifest<TContext>(
+async function fetchBundleManifest(
   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),
-  ]);
+  readStorageText: ReadStorageText,
+): Promise<{
+  byteSize: number | null;
+  manifest: BundleManifest;
+} | null> {
+  const storageText = await readStorageText(storageUri);
   if (storageText === null) {
     return null;
   }
@@ -158,68 +220,191 @@ async function fetchBundleManifest<TContext>(
     return null;
   }
 
-  if (!fileUrl) {
+  return {
+    byteSize: asByteSize(new TextEncoder().encode(storageText).byteLength),
+    manifest: payload,
+  };
+}
+
+function resolveHbcPatchPlan({
+  currentBundle,
+  targetBundle,
+  targetManifest,
+}: {
+  currentBundle: Bundle | null;
+  targetBundle: Bundle;
+  targetManifest: BundleManifest;
+}): { assetPath: string; patch: PlannedPatch } | null {
+  const matchingPatch = currentBundle
+    ? getBundlePatch(targetBundle, currentBundle.id)
+    : null;
+  const patchAssetPath = resolveUniqueHbcAssetPath(targetManifest);
+
+  if (
+    !currentBundle ||
+    !matchingPatch ||
+    !patchAssetPath ||
+    !matchingPatch.patchStorageUri ||
+    !matchingPatch.patchFileHash ||
+    !matchingPatch.baseFileHash
+  ) {
     return null;
   }
 
   return {
-    fileUrl,
-    manifest: payload,
+    assetPath: patchAssetPath,
+    patch: {
+      baseBundleId: matchingPatch.baseBundleId,
+      baseFileHash: matchingPatch.baseFileHash,
+      byteSize: asByteSize(matchingPatch.byteSize),
+      patchFileHash: matchingPatch.patchFileHash,
+      storageUri: matchingPatch.patchStorageUri,
+    },
   };
 }
 
-async function resolveChangedAssets<TContext>({
+function createManifestArtifactPlan({
   assetBaseStorageUri,
   currentManifest,
   currentBundle,
-  resolveFileUrl,
   targetBundle,
   targetManifest,
-  context,
+  targetManifestByteSize,
 }: {
   assetBaseStorageUri: string;
   currentManifest: BundleManifest | null;
   currentBundle: Bundle | null;
-  resolveFileUrl: ResolveFileUrl<TContext>;
-  targetBundle: Bundle | null;
+  targetBundle: Bundle;
   targetManifest: BundleManifest;
-  context?: HotUpdaterContext<TContext>;
-}): Promise<Record<string, ChangedAsset> | null> {
-  const patchDescriptor = await resolveHbcPatchDescriptor({
+  targetManifestByteSize: number | null;
+}): ManifestArtifactPlan {
+  const patchCandidate = resolveHbcPatchPlan({
     currentBundle,
-    resolveFileUrl,
     targetBundle,
     targetManifest,
-    context,
   });
-  const changedEntries = await Promise.all(
-    Object.entries(targetManifest.assets).map(async ([assetPath, asset]) => {
+  const changedAssets = Object.entries(targetManifest.assets).flatMap(
+    ([assetPath, asset]): PlannedChangedAsset[] => {
       const currentAsset = currentManifest?.assets[assetPath];
       if (currentAsset?.fileHash === asset.fileHash) {
-        return null;
+        return [];
       }
 
+      const downloadByteSize = asByteSize(asset.downloadByteSize);
       const downloadPath = getManifestAssetDownloadPath(assetPath);
-      const usesBrotliAsset = downloadPath !== assetPath;
-      const storageUri = resolveManifestAssetStorageUri({
-        assetBaseStorageUri,
-        assetPath: downloadPath,
-        fileHash: asset.fileHash,
-      });
+      const isTransformedDownload = downloadPath !== assetPath;
+      const hasValidDownloadFileHash = isContentAddressedAssetFileHash(
+        asset.downloadFileHash,
+      );
+      const hasKnownDownloadByteSize =
+        downloadByteSize !== null &&
+        (hasValidDownloadFileHash ||
+          (!isTransformedDownload && asset.downloadFileHash === undefined));
+      const file: PlannedFile = {
+        byteSize: hasKnownDownloadByteSize ? downloadByteSize : null,
+        storageUri: resolveManifestAssetStorageUri({
+          assetBaseStorageUri,
+          assetPath: downloadPath,
+          downloadFileHash: asset.downloadFileHash,
+          fileHash: asset.fileHash,
+        }),
+      };
+      if (isTransformedDownload) {
+        file.compression = "br";
+      }
+
       const patch =
-        patchDescriptor?.assetPath === assetPath ? patchDescriptor.patch : null;
+        patchCandidate?.assetPath === assetPath ? patchCandidate.patch : null;
+
+      return [
+        {
+          assetPath,
+          file,
+          fileHash: asset.fileHash,
+          patch,
+        },
+      ];
+    },
+  );
+  const allPossibleByteSizesKnown =
+    targetManifestByteSize !== null &&
+    changedAssets.every(
+      (asset) =>
+        asset.file.byteSize !== null &&
+        (asset.patch === null || asset.patch.byteSize !== null),
+    );
+  const primaryByteSizes = changedAssets.map((asset) => {
+    if (!asset.patch) return asset.file.byteSize;
+    if (asset.patch.byteSize === null || asset.file.byteSize === null) {
+      return null;
+    }
+    return Math.min(asset.patch.byteSize, asset.file.byteSize);
+  });
+
+  return {
+    allPossibleByteSizesKnown,
+    changedAssets,
+    manifestByteSize: targetManifestByteSize,
+    minimumDownloadByteSize: allPossibleByteSizesKnown
+      ? sumByteSizes([targetManifestByteSize, ...primaryByteSizes])
+      : null,
+  };
+}
+
+async function resolveChangedAssets(
+  plan: ManifestArtifactPlan,
+  resolveFileUrl: ResolveFileUrl,
+): Promise<ResolvedChangedAssets | null> {
+  const patchAsset = plan.changedAssets.find((asset) => asset.patch !== null);
+  let resolvedPatch: {
+    assetPath: string;
+    patch: NonNullable<ChangedAsset["patch"]>;
+  } | null = null;
+
+  if (patchAsset?.patch) {
+    const patchUrl = await resolveFileUrl(patchAsset.patch.storageUri);
+    if (patchUrl) {
+      resolvedPatch = {
+        assetPath: patchAsset.assetPath,
+        patch: {
+          algorithm: "bsdiff",
+          baseBundleId: patchAsset.patch.baseBundleId,
+          baseFileHash: patchAsset.patch.baseFileHash,
+          patchFileHash: patchAsset.patch.patchFileHash,
+          patchUrl,
+        },
+      };
+    }
+  }
 
+  const changedEntries = await Promise.all(
+    plan.changedAssets.map(async (asset) => {
+      let patch =
+        resolvedPatch?.assetPath === asset.assetPath
+          ? resolvedPatch.patch
+          : null;
       let fileUrl: string | null = null;
       try {
-        fileUrl = await resolveFileUrl(storageUri, context);
+        fileUrl = await resolveFileUrl(asset.file.storageUri);
       } catch (error) {
         if (!patch) {
           throw error;
         }
       }
 
+      if (
+        fileUrl &&
+        patch &&
+        asset.file.byteSize !== null &&
+        asset.patch !== null &&
+        asset.patch.byteSize !== null &&
+        asset.patch.byteSize >= asset.file.byteSize
+      ) {
+        patch = null;
+      }
+
       if (!fileUrl && !patch) {
-        return false;
+        return null;
       }
 
       const changedAsset: ChangedAsset = {
@@ -229,93 +414,52 @@ async function resolveChangedAssets<TContext>({
         changedAsset.file = {
           url: fileUrl,
         };
-        if (usesBrotliAsset) {
-          changedAsset.file.compression = "br";
+        if (asset.file.compression) {
+          changedAsset.file.compression = asset.file.compression;
         }
       }
       if (patch) {
         changedAsset.patch = patch;
       }
 
-      return [assetPath, changedAsset] as const;
+      return {
+        asset: [asset.assetPath, changedAsset] as const,
+        primaryByteSize: patch
+          ? (asset.patch?.byteSize ?? null)
+          : asset.file.byteSize,
+      };
     }),
   );
 
-  if (changedEntries.some((entry) => entry === false)) {
+  if (changedEntries.some((entry) => entry === null)) {
     return null;
   }
 
-  return Object.fromEntries(
-    changedEntries.filter(
-      (entry): entry is readonly [string, ChangedAsset] => entry !== null,
-    ),
+  const resolvedEntries = changedEntries.filter(
+    (entry): entry is NonNullable<typeof entry> => 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,
-    },
+    changedAssets: Object.fromEntries(
+      resolvedEntries.map((entry) => entry.asset),
+    ),
+    primaryByteSizes: resolvedEntries.map((entry) => entry.primaryByteSize),
   };
 }
 
-export async function resolveManifestArtifacts<TContext>({
+export async function resolveManifestArtifacts({
+  archiveUrlUsable,
   currentBundle,
   resolveFileUrl,
   readStorageText,
   targetBundle,
-  context,
 }: {
+  archiveUrlUsable: boolean;
   currentBundle: Bundle | null;
-  resolveFileUrl: ResolveFileUrl<TContext>;
-  readStorageText: ReadStorageText<TContext>;
+  resolveFileUrl: ResolveFileUrl;
+  readStorageText: ReadStorageText;
   targetBundle: Bundle | null;
-  context?: HotUpdaterContext<TContext>;
 }): Promise<Pick<
-  AppUpdateAvailableInfo,
+  ArtifactInfo,
   "changedAssets" | "manifestFileHash" | "manifestUrl"
 > | null> {
   const manifestStorageUri = targetBundle
@@ -328,7 +472,12 @@ export async function resolveManifestArtifacts<TContext>({
     ? getAssetBaseStorageUri(targetBundle)
     : null;
 
-  if (!manifestStorageUri || !manifestFileHash || !assetBaseStorageUri) {
+  if (
+    !targetBundle ||
+    !manifestStorageUri ||
+    !manifestFileHash ||
+    !assetBaseStorageUri
+  ) {
     return null;
   }
 
@@ -336,19 +485,9 @@ export async function resolveManifestArtifacts<TContext>({
     ? getManifestStorageUri(currentBundle)
     : null;
   const [targetManifestResult, currentManifestResult] = await Promise.all([
-    fetchBundleManifest(
-      manifestStorageUri,
-      readStorageText,
-      resolveFileUrl,
-      context,
-    ),
+    fetchBundleManifest(manifestStorageUri, readStorageText),
     currentManifestStorageUri
-      ? fetchBundleManifest(
-          currentManifestStorageUri,
-          readStorageText,
-          resolveFileUrl,
-          context,
-        )
+      ? fetchBundleManifest(currentManifestStorageUri, readStorageText)
       : null,
   ]);
 
@@ -356,22 +495,47 @@ export async function resolveManifestArtifacts<TContext>({
     return null;
   }
 
-  const changedAssets = await resolveChangedAssets({
+  const plan = createManifestArtifactPlan({
     assetBaseStorageUri,
     currentManifest: currentManifestResult?.manifest ?? null,
     currentBundle,
-    resolveFileUrl,
     targetBundle,
     targetManifest: targetManifestResult.manifest,
-    context,
+    targetManifestByteSize: targetManifestResult.byteSize,
   });
-  if (!changedAssets) {
+
+  if (
+    archiveUrlUsable &&
+    plan.allPossibleByteSizesKnown &&
+    shouldUseArchive(targetBundle, plan.minimumDownloadByteSize)
+  ) {
+    return null;
+  }
+
+  const manifestUrl = await resolveFileUrl(manifestStorageUri);
+  if (!manifestUrl) {
+    return null;
+  }
+
+  const resolved = await resolveChangedAssets(plan, resolveFileUrl);
+  if (!resolved) {
+    return null;
+  }
+
+  const resolvedDownloadByteSize = sumByteSizes([
+    plan.manifestByteSize,
+    ...resolved.primaryByteSizes,
+  ]);
+  if (
+    archiveUrlUsable &&
+    shouldUseArchive(targetBundle, resolvedDownloadByteSize)
+  ) {
     return null;
   }
 
   return {
-    changedAssets,
+    changedAssets: resolved.changedAssets,
     manifestFileHash,
-    manifestUrl: targetManifestResult.fileUrl,
+    manifestUrl,
   };
 }