@odigos/ui-kit 0.0.249 → 0.0.251

package/lib/contexts/odigos-api/hooks/use-tokens-api.d.ts

@@ -0,0 +1,12 @@
+import { type TokenPayload } from '@/types';
+import type { OperationContext, OdigosApiOperations } from '../types';
+export interface TokensApi {
+    fetchTokens?: () => Promise<{
+        data?: TokenPayload[];
+        error?: string;
+    }>;
+    updateToken?: (token: string) => Promise<{
+        error?: string;
+    } | undefined>;
+}
+export declare const useTokensApi: (operations: OdigosApiOperations, ctx: OperationContext) => TokensApi;

package/lib/contexts/odigos-api/index.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Public entry point for the OdigosApiContext.
+ *
+ * This module is exported as `@odigos/ui-kit/contexts/odigos-api` (see the
+ * kit's `package.json` exports). Host adapters import the provider, types,
+ * and per-domain return types from here. Container code imports
+ * `useOdigosApi`.
+ *
+ * The mock provider (used by storybook only) lives under
+ * `.storybook/odigos-api-mock-provider.tsx` so it never compiles into the
+ * production bundle.
+ */
+export { OdigosApiProvider } from './provider';
+export { OdigosApiConnectionsScope } from './connections-scope';
+export { useApiForConnections, type ApiForConnections } from './use-api-for-connections';
+export { useOdigosApi, type SubscribableDomain, type UseOdigosApiReturn } from './use-odigos-api';
+export { useApiQuery, useApiLazyQuery, useApiMutation, type UseApiQueryOptions, type UseApiQueryResult, type UseApiLazyQueryResult, type UseApiMutationOptions, type UseApiMutationResult, type UseApiMutationTuple, } from './use-api-query';
+export { pickByPlatform, versionedDocument, vmDialectMap, type VersionedDocumentMap } from './platform-helpers';
+export type { ApolloConfig, CreateActionResult, CreateActionVars, CreateCostReductionRuleResult, CreateDataStreamResult, CreateDataStreamVars, CreateDestinationResult, CreateDestinationVars, CreateHighlyRelevantOperationRuleResult, CreateInstrumentationRuleResult, CreateInstrumentationRuleVars, CreateNoisyOperationRuleResult, DeleteActionResult, DeleteActionVars, DeleteCostReductionRuleResult, DeleteDataStreamResult, DeleteDataStreamVars, DeleteDestinationResult, DeleteDestinationVars, DeleteHighlyRelevantOperationRuleResult, DeleteInstrumentationRuleResult, DeleteInstrumentationRuleVars, DeleteNoisyOperationRuleResult, DescribeOdigosData, DescribeSourceData, DestinationWireInput, DiagnoseResult, DiagnoseVars, GetActionsData, GetAllClusterSnapshotsData, GetClusterSnapshotData, GetClusterSnapshotVars, GetCollectorPodInfoData, GetCollectorPodInfoVars, GetConfigYamlsData, GetDataStreamsData, GetDestinationsData, GetEffectiveConfigVars, GetGatewayInfoData, GetGatewayPodsData, GetInstrumentationRulesData, GetK8sManifestData, GetK8sManifestVars, GetMetricsData, GetNamespaceVars, GetNamespacesWithWorkloadsData, GetNodeCollectorInfoData, GetNodeCollectorPodsData, GetPeerSourcesVars, GetProfilingSlotsData, GetSamplingRulesData, GetServiceMapData, GetSourceConditionsData, GetSourceLibrariesData, GetSourceLibrariesVars, GetSourceProfilingData, GetTokensData, GetWorkloadsByIdsData, GetWorkloadsByIdsVars, GetWorkloadsData, GetWorkloadsVars, MultiFetchGroup, MultiFetchResponse, MultiFetchResult, OdigosApiOperations, OdigosApiProviderProps, Operation, OperationContext, PersistNamespacesResult, PersistNamespacesVars, PersistSourcesResult, PersistSourcesVars, RecoverFromRollbackVars, ResetLocalUiConfigResult, RestartPodVars, RestartWorkloadsVars, SamplingK8sHealthConfigInput, SamplingK8sHealthConfigVars, SamplingRuleCreateVars, SamplingRuleDeleteVars, SamplingRuleUpdateVars, SourceConditionEntry, TestDestinationConnectionVars, UpdateActionResult, UpdateActionVars, UpdateCostReductionRuleResult, UpdateDataStreamResult, UpdateDataStreamVars, UpdateDestinationData, UpdateDestinationVars, UpdateHighlyRelevantOperationRuleResult, UpdateInstrumentationRuleResult, UpdateInstrumentationRuleVars, UpdateLocalUiConfigResult, UpdateLocalUiConfigVars, UpdateLocalUiSamplingConfigResult, UpdateLocalUiSamplingConfigVars, UpdateNoisyOperationRuleResult, UpdateRemoteConfigResult, UpdateRemoteConfigVars, UpdateSourceVars, UpdateTokenResult, UpdateTokenVars, } from './types';
+export type { Capabilities } from './capabilities';
+export type { ConfigApi } from './hooks/use-config-api';
+export type { TokensApi } from './hooks/use-tokens-api';
+export type { ActionsApi } from './hooks/use-actions-api';
+export type { MetricsApi } from './hooks/use-metrics-api';
+export type { DescribeApi } from './hooks/use-describe-api';
+export type { SamplingApi } from './hooks/use-sampling-api';
+export type { NamespaceApi } from './hooks/use-namespace-api';
+export type { ProfilingApi } from './hooks/use-profiling-api';
+export type { SnapshotsApi } from './hooks/use-snapshots-api';
+export type { CollectorsApi } from './hooks/use-collectors-api';
+export type { ServiceMapApi } from './hooks/use-service-map-api';
+export type { DataStreamsApi } from './hooks/use-data-streams-api';
+export type { K8sManifestApi } from './hooks/use-k8s-manifest-api';
+export type { DestinationsApi } from './hooks/use-destinations-api';
+export type { SourcesApi, PersistSourceInput } from './hooks/use-sources-api';
+export type { InstrumentationRulesApi } from './hooks/use-instrumentation-rules-api';
+export { prepareSourcePayloads, prepareNamespacePayloads, type SourceInstrumentInput, type NamespaceInstrumentInput, type SourceInstrumentInputItem, type NamespaceInstrumentInputItem, } from './internal/source-payloads';

package/lib/contexts/odigos-api/internal/notify.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Shared notification helpers used by every domain hook.
+ *
+ * Each per-domain hook calls `useNotify(entityType)` once at the top to
+ * get the same `notifyError` / `notifySuccess` / `notifyPending` /
+ * `notifyReadonly` shape, with the SSE-target conversion + crdType
+ * pre-wired. This replaces the `notifyError = (title, message, target?) => …`
+ * boilerplate that every hook used to repeat.
+ */
+import type { NotifyPayload } from '@/store';
+import { StatusType, type EntityTypes, type WorkloadId } from '@/types';
+type AddNotification = (notif: NotifyPayload) => void;
+export interface DomainNotifier {
+    /** Generic dispatcher — used for non-success/error/pending paths. */
+    notify: (type: StatusType, title: string, message: string, target?: string | WorkloadId, hideFromHistory?: boolean) => void;
+    /** Toast a CRUD error with the entity-typed crdType + optional target. */
+    notifyError: (title: string, message: string, target?: string | WorkloadId) => void;
+    /** Toast a CRUD success with the entity-typed crdType + optional target. */
+    notifySuccess: (title: string, message: string, target?: string | WorkloadId) => void;
+    /**
+     * Toast a "pending"/in-flight notification (default status, history-hidden).
+     * Use sparingly — these are transient and should be cleared by the
+     * follow-up success/error toast or by SSE.
+     */
+    notifyPending: (message: string, target?: string | WorkloadId) => void;
+    /**
+     * Dispatch the standardized "operation blocked because the user is
+     * read-only" warning. Returns `undefined` so callers can
+     * `return notifyReadonly()` inside Promise-returning functions without
+     * TypeScript complaining about `void` not matching the declared shape.
+     */
+    notifyReadonly: () => undefined;
+}
+/**
+ * Returns a domain-bound notifier. Pass the `EntityTypes` for the domain
+ * (e.g. `EntityTypes.Source`) and every dispatched toast is tagged with
+ * the correct `crdType` and SSE-target translation.
+ */
+export declare const useNotify: (entityType: EntityTypes) => DomainNotifier;
+/**
+ * Standalone form of the readonly notification, used by the small number
+ * of hooks that don't need the full `useNotify` surface (e.g. data-streams,
+ * which doesn't have a CRD entity type and just dispatches a generic
+ * untyped warning).
+ *
+ * @deprecated New code should prefer `useNotify(...).notifyReadonly()`.
+ */
+export declare const notifyReadonly: (addNotification: AddNotification) => undefined;
+export {};

package/lib/contexts/odigos-api/internal/source-payloads.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Source/namespace payload preparation, relocated from the host apps.
+ *
+ * Originally lived as `prepareSourcePayloads` / `prepareNamespacePayloads`
+ * in `odigos/frontend/webapp/utils/functions/sources.ts` and the equivalent
+ * file in central-ui. Now centralized in the kit so `useSourcesApi`
+ * doesn't depend on host code.
+ *
+ * The previous version of this helper accepted Zustand-store
+ * mutators (`addEntities` / `removeEntities`) so it could optimistically
+ * patch the in-memory entity store before the server's mutation
+ * resolved. After the kit moved to Apollo's normalized cache as the
+ * single source of truth, those optimistic patches are gone — every
+ * mutation `await`s `fetchAll()` immediately after, so all
+ * `useApiQuery('GET_WORKLOADS')` subscribers see the canonical
+ * post-mutation state with sub-second latency. The helper is now a
+ * pure (payload, count) builder.
+ */
+import type { NamespaceSelectionFormData, SourceSelectionFormData } from '@/store';
+import type { K8sResourceKind } from '@/types';
+export interface SourceInstrumentInputItem {
+    namespace: string;
+    name: string;
+    kind: K8sResourceKind | '';
+    selected: boolean;
+    currentStreamName: string;
+}
+export interface NamespaceInstrumentInputItem {
+    namespace: string;
+    selected: boolean;
+    currentStreamName: string;
+}
+export interface SourceInstrumentInput {
+    sources: SourceInstrumentInputItem[];
+}
+export interface NamespaceInstrumentInput {
+    namespaces: NamespaceInstrumentInputItem[];
+}
+export declare const prepareSourcePayloads: (selectAppsList: SourceSelectionFormData, existingSources: Array<{
+    id: {
+        namespace: string;
+        name: string;
+        kind: string;
+    };
+    dataStreamNames?: string[] | null;
+}>, selectedStreamName: string, handleInstrumentationCount: (toAddCount: number, toDeleteCount: number) => void) => {
+    payload: SourceInstrumentInput;
+    isEmpty: boolean;
+};
+export declare const prepareNamespacePayloads: (futureSelectAppsList: NamespaceSelectionFormData, selectedStreamName: string) => {
+    payload: NamespaceInstrumentInput;
+    isEmpty: boolean;
+};

package/lib/contexts/odigos-api/platform-helpers.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Platform-routing helpers used by host adapters to express
+ * "this operation has a different document/payload per platform".
+ *
+ * The kit exposes these so adapters can avoid repeating the same
+ * platform-switch / version-floor logic at every operation. They live
+ * separately from `runner.ts` because they don't touch Apollo — they're
+ * pure ergonomic helpers over `OperationContext`.
+ */
+import type { DocumentNode } from 'graphql';
+import { PlatformType } from '@/types';
+import type { OperationContext } from './types';
+/**
+ * Pick a value based on the active platform.
+ *
+ * @example
+ * ```ts
+ * const doc = pickByPlatform(ctx, {
+ *   K8s: K8S_GET_WORKLOADS,
+ *   Vm:  VM_GET_SOURCES,
+ * });
+ * ```
+ *
+ * Returns `undefined` if the active platform doesn't have a branch — the
+ * runner will then short-circuit with "Operation not supported in this
+ * context", which is the correct UX (capabilities flags hide the calling
+ * affordance, but a defensive short-circuit prevents stale UI from
+ * sending an op that doesn't exist on the current platform).
+ */
+export declare const pickByPlatform: <T>(ctx: OperationContext, branches: {
+    K8s?: T;
+    Vm?: T;
+}) => T | undefined;
+/**
+ * Per-platform, per-version map of `DocumentNode`s. Top-level keys are
+ * `PlatformType` values; second-level keys are version strings (as
+ * declared by the host's release schedule — e.g. `'v1.20'`,
+ * `'v0.6.0'`). Values are pre-built `DocumentNode`s.
+ *
+ * Designed to be assignable from the agents-api `dialects` registry's
+ * `print(dialect.docName)` outputs once the host wraps them with `gql`,
+ * and from hand-authored `gql` consts on the K8s side.
+ */
+export type VersionedDocumentMap = {
+    readonly [P in PlatformType]?: Readonly<Record<string, DocumentNode>>;
+};
+/**
+ * Build a `(ctx) => DocumentNode | undefined` resolver for
+ * `Operation.document` from a `VersionedDocumentMap`.
+ *
+ * Resolution algorithm — same as central-ui's `getVersionedQuery`:
+ *   1. Pick the platform branch matching `ctx.platformType`.
+ *   2. Sort that branch's versions descending (numeric-aware via
+ *      `trimVersion`).
+ *   3. Return the highest version that's `<= ctx.version`. This "floor
+ *      to the matching bucket" rule keeps older proxies/agents from
+ *      receiving documents whose schemas they don't understand yet.
+ *   4. If no bucket fits (or the platform is missing), return undefined
+ *      → the runner short-circuits with "Operation not supported in
+ *      this context".
+ *
+ * @example
+ * ```ts
+ * const operations: OdigosApiOperations = {
+ *   GET_WORKLOADS: {
+ *     document: versionedDocument({
+ *       [PlatformType.K8s]: { 'v1.16': K8S_GET_WORKLOADS_V1_16 },
+ *       [PlatformType.Vm]:  vmDialectMap((d) => d.getSourcesV2),
+ *     }),
+ *     transformResult: (raw, ctx) => …,
+ *   },
+ *   …
+ * };
+ * ```
+ */
+export declare const versionedDocument: (map: VersionedDocumentMap) => (ctx: OperationContext) => DocumentNode | undefined;
+/**
+ * Convenience builder for the VM half of a `VersionedDocumentMap` from a
+ * dialect-style registry (e.g. `@odigos/vmagent-api-apollo-client/registry`'s
+ * `dialects` export).
+ *
+ * Hosts pass:
+ *   - `dialects` — the registry value (`Record<DialectVersion, Dialect>`).
+ *   - `select`   — pick a specific `DocumentNode` out of each dialect.
+ *
+ * @example
+ * ```ts
+ * import { dialects } from '@odigos/vmagent-api-apollo-client/registry';
+ *
+ * const VM_GET_SOURCES = vmDialectMap(dialects, (d) => d.getSourcesV2);
+ * // => Record<'v0.6.0' | 'v0.8.0' | …, DocumentNode>
+ * ```
+ *
+ * Generic `<TRegistry, TDialect>` is permissive on purpose — the kit
+ * never imports the `vmagent-api-apollo-client` package itself; this
+ * helper just maps over whatever the host hands in.
+ */
+export declare const vmDialectMap: <TRegistry extends Record<string, TDialect>, TDialect>(dialects: TRegistry, select: (dialect: TDialect) => DocumentNode) => Record<keyof TRegistry & string, DocumentNode>;

package/lib/contexts/odigos-api/provider.d.ts

@@ -0,0 +1,28 @@
+/**
+ * `<OdigosApiProvider>` — the public entry point for the kit's API context.
+ *
+ * Hosts mount this once at the layout level. It:
+ *   1. Constructs the ApolloClient from `apolloConfig` (memoized on the
+ *      `httpUrl` so the client is recreated only when the endpoint changes).
+ *   2. Mounts Apollo's `<ApolloProvider>`.
+ *   3. Exposes `operations` + `context` to per-domain hooks via an internal
+ *      React context.
+ *   4. Reads via `useOdigosApi()` (see `use-odigos-api.ts`) which composes
+ *      every per-domain hook into a single namespaced object.
+ *
+ * Hosts that need Next.js SSR support wrap this with their own
+ * `<ApolloNextAppProvider>` externally — see [odigos-api-adapter.tsx]
+ * in odigos webapp for the canonical pattern.
+ */
+import React, { type FC } from 'react';
+import type { OdigosApiInternalValue, OdigosApiProviderProps } from './types';
+/** @internal — used by per-domain hooks via the `hooks/` folder. */
+export declare const useOdigosApiInternal: () => OdigosApiInternalValue;
+export declare const OdigosApiProvider: FC<OdigosApiProviderProps>;
+/**
+ * Internal context used by the mock provider so storybook stories can
+ * supply a partial API surface without constructing Apollo at all.
+ *
+ * @internal
+ */
+export declare const __OdigosApiInternalContext: React.Context<OdigosApiInternalValue | null>;

package/lib/contexts/odigos-api/runner.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Executes Operations against the host's ApolloClient.
+ *
+ * Each domain hook ultimately calls one of `runQuery`, `runMutation`, or
+ * `runMulti`. The runner resolves the document (which may be a function of
+ * `OperationContext` for versioned-query maps), applies optional variable +
+ * result transformations, and surfaces a uniform `{ data, error }` shape.
+ */
+import type { ApolloClient, FetchPolicy } from '@apollo/client';
+import type { MultiFetchResponse, Operation, OperationContext } from './types';
+export interface RunResult<T> {
+    data?: T;
+    error?: string;
+}
+/**
+ * Execute a single query. Tolerates `op === undefined` (returned as a
+ * graceful "not configured" error) so domain hooks calling `runQuery(client,
+ * operations.X, …)` against a host adapter that omits slot `X` — including
+ * the Storybook mock provider's empty operations map — don't crash with
+ * `Cannot read properties of undefined`.
+ */
+export declare const runQuery: <T, V>(defaultClient: ApolloClient<unknown>, op: Operation<T, V> | undefined, vars: V | undefined, ctx: OperationContext, fetchPolicy?: FetchPolicy) => Promise<RunResult<T>>;
+/** Execute a single mutation. Same `op === undefined` tolerance as `runQuery`. */
+export declare const runMutation: <T, V>(defaultClient: ApolloClient<unknown>, op: Operation<T, V> | undefined, vars: V | undefined, ctx: OperationContext) => Promise<RunResult<T>>;
+/**
+ * Execute a multi-cluster fan-out. When `op.documentMulti` /
+ * `transformVariablesMulti` are set (central-ui), groups proxies by
+ * resolved version and emits one Apollo call per group, then merges
+ * results. When they're absent (odigos webapp), falls back to N parallel
+ * single calls.
+ */
+export declare const runMulti: <T, V>(defaultClient: ApolloClient<unknown>, op: Operation<T, V> | undefined, proxyIDs: string[], vars: V | undefined, ctx: OperationContext) => Promise<MultiFetchResponse<T>>;