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

package/src/insights/queryInput.ts

@@ -1,141 +0,0 @@
-import type {
-  ActiveInstallationWindow,
-  InsightsBundleSelection,
-  InsightsScope,
-} from "./domain";
-import { InsightsBadRequestError } from "./errors";
-import type {
-  InsightsEventPageInput,
-  InsightsUserInstallationPageInput,
-} from "./types";
-
-const MAX_PAGE_LIMIT = 100;
-const MAX_IDENTITY_LENGTH = 255;
-const MAX_CURSOR_LENGTH = 8 * 1_024;
-
-const readSingle = (url: URL, key: string): string | undefined => {
-  const values = url.searchParams.getAll(key);
-  if (values.length > 1) {
-    throw new InsightsBadRequestError(`Duplicate '${key}' query parameter.`);
-  }
-  return values[0];
-};
-
-const readPageLimit = (url: URL): number | undefined => {
-  const value = readSingle(url, "limit");
-  if (value === undefined) return undefined;
-  const limit = Number(value);
-  if (!Number.isSafeInteger(limit) || limit < 1 || limit > MAX_PAGE_LIMIT) {
-    throw new InsightsBadRequestError("Invalid 'limit' query parameter.");
-  }
-  return limit;
-};
-
-const readCursor = (url: URL): string | undefined => {
-  const cursor = readSingle(url, "cursor");
-  if (
-    cursor !== undefined &&
-    (cursor.length === 0 || cursor.length > MAX_CURSOR_LENGTH)
-  ) {
-    throw new InsightsBadRequestError("Invalid 'cursor' query parameter.");
-  }
-  return cursor;
-};
-
-const readId = (
-  url: URL,
-  key: string,
-  maximumLength = MAX_IDENTITY_LENGTH,
-): string => {
-  const value = readSingle(url, key);
-  if (
-    value === undefined ||
-    value.length === 0 ||
-    value.length > maximumLength
-  ) {
-    throw new InsightsBadRequestError(`Invalid '${key}' query parameter.`);
-  }
-  return value;
-};
-
-const readTimestamp = (url: URL, key: string): number | undefined => {
-  const raw = readSingle(url, key);
-  if (raw === undefined) return undefined;
-  const value = Number(raw);
-  if (!raw.length || !Number.isSafeInteger(value) || value < 0) {
-    throw new InsightsBadRequestError(`Invalid '${key}' query parameter.`);
-  }
-  return value;
-};
-
-const readScope = (url: URL): InsightsScope => {
-  const platform = readSingle(url, "platform");
-  if (platform !== "ios" && platform !== "android") {
-    throw new InsightsBadRequestError("Invalid 'platform' query parameter.");
-  }
-  return { platform, channel: readId(url, "channel", 1_024) };
-};
-
-export const parseEventPageInput = (
-  request: Request,
-): InsightsEventPageInput => {
-  const url = new URL(request.url);
-  const bundleFields = ["bundleId", "outcome", "platform", "channel"];
-  let bundle: InsightsBundleSelection | undefined;
-  if (bundleFields.some((key) => url.searchParams.has(key))) {
-    const outcome = readSingle(url, "outcome");
-    if (
-      outcome !== "applied" &&
-      outcome !== "recovered" &&
-      outcome !== "adopted"
-    ) {
-      throw new InsightsBadRequestError("Invalid 'outcome' query parameter.");
-    }
-    bundle = {
-      ...readScope(url),
-      bundleId: readId(url, "bundleId", 1_024),
-      outcome,
-    };
-  }
-  return {
-    beforeReceivedAtMs: readTimestamp(url, "beforeReceivedAtMs"),
-    sinceMs: readTimestamp(url, "sinceMs"),
-    cursor: readCursor(url),
-    limit: readPageLimit(url),
-    ...(bundle === undefined ? {} : { bundle }),
-  };
-};
-
-export const parseUserInstallationPageInput = (
-  request: Request,
-): InsightsUserInstallationPageInput => {
-  const url = new URL(request.url);
-  const cursor = readCursor(url);
-  const limit = readPageLimit(url);
-  return {
-    userId: readId(url, "userId"),
-    ...(cursor === undefined ? {} : { cursor }),
-    ...(limit === undefined ? {} : { limit }),
-  };
-};
-
-export const parseReportingOverviewInput = (
-  request: Request,
-): InsightsScope & {
-  readonly window: ActiveInstallationWindow;
-  readonly bundleId?: string;
-} => {
-  const url = new URL(request.url);
-  const window = readSingle(url, "window") ?? "30d";
-  if (window !== "24h" && window !== "7d" && window !== "30d") {
-    throw new InsightsBadRequestError("Invalid 'window' query parameter.");
-  }
-  const bundleId = readSingle(url, "bundleId");
-  return {
-    ...readScope(url),
-    window,
-    ...(bundleId === undefined
-      ? {}
-      : { bundleId: readId(url, "bundleId", 1_024) }),
-  };
-};

package/src/insights/routes.ts

@@ -1,104 +0,0 @@
-import type { RouteHandler } from "../handlerTypes";
-import {
-  InsightsBadRequestError,
-  InsightsPayloadTooLargeError,
-} from "./errors";
-import { parseBundleEventRequest } from "./eventInput";
-import {
-  parseReportingOverviewInput,
-  parseEventPageInput,
-  parseUserInstallationPageInput,
-} from "./queryInput";
-import type { InsightsProvider } from "./types";
-
-const json = (body: unknown, status: number): Response =>
-  Response.json(body, {
-    headers: { "cache-control": "private, no-store" },
-    status,
-  });
-
-const requireParam = (
-  params: Readonly<Record<string, string>>,
-  key: string,
-): string => {
-  const value = params[key];
-  if (value === undefined || value.length === 0) {
-    throw new InsightsBadRequestError(`Missing route parameter: ${key}`);
-  }
-  try {
-    return decodeURIComponent(value);
-  } catch {
-    throw new InsightsBadRequestError(`Invalid route parameter: ${key}`);
-  }
-};
-
-const run = async (operation: () => Promise<Response>): Promise<Response> => {
-  try {
-    return await operation();
-  } catch (error) {
-    if (error instanceof InsightsBadRequestError) {
-      return json({ error: error.message }, 400);
-    }
-    if (error instanceof InsightsPayloadTooLargeError) {
-      return json({ error: error.message }, 413);
-    }
-    throw error;
-  }
-};
-
-const query = (operation: () => Promise<unknown>): Promise<Response> =>
-  run(async () => json(await operation(), 200));
-
-export const createInsightsRouteHandlers = (
-  provider: InsightsProvider,
-): Record<string, RouteHandler> => ({
-  appendBundleEvent: async (_params, request) =>
-    run(async () => {
-      await provider.appendBundleEvent(await parseBundleEventRequest(request));
-      return new Response(null, { status: 204 });
-    }),
-  getReportingOverview: (_params, request) =>
-    query(() =>
-      provider.getReportingOverview(parseReportingOverviewInput(request)),
-    ),
-  getInstallation: (params) =>
-    run(async () => {
-      const installation = await provider.getInstallation({
-        installId: requireParam(params, "installId"),
-      });
-      return installation === null
-        ? json({ error: "Installation not found" }, 404)
-        : json(installation, 200);
-    }),
-  listEvents: (_params, request) =>
-    query(() => provider.listEvents(parseEventPageInput(request))),
-  listInstallationEvents: (params, request) =>
-    query(() =>
-      provider.listInstallationEvents({
-        ...parseEventPageInput(request),
-        installId: requireParam(params, "installId"),
-      }),
-    ),
-  pageInstallationsByCurrentUserId: (_params, request) =>
-    query(() =>
-      provider.pageInstallationsByCurrentUserId(
-        parseUserInstallationPageInput(request),
-      ),
-    ),
-});
-
-export const registerInsightsClientRoutes = (
-  add: (method: string, path: string, handler: string) => void,
-): void => {
-  add("POST", "/events", "appendBundleEvent");
-};
-
-export const registerInsightsAdminRoutes = (
-  add: (method: string, path: string, handler: string) => void,
-): void => {
-  add("GET", "/events", "listEvents");
-  add("GET", "/overview", "getReportingOverview");
-  add("GET", "/installations", "pageInstallationsByCurrentUserId");
-  add("GET", "/installations/:installId/events", "listInstallationEvents");
-  add("GET", "/installations/:installId", "getInstallation");
-};

package/src/insights/types.ts

@@ -1,55 +0,0 @@
-import type {
-  ReportingOverview,
-  InsightsBundleSelection,
-  InsightsScope,
-  ActiveInstallationWindow,
-  CreateBundleEventRequest,
-  CursorPage,
-  EventCursorPage,
-  EventHistoryRow,
-  InstallationHistoryRow,
-  InstallationRow,
-} from "./domain";
-
-export type InsightsEventPageInput = {
-  readonly beforeReceivedAtMs?: number;
-  readonly sinceMs?: number;
-  readonly bundle?: InsightsBundleSelection;
-  readonly cursor?: string;
-  readonly limit?: number;
-};
-
-export type InsightsInstallationEventPageInput = Omit<
-  InsightsEventPageInput,
-  "bundle"
-> & {
-  readonly installId: string;
-};
-
-export type InsightsUserInstallationPageInput = {
-  readonly userId: string;
-  readonly cursor?: string;
-  readonly limit?: number;
-};
-
-export type InsightsProvider = {
-  appendBundleEvent(input: CreateBundleEventRequest): Promise<void>;
-  listEvents(
-    input: InsightsEventPageInput,
-  ): Promise<EventCursorPage<EventHistoryRow>>;
-  listInstallationEvents(
-    input: InsightsInstallationEventPageInput,
-  ): Promise<EventCursorPage<InstallationHistoryRow>>;
-  getInstallation(input: {
-    readonly installId: string;
-  }): Promise<InstallationRow | null>;
-  pageInstallationsByCurrentUserId(
-    input: InsightsUserInstallationPageInput,
-  ): Promise<CursorPage<InstallationRow>>;
-  getReportingOverview(
-    input: InsightsScope & {
-      readonly window: ActiveInstallationWindow;
-      readonly bundleId?: string;
-    },
-  ): Promise<ReportingOverview>;
-};

package/src/internalRouter.ts

@@ -1,104 +0,0 @@
-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/node.spec.ts

@@ -1,119 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { toNodeHandler } from "./node";
-
-describe("server node entry", () => {
-  it("converts a Web Request handler to Node middleware", async () => {
-    const middleware = toNodeHandler(async (request: Request) =>
-      Response.json({
-        method: request.method,
-        pathname: new URL(request.url).pathname,
-      }),
-    );
-    const headers = new Map<string, string | string[]>();
-    const response = {
-      body: "",
-      statusCode: 0,
-      status(code: number) {
-        this.statusCode = code;
-        return this;
-      },
-      setHeader(name: string, value: string | string[]) {
-        headers.set(name, value);
-      },
-      send(body: Uint8Array) {
-        this.body = new TextDecoder().decode(body);
-      },
-      end() {},
-    };
-
-    await middleware(
-      {
-        method: "GET",
-        url: "/api/check",
-        headers: { host: "example.com" },
-        protocol: "https",
-        get: (name: string) => (name === "host" ? "example.com" : undefined),
-      },
-      response,
-    );
-
-    expect(response.statusCode).toBe(200);
-    expect(headers.get("content-type")).toContain("application/json");
-    expect(JSON.parse(response.body)).toEqual({
-      method: "GET",
-      pathname: "/api/check",
-    });
-  });
-
-  it("uses the mount-relative URL supplied by Express", async () => {
-    const middleware = toNodeHandler(async (request: Request) =>
-      Response.json({ pathname: new URL(request.url).pathname }),
-    );
-    const response = {
-      body: "",
-      statusCode: 0,
-      status(code: number) {
-        this.statusCode = code;
-        return this;
-      },
-      setHeader() {},
-      send(body: Uint8Array) {
-        this.body = new TextDecoder().decode(body);
-      },
-      end() {},
-    };
-
-    await middleware(
-      {
-        method: "GET",
-        url: "/channels",
-        headers: { host: "example.com" },
-        protocol: "https",
-        get: (name: string) => (name === "host" ? "example.com" : undefined),
-      },
-      response,
-    );
-
-    expect(JSON.parse(response.body)).toEqual({
-      pathname: "/channels",
-    });
-  });
-
-  it("preserves binary response bytes", async () => {
-    const bytes = new Uint8Array([0x50, 0x4b, 0x03, 0x04, 0xff, 0xfe, 0x00]);
-    const middleware = toNodeHandler(
-      async () =>
-        new Response(bytes, {
-          headers: { "content-type": "application/zip" },
-        }),
-    );
-    const response = {
-      body: new Uint8Array(),
-      statusCode: 0,
-      status(code: number) {
-        this.statusCode = code;
-        return this;
-      },
-      setHeader() {},
-      send(body: Uint8Array) {
-        this.body = new Uint8Array(body);
-      },
-      end() {},
-    };
-
-    await middleware(
-      {
-        method: "GET",
-        url: "/hot-updater/storage/token/signature",
-        headers: { host: "example.com" },
-        protocol: "https",
-        get: (name: string) => (name === "host" ? "example.com" : undefined),
-      },
-      response,
-    );
-
-    expect(response.statusCode).toBe(200);
-    expect([...response.body]).toEqual([...bytes]);
-  });
-});

package/src/node.ts

@@ -1,111 +0,0 @@
-/**
- * Node.js request/response types (compatible with Express, Connect, etc.)
- */
-interface NodeRequest {
-  method?: string;
-  url?: string;
-  headers: Record<string, string | string[] | undefined>;
-  body?: unknown;
-  protocol?: string;
-  get?(name: string): string | undefined;
-  [key: string]: unknown;
-}
-
-interface NodeResponse {
-  status(code: number): NodeResponse;
-  setHeader(name: string, value: string | string[]): void;
-  send(body: string | Uint8Array): void;
-  end(): void;
-  [key: string]: unknown;
-}
-
-export { HOT_UPDATER_SERVER_VERSION } from "./version";
-export { HOT_UPDATER_INFRASTRUCTURE_GENERATION } from "./handlerVersionRoutes";
-
-/**
- * Converts a Hot Updater handler to a Node.js-compatible middleware
- * Works with Express, Connect, and other frameworks using Node.js req/res
- *
- * @example
- * ```typescript
- * import { toNodeHandler } from "@hot-updater/server/node";
- * import express from "express";
- *
- * const app = express();
- *
- * app.use(
- *   "/hot-updater/admin",
- *   bearerMiddleware,
- *   express.json({ limit: "1mb" }),
- *   toNodeHandler(hotUpdater.handlers.admin),
- * );
- * app.use(
- *   "/hot-updater",
- *   express.json({ limit: "1mb" }),
- *   toNodeHandler(hotUpdater.handlers.client),
- * );
- * ```
- */
-export function toNodeHandler(
-  handler: HotUpdaterHandler,
-): (req: any, res: any, next?: any) => Promise<void> {
-  return async (req: NodeRequest, res: NodeResponse) => {
-    try {
-      // Build full URL
-      const protocol = req.protocol || "http";
-      const host = req.get?.("host") || "localhost";
-      const url = `${protocol}://${host}${req.url ?? "/"}`;
-
-      // Convert headers to Web Headers
-      const headers = new Headers();
-      for (const [key, value] of Object.entries(req.headers)) {
-        if (value) {
-          headers.set(key, Array.isArray(value) ? value.join(", ") : value);
-        }
-      }
-
-      // Handle request body
-      let body: string | undefined;
-      if (
-        req.method &&
-        req.method !== "GET" &&
-        req.method !== "HEAD" &&
-        req.body
-      ) {
-        // If body is already parsed (by express.json()), stringify it
-        body = JSON.stringify(req.body);
-      }
-
-      // Create Web Request
-      const webRequest = new globalThis.Request(url, {
-        method: req.method || "GET",
-        headers,
-        body,
-      });
-
-      const response = await handler(webRequest);
-
-      // Set status code
-      res.status(response.status);
-
-      // Set headers
-      response.headers.forEach((value, key) => {
-        res.setHeader(key, value);
-      });
-
-      // Send response body
-      const responseBody = Buffer.from(await response.arrayBuffer());
-      if (responseBody.length > 0) {
-        res.send(responseBody);
-      } else {
-        res.end();
-      }
-    } catch (error) {
-      // Handle errors gracefully
-      console.error("Hot Updater handler error:", error);
-      res.status(500);
-      res.send("Internal Server Error");
-    }
-  };
-}
-import type { HotUpdaterHandler } from "./handlerTypes";