@contrail/cli 3.4.3 → 3.4.4-alpha.1

package/dist/commands/types/uploadUsageInfo.spec.js

@@ -1,249 +1,249 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-const uploadUsageInfo_1 = require("./uploadUsageInfo");
-const logger_1 = tslib_1.__importDefault(require("../../logger"));
-// Mock the logger
-jest.mock('../../logger', () => ({
-    error: jest.fn(),
-    info: jest.fn(),
-    debug: jest.fn(),
-}));
-describe('transformReducedUsageInfoToTypeIdsFromPath', () => {
-    const mockTypes = [
-        {
-            id: 'type-123',
-            typePath: 'product/clothing',
-            typeProperties: [
-                {
-                    id: 'prop-456',
-                    slug: 'color',
-                },
-                {
-                    id: 'prop-789',
-                    slug: 'size',
-                },
-            ],
-        },
-        {
-            id: 'type-abc',
-            typePath: 'product/electronics',
-            typeProperties: [
-                {
-                    id: 'prop-def',
-                    slug: 'brand',
-                },
-            ],
-        },
-    ];
-    beforeEach(() => {
-        jest.clearAllMocks();
-    });
-    it('should successfully transform a valid reducedUsageInfo object', () => {
-        const reducedUsageInfo = {
-            typePath: 'product/clothing',
-            typePropertySlug: 'color',
-            editable: true,
-            used: true,
-            label: 'Color',
-            extraProperty: 'should be removed',
-        };
-        const result = (0, uploadUsageInfo_1.transformReducedUsageInfoToTypeIdsFromPath)(reducedUsageInfo, mockTypes);
-        expect(result).toBeDefined();
-        expect(result.typeId).toBe('type-123');
-        expect(result.typePropertyId).toBe('prop-456');
-        expect(result.extraProperty).toBeUndefined();
-        expect(result.editable).toBe(true);
-        expect(result.used).toBe(true);
-        expect(result.label).toBe('Color');
-        // Verify original object is not mutated
-        expect(reducedUsageInfo.typeId).toBeUndefined();
-        expect(reducedUsageInfo.typePropertyId).toBeUndefined();
-    });
-    it('should return undefined when type is not found', () => {
-        const reducedUsageInfo = {
-            typePath: 'product/nonexistent',
-            typePropertySlug: 'color',
-            editable: true,
-        };
-        const result = (0, uploadUsageInfo_1.transformReducedUsageInfoToTypeIdsFromPath)(reducedUsageInfo, mockTypes);
-        expect(result).toBeUndefined();
-        expect(logger_1.default.error).toHaveBeenCalledWith(expect.stringContaining('Could not find type with typePath product/nonexistent'));
-        // Verify original object is not mutated
-        expect(reducedUsageInfo.typeId).toBeUndefined();
-        expect(reducedUsageInfo.typePropertyId).toBeUndefined();
-    });
-    it('should return undefined when type property is not found', () => {
-        const reducedUsageInfo = {
-            typePath: 'product/clothing',
-            typePropertySlug: 'nonexistent-property',
-            editable: true,
-        };
-        const result = (0, uploadUsageInfo_1.transformReducedUsageInfoToTypeIdsFromPath)(reducedUsageInfo, mockTypes);
-        expect(result).toBeUndefined();
-        expect(logger_1.default.error).toHaveBeenCalledWith(expect.stringContaining('Could not find type property with slug nonexistent-property'));
-        // Verify original object is not mutated
-        expect(reducedUsageInfo.typeId).toBeUndefined();
-        expect(reducedUsageInfo.typePropertyId).toBeUndefined();
-    });
-    it('should exclude properties not in persistReducedUsageInfoFields', () => {
-        const reducedUsageInfo = {
-            typePath: 'product/clothing',
-            typePropertySlug: 'color',
-            editable: true,
-            used: false,
-            formulaFunction: 'someFormula',
-            extraField1: 'value1',
-            extraField2: 'value2',
-            randomProperty: 123,
-        };
-        const result = (0, uploadUsageInfo_1.transformReducedUsageInfoToTypeIdsFromPath)(reducedUsageInfo, mockTypes);
-        expect(result).toBeDefined();
-        expect(result.extraField1).toBeUndefined();
-        expect(result.extraField2).toBeUndefined();
-        expect(result.randomProperty).toBeUndefined();
-        expect(result.editable).toBeDefined();
-        expect(result.used).toBeDefined();
-        expect(result.formulaFunction).toBeDefined();
-    });
-    it('should preserve all valid persistReducedUsageInfoFields', () => {
-        const reducedUsageInfo = {
-            typePath: 'product/electronics',
-            typePropertySlug: 'brand',
-            editable: true,
-            used: true,
-            formulaFunction: 'formula',
-            validationFunction: 'validation',
-            numberFormat: '0.00',
-            defaultValue: 'default',
-            label: 'Brand',
-            required: true,
-            searchable: true,
-            isUniqueProperty: false,
-            isUniquePropertyInFamily: false,
-            copyBehavior: 'copy',
-            copyDefault: true,
-            propertyLevel: 'instance',
-            isArchived: false,
-            shouldBeRemoved: 'extra',
-            isFederationProperty: false,
-            carryOverBehavior: 'carry',
-            carryOverDefault: 'default',
-        };
-        const result = (0, uploadUsageInfo_1.transformReducedUsageInfoToTypeIdsFromPath)(reducedUsageInfo, mockTypes);
-        expect(result).toBeDefined();
-        expect(result.typeId).toBe('type-abc');
-        expect(result.typePropertyId).toBe('prop-def');
-        expect(result.shouldBeRemoved).toBeUndefined();
-        // Verify all valid fields are preserved
-        uploadUsageInfo_1.persistReducedUsageInfoFields.forEach((field) => {
-            expect(result[field]).toBeDefined();
-        });
-    });
-    it('should return undefined for empty types array', () => {
-        const reducedUsageInfo = {
-            typePath: 'product/clothing',
-            typePropertySlug: 'color',
-            editable: true,
-        };
-        const result = (0, uploadUsageInfo_1.transformReducedUsageInfoToTypeIdsFromPath)(reducedUsageInfo, []);
-        expect(result).toBeUndefined();
-        expect(logger_1.default.error).toHaveBeenCalled();
-    });
-    it('should return undefined for type with empty typeProperties array', () => {
-        const typesWithEmptyProps = [
-            {
-                id: 'type-123',
-                typePath: 'product/clothing',
-                typeProperties: [],
-            },
-        ];
-        const reducedUsageInfo = {
-            typePath: 'product/clothing',
-            typePropertySlug: 'color',
-            editable: true,
-        };
-        const result = (0, uploadUsageInfo_1.transformReducedUsageInfoToTypeIdsFromPath)(reducedUsageInfo, typesWithEmptyProps);
-        expect(result).toBeUndefined();
-        expect(logger_1.default.error).toHaveBeenCalledWith(expect.stringContaining('Could not find type property with slug color'));
-    });
-    it('should not mutate the original object', () => {
-        const reducedUsageInfo = {
-            typePath: 'product/clothing',
-            typePropertySlug: 'size',
-            editable: false,
-            extraProp: 'remove',
-        };
-        const originalRef = reducedUsageInfo;
-        const result = (0, uploadUsageInfo_1.transformReducedUsageInfoToTypeIdsFromPath)(reducedUsageInfo, mockTypes);
-        // Verify the original object is not mutated
-        expect(reducedUsageInfo).toBe(originalRef);
-        expect(reducedUsageInfo.typeId).toBeUndefined();
-        expect(reducedUsageInfo.typePropertyId).toBeUndefined();
-        expect(reducedUsageInfo.extraProp).toBe('remove');
-        // Verify result is a new object with correct data
-        expect(result).toBeDefined();
-        expect(result.typeId).toBe('type-123');
-        expect(result.typePropertyId).toBe('prop-789');
-        expect(result.extraProp).toBeUndefined();
-    });
-});
-describe('persistReducedUsageInfoFields validation', () => {
-    it('should contain all properties from PersistReducedUsageInfo interface', () => {
-        // Create a sample object with all required properties from PersistReducedUsageInfo
-        // This will fail at compile time if we're missing any properties
-        const samplePersistReducedUsageInfo = {
-            typeId: 'type-123',
-            typePropertyId: 'prop-456',
-            editable: true,
-            used: true,
-            formulaFunction: 'formula',
-            validationFunction: 'validation',
-            numberFormat: '0.00',
-            defaultValue: 'default',
-            label: 'Label',
-            required: true,
-            searchable: true,
-            isUniqueProperty: false,
-            isUniquePropertyInFamily: false,
-            copyBehavior: 'copy',
-            copyDefault: 'default',
-            propertyLevel: 'instance',
-            isArchived: false,
-            isFederationProperty: false,
-            carryOverBehavior: 'carry',
-            carryOverDefault: 'default',
-        };
-        // Get all keys from the sample object
-        const allKeys = Object.keys(samplePersistReducedUsageInfo);
-        // Verify that every key exists in persistReducedUsageInfoFields
-        const missingKeys = [];
-        allKeys.forEach((key) => {
-            if (!uploadUsageInfo_1.persistReducedUsageInfoFields.includes(key)) {
-                missingKeys.push(key);
-            }
-        });
-        // This test will fail if any keys are missing
-        expect(missingKeys).toEqual([]);
-        expect(missingKeys.length).toBe(0);
-    });
-    it('should contain only valid properties from PersistReducedUsageInfo interface', () => {
-        // Verify no extra keys that don't exist in the interface
-        // This is more of a documentation test - TypeScript already enforces this at compile time
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        const samplePersistReducedUsageInfo = {
-            typeId: 'type-123',
-            typePropertyId: 'prop-456',
-            editable: true,
-            used: true,
-            isArchived: false,
-        };
-        // Every field in the array should be a valid key
-        uploadUsageInfo_1.persistReducedUsageInfoFields.forEach((field) => {
-            // TypeScript ensures this at compile time, but we can document it in tests
-            expect(typeof field).toBe('string');
-            // Also verify the field could exist in the sample
-            expect(field).toBeTruthy();
-        });
-    });
-});
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const uploadUsageInfo_1 = require("./uploadUsageInfo");
+const logger_1 = tslib_1.__importDefault(require("../../logger"));
+// Mock the logger
+jest.mock('../../logger', () => ({
+    error: jest.fn(),
+    info: jest.fn(),
+    debug: jest.fn(),
+}));
+describe('transformReducedUsageInfoToTypeIdsFromPath', () => {
+    const mockTypes = [
+        {
+            id: 'type-123',
+            typePath: 'product/clothing',
+            typeProperties: [
+                {
+                    id: 'prop-456',
+                    slug: 'color',
+                },
+                {
+                    id: 'prop-789',
+                    slug: 'size',
+                },
+            ],
+        },
+        {
+            id: 'type-abc',
+            typePath: 'product/electronics',
+            typeProperties: [
+                {
+                    id: 'prop-def',
+                    slug: 'brand',
+                },
+            ],
+        },
+    ];
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    it('should successfully transform a valid reducedUsageInfo object', () => {
+        const reducedUsageInfo = {
+            typePath: 'product/clothing',
+            typePropertySlug: 'color',
+            editable: true,
+            used: true,
+            label: 'Color',
+            extraProperty: 'should be removed',
+        };
+        const result = (0, uploadUsageInfo_1.transformReducedUsageInfoToTypeIdsFromPath)(reducedUsageInfo, mockTypes);
+        expect(result).toBeDefined();
+        expect(result.typeId).toBe('type-123');
+        expect(result.typePropertyId).toBe('prop-456');
+        expect(result.extraProperty).toBeUndefined();
+        expect(result.editable).toBe(true);
+        expect(result.used).toBe(true);
+        expect(result.label).toBe('Color');
+        // Verify original object is not mutated
+        expect(reducedUsageInfo.typeId).toBeUndefined();
+        expect(reducedUsageInfo.typePropertyId).toBeUndefined();
+    });
+    it('should return undefined when type is not found', () => {
+        const reducedUsageInfo = {
+            typePath: 'product/nonexistent',
+            typePropertySlug: 'color',
+            editable: true,
+        };
+        const result = (0, uploadUsageInfo_1.transformReducedUsageInfoToTypeIdsFromPath)(reducedUsageInfo, mockTypes);
+        expect(result).toBeUndefined();
+        expect(logger_1.default.error).toHaveBeenCalledWith(expect.stringContaining('Could not find type with typePath product/nonexistent'));
+        // Verify original object is not mutated
+        expect(reducedUsageInfo.typeId).toBeUndefined();
+        expect(reducedUsageInfo.typePropertyId).toBeUndefined();
+    });
+    it('should return undefined when type property is not found', () => {
+        const reducedUsageInfo = {
+            typePath: 'product/clothing',
+            typePropertySlug: 'nonexistent-property',
+            editable: true,
+        };
+        const result = (0, uploadUsageInfo_1.transformReducedUsageInfoToTypeIdsFromPath)(reducedUsageInfo, mockTypes);
+        expect(result).toBeUndefined();
+        expect(logger_1.default.error).toHaveBeenCalledWith(expect.stringContaining('Could not find type property with slug nonexistent-property'));
+        // Verify original object is not mutated
+        expect(reducedUsageInfo.typeId).toBeUndefined();
+        expect(reducedUsageInfo.typePropertyId).toBeUndefined();
+    });
+    it('should exclude properties not in persistReducedUsageInfoFields', () => {
+        const reducedUsageInfo = {
+            typePath: 'product/clothing',
+            typePropertySlug: 'color',
+            editable: true,
+            used: false,
+            formulaFunction: 'someFormula',
+            extraField1: 'value1',
+            extraField2: 'value2',
+            randomProperty: 123,
+        };
+        const result = (0, uploadUsageInfo_1.transformReducedUsageInfoToTypeIdsFromPath)(reducedUsageInfo, mockTypes);
+        expect(result).toBeDefined();
+        expect(result.extraField1).toBeUndefined();
+        expect(result.extraField2).toBeUndefined();
+        expect(result.randomProperty).toBeUndefined();
+        expect(result.editable).toBeDefined();
+        expect(result.used).toBeDefined();
+        expect(result.formulaFunction).toBeDefined();
+    });
+    it('should preserve all valid persistReducedUsageInfoFields', () => {
+        const reducedUsageInfo = {
+            typePath: 'product/electronics',
+            typePropertySlug: 'brand',
+            editable: true,
+            used: true,
+            formulaFunction: 'formula',
+            validationFunction: 'validation',
+            numberFormat: '0.00',
+            defaultValue: 'default',
+            label: 'Brand',
+            required: true,
+            searchable: true,
+            isUniqueProperty: false,
+            isUniquePropertyInFamily: false,
+            copyBehavior: 'copy',
+            copyDefault: true,
+            propertyLevel: 'instance',
+            isArchived: false,
+            shouldBeRemoved: 'extra',
+            isFederationProperty: false,
+            carryOverBehavior: 'carry',
+            carryOverDefault: 'default',
+        };
+        const result = (0, uploadUsageInfo_1.transformReducedUsageInfoToTypeIdsFromPath)(reducedUsageInfo, mockTypes);
+        expect(result).toBeDefined();
+        expect(result.typeId).toBe('type-abc');
+        expect(result.typePropertyId).toBe('prop-def');
+        expect(result.shouldBeRemoved).toBeUndefined();
+        // Verify all valid fields are preserved
+        uploadUsageInfo_1.persistReducedUsageInfoFields.forEach((field) => {
+            expect(result[field]).toBeDefined();
+        });
+    });
+    it('should return undefined for empty types array', () => {
+        const reducedUsageInfo = {
+            typePath: 'product/clothing',
+            typePropertySlug: 'color',
+            editable: true,
+        };
+        const result = (0, uploadUsageInfo_1.transformReducedUsageInfoToTypeIdsFromPath)(reducedUsageInfo, []);
+        expect(result).toBeUndefined();
+        expect(logger_1.default.error).toHaveBeenCalled();
+    });
+    it('should return undefined for type with empty typeProperties array', () => {
+        const typesWithEmptyProps = [
+            {
+                id: 'type-123',
+                typePath: 'product/clothing',
+                typeProperties: [],
+            },
+        ];
+        const reducedUsageInfo = {
+            typePath: 'product/clothing',
+            typePropertySlug: 'color',
+            editable: true,
+        };
+        const result = (0, uploadUsageInfo_1.transformReducedUsageInfoToTypeIdsFromPath)(reducedUsageInfo, typesWithEmptyProps);
+        expect(result).toBeUndefined();
+        expect(logger_1.default.error).toHaveBeenCalledWith(expect.stringContaining('Could not find type property with slug color'));
+    });
+    it('should not mutate the original object', () => {
+        const reducedUsageInfo = {
+            typePath: 'product/clothing',
+            typePropertySlug: 'size',
+            editable: false,
+            extraProp: 'remove',
+        };
+        const originalRef = reducedUsageInfo;
+        const result = (0, uploadUsageInfo_1.transformReducedUsageInfoToTypeIdsFromPath)(reducedUsageInfo, mockTypes);
+        // Verify the original object is not mutated
+        expect(reducedUsageInfo).toBe(originalRef);
+        expect(reducedUsageInfo.typeId).toBeUndefined();
+        expect(reducedUsageInfo.typePropertyId).toBeUndefined();
+        expect(reducedUsageInfo.extraProp).toBe('remove');
+        // Verify result is a new object with correct data
+        expect(result).toBeDefined();
+        expect(result.typeId).toBe('type-123');
+        expect(result.typePropertyId).toBe('prop-789');
+        expect(result.extraProp).toBeUndefined();
+    });
+});
+describe('persistReducedUsageInfoFields validation', () => {
+    it('should contain all properties from PersistReducedUsageInfo interface', () => {
+        // Create a sample object with all required properties from PersistReducedUsageInfo
+        // This will fail at compile time if we're missing any properties
+        const samplePersistReducedUsageInfo = {
+            typeId: 'type-123',
+            typePropertyId: 'prop-456',
+            editable: true,
+            used: true,
+            formulaFunction: 'formula',
+            validationFunction: 'validation',
+            numberFormat: '0.00',
+            defaultValue: 'default',
+            label: 'Label',
+            required: true,
+            searchable: true,
+            isUniqueProperty: false,
+            isUniquePropertyInFamily: false,
+            copyBehavior: 'copy',
+            copyDefault: 'default',
+            propertyLevel: 'instance',
+            isArchived: false,
+            isFederationProperty: false,
+            carryOverBehavior: 'carry',
+            carryOverDefault: 'default',
+        };
+        // Get all keys from the sample object
+        const allKeys = Object.keys(samplePersistReducedUsageInfo);
+        // Verify that every key exists in persistReducedUsageInfoFields
+        const missingKeys = [];
+        allKeys.forEach((key) => {
+            if (!uploadUsageInfo_1.persistReducedUsageInfoFields.includes(key)) {
+                missingKeys.push(key);
+            }
+        });
+        // This test will fail if any keys are missing
+        expect(missingKeys).toEqual([]);
+        expect(missingKeys.length).toBe(0);
+    });
+    it('should contain only valid properties from PersistReducedUsageInfo interface', () => {
+        // Verify no extra keys that don't exist in the interface
+        // This is more of a documentation test - TypeScript already enforces this at compile time
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const samplePersistReducedUsageInfo = {
+            typeId: 'type-123',
+            typePropertyId: 'prop-456',
+            editable: true,
+            used: true,
+            isArchived: false,
+        };
+        // Every field in the array should be a valid key
+        uploadUsageInfo_1.persistReducedUsageInfoFields.forEach((field) => {
+            // TypeScript ensures this at compile time, but we can document it in tests
+            expect(typeof field).toBe('string');
+            // Also verify the field could exist in the sample
+            expect(field).toBeTruthy();
+        });
+    });
+});

package/dist/commands/users/export.d.ts

@@ -1,14 +1,14 @@
-import { BaseCommand } from '../../basecommand';
-export declare const DEFAULT_FILE_LOCATION = "users.yml";
-export default class ExportUsers extends BaseCommand {
-    static description: string;
-    static examples: string[];
-    static flags: {
-        outFile: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
-        overwrite: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
-        alwaysConfirmEnv: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
-        logLevel: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
-    };
-    run(): Promise<void>;
-}
-export declare function exportUsers(fileLocation: string, overwrite: boolean): Promise<void>;
+import { BaseCommand } from '../../basecommand';
+export declare const DEFAULT_FILE_LOCATION = "users.yml";
+export default class ExportUsers extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        outFile: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        overwrite: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        alwaysConfirmEnv: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        logLevel: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    };
+    run(): Promise<void>;
+}
+export declare function exportUsers(fileLocation: string, overwrite: boolean): Promise<void>;