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

package/src/rtk/endpoints/availability.ts

@@ -3,39 +3,36 @@ import { BaseQueryTypes, orchestratorApi } from '@/rtk';
 type AvailabilityCheckResponse = Record<string, unknown>;
 
 const availabilityApi = orchestratorApi.injectEndpoints({
-    endpoints: (build) => ({
-        checkSearchAvailability: build.query<AvailabilityCheckResponse, void>({
-            query: () => ({
-                url: 'search/definitions',
-                method: 'GET',
-                headers: {
-                    'Content-Type': 'application/json',
-                },
-            }),
-            extraOptions: {
-                baseQueryType: BaseQueryTypes.fetch,
-            },
-        }),
-        checkAgentAvailability: build.query<AvailabilityCheckResponse, void>({
-            query: () => ({
-                url: '/agent/',
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                },
-                body: JSON.stringify({
-                    messages: [],
-                }),
-            }),
-            extraOptions: {
-                baseQueryType: BaseQueryTypes.fetch,
-                apiName: 'agent',
-            },
+  endpoints: (build) => ({
+    checkSearchAvailability: build.query<AvailabilityCheckResponse, void>({
+      query: () => ({
+        url: 'search/definitions',
+        method: 'GET',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+      }),
+      extraOptions: {
+        baseQueryType: BaseQueryTypes.fetch,
+      },
+    }),
+    checkAgentAvailability: build.query<AvailabilityCheckResponse, void>({
+      query: () => ({
+        url: '/agent/',
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+          messages: [],
         }),
+      }),
+      extraOptions: {
+        baseQueryType: BaseQueryTypes.fetch,
+        apiName: 'agent',
+      },
     }),
+  }),
 });
 
-export const {
-    useCheckSearchAvailabilityQuery,
-    useCheckAgentAvailabilityQuery,
-} = availabilityApi;
+export const { useCheckSearchAvailabilityQuery, useCheckAgentAvailabilityQuery } = availabilityApi;

package/src/rtk/endpoints/customerDescriptions.ts

@@ -3,52 +3,46 @@ import { BaseQueryTypes, orchestratorApi } from '@/rtk';
 import { CustomerDescriptions } from '@/types';
 
 const customerDescriptionsApi = orchestratorApi.injectEndpoints({
-    endpoints: (build) => ({
-        setCustomerDescription: build.mutation<
-            null,
-            Pick<
-                CustomerDescriptions,
-                'description' | 'customerId' | 'subscriptionId'
-            >
-        >({
-            query: (customerDescription) => ({
-                url: `${CUSTOMER_DESCRIPTION_ENDPOINT}`,
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                },
-                body: {
-                    customer_id: customerDescription.customerId,
-                    subscription_id: customerDescription.subscriptionId,
-                    description: customerDescription.description,
-                },
-            }),
-            extraOptions: {
-                baseQueryType: BaseQueryTypes.fetch,
-            },
-        }),
-        updateCustomerDescription: build.mutation<null, CustomerDescriptions>({
-            query: (customerDescription) => ({
-                url: `${CUSTOMER_DESCRIPTION_ENDPOINT}`,
-                method: 'PUT',
-                headers: {
-                    'Content-Type': 'application/json',
-                },
-                body: {
-                    id: customerDescription.id,
-                    customer_id: customerDescription.customerId,
-                    subscription_id: customerDescription.subscriptionId,
-                    description: customerDescription.description,
-                },
-            }),
-            extraOptions: {
-                baseQueryType: BaseQueryTypes.fetch,
-            },
-        }),
+  endpoints: (build) => ({
+    setCustomerDescription: build.mutation<
+      null,
+      Pick<CustomerDescriptions, 'description' | 'customerId' | 'subscriptionId'>
+    >({
+      query: (customerDescription) => ({
+        url: `${CUSTOMER_DESCRIPTION_ENDPOINT}`,
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: {
+          customer_id: customerDescription.customerId,
+          subscription_id: customerDescription.subscriptionId,
+          description: customerDescription.description,
+        },
+      }),
+      extraOptions: {
+        baseQueryType: BaseQueryTypes.fetch,
+      },
     }),
+    updateCustomerDescription: build.mutation<null, CustomerDescriptions>({
+      query: (customerDescription) => ({
+        url: `${CUSTOMER_DESCRIPTION_ENDPOINT}`,
+        method: 'PUT',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: {
+          id: customerDescription.id,
+          customer_id: customerDescription.customerId,
+          subscription_id: customerDescription.subscriptionId,
+          description: customerDescription.description,
+        },
+      }),
+      extraOptions: {
+        baseQueryType: BaseQueryTypes.fetch,
+      },
+    }),
+  }),
 });
 
-export const {
-    useSetCustomerDescriptionMutation,
-    useUpdateCustomerDescriptionMutation,
-} = customerDescriptionsApi;
+export const { useSetCustomerDescriptionMutation, useUpdateCustomerDescriptionMutation } = customerDescriptionsApi;

package/src/rtk/endpoints/customers.ts

@@ -1,10 +1,10 @@
 import { NUMBER_OF_ITEMS_REPRESENTING_ALL_ITEMS } from '@/configuration';
 import {
-    Customer,
-    CustomerWithSubscriptionCount,
-    CustomersResult,
-    CustomersWithSubscriptionCountResult,
-    SubscriptionStatus,
+  Customer,
+  CustomerWithSubscriptionCount,
+  CustomersResult,
+  CustomersWithSubscriptionCountResult,
+  SubscriptionStatus,
 } from '@/types';
 
 import { orchestratorApi } from '../api';
@@ -51,41 +51,27 @@ const customerQuery = `query Customer(
 }`;
 
 const customersApi = orchestratorApi.injectEndpoints({
-    endpoints: (build) => ({
-        getCustomersWithSubscriptionCount: build.query<
-            CustomerWithSubscriptionCount[],
-            void
-        >({
-            query: () => ({ document: customersWithSubscriptionCountQuery }),
-            transformResponse: (
-                response: CustomersWithSubscriptionCountResult,
-            ): CustomerWithSubscriptionCount[] =>
-                response.customers.page.filter(
-                    (customer) =>
-                        customer.subscriptions.pageInfo.totalItems > 0,
-                ),
-        }),
-        getCustomers: build.query<Customer[], void>({
-            query: () => ({ document: customersQuery }),
-            transformResponse: (response: CustomersResult): Customer[] =>
-                response?.customers?.page || [],
-        }),
-        getCustomer: build.query<Customer[], { customerIds: string[] }>({
-            query: ({ customerIds }) => ({
-                document: customerQuery,
-                variables: {
-                    customerId: customerIds.join('|'),
-                    first: customerIds.length,
-                },
-            }),
-            transformResponse: (response: CustomersResult): Customer[] =>
-                response?.customers?.page || [],
-        }),
+  endpoints: (build) => ({
+    getCustomersWithSubscriptionCount: build.query<CustomerWithSubscriptionCount[], void>({
+      query: () => ({ document: customersWithSubscriptionCountQuery }),
+      transformResponse: (response: CustomersWithSubscriptionCountResult): CustomerWithSubscriptionCount[] =>
+        response.customers.page.filter((customer) => customer.subscriptions.pageInfo.totalItems > 0),
     }),
+    getCustomers: build.query<Customer[], void>({
+      query: () => ({ document: customersQuery }),
+      transformResponse: (response: CustomersResult): Customer[] => response?.customers?.page || [],
+    }),
+    getCustomer: build.query<Customer[], { customerIds: string[] }>({
+      query: ({ customerIds }) => ({
+        document: customerQuery,
+        variables: {
+          customerId: customerIds.join('|'),
+          first: customerIds.length,
+        },
+      }),
+      transformResponse: (response: CustomersResult): Customer[] => response?.customers?.page || [],
+    }),
+  }),
 });
 
-export const {
-    useGetCustomersQuery,
-    useGetCustomerQuery,
-    useGetCustomersWithSubscriptionCountQuery,
-} = customersApi;
+export const { useGetCustomersQuery, useGetCustomerQuery, useGetCustomersWithSubscriptionCountQuery } = customersApi;

package/src/rtk/endpoints/fileUpload.ts

@@ -1,33 +1,33 @@
 import { BaseQueryTypes, orchestratorApi } from '@/rtk';
 
 export interface FileUploadPayload {
-    url: string;
-    file: File;
+  url: string;
+  file: File;
 }
 
 interface FileUploadReturnValue {
-    file_id: string;
-    file_name: string;
+  file_id: string;
+  file_name: string;
 }
 
 const fileUploadApi = orchestratorApi.injectEndpoints({
-    endpoints: (build) => ({
-        uploadFile: build.mutation<FileUploadReturnValue, FileUploadPayload>({
-            query: ({ url, file }) => {
-                const formData = new FormData();
-                formData.append('file', file);
-                return {
-                    url,
-                    method: 'POST',
-                    body: formData,
-                };
-            },
-            extraOptions: {
-                baseQueryType: BaseQueryTypes.fetch,
-                apiName: 'cim',
-            },
-        }),
+  endpoints: (build) => ({
+    uploadFile: build.mutation<FileUploadReturnValue, FileUploadPayload>({
+      query: ({ url, file }) => {
+        const formData = new FormData();
+        formData.append('file', file);
+        return {
+          url,
+          method: 'POST',
+          body: formData,
+        };
+      },
+      extraOptions: {
+        baseQueryType: BaseQueryTypes.fetch,
+        apiName: 'cim',
+      },
     }),
+  }),
 });
 
 export const { useUploadFileMutation } = fileUploadApi;

package/src/rtk/endpoints/forms.ts

@@ -5,60 +5,47 @@ const RESUME_ENDPOINT = 'resume';
 const FORMS_ENDPOINT = 'surf/forms/'; // It is still being used by example-wfo-ui
 
 const formsApi = orchestratorApi.injectEndpoints({
-    endpoints: (build) => ({
-        startProcess: build.mutation<
-            { id: string },
-            { workflowName: string; userInputs: object[] }
-        >({
-            query: ({ workflowName, userInputs }) => ({
-                url: `${PROCESS_ENDPOINT}/${workflowName}`,
-                method: 'POST',
-                body: JSON.stringify(userInputs),
-                headers: {
-                    'Content-Type': 'application/json',
-                },
-            }),
-            extraOptions: {
-                baseQueryType: BaseQueryTypes.fetch,
-            },
-        }),
-        resumeProcess: build.mutation<
-            void,
-            { processId: string; userInputs: object[] }
-        >({
-            query: ({ processId, userInputs }) => ({
-                url: `${PROCESS_ENDPOINT}/${processId}/${RESUME_ENDPOINT}`,
-                method: 'PUT',
-                body: JSON.stringify(userInputs),
-                headers: {
-                    'Content-Type': 'application/json',
-                },
-            }),
-            extraOptions: {
-                baseQueryType: BaseQueryTypes.fetch,
-            },
-        }),
-        startForm: build.mutation<
-            void,
-            { formKey: string; userInputs: object[] }
-        >({
-            query: ({ formKey, userInputs }) => ({
-                url: `${FORMS_ENDPOINT}${formKey}`,
-                method: 'POST',
-                body: JSON.stringify(userInputs),
-                headers: {
-                    'Content-Type': 'application/json',
-                },
-            }),
-            extraOptions: {
-                baseQueryType: BaseQueryTypes.fetch,
-            },
-        }),
+  endpoints: (build) => ({
+    startProcess: build.mutation<{ id: string }, { workflowName: string; userInputs: object[] }>({
+      query: ({ workflowName, userInputs }) => ({
+        url: `${PROCESS_ENDPOINT}/${workflowName}`,
+        method: 'POST',
+        body: JSON.stringify(userInputs),
+        headers: {
+          'Content-Type': 'application/json',
+        },
+      }),
+      extraOptions: {
+        baseQueryType: BaseQueryTypes.fetch,
+      },
     }),
+    resumeProcess: build.mutation<void, { processId: string; userInputs: object[] }>({
+      query: ({ processId, userInputs }) => ({
+        url: `${PROCESS_ENDPOINT}/${processId}/${RESUME_ENDPOINT}`,
+        method: 'PUT',
+        body: JSON.stringify(userInputs),
+        headers: {
+          'Content-Type': 'application/json',
+        },
+      }),
+      extraOptions: {
+        baseQueryType: BaseQueryTypes.fetch,
+      },
+    }),
+    startForm: build.mutation<void, { formKey: string; userInputs: object[] }>({
+      query: ({ formKey, userInputs }) => ({
+        url: `${FORMS_ENDPOINT}${formKey}`,
+        method: 'POST',
+        body: JSON.stringify(userInputs),
+        headers: {
+          'Content-Type': 'application/json',
+        },
+      }),
+      extraOptions: {
+        baseQueryType: BaseQueryTypes.fetch,
+      },
+    }),
+  }),
 });
 
-export const {
-    useStartProcessMutation,
-    useResumeProcessMutation,
-    useStartFormMutation,
-} = formsApi;
+export const { useStartProcessMutation, useResumeProcessMutation, useStartFormMutation } = formsApi;

package/src/rtk/endpoints/inSync.ts

@@ -3,26 +3,23 @@ import { CacheTagType, Subscription } from '@/types';
 import { BaseQueryTypes, orchestratorApi } from '../api';
 
 const inSyncApi = orchestratorApi.injectEndpoints({
-    endpoints: (build) => ({
-        setSubscriptionInSync: build.mutation<
-            void,
-            Subscription['subscriptionId']
-        >({
-            query: (subscriptionId) => ({
-                url: `subscriptions/${subscriptionId}/set_in_sync`,
-                method: 'PUT',
-            }),
-            extraOptions: {
-                baseQueryType: BaseQueryTypes.fetch,
-            },
-            invalidatesTags: (_result, _error, subscriptionId) => [
-                {
-                    type: CacheTagType.subscriptions,
-                    id: subscriptionId,
-                },
-            ],
-        }),
+  endpoints: (build) => ({
+    setSubscriptionInSync: build.mutation<void, Subscription['subscriptionId']>({
+      query: (subscriptionId) => ({
+        url: `subscriptions/${subscriptionId}/set_in_sync`,
+        method: 'PUT',
+      }),
+      extraOptions: {
+        baseQueryType: BaseQueryTypes.fetch,
+      },
+      invalidatesTags: (_result, _error, subscriptionId) => [
+        {
+          type: CacheTagType.subscriptions,
+          id: subscriptionId,
+        },
+      ],
     }),
+  }),
 });
 
 export const { useSetSubscriptionInSyncMutation } = inSyncApi;

package/src/rtk/endpoints/metadata/productBlocks.ts

@@ -2,10 +2,10 @@ import { METADATA_PRODUCT_BLOCK_ENDPOINT } from '@/configuration';
 import { BaseQueryTypes, orchestratorApi } from '@/rtk';
 import { MetadataDescriptionParams } from '@/types';
 import {
-    BaseGraphQlResult,
-    GraphqlQueryVariables,
-    ProductBlockDefinition,
-    ProductBlockDefinitionsResult,
+  BaseGraphQlResult,
+  GraphqlQueryVariables,
+  ProductBlockDefinition,
+  ProductBlockDefinitionsResult,
 } from '@/types';
 
 export const productBlocksQuery = `
@@ -58,55 +58,49 @@ export const productBlocksQuery = `
 `;
 
 export type ProductBlocksResponse = {
-    productBlocks: ProductBlockDefinition[];
+  productBlocks: ProductBlockDefinition[];
 } & BaseGraphQlResult;
 
 const productBlocksApi = orchestratorApi.injectEndpoints({
-    endpoints: (builder) => ({
-        getProductBlocks: builder.query<
-            ProductBlocksResponse,
-            GraphqlQueryVariables<ProductBlockDefinition>
-        >({
-            query: (variables) => ({
-                document: productBlocksQuery,
-                variables,
-            }),
-            transformResponse: (
-                response: ProductBlockDefinitionsResult,
-            ): ProductBlocksResponse => {
-                const productBlocks = response.productBlocks.page || [];
-                const pageInfo = response.productBlocks.pageInfo || {};
+  endpoints: (builder) => ({
+    getProductBlocks: builder.query<ProductBlocksResponse, GraphqlQueryVariables<ProductBlockDefinition>>({
+      query: (variables) => ({
+        document: productBlocksQuery,
+        variables,
+      }),
+      transformResponse: (response: ProductBlockDefinitionsResult): ProductBlocksResponse => {
+        const productBlocks = response.productBlocks.page || [];
+        const pageInfo = response.productBlocks.pageInfo || {};
 
-                return {
-                    productBlocks,
-                    pageInfo,
-                };
-            },
-        }),
+        return {
+          productBlocks,
+          pageInfo,
+        };
+      },
     }),
+  }),
 });
 
-export const { useGetProductBlocksQuery, useLazyGetProductBlocksQuery } =
-    productBlocksApi;
+export const { useGetProductBlocksQuery, useLazyGetProductBlocksQuery } = productBlocksApi;
 
 const productBlocksRestApi = orchestratorApi.injectEndpoints({
-    endpoints: (build) => ({
-        updateProductBlock: build.mutation<null, MetadataDescriptionParams>({
-            query: (productBlock) => ({
-                url: `${METADATA_PRODUCT_BLOCK_ENDPOINT}/${productBlock.id}`,
-                method: 'PATCH',
-                headers: {
-                    'Content-Type': 'application/json',
-                },
-                body: {
-                    description: productBlock.description,
-                },
-            }),
-            extraOptions: {
-                baseQueryType: BaseQueryTypes.fetch,
-            },
-        }),
+  endpoints: (build) => ({
+    updateProductBlock: build.mutation<null, MetadataDescriptionParams>({
+      query: (productBlock) => ({
+        url: `${METADATA_PRODUCT_BLOCK_ENDPOINT}/${productBlock.id}`,
+        method: 'PATCH',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: {
+          description: productBlock.description,
+        },
+      }),
+      extraOptions: {
+        baseQueryType: BaseQueryTypes.fetch,
+      },
     }),
+  }),
 });
 
 export const { useUpdateProductBlockMutation } = productBlocksRestApi;

package/src/rtk/endpoints/metadata/products.ts

@@ -1,11 +1,11 @@
 import { METADATA_PRODUCT_ENDPOINT } from '@/configuration/constants';
 import { BaseQueryTypes, orchestratorApi } from '@/rtk';
 import {
-    BaseGraphQlResult,
-    GraphqlQueryVariables,
-    MetadataDescriptionParams,
-    ProductDefinition,
-    ProductDefinitionsResult,
+  BaseGraphQlResult,
+  GraphqlQueryVariables,
+  MetadataDescriptionParams,
+  ProductDefinition,
+  ProductDefinitionsResult,
 } from '@/types';
 
 export const products = `
@@ -47,54 +47,49 @@ export const products = `
 `;
 
 export type ProductsResponse = {
-    products: ProductDefinition[];
+  products: ProductDefinition[];
 } & BaseGraphQlResult;
 
 const productsApi = orchestratorApi.injectEndpoints({
-    endpoints: (builder) => ({
-        getProducts: builder.query<
-            ProductsResponse,
-            GraphqlQueryVariables<ProductDefinition>
-        >({
-            query: (variables) => ({
-                document: products,
-                variables,
-            }),
-            transformResponse: (
-                response: ProductDefinitionsResult,
-            ): ProductsResponse => {
-                const products = response.products.page || [];
-                const pageInfo = response.products.pageInfo || {};
+  endpoints: (builder) => ({
+    getProducts: builder.query<ProductsResponse, GraphqlQueryVariables<ProductDefinition>>({
+      query: (variables) => ({
+        document: products,
+        variables,
+      }),
+      transformResponse: (response: ProductDefinitionsResult): ProductsResponse => {
+        const products = response.products.page || [];
+        const pageInfo = response.products.pageInfo || {};
 
-                return {
-                    products,
-                    pageInfo,
-                };
-            },
-        }),
+        return {
+          products,
+          pageInfo,
+        };
+      },
     }),
+  }),
 });
 
 export const { useGetProductsQuery, useLazyGetProductsQuery } = productsApi;
 
 const productRestApi = orchestratorApi.injectEndpoints({
-    endpoints: (build) => ({
-        updateProduct: build.mutation<null, MetadataDescriptionParams>({
-            query: (product) => ({
-                url: `${METADATA_PRODUCT_ENDPOINT}/${product.id}`,
-                method: 'PATCH',
-                headers: {
-                    'Content-Type': 'application/json',
-                },
-                body: {
-                    description: product.description,
-                },
-            }),
-            extraOptions: {
-                baseQueryType: BaseQueryTypes.fetch,
-            },
-        }),
+  endpoints: (build) => ({
+    updateProduct: build.mutation<null, MetadataDescriptionParams>({
+      query: (product) => ({
+        url: `${METADATA_PRODUCT_ENDPOINT}/${product.id}`,
+        method: 'PATCH',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: {
+          description: product.description,
+        },
+      }),
+      extraOptions: {
+        baseQueryType: BaseQueryTypes.fetch,
+      },
     }),
+  }),
 });
 
 export const { useUpdateProductMutation } = productRestApi;