@hot-updater/server 1.0.0-rc.2 → 1.0.0-rc.21

package/src/db/bundleRows.spec.ts

@@ -1,164 +0,0 @@
-import type { Bundle } from "@hot-updater/core";
-import { describe, expect, it } from "vitest";
-
-import {
-  BundleRowHydrationError,
-  bundleToPatchRows,
-  bundleToRow,
-  rowsToBundles,
-  type BundlePatchRow,
-  type BundleRow,
-} from "./bundleRows";
-
-const createBundle = (id: string): Bundle => ({
-  id,
-  platform: "ios",
-  fileHash: `hash-${id}`,
-  gitCommitHash: null,
-  storageUri: `s3://bucket/${id}.zip`,
-  archiveByteSize: 3_000_000_001,
-});
-
-const toRow = (bundle: Bundle): BundleRow => bundleToRow(bundle);
-
-const createPatchRow = (
-  id: string,
-  bundleId: string,
-  baseBundleId: string,
-  orderIndex: number,
-): BundlePatchRow => ({
-  id,
-  bundle_id: bundleId,
-  base_bundle_id: baseBundleId,
-  base_file_hash: `base-hash-${id}`,
-  patch_file_hash: `patch-hash-${id}`,
-  patch_storage_uri: `s3://bucket/${id}.patch`,
-  byte_size: 3_000_000_002,
-  order_index: orderIndex,
-});
-
-describe("bundle row conversion", () => {
-  it("round-trips bundle fields without embedding patch artifacts in the bundle row", () => {
-    const baseBundle = createBundle("base");
-    const bundle: Bundle = {
-      ...createBundle("target"),
-      metadata: { app_version: "1.0.0" },
-      manifestStorageUri: "s3://bucket/manifest.json",
-      manifestFileHash: "manifest-hash",
-      assetBaseStorageUri: "s3://bucket/assets",
-      patches: [
-        {
-          baseBundleId: baseBundle.id,
-          baseFileHash: "base-hash",
-          byteSize: 3_000_000_002,
-          patchFileHash: "patch-hash",
-          patchStorageUri: "s3://bucket/target.patch",
-        },
-      ],
-    };
-
-    const row = toRow(bundle);
-    const patchRows = bundleToPatchRows(bundle);
-    const hydratedBundles = rowsToBundles([row], patchRows, [
-      toRow(baseBundle),
-    ]);
-
-    expect(row).not.toHaveProperty("patches");
-    expect(row).not.toHaveProperty("patch_file_hash");
-    expect(row).not.toHaveProperty("channel");
-    expect(row).not.toHaveProperty("enabled");
-    expect(hydratedBundles).toHaveLength(1);
-    expect(hydratedBundles[0]).toEqual(bundle);
-  });
-
-  it("orders multiple patches deterministically", () => {
-    const oldest = createBundle("oldest");
-    const newest = createBundle("newest");
-    const target = createBundle("target");
-    const rows: readonly BundleRow[] = [toRow(target)];
-    const later = createPatchRow("later", target.id, newest.id, 1);
-    const firstById = createPatchRow("a-first", target.id, oldest.id, 0);
-    const secondById = createPatchRow("z-second", target.id, newest.id, 0);
-
-    const [hydrated] = rowsToBundles(
-      rows,
-      [later, secondById, firstById],
-      [toRow(oldest), toRow(newest)],
-    );
-
-    expect(hydrated?.patches?.map((patch) => patch.patchFileHash)).toEqual([
-      firstById.patch_file_hash,
-      secondById.patch_file_hash,
-      later.patch_file_hash,
-    ]);
-  });
-
-  it("hydrates an empty patch set", () => {
-    const bundle = createBundle("without-patches");
-
-    const [hydrated] = rowsToBundles([toRow(bundle)], [], []);
-
-    expect(hydrated).toMatchObject({ patches: [] });
-  });
-
-  it("preserves nested metadata at the row boundary", () => {
-    const row: BundleRow = {
-      ...toRow(createBundle("nested-metadata")),
-      metadata: { release: { flags: [true, null, 3] } },
-    };
-
-    const [hydrated] = rowsToBundles([row], [], []);
-
-    expect(hydrated).toMatchObject({
-      metadata: { release: { flags: [true, null, 3] } },
-    });
-  });
-
-  it("rejects duplicate patch ids during aggregate hydration", () => {
-    const base = createBundle("base");
-    const target = createBundle("target");
-    const patch = createPatchRow("duplicate", target.id, base.id, 0);
-    const duplicate = { ...patch, base_file_hash: "different-hash" };
-
-    const hydrate = () =>
-      rowsToBundles([toRow(target)], [patch, duplicate], [toRow(base)]);
-
-    expect(hydrate).toThrowError(BundleRowHydrationError);
-    expect(hydrate).toThrowError(
-      expect.objectContaining({
-        reason: "duplicate_patch_id",
-        patchId: patch.id,
-      }),
-    );
-  });
-
-  it("rejects a patch whose owner bundle row is absent", () => {
-    const base = createBundle("base");
-    const patch = createPatchRow("orphan-owner", "missing", base.id, 0);
-
-    const hydrate = () => rowsToBundles([], [patch], [toRow(base)]);
-
-    expect(hydrate).toThrowError(
-      expect.objectContaining({
-        reason: "orphan_patch_owner",
-        patchId: patch.id,
-        bundleId: patch.bundle_id,
-      }),
-    );
-  });
-
-  it("rejects a patch whose base bundle row is absent", () => {
-    const target = createBundle("target");
-    const patch = createPatchRow("orphan-base", target.id, "missing", 0);
-
-    const hydrate = () => rowsToBundles([toRow(target)], [patch], []);
-
-    expect(hydrate).toThrowError(
-      expect.objectContaining({
-        reason: "orphan_patch_base",
-        patchId: patch.id,
-        bundleId: patch.base_bundle_id,
-      }),
-    );
-  });
-});

package/src/db/bundleRows.ts

@@ -1,10 +0,0 @@
-export {
-  BundleRowHydrationError,
-  BundleRowHydrationErrorReason,
-  bundleToPatchRows,
-  bundleToRow,
-  rowToBundle,
-  rowsToBundles,
-} from "@hot-updater/plugin-core";
-
-export type { BundlePatchRow, BundleRow } from "@hot-updater/plugin-core";

package/src/db/createBundleDiff.spec.ts

@@ -1,450 +0,0 @@
-import { brotliCompressSync } from "node:zlib";
-
-import type {
-  Bundle,
-  DatabasePlugin,
-  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])),
-}));
-
-import { createBundleDiff } from "./createBundleDiff";
-
-const createBundle = (id: string, overrides: Partial<Bundle> = {}): Bundle => ({
-  archiveByteSize: 1_024,
-  fileHash: `${id}-file-hash`,
-  gitCommitHash: null,
-  id,
-  assetBaseStorageUri: "s3://test-bucket/releases/assets",
-  manifestStorageUri: `s3://test-bucket/releases/bundles/${id}/manifest.json`,
-  metadata: {},
-  platform: "ios",
-  storageUri: `s3://test-bucket/releases/bundles/${id}/bundle.zip`,
-  ...overrides,
-});
-
-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 = (
-  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}`,
-        );
-        return { response: response.ok ? response : null };
-      }),
-    put,
-  });
-
-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");
-    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(
-      "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": {
-                  downloadByteSize: 7,
-                  downloadFileHash: baseDownloadFileHash,
-                  fileHash: "hash-old",
-                },
-              },
-              bundleId: baseBundle.id,
-            }),
-          );
-        }
-
-        if (url.endsWith(`${targetBundle.id}/manifest.json`)) {
-          return new Response(
-            JSON.stringify({
-              assets: {
-                "index.ios.bundle": {
-                  downloadByteSize: 7,
-                  downloadFileHash: targetDownloadFileHash,
-                  fileHash: "hash-new",
-                },
-              },
-              bundleId: targetBundle.id,
-            }),
-          );
-        }
-
-        if (url.endsWith(`/assets/sha256/aa/${baseDownloadFileHash}.br`)) {
-          return new Response(brotliCompressSync(new Uint8Array([1, 2, 3])));
-        }
-
-        if (url.endsWith("/assets/sha256/ha/hash-old.bundle")) {
-          return new Response(new Uint8Array([1, 2, 3]));
-        }
-
-        if (url.endsWith(`/assets/sha256/bb/${targetDownloadFileHash}.br`)) {
-          return new Response(brotliCompressSync(new Uint8Array([1, 9, 3])));
-        }
-
-        if (url.endsWith("/assets/sha256/ha/hash-new.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,
-          storagePlugin: createStoragePlugin(upload),
-        },
-      );
-
-      expect(upload).toHaveBeenCalledOnce();
-      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",
-          byteSize: 4,
-          patchFileHash: patch?.patchFileHash,
-          patchStorageUri: patch?.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 databasePlugin = await createDatabasePlugin([
-      baseBundle,
-      targetBundle,
-    ]);
-    const upload = vi.fn<NonNullable<StoragePlugin["put"]>>(
-      async ({ key }) => ({
-        storageUri: `s3://test-bucket/${key}`,
-      }),
-    );
-
-    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,
-            storagePlugin: createStoragePlugin(upload),
-          },
-        ),
-      ).rejects.toThrow("Expected exactly one Hermes bundle asset in manifest");
-      expect(upload).not.toHaveBeenCalled();
-    } finally {
-      vi.unstubAllGlobals();
-    }
-  });
-
-  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",
-    );
-    const secondaryBaseBundle = createBundle(
-      "00000000-0000-0000-0000-000000000002",
-    );
-    const targetBundle = createBundle("00000000-0000-0000-0000-000000000003", {
-      patches: [
-        {
-          baseBundleId: primaryBaseBundle.id,
-          baseFileHash: "hash-primary-old",
-          byteSize: 4,
-          patchFileHash: "hash-primary-patch",
-          patchStorageUri: `s3://test-bucket/${primaryBaseBundle.id}/existing.bsdiff`,
-        },
-      ],
-    });
-    const databasePlugin = await createDatabasePlugin([
-      primaryBaseBundle,
-      secondaryBaseBundle,
-      targetBundle,
-    ]);
-    const upload = vi.fn<NonNullable<StoragePlugin["put"]>>(
-      async ({ key }) => ({
-        storageUri: `s3://test-bucket/${key}`,
-      }),
-    );
-
-    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("/assets/sha256/ha/hash-secondary-old.br")) {
-          return new Response(brotliCompressSync(new Uint8Array([1, 2, 3])));
-        }
-
-        if (url.endsWith("/assets/sha256/ha/hash-secondary-old.bundle")) {
-          return new Response(new Uint8Array([1, 2, 3]));
-        }
-
-        if (url.endsWith("/assets/sha256/ha/hash-target-new.br")) {
-          return new Response(brotliCompressSync(new Uint8Array([1, 4, 3])));
-        }
-
-        if (url.endsWith("/assets/sha256/ha/hash-target-new.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,
-          storagePlugin: createStoragePlugin(upload),
-        },
-        {
-          makePrimary: false,
-        },
-      );
-
-      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(
-            `bundles/${targetBundle.id}/patches/${secondaryBaseBundle.id}`,
-          ),
-        },
-      ]);
-    } finally {
-      vi.unstubAllGlobals();
-    }
-  });
-});