@contrail/cli 3.3.3 → 3.5.0-alpha

package/dist/commands/entities/create.spec.js

@@ -0,0 +1,514 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("@contrail/types");
+const create_1 = require("./create");
+const propertySpecifications_1 = require("../../helpers/propertySpecifications/propertySpecifications");
+describe('doesPropertyLevelMatchRole', () => {
+    it('should return true for exact matches', () => {
+        expect((0, create_1.doesPropertyLevelMatchRole)(types_1.PropertyLevel.OPTION, 'option')).toBe(true);
+        expect((0, create_1.doesPropertyLevelMatchRole)(types_1.PropertyLevel.FAMILY, 'family')).toBe(true);
+    });
+    it('should return false when propertyLevel does not match role', () => {
+        expect((0, create_1.doesPropertyLevelMatchRole)(types_1.PropertyLevel.OPTION, 'family')).toBe(false);
+        expect((0, create_1.doesPropertyLevelMatchRole)(types_1.PropertyLevel.FAMILY, 'option')).toBe(false);
+    });
+    it('should return true for ALL property level with any role', () => {
+        expect((0, create_1.doesPropertyLevelMatchRole)(types_1.PropertyLevel.ALL, 'option')).toBe(true);
+        expect((0, create_1.doesPropertyLevelMatchRole)(types_1.PropertyLevel.ALL, 'family')).toBe(true);
+    });
+    it('should return true for OVERRIDABLE property level with any role', () => {
+        expect((0, create_1.doesPropertyLevelMatchRole)(types_1.PropertyLevel.OVERRIDABLE, 'option')).toBe(true);
+        expect((0, create_1.doesPropertyLevelMatchRole)(types_1.PropertyLevel.OVERRIDABLE, 'family')).toBe(true);
+    });
+});
+describe('Entity Creation E2E Happy Path', () => {
+    describe('pickRandomValueForProperty', () => {
+        const mockObjectReferencesCache = new Map();
+        const mockTypeReferencesCache = new Map();
+        it('should generate random string values for String property type', () => {
+            const property = {
+                slug: 'name',
+                propertyType: types_1.PropertyType.String,
+                propertyLevel: types_1.PropertyLevel.ALL,
+            };
+            const result = (0, create_1.pickRandomValueForProperty)(property, mockObjectReferencesCache, mockTypeReferencesCache);
+            expect(typeof result).toBe('string');
+            expect(result.length).toBeGreaterThan(0);
+        });
+        it('should generate random boolean values for Boolean property type', () => {
+            const property = {
+                slug: 'isActive',
+                propertyType: types_1.PropertyType.Boolean,
+                propertyLevel: types_1.PropertyLevel.ALL,
+            };
+            const result = (0, create_1.pickRandomValueForProperty)(property, mockObjectReferencesCache, mockTypeReferencesCache);
+            expect(typeof result).toBe('boolean');
+        });
+        it('should generate random number values for Number property type', () => {
+            const property = {
+                slug: 'quantity',
+                propertyType: types_1.PropertyType.Number,
+                propertyLevel: types_1.PropertyLevel.ALL,
+            };
+            const result = (0, create_1.pickRandomValueForProperty)(property, mockObjectReferencesCache, mockTypeReferencesCache);
+            expect(typeof result).toBe('number');
+        });
+        it('should generate random date string for Date property type', () => {
+            const property = {
+                slug: 'createdAt',
+                propertyType: types_1.PropertyType.Date,
+                propertyLevel: types_1.PropertyLevel.ALL,
+            };
+            const result = (0, create_1.pickRandomValueForProperty)(property, mockObjectReferencesCache, mockTypeReferencesCache);
+            expect(typeof result).toBe('string');
+            expect(new Date(result).toString()).not.toBe('Invalid Date');
+        });
+        it('should pick random option for SingleSelect property type', () => {
+            const options = [
+                { value: 'red', display: 'Red' },
+                { value: 'blue', display: 'Blue' },
+                { value: 'green', display: 'Green' },
+            ];
+            const property = {
+                slug: 'color',
+                propertyType: types_1.PropertyType.SingleSelect,
+                propertyLevel: types_1.PropertyLevel.ALL,
+                options,
+            };
+            const result = (0, create_1.pickRandomValueForProperty)(property, mockObjectReferencesCache, mockTypeReferencesCache);
+            expect(options.some((option) => option.value === result)).toBe(true);
+        });
+        it('should pick random options for MultiSelect property type', () => {
+            const options = [
+                { value: 'feature1', display: 'Feature 1' },
+                { value: 'feature2', display: 'Feature 2' },
+                { value: 'feature3', display: 'Feature 3' },
+            ];
+            const property = {
+                slug: 'features',
+                propertyType: types_1.PropertyType.MultiSelect,
+                propertyLevel: types_1.PropertyLevel.ALL,
+                options,
+            };
+            const result = (0, create_1.pickRandomValueForProperty)(property, mockObjectReferencesCache, mockTypeReferencesCache);
+            expect(Array.isArray(result)).toBe(true);
+            expect(result.length).toBeGreaterThan(0);
+            result.forEach((value) => {
+                expect(options.some((option) => option.value === value)).toBe(true);
+            });
+        });
+        it('should return object reference ID for ObjectReference property type', () => {
+            const mockEntity = { id: 'test-id-123', name: 'Test Entity' };
+            const objectCache = new Map([['test-id-123', mockEntity]]);
+            mockObjectReferencesCache.set('custom-entity:test', objectCache);
+            const property = {
+                slug: 'parentId',
+                propertyType: types_1.PropertyType.ObjectReference,
+                propertyLevel: types_1.PropertyLevel.ALL,
+                referencedTypePath: 'custom-entity:test',
+            };
+            const result = (0, create_1.pickRandomValueForProperty)(property, mockObjectReferencesCache, mockTypeReferencesCache);
+            expect(result).toBe('test-id-123');
+        });
+        it('should return type reference ID for TypeReference property type', () => {
+            const mockType = { id: 'type-id-456', typePath: 'custom-entity:category' };
+            mockTypeReferencesCache.set('custom-entity:category', mockType);
+            const property = {
+                slug: 'categoryType',
+                propertyType: types_1.PropertyType.TypeReference,
+                propertyLevel: types_1.PropertyLevel.ALL,
+                referencedTypePath: 'custom-entity:category',
+            };
+            const result = (0, create_1.pickRandomValueForProperty)(property, mockObjectReferencesCache, mockTypeReferencesCache);
+            expect(result).toBe('type-id-456');
+        });
+    });
+    describe('buildObjectReferenceCache', () => {
+        it('should build a cache from entities with IDs', () => {
+            const entities = [
+                { id: 'entity-1', name: 'First Entity', type: 'test' },
+                { id: 'entity-2', name: 'Second Entity', type: 'test' },
+                { id: 'entity-3', name: 'Third Entity', type: 'test' },
+            ];
+            const cache = (0, create_1.buildObjectReferenceCache)(entities);
+            expect(cache.size).toBe(3);
+            expect(cache.get('entity-1')).toEqual(entities[0]);
+            expect(cache.get('entity-2')).toEqual(entities[1]);
+            expect(cache.get('entity-3')).toEqual(entities[2]);
+        });
+    });
+    describe('getReferencedObjectPaths', () => {
+        it('should extract object reference paths from type properties', () => {
+            const mockType = {
+                id: 'test-type',
+                typePath: 'item',
+                typeProperties: [
+                    {
+                        slug: 'name',
+                        propertyType: types_1.PropertyType.String,
+                        propertyLevel: types_1.PropertyLevel.ALL,
+                    },
+                    {
+                        slug: 'categoryId',
+                        propertyType: types_1.PropertyType.ObjectReference,
+                        propertyLevel: types_1.PropertyLevel.ALL,
+                        referencedTypePath: 'custom-entity:category',
+                    },
+                    {
+                        slug: 'supplierId',
+                        propertyType: types_1.PropertyType.ObjectReference,
+                        propertyLevel: types_1.PropertyLevel.ALL,
+                        referencedTypePath: 'custom-entity:supplier',
+                    },
+                    {
+                        slug: 'description',
+                        propertyType: types_1.PropertyType.Text,
+                        propertyLevel: types_1.PropertyLevel.ALL,
+                    },
+                ],
+            };
+            const referencedPaths = (0, create_1.getReferencedObjectPaths)(mockType);
+            expect(referencedPaths).toEqual(['custom-entity:category', 'custom-entity:supplier']);
+        });
+        it('should return empty array when no object references exist', () => {
+            const mockType = {
+                id: 'test-type',
+                typePath: 'item',
+                typeProperties: [
+                    {
+                        slug: 'name',
+                        propertyType: types_1.PropertyType.String,
+                        propertyLevel: types_1.PropertyLevel.ALL,
+                    },
+                    {
+                        slug: 'isActive',
+                        propertyType: types_1.PropertyType.Boolean,
+                        propertyLevel: types_1.PropertyLevel.ALL,
+                    },
+                ],
+            };
+            expect((0, create_1.getReferencedObjectPaths)(mockType)).toEqual([]);
+        });
+    });
+    describe('Integration: Complete entity creation flow', () => {
+        it('should create a complete entity with all property types populated', () => {
+            // Mock a comprehensive type with various property types
+            const mockType = {
+                id: 'comprehensive-type',
+                typePath: 'item',
+                typeProperties: [
+                    {
+                        slug: 'name',
+                        propertyType: types_1.PropertyType.String,
+                        propertyLevel: types_1.PropertyLevel.ALL,
+                    },
+                    {
+                        slug: 'isActive',
+                        propertyType: types_1.PropertyType.Boolean,
+                        propertyLevel: types_1.PropertyLevel.ALL,
+                    },
+                    {
+                        slug: 'quantity',
+                        propertyType: types_1.PropertyType.Number,
+                        propertyLevel: types_1.PropertyLevel.ALL,
+                    },
+                    {
+                        slug: 'color',
+                        propertyType: types_1.PropertyType.SingleSelect,
+                        propertyLevel: types_1.PropertyLevel.ALL,
+                        options: [
+                            { value: 'red', display: 'Red' },
+                            { value: 'blue', display: 'Blue' },
+                            { value: 'green', display: 'Green' },
+                        ],
+                    },
+                    {
+                        slug: 'features',
+                        propertyType: types_1.PropertyType.MultiSelect,
+                        propertyLevel: types_1.PropertyLevel.ALL,
+                        options: [
+                            { value: 'waterproof', display: 'Waterproof' },
+                            { value: 'durable', display: 'Durable' },
+                            { value: 'lightweight', display: 'Lightweight' },
+                        ],
+                    },
+                ],
+            };
+            // Create mock caches
+            const objectReferencesCache = new Map();
+            const typeReferencesCache = new Map();
+            // Generate random values for each property
+            const generatedEntity = {};
+            for (const property of mockType.typeProperties) {
+                const value = (0, create_1.pickRandomValueForProperty)(property, objectReferencesCache, typeReferencesCache);
+                generatedEntity[property.slug] = value;
+            }
+            // Verify all properties are populated with correct types
+            expect(typeof generatedEntity.name).toBe('string');
+            expect(generatedEntity.name.length).toBeGreaterThan(0);
+            expect(typeof generatedEntity.isActive).toBe('boolean');
+            expect(typeof generatedEntity.quantity).toBe('number');
+            expect(generatedEntity.quantity).toBeGreaterThanOrEqual(0);
+            expect(['red', 'blue', 'green']).toContain(generatedEntity.color);
+            expect(Array.isArray(generatedEntity.features)).toBe(true);
+            expect(generatedEntity.features.length).toBeGreaterThan(0);
+            generatedEntity.features.forEach((feature) => {
+                expect(['waterproof', 'durable', 'lightweight']).toContain(feature);
+            });
+        });
+    });
+    describe('Property Specifications Integration', () => {
+        describe('parsePropertySpecificationsIntoMap', () => {
+            it('should parse simple property specifications', () => {
+                const specs = [
+                    'name=Test Item',
+                    'quantity=10',
+                    'isActive=true',
+                ];
+                const result = (0, propertySpecifications_1.parsePropertySpecificationsIntoMap)(specs);
+                expect(result.get('name')).toBe('Test Item');
+                expect(result.get('quantity')).toBe('10');
+                expect(result.get('isActive')).toBe('true');
+            });
+            it('should handle roles as comma-separated array', () => {
+                const specs = ['roles=option,family', 'name=Test'];
+                const result = (0, propertySpecifications_1.parsePropertySpecificationsIntoMap)(specs);
+                expect(result.get('roles')).toEqual(['option', 'family']);
+                expect(result.get('name')).toBe('Test');
+            });
+            it('should handle complex values with spaces and special characters', () => {
+                const specs = [
+                    'description=This is a long description with spaces',
+                    'hex=#FF0000',
+                ];
+                const result = (0, propertySpecifications_1.parsePropertySpecificationsIntoMap)(specs);
+                expect(result.get('description')).toBe('This is a long description with spaces');
+                expect(result.get('hex')).toBe('#FF0000');
+            });
+            it('should throw error for invalid specifications', () => {
+                expect(() => (0, propertySpecifications_1.parsePropertySpecificationsIntoMap)(['invalid-spec'])).toThrow('Invalid property specification: invalid-spec');
+                expect(() => (0, propertySpecifications_1.parsePropertySpecificationsIntoMap)(['=value'])).toThrow('Invalid property specification: =value');
+                expect(() => (0, propertySpecifications_1.parsePropertySpecificationsIntoMap)(['key='])).toThrow('Invalid property specification: key=');
+            });
+        });
+        describe('isValidPropertySpecification', () => {
+            it('should validate correct property specifications', () => {
+                expect((0, propertySpecifications_1.isValidPropertySpecification)('name=value')).toBe(true);
+                expect((0, propertySpecifications_1.isValidPropertySpecification)('id=123')).toBe(true);
+                expect((0, propertySpecifications_1.isValidPropertySpecification)('description=Long description with spaces')).toBe(true);
+                expect((0, propertySpecifications_1.isValidPropertySpecification)('roles=option,family')).toBe(true);
+            });
+            it('should reject invalid property specifications', () => {
+                expect((0, propertySpecifications_1.isValidPropertySpecification)('invalid')).toBe(false);
+                expect((0, propertySpecifications_1.isValidPropertySpecification)('=')).toBe(false);
+                expect((0, propertySpecifications_1.isValidPropertySpecification)('key=')).toBe(false);
+                expect((0, propertySpecifications_1.isValidPropertySpecification)('=value')).toBe(false);
+                expect((0, propertySpecifications_1.isValidPropertySpecification)('')).toBe(false);
+            });
+        });
+        describe('Property specifications with entity creation', () => {
+            it('should apply property specifications to override random values', () => {
+                const propertySpecs = (0, propertySpecifications_1.parsePropertySpecificationsIntoMap)([
+                    'name=Custom Name',
+                    'quantity=42',
+                    'isActive=true',
+                ]);
+                // Simulate the property specification override logic
+                const entity = {};
+                // First generate random values (simulated)
+                entity.name = 'random-name';
+                entity.quantity = 99;
+                entity.isActive = false;
+                // Then apply property specifications
+                for (const [slug, value] of propertySpecs.entries()) {
+                    entity[slug] = value;
+                }
+                expect(entity.name).toBe('Custom Name');
+                expect(entity.quantity).toBe('42'); // Note: type casting would happen in real implementation
+                expect(entity.isActive).toBe('true'); // Note: type casting would happen in real implementation
+            });
+            it('should handle roles property specification for filtering properties', () => {
+                const propertySpecs = (0, propertySpecifications_1.parsePropertySpecificationsIntoMap)([
+                    'roles=option',
+                ]);
+                const roles = propertySpecs.get('roles');
+                // Test that property level matching works with specified roles
+                expect((0, create_1.doesPropertyLevelMatchRole)(types_1.PropertyLevel.OPTION, roles[0])).toBe(true);
+                expect((0, create_1.doesPropertyLevelMatchRole)(types_1.PropertyLevel.FAMILY, roles[0])).toBe(false);
+                expect((0, create_1.doesPropertyLevelMatchRole)(types_1.PropertyLevel.ALL, roles[0])).toBe(true);
+                expect((0, create_1.doesPropertyLevelMatchRole)(types_1.PropertyLevel.OVERRIDABLE, roles[0])).toBe(true);
+            });
+        });
+    });
+    describe('Error Handling and Edge Cases', () => {
+        describe('pickRandomValueForProperty error scenarios', () => {
+            const mockObjectReferencesCache = new Map();
+            const mockTypeReferencesCache = new Map();
+            it('should throw error for SingleSelect without options', () => {
+                const property = {
+                    slug: 'color',
+                    propertyType: types_1.PropertyType.SingleSelect,
+                    propertyLevel: types_1.PropertyLevel.ALL,
+                    // Missing options property
+                };
+                expect(() => (0, create_1.pickRandomValueForProperty)(property, mockObjectReferencesCache, mockTypeReferencesCache)).toThrow('Option set is required for SingleSelect property');
+            });
+            it('should throw error for MultiSelect without options', () => {
+                const property = {
+                    slug: 'features',
+                    propertyType: types_1.PropertyType.MultiSelect,
+                    propertyLevel: types_1.PropertyLevel.ALL,
+                    // Missing options property
+                };
+                expect(() => (0, create_1.pickRandomValueForProperty)(property, mockObjectReferencesCache, mockTypeReferencesCache)).toThrow('Option set is required for MultiSelect property');
+            });
+            it('should throw error for ObjectReference with missing cache', () => {
+                const property = {
+                    slug: 'categoryId',
+                    propertyType: types_1.PropertyType.ObjectReference,
+                    propertyLevel: types_1.PropertyLevel.ALL,
+                    referencedTypePath: 'custom-entity:nonexistent',
+                };
+                expect(() => (0, create_1.pickRandomValueForProperty)(property, mockObjectReferencesCache, mockTypeReferencesCache)).toThrow('No object references found for referencedTypePath: custom-entity:nonexistent');
+            });
+            it('should throw error for ObjectReference with empty cache', () => {
+                const emptyCache = new Map();
+                emptyCache.set('custom-entity:empty', new Map());
+                const property = {
+                    slug: 'categoryId',
+                    propertyType: types_1.PropertyType.ObjectReference,
+                    propertyLevel: types_1.PropertyLevel.ALL,
+                    referencedTypePath: 'custom-entity:empty',
+                };
+                expect(() => (0, create_1.pickRandomValueForProperty)(property, emptyCache, mockTypeReferencesCache)).toThrow('No object references found for referencedTypePath: custom-entity:empty');
+            });
+            it('should throw error for TypeReference with missing type', () => {
+                const property = {
+                    slug: 'categoryType',
+                    propertyType: types_1.PropertyType.TypeReference,
+                    propertyLevel: types_1.PropertyLevel.ALL,
+                    referencedTypePath: 'custom-entity:nonexistent',
+                };
+                expect(() => (0, create_1.pickRandomValueForProperty)(property, mockObjectReferencesCache, mockTypeReferencesCache)).toThrow('Referenced type not found for path: custom-entity:nonexistent');
+            });
+            it('should throw error for unsupported property type', () => {
+                const property = {
+                    slug: 'unsupported',
+                    propertyType: 'UnsupportedType',
+                    propertyLevel: types_1.PropertyLevel.ALL,
+                };
+                expect(() => (0, create_1.pickRandomValueForProperty)(property, mockObjectReferencesCache, mockTypeReferencesCache)).toThrow('Cannot handle property type: UnsupportedType');
+            });
+            it('should handle Formula property type gracefully', () => {
+                const property = {
+                    slug: 'calculatedValue',
+                    propertyType: types_1.PropertyType.Formula,
+                    propertyLevel: types_1.PropertyLevel.ALL,
+                };
+                const result = (0, create_1.pickRandomValueForProperty)(property, mockObjectReferencesCache, mockTypeReferencesCache);
+                expect(result).toBeUndefined();
+            });
+        });
+        describe('Cache building edge cases', () => {
+            it('should handle empty entities array', () => {
+                const cache = (0, create_1.buildObjectReferenceCache)([]);
+                expect(cache.size).toBe(0);
+            });
+            it('should handle entities without IDs gracefully', () => {
+                const entitiesWithoutIds = [
+                    { name: 'Entity 1' },
+                    { id: 'entity-2', name: 'Entity 2' },
+                    undefined, // Undefined entity
+                ].filter(Boolean); // Remove undefined
+                const cache = (0, create_1.buildObjectReferenceCache)(entitiesWithoutIds);
+                expect(cache.size).toBe(1); // Only the valid entity with ID
+                expect(cache.get('entity-2')).toEqual({ id: 'entity-2', name: 'Entity 2' });
+            });
+            it('should handle duplicate entity IDs', () => {
+                const entitiesWithDuplicates = [
+                    { id: 'duplicate-id', name: 'First Entity' },
+                    { id: 'duplicate-id', name: 'Second Entity' },
+                    { id: 'unique-id', name: 'Unique Entity' },
+                ];
+                const cache = (0, create_1.buildObjectReferenceCache)(entitiesWithDuplicates);
+                expect(cache.size).toBe(2);
+                // Should keep the first occurrence
+                expect(cache.get('duplicate-id')).toEqual({ id: 'duplicate-id', name: 'First Entity' });
+                expect(cache.get('unique-id')).toEqual({ id: 'unique-id', name: 'Unique Entity' });
+            });
+        });
+        describe('Reference path extraction edge cases', () => {
+            it('should handle type with no properties', () => {
+                const typeWithNoProperties = {
+                    id: 'empty-type',
+                    typePath: 'item',
+                    typeProperties: [],
+                };
+                const referencedPaths = (0, create_1.getReferencedObjectPaths)(typeWithNoProperties);
+                expect(referencedPaths).toEqual([]);
+            });
+            it('should handle type with undefined typeProperties', () => {
+                const typeWithUndefinedProperties = {
+                    id: 'undefined-props-type',
+                    typePath: 'item',
+                    typeProperties: undefined,
+                };
+                const referencedPaths = (0, create_1.getReferencedObjectPaths)(typeWithUndefinedProperties);
+                expect(referencedPaths).toEqual([]);
+            });
+            it('should filter out non-ObjectReference properties correctly', () => {
+                const mixedType = {
+                    id: 'mixed-type',
+                    typePath: 'item',
+                    typeProperties: [
+                        {
+                            slug: 'name',
+                            propertyType: types_1.PropertyType.String,
+                            propertyLevel: types_1.PropertyLevel.ALL,
+                        },
+                        {
+                            slug: 'categoryId',
+                            propertyType: types_1.PropertyType.ObjectReference,
+                            propertyLevel: types_1.PropertyLevel.ALL,
+                            referencedTypePath: 'custom-entity:category',
+                        },
+                        {
+                            slug: 'isActive',
+                            propertyType: types_1.PropertyType.Boolean,
+                            propertyLevel: types_1.PropertyLevel.ALL,
+                        },
+                        {
+                            slug: 'supplierId',
+                            propertyType: types_1.PropertyType.ObjectReference,
+                            propertyLevel: types_1.PropertyLevel.ALL,
+                            referencedTypePath: 'custom-entity:supplier',
+                        },
+                        {
+                            slug: 'typeRef',
+                            propertyType: types_1.PropertyType.TypeReference,
+                            propertyLevel: types_1.PropertyLevel.ALL,
+                            referencedTypePath: 'custom-entity:type',
+                        },
+                    ],
+                };
+                const referencedPaths = (0, create_1.getReferencedObjectPaths)(mixedType);
+                expect(referencedPaths).toEqual(['custom-entity:category', 'custom-entity:supplier']);
+                expect(referencedPaths).not.toContain('custom-entity:type'); // TypeReference should not be included
+            });
+        });
+        describe('Property level and role matching edge cases', () => {
+            it('should handle valid roles correctly', () => {
+                expect((0, create_1.doesPropertyLevelMatchRole)(types_1.PropertyLevel.OPTION, 'option')).toBe(true);
+                expect((0, create_1.doesPropertyLevelMatchRole)(types_1.PropertyLevel.FAMILY, 'family')).toBe(true);
+                expect((0, create_1.doesPropertyLevelMatchRole)(types_1.PropertyLevel.ALL, 'option')).toBe(true);
+                expect((0, create_1.doesPropertyLevelMatchRole)(types_1.PropertyLevel.ALL, 'family')).toBe(true);
+                expect((0, create_1.doesPropertyLevelMatchRole)(types_1.PropertyLevel.OVERRIDABLE, 'option')).toBe(true);
+                expect((0, create_1.doesPropertyLevelMatchRole)(types_1.PropertyLevel.OVERRIDABLE, 'family')).toBe(true);
+            });
+            it('should reject mismatched property levels and roles', () => {
+                expect((0, create_1.doesPropertyLevelMatchRole)(types_1.PropertyLevel.OPTION, 'family')).toBe(false);
+                expect((0, create_1.doesPropertyLevelMatchRole)(types_1.PropertyLevel.FAMILY, 'option')).toBe(false);
+            });
+        });
+    });
+});

package/dist/commands/entities/delete.d.ts

@@ -0,0 +1,16 @@
+import { BaseCommand } from '../../basecommand';
+export default class DeleteEntity extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        dryRun: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        input: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        id: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        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>;
+    };
+    static args: {
+        entityName: import("@oclif/core/lib/interfaces/parser").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/entities/delete.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const p_limit_1 = tslib_1.__importDefault(require("p-limit"));
+const basecommand_1 = require("../../basecommand");
+const sdk_1 = require("@contrail/sdk");
+const login_1 = require("../../auth/login");
+const file_helpers_1 = require("../../helpers/file-helpers");
+let IS_DRY_RUN = false;
+class DeleteEntity extends basecommand_1.BaseCommand {
+    static description = '(BETA) Delete an entity';
+    static examples = ['contrail entities delete color 123'];
+    static flags = {
+        ...basecommand_1.BaseCommand.baseFlags,
+        dryRun: core_1.Flags.boolean({
+            char: 'd',
+            description: 'If true, does not delete the entity but simulates the deletion',
+            required: false,
+            default: false,
+        }),
+        input: core_1.Flags.string({
+            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: core_1.Flags.string({
+            description: 'The unique identifier of the entity',
+            required: false,
+        }),
+    };
+    static args = {
+        entityName: core_1.Args.string({
+            description: 'The name of the entity type to delete',
+            required: true,
+        }),
+    };
+    async run() {
+        this.log('🚨 This command is in BETA and may change or be removed at any time.');
+        await (0, login_1.authUser)();
+        const { args, flags } = await this.parse(DeleteEntity);
+        const { entityName } = args;
+        const { id, input: inputFilename } = flags;
+        if (flags.dryRun) {
+            IS_DRY_RUN = true;
+            this.log('Running in dry run mode. No entities will be deleted.');
+        }
+        const jsonInput = inputFilename ? (0, file_helpers_1.parseFileAsJsonArray)(inputFilename) : undefined;
+        if (!jsonInput && !id) {
+            this.error('You must provide either an ID or a JSON input file with entities to delete.');
+        }
+        const ids = jsonInput ? jsonInput.map((item) => item.id) : [id];
+        try {
+            const response = await deleteEntityByIds(entityName, ids);
+            if (IS_DRY_RUN) {
+                this.log('simulated deletion of entities:');
+            }
+            else {
+                this.log('deleted entities:');
+            }
+            this.log(JSON.stringify(response, null, 2));
+        }
+        catch (e) {
+            this.error(`Error fetching entity: ${e.message}`);
+        }
+    }
+}
+exports.default = DeleteEntity;
+async function deleteEntityByIds(entityName, ids) {
+    const idsDeleted = new Set();
+    const idsNotFound = new Set();
+    const idsErrored = new Set();
+    const limit = (0, p_limit_1.default)(10);
+    const deletePromises = ids.map((id) => limit(() => deleteEntityById(entityName, id).then((entity) => {
+        if (!entity) {
+            idsNotFound.add(id);
+            return null;
+        }
+        idsDeleted.add(id);
+        return entity;
+    }, (error) => {
+        if (error.message.includes('not found')) {
+            idsNotFound.add(id);
+        }
+        else {
+            idsErrored.add(id);
+        }
+        return null;
+    })));
+    await Promise.all(deletePromises);
+    return {
+        idsDeleted: Array.from(idsDeleted),
+        idsNotFound: Array.from(idsNotFound),
+        idsErrored: Array.from(idsErrored),
+    };
+}
+async function deleteEntityById(entityName, id) {
+    const client = new sdk_1.Entities();
+    if (IS_DRY_RUN) {
+        return client.get({ entityName, id, ignore404: true }).catch(throwIfNot404);
+    }
+    return client.delete({ entityName, id, ignore404: true }).catch(throwIfNot404);
+}
+function throwIfNot404(e) {
+    const { statusCode } = parseSDKErrorMessage(e);
+    if (statusCode === 404) {
+        return null;
+    }
+    throw e;
+}
+function parseSDKErrorMessage(e) {
+    const parsed = JSON.parse(e.details);
+    return {
+        statusCode: parsed.statusCode,
+        message: parsed.message,
+    };
+}