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

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

@@ -1,11 +1,11 @@
 import { METADATA_RESOURCE_TYPE_ENDPOINT } from '@/configuration';
 import { BaseQueryTypes, orchestratorApi } from '@/rtk';
 import {
-    BaseGraphQlResult,
-    GraphqlQueryVariables,
-    MetadataDescriptionParams,
-    ResourceTypeDefinition,
-    ResourceTypeDefinitionsResult,
+  BaseGraphQlResult,
+  GraphqlQueryVariables,
+  MetadataDescriptionParams,
+  ResourceTypeDefinition,
+  ResourceTypeDefinitionsResult,
 } from '@/types';
 
 export const resourceTypesQuery = `
@@ -48,55 +48,49 @@ query MetadataResourceTypes(
 `;
 
 export type ResourceTypesResponse = {
-    resourceTypes: ResourceTypeDefinition[];
+  resourceTypes: ResourceTypeDefinition[];
 } & BaseGraphQlResult;
 
 const resourceTypesApi = orchestratorApi.injectEndpoints({
-    endpoints: (builder) => ({
-        getResourceTypes: builder.query<
-            ResourceTypesResponse,
-            GraphqlQueryVariables<ResourceTypeDefinition>
-        >({
-            query: (variables) => ({
-                document: resourceTypesQuery,
-                variables,
-            }),
-            transformResponse: (
-                response: ResourceTypeDefinitionsResult,
-            ): ResourceTypesResponse => {
-                const resourceTypes = response.resourceTypes.page || [];
-                const pageInfo = response.resourceTypes.pageInfo || {};
+  endpoints: (builder) => ({
+    getResourceTypes: builder.query<ResourceTypesResponse, GraphqlQueryVariables<ResourceTypeDefinition>>({
+      query: (variables) => ({
+        document: resourceTypesQuery,
+        variables,
+      }),
+      transformResponse: (response: ResourceTypeDefinitionsResult): ResourceTypesResponse => {
+        const resourceTypes = response.resourceTypes.page || [];
+        const pageInfo = response.resourceTypes.pageInfo || {};
 
-                return {
-                    resourceTypes,
-                    pageInfo,
-                };
-            },
-        }),
+        return {
+          resourceTypes,
+          pageInfo,
+        };
+      },
     }),
+  }),
 });
 
-export const { useGetResourceTypesQuery, useLazyGetResourceTypesQuery } =
-    resourceTypesApi;
+export const { useGetResourceTypesQuery, useLazyGetResourceTypesQuery } = resourceTypesApi;
 
 const resourceTypesRestApi = orchestratorApi.injectEndpoints({
-    endpoints: (build) => ({
-        updateResourceType: build.mutation<null, MetadataDescriptionParams>({
-            query: (resourceType) => ({
-                url: `${METADATA_RESOURCE_TYPE_ENDPOINT}/${resourceType.id}`,
-                method: 'PATCH',
-                headers: {
-                    'Content-Type': 'application/json',
-                },
-                body: {
-                    description: resourceType.description,
-                },
-            }),
-            extraOptions: {
-                baseQueryType: BaseQueryTypes.fetch,
-            },
-        }),
+  endpoints: (build) => ({
+    updateResourceType: build.mutation<null, MetadataDescriptionParams>({
+      query: (resourceType) => ({
+        url: `${METADATA_RESOURCE_TYPE_ENDPOINT}/${resourceType.id}`,
+        method: 'PATCH',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: {
+          description: resourceType.description,
+        },
+      }),
+      extraOptions: {
+        baseQueryType: BaseQueryTypes.fetch,
+      },
     }),
+  }),
 });
 
 export const { useUpdateResourceTypeMutation } = resourceTypesRestApi;

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

@@ -2,12 +2,12 @@ import { METADATA_SCHEDULES_ENDPOINT } from '@/configuration/constants';
 import { orchestratorApi } from '@/rtk';
 import { BaseQueryTypes } from '@/rtk';
 import {
-    BaseGraphQlResult,
-    CacheTagType,
-    GraphqlQueryVariables,
-    ScheduledTaskDefinition,
-    ScheduledTasksDefinitionsResult,
-    TaskType,
+  BaseGraphQlResult,
+  CacheTagType,
+  GraphqlQueryVariables,
+  ScheduledTaskDefinition,
+  ScheduledTasksDefinitionsResult,
+  TaskType,
 } from '@/types';
 
 export const scheduledTasks = `
@@ -38,7 +38,7 @@ export const scheduledTasks = `
 `;
 
 export type ScheduledTasksResponse = {
-    schedules: ScheduledTaskDefinition[];
+  schedules: ScheduledTaskDefinition[];
 } & BaseGraphQlResult;
 
 /* 
@@ -56,10 +56,10 @@ jitter (int|None) – delay the job execution by jitter seconds at most
 */
 
 export type InterValKwargs = {
-    weeks?: number;
-    days?: number;
-    hours?: number;
-    start_date: string;
+  weeks?: number;
+  days?: number;
+  hours?: number;
+  start_date: string;
 };
 
 /*
@@ -69,7 +69,7 @@ run_date (datetime|str) – the date/time to run the job at
 timezone (datetime.tzinfo|str) – time zone for run_date if it doesn’t have one already
 */
 export type DateKwargs = {
-    run_date: string;
+  run_date: string;
 };
 
 /*
@@ -91,104 +91,93 @@ timezone (datetime.tzinfo|str) – time zone to use for the date/time calculatio
 jitter (int|None) – delay the job execution by jitter seconds at most
 */
 export type CronKwargs = {
-    year?: number;
-    month?: number;
-    day?: number;
-    week?: number;
-    day_of_week?: number;
-    hour?: number;
-    minute?: number;
-    second?: number;
-    start_date: string;
+  year?: number;
+  month?: number;
+  day?: number;
+  week?: number;
+  day_of_week?: number;
+  hour?: number;
+  minute?: number;
+  second?: number;
+  start_date: string;
 };
 
 type Kwargs = DateKwargs | InterValKwargs | CronKwargs;
 
 export type ScheduledTaskPostPayload = {
-    workflowId: string;
-    workflowName: string;
-    workflowDescription: string;
-    type: TaskType;
-    kwargs: Kwargs;
+  workflowId: string;
+  workflowName: string;
+  workflowDescription: string;
+  type: TaskType;
+  kwargs: Kwargs;
 };
 
 const scheduledTasksApi = orchestratorApi.injectEndpoints({
-    endpoints: (builder) => ({
-        getScheduledTasks: builder.query<
-            ScheduledTasksResponse,
-            GraphqlQueryVariables<ScheduledTaskDefinition>
-        >({
-            query: (variables) => ({
-                document: scheduledTasks,
-                variables,
-            }),
-            transformResponse: (
-                response: ScheduledTasksDefinitionsResult,
-            ): ScheduledTasksResponse => {
-                const schedules = response.scheduledTasks.page || [];
-                const pageInfo = response.scheduledTasks.pageInfo || {};
-                return {
-                    schedules,
-                    pageInfo,
-                };
-            },
-            providesTags: [CacheTagType.scheduledTasks],
-        }),
-        deleteScheduledTask: builder.mutation<
-            unknown,
-            { workflowId: string; scheduleId: string }
-        >({
-            query: ({ workflowId, scheduleId }) => ({
-                url: METADATA_SCHEDULES_ENDPOINT,
-                method: 'DELETE',
-                headers: {
-                    'Content-Type': 'application/json',
-                },
-                body: {
-                    scheduled_type: 'delete',
-                    workflow_id: workflowId,
-                    schedule_id: scheduleId,
-                },
-            }),
-            extraOptions: {
-                baseQueryType: BaseQueryTypes.fetch,
-            },
-            invalidatesTags: [CacheTagType.scheduledTasks],
-        }),
-        createScheduledTask: builder.mutation<
-            unknown,
-            ScheduledTaskPostPayload
-        >({
-            query: (payload) => {
-                const scheduleTaskPayload = {
-                    scheduled_type: 'create',
-                    name: payload.workflowDescription,
-                    workflow_name: payload.workflowName,
-                    workflow_id: payload.workflowId,
-                    trigger: payload.type,
-                    trigger_kwargs: payload.kwargs,
-                };
+  endpoints: (builder) => ({
+    getScheduledTasks: builder.query<ScheduledTasksResponse, GraphqlQueryVariables<ScheduledTaskDefinition>>({
+      query: (variables) => ({
+        document: scheduledTasks,
+        variables,
+      }),
+      transformResponse: (response: ScheduledTasksDefinitionsResult): ScheduledTasksResponse => {
+        const schedules = response.scheduledTasks.page || [];
+        const pageInfo = response.scheduledTasks.pageInfo || {};
+        return {
+          schedules,
+          pageInfo,
+        };
+      },
+      providesTags: [CacheTagType.scheduledTasks],
+    }),
+    deleteScheduledTask: builder.mutation<unknown, { workflowId: string; scheduleId: string }>({
+      query: ({ workflowId, scheduleId }) => ({
+        url: METADATA_SCHEDULES_ENDPOINT,
+        method: 'DELETE',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: {
+          scheduled_type: 'delete',
+          workflow_id: workflowId,
+          schedule_id: scheduleId,
+        },
+      }),
+      extraOptions: {
+        baseQueryType: BaseQueryTypes.fetch,
+      },
+      invalidatesTags: [CacheTagType.scheduledTasks],
+    }),
+    createScheduledTask: builder.mutation<unknown, ScheduledTaskPostPayload>({
+      query: (payload) => {
+        const scheduleTaskPayload = {
+          scheduled_type: 'create',
+          name: payload.workflowDescription,
+          workflow_name: payload.workflowName,
+          workflow_id: payload.workflowId,
+          trigger: payload.type,
+          trigger_kwargs: payload.kwargs,
+        };
 
-                return {
-                    url: METADATA_SCHEDULES_ENDPOINT,
-                    method: 'POST',
-                    headers: {
-                        'Content-Type': 'application/json',
-                    },
-                    body: scheduleTaskPayload,
-                };
-            },
-            extraOptions: {
-                baseQueryType: BaseQueryTypes.fetch,
-            },
-            invalidatesTags: [CacheTagType.scheduledTasks],
-        }),
+        return {
+          url: METADATA_SCHEDULES_ENDPOINT,
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+          },
+          body: scheduleTaskPayload,
+        };
+      },
+      extraOptions: {
+        baseQueryType: BaseQueryTypes.fetch,
+      },
+      invalidatesTags: [CacheTagType.scheduledTasks],
     }),
+  }),
 });
 
 export const {
-    useGetScheduledTasksQuery,
-    useLazyGetScheduledTasksQuery,
-    useDeleteScheduledTaskMutation,
-    useCreateScheduledTaskMutation,
+  useGetScheduledTasksQuery,
+  useLazyGetScheduledTasksQuery,
+  useDeleteScheduledTaskMutation,
+  useCreateScheduledTaskMutation,
 } = scheduledTasksApi;

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

@@ -1,11 +1,5 @@
 import { orchestratorApi } from '@/rtk';
-import {
-    BaseGraphQlResult,
-    CacheTagType,
-    GraphqlQueryVariables,
-    TaskDefinition,
-    TaskDefinitionsResult,
-} from '@/types';
+import { BaseGraphQlResult, CacheTagType, GraphqlQueryVariables, TaskDefinition, TaskDefinitionsResult } from '@/types';
 
 export const tasksQuery = `
 query MetadataTasks(
@@ -46,37 +40,32 @@ query MetadataTasks(
 `;
 
 export type TasksResponse = {
-    tasks: TaskDefinition[];
+  tasks: TaskDefinition[];
 } & BaseGraphQlResult;
 
 const tasksApi = orchestratorApi.injectEndpoints({
-    endpoints: (builder) => ({
-        getTasks: builder.query<
-            TasksResponse | undefined,
-            GraphqlQueryVariables<TaskDefinition>
-        >({
-            query: (variables) => ({
-                document: tasksQuery,
-                variables,
-            }),
-            transformResponse: (
-                response: TaskDefinitionsResult | undefined,
-            ): TasksResponse | undefined => {
-                if (!response) {
-                    return undefined;
-                }
+  endpoints: (builder) => ({
+    getTasks: builder.query<TasksResponse | undefined, GraphqlQueryVariables<TaskDefinition>>({
+      query: (variables) => ({
+        document: tasksQuery,
+        variables,
+      }),
+      transformResponse: (response: TaskDefinitionsResult | undefined): TasksResponse | undefined => {
+        if (!response) {
+          return undefined;
+        }
 
-                const tasks = response.workflows.page || [];
-                const pageInfo = response.workflows.pageInfo || {};
+        const tasks = response.workflows.page || [];
+        const pageInfo = response.workflows.pageInfo || {};
 
-                return {
-                    tasks,
-                    pageInfo,
-                };
-            },
-            providesTags: [CacheTagType.scheduledTasks],
-        }),
+        return {
+          tasks,
+          pageInfo,
+        };
+      },
+      providesTags: [CacheTagType.scheduledTasks],
     }),
+  }),
 });
 
 export const { useGetTasksQuery, useLazyGetTasksQuery } = tasksApi;

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

@@ -1,11 +1,11 @@
 import { METADATA_WORKFLOWS_ENDPOINT } from '@/configuration';
 import { BaseQueryTypes, orchestratorApi } from '@/rtk';
 import {
-    BaseGraphQlResult,
-    GraphqlQueryVariables,
-    MetadataDescriptionParams,
-    WorkflowDefinition,
-    WorkflowDefinitionsResult,
+  BaseGraphQlResult,
+  GraphqlQueryVariables,
+  MetadataDescriptionParams,
+  WorkflowDefinition,
+  WorkflowDefinitionsResult,
 } from '@/types';
 
 export const workflowsDescription = `
@@ -62,104 +62,83 @@ query MetadataWorkflows(
 `;
 
 export type WorkflowsDescriptionQueryVariables = {
-    workflowName: string;
+  workflowName: string;
 };
 
-export type WorkflowsDescriptionResponse = Pick<
-    WorkflowDefinition,
-    'name' | 'description'
->;
+export type WorkflowsDescriptionResponse = Pick<WorkflowDefinition, 'name' | 'description'>;
 
 export type WorkflowsResponse = {
-    workflows: WorkflowDefinition[];
+  workflows: WorkflowDefinition[];
 } & BaseGraphQlResult;
 
 const workflowsApi = orchestratorApi.injectEndpoints({
-    endpoints: (builder) => ({
-        getWorkflows: builder.query<
-            WorkflowsResponse | undefined,
-            GraphqlQueryVariables<WorkflowDefinition>
-        >({
-            query: (variables) => ({
-                document: workflowsQuery,
-                variables,
-            }),
-            transformResponse: (
-                response: WorkflowDefinitionsResult | undefined,
-            ): WorkflowsResponse | undefined => {
-                if (!response) {
-                    return undefined;
-                }
+  endpoints: (builder) => ({
+    getWorkflows: builder.query<WorkflowsResponse | undefined, GraphqlQueryVariables<WorkflowDefinition>>({
+      query: (variables) => ({
+        document: workflowsQuery,
+        variables,
+      }),
+      transformResponse: (response: WorkflowDefinitionsResult | undefined): WorkflowsResponse | undefined => {
+        if (!response) {
+          return undefined;
+        }
 
-                const workflows = response?.workflows.page || [];
-                const pageInfo = response?.workflows.pageInfo || {};
+        const workflows = response?.workflows.page || [];
+        const pageInfo = response?.workflows.pageInfo || {};
 
-                return {
-                    workflows,
-                    pageInfo,
-                };
-            },
-        }),
-        getDescriptionForWorkflowName: builder.query<
-            WorkflowsDescriptionResponse,
-            WorkflowsDescriptionQueryVariables
-        >({
-            query: (variables) => ({
-                document: workflowsDescription,
-                variables,
-            }),
-            transformResponse: (
-                response: WorkflowDefinitionsResult<
-                    Pick<WorkflowDefinition, 'name' | 'description'>
-                >,
-                _,
-                variables,
-            ): WorkflowsDescriptionResponse => {
-                const workflows = response.workflows.page || [];
-                const workflow = workflows.find(
-                    ({ name }) => name === variables.workflowName,
-                );
+        return {
+          workflows,
+          pageInfo,
+        };
+      },
+    }),
+    getDescriptionForWorkflowName: builder.query<WorkflowsDescriptionResponse, WorkflowsDescriptionQueryVariables>({
+      query: (variables) => ({
+        document: workflowsDescription,
+        variables,
+      }),
+      transformResponse: (
+        response: WorkflowDefinitionsResult<Pick<WorkflowDefinition, 'name' | 'description'>>,
+        _,
+        variables,
+      ): WorkflowsDescriptionResponse => {
+        const workflows = response.workflows.page || [];
+        const workflow = workflows.find(({ name }) => name === variables.workflowName);
 
-                if (!workflow) {
-                    throw new Error(
-                        `No workflow found with name ${variables.workflowName}`,
-                    );
-                }
+        if (!workflow) {
+          throw new Error(`No workflow found with name ${variables.workflowName}`);
+        }
 
-                const { name, description } = workflow;
-                return {
-                    name,
-                    description,
-                };
-            },
-        }),
+        const { name, description } = workflow;
+        return {
+          name,
+          description,
+        };
+      },
     }),
+  }),
 });
 
-export const {
-    useGetWorkflowsQuery,
-    useLazyGetWorkflowsQuery,
-    useGetDescriptionForWorkflowNameQuery,
-} = workflowsApi;
+export const { useGetWorkflowsQuery, useLazyGetWorkflowsQuery, useGetDescriptionForWorkflowNameQuery } = workflowsApi;
 
 const workflowsRestApi = orchestratorApi.injectEndpoints({
-    endpoints: (build) => ({
-        updateWorkflow: build.mutation<null, MetadataDescriptionParams>({
-            query: (workflow) => ({
-                url: `${METADATA_WORKFLOWS_ENDPOINT}/${workflow.id}`,
-                method: 'PATCH',
-                headers: {
-                    'Content-Type': 'application/json',
-                },
-                body: {
-                    description: workflow.description,
-                },
-            }),
-            extraOptions: {
-                baseQueryType: BaseQueryTypes.fetch,
-            },
-        }),
+  endpoints: (build) => ({
+    updateWorkflow: build.mutation<null, MetadataDescriptionParams>({
+      query: (workflow) => ({
+        url: `${METADATA_WORKFLOWS_ENDPOINT}/${workflow.id}`,
+        method: 'PATCH',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: {
+          description: workflow.description,
+        },
+      }),
+      extraOptions: {
+        baseQueryType: BaseQueryTypes.fetch,
+      },
     }),
+  }),
 });
 
 export const { useUpdateWorkflowMutation } = workflowsRestApi;