@contrail/cli 3.4.2-alpha.1 → 3.4.3

package/README.md

@@ -17,7 +17,7 @@ $ npm install -g @contrail/cli
 $ contrail COMMAND
 running command...
 $ contrail (--version)
-@contrail/cli/3.4.2-alpha.1 win32-x64 node-v22.20.0
+@contrail/cli/3.4.3 win32-x64 node-v22.20.0
 $ contrail --help [COMMAND]
 USAGE
   $ contrail COMMAND

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

@@ -1,4 +1,5 @@
 import { BaseCommand } from '../../basecommand';
+import { PersistReducedUsageInfo } from '../../interfaces';
 export default class UploadUsageInfo extends BaseCommand {
     static description: string;
     static examples: string[];
@@ -10,3 +11,5 @@ export default class UploadUsageInfo extends BaseCommand {
     run(): Promise<void>;
 }
 export declare function uploadUsageInfo(dir: string): Promise<void>;
+export declare const persistReducedUsageInfoFields: readonly ["typeId", "typePropertyId", "editable", "used", "formulaFunction", "validationFunction", "numberFormat", "defaultValue", "label", "required", "searchable", "isUniqueProperty", "isUniquePropertyInFamily", "copyBehavior", "copyDefault", "propertyLevel", "isArchived", "isFederationProperty", "carryOverBehavior", "carryOverDefault"];
+export declare function transformReducedUsageInfoToTypeIdsFromPath(reducedUsageInfo: any, types: any): PersistReducedUsageInfo | undefined;

package/dist/commands/types/uploadUsageInfo.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.uploadUsageInfo = void 0;
+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"));
@@ -58,80 +58,48 @@ function loadUsageInfo(dir) {
 }
 async function uploadUsageInfoObjects(loadedUsageInfo) {
     const typesWithProperties = await (0, type_extractor_1.getTypes)();
-    const typeProperties = typesWithProperties
-        .filter((t) => !!t.typeProperties)
-        .map((t) => t.typeProperties)
-        .reduce((a, b) => a.concat(b));
     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.slug}|${foundTypeProperty.slug}`;
+        const hash = `${foundType.typePath}|${foundTypeProperty.slug}`;
         currentUsageInfosHashes[hash] = currentUI;
     }
     const reducedUsageInfoHashes = {};
     for (const loadedUI of loadedUsageInfo) {
-        const hash = `${loadedUI.typeSlug}|${loadedUI.typePropertySlug}`;
+        const hash = `${loadedUI.typePath}|${loadedUI.typePropertySlug}`;
         reducedUsageInfoHashes[hash] = loadedUI;
     }
-    logger_1.default.debug(`current usage info: ${currentUsageInfo}`);
-    logger_1.default.debug('loaded usage info:', loadedUsageInfo);
+    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.typeSlug}|${loadedUI.typePropertySlug}`];
+            const found = currentUsageInfosHashes[`${loadedUI.typePath}|${loadedUI.typePropertySlug}`];
+            const transformedUI = transformReducedUsageInfoToTypeIdsFromPath(loadedUI, typesWithProperties);
+            if (!transformedUI) {
+                continue;
+            }
             if (!found) {
-                if (!transformReducedUI(loadedUI, typesWithProperties, typeProperties)) {
-                    continue;
-                }
-                logger_1.default.debug(`Creating:  ${loadedUI}`);
+                logger_1.default.debug(`Creating:  ${JSON.stringify(transformedUI)}`);
                 await new sdk_1.Entities().create({
                     entityName: 'type-property-usage-info',
-                    object: {
-                        typePropertyId: loadedUI.typePropertyId,
-                        typeId: loadedUI.typeId,
-                        editable: loadedUI.editable,
-                        used: loadedUI.used,
-                        formulaFunction: loadedUI.formulaFunction,
-                        validationFunction: loadedUI.validationFunction,
-                        numberFormat: loadedUI.numberFormat,
-                        defaultValue: loadedUI.defaultValue,
-                        label: loadedUI.label,
-                        isArchived: loadedUI.isArchived,
-                    },
+                    object: transformedUI,
                 });
             }
             else {
-                if (!transformReducedUI(loadedUI, typesWithProperties, typeProperties)) {
-                    continue;
-                }
-                logger_1.default.info(`Updating:  ${loadedUI}`);
+                logger_1.default.info(`Updating:  ${JSON.stringify(transformedUI)}`);
                 await new sdk_1.Entities().update({
                     entityName: 'type-property-usage-info',
                     id: found.id,
-                    object: {
-                        editable: loadedUI?.editable,
-                        used: loadedUI?.used,
-                        formulaFunction: loadedUI?.formulaFunction,
-                        validationFunction: loadedUI?.validationFunction,
-                        numberFormat: loadedUI?.numberFormat,
-                        defaultValue: loadedUI?.defaultValue,
-                        label: loadedUI?.label,
-                        required: loadedUI?.required,
-                        searchable: loadedUI?.searchable,
-                        isUniqueProperty: loadedUI?.isUniqueProperty,
-                        isUniquePropertyInFamily: loadedUI?.isUniquePropertyInFamily,
-                        copyBehavior: loadedUI?.copyBehavior,
-                        copyDefault: loadedUI?.copyDefault,
-                        propertyLevel: loadedUI?.propertyLevel,
-                        isArchived: loadedUI?.isArchived,
-                    },
+                    object: transformedUI,
                 });
             }
         }
@@ -155,19 +123,58 @@ async function uploadUsageInfoObjects(loadedUsageInfo) {
         }
     }
 }
+//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 transformReducedUI(reducedUsageInfo, types, typeProperties) {
-    const foundType = types.find((t) => t.slug === reducedUsageInfo.typeSlug);
+function transformReducedUsageInfoToTypeIdsFromPath(reducedUsageInfo, types) {
+    const foundType = types.find((t) => t.typePath === reducedUsageInfo.typePath);
     if (!foundType) {
-        logger_1.default.error(`Could not find type with slug ${reducedUsageInfo.typeSlug} while transforming ${reducedUsageInfo}`);
-        return false;
+        logger_1.default.error(`Could not find type with typePath ${reducedUsageInfo.typePath} while transforming ${reducedUsageInfo.typePropertySlug}`);
+        return undefined;
     }
-    reducedUsageInfo.typeId = foundType.id;
-    const foundTypeProperty = typeProperties.find((tp) => tp.slug === reducedUsageInfo.typePropertySlug);
+    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 ${reducedUsageInfo}`);
-        return false;
+        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];
+        }
     }
-    reducedUsageInfo.typePropertyId = foundTypeProperty.id;
-    return true;
+    return persistedUsageInfo;
 }
+exports.transformReducedUsageInfoToTypeIdsFromPath = transformReducedUsageInfoToTypeIdsFromPath;

package/dist/commands/types/uploadUsageInfo.spec.d.ts

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

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

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

package/dist/interfaces.d.ts

@@ -370,6 +370,31 @@ export interface ReducedOptionSet {
     isArchived: boolean;
     optionSet: any[];
 }
+export interface ReducedUsageInfo {
+    typeId: string;
+    typePropertyId: string;
+    typePath: string;
+    typePropertySlug: string;
+    editable: boolean;
+    used: boolean;
+    formulaFunction?: string;
+    validationFunction?: string;
+    numberFormat?: any;
+    defaultValue?: string;
+    label?: string;
+    required?: boolean;
+    searchable?: boolean;
+    isUniqueProperty?: boolean;
+    isUniquePropertyInFamily?: boolean;
+    copyBehavior?: string;
+    copyDefault?: string;
+    propertyLevel?: string;
+    isArchived: boolean;
+    isFederationProperty?: boolean;
+    carryOverBehavior?: string;
+    carryOverDefault?: string;
+}
+export type PersistReducedUsageInfo = Omit<ReducedUsageInfo, 'typePath' | 'typePropertySlug'>;
 export declare enum PropertyType {
     Text = "text",
     String = "string",

package/oclif.manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "3.4.2-alpha.1",
+  "version": "3.4.3",
   "commands": {
     "app:create": {
       "id": "app:create",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contrail/cli",
-  "version": "3.4.2-alpha.1",
+  "version": "3.4.3",
   "description": "VibeIQ's Contrail Platform CLI.",
   "bin": {
     "contrail-cli": "./bin/run",
@@ -22,11 +22,11 @@
     "/oclif.manifest.json"
   ],
   "dependencies": {
-    "@contrail/entity-types": "^1.5.1",
-    "@contrail/org-config-migration": "^1.1.7",
-    "@contrail/sdk": "^1.4.6",
-    "@contrail/types": "^3.0.48",
-    "@contrail/util": "^1.1.10",
+    "@contrail/entity-types": "^1.6.0",
+    "@contrail/org-config-migration": "^1.1.13",
+    "@contrail/sdk": "^1.5.5",
+    "@contrail/types": "^3.1.5",
+    "@contrail/util": "^1.2.0",
     "@oclif/core": "^2",
     "@oclif/plugin-autocomplete": "^2.1.4",
     "@oclif/plugin-help": "^5",