@contrail/cli 3.4.5 → 3.4.6-alpha.cffb28e

package/node_modules/@contrail/loader/lib/common/conditional-columns.spec.js

@@ -0,0 +1,644 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const conditional_columns_1 = require("./conditional-columns");
+describe('Conditional-Columns', () => {
+    describe('evaluateColumnDefinitionsOnBatch', () => {
+        it('should not add anything with no conditions, fromProperty, or default', async () => {
+            const data = [
+                {
+                    btpString: 'btp',
+                    styleNumber: 1,
+                    booleanProp: false,
+                    optionalString: '123',
+                },
+                {
+                    btpString: 'btp2',
+                    styleNumber: 2,
+                    booleanProp: true,
+                },
+            ];
+            const columnDefinition = {
+                toProperty: 'newProp',
+            };
+            conditional_columns_1.ColumnDefinitionEvaluator.evaluateColumnDefinitionsOnBatch([columnDefinition], data);
+            expect(data[0].newProp).toBeFalsy();
+        });
+        it('should use default value with no conditions or fromProperty', async () => {
+            const data = [
+                {
+                    btpString: 'btp',
+                    styleNumber: 1,
+                    booleanProp: false,
+                    optionalString: '123',
+                },
+                {
+                    btpString: 'btp2',
+                    styleNumber: 2,
+                    booleanProp: true,
+                },
+            ];
+            const columnDefinition = {
+                toProperty: 'newProp',
+                default: 'color',
+            };
+            conditional_columns_1.ColumnDefinitionEvaluator.evaluateColumnDefinitionsOnBatch([columnDefinition], data);
+            expect(data[0].newProp).toEqual('color');
+            expect(data[1].newProp).toEqual('color');
+        });
+        it('should use default value with no conditions and undefined fromProperty value', async () => {
+            const data = [
+                {
+                    btpString: 'btp',
+                    styleNumber: 1,
+                    booleanProp: false,
+                    optionalString: '123',
+                },
+                {
+                    btpString: 'btp2',
+                    styleNumber: 2,
+                    booleanProp: true,
+                },
+            ];
+            const columnDefinition = {
+                toProperty: 'newProp',
+                fromProperty: 'badProperty',
+                default: 'color',
+            };
+            conditional_columns_1.ColumnDefinitionEvaluator.evaluateColumnDefinitionsOnBatch([columnDefinition], data);
+            expect(data[0].newProp).toEqual('color');
+            expect(data[1].newProp).toEqual('color');
+        });
+        it('should use fromProperty value with no conditions and undefined default value', async () => {
+            const data = [
+                {
+                    btpString: 'btp',
+                    styleNumber: 1,
+                    booleanProp: false,
+                    optionalString: '123',
+                },
+                {
+                    btpString: 'btp2',
+                    styleNumber: 2,
+                    booleanProp: true,
+                },
+            ];
+            const columnDefinition = {
+                toProperty: 'newProp',
+                fromProperty: 'btpString',
+            };
+            conditional_columns_1.ColumnDefinitionEvaluator.evaluateColumnDefinitionsOnBatch([columnDefinition], data);
+            expect(data[0].newProp).toEqual('btp');
+            expect(data[1].newProp).toEqual('btp2');
+        });
+        it('should use fromProperty value with no conditions and defined default value when fromProperty has value', async () => {
+            const data = [
+                {
+                    btpString: 'btp',
+                    styleNumber: 1,
+                    booleanProp: false,
+                    optionalString: '123',
+                },
+                {
+                    btpString: 'btp2',
+                    styleNumber: 2,
+                    booleanProp: true,
+                },
+            ];
+            const columnDefinition = {
+                toProperty: 'newProp',
+                fromProperty: 'btpString',
+                default: 'color',
+            };
+            conditional_columns_1.ColumnDefinitionEvaluator.evaluateColumnDefinitionsOnBatch([columnDefinition], data);
+            expect(data[0].newProp).toEqual('btp');
+            expect(data[1].newProp).toEqual('btp2');
+        });
+        it('should do nothing with conditions had dont hit and no default', async () => {
+            const data = [
+                {
+                    btpString: 'btp',
+                    styleNumber: 1,
+                    booleanProp: false,
+                    optionalString: '123',
+                },
+                {
+                    btpString: 'btp2',
+                    styleNumber: 2,
+                    booleanProp: true,
+                },
+            ];
+            const columnDefinition = {
+                toProperty: 'newProp',
+                conditions: [
+                    {
+                        conditional: '{btpString} === "nope"',
+                        value: 'shouldNotBeUsed',
+                    },
+                ],
+            };
+            conditional_columns_1.ColumnDefinitionEvaluator.evaluateColumnDefinitionsOnBatch([columnDefinition], data);
+            expect(data[0].newProp).toBeFalsy();
+            expect(data[1].newProp).toBeFalsy();
+        });
+        it('should parse empty string as false', async () => {
+            const data = [
+                {
+                    btpString: '',
+                    styleNumber: 2,
+                    booleanProp: true,
+                },
+                {
+                    btpString: 'something',
+                    styleNumber: 2,
+                    booleanProp: true,
+                },
+            ];
+            const columnDefinition = {
+                toProperty: 'newProp',
+                conditions: [
+                    {
+                        conditional: '{btpString}',
+                        value: '{btpString}',
+                    },
+                    {
+                        conditional: '!{btpString}',
+                        value: '{styleNumber}',
+                    },
+                ],
+                default: '${styleNumber}',
+            };
+            conditional_columns_1.ColumnDefinitionEvaluator.evaluateColumnDefinitionsOnBatch([columnDefinition], data);
+            expect(data[0].newProp).toBe(2);
+            expect(data[1].newProp).toBe('something');
+        });
+        it('should use default with conditions had dont hit', async () => {
+            const data = [
+                {
+                    btpString: 'btp',
+                    styleNumber: 1,
+                    booleanProp: false,
+                    optionalString: '123',
+                },
+                {
+                    btpString: 'btp2',
+                    styleNumber: 2,
+                    booleanProp: true,
+                },
+            ];
+            const columnDefinition = {
+                toProperty: 'newProp',
+                conditions: [
+                    {
+                        conditional: '{btpString} === "nope"',
+                        value: 'shouldNotBeUsed',
+                    },
+                ],
+                default: 'color',
+            };
+            conditional_columns_1.ColumnDefinitionEvaluator.evaluateColumnDefinitionsOnBatch([columnDefinition], data);
+            expect(data[0].newProp).toBe('color');
+            expect(data[1].newProp).toBe('color');
+        });
+        it('should use value with first condition that hits - string equals', async () => {
+            const data = [
+                {
+                    btpString: 'btp',
+                    styleNumber: 1,
+                    booleanProp: false,
+                    optionalString: '123',
+                },
+                {
+                    btpString: 'btp2',
+                    styleNumber: 2,
+                    booleanProp: true,
+                },
+            ];
+            const columnDefinition = {
+                toProperty: 'newProp',
+                conditions: [
+                    {
+                        conditional: '{btpString} === "nope"',
+                        value: 'shouldBeUsed',
+                    },
+                    {
+                        conditional: '{btpString} === "btp"',
+                        value: 'shouldBeUsed',
+                    },
+                ],
+                default: 'color',
+            };
+            conditional_columns_1.ColumnDefinitionEvaluator.evaluateColumnDefinitionsOnBatch([columnDefinition], data);
+            expect(data[0].newProp).toBe('shouldBeUsed');
+            expect(data[1].newProp).toBe('color');
+        });
+        it('should use value with first condition that hits - boolean equals - 1', async () => {
+            const data = [
+                {
+                    btpString: 'btp',
+                    styleNumber: 1,
+                    booleanProp: false,
+                    optionalString: '123',
+                },
+                {
+                    btpString: 'btp2',
+                    styleNumber: 2,
+                    booleanProp: true,
+                },
+            ];
+            const columnDefinition = {
+                toProperty: 'newProp',
+                conditions: [
+                    {
+                        conditional: '{booleanProp}',
+                        value: 'shouldBeUsed',
+                    },
+                    {
+                        conditional: '{booleanProp}',
+                        value: 'shouldBeUsed2',
+                    },
+                ],
+                default: 'color',
+            };
+            conditional_columns_1.ColumnDefinitionEvaluator.evaluateColumnDefinitionsOnBatch([columnDefinition], data);
+            expect(data[0].newProp).toBe('color');
+            expect(data[1].newProp).toBe('shouldBeUsed');
+        });
+        it('should use value with first condition that hits - boolean equals - 2', async () => {
+            const data = [
+                {
+                    btpString: 'btp',
+                    styleNumber: 1,
+                    booleanProp: false,
+                    optionalString: '123',
+                },
+                {
+                    btpString: 'btp2',
+                    styleNumber: 2,
+                    booleanProp: true,
+                },
+            ];
+            const columnDefinition = {
+                toProperty: 'newProp',
+                conditions: [
+                    {
+                        conditional: '{booleanProp} === false',
+                        value: 'shouldBeUsed',
+                    },
+                    {
+                        conditional: '{booleanProp} === false',
+                        value: 'shouldBeUsed2',
+                    },
+                ],
+                default: 'color',
+            };
+            conditional_columns_1.ColumnDefinitionEvaluator.evaluateColumnDefinitionsOnBatch([columnDefinition], data);
+            expect(data[0].newProp).toBe('shouldBeUsed');
+            expect(data[1].newProp).toBe('color');
+        });
+        it('should use value with first condition that hits - number greater than', async () => {
+            const data = [
+                {
+                    btpString: 'btp',
+                    styleNumber: 1,
+                    booleanProp: false,
+                    optionalString: '123',
+                },
+                {
+                    btpString: 'btp2',
+                    styleNumber: 20,
+                    booleanProp: true,
+                },
+            ];
+            const columnDefinition = {
+                toProperty: 'newProp',
+                conditions: [
+                    {
+                        conditional: '{styleNumber} < 10',
+                        value: 'shouldBeUsed1',
+                    },
+                    {
+                        conditional: '{styleNumber} === 20',
+                        value: 'shouldBeUsed2',
+                    },
+                ],
+                default: 'color',
+            };
+            conditional_columns_1.ColumnDefinitionEvaluator.evaluateColumnDefinitionsOnBatch([columnDefinition], data);
+            expect(data[0].newProp).toBe('shouldBeUsed1');
+            expect(data[1].newProp).toBe('shouldBeUsed2');
+        });
+        it('should use value with first condition that hits - using column as value', async () => {
+            const data = [
+                {
+                    btpString: 'btp',
+                    styleNumber: 1,
+                    booleanProp: false,
+                    optionalString: '123',
+                },
+                {
+                    btpString: 'btp2',
+                    styleNumber: 20,
+                    booleanProp: true,
+                },
+            ];
+            const columnDefinition = {
+                toProperty: 'newProp',
+                conditions: [
+                    {
+                        conditional: '{styleNumber} < 10',
+                        value: '{styleNumber}',
+                    },
+                    {
+                        conditional: '{styleNumber} === 20',
+                        value: '{booleanProp}',
+                    },
+                ],
+                default: 'color',
+            };
+            conditional_columns_1.ColumnDefinitionEvaluator.evaluateColumnDefinitionsOnBatch([columnDefinition], data);
+            expect(data[0].newProp).toBe(1);
+            expect(data[1].newProp).toBe(true);
+        });
+        it('should use value with first condition that hits - using column as value with operations', async () => {
+            const data = [
+                {
+                    btpString: 'btp',
+                    styleNumber: 1,
+                    booleanProp: false,
+                    optionalString: '123',
+                    style: 'fam1-01',
+                },
+                {
+                    btpString: 'btp2',
+                    styleNumber: 20,
+                    booleanProp: true,
+                },
+            ];
+            const columnDefinition = {
+                toProperty: 'newProp',
+                conditions: [
+                    {
+                        conditional: '{styleNumber} < 10',
+                        value: '{style}.split("-")[0]',
+                    },
+                ],
+                default: 'color',
+            };
+            conditional_columns_1.ColumnDefinitionEvaluator.evaluateColumnDefinitionsOnBatch([columnDefinition], data);
+            expect(data[0].newProp).toBe('fam1');
+        });
+        it('should use default - using column as value with operations', async () => {
+            const data = [
+                {
+                    btpString: 'btp',
+                    styleNumber: 1,
+                    booleanProp: false,
+                    optionalString: '123',
+                    style: 'fam1-01',
+                },
+                {
+                    btpString: 'btp2',
+                    styleNumber: 20,
+                    booleanProp: true,
+                },
+            ];
+            const columnDefinition = {
+                toProperty: 'newProp',
+                default: '{style}.split("-")[0]',
+            };
+            conditional_columns_1.ColumnDefinitionEvaluator.evaluateColumnDefinitionsOnBatch([columnDefinition], data);
+            expect(data[0].newProp).toBe('fam1');
+        });
+        it('should use default value when default is boolean false', async () => {
+            const data = [
+                {
+                    btpString: 'btp',
+                    styleNumber: 1,
+                },
+                {
+                    btpString: 'btp2',
+                    styleNumber: 2,
+                },
+            ];
+            const columnDefinition = {
+                toProperty: 'dropField',
+                default: false,
+            };
+            conditional_columns_1.ColumnDefinitionEvaluator.evaluateColumnDefinitionsOnBatch([columnDefinition], data);
+            expect(data[0].dropField).toBe(false);
+            expect(data[1].dropField).toBe(false);
+        });
+        it('should use default value when default is string "false"', async () => {
+            const data = [
+                {
+                    btpString: 'btp',
+                    styleNumber: 1,
+                },
+                {
+                    btpString: 'btp2',
+                    styleNumber: 2,
+                },
+            ];
+            const columnDefinition = {
+                toProperty: 'dropField',
+                default: 'false',
+            };
+            conditional_columns_1.ColumnDefinitionEvaluator.evaluateColumnDefinitionsOnBatch([columnDefinition], data);
+            expect(data[0].dropField).toBe('false');
+            expect(data[1].dropField).toBe('false');
+        });
+        it('should use default value when default is number 0', async () => {
+            const data = [
+                {
+                    btpString: 'btp',
+                    styleNumber: 1,
+                },
+                {
+                    btpString: 'btp2',
+                    styleNumber: 2,
+                },
+            ];
+            const columnDefinition = {
+                toProperty: 'count',
+                default: 0,
+            };
+            conditional_columns_1.ColumnDefinitionEvaluator.evaluateColumnDefinitionsOnBatch([columnDefinition], data);
+            expect(data[0].count).toBe(0);
+            expect(data[1].count).toBe(0);
+        });
+        it('should use default value when default is empty string', async () => {
+            const data = [
+                {
+                    btpString: 'btp',
+                    styleNumber: 1,
+                },
+                {
+                    btpString: 'btp2',
+                    styleNumber: 2,
+                },
+            ];
+            const columnDefinition = {
+                toProperty: 'description',
+                default: '',
+            };
+            conditional_columns_1.ColumnDefinitionEvaluator.evaluateColumnDefinitionsOnBatch([columnDefinition], data);
+            expect(data[0].description).toBe('');
+            expect(data[1].description).toBe('');
+        });
+        it('should use default false when conditions dont hit', async () => {
+            const data = [
+                {
+                    btpString: 'btp',
+                    styleNumber: 1,
+                },
+                {
+                    btpString: 'btp2',
+                    styleNumber: 2,
+                },
+            ];
+            const columnDefinition = {
+                toProperty: 'isPremium',
+                conditions: [
+                    {
+                        conditional: '{styleNumber} > 100',
+                        value: 'true',
+                    },
+                ],
+                default: false,
+            };
+            conditional_columns_1.ColumnDefinitionEvaluator.evaluateColumnDefinitionsOnBatch([columnDefinition], data);
+            expect(data[0].isPremium).toBe(false);
+            expect(data[1].isPremium).toBe(false);
+        });
+        it('should use default 0 when conditions dont hit', async () => {
+            const data = [
+                {
+                    btpString: 'btp',
+                    styleNumber: 1,
+                },
+                {
+                    btpString: 'btp2',
+                    styleNumber: 2,
+                },
+            ];
+            const columnDefinition = {
+                toProperty: 'discount',
+                conditions: [
+                    {
+                        conditional: '{styleNumber} > 100',
+                        value: '50',
+                    },
+                ],
+                default: 0,
+            };
+            conditional_columns_1.ColumnDefinitionEvaluator.evaluateColumnDefinitionsOnBatch([columnDefinition], data);
+            expect(data[0].discount).toBe(0);
+            expect(data[1].discount).toBe(0);
+        });
+        it('should use default empty string when conditions dont hit', async () => {
+            const data = [
+                {
+                    btpString: 'btp',
+                    styleNumber: 1,
+                },
+                {
+                    btpString: 'btp2',
+                    styleNumber: 2,
+                },
+            ];
+            const columnDefinition = {
+                toProperty: 'notes',
+                conditions: [
+                    {
+                        conditional: '{styleNumber} > 100',
+                        value: 'Premium item',
+                    },
+                ],
+                default: '',
+            };
+            conditional_columns_1.ColumnDefinitionEvaluator.evaluateColumnDefinitionsOnBatch([columnDefinition], data);
+            expect(data[0].notes).toBe('');
+            expect(data[1].notes).toBe('');
+        });
+        it('should use fromProperty value even when it is falsy (0) instead of default', async () => {
+            const data = [
+                {
+                    count: 0,
+                    styleNumber: 1,
+                },
+                {
+                    count: 5,
+                    styleNumber: 2,
+                },
+            ];
+            const columnDefinition = {
+                toProperty: 'quantity',
+                fromProperty: 'count',
+                default: 100,
+            };
+            conditional_columns_1.ColumnDefinitionEvaluator.evaluateColumnDefinitionsOnBatch([columnDefinition], data);
+            expect(data[0].quantity).toBe(0);
+            expect(data[1].quantity).toBe(5);
+        });
+        it('should use fromProperty value even when it is falsy (false) instead of default', async () => {
+            const data = [
+                {
+                    active: false,
+                    styleNumber: 1,
+                },
+                {
+                    active: true,
+                    styleNumber: 2,
+                },
+            ];
+            const columnDefinition = {
+                toProperty: 'isActive',
+                fromProperty: 'active',
+                default: true,
+            };
+            conditional_columns_1.ColumnDefinitionEvaluator.evaluateColumnDefinitionsOnBatch([columnDefinition], data);
+            expect(data[0].isActive).toBe(false);
+            expect(data[1].isActive).toBe(true);
+        });
+        it('should use default when fromProperty is null', async () => {
+            const data = [
+                {
+                    name: null,
+                    styleNumber: 1,
+                },
+                {
+                    name: 'Test',
+                    styleNumber: 2,
+                },
+            ];
+            const columnDefinition = {
+                toProperty: 'displayName',
+                fromProperty: 'name',
+                default: false,
+            };
+            conditional_columns_1.ColumnDefinitionEvaluator.evaluateColumnDefinitionsOnBatch([columnDefinition], data);
+            expect(data[0].displayName).toBe(false);
+            expect(data[1].displayName).toBe('Test');
+        });
+        it('should use default when fromProperty is empty string', async () => {
+            const data = [
+                {
+                    name: '',
+                    styleNumber: 1,
+                },
+                {
+                    name: 'Test',
+                    styleNumber: 2,
+                },
+            ];
+            const columnDefinition = {
+                toProperty: 'displayName',
+                fromProperty: 'name',
+                default: 0,
+            };
+            conditional_columns_1.ColumnDefinitionEvaluator.evaluateColumnDefinitionsOnBatch([columnDefinition], data);
+            expect(data[0].displayName).toBe(0);
+            expect(data[1].displayName).toBe('Test');
+        });
+    });
+});

package/node_modules/@contrail/loader/lib/common/constants.d.ts

@@ -0,0 +1 @@
+export declare const FALSY_VALUES: Set<string>;

package/node_modules/@contrail/loader/lib/common/constants.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FALSY_VALUES = void 0;
+exports.FALSY_VALUES = new Set(['false', 'no', 'n', '0']);

package/node_modules/@contrail/loader/lib/common/csv-file-helper.d.ts

@@ -0,0 +1,6 @@
+import { EntitiesClient } from '@contrail/entity-types';
+export declare function getCSVFromFile(loadFileId: string, client: EntitiesClient): Promise<any[]>;
+export declare function parseCSVData(data: string): any[];
+export declare class InvalidCSVError extends Error {
+    constructor(message: string);
+}