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

package/src/lib/server/releaseAdoption.ts

@@ -0,0 +1,151 @@
+import type { HotUpdaterCoreApi, ReleaseRow } from "@hot-updater/plugin-core";
+import type {
+  InsightsBundleEventFilter,
+  InsightsModel,
+} from "@hot-updater/server/plugins";
+
+import { insightsPeriodEnd, recoveryWindows } from "../insights-recovery";
+import {
+  ADOPTION_CANDIDATES,
+  type AdoptionRelease,
+  type AdoptionReleaseInput,
+  type AdoptionReleaseResult,
+  type AdoptionReleasesInput,
+  type BundleEventsInput,
+  type BundleEventsSeries,
+  readAdoptionReleaseInput,
+  readAdoptionReleasesInput,
+  readBundleEventsInput,
+} from "../release-adoption";
+
+type ReleaseReads = Pick<
+  HotUpdaterCoreApi,
+  "findChannelByName" | "getRelease" | "listReleases"
+>;
+
+/** Rows read past a focused release to find the bundle before it. */
+const PREVIOUS_ROWS = 4;
+
+const labelOf = (release: ReleaseRow): AdoptionRelease => ({
+  releaseId: release.id,
+  bundleId: release.bundle_id!,
+  deployedAtMs: release.created_at_ms,
+  targetAppVersion: release.target_app_version,
+  enabled: release.enabled,
+  revision: release.revision,
+});
+
+// A release without a bundle has nothing to apply.
+const bundles = (releases: readonly ReleaseRow[]) =>
+  releases.filter((release) => release.bundle_id).map(labelOf);
+
+/**
+ * The newest bundle deployments of a channel and platform, newest first: one
+ * read of the channel and one of its newest releases.
+ */
+export async function listAdoptionReleases(
+  core: ReleaseReads,
+  input: AdoptionReleasesInput,
+): Promise<readonly AdoptionRelease[]> {
+  const { platform, channel } = readAdoptionReleasesInput(input);
+  const row = await core.findChannelByName(channel);
+  if (row === null) return [];
+  return bundles(
+    await core.listReleases({
+      filter: { kind: "channelPlatform", channelId: row.id, platform },
+      order: "desc",
+      limit: ADOPTION_CANDIDATES,
+    }),
+  );
+}
+
+/**
+ * One bundle deployment of the channel and platform, for a focus the newest
+ * ones leave out, and with `withPrevious` the bundle deployed before it.
+ */
+export async function getAdoptionRelease(
+  core: ReleaseReads,
+  input: AdoptionReleaseInput,
+): Promise<AdoptionReleaseResult> {
+  const { platform, channel, releaseId, withPrevious } =
+    readAdoptionReleaseInput(input);
+  const [row, release] = await Promise.all([
+    core.findChannelByName(channel),
+    core.getRelease(releaseId),
+  ]);
+  if (
+    row === null ||
+    release === null ||
+    !release.bundle_id ||
+    release.platform !== platform ||
+    release.channel_id !== row.id
+  )
+    return withPrevious ? { release: null, previous: null } : { release: null };
+  if (!withPrevious) return { release: labelOf(release) };
+  // Newest first, `after` a release lists older ones.
+  const older = await core.listReleases({
+    filter: { kind: "channelPlatform", channelId: row.id, platform },
+    order: "desc",
+    after: release.id,
+    limit: PREVIOUS_ROWS,
+  });
+  return { release: labelOf(release), previous: bundles(older)[0] ?? null };
+}
+
+/**
+ * One bundle's counts of one type in each interval of the period, from
+ * their hourly counts, never the events or the release table. Downloads are
+ * the bundle's download hours, which count the downloads a launch or crash
+ * implied too. Launches add two series: apply reports, and the kept
+ * UNCHANGED reports that moved an installation to the bundle with no apply
+ * report.
+ */
+export async function getBundleEvents(
+  model: Pick<InsightsModel, "countEventSeries">,
+  input: BundleEventsInput,
+  now = Date.now(),
+): Promise<BundleEventsSeries> {
+  const { platform, channel, window, endMs, bundleId, type } =
+    readBundleEventsInput(input);
+  const { durationMs, intervalMs } = recoveryWindows[window];
+  const end = Math.min(endMs, insightsPeriodEnd(now));
+  const timeRange = { start: Math.max(0, end - durationMs), end };
+  const series = (filter: InsightsBundleEventFilter) =>
+    model.countEventSeries({ filter, timeRange, intervalMs });
+  const points =
+    type === "RECOVERED"
+      ? await series({ platform, channel, type, fromBundleId: bundleId })
+      : type === "DOWNLOADED"
+        ? await series({
+            platform,
+            channel,
+            type: "UPDATE_DOWNLOADED",
+            toBundleId: bundleId,
+          })
+        : await Promise.all([
+            series({
+              platform,
+              channel,
+              type: "UPDATE_APPLIED",
+              toBundleId: bundleId,
+            }),
+            series({
+              platform,
+              channel,
+              type: "UNCHANGED",
+              toBundleId: bundleId,
+            }),
+          ]).then(([applied, moved]) =>
+            applied.map((point, index) => ({
+              startMs: point.startMs,
+              events: point.events + (moved[index]?.events ?? 0),
+            })),
+          );
+  return {
+    bundleId,
+    type,
+    measuredAtMs: now,
+    points,
+    total: points.reduce((sum, point) => sum + point.events, 0),
+  };
+}

package/src/lib/server/releaseReachability.ts

@@ -1,12 +1,12 @@
-import {
-  isReleaseEligibleForCohort,
-  NUMERIC_COHORT_SIZE,
-} from "@hot-updater/core";
 import type {
   CompiledReleaseCatalog,
-  ReleaseCatalogModel,
+  HotUpdaterCoreApi,
   ReleaseRow,
 } from "@hot-updater/plugin-core";
+import {
+  isReleaseEligibleForCohort,
+  NUMERIC_COHORT_SIZE,
+} from "@hot-updater/protocol";
 
 export type ReleaseReachabilityRow = ReleaseRow & {
   readonly currentlyUnreachable: boolean;
@@ -37,7 +37,6 @@ function collectReachableFromIndexes(
   for (const cohort of cohorts) {
     const selected = descriptors.find(
       (descriptor) =>
-        descriptor.kind === "BUNDLE" &&
         descriptor.bundleId !== null &&
         isReleaseEligibleForCohort(descriptor, cohort),
     );
@@ -63,15 +62,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/remoteConfig.ts

@@ -0,0 +1,75 @@
+import type { RemoteDatabase } from "@hot-updater/plugin-core";
+import {
+  createRemoteConfigAdminApi,
+  type RemoteConfigActive,
+  type RemoteConfigAdminApi,
+  type RemoteConfigPublishResult,
+  type RemoteConfigTemplateIssue,
+  RemoteConfigValidationError,
+  type RemoteConfigVersionDetail,
+  type RemoteConfigVersionsPage,
+} from "@hot-updater/server/plugins";
+
+import { ConsoleFeatureUnavailableError } from "../console-features";
+
+/** How a publish from the console ended; `invalid` lists what to fix. */
+export type ConsolePublishResult =
+  | RemoteConfigPublishResult
+  | {
+      readonly status: "invalid";
+      readonly issues: readonly RemoteConfigTemplateIssue[];
+    };
+
+/** The Remote Config the console pages use. */
+export interface ConsoleRemoteConfig {
+  getActive(): Promise<RemoteConfigActive>;
+  listVersions(input: {
+    readonly limit?: number;
+    readonly cursor?: string;
+  }): Promise<RemoteConfigVersionsPage>;
+  getVersion(version: number): Promise<RemoteConfigVersionDetail | null>;
+  publish(input: {
+    readonly template: unknown;
+    readonly baseVersion: number;
+    readonly description?: string;
+  }): Promise<ConsolePublishResult>;
+  rollback(input: {
+    readonly version: number;
+    readonly baseVersion: number;
+  }): Promise<ConsolePublishResult | { readonly status: "not_found" }>;
+}
+
+const invalidOf = (error: unknown): ConsolePublishResult => {
+  if (error instanceof RemoteConfigValidationError) {
+    return { status: "invalid", issues: error.issues };
+  }
+  throw error;
+};
+
+/**
+ * Remote Config over the `remoteConfig()` API the console assembled on the
+ * database, or over the admin routes, which answer as the API does.
+ */
+export const createLocalRemoteConfig = (
+  api: RemoteConfigAdminApi,
+): ConsoleRemoteConfig => ({
+  getActive: () => api.getActive(),
+  listVersions: (input) => api.listVersions(input),
+  getVersion: (version) => api.getVersion(version),
+  publish: (input) => api.publish(input).catch(invalidOf),
+  rollback: (input) => api.rollback(input),
+});
+
+/**
+ * Remote Config over a self-hosted server's admin routes. A route the server
+ * does not mount answers core's 404: it runs without `remoteConfig()`.
+ */
+export const createAdminRemoteConfig = (
+  fetchAdmin: RemoteDatabase["fetchAdmin"],
+): ConsoleRemoteConfig =>
+  createLocalRemoteConfig(
+    createRemoteConfigAdminApi(fetchAdmin, {
+      unavailable: () =>
+        new ConsoleFeatureUnavailableError("remoteConfig", { remote: true }),
+    }),
+  );

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

@@ -1,36 +1,125 @@
-import type {
-  ApiKeyModel,
-  BundleRepository,
-  DatabasePlugin,
+import {
+  type ConfiguredDatabase,
+  isRemoteDatabase,
 } from "@hot-updater/plugin-core";
+
+import {
+  type ConsoleFeature,
+  ConsoleFeatureUnavailableError,
+  type ConsoleFeatures,
+  consoleFeatures,
+  resolveConsoleFeatures,
+} from "../console-features";
 import {
-  createInsightsProvider,
-  type InsightsProvider,
-} from "@hot-updater/server";
-
-export function createRuntimeHotUpdater(config: {
-  readonly database: DatabasePlugin;
-}): InsightsProvider {
-  return createInsightsProvider(config.database.models.insights);
+  type ConsoleFeatureApis,
+  consoleFeatureApis,
+} 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, from the plugins the console's config lists. */
+  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;
+
+/**
+ * Whether one of Hot Updater's own factories made `plugin`: the brand they
+ * set under a registered symbol, read here with a copy of the key so the
+ * console imports no package's internals. Assembly refuses any other plugin
+ * that takes one of their ids, so features key on it.
+ */
+const isOfficialPlugin = (plugin: unknown): boolean =>
+  isRecord(plugin) &&
+  Reflect.get(plugin, Symbol.for("@hot-updater/server/official-plugin")) ===
+    true;
+
+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 the plugins its config
+ * lists, the plugins the server runs:
+ * - a self-hosted server (`standaloneRepository`) runs them itself; the
+ *   console serves what that server's admin API serves of their features,
+ *   and nothing that needs the database;
+ * - otherwise the console runs them over the database, as the server does,
+ *   and serves their features through `api`, their APIs.
+ */
+export const createConsoleRuntime = (config: {
+  readonly database: ConfiguredDatabase;
+  readonly plugins: readonly unknown[];
+  readonly api?: Readonly<Record<string, unknown>>;
+}): ConsoleRuntime => {
+  const { database } = config;
+  // A feature's plugin is Hot Updater's own, which alone may take its id:
+  // the server's assembly refuses any other, and features key on the
+  // factory's mark, so another plugin under that id turns on nothing.
+  const official = new Set(
+    config.plugins
+      .filter(isOfficialPlugin)
+      .map((plugin) => (plugin as { id: string }).id),
+  );
+  if (isRemoteDatabase(database)) {
+    const { fetchAdmin } = database;
+    const features = resolveConsoleFeatures([...official], { remote: true });
+    return {
+      remote: true,
+      features: async () => features,
+      apis: featureApis((feature) =>
+        consoleFeatureApis[feature].remote?.(fetchAdmin),
+      ),
+    };
   }
-  return apiKeys as ApiKeyModel;
-}
+  const api = config.api ?? {};
+  const features = resolveConsoleFeatures([...official], { remote: false });
+  return {
+    remote: false,
+    features: async () => features,
+    apis: featureApis((feature) => {
+      const { plugin } = consoleFeatures[feature];
+      const pluginApi = official.has(plugin) ? api[plugin] : undefined;
+      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];
+};

package/src/lib/server/updateFailures.ts

@@ -0,0 +1,66 @@
+import type { InsightsReads } from "@hot-updater/server/plugins";
+
+import {
+  checkFailureRate,
+  failureRate,
+  readUpdateFailuresInput,
+  type UpdateFailuresInput,
+  type UpdateFailuresReport,
+} from "../insights-failures";
+import { insightsPeriodEnd, recoveryWindows } from "../insights-recovery";
+
+/** A release's or a channel's update failures over a period that ends with the current hour. */
+export async function getUpdateFailuresReport(
+  reads: Pick<InsightsReads, "getUpdateFailures">,
+  input: UpdateFailuresInput,
+  now = Date.now(),
+): Promise<UpdateFailuresReport> {
+  readUpdateFailuresInput(input);
+  const end = insightsPeriodEnd(now);
+  const timeRange =
+    input.window === undefined
+      ? undefined
+      : {
+          start: Math.max(0, end - recoveryWindows[input.window].durationMs),
+          end,
+        };
+  const scope = {
+    platform: input.platform,
+    channel: input.channel,
+    ...(input.releaseId === undefined ? {} : { releaseId: input.releaseId }),
+  };
+  const previousRange =
+    timeRange && timeRange.start >= timeRange.end - timeRange.start
+      ? {
+          start: timeRange.start - (timeRange.end - timeRange.start),
+          end: timeRange.start,
+        }
+      : undefined;
+  const [failures, previous] = await Promise.all([
+    reads.getUpdateFailures({
+      ...scope,
+      ...(timeRange === undefined ? {} : { timeRange }),
+    }),
+    previousRange === undefined
+      ? undefined
+      : reads.getUpdateFailures({ ...scope, timeRange: previousRange }),
+  ]);
+  return {
+    ...failures,
+    startMs: timeRange?.start ?? null,
+    endMs: end,
+    ...(previous === undefined
+      ? {}
+      : {
+          previous: {
+            attemptRate: failureRate(previous),
+            checkRate: previous.checks
+              ? checkFailureRate(previous.checks)
+              : null,
+            complete:
+              previous.coverage.kind === "complete" &&
+              failures.coverage.kind === "complete",
+          },
+        }),
+  };
+}

package/src/lib/use-dialog-target.ts

@@ -0,0 +1,27 @@
+import { useState } from "react";
+
+/**
+ * What a dialog opened for, kept while it animates closed. Closing clears
+ * the target at once, and without the kept one the dialog would empty or
+ * switch to another state, such as "Delete ?", during its exit animation.
+ */
+export function useDialogTarget<T>(target: T | null): T | null {
+  const [shown, setShown] = useState(target);
+  if (target !== null && target !== shown) setShown(target);
+  return target ?? shown;
+}
+
+/**
+ * A number that changes each time `open` turns true, to key a dialog's form
+ * so every opening starts from its props, even one that comes before the
+ * last close finished animating.
+ */
+export function useOpenSession(open: boolean): number {
+  const [session, setSession] = useState(0);
+  const [wasOpen, setWasOpen] = useState(open);
+  if (open !== wasOpen) {
+    setWasOpen(open);
+    if (open) setSession(session + 1);
+  }
+  return session;
+}