@contrail/cli 2.4.0 → 3.0.1

package/dist/helpers/load/validators.spec.js

@@ -0,0 +1,450 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const validators_1 = require("./validators");
+describe('LoadValidators', () => {
+    describe('ValidateColorsLoadFile', () => {
+        it('should return errors if Federated ID is missing in the config file', () => {
+            const colorsData = [{ id: 1, name: 'Red', hex: '#FF0000' }];
+            const config = {
+                federatedMappings: { name: 'Colors' },
+                loadType: ['COLOR'],
+                conditionalColumns: [{ toProperty: 'typePath', default: 'color' }],
+            };
+            const result = validators_1.LoadValidators.ValidateColorsLoadFile(colorsData, config);
+            expect(result.errors).toContain('"federatedId" is required in the config file');
+        });
+        it('should return errors if Name is missing in the config file', () => {
+            const colorsData = [{ id: 1, name: 'Red', hex: '#FF0000' }];
+            const config = {
+                federatedMappings: { federatedId: 'id' },
+                loadType: ['COLOR'],
+                conditionalColumns: [{ toProperty: 'typePath', default: 'color' }],
+            };
+            const result = validators_1.LoadValidators.ValidateColorsLoadFile(colorsData, config);
+            expect(result.errors).toContain('"name" is required in the config file');
+        });
+        it('should return errors if Name column is not found in the CSV file', () => {
+            const colorsData = [{ id: 1, name: 'Red', hex: '#FF0000' }];
+            const config = {
+                federatedMappings: { federatedId: 'id', name: 'Colors' },
+                loadType: ['COLOR'],
+                conditionalColumns: [{ toProperty: 'typePath', default: 'color' }],
+            };
+            const result = validators_1.LoadValidators.ValidateColorsLoadFile(colorsData, config);
+            expect(result.errors).toContain('Name column (Colors) not found in the CSV file');
+        });
+        it('should return errors if Federated ID is not found in the CSV file', () => {
+            const colorsData = [{ Colors: 'Red', hex: '#FF0000' }];
+            const config = {
+                federatedMappings: { name: 'Colors', federatedId: 'id' },
+                loadType: ['COLOR'],
+                conditionalColumns: [{ toProperty: 'typePath', default: 'color' }],
+            };
+            const result = validators_1.LoadValidators.ValidateColorsLoadFile(colorsData, config);
+            expect(result.errors).toContain('Federated ID column (id) not found in the CSV file');
+        });
+        it('should return multiple errors', () => {
+            const colorsData = [{ hex: '#FF0000' }];
+            const config = {
+                federatedMappings: { name: 'Colors', federatedId: 'id' },
+                loadType: ['COLOR'],
+                conditionalColumns: [{ toProperty: 'typePath', default: 'color' }],
+            };
+            const result = validators_1.LoadValidators.ValidateColorsLoadFile(colorsData, config);
+            expect(result.errors).toContain('Name column (Colors) not found in the CSV file');
+            expect(result.errors).toContain('Federated ID column (id) not found in the CSV file');
+        });
+        it('should return warnings if Hex is ignored when red, green, and blue columns are present', () => {
+            const colorsData = [{ id: 1, name: 'Red', red: 255, green: 0, blue: 0, hex: '#FF0000' }];
+            const config = {
+                loadType: ['COLOR'],
+                conditionalColumns: [{ toProperty: 'typePath', default: 'color' }],
+                federatedMappings: {
+                    red: 'red',
+                    green: 'green',
+                    blue: 'blue',
+                    hex: 'hex',
+                    name: 'Colors',
+                    federatedId: 'id',
+                },
+            };
+            const result = validators_1.LoadValidators.ValidateColorsLoadFile(colorsData, config);
+            expect(result.warnings).toContain('"Hex" is ignored when red, green, and blue columns are present');
+        });
+        it('should return empty errors and warnings if all validations pass', () => {
+            const colorsData = [{ id: 1, Colors: 'Red', red: 255, green: 0, blue: 0 }];
+            const config = {
+                loadType: ['COLOR'],
+                conditionalColumns: [{ toProperty: 'typePath', default: 'color' }],
+                federatedMappings: {
+                    red: 'red',
+                    green: 'green',
+                    blue: 'blue',
+                    name: 'Colors',
+                    federatedId: 'id',
+                },
+            };
+            const result = validators_1.LoadValidators.ValidateColorsLoadFile(colorsData, config);
+            expect(result.errors).toEqual([]);
+            expect(result.warnings).toEqual([]);
+        });
+        it('should return error if duplicate federatedId is found', () => {
+            const colorsData = [
+                { id: 1, Colors: 'Red', red: 255, green: 0, blue: 0 },
+                { id: 1, Colors: 'Green', red: 0, green: 255, blue: 0 },
+                { id: 2, Colors: 'Blue', red: 0, green: 0, blue: 255 },
+            ];
+            const config = {
+                loadType: ['COLOR'],
+                conditionalColumns: [{ toProperty: 'typePath', default: 'color' }],
+                federatedMappings: {
+                    red: 'red',
+                    green: 'green',
+                    blue: 'blue',
+                    name: 'Colors',
+                    federatedId: 'id',
+                },
+            };
+            const result = validators_1.LoadValidators.ValidateColorsLoadFile(colorsData, config);
+            expect(result.errors).toContain('Duplicate FederatedIds found: 1');
+        });
+        it('should throw error if typePath is present in the csv header but have incorrect typePath', () => {
+            const colorsData = [{ name: 'color1', typePath: 'color1' }];
+            const config = {
+                loadType: ['COLOR'],
+                conditionalColumns: [],
+                federatedMappings: {
+                    red: 'red',
+                    green: 'green',
+                    blue: 'blue',
+                    name: 'Colors',
+                    federatedId: 'id',
+                },
+            };
+            const result = validators_1.LoadValidators.ValidateColorsLoadFile(colorsData, config);
+            expect(result.errors).toContain('"typePath" must be "color" in each row in the csv file');
+        });
+        it('should not throw error if typepath is present in the csv header and have correct typePath', () => {
+            const colorsData = [{ name: 'color1', typePath: 'color' }];
+            const config = {
+                loadType: ['COLOR'],
+                conditionalColumns: [],
+                federatedMappings: {
+                    red: 'red',
+                    green: 'green',
+                    blue: 'blue',
+                    name: 'name',
+                    federatedId: 'name',
+                },
+            };
+            const result = validators_1.LoadValidators.ValidateColorsLoadFile(colorsData, config);
+            expect(result.errors).toHaveLength(0);
+        });
+    });
+    describe('ValidateCustomEntityLoadFile', () => {
+        it('should return error if config is null', () => {
+            const customEntityData = [{ id: 1, name: 'Test' }];
+            const result = validators_1.LoadValidators.ValidateCustomEntityLoadFile(customEntityData, null);
+            expect(result.errors).toContain('Config file is empty');
+        });
+        it('should return error if loadType is missing in config', () => {
+            const customEntityData = [{ id: 1, name: 'Test' }];
+            const config = {};
+            const result = validators_1.LoadValidators.ValidateCustomEntityLoadFile(customEntityData, config);
+            expect(result.errors).toContain('"loadType" is required in the config file');
+        });
+        it('should return error if loadType is not CUSTOM_ENTITY', () => {
+            const customEntityData = [{ id: 1, name: 'Test' }];
+            const config = { loadType: ['OTHER_TYPE'] };
+            const result = validators_1.LoadValidators.ValidateCustomEntityLoadFile(customEntityData, config);
+            expect(result.errors).toContain('"loadType" must be must be single value "CUSTOM_ENTITY" in the config file');
+        });
+        it('should return error if federatedMappings.federatedId is missing in config', () => {
+            const customEntityData = [{ id: 1, name: 'Test' }];
+            const config = { loadType: ['CUSTOM_ENTITY'] };
+            const result = validators_1.LoadValidators.ValidateCustomEntityLoadFile(customEntityData, config);
+            expect(result.errors).toContain('"federatedId" is required in the config file');
+        });
+        it('should return error if federatedMappings.name is missing in config', () => {
+            const customEntityData = [{ id: 1, name: 'Test' }];
+            const config = {
+                loadType: ['CUSTOM_ENTITY'],
+                federatedMappings: { federatedId: 'id' },
+            };
+            const result = validators_1.LoadValidators.ValidateCustomEntityLoadFile(customEntityData, config);
+            expect(result.errors).toContain('"name" is required in the config file');
+        });
+        it('should return error if federatedId column is missing in CSV', () => {
+            const customEntityData = [{ name: 'Test' }];
+            const config = {
+                loadType: ['CUSTOM_ENTITY'],
+                federatedMappings: { federatedId: 'id', name: 'name' },
+                conditionalColumns: ['typePath'],
+            };
+            const result = validators_1.LoadValidators.ValidateCustomEntityLoadFile(customEntityData, config);
+            expect(result.errors).toContain('Federated ID column (id) not found in the CSV file');
+        });
+        it('should return error if conditionalColumns is missing in config', () => {
+            const customEntityData = [{ id: 1, name: 'Test' }];
+            const config = {
+                loadType: ['CUSTOM_ENTITY'],
+                federatedMappings: { federatedId: 'id', name: 'name' },
+            };
+            const result = validators_1.LoadValidators.ValidateCustomEntityLoadFile(customEntityData, config);
+            expect(result.errors).toContain('Missing "typePath" column in the csv file or config file');
+        });
+        it('should return error if name column is missing in CSV', () => {
+            const customEntityData = [{ id: 1 }];
+            const config = {
+                loadType: ['CUSTOM_ENTITY'],
+                federatedMappings: { federatedId: 'id', name: 'name' },
+                conditionalColumns: ['typePath'],
+            };
+            const result = validators_1.LoadValidators.ValidateCustomEntityLoadFile(customEntityData, config);
+            expect(result.errors).toContain('Name column not found in the CSV file');
+        });
+        it('should not return errors if all conditions are met', () => {
+            const customEntityData = [{ id: 1, name: 'Test' }];
+            const config = {
+                loadType: ['CUSTOM_ENTITY'],
+                federatedMappings: { federatedId: 'id', name: 'name' },
+                conditionalColumns: [{ toProperty: 'typePath', default: 'custom-entity:material' }],
+            };
+            const result = validators_1.LoadValidators.ValidateCustomEntityLoadFile(customEntityData, config);
+            expect(result.errors).toHaveLength(0);
+        });
+        it('should return error if duplicate federatedId is found', () => {
+            const customEntityData = [
+                { id: 1, name: 'Test' },
+                { id: 2, name: 'Test2' },
+                { id: 1, name: 'Test3' },
+            ];
+            const config = {
+                loadType: ['CUSTOM_ENTITY'],
+                federatedMappings: { federatedId: 'id', name: 'name' },
+                conditionalColumns: [{ toProperty: 'typePath', default: 'custom-entity' }],
+            };
+            const result = validators_1.LoadValidators.ValidateCustomEntityLoadFile(customEntityData, config);
+            expect(result.errors).toContain('Duplicate FederatedIds found: 1');
+        });
+        it('should throw error if typepath is present in the csv header but have incorrect typePath', () => {
+            const customEntityData = [{ name: 'custom-entity1', typePath: 'custom-entity1' }];
+            const config = {
+                loadType: ['CUSTOM_ENTITY'],
+                federatedMappings: { federatedId: 'name', name: 'name' },
+                conditionalColumns: [],
+            };
+            const result = validators_1.LoadValidators.ValidateCustomEntityLoadFile(customEntityData, config);
+            expect(result.errors).toContain('"typePath" must be "custom-entity:<subtypepath>" in each row in the csv file');
+        });
+        it('should not throw error if typepath is present in the csv header but have correct typePath', () => {
+            const customEntityData = [{ name: 'custom-entity1', typePath: 'custom-entity:material' }];
+            const config = {
+                loadType: ['CUSTOM_ENTITY'],
+                federatedMappings: { federatedId: 'name', name: 'name' },
+                conditionalColumns: [],
+            };
+            const result = validators_1.LoadValidators.ValidateCustomEntityLoadFile(customEntityData, config);
+            expect(result.errors).toHaveLength(0);
+        });
+    });
+    describe('ValidateLineSheetLoadFile', () => {
+        it('should return an error if config is empty', () => {
+            const lineSheetData = [{ header1: 'value1' }];
+            const config = null;
+            const result = validators_1.LoadValidators.ValidateLineSheetLoadFile(lineSheetData, config);
+            expect(result.errors).toContain('Config file is empty');
+            expect(result.warnings).toHaveLength(0);
+        });
+        it('should return an error if load type is missing', () => {
+            const lineSheetData = [{ header1: 'value1' }];
+            const config = { loadType: '', federatedMappings: {} };
+            const result = validators_1.LoadValidators.ValidateLineSheetLoadFile(lineSheetData, config);
+            expect(result.errors).toContain('"loadType" is required in the config file');
+        });
+        it('should return an error if load type is invalid', () => {
+            const lineSheetData = [{ header1: 'value1' }];
+            const config = { loadType: ['INVALID'], federatedMappings: {} };
+            const result = validators_1.LoadValidators.ValidateLineSheetLoadFile(lineSheetData, config);
+            expect(result.errors).toContain('"loadType" must be either of values ["ITEM", "PROJECT_ITEM", "ASSORTMENT"] in the config file');
+        });
+        it('should return an error if name is not mapped in federatedMappings', () => {
+            const lineSheetData = [{ header1: 'value1' }];
+            const config = { loadType: ['ITEM'], federatedMappings: {} };
+            const result = validators_1.LoadValidators.ValidateLineSheetLoadFile(lineSheetData, config);
+            expect(result.errors).toContain('"name" is required in the config file and must be mapped to Item Family Name');
+        });
+        it('should return a warning if optionName is not mapped in federatedMappings', () => {
+            const lineSheetData = [{ header1: 'value1' }];
+            const config = {
+                loadType: ['ITEM'],
+                federatedMappings: {
+                    name: 'header1',
+                    itemFamilyFederatedId: 'someId',
+                },
+            };
+            const result = validators_1.LoadValidators.ValidateLineSheetLoadFile(lineSheetData, config);
+            expect(result.warnings).toContain('"optionName" is not mapped in the config file');
+        });
+        it('should return an error if itemFamilyFederatedId is not mapped in federatedMappings', () => {
+            const lineSheetData = [{ header1: 'value1' }];
+            const config = {
+                loadType: ['ITEM'],
+                federatedMappings: {
+                    name: 'header1',
+                },
+            };
+            const result = validators_1.LoadValidators.ValidateLineSheetLoadFile(lineSheetData, config);
+            expect(result.errors).toContain('"itemFamilyFederatedId" is required in the config file');
+        });
+        it('should return a warning if itemOptionFederatedId is not mapped in federatedMappings', () => {
+            const lineSheetData = [{ header1: 'value1' }];
+            const config = {
+                loadType: ['ITEM'],
+                federatedMappings: {
+                    name: 'header1',
+                    itemFamilyFederatedId: 'someId',
+                },
+            };
+            const result = validators_1.LoadValidators.ValidateLineSheetLoadFile(lineSheetData, config);
+            expect(result.warnings).toContain('"itemOptionFederatedId" is not mapped in the config file');
+        });
+        it('should return an error if itemFamilyFederatedId is missing in the CSV file', () => {
+            const lineSheetData = [{ header1: 'value1', itemFamilyFederatedId: 'someId' }];
+            const config = {
+                loadType: ['ITEM'],
+                federatedMappings: {
+                    name: 'header1',
+                    itemFamilyFederatedId: null,
+                },
+            };
+            const result = validators_1.LoadValidators.ValidateLineSheetLoadFile(lineSheetData, config);
+            expect(result.errors).toContain(`itemFamilyFederatedId column (${config?.federatedMappings?.itemFamilyFederatedId}) not found in the CSV file`);
+        });
+        it('should return an error if itemFamilyFederatedId is null or undefined or empty in lineSheetData', () => {
+            const lineSheetData = [
+                { header1: 'value1', itemFamilyFederatedId: null },
+                { header1: 'value2', itemFamilyFederatedId: undefined },
+                { header1: 'value3', itemFamilyFederatedId: 'valid' },
+                { header1: 'value4', itemFamilyFederatedId: '' },
+            ];
+            const config = {
+                loadType: ['ITEM'],
+                federatedMappings: {
+                    name: 'header1',
+                    itemFamilyFederatedId: 'itemFamilyFederatedId',
+                },
+            };
+            const result = validators_1.LoadValidators.ValidateLineSheetLoadFile(lineSheetData, config);
+            expect(result.errors).toContain('some rows contain itemFamilyFederatedId is null or undefined or empty in the CSV file (rows 0,1,3)');
+        });
+        it('should return errors if duplicate itemFamilyFederatedId is found in lineSheetData', () => {
+            const lineSheetData = [
+                {
+                    header1: 'value1',
+                    itemFamilyFederatedId: '1',
+                },
+                {
+                    header1: 'value2',
+                    itemFamilyFederatedId: '1',
+                },
+                {
+                    header1: 'value3',
+                    itemFamilyFederatedId: '2',
+                },
+            ];
+            const config = {
+                loadType: ['ITEM'],
+                federatedMappings: {
+                    name: 'header1',
+                    itemFamilyFederatedId: 'itemFamilyFederatedId',
+                },
+            };
+            const result = validators_1.LoadValidators.ValidateLineSheetLoadFile(lineSheetData, config);
+            expect(result.errors).toContain('Found conflicting fields for family federated Ids: (1: (value1, value2))');
+        });
+        it('should allow for the same itemFamilyFederatedId if the names are the same', () => {
+            const lineSheetData = [
+                {
+                    itemName: 'foo',
+                    itemFamilyFederatedId: '1',
+                },
+                {
+                    itemName: 'foo',
+                    itemFamilyFederatedId: '1',
+                },
+                {
+                    itemName: 'bar',
+                    itemFamilyFederatedId: '2',
+                },
+            ];
+            const config = {
+                loadType: ['ITEM'],
+                federatedMappings: {
+                    name: 'itemName',
+                    itemFamilyFederatedId: 'itemFamilyFederatedId',
+                },
+            };
+            const result = validators_1.LoadValidators.ValidateLineSheetLoadFile(lineSheetData, config);
+            expect(result.errors.length).toBe(0);
+        });
+        it('should find error if itemFamilyFederatedId is duplicated across different names', () => {
+            const lineSheetData = [
+                {
+                    itemName: 'foo',
+                    itemFamilyFederatedId: '1',
+                },
+                {
+                    itemName: 'bar',
+                    itemFamilyFederatedId: '1',
+                },
+                {
+                    itemName: 'baz',
+                    itemFamilyFederatedId: '2',
+                },
+            ];
+            const config = {
+                loadType: ['ITEM'],
+                federatedMappings: {
+                    name: 'itemName',
+                    itemFamilyFederatedId: 'itemFamilyFederatedId',
+                },
+            };
+            const result = validators_1.LoadValidators.ValidateLineSheetLoadFile(lineSheetData, config);
+            expect(result.errors).toContain('Found conflicting fields for family federated Ids: (1: (foo, bar))');
+        });
+        it('should return warnings if duplicate itemOptionFederatedId is found in lineSheetData', () => {
+            const lineSheetData = [
+                {
+                    header1: 'value1',
+                    itemFamilyFederatedId: '1',
+                    itemOptionFederatedId: '1',
+                    optionName: 'option1',
+                },
+                {
+                    header1: 'value2',
+                    itemFamilyFederatedId: '2',
+                    itemOptionFederatedId: '1',
+                    optionName: 'option2',
+                },
+                {
+                    header1: 'value3',
+                    itemFamilyFederatedId: '3',
+                    itemOptionFederatedId: '2',
+                    optionName: 'option3',
+                },
+            ];
+            const config = {
+                loadType: ['ITEM'],
+                federatedMappings: {
+                    name: 'header1',
+                    itemFamilyFederatedId: 'itemFamilyFederatedId',
+                    itemOptionFederatedId: 'itemOptionFederatedId',
+                    optionName: 'optionName',
+                },
+            };
+            const result = validators_1.LoadValidators.ValidateLineSheetLoadFile(lineSheetData, config);
+            expect(result.errors).toContain('Duplicate itemOptionFederatedId found: 1');
+        });
+    });
+});

package/dist/helpers/types/type-uploader.js

@@ -13,7 +13,7 @@ const logger_1 = tslib_1.__importDefault(require("../../logger"));
 async function uploadTypes(dir) {
     try {
         const userConfig = await (0, login_1.authUser)();
-        logger_1.default.info(`START Getting all types for orgId: ${userConfig.orgId}`);
+        logger_1.default.info(`START Getting all types for org ${userConfig.orgSlug}`);
         logger_1.default.info('TYPES Uploading ');
         await uploadReducedTypes(dir);
         logger_1.default.info(`${chalk_1.default.yellow.bold('TYPES')} Uploaded`);
@@ -149,8 +149,16 @@ async function uploadReducedTypeProperties(type, currentPropertyTypes, newProper
     for (const optionSet of optionSets) {
         optionSetIdBySlug[optionSet.slug] = optionSet.id;
     }
+    const sets = await new sdk_1.Entities().get({ entityName: 'user-list' });
     for (const newPropertyType of newPropertyTypes) {
+        let typePropertyUserListId = null;
         try {
+            if (newPropertyType.typePropertyUserListName) {
+                const userList = sets.find((s) => s.name === newPropertyType.typePropertyUserListName);
+                if (userList) {
+                    typePropertyUserListId = userList.id;
+                }
+            }
             const found = currentPropertyTypeBySlug[newPropertyType.slug];
             if (!found) {
                 logger_1.default.info(`Creating Type-Property:  ${newPropertyType.slug}`);
@@ -171,7 +179,7 @@ async function uploadReducedTypeProperties(type, currentPropertyTypes, newProper
                         carryOverDefault: newPropertyType.carryOverDefault,
                         referencedTypeRootSlug: newPropertyType.referencedTypeRootSlug,
                         defaultValue: newPropertyType.defaultValue,
-                        typePropertyUserListId: newPropertyType.typePropertyUserListId,
+                        typePropertyUserListId,
                         referencedTypeRole: newPropertyType.referencedTypeRole,
                         isUniqueProperty: newPropertyType.isUniqueProperty,
                         isUniquePropertyInFamily: newPropertyType.isUniquePropertyInFamily,
@@ -207,7 +215,7 @@ async function uploadReducedTypeProperties(type, currentPropertyTypes, newProper
                     referencedTypeRootSlug: newPropertyType.referencedTypeRootSlug ?? null,
                     defaultValue: newPropertyType.defaultValue ?? null,
                     propertyLevel: newPropertyType.propertyLevel ?? null,
-                    typePropertyUserListId: newPropertyType.typePropertyUserListId ?? null,
+                    typePropertyUserListId,
                     referencedTypeRole: newPropertyType.referencedTypeRole ?? null,
                     isUniqueProperty: newPropertyType.isUniqueProperty ?? null,
                     isUniquePropertyInFamily: newPropertyType.isUniquePropertyInFamily ?? null,

package/dist/helpers/workflow-template-definitions/workflow-template-definition-deployer.js

@@ -51,7 +51,7 @@ class WorkflowTemplateDefinitionDeployer {
             {
                 type: 'confirm',
                 name: 'makeActive',
-                message: 'Should the workflows be active ?(yes)',
+                message: 'Should the workflows be active?',
                 default: true,
             },
         ]);

package/dist/helpers/workflow-templates/helper.js

@@ -44,8 +44,6 @@ class LocalWorkflowTemplateDeployer {
             isActive: workflowTemplate.isActive,
             supportingAppId: workflowTemplate.supportingAppId,
             messageGroupId: workflowTemplate.messageGroupId,
-            messageGroup: workflowTemplate.messageGroup,
-            dynamicMessageGroupId: workflowTemplate.dynamicMessageGroupId,
             parallelWorkerCount: workflowTemplate.parallelWorkerCount,
         };
         const newWorkflowTemplate = await (0, event_workflow_templates_1.createWorkflowTemplate)(newObject);
@@ -160,8 +158,6 @@ class LocalWorkflowTemplateDeployer {
             triggerKey: workflowTemplate.triggerKey,
             builtIn: workflowTemplate.builtIn,
             workflowDefinition: workflowTemplate.workflowDefinition,
-            messageGroupId: workflowTemplate.messageGroupId ?? existingWorkflowTemplate.messageGroupId,
-            messageGroup: workflowTemplate.messageGroup ?? existingWorkflowTemplate.messageGroup,
             dynamicMessageGroupId: workflowTemplate.dynamicMessageGroupId ?? existingWorkflowTemplate.dynamicMessageGroupId,
             parallelWorkerCount: workflowTemplate.parallelWorkerCount ?? existingWorkflowTemplate.parallelWorkerCount,
         });

package/dist/interfaces.d.ts

@@ -355,6 +355,7 @@ export interface ReducedTypeProperty {
     referencedTypePath: string;
     referencedTypeRole: string;
     typePropertyUserListId: string;
+    typePropertyUserListName?: string;
     isUniqueProperty: boolean;
     isUniquePropertyInFamily: boolean;
     referencedTypeRootSlug: string;

package/dist/templates/typescript/app.yml

@@ -1,60 +1,58 @@
-appIdentifier: "APP_IDENTIFIER_STUB"  # Change to be your company root domain and the name of the app
-appName: "APP_NAME_STUB" # Give your app a name
-appDescription: "APP_DESCRIPTION_STUB" # Give your app a description
-visibility: private  # This should be private unless you want to develop an app for all VibeIQ customers to use
+appIdentifier: 'APP_IDENTIFIER_STUB' # Change to be your company root domain and the name of the app
+appName: 'APP_NAME_STUB' # Give your app a name
+appDescription: 'APP_DESCRIPTION_STUB' # Give your app a description
+visibility: private # This should be private unless you want to develop an app for all VibeIQ customers to use
 # Access Grants
 # Use this section to share this app with other organizations.
 # accessGrants:
 #   - orgSlug: "ORG_SLUG"
 #     permissions:
 #       - install
-publisher: "APP_PUBLISHER_STUB" # Your company name, used for public apps
-version: "1.0.0"
+publisher: 'APP_PUBLISHER_STUB' # Your company name, used for public apps
+version: '1.0.0'
 
 # Properties you can configure when you install the app.
 # These property values will be available to all of your actions when they run
 appConfiguration:
   apiHost:
-    label: "API Host"
-    propertyType: "string"
-
+    label: 'API Host'
+    propertyType: 'string'
 
 # Action declarations.  You define actions here.  The 'slug' for the action
 # should match the name of a 'handler' in the /actions folder.
 # See documentation on how to implement actions.
 actions:
   logItem:
-    name: "Log Item"
-    description: "Fetches an item from the API and returns it to the log."
+    name: 'Log Item'
+    description: 'Fetches an item from the API and returns it to the log.'
     async: false
     actionConfiguration:
       message:
-        label: "Additional message to log."
-        propertyType: "string"
+        label: 'Additional message to log.'
+        propertyType: 'string'
 
 workflows:
   logItemUpdate:
-    identifier: "logItemUpdate"
-    name: "Item Update -> Log"
+    identifier: 'logItemUpdate'
+    name: 'Item Update -> Log'
     triggerKey: item|update
     isActive: true
     public: true
-    parallelWorkerCount: 5  # The maximum number of concurrent jobs to run for this workflow (Range 1-30). Defaults to 5
+    parallelWorkerCount: 5 # The maximum number of concurrent jobs to run for this workflow (Range 1-30). Defaults to 5
     messageGroupId: # Optional. Used to group jobs in a specific queue. Allows multiple workflows to use the same queue. Not to be used with dynamicMessageGroupId
     messageGroup: # Optional.  Used with dynamicMessageGroupId to allow for dynamic queue assignment and allows for multiple workflows to use the same queue
     dynamicMessageGroupId: # Optional.  Allows for dynamic queue assignment based on the event data. Example usage: 'family-queue-{newData.itemFamilyId}'
     workflowDefinition:
       paths:
-        - conditional: "true"
+        - conditional: 'true'
           actionDefinitionConfigs:
             - action: logItem
               name: Log Item
 
-
 # This is an advanced feature that can 'derive' a trigger key for external events.
 # External events are events sent to the VibeIQ API's /external-events end point from another system
 # Here, you can define a string based on properties from the event payloads (which are custom to your payload)
 # i.e. an event {details: {eventType: 'apparel'}, actionType: 'create'} can be parsed to apparel|create with the following
 # When this is defined, any event coming from your app's credentials will define a trigger key using this logic.
 # You can then define workflows to run based on those external events, based on this trigger key definition.
-eventWorkflowTriggerKeyMapping: "{details.eventType}|{actionType}"
+eventWorkflowTriggerKeyMapping: '{details.eventType}|{actionType}'

package/dist/templates/typescript/package.json

@@ -28,6 +28,20 @@
     "chalk": "^4.0.0",
     "js-yaml": "^4.1.0"
   },
+  "jest": {
+    "moduleFileExtensions": [
+      "js",
+      "json",
+      "ts"
+    ],
+    "rootDir": "",
+    "testRegex": ".spec.ts$",
+    "transform": {
+      "^.+\\.(t|j)s$": "ts-jest"
+    },
+    "coverageDirectory": "../coverage",
+    "testEnvironment": "node"
+  },
   "devDependencies": {
     "@types/node": "^18.14.6",
     "body-parser": "^1.20.2",

package/dist/templates/typescript/src/actions/logItem.ts

@@ -4,7 +4,6 @@ import {
   AppAction,
   AppActionCallBack,
   AppActionCallbackStatus,
-  Logger,
 } from '@contrail/app-framework';
 
 export class LogItemAction implements AppAction {
@@ -17,7 +16,7 @@ export class LogItemAction implements AppAction {
       entityName: 'item',
       id: event.id,
     });
-    console.log('Got item: ', JSON.stringify(item, null, 2));
+    console.log('Got item: ', item);
 
     return {
       output: {