@contrail/cli 3.1.8 → 3.3.0-alpha

package/dist/helpers/entities/items.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.throwIfInvalidItemLevel = exports.Roles = exports.getFamilyName = exports.getItemFamilies = exports.getAllItems = exports.getAllItemsUsingCacheFallback = exports.throwIfInvalidItemId = void 0;
+const sdk_1 = require("@contrail/sdk");
+async function throwIfInvalidItemId(itemId) {
+    if (!(await doesItemExistById(itemId))) {
+        throw new Error(`Item with ID ${itemId} does not exist`);
+    }
+}
+exports.throwIfInvalidItemId = throwIfInvalidItemId;
+async function doesItemExistById(id) {
+    const client = new sdk_1.Entities();
+    const item = await client.get({ entityName: 'item', id });
+    return !!item;
+}
+const ITEMS_CACHE_BY_ID = new Map();
+async function getAllItemsUsingCacheFallback() {
+    if (ITEMS_CACHE_BY_ID.size > 0) {
+        return Array.from(ITEMS_CACHE_BY_ID.values());
+    }
+    const items = await getAllItems();
+    items.forEach((item) => {
+        ITEMS_CACHE_BY_ID.set(item.id, item);
+    });
+    return items;
+}
+exports.getAllItemsUsingCacheFallback = getAllItemsUsingCacheFallback;
+async function getAllItems() {
+    const client = new sdk_1.Entities();
+    const MAX_ITEMS = 100000;
+    // paginate to get all items
+    // Note: This will only return the first 100 assortments by default.
+    const items = [];
+    let nextPageKey = undefined;
+    while (true) {
+        const response = await client.get({
+            entityName: 'item',
+            apiVersion: sdk_1.API_VERSION.V2,
+            //      customParams: { propertySlugs: 'id,familyId,roles,name' }, // not compatible with V2 for some reason
+            nextPageKey,
+        });
+        nextPageKey = response.nextPageKey;
+        if (response.results.length === 0) {
+            break; // No more assortments to fetch
+        }
+        items.push(...response.results);
+        if (items.length >= MAX_ITEMS) {
+            console.warn(`Reached maximum item limit of ${MAX_ITEMS}. Some items may not be included.`);
+            break; // Stop if we reach the maximum limit
+        }
+    }
+    return items;
+}
+exports.getAllItems = getAllItems;
+async function getItemFamilies() {
+    const allItems = await getAllItemsUsingCacheFallback();
+    const allItemFamiles = allItems.filter(({ roles }) => roles.includes('family'));
+    return allItemFamiles;
+}
+exports.getItemFamilies = getItemFamilies;
+async function getFamilyName(item) {
+    if (!item.roles.includes('option')) {
+        return undefined;
+    }
+    if (!item.familyId) {
+        return undefined;
+    }
+    await ensureItemCacheIsPopulated();
+    const family = ITEMS_CACHE_BY_ID.get(item.familyId);
+    return family ? [family.name] : ['placeholder']; // placeholder if family not found
+}
+exports.getFamilyName = getFamilyName;
+async function ensureItemCacheIsPopulated() {
+    if (ITEMS_CACHE_BY_ID.size === 0) {
+        await getAllItemsUsingCacheFallback();
+    }
+}
+exports.Roles = ['option', 'family'];
+function throwIfInvalidItemLevel(role) {
+    if (!exports.Roles.includes(role)) {
+        throw new Error(`Invalid role: ${role}. Valid roles are: ${exports.Roles.join(', ')}`);
+    }
+}
+exports.throwIfInvalidItemLevel = throwIfInvalidItemLevel;

package/dist/helpers/entities/project-items.d.ts

@@ -0,0 +1,3 @@
+import { Item } from '@contrail/entity-types';
+export declare function throwIfInvalidProjectId(projectId: string): Promise<void>;
+export declare function findItemsNotInProject(projectId: string): Promise<Item[]>;

package/dist/helpers/entities/project-items.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findItemsNotInProject = exports.throwIfInvalidProjectId = void 0;
+const sdk_1 = require("@contrail/sdk");
+const batchFetch_1 = require("./batchFetch");
+const items_1 = require("./items");
+const PROJECT_ITEMS_CACHE_BY_PROJECT_ID = new Map();
+const PROJECT_ITEMS_CACHE_BY_ITEM_ID = new Map();
+async function throwIfInvalidProjectId(projectId) {
+    if (!(await doesProjectExistById(projectId))) {
+        throw new Error(`Project with ID ${projectId} does not exist`);
+    }
+}
+exports.throwIfInvalidProjectId = throwIfInvalidProjectId;
+async function doesProjectExistById(id) {
+    const client = new sdk_1.Entities();
+    const project = await client
+        .get({
+        entityName: 'project',
+        id,
+        customParams: { propertySlugs: 'id' },
+    })
+        .catch((e) => {
+        console.error(e);
+        return null; // Return null if project does not exist
+    });
+    return !!project;
+}
+async function cacheProjectItemsByProjectId(projectId) {
+    if (PROJECT_ITEMS_CACHE_BY_PROJECT_ID.has(projectId)) {
+        return; // Already cached
+    }
+    const projectItems = await (0, batchFetch_1.batchFetch)('project-item', {
+        criteria: { projectId },
+        customParams: { propertySlugs: 'id,projectId,assortmentId' },
+    });
+    PROJECT_ITEMS_CACHE_BY_PROJECT_ID.set(projectId, projectItems);
+    projectItems.forEach((item) => {
+        if (!PROJECT_ITEMS_CACHE_BY_ITEM_ID.has(item.itemId)) {
+            PROJECT_ITEMS_CACHE_BY_ITEM_ID.set(item.itemId, []);
+        }
+        PROJECT_ITEMS_CACHE_BY_ITEM_ID.get(item.itemId).push(item);
+    });
+}
+async function getProjectItemsByProjectId(projectId) {
+    await cacheProjectItemsByProjectId(projectId);
+    const projectItems = PROJECT_ITEMS_CACHE_BY_PROJECT_ID.get(projectId);
+    if (!projectItems) {
+        throw new Error(`No project items found for project ID ${projectId}`);
+    }
+    return projectItems;
+}
+async function findItemsNotInProject(projectId) {
+    const [projectItemsInProject, allItems] = await Promise.all([
+        getProjectItemsByProjectId(projectId),
+        (0, items_1.getAllItems)(),
+    ]);
+    const projectItemIds = new Set(projectItemsInProject.map((item) => item.itemId));
+    const itemsNotInProject = allItems.filter((item) => !projectItemIds.has(item.id));
+    if (itemsNotInProject.length === 0) {
+        throw new Error(`All items are already in project ${projectId}`);
+    }
+    return itemsNotInProject.sort((a, b) => a.id.localeCompare(b.id)); // sorting ensures consistent order of response
+}
+exports.findItemsNotInProject = findItemsNotInProject;

package/dist/helpers/file-helpers.d.ts

@@ -1,2 +1,3 @@
 export declare function safeFileOverwrite(fileLocation: string, overwrite: boolean): Promise<boolean>;
 export declare function parseCSVData(data: string): any;
+export declare function parseFileAsJsonArray(fileName: string): any[];

package/dist/helpers/file-helpers.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseCSVData = exports.safeFileOverwrite = void 0;
+exports.parseFileAsJsonArray = exports.parseCSVData = exports.safeFileOverwrite = void 0;
 const tslib_1 = require("tslib");
+const fs_1 = tslib_1.__importDefault(require("fs"));
 const inquirer_1 = tslib_1.__importDefault(require("inquirer"));
 const logger_1 = tslib_1.__importDefault(require("../logger"));
 const sync_1 = require("csv-parse/sync");
@@ -34,3 +35,20 @@ function parseCSVData(data) {
     });
 }
 exports.parseCSVData = parseCSVData;
+function parseFileAsJsonArray(fileName) {
+    if (!fs_1.default.existsSync(fileName)) {
+        throw new Error(`File not found: ${fileName}`);
+    }
+    const fileContent = fs_1.default.readFileSync(fileName, 'utf-8');
+    try {
+        const jsonArray = JSON.parse(fileContent);
+        if (!Array.isArray(jsonArray)) {
+            throw new Error(`File content is not a valid JSON array: ${fileName}`);
+        }
+        return jsonArray;
+    }
+    catch (error) {
+        throw new Error(`Error parsing JSON from file ${fileName}: ${error.message}`);
+    }
+}
+exports.parseFileAsJsonArray = parseFileAsJsonArray;

package/dist/helpers/propertySpecifications/propertySpecifications.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Property Specification
+ *
+ * Property Specifications is an argument pattern used to express that
+ * a specific property has a specific value. In GET requests, this is used
+ * to specify the query parameters. In PUT requests, this is used to
+ * specify the properties to update.
+ *
+ * Each follows the format: slug=value
+ *
+ * It is typically used as the argv in a command.
+ *
+ * Examples:
+ *
+ * contrail entities get color -- id=123
+ * contrail entities update color 123 -- name=obsidian hex=000000
+ */
+export type PropertySpecification = {
+    slug: string;
+    value: string;
+};
+export type PropertySpecificationBySlug = Map<string, string | number | string[] | number[]>;
+export type PropertySpecificationString = `${string}=${string}`;
+export declare function parsePropertySpecification(spec: PropertySpecificationString): PropertySpecification;
+export declare function parsePropertySpecificationsIntoMap(propertySpecifications: PropertySpecificationString[]): PropertySpecificationBySlug;
+export declare function isValidPropertySpecification(maybeSpec: string): maybeSpec is PropertySpecificationString;

package/dist/helpers/propertySpecifications/propertySpecifications.js

@@ -0,0 +1,58 @@
+"use strict";
+/**
+ * Property Specification
+ *
+ * Property Specifications is an argument pattern used to express that
+ * a specific property has a specific value. In GET requests, this is used
+ * to specify the query parameters. In PUT requests, this is used to
+ * specify the properties to update.
+ *
+ * Each follows the format: slug=value
+ *
+ * It is typically used as the argv in a command.
+ *
+ * Examples:
+ *
+ * contrail entities get color -- id=123
+ * contrail entities update color 123 -- name=obsidian hex=000000
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidPropertySpecification = exports.parsePropertySpecificationsIntoMap = exports.parsePropertySpecification = void 0;
+function parsePropertySpecification(spec) {
+    const equalsIndex = spec.indexOf('=');
+    if (equalsIndex === -1) {
+        throw new Error(`Invalid property specification: ${spec}`);
+    }
+    const slug = spec.substring(0, equalsIndex);
+    const value = spec.substring(equalsIndex + 1);
+    if (!slug || !value) {
+        throw new Error(`Invalid property specification: ${spec}`);
+    }
+    return { slug, value };
+}
+exports.parsePropertySpecification = parsePropertySpecification;
+function parsePropertySpecificationsIntoMap(propertySpecifications) {
+    const propertySpecBySlug = new Map();
+    for (const spec of propertySpecifications) {
+        const { slug, value } = parsePropertySpecification(spec);
+        if (slug === 'roles') {
+            // Special handling for roles, which can be an array
+            const rolesArray = value.split(',').map((role) => role.trim());
+            propertySpecBySlug.set(slug, rolesArray);
+            continue;
+        }
+        propertySpecBySlug.set(slug, value);
+    }
+    return propertySpecBySlug;
+}
+exports.parsePropertySpecificationsIntoMap = parsePropertySpecificationsIntoMap;
+function isValidPropertySpecification(maybeSpec) {
+    try {
+        const { slug, value } = parsePropertySpecification(maybeSpec);
+        return !!slug && !!value;
+    }
+    catch (e) {
+        return false;
+    }
+}
+exports.isValidPropertySpecification = isValidPropertySpecification;

package/dist/helpers/propertySpecifications/propertySpecifications.spec.d.ts

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

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',
+        });
+    });
+});