@hot-updater/console 0.36.7 → 1.0.0-rc.1

package/src/lib/insights-input.ts

@@ -0,0 +1,187 @@
+import type { ActiveInstallationWindow } from "@hot-updater/server";
+import type { BundleEventInsightsWindow } from "@hot-updater/server";
+
+const MAX_INSIGHTS_STRING_LENGTH = 1024;
+const MAX_INSIGHTS_LIMIT = 100;
+
+export type BundleEventSummaryInput = {
+  readonly bundleId: string;
+};
+
+export type BundleEventInsightsInput = BundleEventSummaryInput & {
+  readonly window: BundleEventInsightsWindow;
+  readonly limit?: number;
+  readonly offset?: number;
+};
+
+export type SearchInstallationsInput = {
+  readonly query: string;
+  readonly limit?: number;
+  readonly offset?: number;
+};
+
+export type InstallationHistoryInput = {
+  readonly installId: string;
+  readonly limit?: number;
+  readonly offset?: number;
+};
+
+export type ActiveInstallationInput = {
+  readonly window: ActiveInstallationWindow;
+  readonly userId?: string;
+};
+
+type InsightsPagination = {
+  readonly limit?: number;
+  readonly offset?: number;
+};
+
+export class InsightsInputValidationError extends Error {
+  readonly name = "InsightsInputValidationError";
+
+  constructor(readonly field: string) {
+    super(`Invalid insights input: ${field}`);
+  }
+}
+
+const isRecord = (input: unknown): input is Record<string, unknown> =>
+  typeof input === "object" && input !== null && !Array.isArray(input);
+
+const parseRecord = (input: unknown): Record<string, unknown> => {
+  if (!isRecord(input)) {
+    throw new InsightsInputValidationError("input");
+  }
+  return input;
+};
+
+const parseString = (input: Record<string, unknown>, field: string): string => {
+  const value = input[field];
+  if (typeof value !== "string") {
+    throw new InsightsInputValidationError(field);
+  }
+  const trimmed = value.trim();
+  if (trimmed.length === 0 || trimmed.length > MAX_INSIGHTS_STRING_LENGTH) {
+    throw new InsightsInputValidationError(field);
+  }
+  return trimmed;
+};
+
+const parseLimit = (input: Record<string, unknown>): number | undefined => {
+  const value = input.limit;
+  if (value === undefined) {
+    return undefined;
+  }
+  if (
+    typeof value !== "number" ||
+    !Number.isInteger(value) ||
+    value < 1 ||
+    value > MAX_INSIGHTS_LIMIT
+  ) {
+    throw new InsightsInputValidationError("limit");
+  }
+  return value;
+};
+
+const parseOffset = (input: Record<string, unknown>): number | undefined => {
+  const value = input.offset;
+  if (value === undefined) {
+    return undefined;
+  }
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
+    throw new InsightsInputValidationError("offset");
+  }
+  return value;
+};
+
+const parsePagination = (
+  input: Record<string, unknown>,
+): InsightsPagination => {
+  const limit = parseLimit(input);
+  const offset = parseOffset(input);
+  return {
+    ...(limit === undefined ? {} : { limit }),
+    ...(offset === undefined ? {} : { offset }),
+  };
+};
+
+const parseWindow = (
+  input: Record<string, unknown>,
+): BundleEventInsightsWindow => {
+  const value = input.window;
+  if (value === "24h" || value === "7d" || value === "30d" || value === "all") {
+    return value;
+  }
+  throw new InsightsInputValidationError("window");
+};
+
+const parseActiveWindow = (
+  input: Record<string, unknown>,
+): ActiveInstallationWindow => {
+  const value = input.window;
+  if (value === "24h" || value === "7d" || value === "30d") {
+    return value;
+  }
+  throw new InsightsInputValidationError("window");
+};
+
+const parseOptionalUserId = (
+  input: Record<string, unknown>,
+): string | undefined => {
+  if (input.userId === undefined) return undefined;
+  if (typeof input.userId !== "string") {
+    throw new InsightsInputValidationError("userId");
+  }
+  const userId = input.userId.trim();
+  if (userId.length === 0) return undefined;
+  if (userId.length > MAX_INSIGHTS_STRING_LENGTH) {
+    throw new InsightsInputValidationError("userId");
+  }
+  return userId;
+};
+
+export const parseActiveInstallationInput = (
+  input: unknown,
+): ActiveInstallationInput => {
+  const record = parseRecord(input);
+  const window = parseActiveWindow(record);
+  const userId = parseOptionalUserId(record);
+  return userId === undefined ? { window } : { window, userId };
+};
+
+export const parseBundleEventSummaryInput = (
+  input: unknown,
+): BundleEventSummaryInput => {
+  const record = parseRecord(input);
+  return { bundleId: parseString(record, "bundleId") };
+};
+
+export const parseBundleEventInsightsInput = (
+  input: unknown,
+): BundleEventInsightsInput => {
+  const record = parseRecord(input);
+  return {
+    bundleId: parseString(record, "bundleId"),
+    window: parseWindow(record),
+    ...parsePagination(record),
+  };
+};
+
+export const parseSearchInstallationsInput = (
+  input: unknown,
+): SearchInstallationsInput => {
+  const record = parseRecord(input);
+  return {
+    query: parseString(record, "query"),
+    ...parsePagination(record),
+  };
+};
+
+export const parseInstallationHistoryInput = (
+  input: unknown,
+): InstallationHistoryInput => {
+  const record = parseRecord(input);
+  return {
+    installId: parseString(record, "installId"),
+    ...parsePagination(record),
+  };
+};

package/src/lib/insights-overview.ts

@@ -0,0 +1,170 @@
+import { normalizeRolloutCohortCount } from "@hot-updater/core";
+import type { Bundle, ChannelRow, ReleaseRow } from "@hot-updater/plugin-core";
+
+export type InsightsBundleMetadata = {
+  readonly platform: "ios" | "android";
+  readonly channel: string | null;
+  readonly targetAppVersion: string | null;
+  readonly fingerprintHash: string | null;
+};
+
+export type LatestReportedBundle = {
+  readonly bundleId: string;
+  readonly trackedInstallations: number;
+  readonly observedShare: number;
+  readonly bundle: InsightsBundleMetadata | null;
+};
+
+export type ConfiguredRollout = {
+  readonly releaseId: string;
+  readonly bundleId: string;
+  readonly configuredPercentage: number;
+  readonly trackedInstallations: number;
+  readonly bundle: InsightsBundleMetadata;
+};
+
+export type InsightsOverview = {
+  readonly trackedInstallations: number;
+  readonly mostCommonLatestReportedBundle: LatestReportedBundle | null;
+  readonly latestReportedBundles: readonly LatestReportedBundle[];
+  readonly configuredRollouts: readonly ConfiguredRollout[];
+};
+
+export type LatestInstallationBundle = {
+  readonly lastKnownBundleId: string | null;
+};
+
+export type InstallationBundleCount = {
+  readonly bundleId: string;
+  readonly installations: number;
+};
+
+const toBundleMetadata = (
+  bundle: Bundle,
+  release: ReleaseRow | undefined,
+  channelById: ReadonlyMap<string, string>,
+): InsightsBundleMetadata => ({
+  platform: bundle.platform,
+  channel: release ? (channelById.get(release.channel_id) ?? null) : null,
+  targetAppVersion: release?.target_app_version ?? null,
+  fingerprintHash: release?.fingerprint_hash ?? null,
+});
+
+const compareCodePoints = (left: string, right: string): number =>
+  left < right ? -1 : left > right ? 1 : 0;
+
+const createOverview = (
+  bundles: readonly Bundle[],
+  releases: readonly ReleaseRow[],
+  channels: readonly ChannelRow[],
+  trackedInstallations: number,
+  latestReportedCounts: ReadonlyMap<string, number>,
+): InsightsOverview => {
+  const bundleById = new Map(bundles.map((bundle) => [bundle.id, bundle]));
+  const channelById = new Map(
+    channels.map((channel) => [channel.id, channel.name]),
+  );
+  const bundleReleases = releases
+    .filter(
+      (release): release is ReleaseRow & { readonly bundle_id: string } =>
+        release.kind === "BUNDLE" && release.bundle_id !== null,
+    )
+    .sort((left, right) => compareCodePoints(right.id, left.id));
+  const latestReleaseByBundleId = new Map<string, ReleaseRow>();
+  for (const release of bundleReleases) {
+    if (!latestReleaseByBundleId.has(release.bundle_id)) {
+      latestReleaseByBundleId.set(release.bundle_id, release);
+    }
+  }
+  const latestReportedBundles = [...latestReportedCounts]
+    .map(([bundleId, count]): LatestReportedBundle => {
+      const bundle = bundleById.get(bundleId);
+      return {
+        bundleId,
+        trackedInstallations: count,
+        observedShare:
+          trackedInstallations === 0 ? 0 : count / trackedInstallations,
+        bundle: bundle
+          ? toBundleMetadata(
+              bundle,
+              latestReleaseByBundleId.get(bundle.id),
+              channelById,
+            )
+          : null,
+      };
+    })
+    .sort(
+      (left, right) =>
+        right.trackedInstallations - left.trackedInstallations ||
+        compareCodePoints(left.bundleId, right.bundleId),
+    );
+  const configuredRollouts = bundleReleases
+    .filter((release) => bundleById.has(release.bundle_id))
+    .map(
+      (release): ConfiguredRollout => ({
+        releaseId: release.id,
+        bundleId: release.bundle_id,
+        configuredPercentage:
+          normalizeRolloutCohortCount(release.rollout_cohort_count) / 10,
+        trackedInstallations: latestReportedCounts.get(release.bundle_id) ?? 0,
+        bundle: toBundleMetadata(
+          bundleById.get(release.bundle_id)!,
+          release,
+          channelById,
+        ),
+      }),
+    )
+    .sort((left, right) => compareCodePoints(left.releaseId, right.releaseId));
+
+  return {
+    trackedInstallations,
+    mostCommonLatestReportedBundle: latestReportedBundles[0] ?? null,
+    latestReportedBundles,
+    configuredRollouts,
+  };
+};
+
+const countLatestInstallationBundles = (
+  rows: readonly LatestInstallationBundle[],
+): ReadonlyMap<string, number> => {
+  const counts = new Map<string, number>();
+  for (const row of rows) {
+    if (row.lastKnownBundleId === null) continue;
+    counts.set(
+      row.lastKnownBundleId,
+      (counts.get(row.lastKnownBundleId) ?? 0) + 1,
+    );
+  }
+  return counts;
+};
+
+export const createInsightsOverviewFromCounts = (
+  bundles: readonly Bundle[],
+  releases: readonly ReleaseRow[],
+  channels: readonly ChannelRow[],
+  trackedInstallations: number,
+  counts: readonly InstallationBundleCount[],
+): InsightsOverview =>
+  createOverview(
+    bundles,
+    releases,
+    channels,
+    trackedInstallations,
+    new Map(
+      counts.map(({ bundleId, installations }) => [bundleId, installations]),
+    ),
+  );
+
+export const createInsightsOverview = (
+  bundles: readonly Bundle[],
+  releases: readonly ReleaseRow[],
+  channels: readonly ChannelRow[],
+  latestInstallations: readonly LatestInstallationBundle[],
+): InsightsOverview =>
+  createOverview(
+    bundles,
+    releases,
+    channels,
+    latestInstallations.length,
+    countLatestInstallationBundles(latestInstallations),
+  );

package/src/lib/insights-rpc.ts

@@ -0,0 +1,218 @@
+import type { Bundle, ChannelRow, ReleaseRow } from "@hot-updater/plugin-core";
+import { createServerFn } from "@tanstack/react-start";
+
+import { parseActiveInstallationInput } from "./insights-input";
+import {
+  type InsightsOverview,
+  createInsightsOverviewFromCounts,
+} from "./insights-overview";
+
+const DEFAULT_INSIGHTS_PAGE_SIZE = 100;
+
+export type InsightsCapabilities = {
+  readonly capabilities:
+    | { readonly insights: false }
+    | {
+        readonly insights: true;
+        readonly mode: "bounded";
+        readonly maxMatchingRows: number;
+      };
+};
+
+type BundlePage = {
+  readonly data: readonly Bundle[];
+  readonly pagination: {
+    readonly hasNextPage: boolean;
+    readonly currentPage: number;
+    readonly totalPages: number;
+  };
+};
+
+type InsightsOverviewDependencies = {
+  readonly runtime: unknown;
+  readonly getBundles: (options: {
+    readonly limit: number;
+    readonly page: number;
+  }) => Promise<BundlePage>;
+  readonly getReleases: (options: {
+    readonly beforeReleaseId?: string;
+    readonly limit: number;
+  }) => Promise<readonly ReleaseRow[]>;
+  readonly getChannels: () => Promise<readonly ChannelRow[]>;
+  readonly pageSize?: number;
+};
+
+export class InsightsNotSupportedError extends Error {
+  constructor() {
+    super("Insights are not supported by the configured database plugin.");
+    this.name = "InsightsNotSupportedError";
+  }
+}
+
+export class InsightsBundlePaginationError extends Error {
+  readonly name = "InsightsBundlePaginationError";
+
+  constructor(
+    readonly requestedPage: number,
+    readonly reason: string,
+  ) {
+    super(`Invalid bundle pagination for page ${requestedPage}: ${reason}`);
+  }
+}
+
+export const getInsightsCapabilities = async (
+  runtime: unknown,
+): Promise<InsightsCapabilities> => {
+  const { getInsightsCapability } = await import("./server/runtime.server");
+  const capability = await getInsightsCapability(runtime);
+  if (!capability.insights || !capability.insightsQueries) {
+    return { capabilities: { insights: false } };
+  }
+  return {
+    capabilities: {
+      insights: true,
+      mode: "bounded",
+      maxMatchingRows: capability.maxMatchingRows,
+    },
+  };
+};
+
+const collectBundles = async (
+  getBundles: InsightsOverviewDependencies["getBundles"],
+  pageSize: number,
+): Promise<readonly Bundle[]> => {
+  const bundles: Bundle[] = [];
+  let page = 1;
+  while (true) {
+    const result = await getBundles({ limit: pageSize, page });
+    const { currentPage, hasNextPage, totalPages } = result.pagination;
+    const isEmptyFirstPage =
+      page === 1 &&
+      currentPage === 1 &&
+      totalPages === 0 &&
+      result.data.length === 0 &&
+      hasNextPage === false;
+
+    if (currentPage !== page) {
+      throw new InsightsBundlePaginationError(
+        page,
+        `currentPage must equal ${page}, received ${currentPage}`,
+      );
+    }
+    if (!Number.isFinite(totalPages) || !Number.isInteger(totalPages)) {
+      throw new InsightsBundlePaginationError(
+        page,
+        `totalPages must be a finite integer, received ${totalPages}`,
+      );
+    }
+    if (totalPages < 0) {
+      throw new InsightsBundlePaginationError(
+        page,
+        `totalPages must be nonnegative, received ${totalPages}`,
+      );
+    }
+    if (!isEmptyFirstPage && totalPages < currentPage) {
+      throw new InsightsBundlePaginationError(
+        page,
+        `totalPages ${totalPages} is lower than currentPage ${currentPage}`,
+      );
+    }
+    if (!isEmptyFirstPage && hasNextPage !== currentPage < totalPages) {
+      throw new InsightsBundlePaginationError(
+        page,
+        "hasNextPage contradicts currentPage and totalPages",
+      );
+    }
+    bundles.push(...result.data);
+    if (!hasNextPage) {
+      return bundles;
+    }
+    page += 1;
+  }
+};
+
+const collectReleases = async (
+  getReleases: InsightsOverviewDependencies["getReleases"],
+  pageSize: number,
+): Promise<readonly ReleaseRow[]> => {
+  const releases: ReleaseRow[] = [];
+  const cursors = new Set<string>();
+  let beforeReleaseId: string | undefined;
+  while (true) {
+    const page = await getReleases({ beforeReleaseId, limit: pageSize });
+    releases.push(...page);
+    if (page.length < pageSize) return releases;
+    const nextCursor = page.at(-1)?.id;
+    if (!nextCursor || cursors.has(nextCursor)) {
+      throw new InsightsBundlePaginationError(
+        releases.length,
+        "release cursor did not advance",
+      );
+    }
+    cursors.add(nextCursor);
+    beforeReleaseId = nextCursor;
+  }
+};
+
+export const collectInsightsOverview = async ({
+  runtime,
+  getBundles,
+  getReleases,
+  getChannels,
+  pageSize = DEFAULT_INSIGHTS_PAGE_SIZE,
+}: InsightsOverviewDependencies): Promise<InsightsOverview> => {
+  const { capabilities } = await getInsightsCapabilities(runtime);
+  if (!capabilities.insights) {
+    throw new InsightsNotSupportedError();
+  }
+
+  const [bundles, releases, channels] = await Promise.all([
+    collectBundles(getBundles, pageSize),
+    collectReleases(getReleases, pageSize),
+    getChannels(),
+  ]);
+  const overview = await (
+    runtime as import("@hot-updater/server").InsightsProvider
+  ).getBundleEventOverview();
+  return createInsightsOverviewFromCounts(
+    bundles,
+    releases,
+    channels,
+    overview.trackedInstallations,
+    overview.bundles,
+  );
+};
+
+export const getInsightsCapabilitiesRpc = createServerFn({
+  method: "GET",
+}).handler(async () => {
+  const { prepareConfig } = await import("./server/config.server");
+  const { hotUpdater } = await prepareConfig();
+  return getInsightsCapabilities(hotUpdater);
+});
+
+export const getInsightsOverviewRpc = createServerFn({
+  method: "GET",
+}).handler(async () => {
+  const { prepareConfig } = await import("./server/config.server");
+  const { config, databaseClient, hotUpdater } = await prepareConfig();
+  return collectInsightsOverview({
+    runtime: hotUpdater,
+    getBundles: (options) => databaseClient.getBundles(options),
+    getReleases: (options) => config.database.models.releases.findMany(options),
+    getChannels: () =>
+      config.database.models.channels.list({}).then(({ channels }) => channels),
+  });
+});
+
+export const getActiveInstallationOverviewRpc = createServerFn({
+  method: "GET",
+})
+  .validator(parseActiveInstallationInput)
+  .handler(async ({ data }) => {
+    const { prepareConfig } = await import("./server/config.server");
+    const { getActiveInstallationOverview } =
+      await import("./server/runtime.server");
+    const { hotUpdater } = await prepareConfig();
+    return getActiveInstallationOverview(hotUpdater, data);
+  });

package/src/lib/server/auth.server.ts

@@ -0,0 +1,43 @@
+import type {
+  ConsoleAccess,
+  ConsoleAuthProvider,
+  ConsolePrincipal,
+} from "../../index";
+import { getConsoleAuthAdapter } from "./console-runtime.server";
+
+const accessError = (
+  access: Exclude<ConsoleAccess, { status: "authorized" }>,
+) =>
+  new Response(
+    access.status === "unauthenticated" ? "Unauthorized" : "Forbidden",
+    { status: access.status === "unauthenticated" ? 401 : 403 },
+  );
+
+export const getConsoleAccess = async (
+  request: Request,
+): Promise<ConsoleAccess> => {
+  const adapter = await getConsoleAuthAdapter();
+  return adapter.getAccess(request);
+};
+
+export const getConsoleAuthProviders = async (
+  request: Request,
+): Promise<readonly ConsoleAuthProvider[]> => {
+  const adapter = await getConsoleAuthAdapter();
+  return adapter.getProviders(request);
+};
+
+export const handleConsoleAuth = async (request: Request) => {
+  const adapter = await getConsoleAuthAdapter();
+  return adapter.handle(request);
+};
+
+export const requireConsoleAccess = async (
+  request: Request,
+): Promise<ConsolePrincipal> => {
+  const access = await getConsoleAccess(request);
+  if (access.status !== "authorized") {
+    throw accessError(access);
+  }
+  return access.principal;
+};

package/src/lib/server/bundle-signing.server.ts

@@ -0,0 +1,23 @@
+import type { ConsoleSigningConfig } from "../../index";
+
+const DEFAULT_PROVIDER = "Configured provider";
+
+export type BundleSigningInspection =
+  | { readonly status: "disabled" }
+  | {
+      readonly status: "enabled";
+      readonly provider: string;
+      readonly algorithm: "RSA-SHA256";
+    };
+
+export const inspectBundleSigning = async (
+  signing: ConsoleSigningConfig | undefined,
+): Promise<BundleSigningInspection> => {
+  if (!signing?.enabled) return { status: "disabled" };
+
+  return {
+    algorithm: "RSA-SHA256",
+    provider: signing.provider ?? DEFAULT_PROVIDER,
+    status: "enabled",
+  };
+};