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

package/src/handler.spec.ts

@@ -1,635 +1,190 @@
-import { type Bundle, NIL_UUID } from "@hot-updater/core";
+import type { ReleaseCatalog } from "@hot-updater/core";
+import { Hono } from "hono";
 import { describe, expect, it, vi } from "vitest";
 
-import { createHandler, type HandlerAPI, type HandlerRoutes } from "./handler";
+import {
+  createHandlers,
+  createHotUpdaterHandlers,
+  type HandlerAPI,
+} from "./handler";
+import { createApi } from "./handler.testFixtures";
+import { HOT_UPDATER_INFRASTRUCTURE_GENERATION } from "./handlerVersionRoutes";
 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;
-};
-
-type TestContext = {
-  env: TestEnv;
-};
-
-const testBundle: Bundle = {
-  id: "bundle-1",
-  platform: "ios",
-  shouldForceUpdate: false,
-  enabled: true,
-  fileHash: "hash123",
-  gitCommitHash: null,
-  message: "Test bundle",
-  channel: "production",
-  storageUri: "s3://test-bucket/bundles/bundle-1.zip",
-  targetAppVersion: "1.0.0",
-  fingerprintHash: null,
-};
-
-const createApi = () =>
-  ({
-    getAppUpdateInfo: vi
-      .fn<HandlerAPI<TestContext>["getAppUpdateInfo"]>()
-      .mockResolvedValue({
-        fileHash: null,
-        fileUrl: null,
-        id: NIL_UUID,
-        message: null,
-        shouldForceUpdate: true,
-        status: "ROLLBACK",
-      }),
-    getBundleById: vi.fn<HandlerAPI<TestContext>["getBundleById"]>(),
-    getBundles: vi.fn<HandlerAPI<TestContext>["getBundles"]>(),
-    getChannels: vi
-      .fn<HandlerAPI<TestContext>["getChannels"]>()
-      .mockResolvedValue(["production"]),
-    insertBundle: vi.fn<HandlerAPI<TestContext>["insertBundle"]>(),
-    updateBundleById: vi.fn<HandlerAPI<TestContext>["updateBundleById"]>(),
-    deleteBundleById: vi.fn<HandlerAPI<TestContext>["deleteBundleById"]>(),
-  }) satisfies HandlerAPI<TestContext>;
-
-const createManagementHandler = (
-  api: HandlerAPI<TestContext>,
-  routes: Partial<HandlerRoutes> = {},
-) =>
-  createHandler(api, {
-    basePath: "/hot-updater",
-    routes: {
-      updateCheck: true,
-      bundles: true,
-      ...routes,
-    },
-  });
-
-describe("createHandler", () => {
-  it("supports the app-version route without a cohort segment", async () => {
-    const api = createApi();
-    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",
-      ),
-      {
-        env: {
-          tenantId: "tenant-a",
-        },
-      },
-    );
-
-    expect(response.status).toBe(200);
-    expect(api.getAppUpdateInfo).toHaveBeenCalledWith(
-      {
-        _updateStrategy: "appVersion",
-        appVersion: "1.0.0",
-        bundleId: "default",
-        channel: "production",
-        cohort: undefined,
-        minBundleId: "default",
-        platform: "ios",
-      },
-      {
-        env: {
-          tenantId: "tenant-a",
-        },
-      },
-    );
-  });
-
-  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,
-          },
-        },
-      ),
-    );
+describe("createHandlers client routes", () => {
+  it("reports the v1 infrastructure generation", async () => {
+    const handler = createHandlers(createApi()).client;
+    const response = await handler(new Request("http://localhost/version"));
 
     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" });
-
-    const response = await handler(
-      new Request(
-        "http://localhost/hot-updater/fingerprint/android/fingerprint-123/production/default/default",
-      ),
-    );
-
-    expect(response.status).toBe(200);
-    expect(api.getAppUpdateInfo).toHaveBeenCalledWith(
-      {
-        _updateStrategy: "fingerprint",
-        bundleId: "default",
-        channel: "production",
-        cohort: undefined,
-        fingerprintHash: "fingerprint-123",
-        minBundleId: "default",
-        platform: "android",
-      },
-      undefined,
-    );
-  });
-
-  it("keeps version mounted when bundle routes are disabled", async () => {
-    const api = createApi();
-    const handler = createHandler(api, {
-      basePath: "/hot-updater",
-      routes: {
-        updateCheck: true,
-        bundles: false,
-      },
-    });
-
-    const versionResponse = await handler(
-      new Request("http://localhost/hot-updater/version"),
-    );
-    const bundlesResponse = await handler(
-      new Request("http://localhost/hot-updater/api/bundles"),
-    );
-    const updateResponse = await handler(
-      new Request(
-        "http://localhost/hot-updater/app-version/ios/1.0.0/production/default/default",
-      ),
-    );
-
-    expect(versionResponse.status).toBe(200);
-    await expect(versionResponse.json()).resolves.toEqual({
+      infrastructureGeneration: HOT_UPDATER_INFRASTRUCTURE_GENERATION,
       version: HOT_UPDATER_SERVER_VERSION,
     });
-    expect(bundlesResponse.status).toBe(404);
-    expect(updateResponse.status).toBe(200);
-  });
-
-  it("does not mount bundle routes by default", async () => {
-    const api = createApi();
-    const handler = createHandler(api, { basePath: "/hot-updater" });
-
-    const versionResponse = await handler(
-      new Request("http://localhost/hot-updater/version"),
-    );
-    const bundlesResponse = await handler(
-      new Request("http://localhost/hot-updater/api/bundles"),
-    );
-    const updateResponse = await handler(
-      new Request(
-        "http://localhost/hot-updater/app-version/ios/1.0.0/production/default/default",
-      ),
-    );
-
-    expect(versionResponse.status).toBe(200);
-    expect(bundlesResponse.status).toBe(404);
-    expect(updateResponse.status).toBe(200);
-  });
-
-  it("mounts bundle routes when explicitly enabled", async () => {
-    const api = createApi();
-    api.getBundles.mockResolvedValueOnce({
-      data: [],
-      pagination: {
-        total: 0,
-        hasNextPage: false,
-        hasPreviousPage: false,
-        currentPage: 1,
-        totalPages: 0,
-      },
-    });
-    const handler = createHandler(api, {
-      basePath: "/hot-updater",
-      routes: {
-        updateCheck: true,
-        bundles: true,
-      },
-    });
-
-    const response = await handler(
-      new Request("http://localhost/hot-updater/api/bundles"),
-    );
-
-    expect(response.status).toBe(200);
-    expect(api.getBundles).toHaveBeenCalledWith(
-      {
-        cursor: undefined,
-        limit: 50,
-        page: undefined,
-        where: {},
-      },
-      undefined,
-    );
-  });
-
-  it("keeps update-check routes mounted for partial runtime route config", async () => {
-    const api = createApi();
-    const handler = createHandler(api, {
-      basePath: "/hot-updater",
-      routes: JSON.parse('{"bundles":true}') as HandlerRoutes,
-    });
-
-    const updateResponse = await handler(
-      new Request(
-        "http://localhost/hot-updater/app-version/ios/1.0.0/production/default/default",
-      ),
-    );
-
-    expect(updateResponse.status).toBe(200);
   });
 
-  it("keeps the version route mounted when update-check routes are disabled", async () => {
-    const api = createApi();
-    const handler = createHandler(api, {
-      basePath: "/hot-updater",
-      routes: {
-        updateCheck: false,
-        bundles: false,
-      },
-    });
+  it.each([
+    "/app-version/ios/1.0.0/production/default/default",
+    "/fingerprint/android/fingerprint-123/production/default/default",
+  ])("does not expose the v0 route %s", async (path) => {
+    const handler = createHandlers(createApi()).client;
 
-    const versionResponse = await handler(
-      new Request("http://localhost/hot-updater/version"),
-    );
-    const bundlesResponse = await handler(
-      new Request("http://localhost/hot-updater/api/bundles"),
-    );
-    const updateResponse = await handler(
-      new Request(
-        "http://localhost/hot-updater/app-version/ios/1.0.0/production/default/default",
-      ),
-    );
+    const response = await handler(new Request(`http://localhost${path}`));
 
-    expect(versionResponse.status).toBe(200);
-    await expect(versionResponse.json()).resolves.toEqual({
-      version: HOT_UPDATER_SERVER_VERSION,
-    });
-    expect(bundlesResponse.status).toBe(404);
-    expect(updateResponse.status).toBe(404);
+    expect(response.status).toBe(404);
   });
 
-  it("can mount bundle routes without update-check routes", async () => {
-    const api = createApi();
-    const handler = createManagementHandler(api, { updateCheck: false });
+  it.each([
+    "/v2/release-catalogs/app-version/ios/cHJvZHVjdGlvbg/1.0.0",
+    "/v2/artifacts/target-bundle/from/current-bundle",
+  ])("does not expose the version-prefixed route %s", async (path) => {
+    const handler = createHandlers(createApi()).client;
 
-    const versionResponse = await handler(
-      new Request("http://localhost/hot-updater/version"),
-    );
-    const channelsResponse = await handler(
-      new Request("http://localhost/hot-updater/api/bundles/channels"),
-    );
-    const updateResponse = await handler(
-      new Request(
-        "http://localhost/hot-updater/app-version/ios/1.0.0/production/default/default",
-      ),
-    );
+    const response = await handler(new Request(`http://localhost${path}`));
 
-    expect(versionResponse.status).toBe(200);
-    await expect(versionResponse.json()).resolves.toEqual({
-      version: HOT_UPDATER_SERVER_VERSION,
-    });
-    expect(channelsResponse.status).toBe(200);
-    await expect(channelsResponse.json()).resolves.toEqual({
-      data: {
-        channels: ["production"],
-      },
-    });
-    expect(api.getChannels).toHaveBeenCalledWith(undefined);
-    expect(updateResponse.status).toBe(404);
+    expect(response.status).toBe(404);
   });
 
-  it("returns paginated bundle results in the response body", async () => {
-    const api = createApi();
-    api.getBundles.mockResolvedValue({
-      data: [testBundle],
-      pagination: {
-        total: 51,
-        hasNextPage: true,
-        hasPreviousPage: true,
-        currentPage: 6,
-        totalPages: 26,
-      },
-    });
-    const handler = createManagementHandler(api);
+  it("does not match the admin mount namespace", async () => {
+    const handler = createHandlers(createApi()).client;
 
     const response = await handler(
-      new Request(
-        "http://localhost/hot-updater/api/bundles?channel=production&platform=ios&limit=2",
-      ),
+      new Request("http://localhost/admin/channels"),
     );
 
-    expect(response.status).toBe(200);
-    expect(response.headers.get("X-Total-Count")).toBeNull();
-    await expect(response.json()).resolves.toEqual({
-      data: [testBundle],
-      pagination: {
-        total: 51,
-        hasNextPage: true,
-        hasPreviousPage: true,
-        currentPage: 6,
-        totalPages: 26,
-      },
-    });
-    expect(api.getBundles).toHaveBeenCalledWith(
-      {
-        where: {
-          channel: "production",
-          platform: "ios",
-        },
-        limit: 2,
-        page: undefined,
-      },
-      undefined,
-    );
+    expect(response.status).toBe(404);
   });
 
-  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 = createManagementHandler(api);
+  it("returns the stored Catalog identity without accepting identity parameters", async () => {
+    const catalog = {
+      catalogId: "project-a",
+      catalogHash: "sha256:catalog",
+      fallbackPolicy: "BUILTIN_IF_ACTIVE_INELIGIBLE",
+      generation: 1,
+      releases: [],
+      schemaVersion: 1,
+      scopeKey: "v1:fingerprint:android:cHJvZHVjdGlvbg:fingerprint-123",
+    } satisfies ReleaseCatalog;
+    const getReleaseCatalog = vi
+      .fn<NonNullable<HandlerAPI["getReleaseCatalog"]>>()
+      .mockResolvedValue(catalog);
+    const handler = createHandlers({
+      ...createApi(),
+      getReleaseCatalog,
+    }).client;
+    const url =
+      "http://localhost/release-catalogs/fingerprint/android/" +
+      "cHJvZHVjdGlvbg/fingerprint-123";
 
-    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",
-      ),
-    );
+    const response = await handler(new Request(url));
 
     expect(response.status).toBe(200);
-    expect(api.getBundles).toHaveBeenCalledWith(
-      {
-        where: {
-          channel: "production",
-          platform: "ios",
-          enabled: true,
-          id: {
-            lt: "bundle-9",
+    await expect(response.json()).resolves.toMatchObject({
+      catalogId: "project-a",
+    });
+    expect(getReleaseCatalog).toHaveBeenCalledWith({
+      channelKey: "cHJvZHVjdGlvbg",
+      fingerprintHash: "fingerprint-123",
+      platform: "android",
+      strategy: "FINGERPRINT",
+    });
+
+    const legacyAuthorityPath = await handler(
+      new Request(url.replace("/android/", "/project-a/android/")),
+    );
+    expect(legacyAuthorityPath.status).toBe(404);
+    expect(getReleaseCatalog).toHaveBeenCalledOnce();
+  });
+
+  it("serves client-relative storage paths under a framework mount", async () => {
+    const api = {
+      ...createApi(),
+      getArtifactInfo: vi.fn().mockResolvedValue({
+        changedAssets: {
+          "index.bundle": {
+            file: {
+              url: "/storage/asset-token/asset-signature",
+            },
+            fileHash: "asset-hash",
+            patch: {
+              algorithm: "bsdiff",
+              baseBundleId: "bundle-1",
+              baseFileHash: "base-hash",
+              patchFileHash: "patch-hash",
+              patchUrl: "/storage/patch-token/patch-signature",
+            },
           },
-          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({
-      data: [testBundle],
-      pagination: {
-        total: 51,
-        hasNextPage: true,
-        hasPreviousPage: true,
-        currentPage: 2,
-        totalPages: 26,
-        nextCursor: "bundle-1",
-        previousCursor: "bundle-9",
-      },
-    });
-    const handler = createManagementHandler(api);
-
-    const response = await handler(
-      new Request(
-        "http://localhost/hot-updater/api/bundles?channel=production&limit=20&after=bundle-20",
-      ),
-    );
-
-    expect(response.status).toBe(200);
-    expect(api.getBundles).toHaveBeenCalledWith(
-      {
-        where: {
-          channel: "production",
         },
-        limit: 20,
-        page: undefined,
-        cursor: {
-          after: "bundle-20",
-          before: undefined,
-        },
-      },
+        fileHash: "archive-hash",
+        fileUrl: "/storage/archive-token/archive-signature",
+        manifestFileHash: "manifest-hash",
+        manifestUrl: "/storage/manifest-token/manifest-signature",
+      }),
+    };
+    const handlers = createHotUpdaterHandlers(
+      api,
       undefined,
-    );
-  });
-
-  it("supports cursor pagination without a legacy offset query param", async () => {
-    const api = createApi();
-    api.getBundles.mockResolvedValue({
-      data: [testBundle],
-      pagination: {
-        total: 1,
-        hasNextPage: false,
-        hasPreviousPage: false,
-        currentPage: 1,
-        totalPages: 1,
-        nextCursor: null,
-        previousCursor: null,
-      },
-    });
-    const handler = createManagementHandler(api);
-
-    const response = await handler(
-      new Request(
-        "http://localhost/hot-updater/api/bundles?channel=production&limit=20&after=bundle-20",
-      ),
-    );
-
-    expect(response.status).toBe(200);
-    expect(api.getBundles).toHaveBeenCalledWith(
-      {
-        where: {
-          channel: "production",
-        },
-        limit: 20,
-        page: undefined,
-        cursor: {
-          after: "bundle-20",
-          before: undefined,
-        },
-      },
       undefined,
+      async () => new Response("bundle archive"),
     );
-  });
+    const app = new Hono();
+    app.mount("/hot-updater", handlers.client);
 
-  it("returns 400 when bundle list requests still send offset pagination", async () => {
-    const api = createApi();
-    const handler = createManagementHandler(api);
-
-    const response = await handler(
-      new Request(
-        "http://localhost/hot-updater/api/bundles?limit=20&offset=40",
-      ),
-    );
-
-    expect(response.status).toBe(400);
-    await expect(response.json()).resolves.toEqual({
-      error:
-        "The 'offset' query parameter has been removed. Use 'after' or 'before' cursor pagination instead.",
-    });
-    expect(api.getBundles).not.toHaveBeenCalled();
-  });
-
-  it("passes page-aligned pagination params through to getBundles", async () => {
-    const api = createApi();
-    api.getBundles.mockResolvedValue({
-      data: [testBundle],
-      pagination: {
-        total: 121,
-        hasNextPage: true,
-        hasPreviousPage: true,
-        currentPage: 2,
-        totalPages: 7,
-        nextCursor: "bundle-1",
-        previousCursor: "bundle-9",
-      },
-    });
-    const handler = createManagementHandler(api);
-
-    const response = await handler(
-      new Request(
-        "http://localhost/hot-updater/api/bundles?channel=production&limit=20&page=2&after=bundle-20",
-      ),
+    const response = await app.request(
+      "/hot-updater/artifacts/bundle-2/from/bundle-1",
     );
 
     expect(response.status).toBe(200);
-    expect(api.getBundles).toHaveBeenCalledWith(
-      {
-        where: {
-          channel: "production",
-        },
-        limit: 20,
-        page: 2,
-        cursor: {
-          after: "bundle-20",
-          before: undefined,
+    const info = (await response.json()) as {
+      changedAssets: Record<
+        string,
+        { file: { url: string }; patch: { patchUrl: string } }
+      >;
+      fileUrl: string;
+      manifestUrl: string;
+    };
+    expect(info).toMatchObject({
+      changedAssets: {
+        "index.bundle": {
+          file: { url: "/storage/asset-token/asset-signature" },
+          patch: { patchUrl: "/storage/patch-token/patch-signature" },
         },
       },
-      undefined,
-    );
-  });
-
-  it("returns 400 when bundle list requests send an invalid page", async () => {
-    const api = createApi();
-    const handler = createManagementHandler(api);
-
-    const response = await handler(
-      new Request("http://localhost/hot-updater/api/bundles?limit=20&page=0"),
-    );
-
-    expect(response.status).toBe(400);
-    await expect(response.json()).resolves.toEqual({
-      error: "The 'page' query parameter must be a positive integer.",
+      fileUrl: "/storage/archive-token/archive-signature",
+      manifestUrl: "/storage/manifest-token/manifest-signature",
     });
-    expect(api.getBundles).not.toHaveBeenCalled();
-  });
-
-  it("returns 400 when bundle list limit exceeds the maximum", async () => {
-    const api = createApi();
-    const handler = createManagementHandler(api);
 
-    const response = await handler(
-      new Request("http://localhost/hot-updater/api/bundles?limit=101"),
-    );
-
-    expect(response.status).toBe(400);
-    await expect(response.json()).resolves.toEqual({
-      error:
-        "The 'limit' query parameter must be a positive integer between 1 and 100.",
-    });
-    expect(api.getBundles).not.toHaveBeenCalled();
+    const download = await app.request(`/hot-updater${info.fileUrl}`);
+    expect(download.status).toBe(200);
+    await expect(download.text()).resolves.toBe("bundle archive");
   });
 
-  it("returns 400 when the platform route parameter is invalid", async () => {
-    const api = createApi();
-    const handler = createHandler(api, { basePath: "/hot-updater" });
+  it("does not expose provider errors from the public client handler", async () => {
+    const api = {
+      ...createApi(),
+      getReleaseCatalog: vi
+        .fn()
+        .mockRejectedValue(new Error("private database connection details")),
+    };
+    const consoleError = vi
+      .spyOn(console, "error")
+      .mockImplementation(() => {});
+    const handler = createHandlers(api).client;
 
     const response = await handler(
       new Request(
-        "http://localhost/hot-updater/app-version/web/1.0.0/production/default/default",
+        "http://localhost/release-catalogs/app-version/ios/cHJvZHVjdGlvbg/1.0.0",
       ),
     );
 
+    expect(response.status).toBe(500);
     await expect(response.json()).resolves.toEqual({
-      error: "Invalid platform: web. Expected 'ios' or 'android'.",
+      error: "Internal server error",
     });
-    expect(response.status).toBe(400);
-    expect(api.getAppUpdateInfo).not.toHaveBeenCalled();
+    expect(consoleError).toHaveBeenCalledWith(
+      "Hot Updater handler error:",
+      expect.any(Error),
+    );
+    consoleError.mockRestore();
   });
 });