@contrail/cli 2.3.3 → 2.3.5

package/dist/helpers/types/parseOptionSetsLocalFiles.spec.js

@@ -0,0 +1,285 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const parseOptionSetsLocalFiles_1 = require("../../commands/types/parseOptionSetsLocalFiles");
+describe('parseNameAndLabelAndKey', () => {
+    it('should parse Name, Value, and Display, Disabled columns correctly if they are all present', () => {
+        const input = [
+            {
+                Name: 'Category',
+                Value: 'bottoms',
+                Display: 'Bottoms',
+                Disabled: 'false',
+            },
+            {
+                Name: 'Category',
+                Value: 'dresses',
+                Display: 'Dresses',
+                Disabled: 'true',
+            },
+            {
+                Name: 'Category',
+                Value: 'jacket',
+                Display: 'Jacket',
+                Disabled: 'true',
+            },
+            { Name: 'Fit', Value: 'active', Display: 'Active', Disabled: 'TRUE' },
+        ];
+        const expectedOutput = [
+            {
+                name: 'Category',
+                slug: 'category',
+                isArchived: false,
+                optionSet: [
+                    {
+                        value: 'bottoms',
+                        display: 'Bottoms',
+                        disabled: false,
+                    },
+                    {
+                        value: 'dresses',
+                        display: 'Dresses',
+                        disabled: true,
+                    },
+                    {
+                        value: 'jacket',
+                        display: 'Jacket',
+                        disabled: true,
+                    },
+                ],
+            },
+            {
+                name: 'Fit',
+                slug: 'fit',
+                isArchived: false,
+                optionSet: [
+                    {
+                        value: 'active',
+                        display: 'Active',
+                        disabled: true,
+                    },
+                ],
+            },
+        ];
+        const result = (0, parseOptionSetsLocalFiles_1.parseNameAndLabelAndKey)(input);
+        expect(result).toEqual(expectedOutput);
+    });
+    it('should skip invalid rows or rows with incorrect number of columns', () => {
+        const input = [
+            {
+                Name: 'Category',
+                Value: 'dresses',
+                Display: 'Dresses',
+            },
+            {
+                Name: 'Category',
+                Value: 'bottoms',
+                Display: 'Bottoms',
+                Disabled: '', // this is invalid row which should be skipped
+            },
+            {
+                Name: 'Category',
+                Value: 'jacket',
+            },
+            { Name: 'Fit', Value: 'active', Display: 'Active', Disabled: 'true' },
+        ];
+        const expectedOutput = [
+            {
+                name: 'Category',
+                slug: 'category',
+                isArchived: false,
+                optionSet: [
+                    {
+                        value: 'dresses',
+                        display: 'Dresses',
+                        disabled: false,
+                    },
+                ],
+            },
+            {
+                name: 'Fit',
+                slug: 'fit',
+                isArchived: false,
+                optionSet: [
+                    {
+                        value: 'active',
+                        display: 'Active',
+                        disabled: true,
+                    },
+                ],
+            },
+        ];
+        const result = (0, parseOptionSetsLocalFiles_1.parseNameAndLabelAndKey)(input);
+        expect(result).toEqual(expectedOutput);
+    });
+    it('should set disabled value to default value of false for invalid row values', () => {
+        const input = [
+            {
+                Name: 'Category',
+                Value: 'bottoms',
+                Display: 'Bottoms',
+                Disabled: 'false',
+            },
+            {
+                Name: 'Category',
+                Value: 'dresses',
+                Display: 'Dresses',
+                Disabled: 'test',
+            },
+            {
+                Name: 'Category',
+                Value: 'jacket',
+                Display: 'Jacket',
+                Disabled: 'abc',
+            },
+            { Name: 'Fit', Value: 'active', Display: 'Active', Disabled: 'true' },
+        ];
+        const expectedOutput = [
+            {
+                name: 'Category',
+                slug: 'category',
+                isArchived: false,
+                optionSet: [
+                    {
+                        value: 'bottoms',
+                        display: 'Bottoms',
+                        disabled: false,
+                    },
+                    {
+                        value: 'dresses',
+                        display: 'Dresses',
+                        disabled: false,
+                    },
+                    {
+                        value: 'jacket',
+                        display: 'Jacket',
+                        disabled: false,
+                    },
+                ],
+            },
+            {
+                name: 'Fit',
+                slug: 'fit',
+                isArchived: false,
+                optionSet: [
+                    {
+                        value: 'active',
+                        display: 'Active',
+                        disabled: true,
+                    },
+                ],
+            },
+        ];
+        const result = (0, parseOptionSetsLocalFiles_1.parseNameAndLabelAndKey)(input);
+        expect(result).toEqual(expectedOutput);
+    });
+    it('should handle missing disabled field correctly', () => {
+        const input = [
+            {
+                Name: 'Category',
+                Value: 'dresses',
+                Display: 'Dresses',
+            },
+            { Name: 'Fit', Value: 'active', Display: 'Active' },
+        ];
+        const expectedOutput = [
+            {
+                name: 'Category',
+                slug: 'category',
+                isArchived: false,
+                optionSet: [
+                    {
+                        value: 'dresses',
+                        display: 'Dresses',
+                        disabled: false,
+                    },
+                ],
+            },
+            {
+                name: 'Fit',
+                slug: 'fit',
+                isArchived: false,
+                optionSet: [
+                    {
+                        value: 'active',
+                        display: 'Active',
+                        disabled: false,
+                    },
+                ],
+            },
+        ];
+        const result = (0, parseOptionSetsLocalFiles_1.parseNameAndLabelAndKey)(input);
+        expect(result).toEqual(expectedOutput);
+    });
+    it('should convert number value to string', () => {
+        const input = [
+            {
+                Name: 'Category',
+                Value: 123,
+                Display: 'Category',
+                Disabled: 'false',
+            },
+        ];
+        const expectedOutput = [
+            {
+                name: 'Category',
+                slug: 'category',
+                isArchived: false,
+                optionSet: [
+                    {
+                        value: '123',
+                        display: 'Category',
+                        disabled: false,
+                    },
+                ],
+            },
+        ];
+        const result = (0, parseOptionSetsLocalFiles_1.parseNameAndLabelAndKey)(input);
+        expect(result).toEqual(expectedOutput);
+    });
+    describe('parseDisabledValue', () => {
+        it('should return true for valid "true" string', () => {
+            const input = 'true';
+            const result = (0, parseOptionSetsLocalFiles_1.parseDisabledValue)(input);
+            expect(result).toBe(true);
+        });
+        it('should return true for valid case insensitive "true" string', () => {
+            const input = 'TRUE';
+            const result = (0, parseOptionSetsLocalFiles_1.parseDisabledValue)(input);
+            expect(result).toBe(true);
+        });
+        it('should return false for valid "false" string', () => {
+            const input = 'false';
+            const result = (0, parseOptionSetsLocalFiles_1.parseDisabledValue)(input);
+            expect(result).toBe(false);
+        });
+        it('should return true for valid case insensitive "false" string', () => {
+            const input = 'FALSE';
+            const result = (0, parseOptionSetsLocalFiles_1.parseDisabledValue)(input);
+            expect(result).toBe(false);
+        });
+        it('should return false for invalid string', () => {
+            const input = 'invalid';
+            const result = (0, parseOptionSetsLocalFiles_1.parseDisabledValue)(input);
+            expect(result).toBe(false);
+        });
+    });
+});
+describe('parseLabelsInColumn', () => {
+    it('should parse option sets with number values as strings', () => {
+        const input = [{ Gender: 1 }, { Gender: 2 }, { Gender: 3 }];
+        const expectedOutput = [
+            {
+                name: 'Gender',
+                slug: 'gender',
+                isArchived: false,
+                optionSet: [
+                    { value: '1', display: '1' },
+                    { value: '2', display: '2' },
+                    { value: '3', display: '3' },
+                ],
+            },
+        ];
+        const result = (0, parseOptionSetsLocalFiles_1.parseLabelsInColumn)(input);
+        expect(result).toEqual(expectedOutput);
+    });
+});

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

@@ -53,13 +53,13 @@ async function uploadReducedTypes(dir) {
         });
         currentTypes.push(typeWithProperties);
     }
-    const currentTypesBySlug = {};
+    const currentTypesByTypePath = {};
     for (const currentType of currentTypes) {
-        currentTypesBySlug[currentType.slug] = currentType;
+        currentTypesByTypePath[currentType.typePath] = currentType;
     }
-    const newTypesBySlug = {};
+    const newTypesByTypePath = {};
     for (const type of types) {
-        newTypesBySlug[type.slug] = type;
+        newTypesByTypePath[type.typePath] = type;
     }
     const optionSets = await new sdk_1.Entities().get({
         entityName: 'type-property-option-set',
@@ -70,13 +70,13 @@ async function uploadReducedTypes(dir) {
     }
     for (const type of types) {
         try {
-            const found = currentTypesBySlug[type.slug];
+            const found = currentTypesByTypePath[type.typePath];
             if (!found) {
                 if (!type.typePath.includes(':')) {
                     logger_1.default.info(`Cannot create a base type. Skipping: ${type.slug}`);
                     continue;
                 }
-                logger_1.default.info(`Creating Type:  ${type.slug}`);
+                logger_1.default.info(`Creating Type:  ${type.typePath}`);
                 const createdType = await new sdk_1.Entities().create({
                     entityName: 'type',
                     object: {
@@ -126,7 +126,7 @@ async function uploadReducedTypes(dir) {
                     });
                 }
                 else {
-                    logger_1.default.debug(`Skipping empty update of type ${type.slug}`);
+                    logger_1.default.debug(`Skipping empty update of type ${type.typePath}`);
                 }
                 await uploadReducedTypeProperties(updatedType, found.typeProperties, type.typeProperties, optionSets);
             }
@@ -171,6 +171,10 @@ async function uploadReducedTypeProperties(type, currentPropertyTypes, newProper
                         carryOverDefault: newPropertyType.carryOverDefault,
                         referencedTypeRootSlug: newPropertyType.referencedTypeRootSlug,
                         defaultValue: newPropertyType.defaultValue,
+                        typePropertyUserListId: newPropertyType.typePropertyUserListId,
+                        referencedTypeRole: newPropertyType.referencedTypeRole,
+                        isUniqueProperty: newPropertyType.isUniqueProperty,
+                        isUniquePropertyInFamily: newPropertyType.isUniquePropertyInFamily,
                         propertyLevel: newPropertyType.propertyLevel,
                         formulaFunction: newPropertyType.formulaFunction,
                         validationFunction: newPropertyType.validationFunction,
@@ -203,6 +207,10 @@ async function uploadReducedTypeProperties(type, currentPropertyTypes, newProper
                     referencedTypeRootSlug: newPropertyType.referencedTypeRootSlug ?? null,
                     defaultValue: newPropertyType.defaultValue ?? null,
                     propertyLevel: newPropertyType.propertyLevel ?? null,
+                    typePropertyUserListId: newPropertyType.typePropertyUserListId ?? null,
+                    referencedTypeRole: newPropertyType.referencedTypeRole ?? null,
+                    isUniqueProperty: newPropertyType.isUniqueProperty ?? null,
+                    isUniquePropertyInFamily: newPropertyType.isUniquePropertyInFamily ?? null,
                     formulaFunction: newPropertyType.formulaFunction ?? null,
                     validationFunction: newPropertyType.validationFunction ?? null,
                     numberFormat: newPropertyType.numberFormat ?? null,

package/dist/helpers/types/uploadOptionSets.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/helpers/types/uploadOptionSets.spec.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const uploadOptionSets_1 = require("../../commands/types/uploadOptionSets");
+describe('parseOptionSetValuesToString', () => {
+    it('should convert all option set values to strings', () => {
+        const input = {
+            value1: 123,
+            value2: true,
+            value3: { nested: 'object' },
+        };
+        const expectedOutput = {
+            value1: '123',
+            value2: 'true',
+            value3: { nested: 'object' },
+        };
+        const result = (0, uploadOptionSets_1.parseOptionSetValuesToString)(input);
+        expect(result).toEqual(expectedOutput);
+    });
+});

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

@@ -62,6 +62,8 @@ class WorkflowTemplateDefinitionDeployer {
                 identifier: definition.identifier,
                 builtIn: definition.builtIn,
                 messageGroupId: definition.messageGroupId,
+                messageGroup: definition.messageGroup,
+                dynamicMessageGroupId: definition.dynamicMessageGroupId,
                 parallelWorkerCount: definition.parallelWorkerCount,
                 triggerKey: definition.triggerKey,
                 workflowDefinition: definition.workflowDefinition,
@@ -115,6 +117,8 @@ class WorkflowTemplateDefinitionDeployer {
             public: workflowDeclaration.public,
             isActive: workflowDeclaration.isActive,
             messageGroupId: workflowDeclaration.messageGroupId,
+            messageGroup: workflowDeclaration.messageGroup,
+            dynamicMessageGroupId: workflowDeclaration.dynamicMessageGroupId,
             parallelWorkerCount: workflowDeclaration.parallelWorkerCount,
         };
         const workflowTemplate = await (0, event_workflow_template_definition_1.createWorkflowTemplateDefinition)(newObject);

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

@@ -44,6 +44,8 @@ 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);
@@ -159,6 +161,8 @@ class LocalWorkflowTemplateDeployer {
             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,
         });
         const updatedWorkflowTemplate = await (0, event_workflow_templates_1.updateWorkflowTemplate)({

package/dist/interfaces.d.ts

@@ -73,6 +73,8 @@ export interface WorkflowDefinition {
     supportingAppId?: string;
     parallelWorkerCount?: number;
     messageGroupId?: string;
+    messageGroup?: string;
+    dynamicMessageGroupId?: string;
 }
 export interface WorkflowTemplateDeclaration {
     appIdentifier: string;
@@ -91,6 +93,8 @@ export interface WorkflowTemplate {
     supportingAppId?: string;
     parallelWorkerCount?: number;
     messageGroupId?: string;
+    messageGroup?: string;
+    dynamicMessageGroupId?: string;
     createdOn?: Date;
     updatedOn?: Date;
     createdById?: string;
@@ -330,6 +334,10 @@ export interface ReducedTypeProperty {
     typePropertyOptionSetSlug: string;
     formula: string;
     referencedTypePath: string;
+    referencedTypeRole: string;
+    typePropertyUserListId: string;
+    isUniqueProperty: boolean;
+    isUniquePropertyInFamily: boolean;
     referencedTypeRootSlug: string;
     defaultValue: string;
     propertyLevel: string;

package/dist/templates/typescript/app.yml

@@ -34,7 +34,10 @@ workflows:
     triggerKey: item|update
     isActive: true
     public: true
-    concurrency: 3  # The maximum number of concurrent jobs to run for this workflow. 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"