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

package/src/lib/api.ts

@@ -1,29 +1,18 @@
 import type {
-  ChannelDeleteInput,
-  ChannelInsertInput,
+  ReleaseFilter,
   ReleasePolicyPatch,
 } from "@hot-updater/plugin-core";
-import {
-  type QueryClient,
-  type QueryKey,
-  useMutation,
-  useQuery,
-  useQueryClient,
-} from "@tanstack/react-query";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 
 import {
   createChannel as createChannelApi,
   deleteChannel as deleteChannelApi,
-  deleteBundle as deleteBundleApi,
-  deleteBundles as deleteBundlesApi,
   deleteRelease as deleteReleaseApi,
   getBundle,
   getBundleChildCounts,
   getBundleChildren,
-  getBundles,
   getChannels,
   getConfig,
-  getConfigLoaded,
   getRelease,
   getReleaseCatalogDiagnostics,
   getReleases,
@@ -32,28 +21,11 @@ import {
   updateRelease as updateReleaseApi,
 } from "./api-rpc";
 
-type BundleFilters = {
-  platform?: "ios" | "android";
-  page?: number;
-  limit?: string;
-  after?: string;
-  before?: string;
-};
-
-type BundlesQueryData = Awaited<ReturnType<typeof getBundles>>;
-
-const bundleListQueryKey = ["bundles"] as const;
 const releaseListQueryKey = ["releases"] as const;
 
 export const queryKeys = {
   config: ["config"] as const,
   channels: ["channels"] as const,
-  configLoaded: ["config-loaded"] as const,
-  bundles: {
-    all: bundleListQueryKey,
-    list: (filters?: BundleFilters) =>
-      [...bundleListQueryKey, filters ?? {}] as const,
-  },
   releases: {
     all: releaseListQueryKey,
     list: (filters?: ReleaseFilters) =>
@@ -71,51 +43,13 @@ export const queryKeys = {
 };
 
 export type ReleaseFilters = {
-  afterReleaseId?: string;
+  /** One of the filter sets the release indexes serve; none lists every release. */
+  filter?: ReleaseFilter;
+  /** Releases older than this id: the next page. */
   beforeReleaseId?: string;
-  bundleId?: string;
-  channelId?: string;
-  enabled?: boolean;
-  platform?: "ios" | "android";
+  /** Releases newer than this id: the previous page. */
+  afterReleaseId?: string;
   limit?: number;
-  page?: number;
-  targetAppVersion?: string;
-};
-
-function removeBundleFromQueryData(
-  data: BundlesQueryData | undefined,
-  bundleId: string,
-) {
-  if (!data) {
-    return data;
-  }
-
-  return {
-    ...data,
-    data: data.data.filter((bundle) => bundle.id !== bundleId),
-  };
-}
-
-function removeBundlesFromQueryData(
-  data: BundlesQueryData | undefined,
-  bundleIds: readonly string[],
-) {
-  if (!data) {
-    return data;
-  }
-
-  const bundleIdSet = new Set(bundleIds);
-  return {
-    ...data,
-    data: data.data.filter((bundle) => !bundleIdSet.has(bundle.id)),
-  };
-}
-
-const invalidateInBackground = (
-  queryClient: QueryClient,
-  queryKey: QueryKey,
-) => {
-  void queryClient.invalidateQueries({ queryKey }).catch(() => undefined);
 };
 
 // Query Hooks
@@ -135,23 +69,6 @@ export function useChannelsQuery() {
   });
 }
 
-export function useConfigLoadedQuery() {
-  return useQuery({
-    queryKey: queryKeys.configLoaded,
-    queryFn: () => getConfigLoaded(),
-    staleTime: Infinity,
-  });
-}
-
-export function useBundlesQuery(filters?: BundleFilters) {
-  return useQuery({
-    queryKey: queryKeys.bundles.list(filters),
-    queryFn: () => getBundles({ data: filters }),
-    staleTime: Infinity,
-    placeholderData: (previousData) => previousData,
-  });
-}
-
 export function useReleasesQuery(filters?: ReleaseFilters) {
   return useQuery({
     queryKey: queryKeys.releases.list(filters),
@@ -213,7 +130,7 @@ export function useCreateChannelMutation() {
   const queryClient = useQueryClient();
 
   return useMutation({
-    mutationFn: (input: ChannelInsertInput) =>
+    mutationFn: (input: { name: string }) =>
       createChannelApi({ data: input }).then((response) => response.data),
     onSuccess: async () => {
       await queryClient.invalidateQueries({ queryKey: queryKeys.channels });
@@ -225,7 +142,7 @@ export function useDeleteChannelMutation() {
   const queryClient = useQueryClient();
 
   return useMutation({
-    mutationFn: (input: ChannelDeleteInput) =>
+    mutationFn: (input: { id: string }) =>
       deleteChannelApi({ data: input }).then((response) => response.data),
     onSettled: async () => {
       await queryClient.invalidateQueries({ queryKey: queryKeys.channels });
@@ -233,48 +150,6 @@ export function useDeleteChannelMutation() {
   });
 }
 
-export function useDeleteBundleMutation() {
-  const queryClient = useQueryClient();
-
-  return useMutation({
-    mutationFn: (params: { bundleId: string }) =>
-      deleteBundleApi({ data: params }),
-    onSuccess: (_, vars) => {
-      queryClient.removeQueries({ queryKey: queryKeys.bundle(vars.bundleId) });
-      queryClient.setQueriesData(
-        { queryKey: queryKeys.bundles.all },
-        (data: BundlesQueryData | undefined) =>
-          removeBundleFromQueryData(data, vars.bundleId),
-      );
-
-      invalidateInBackground(queryClient, queryKeys.bundles.all);
-      invalidateInBackground(queryClient, queryKeys.bundleChildren.all);
-    },
-  });
-}
-
-export function useDeleteBundlesMutation() {
-  const queryClient = useQueryClient();
-
-  return useMutation({
-    mutationFn: (params: { bundleIds: string[] }) =>
-      deleteBundlesApi({ data: params }),
-    onSuccess: (_, vars) => {
-      for (const bundleId of vars.bundleIds) {
-        queryClient.removeQueries({ queryKey: queryKeys.bundle(bundleId) });
-      }
-      queryClient.setQueriesData(
-        { queryKey: queryKeys.bundles.all },
-        (data: BundlesQueryData | undefined) =>
-          removeBundlesFromQueryData(data, vars.bundleIds),
-      );
-
-      invalidateInBackground(queryClient, queryKeys.bundles.all);
-      invalidateInBackground(queryClient, queryKeys.bundleChildren.all);
-    },
-  });
-}
-
 export function useUpdateReleaseMutation() {
   const queryClient = useQueryClient();
   return useMutation({
@@ -315,10 +190,16 @@ export function useDeleteReleaseMutation() {
       queryClient.removeQueries({
         queryKey: queryKeys.release(input.releaseId),
       });
+      // Core deletes the artifact with its last release, and the patches
+      // built on it, so the bundle reads can change too.
       await Promise.all([
         queryClient.invalidateQueries({ queryKey: queryKeys.releases.all }),
         queryClient.invalidateQueries({ queryKey: ["release-catalog"] }),
         queryClient.invalidateQueries({ queryKey: queryKeys.channels }),
+        queryClient.invalidateQueries({ queryKey: ["bundle"] }),
+        queryClient.invalidateQueries({
+          queryKey: queryKeys.bundleChildren.all,
+        }),
       ]);
     },
   });

package/src/lib/bundle-activity.ts

@@ -6,12 +6,32 @@ import { getBundleActivityRpc } from "./insights-recovery-rpc";
 export type BundleActivityInput = Pick<
   RecoveryInput,
   "platform" | "channel"
-> & { readonly releaseId: string };
+> & {
+  readonly releaseId: string;
+  /** The release runs the native build's built-in bundle, which nothing downloads. */
+  readonly builtIn?: boolean;
+};
 
+export type BundleActivityReport = {
+  /** Installations that downloaded the release. */
+  readonly downloads: number;
+  /** Installations that reported running it, once each at the first such report. */
+  readonly launched: number;
+  /** Launches that crashed on it and rolled back. */
+  readonly failedLaunches: number;
+  readonly measuredAtMs: number;
+};
+
+/** Release activity for bundle rows; mounted only where the console reads it. */
 export function useBundleActivityQuery(inputs: readonly BundleActivityInput[]) {
-  const sorted = [...inputs].sort((a, b) =>
-    a.releaseId.localeCompare(b.releaseId),
-  );
+  // The server reads only what names a release.
+  const sorted = inputs
+    .map(({ releaseId, platform, channel }) => ({
+      releaseId,
+      platform,
+      channel,
+    }))
+    .sort((a, b) => a.releaseId.localeCompare(b.releaseId));
   return useQuery({
     queryKey: ["bundle-activity", sorted],
     queryFn: () => getBundleActivityRpc({ data: sorted }),

package/src/lib/console-access.ts

@@ -0,0 +1,20 @@
+import { createMiddleware } from "@tanstack/react-start";
+
+/**
+ * Refuses a caller the console does not authorize before a server function
+ * reads its input. TanStack Start runs a function's middleware before the
+ * function's own validator, so an anonymous or unlisted caller gets the access
+ * check's 401 or 403, never an input error, whatever it sends. Every server
+ * function except the sign-in reads in `auth-rpc.ts` uses it, and
+ * `console-access.spec.ts` checks that.
+ */
+export const consoleAccess = createMiddleware({ type: "function" }).server(
+  async ({ next }) => {
+    const [{ getRequest }, { requireConsoleAccess }] = await Promise.all([
+      import("@tanstack/react-start/server"),
+      import("./server/auth.server"),
+    ]);
+    await requireConsoleAccess(getRequest());
+    return next();
+  },
+);

package/src/lib/console-features-api.ts

@@ -0,0 +1,68 @@
+import {
+  type QueryClient,
+  queryOptions,
+  useQuery,
+} from "@tanstack/react-query";
+import { notFound } from "@tanstack/react-router";
+
+import { type ConsoleFeature, consoleFeatures } from "./console-features";
+import { getConsoleFeaturesRpc } from "./console-features-rpc";
+
+export const consoleFeaturesQueryKey = ["console", "features"] as const;
+
+export const consoleFeaturesQueryOptions = () =>
+  queryOptions({
+    queryKey: consoleFeaturesQueryKey,
+    queryFn: () => getConsoleFeaturesRpc(),
+    // A server's plugins change only when it restarts: one read serves a visit.
+    staleTime: Infinity,
+  });
+
+/** The features the console serves; the authorized layout loads them first. */
+export const useConsoleFeatures = () => useQuery(consoleFeaturesQueryOptions());
+
+/** Whether `feature` is on; false until the features load. */
+export const useConsoleFeature = (feature: ConsoleFeature): boolean =>
+  useConsoleFeatures().data?.features[feature] === true;
+
+/** A feature route's not-found data: the feature its guard found off. */
+type ConsoleFeatureNotFoundData = { readonly feature: ConsoleFeature };
+
+/** The feature in a route's not-found data, when a feature guard threw it. */
+export const notFoundFeature = (data: unknown): ConsoleFeature | undefined => {
+  const feature =
+    typeof data === "object" && data !== null
+      ? Reflect.get(data, "feature")
+      : undefined;
+  return typeof feature === "string" && Object.hasOwn(consoleFeatures, feature)
+    ? (feature as ConsoleFeature)
+    : undefined;
+};
+
+/**
+ * A feature route's `beforeLoad`: not found, naming the feature, when the
+ * console does not serve it. A failed features read lets the route load: the
+ * root layout answers a visitor it does not authorize, and the route's own
+ * reads report any other failure. The failure leaves the cache, which a
+ * server render sends to the browser: a refused visitor's failure is the 401
+ * or 403 Response, which the render cannot serialize.
+ */
+export const requireConsoleFeature = async (
+  queryClient: QueryClient,
+  feature: ConsoleFeature,
+): Promise<void> => {
+  const featureSet = await queryClient
+    .ensureQueryData(consoleFeaturesQueryOptions())
+    .catch(() => {
+      queryClient.removeQueries({
+        queryKey: consoleFeaturesQueryKey,
+        exact: true,
+      });
+      return undefined;
+    });
+  if (featureSet !== undefined && !featureSet.features[feature]) {
+    throw notFound({
+      data: { feature } satisfies ConsoleFeatureNotFoundData,
+    });
+  }
+};

package/src/lib/console-features-rpc.ts

@@ -0,0 +1,13 @@
+import { createServerFn } from "@tanstack/react-start";
+
+import { consoleAccess } from "./console-access";
+import type { ConsoleFeatureSet } from "./console-features";
+
+/** The features this console serves, for navigation and route guards. */
+export const getConsoleFeaturesRpc = createServerFn({ method: "GET" })
+  .middleware([consoleAccess])
+  .handler(async (): Promise<ConsoleFeatureSet> => {
+    const { prepareConfig } = await import("./server/config.server");
+    const { runtime } = await prepareConfig();
+    return { features: await runtime.features(), remote: runtime.remote };
+  });

package/src/lib/console-features.ts

@@ -0,0 +1,98 @@
+/**
+ * The console's features and the server plugin each one needs. The console
+ * serves a feature only when its config lists the plugin, as the server runs
+ * it, and against a self-hosted server (`standaloneRepository`) only the
+ * features its admin API serves (`remote`); the rest read the database.
+ * Navigation, route guards, and server functions all read this registry. Its
+ * other halves, keyed by the same features, hold what serves each feature on
+ * the server (`server/console-feature-apis.ts`) and what each adds to pages
+ * (`components/features/FeatureSlots.tsx`). Their order is the sidebar's,
+ * below Bundles.
+ */
+export const consoleFeatures = {
+  /** Event history and installation lookups, which the admin API serves too. */
+  insights: { plugin: "insights", label: "Insights", remote: true },
+  /** App usage, distribution, and release activity, read from the database. */
+  insightsAnalytics: { plugin: "insights", label: "Insights", remote: false },
+  /** Template editing, publishing, and rollback, which the admin API serves too. */
+  remoteConfig: {
+    plugin: "remoteConfig",
+    label: "Remote Config",
+    remote: true,
+  },
+  /** API key management: `apiKeys()` mounts no admin routes to manage them. */
+  apiKeys: { plugin: "apiKeys", label: "API keys", remote: false },
+} as const satisfies Readonly<
+  Record<
+    string,
+    {
+      readonly plugin: string;
+      /** How navigation and the not-installed page name the feature. */
+      readonly label: string;
+      readonly remote: boolean;
+    }
+  >
+>;
+
+export type ConsoleFeature = keyof typeof consoleFeatures;
+
+/** Whether each feature is on. */
+export type ConsoleFeatures = Readonly<Record<ConsoleFeature, boolean>>;
+
+/** What the console serves, as its client reads it. */
+export type ConsoleFeatureSet = {
+  readonly features: ConsoleFeatures;
+  /** Whether the console reaches a self-hosted server through its admin API. */
+  readonly remote: boolean;
+};
+
+const featureIds = Object.keys(consoleFeatures) as ConsoleFeature[];
+
+/** The features on for the plugins the console's config lists, from where the console reads them. */
+export const resolveConsoleFeatures = (
+  plugins: readonly string[],
+  { remote }: { readonly remote: boolean },
+): ConsoleFeatures => {
+  const installed = new Set(plugins);
+  return Object.fromEntries(
+    featureIds.map((feature) => {
+      const { plugin, remote: servedRemotely } = consoleFeatures[feature];
+      return [feature, installed.has(plugin) && (servedRemotely || !remote)];
+    }),
+  ) as Record<ConsoleFeature, boolean>;
+};
+
+/** Why a feature is off: its plugin is missing, or it reads a database the console does not open. */
+export const unavailableReason = (
+  feature: ConsoleFeature,
+  { remote }: { readonly remote: boolean },
+): "plugin" | "remote" =>
+  remote && !consoleFeatures[feature].remote ? "remote" : "plugin";
+
+/**
+ * A server function refused a feature the console does not serve: the
+ * features' 404. The client recognizes it by `name`, which survives
+ * serialization where the class does not.
+ */
+export class ConsoleFeatureUnavailableError extends Error {
+  override readonly name = "ConsoleFeatureUnavailableError";
+  readonly status = 404;
+
+  constructor(
+    readonly feature: ConsoleFeature,
+    { remote }: { readonly remote: boolean },
+  ) {
+    super(
+      unavailableReason(feature, { remote }) === "remote"
+        ? "The console reads this from the database, and it reaches a self-hosted server through its admin API instead."
+        : `The server runs without the ${consoleFeatures[feature].plugin}() plugin.`,
+    );
+  }
+}
+
+export const isConsoleFeatureUnavailableError = (
+  error: unknown,
+): error is Error & { readonly feature: ConsoleFeature } =>
+  error instanceof Error &&
+  error.name === "ConsoleFeatureUnavailableError" &&
+  featureIds.includes(Reflect.get(error, "feature") as ConsoleFeature);

package/src/lib/insights-api.ts

@@ -1,9 +1,23 @@
-import type { InsightsEventPageInput } from "@hot-updater/server";
-import { useQuery } from "@tanstack/react-query";
+import type { InsightsEventPageInput } from "@hot-updater/server/plugins";
+import { useInfiniteQuery, useQuery } from "@tanstack/react-query";
 
+import type { FailureReportsInput } from "./insights-errors";
+import {
+  readUpdateFailuresInput,
+  type UpdateFailuresInput,
+} from "./insights-failures";
+import {
+  getUpdateFailuresRpc,
+  listFailureReportsRpc,
+} from "./insights-failures-rpc";
+import {
+  DEFAULT_INSIGHTS_RETENTION,
+  type InsightsRetentionDays,
+} from "./insights-retention";
 import {
   findInsightsInstallationsRpc,
   getInsightsInstallationRpc,
+  getInsightsRetentionRpc,
   getReportingInstallationsRpc,
   listInsightsEventsRpc,
   listInsightsInstallationEventsRpc,
@@ -98,3 +112,43 @@ export const useInsightsInstallationEventsQuery = (
     refetchOnWindowFocus: true,
     staleTime: STALE_TIME_MS,
   });
+
+/** A release's or a channel's update failures; lifetime for a release without a window. */
+export const useUpdateFailuresQuery = (
+  input: UpdateFailuresInput,
+  enabled = true,
+) =>
+  useQuery({
+    queryKey: ["insights", "update-failures", input],
+    queryFn: () =>
+      getUpdateFailuresRpc({ data: readUpdateFailuresInput(input) }),
+    enabled,
+    refetchOnWindowFocus: true,
+    staleTime: STALE_TIME_MS,
+  });
+
+/**
+ * How long the server keeps Insights rows; the defaults until it answers, or
+ * when it does not report them.
+ */
+export const useInsightsRetention = (): InsightsRetentionDays =>
+  useQuery({
+    queryKey: ["insights", "retention"],
+    queryFn: () => getInsightsRetentionRpc(),
+    // A server's periods change only when it restarts.
+    staleTime: Infinity,
+  }).data ?? DEFAULT_INSIGHTS_RETENTION;
+
+export const useFailureReportsQuery = (
+  input: FailureReportsInput,
+  enabled: boolean,
+) =>
+  useInfiniteQuery({
+    queryKey: ["insights", "failure-reports", input],
+    queryFn: ({ pageParam }) =>
+      listFailureReportsRpc({ data: { ...input, cursor: pageParam } }),
+    initialPageParam: undefined as string | undefined,
+    getNextPageParam: (page) => page.nextCursor ?? undefined,
+    enabled,
+    staleTime: STALE_TIME_MS,
+  });

package/src/lib/insights-errors.ts

@@ -0,0 +1,64 @@
+import type { UpdateFailuresInput } from "./insights-failures";
+import { readUpdateFailuresInput } from "./insights-failures";
+import type { InsightsEventRow } from "./insights-view";
+
+export type FailureReportsInput = UpdateFailuresInput & {
+  readonly beforeReceivedAtMs: number;
+  readonly cursor?: string;
+};
+
+export type FailureReportsPage = {
+  readonly data: readonly InsightsEventRow[];
+  readonly nextCursor: string | null;
+  readonly scanned: number;
+  readonly sinceMs: number;
+};
+
+export function readFailureReportsInput(input: FailureReportsInput) {
+  readUpdateFailuresInput(input);
+  if (
+    !Number.isSafeInteger(input.beforeReceivedAtMs) ||
+    input.beforeReceivedAtMs < 0 ||
+    (input.cursor !== undefined &&
+      (typeof input.cursor !== "string" ||
+        !input.cursor.length ||
+        input.cursor.length > 8_192))
+  ) {
+    throw new Error("Invalid failure report range or cursor.");
+  }
+  return input;
+}
+
+/** Exact text and reported context only; never guess a cause from the message. */
+export function groupFailureReports(events: readonly InsightsEventRow[]) {
+  const groups = new Map<string, InsightsEventRow[]>();
+  for (const event of events) {
+    if (event.type !== "UPDATE_FAILED" || !event.failure) continue;
+    const f = event.failure;
+    const key = JSON.stringify([
+      f.stage,
+      f.reason,
+      f.errorMessage ?? null,
+      f.resource ?? null,
+      f.httpStatus ?? null,
+      f.originCode ?? null,
+      f.transport ?? null,
+    ]);
+    const group = groups.get(key) ?? [];
+    group.push(event);
+    groups.set(key, group);
+  }
+  return [...groups]
+    .map(([key, reports]) => ({
+      key,
+      reports: reports.sort((a, b) => b.receivedAtMs - a.receivedAtMs),
+      installations: new Set(reports.map((event) => event.installId)).size,
+    }))
+    .sort(
+      (a, b) =>
+        b.reports.length - a.reports.length ||
+        b.reports[0]!.receivedAtMs - a.reports[0]!.receivedAtMs,
+    );
+}
+
+export type FailureGroup = ReturnType<typeof groupFailureReports>[number];

package/src/lib/insights-failures-rpc.ts

@@ -0,0 +1,36 @@
+import { createServerFn } from "@tanstack/react-start";
+
+import { consoleAccess } from "./console-access";
+import { readFailureReportsInput } from "./insights-errors";
+import { readUpdateFailuresInput } from "./insights-failures";
+
+export const getUpdateFailuresRpc = createServerFn({ method: "GET" })
+  .middleware([consoleAccess])
+  .validator(readUpdateFailuresInput)
+  .handler(async ({ data }) => {
+    const [{ prepareConfig }, { getUpdateFailuresReport }, { requireFeature }] =
+      await Promise.all([
+        import("./server/config.server"),
+        import("./server/updateFailures"),
+        import("./server/runtime.server"),
+      ]);
+    const { runtime } = await prepareConfig();
+    return getUpdateFailuresReport(
+      await requireFeature(runtime, "insights"),
+      data,
+    );
+  });
+
+export const listFailureReportsRpc = createServerFn({ method: "GET" })
+  .middleware([consoleAccess])
+  .validator(readFailureReportsInput)
+  .handler(async ({ data }) => {
+    const [{ prepareConfig }, { listFailureReports }, { requireFeature }] =
+      await Promise.all([
+        import("./server/config.server"),
+        import("./server/failureReports"),
+        import("./server/runtime.server"),
+      ]);
+    const { runtime } = await prepareConfig();
+    return listFailureReports(await requireFeature(runtime, "insights"), data);
+  });