@hot-updater/console 1.0.0-rc.2 → 1.0.0-rc.20

package/src/lib/server/downloadBundle.ts

@@ -1,24 +1,21 @@
 import type {
-  DatabaseClient,
+  HotUpdaterCoreApi,
   StoragePluginWith,
 } from "@hot-updater/plugin-core";
 
 interface DownloadBundleDependencies {
-  readonly databaseClient: DatabaseClient;
+  readonly core: Pick<HotUpdaterCoreApi, "getBundle">;
   readonly storagePlugin?: StoragePluginWith<"get">;
 }
 
 export const downloadBundle = async (
   bundleId: string,
-  { databaseClient, storagePlugin }: DownloadBundleDependencies,
+  { core, storagePlugin }: 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) {
@@ -28,7 +25,7 @@ export const downloadBundle = async (
 
     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,

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/insightsRecovery.ts

@@ -0,0 +1,55 @@
+import type { InsightsModel } from "@hot-updater/server/plugins/insights";
+
+import {
+  insightsPeriodEnd,
+  readRecoveryInput,
+  recoveryWindows,
+  type RecoveryInput,
+  type RecoveryReport,
+} from "../insights-recovery";
+
+export async function getRecoveryReport(
+  model: InsightsModel,
+  input: RecoveryInput,
+  now = Date.now(),
+): Promise<RecoveryReport> {
+  readRecoveryInput(input);
+  const end = insightsPeriodEnd(now);
+  const start = Math.max(0, end - recoveryWindows[input.window].durationMs);
+  const result = await model.getReleaseActivity(
+    input.releaseId === undefined
+      ? {
+          scope: { platform: input.platform, channel: input.channel },
+          timeRange: { start, end },
+        }
+      : {
+          releases: [
+            {
+              releaseId: input.releaseId,
+              platform: input.platform,
+              channel: input.channel,
+            },
+          ],
+          timeRange: { start, end },
+        },
+  );
+  const metrics = result.data[0]?.metrics;
+  // The launches counter counts each installation once per UTC day it
+  // launched, so it reads as active days, and per day as daily active
+  // installations.
+  return {
+    downloads: metrics?.downloads ?? 0,
+    activeInstallations: metrics?.uniqueUsers ?? 0,
+    activeDays: metrics?.launches ?? 0,
+    failedLaunches: metrics?.failedLaunches ?? 0,
+    points: (metrics?.series ?? []).map((point) => ({
+      startMs: point.startMs,
+      dailyActiveInstallations: point.launches,
+      failedLaunches: point.failedLaunches,
+    })),
+    startMs: start,
+    endMs: end,
+    measuredAtMs: result.measuredAtMs,
+    coverage: result.coverage,
+  };
+}

package/src/lib/server/insightsUsage.ts

@@ -0,0 +1,63 @@
+import type { InsightsModel } from "@hot-updater/server/plugins/insights";
+
+import { insightsPeriodEnd, recoveryWindows } from "../insights-recovery";
+import {
+  readAppUsageInput,
+  type AppUsageInput,
+  type AppUsageReport,
+  type UsageWindow,
+} from "../insights-usage";
+
+const DAY_MS = 86_400_000;
+const WEEK_MS = 7 * DAY_MS;
+
+/**
+ * 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,
+    };
+  }
+  const { durationMs, intervalMs } = recoveryWindows[window];
+  return { start: Math.max(0, end - durationMs), end, intervalMs };
+};
+
+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: 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: 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 }
+      : {}),
   };
 }

package/src/lib/server/releaseReachability.ts

@@ -4,7 +4,7 @@ import {
 } from "@hot-updater/core";
 import type {
   CompiledReleaseCatalog,
-  ReleaseCatalogModel,
+  HotUpdaterCoreApi,
   ReleaseRow,
 } from "@hot-updater/plugin-core";
 
@@ -63,15 +63,16 @@ export function collectCurrentlyReachableReleaseIds(
   return reachableReleaseIds;
 }
 
+/** Marks each release its scope's compiled catalog no longer serves: one catalog read per scope. */
 export async function addReleaseReachability(
-  releaseCatalogs: Pick<ReleaseCatalogModel, "findByScopeKey">,
+  core: Pick<HotUpdaterCoreApi, "getReleaseCatalogRow">,
   releases: readonly ReleaseRow[],
 ): Promise<readonly ReleaseReachabilityRow[]> {
   const scopeKeys = [...new Set(releases.map(({ scope_key }) => scope_key))];
   const reachableByScope = new Map(
     await Promise.all(
       scopeKeys.map(async (scopeKey) => {
-        const row = await releaseCatalogs.findByScopeKey(scopeKey);
+        const row = await core.getReleaseCatalogRow(scopeKey);
         const reachableReleaseIds =
           row === null
             ? new Set<string>()

package/src/lib/server/runtime.server.ts

@@ -1,36 +1,137 @@
-import type {
-  ApiKeyModel,
-  BundleRepository,
-  DatabasePlugin,
+import {
+  type ConfiguredDatabase,
+  isRemoteDatabase,
 } from "@hot-updater/plugin-core";
+import { createDatabasePluginApis } from "@hot-updater/server/db";
+
 import {
-  createInsightsProvider,
-  type InsightsProvider,
-} from "@hot-updater/server";
-
-export function createRuntimeHotUpdater(config: {
-  readonly database: DatabasePlugin;
-}): InsightsProvider {
-  return createInsightsProvider(config.database.models.insights);
+  type ConsoleFeature,
+  ConsoleFeatureUnavailableError,
+  type ConsoleFeatures,
+  consoleFeatures,
+  resolveConsoleFeatures,
+} from "../console-features";
+import {
+  type ConsoleFeatureApis,
+  consoleFeatureApis,
+  type FetchAdmin,
+} from "./console-feature-apis";
+
+export type { ConsoleFeatureApis } from "./console-feature-apis";
+
+export interface ConsoleRuntime {
+  /** Whether the console reaches a self-hosted server through its admin API. */
+  readonly remote: boolean;
+  /** The features on here, resolved once from the plugins the server runs. */
+  features(): Promise<ConsoleFeatures>;
+  /** What serves the features the console can serve here; {@link requireFeature} hands it out. */
+  readonly apis: Partial<ConsoleFeatureApis>;
 }
 
-export function createApiKeyStore(config: {
-  readonly database: BundleRepository;
-}): ApiKeyModel | null {
-  const models: unknown = Reflect.get(config.database, "models");
-  const apiKeys: unknown =
-    typeof models === "object" && models !== null
-      ? Reflect.get(models, "apiKeys")
-      : undefined;
-  if (
-    typeof apiKeys !== "object" ||
-    apiKeys === null ||
-    typeof Reflect.get(apiKeys, "create") !== "function" ||
-    typeof Reflect.get(apiKeys, "findByHash") !== "function" ||
-    typeof Reflect.get(apiKeys, "list") !== "function" ||
-    typeof Reflect.get(apiKeys, "revoke") !== "function"
-  ) {
-    return null;
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === "object" && value !== null;
+
+/** The ids of the plugins a self-hosted server lists on its admin `/version`. */
+const readServerPlugins = async (
+  fetchAdmin: FetchAdmin,
+): Promise<readonly string[]> => {
+  const response = await fetchAdmin("/version");
+  if (!response.ok) {
+    throw new Error(`The server answered /version with ${response.status}.`);
   }
-  return apiKeys as ApiKeyModel;
-}
+  const body: unknown = await response.json();
+  const plugins = isRecord(body) ? body.plugins : undefined;
+  // A server from before `/version` listed its plugins reports none, so the
+  // console serves none of their features until the server is upgraded.
+  return Array.isArray(plugins)
+    ? plugins.filter((id): id is string => typeof id === "string")
+    : [];
+};
+
+/** Runs `load` once and keeps its result; a failure is not kept, so the next call retries. */
+const once = <T>(load: () => Promise<T>): (() => Promise<T>) => {
+  let pending: Promise<T> | undefined;
+  return () =>
+    (pending ??= load().catch((error: unknown) => {
+      pending = undefined;
+      throw error;
+    }));
+};
+
+const featureIds = Object.keys(consoleFeatureApis) as ConsoleFeature[];
+
+/**
+ * What serves each feature, built by its factory: over the plugins' APIs the
+ * console assembled, or over a self-hosted server's admin API. A feature
+ * without its plugin, or without a factory for the admin API, has none.
+ */
+const featureApis = (
+  build: (feature: ConsoleFeature) => unknown,
+): Partial<ConsoleFeatureApis> =>
+  Object.fromEntries(
+    featureIds.flatMap((feature) => {
+      const api = build(feature);
+      return api === undefined ? [] : [[feature, api]];
+    }),
+  );
+
+/**
+ * The console's features and what serves them, for a console config:
+ * - a self-hosted server (`standaloneRepository`) runs its plugins and lists
+ *   them on its admin `/version`; the console serves what that server's admin
+ *   API serves, and nothing that needs the database;
+ * - otherwise the console assembles `plugins` over the database, as the
+ *   server does, and serves the features of the plugins it assembled.
+ */
+export const createConsoleRuntime = (config: {
+  readonly database: ConfiguredDatabase;
+  readonly plugins?: readonly unknown[];
+}): ConsoleRuntime => {
+  const { database } = config;
+  if (isRemoteDatabase(database)) {
+    const { fetchAdmin } = database;
+    return {
+      remote: true,
+      features: once(async () =>
+        resolveConsoleFeatures(await readServerPlugins(fetchAdmin), {
+          remote: true,
+        }),
+      ),
+      apis: featureApis((feature) =>
+        consoleFeatureApis[feature].remote?.(fetchAdmin),
+      ),
+    };
+  }
+  const api = createDatabasePluginApis(database, config.plugins ?? []);
+  const features = resolveConsoleFeatures(Object.keys(api), { remote: false });
+  return {
+    remote: false,
+    features: async () => features,
+    // A feature reads the plugin with its plugin's id, taken to be Hot
+    // Updater's own, as a self-hosted server's /version list is.
+    apis: featureApis((feature) => {
+      const pluginApi = api[consoleFeatures[feature].plugin];
+      return pluginApi === undefined
+        ? undefined
+        : consoleFeatureApis[feature].local(pluginApi as never);
+    }),
+  };
+};
+
+/**
+ * What serves `feature`. Every feature's server function asks for it first,
+ * so a feature the console does not serve is refused with one error the
+ * client recognizes, before anything is read.
+ */
+export const requireFeature = async <F extends ConsoleFeature>(
+  runtime: ConsoleRuntime,
+  feature: F,
+): Promise<ConsoleFeatureApis[F]> => {
+  const api = runtime.apis[feature];
+  if (api === undefined || !(await runtime.features())[feature]) {
+    throw new ConsoleFeatureUnavailableError(feature, {
+      remote: runtime.remote,
+    });
+  }
+  return api as ConsoleFeatureApis[F];
+};