@yugabytedb/perf-advisor-ui 1.0.160 → 1.0.162

package/dist/api.d.ts

@@ -1,5 +1,5 @@
 import { AxiosError, AxiosRequestConfig, AxiosResponse } from 'axios';
-import { Anomaly, AnomalyDetectionStatus, AnomalyGroup, BackgroundTasksResponse, ClusterLoadResponseData, MetadataFields, GraphRequestParams, QueryPlanData, QueryStatsPagedBody, ClusterDetails, IndexPagedResponse, MaterializedViewPagedResponse, TablePagedResponse } from './helpers/dtos';
+import { Anomaly, AnomalyDetectionStatus, AnomalyGroup, BackgroundTasksResponse, ClusterLoadResponseData, MetadataFields, GraphRequestParams, QueryPlanData, QueryStatsPagedBody, ClusterDetails, IndexPagedResponse, MaterializedViewPagedResponse, TablePagedResponse, HaState, HaGroupRequest, HaPromoteRequest } from './helpers/dtos';
 export declare enum QUERY_KEY {
     fetchAnomalies = "fetchAnomalies",
     fetchGraphs = "fetchGraphs",
@@ -36,7 +36,9 @@ export declare enum QUERY_KEY {
     fetchClusterDetails = "fetchClusterDetails",
     fetchIndexesPage = "fetchIndexesPage",
     fetchTableMetadata = "fetchTableMetadata",
-    fetchMaterializedViewMetadata = "fetchMaterializedViewMetadata"
+    fetchMaterializedViewMetadata = "fetchMaterializedViewMetadata",
+    fetchHaState = "fetchHaState",
+    fetchAppConfig = "fetchAppConfig"
 }
 export type { AxiosError, AxiosRequestConfig, AxiosResponse };
 export type PerfAdvisorRequestInterceptor = (config: AxiosRequestConfig) => AxiosRequestConfig | Promise<AxiosRequestConfig>;
@@ -120,5 +122,25 @@ declare class ApiService {
     fetchAnomalyGroupById: (universeUuid: string, anomalyGroupId: string, startTime: string, endTime: string, apiUrl?: string) => {};
     sendTelemetryEvent: (universeUuid: string, payload: any, apiUrl?: string) => Promise<any>;
     fetchClusterDetails: (universeUuid: string, startTime: string | null, endTime: string | null, apiUrl?: string) => Promise<any>;
+    fetchHaState: (apiUrl?: string) => Promise<HaState>;
+    applyHaGroup: (payload: HaGroupRequest, apiUrl?: string) => Promise<HaState>;
+    promoteHaMember: (payload: HaPromoteRequest, apiUrl?: string) => Promise<HaState>;
+    leaveHaGroup: (apiUrl?: string) => Promise<HaState>;
+    /**
+     * Leader-only "disband HA group" action. Routes through the backend's
+     * {@code HaService.disbandGroup()} which proactively fires {@code POST /api/ha/member/kick} at
+     * every remote follower before wiping its own {@code ha_group} / {@code ha_member} rows -
+     * followers therefore run their own CONFIG purge + COLLECTED cleanup synchronously instead of
+     * waiting up to a full follower-poll cycle to discover the eviction. If a follower is
+     * unreachable at disband time the leader logs it and proceeds; the follower will need to be
+     * cleaned up manually via its own "Leave HA group" button once it's back online.
+     *
+     * <p>On a non-leader caller the backend falls back to the plain {@code leave()} path so this
+     * endpoint stays idempotent from the UI regardless of which side of the group the operator
+     * clicks it on. The UI still prefers to hide this affordance behind an explicit "leader
+     * disband" button so the copy can call out the kick-fan-out behaviour.
+     */
+    deleteHaGroup: (apiUrl?: string) => Promise<HaState>;
+    restartHaBootstrap: (apiUrl?: string) => Promise<HaState>;
 }
 export declare const PerfAdvisorAPI: ApiService;

package/dist/components/HighAvailability/HaMembersTable.d.ts

@@ -0,0 +1,38 @@
+import { HaMemberState } from '../../helpers/dtos';
+interface HaMembersTableProps {
+    members: HaMemberState[];
+    leaderMemberUuid?: string;
+    /**
+     * Whether the local PA is the current group leader. Historically we used this to hide the
+     * Promote button on standbys; now the button is enabled on both roles because operators may
+     * need to promote *this* standby when the active PA is down and unreachable. The button is
+     * still disabled per-row for anything other than a READY member so an in-flight bootstrap
+     * doesn't get promoted mid-catch-up (see {@link HaMemberLifecycleState}).
+     */
+    localIsLeader: boolean;
+    localMemberUuid?: string;
+    promoting?: string;
+    /**
+     * Promote request handler. The optional {@code force} parameter is true only when the
+     * "Force Promote" dialog was confirmed on a STALE_CONFIG row - the backend uses it to
+     * bypass the version-order and STALE_CONFIG promote gates. Defaults to false / undefined
+     * on the normal Promote button which keeps every existing caller working unchanged.
+     */
+    onPromote: (memberUuid: string, force?: boolean) => void;
+    /**
+     * "Retry Bootstrap" affordance for the local follower. Rendered next to the Promote button on
+     * the local row when its state is FAILED (bootstrap retry budget exhausted) so an operator
+     * can un-stick the follower without shelling into the box. Undefined on the leader UI and on
+     * peer rows - retry is a local-only recovery action; nobody can (or should) restart another
+     * PA's bootstrap remotely.
+     */
+    onRetryBootstrap?: () => void;
+    /**
+     * Set to {@code true} while the {@code POST /api/ha/member/bootstrap/restart} call is
+     * inflight. Disables the button and swaps the label to a "Retrying…" spinner so the
+     * operator can't double-click and stack requests.
+     */
+    retryingBootstrap?: boolean;
+}
+export declare const HaMembersTable: ({ members, leaderMemberUuid, localIsLeader, localMemberUuid, promoting, onPromote, onRetryBootstrap, retryingBootstrap }: HaMembersTableProps) => JSX.Element;
+export {};

package/dist/components/HighAvailability/HaSetupDialog.d.ts

@@ -0,0 +1,27 @@
+import { HaGroupMode, HaMemberSpec, HaState } from '../../helpers/dtos';
+interface HaSetupDialogProps {
+    open: boolean;
+    apiUrl: string;
+    onClose: () => void;
+    onApplied: (next: HaState) => void;
+    toast: {
+        success: (message: string) => void;
+        error: (message: string) => void;
+    };
+    /**
+     * Optional starting members. When editing an existing group we prefill the form so operators can
+     * add or remove a peer without retyping everything. The local member is identified by
+     * {@link HaMemberSpec.isLocal}.
+     */
+    initialMembers?: HaMemberSpec[];
+    initialGroupUuid?: string;
+    initialClusterKey?: string;
+    /**
+     * When editing, the caller passes the local PA's current role so the dialog opens in the
+     * matching mode and locks the toggle (mode switches are not a control-plane operation the setup
+     * dialog is authorised to perform - use promote / leave for that).
+     */
+    initialMode?: HaGroupMode;
+}
+export declare const HaSetupDialog: ({ open, apiUrl, onClose, onApplied, toast, initialMembers, initialGroupUuid, initialClusterKey, initialMode }: HaSetupDialogProps) => JSX.Element;
+export {};

package/dist/components/HighAvailability/HighAvailability.d.ts

@@ -0,0 +1,11 @@
+import { AppName, HaMemberRole } from '../../helpers/dtos';
+interface HighAvailabilityProps {
+    apiUrl: string;
+    appName: AppName;
+    toast: {
+        success: (message: string) => void;
+        error: (message: string) => void;
+    };
+}
+export declare const HighAvailability: ({ apiUrl, appName, toast }: HighAvailabilityProps) => JSX.Element;
+export { HaMemberRole };

package/dist/components/HighAvailability/StandbyBanner.d.ts

@@ -0,0 +1,28 @@
+/// <reference types="react" />
+interface StandbyBannerProps {
+    /**
+     * Optional API URL prefix. Must match the value the host app passes to other PA entry points
+     * (e.g. {@code PerfAdvisorEntry}); mismatched values would cause the banner to poll a
+     * different backend than the mutation buttons themselves, opening a "banner hidden but
+     * server refuses" gap on the affected page.
+     */
+    apiUrl?: string;
+}
+/**
+ * Persistent banner rendered at the top of every top-level PA entry point when the current PA
+ * is a HA standby. Signals to the operator:
+ *
+ * <ul>
+ *   <li>They are on a read-only PA. Any mutation they attempt will be refused server-side
+ *       with a 409 CONFLICT (see {@code HaService.requireLeaderOrStandalone}).
+ *   <li>Where to go to make the change: a link to the current active PA's endpoint, when
+ *       we know it. When we don't (leader row missing an endpoint, or leader currently
+ *       elected but not addressable), the banner degrades to a static warning.
+ * </ul>
+ *
+ * <p>Renders nothing when not on a standby - {@link useHaStandby} handles the loading and
+ * error states as "hide the banner", so this component is safe to include at the top of any
+ * entry point without gating it further.
+ */
+export declare const StandbyBanner: ({ apiUrl }: StandbyBannerProps) => JSX.Element | null;
+export {};

package/dist/components/index.d.ts

@@ -6,5 +6,8 @@ export * from './PrimaryDashboard/DbCPUActivity/CPUByDatabaseChart';
 export * from './PrimaryDashboard/DbCPUActivity/CPUByDatabaseMetadata';
 export * from './ConfigureUniverse/ConfigureUniverseMetadata';
 export * from './RuntimeConfigs/RuntimeConfigs';
+export * from './HighAvailability/HighAvailability';
+export * from './HighAvailability/StandbyBanner';
 export * from '../helpers/dtos';
+export * from '../helpers/useHaStandby';
 export * from '../api';