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

package/src/rtk/endpoints/subscriptionListMutation.ts

@@ -1,90 +1,74 @@
 import { SubscriptionListItem } from '@/components/WfoSubscriptionsList';
-import {
-    SubscriptionDetailResponse,
-    SubscriptionListResponse,
-    orchestratorApi,
-} from '@/rtk';
+import { SubscriptionDetailResponse, SubscriptionListResponse, orchestratorApi } from '@/rtk';
 import { GraphqlQueryVariables } from '@/types';
 
 const subscriptionListMutationApi = orchestratorApi.injectEndpoints({
-    endpoints: (builder) => ({
-        emptyQuery: builder.query<
-            SubscriptionListResponse,
-            GraphqlQueryVariables<SubscriptionListItem>
-        >({ query: () => ({}) }),
-        emptyDetailQuery: builder.query<
-            SubscriptionDetailResponse,
-            { subscriptionId: string }
-        >({ query: () => ({}) }),
-        updateSubscriptionNoteOptimistic: builder.mutation<
-            { mockResponse: boolean },
-            {
-                queryName: string;
-                subscriptionId: string;
-                graphQlQueryVariables: GraphqlQueryVariables<SubscriptionListItem>;
-                note: string;
-            }
-        >({
-            queryFn: async () => ({ data: { mockResponse: true } }),
-            async onQueryStarted(
-                { queryName, subscriptionId, graphQlQueryVariables, ...patch },
-                { dispatch, queryFulfilled },
-            ) {
-                const patchResult = dispatch(
-                    subscriptionListMutationApi.util.updateQueryData(
-                        // @ts-expect-error - Suggest ts ignore because of the type mismatch between emptyQuery and queryName
-                        queryName,
-                        graphQlQueryVariables,
-                        (draft: SubscriptionListResponse) => {
-                            const subscription = draft.subscriptions.find(
-                                (item) =>
-                                    item.subscriptionId === subscriptionId,
-                            );
-                            if (subscription) {
-                                subscription.note = patch.note;
-                            }
-                        },
-                    ),
-                );
-                try {
-                    await queryFulfilled;
-                } catch {
-                    patchResult.undo();
-                }
+  endpoints: (builder) => ({
+    emptyQuery: builder.query<SubscriptionListResponse, GraphqlQueryVariables<SubscriptionListItem>>({
+      query: () => ({}),
+    }),
+    emptyDetailQuery: builder.query<SubscriptionDetailResponse, { subscriptionId: string }>({ query: () => ({}) }),
+    updateSubscriptionNoteOptimistic: builder.mutation<
+      { mockResponse: boolean },
+      {
+        queryName: string;
+        subscriptionId: string;
+        graphQlQueryVariables: GraphqlQueryVariables<SubscriptionListItem>;
+        note: string;
+      }
+    >({
+      queryFn: async () => ({ data: { mockResponse: true } }),
+      async onQueryStarted(
+        { queryName, subscriptionId, graphQlQueryVariables, ...patch },
+        { dispatch, queryFulfilled },
+      ) {
+        const patchResult = dispatch(
+          subscriptionListMutationApi.util.updateQueryData(
+            // @ts-expect-error - Suggest ts ignore because of the type mismatch between emptyQuery and queryName
+            queryName,
+            graphQlQueryVariables,
+            (draft: SubscriptionListResponse) => {
+              const subscription = draft.subscriptions.find((item) => item.subscriptionId === subscriptionId);
+              if (subscription) {
+                subscription.note = patch.note;
+              }
             },
-        }),
-        updateSubscriptionDetailNoteOptimistic: builder.mutation<
-            { mockResponse: boolean },
-            { queryName: string; subscriptionId: string; note: string }
-        >({
-            queryFn: async () => ({ data: { mockResponse: true } }),
-            async onQueryStarted(
-                { queryName, subscriptionId, ...patch },
-                { dispatch, queryFulfilled },
-            ) {
-                const patchResult = dispatch(
-                    subscriptionListMutationApi.util.updateQueryData(
-                        // @ts-expect-error - Suggest ts ignore because of the type mismatch between emptyDetailQuery and queryName
-                        queryName,
-                        { subscriptionId: subscriptionId },
-                        (draft: SubscriptionDetailResponse) => {
-                            if (draft) {
-                                draft.subscription.note = patch.note;
-                            }
-                        },
-                    ),
-                );
-                try {
-                    await queryFulfilled;
-                } catch {
-                    patchResult.undo();
-                }
+          ),
+        );
+        try {
+          await queryFulfilled;
+        } catch {
+          patchResult.undo();
+        }
+      },
+    }),
+    updateSubscriptionDetailNoteOptimistic: builder.mutation<
+      { mockResponse: boolean },
+      { queryName: string; subscriptionId: string; note: string }
+    >({
+      queryFn: async () => ({ data: { mockResponse: true } }),
+      async onQueryStarted({ queryName, subscriptionId, ...patch }, { dispatch, queryFulfilled }) {
+        const patchResult = dispatch(
+          subscriptionListMutationApi.util.updateQueryData(
+            // @ts-expect-error - Suggest ts ignore because of the type mismatch between emptyDetailQuery and queryName
+            queryName,
+            { subscriptionId: subscriptionId },
+            (draft: SubscriptionDetailResponse) => {
+              if (draft) {
+                draft.subscription.note = patch.note;
+              }
             },
-        }),
+          ),
+        );
+        try {
+          await queryFulfilled;
+        } catch {
+          patchResult.undo();
+        }
+      },
     }),
+  }),
 });
 
-export const {
-    useUpdateSubscriptionNoteOptimisticMutation,
-    useUpdateSubscriptionDetailNoteOptimisticMutation,
-} = subscriptionListMutationApi;
+export const { useUpdateSubscriptionNoteOptimisticMutation, useUpdateSubscriptionDetailNoteOptimisticMutation } =
+  subscriptionListMutationApi;

package/src/rtk/endpoints/subscriptionListSummary.ts

@@ -1,11 +1,11 @@
 import { orchestratorApi } from '@/rtk';
 import { CacheTagType } from '@/types';
 import {
-    BaseGraphQlResult,
-    GraphqlQueryVariables,
-    Subscription,
-    SubscriptionSummary,
-    SubscriptionsResult,
+  BaseGraphQlResult,
+  GraphqlQueryVariables,
+  Subscription,
+  SubscriptionSummary,
+  SubscriptionsResult,
 } from '@/types';
 import { getCacheTag } from '@/utils/cacheTag';
 
@@ -39,34 +39,28 @@ export const subscriptionListSummaryQuery = `
 `;
 
 export type SubscriptionListSummaryResponse = {
-    subscriptions: SubscriptionSummary[];
+  subscriptions: SubscriptionSummary[];
 } & BaseGraphQlResult;
 
 const subscriptionListSummaryApi = orchestratorApi.injectEndpoints({
-    endpoints: (builder) => ({
-        getSubscriptionSummaryList: builder.query<
-            SubscriptionListSummaryResponse,
-            GraphqlQueryVariables<Subscription>
-        >({
-            query: (variables) => ({
-                document: subscriptionListSummaryQuery,
-                variables,
-            }),
-            transformResponse: (
-                response: SubscriptionsResult<SubscriptionSummary>,
-            ): SubscriptionListSummaryResponse => {
-                const subscriptions = response.subscriptions.page || [];
-                const pageInfo = response.subscriptions.pageInfo || {};
+  endpoints: (builder) => ({
+    getSubscriptionSummaryList: builder.query<SubscriptionListSummaryResponse, GraphqlQueryVariables<Subscription>>({
+      query: (variables) => ({
+        document: subscriptionListSummaryQuery,
+        variables,
+      }),
+      transformResponse: (response: SubscriptionsResult<SubscriptionSummary>): SubscriptionListSummaryResponse => {
+        const subscriptions = response.subscriptions.page || [];
+        const pageInfo = response.subscriptions.pageInfo || {};
 
-                return {
-                    subscriptions,
-                    pageInfo,
-                };
-            },
-            providesTags: getCacheTag(CacheTagType.subscriptions),
-        }),
+        return {
+          subscriptions,
+          pageInfo,
+        };
+      },
+      providesTags: getCacheTag(CacheTagType.subscriptions),
     }),
+  }),
 });
 
-export const { useGetSubscriptionSummaryListQuery } =
-    subscriptionListSummaryApi;
+export const { useGetSubscriptionSummaryListQuery } = subscriptionListSummaryApi;

package/src/rtk/endpoints/translations.ts

@@ -3,29 +3,26 @@ import { BaseQueryTypes, orchestratorApi } from '@/rtk';
 const TRANSLATIONS_URL = 'translations';
 
 export type BackendTranslationsResponse = {
-    forms: {
-        fields: Record<string, string>;
-    };
+  forms: {
+    fields: Record<string, string>;
+  };
 };
 
 const translationsApi = orchestratorApi.injectEndpoints({
-    endpoints: (build) => ({
-        translations: build.query<
-            BackendTranslationsResponse,
-            { locale: string }
-        >({
-            query: ({ locale }) => ({
-                url: `${TRANSLATIONS_URL}/${locale}`,
-                method: 'GET',
-                headers: {
-                    'Content-Type': 'application/json',
-                },
-            }),
-            extraOptions: {
-                baseQueryType: BaseQueryTypes.fetch,
-            },
-        }),
+  endpoints: (build) => ({
+    translations: build.query<BackendTranslationsResponse, { locale: string }>({
+      query: ({ locale }) => ({
+        url: `${TRANSLATIONS_URL}/${locale}`,
+        method: 'GET',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+      }),
+      extraOptions: {
+        baseQueryType: BaseQueryTypes.fetch,
+      },
     }),
+  }),
 });
 
 export const { useTranslationsQuery } = translationsApi;

package/src/rtk/endpoints/versions.ts

@@ -9,19 +9,19 @@ const versionsQuery = `
 `;
 
 export type VersionsResponse = {
-    version: {
-        applicationVersions: [string];
-    };
+  version: {
+    applicationVersions: [string];
+  };
 };
 
 const versionsApi = orchestratorApi.injectEndpoints({
-    endpoints: (build) => ({
-        getVersions: build.query<VersionsResponse, void>({
-            query: () => ({
-                document: versionsQuery,
-            }),
-        }),
+  endpoints: (build) => ({
+    getVersions: build.query<VersionsResponse, void>({
+      query: () => ({
+        document: versionsQuery,
+      }),
     }),
+  }),
 });
 
 export const { useGetVersionsQuery } = versionsApi;

package/src/rtk/slices/customApis.ts

@@ -2,17 +2,15 @@ import { createSlice } from '@reduxjs/toolkit';
 import type { Slice } from '@reduxjs/toolkit';
 
 export type CustomApiConfig = {
-    apiName: string;
-    apiBaseUrl: string;
+  apiName: string;
+  apiBaseUrl: string;
 };
 type CustomApiSlice = Slice<CustomApiConfig[]>;
 
-export const getCustomApiSlice = (
-    customApis: CustomApiConfig[],
-): CustomApiSlice => {
-    return createSlice({
-        name: 'customApis',
-        initialState: customApis,
-        reducers: {},
-    });
+export const getCustomApiSlice = (customApis: CustomApiConfig[]): CustomApiSlice => {
+  return createSlice({
+    name: 'customApis',
+    initialState: customApis,
+    reducers: {},
+  });
 };

package/src/rtk/slices/orchestratorComponentOverride.ts

@@ -5,38 +5,36 @@ import { Slice, createSlice } from '@reduxjs/toolkit';
 import { FieldValue, RenderableFieldValue, SubscriptionDetail } from '@/types';
 
 export type ValueOverrideFunction = (
-    fieldValue: FieldValue | RenderableFieldValue,
-    allFieldValues: FieldValue[] | RenderableFieldValue[],
+  fieldValue: FieldValue | RenderableFieldValue,
+  allFieldValues: FieldValue[] | RenderableFieldValue[],
 ) => ReactNode;
 export type ValueOverrideConfiguration = Record<string, ValueOverrideFunction>;
 
 export type WfoSubscriptionDetailGeneralConfiguration = {
-    id: string;
-    node: ReactNode;
+  id: string;
+  node: ReactNode;
 };
 
 export type OrchestratorComponentOverride = {
-    startPage?: {
-        summaryCardConfigurationOverride?: (
-            defaultItems: ReactElement[],
-        ) => ReactElement[];
-    };
-    subscriptionDetail?: {
-        valueOverrides?: ValueOverrideConfiguration;
-        generalSectionConfigurationOverride?: (
-            defaultSections: WfoSubscriptionDetailGeneralConfiguration[],
-            subscriptionDetail: SubscriptionDetail,
-        ) => WfoSubscriptionDetailGeneralConfiguration[];
-    };
+  startPage?: {
+    summaryCardConfigurationOverride?: (defaultItems: ReactElement[]) => ReactElement[];
+  };
+  subscriptionDetail?: {
+    valueOverrides?: ValueOverrideConfiguration;
+    generalSectionConfigurationOverride?: (
+      defaultSections: WfoSubscriptionDetailGeneralConfiguration[],
+      subscriptionDetail: SubscriptionDetail,
+    ) => WfoSubscriptionDetailGeneralConfiguration[];
+  };
 };
 
 type OrchestratorComponentOverrideSlice = Slice<OrchestratorComponentOverride>;
 
 export const getOrchestratorComponentOverrideSlice = (
-    config: OrchestratorComponentOverride,
+  config: OrchestratorComponentOverride,
 ): OrchestratorComponentOverrideSlice =>
-    createSlice({
-        name: 'orchestratorComponentOverride',
-        initialState: config,
-        reducers: {},
-    });
+  createSlice({
+    name: 'orchestratorComponentOverride',
+    initialState: config,
+    reducers: {},
+  });

package/src/rtk/slices/orchestratorConfig.ts

@@ -7,15 +7,12 @@ import { RootState } from '../store';
 
 type OrchestratorConfigSlice = Slice<OrchestratorConfig>;
 
-export const getOrchestratorConfigSlice = (
-    config: OrchestratorConfig,
-): OrchestratorConfigSlice => {
-    return createSlice({
-        name: 'orchestrator',
-        initialState: config,
-        reducers: {},
-    });
+export const getOrchestratorConfigSlice = (config: OrchestratorConfig): OrchestratorConfigSlice => {
+  return createSlice({
+    name: 'orchestrator',
+    initialState: config,
+    reducers: {},
+  });
 };
 
-export const selectOrchestratorConfig = (state: RootState) =>
-    state.orchestratorConfig;
+export const selectOrchestratorConfig = (state: RootState) => state.orchestratorConfig;

package/src/rtk/slices/pydanticForm.ts

@@ -3,16 +3,14 @@ import type { ComponentMatcherExtender } from 'pydantic-forms';
 import { Slice, createSlice } from '@reduxjs/toolkit';
 
 export type PydanticForm = {
-    componentMatcherExtender?: ComponentMatcherExtender;
+  componentMatcherExtender?: ComponentMatcherExtender;
 };
 
 type PydanticFormComponentMatcherSlice = Slice<PydanticForm>;
 
-export const getPydanticFormSlice = (
-    pydanticForm: PydanticForm,
-): PydanticFormComponentMatcherSlice =>
-    createSlice({
-        name: 'pydanticForm',
-        initialState: pydanticForm,
-        reducers: {},
-    });
+export const getPydanticFormSlice = (pydanticForm: PydanticForm): PydanticFormComponentMatcherSlice =>
+  createSlice({
+    name: 'pydanticForm',
+    initialState: pydanticForm,
+    reducers: {},
+  });

package/src/rtk/slices/toastMessages.ts

@@ -4,53 +4,43 @@ import type { PayloadAction, Reducer, Slice } from '@reduxjs/toolkit';
 import type { Toast } from '@/types';
 
 export type ToastState = {
-    messages: Toast[];
+  messages: Toast[];
 };
 
 const initialState: ToastState = {
-    messages: [],
+  messages: [],
 };
 
 type ToastMessagesSlice = Slice<
-    ToastState,
-    {
-        addToastMessage: (
-            state: ToastState,
-            action: PayloadAction<Toast>,
-        ) => ToastState;
-        removeToastMessage: (
-            state: ToastState,
-            action: PayloadAction<Toast['id']>,
-        ) => ToastState;
-    },
-    'toastMessages',
-    'toastMessages'
+  ToastState,
+  {
+    addToastMessage: (state: ToastState, action: PayloadAction<Toast>) => ToastState;
+    removeToastMessage: (state: ToastState, action: PayloadAction<Toast['id']>) => ToastState;
+  },
+  'toastMessages',
+  'toastMessages'
 >;
 
 export const toastMessagesSlice: ToastMessagesSlice = createSlice({
-    name: 'toastMessages',
-    initialState,
-    reducers: {
-        addToastMessage: (state, action: PayloadAction<Toast>) => {
-            return {
-                ...state,
-                messages: [...state.messages, action.payload],
-            };
-        },
-        removeToastMessage: (state, action: PayloadAction<Toast['id']>) => {
-            return {
-                ...state,
-                messages: state.messages.filter(
-                    (message) => message.id !== action.payload,
-                ),
-            };
-        },
+  name: 'toastMessages',
+  initialState,
+  reducers: {
+    addToastMessage: (state, action: PayloadAction<Toast>) => {
+      return {
+        ...state,
+        messages: [...state.messages, action.payload],
+      };
+    },
+    removeToastMessage: (state, action: PayloadAction<Toast['id']>) => {
+      return {
+        ...state,
+        messages: state.messages.filter((message) => message.id !== action.payload),
+      };
     },
+  },
 });
 
 // Action creators are generated for each case reducer function
-export const { addToastMessage, removeToastMessage } =
-    toastMessagesSlice.actions;
+export const { addToastMessage, removeToastMessage } = toastMessagesSlice.actions;
 
-export const toastMessagesReducer: Reducer<ToastState> =
-    toastMessagesSlice.reducer;
+export const toastMessagesReducer: Reducer<ToastState> = toastMessagesSlice.reducer;

package/src/rtk/store.ts

@@ -5,8 +5,8 @@ import { CombinedState } from '@reduxjs/toolkit/query';
 
 import { CustomApiConfig, getCustomApiSlice } from '@/rtk/slices';
 import {
-    OrchestratorComponentOverride,
-    getOrchestratorComponentOverrideSlice,
+  OrchestratorComponentOverride,
+  getOrchestratorComponentOverrideSlice,
 } from '@/rtk/slices/orchestratorComponentOverride';
 import { PydanticForm, getPydanticFormSlice } from '@/rtk/slices/pydanticForm';
 import type { OrchestratorConfig } from '@/types';
@@ -15,55 +15,46 @@ import { orchestratorApi } from './api';
 import { getOrchestratorConfigSlice, toastMessagesReducer } from './slices';
 
 export type RootState = {
-    orchestratorApi: CombinedState<
-        Record<string, never>,
-        'engineStatus',
-        'orchestratorApi'
-    >;
-    toastMessages: ReturnType<typeof toastMessagesReducer>;
-    orchestratorConfig: OrchestratorConfig;
-    orchestratorComponentOverride?: OrchestratorComponentOverride;
-    pydanticForm?: PydanticForm;
-    customApis: CustomApiConfig[];
+  orchestratorApi: CombinedState<Record<string, never>, 'engineStatus', 'orchestratorApi'>;
+  toastMessages: ReturnType<typeof toastMessagesReducer>;
+  orchestratorConfig: OrchestratorConfig;
+  orchestratorComponentOverride?: OrchestratorComponentOverride;
+  pydanticForm?: PydanticForm;
+  customApis: CustomApiConfig[];
 };
 
 export type InitialOrchestratorStoreConfig = Pick<
-    RootState,
-    | 'orchestratorConfig'
-    | 'customApis'
-    | 'orchestratorComponentOverride'
-    | 'pydanticForm'
+  RootState,
+  'orchestratorConfig' | 'customApis' | 'orchestratorComponentOverride' | 'pydanticForm'
 >;
 
 export const getOrchestratorStore = ({
-    orchestratorConfig,
-    orchestratorComponentOverride = {},
-    pydanticForm = {},
-    customApis,
+  orchestratorConfig,
+  orchestratorComponentOverride = {},
+  pydanticForm = {},
+  customApis,
 }: InitialOrchestratorStoreConfig): EnhancedStore<RootState> => {
-    const configSlice = getOrchestratorConfigSlice(orchestratorConfig);
-    const orchestratorComponentOverrideSlice =
-        getOrchestratorComponentOverrideSlice(orchestratorComponentOverride);
-    const customApisSlice = getCustomApiSlice(customApis);
-    const componentMatcherSlice = getPydanticFormSlice(pydanticForm);
-
-    const orchestratorStore = configureStore({
-        reducer: {
-            [orchestratorApi.reducerPath]: orchestratorApi.reducer,
-            toastMessages: toastMessagesReducer,
-            orchestratorConfig: configSlice.reducer,
-            orchestratorComponentOverride:
-                orchestratorComponentOverrideSlice.reducer,
-            customApis: customApisSlice?.reducer,
-            pydanticForm: componentMatcherSlice?.reducer,
-        },
-        middleware: (getDefaultMiddleware) =>
-            getDefaultMiddleware({
-                serializableCheck: false,
-            }).concat(orchestratorApi.middleware),
-    });
-
-    return orchestratorStore;
+  const configSlice = getOrchestratorConfigSlice(orchestratorConfig);
+  const orchestratorComponentOverrideSlice = getOrchestratorComponentOverrideSlice(orchestratorComponentOverride);
+  const customApisSlice = getCustomApiSlice(customApis);
+  const componentMatcherSlice = getPydanticFormSlice(pydanticForm);
+
+  const orchestratorStore = configureStore({
+    reducer: {
+      [orchestratorApi.reducerPath]: orchestratorApi.reducer,
+      toastMessages: toastMessagesReducer,
+      orchestratorConfig: configSlice.reducer,
+      orchestratorComponentOverride: orchestratorComponentOverrideSlice.reducer,
+      customApis: customApisSlice?.reducer,
+      pydanticForm: componentMatcherSlice?.reducer,
+    },
+    middleware: (getDefaultMiddleware) =>
+      getDefaultMiddleware({
+        serializableCheck: false,
+      }).concat(orchestratorApi.middleware),
+  });
+
+  return orchestratorStore;
 };
 
 export type AppDispatch = Dispatch<UnknownAction>;