@contrail/cli 3.3.3 → 3.5.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',
@@ -200,11 +199,6 @@ async function uploadReducedTypeProperties(type, currentPropertyTypes, newProper
             // !newPropertyType.inherited &&
             // !typePropertiesEqual(found, newPropertyType, optionSetIdBySlug)
             ) {
-                // Skip platform-managed entities
-                if (newPropertyType.core) {
-                    logger_1.default.debug(`Skipping platform-managed property: ${newPropertyType.slug}`);
-                    continue;
-                }
                 const proposedTP = {
                     isArchived: newPropertyType.isArchived ?? null,
                     propertyType: newPropertyType.propertyType ?? null,
@@ -229,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/dist/templates/typescript/README.md

@@ -1,7 +1,5 @@
 ### Running your app
-
 Run `npm run start` at the root directory of your app (where the `package.json` file is located).
 
 ### Publishing your app
-
-Run `contrail app publish` to publish a new version of the app.
+Run `contrail app publish` to publish a new version of the app.

package/dist/templates/typescript/assets/sample.json

@@ -1,3 +1,3 @@
 {
   "foo": "bar"
-}
+}

package/dist/templates/typescript/eslintrc.json

@@ -25,7 +25,10 @@
     "no-multiple-empty-lines": ["error", { "max": 1, "maxEOF": 0 }],
     "no-trailing-spaces": "error",
     "no-mixed-spaces-and-tabs": ["error", "smart-tabs"],
-    "@typescript-eslint/no-empty-function": ["error", { "allow": ["arrowFunctions"] }],
+    "@typescript-eslint/no-empty-function": [
+      "error",
+      { "allow": ["arrowFunctions"] }
+    ],
     "@typescript-eslint/no-explicit-any": "off",
     "@typescript-eslint/no-var-requires": "warn",
     "no-unused-vars": "off",

package/dist/templates/typescript/tsconfig.json

@@ -4,7 +4,15 @@
     "emitDecoratorMetadata": true,
     "esModuleInterop": true,
     "experimentalDecorators": true,
-    "lib": ["es5", "ES2015", "ES2016", "ES2017", "ES2020", "dom", "esnext.asynciterable"],
+    "lib": [
+      "es5",
+      "ES2015",
+      "ES2016",
+      "ES2017",
+      "ES2020",
+      "dom",
+      "esnext.asynciterable"
+    ],
     "module": "CommonJS",
     // "moduleResolution": "node",
     "noImplicitAny": false,
@@ -14,8 +22,16 @@
     "strict": false,
     "strictPropertyInitialization": false,
     "target": "ES2020",
-    "types": ["node", "jest"]
+    "types": [
+      "node", "jest"
+    ]
   },
-  "exclude": ["node_modules", "**/__tests__/*"],
-  "include": ["src", "package.json"]
-}
+  "exclude": [
+    "node_modules",
+    "**/__tests__/*"
+  ],
+  "include": [
+    "src",
+    "package.json"
+  ]
+}