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

package/src/handler-standalone.integration.spec.ts

@@ -1,7 +1,15 @@
 import { PGlite } from "@electric-sql/pglite";
 import type { Bundle } from "@hot-updater/core";
-import { NIL_UUID } from "@hot-updater/core";
-import { createBlobDatabasePlugin } from "@hot-updater/plugin-core";
+import {
+  createReleaseCatalogScopeKey,
+  encodeChannelKey,
+  NIL_UUID,
+} from "@hot-updater/core";
+import {
+  bundleToRow,
+  commitReleaseCatalogMutation,
+  createDatabaseClient,
+} from "@hot-updater/plugin-core";
 import { Kysely } from "kysely";
 import { PGliteDialect } from "kysely-pglite-dialect";
 import { HttpResponse, http } from "msw";
@@ -10,90 +18,60 @@ import { uuidv7 } from "uuidv7";
 import { afterAll, afterEach, beforeAll, describe, expect, it } from "vitest";
 
 import { standaloneRepository } from "../../../plugins/standalone/src";
+import { createInMemoryDatabasePlugin } from "../../test-utils/test/inMemoryDatabasePlugin";
 import { kyselyAdapter } from "./adapters/kysely";
 import { createMigrator } from "./db";
-import { createHotUpdater } from "./index";
-
-/**
- * Integration tests between @hot-updater/server handler and @hot-updater/standalone repository
- *
- * This test suite verifies real-world compatibility by:
- * 1. Using actual standaloneRepository (not mocks)
- * 2. Using actual handler (not mocks)
- * 3. Simulating HTTP communication via MSW
- * 4. Testing end-to-end flows: standalone → HTTP → handler → database
- */
-
-// Create in-memory database for testing
+import { createHotUpdater, type RuntimeHotUpdaterAPI } from "./index";
+
 const db = new PGlite();
 const kysely = new Kysely<object>({ dialect: new PGliteDialect(db) });
-
-// Create handler API with in-memory DB
+const clientMountPath = "/hot-updater";
 const api = createHotUpdater({
-  database: kyselyAdapter({
-    db: kysely,
-    provider: "postgresql",
-  }),
-  basePath: "/hot-updater",
-  routes: {
-    updateCheck: true,
-    bundles: true,
-  },
+  database: kyselyAdapter({ db: kysely, provider: "postgresql" }),
+  clientAccess: { type: "public" },
 });
-
-// Setup MSW server to intercept HTTP requests
 const baseUrl = "http://localhost:3000";
 const server = setupServer();
+const invokeHandler = async (
+  hotUpdater: RuntimeHotUpdaterAPI,
+  request: Request,
+  clientPath: string,
+) => {
+  const url = new URL(request.url);
+  const adminBasePath = `${clientPath}/admin`;
+  const isAdmin = url.pathname.startsWith(`${adminBasePath}/`);
+  const mountPath = isAdmin ? adminBasePath : clientPath;
+  url.pathname = url.pathname.slice(mountPath.length) || "/";
+  const handler = isAdmin
+    ? hotUpdater.handlers.admin
+    : hotUpdater.handlers.client;
+  const response = await handler(new Request(url, request));
+  return new HttpResponse(await response.text(), {
+    status: response.status,
+    headers: response.headers,
+  });
+};
 
 beforeAll(async () => {
-  // Initialize database
-  const migrator = createMigrator(api);
-  const result = await migrator.migrateToLatest({
+  const result = await createMigrator(api).migrateToLatest({
     mode: "from-schema",
     updateSettings: true,
   });
   await result.execute();
-
-  // Start MSW server
   server.listen({ onUnhandledRequest: "error" });
-
-  // Route all requests to our handler
-  const handleRequest = async (request: Request) => {
-    const response = await api.handler(request);
-    const data = (await response.json()) as Record<string, unknown>;
-    return HttpResponse.json(data, {
-      status: response.status,
-      headers: response.headers,
-    });
-  };
-
   server.use(
-    // Specific routes
-    http.get(`${baseUrl}/hot-updater/api/bundles`, ({ request }) =>
-      handleRequest(request),
-    ),
-    http.get(`${baseUrl}/hot-updater/api/bundles/channels`, ({ request }) =>
-      handleRequest(request),
-    ),
-    http.get(`${baseUrl}/hot-updater/api/bundles/:id`, ({ request }) =>
-      handleRequest(request),
-    ),
-    http.post(`${baseUrl}/hot-updater/api/bundles`, ({ request }) =>
-      handleRequest(request),
-    ),
-    http.patch(`${baseUrl}/hot-updater/api/bundles/:id`, ({ request }) =>
-      handleRequest(request),
-    ),
-    http.delete(`${baseUrl}/hot-updater/api/bundles/:id`, ({ request }) =>
-      handleRequest(request),
+    http.all(`${baseUrl}/hot-updater/*`, ({ request }) =>
+      invokeHandler(api, request, clientMountPath),
     ),
   );
 });
 
 afterEach(async () => {
-  // Clean up database after each test
   await db.exec("DELETE FROM bundle_patches");
+  await db.exec("DELETE FROM release_catalogs");
+  await db.exec("DELETE FROM releases");
   await db.exec("DELETE FROM bundles");
+  await db.exec("DELETE FROM channels");
 });
 
 afterAll(async () => {
@@ -105,389 +83,448 @@ afterAll(async () => {
 const createTestBundle = (overrides?: Partial<Bundle>): Bundle => ({
   id: NIL_UUID,
   platform: "ios",
-  channel: "production",
-  enabled: true,
-  shouldForceUpdate: false,
   fileHash: "test-hash",
   gitCommitHash: null,
-  message: null,
-  targetAppVersion: "*",
   storageUri: "test://storage",
-  fingerprintHash: null,
+  archiveByteSize: 3_000_000_001,
   ...overrides,
 });
 
-const createInMemoryBlobDatabase = (store: Record<string, string>) =>
-  createBlobDatabasePlugin({
-    name: "blob-test",
-    factory: () => ({
-      apiBasePath: "/api/check-update",
-      listObjects: async (prefix: string) =>
-        Object.keys(store).filter((key) => key.startsWith(prefix)),
-      loadObject: async <T>(key: string) => {
-        const value = store[key];
-        return value ? (JSON.parse(value) as T) : null;
-      },
-      uploadObject: async <T>(key: string, data: T) => {
-        store[key] = JSON.stringify(data);
+const createStandaloneClient = (base = `${baseUrl}/hot-updater/admin`) =>
+  createDatabaseClient(standaloneRepository({ baseUrl: base }));
+
+const commitTestRelease = async (
+  bundle: Bundle,
+  channelName = "production",
+) => {
+  const repository = standaloneRepository({
+    baseUrl: `${baseUrl}/hot-updater/admin`,
+  });
+  const channel = await repository.models.channels.insert({
+    onConflict: "returnExisting",
+    row: { id: uuidv7(), name: channelName },
+  });
+  const scopeKey = createReleaseCatalogScopeKey({
+    channelKey: encodeChannelKey(channelName),
+    platform: bundle.platform,
+    strategy: "APP_VERSION",
+  });
+  const releaseId = uuidv7();
+  const committed = await commitReleaseCatalogMutation({
+    companionChanges: [
+      {
+        model: "bundles",
+        operation: "insert",
+        row: bundleToRow(bundle),
       },
-      deleteObject: async (key: string) => {
-        delete store[key];
+    ],
+    database: repository,
+    mutation: {
+      operation: "insert",
+      row: {
+        bundle_id: bundle.id,
+        channel_id: channel.row.id,
+        created_at_ms: 1,
+        enabled: true,
+        fingerprint_hash: null,
+        id: releaseId,
+        kind: "BUNDLE",
+        message: null,
+        operation: "DEPLOY",
+        platform: bundle.platform,
+        revision: 1,
+        rollout_cohort_count: 1_000,
+        scope_key: scopeKey,
+        should_force_update: false,
+        source_release_id: null,
+        strategy: "APP_VERSION",
+        target_app_version: "*",
+        target_cohorts: [],
+        updated_at_ms: 1,
       },
-      invalidatePaths: async () => {},
-    }),
-  })({});
+    },
+    scope: {
+      channelId: channel.row.id,
+      channelName,
+      fingerprintHash: null,
+      platform: bundle.platform,
+      scopeKey,
+      strategy: "APP_VERSION",
+    },
+  });
+  return { channel: channel.row, committed, releaseId, repository, scopeKey };
+};
 
 describe("Handler <-> Standalone Repository Integration", () => {
-  it("Real integration: appendBundle + commitBundle → handler POST /bundles", async () => {
-    // Create standalone repository pointing to our test server
-    const repo = standaloneRepository({
-      baseUrl: `${baseUrl}/hot-updater`,
-    })();
-
+  it("uses Standalone for bundle management and the server database for Analytics", async () => {
     const bundleId = uuidv7();
-    const bundle = createTestBundle({
-      id: bundleId,
-      fileHash: "integration-hash-1",
+    const installId = "standalone-install";
+    await createStandaloneClient().insertBundle(
+      createTestBundle({ id: bundleId }),
+    );
+
+    const ingestion = await api.handlers.client(
+      new Request(`${baseUrl}/events`, {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+        },
+        body: JSON.stringify({
+          appVersion: "1.0.0",
+          channel: "production",
+          cohort: "default",
+          fingerprintHash: null,
+          fromBundleId: NIL_UUID,
+          fromReleaseId: null,
+          installId,
+          platform: "ios",
+          sdkVersion: "2.0.0",
+          toBundleId: bundleId,
+          toReleaseId: null,
+          type: "UPDATE_APPLIED",
+          updateStrategy: "appVersion",
+        }),
+      }),
+    );
+    const overview = await api.handlers.admin(
+      new Request(`${baseUrl}/installations/overview`),
+    );
+
+    expect(ingestion.status).toBe(204);
+    expect(overview.status).toBe(200);
+    await expect(overview.json()).resolves.toEqual({
+      bundles: [{ bundleId, installations: 1 }],
+      trackedInstallations: 1,
     });
+  });
 
-    // Standalone repository operations
-    await repo.appendBundle(bundle);
-    await repo.commitBundle(); // Triggers actual commit
+  it("atomically commits and reads Release catalogs through standalone management routes", async () => {
+    const bundle = createTestBundle({ id: uuidv7() });
+    const { committed, releaseId, repository, scopeKey } =
+      await commitTestRelease(bundle);
 
-    // Verify via handler that bundle was created
-    const request = new Request(
-      `${baseUrl}/hot-updater/api/bundles/${bundleId}`,
-      {
-        method: "GET",
-      },
+    await expect(
+      repository.models.releases.findById(releaseId),
+    ).resolves.toMatchObject({
+      bundle_id: bundle.id,
+      revision: 1,
+    });
+    await expect(
+      repository.models.releaseCatalogs.findByScopeKey(scopeKey),
+    ).resolves.toMatchObject({ generation: committed.catalog.generation });
+    const response = await api.handlers.client(
+      new Request(
+        `${baseUrl}/release-catalogs/app-version/ios/${encodeChannelKey("production")}/1.0.0`,
+      ),
     );
-
-    const response = await api.handler(request);
     expect(response.status).toBe(200);
-
-    const retrieved = (await response.json()) as Bundle;
-    expect(retrieved.id).toBe(bundleId);
-    expect(retrieved.fileHash).toBe("integration-hash-1");
+    await expect(response.json()).resolves.toMatchObject({
+      releases: [{ bundleId: bundle.id, releaseId }],
+    });
   });
 
-  it("Real integration: getBundleById → handler GET /bundles/:id", async () => {
-    // First, create a bundle directly via handler
-    const bundleId = uuidv7();
-    const bundle = createTestBundle({
-      id: bundleId,
-      fileHash: "get-hash-1",
+  it("keeps Standalone management routes separate from API key protection", async () => {
+    const protectedApi = createHotUpdater({
+      database: createInMemoryDatabasePlugin(),
+      clientAccess: { type: "api-key" },
     });
+    server.use(
+      http.all(`${baseUrl}/protected-hot-updater/*`, async ({ request }) => {
+        return invokeHandler(protectedApi, request, "/protected-hot-updater");
+      }),
+    );
+    const bundleId = uuidv7();
+    const client = createStandaloneClient(
+      `${baseUrl}/protected-hot-updater/admin`,
+    );
 
-    await api.insertBundle(bundle);
-
-    // Create standalone repository
-    const repo = standaloneRepository({
-      baseUrl: `${baseUrl}/hot-updater`,
-    })();
-
-    // Use standalone repository to retrieve
-    const retrieved = await repo.getBundleById(bundleId);
+    await client.insertBundle(createTestBundle({ id: bundleId }));
+    const updateCheck = await protectedApi.handlers.client(
+      new Request(
+        `${baseUrl}/release-catalogs/app-version/ios/${encodeChannelKey("production")}/1.0.0`,
+      ),
+    );
 
-    expect(retrieved).toBeTruthy();
-    expect(retrieved?.id).toBe(bundleId);
-    expect(retrieved?.fileHash).toBe("get-hash-1");
+    await expect(client.getBundleById(bundleId)).resolves.toMatchObject({
+      id: bundleId,
+    });
+    expect(updateCheck.status).toBe(401);
   });
 
-  it("Real integration: deleteBundle + commitBundle → handler DELETE /bundles/:id", async () => {
-    // Create a bundle via handler
+  it("creates a bundle through handler POST /bundles", async () => {
     const bundleId = uuidv7();
-    const bundle = createTestBundle({
+    const response = await api.handlers.admin(
+      new Request(`${baseUrl}/bundles`, {
+        body: JSON.stringify(
+          createTestBundle({
+            id: bundleId,
+            fileHash: "integration-hash-1",
+          }),
+        ),
+        headers: { "Content-Type": "application/json" },
+        method: "POST",
+      }),
+    );
+
+    const retrieved = await api.handlers.admin(
+      new Request(`${baseUrl}/bundles/${bundleId}`),
+    );
+    expect(response.status).toBe(201);
+    expect(retrieved.status).toBe(200);
+    await expect(retrieved.json()).resolves.toMatchObject({
       id: bundleId,
-      fileHash: "delete-hash-1",
+      fileHash: "integration-hash-1",
     });
+    await expect(api.getReleases({ bundleId, limit: 10 })).resolves.toEqual([]);
+  });
 
-    await api.insertBundle(bundle);
-
-    // Verify it exists
-    const beforeDelete = await api.getBundleById(bundleId);
-    expect(beforeDelete).toBeTruthy();
-
-    // Create standalone repository
-    const repo = standaloneRepository({
-      baseUrl: `${baseUrl}/hot-updater`,
-    })();
+  it("retrieves a bundle through handler GET /bundles/:id", async () => {
+    const bundleId = uuidv7();
+    await api.insertBundle(
+      createTestBundle({ id: bundleId, fileHash: "get-hash-1" }),
+    );
 
-    // Delete via standalone repository
-    await repo.deleteBundle(bundle);
-    await repo.commitBundle();
+    const retrieved = await createStandaloneClient().getBundleById(bundleId);
 
-    // Verify it was deleted
-    const afterDelete = await api.getBundleById(bundleId);
-    expect(afterDelete).toBeNull();
+    expect(retrieved).toMatchObject({ id: bundleId, fileHash: "get-hash-1" });
   });
 
-  it("Real integration: getBundles → handler GET /bundles", async () => {
-    // Create multiple bundles
-    await api.insertBundle(
-      createTestBundle({ id: uuidv7(), channel: "production" }),
-    );
-    await api.insertBundle(
-      createTestBundle({ id: uuidv7(), channel: "production" }),
-    );
-    await api.insertBundle(
-      createTestBundle({ id: uuidv7(), channel: "staging" }),
-    );
+  it("refuses to delete an artifact referenced by a Release", async () => {
+    const bundleId = uuidv7();
+    const bundle = createTestBundle({ id: bundleId });
+    await commitTestRelease(bundle);
+    const client = createStandaloneClient();
 
-    // Create standalone repository
-    const repo = standaloneRepository({
-      baseUrl: `${baseUrl}/hot-updater`,
-    })();
+    await expect(client.deleteBundleById(bundleId)).rejects.toThrow(
+      "still referenced",
+    );
 
-    // Get all bundles
-    const result = await repo.getBundles({ limit: 50 });
+    await expect(api.getBundleById(bundleId)).resolves.toMatchObject({
+      id: bundleId,
+    });
+  });
 
-    expect(result.data).toHaveLength(3);
-    expect(result.pagination.total).toBe(3);
+  it("lists and filters artifacts through handler GET /bundles", async () => {
+    await api.insertBundle(createTestBundle({ id: uuidv7() }));
+    await api.insertBundle(createTestBundle({ id: uuidv7() }));
+    await api.insertBundle(createTestBundle({ id: uuidv7() }));
+    const client = createStandaloneClient();
 
-    // Filter by channel
-    const prodResult = await repo.getBundles({
-      where: { channel: "production" },
+    const all = await client.getBundles({ limit: 50 });
+    const ios = await client.getBundles({
+      where: { platform: "ios" },
       limit: 50,
     });
 
-    expect(prodResult.data).toHaveLength(2);
+    expect(all.data).toHaveLength(3);
+    expect(all.pagination.total).toBe(3);
+    expect(ios.data).toHaveLength(3);
   });
 
-  it("Real integration: getChannels → handler GET /bundles/channels", async () => {
-    await api.insertBundle(
-      createTestBundle({ id: uuidv7(), channel: "production" }),
+  it("lists Channel rows through handler GET /channels", async () => {
+    await api.insertChannel({
+      onConflict: "returnExisting",
+      row: { id: uuidv7(), name: "production" },
+    });
+    await api.insertChannel({
+      onConflict: "returnExisting",
+      row: { id: uuidv7(), name: "beta" },
+    });
+
+    const channels = await createStandaloneClient().getChannels();
+
+    expect(channels.map(({ name }) => name)).toEqual(
+      expect.arrayContaining(["production", "beta"]),
     );
-    await api.insertBundle(createTestBundle({ id: uuidv7(), channel: "beta" }));
-    await api.insertBundle(
-      createTestBundle({ id: uuidv7(), channel: "production" }),
+    expect(channels.every(({ id }) => id.length > 0)).toBe(true);
+    expect(new Set(channels.map(({ name }) => name)).size).toBe(
+      channels.length,
     );
+  });
 
-    const repo = standaloneRepository({
-      baseUrl: `${baseUrl}/hot-updater`,
-    })();
-
-    const channels = await repo.getChannels();
+  it("creates and deletes an empty Channel through the canonical routes", async () => {
+    const client = createStandaloneClient();
+    const id = uuidv7();
 
-    expect(channels).toHaveLength(2);
-    expect(channels).toContain("production");
-    expect(channels).toContain("beta");
+    await expect(
+      client.insertChannel({
+        row: { id, name: "preview" },
+        onConflict: "returnExisting",
+      }),
+    ).resolves.toEqual({
+      row: { id, name: "preview" },
+      inserted: true,
+    });
+    await expect(client.deleteChannel({ id })).resolves.toEqual({
+      deleted: true,
+    });
+    await expect(client.deleteChannel({ id })).resolves.toEqual({
+      deleted: false,
+      reason: "not_found",
+    });
   });
 
-  it("Full E2E: create → retrieve → update → delete via standalone", async () => {
-    const repo = standaloneRepository({
-      baseUrl: `${baseUrl}/hot-updater`,
-    })();
-
-    // Step 1: Create bundle via standalone
+  it("refuses to delete a Channel referenced by a Release", async () => {
+    const client = createStandaloneClient();
     const bundleId = uuidv7();
-    const bundle = createTestBundle({
+    await commitTestRelease(createTestBundle({ id: bundleId }), "preview");
+    const channel = (await client.getChannels()).find(
+      ({ name }) => name === "preview",
+    );
+
+    expect(channel).toBeDefined();
+    if (!channel) throw new Error("preview Channel was not created");
+    await expect(client.deleteChannel({ id: channel.id })).resolves.toEqual({
+      deleted: false,
+      reason: "not_empty",
+    });
+    await expect(client.getBundleById(bundleId)).resolves.toMatchObject({
       id: bundleId,
-      fileHash: "e2e-hash",
-      enabled: true,
     });
+  });
 
-    await repo.appendBundle(bundle);
-    await repo.commitBundle();
+  it("updates an artifact without changing its Release or catalog", async () => {
+    const bundle = createTestBundle({ id: uuidv7() });
+    const { releaseId, repository, scopeKey } = await commitTestRelease(bundle);
+    const releaseBefore = await repository.models.releases.findById(releaseId);
+    const catalogBefore =
+      await repository.models.releaseCatalogs.findByScopeKey(scopeKey);
 
-    // Step 2: Retrieve via standalone
-    const retrieved = await repo.getBundleById(bundleId);
-    expect(retrieved).toBeTruthy();
-    expect(retrieved?.enabled).toBe(true);
+    await createStandaloneClient().updateBundleById(bundle.id, {
+      storageUri: "test://updated-artifact",
+    });
 
-    // Step 3: Update via standalone
-    await repo.updateBundle(bundleId, { enabled: false });
-    await repo.commitBundle();
+    await expect(api.getBundleById(bundle.id)).resolves.toMatchObject({
+      storageUri: "test://updated-artifact",
+    });
+    await expect(
+      repository.models.releases.findById(releaseId),
+    ).resolves.toEqual(releaseBefore);
+    await expect(
+      repository.models.releaseCatalogs.findByScopeKey(scopeKey),
+    ).resolves.toEqual(catalogBefore);
+  });
 
-    // Verify update
-    const updated = await repo.getBundleById(bundleId);
-    expect(updated?.enabled).toBe(false);
+  it("creates, retrieves, updates, and deletes through existing routes", async () => {
+    const client = createStandaloneClient();
+    const bundleId = uuidv7();
+    await client.insertBundle(
+      createTestBundle({ id: bundleId, fileHash: "e2e-hash" }),
+    );
 
-    // Step 4: Delete via standalone
-    await repo.deleteBundle(bundle);
-    await repo.commitBundle();
+    await expect(client.getBundleById(bundleId)).resolves.toMatchObject({
+      fileHash: "e2e-hash",
+    });
+    await client.updateBundleById(bundleId, { storageUri: "test://updated" });
+    await expect(client.getBundleById(bundleId)).resolves.toMatchObject({
+      storageUri: "test://updated",
+    });
+    await client.deleteBundleById(bundleId);
+    await expect(client.getBundleById(bundleId)).resolves.toBeNull();
+  });
+
+  it("creates multiple artifacts atomically through POST /bundles", async () => {
+    const ids = [uuidv7(), uuidv7(), uuidv7()];
 
-    // Verify deletion
-    const deleted = await repo.getBundleById(bundleId);
-    expect(deleted).toBeNull();
+    const response = await api.handlers.admin(
+      new Request(`${baseUrl}/bundles`, {
+        body: JSON.stringify(ids.map((id) => createTestBundle({ id }))),
+        headers: { "Content-Type": "application/json" },
+        method: "POST",
+      }),
+    );
+
+    expect(response.status).toBe(201);
+    for (const id of ids) {
+      await expect(api.getBundleById(id)).resolves.toMatchObject({ id });
+    }
   });
 
-  it("Multiple bundles in single commit (standalone sends array)", async () => {
-    const repo = standaloneRepository({
-      baseUrl: `${baseUrl}/hot-updater`,
-    })();
-
-    // Append multiple bundles
-    const bundleId1 = uuidv7();
-    const bundleId2 = uuidv7();
-    const bundleId3 = uuidv7();
-    await repo.appendBundle(createTestBundle({ id: bundleId1 }));
-    await repo.appendBundle(createTestBundle({ id: bundleId2 }));
-    await repo.appendBundle(createTestBundle({ id: bundleId3 }));
-
-    // Commit all at once (standalone sends array in POST)
-    await repo.commitBundle();
-
-    // Verify all were created
-    const bundle1 = await api.getBundleById(bundleId1);
-    const bundle2 = await api.getBundleById(bundleId2);
-    const bundle3 = await api.getBundleById(bundleId3);
-
-    expect(bundle1).toBeTruthy();
-    expect(bundle2).toBeTruthy();
-    expect(bundle3).toBeTruthy();
+  it("rolls back the entire create batch when one bundle cannot be inserted", async () => {
+    const existingId = uuidv7();
+    const newId = uuidv7();
+    await api.insertBundle(createTestBundle({ id: existingId }));
+
+    const response = await api.handlers.admin(
+      new Request(`${baseUrl}/bundles`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify([
+          createTestBundle({ id: newId }),
+          createTestBundle({ id: existingId }),
+        ]),
+      }),
+    );
+
+    expect(response.status).toBe(500);
+    await expect(api.getBundleById(newId)).resolves.toBeNull();
   });
 
-  it("Works with custom basePath configuration", async () => {
-    // Create handler with custom basePath
+  it("works when handlers are mounted under a custom client path", async () => {
     const customApi = createHotUpdater({
-      database: kyselyAdapter({
-        db: kysely,
-        provider: "postgresql",
-      }),
-      basePath: "/api/v2",
-      routes: {
-        updateCheck: true,
-        bundles: true,
-      },
+      database: kyselyAdapter({ db: kysely, provider: "postgresql" }),
+      clientAccess: { type: "public" },
     });
-
-    // Setup MSW for custom basePath
     server.use(
-      http.get(`${baseUrl}/api/v2/*`, async ({ request }) => {
-        const response = await customApi.handler(request);
-        return HttpResponse.json(
-          (await response.json()) as Record<string, unknown>,
-          {
-            status: response.status,
-          },
-        );
-      }),
-      http.post(`${baseUrl}/api/v2/*`, async ({ request }) => {
-        const response = await customApi.handler(request);
-        return HttpResponse.json(
-          (await response.json()) as Record<string, unknown>,
-          {
-            status: response.status,
-          },
-        );
-      }),
-      http.patch(`${baseUrl}/api/v2/*`, async ({ request }) => {
-        const response = await customApi.handler(request);
-        return HttpResponse.json(
-          (await response.json()) as Record<string, unknown>,
-          {
-            status: response.status,
-          },
-        );
+      http.all(`${baseUrl}/api/v2/*`, async ({ request }) => {
+        return invokeHandler(customApi, request, "/api/v2");
       }),
     );
+    const bundleId = uuidv7();
+    const client = createStandaloneClient(`${baseUrl}/api/v2/admin`);
 
-    // Create standalone repository with matching basePath
-    const repo = standaloneRepository({
-      baseUrl: `${baseUrl}/api/v2`,
-    })();
+    await client.insertBundle(
+      createTestBundle({ id: bundleId, fileHash: "custom-hash" }),
+    );
 
-    // Test create and retrieve
-    const bundleId = uuidv7();
-    const bundle = createTestBundle({
-      id: bundleId,
+    await expect(client.getBundleById(bundleId)).resolves.toMatchObject({
       fileHash: "custom-hash",
     });
-
-    await repo.appendBundle(bundle);
-    await repo.commitBundle();
-
-    const retrieved = await repo.getBundleById(bundleId);
-    expect(retrieved).toBeTruthy();
-    expect(retrieved?.fileHash).toBe("custom-hash");
   });
 
-  it("Handler returns 404 when bundle not found (standalone handles gracefully)", async () => {
-    const repo = standaloneRepository({
-      baseUrl: `${baseUrl}/hot-updater`,
-    })();
-
-    // Try to get non-existent bundle
-    const result = await repo.getBundleById("non-existent-bundle");
-
-    // Standalone should return null gracefully
-    expect(result).toBeNull();
+  it("returns null when the bundle endpoint returns 404", async () => {
+    await expect(
+      createStandaloneClient().getBundleById(uuidv7()),
+    ).resolves.toBeNull();
   });
 
-  it("updates targetAppVersion through standalone without creating a duplicate blob entry", async () => {
-    const store: Record<string, string> = {};
-    const blobApi = createHotUpdater({
-      database: createInMemoryBlobDatabase(store),
-      basePath: "/blob-hot-updater",
-      routes: {
-        updateCheck: true,
-        bundles: true,
-      },
+  it("updates a bundle without creating a duplicate row", async () => {
+    const memoryApi = createHotUpdater({
+      database: createInMemoryDatabasePlugin(),
+      clientAccess: { type: "public" },
     });
-    const handleBlobRequest = async (request: Request) => {
-      const response = await blobApi.handler(request);
-      return HttpResponse.json(
-        (await response.json()) as Record<string, unknown>,
-        {
-          status: response.status,
-          headers: response.headers,
-        },
-      );
-    };
-
     server.use(
-      http.get(`${baseUrl}/blob-hot-updater/api/bundles`, ({ request }) =>
-        handleBlobRequest(request),
-      ),
-      http.get(`${baseUrl}/blob-hot-updater/api/bundles/:id`, ({ request }) =>
-        handleBlobRequest(request),
-      ),
-      http.post(`${baseUrl}/blob-hot-updater/api/bundles`, ({ request }) =>
-        handleBlobRequest(request),
-      ),
-      http.patch(`${baseUrl}/blob-hot-updater/api/bundles/:id`, ({ request }) =>
-        handleBlobRequest(request),
-      ),
-      http.delete(
-        `${baseUrl}/blob-hot-updater/api/bundles/:id`,
-        ({ request }) => handleBlobRequest(request),
-      ),
+      http.all(`${baseUrl}/memory-hot-updater/*`, async ({ request }) => {
+        return invokeHandler(memoryApi, request, "/memory-hot-updater");
+      }),
+    );
+    const client = createStandaloneClient(
+      `${baseUrl}/memory-hot-updater/admin`,
     );
-
-    const repo = standaloneRepository({
-      baseUrl: `${baseUrl}/blob-hot-updater`,
-    })();
-
     const bundleId = uuidv7();
-    await repo.appendBundle(
+    await client.insertBundle(
       createTestBundle({
         id: bundleId,
-        platform: "ios",
-        targetAppVersion: "1.x.x",
         storageUri: "s3://test-bucket/original.zip",
       }),
     );
-    await repo.commitBundle();
-
-    await repo.updateBundle(bundleId, { targetAppVersion: "1.0.2" });
-    await repo.commitBundle();
-
-    const updatedBundle = await repo.getBundleById(bundleId);
-    expect(updatedBundle?.targetAppVersion).toBe("1.0.2");
-
-    expect(store["production/ios/1.x.x/update.json"]).toBeUndefined();
 
-    const nextBundles = JSON.parse(
-      store["production/ios/1.0.2/update.json"] ?? "[]",
-    ) as Bundle[];
-    expect(nextBundles).toHaveLength(1);
-    expect(nextBundles[0]?.id).toBe(bundleId);
-    expect(nextBundles[0]?.targetAppVersion).toBe("1.0.2");
+    await client.updateBundleById(bundleId, {
+      storageUri: "s3://test-bucket/updated.zip",
+    });
 
-    const targetVersions = JSON.parse(
-      store["production/ios/target-app-versions.json"] ?? "[]",
-    ) as string[];
-    expect(targetVersions).toEqual(["1.0.2"]);
+    await expect(client.getBundleById(bundleId)).resolves.toMatchObject({
+      id: bundleId,
+      storageUri: "s3://test-bucket/updated.zip",
+    });
+    await expect(client.getBundles({ limit: 50 })).resolves.toMatchObject({
+      data: [
+        expect.objectContaining({
+          id: bundleId,
+          storageUri: "s3://test-bucket/updated.zip",
+        }),
+      ],
+      pagination: { total: 1 },
+    });
   });
 });