@orchestrator-ui/orchestrator-ui-components 7.4.0 → 7.5.0

package/src/rtk/endpoints/processDetail.ts

@@ -1,16 +1,11 @@
 import {
-    PROCESSES_ENDPOINT,
-    PROCESSES_RESUME_ALL_ENDPOINT,
-    PROCESS_ABORT_ENDPOINT,
-    PROCESS_RESUME_ENDPOINT,
+  PROCESSES_ENDPOINT,
+  PROCESSES_RESUME_ALL_ENDPOINT,
+  PROCESS_ABORT_ENDPOINT,
+  PROCESS_RESUME_ENDPOINT,
 } from '@/configuration';
 import { BaseQueryTypes, orchestratorApi } from '@/rtk';
-import {
-    CacheTagType,
-    ProcessDetail,
-    ProcessDetailResultRaw,
-    ProcessesDetailResult,
-} from '@/types';
+import { CacheTagType, ProcessDetail, ProcessDetailResultRaw, ProcessesDetailResult } from '@/types';
 import { getCacheTag } from '@/utils/cacheTag';
 
 export const processDetailQuery = `query ProcessDetail($processId: String!) {
@@ -55,105 +50,94 @@ export const processDetailQuery = `query ProcessDetail($processId: String!) {
     }`;
 
 export type ProcessDetailResponse = {
-    processes: ProcessDetail[];
+  processes: ProcessDetail[];
 };
 
 const processDetailApi = orchestratorApi.injectEndpoints({
-    endpoints: (builder) => ({
-        getProcessDetail: builder.query<
-            ProcessDetailResponse,
-            { processId: string }
-        >({
-            query: (variables) => ({
-                document: processDetailQuery,
-                variables,
-            }),
-            transformResponse: (
-                response: ProcessesDetailResult,
-            ): ProcessDetailResponse => {
-                const processes = response.processes.page || [];
+  endpoints: (builder) => ({
+    getProcessDetail: builder.query<ProcessDetailResponse, { processId: string }>({
+      query: (variables) => ({
+        document: processDetailQuery,
+        variables,
+      }),
+      transformResponse: (response: ProcessesDetailResult): ProcessDetailResponse => {
+        const processes = response.processes.page || [];
 
-                return {
-                    processes,
-                };
-            },
-            providesTags: (result, error, queryArguments) => {
-                if (!error && result) {
-                    return getCacheTag(
-                        CacheTagType.processes,
-                        queryArguments.processId,
-                    );
-                }
-                return [];
-            },
-        }),
-        getRawProcessDetail: builder.query<
-            ProcessDetailResultRaw,
-            { processId: string }
-        >({
-            query: ({ processId }) => ({
-                url: `${PROCESSES_ENDPOINT}/${processId}`,
-                method: 'GET',
-                headers: {
-                    'Content-Type': 'application/json',
-                },
-            }),
-            extraOptions: {
-                baseQueryType: BaseQueryTypes.fetch,
-            },
-        }),
-        retryAllProcesses: builder.mutation<void, null>({
-            query: () => ({
-                url: `${PROCESSES_ENDPOINT}/${PROCESSES_RESUME_ALL_ENDPOINT}`,
-                method: 'PUT',
-            }),
-            extraOptions: {
-                baseQueryType: BaseQueryTypes.fetch,
-            },
-            invalidatesTags: getCacheTag(CacheTagType.processes),
-        }),
-        retryProcess: builder.mutation<void, { processId: string }>({
-            query: ({ processId }) => ({
-                url: `${PROCESSES_ENDPOINT}/${processId}/${PROCESS_RESUME_ENDPOINT}`,
-                method: 'PUT',
-                headers: {
-                    'Content-Type': 'application/json',
-                },
-                body: '{}',
-            }),
-            extraOptions: {
-                baseQueryType: BaseQueryTypes.fetch,
-            },
-            invalidatesTags: getCacheTag(CacheTagType.processes),
-        }),
-        deleteProcess: builder.mutation<void, { processId: string }>({
-            query: ({ processId }) => ({
-                url: `${PROCESSES_ENDPOINT}/${processId}`,
-                method: 'DELETE',
-            }),
-            extraOptions: {
-                baseQueryType: BaseQueryTypes.fetch,
-            },
-            invalidatesTags: getCacheTag(CacheTagType.processes),
-        }),
-        abortProcess: builder.mutation<void, { processId: string }>({
-            query: ({ processId }) => ({
-                url: `${PROCESSES_ENDPOINT}/${processId}/${PROCESS_ABORT_ENDPOINT}`,
-                method: 'PUT',
-            }),
-            extraOptions: {
-                baseQueryType: BaseQueryTypes.fetch,
-            },
-            invalidatesTags: getCacheTag(CacheTagType.processes),
-        }),
+        return {
+          processes,
+        };
+      },
+      providesTags: (result, error, queryArguments) => {
+        if (!error && result) {
+          return getCacheTag(CacheTagType.processes, queryArguments.processId);
+        }
+        return [];
+      },
+    }),
+    getRawProcessDetail: builder.query<ProcessDetailResultRaw, { processId: string }>({
+      query: ({ processId }) => ({
+        url: `${PROCESSES_ENDPOINT}/${processId}`,
+        method: 'GET',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+      }),
+      extraOptions: {
+        baseQueryType: BaseQueryTypes.fetch,
+      },
+    }),
+    retryAllProcesses: builder.mutation<void, null>({
+      query: () => ({
+        url: `${PROCESSES_ENDPOINT}/${PROCESSES_RESUME_ALL_ENDPOINT}`,
+        method: 'PUT',
+      }),
+      extraOptions: {
+        baseQueryType: BaseQueryTypes.fetch,
+      },
+      invalidatesTags: getCacheTag(CacheTagType.processes),
+    }),
+    retryProcess: builder.mutation<void, { processId: string }>({
+      query: ({ processId }) => ({
+        url: `${PROCESSES_ENDPOINT}/${processId}/${PROCESS_RESUME_ENDPOINT}`,
+        method: 'PUT',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: '{}',
+      }),
+      extraOptions: {
+        baseQueryType: BaseQueryTypes.fetch,
+      },
+      invalidatesTags: getCacheTag(CacheTagType.processes),
+    }),
+    deleteProcess: builder.mutation<void, { processId: string }>({
+      query: ({ processId }) => ({
+        url: `${PROCESSES_ENDPOINT}/${processId}`,
+        method: 'DELETE',
+      }),
+      extraOptions: {
+        baseQueryType: BaseQueryTypes.fetch,
+      },
+      invalidatesTags: getCacheTag(CacheTagType.processes),
+    }),
+    abortProcess: builder.mutation<void, { processId: string }>({
+      query: ({ processId }) => ({
+        url: `${PROCESSES_ENDPOINT}/${processId}/${PROCESS_ABORT_ENDPOINT}`,
+        method: 'PUT',
+      }),
+      extraOptions: {
+        baseQueryType: BaseQueryTypes.fetch,
+      },
+      invalidatesTags: getCacheTag(CacheTagType.processes),
     }),
+  }),
 });
 
 export const {
-    useGetProcessDetailQuery,
-    useGetRawProcessDetailQuery,
-    useRetryAllProcessesMutation,
-    useRetryProcessMutation,
-    useDeleteProcessMutation,
-    useAbortProcessMutation,
+  useGetProcessDetailQuery,
+  useGetRawProcessDetailQuery,
+  useRetryAllProcessesMutation,
+  useRetryProcessMutation,
+  useDeleteProcessMutation,
+  useAbortProcessMutation,
 } = processDetailApi;

package/src/rtk/endpoints/processList.ts

@@ -1,10 +1,10 @@
 import {
-    BaseGraphQlResult,
-    CACHETAG_TYPE_LIST,
-    CacheTagType,
-    GraphqlQueryVariables,
-    Process,
-    ProcessListResult,
+  BaseGraphQlResult,
+  CACHETAG_TYPE_LIST,
+  CacheTagType,
+  GraphqlQueryVariables,
+  Process,
+  ProcessListResult,
 } from '@/types';
 import { getCacheTag } from '@/utils/cacheTag';
 
@@ -65,33 +65,24 @@ export const processListQuery = `
 `;
 
 export type ProcessListResponse = {
-    processes: Process[];
+  processes: Process[];
 } & BaseGraphQlResult;
 
 const processApi = orchestratorApi.injectEndpoints({
-    endpoints: (build) => ({
-        getProcessList: build.query<
-            ProcessListResponse,
-            GraphqlQueryVariables<Process>
-        >({
-            query: (variables) => ({ document: processListQuery, variables }),
-            transformResponse: (
-                response: ProcessListResult,
-            ): ProcessListResponse => {
-                const processes = response.processes.page || [];
+  endpoints: (build) => ({
+    getProcessList: build.query<ProcessListResponse, GraphqlQueryVariables<Process>>({
+      query: (variables) => ({ document: processListQuery, variables }),
+      transformResponse: (response: ProcessListResult): ProcessListResponse => {
+        const processes = response.processes.page || [];
 
-                return {
-                    processes,
-                    pageInfo: response.processes?.pageInfo || {},
-                };
-            },
-            providesTags: getCacheTag(
-                CacheTagType.processes,
-                CACHETAG_TYPE_LIST,
-            ),
-        }),
+        return {
+          processes,
+          pageInfo: response.processes?.pageInfo || {},
+        };
+      },
+      providesTags: getCacheTag(CacheTagType.processes, CACHETAG_TYPE_LIST),
     }),
+  }),
 });
 
-export const { useGetProcessListQuery, useLazyGetProcessListQuery } =
-    processApi;
+export const { useGetProcessListQuery, useLazyGetProcessListQuery } = processApi;

package/src/rtk/endpoints/processListSummary.ts

@@ -1,10 +1,5 @@
 import { orchestratorApi } from '@/rtk';
-import {
-    BaseGraphQlResult,
-    GraphqlQueryVariables,
-    Process,
-    ProcessListResult,
-} from '@/types';
+import { BaseGraphQlResult, GraphqlQueryVariables, Process, ProcessListResult } from '@/types';
 import { CACHETAG_TYPE_LIST, CacheTagType } from '@/types';
 import { getCacheTag } from '@/utils/cacheTag';
 
@@ -37,41 +32,30 @@ export const processListSummaryQuery = `
     }
 `;
 
-export type ProcessSummary = Pick<
-    Process,
-    'processId' | 'workflowName' | 'startedAt'
->;
+export type ProcessSummary = Pick<Process, 'processId' | 'workflowName' | 'startedAt'>;
 
 export type ProcessListSummaryResponse = {
-    processes: ProcessSummary[];
+  processes: ProcessSummary[];
 } & BaseGraphQlResult;
 
 const processApi = orchestratorApi.injectEndpoints({
-    endpoints: (build) => ({
-        getProcessListSummary: build.query<
-            ProcessListSummaryResponse,
-            GraphqlQueryVariables<Process>
-        >({
-            query: (variables) => ({
-                document: processListSummaryQuery,
-                variables,
-            }),
-            transformResponse: (
-                response: ProcessListResult<ProcessSummary>,
-            ): ProcessListSummaryResponse => {
-                const processes = response.processes.page || [];
+  endpoints: (build) => ({
+    getProcessListSummary: build.query<ProcessListSummaryResponse, GraphqlQueryVariables<Process>>({
+      query: (variables) => ({
+        document: processListSummaryQuery,
+        variables,
+      }),
+      transformResponse: (response: ProcessListResult<ProcessSummary>): ProcessListSummaryResponse => {
+        const processes = response.processes.page || [];
 
-                return {
-                    processes,
-                    pageInfo: response.processes?.pageInfo || {},
-                };
-            },
-            providesTags: getCacheTag(
-                CacheTagType.processes,
-                CACHETAG_TYPE_LIST,
-            ),
-        }),
+        return {
+          processes,
+          pageInfo: response.processes?.pageInfo || {},
+        };
+      },
+      providesTags: getCacheTag(CacheTagType.processes, CACHETAG_TYPE_LIST),
     }),
+  }),
 });
 
 export const { useGetProcessListSummaryQuery } = processApi;

package/src/rtk/endpoints/processStatusCounts.ts

@@ -4,26 +4,26 @@ import { CacheTagType, ProcessStatus } from '@/types';
 import { getCacheTag } from '@/utils/cacheTag';
 
 export type ProcessStatusCounts = {
-    process_counts: Record<ProcessStatus, number>;
-    task_counts: Record<ProcessStatus, number>;
+  process_counts: Record<ProcessStatus, number>;
+  task_counts: Record<ProcessStatus, number>;
 };
 
 const processStatusApi = orchestratorApi.injectEndpoints({
-    endpoints: (build) => ({
-        processStatusCounts: build.query<ProcessStatusCounts, void>({
-            query: () => ({
-                url: `${PROCESS_STATUS_COUNTS_ENDPOINT}`,
-                method: 'GET',
-                headers: {
-                    'Content-Type': 'application/json',
-                },
-            }),
-            extraOptions: {
-                baseQueryType: BaseQueryTypes.fetch,
-            },
-            providesTags: getCacheTag(CacheTagType.processStatusCounts),
-        }),
+  endpoints: (build) => ({
+    processStatusCounts: build.query<ProcessStatusCounts, void>({
+      query: () => ({
+        url: `${PROCESS_STATUS_COUNTS_ENDPOINT}`,
+        method: 'GET',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+      }),
+      extraOptions: {
+        baseQueryType: BaseQueryTypes.fetch,
+      },
+      providesTags: getCacheTag(CacheTagType.processStatusCounts),
     }),
+  }),
 });
 
 export const { useProcessStatusCountsQuery } = processStatusApi;

package/src/rtk/endpoints/processSteps.ts

@@ -1,10 +1,5 @@
 import { TimelineItem } from '@/components';
-import {
-    Process,
-    ProcessStepsResult,
-    StartProcessStep,
-    StepStatus,
-} from '@/types';
+import { Process, ProcessStepsResult, StartProcessStep, StepStatus } from '@/types';
 
 import { orchestratorApi } from '../api';
 
@@ -22,29 +17,24 @@ export const processStepsQuery = `
 `;
 
 const processStepApi = orchestratorApi.injectEndpoints({
-    endpoints: (build) => ({
-        getTimeLineItems: build.query<TimelineItem[], Process['workflowName']>({
-            query: (processName) => ({
-                document: processStepsQuery,
-                variables: { processName },
-            }),
-            transformResponse: (
-                response: ProcessStepsResult,
-            ): TimelineItem[] => {
-                const timeLineItems: TimelineItem[] =
-                    response.workflows.page[0].steps.map(
-                        ({ name }: StartProcessStep) => {
-                            return {
-                                processStepStatus: StepStatus.PENDING,
-                                stepDetail: name,
-                            };
-                        },
-                    );
+  endpoints: (build) => ({
+    getTimeLineItems: build.query<TimelineItem[], Process['workflowName']>({
+      query: (processName) => ({
+        document: processStepsQuery,
+        variables: { processName },
+      }),
+      transformResponse: (response: ProcessStepsResult): TimelineItem[] => {
+        const timeLineItems: TimelineItem[] = response.workflows.page[0].steps.map(({ name }: StartProcessStep) => {
+          return {
+            processStepStatus: StepStatus.PENDING,
+            stepDetail: name,
+          };
+        });
 
-                return timeLineItems;
-            },
-        }),
+        return timeLineItems;
+      },
     }),
+  }),
 });
 
 export const { useGetTimeLineItemsQuery } = processStepApi;

package/src/rtk/endpoints/productsSummary.ts

@@ -1,10 +1,10 @@
 import { orchestratorApi } from '@/rtk';
 import {
-    BaseGraphQlResult,
-    GraphqlQueryVariables,
-    ProductDefinitionsResult,
-    ProductsSummary,
-    Subscription,
+  BaseGraphQlResult,
+  GraphqlQueryVariables,
+  ProductDefinitionsResult,
+  ProductsSummary,
+  Subscription,
 } from '@/types';
 
 export const productsSummary = `
@@ -33,32 +33,27 @@ export const productsSummary = `
 `;
 
 export type ProductsSummaryResponse = {
-    products: ProductsSummary[];
+  products: ProductsSummary[];
 } & BaseGraphQlResult;
 
 const productsSummaryApi = orchestratorApi.injectEndpoints({
-    endpoints: (builder) => ({
-        getProductsSummary: builder.query<
-            ProductsSummaryResponse,
-            GraphqlQueryVariables<ProductsSummary & Subscription>
-        >({
-            query: (variables) => ({
-                document: productsSummary,
-                variables,
-            }),
-            transformResponse: (
-                response: ProductDefinitionsResult<ProductsSummary>,
-            ): ProductsSummaryResponse => {
-                const products = response.products.page || [];
-                const pageInfo = response.products.pageInfo || {};
+  endpoints: (builder) => ({
+    getProductsSummary: builder.query<ProductsSummaryResponse, GraphqlQueryVariables<ProductsSummary & Subscription>>({
+      query: (variables) => ({
+        document: productsSummary,
+        variables,
+      }),
+      transformResponse: (response: ProductDefinitionsResult<ProductsSummary>): ProductsSummaryResponse => {
+        const products = response.products.page || [];
+        const pageInfo = response.products.pageInfo || {};
 
-                return {
-                    products,
-                    pageInfo,
-                };
-            },
-        }),
+        return {
+          products,
+          pageInfo,
+        };
+      },
     }),
+  }),
 });
 
 export const { useGetProductsSummaryQuery } = productsSummaryApi;

package/src/rtk/endpoints/relatedSubscriptions.ts

@@ -1,10 +1,10 @@
 import {
-    BaseGraphQlResult,
-    GraphqlFilter,
-    GraphqlQueryVariables,
-    RelatedSubscription,
-    RelatedSubscriptionsResult,
-    Subscription,
+  BaseGraphQlResult,
+  GraphqlFilter,
+  GraphqlQueryVariables,
+  RelatedSubscription,
+  RelatedSubscriptionsResult,
+  Subscription,
 } from '@/types';
 
 import { orchestratorApi } from '../api';
@@ -57,44 +57,33 @@ query RelatedSubscriptions(
 `;
 
 export type RelatedSubscriptionsResponse = {
-    relatedSubscriptions: RelatedSubscription[];
+  relatedSubscriptions: RelatedSubscription[];
 } & BaseGraphQlResult;
 
-export type RelatedSubscriptionVariables =
-    GraphqlQueryVariables<RelatedSubscription> &
-        Pick<Subscription, 'subscriptionId'> & {
-            terminatedSubscriptionFilter?: GraphqlFilter<RelatedSubscription>;
-        };
+export type RelatedSubscriptionVariables = GraphqlQueryVariables<RelatedSubscription>
+  & Pick<Subscription, 'subscriptionId'> & {
+    terminatedSubscriptionFilter?: GraphqlFilter<RelatedSubscription>;
+  };
 
 const relatedSubscriptionsApi = orchestratorApi.injectEndpoints({
-    endpoints: (build) => ({
-        getRelatedSubscriptions: build.query<
-            RelatedSubscriptionsResponse,
-            RelatedSubscriptionVariables
-        >({
-            query: (variables) => ({
-                document: RelatedSubscriptionsQuery,
-                variables,
-            }),
-            transformResponse: (
-                result: RelatedSubscriptionsResult,
-            ): RelatedSubscriptionsResponse => {
-                const relatedSubscriptionResultForSubscription =
-                    result.subscriptions.page[0] || [];
-                const relatedSubscriptions =
-                    relatedSubscriptionResultForSubscription
-                        .inUseBySubscriptions.page || [];
-                const pageInfo =
-                    relatedSubscriptionResultForSubscription
-                        .inUseBySubscriptions.pageInfo || {};
+  endpoints: (build) => ({
+    getRelatedSubscriptions: build.query<RelatedSubscriptionsResponse, RelatedSubscriptionVariables>({
+      query: (variables) => ({
+        document: RelatedSubscriptionsQuery,
+        variables,
+      }),
+      transformResponse: (result: RelatedSubscriptionsResult): RelatedSubscriptionsResponse => {
+        const relatedSubscriptionResultForSubscription = result.subscriptions.page[0] || [];
+        const relatedSubscriptions = relatedSubscriptionResultForSubscription.inUseBySubscriptions.page || [];
+        const pageInfo = relatedSubscriptionResultForSubscription.inUseBySubscriptions.pageInfo || {};
 
-                return {
-                    relatedSubscriptions,
-                    pageInfo,
-                };
-            },
-        }),
+        return {
+          relatedSubscriptions,
+          pageInfo,
+        };
+      },
     }),
+  }),
 });
 
 export const { useGetRelatedSubscriptionsQuery } = relatedSubscriptionsApi;