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

package/src/lib/server/config.server.ts

@@ -1,98 +1,45 @@
-import {
-  assertStorageOperations,
-  createDatabaseClient,
-  type DatabaseClient,
-  type StoragePluginWith,
-} from "@hot-updater/plugin-core";
+import type { HotUpdaterCoreApi } from "@hot-updater/plugin-core";
 import { getRequest } from "@tanstack/react-start/server";
 
-import type { ResolvedHotUpdaterConsoleConfig } from "../../index";
 import { requireConsoleAccess } from "./auth.server";
-import { resolveConsoleConfig } from "./console-runtime.server";
-
-type ResolvedConsoleConfig = ResolvedHotUpdaterConsoleConfig & {
-  readonly console: NonNullable<ResolvedHotUpdaterConsoleConfig["console"]>;
-};
+import {
+  resolveConsoleConfig,
+  type ResolvedConsoleConfig,
+} from "./console-runtime.server";
+import type { ConsoleRuntime } from "./runtime.server";
 
 let configPromise: Promise<ResolvedConsoleConfig> | null = null;
-let databaseClient: DatabaseClient | null = null;
-let hotUpdater: ReturnType<
-  typeof import("./runtime.server").createRuntimeHotUpdater
-> | null = null;
-let apiKeyStore: ReturnType<
-  typeof import("./runtime.server").createApiKeyStore
-> | null = null;
-let apiKeyStoreResolved = false;
-let storagePluginPromise: Promise<
-  StoragePluginWith<"get" | "put" | "exists" | "delete">
-> | null = null;
+let core: HotUpdaterCoreApi | null = null;
+let runtime: ConsoleRuntime | null = null;
 
 const loadCachedConfig = async (request: Request) => {
   if (!configPromise) {
-    configPromise = resolveConsoleConfig(request)
-      .then((config) => ({
-        ...config,
-        console: config.console ?? {},
-      }))
-      .catch((error) => {
-        configPromise = null;
-        throw error;
-      });
+    configPromise = resolveConsoleConfig(request).catch((error) => {
+      configPromise = null;
+      throw error;
+    });
   }
 
   return configPromise;
 };
 
-const loadCachedStoragePlugin = async (config: ResolvedConsoleConfig) => {
-  if (!storagePluginPromise) {
-    storagePluginPromise = Promise.resolve(config.storage)
-      .then((storagePlugin) => {
-        assertStorageOperations(storagePlugin, [
-          "get",
-          "put",
-          "exists",
-          "delete",
-        ]);
-        return storagePlugin;
-      })
-      .catch((error) => {
-        storagePluginPromise = null;
-        throw error;
-      });
-  }
-
-  return storagePluginPromise;
-};
-
 export const prepareConfig = async (request: Request = getRequest()) => {
   try {
     await requireConsoleAccess(request);
     const config = await loadCachedConfig(request);
 
-    if (!databaseClient) {
-      databaseClient = createDatabaseClient(config.database);
-    }
-
-    if (!hotUpdater) {
-      const { createRuntimeHotUpdater } = await import("./runtime.server");
-      hotUpdater = createRuntimeHotUpdater(config);
-    }
+    // Bundles, releases, catalogs, and channels: core assembled as the
+    // server's, on the server's own path, or a self-hosted server's admin API.
+    core ??= config.core;
 
-    if (!apiKeyStoreResolved) {
-      const { createApiKeyStore } = await import("./runtime.server");
-      apiKeyStore = createApiKeyStore(config);
-      apiKeyStoreResolved = true;
+    // The console's features: those of the plugins its config lists.
+    if (!runtime) {
+      const { createConsoleRuntime } = await import("./runtime.server");
+      runtime = createConsoleRuntime(config);
     }
 
-    const storagePlugin = await loadCachedStoragePlugin(config);
-
-    return {
-      config,
-      databaseClient,
-      hotUpdater,
-      apiKeyStore,
-      storagePlugin,
-    };
+    // Each bundle file is read and deleted with its protocol's storage.
+    return { config, core, runtime, storage: config.storage };
   } catch (error) {
     if (
       !(

package/src/lib/server/console-feature-apis.ts

@@ -0,0 +1,59 @@
+import type { RemoteDatabase } from "@hot-updater/plugin-core";
+import type { ApiKeyManagementAPI } from "@hot-updater/server/plugins/api-keys";
+import {
+  createInsightsModel,
+  createInsightsProvider,
+  type InsightsApi,
+  type InsightsModel,
+} from "@hot-updater/server/plugins/insights";
+
+import type { ConsoleFeature } from "../console-features";
+import {
+  type ConsoleInsightsReads,
+  createAdminInsightsReads,
+} from "./adminInsights";
+
+/** A GET on a self-hosted server's admin handler. */
+export type FetchAdmin = RemoteDatabase["fetchAdmin"];
+
+/**
+ * What serves one console feature: `local` builds it from the API of the
+ * feature's plugin, which the console assembles over the database as the
+ * server does; `remote` builds it over a self-hosted server's admin API, for
+ * a feature that API serves.
+ */
+export interface ConsoleFeatureApi<TPluginApi, TApi> {
+  readonly local: (pluginApi: TPluginApi) => TApi;
+  readonly remote?: (fetchAdmin: FetchAdmin) => TApi;
+}
+
+const featureApi = <TPluginApi, TApi>(
+  api: ConsoleFeatureApi<TPluginApi, TApi>,
+): ConsoleFeatureApi<TPluginApi, TApi> => api;
+
+/** What serves each console feature, keyed like `consoleFeatures`. */
+export const consoleFeatureApis = {
+  insights: featureApi({
+    local: (api: InsightsApi): ConsoleInsightsReads => ({
+      ...createInsightsProvider(createInsightsModel(api)),
+      getRetention: async () => api.retention,
+      getUpdateFailures: api.getUpdateFailures,
+    }),
+    remote: createAdminInsightsReads,
+  }),
+  insightsAnalytics: featureApi({
+    local: (api: InsightsApi): InsightsModel => createInsightsModel(api),
+  }),
+  apiKeys: featureApi({
+    local: (api: ApiKeyManagementAPI) => api,
+  }),
+} satisfies {
+  readonly [F in ConsoleFeature]: ConsoleFeatureApi<never, unknown>;
+};
+
+/** What serves each console feature, as its server functions use it. */
+export type ConsoleFeatureApis = {
+  readonly [F in ConsoleFeature]: ReturnType<
+    (typeof consoleFeatureApis)[F]["local"]
+  >;
+};

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

@@ -1,42 +1,61 @@
+import {
+  type AnyHotUpdaterPlugin,
+  type ConfiguredDatabase,
+  createMemoryAdapter,
+  type EngineDatabase,
+  type HotUpdaterCoreApi,
+  isRemoteDatabase,
+  type StorageAdapter,
+} from "@hot-updater/plugin-core";
+import { createHotUpdater } from "@hot-updater/server";
+
 import type {
   ConsoleAuthAdapter,
-  ConsoleSigningConfig,
   HotUpdaterConsoleConfigSource,
-  ResolvedHotUpdaterConsoleConfig,
 } from "../../index";
 
-const readString = (value: unknown, key: string): string | undefined => {
-  if (typeof value !== "object" || value === null) return undefined;
-  const member = Reflect.get(value, key);
-  return typeof member === "string" && member.trim().length > 0
-    ? member.trim()
-    : undefined;
-};
+/** What the console runs on, assembled from its config as the server is. */
+export interface ResolvedConsoleConfig {
+  readonly gitUrl?: string;
+  /** The server's database, or its admin API. */
+  readonly database: ConfiguredDatabase;
+  /**
+   * Core's API, assembled over the database as the server assembles it, so
+   * the console's writes take the server's path, or a self-hosted server's
+   * admin API.
+   */
+  readonly core: HotUpdaterCoreApi;
+  /** The server's storage; each bundle file is read with its protocol's. */
+  readonly storage: readonly StorageAdapter[];
+  /** The plugins the server runs, as the config lists them. */
+  readonly plugins: readonly AnyHotUpdaterPlugin[];
+  /**
+   * The plugins' APIs by id, which serve their features; absent over a
+   * self-hosted server's admin API, whose plugins run on the server.
+   */
+  readonly api?: Readonly<Record<string, unknown>>;
+}
 
-const getProviderName = (signing: unknown): string => {
-  return (
-    readString(signing, "name")?.slice(0, 80) ??
-    (readString(signing, "privateKeyPath") ? "localSigning" : undefined) ??
-    "Configured provider"
-  );
-};
-
-export const sanitizeConsoleSigningConfig = (
-  signing: unknown,
-): ConsoleSigningConfig | undefined => {
-  if (typeof signing !== "object" || signing === null) return undefined;
-  const privateKeyPath = readString(signing, "privateKeyPath");
-  if (
-    Reflect.get(signing, "enabled") === false ||
-    (privateKeyPath && Reflect.get(signing, "enabled") !== true)
-  )
-    return undefined;
-
-  return {
-    enabled: true,
-    provider: getProviderName(signing),
-  };
-};
+/**
+ * Core and the plugins over `database`, assembled by `createHotUpdater` as
+ * the server assembles them, with public client routes unless a plugin
+ * provides clientAuth: the console mounts no handlers. cli-tools'
+ * `assembleServer` does the same for the CLI; the console keeps its own
+ * copy, since a hosted console never loads cli-tools.
+ */
+const assemble = (
+  database: EngineDatabase,
+  storage: StorageAdapter,
+  plugins: readonly AnyHotUpdaterPlugin[],
+) =>
+  createHotUpdater({
+    database,
+    storage: [storage],
+    plugins,
+    ...(plugins.some((plugin) => plugin.provides?.clientAuth)
+      ? {}
+      : { clientAccess: "public" }),
+  } as Parameters<typeof createHotUpdater>[0]);
 
 export const getConsoleAuthAdapter = async (): Promise<ConsoleAuthAdapter> => {
   const module = await import("virtual:hot-updater-console/auth");
@@ -45,17 +64,42 @@ export const getConsoleAuthAdapter = async (): Promise<ConsoleAuthAdapter> => {
 
 export const resolveConsoleConfig = async (
   request: Request,
-): Promise<ResolvedHotUpdaterConsoleConfig> => {
+): Promise<ResolvedConsoleConfig> => {
   const { default: source } =
     (await import("virtual:hot-updater-console/config")) as {
       readonly default: HotUpdaterConsoleConfigSource;
     };
 
   const config = typeof source === "function" ? await source(request) : source;
-  const { signing: signingSource, ...configWithoutSigning } = config;
-  const signing = sanitizeConsoleSigningConfig(signingSource);
+  const { database, storage, plugins = [] } = config;
+  const gitUrl =
+    config.console?.gitUrl === undefined
+      ? {}
+      : { gitUrl: config.console.gitUrl };
+  // A self-hosted server runs the plugins itself: core is its admin API.
+  // The plugins are still checked as the server checks them, on a database
+  // nothing reads, so one the server would refuse is refused here too.
+  if (isRemoteDatabase(database)) {
+    const checked = assemble(
+      { name: "memory", adapter: createMemoryAdapter() },
+      storage,
+      plugins,
+    );
+    return {
+      ...gitUrl,
+      database,
+      core: database.core,
+      storage: [storage],
+      plugins: checked.plugins,
+    };
+  }
+  const server = assemble(database, storage, plugins);
   return {
-    ...configWithoutSigning,
-    ...(signing === undefined ? {} : { signing }),
+    ...gitUrl,
+    database,
+    core: server.core,
+    storage: server.storage,
+    plugins: server.plugins,
+    api: server.api,
   };
 };

package/src/lib/server/downloadBundle.ts

@@ -1,34 +1,35 @@
 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; the manifest is read with its protocol's. */
+  readonly storage: readonly 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.find(
+    (adapter) => adapter.protocol === protocol,
+  );
+  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 +38,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/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,
+  };
+}