@hot-updater/console 1.0.0-rc.8 → 1.0.0

package/src/lib/server/downloadBundle.ts

@@ -1,34 +1,33 @@
 import type {
-  DatabaseClient,
-  StoragePluginWith,
+  HotUpdaterCoreApi,
+  StorageAdapter,
 } from "@hot-updater/plugin-core";
 
 interface DownloadBundleDependencies {
-  readonly databaseClient: DatabaseClient;
-  readonly storagePlugin?: StoragePluginWith<"get">;
+  readonly core: Pick<HotUpdaterCoreApi, "getBundle">;
+  /** The server's storage, which reads the manifest of its protocol. */
+  readonly storage: StorageAdapter;
 }
 
 export const downloadBundle = async (
   bundleId: string,
-  { databaseClient, storagePlugin }: DownloadBundleDependencies,
+  { core, storage }: DownloadBundleDependencies,
 ): Promise<Response> => {
-  const bundle = await databaseClient.getBundleById(bundleId);
-  if (!bundle) return new Response("Bundle not found", { status: 404 });
+  const detail = await core.getBundle(bundleId);
+  if (!detail) return new Response("Bundle not found", { status: 404 });
 
-  const storageUri = bundle.storageUri;
-  if (!storageUri) {
-    return new Response("Bundle has no storage URI", { status: 404 });
-  }
+  const storageUri = detail.bundle.manifest_storage_uri;
 
   const protocol = new URL(storageUri).protocol.replace(":", "");
-  if (storagePlugin?.protocol === protocol) {
-    const { response } = await storagePlugin.get({ storageUri });
+  const storageAdapter = storage.protocol === protocol ? storage : undefined;
+  if (storageAdapter?.get !== undefined) {
+    const { response } = await storageAdapter.get({ storageUri });
     if (!response)
       return new Response("Storage object not found", { status: 404 });
 
     const headers = new Headers(response.headers);
     headers.set("cache-control", "private, no-store");
-    headers.set("content-disposition", "attachment");
+    headers.set("content-disposition", 'attachment; filename="manifest.json"');
     return new Response(response.body, {
       headers,
       status: response.status,
@@ -37,7 +36,7 @@ export const downloadBundle = async (
   }
 
   if (protocol !== "http" && protocol !== "https") {
-    return new Response(`No storage plugin for protocol: ${protocol}`, {
+    return new Response(`No storage adapter for protocol: ${protocol}`, {
       status: 503,
     });
   }

package/src/lib/server/failureReports.ts

@@ -0,0 +1,50 @@
+import type { InsightsReads } from "@hot-updater/server/plugins";
+
+import type {
+  FailureReportsInput,
+  FailureReportsPage,
+} from "../insights-errors";
+import { readFailureReportsInput } from "../insights-errors";
+import { recoveryWindows } from "../insights-recovery";
+import type { InsightsEventRow } from "../insights-view";
+
+/** Bounded raw-event reads, with continuation even when a batch finds no failures. */
+export async function listFailureReports(
+  reads: Pick<InsightsReads, "listEvents" | "getRetention">,
+  input: FailureReportsInput,
+): Promise<FailureReportsPage> {
+  readFailureReportsInput(input);
+  const { rawDays } = await reads.getRetention();
+  const duration = Math.min(
+    90 * 86_400_000,
+    rawDays * 86_400_000,
+    input.window ? recoveryWindows[input.window].durationMs : Infinity,
+  );
+  const sinceMs = Math.max(0, input.beforeReceivedAtMs - duration);
+  const data: InsightsEventRow[] = [];
+  let cursor = input.cursor;
+  let scanned = 0;
+  for (let batch = 0; batch < 5; batch += 1) {
+    const page = await reads.listEvents({
+      sinceMs,
+      beforeReceivedAtMs: input.beforeReceivedAtMs,
+      limit: 100,
+      ...(cursor === undefined ? {} : { cursor }),
+    });
+    scanned += page.data.length;
+    data.push(
+      ...page.data.filter(
+        (event) =>
+          event.type === "UPDATE_FAILED" &&
+          event.platform === input.platform &&
+          event.channel === input.channel &&
+          (input.releaseId === undefined ||
+            (event.failure?.stage !== "check" &&
+              event.toReleaseId === input.releaseId)),
+      ),
+    );
+    cursor = page.nextCursor ?? undefined;
+    if (!cursor || data.length >= 50) break;
+  }
+  return { data, scanned, sinceMs, nextCursor: cursor ?? null };
+}

package/src/lib/server/getBundleChildren.ts

@@ -1,130 +1,39 @@
-import { getBundlePatches } from "@hot-updater/core";
-import type { Bundle, DatabaseClient } from "@hot-updater/plugin-core";
-
-const CHILDREN_QUERY_LIMIT = 100;
-
-interface GetBundleChildrenInput {
-  baseBundleId: string;
-}
-
-interface GetBundleChildrenDeps {
-  databaseClient: DatabaseClient;
-}
-
-type CursorPaginationInfo = {
-  hasNextPage: boolean;
-  nextCursor?: string | null;
-};
-
-async function collectBundleChildrenByBaseIds(
-  baseBundleIds: string[],
-  deps: GetBundleChildrenDeps,
-): Promise<Record<string, Bundle[]>> {
-  const uniqueBaseBundleIds = [...new Set(baseBundleIds.filter(Boolean))];
-  const bundlesByBaseId = Object.fromEntries(
-    uniqueBaseBundleIds.map((bundleId) => [bundleId, [] as Bundle[]]),
-  );
-
-  const baseBundles = (
-    await Promise.all(
-      uniqueBaseBundleIds.map((bundleId) =>
-        deps.databaseClient.getBundleById(bundleId),
-      ),
-    )
-  ).filter((bundle): bundle is Bundle => Boolean(bundle));
-
-  const groupMap = new Map<Bundle["platform"], Set<string>>();
-
-  for (const baseBundle of baseBundles) {
-    const existingGroup = groupMap.get(baseBundle.platform);
-
-    if (existingGroup) {
-      existingGroup.add(baseBundle.id);
-      continue;
-    }
-
-    groupMap.set(baseBundle.platform, new Set([baseBundle.id]));
-  }
-
-  for (const [platform, bundleIds] of groupMap) {
-    const seenBundleIds = new Set<string>();
-    const seenCursors = new Set<string>();
-    let after: string | undefined;
-
-    while (true) {
-      const page = await deps.databaseClient.getBundles({
-        where: {
-          platform,
-        },
-        limit: CHILDREN_QUERY_LIMIT,
-        cursor: after ? { after } : undefined,
-      });
-
-      for (const bundle of page.data) {
-        const parentBundleIds = getBundlePatches(bundle).map(
-          (patch) => patch.baseBundleId,
-        );
-        const matchedParentBundleIds = parentBundleIds.filter((bundleId) =>
-          bundleIds.has(bundleId),
-        );
-
-        if (
-          matchedParentBundleIds.length === 0 ||
-          seenBundleIds.has(bundle.id)
-        ) {
-          continue;
-        }
-
-        seenBundleIds.add(bundle.id);
-        for (const parentBundleId of matchedParentBundleIds) {
-          bundlesByBaseId[parentBundleId]?.push(bundle);
-        }
-      }
-
-      const pagination = page.pagination as CursorPaginationInfo;
-      const nextCursor = pagination.nextCursor ?? undefined;
-
-      if (
-        !pagination.hasNextPage ||
-        !nextCursor ||
-        seenCursors.has(nextCursor)
-      ) {
-        break;
-      }
-
-      seenCursors.add(nextCursor);
-      after = nextCursor;
-    }
-  }
-
-  return bundlesByBaseId;
-}
-
+import {
+  type Bundle,
+  type HotUpdaterCoreApi,
+  rowToBundle,
+} from "@hot-updater/plugin-core";
+
+/** The most children the lineage panel lists; the count comes from the base bundle's counter. */
+export const BUNDLE_CHILDREN_LIMIT = 100;
+
+/**
+ * The bundles with a patch from this base, newest first: one read of the
+ * patches index, then each child bundle.
+ */
 export async function getBundleChildren(
-  { baseBundleId }: GetBundleChildrenInput,
-  deps: GetBundleChildrenDeps,
+  core: Pick<HotUpdaterCoreApi, "getBundle" | "listPatchesFromBase">,
+  baseBundleId: string,
 ): Promise<Bundle[]> {
-  const childrenByBaseId = await collectBundleChildrenByBaseIds(
-    [baseBundleId],
-    deps,
+  const patches = await core.listPatchesFromBase(baseBundleId, {
+    order: "desc",
+    limit: BUNDLE_CHILDREN_LIMIT,
+  });
+  const details = await Promise.all(
+    [...new Set(patches.map(({ bundle_id }) => bundle_id))].map((id) =>
+      core.getBundle(id),
+    ),
+  );
+  return details.flatMap((detail) =>
+    detail === null ? [] : [rowToBundle(detail.bundle, detail.patches)],
   );
-
-  return childrenByBaseId[baseBundleId] ?? [];
 }
 
+/** How many bundles patch from each base: each base bundle's reference counter, in one batch read. */
 export async function getBundleChildCounts(
-  baseBundleIds: string[],
-  deps: GetBundleChildrenDeps,
+  core: Pick<HotUpdaterCoreApi, "countBundleChildren">,
+  baseBundleIds: readonly string[],
 ): Promise<Record<string, number>> {
-  const childrenByBaseId = await collectBundleChildrenByBaseIds(
-    baseBundleIds,
-    deps,
-  );
-
-  return Object.fromEntries(
-    Object.entries(childrenByBaseId).map(([bundleId, bundles]) => [
-      bundleId,
-      bundles.length,
-    ]),
-  );
+  const ids = [...new Set(baseBundleIds.filter(Boolean))];
+  return ids.length === 0 ? {} : core.countBundleChildren(ids);
 }

package/src/lib/server/insightsUsage.ts

@@ -1,124 +1,63 @@
-import type { BundleEventRow, InsightsModel } from "@hot-updater/plugin-core";
+import type { InsightsModel } from "@hot-updater/server/plugins";
 
-import { readRecoveryInput, recoveryWindows } from "../insights-recovery";
-import type {
-  AppUsageInput,
-  AppUsageReport,
-  BundleDistribution,
-  UsageDistribution,
+import { insightsPeriodEnd, recoveryWindows } from "../insights-recovery";
+import {
+  readAppUsageInput,
+  type AppUsageInput,
+  type AppUsageReport,
+  type UsageWindow,
 } from "../insights-usage";
-import { readInsightsHistory } from "./insightsHistory";
 
-export async function getAppUsageReport(
-  model: InsightsModel,
-  input: AppUsageInput,
-  beforeReceivedAtMs = Date.now(),
-): Promise<AppUsageReport> {
-  readRecoveryInput(input);
-  const history = await readInsightsHistory(
-    model,
-    input.window,
-    beforeReceivedAtMs,
-  );
-  const { intervalMs, durationMs } = recoveryWindows[input.window];
-  const startMs = Math.max(0, beforeReceivedAtMs - durationMs);
-  const bucketStart = (ms: number) => Math.floor(ms / intervalMs) * intervalMs;
-  const latest = new Map<string, BundleEventRow>();
-  const observed = new Map<string, BundleEventRow>();
-  const buckets = new Map<number, Set<string>>();
-  const appVersions = new Set<string>();
+const DAY_MS = 86_400_000;
+const WEEK_MS = 7 * DAY_MS;
 
-  for (const event of history.events) {
-    const previous = observed.get(event.install_id);
-    const row = {
-      ...event,
-      to_release_id:
-        event.to_release_id ??
-        (event.type === "UNCHANGED" &&
-        previous?.to_bundle_id === event.to_bundle_id &&
-        previous.platform === event.platform &&
-        previous.channel === event.channel
-          ? previous.to_release_id
-          : null),
+/**
+ * What a period reads, ending with the current hour. The 12-month period is
+ * 52 weeks of whole UTC days, the last one today, so it reads the daily
+ * counts: the hourly ones are kept 90 days.
+ */
+const usageRange = (window: UsageWindow, now: number) => {
+  const end = insightsPeriodEnd(now);
+  if (window === "12m") {
+    const lastDay = Math.ceil(end / DAY_MS) * DAY_MS;
+    return {
+      start: Math.max(0, lastDay - 52 * WEEK_MS),
+      end,
+      intervalMs: WEEK_MS,
     };
-    observed.set(row.install_id, row);
-    if (
-      row.channel !== input.channel ||
-      (input.platform !== "all" && row.platform !== input.platform)
-    )
-      continue;
-    appVersions.add(row.app_version);
-    if (input.appVersion !== undefined && row.app_version !== input.appVersion)
-      continue;
-    latest.set(row.install_id, row);
-    const start = bucketStart(row.received_at_ms);
-    const installations = buckets.get(start) ?? new Set<string>();
-    installations.add(row.install_id);
-    buckets.set(start, installations);
   }
+  const { durationMs, intervalMs } = recoveryWindows[window];
+  return { start: Math.max(0, end - durationMs), end, intervalMs };
+};
 
-  const distribution = (
-    field: "app_version" | "platform",
-  ): UsageDistribution[] => {
-    const counts = new Map<string, number>();
-    for (const row of latest.values())
-      counts.set(row[field], (counts.get(row[field]) ?? 0) + 1);
-    return Array.from(counts, ([name, installations]) => ({
-      name,
-      installations,
-    })).sort(
-      (a, b) =>
-        b.installations - a.installations ||
-        a.name.localeCompare(b.name, "en", { numeric: true }),
-    );
-  };
-  const points: AppUsageReport["points"][number][] = [];
-  for (
-    let start = bucketStart(startMs);
-    start < beforeReceivedAtMs;
-    start += intervalMs
-  ) {
-    points.push({
-      startMs: start,
-      // Missing history is unknown, while a completely read interval with no reports is zero.
-      installations:
-        start + intervalMs <= history.sinceMs
-          ? null
-          : (buckets.get(start)?.size ?? 0),
-    });
-  }
-  const bundleCounts = new Map<string, BundleDistribution>();
-  for (const row of latest.values()) {
-    const key = JSON.stringify([
-      row.app_version,
-      row.platform,
-      row.to_release_id,
-    ]);
-    bundleCounts.set(key, {
-      appVersion: row.app_version,
-      platform: row.platform,
-      releaseId: row.to_release_id,
-      installations: (bundleCounts.get(key)?.installations ?? 0) + 1,
-    });
-  }
+export async function getAppUsageReport(
+  model: InsightsModel,
+  input: AppUsageInput,
+  now = Date.now(),
+): Promise<AppUsageReport> {
+  readAppUsageInput(input);
+  const { start, end, intervalMs } = usageRange(input.window, now);
+  const report = await model.getAppUsage({
+    channel: input.channel,
+    platform: input.platform,
+    ...(input.appVersion === undefined ? {} : { appVersion: input.appVersion }),
+    timeRange: { start, end },
+    intervalMs,
+  });
   return {
-    bundleDistribution: [...bundleCounts.values()].sort(
-      (a, b) =>
-        b.appVersion.localeCompare(a.appVersion, "en", { numeric: true }) ||
-        b.installations - a.installations ||
-        a.platform.localeCompare(b.platform) ||
-        (a.releaseId ?? "").localeCompare(b.releaseId ?? ""),
-    ),
-    activeInstallations: latest.size,
-    sinceMs: history.sinceMs,
-    beforeReceivedAtMs,
+    bundleDistribution: report.bundleDistribution,
+    activeInstallations: report.activeInstallations,
+    sinceMs:
+      report.coverage.sinceMs === null
+        ? start
+        : Math.max(start, report.coverage.sinceMs),
+    distributionSinceMs: start - (start % DAY_MS),
+    beforeReceivedAtMs: end,
     intervalMs,
-    truncated: history.truncated,
-    appVersions: [...appVersions].sort((a, b) =>
-      b.localeCompare(a, "en", { numeric: true }),
-    ),
-    versions: distribution("app_version"),
-    platforms: distribution("platform"),
-    points,
+    truncated: report.coverage.kind === "partial",
+    appVersions: report.appVersions,
+    versions: report.versions,
+    platforms: report.platforms,
+    points: report.points,
   };
 }

package/src/lib/server/listReleases.ts

@@ -1,61 +1,126 @@
-import type { ReleaseModel, ReleaseRow } from "@hot-updater/plugin-core";
+import type {
+  HotUpdaterCoreApi,
+  ReleaseFilter,
+  ReleaseRow,
+} from "@hot-updater/plugin-core";
 
 export interface ReleaseListInput {
-  afterReleaseId?: string;
-  beforeReleaseId?: string;
-  bundleId?: string;
-  channelId?: string;
-  enabled?: boolean;
-  limit: number;
-  page?: number;
-  platform?: "ios" | "android";
-  targetAppVersion?: string;
+  /** One of the filter sets the release indexes serve. */
+  readonly filter: ReleaseFilter;
+  /** Releases older than this id: the next page. */
+  readonly beforeReleaseId?: string;
+  /** Releases newer than this id: the previous page. */
+  readonly afterReleaseId?: string;
+  readonly limit: number;
 }
 
 export interface ReleaseListResult {
-  data: readonly ReleaseRow[];
-  pagination: {
-    currentPage: number;
-    hasNextPage: boolean;
-    hasPreviousPage: boolean;
-  };
+  /** Newest first. */
+  readonly data: readonly ReleaseRow[];
+  /** `beforeReleaseId` of the next page, when there may be older releases. */
+  readonly next?: string;
+  /** `afterReleaseId` of the previous page, when there may be newer releases. */
+  readonly previous?: string;
 }
 
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === "object" && value !== null;
+
+const text = (value: unknown, name: string): string => {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new Error(`Release filter ${name} is required.`);
+  }
+  return value;
+};
+
+const enabledOf = (value: unknown) => {
+  if (value === undefined) return {};
+  if (typeof value !== "boolean") {
+    throw new Error("Release filter enabled must be true or false.");
+  }
+  return { enabled: value };
+};
+
+/**
+ * A release list's filter: none, a channel with its platform (and enabled),
+ * a bundle, or a scope (and enabled). Those are the sets the release indexes
+ * serve, so any other combination is refused.
+ */
+export const readReleaseFilter = (value: unknown): ReleaseFilter => {
+  if (value === undefined) return { kind: "all" };
+  if (!isRecord(value)) throw new Error("Invalid release filter.");
+  switch (value.kind) {
+    case "all":
+      return { kind: "all" };
+    case "channelPlatform": {
+      if (value.platform !== "ios" && value.platform !== "android") {
+        throw new Error("Release filter platform must be ios or android.");
+      }
+      return {
+        kind: "channelPlatform",
+        channelId: text(value.channelId, "channelId"),
+        platform: value.platform,
+        ...enabledOf(value.enabled),
+      };
+    }
+    case "bundle":
+      return { kind: "bundle", bundleId: text(value.bundleId, "bundleId") };
+    case "scope":
+      return {
+        kind: "scope",
+        scopeKey: text(value.scopeKey, "scopeKey"),
+        ...enabledOf(value.enabled),
+      };
+    default:
+      throw new Error("Invalid release filter.");
+  }
+};
+
+/**
+ * One page of releases, newest first, through the index the filter names:
+ * each page reads only its own rows. `next` is set for a full page, so the
+ * last page may lead to an empty one.
+ */
 export async function listReleases(
-  releases: ReleaseModel,
+  core: Pick<HotUpdaterCoreApi, "listReleases">,
   input: ReleaseListInput,
 ): Promise<ReleaseListResult> {
-  const page = input.page ?? 1;
-  const rows = await releases.findMany({
-    ...(input.afterReleaseId === undefined
-      ? {}
-      : { afterReleaseId: input.afterReleaseId }),
+  const { filter, limit } = input;
+  if (input.afterReleaseId !== undefined) {
+    // Newer releases, read oldest first from the cursor, then turned around.
+    const data = (
+      await core.listReleases({
+        filter,
+        order: "asc",
+        after: input.afterReleaseId,
+        limit,
+      })
+    ).reverse();
+    const first = data[0]?.id;
+    const last = data.at(-1)?.id;
+    return {
+      data,
+      ...(last === undefined ? {} : { next: last }),
+      ...(first !== undefined && data.length === limit
+        ? { previous: first }
+        : {}),
+    };
+  }
+  const data = await core.listReleases({
+    filter,
+    order: "desc",
+    limit,
     ...(input.beforeReleaseId === undefined
       ? {}
-      : { beforeReleaseId: input.beforeReleaseId }),
-    ...(input.bundleId === undefined ? {} : { bundleId: input.bundleId }),
-    ...(input.channelId === undefined ? {} : { channelId: input.channelId }),
-    ...(input.enabled === undefined ? {} : { enabled: input.enabled }),
-    ...(input.platform === undefined ? {} : { platform: input.platform }),
-    ...(input.targetAppVersion === undefined
-      ? {}
-      : { targetAppVersion: input.targetAppVersion }),
-    limit: input.limit + 1,
+      : { after: input.beforeReleaseId }),
   });
-  const isPreviousRequest = input.afterReleaseId !== undefined;
-  const hasExtraRow = rows.length > input.limit;
-  const data = isPreviousRequest
-    ? hasExtraRow
-      ? rows.slice(1)
-      : rows
-    : rows.slice(0, input.limit);
-
+  const first = data[0]?.id;
+  const last = data.at(-1)?.id;
   return {
     data,
-    pagination: {
-      currentPage: page,
-      hasNextPage: isPreviousRequest || hasExtraRow,
-      hasPreviousPage: page > 1,
-    },
+    ...(last !== undefined && data.length === limit ? { next: last } : {}),
+    ...(first !== undefined && input.beforeReleaseId !== undefined
+      ? { previous: first }
+      : {}),
   };
 }