@hot-updater/server 1.0.0-rc.14 → 1.0.0-rc.16

package/src/insights/provider.spec.ts

@@ -7,6 +7,16 @@ import { createInsightsProvider } from "./provider";
 const eventId = (index: number) =>
   `00000000-0000-7000-8000-${String(index).padStart(12, "0")}`;
 
+const HOUR = 3_600_000;
+const DAY = 86_400_000;
+const cutoff = Date.UTC(2026, 8, 20, 9, 30);
+const bundle = {
+  platform: "ios",
+  channel: "production",
+  bundleId: "bundle-after",
+  outcome: "applied",
+} as const;
+
 type TransitionEventRow = Extract<
   BundleEventRow,
   { readonly type: "UPDATE_APPLIED" | "RECOVERED" }
@@ -67,6 +77,23 @@ const createModel = () => {
     findLatestEvents: vi.fn<InsightsModel["findLatestEvents"]>(async () => []),
     countLatestEvents: vi.fn<InsightsModel["countLatestEvents"]>(async () => 0),
     countEvents: vi.fn<InsightsModel["countEvents"]>(async () => 0),
+    getReleaseActivity: vi.fn<InsightsModel["getReleaseActivity"]>(
+      async () => ({
+        coverage: { kind: "complete", sinceMs: 0 },
+        data: [],
+        measuredAtMs: 0,
+      }),
+    ),
+    getAppUsage: vi.fn<InsightsModel["getAppUsage"]>(async () => ({
+      coverage: { kind: "complete", sinceMs: 0 },
+      activeInstallations: 0,
+      points: [],
+      appVersions: [],
+      versions: [],
+      platforms: [],
+      bundleDistribution: [],
+      measuredAtMs: 0,
+    })),
   } satisfies InsightsModel;
   return { ...model, model };
 };
@@ -84,7 +111,6 @@ describe("createInsightsProvider", () => {
       .mockResolvedValueOnce([
         eventRow(eventId(3), 999),
         eventRow(eventId(2), 900),
-        eventRow(eventId(1), 800),
       ])
       .mockResolvedValueOnce([eventRow(eventId(1), 800)]);
     const provider = createInsightsProvider(fixture.model);
@@ -96,7 +122,7 @@ describe("createInsightsProvider", () => {
     expect(first.nextCursor).not.toBeNull();
     expect(fixture.listEvents).toHaveBeenNthCalledWith(1, {
       beforeReceivedAtMs: 1_000,
-      limit: 3,
+      limit: 2,
       sinceMs: 0,
       filter: { kind: "all" },
     });
@@ -111,20 +137,160 @@ describe("createInsightsProvider", () => {
     expect(fixture.listEvents).toHaveBeenNthCalledWith(2, {
       after: { id: eventId(2), receivedAtMs: 900 },
       beforeReceivedAtMs: 1_000,
-      limit: 3,
+      limit: 2,
       sinceMs: 0,
       filter: { kind: "all" },
     });
   });
 
-  it("binds event cursors to their filter", async () => {
+  it("reads only `limit` rows, so a full last page is followed by an empty one", async () => {
     vi.useFakeTimers();
     vi.setSystemTime(1_000);
     const fixture = createModel();
-    fixture.listEvents.mockResolvedValue([
-      eventRow(eventId(2), 900),
-      eventRow(eventId(1), 800),
+    fixture.listEvents
+      .mockResolvedValueOnce([
+        eventRow(eventId(2), 900),
+        eventRow(eventId(1), 800),
+      ])
+      .mockResolvedValueOnce([]);
+    const provider = createInsightsProvider(fixture.model);
+
+    const first = await provider.listEvents({ limit: 2 });
+    const second = await provider.listEvents({
+      cursor: first.nextCursor ?? undefined,
+      limit: 2,
+    });
+
+    expect(first.nextCursor).not.toBeNull();
+    expect(second).toMatchObject({ data: [], nextCursor: null });
+    expect(fixture.listEvents.mock.calls.map(([input]) => input.limit)).toEqual(
+      [2, 2],
+    );
+  });
+
+  it("lists the 90 days before the cutoff without a start, and all of an installation's history", async () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(cutoff);
+    const fixture = createModel();
+    const provider = createInsightsProvider(fixture.model);
+
+    await provider.listEvents({});
+    await provider.listEvents({ beforeReceivedAtMs: cutoff - DAY, bundle });
+    await provider.listInstallationEvents({ installId: "install-1" });
+
+    expect(
+      fixture.listEvents.mock.calls.map(([input]) => [
+        input.sinceMs,
+        input.beforeReceivedAtMs,
+      ]),
+    ).toEqual([
+      [cutoff - 90 * DAY, cutoff],
+      [cutoff - 91 * DAY, cutoff - DAY],
+      [0, cutoff],
     ]);
+  });
+
+  it("answers 400 for a global or bundle range over 90 days, before the database", async () => {
+    const fixture = createModel();
+    const provider = createInsightsProvider(fixture.model);
+    const range = { beforeReceivedAtMs: cutoff, sinceMs: cutoff - 90 * DAY };
+
+    for (const input of [{}, { bundle }]) {
+      await expect(
+        provider.listEvents({ ...input, ...range, sinceMs: range.sinceMs - 1 }),
+      ).rejects.toThrow(
+        new InsightsBadRequestError(
+          "Insights event lists cover at most 90 days: send a sinceMs no more than 90 days before beforeReceivedAtMs.",
+        ),
+      );
+      await provider.listEvents({ ...input, ...range });
+    }
+    await provider.listInstallationEvents({
+      installId: "install-1",
+      beforeReceivedAtMs: cutoff,
+      sinceMs: 0,
+    });
+    expect(
+      fixture.listEvents.mock.calls.map(([input]) => input.sinceMs),
+    ).toEqual([range.sinceMs, range.sinceMs, 0]);
+  });
+
+  it("returns a cursor only after a full page, and keeps the first page's range", async () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(cutoff);
+    const fixture = createModel();
+    fixture.listEvents
+      .mockResolvedValueOnce([
+        eventRow(eventId(3), cutoff - HOUR),
+        eventRow(eventId(2), cutoff - 30 * DAY),
+      ])
+      .mockResolvedValueOnce([eventRow(eventId(1), cutoff - 60 * DAY)]);
+    const provider = createInsightsProvider(fixture.model);
+
+    const first = await provider.listEvents({ limit: 2 });
+    // Days later, the next page still reads the first page's range.
+    vi.setSystemTime(cutoff + 3 * DAY);
+    const second = await provider.listEvents({
+      cursor: first.nextCursor ?? undefined,
+      limit: 2,
+    });
+
+    expect(
+      JSON.parse(Buffer.from(first.nextCursor!, "base64url").toString("utf8")),
+    ).toEqual({
+      after: { id: eventId(2), receivedAtMs: cutoff - 30 * DAY },
+      beforeReceivedAtMs: cutoff,
+      sinceMs: cutoff - 90 * DAY,
+      kind: "events",
+      filter: { kind: "all" },
+      version: 2,
+    });
+    expect(second).toMatchObject({
+      beforeReceivedAtMs: cutoff,
+      nextCursor: null,
+    });
+    expect(fixture.listEvents).toHaveBeenLastCalledWith({
+      after: { id: eventId(2), receivedAtMs: cutoff - 30 * DAY },
+      beforeReceivedAtMs: cutoff,
+      sinceMs: cutoff - 90 * DAY,
+      filter: { kind: "all" },
+      limit: 2,
+    });
+    // A short page and an empty one end the list.
+    await expect(provider.listEvents({ limit: 2 })).resolves.toMatchObject({
+      data: [],
+      nextCursor: null,
+    });
+  });
+
+  it("rejects the cursors that continued below a window of days", async () => {
+    const fixture = createModel();
+    const provider = createInsightsProvider(fixture.model);
+    const window = {
+      beforeReceivedAtMs: cutoff,
+      kind: "events",
+      filter: { kind: "all" },
+      version: 2,
+    };
+    for (const position of [
+      { olderThanMs: cutoff - 90 * DAY, sinceMs: cutoff - 150 * DAY },
+      { olderThanMs: cutoff - 10 * DAY, sinceMs: cutoff - 30 * DAY },
+    ]) {
+      const cursor = Buffer.from(
+        JSON.stringify({ ...window, ...position }),
+      ).toString("base64url");
+      await expect(provider.listEvents({ cursor })).rejects.toThrow(
+        new InsightsBadRequestError("Invalid Insights cursor."),
+      );
+    }
+    expect(fixture.listEvents).not.toHaveBeenCalled();
+  });
+
+  it("binds event cursors to their filter", async () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(1_000);
+    const fixture = createModel();
+    fixture.listEvents.mockResolvedValue([eventRow(eventId(2), 900)]);
     const provider = createInsightsProvider(fixture.model);
     const allEvents = await provider.listEvents({ limit: 1 });
 
@@ -181,7 +347,7 @@ describe("createInsightsProvider", () => {
     ]);
     expect(fixture.listEvents).toHaveBeenCalledWith({
       beforeReceivedAtMs: 1_000,
-      limit: 11,
+      limit: 10,
       sinceMs: 0,
       filter: { kind: "installationMovement", installId: "install-2" },
     });
@@ -192,7 +358,6 @@ describe("createInsightsProvider", () => {
     fixture.findLatestEvents.mockResolvedValue([
       installationRow("install-a"),
       installationRow("install-b"),
-      installationRow("install-c"),
     ]);
     const provider = createInsightsProvider(fixture.model);
 
@@ -206,7 +371,7 @@ describe("createInsightsProvider", () => {
       "install-b",
     ]);
     expect(fixture.findLatestEvents).toHaveBeenCalledWith({
-      limit: 3,
+      limit: 2,
       userId: "user-1",
     });
     await expect(
@@ -243,6 +408,31 @@ describe("createInsightsProvider", () => {
     expect(fixture.countEvents).not.toHaveBeenCalled();
   });
 
+  it("counts whole hours that end with the current one", async () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date("2026-08-12T10:25:00.000Z"));
+    const fixture = createModel();
+    fixture.countLatestEvents.mockResolvedValue(4);
+    const provider = createInsightsProvider(fixture.model);
+
+    const overview = await provider.getReportingOverview({
+      window: "24h",
+      platform: "ios",
+      channel: "production",
+    });
+
+    const end = Date.parse("2026-08-12T11:00:00.000Z");
+    expect(overview).toMatchObject({
+      beforeReceivedAtMs: end,
+      sinceMs: end - 24 * 60 * 60 * 1_000,
+    });
+    expect(fixture.countLatestEvents).toHaveBeenCalledWith({
+      platform: "ios",
+      channel: "production",
+      sinceMs: end - 24 * 60 * 60 * 1_000,
+    });
+  });
+
   it("attributes recovery to the source bundle and reuses its count predicate for drill-down", async () => {
     vi.useFakeTimers();
     vi.setSystemTime(new Date("2026-08-12T00:00:00.000Z"));
@@ -297,23 +487,14 @@ describe("createInsightsProvider", () => {
     expect(fixture.listEvents).toHaveBeenCalledWith({
       ...counted,
       filter: { kind: "bundle", ...counted.filter },
-      limit: 51,
+      limit: 50,
     });
   });
 
   it("binds bundle cursors to the outcome, scope, bundle, and both time bounds", async () => {
     const fixture = createModel();
-    fixture.listEvents.mockResolvedValue([
-      eventRow(eventId(2), 900),
-      eventRow(eventId(1), 800),
-    ]);
+    fixture.listEvents.mockResolvedValue([eventRow(eventId(2), 900)]);
     const provider = createInsightsProvider(fixture.model);
-    const bundle = {
-      platform: "ios",
-      channel: "production",
-      bundleId: "bundle-after",
-      outcome: "applied",
-    } as const;
     const first = await provider.listEvents({
       bundle,
       sinceMs: 100,
@@ -337,10 +518,7 @@ describe("createInsightsProvider", () => {
 
   it("rejects forged event keys before they reach the database boundary", async () => {
     const fixture = createModel();
-    fixture.listEvents.mockResolvedValue([
-      eventRow(eventId(2), 900),
-      eventRow(eventId(1), 800),
-    ]);
+    fixture.listEvents.mockResolvedValue([eventRow(eventId(2), 900)]);
     const provider = createInsightsProvider(fixture.model);
     const first = await provider.listEvents({
       sinceMs: 100,

package/src/insights/provider.ts

@@ -32,12 +32,24 @@ const MAX_EVENT_ID_LENGTH = 1_024;
 const MAX_IDENTITY_LENGTH = 255;
 const MAX_CURSOR_LENGTH = 8 * 1_024;
 
+const HOUR_MS = 60 * 60 * 1_000;
+
 const WINDOW_MS: Record<ActiveInstallationWindow, number> = {
   "24h": 24 * 60 * 60 * 1_000,
   "7d": 7 * 24 * 60 * 60 * 1_000,
   "30d": 30 * 24 * 60 * 60 * 1_000,
 };
 
+/**
+ * The longest receipt range, `[sinceMs, beforeReceivedAtMs)`, of a global or
+ * bundle event list, and the range one covers without `sinceMs`: raw events
+ * are listed inside a time range, as analytics products list them. It is a
+ * duration, so a range that ends mid-day touches 91 UTC days. Installation
+ * history is one index range and reads back to `sinceMs`.
+ */
+export const EVENT_LIST_RANGE_MS = 90 * 24 * HOUR_MS;
+
+/** A full page's last row, and the range every page of the list shares. */
 type EventCursorPayload = {
   readonly after: InsightsEventCursor;
   readonly beforeReceivedAtMs: number;
@@ -188,6 +200,8 @@ const readEventCursor = (
   filter: InsightsEventFilter,
 ): EventCursorPayload => {
   const cursor = decodeCursor(value);
+  // A cursor names the row it continues after. One that only held a time
+  // (`olderThanMs`) resumed below a window of days, which lists no longer do.
   if (
     !isRecord(cursor) ||
     cursor.version !== 2 ||
@@ -335,17 +349,34 @@ const toInstallationRow = (row: BundleEventRow): InstallationRow => ({
   username: row.metadata.username,
 });
 
-const pageEventRows = async <T extends EventHistoryRow>(
-  model: InsightsModel,
+interface EventBounds {
+  readonly beforeReceivedAtMs: number;
+  readonly sinceMs: number;
+}
+
+/**
+ * Where a list without `sinceMs` starts: 90 days before its cutoff for the
+ * global and bundle lists, at the first event for installation history.
+ */
+const defaultEventStart = (
+  filter: InsightsEventFilter,
+  beforeReceivedAtMs: number,
+): number =>
+  filter.kind === "installationMovement"
+    ? 0
+    : Math.max(0, beforeReceivedAtMs - EVENT_LIST_RANGE_MS);
+
+/** Whether a cursor's row lies inside the list's range. */
+const isInsideBounds = ({ after }: EventCursorPayload, bounds: EventBounds) =>
+  after.receivedAtMs >= bounds.sinceMs &&
+  after.receivedAtMs < bounds.beforeReceivedAtMs;
+
+/** A page's range: its cursor's, which the request may repeat but not change. */
+const readEventBounds = (
   input: InsightsEventPageInput,
+  cursor: EventCursorPayload | undefined,
   filter: InsightsEventFilter,
-  map: (row: BundleEventRow) => T,
-) => {
-  const limit = readLimit(input.limit);
-  const cursor =
-    input.cursor === undefined
-      ? undefined
-      : readEventCursor(input.cursor, filter);
+): EventBounds => {
   const beforeReceivedAtMs =
     cursor?.beforeReceivedAtMs ??
     (input.beforeReceivedAtMs === undefined
@@ -363,41 +394,63 @@ const pageEventRows = async <T extends EventHistoryRow>(
   const sinceMs =
     cursor?.sinceMs ??
     (input.sinceMs === undefined
-      ? 0
+      ? defaultEventStart(filter, beforeReceivedAtMs)
       : requireTimestamp(input.sinceMs, "event start"));
+  const bounds = { beforeReceivedAtMs, sinceMs };
   if (
     sinceMs > beforeReceivedAtMs ||
     (input.sinceMs !== undefined && input.sinceMs !== sinceMs) ||
-    (cursor !== undefined &&
-      (cursor.after.receivedAtMs < sinceMs ||
-        cursor.after.receivedAtMs >= beforeReceivedAtMs))
+    (cursor !== undefined && !isInsideBounds(cursor, bounds))
   ) {
     throw new InsightsBadRequestError(
       "Insights cursor or range does not match the requested event start.",
     );
   }
-  const databaseInput = {
+  if (
+    filter.kind !== "installationMovement" &&
+    beforeReceivedAtMs - sinceMs > EVENT_LIST_RANGE_MS
+  ) {
+    throw new InsightsBadRequestError(
+      "Insights event lists cover at most 90 days: send a sinceMs no more than 90 days before beforeReceivedAtMs.",
+    );
+  }
+  return bounds;
+};
+
+const pageEventRows = async <T extends EventHistoryRow>(
+  model: InsightsModel,
+  input: InsightsEventPageInput,
+  filter: InsightsEventFilter,
+  map: (row: BundleEventRow) => T,
+) => {
+  const limit = readLimit(input.limit);
+  const cursor =
+    input.cursor === undefined
+      ? undefined
+      : readEventCursor(input.cursor, filter);
+  const bounds = readEventBounds(input, cursor, filter);
+  const query = {
     filter,
-    sinceMs,
-    beforeReceivedAtMs,
+    ...bounds,
     ...(cursor === undefined ? {} : { after: cursor.after }),
-    limit: limit + 1,
+    limit,
   };
-  const rows = await model.listEvents(databaseInput);
-  assertEventRows(rows, databaseInput);
-  const pageRows = rows.slice(0, limit);
-  const last = pageRows.at(-1);
+  const rows = await model.listEvents(query);
+  assertEventRows(rows, query);
+  const last = rows.at(-1);
   return {
-    beforeReceivedAtMs,
-    data: pageRows.map(map),
+    beforeReceivedAtMs: bounds.beforeReceivedAtMs,
+    data: rows.map(map),
+    // A short page ends the range, so only a full page carries a cursor,
+    // with the range every page shares: the last call may read an empty
+    // page, and no page ends before the range start while events remain.
     nextCursor:
-      rows.length > limit && last
+      rows.length === limit && last
         ? encodeCursor({
             after: { id: last.id, receivedAtMs: last.received_at_ms },
-            beforeReceivedAtMs,
+            ...bounds,
             kind: "events",
             filter,
-            sinceMs,
             version: 2,
           })
         : null,
@@ -502,16 +555,15 @@ export const createInsightsProvider = (
         ...(cursor === undefined
           ? {}
           : { afterInstallId: cursor.afterInstallId }),
-        limit: limit + 1,
+        limit,
       };
       const rows = await model.findLatestEvents(databaseInput);
       assertInstallationRows(rows, databaseInput);
-      const pageRows = rows.slice(0, limit);
-      const last = pageRows.at(-1);
+      const last = rows.at(-1);
       return {
-        data: pageRows.map(toInstallationRow),
+        data: rows.map(toInstallationRow),
         nextCursor:
-          rows.length > limit && last
+          rows.length === limit && last
             ? encodeCursor({
                 afterInstallId: last.install_id,
                 kind: "user-installations",
@@ -529,7 +581,11 @@ export const createInsightsProvider = (
           "Invalid reporting installation window.",
         );
       }
-      const beforeReceivedAtMs = Date.now();
+      // Whole hours, ending with the current one: the counts read only the
+      // maintained hour and day rows, never raw events.
+      const now = Date.now();
+      const beforeReceivedAtMs =
+        now - (now % HOUR_MS) + (now % HOUR_MS === 0 ? 0 : HOUR_MS);
       const sinceMs = Math.max(0, beforeReceivedAtMs - WINDOW_MS[window]);
       const measure = async (count: Promise<number>) => {
         const value = await count;

package/src/insights/routes.ts

@@ -1,7 +1,7 @@
-import type { RouteHandler } from "../handlerTypes";
 import {
   InsightsBadRequestError,
   InsightsPayloadTooLargeError,
+  isDatabaseBusyError,
 } from "./errors";
 import { parseBundleEventRequest } from "./eventInput";
 import {
@@ -11,9 +11,16 @@ import {
 } from "./queryInput";
 import type { InsightsProvider } from "./types";
 
-const json = (body: unknown, status: number): Response =>
+/** Seconds a client waits before it resends a request the busy database refused. */
+const RETRY_AFTER_SECONDS = 5;
+
+const json = (
+  body: unknown,
+  status: number,
+  headers: Readonly<Record<string, string>> = {},
+): Response =>
   Response.json(body, {
-    headers: { "cache-control": "private, no-store" },
+    headers: { "cache-control": "private, no-store", ...headers },
     status,
   });
 
@@ -42,6 +49,18 @@ const run = async (operation: () => Promise<Response>): Promise<Response> => {
     if (error instanceof InsightsPayloadTooLargeError) {
       return json({ error: error.message }, 413);
     }
+    // Back-pressure: a busy database has not failed the request, so the
+    // client may send it again after Retry-After. A 500 would read as a fault.
+    // The warning keeps the overload visible to whoever runs the server.
+    if (isDatabaseBusyError(error)) {
+      console.warn(
+        "[hot-updater] Insights answered 503: the database is busy.",
+        error,
+      );
+      return json({ error: "Service unavailable" }, 503, {
+        "retry-after": String(RETRY_AFTER_SECONDS),
+      });
+    }
     throw error;
   }
 };
@@ -49,9 +68,81 @@ const run = async (operation: () => Promise<Response>): Promise<Response> => {
 const query = (operation: () => Promise<unknown>): Promise<Response> =>
   run(async () => json(await operation(), 200));
 
+/** Every Insights route: where it mounts, and the handler it runs. */
+export const INSIGHTS_ROUTES = [
+  {
+    access: "client",
+    method: "POST",
+    path: "/events",
+    handler: "appendBundleEvent",
+  },
+  { access: "admin", method: "GET", path: "/events", handler: "listEvents" },
+  {
+    access: "admin",
+    method: "GET",
+    path: "/overview",
+    handler: "getReportingOverview",
+  },
+  {
+    access: "admin",
+    method: "GET",
+    path: "/installations",
+    handler: "pageInstallationsByCurrentUserId",
+  },
+  {
+    access: "admin",
+    method: "GET",
+    path: "/installations/:installId/events",
+    handler: "listInstallationEvents",
+  },
+  {
+    access: "admin",
+    method: "GET",
+    path: "/installations/:installId",
+    handler: "getInstallation",
+  },
+] as const;
+
+export type InsightsRouteName = (typeof INSIGHTS_ROUTES)[number]["handler"];
+
+export type InsightsRouteHandler = (
+  params: Readonly<Record<string, string>>,
+  request: Request,
+) => Promise<Response>;
+
+/** Without the insights plugin, its routes answer 204 and say Insights is off. */
+export const insightsDisabled: InsightsRouteHandler = async () =>
+  new Response(null, {
+    headers: {
+      "cache-control": "private, no-store",
+      "x-hot-updater-insights": "disabled",
+    },
+    status: 204,
+  });
+
+/** What a server without the insights plugin logs on the first event it drops. */
+export const INSIGHTS_OFF_WARNING =
+  "[hot-updater] Insights is off, so POST /events answered 204 and stored nothing. Add insights() from @hot-updater/server/plugins/insights to plugins to record app events, or set insights: false in the app's HotUpdater.init to stop sending them. This warning prints once per server.";
+
+/**
+ * The client's `POST /events` without the insights plugin. It answers as
+ * {@link insightsDisabled} does, so apps need no change, and warns on the
+ * first event it drops, so a server that left out `insights()` says so.
+ */
+export const createDroppedEventHandler = (): InsightsRouteHandler => {
+  let warned = false;
+  return (params, request) => {
+    if (!warned) {
+      warned = true;
+      console.warn(INSIGHTS_OFF_WARNING);
+    }
+    return insightsDisabled(params, request);
+  };
+};
+
 export const createInsightsRouteHandlers = (
   provider: InsightsProvider,
-): Record<string, RouteHandler> => ({
+): Record<InsightsRouteName, InsightsRouteHandler> => ({
   appendBundleEvent: async (_params, request) =>
     run(async () => {
       await provider.appendBundleEvent(await parseBundleEventRequest(request));
@@ -86,19 +177,3 @@ export const createInsightsRouteHandlers = (
       ),
     ),
 });
-
-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");
-};