@hot-updater/console 1.0.0-rc.4 → 1.0.0-rc.41

package/src/lib/server/releaseAdoption.ts

@@ -0,0 +1,154 @@
+import type { HotUpdaterCoreApi, ReleaseRow } from "@hot-updater/plugin-core";
+import type {
+  InsightsBundleEventFilter,
+  InsightsModel,
+} from "@hot-updater/server/plugins/insights";
+
+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 rollback to the built-in bundle has nothing to apply.
+const bundles = (releases: readonly ReleaseRow[]) =>
+  releases
+    .filter((release) => release.kind === "BUNDLE" && 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.kind !== "BUNDLE" ||
+    !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;
@@ -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/remoteConfig.ts

@@ -0,0 +1,191 @@
+import type { RemoteDatabase } from "@hot-updater/plugin-core";
+import {
+  type RemoteConfigActive,
+  type RemoteConfigApi,
+  type RemoteConfigPublishResult,
+  type RemoteConfigTemplateIssue,
+  RemoteConfigValidationError,
+  type RemoteConfigVersion,
+  type RemoteConfigVersionDetail,
+  type RemoteConfigVersionsPage,
+} from "@hot-updater/server/plugins/remote-config";
+
+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. */
+export const createLocalRemoteConfig = (
+  api: RemoteConfigApi,
+): 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),
+});
+
+const readBody = async (response: Response): Promise<unknown> =>
+  response.json().catch(() => null);
+
+const field = (body: unknown, name: string): unknown =>
+  typeof body === "object" && body !== null
+    ? Reflect.get(body, name)
+    : undefined;
+
+/** A published version's record, as a publish or a rollback answers it. */
+const isPublishedVersion = (body: unknown): body is RemoteConfigVersion => {
+  const version = field(body, "version");
+  const updateType = field(body, "updateType");
+  return (
+    typeof version === "number" &&
+    Number.isSafeInteger(version) &&
+    version > 0 &&
+    (updateType === "PUBLISH" || updateType === "ROLLBACK") &&
+    typeof field(body, "createdAtMs") === "number"
+  );
+};
+
+const errorText = (body: unknown): string | undefined => {
+  const error = field(body, "error");
+  return typeof error === "string" ? error : undefined;
+};
+
+/**
+ * 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 => {
+  const unavailable = () =>
+    new ConsoleFeatureUnavailableError("remoteConfig", { remote: true });
+  const request = async (
+    path: string,
+    init?: { readonly method: string; readonly body: unknown },
+  ): Promise<{ readonly status: number; readonly body: unknown }> => {
+    const response = await fetchAdmin(
+      path,
+      init === undefined
+        ? undefined
+        : {
+            method: init.method,
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify(init.body),
+          },
+    );
+    const body = await readBody(response);
+    // Core's own 404 for a path no route matches.
+    if (response.status === 404 && errorText(body) === "Not found") {
+      throw unavailable();
+    }
+    return { status: response.status, body };
+  };
+  const expectOk = <T>(
+    path: string,
+    { status, body }: { status: number; body: unknown },
+  ): T => {
+    if (status >= 200 && status < 300) return body as T;
+    throw new Error(
+      errorText(body) ??
+        `The server answered ${path.split("?")[0]} with ${status}.`,
+    );
+  };
+  const published = (
+    path: string,
+    result: { status: number; body: unknown },
+  ): ConsolePublishResult => {
+    const currentVersion = field(result.body, "currentVersion");
+    if (
+      result.status === 409 &&
+      typeof currentVersion === "number" &&
+      Number.isSafeInteger(currentVersion)
+    ) {
+      return { status: "conflict", currentVersion };
+    }
+    const issues = field(result.body, "issues");
+    if (result.status === 400 && Array.isArray(issues)) {
+      return { status: "invalid", issues };
+    }
+    const version = expectOk<unknown>(path, result);
+    // Anything else, such as the active template a server that ignores the
+    // method answers, published nothing.
+    if (!isPublishedVersion(version)) {
+      throw new Error(
+        `The server answered ${path} without the version it published.`,
+      );
+    }
+    return { status: "published", version };
+  };
+
+  return {
+    getActive: async () => {
+      const path = "/remote-config/template";
+      return expectOk(path, await request(path));
+    },
+    listVersions: async ({ limit, cursor }) => {
+      const query = new URLSearchParams();
+      if (limit !== undefined) query.set("limit", String(limit));
+      if (cursor !== undefined) query.set("cursor", cursor);
+      const path = `/remote-config/versions${query.size === 0 ? "" : `?${query}`}`;
+      return expectOk(path, await request(path));
+    },
+    getVersion: async (version) => {
+      const path = `/remote-config/versions/${version}`;
+      const result = await request(path);
+      return result.status === 404 ? null : expectOk(path, result);
+    },
+    publish: async ({ template, baseVersion, description }) => {
+      const path = "/remote-config/template";
+      return published(
+        path,
+        await request(path, {
+          method: "PUT",
+          body: { template, baseVersion, description },
+        }),
+      );
+    },
+    rollback: async ({ version, baseVersion }) => {
+      const path = `/remote-config/versions/${version}/rollback`;
+      const result = await request(path, {
+        method: "POST",
+        body: { baseVersion },
+      });
+      return result.status === 404
+        ? { status: "not_found" }
+        : published(path, result);
+    },
+  };
+};

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,65 @@
+import {
+  checkFailureRate,
+  failureRate,
+  readUpdateFailuresInput,
+  type UpdateFailuresInput,
+  type UpdateFailuresReport,
+} from "../insights-failures";
+import { insightsPeriodEnd, recoveryWindows } from "../insights-recovery";
+import type { ConsoleInsightsReads } from "./adminInsights";
+
+/** A release's or a channel's update failures over a period that ends with the current hour. */
+export async function getUpdateFailuresReport(
+  reads: Pick<ConsoleInsightsReads, "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",
+          },
+        }),
+  };
+}