@hot-updater/server 0.28.0 → 0.29.1

package/src/handler.ts

@@ -3,26 +3,45 @@ import type {
   AppVersionGetBundlesArgs,
   Bundle,
   FingerprintGetBundlesArgs,
+  Platform,
 } from "@hot-updater/core";
-import { addRoute, createRouter, findRoute } from "rou3";
+import type {
+  DatabaseBundleQueryOptions,
+  HotUpdaterContext,
+} from "@hot-updater/plugin-core";
+import { addRoute, createRouter, findRoute } from "./internalRouter";
 import type { PaginationInfo } from "./types";
 
 declare const __VERSION__: string;
 
 // Narrow API surface needed by the handler to avoid circular types
-export interface HandlerAPI {
+export interface HandlerAPI<TContext = unknown> {
   getAppUpdateInfo: (
     args: AppVersionGetBundlesArgs | FingerprintGetBundlesArgs,
+    context?: HotUpdaterContext<TContext>,
   ) => Promise<AppUpdateInfo | null>;
-  getBundleById: (id: string) => Promise<Bundle | null>;
-  getBundles: (options: {
-    where?: { channel?: string; platform?: string };
-    limit: number;
-    offset: number;
-  }) => Promise<{ data: Bundle[]; pagination: PaginationInfo }>;
-  insertBundle: (bundle: Bundle) => Promise<void>;
-  deleteBundleById: (bundleId: string) => Promise<void>;
-  getChannels: () => Promise<string[]>;
+  getBundleById: (
+    id: string,
+    context?: HotUpdaterContext<TContext>,
+  ) => Promise<Bundle | null>;
+  getBundles: (
+    options: DatabaseBundleQueryOptions,
+    context?: HotUpdaterContext<TContext>,
+  ) => Promise<{ data: Bundle[]; pagination: PaginationInfo }>;
+  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 {
@@ -31,14 +50,38 @@ export interface HandlerOptions {
    * @default "/api"
    */
   basePath?: string;
+  routes?: HandlerRoutes;
+}
+
+export interface HandlerRoutes {
+  /**
+   * Controls whether update-check routes are mounted.
+   * @default true
+   */
+  updateCheck?: boolean;
+  /**
+   * Controls whether bundle management routes are mounted.
+   * This includes `/version` and `/api/bundles*`, which are used by the
+   * CLI `standaloneRepository` plugin.
+   * @default true
+   */
+  bundles?: boolean;
 }
 
-type RouteHandler = (
+type RouteHandler<TContext = unknown> = (
   params: Record<string, string>,
   request: Request,
-  api: HandlerAPI,
+  api: HandlerAPI<TContext>,
+  context?: HotUpdaterContext<TContext>,
 ) => Promise<Response>;
 
+class HandlerBadRequestError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "HandlerBadRequestError";
+  }
+}
+
 // Route handlers
 const handleVersion: RouteHandler = async () => {
   return new Response(JSON.stringify({ version: __VERSION__ }), {
@@ -47,15 +90,88 @@ const handleVersion: RouteHandler = async () => {
   });
 };
 
-const handleFingerprintUpdate: RouteHandler = async (params, _request, api) => {
-  const updateInfo = await api.getAppUpdateInfo({
-    _updateStrategy: "fingerprint",
-    platform: params.platform as "ios" | "android",
-    fingerprintHash: params.fingerprintHash,
-    channel: params.channel,
-    minBundleId: params.minBundleId,
-    bundleId: params.bundleId,
-  });
+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 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(
+    {
+      _updateStrategy: "fingerprint",
+      platform,
+      fingerprintHash,
+      channel,
+      minBundleId,
+      bundleId,
+      cohort: decodeMaybe(params.cohort),
+    },
+    context,
+  );
 
   return new Response(JSON.stringify(updateInfo), {
     status: 200,
@@ -63,15 +179,30 @@ const handleFingerprintUpdate: RouteHandler = async (params, _request, api) => {
   });
 };
 
-const handleAppVersionUpdate: RouteHandler = async (params, _request, api) => {
-  const updateInfo = await api.getAppUpdateInfo({
-    _updateStrategy: "appVersion",
-    platform: params.platform as "ios" | "android",
-    appVersion: params.appVersion,
-    channel: params.channel,
-    minBundleId: params.minBundleId,
-    bundleId: params.bundleId,
-  });
+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(JSON.stringify(updateInfo), {
     status: 200,
@@ -79,8 +210,14 @@ const handleAppVersionUpdate: RouteHandler = async (params, _request, api) => {
   });
 };
 
-const handleGetBundle: RouteHandler = async (params, _request, api) => {
-  const bundle = await api.getBundleById(params.id);
+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" }), {
@@ -95,21 +232,35 @@ const handleGetBundle: RouteHandler = async (params, _request, api) => {
   });
 };
 
-const handleGetBundles: RouteHandler = async (_params, request, api) => {
+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") ?? undefined;
+  const platform = url.searchParams.get("platform");
   const limit = Number(url.searchParams.get("limit")) || 50;
   const offset = Number(url.searchParams.get("offset")) || 0;
 
-  const result = await api.getBundles({
-    where: {
-      ...(channel && { channel }),
-      ...(platform && { platform }),
+  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 }),
+      },
+      limit,
+      offset,
     },
-    limit,
-    offset,
-  });
+    context,
+  );
 
   return new Response(JSON.stringify(result.data), {
     status: 200,
@@ -117,12 +268,17 @@ const handleGetBundles: RouteHandler = async (_params, request, api) => {
   });
 };
 
-const handleCreateBundles: RouteHandler = async (_params, request, api) => {
+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);
+    await api.insertBundle(bundle as Bundle, context);
   }
 
   return new Response(JSON.stringify({ success: true }), {
@@ -131,8 +287,32 @@ const handleCreateBundles: RouteHandler = async (_params, request, api) => {
   });
 };
 
-const handleDeleteBundle: RouteHandler = async (params, _request, api) => {
-  await api.deleteBundleById(params.id);
+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,
@@ -140,8 +320,13 @@ const handleDeleteBundle: RouteHandler = async (params, _request, api) => {
   });
 };
 
-const handleGetChannels: RouteHandler = async (_params, _request, api) => {
-  const channels = await api.getChannels();
+const handleGetChannels: RouteHandler = async (
+  _params,
+  _request,
+  api,
+  context,
+) => {
+  const channels = await api.getChannels(context);
 
   return new Response(JSON.stringify({ channels }), {
     status: 200,
@@ -150,52 +335,79 @@ const handleGetChannels: RouteHandler = async (_params, _request, api) => {
 };
 
 // Route handlers map
-const routes: Record<string, RouteHandler> = {
+const routes: Record<string, RouteHandler<any>> = {
   version: handleVersion,
-  fingerprintUpdate: handleFingerprintUpdate,
-  appVersionUpdate: handleAppVersionUpdate,
+  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 framework
- * that supports Web Standard Request/Response (Hono, Elysia, etc.)
+ * This handler is framework-agnostic and works with any runtime that
+ * supports standard Request/Response objects.
  */
-export function createHandler(
-  api: HandlerAPI,
+export function createHandler<TContext = unknown>(
+  api: HandlerAPI<TContext>,
   options: HandlerOptions = {},
-): (request: Request) => Promise<Response> {
+): (
+  request: Request,
+  context?: HotUpdaterContext<TContext>,
+) => Promise<Response> {
   const basePath = options.basePath ?? "/api";
+  const updateCheckEnabled = options.routes?.updateCheck ?? true;
+  const bundlesEnabled = options.routes?.bundles ?? true;
 
   // Create and configure router
   const router = createRouter();
 
   // Register routes
-  addRoute(router, "GET", "/version", "version");
-  addRoute(
-    router,
-    "GET",
-    "/fingerprint/:platform/:fingerprintHash/:channel/:minBundleId/:bundleId",
-    "fingerprintUpdate",
-  );
-  addRoute(
-    router,
-    "GET",
-    "/app-version/:platform/:appVersion/:channel/:minBundleId/:bundleId",
-    "appVersionUpdate",
-  );
-  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, "DELETE", "/api/bundles/:id", "deleteBundle");
+  if (updateCheckEnabled) {
+    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 (bundlesEnabled) {
+    addRoute(router, "GET", "/version", "version");
+    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): Promise<Response> => {
+  return async (
+    request: Request,
+    context?: HotUpdaterContext<TContext>,
+  ): Promise<Response> => {
     try {
       const url = new URL(request.url);
       const path = url.pathname;
@@ -217,7 +429,7 @@ export function createHandler(
       }
 
       // Get handler and execute
-      const handler = routes[match.data as string];
+      const handler = routes[match.data as string] as RouteHandler<TContext>;
       if (!handler) {
         return new Response(JSON.stringify({ error: "Handler not found" }), {
           status: 500,
@@ -225,8 +437,15 @@ export function createHandler(
         });
       }
 
-      return await handler(match.params || {}, request, api);
+      return await handler(match.params || {}, request, api, context);
     } catch (error) {
+      if (error instanceof HandlerBadRequestError) {
+        return new Response(JSON.stringify({ error: error.message }), {
+          status: 400,
+          headers: { "Content-Type": "application/json" },
+        });
+      }
+
       console.error("Hot Updater handler error:", error);
       return new Response(
         JSON.stringify({

package/src/internalRouter.ts

@@ -0,0 +1,104 @@
+interface RouteRecord<T> {
+  data: T;
+  method: string;
+  paramNames: string[];
+  segments: string[];
+}
+
+interface RouteMatch<T> {
+  data: T;
+  params: Record<string, string>;
+}
+
+interface Router<T> {
+  routes: RouteRecord<T>[];
+}
+
+const normalizePath = (path: string) => {
+  if (!path) {
+    return "/";
+  }
+
+  if (path === "/") {
+    return path;
+  }
+
+  const withLeadingSlash = path.startsWith("/") ? path : `/${path}`;
+  return withLeadingSlash.endsWith("/")
+    ? withLeadingSlash.slice(0, -1)
+    : withLeadingSlash;
+};
+
+const toSegments = (path: string) => {
+  const normalized = normalizePath(path);
+  return normalized === "/" ? [] : normalized.slice(1).split("/");
+};
+
+export function createRouter<T>(): Router<T> {
+  return { routes: [] };
+}
+
+export function addRoute<T>(
+  router: Router<T>,
+  method: string,
+  path: string,
+  data: T,
+) {
+  const segments = toSegments(path);
+  const paramNames = segments
+    .filter((segment) => segment.startsWith(":"))
+    .map((segment) => segment.slice(1));
+
+  router.routes.push({
+    data,
+    method: method.toUpperCase(),
+    paramNames,
+    segments,
+  });
+}
+
+export function findRoute<T>(
+  router: Router<T>,
+  method: string,
+  path: string,
+): RouteMatch<T> | undefined {
+  const normalizedMethod = method.toUpperCase();
+  const pathSegments = toSegments(path);
+
+  for (const route of router.routes) {
+    if (route.method !== normalizedMethod) {
+      continue;
+    }
+
+    if (route.segments.length !== pathSegments.length) {
+      continue;
+    }
+
+    const params: Record<string, string> = {};
+    let matched = true;
+
+    for (let index = 0; index < route.segments.length; index += 1) {
+      const routeSegment = route.segments[index];
+      const pathSegment = pathSegments[index];
+
+      if (routeSegment.startsWith(":")) {
+        params[routeSegment.slice(1)] = pathSegment;
+        continue;
+      }
+
+      if (routeSegment !== pathSegment) {
+        matched = false;
+        break;
+      }
+    }
+
+    if (matched) {
+      return {
+        data: route.data,
+        params,
+      };
+    }
+  }
+
+  return undefined;
+}

package/src/route.ts

@@ -0,0 +1,7 @@
+export const normalizeBasePath = (basePath?: string) => {
+  if (!basePath || basePath === "/") {
+    return "/";
+  }
+
+  return basePath.endsWith("/") ? basePath.slice(0, -1) : basePath;
+};