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

package/src/lib/api.ts

@@ -0,0 +1,444 @@
+import type {
+  ChannelDeleteInput,
+  ChannelInsertInput,
+  ReleasePolicyPatch,
+} from "@hot-updater/plugin-core";
+import type { BundleEventInsightsWindow } 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,
+  getBundleEventInsights as getBundleEventInsightsApi,
+  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 INSIGHTS_STALE_TIME_MS = 30_000;
+
+export type BundleEventSummary = Awaited<
+  ReturnType<typeof getBundleEventSummaryApi>
+>;
+export type BundleEventInsights = Awaited<
+  ReturnType<typeof getBundleEventInsightsApi>
+>;
+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,
+  bundleEventInsights: (input: {
+    bundleId: string;
+    window: BundleEventInsightsWindow;
+    limit?: number;
+    offset?: number;
+  }) => ["bundle-event-insights", 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: INSIGHTS_STALE_TIME_MS,
+    refetchOnWindowFocus: true,
+    enabled: enabled && bundleId.length > 0,
+  });
+}
+
+export function useBundleEventInsightsQuery(
+  input: {
+    bundleId: string;
+    window: BundleEventInsightsWindow;
+    limit?: number;
+    offset?: number;
+  },
+  enabled: boolean,
+) {
+  return useQuery({
+    queryKey: queryKeys.bundleEventInsights(input),
+    queryFn: () => getBundleEventInsightsApi({ data: input }),
+    staleTime: INSIGHTS_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: INSIGHTS_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: INSIGHTS_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/insights-api.ts

@@ -0,0 +1,144 @@
+import { type QueryClient, useQuery } from "@tanstack/react-query";
+import { redirect } from "@tanstack/react-router";
+
+import {
+  type ActiveInstallationInput,
+  parseActiveInstallationInput,
+} from "./insights-input";
+import {
+  getActiveInstallationOverviewRpc,
+  getInsightsCapabilitiesRpc,
+  getInsightsOverviewRpc,
+  type InsightsCapabilities,
+} from "./insights-rpc";
+
+export type InsightsCapabilityState =
+  | { readonly status: "unresolved" }
+  | { readonly status: "unsupported" }
+  | {
+      readonly status: "supported";
+      readonly mode: "bounded";
+      readonly maxMatchingRows: number;
+    }
+  | { readonly status: "error"; readonly error: Error };
+
+type InsightsCapabilityQueryResult =
+  | { readonly status: "pending" }
+  | { readonly status: "success"; readonly data: InsightsCapabilities }
+  | { readonly status: "error"; readonly error: Error };
+
+export type ProtectedInsightsRouteDecision =
+  | "loading"
+  | "redirect"
+  | "allow"
+  | "error";
+
+export const insightsQueryKeys = {
+  capabilities: ["insights", "capabilities"] as const,
+  overview: ["insights", "overview"] as const,
+  activeInstallations: (input: ActiveInstallationInput) =>
+    [
+      "insights",
+      "active-installations",
+      input.window,
+      input.userId ?? null,
+    ] as const,
+};
+
+const INSIGHTS_STALE_TIME_MS = 30_000;
+
+export const getInsightsCapabilityState = (
+  query: InsightsCapabilityQueryResult,
+): InsightsCapabilityState => {
+  switch (query.status) {
+    case "pending":
+      return { status: "unresolved" };
+    case "error":
+      return { status: "error", error: query.error };
+    case "success":
+      if (!query.data.capabilities.insights) {
+        return { status: "unsupported" };
+      }
+      return {
+        status: "supported",
+        mode: "bounded",
+        maxMatchingRows: query.data.capabilities.maxMatchingRows,
+      };
+  }
+};
+
+export const getProtectedInsightsRouteDecision = (
+  capability: InsightsCapabilityState,
+): ProtectedInsightsRouteDecision => {
+  switch (capability.status) {
+    case "unresolved":
+      return "loading";
+    case "unsupported":
+      return "redirect";
+    case "supported":
+      return "allow";
+    case "error":
+      return "error";
+  }
+};
+
+export const isInsightsQueryEnabled = (
+  capability: InsightsCapabilityState,
+): boolean => capability.status === "supported";
+
+export const getInsightsCapabilitiesQueryOptions = () => ({
+  queryKey: insightsQueryKeys.capabilities,
+  queryFn: () => getInsightsCapabilitiesRpc(),
+  staleTime: Infinity,
+});
+
+export const useInsightsCapabilitiesQuery = () =>
+  useQuery(getInsightsCapabilitiesQueryOptions());
+
+export const ensureInsightsRouteAccess = async (
+  queryClient: QueryClient,
+): Promise<void> => {
+  const result = await queryClient.ensureQueryData(
+    getInsightsCapabilitiesQueryOptions(),
+  );
+
+  if (!result.capabilities.insights) {
+    throw redirect({
+      to: "/",
+      search: {},
+      replace: true,
+    });
+  }
+};
+
+export const getInsightsOverviewQueryOptions = (
+  capability: InsightsCapabilityState,
+) => ({
+  queryKey: insightsQueryKeys.overview,
+  queryFn: () => getInsightsOverviewRpc(),
+  staleTime: INSIGHTS_STALE_TIME_MS,
+  refetchOnWindowFocus: true,
+  enabled: isInsightsQueryEnabled(capability),
+});
+
+export const useInsightsOverviewQuery = (capability: InsightsCapabilityState) =>
+  useQuery(getInsightsOverviewQueryOptions(capability));
+
+export const getActiveInstallationQueryOptions = (
+  capability: InsightsCapabilityState,
+  input: ActiveInstallationInput,
+) => {
+  const normalized = parseActiveInstallationInput(input);
+  return {
+    queryKey: insightsQueryKeys.activeInstallations(normalized),
+    queryFn: () => getActiveInstallationOverviewRpc({ data: normalized }),
+    staleTime: INSIGHTS_STALE_TIME_MS,
+    refetchOnWindowFocus: true,
+    enabled: isInsightsQueryEnabled(capability),
+  };
+};
+
+export const useActiveInstallationQuery = (
+  capability: InsightsCapabilityState,
+  input: ActiveInstallationInput,
+) => useQuery(getActiveInstallationQueryOptions(capability, input));

package/src/lib/insights-error.ts

@@ -0,0 +1,19 @@
+export type InsightsErrorCopy = {
+  readonly title: string;
+  readonly description: string;
+};
+
+export const getInsightsErrorCopy = (
+  error: Error,
+  fallbackTitle: string,
+): InsightsErrorCopy => {
+  const match = /^Bundle event scan exceeded (\d+) rows\.$/.exec(error.message);
+  if (!match) {
+    return { title: fallbackTitle, description: error.message };
+  }
+  const limit = Number(match[1]);
+  return {
+    title: "Insights report limit reached",
+    description: `This query matched more than ${limit.toLocaleString()} reports. Narrow the query and try again.`,
+  };
+};