@orchestrator-ui/orchestrator-ui-components 7.4.1 → 7.5.1

package/src/rtk/endpoints/search.ts

@@ -1,100 +1,81 @@
 import { getEndpointPath } from '@/components/WfoSearchPage/utils';
 import { BaseQueryTypes, orchestratorApi } from '@/rtk';
 import {
-    EntityKind,
-    Group,
-    PaginatedSearchResults,
-    PathAutocompleteResponse,
-    RetrieverType,
-    value_schema,
+  EntityKind,
+  Group,
+  PaginatedSearchResults,
+  PathAutocompleteResponse,
+  RetrieverType,
+  value_schema,
 } from '@/types';
 
 export interface SearchPayload {
-    entity_type: EntityKind;
-    query: string;
-    filters?: Group;
-    limit?: number;
-    retriever?: RetrieverType;
+  entity_type: EntityKind;
+  query: string;
+  filters?: Group;
+  limit?: number;
+  retriever?: RetrieverType;
 }
 
 export interface SearchPaginationPayload extends SearchPayload {
-    cursor: number;
+  cursor: number;
 }
 
 export interface SearchDefinitionsResponse {
-    [key: string]: {
-        operators: string[];
-        value_schema: Record<string, value_schema>;
-    };
+  [key: string]: {
+    operators: string[];
+    value_schema: Record<string, value_schema>;
+  };
 }
 
 const searchApi = orchestratorApi.injectEndpoints({
-    endpoints: (build) => ({
-        search: build.mutation<PaginatedSearchResults, SearchPayload>({
-            query: ({ entity_type, query, filters, limit, retriever }) => ({
-                url: `search/${getEndpointPath(entity_type)}`,
-                method: 'POST',
-                body: { query, filters, limit, retriever },
-                headers: {
-                    'Content-Type': 'application/json',
-                },
-            }),
-            extraOptions: {
-                baseQueryType: BaseQueryTypes.fetch,
-            },
-        }),
-        searchWithPagination: build.mutation<
-            PaginatedSearchResults,
-            SearchPaginationPayload
-        >({
-            query: ({
-                cursor,
-                entity_type,
-                query,
-                filters,
-                limit,
-                retriever,
-            }) => ({
-                url: `search/${getEndpointPath(entity_type)}?cursor=${cursor}`,
-                method: 'POST',
-                body: { query, filters, limit, retriever },
-                headers: {
-                    'Content-Type': 'application/json',
-                },
-            }),
-            extraOptions: {
-                baseQueryType: BaseQueryTypes.fetch,
-            },
-        }),
-        searchPaths: build.query<
-            PathAutocompleteResponse,
-            { q: string; entity_type: EntityKind }
-        >({
-            query: ({ q, entity_type }) => ({
-                url: `search/paths?q=${encodeURIComponent(
-                    q,
-                )}&entity_type=${entity_type}`,
-                method: 'GET',
-            }),
-            extraOptions: {
-                baseQueryType: BaseQueryTypes.fetch,
-            },
-        }),
-        searchDefinitions: build.query<SearchDefinitionsResponse, void>({
-            query: () => ({
-                url: 'search/definitions',
-                method: 'GET',
-            }),
-            extraOptions: {
-                baseQueryType: BaseQueryTypes.fetch,
-            },
-        }),
+  endpoints: (build) => ({
+    search: build.mutation<PaginatedSearchResults, SearchPayload>({
+      query: ({ entity_type, query, filters, limit, retriever }) => ({
+        url: `search/${getEndpointPath(entity_type)}`,
+        method: 'POST',
+        body: { query, filters, limit, retriever },
+        headers: {
+          'Content-Type': 'application/json',
+        },
+      }),
+      extraOptions: {
+        baseQueryType: BaseQueryTypes.fetch,
+      },
     }),
+    searchWithPagination: build.mutation<PaginatedSearchResults, SearchPaginationPayload>({
+      query: ({ cursor, entity_type, query, filters, limit, retriever }) => ({
+        url: `search/${getEndpointPath(entity_type)}?cursor=${cursor}`,
+        method: 'POST',
+        body: { query, filters, limit, retriever },
+        headers: {
+          'Content-Type': 'application/json',
+        },
+      }),
+      extraOptions: {
+        baseQueryType: BaseQueryTypes.fetch,
+      },
+    }),
+    searchPaths: build.query<PathAutocompleteResponse, { q: string; entity_type: EntityKind }>({
+      query: ({ q, entity_type }) => ({
+        url: `search/paths?q=${encodeURIComponent(q)}&entity_type=${entity_type}`,
+        method: 'GET',
+      }),
+      extraOptions: {
+        baseQueryType: BaseQueryTypes.fetch,
+      },
+    }),
+    searchDefinitions: build.query<SearchDefinitionsResponse, void>({
+      query: () => ({
+        url: 'search/definitions',
+        method: 'GET',
+      }),
+      extraOptions: {
+        baseQueryType: BaseQueryTypes.fetch,
+      },
+    }),
+  }),
 });
 
-export const {
-    useSearchMutation,
-    useSearchWithPaginationMutation,
-    useSearchPathsQuery,
-    useSearchDefinitionsQuery,
-} = searchApi;
+export const { useSearchMutation, useSearchWithPaginationMutation, useSearchPathsQuery, useSearchDefinitionsQuery } =
+  searchApi;

package/src/rtk/endpoints/settings.ts

@@ -1,139 +1,130 @@
 import {
-    SETTINGS_CACHE_ENDPOINT,
-    SETTINGS_CACHE_NAMES_ENDPOINT,
-    SETTINGS_ENGINE_STATUS_ENDPOINT,
-    SETTINGS_OVERVIEW,
-    SETTINGS_SEARCH_INDEX_RESET_ENDPOINT,
-    SETTINGS_WORKER_STATUS_ENDPOINT,
+  SETTINGS_CACHE_ENDPOINT,
+  SETTINGS_CACHE_NAMES_ENDPOINT,
+  SETTINGS_ENGINE_STATUS_ENDPOINT,
+  SETTINGS_OVERVIEW,
+  SETTINGS_SEARCH_INDEX_RESET_ENDPOINT,
+  SETTINGS_WORKER_STATUS_ENDPOINT,
 } from '@/configuration';
 import { BaseQueryTypes, orchestratorApi } from '@/rtk';
-import {
-    CacheNames,
-    CacheTagType,
-    EngineStatus,
-    EnvironmentVariables,
-    WorkerTypes,
-} from '@/types';
+import { CacheNames, CacheTagType, EngineStatus, EnvironmentVariables, WorkerTypes } from '@/types';
 import { getCacheTag } from '@/utils/cacheTag';
 
 interface EngineStatusReturnValue {
-    engineStatus: EngineStatus;
-    runningProcesses: number;
+  engineStatus: EngineStatus;
+  runningProcesses: number;
 }
 
 interface WorkerStatusReturnValue {
-    executorType: WorkerTypes;
-    numberOfWorkersOnline: number;
-    numberOfQueuedJobs: number;
-    numberOfRunningJobs: number;
+  executorType: WorkerTypes;
+  numberOfWorkersOnline: number;
+  numberOfQueuedJobs: number;
+  numberOfRunningJobs: number;
 }
 
 interface WorkerStatusData {
-    executor_type: string;
-    number_of_workers_online: number;
-    number_of_queued_jobs: number;
-    number_of_running_jobs: number;
+  executor_type: string;
+  number_of_workers_online: number;
+  number_of_queued_jobs: number;
+  number_of_running_jobs: number;
 }
 const statusApi = orchestratorApi.injectEndpoints({
-    endpoints: (build) => ({
-        getEngineStatus: build.query<EngineStatusReturnValue, void>({
-            query: () => SETTINGS_ENGINE_STATUS_ENDPOINT,
-            extraOptions: {
-                baseQueryType: BaseQueryTypes.fetch,
-            },
-            transformResponse(data: {
-                global_status: string;
-                running_processes: number;
-            }) {
-                const engineStatus = (() => {
-                    switch (data?.global_status) {
-                        case 'RUNNING':
-                            return EngineStatus.RUNNING;
-                        case 'PAUSING':
-                            return EngineStatus.PAUSING;
-                        case 'PAUSED':
-                            return EngineStatus.PAUSED;
-                        default:
-                            return EngineStatus.UNKNOWN;
-                    }
-                })();
-                return {
-                    engineStatus,
-                    runningProcesses: data?.running_processes || 0,
-                };
-            },
-            providesTags: getCacheTag(CacheTagType.engineStatus),
-        }),
-        getWorkerStatus: build.query<WorkerStatusReturnValue, void>({
-            query: () => SETTINGS_WORKER_STATUS_ENDPOINT,
-            extraOptions: {
-                baseQueryType: BaseQueryTypes.fetch,
-            },
-            transformResponse: (data: WorkerStatusData) => {
-                return {
-                    executorType: data?.executor_type as WorkerTypes,
-                    numberOfWorkersOnline: data?.number_of_workers_online || 0,
-                    numberOfQueuedJobs: data?.number_of_queued_jobs || 0,
-                    numberOfRunningJobs: data?.number_of_running_jobs || 0,
-                };
-            },
-            providesTags: getCacheTag(CacheTagType.workerStatus),
-        }),
-        getCacheNames: build.query<CacheNames, void>({
-            query: () => SETTINGS_CACHE_NAMES_ENDPOINT,
-            extraOptions: {
-                baseQueryType: BaseQueryTypes.fetch,
-            },
-        }),
-        clearCache: build.mutation<void, string>({
-            query: (settingName) => ({
-                url: `${SETTINGS_CACHE_ENDPOINT}/${settingName}`,
-                method: 'DELETE',
-            }),
-            extraOptions: {
-                baseQueryType: BaseQueryTypes.fetch,
-            },
-        }),
-        resetTextSearchIndex: build.mutation<void, null>({
-            query: () => ({
-                url: SETTINGS_SEARCH_INDEX_RESET_ENDPOINT,
-                method: 'POST',
-            }),
-            extraOptions: {
-                baseQueryType: BaseQueryTypes.fetch,
-            },
-        }),
-        setEngineStatus: build.mutation<EngineStatusReturnValue, boolean>({
-            query: (globalStatus) => ({
-                url: SETTINGS_ENGINE_STATUS_ENDPOINT,
-                method: 'PUT',
-                body: JSON.stringify({
-                    global_lock: globalStatus,
-                }),
-                headers: {
-                    'Content-Type': 'application/json',
-                },
-            }),
-            extraOptions: {
-                baseQueryType: BaseQueryTypes.fetch,
-            },
-            invalidatesTags: getCacheTag(CacheTagType.engineStatus),
-        }),
-        getEnvironmentVariables: build.query<EnvironmentVariables[], void>({
-            query: () => SETTINGS_OVERVIEW,
-            extraOptions: {
-                baseQueryType: BaseQueryTypes.fetch,
-            },
+  endpoints: (build) => ({
+    getEngineStatus: build.query<EngineStatusReturnValue, void>({
+      query: () => SETTINGS_ENGINE_STATUS_ENDPOINT,
+      extraOptions: {
+        baseQueryType: BaseQueryTypes.fetch,
+      },
+      transformResponse(data: { global_status: string; running_processes: number }) {
+        const engineStatus = (() => {
+          switch (data?.global_status) {
+            case 'RUNNING':
+              return EngineStatus.RUNNING;
+            case 'PAUSING':
+              return EngineStatus.PAUSING;
+            case 'PAUSED':
+              return EngineStatus.PAUSED;
+            default:
+              return EngineStatus.UNKNOWN;
+          }
+        })();
+        return {
+          engineStatus,
+          runningProcesses: data?.running_processes || 0,
+        };
+      },
+      providesTags: getCacheTag(CacheTagType.engineStatus),
+    }),
+    getWorkerStatus: build.query<WorkerStatusReturnValue, void>({
+      query: () => SETTINGS_WORKER_STATUS_ENDPOINT,
+      extraOptions: {
+        baseQueryType: BaseQueryTypes.fetch,
+      },
+      transformResponse: (data: WorkerStatusData) => {
+        return {
+          executorType: data?.executor_type as WorkerTypes,
+          numberOfWorkersOnline: data?.number_of_workers_online || 0,
+          numberOfQueuedJobs: data?.number_of_queued_jobs || 0,
+          numberOfRunningJobs: data?.number_of_running_jobs || 0,
+        };
+      },
+      providesTags: getCacheTag(CacheTagType.workerStatus),
+    }),
+    getCacheNames: build.query<CacheNames, void>({
+      query: () => SETTINGS_CACHE_NAMES_ENDPOINT,
+      extraOptions: {
+        baseQueryType: BaseQueryTypes.fetch,
+      },
+    }),
+    clearCache: build.mutation<void, string>({
+      query: (settingName) => ({
+        url: `${SETTINGS_CACHE_ENDPOINT}/${settingName}`,
+        method: 'DELETE',
+      }),
+      extraOptions: {
+        baseQueryType: BaseQueryTypes.fetch,
+      },
+    }),
+    resetTextSearchIndex: build.mutation<void, null>({
+      query: () => ({
+        url: SETTINGS_SEARCH_INDEX_RESET_ENDPOINT,
+        method: 'POST',
+      }),
+      extraOptions: {
+        baseQueryType: BaseQueryTypes.fetch,
+      },
+    }),
+    setEngineStatus: build.mutation<EngineStatusReturnValue, boolean>({
+      query: (globalStatus) => ({
+        url: SETTINGS_ENGINE_STATUS_ENDPOINT,
+        method: 'PUT',
+        body: JSON.stringify({
+          global_lock: globalStatus,
         }),
+        headers: {
+          'Content-Type': 'application/json',
+        },
+      }),
+      extraOptions: {
+        baseQueryType: BaseQueryTypes.fetch,
+      },
+      invalidatesTags: getCacheTag(CacheTagType.engineStatus),
+    }),
+    getEnvironmentVariables: build.query<EnvironmentVariables[], void>({
+      query: () => SETTINGS_OVERVIEW,
+      extraOptions: {
+        baseQueryType: BaseQueryTypes.fetch,
+      },
     }),
+  }),
 });
 
 export const {
-    useGetEngineStatusQuery,
-    useGetCacheNamesQuery,
-    useClearCacheMutation,
-    useResetTextSearchIndexMutation,
-    useSetEngineStatusMutation,
-    useGetWorkerStatusQuery,
-    useGetEnvironmentVariablesQuery,
+  useGetEngineStatusQuery,
+  useGetCacheNamesQuery,
+  useClearCacheMutation,
+  useResetTextSearchIndexMutation,
+  useSetEngineStatusMutation,
+  useGetWorkerStatusQuery,
+  useGetEnvironmentVariablesQuery,
 } = statusApi;

package/src/rtk/endpoints/startOptions.ts

@@ -1,9 +1,9 @@
 import {
-    ProductDefinition,
-    ProductLifecycleStatus,
-    StartOptionsResult,
-    WorkflowDefinition,
-    WorkflowTarget,
+  ProductDefinition,
+  ProductLifecycleStatus,
+  StartOptionsResult,
+  WorkflowDefinition,
+  WorkflowTarget,
 } from '@/types';
 
 import { orchestratorApi } from '../api';
@@ -39,93 +39,77 @@ const taskOptionsQuery = `
 `;
 
 type WorkflowOption = {
-    workflowName: WorkflowDefinition['name'];
-    isAllowed: WorkflowDefinition['isAllowed'];
-    productName: ProductDefinition['name'];
-    productId: ProductDefinition['productId'];
-    productType: ProductDefinition['productType'];
-    productTag: ProductDefinition['tag'];
+  workflowName: WorkflowDefinition['name'];
+  isAllowed: WorkflowDefinition['isAllowed'];
+  productName: ProductDefinition['name'];
+  productId: ProductDefinition['productId'];
+  productType: ProductDefinition['productType'];
+  productTag: ProductDefinition['tag'];
 };
 
 type WorkflowOptionsResult = StartOptionsResult<{
-    name: WorkflowDefinition['name'];
-    isAllowed: WorkflowDefinition['isAllowed'];
-    products: {
-        name: ProductDefinition['name'];
-        productId: ProductDefinition['productId'];
-        productType: ProductDefinition['productType'];
-        tag: ProductDefinition['tag'];
-        status: ProductDefinition['status'];
-    }[];
+  name: WorkflowDefinition['name'];
+  isAllowed: WorkflowDefinition['isAllowed'];
+  products: {
+    name: ProductDefinition['name'];
+    productId: ProductDefinition['productId'];
+    productType: ProductDefinition['productType'];
+    tag: ProductDefinition['tag'];
+    status: ProductDefinition['status'];
+  }[];
 }>;
 
 export type StartOptionsResponse<StartOption> = {
-    startOptions: StartOption[];
+  startOptions: StartOption[];
 };
 
-type TaskOption = Pick<
-    WorkflowDefinition,
-    'name' | 'isAllowed' | 'description'
->;
+type TaskOption = Pick<WorkflowDefinition, 'name' | 'isAllowed' | 'description'>;
 type TaskOptionsResult = StartOptionsResult<TaskOption>;
 
 const startButtonOptionsApi = orchestratorApi.injectEndpoints({
-    endpoints: (build) => ({
-        getWorkflowOptions: build.query<
-            StartOptionsResponse<WorkflowOption>,
-            ProductLifecycleStatus | string
-        >({
-            query: () => ({
-                document: workflowOptionsQuery,
-            }),
-            transformResponse: (
-                response: WorkflowOptionsResult | undefined,
-                _,
-                productStatus,
-            ) => {
-                const statusToMatch = (
-                    productStatus ?? ProductLifecycleStatus.ACTIVE
-                ).toLowerCase();
-                const startOptions: WorkflowOption[] = [];
-                const workflows = response?.workflows?.page || [];
-                workflows.forEach((workflow) => {
-                    const workflowName = workflow.name;
-                    workflow.products
-                        .filter(
-                            (product) =>
-                                product.status.toLowerCase() === statusToMatch,
-                        )
-                        .forEach((product) => {
-                            startOptions.push({
-                                workflowName,
-                                isAllowed: workflow.isAllowed,
-                                productName: product.name,
-                                productId: product.productId,
-                                productType: product.productType,
-                                productTag: product.tag,
-                            });
-                        });
-                });
+  endpoints: (build) => ({
+    getWorkflowOptions: build.query<StartOptionsResponse<WorkflowOption>, ProductLifecycleStatus | string>({
+      query: () => ({
+        document: workflowOptionsQuery,
+      }),
+      transformResponse: (response: WorkflowOptionsResult | undefined, _, productStatus) => {
+        const statusToMatch = (productStatus ?? ProductLifecycleStatus.ACTIVE).toLowerCase();
+        const startOptions: WorkflowOption[] = [];
+        const workflows = response?.workflows?.page || [];
+        workflows.forEach((workflow) => {
+          const workflowName = workflow.name;
+          workflow.products
+            .filter((product) => product.status.toLowerCase() === statusToMatch)
+            .forEach((product) => {
+              startOptions.push({
+                workflowName,
+                isAllowed: workflow.isAllowed,
+                productName: product.name,
+                productId: product.productId,
+                productType: product.productType,
+                productTag: product.tag,
+              });
+            });
+        });
 
-                return { startOptions };
-            },
-        }),
-        getTaskOptions: build.query<StartOptionsResponse<TaskOption>, void>({
-            query: () => ({
-                document: taskOptionsQuery,
-            }),
-            transformResponse: (response: TaskOptionsResult) => {
-                return {
-                    startOptions: response.workflows.page.map((option) => ({
-                        name: option.name,
-                        isAllowed: option.isAllowed,
-                        description: option.description,
-                    })),
-                };
-            },
-        }),
+        return { startOptions };
+      },
+    }),
+    getTaskOptions: build.query<StartOptionsResponse<TaskOption>, void>({
+      query: () => ({
+        document: taskOptionsQuery,
+      }),
+      transformResponse: (response: TaskOptionsResult) => {
+        return {
+          startOptions: response.workflows.page.map((option) => ({
+            name: option.name,
+            isAllowed: option.isAllowed,
+            description: option.description,
+          })),
+        };
+      },
     }),
+  }),
 });
 
-export const { useGetWorkflowOptionsQuery, useGetTaskOptionsQuery } =
-    startButtonOptionsApi;
+export const { useGetWorkflowOptionsQuery, useGetTaskOptionsQuery } = startButtonOptionsApi;