@hot-updater/console 0.36.6 → 1.0.0-rc.0

package/src/lib/api.ts

@@ -0,0 +1,444 @@
+import type {
+  ChannelDeleteInput,
+  ChannelInsertInput,
+  ReleasePolicyPatch,
+} from "@hot-updater/plugin-core";
+import type { BundleEventAnalyticsWindow } from "@hot-updater/server";
+import {
+  type QueryClient,
+  type QueryKey,
+  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,
+  getBundleEventAnalytics as getBundleEventAnalyticsApi,
+  getBundleEventSummary as getBundleEventSummaryApi,
+  getBundles,
+  getChannels,
+  getConfig,
+  getConfigLoaded,
+  getInstallationHistory as getInstallationHistoryApi,
+  getRelease,
+  getReleaseCatalogDiagnostics,
+  getReleases,
+  preflightRelease as preflightReleaseApi,
+  promoteRelease as promoteReleaseApi,
+  searchInstallations as searchInstallationsApi,
+  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 ANALYTICS_STALE_TIME_MS = 30_000;
+
+export type BundleEventSummary = Awaited<
+  ReturnType<typeof getBundleEventSummaryApi>
+>;
+export type BundleEventAnalytics = Awaited<
+  ReturnType<typeof getBundleEventAnalyticsApi>
+>;
+export type InstallationSearchResult = Awaited<
+  ReturnType<typeof searchInstallationsApi>
+>;
+export type InstallationHistoryResult = Awaited<
+  ReturnType<typeof getInstallationHistoryApi>
+>;
+export type InstallationSearchRow = InstallationSearchResult["data"][number];
+export type InstallationHistoryRow = InstallationHistoryResult["data"][number];
+
+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) =>
+      [...releaseListQueryKey, filters ?? {}] as const,
+  },
+  release: (releaseId: string) => ["release", releaseId] as const,
+  releaseCatalog: (scopeKey: string) => ["release-catalog", scopeKey] as const,
+  bundleChildren: {
+    all: ["bundle-children"] as const,
+    list: (baseBundleId: string) => ["bundle-children", baseBundleId] as const,
+    counts: (bundleIds: string[]) =>
+      ["bundle-children", "counts", ...bundleIds] as const,
+  },
+  bundle: (bundleId: string) => ["bundle", bundleId] as const,
+  bundleEventSummary: (bundleId: string) =>
+    ["bundle-event-summary", bundleId] as const,
+  bundleEventAnalytics: (input: {
+    bundleId: string;
+    window: BundleEventAnalyticsWindow;
+    limit?: number;
+    offset?: number;
+  }) => ["bundle-event-analytics", input] as const,
+
+  installations: {
+    search: (input: { query: string; limit?: number; offset?: number }) =>
+      ["installations", "search", input] as const,
+    history: (input: { installId: string; limit?: number; offset?: number }) =>
+      ["installations", "history", input] as const,
+  },
+};
+
+export type ReleaseFilters = {
+  afterReleaseId?: string;
+  beforeReleaseId?: string;
+  bundleId?: string;
+  channelId?: string;
+  enabled?: boolean;
+  platform?: "ios" | "android";
+  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
+export function useConfigQuery() {
+  return useQuery({
+    queryKey: queryKeys.config,
+    queryFn: () => getConfig(),
+    staleTime: Infinity,
+  });
+}
+
+export function useChannelsQuery() {
+  return useQuery({
+    queryKey: queryKeys.channels,
+    queryFn: () => getChannels(),
+    staleTime: Infinity,
+  });
+}
+
+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),
+    queryFn: () => getReleases({ data: filters }),
+    placeholderData: (previousData) => previousData,
+  });
+}
+
+export function useReleaseQuery(releaseId: string) {
+  return useQuery({
+    enabled: releaseId.length > 0,
+    queryFn: () => getRelease({ data: { releaseId } }),
+    queryKey: queryKeys.release(releaseId),
+  });
+}
+
+export function useReleaseCatalogDiagnosticsQuery(scopeKey: string) {
+  return useQuery({
+    enabled: scopeKey.length > 0,
+    queryFn: () => getReleaseCatalogDiagnostics({ data: { scopeKey } }),
+    queryKey: queryKeys.releaseCatalog(scopeKey),
+  });
+}
+
+export function useBundleQuery(bundleId: string) {
+  return useQuery({
+    queryKey: queryKeys.bundle(bundleId),
+    queryFn: () => getBundle({ data: { bundleId } }),
+    staleTime: Infinity,
+    enabled: !!bundleId,
+  });
+}
+
+export function useBundleEventSummaryQuery(bundleId: string, enabled: boolean) {
+  return useQuery({
+    queryKey: queryKeys.bundleEventSummary(bundleId),
+    queryFn: () => getBundleEventSummaryApi({ data: { bundleId } }),
+    staleTime: ANALYTICS_STALE_TIME_MS,
+    refetchOnWindowFocus: true,
+    enabled: enabled && bundleId.length > 0,
+  });
+}
+
+export function useBundleEventAnalyticsQuery(
+  input: {
+    bundleId: string;
+    window: BundleEventAnalyticsWindow;
+    limit?: number;
+    offset?: number;
+  },
+  enabled: boolean,
+) {
+  return useQuery({
+    queryKey: queryKeys.bundleEventAnalytics(input),
+    queryFn: () => getBundleEventAnalyticsApi({ data: input }),
+    staleTime: ANALYTICS_STALE_TIME_MS,
+    refetchOnWindowFocus: true,
+    enabled: enabled && input.bundleId.length > 0,
+  });
+}
+
+export function useInstallationSearchQuery(
+  input: {
+    query: string;
+    limit?: number;
+    offset?: number;
+  },
+  enabled: boolean,
+) {
+  return useQuery({
+    queryKey: queryKeys.installations.search(input),
+    queryFn: () => searchInstallationsApi({ data: input }),
+    staleTime: ANALYTICS_STALE_TIME_MS,
+    refetchOnWindowFocus: true,
+    enabled: enabled && input.query.trim().length > 0,
+  });
+}
+
+export function useInstallationHistoryQuery(
+  input: {
+    installId: string;
+    limit?: number;
+    offset?: number;
+  },
+  enabled: boolean,
+) {
+  return useQuery({
+    queryKey: queryKeys.installations.history(input),
+    queryFn: () => getInstallationHistoryApi({ data: input }),
+    staleTime: ANALYTICS_STALE_TIME_MS,
+    refetchOnWindowFocus: true,
+    enabled: enabled && input.installId.length > 0,
+  });
+}
+
+export function useBundleChildrenQuery(baseBundleId: string) {
+  return useQuery({
+    queryKey: queryKeys.bundleChildren.list(baseBundleId),
+    queryFn: () => getBundleChildren({ data: { baseBundleId } }),
+    staleTime: Infinity,
+    enabled: !!baseBundleId,
+  });
+}
+
+export function useBundleChildCountsQuery(bundleIds: string[]) {
+  const normalizedBundleIds = [...bundleIds].sort((left, right) =>
+    left.localeCompare(right),
+  );
+
+  return useQuery({
+    queryKey: queryKeys.bundleChildren.counts(normalizedBundleIds),
+    queryFn: () =>
+      getBundleChildCounts({ data: { bundleIds: normalizedBundleIds } }),
+    staleTime: Infinity,
+    enabled: normalizedBundleIds.length > 0,
+  });
+}
+
+// Mutation Hooks
+export function useCreateChannelMutation() {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: (input: ChannelInsertInput) =>
+      createChannelApi({ data: input }).then((response) => response.data),
+    onSuccess: async () => {
+      await queryClient.invalidateQueries({ queryKey: queryKeys.channels });
+    },
+  });
+}
+
+export function useDeleteChannelMutation() {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: (input: ChannelDeleteInput) =>
+      deleteChannelApi({ data: input }).then((response) => response.data),
+    onSettled: async () => {
+      await queryClient.invalidateQueries({ queryKey: queryKeys.channels });
+    },
+  });
+}
+
+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({
+    mutationFn: (input: {
+      expectedRevision: number;
+      patch: ReleasePolicyPatch;
+      releaseId: string;
+    }) => updateReleaseApi({ data: input }),
+    onSuccess: async (_, input) => {
+      await Promise.all([
+        queryClient.invalidateQueries({ queryKey: queryKeys.releases.all }),
+        queryClient.invalidateQueries({
+          queryKey: queryKeys.release(input.releaseId),
+        }),
+        queryClient.invalidateQueries({ queryKey: ["release-catalog"] }),
+        queryClient.invalidateQueries({ queryKey: queryKeys.channels }),
+      ]);
+    },
+  });
+}
+
+export function usePreflightReleaseMutation() {
+  return useMutation({
+    mutationFn: (input: {
+      expectedRevision: number;
+      patch: ReleasePolicyPatch;
+      releaseId: string;
+    }) => preflightReleaseApi({ data: input }),
+  });
+}
+
+export function useDeleteReleaseMutation() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (input: { expectedRevision: number; releaseId: string }) =>
+      deleteReleaseApi({ data: input }),
+    onSuccess: async (_, input) => {
+      queryClient.removeQueries({
+        queryKey: queryKeys.release(input.releaseId),
+      });
+      await Promise.all([
+        queryClient.invalidateQueries({ queryKey: queryKeys.releases.all }),
+        queryClient.invalidateQueries({ queryKey: ["release-catalog"] }),
+        queryClient.invalidateQueries({ queryKey: queryKeys.channels }),
+      ]);
+    },
+  });
+}
+
+export function usePromoteReleaseMutation() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (input: {
+      action: "copy" | "move";
+      expectedRevision: number;
+      releaseId: string;
+      targetChannel: string;
+    }) => promoteReleaseApi({ data: input }),
+    onSuccess: async () => {
+      await Promise.all([
+        queryClient.invalidateQueries({ queryKey: queryKeys.releases.all }),
+        queryClient.invalidateQueries({ queryKey: ["release"] }),
+        queryClient.invalidateQueries({ queryKey: ["release-catalog"] }),
+        queryClient.invalidateQueries({ queryKey: queryKeys.channels }),
+      ]);
+    },
+  });
+}

package/src/lib/auth-rpc.ts

@@ -0,0 +1,16 @@
+import { createServerFn } from "@tanstack/react-start";
+import { getRequest } from "@tanstack/react-start/server";
+
+export const getConsoleAccessRpc = createServerFn({ method: "GET" }).handler(
+  async () => {
+    const { getConsoleAccess } = await import("./server/auth.server");
+    return getConsoleAccess(getRequest());
+  },
+);
+
+export const getConsoleAuthProvidersRpc = createServerFn({
+  method: "GET",
+}).handler(async () => {
+  const { getConsoleAuthProviders } = await import("./server/auth.server");
+  return getConsoleAuthProviders(getRequest());
+});

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

@@ -0,0 +1,14 @@
+import { useQuery } from "@tanstack/react-query";
+
+import { getBundleSigningInspectionRpc } from "./bundle-signing-rpc";
+
+export const bundleSigningQueryKey = ["bundle-signing"] as const;
+
+export const getBundleSigningInspectionQueryOptions = () => ({
+  queryFn: () => getBundleSigningInspectionRpc(),
+  queryKey: bundleSigningQueryKey,
+  staleTime: 30_000,
+});
+
+export const useBundleSigningInspectionQuery = () =>
+  useQuery(getBundleSigningInspectionQueryOptions());

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

@@ -0,0 +1,16 @@
+import { createServerFn } from "@tanstack/react-start";
+
+export type { BundleSigningInspection } from "./server/bundle-signing.server";
+
+export const getBundleSigningInspection = async () => {
+  const [{ prepareConfig }, { inspectBundleSigning }] = await Promise.all([
+    import("./server/config.server"),
+    import("./server/bundle-signing.server"),
+  ]);
+  const { config } = await prepareConfig();
+  return inspectBundleSigning(config.signing);
+};
+
+export const getBundleSigningInspectionRpc = createServerFn({
+  method: "GET",
+}).handler(getBundleSigningInspection);

package/src/lib/constants.ts

@@ -0,0 +1 @@
+export const DEFAULT_PAGE_LIMIT = 20;

package/src/lib/git.ts

@@ -0,0 +1,51 @@
+const normalizeGitUrl = (gitUrl: string) => {
+  const trimmedGitUrl = gitUrl.trim();
+
+  if (trimmedGitUrl.startsWith("git@")) {
+    const sshMatch = trimmedGitUrl.match(/^git@([^:]+):(.+?)(?:\.git)?$/);
+
+    if (sshMatch) {
+      return `https://${sshMatch[1]}/${sshMatch[2]}`;
+    }
+  }
+
+  if (trimmedGitUrl.startsWith("ssh://")) {
+    try {
+      const url = new URL(trimmedGitUrl);
+      return `https://${url.hostname}${url.pathname}`
+        .replace(/\/+$/, "")
+        .replace(/\.git$/, "");
+    } catch {
+      return trimmedGitUrl.replace(/\/+$/, "").replace(/\.git$/, "");
+    }
+  }
+
+  return trimmedGitUrl.replace(/\/+$/, "").replace(/\.git$/, "");
+};
+
+export const getCommitUrl = (
+  gitUrl: string | undefined,
+  commitHash: string,
+) => {
+  if (!gitUrl?.trim()) {
+    return null;
+  }
+
+  const normalizedGitUrl = normalizeGitUrl(gitUrl);
+
+  try {
+    const { hostname } = new URL(normalizedGitUrl);
+
+    if (hostname.includes("gitlab")) {
+      return `${normalizedGitUrl}/-/commit/${commitHash}`;
+    }
+
+    if (hostname.includes("bitbucket")) {
+      return `${normalizedGitUrl}/commits/${commitHash}`;
+    }
+  } catch {
+    // Fall back to the default commit route for custom git hosts.
+  }
+
+  return `${normalizedGitUrl}/commit/${commitHash}`;
+};

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,100 @@
+import { createHash, createPublicKey } from "node:crypto";
+import { readFile, stat } from "node:fs/promises";
+import path from "node:path";
+
+import type { ConsoleSigningConfig } from "../../index";
+
+const MAX_PUBLIC_KEY_BYTES = 16 * 1024;
+const DEFAULT_PROVIDER = "Configured provider";
+const PUBLIC_KEY_HEADER = "-----BEGIN PUBLIC KEY-----";
+const PUBLIC_KEY_FOOTER = "-----END PUBLIC KEY-----";
+
+export type BundleSigningInspection =
+  | { readonly status: "disabled" }
+  | {
+      readonly status: "misconfigured";
+      readonly provider: string;
+      readonly message: string;
+    }
+  | {
+      readonly status: "enabled";
+      readonly provider: string;
+      readonly algorithm: "RSA-SHA256";
+      readonly fingerprint: string;
+      readonly publicKey: string;
+    };
+
+const misconfigured = (
+  provider: string,
+  message: string,
+): BundleSigningInspection => ({ message, provider, status: "misconfigured" });
+
+const isSpkiPublicKeyPem = (value: string): boolean => {
+  const trimmed = value.trim();
+  return (
+    trimmed.startsWith(PUBLIC_KEY_HEADER) &&
+    trimmed.endsWith(PUBLIC_KEY_FOOTER) &&
+    !trimmed.includes("PRIVATE KEY")
+  );
+};
+
+export const inspectBundleSigning = async (
+  signing: ConsoleSigningConfig | undefined,
+): Promise<BundleSigningInspection> => {
+  if (!signing?.enabled) return { status: "disabled" };
+
+  const provider = signing.provider ?? DEFAULT_PROVIDER;
+  if (!signing.publicKeyPath) {
+    return misconfigured(provider, "A public key file is not configured.");
+  }
+
+  try {
+    const publicKeyPath = path.isAbsolute(signing.publicKeyPath)
+      ? signing.publicKeyPath
+      : path.resolve(process.cwd(), signing.publicKeyPath);
+    const publicKeyStat = await stat(publicKeyPath);
+    if (!publicKeyStat.isFile() || publicKeyStat.size > MAX_PUBLIC_KEY_BYTES) {
+      return misconfigured(
+        provider,
+        "The configured public key could not be loaded.",
+      );
+    }
+
+    const publicKeyPem = await readFile(publicKeyPath, "utf8");
+    if (!isSpkiPublicKeyPem(publicKeyPem)) {
+      return misconfigured(
+        provider,
+        "The configured public key is not a valid SPKI public key.",
+      );
+    }
+
+    const publicKey = createPublicKey(publicKeyPem);
+    if (publicKey.asymmetricKeyType !== "rsa") {
+      return misconfigured(
+        provider,
+        "The configured public key is not an RSA public key.",
+      );
+    }
+    if ((publicKey.asymmetricKeyDetails?.modulusLength ?? 0) < 2048) {
+      return misconfigured(
+        provider,
+        "The configured RSA public key must be at least 2048 bits.",
+      );
+    }
+
+    const canonicalDer = publicKey.export({ format: "der", type: "spki" });
+    const canonicalPem = publicKey.export({ format: "pem", type: "spki" });
+    return {
+      algorithm: "RSA-SHA256",
+      fingerprint: createHash("sha256").update(canonicalDer).digest("hex"),
+      provider,
+      publicKey: canonicalPem.toString().trim(),
+      status: "enabled",
+    };
+  } catch {
+    return misconfigured(
+      provider,
+      "The configured public key could not be loaded.",
+    );
+  }
+};