@contrail/cli 3.5.0 → 3.5.1-alpha.64bf880

package/dist/commands/types/uploadUsageInfo.js

@@ -1,180 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformReducedUsageInfoToTypeIdsFromPath = exports.persistReducedUsageInfoFields = exports.uploadUsageInfo = void 0;
-const tslib_1 = require("tslib");
-const sdk_1 = require("@contrail/sdk");
-const fs_1 = tslib_1.__importDefault(require("fs"));
-const login_1 = require("../../auth/login");
-const chalk_1 = tslib_1.__importDefault(require("chalk"));
-const path = tslib_1.__importStar(require("path"));
-const core_1 = require("@oclif/core");
-const type_extractor_1 = require("../../helpers/types/type-extractor");
-const basecommand_1 = require("../../basecommand");
-const logger_1 = tslib_1.__importDefault(require("../../logger"));
-const js_yaml_1 = tslib_1.__importDefault(require("js-yaml"));
-class UploadUsageInfo extends basecommand_1.BaseCommand {
-    static description = 'Upload extracted usage info';
-    static examples = [
-        `$ contrail types uploadUsageInfo
-`,
-    ];
-    static flags = {
-        ...basecommand_1.BaseCommand.baseFlags,
-        dir: core_1.Flags.string({
-            char: 'd',
-            description: 'The directory from which to export the usage info data. Defaults to the current directory. The usage info data will be loaded from $dir/usage-info.yml',
-            required: false,
-            default: '.',
-        }),
-    };
-    async run() {
-        await uploadUsageInfo(this.flags.dir);
-    }
-}
-exports.default = UploadUsageInfo;
-async function uploadUsageInfo(dir) {
-    try {
-        await (0, login_1.authUser)();
-        logger_1.default.info(`${chalk_1.default.yellow.bold('USAGE INFO')} Uploading`);
-        const reducedUsageInfo = await loadUsageInfo(dir);
-        await uploadUsageInfoObjects(reducedUsageInfo);
-        logger_1.default.info(`${chalk_1.default.yellow.bold('USAGE INFO')} Uploaded`);
-    }
-    catch (e) {
-        logger_1.default.info(`${chalk_1.default.red.bold('FAIL')} Usage Info Upload Failed . ${e}`);
-        return;
-    }
-    logger_1.default.info(`${chalk_1.default.green.bold('COMPLETE')} Usage Info Upload Complete.`);
-}
-exports.uploadUsageInfo = uploadUsageInfo;
-function loadUsageInfo(dir) {
-    try {
-        const doc = js_yaml_1.default.load(fs_1.default.readFileSync(path.join(dir, 'usage-info.yml'), 'utf8'));
-        return doc;
-    }
-    catch (e) {
-        throw new Error(`ERROR PARSING YAML: ${e}`);
-    }
-}
-async function uploadUsageInfoObjects(loadedUsageInfo) {
-    const typesWithProperties = await (0, type_extractor_1.getTypes)();
-    const currentUsageInfo = await new sdk_1.Entities().get({
-        entityName: 'type-property-usage-info',
-    });
-    const currentUsageInfosHashes = {};
-    for (const currentUI of currentUsageInfo) {
-        const foundType = typesWithProperties.find((t) => t.id === currentUI.typeId);
-        const typeProperties = foundType?.typeProperties || [];
-        const foundTypeProperty = typeProperties.find((tp) => tp.id === currentUI.typePropertyId);
-        if (!foundType || !foundTypeProperty) {
-            logger_1.default.info(`skipping unhashable, invalid usage info: ${JSON.stringify(currentUI, null, 2)}`);
-            continue;
-        }
-        const hash = `${foundType.typePath}|${foundTypeProperty.slug}`;
-        currentUsageInfosHashes[hash] = currentUI;
-    }
-    const reducedUsageInfoHashes = {};
-    for (const loadedUI of loadedUsageInfo) {
-        const hash = `${loadedUI.typePath}|${loadedUI.typePropertySlug}`;
-        reducedUsageInfoHashes[hash] = loadedUI;
-    }
-    logger_1.default.debug(`current usage info: ${JSON.stringify(currentUsageInfo)}`);
-    logger_1.default.debug(`loaded usage info: ${JSON.stringify(loadedUsageInfo)}`);
-    for (const loadedUI of loadedUsageInfo) {
-        try {
-            const found = currentUsageInfosHashes[`${loadedUI.typePath}|${loadedUI.typePropertySlug}`];
-            const transformedUI = transformReducedUsageInfoToTypeIdsFromPath(loadedUI, typesWithProperties);
-            if (!transformedUI) {
-                continue;
-            }
-            if (!found) {
-                logger_1.default.debug(`Creating:  ${JSON.stringify(transformedUI)}`);
-                await new sdk_1.Entities().create({
-                    entityName: 'type-property-usage-info',
-                    object: transformedUI,
-                });
-            }
-            else {
-                logger_1.default.info(`Updating:  ${JSON.stringify(transformedUI)}`);
-                await new sdk_1.Entities().update({
-                    entityName: 'type-property-usage-info',
-                    id: found.id,
-                    object: transformedUI,
-                });
-            }
-        }
-        catch (err) {
-            logger_1.default.error(`Error Uploading usage info: ${err}`);
-        }
-    }
-    for (const [hash, currentUI] of Object.entries(currentUsageInfosHashes)) {
-        try {
-            const found = reducedUsageInfoHashes[hash];
-            if (!found) {
-                logger_1.default.debug(`Creating:  ${hash}`);
-                await new sdk_1.Entities().delete({
-                    entityName: 'type-property-usage-info',
-                    id: currentUI['id'],
-                });
-            }
-        }
-        catch (err) {
-            logger_1.default.error(`Error Deleting usage info: ${err}`);
-        }
-    }
-}
-//This should contain the property keys in PersistReducedUsageInfo in interfaces.ts
-//except for typePath and typePropertySlug which are used for transformation but not persisted to the database.
-// If you add a new property to PersistReducedUsageInfo, you need to add it to this array to be persisted to the database.
-exports.persistReducedUsageInfoFields = [
-    // 'typePath',
-    // 'typePropertySlug',
-    'typeId',
-    'typePropertyId',
-    'editable',
-    'used',
-    'formulaFunction',
-    'validationFunction',
-    'numberFormat',
-    'defaultValue',
-    'label',
-    'required',
-    'searchable',
-    'isUniqueProperty',
-    'isUniquePropertyInFamily',
-    'copyBehavior',
-    'copyDefault',
-    'propertyLevel',
-    'isArchived',
-    'isFederationProperty',
-    'carryOverBehavior',
-    'carryOverDefault',
-];
-// transforms the reduced Usage Info from name slugs to ids
-function transformReducedUsageInfoToTypeIdsFromPath(reducedUsageInfo, types) {
-    const foundType = types.find((t) => t.typePath === reducedUsageInfo.typePath);
-    if (!foundType) {
-        logger_1.default.error(`Could not find type with typePath ${reducedUsageInfo.typePath} while transforming ${reducedUsageInfo.typePropertySlug}`);
-        return undefined;
-    }
-    const foundTypeProperty = foundType.typeProperties?.find((tp) => tp.slug === reducedUsageInfo.typePropertySlug);
-    if (!foundTypeProperty) {
-        logger_1.default.error(`Could not find type property with slug ${reducedUsageInfo.typePropertySlug} while transforming ${JSON.stringify(reducedUsageInfo)}`);
-        return undefined;
-    }
-    // Create a new object with only the properties that are in the persistReducedUsageInfoFields array
-    // If there is a compile error on the code below, it means you added a new property to PersistReducedUsageInfo
-    // interface in interfaces.ts but forgot to add it to the persistReducedUsageInfoFields array above,
-    // It needs to be added to be persisted to the database.
-    const persistedUsageInfo = {
-        typeId: foundType.id,
-        typePropertyId: foundTypeProperty.id,
-    };
-    for (const key of Object.keys(reducedUsageInfo)) {
-        if (exports.persistReducedUsageInfoFields.includes(key)) {
-            persistedUsageInfo[key] = reducedUsageInfo[key];
-        }
-    }
-    return persistedUsageInfo;
-}
-exports.transformReducedUsageInfoToTypeIdsFromPath = transformReducedUsageInfoToTypeIdsFromPath;

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

@@ -1,249 +0,0 @@
-"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();
-        });
-    });
-});