@contrail/cli 2.3.4 → 2.3.5

package/README.md

@@ -17,7 +17,7 @@ $ npm install -g @contrail/cli
 $ contrail COMMAND
 running command...
 $ contrail (--version)
-@contrail/cli/2.3.4 darwin-arm64 node-v20.12.1
+@contrail/cli/2.3.5 darwin-arm64 node-v22.3.0
 $ contrail --help [COMMAND]
 USAGE
   $ contrail COMMAND
@@ -876,11 +876,14 @@ Configure a project from a yml file.
 
 ```
 USAGE
-  $ contrail projects load TEMPLATEFILELOCATION
+  $ contrail projects load TEMPLATEFILELOCATION [--dumpTransformedFile]
 
 ARGUMENTS
   TEMPLATEFILELOCATION  The location to the template file
 
+FLAGS
+  --dumpTransformedFile  If set to true, stores a transformed version of the template file
+
 DESCRIPTION
   Configure a project from a yml file.
 

package/dist/commands/projects/load.d.ts

@@ -5,6 +5,9 @@ export default class LoadProject extends BaseCommand {
     static args: {
         templateFileLocation: import("@oclif/core/lib/interfaces/parser").Arg<string, Record<string, unknown>>;
     };
+    static flags: {
+        dumpTransformedFile: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
     run(): Promise<void>;
 }
 interface CheckerFunction {

package/dist/commands/projects/load.js

@@ -9,6 +9,8 @@ const login_1 = require("../../auth/login");
 const basecommand_1 = require("../../basecommand");
 const helpers_1 = require("../../helpers/projects/helpers");
 const logger_1 = tslib_1.__importDefault(require("../../logger"));
+const pLimit = require('p-limit');
+const limit = pLimit(30);
 class LoadProject extends basecommand_1.BaseCommand {
     static description = 'Configure a project from a yml file.';
     static examples = [
@@ -21,18 +23,26 @@ class LoadProject extends basecommand_1.BaseCommand {
             required: true,
         }),
     };
+    static flags = {
+        ...basecommand_1.BaseCommand.flags,
+        dumpTransformedFile: core_1.Flags.boolean({
+            description: 'If set to true, stores a transformed version of the template file',
+            default: false,
+        }),
+    };
     async run() {
-        const { args } = await this.parse(LoadProject);
+        const { args, flags } = await this.parse(LoadProject);
         try {
             await (0, login_1.authUser)();
             this.log('%s Parsing Template.', chalk_1.default.blue.bold('START'));
             this.log('%s Uploading', chalk_1.default.yellow.bold('PROJECT'));
             const templateFileLocation = args.templateFileLocation;
             this.log('Using Template File Location: ', args.templateFileLocation);
-            await uploadProject(templateFileLocation);
+            await uploadProject(templateFileLocation, flags);
             this.log('%s Uploaded', chalk_1.default.yellow.bold('PROJECT'));
         }
         catch (e) {
+            console.error(e);
             this.log(`%s Project Upload Failed. ${e}`, chalk_1.default.red.bold('FAIL'));
             return;
         }
@@ -40,11 +50,16 @@ class LoadProject extends basecommand_1.BaseCommand {
     }
 }
 exports.default = LoadProject;
-async function uploadProject(templateFileLocation) {
+async function uploadProject(templateFileLocation, flags) {
     const projectConfigurationFromFile = (0, helpers_1.getProjectFile)(templateFileLocation);
     const projectConfiguration = getProjectConfiguration(projectConfigurationFromFile);
     logger_1.default.info('Checking for object and type references');
     await transformProject(projectConfiguration);
+    if (flags.dumpTransformedFile) {
+        logger_1.default.info('Dumping transformed project file');
+        const fs = require('fs');
+        fs.writeFileSync(templateFileLocation + '.transformed', JSON.stringify(projectConfiguration, null, 2));
+    }
     logger_1.default.info('Configuring Project.');
     await sdk_1.Request.request('/project-configurator', {
         method: 'POST',
@@ -155,43 +170,47 @@ async function transformAssortmentObjectReferences(_, assortments) {
         relations: ['typeProperties'],
     });
     const assortmentProperties = assortmentType.typeProperties;
+    const promises = [];
     for (const assortment of assortments ?? []) {
-        const attributes = JSON.parse(JSON.stringify(assortment?.assortmentAtts ?? {}));
-        if (!Object.keys(attributes)?.length) {
-            continue;
-        }
-        for (const [attributeKey, attributeValue] of Object.entries(attributes)) {
-            const property = assortmentProperties.find((x) => x.slug === attributeKey);
-            // if not a reference
-            if (!property || !property.referencedTypePath) {
-                continue;
+        promises.push(limit(async () => {
+            const attributes = JSON.parse(JSON.stringify(assortment?.assortmentAtts ?? {}));
+            if (!Object.keys(attributes)?.length) {
+                return;
             }
-            if (property.propertyType === types_1.PropertyType.TypeReference) {
-                logger_1.default.debug(`found type reference!${attributeKey}${attributeValue}`);
-                // special case: handle type references
-                const type = (await new sdk_1.Types().getType({ path: attributeValue }))?.id;
-                logger_1.default.debug(`found type ${type}`);
-                logger_1.default.info(`replacing ${attributeKey}:${attributeValue} with ${attributeKey}Id:${type}`);
-                assortment.assortmentAtts[`${attributeKey}Id`] = type;
-            }
-            else if (property.propertyType === types_1.PropertyType.ObjectReference) {
-                logger_1.default.debug(`found object reference!${attributeKey}${attributeValue}`);
-                let allEntities = [];
-                if (property.referencedTypePath.startsWith('custom-entity')) {
-                    allEntities = await new sdk_1.Entities().get({
-                        entityName: 'custom-entity',
-                        criteria: { typePath: property.referencedTypePath },
-                    });
+            for (const [attributeKey, attributeValue] of Object.entries(attributes)) {
+                const property = assortmentProperties.find((x) => x.slug === attributeKey);
+                // if not a reference
+                if (!property || !property.referencedTypePath) {
+                    continue;
+                }
+                if (property.propertyType === types_1.PropertyType.TypeReference) {
+                    logger_1.default.debug(`found type reference!${attributeKey}${attributeValue}`);
+                    // special case: handle type references
+                    const type = (await new sdk_1.Types().getType({ path: attributeValue }))?.id;
+                    logger_1.default.debug(`found type ${type}`);
+                    logger_1.default.info(`replacing ${attributeKey}:${attributeValue} with ${attributeKey}Id:${type}`);
+                    assortment.assortmentAtts[`${attributeKey}Id`] = type;
                 }
-                else {
-                    allEntities = await new sdk_1.Entities().get({ entityName: property.referencedTypePath });
+                else if (property.propertyType === types_1.PropertyType.ObjectReference) {
+                    logger_1.default.debug(`found object reference!${attributeKey}${attributeValue}`);
+                    let allEntities = [];
+                    if (property.referencedTypePath.startsWith('custom-entity')) {
+                        allEntities = await new sdk_1.Entities().get({
+                            entityName: 'custom-entity',
+                            criteria: { typePath: property.referencedTypePath },
+                        });
+                    }
+                    else {
+                        allEntities = await new sdk_1.Entities().get({ entityName: property.referencedTypePath });
+                    }
+                    // special case: handle type references
+                    const foundAttribute = allEntities.find((x) => x.name === attributeValue)?.id ?? attributeKey;
+                    logger_1.default.debug(`found attribute ${foundAttribute}`);
+                    logger_1.default.info(`replacing ${attributeKey}:${attributeValue} with ${attributeKey}Id:${foundAttribute}`);
+                    assortment.assortmentAtts[`${attributeKey}Id`] = foundAttribute;
                 }
-                // special case: handle type references
-                const foundAttribute = allEntities.find((x) => x.name === attributeValue)?.id ?? attributeKey;
-                logger_1.default.debug(`found attribute ${foundAttribute}`);
-                logger_1.default.info(`replacing ${attributeKey}:${attributeValue} with ${attributeKey}Id:${foundAttribute}`);
-                assortment.assortmentAtts[`${attributeKey}Id`] = foundAttribute;
             }
-        }
+        }));
+        await Promise.all(promises);
     }
 }

package/dist/commands/types/mergeOptionSets.js

@@ -55,6 +55,7 @@ async function mergeOptionSets(fileLocation) {
     const currentOptionSets = currentOptionSetsFull.map((os) => Object.assign({}, {
         name: os.name,
         isArchived: os.isArchived,
+        slug: os.slug,
         optionSet: os.optionSet,
     }));
     const currentOptionSetsByName = {};
@@ -101,9 +102,10 @@ function mergeOptionSet(existingOptionSet, uploadedOptionSet) {
         for (const keyVal of existingOptionSet.optionSet) {
             const value = keyVal.value;
             const display = keyVal.display;
+            const disabled = keyVal?.disabled;
             const found = merged.optionSet.find((keyVal) => keyVal.value === value);
             if (!found) {
-                merged.optionSet.push({ value, display });
+                merged.optionSet.push({ value, display, disabled });
             }
         }
     }

package/dist/commands/types/parseOptionSetsLocalFiles.d.ts

@@ -18,18 +18,20 @@ export declare function ParseOptionSetsToFolderStructure(args: any): Promise<voi
  */
 export declare function parseLabelsInColumn(uploadedOptionData: any): any[];
 /**
- * Expects a CSV file with an ignored header file and 3 columns:
+ * Expects a CSV file with an ignored header file and 4 columns:
  *  The first column contains the option set name (e.g. Gender)
  *  The second column contains the option keys (e.g. ge_men)
- *  The second column contains the option display label (e.g. Men)
+ *  The third column contains the option display label (e.g. Men)
+ *  The fourth column contains the disabled value (e.g. true / false)
  *
  * Sample file
- * ignored header 1, ignored header 2, ignored header 3
- * Gender, ge_men, Men
- * Gender, ge_women, Women
- * Brand, b_prada, Prada
- * Brand, b_coach, Coach
+ * ignored header 1, ignored header 2, ignored header 3, ignored header 4
+ * Gender, ge_men, Men, true
+ * Gender, ge_women, Women, false
+ * Brand, b_prada, Prada, true
+ * Brand, b_coach, Coach, true
  * @param uploadedOptionData
  * @returns
  */
 export declare function parseNameAndLabelAndKey(uploadedOptionData: any[]): any[];
+export declare function parseDisabledValue(stringValue: string): boolean;

package/dist/commands/types/parseOptionSetsLocalFiles.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseNameAndLabelAndKey = exports.parseLabelsInColumn = exports.ParseOptionSetsToFolderStructure = void 0;
+exports.parseDisabledValue = exports.parseNameAndLabelAndKey = exports.parseLabelsInColumn = exports.ParseOptionSetsToFolderStructure = void 0;
 const tslib_1 = require("tslib");
 const path = tslib_1.__importStar(require("path"));
 const fs_1 = tslib_1.__importDefault(require("fs"));
@@ -154,7 +154,7 @@ function parseLabelsInColumn(uploadedOptionData) {
         const uniqueOptionSetValues = new Set();
         for (const data of uploadedOptionData) {
             const label = data[optionSetName];
-            uniqueOptionSetValues.add(label);
+            uniqueOptionSetValues.add(label.toString()); // Parse the value to string
         }
         const optionSet = [];
         if (uniqueOptionSetValues) {
@@ -180,17 +180,18 @@ function parseLabelsInColumn(uploadedOptionData) {
 }
 exports.parseLabelsInColumn = parseLabelsInColumn;
 /**
- * Expects a CSV file with an ignored header file and 3 columns:
+ * Expects a CSV file with an ignored header file and 4 columns:
  *  The first column contains the option set name (e.g. Gender)
  *  The second column contains the option keys (e.g. ge_men)
- *  The second column contains the option display label (e.g. Men)
+ *  The third column contains the option display label (e.g. Men)
+ *  The fourth column contains the disabled value (e.g. true / false)
  *
  * Sample file
- * ignored header 1, ignored header 2, ignored header 3
- * Gender, ge_men, Men
- * Gender, ge_women, Women
- * Brand, b_prada, Prada
- * Brand, b_coach, Coach
+ * ignored header 1, ignored header 2, ignored header 3, ignored header 4
+ * Gender, ge_men, Men, true
+ * Gender, ge_women, Women, false
+ * Brand, b_prada, Prada, true
+ * Brand, b_coach, Coach, true
  * @param uploadedOptionData
  * @returns
  */
@@ -198,7 +199,7 @@ function parseNameAndLabelAndKey(uploadedOptionData) {
     const optionSets = {};
     for (const csvRow of uploadedOptionData) {
         const row = Object.values(csvRow);
-        if (row.length !== 3 || row.some((x) => !x)) {
+        if (!(row.length === 4 || row.length === 3) || row.some((x) => !x)) {
             console.log('skipping bad row', JSON.stringify(row, null, 2));
             continue;
         }
@@ -208,15 +209,23 @@ function parseNameAndLabelAndKey(uploadedOptionData) {
         }
         const key = row[1];
         const label = row[2];
-        optionSets[optionSetName][key] = label;
+        let disabled = false;
+        if (row.length === 4) {
+            // as bad row is skipped above, testString is always a string
+            const testString = row[3];
+            disabled = parseDisabledValue(testString);
+        }
+        optionSets[optionSetName][key] = { label, disabled };
     }
     const result = [];
     for (const optionSetName of Object.keys(optionSets)) {
         const optionSet = [];
-        for (const [key, value] of Object.entries(optionSets[optionSetName])) {
+        for (const [key, obj] of Object.entries(optionSets[optionSetName])) {
+            const optionObj = obj; // Add type annotation
             optionSet.push({
-                value: key,
-                display: value,
+                value: key.toString(),
+                display: optionObj?.label,
+                disabled: optionObj?.disabled, // Use the type annotated variable
             });
         }
         const reducedOptionSet = {
@@ -230,3 +239,13 @@ function parseNameAndLabelAndKey(uploadedOptionData) {
     return result;
 }
 exports.parseNameAndLabelAndKey = parseNameAndLabelAndKey;
+function parseDisabledValue(stringValue) {
+    const testString = /^true$/i.test(stringValue?.trim());
+    const isDisabledFalse = testString === false;
+    const isDisabledTrue = testString === true;
+    if (!isDisabledFalse && !isDisabledTrue) {
+        console.warn(`Invalid value (${stringValue}) for disabled attribute. Must be either "true" or "false"`);
+    }
+    return isDisabledTrue;
+}
+exports.parseDisabledValue = parseDisabledValue;

package/dist/commands/types/uploadOptionSets.d.ts

@@ -8,3 +8,4 @@ export default class UploadOptionSets extends BaseCommand {
     run(): Promise<void>;
 }
 export declare function uploadOptionSets(dir: string): Promise<void>;
+export declare function parseOptionSetValuesToString(optionSet: any): any;

package/dist/commands/types/uploadOptionSets.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.uploadOptionSets = void 0;
+exports.parseOptionSetValuesToString = exports.uploadOptionSets = void 0;
 const tslib_1 = require("tslib");
 const sdk_1 = require("@contrail/sdk");
 const fs_1 = tslib_1.__importDefault(require("fs"));
@@ -11,6 +11,7 @@ const core_1 = require("@oclif/core");
 const basecommand_1 = require("../../basecommand");
 const logger_1 = tslib_1.__importDefault(require("../../logger"));
 const js_yaml_1 = tslib_1.__importDefault(require("js-yaml"));
+const lodash_1 = require("lodash");
 class UploadOptionSets extends basecommand_1.BaseCommand {
     static description = 'Upload OptionSets for your Org. OptionSets are loaded from .yml files in the option-sets directory.';
     static examples = [
@@ -34,7 +35,7 @@ exports.default = UploadOptionSets;
 async function uploadOptionSets(dir) {
     try {
         const userConfig = await (0, login_1.authUser)();
-        logger_1.default.info(`${chalk_1.default.blue.bold('START')} Getting all types for orgId: ${userConfig.orgId}`);
+        logger_1.default.info(`${chalk_1.default.blue.bold('START')} Getting all types for org ${userConfig.orgSlug}`);
         logger_1.default.info(`${chalk_1.default.yellow.bold('OPTION SETS')} Uploading`);
         await uploadOS(dir);
         logger_1.default.info(`${chalk_1.default.yellow.bold('OPTION SETS')} Uploaded`);
@@ -60,6 +61,17 @@ function loadOptionSets(fromDir) {
         throw new Error(`ERROR PARSING YAML: ${e}`);
     }
 }
+function parseOptionSetValuesToString(optionSet) {
+    return (0, lodash_1.cloneDeepWith)(optionSet, (value) => {
+        // If the value is an object or array, let cloneDeepWith handle it
+        if ((0, lodash_1.isObject)(value) || (0, lodash_1.isArray)(value)) {
+            return undefined;
+        }
+        // Otherwise, convert the value to string
+        return String(value);
+    });
+}
+exports.parseOptionSetValuesToString = parseOptionSetValuesToString;
 async function uploadOS(dir) {
     const optionSets = loadOptionSets(dir);
     const currentOptionSets = await new sdk_1.Entities().get({
@@ -83,18 +95,20 @@ async function uploadOS(dir) {
                     logger_1.default.info(`No OptionSet for: ${optionSet.slug}`);
                     continue;
                 }
-                logger_1.default.info(`Creating: ${JSON.stringify(optionSet, null, 2)}`);
+                const parsedOptionSet = parseOptionSetValuesToString(optionSet.optionSet);
+                logger_1.default.info(`Creating: ${JSON.stringify(parsedOptionSet, null, 2)}`);
                 await new sdk_1.Entities().create({
                     entityName: 'type-property-option-set',
                     object: {
                         name: optionSet.name,
                         slug: optionSet.slug,
-                        optionSet: optionSet.optionSet,
+                        optionSet: parsedOptionSet,
                         isArchived: optionSet.isArchived,
                     },
                 });
             }
             else {
+                const parsedOptionSet = parseOptionSetValuesToString(optionSet.optionSet);
                 logger_1.default.info(`Updating: ${optionSet.slug}`);
                 await new sdk_1.Entities().update({
                     entityName: 'type-property-option-set',
@@ -102,7 +116,7 @@ async function uploadOS(dir) {
                     object: {
                         name: optionSet.name,
                         slug: optionSet.slug,
-                        optionSet: optionSet.optionSet,
+                        optionSet: parsedOptionSet,
                         isArchived: optionSet.isArchived,
                     },
                 });
@@ -112,19 +126,18 @@ async function uploadOS(dir) {
             logger_1.default.error(`Error Uploading OptionSets: ${err}`);
         }
     }
-    for (const currentOptionSet of currentOptionSets) {
-        try {
-            const found = newOptionSetsBySlug[currentOptionSet.slug];
-            if (!found) {
-                logger_1.default.info(`Deleting: ${currentOptionSet.slug}`);
-                await new sdk_1.Entities().delete({
-                    entityName: 'type-property-option-set',
-                    id: currentOptionSet.id,
-                });
-            }
-        }
-        catch (err) {
-            logger_1.default.error(`Error Deleting OptionSets: ${err}`);
-        }
-    }
+    // for (const currentOptionSet of currentOptionSets) {
+    //   try {
+    //     const found = newOptionSetsBySlug[currentOptionSet.slug];
+    //     if (!found) {
+    //       logger.info(`Deleting: ${currentOptionSet.slug}`);
+    //       await new Entities().delete({
+    //         entityName: 'type-property-option-set',
+    //         id: currentOptionSet.id,
+    //       });
+    //     }
+    //   } catch (err) {
+    //     logger.error(`Error Deleting OptionSets: ${err}`);
+    //   }
+    // }
 }

package/dist/helpers/projects/helpers.js

@@ -8,6 +8,9 @@ const fs_1 = tslib_1.__importDefault(require("fs"));
 const sdk_1 = require("@contrail/sdk");
 const util_1 = require("@contrail/util");
 const logger_1 = tslib_1.__importDefault(require("../../logger"));
+const uuid_1 = require("uuid");
+const pLimit = require('p-limit');
+const limit = pLimit(30);
 function getProjectFile(fileName) {
     const CURRENT_DIR = process.cwd();
     try {
@@ -52,7 +55,7 @@ async function getAssortmentsAndSubFolders(parentId, assortments, subFolders, al
             workspaceId: parentId,
         },
     });
-    const integrationAssortments = workspaceAssortments; //?.filter(a => a.assortmentType === 'INTEGRATION');
+    const integrationAssortments = workspaceAssortments.filter((x) => x.assortmentType !== 'BACKING'); //?.filter(a => a.assortmentType === 'INTEGRATION');
     if (integrationAssortments?.length > 0) {
         allAssortments.push(...integrationAssortments);
         for (const a of integrationAssortments) {
@@ -60,7 +63,7 @@ async function getAssortmentsAndSubFolders(parentId, assortments, subFolders, al
             deleteNonUserKeys(integrationAssortmentsCopy);
             const assortmentType = a.assortmentType === 'INTEGRATION' ? 'ASSORTMENT' : a.assortmentType;
             const converted = {
-                identifier: a.identifier,
+                identifier: a.identifier ?? `${a.name}_${(0, uuid_1.v4)()}.assortment`,
                 name: a.name,
                 type: assortmentType,
                 sourceAssortmentIdentifier: [],
@@ -82,20 +85,18 @@ async function getAssortmentsAndSubFolders(parentId, assortments, subFolders, al
         relations: ['entity'],
     });
     const workspaceFolders = workspaceFolderLinks?.map((wfl) => wfl.entity);
-    if (workspaceFolders?.length > 0) {
-        for (const folder of workspaceFolders) {
-            const converted = {
-                identifier: folder.identifier,
-                name: folder.name,
-                principals: [],
-                assortments: [],
-                subFolders: [],
-            };
-            converted.principals = await getFolderPrincipals(folder);
-            await getAssortmentsAndSubFolders(folder.id, converted.assortments, converted.subFolders, allAssortments);
-            subFolders.push(converted);
-        }
-    }
+    await Promise.all((workspaceFolders ?? [])?.map((folder) => limit(async () => {
+        const converted = {
+            identifier: folder.identifier ?? `${folder.name}_${(0, uuid_1.v4)()}.folder`,
+            name: folder.name,
+            principals: [],
+            assortments: [],
+            subFolders: [],
+        };
+        converted.principals = await getFolderPrincipals(folder);
+        await getAssortmentsAndSubFolders(folder.id, converted.assortments, converted.subFolders, allAssortments);
+        subFolders.push(converted);
+    })));
 }
 function convertRelationshipsInFolders(folder, allAssortments) {
     if (!(allAssortments.length > 0)) {
@@ -159,6 +160,10 @@ function deleteNonUserKeys(assortment) {
     delete assortment.updatedById;
     delete assortment.updatedOn;
     delete assortment.workspaceId;
+    delete assortment.itemTypeId;
+    if (assortment.itemType && typeof assortment.itemType === 'object') {
+        assortment.itemType = assortment.itemType?.typePath;
+    }
 }
 function saveData(data, name) {
     const yamlStr = js_yaml_1.default.dump(data);

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

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

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/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;

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"

package/oclif.manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "2.3.4",
+  "version": "2.3.5",
   "commands": {
     "app:create": {
       "id": "app:create",
@@ -537,7 +537,14 @@
       "examples": [
         "$ contrail project load <TEMPLATE_FILE_LOCATION>\n"
       ],
-      "flags": {},
+      "flags": {
+        "dumpTransformedFile": {
+          "name": "dumpTransformedFile",
+          "type": "boolean",
+          "description": "If set to true, stores a transformed version of the template file",
+          "allowNo": false
+        }
+      },
       "args": {
         "templateFileLocation": {
           "name": "templateFileLocation",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contrail/cli",
-  "version": "2.3.4",
+  "version": "2.3.5",
   "description": "VibeIQ's Contrail Platform CLI.",
   "bin": {
     "contrail-cli": "./bin/run",