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

package/src/db/createBundleDiff.spec.ts

@@ -1,14 +1,19 @@
-import fs from "node:fs/promises";
 import { brotliCompressSync } from "node:zlib";
 
 import type {
   Bundle,
   DatabasePlugin,
-  NodeStoragePlugin,
-  NodeStorageProfile,
+  StoragePlugin,
+  StoragePluginWith,
+} from "@hot-updater/plugin-core";
+import {
+  createDatabaseClient,
+  createStoragePlugin as createCoreStoragePlugin,
 } from "@hot-updater/plugin-core";
 import { afterEach, describe, expect, it, vi } from "vitest";
 
+import { createInMemoryDatabasePlugin } from "../../../test-utils/test/inMemoryDatabasePlugin";
+
 vi.mock("@hot-updater/bsdiff", () => ({
   hdiff: vi.fn(async () => new Uint8Array([1, 2, 3, 4])),
 }));
@@ -16,90 +21,52 @@ vi.mock("@hot-updater/bsdiff", () => ({
 import { createBundleDiff } from "./createBundleDiff";
 
 const createBundle = (id: string, overrides: Partial<Bundle> = {}): Bundle => ({
-  channel: "production",
-  enabled: true,
+  archiveByteSize: 1_024,
   fileHash: `${id}-file-hash`,
-  fingerprintHash: null,
   gitCommitHash: null,
   id,
-  message: id,
-  assetBaseStorageUri: `s3://test-bucket/releases/${id}/files`,
-  manifestStorageUri: `s3://test-bucket/releases/${id}/manifest.json`,
+  assetBaseStorageUri: "s3://test-bucket/releases/assets",
+  manifestStorageUri: `s3://test-bucket/releases/bundles/${id}/manifest.json`,
   metadata: {},
   platform: "ios",
-  shouldForceUpdate: false,
-  storageUri: `s3://test-bucket/releases/${id}/bundle.zip`,
-  targetAppVersion: "1.0.0",
+  storageUri: `s3://test-bucket/releases/bundles/${id}/bundle.zip`,
   ...overrides,
 });
 
-const createDatabasePlugin = (
-  bundles: Map<string, Bundle>,
-): DatabasePlugin => ({
-  name: "mockDatabase",
-  async appendBundle() {},
-  async commitBundle() {},
-  async deleteBundle() {},
-  async getBundleById(bundleId) {
-    return bundles.get(bundleId) ?? null;
-  },
-  async getBundles() {
-    return {
-      data: Array.from(bundles.values()),
-      pagination: {
-        currentPage: 1,
-        hasNextPage: false,
-        hasPreviousPage: false,
-        total: bundles.size,
-        totalPages: 1,
-      },
-    };
-  },
-  async getChannels() {
-    return ["production"];
-  },
-  async onUnmount() {},
-  async updateBundle(bundleId, nextBundle) {
-    const currentBundle = bundles.get(bundleId);
-    if (!currentBundle) {
-      return;
-    }
-    bundles.set(bundleId, {
-      ...currentBundle,
-      ...nextBundle,
-      metadata: {
-        ...currentBundle.metadata,
-        ...nextBundle.metadata,
-      },
-    });
-  },
-});
+const createDatabasePlugin = async (
+  bundles: readonly Bundle[],
+): Promise<DatabasePlugin> => {
+  const plugin = createInMemoryDatabasePlugin();
+  const client = createDatabaseClient(plugin);
+  for (const bundle of bundles) await client.insertBundle(bundle);
+  return plugin;
+};
 
 const createStoragePlugin = (
-  upload: NodeStorageProfile["upload"],
-): NodeStoragePlugin => ({
-  name: "mockStorage",
-  supportedProtocol: "s3",
-  profiles: {
-    node: {
-      async delete() {},
-      async downloadFile(storageUri, filePath) {
+  put: NonNullable<StoragePlugin["put"]>,
+  options: {
+    get?: NonNullable<StoragePlugin["get"]>;
+    protocol?: string;
+  } = {},
+): StoragePluginWith<"get" | "put" | "delete"> =>
+  createCoreStoragePlugin({
+    name: "mockStorage",
+    protocol: options.protocol ?? "s3",
+    async delete({ storageUri }) {
+      void storageUri;
+      return { deleted: true };
+    },
+    get:
+      options.get ??
+      (async ({ storageUri }) => {
         const storageUrl = new URL(storageUri);
         const response = await fetch(
           `https://assets.example.com${storageUrl.pathname}`,
         );
-        await fs.writeFile(
-          filePath,
-          new Uint8Array(await response.arrayBuffer()),
-        );
-      },
-      async exists() {
-        return false;
-      },
-      upload,
-    },
-  },
-});
+        return { response: response.ok ? response : null };
+      }),
+    put,
+  });
 
 describe("createBundleDiff", () => {
   afterEach(() => {
@@ -107,20 +74,20 @@ describe("createBundleDiff", () => {
   });
 
   it("uploads a Hermes patch and stores patch metadata on the target bundle", async () => {
-    const baseBundle = createBundle("00000000-0000-0000-0000-000000000001", {
-      message: "base",
-    });
-    const targetBundle = createBundle("00000000-0000-0000-0000-000000000002", {
-      message: "target",
-    });
-    const bundles = new Map([
-      [baseBundle.id, baseBundle],
-      [targetBundle.id, targetBundle],
-    ]);
-    const upload = vi.fn<NodeStorageProfile["upload"]>(
-      async (key, filePath) => ({
-        storageUri: `s3://test-bucket/${key}/${filePath.split("/").pop()}`,
-      }),
+    const baseBundle = createBundle("00000000-0000-0000-0000-000000000001");
+    const targetBundle = createBundle("00000000-0000-0000-0000-000000000002");
+    const baseDownloadFileHash = "a".repeat(64);
+    const targetDownloadFileHash = "b".repeat(64);
+    const plugin = await createDatabasePlugin([baseBundle, targetBundle]);
+    const databasePlugin: DatabasePlugin = plugin;
+    const commit = vi.spyOn(databasePlugin, "commit");
+    const upload = vi.fn<NonNullable<StoragePlugin["put"]>>(
+      async ({ key, body, contentLength }) => {
+        const bytes = new Uint8Array(await new Response(body).arrayBuffer());
+        expect(bytes).toEqual(new Uint8Array([1, 2, 3, 4]));
+        expect(contentLength).toBe(bytes.byteLength);
+        return { storageUri: `s3://test-bucket/${key}` };
+      },
     );
 
     vi.stubGlobal(
@@ -133,6 +100,8 @@ describe("createBundleDiff", () => {
             JSON.stringify({
               assets: {
                 "index.ios.bundle": {
+                  downloadByteSize: 7,
+                  downloadFileHash: baseDownloadFileHash,
                   fileHash: "hash-old",
                 },
               },
@@ -146,6 +115,8 @@ describe("createBundleDiff", () => {
             JSON.stringify({
               assets: {
                 "index.ios.bundle": {
+                  downloadByteSize: 7,
+                  downloadFileHash: targetDownloadFileHash,
                   fileHash: "hash-new",
                 },
               },
@@ -154,19 +125,19 @@ describe("createBundleDiff", () => {
           );
         }
 
-        if (url.endsWith(`${baseBundle.id}/files/index.ios.bundle.br`)) {
+        if (url.endsWith(`/assets/sha256/aa/${baseDownloadFileHash}.br`)) {
           return new Response(brotliCompressSync(new Uint8Array([1, 2, 3])));
         }
 
-        if (url.endsWith(`${baseBundle.id}/files/index.ios.bundle`)) {
+        if (url.endsWith("/assets/sha256/ha/hash-old.bundle")) {
           return new Response(new Uint8Array([1, 2, 3]));
         }
 
-        if (url.endsWith(`${targetBundle.id}/files/index.ios.bundle.br`)) {
+        if (url.endsWith(`/assets/sha256/bb/${targetDownloadFileHash}.br`)) {
           return new Response(brotliCompressSync(new Uint8Array([1, 9, 3])));
         }
 
-        if (url.endsWith(`${targetBundle.id}/files/index.ios.bundle`)) {
+        if (url.endsWith("/assets/sha256/ha/hash-new.bundle")) {
           return new Response(new Uint8Array([1, 9, 3]));
         }
 
@@ -181,26 +152,28 @@ describe("createBundleDiff", () => {
           bundleId: targetBundle.id,
         },
         {
-          databasePlugin: createDatabasePlugin(bundles),
+          databasePlugin,
           storagePlugin: createStoragePlugin(upload),
         },
       );
 
       expect(upload).toHaveBeenCalledOnce();
-      expect(updatedBundle).toMatchObject({
-        patchBaseBundleId: baseBundle.id,
-        patchBaseFileHash: "hash-old",
-      });
-      expect(updatedBundle.patchFileHash).toMatch(/[a-f0-9]{64}/);
-      expect(updatedBundle.patchStorageUri).toContain(
-        `bundles/${targetBundle.id}/patches/${baseBundle.id}`,
+      expect(commit).toHaveBeenCalledOnce();
+      const [patch] = updatedBundle.patches ?? [];
+      expect(patch?.baseBundleId).toBe(baseBundle.id);
+      expect(patch?.baseFileHash).toBe("hash-old");
+      expect(patch?.byteSize).toBe(4);
+      expect(patch?.patchFileHash).toMatch(/[a-f0-9]{64}/);
+      expect(patch?.patchStorageUri).toContain(
+        `bundles/${targetBundle.id}/patches/${baseBundle.id}/${patch?.patchFileHash}/`,
       );
       expect(updatedBundle.patches).toEqual([
         {
           baseBundleId: baseBundle.id,
           baseFileHash: "hash-old",
-          patchFileHash: updatedBundle.patchFileHash,
-          patchStorageUri: updatedBundle.patchStorageUri,
+          byteSize: 4,
+          patchFileHash: patch?.patchFileHash,
+          patchStorageUri: patch?.patchStorageUri,
         },
       ]);
     } finally {
@@ -211,13 +184,13 @@ describe("createBundleDiff", () => {
   it("rejects ambiguous Hermes bundle assets in manifests", async () => {
     const baseBundle = createBundle("00000000-0000-0000-0000-000000000001");
     const targetBundle = createBundle("00000000-0000-0000-0000-000000000002");
-    const bundles = new Map([
-      [baseBundle.id, baseBundle],
-      [targetBundle.id, targetBundle],
+    const databasePlugin = await createDatabasePlugin([
+      baseBundle,
+      targetBundle,
     ]);
-    const upload = vi.fn<NodeStorageProfile["upload"]>(
-      async (key, filePath) => ({
-        storageUri: `s3://test-bucket/${key}/${filePath.split("/").pop()}`,
+    const upload = vi.fn<NonNullable<StoragePlugin["put"]>>(
+      async ({ key }) => ({
+        storageUri: `s3://test-bucket/${key}`,
       }),
     );
 
@@ -270,7 +243,7 @@ describe("createBundleDiff", () => {
             bundleId: targetBundle.id,
           },
           {
-            databasePlugin: createDatabasePlugin(bundles),
+            databasePlugin,
             storagePlugin: createStoragePlugin(upload),
           },
         ),
@@ -281,6 +254,84 @@ describe("createBundleDiff", () => {
     }
   });
 
+  it("uses a matching HTTPS storage plugin before direct fetch", async () => {
+    const baseBundle = createBundle("00000000-0000-0000-0000-000000000001", {
+      assetBaseStorageUri: "https://storage.example.com/releases/assets",
+      manifestStorageUri:
+        "https://storage.example.com/releases/base/manifest.json",
+    });
+    const targetBundle = createBundle("00000000-0000-0000-0000-000000000002", {
+      assetBaseStorageUri: "https://storage.example.com/releases/assets",
+      manifestStorageUri:
+        "https://storage.example.com/releases/target/manifest.json",
+    });
+    const databasePlugin = await createDatabasePlugin([
+      baseBundle,
+      targetBundle,
+    ]);
+    const responses = new Map<string, string | Uint8Array>([
+      [
+        baseBundle.manifestStorageUri!,
+        JSON.stringify({
+          assets: { "index.ios.bundle": { fileHash: "hash-old" } },
+          bundleId: baseBundle.id,
+        }),
+      ],
+      [
+        targetBundle.manifestStorageUri!,
+        JSON.stringify({
+          assets: { "index.ios.bundle": { fileHash: "hash-new" } },
+          bundleId: targetBundle.id,
+        }),
+      ],
+      [
+        `${baseBundle.assetBaseStorageUri}/sha256/ha/hash-old.bundle`,
+        new Uint8Array([1, 2, 3]),
+      ],
+      [
+        `${targetBundle.assetBaseStorageUri}/sha256/ha/hash-new.bundle`,
+        new Uint8Array([1, 9, 3]),
+      ],
+    ]);
+    const get = vi.fn<NonNullable<StoragePlugin["get"]>>(
+      async ({ storageUri }) => ({
+        response: responses.has(storageUri)
+          ? new Response(responses.get(storageUri))
+          : null,
+      }),
+    );
+    const directFetch = vi.fn<typeof fetch>();
+    vi.stubGlobal("fetch", directFetch);
+    const upload = vi.fn<NonNullable<StoragePlugin["put"]>>(
+      async ({ key }) => ({
+        storageUri: `https://storage.example.com/${key}`,
+      }),
+    );
+
+    try {
+      await createBundleDiff(
+        { baseBundleId: baseBundle.id, bundleId: targetBundle.id },
+        {
+          databasePlugin,
+          storagePlugin: createStoragePlugin(upload, {
+            get,
+            protocol: "https",
+          }),
+        },
+      );
+
+      expect(get).toHaveBeenCalledWith({
+        storageUri: baseBundle.manifestStorageUri,
+      });
+      expect(get).toHaveBeenCalledWith({
+        storageUri: targetBundle.manifestStorageUri,
+      });
+      expect(directFetch).not.toHaveBeenCalled();
+    } finally {
+      vi.unstubAllGlobals();
+    }
+  });
+
   it("appends additional patch bases without replacing the primary patch when requested", async () => {
     const primaryBaseBundle = createBundle(
       "00000000-0000-0000-0000-000000000001",
@@ -293,23 +344,20 @@ describe("createBundleDiff", () => {
         {
           baseBundleId: primaryBaseBundle.id,
           baseFileHash: "hash-primary-old",
+          byteSize: 4,
           patchFileHash: "hash-primary-patch",
           patchStorageUri: `s3://test-bucket/${primaryBaseBundle.id}/existing.bsdiff`,
         },
       ],
-      patchBaseBundleId: primaryBaseBundle.id,
-      patchBaseFileHash: "hash-primary-old",
-      patchFileHash: "hash-primary-patch",
-      patchStorageUri: `s3://test-bucket/${primaryBaseBundle.id}/existing.bsdiff`,
     });
-    const bundles = new Map([
-      [primaryBaseBundle.id, primaryBaseBundle],
-      [secondaryBaseBundle.id, secondaryBaseBundle],
-      [targetBundle.id, targetBundle],
+    const databasePlugin = await createDatabasePlugin([
+      primaryBaseBundle,
+      secondaryBaseBundle,
+      targetBundle,
     ]);
-    const upload = vi.fn<NodeStorageProfile["upload"]>(
-      async (key, filePath) => ({
-        storageUri: `s3://test-bucket/${key}/${filePath.split("/").pop()}`,
+    const upload = vi.fn<NonNullable<StoragePlugin["put"]>>(
+      async ({ key }) => ({
+        storageUri: `s3://test-bucket/${key}`,
       }),
     );
 
@@ -344,21 +392,19 @@ describe("createBundleDiff", () => {
           );
         }
 
-        if (
-          url.endsWith(`${secondaryBaseBundle.id}/files/index.ios.bundle.br`)
-        ) {
+        if (url.endsWith("/assets/sha256/ha/hash-secondary-old.br")) {
           return new Response(brotliCompressSync(new Uint8Array([1, 2, 3])));
         }
 
-        if (url.endsWith(`${secondaryBaseBundle.id}/files/index.ios.bundle`)) {
+        if (url.endsWith("/assets/sha256/ha/hash-secondary-old.bundle")) {
           return new Response(new Uint8Array([1, 2, 3]));
         }
 
-        if (url.endsWith(`${targetBundle.id}/files/index.ios.bundle.br`)) {
+        if (url.endsWith("/assets/sha256/ha/hash-target-new.br")) {
           return new Response(brotliCompressSync(new Uint8Array([1, 4, 3])));
         }
 
-        if (url.endsWith(`${targetBundle.id}/files/index.ios.bundle`)) {
+        if (url.endsWith("/assets/sha256/ha/hash-target-new.bundle")) {
           return new Response(new Uint8Array([1, 4, 3]));
         }
 
@@ -373,7 +419,7 @@ describe("createBundleDiff", () => {
           bundleId: targetBundle.id,
         },
         {
-          databasePlugin: createDatabasePlugin(bundles),
+          databasePlugin,
           storagePlugin: createStoragePlugin(upload),
         },
         {
@@ -381,7 +427,6 @@ describe("createBundleDiff", () => {
         },
       );
 
-      expect(updatedBundle.patchBaseBundleId).toBe(primaryBaseBundle.id);
       expect(updatedBundle.patches).toMatchObject([
         {
           baseBundleId: primaryBaseBundle.id,