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

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

@@ -0,0 +1,109 @@
+import {
+  assertStorageOperations,
+  createDatabaseClient,
+  type DatabaseClient,
+  type StoragePluginWith,
+} 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"]>;
+};
+
+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;
+
+const loadCachedConfig = async (request: Request) => {
+  if (!configPromise) {
+    configPromise = resolveConsoleConfig(request)
+      .then((config) => ({
+        ...config,
+        console: config.console ?? {},
+      }))
+      .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);
+    }
+
+    if (!apiKeyStoreResolved) {
+      const { createApiKeyStore } = await import("./runtime.server");
+      apiKeyStore = createApiKeyStore(config);
+      apiKeyStoreResolved = true;
+    }
+
+    const storagePlugin = await loadCachedStoragePlugin(config);
+
+    return {
+      config,
+      databaseClient,
+      hotUpdater,
+      apiKeyStore,
+      storagePlugin,
+    };
+  } catch (error) {
+    if (
+      !(
+        error instanceof Response &&
+        (error.status === 401 || error.status === 403)
+      )
+    ) {
+      console.error("Error during configuration initialization:", error);
+    }
+    throw error;
+  }
+};
+
+export const isConfigLoaded = () => Boolean(configPromise);

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

@@ -0,0 +1,61 @@
+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;
+};
+
+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),
+  };
+};
+
+export const getConsoleAuthAdapter = async (): Promise<ConsoleAuthAdapter> => {
+  const module = await import("virtual:hot-updater-console/auth");
+  return module.default;
+};
+
+export const resolveConsoleConfig = async (
+  request: Request,
+): Promise<ResolvedHotUpdaterConsoleConfig> => {
+  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);
+  return {
+    ...configWithoutSigning,
+    ...(signing === undefined ? {} : { signing }),
+  };
+};

package/src/lib/server/deleteBundle.ts

@@ -0,0 +1,145 @@
+import {
+  getBundlePatches,
+  getManifestStorageUri,
+  getPatchStorageUri,
+} from "@hot-updater/core";
+import type {
+  Bundle,
+  DatabaseClient,
+  StoragePluginWith,
+} from "@hot-updater/plugin-core";
+
+interface DeleteBundleInput {
+  bundleId: string;
+}
+
+interface DeleteBundlesInput {
+  bundleIds: readonly string[];
+}
+
+interface DeleteBundleDependencies {
+  databaseClient: DatabaseClient;
+  storagePlugin: StoragePluginWith<"delete">;
+  waitForStorageCleanup?: boolean;
+}
+
+function resolveStorageUriForDeletion(
+  storageUri: string,
+  storagePlugin: StoragePluginWith<"delete">,
+) {
+  const protocol = new URL(storageUri).protocol.replace(":", "");
+
+  if (storagePlugin.protocol === protocol) {
+    return storageUri;
+  }
+
+  if (protocol === "http" || protocol === "https") {
+    return null;
+  }
+
+  throw new Error(`No storage plugin for protocol: ${protocol}`);
+}
+
+async function cleanupBundleStorage(
+  bundle: Bundle,
+  storagePlugin: StoragePluginWith<"delete">,
+) {
+  const cleanupUris = new Set<string>();
+  const addCleanupUri = (storageUri: string | undefined) => {
+    if (!storageUri) return;
+    const resolvedStorageUri = resolveStorageUriForDeletion(
+      storageUri,
+      storagePlugin,
+    );
+    if (resolvedStorageUri) cleanupUris.add(resolvedStorageUri);
+  };
+
+  addCleanupUri(bundle.storageUri);
+  addCleanupUri(getManifestStorageUri(bundle) ?? undefined);
+  addCleanupUri(getPatchStorageUri(bundle) ?? undefined);
+  for (const patch of getBundlePatches(bundle)) {
+    addCleanupUri(patch.patchStorageUri);
+  }
+
+  for (const storageUri of cleanupUris) {
+    try {
+      await storagePlugin.delete({ storageUri });
+    } catch (error) {
+      console.error("Failed to delete bundle from storage:", error);
+    }
+  }
+}
+
+export async function deleteBundles(
+  { bundleIds }: DeleteBundlesInput,
+  {
+    databaseClient,
+    storagePlugin,
+    waitForStorageCleanup = true,
+  }: DeleteBundleDependencies,
+) {
+  const uniqueBundleIds = [...new Set(bundleIds)];
+  const { data: matchedBundles } = await databaseClient.getBundles({
+    where: { id: { in: uniqueBundleIds } },
+    limit: uniqueBundleIds.length,
+  });
+  const matchedById = new Map(
+    matchedBundles.map((bundle) => [bundle.id, bundle]),
+  );
+  const bundles = uniqueBundleIds.flatMap((bundleId) => {
+    const bundle = matchedById.get(bundleId);
+    return bundle ? [bundle] : [];
+  });
+  const missingBundleIds = uniqueBundleIds.filter(
+    (bundleId) => !matchedById.has(bundleId),
+  );
+
+  for (const bundle of bundles) {
+    const cleanupCandidates = [
+      bundle.storageUri,
+      getManifestStorageUri(bundle),
+      getPatchStorageUri(bundle),
+      ...getBundlePatches(bundle).map((patch) => patch.patchStorageUri),
+    ].filter((value): value is string => Boolean(value));
+    for (const candidate of cleanupCandidates) {
+      resolveStorageUriForDeletion(candidate, storagePlugin);
+    }
+  }
+
+  if (bundles.length > 0) {
+    await databaseClient.mutate(async (mutation) => {
+      for (const bundle of bundles) {
+        await mutation.deleteBundleById(bundle.id);
+      }
+    });
+  }
+
+  const cleanupStorage = async () => {
+    for (const bundle of bundles) {
+      await cleanupBundleStorage(bundle, storagePlugin);
+    }
+  };
+
+  if (waitForStorageCleanup) {
+    await cleanupStorage();
+  } else {
+    void cleanupStorage().catch((error) => {
+      console.error("Failed to clean up bundle storage:", error);
+    });
+  }
+
+  return {
+    deletedBundleIds: bundles.map((bundle) => bundle.id),
+    missingBundleIds,
+  };
+}
+
+export async function deleteBundle(
+  { bundleId }: DeleteBundleInput,
+  dependencies: DeleteBundleDependencies,
+) {
+  const result = await deleteBundles({ bundleIds: [bundleId] }, dependencies);
+  if (result.missingBundleIds.length > 0) {
+    throw new Error(`Bundle not found: ${bundleId}`);
+  }
+}

package/src/lib/server/downloadBundle.ts

@@ -0,0 +1,46 @@
+import type {
+  DatabaseClient,
+  StoragePluginWith,
+} from "@hot-updater/plugin-core";
+
+interface DownloadBundleDependencies {
+  readonly databaseClient: DatabaseClient;
+  readonly storagePlugin?: StoragePluginWith<"get">;
+}
+
+export const downloadBundle = async (
+  bundleId: string,
+  { databaseClient, storagePlugin }: DownloadBundleDependencies,
+): Promise<Response> => {
+  const bundle = await databaseClient.getBundleById(bundleId);
+  if (!bundle) 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 protocol = new URL(storageUri).protocol.replace(":", "");
+  if (storagePlugin?.protocol === protocol) {
+    const { response } = await storagePlugin.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");
+    return new Response(response.body, {
+      headers,
+      status: response.status,
+      statusText: response.statusText,
+    });
+  }
+
+  if (protocol !== "http" && protocol !== "https") {
+    return new Response(`No storage plugin for protocol: ${protocol}`, {
+      status: 503,
+    });
+  }
+
+  return Response.redirect(storageUri, 302);
+};

package/src/lib/server/getBundleChildren.ts

@@ -0,0 +1,130 @@
+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;
+}
+
+export async function getBundleChildren(
+  { baseBundleId }: GetBundleChildrenInput,
+  deps: GetBundleChildrenDeps,
+): Promise<Bundle[]> {
+  const childrenByBaseId = await collectBundleChildrenByBaseIds(
+    [baseBundleId],
+    deps,
+  );
+
+  return childrenByBaseId[baseBundleId] ?? [];
+}
+
+export async function getBundleChildCounts(
+  baseBundleIds: string[],
+  deps: GetBundleChildrenDeps,
+): Promise<Record<string, number>> {
+  const childrenByBaseId = await collectBundleChildrenByBaseIds(
+    baseBundleIds,
+    deps,
+  );
+
+  return Object.fromEntries(
+    Object.entries(childrenByBaseId).map(([bundleId, bundles]) => [
+      bundleId,
+      bundles.length,
+    ]),
+  );
+}

package/src/lib/server/listReleases.ts

@@ -0,0 +1,61 @@
+import type { ReleaseModel, ReleaseRow } from "@hot-updater/plugin-core";
+
+export interface ReleaseListInput {
+  afterReleaseId?: string;
+  beforeReleaseId?: string;
+  bundleId?: string;
+  channelId?: string;
+  enabled?: boolean;
+  limit: number;
+  page?: number;
+  platform?: "ios" | "android";
+  targetAppVersion?: string;
+}
+
+export interface ReleaseListResult {
+  data: readonly ReleaseRow[];
+  pagination: {
+    currentPage: number;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+  };
+}
+
+export async function listReleases(
+  releases: ReleaseModel,
+  input: ReleaseListInput,
+): Promise<ReleaseListResult> {
+  const page = input.page ?? 1;
+  const rows = await releases.findMany({
+    ...(input.afterReleaseId === undefined
+      ? {}
+      : { afterReleaseId: input.afterReleaseId }),
+    ...(input.beforeReleaseId === undefined
+      ? {}
+      : { beforeReleaseId: input.beforeReleaseId }),
+    ...(input.bundleId === undefined ? {} : { bundleId: input.bundleId }),
+    ...(input.channelId === undefined ? {} : { channelId: input.channelId }),
+    ...(input.enabled === undefined ? {} : { enabled: input.enabled }),
+    ...(input.platform === undefined ? {} : { platform: input.platform }),
+    ...(input.targetAppVersion === undefined
+      ? {}
+      : { targetAppVersion: input.targetAppVersion }),
+    limit: input.limit + 1,
+  });
+  const isPreviousRequest = input.afterReleaseId !== undefined;
+  const hasExtraRow = rows.length > input.limit;
+  const data = isPreviousRequest
+    ? hasExtraRow
+      ? rows.slice(1)
+      : rows
+    : rows.slice(0, input.limit);
+
+  return {
+    data,
+    pagination: {
+      currentPage: page,
+      hasNextPage: isPreviousRequest || hasExtraRow,
+      hasPreviousPage: page > 1,
+    },
+  };
+}

package/src/lib/server/releaseActivity.ts

@@ -0,0 +1,27 @@
+import type { ReleaseRow } from "@hot-updater/plugin-core";
+import type {
+  InsightsProvider,
+  BundleEventSummaryByBundle,
+} from "@hot-updater/server";
+
+export async function getReleaseActivity30d(
+  insights: Pick<InsightsProvider, "getBundleEventSummaries"> | null,
+  releases: readonly ReleaseRow[],
+): Promise<ReadonlyMap<string, BundleEventSummaryByBundle>> {
+  const bundleIds = [
+    ...new Set(
+      releases.flatMap(({ bundle_id }) =>
+        bundle_id === null ? [] : [bundle_id],
+      ),
+    ),
+  ];
+  if (insights === null || bundleIds.length === 0) return new Map();
+
+  try {
+    const summaries = await insights.getBundleEventSummaries(bundleIds, "30d");
+    return new Map(summaries.map((summary) => [summary.bundleId, summary]));
+  } catch (error) {
+    console.error("Error during Release list activity retrieval:", error);
+    return new Map();
+  }
+}

package/src/lib/server/releaseReachability.ts

@@ -0,0 +1,95 @@
+import {
+  isReleaseEligibleForCohort,
+  NUMERIC_COHORT_SIZE,
+} from "@hot-updater/core";
+import type {
+  CompiledReleaseCatalog,
+  ReleaseCatalogModel,
+  ReleaseRow,
+} from "@hot-updater/plugin-core";
+import type { BundleEventSummary } from "@hot-updater/server";
+
+export type ReleaseReachabilityRow = ReleaseRow & {
+  readonly currentlyUnreachable: boolean;
+};
+
+export type ReleaseListRow = ReleaseReachabilityRow & {
+  readonly activity30d: BundleEventSummary | null;
+};
+
+const NON_TARGETED_COHORT = "release-catalog-non-targeted-cohort";
+
+function collectReachableFromIndexes(
+  catalog: CompiledReleaseCatalog,
+  indexes: readonly number[],
+  reachableReleaseIds: Set<string>,
+) {
+  const descriptors = indexes.flatMap((index) => {
+    const descriptor = catalog.releaseDescriptors[index];
+    return descriptor === undefined ? [] : [descriptor];
+  });
+  const cohorts = new Set<string | undefined>([
+    undefined,
+    ...Array.from({ length: NUMERIC_COHORT_SIZE }, (_, index) =>
+      String(index + 1),
+    ),
+    ...descriptors.flatMap(({ targetCohorts }) => targetCohorts),
+    NON_TARGETED_COHORT,
+  ]);
+
+  for (const cohort of cohorts) {
+    const selected = descriptors.find(
+      (descriptor) =>
+        descriptor.kind === "BUNDLE" &&
+        descriptor.bundleId !== null &&
+        isReleaseEligibleForCohort(descriptor, cohort),
+    );
+    if (selected !== undefined) {
+      reachableReleaseIds.add(selected.releaseId);
+    }
+  }
+}
+
+export function collectCurrentlyReachableReleaseIds(
+  catalog: CompiledReleaseCatalog,
+): ReadonlySet<string> {
+  const reachableReleaseIds = new Set<string>();
+  const indexGroups =
+    catalog.strategy === "APP_VERSION"
+      ? catalog.segments.map(({ releaseIndexes }) => releaseIndexes)
+      : [catalog.releaseIndexes];
+
+  for (const indexes of indexGroups) {
+    collectReachableFromIndexes(catalog, indexes, reachableReleaseIds);
+  }
+
+  return reachableReleaseIds;
+}
+
+export async function addReleaseReachability(
+  releaseCatalogs: Pick<ReleaseCatalogModel, "findByScopeKey">,
+  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 reachableReleaseIds =
+          row === null
+            ? new Set<string>()
+            : collectCurrentlyReachableReleaseIds(
+                JSON.parse(row.payload) as CompiledReleaseCatalog,
+              );
+        return [scopeKey, reachableReleaseIds] as const;
+      }),
+    ),
+  );
+
+  return releases.map((release) => ({
+    ...release,
+    currentlyUnreachable: !reachableByScope
+      .get(release.scope_key)
+      ?.has(release.id),
+  }));
+}