@contrail/cli 3.3.2 → 3.4.0-alpha

package/dist/helpers/propertySpecifications/propertySpecifications.spec.js

@@ -0,0 +1,266 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const propertySpecifications_1 = require("./propertySpecifications");
+describe('parsePropertySpecification', () => {
+    it('should parse a valid property specification', () => {
+        const spec = 'name=john';
+        const result = (0, propertySpecifications_1.parsePropertySpecification)(spec);
+        expect(result).toEqual({
+            slug: 'name',
+            value: 'john',
+        });
+    });
+    it('should parse property specification with numeric value', () => {
+        const spec = 'id=123';
+        const result = (0, propertySpecifications_1.parsePropertySpecification)(spec);
+        expect(result).toEqual({
+            slug: 'id',
+            value: '123',
+        });
+    });
+    it('should parse property specification with hex color value', () => {
+        const spec = 'hex=000000';
+        const result = (0, propertySpecifications_1.parsePropertySpecification)(spec);
+        expect(result).toEqual({
+            slug: 'hex',
+            value: '000000',
+        });
+    });
+    it('should parse property specification with spaces in value', () => {
+        const spec = 'name=john doe';
+        const result = (0, propertySpecifications_1.parsePropertySpecification)(spec);
+        expect(result).toEqual({
+            slug: 'name',
+            value: 'john doe',
+        });
+    });
+    it('should parse property specification with equals sign in value', () => {
+        const spec = 'formula=x=y+z';
+        const result = (0, propertySpecifications_1.parsePropertySpecification)(spec);
+        expect(result).toEqual({
+            slug: 'formula',
+            value: 'x=y+z', // Now correctly keeps everything after first equals
+        });
+    });
+    it('should parse property specification with empty value', () => {
+        const spec = 'description=';
+        // Current implementation throws error for empty values
+        expect(() => (0, propertySpecifications_1.parsePropertySpecification)(spec)).toThrow('Invalid property specification: description=');
+    });
+    it('should throw error for spec without equals sign', () => {
+        const spec = 'invalidspec';
+        expect(() => (0, propertySpecifications_1.parsePropertySpecification)(spec)).toThrow('Invalid property specification: invalidspec');
+    });
+    it('should throw error for spec with only equals sign', () => {
+        const spec = '=';
+        expect(() => (0, propertySpecifications_1.parsePropertySpecification)(spec)).toThrow('Invalid property specification: =');
+    });
+    it('should throw error for spec with empty slug', () => {
+        const spec = '=value';
+        expect(() => (0, propertySpecifications_1.parsePropertySpecification)(spec)).toThrow('Invalid property specification: =value');
+    });
+    it('should parse property specification with special characters in slug', () => {
+        const spec = 'property_name=value';
+        const result = (0, propertySpecifications_1.parsePropertySpecification)(spec);
+        expect(result).toEqual({
+            slug: 'property_name',
+            value: 'value',
+        });
+    });
+    it('should parse property specification with hyphenated slug', () => {
+        const spec = 'property-name=value';
+        const result = (0, propertySpecifications_1.parsePropertySpecification)(spec);
+        expect(result).toEqual({
+            slug: 'property-name',
+            value: 'value',
+        });
+    });
+});
+describe('parsePropertySpecificationsIntoMap', () => {
+    it('should parse multiple property specifications into a map', () => {
+        const specs = ['name=obsidian', 'hex=000000', 'id=123'];
+        const result = (0, propertySpecifications_1.parsePropertySpecificationsIntoMap)(specs);
+        expect(result).toBeInstanceOf(Map);
+        expect(result.get('name')).toBe('obsidian');
+        expect(result.get('hex')).toBe('000000');
+        expect(result.get('id')).toBe('123');
+        expect(result.size).toBe(3);
+    });
+    it('should handle empty array', () => {
+        const specs = [];
+        const result = (0, propertySpecifications_1.parsePropertySpecificationsIntoMap)(specs);
+        expect(result).toBeInstanceOf(Map);
+        expect(result.size).toBe(0);
+    });
+    it('should handle single property specification', () => {
+        const specs = ['name=john'];
+        const result = (0, propertySpecifications_1.parsePropertySpecificationsIntoMap)(specs);
+        expect(result).toBeInstanceOf(Map);
+        expect(result.get('name')).toBe('john');
+        expect(result.size).toBe(1);
+    });
+    it('should handle property specifications with complex values', () => {
+        const specs = [
+            'description=This is a long description with spaces',
+            'formula=x=y+z',
+            'url=https://example.com',
+        ];
+        const result = (0, propertySpecifications_1.parsePropertySpecificationsIntoMap)(specs);
+        expect(result.get('description')).toBe('This is a long description with spaces');
+        expect(result.get('formula')).toBe('x=y+z'); // Now correctly handles multiple equals
+        expect(result.get('url')).toBe('https://example.com');
+        expect(result.size).toBe(3);
+    });
+    it('should handle duplicate slugs by overwriting with last value', () => {
+        const specs = ['name=first', 'name=second', 'name=third'];
+        const result = (0, propertySpecifications_1.parsePropertySpecificationsIntoMap)(specs);
+        expect(result.get('name')).toBe('third');
+        expect(result.size).toBe(1);
+    });
+    it('should handle property specifications with empty values', () => {
+        const specs = ['name=john', 'description=', 'notes='];
+        // Current implementation throws error for empty values
+        expect(() => (0, propertySpecifications_1.parsePropertySpecificationsIntoMap)(specs)).toThrow('Invalid property specification: description=');
+    });
+    it('should throw error for invalid property specifications', () => {
+        const specs = [
+            'name=john',
+            'invalid',
+        ];
+        expect(() => (0, propertySpecifications_1.parsePropertySpecificationsIntoMap)(specs)).toThrow('Invalid property specification: invalid');
+    });
+});
+describe('isValidPropertySpecification', () => {
+    it('should return true for valid property specifications', () => {
+        expect((0, propertySpecifications_1.isValidPropertySpecification)('name=john')).toBe(true);
+        expect((0, propertySpecifications_1.isValidPropertySpecification)('id=123')).toBe(true);
+        expect((0, propertySpecifications_1.isValidPropertySpecification)('hex=000000')).toBe(true);
+        expect((0, propertySpecifications_1.isValidPropertySpecification)('description=This is a description')).toBe(true);
+        expect((0, propertySpecifications_1.isValidPropertySpecification)('formula=x=y+z')).toBe(true);
+        expect((0, propertySpecifications_1.isValidPropertySpecification)('property_name=value')).toBe(true);
+        expect((0, propertySpecifications_1.isValidPropertySpecification)('property-name=value')).toBe(true);
+    });
+    it('should return true for property specifications with empty values', () => {
+        // Current implementation rejects empty values
+        expect((0, propertySpecifications_1.isValidPropertySpecification)('description=')).toBe(false);
+        expect((0, propertySpecifications_1.isValidPropertySpecification)('notes=')).toBe(false);
+    });
+    it('should return false for invalid property specifications', () => {
+        expect((0, propertySpecifications_1.isValidPropertySpecification)('invalid')).toBe(false);
+        expect((0, propertySpecifications_1.isValidPropertySpecification)('')).toBe(false);
+        expect((0, propertySpecifications_1.isValidPropertySpecification)('=')).toBe(false);
+        expect((0, propertySpecifications_1.isValidPropertySpecification)('=value')).toBe(false);
+    });
+    it('should return false for null or undefined', () => {
+        expect((0, propertySpecifications_1.isValidPropertySpecification)(null)).toBe(false);
+        expect((0, propertySpecifications_1.isValidPropertySpecification)(undefined)).toBe(false);
+    });
+    it('should return false for non-string values', () => {
+        expect((0, propertySpecifications_1.isValidPropertySpecification)(123)).toBe(false);
+        expect((0, propertySpecifications_1.isValidPropertySpecification)({})).toBe(false);
+        expect((0, propertySpecifications_1.isValidPropertySpecification)([])).toBe(false);
+    });
+    it('should act as type guard', () => {
+        const maybeSpec = 'name=john';
+        if ((0, propertySpecifications_1.isValidPropertySpecification)(maybeSpec)) {
+            // TypeScript should recognize maybeSpec as PropertySpecificationString
+            const parsed = (0, propertySpecifications_1.parsePropertySpecification)(maybeSpec);
+            expect(parsed.slug).toBe('name');
+            expect(parsed.value).toBe('john');
+        }
+    });
+});
+describe('integration tests', () => {
+    it('should work with the example from the comments', () => {
+        // Example: contrail entities get color -- id=123
+        const getSpecs = ['id=123'];
+        const getMap = (0, propertySpecifications_1.parsePropertySpecificationsIntoMap)(getSpecs);
+        expect(getMap.get('id')).toBe('123');
+        expect(getMap.size).toBe(1);
+    });
+    it('should work with the update example from the comments', () => {
+        // Example: contrail entities update color 123 -- name=obsidian hex=000000
+        const updateSpecs = ['name=obsidian', 'hex=000000'];
+        const updateMap = (0, propertySpecifications_1.parsePropertySpecificationsIntoMap)(updateSpecs);
+        expect(updateMap.get('name')).toBe('obsidian');
+        expect(updateMap.get('hex')).toBe('000000');
+        expect(updateMap.size).toBe(2);
+    });
+    it('should handle validation before parsing', () => {
+        const userInputs = ['name=john', 'invalid', 'id=123', '=empty'];
+        const validSpecs = userInputs.filter(propertySpecifications_1.isValidPropertySpecification);
+        expect(validSpecs).toEqual(['name=john', 'id=123']);
+        const map = (0, propertySpecifications_1.parsePropertySpecificationsIntoMap)(validSpecs);
+        expect(map.get('name')).toBe('john');
+        expect(map.get('id')).toBe('123');
+        expect(map.size).toBe(2);
+    });
+});
+describe('edge cases and limitations', () => {
+    it('should handle multiple equals signs correctly', () => {
+        // This test shows that multiple equals signs are now handled correctly
+        const spec = 'calculation=2+2=4';
+        const result = (0, propertySpecifications_1.parsePropertySpecification)(spec);
+        expect(result).toEqual({
+            slug: 'calculation',
+            value: '2+2=4', // now preserves everything after first equals
+        });
+    });
+    it('should handle the specific example equation=x+z=1', () => {
+        const spec = 'equation=x+z=1';
+        const result = (0, propertySpecifications_1.parsePropertySpecification)(spec);
+        expect(result).toEqual({
+            slug: 'equation',
+            value: 'x+z=1',
+        });
+    });
+    it('should handle mathematical expressions with one equals', () => {
+        const spec = 'formula=x+y';
+        const result = (0, propertySpecifications_1.parsePropertySpecification)(spec);
+        expect(result).toEqual({
+            slug: 'formula',
+            value: 'x+y',
+        });
+    });
+    it('should handle URLs without equals signs', () => {
+        const spec = 'url=https://example.com/path';
+        const result = (0, propertySpecifications_1.parsePropertySpecification)(spec);
+        expect(result).toEqual({
+            slug: 'url',
+            value: 'https://example.com/path',
+        });
+    });
+    it('should handle JSON-like values', () => {
+        const spec = 'config={"key":"value"}';
+        const result = (0, propertySpecifications_1.parsePropertySpecification)(spec);
+        expect(result).toEqual({
+            slug: 'config',
+            value: '{"key":"value"}',
+        });
+    });
+    it('should handle comma-separated values', () => {
+        const spec = 'tags=red,blue,green';
+        const result = (0, propertySpecifications_1.parsePropertySpecification)(spec);
+        expect(result).toEqual({
+            slug: 'tags',
+            value: 'red,blue,green',
+        });
+    });
+    it('should handle escaped characters', () => {
+        const spec = 'message=Hello\\nWorld';
+        const result = (0, propertySpecifications_1.parsePropertySpecification)(spec);
+        expect(result).toEqual({
+            slug: 'message',
+            value: 'Hello\\nWorld',
+        });
+    });
+    it('should handle whitespace in slugs', () => {
+        // This documents current behavior - spaces in slugs are allowed
+        const spec = 'property name=value';
+        const result = (0, propertySpecifications_1.parsePropertySpecification)(spec);
+        expect(result).toEqual({
+            slug: 'property name',
+            value: 'value',
+        });
+    });
+});

package/dist/helpers/types/type-uploader.js

@@ -188,7 +188,6 @@ async function uploadReducedTypeProperties(type, currentPropertyTypes, newProper
                         validationFunction: newPropertyType.validationFunction,
                         numberFormat: newPropertyType.numberFormat,
                         sequenceSeedValue: newPropertyType.sequenceSeedValue,
-                        copyBehavior: newPropertyType?.copyBehavior,
                     }),
                     headers: {
                         Accept: 'application/json',
@@ -224,7 +223,6 @@ async function uploadReducedTypeProperties(type, currentPropertyTypes, newProper
                     validationFunction: newPropertyType.validationFunction ?? null,
                     numberFormat: newPropertyType.numberFormat ?? null,
                     sequenceSeedValue: newPropertyType.sequenceSeedValue ?? null,
-                    copyBehavior: newPropertyType.copyBehavior ?? null,
                 };
                 // logger.debug(
                 //   `found type property option set: ${newPropertyType.typePropertyOptionSetSlug}, ${proposedTP.typePropertyOptionSetId}, `,

package/dist/interfaces.d.ts

@@ -360,7 +360,6 @@ export interface ReducedTypeProperty {
     validationFunction?: string;
     numberFormat?: any;
     sequenceSeedValue?: number;
-    copyBehavior?: string;
 }
 export interface ReducedOptionSet {
     name: string;

package/oclif.manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "3.3.2",
+  "version": "3.4.0-alpha",
   "commands": {
     "app:create": {
       "id": "app:create",
@@ -672,6 +672,366 @@
         }
       }
     },
+    "entities:create": {
+      "id": "entities:create",
+      "description": "(BETA) Create entities",
+      "strict": false,
+      "pluginName": "@contrail/cli",
+      "pluginAlias": "@contrail/cli",
+      "pluginType": "core",
+      "aliases": [],
+      "examples": [
+        "contrail entities create color -n=10 # creates 10 random colors",
+        "contrail entities create color # creates one item",
+        "contrail entities create custom-entities:franchise",
+        "contrail entities create project-item -n=1 -- projectId=abc # creates 10 project items within project ABC",
+        "contrail entities create color -r # creates a random color with a human readable ID",
+        "contrail entities create color -d # simulates the creation of a random color without actually creating it",
+        "contrail entities create custom-entity:franchise -s # creates a random color and the response does not contain hydrating relationships",
+        "contrail entities create color -p -- name=Electric Blue green=1 red=2 blue=3 # creates a color with specified properties",
+        "contrail entities create color -o /tmp/colors.json # creates a random color and saves the output to /tmp/colors.json"
+      ],
+      "flags": {
+        "logLevel": {
+          "name": "logLevel",
+          "type": "option",
+          "char": "l",
+          "description": "The Log Level",
+          "required": false,
+          "multiple": false,
+          "options": [
+            "error",
+            "warn",
+            "info",
+            "debug"
+          ]
+        },
+        "alwaysConfirmEnv": {
+          "name": "alwaysConfirmEnv",
+          "type": "option",
+          "char": "e",
+          "description": "The Environment variables",
+          "required": false,
+          "multiple": false,
+          "options": [
+            "true",
+            "false"
+          ],
+          "default": "true"
+        },
+        "count": {
+          "name": "count",
+          "type": "option",
+          "char": "n",
+          "description": "Number of random entities to create",
+          "required": false,
+          "multiple": false
+        },
+        "dryRun": {
+          "name": "dryRun",
+          "type": "boolean",
+          "char": "d",
+          "description": "If true, does not create the entity but simulates the creation",
+          "required": false,
+          "allowNo": false
+        },
+        "inputFile": {
+          "name": "inputFile",
+          "type": "option",
+          "char": "i",
+          "description": "A file with a JSON array of objects where each object is one entity to create. Cannot be used with --count. Unless --precise is specified, any missing values will be populated with random values.",
+          "required": false,
+          "multiple": false
+        },
+        "outputFile": {
+          "name": "outputFile",
+          "type": "option",
+          "char": "o",
+          "description": "File to save the output (optional)",
+          "required": false,
+          "multiple": false
+        },
+        "preciseProperties": {
+          "name": "preciseProperties",
+          "type": "boolean",
+          "char": "p",
+          "description": "If true, does not generate random values for properties. All values must be specified.",
+          "required": false,
+          "allowNo": false
+        },
+        "readableIds": {
+          "name": "readableIds",
+          "type": "boolean",
+          "char": "r",
+          "description": "If true, uses readable IDs for the created entities",
+          "required": false,
+          "allowNo": false
+        },
+        "skipHydrateRelationships": {
+          "name": "skipHydrateRelationships",
+          "type": "boolean",
+          "char": "s",
+          "description": "If true, does not hydrate relationships for the created entities",
+          "required": false,
+          "allowNo": false
+        }
+      },
+      "args": {
+        "path": {
+          "name": "path",
+          "description": "Path of the entity type to create",
+          "required": true
+        }
+      }
+    },
+    "entities:delete": {
+      "id": "entities:delete",
+      "description": "(BETA) Delete an entity",
+      "strict": true,
+      "pluginName": "@contrail/cli",
+      "pluginAlias": "@contrail/cli",
+      "pluginType": "core",
+      "aliases": [],
+      "examples": [
+        "contrail entities delete color 123"
+      ],
+      "flags": {
+        "logLevel": {
+          "name": "logLevel",
+          "type": "option",
+          "char": "l",
+          "description": "The Log Level",
+          "required": false,
+          "multiple": false,
+          "options": [
+            "error",
+            "warn",
+            "info",
+            "debug"
+          ]
+        },
+        "alwaysConfirmEnv": {
+          "name": "alwaysConfirmEnv",
+          "type": "option",
+          "char": "e",
+          "description": "The Environment variables",
+          "required": false,
+          "multiple": false,
+          "options": [
+            "true",
+            "false"
+          ],
+          "default": "true"
+        },
+        "dryRun": {
+          "name": "dryRun",
+          "type": "boolean",
+          "char": "d",
+          "description": "If true, does not delete the entity but simulates the deletion",
+          "required": false,
+          "allowNo": false
+        },
+        "input": {
+          "name": "input",
+          "type": "option",
+          "char": "i",
+          "description": "A JSON array of objects where each object is one entity to create. Cannot be used with --count. Unless --precise is specified, any missing values will be populated with random values.",
+          "required": false,
+          "multiple": false
+        },
+        "id": {
+          "name": "id",
+          "type": "option",
+          "description": "The unique identifier of the entity",
+          "required": false,
+          "multiple": false
+        }
+      },
+      "args": {
+        "entityName": {
+          "name": "entityName",
+          "description": "The name of the entity type to delete",
+          "required": true
+        }
+      }
+    },
+    "entities:get": {
+      "id": "entities:get",
+      "description": "(BETA) Get an entity",
+      "strict": false,
+      "pluginName": "@contrail/cli",
+      "pluginAlias": "@contrail/cli",
+      "pluginType": "core",
+      "aliases": [],
+      "examples": [
+        "contrail entities get color -- id=123",
+        "contrail entities get loader-processes -- createdOn=2025-09-15..2025-09-16",
+        "contrail entities get orders -- updatedAt=2025-09-15T04:00:00Z..",
+        "contrail entities get events -- timestamp=..2025-09-16T23:59:59Z"
+      ],
+      "flags": {
+        "logLevel": {
+          "name": "logLevel",
+          "type": "option",
+          "char": "l",
+          "description": "The Log Level",
+          "required": false,
+          "multiple": false,
+          "options": [
+            "error",
+            "warn",
+            "info",
+            "debug"
+          ]
+        },
+        "alwaysConfirmEnv": {
+          "name": "alwaysConfirmEnv",
+          "type": "option",
+          "char": "e",
+          "description": "The Environment variables",
+          "required": false,
+          "multiple": false,
+          "options": [
+            "true",
+            "false"
+          ],
+          "default": "true"
+        },
+        "outputFile": {
+          "name": "outputFile",
+          "type": "option",
+          "char": "o",
+          "description": "File to save the output (optional)",
+          "required": false,
+          "multiple": false
+        },
+        "skipHydrateRelationships": {
+          "name": "skipHydrateRelationships",
+          "type": "boolean",
+          "char": "s",
+          "description": "Skip hydrating relationships when fetching the entity",
+          "required": false,
+          "allowNo": false
+        },
+        "relations": {
+          "name": "relations",
+          "type": "option",
+          "char": "r",
+          "description": "Comma-separated list of relations to include in the output",
+          "required": false,
+          "multiple": false
+        },
+        "propertySlugs": {
+          "name": "propertySlugs",
+          "type": "option",
+          "char": "p",
+          "description": "Comma-separated list of property slugs to include in the output",
+          "required": false,
+          "multiple": false
+        },
+        "paginated": {
+          "name": "paginated",
+          "type": "boolean",
+          "char": "P",
+          "description": "If true, fetches all entities in a paginated manner",
+          "required": false,
+          "allowNo": false
+        },
+        "take": {
+          "name": "take",
+          "type": "option",
+          "char": "t",
+          "description": "Number of entities to fetch in a single request (default is 100)",
+          "required": false,
+          "multiple": false,
+          "default": 1000
+        }
+      },
+      "args": {
+        "typePath": {
+          "name": "typePath",
+          "description": "The name of the entity type to fetch",
+          "required": true
+        }
+      }
+    },
+    "entities:update": {
+      "id": "entities:update",
+      "description": "(BETA) Update an entity",
+      "strict": false,
+      "pluginName": "@contrail/cli",
+      "pluginAlias": "@contrail/cli",
+      "pluginType": "core",
+      "aliases": [],
+      "examples": [
+        "contrail entities update color 123 -- name=obsidian hex=000000"
+      ],
+      "flags": {
+        "logLevel": {
+          "name": "logLevel",
+          "type": "option",
+          "char": "l",
+          "description": "The Log Level",
+          "required": false,
+          "multiple": false,
+          "options": [
+            "error",
+            "warn",
+            "info",
+            "debug"
+          ]
+        },
+        "alwaysConfirmEnv": {
+          "name": "alwaysConfirmEnv",
+          "type": "option",
+          "char": "e",
+          "description": "The Environment variables",
+          "required": false,
+          "multiple": false,
+          "options": [
+            "true",
+            "false"
+          ],
+          "default": "true"
+        },
+        "skipHydrateRelationships": {
+          "name": "skipHydrateRelationships",
+          "type": "boolean",
+          "char": "s",
+          "description": "Skip hydrating relationships when updating the entity",
+          "required": false,
+          "allowNo": false
+        },
+        "dryRun": {
+          "name": "dryRun",
+          "type": "boolean",
+          "char": "d",
+          "description": "If true, does not create the entity but simulates the creation",
+          "required": false,
+          "allowNo": false
+        },
+        "inputFile": {
+          "name": "inputFile",
+          "type": "option",
+          "char": "i",
+          "description": "File containing properties to update the entity (optional)",
+          "required": false,
+          "multiple": false
+        }
+      },
+      "args": {
+        "entityName": {
+          "name": "entityName",
+          "description": "The name of the entity type to update",
+          "required": true
+        },
+        "id": {
+          "name": "id",
+          "description": "The unique identifier of the entity",
+          "required": true
+        }
+      }
+    },
     "file:upload": {
       "id": "file:upload",
       "description": "Uploads a file to the VibeIQ platform",