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

package/src/handler.ts

@@ -1,643 +1,245 @@
+import {
+  createAnalyticsRouteHandlers,
+  registerAnalyticsAdminRoutes,
+  registerAnalyticsClientRoutes,
+} from "./analytics/routes";
+import type { AnalyticsProvider } from "./analytics/types";
+import { createBundleRouteHandlers } from "./handlerBundleRoutes";
+import { HandlerBadRequestError } from "./handlerErrors";
+import { createReleaseCatalogRouteHandlers } from "./handlerReleaseCatalogRoutes";
+import { createReleaseManagementRouteHandlers } from "./handlerReleaseManagementRoutes";
 import type {
-  AppUpdateAvailableInfo,
-  AppUpdateInfo,
-  AppVersionGetBundlesArgs,
-  Bundle,
-  FingerprintGetBundlesArgs,
-  Platform,
-} from "@hot-updater/core";
-import type {
-  DatabaseBundleQueryOptions,
-  HotUpdaterContext,
-} from "@hot-updater/plugin-core";
-import { isGreaterOrEqual, normalize } from "verkit";
-
+  HandlerAPI,
+  HotUpdaterHandler,
+  HotUpdaterHandlers,
+  RouteHandler,
+} from "./handlerTypes";
+import { createVersionRouteHandlers } from "./handlerVersionRoutes";
 import { addRoute, createRouter, findRoute } from "./internalRouter";
-import type { ChannelsResponse, PaginatedResult } from "./types";
-import { HOT_UPDATER_SERVER_VERSION } from "./version";
-
-// Narrow API surface needed by the handler to avoid circular types
-export interface HandlerAPI<TContext = unknown> {
-  getAppUpdateInfo: (
-    args: AppVersionGetBundlesArgs | FingerprintGetBundlesArgs,
-    context?: HotUpdaterContext<TContext>,
-  ) => Promise<AppUpdateAvailableInfo | null>;
-  getBundleById: (
-    id: string,
-    context?: HotUpdaterContext<TContext>,
-  ) => Promise<Bundle | null>;
-  getBundles: (
-    options: DatabaseBundleQueryOptions,
-    context?: HotUpdaterContext<TContext>,
-  ) => Promise<PaginatedResult>;
-  insertBundle: (
-    bundle: Bundle,
-    context?: HotUpdaterContext<TContext>,
-  ) => Promise<void>;
-  updateBundleById: (
-    bundleId: string,
-    bundle: Partial<Bundle>,
-    context?: HotUpdaterContext<TContext>,
-  ) => Promise<void>;
-  deleteBundleById: (
-    bundleId: string,
-    context?: HotUpdaterContext<TContext>,
-  ) => Promise<void>;
-  getChannels: (context?: HotUpdaterContext<TContext>) => Promise<string[]>;
-}
-
-export interface HandlerOptions {
-  /**
-   * Base path for all routes
-   * @default "/api"
-   */
-  basePath?: string;
-  /**
-   * Route groups to mount. Omit this option to use the default route groups.
-   * When provided, both route groups must be specified explicitly.
-   * The `/version` endpoint is always mounted for diagnostics.
-   */
-  routes?: HandlerRoutes;
-}
-
-export interface HandlerRoutes {
-  /**
-   * Controls whether update-check routes are mounted.
-   * Defaults to `true` only when `routes` is omitted.
-   */
-  updateCheck: boolean;
-  /**
-   * Controls whether bundle management routes are mounted.
-   * This includes `/api/bundles*`, which are used by the
-   * CLI `standaloneRepository` plugin.
-   * Defaults to `false` only when `routes` is omitted.
-   */
-  bundles: boolean;
-}
-
-type RouteHandler<TContext = unknown> = (
-  params: Record<string, string>,
-  request: Request,
-  api: HandlerAPI<TContext>,
-  context?: HotUpdaterContext<TContext>,
-) => Promise<Response>;
-
-class HandlerBadRequestError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = "HandlerBadRequestError";
-  }
-}
 
-const SDK_VERSION_HEADER = "Hot-Updater-SDK-Version";
-const EXPLICIT_NO_UPDATE_MIN_SDK_VERSION = "0.31.0";
-const DEFAULT_BUNDLE_LIST_LIMIT = 50;
-const MAX_BUNDLE_LIST_LIMIT = 100;
-
-const supportsExplicitNoUpdateResponse = (request: Request) => {
-  const sdkVersion = request.headers.get(SDK_VERSION_HEADER)?.trim();
-  if (!sdkVersion) {
-    return false;
-  }
-
-  const normalizedSdkVersion = normalize(sdkVersion);
-  return (
-    normalizedSdkVersion !== null &&
-    isGreaterOrEqual(normalizedSdkVersion, EXPLICIT_NO_UPDATE_MIN_SDK_VERSION)
-  );
-};
-
-const serializeUpdateInfo = (
-  updateInfo: AppUpdateAvailableInfo | null,
-  request: Request,
-): string => {
-  if (updateInfo) {
-    return JSON.stringify(updateInfo satisfies AppUpdateInfo);
-  }
-
-  if (supportsExplicitNoUpdateResponse(request)) {
-    return JSON.stringify({ status: "UP_TO_DATE" } satisfies AppUpdateInfo);
-  }
-
-  return JSON.stringify(null);
-};
-
-// Route handlers
-const handleVersion: RouteHandler = async () => {
-  return new Response(JSON.stringify({ version: HOT_UPDATER_SERVER_VERSION }), {
-    status: 200,
-    headers: { "Content-Type": "application/json" },
+export type {
+  HandlerAPI,
+  HotUpdaterHandler,
+  HotUpdaterHandlers,
+} from "./handlerTypes";
+
+const withPrivateNoStore = (response: Response): Response => {
+  const headers = new Headers(response.headers);
+  headers.set("cache-control", "private, no-store");
+  return new Response(response.body, {
+    headers,
+    status: response.status,
+    statusText: response.statusText,
   });
 };
 
-const decodeMaybe = (value: string | undefined): string | undefined => {
-  if (value === undefined) return undefined;
-  try {
-    return decodeURIComponent(value);
-  } catch {
-    return value;
-  }
-};
-
-const isPlatform = (value: string): value is Platform => {
-  return value === "ios" || value === "android";
-};
-
-const requireRouteParam = (
-  params: Record<string, string>,
-  key: string,
-): string => {
-  const value = params[key];
-  if (!value) {
-    throw new HandlerBadRequestError(`Missing route parameter: ${key}`);
-  }
-
-  return value;
-};
-
-const parseBooleanSearchParam = (
-  url: URL,
-  key: string,
-): boolean | undefined => {
-  const value = url.searchParams.get(key);
-  if (value === null) {
-    return undefined;
-  }
-  if (value === "true") {
-    return true;
-  }
-  if (value === "false") {
-    return false;
-  }
-
-  throw new HandlerBadRequestError(
-    `The '${key}' query parameter must be 'true' or 'false'.`,
-  );
-};
-
-const parseNullableStringSearchParam = (
-  url: URL,
-  key: string,
-): string | null | undefined => {
-  const value = url.searchParams.get(key);
-  if (value === null) {
-    return undefined;
-  }
-
-  return value === "null" ? null : value;
-};
-
-const parseStringArraySearchParam = (url: URL, key: string) => {
-  const values = url.searchParams.getAll(key);
-  return values.length > 0 ? values : undefined;
-};
-
-const parsePositiveIntegerSearchParam = (
-  url: URL,
-  key: string,
-  defaultValue: number,
-  maxValue: number,
-): number => {
-  const value = url.searchParams.get(key);
-  if (value === null) {
-    return defaultValue;
-  }
-
-  const parsed = Number(value);
-  if (!Number.isInteger(parsed) || parsed < 1 || parsed > maxValue) {
-    throw new HandlerBadRequestError(
-      `The '${key}' query parameter must be a positive integer between 1 and ${maxValue}.`,
-    );
-  }
-
-  return parsed;
-};
-
-const requirePlatformParam = (params: Record<string, string>): Platform => {
-  const platform = requireRouteParam(params, "platform");
-
-  if (!isPlatform(platform)) {
-    throw new HandlerBadRequestError(
-      `Invalid platform: ${platform}. Expected 'ios' or 'android'.`,
-    );
-  }
-
-  return platform;
-};
-
-type BundlePatchPayload = Partial<Bundle> & {
-  id?: string;
-};
-
-const requireBundlePatchPayload = (
-  payload: unknown,
-  bundleId: string,
-): Partial<Bundle> => {
-  if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
-    throw new HandlerBadRequestError("Invalid bundle payload");
-  }
-
-  const bundlePatch = payload as BundlePatchPayload;
-  if (bundlePatch.id !== undefined && bundlePatch.id !== bundleId) {
-    throw new HandlerBadRequestError("Bundle id mismatch");
-  }
-
-  const { id: _ignoredId, ...rest } = bundlePatch;
-  return rest;
-};
-
-const handleFingerprintUpdateWithCohort: RouteHandler = async (
-  params,
-  request,
-  api,
-  context,
-) => {
-  const platform = requirePlatformParam(params);
-  const fingerprintHash = requireRouteParam(params, "fingerprintHash");
-  const channel = requireRouteParam(params, "channel");
-  const minBundleId = requireRouteParam(params, "minBundleId");
-  const bundleId = requireRouteParam(params, "bundleId");
-
-  const updateInfo = await api.getAppUpdateInfo(
+const errorResponse = (error: string, status: number): Response =>
+  Response.json(
+    { error },
     {
-      _updateStrategy: "fingerprint",
-      platform,
-      fingerprintHash,
-      channel,
-      minBundleId,
-      bundleId,
-      cohort: decodeMaybe(params.cohort),
+      headers: { "cache-control": "private, no-store" },
+      status,
     },
-    context,
   );
 
-  return new Response(serializeUpdateInfo(updateInfo, request), {
-    status: 200,
-    headers: { "Content-Type": "application/json" },
-  });
-};
-
-const handleAppVersionUpdateWithCohort: RouteHandler = async (
-  params,
-  request,
-  api,
-  context,
-) => {
-  const platform = requirePlatformParam(params);
-  const appVersion = requireRouteParam(params, "appVersion");
-  const channel = requireRouteParam(params, "channel");
-  const minBundleId = requireRouteParam(params, "minBundleId");
-  const bundleId = requireRouteParam(params, "bundleId");
-
-  const updateInfo = await api.getAppUpdateInfo(
-    {
-      _updateStrategy: "appVersion",
-      platform,
-      appVersion,
-      channel,
-      minBundleId,
-      bundleId,
-      cohort: decodeMaybe(params.cohort),
-    },
-    context,
-  );
-
-  return new Response(serializeUpdateInfo(updateInfo, request), {
-    status: 200,
-    headers: { "Content-Type": "application/json" },
-  });
-};
-
-const handleGetBundle: RouteHandler = async (
-  params,
-  _request,
-  api,
-  context,
-) => {
-  const bundleId = requireRouteParam(params, "id");
-  const bundle = await api.getBundleById(bundleId, context);
-
-  if (!bundle) {
-    return new Response(JSON.stringify({ error: "Bundle not found" }), {
-      status: 404,
-      headers: { "Content-Type": "application/json" },
-    });
-  }
-
-  return new Response(JSON.stringify(bundle), {
-    status: 200,
-    headers: { "Content-Type": "application/json" },
-  });
-};
-
-const handleGetBundles: RouteHandler = async (
-  _params,
-  request,
-  api,
-  context,
-) => {
-  const url = new URL(request.url);
-  const channel = url.searchParams.get("channel") ?? undefined;
-  const platform = url.searchParams.get("platform");
-  const limit = parsePositiveIntegerSearchParam(
-    url,
-    "limit",
-    DEFAULT_BUNDLE_LIST_LIMIT,
-    MAX_BUNDLE_LIST_LIMIT,
-  );
-  const pageParam = url.searchParams.get("page");
-  const offset = url.searchParams.get("offset");
-  const after = url.searchParams.get("after") ?? undefined;
-  const before = url.searchParams.get("before") ?? undefined;
-  const enabled = parseBooleanSearchParam(url, "enabled");
-  const targetAppVersion = parseNullableStringSearchParam(
-    url,
-    "targetAppVersion",
-  );
-  const targetAppVersionIn = parseStringArraySearchParam(
-    url,
-    "targetAppVersionIn",
-  );
-  const targetAppVersionNotNull = parseBooleanSearchParam(
-    url,
-    "targetAppVersionNotNull",
-  );
-  const fingerprintHash = parseNullableStringSearchParam(
-    url,
-    "fingerprintHash",
-  );
-  const idEq = url.searchParams.get("idEq") ?? undefined;
-  const idGt = url.searchParams.get("idGt") ?? undefined;
-  const idGte = url.searchParams.get("idGte") ?? undefined;
-  const idLt = url.searchParams.get("idLt") ?? undefined;
-  const idLte = url.searchParams.get("idLte") ?? undefined;
-  const idIn = parseStringArraySearchParam(url, "idIn");
-  const page =
-    pageParam === null
-      ? undefined
-      : Number.isInteger(Number(pageParam)) && Number(pageParam) > 0
-        ? Number(pageParam)
-        : null;
-
-  if (offset !== null) {
-    throw new HandlerBadRequestError(
-      "The 'offset' query parameter has been removed. Use 'after' or 'before' cursor pagination instead.",
-    );
-  }
-
-  if (page === null) {
-    throw new HandlerBadRequestError(
-      "The 'page' query parameter must be a positive integer.",
-    );
-  }
-
-  if (platform !== null && !isPlatform(platform)) {
-    throw new HandlerBadRequestError(
-      `Invalid platform: ${platform}. Expected 'ios' or 'android'.`,
-    );
-  }
-
-  const result = await api.getBundles(
-    {
-      where: {
-        ...(channel && { channel }),
-        ...(platform && { platform }),
-        ...(enabled !== undefined && { enabled }),
-        ...(idEq || idGt || idGte || idLt || idLte || (idIn && idIn.length > 0)
-          ? {
-              id: {
-                ...(idEq && { eq: idEq }),
-                ...(idGt && { gt: idGt }),
-                ...(idGte && { gte: idGte }),
-                ...(idLt && { lt: idLt }),
-                ...(idLte && { lte: idLte }),
-                ...(idIn && idIn.length > 0 && { in: idIn }),
-              },
-            }
-          : {}),
-        ...(targetAppVersion !== undefined && { targetAppVersion }),
-        ...(targetAppVersionIn && { targetAppVersionIn }),
-        ...(targetAppVersionNotNull !== undefined && {
-          targetAppVersionNotNull,
-        }),
-        ...(fingerprintHash !== undefined && { fingerprintHash }),
-      },
-      limit,
-      page,
-      cursor:
-        after || before
-          ? {
-              after,
-              before,
-            }
-          : undefined,
-    },
-    context,
-  );
-
-  return new Response(JSON.stringify(result), {
-    status: 200,
-    headers: { "Content-Type": "application/json" },
-  });
-};
-
-const handleCreateBundles: RouteHandler = async (
-  _params,
-  request,
-  api,
-  context,
-) => {
-  const body = await request.json();
-  const bundles = Array.isArray(body) ? body : [body];
-
-  for (const bundle of bundles) {
-    await api.insertBundle(bundle as Bundle, context);
-  }
-
-  return new Response(JSON.stringify({ success: true }), {
-    status: 201,
-    headers: { "Content-Type": "application/json" },
-  });
-};
-
-const handleUpdateBundle: RouteHandler = async (
-  params,
-  request,
-  api,
-  context,
-) => {
-  const bundleId = requireRouteParam(params, "id");
-  const body = await request.json();
-  const payload = Array.isArray(body) ? body[0] : body;
-  const bundlePatch = requireBundlePatchPayload(payload, bundleId);
-  await api.updateBundleById(bundleId, bundlePatch, context);
-
-  return new Response(JSON.stringify({ success: true }), {
-    status: 200,
-    headers: { "Content-Type": "application/json" },
-  });
-};
-
-const handleDeleteBundle: RouteHandler = async (
-  params,
-  _request,
-  api,
-  context,
-) => {
-  const bundleId = requireRouteParam(params, "id");
-  await api.deleteBundleById(bundleId, context);
-
-  return new Response(JSON.stringify({ success: true }), {
-    status: 200,
-    headers: { "Content-Type": "application/json" },
-  });
-};
-
-const handleGetChannels: RouteHandler = async (
-  _params,
-  _request,
-  api,
-  context,
-) => {
-  const channels = await api.getChannels(context);
-  const response: ChannelsResponse = {
-    data: {
-      channels,
-    },
-  };
-
-  return new Response(JSON.stringify(response), {
-    status: 200,
-    headers: { "Content-Type": "application/json" },
-  });
-};
-
-// Route handlers map
-const routes: Record<string, RouteHandler<any>> = {
-  version: handleVersion,
-  fingerprintUpdateWithCohort: handleFingerprintUpdateWithCohort,
-  appVersionUpdateWithCohort: handleAppVersionUpdateWithCohort,
-  getBundle: handleGetBundle,
-  getBundles: handleGetBundles,
-  createBundles: handleCreateBundles,
-  updateBundle: handleUpdateBundle,
-  deleteBundle: handleDeleteBundle,
-  getChannels: handleGetChannels,
-};
-
-/**
- * Creates a Web Standard Request handler for Hot Updater API
- * This handler is framework-agnostic and works with any runtime that
- * supports standard Request/Response objects.
- */
-export function createHandler<TContext = unknown>(
-  api: HandlerAPI<TContext>,
-  options: HandlerOptions = {},
-): (
-  request: Request,
-  context?: HotUpdaterContext<TContext>,
-) => Promise<Response> {
-  const basePath = options.basePath ?? "/api";
-  const routeOptions = {
-    updateCheck: options.routes?.updateCheck ?? true,
-    bundles: options.routes?.bundles ?? false,
-  };
-
-  // Create and configure router
-  const router = createRouter();
-
-  // Register routes
-  addRoute(router, "GET", "/version", "version");
-
-  if (routeOptions.updateCheck) {
-    addRoute(
-      router,
-      "GET",
-      "/fingerprint/:platform/:fingerprintHash/:channel/:minBundleId/:bundleId",
-      "fingerprintUpdateWithCohort",
-    );
-    addRoute(
-      router,
-      "GET",
-      "/fingerprint/:platform/:fingerprintHash/:channel/:minBundleId/:bundleId/:cohort",
-      "fingerprintUpdateWithCohort",
-    );
-    addRoute(
-      router,
-      "GET",
-      "/app-version/:platform/:appVersion/:channel/:minBundleId/:bundleId",
-      "appVersionUpdateWithCohort",
-    );
-    addRoute(
-      router,
-      "GET",
-      "/app-version/:platform/:appVersion/:channel/:minBundleId/:bundleId/:cohort",
-      "appVersionUpdateWithCohort",
-    );
-  }
-
-  if (routeOptions.bundles) {
-    addRoute(router, "GET", "/api/bundles/channels", "getChannels");
-    addRoute(router, "GET", "/api/bundles/:id", "getBundle");
-    addRoute(router, "GET", "/api/bundles", "getBundles");
-    addRoute(router, "POST", "/api/bundles", "createBundles");
-    addRoute(router, "PATCH", "/api/bundles/:id", "updateBundle");
-    addRoute(router, "DELETE", "/api/bundles/:id", "deleteBundle");
-  }
-
-  return async (
-    request: Request,
-    context?: HotUpdaterContext<TContext>,
-  ): Promise<Response> => {
+const requiresApiKey = (handlerName: string): boolean =>
+  handlerName === "appVersionReleaseCatalog" ||
+  handlerName === "fingerprintReleaseCatalog" ||
+  handlerName === "artifact" ||
+  handlerName === "appendBundleEvent";
+
+const createRequestHandler =
+  ({
+    api,
+    apiKeyAuth,
+    privateResponses = false,
+    routeHandlers,
+    router,
+  }: {
+    readonly api: HandlerAPI;
+    readonly apiKeyAuth?: {
+      readonly authenticate: (request: Request) => Promise<boolean>;
+    };
+    readonly privateResponses?: boolean;
+    readonly routeHandlers: Record<string, RouteHandler>;
+    readonly router: ReturnType<typeof createRouter<string>>;
+  }): HotUpdaterHandler =>
+  async (request): Promise<Response> => {
     try {
-      const url = new URL(request.url);
-      const path = url.pathname;
-      const method = request.method;
-
-      // Remove base path from pathname
-      const routePath = path.startsWith(basePath)
-        ? path.slice(basePath.length)
-        : path;
-
-      // Find matching route
-      const match = findRoute(router, method, routePath);
-
+      const match = findRoute(
+        router,
+        request.method,
+        new URL(request.url).pathname,
+      );
       if (!match) {
-        return new Response(JSON.stringify({ error: "Not found" }), {
-          status: 404,
-          headers: { "Content-Type": "application/json" },
-        });
+        return errorResponse("Not found", 404);
       }
 
-      const routeName = match.data as string;
-      const handler = routes[routeName] as RouteHandler<TContext>;
-      if (!handler) {
-        return new Response(JSON.stringify({ error: "Handler not found" }), {
-          status: 500,
-          headers: { "Content-Type": "application/json" },
-        });
+      if (apiKeyAuth !== undefined && requiresApiKey(match.data)) {
+        let authenticated: boolean;
+        try {
+          authenticated = await apiKeyAuth.authenticate(request);
+        } catch {
+          return errorResponse("Service unavailable", 503);
+        }
+        if (!authenticated) {
+          return errorResponse("Unauthorized", 401);
+        }
       }
 
-      return await handler(match.params || {}, request, api, context);
+      const handler = routeHandlers[match.data];
+      if (!handler) {
+        return errorResponse("Handler not found", 500);
+      }
+      const response = await handler(match.params, request, api);
+      return privateResponses ? withPrivateNoStore(response) : response;
     } catch (error) {
       if (error instanceof HandlerBadRequestError) {
-        return new Response(JSON.stringify({ error: error.message }), {
-          status: 400,
-          headers: { "Content-Type": "application/json" },
-        });
+        return errorResponse(error.message, 400);
       }
-
       console.error("Hot Updater handler error:", error);
-      return new Response(
-        JSON.stringify({
-          error: "Internal server error",
-          message: error instanceof Error ? error.message : "Unknown error",
-        }),
+      return Response.json(
+        { error: "Internal server error" },
         {
+          headers: { "cache-control": "private, no-store" },
           status: 500,
-          headers: { "Content-Type": "application/json" },
         },
       );
     }
   };
+
+const createDownloadStorageRouteHandler =
+  (
+    downloadStorageObject: (
+      token: string,
+      signature: string,
+    ) => Promise<Response | null>,
+  ): RouteHandler =>
+  async (params) => {
+    const token = params.token;
+    const signature = params.signature;
+    if (!token || !signature) {
+      return errorResponse("Not found", 404);
+    }
+    const response = await downloadStorageObject(token, signature);
+    if (!response) {
+      return errorResponse("Not found", 404);
+    }
+    const headers = new Headers(response.headers);
+    if (!headers.has("cache-control")) {
+      headers.set("cache-control", "public, max-age=31536000, immutable");
+    }
+    return new Response(response.body, {
+      headers,
+      status: response.status,
+      statusText: response.statusText,
+    });
+  };
+
+export function createHandlers(api: HandlerAPI): HotUpdaterHandlers {
+  return createHotUpdaterHandlers(api);
+}
+
+export function createHotUpdaterHandlers(
+  api: HandlerAPI,
+  analytics?: AnalyticsProvider,
+  apiKeyAuth?: {
+    readonly authenticate: (request: Request) => Promise<boolean>;
+    readonly headerName: string;
+  },
+  downloadStorageObject?: (
+    token: string,
+    signature: string,
+  ) => Promise<Response | null>,
+): HotUpdaterHandlers {
+  const routeHandlers: Record<string, RouteHandler> = {
+    ...createVersionRouteHandlers(),
+    ...createReleaseCatalogRouteHandlers(apiKeyAuth?.headerName),
+    ...createReleaseManagementRouteHandlers(),
+    ...createBundleRouteHandlers(),
+    ...(analytics === undefined ? {} : createAnalyticsRouteHandlers(analytics)),
+    ...(downloadStorageObject === undefined
+      ? {}
+      : {
+          downloadStorageObject: createDownloadStorageRouteHandler(
+            downloadStorageObject,
+          ),
+        }),
+  };
+
+  const clientRouter = createRouter<string>();
+  const addClientRoute = (
+    method: string,
+    path: string,
+    handler: string,
+  ): void => addRoute(clientRouter, method, path, handler);
+  addClientRoute("GET", "/version", "version");
+  if (downloadStorageObject !== undefined) {
+    addClientRoute(
+      "GET",
+      "/storage/:token/:signature",
+      "downloadStorageObject",
+    );
+  }
+  addClientRoute(
+    "GET",
+    "/release-catalogs/app-version/:platform/:channelKey/:appVersion",
+    "appVersionReleaseCatalog",
+  );
+  addClientRoute(
+    "GET",
+    "/release-catalogs/fingerprint/:platform/:channelKey/:fingerprintHash",
+    "fingerprintReleaseCatalog",
+  );
+  addClientRoute(
+    "GET",
+    "/artifacts/:targetBundleId/from/:currentBundleId",
+    "artifact",
+  );
+  if (analytics !== undefined) {
+    registerAnalyticsClientRoutes(addClientRoute);
+  }
+
+  const adminRouter = createRouter<string>();
+  const addAdminRoute = (method: string, path: string, handler: string): void =>
+    addRoute(adminRouter, method, path, handler);
+  addAdminRoute("GET", "/releases/:id", "getRelease");
+  addAdminRoute("GET", "/releases", "getReleases");
+  addAdminRoute("PATCH", "/releases/:id", "updateRelease");
+  addAdminRoute("POST", "/releases/:id/preflight", "preflightRelease");
+  addAdminRoute("DELETE", "/releases/:id", "deleteRelease");
+  addAdminRoute("GET", "/release-catalogs/:scopeKey", "getReleaseCatalogRow");
+  addAdminRoute("GET", "/release-catalogs", "getReleaseCatalogs");
+  addAdminRoute(
+    "POST",
+    "/release-catalogs/:scopeKey/rebuild",
+    "rebuildReleaseCatalog",
+  );
+  addAdminRoute("POST", "/database/commit", "commitDatabase");
+  addAdminRoute("GET", "/channels", "getChannels");
+  addAdminRoute("POST", "/channels", "createChannel");
+  addAdminRoute("DELETE", "/channels/:id", "deleteChannel");
+  addAdminRoute("GET", "/bundles/:id", "getBundle");
+  addAdminRoute("GET", "/bundles", "getBundles");
+  addAdminRoute("POST", "/bundles", "createBundles");
+  addAdminRoute("PATCH", "/bundles/:id", "updateBundle");
+  addAdminRoute("DELETE", "/bundles/:id", "deleteBundle");
+  if (analytics !== undefined) {
+    registerAnalyticsAdminRoutes(addAdminRoute);
+  }
+
+  return Object.freeze({
+    client: createRequestHandler({
+      api,
+      apiKeyAuth,
+      routeHandlers,
+      router: clientRouter,
+    }),
+    admin: createRequestHandler({
+      api,
+      privateResponses: true,
+      routeHandlers,
+      router: adminRouter,
+    }),
+  });
 }