@hot-updater/server 0.30.11 → 0.31.0

package/dist/schema/v0_31_0.mjs

@@ -0,0 +1,48 @@
+import { column, idColumn, schema, table } from "../node_modules/.pnpm/fumadb@0.2.2_drizzle-orm@0.44.7_@cloudflare_workers-types@4.20260313.1_@electric-sql_pg_c72c8c754becd21f6d6662e8fbd28e7f/node_modules/fumadb/dist/chunk-ZEQMAIFI.mjs";
+import "../node_modules/.pnpm/fumadb@0.2.2_drizzle-orm@0.44.7_@cloudflare_workers-types@4.20260313.1_@electric-sql_pg_c72c8c754becd21f6d6662e8fbd28e7f/node_modules/fumadb/dist/schema/index.mjs";
+//#region src/schema/v0_31_0.ts
+const v0_31_0 = schema({
+	version: "0.31.0",
+	tables: {
+		bundles: table("bundles", {
+			id: idColumn("id", "uuid"),
+			platform: column("platform", "string"),
+			should_force_update: column("should_force_update", "bool"),
+			enabled: column("enabled", "bool"),
+			file_hash: column("file_hash", "string"),
+			git_commit_hash: column("git_commit_hash", "string").nullable(),
+			message: column("message", "string").nullable(),
+			channel: column("channel", "string").defaultTo("production"),
+			storage_uri: column("storage_uri", "string"),
+			target_app_version: column("target_app_version", "string").nullable(),
+			fingerprint_hash: column("fingerprint_hash", "string").nullable(),
+			metadata: column("metadata", "json"),
+			manifest_storage_uri: column("manifest_storage_uri", "string").nullable(),
+			manifest_file_hash: column("manifest_file_hash", "string").nullable(),
+			asset_base_storage_uri: column("asset_base_storage_uri", "string").nullable(),
+			rollout_cohort_count: column("rollout_cohort_count", "integer").defaultTo(1e3),
+			target_cohorts: column("target_cohorts", "json").nullable()
+		}),
+		bundle_patches: table("bundle_patches", {
+			id: idColumn("id", "varchar(255)"),
+			bundle_id: column("bundle_id", "uuid"),
+			base_bundle_id: column("base_bundle_id", "uuid"),
+			base_file_hash: column("base_file_hash", "string"),
+			patch_file_hash: column("patch_file_hash", "string"),
+			patch_storage_uri: column("patch_storage_uri", "string"),
+			order_index: column("order_index", "integer").defaultTo(0)
+		})
+	},
+	relations: { bundle_patches: (builder) => ({
+		bundle: builder.one("bundles", ["bundle_id", "id"]).imply("patches").foreignKey({
+			name: "bundle_patches_bundle_id_fk",
+			onDelete: "CASCADE"
+		}),
+		baseBundle: builder.one("bundles", ["base_bundle_id", "id"]).imply("baseForPatches").foreignKey({
+			name: "bundle_patches_base_bundle_id_fk",
+			onDelete: "CASCADE"
+		})
+	}) }
+});
+//#endregion
+export { v0_31_0 };

package/dist/storageAccess.cjs

@@ -0,0 +1,44 @@
+//#region src/storageAccess.ts
+const assertRemoteDownloadUrl = (fileUrl) => {
+	try {
+		const protocol = new URL(fileUrl).protocol.replace(":", "");
+		if (protocol === "http" || protocol === "https") return fileUrl;
+	} catch {}
+	throw new Error("Storage plugin returned a local file path; runtime update checks require an HTTP(S) download URL.");
+};
+const getStorageProtocol = (storageUri) => new URL(storageUri).protocol.replace(":", "");
+const isRemoteUrlProtocol = (protocol) => protocol === "http" || protocol === "https";
+const createStorageAccess = (storagePlugins) => {
+	const findStoragePlugin = (protocol) => {
+		return storagePlugins.find((item) => item.supportedProtocol === protocol);
+	};
+	const resolveFileUrl = async (storageUri, context) => {
+		if (!storageUri) return null;
+		const protocol = getStorageProtocol(storageUri);
+		const plugin = findStoragePlugin(protocol);
+		if (plugin) {
+			const { fileUrl } = await plugin.profiles.runtime.getDownloadUrl(storageUri, context);
+			if (!fileUrl) throw new Error("Storage plugin returned empty fileUrl");
+			return assertRemoteDownloadUrl(fileUrl);
+		}
+		if (isRemoteUrlProtocol(protocol)) return storageUri;
+		throw new Error(`No storage plugin for protocol: ${protocol}`);
+	};
+	const readStorageText = async (storageUri, context) => {
+		const protocol = getStorageProtocol(storageUri);
+		const plugin = findStoragePlugin(protocol);
+		if (plugin) return plugin.profiles.runtime.readText(storageUri, context);
+		if (isRemoteUrlProtocol(protocol)) {
+			const response = await fetch(storageUri);
+			if (!response.ok) return null;
+			return response.text();
+		}
+		throw new Error(`No storage plugin for protocol: ${protocol}`);
+	};
+	return {
+		readStorageText,
+		resolveFileUrl
+	};
+};
+//#endregion
+exports.createStorageAccess = createStorageAccess;

package/dist/storageAccess.mjs

@@ -0,0 +1,44 @@
+//#region src/storageAccess.ts
+const assertRemoteDownloadUrl = (fileUrl) => {
+	try {
+		const protocol = new URL(fileUrl).protocol.replace(":", "");
+		if (protocol === "http" || protocol === "https") return fileUrl;
+	} catch {}
+	throw new Error("Storage plugin returned a local file path; runtime update checks require an HTTP(S) download URL.");
+};
+const getStorageProtocol = (storageUri) => new URL(storageUri).protocol.replace(":", "");
+const isRemoteUrlProtocol = (protocol) => protocol === "http" || protocol === "https";
+const createStorageAccess = (storagePlugins) => {
+	const findStoragePlugin = (protocol) => {
+		return storagePlugins.find((item) => item.supportedProtocol === protocol);
+	};
+	const resolveFileUrl = async (storageUri, context) => {
+		if (!storageUri) return null;
+		const protocol = getStorageProtocol(storageUri);
+		const plugin = findStoragePlugin(protocol);
+		if (plugin) {
+			const { fileUrl } = await plugin.profiles.runtime.getDownloadUrl(storageUri, context);
+			if (!fileUrl) throw new Error("Storage plugin returned empty fileUrl");
+			return assertRemoteDownloadUrl(fileUrl);
+		}
+		if (isRemoteUrlProtocol(protocol)) return storageUri;
+		throw new Error(`No storage plugin for protocol: ${protocol}`);
+	};
+	const readStorageText = async (storageUri, context) => {
+		const protocol = getStorageProtocol(storageUri);
+		const plugin = findStoragePlugin(protocol);
+		if (plugin) return plugin.profiles.runtime.readText(storageUri, context);
+		if (isRemoteUrlProtocol(protocol)) {
+			const response = await fetch(storageUri);
+			if (!response.ok) return null;
+			return response.text();
+		}
+		throw new Error(`No storage plugin for protocol: ${protocol}`);
+	};
+	return {
+		readStorageText,
+		resolveFileUrl
+	};
+};
+//#endregion
+export { createStorageAccess };

package/dist/version.cjs

@@ -1,4 +1,4 @@
 //#region src/version.ts
-const HOT_UPDATER_SERVER_VERSION = require("./package.cjs").version;
+const HOT_UPDATER_SERVER_VERSION = require("./packages/server/package.cjs").version;
 //#endregion
 exports.HOT_UPDATER_SERVER_VERSION = HOT_UPDATER_SERVER_VERSION;

package/dist/version.mjs

@@ -1,4 +1,4 @@
-import { version } from "./package.mjs";
+import { version } from "./packages/server/package.mjs";
 //#region src/version.ts
 const HOT_UPDATER_SERVER_VERSION = version;
 //#endregion

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hot-updater/server",
-  "version": "0.30.11",
+  "version": "0.31.0",
   "type": "module",
   "description": "React Native OTA solution for self-hosted",
   "sideEffects": false,
@@ -51,23 +51,31 @@
   },
   "dependencies": {
     "fumadb": "0.2.2",
+    "kysely": "0.28.16",
+    "mongodb": "6.20.0",
     "rou3": "0.7.9",
     "semver": "^7.7.2",
-    "@hot-updater/core": "0.30.11",
-    "@hot-updater/js": "0.30.11",
-    "@hot-updater/plugin-core": "0.30.11"
+    "@hot-updater/bsdiff": "0.31.0",
+    "@hot-updater/core": "0.31.0",
+    "@hot-updater/plugin-core": "0.31.0",
+    "@hot-updater/js": "0.31.0"
   },
   "devDependencies": {
     "@electric-sql/pglite": "0.2.17",
     "@types/node": "^20",
     "@types/semver": "^7.5.8",
     "execa": "9.5.2",
-    "kysely": "0.28.16",
     "kysely-pglite-dialect": "1.2.0",
     "msw": "^2.7.0",
     "uuidv7": "^1.0.2",
-    "@hot-updater/standalone": "0.30.11",
-    "@hot-updater/test-utils": "0.30.11"
+    "@hot-updater/standalone": "0.31.0",
+    "@hot-updater/test-utils": "0.31.0"
+  },
+  "inlinedDependencies": {
+    "@noble/hashes": "1.8.0",
+    "@paralleldrive/cuid2": "2.3.1",
+    "drizzle-orm": "0.44.7",
+    "fumadb": "0.2.2"
   },
   "scripts": {
     "build": "tsdown",

package/src/adapters/drizzle.ts

@@ -1 +1,15 @@
-export * from "fumadb/adapters/drizzle";
+import { drizzleAdapter as fumadbDrizzleAdapter } from "fumadb/adapters/drizzle";
+
+import type { ORMDatabaseAdapter } from "../db/types";
+
+export type DrizzleConfig = Parameters<typeof fumadbDrizzleAdapter>[0];
+
+export const drizzleAdapter = (config: DrizzleConfig): ORMDatabaseAdapter =>
+  Object.assign(
+    fumadbDrizzleAdapter(
+      config as unknown as Parameters<typeof fumadbDrizzleAdapter>[0],
+    ) as unknown as ORMDatabaseAdapter,
+    {
+      provider: config.provider,
+    },
+  );

package/src/adapters/kysely.ts

@@ -1 +1,24 @@
-export * from "fumadb/adapters/kysely";
+import { kyselyAdapter as fumadbKyselyAdapter } from "fumadb/adapters/kysely";
+
+import type { ORMDatabaseAdapter } from "../db/types";
+
+export type RelationMode = import("fumadb").RelationMode;
+export type SQLProvider = import("fumadb").SQLProvider;
+
+export interface KyselyConfig<TDatabase extends object = object> {
+  db: TDatabase;
+  provider: SQLProvider;
+  relationMode?: RelationMode;
+}
+
+export const kyselyAdapter = <TDatabase extends object>(
+  config: KyselyConfig<TDatabase>,
+): ORMDatabaseAdapter =>
+  Object.assign(
+    fumadbKyselyAdapter(
+      config as unknown as Parameters<typeof fumadbKyselyAdapter>[0],
+    ) as unknown as ORMDatabaseAdapter,
+    {
+      provider: config.provider,
+    },
+  );

package/src/adapters/mongodb.ts

@@ -1 +1,19 @@
-export * from "fumadb/adapters/mongodb";
+import { mongoAdapter as fumadbMongoAdapter } from "fumadb/adapters/mongodb";
+
+import type { ORMDatabaseAdapter } from "../db/types";
+
+export interface MongoDBConfig<TClient extends object = object> {
+  client: TClient;
+}
+
+export const mongoAdapter = <TClient extends object>(
+  options: MongoDBConfig<TClient>,
+): ORMDatabaseAdapter =>
+  Object.assign(
+    fumadbMongoAdapter(
+      options as unknown as Parameters<typeof fumadbMongoAdapter>[0],
+    ) as unknown as ORMDatabaseAdapter,
+    {
+      provider: "mongodb",
+    },
+  );

package/src/adapters/prisma.ts

@@ -1 +1,15 @@
-export * from "fumadb/adapters/prisma";
+import { prismaAdapter as fumadbPrismaAdapter } from "fumadb/adapters/prisma";
+
+import type { ORMDatabaseAdapter } from "../db/types";
+
+export type PrismaConfig = Parameters<typeof fumadbPrismaAdapter>[0];
+
+export const prismaAdapter = (config: PrismaConfig): ORMDatabaseAdapter =>
+  Object.assign(
+    fumadbPrismaAdapter(
+      config as unknown as Parameters<typeof fumadbPrismaAdapter>[0],
+    ) as unknown as ORMDatabaseAdapter,
+    {
+      provider: config.provider,
+    },
+  );

package/src/db/createBundleDiff.spec.ts

@@ -0,0 +1,402 @@
+import fs from "node:fs/promises";
+import { brotliCompressSync } from "node:zlib";
+
+import type {
+  Bundle,
+  DatabasePlugin,
+  NodeStoragePlugin,
+  NodeStorageProfile,
+} from "@hot-updater/plugin-core";
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+vi.mock("@hot-updater/bsdiff", () => ({
+  hdiff: vi.fn(async () => new Uint8Array([1, 2, 3, 4])),
+}));
+
+import { createBundleDiff } from "./createBundleDiff";
+
+const createBundle = (id: string, overrides: Partial<Bundle> = {}): Bundle => ({
+  channel: "production",
+  enabled: true,
+  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`,
+  metadata: {},
+  platform: "ios",
+  shouldForceUpdate: false,
+  storageUri: `s3://test-bucket/releases/${id}/bundle.zip`,
+  targetAppVersion: "1.0.0",
+  ...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 createStoragePlugin = (
+  upload: NodeStorageProfile["upload"],
+): NodeStoragePlugin => ({
+  name: "mockStorage",
+  supportedProtocol: "s3",
+  profiles: {
+    node: {
+      async delete() {},
+      async downloadFile(storageUri, filePath) {
+        const storageUrl = new URL(storageUri);
+        const response = await fetch(
+          `https://assets.example.com${storageUrl.pathname}`,
+        );
+        await fs.writeFile(
+          filePath,
+          new Uint8Array(await response.arrayBuffer()),
+        );
+      },
+      upload,
+    },
+  },
+});
+
+describe("createBundleDiff", () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  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()}`,
+      }),
+    );
+
+    vi.stubGlobal(
+      "fetch",
+      vi.fn(async (input: Request | URL | string) => {
+        const url = String(input);
+
+        if (url.endsWith(`${baseBundle.id}/manifest.json`)) {
+          return new Response(
+            JSON.stringify({
+              assets: {
+                "index.ios.bundle": {
+                  fileHash: "hash-old",
+                },
+              },
+              bundleId: baseBundle.id,
+            }),
+          );
+        }
+
+        if (url.endsWith(`${targetBundle.id}/manifest.json`)) {
+          return new Response(
+            JSON.stringify({
+              assets: {
+                "index.ios.bundle": {
+                  fileHash: "hash-new",
+                },
+              },
+              bundleId: targetBundle.id,
+            }),
+          );
+        }
+
+        if (url.endsWith(`${baseBundle.id}/files/index.ios.bundle.br`)) {
+          return new Response(brotliCompressSync(new Uint8Array([1, 2, 3])));
+        }
+
+        if (url.endsWith(`${baseBundle.id}/files/index.ios.bundle`)) {
+          return new Response(new Uint8Array([1, 2, 3]));
+        }
+
+        if (url.endsWith(`${targetBundle.id}/files/index.ios.bundle.br`)) {
+          return new Response(brotliCompressSync(new Uint8Array([1, 9, 3])));
+        }
+
+        if (url.endsWith(`${targetBundle.id}/files/index.ios.bundle`)) {
+          return new Response(new Uint8Array([1, 9, 3]));
+        }
+
+        return new Response("not found", { status: 404 });
+      }),
+    );
+
+    try {
+      const updatedBundle = await createBundleDiff(
+        {
+          baseBundleId: baseBundle.id,
+          bundleId: targetBundle.id,
+        },
+        {
+          databasePlugin: createDatabasePlugin(bundles),
+          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(
+        `${targetBundle.id}/patches/${baseBundle.id}`,
+      );
+      expect(updatedBundle.patches).toEqual([
+        {
+          baseBundleId: baseBundle.id,
+          baseFileHash: "hash-old",
+          patchFileHash: updatedBundle.patchFileHash,
+          patchStorageUri: updatedBundle.patchStorageUri,
+        },
+      ]);
+    } finally {
+      vi.unstubAllGlobals();
+    }
+  });
+
+  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 upload = vi.fn<NodeStorageProfile["upload"]>(
+      async (key, filePath) => ({
+        storageUri: `s3://test-bucket/${key}/${filePath.split("/").pop()}`,
+      }),
+    );
+
+    vi.stubGlobal(
+      "fetch",
+      vi.fn(async (input: Request | URL | string) => {
+        const url = String(input);
+
+        if (url.endsWith(`${baseBundle.id}/manifest.json`)) {
+          return new Response(
+            JSON.stringify({
+              assets: {
+                "index.ios.bundle": {
+                  fileHash: "hash-old",
+                },
+                "secondary.ios.bundle": {
+                  fileHash: "hash-secondary-old",
+                },
+              },
+              bundleId: baseBundle.id,
+            }),
+          );
+        }
+
+        if (url.endsWith(`${targetBundle.id}/manifest.json`)) {
+          return new Response(
+            JSON.stringify({
+              assets: {
+                "index.ios.bundle": {
+                  fileHash: "hash-new",
+                },
+                "secondary.ios.bundle": {
+                  fileHash: "hash-secondary-new",
+                },
+              },
+              bundleId: targetBundle.id,
+            }),
+          );
+        }
+
+        return new Response("not found", { status: 404 });
+      }),
+    );
+
+    try {
+      await expect(
+        createBundleDiff(
+          {
+            baseBundleId: baseBundle.id,
+            bundleId: targetBundle.id,
+          },
+          {
+            databasePlugin: createDatabasePlugin(bundles),
+            storagePlugin: createStoragePlugin(upload),
+          },
+        ),
+      ).rejects.toThrow("Expected exactly one Hermes bundle asset in manifest");
+      expect(upload).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",
+    );
+    const secondaryBaseBundle = createBundle(
+      "00000000-0000-0000-0000-000000000002",
+    );
+    const targetBundle = createBundle("00000000-0000-0000-0000-000000000003", {
+      patches: [
+        {
+          baseBundleId: primaryBaseBundle.id,
+          baseFileHash: "hash-primary-old",
+          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 upload = vi.fn<NodeStorageProfile["upload"]>(
+      async (key, filePath) => ({
+        storageUri: `s3://test-bucket/${key}/${filePath.split("/").pop()}`,
+      }),
+    );
+
+    vi.stubGlobal(
+      "fetch",
+      vi.fn(async (input: Request | URL | string) => {
+        const url = String(input);
+
+        if (url.endsWith(`${secondaryBaseBundle.id}/manifest.json`)) {
+          return new Response(
+            JSON.stringify({
+              assets: {
+                "index.ios.bundle": {
+                  fileHash: "hash-secondary-old",
+                },
+              },
+              bundleId: secondaryBaseBundle.id,
+            }),
+          );
+        }
+
+        if (url.endsWith(`${targetBundle.id}/manifest.json`)) {
+          return new Response(
+            JSON.stringify({
+              assets: {
+                "index.ios.bundle": {
+                  fileHash: "hash-target-new",
+                },
+              },
+              bundleId: targetBundle.id,
+            }),
+          );
+        }
+
+        if (
+          url.endsWith(`${secondaryBaseBundle.id}/files/index.ios.bundle.br`)
+        ) {
+          return new Response(brotliCompressSync(new Uint8Array([1, 2, 3])));
+        }
+
+        if (url.endsWith(`${secondaryBaseBundle.id}/files/index.ios.bundle`)) {
+          return new Response(new Uint8Array([1, 2, 3]));
+        }
+
+        if (url.endsWith(`${targetBundle.id}/files/index.ios.bundle.br`)) {
+          return new Response(brotliCompressSync(new Uint8Array([1, 4, 3])));
+        }
+
+        if (url.endsWith(`${targetBundle.id}/files/index.ios.bundle`)) {
+          return new Response(new Uint8Array([1, 4, 3]));
+        }
+
+        return new Response("not found", { status: 404 });
+      }),
+    );
+
+    try {
+      const updatedBundle = await createBundleDiff(
+        {
+          baseBundleId: secondaryBaseBundle.id,
+          bundleId: targetBundle.id,
+        },
+        {
+          databasePlugin: createDatabasePlugin(bundles),
+          storagePlugin: createStoragePlugin(upload),
+        },
+        {
+          makePrimary: false,
+        },
+      );
+
+      expect(updatedBundle.patchBaseBundleId).toBe(primaryBaseBundle.id);
+      expect(updatedBundle.patches).toMatchObject([
+        {
+          baseBundleId: primaryBaseBundle.id,
+          baseFileHash: "hash-primary-old",
+          patchFileHash: "hash-primary-patch",
+          patchStorageUri: `s3://test-bucket/${primaryBaseBundle.id}/existing.bsdiff`,
+        },
+        {
+          baseBundleId: secondaryBaseBundle.id,
+          baseFileHash: "hash-secondary-old",
+          patchFileHash: expect.any(String),
+          patchStorageUri: expect.stringContaining(
+            `${targetBundle.id}/patches/${secondaryBaseBundle.id}`,
+          ),
+        },
+      ]);
+    } finally {
+      vi.unstubAllGlobals();
+    }
+  });
+});