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

package/src/utils/getDefaultTableConfig.ts

@@ -1,126 +1,104 @@
 import {
-    ACTIVE_PROCESSES_LIST_TABLE_LOCAL_STORAGE_KEY,
-    ACTIVE_TASKS_LIST_TABLE_LOCAL_STORAGE_KEY,
-    COMPLETED_PROCESSES_LIST_TABLE_LOCAL_STORAGE_KEY,
-    COMPLETED_TASKS_LIST_TABLE_LOCAL_STORAGE_KEY,
-    DEFAULT_PAGE_SIZE,
-    METADATA_PRODUCT_BLOCKS_TABLE_LOCAL_STORAGE_KEY,
-    METADATA_PRODUCT_TABLE_LOCAL_STORAGE_KEY,
-    METADATA_RESOURCE_TYPES_TABLE_LOCAL_STORAGE_KEY,
-    METADATA_TASKS_TABLE_LOCAL_STORAGE_KEY,
-    METADATA_WORKFLOWS_TABLE_LOCAL_STORAGE_KEY,
-    SUBSCRIPTIONS_TABLE_LOCAL_STORAGE_KEY,
+  ACTIVE_PROCESSES_LIST_TABLE_LOCAL_STORAGE_KEY,
+  ACTIVE_TASKS_LIST_TABLE_LOCAL_STORAGE_KEY,
+  COMPLETED_PROCESSES_LIST_TABLE_LOCAL_STORAGE_KEY,
+  COMPLETED_TASKS_LIST_TABLE_LOCAL_STORAGE_KEY,
+  DEFAULT_PAGE_SIZE,
+  METADATA_PRODUCT_BLOCKS_TABLE_LOCAL_STORAGE_KEY,
+  METADATA_PRODUCT_TABLE_LOCAL_STORAGE_KEY,
+  METADATA_RESOURCE_TYPES_TABLE_LOCAL_STORAGE_KEY,
+  METADATA_TASKS_TABLE_LOCAL_STORAGE_KEY,
+  METADATA_WORKFLOWS_TABLE_LOCAL_STORAGE_KEY,
+  SUBSCRIPTIONS_TABLE_LOCAL_STORAGE_KEY,
 } from '@/components';
 import type { StoredTableConfig } from '@/components';
 import { ProcessListItem } from '@/components';
 import { SubscriptionListItem } from '@/components/WfoSubscriptionsList';
-import {
-    ProductBlockDefinition,
-    ProductDefinition,
-    ResourceTypeDefinition,
-    WorkflowDefinition,
-} from '@/types';
+import { ProductBlockDefinition, ProductDefinition, ResourceTypeDefinition, WorkflowDefinition } from '@/types';
 
 function getTableConfig<T>(
-    hiddenColumns: (keyof T)[] = [],
-    selectedPageSize = DEFAULT_PAGE_SIZE,
+  hiddenColumns: (keyof T)[] = [],
+  selectedPageSize = DEFAULT_PAGE_SIZE,
 ): StoredTableConfig<T> {
-    return {
-        selectedPageSize,
-        hiddenColumns,
-    };
+  return {
+    selectedPageSize,
+    hiddenColumns,
+  };
 }
 
 export const getDefaultTableConfig = <T>(storageKey: string) => {
-    switch (storageKey) {
-        case METADATA_PRODUCT_BLOCKS_TABLE_LOCAL_STORAGE_KEY: {
-            const productBlockColumns: (keyof ProductBlockDefinition)[] = [
-                'productBlockId',
-                'status',
-                'endDate',
-                'createdAt',
-            ];
-            return getTableConfig<T>(productBlockColumns as (keyof T)[]);
-        }
-        case METADATA_RESOURCE_TYPES_TABLE_LOCAL_STORAGE_KEY: {
-            const resourceTypeColumns: (keyof ResourceTypeDefinition)[] = [
-                'resourceTypeId',
-            ];
-            return getTableConfig<T>(resourceTypeColumns as (keyof T)[]);
-        }
-        case METADATA_PRODUCT_TABLE_LOCAL_STORAGE_KEY: {
-            const productColumns: (keyof ProductDefinition)[] = [
-                'productId',
-                'productType',
-                'status',
-                'createdAt',
-            ];
-            return getTableConfig<T>(productColumns as (keyof T)[]);
-        }
-        case METADATA_WORKFLOWS_TABLE_LOCAL_STORAGE_KEY: {
-            const workflowColumns: (keyof WorkflowDefinition)[] = [
-                'workflowId',
-                'createdAt',
-            ];
-            return getTableConfig<T>(workflowColumns as (keyof T)[]);
-        }
-        case METADATA_TASKS_TABLE_LOCAL_STORAGE_KEY: {
-            const taskColumns: (keyof WorkflowDefinition)[] = [
-                'workflowId',
-                'createdAt',
-            ];
-            return getTableConfig<T>(taskColumns as (keyof T)[]);
-        }
-        case ACTIVE_PROCESSES_LIST_TABLE_LOCAL_STORAGE_KEY: {
-            const activeProcessColumns: (keyof ProcessListItem)[] = [
-                'productName',
-                'customer',
-                'assignee',
-                'processId',
-                'startedAt',
-            ];
-            return getTableConfig<T>(activeProcessColumns as (keyof T)[]);
-        }
-        case COMPLETED_PROCESSES_LIST_TABLE_LOCAL_STORAGE_KEY: {
-            const completedProcessColumns: (keyof ProcessListItem)[] = [
-                'lastStep',
-                'productName',
-                'customer',
-                'assignee',
-                'processId',
-                'startedAt',
-            ];
-            return getTableConfig<T>(completedProcessColumns as (keyof T)[]);
-        }
-        case ACTIVE_TASKS_LIST_TABLE_LOCAL_STORAGE_KEY: {
-            const activeTasksColumns: (keyof ProcessListItem)[] = [
-                'assignee',
-                'workflowTarget',
-                'productName',
-                'customer',
-                'processId',
-            ];
-            return getTableConfig<T>(activeTasksColumns as (keyof T)[]);
-        }
-        case COMPLETED_TASKS_LIST_TABLE_LOCAL_STORAGE_KEY: {
-            const completedTasksColumns: (keyof ProcessListItem)[] = [
-                'assignee',
-                'workflowTarget',
-                'productName',
-                'customer',
-                'processId',
-            ];
-            return getTableConfig<T>(completedTasksColumns as (keyof T)[]);
-        }
-        case SUBSCRIPTIONS_TABLE_LOCAL_STORAGE_KEY: {
-            const subscriptionColumns: (keyof SubscriptionListItem)[] = [
-                'productName',
-                'customerFullname',
-                'metadata',
-            ];
-            return getTableConfig<T>(subscriptionColumns as (keyof T)[]);
-        }
-        default:
-            return getTableConfig();
+  switch (storageKey) {
+    case METADATA_PRODUCT_BLOCKS_TABLE_LOCAL_STORAGE_KEY: {
+      const productBlockColumns: (keyof ProductBlockDefinition)[] = [
+        'productBlockId',
+        'status',
+        'endDate',
+        'createdAt',
+      ];
+      return getTableConfig<T>(productBlockColumns as (keyof T)[]);
+    }
+    case METADATA_RESOURCE_TYPES_TABLE_LOCAL_STORAGE_KEY: {
+      const resourceTypeColumns: (keyof ResourceTypeDefinition)[] = ['resourceTypeId'];
+      return getTableConfig<T>(resourceTypeColumns as (keyof T)[]);
+    }
+    case METADATA_PRODUCT_TABLE_LOCAL_STORAGE_KEY: {
+      const productColumns: (keyof ProductDefinition)[] = ['productId', 'productType', 'status', 'createdAt'];
+      return getTableConfig<T>(productColumns as (keyof T)[]);
+    }
+    case METADATA_WORKFLOWS_TABLE_LOCAL_STORAGE_KEY: {
+      const workflowColumns: (keyof WorkflowDefinition)[] = ['workflowId', 'createdAt'];
+      return getTableConfig<T>(workflowColumns as (keyof T)[]);
+    }
+    case METADATA_TASKS_TABLE_LOCAL_STORAGE_KEY: {
+      const taskColumns: (keyof WorkflowDefinition)[] = ['workflowId', 'createdAt'];
+      return getTableConfig<T>(taskColumns as (keyof T)[]);
+    }
+    case ACTIVE_PROCESSES_LIST_TABLE_LOCAL_STORAGE_KEY: {
+      const activeProcessColumns: (keyof ProcessListItem)[] = [
+        'productName',
+        'customer',
+        'assignee',
+        'processId',
+        'startedAt',
+      ];
+      return getTableConfig<T>(activeProcessColumns as (keyof T)[]);
+    }
+    case COMPLETED_PROCESSES_LIST_TABLE_LOCAL_STORAGE_KEY: {
+      const completedProcessColumns: (keyof ProcessListItem)[] = [
+        'lastStep',
+        'productName',
+        'customer',
+        'assignee',
+        'processId',
+        'startedAt',
+      ];
+      return getTableConfig<T>(completedProcessColumns as (keyof T)[]);
+    }
+    case ACTIVE_TASKS_LIST_TABLE_LOCAL_STORAGE_KEY: {
+      const activeTasksColumns: (keyof ProcessListItem)[] = [
+        'assignee',
+        'workflowTarget',
+        'productName',
+        'customer',
+        'processId',
+      ];
+      return getTableConfig<T>(activeTasksColumns as (keyof T)[]);
+    }
+    case COMPLETED_TASKS_LIST_TABLE_LOCAL_STORAGE_KEY: {
+      const completedTasksColumns: (keyof ProcessListItem)[] = [
+        'assignee',
+        'workflowTarget',
+        'productName',
+        'customer',
+        'processId',
+      ];
+      return getTableConfig<T>(completedTasksColumns as (keyof T)[]);
+    }
+    case SUBSCRIPTIONS_TABLE_LOCAL_STORAGE_KEY: {
+      const subscriptionColumns: (keyof SubscriptionListItem)[] = ['productName', 'customerFullname', 'metadata'];
+      return getTableConfig<T>(subscriptionColumns as (keyof T)[]);
     }
+    default:
+      return getTableConfig();
+  }
 };

package/src/utils/getEnvironmentVariables.spec.ts

@@ -5,47 +5,45 @@ import { getEnvironmentVariables } from './getEnvironmentVariables';
 const originalEnv = process.env;
 
 describe('getEnvironmentVariables()', () => {
-    const warnMock = jest.spyOn(console, 'warn');
+  const warnMock = jest.spyOn(console, 'warn');
 
-    jest.mock('process');
+  jest.mock('process');
 
-    beforeEach(() => {
-        process.env = {
-            ...originalEnv,
-        };
-        jest.resetAllMocks();
-    });
+  beforeEach(() => {
+    process.env = {
+      ...originalEnv,
+    };
+    jest.resetAllMocks();
+  });
 
-    afterEach(() => {
-        process.env = originalEnv;
-    });
+  afterEach(() => {
+    process.env = originalEnv;
+  });
 
-    it('returns an object with the environment variables and its values', () => {
-        process.env.test01 = 'value01';
-        process.env.test02 = 'value02';
+  it('returns an object with the environment variables and its values', () => {
+    process.env.test01 = 'value01';
+    process.env.test02 = 'value02';
 
-        const result = getEnvironmentVariables(['test01', 'test02']);
+    const result = getEnvironmentVariables(['test01', 'test02']);
 
-        expect(warnMock).not.toHaveBeenCalled();
-        expect(result).toEqual({
-            test01: 'value01',
-            test02: 'value02',
-        });
+    expect(warnMock).not.toHaveBeenCalled();
+    expect(result).toEqual({
+      test01: 'value01',
+      test02: 'value02',
     });
+  });
 
-    it('returns an empty string as value in the result when the environment variable is not set', () => {
-        process.env.test01 = 'value01';
-        process.env.test03 = 'value03';
+  it('returns an empty string as value in the result when the environment variable is not set', () => {
+    process.env.test01 = 'value01';
+    process.env.test03 = 'value03';
 
-        const result = getEnvironmentVariables(['test01', 'test02', 'test03']);
+    const result = getEnvironmentVariables(['test01', 'test02', 'test03']);
 
-        expect(warnMock).toHaveBeenCalledWith(
-            'Warning: Missing required environment variables: test02',
-        );
-        expect(result).toEqual({
-            test01: 'value01',
-            test02: '',
-            test03: 'value03',
-        });
+    expect(warnMock).toHaveBeenCalledWith('Warning: Missing required environment variables: test02');
+    expect(result).toEqual({
+      test01: 'value01',
+      test02: '',
+      test03: 'value03',
     });
+  });
 });

package/src/utils/getEnvironmentVariables.ts

@@ -2,31 +2,28 @@ import process from 'process';
 
 // By convention, only this function should be used to access the process.env object.
 // It logs a warning if one or more variables are not set
-export function getEnvironmentVariables<T>(
-    envVars: (keyof T)[],
-): Record<keyof T, string> {
-    const missingEnvironmentVariables: string[] = [];
+export function getEnvironmentVariables<T>(envVars: (keyof T)[]): Record<keyof T, string> {
+  const missingEnvironmentVariables: string[] = [];
 
-    const environmentVariablesWithValues = envVars.reduce((acc, currentKey) => {
-        const value = process.env[currentKey.toString()];
+  const environmentVariablesWithValues = envVars.reduce(
+    (acc, currentKey) => {
+      const value = process.env[currentKey.toString()];
 
-        if (value === undefined) {
-            missingEnvironmentVariables.push(currentKey.toString());
-        }
+      if (value === undefined) {
+        missingEnvironmentVariables.push(currentKey.toString());
+      }
 
-        return {
-            ...acc,
-            [currentKey]: value || '',
-        };
-    }, {} as Record<keyof T, string>);
+      return {
+        ...acc,
+        [currentKey]: value || '',
+      };
+    },
+    {} as Record<keyof T, string>,
+  );
 
-    if (missingEnvironmentVariables.length > 0) {
-        console.warn(
-            `Warning: Missing required environment variables: ${missingEnvironmentVariables.join(
-                ', ',
-            )}`,
-        );
-    }
+  if (missingEnvironmentVariables.length > 0) {
+    console.warn(`Warning: Missing required environment variables: ${missingEnvironmentVariables.join(', ')}`);
+  }
 
-    return environmentVariablesWithValues;
+  return environmentVariablesWithValues;
 }

package/src/utils/getObjectKeys.ts

@@ -1,3 +1,2 @@
-export const getObjectKeys = <T extends object>(
-    inputObject: T,
-): Array<keyof T> => Object.keys(inputObject) as Array<keyof T>;
+export const getObjectKeys = <T extends object>(inputObject: T): Array<keyof T> =>
+  Object.keys(inputObject) as Array<keyof T>;

package/src/utils/getProductNamesFromProcess.spec.ts

@@ -2,138 +2,136 @@ import { ProcessDetail, ProcessStatus, StepStatus } from '../types';
 import { getProductNamesFromProcess } from './getProductNamesFromProcess';
 
 const getProcessDetail = (data: Partial<ProcessDetail> = {}): ProcessDetail => {
-    return {
-        processId: 'processId',
-        createdBy: 'createdBy',
-        startedAt: 'startedAt',
-        lastStatus: ProcessStatus.CREATED,
-        lastStep: 'lastStep',
-        lastModifiedAt: 'lastModifiedAt',
-        workflowName: 'workflowName',
-        isTask: false,
-        traceback: null,
-        userPermissions: {
-            retryAllowed: true,
-            resumeAllowed: true,
+  return {
+    processId: 'processId',
+    createdBy: 'createdBy',
+    startedAt: 'startedAt',
+    lastStatus: ProcessStatus.CREATED,
+    lastStep: 'lastStep',
+    lastModifiedAt: 'lastModifiedAt',
+    workflowName: 'workflowName',
+    isTask: false,
+    traceback: null,
+    userPermissions: {
+      retryAllowed: true,
+      resumeAllowed: true,
+    },
+    steps: [
+      {
+        name: 'step name',
+        status: StepStatus.RUNNING,
+        stepId: 'step id',
+        started: 'started',
+        completed: 'completed',
+        state: {},
+        stateDelta: {},
+      },
+    ],
+    subscriptions: {
+      page: [
+        {
+          product: { name: 'productName' },
+          subscriptionId: 'id',
+          description: 'description',
         },
-        steps: [
+      ],
+    },
+    customer: {
+      fullname: 'customer',
+    },
+    ...data,
+  };
+};
+
+describe('getProductNamesFromProcess()', () => {
+  it('returns empty string when process has no subscriptions', () => {
+    const result = getProductNamesFromProcess(getProcessDetail({ subscriptions: undefined }));
+    expect(result).toEqual('');
+  });
+  it('returns 1 productName when process has 1 subscriptions', () => {
+    const result = getProductNamesFromProcess(
+      getProcessDetail({
+        subscriptions: {
+          page: [
             {
-                name: 'step name',
-                status: StepStatus.RUNNING,
-                stepId: 'step id',
-                started: 'started',
-                completed: 'completed',
-                state: {},
-                stateDelta: {},
+              product: { name: 'TEST NAME' },
+              subscriptionId: 'id',
+              description: 'description',
             },
-        ],
+          ],
+        },
+      }),
+    );
+    expect(result).toEqual('TEST NAME');
+  });
+
+  it('returns 2 productNames concatenated when process has 2 subscriptions with different products', () => {
+    const result = getProductNamesFromProcess(
+      getProcessDetail({
         subscriptions: {
-            page: [
-                {
-                    product: { name: 'productName' },
-                    subscriptionId: 'id',
-                    description: 'description',
-                },
-            ],
+          page: [
+            {
+              product: { name: 'TEST NAME' },
+              subscriptionId: 'id',
+              description: 'description',
+            },
+            {
+              product: { name: 'TEST NAME 2' },
+              subscriptionId: 'id',
+              description: 'description',
+            },
+          ],
         },
-        customer: {
-            fullname: 'customer',
+      }),
+    );
+    expect(result).toEqual('TEST NAME, TEST NAME 2');
+  });
+  it('returns 1 productName when process has 2 subscriptions with same products', () => {
+    const result = getProductNamesFromProcess(
+      getProcessDetail({
+        subscriptions: {
+          page: [
+            {
+              product: { name: 'TEST NAME' },
+              subscriptionId: 'id',
+              description: 'description',
+            },
+            {
+              product: { name: 'TEST NAME' },
+              subscriptionId: 'id',
+              description: 'description',
+            },
+          ],
         },
-        ...data,
-    };
-};
-
-describe('getProductNamesFromProcess()', () => {
-    it('returns empty string when process has no subscriptions', () => {
-        const result = getProductNamesFromProcess(
-            getProcessDetail({ subscriptions: undefined }),
-        );
-        expect(result).toEqual('');
-    });
-    it('returns 1 productName when process has 1 subscriptions', () => {
-        const result = getProductNamesFromProcess(
-            getProcessDetail({
-                subscriptions: {
-                    page: [
-                        {
-                            product: { name: 'TEST NAME' },
-                            subscriptionId: 'id',
-                            description: 'description',
-                        },
-                    ],
-                },
-            }),
-        );
-        expect(result).toEqual('TEST NAME');
-    });
+      }),
+    );
+    expect(result).toEqual('TEST NAME');
+  });
 
-    it('returns 2 productNames concatenated when process has 2 subscriptions with different products', () => {
-        const result = getProductNamesFromProcess(
-            getProcessDetail({
-                subscriptions: {
-                    page: [
-                        {
-                            product: { name: 'TEST NAME' },
-                            subscriptionId: 'id',
-                            description: 'description',
-                        },
-                        {
-                            product: { name: 'TEST NAME 2' },
-                            subscriptionId: 'id',
-                            description: 'description',
-                        },
-                    ],
-                },
-            }),
-        );
-        expect(result).toEqual('TEST NAME, TEST NAME 2');
-    });
-    it('returns 1 productName when process has 2 subscriptions with same products', () => {
-        const result = getProductNamesFromProcess(
-            getProcessDetail({
-                subscriptions: {
-                    page: [
-                        {
-                            product: { name: 'TEST NAME' },
-                            subscriptionId: 'id',
-                            description: 'description',
-                        },
-                        {
-                            product: { name: 'TEST NAME' },
-                            subscriptionId: 'id',
-                            description: 'description',
-                        },
-                    ],
-                },
-            }),
-        );
-        expect(result).toEqual('TEST NAME');
-    });
-
-    it('returns correct string when process has these subscriptions', () => {
-        const result = getProductNamesFromProcess(
-            getProcessDetail({
-                subscriptions: {
-                    page: [
-                        {
-                            product: { name: 'TEST NAME' },
-                            subscriptionId: 'id',
-                            description: 'description',
-                        },
-                        {
-                            product: { name: 'TEST NAME' },
-                            subscriptionId: 'id',
-                            description: 'description',
-                        },
-                        {
-                            product: { name: 'TEST NAME 2' },
-                            subscriptionId: 'id',
-                            description: 'description',
-                        },
-                    ],
-                },
-            }),
-        );
-        expect(result).toEqual('TEST NAME, TEST NAME 2');
-    });
+  it('returns correct string when process has these subscriptions', () => {
+    const result = getProductNamesFromProcess(
+      getProcessDetail({
+        subscriptions: {
+          page: [
+            {
+              product: { name: 'TEST NAME' },
+              subscriptionId: 'id',
+              description: 'description',
+            },
+            {
+              product: { name: 'TEST NAME' },
+              subscriptionId: 'id',
+              description: 'description',
+            },
+            {
+              product: { name: 'TEST NAME 2' },
+              subscriptionId: 'id',
+              description: 'description',
+            },
+          ],
+        },
+      }),
+    );
+    expect(result).toEqual('TEST NAME, TEST NAME 2');
+  });
 });

package/src/utils/getProductNamesFromProcess.ts

@@ -1,16 +1,14 @@
 import { ProcessDetail } from '../types';
 
 export const getProductNamesFromProcess = (
-    process: ProcessDetail | undefined | Omit<ProcessDetail, 'status'>,
+  process: ProcessDetail | undefined | Omit<ProcessDetail, 'status'>,
 ): string => {
-    if (!process) return '';
+  if (!process) return '';
 
-    const productNames: string[] =
-        process && process.subscriptions && process.subscriptions.page
-            ? process.subscriptions.page.map((page) => page.product.name)
-            : [];
+  const productNames: string[] =
+    process && process.subscriptions && process.subscriptions.page ?
+      process.subscriptions.page.map((page) => page.product.name)
+    : [];
 
-    return productNames
-        .filter((name, index) => productNames.indexOf(name) === index)
-        .join(', ');
+  return productNames.filter((name, index) => productNames.indexOf(name) === index).join(', ');
 };