@contrail/cli 3.4.0-alpha → 3.4.1

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

@@ -1,65 +0,0 @@
-"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.getManyItems)(),
-    ]);
-    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/propertySpecifications/dateRanges.d.ts

@@ -1,38 +0,0 @@
-/**
- * Date Range Parsing Utilities
- *
- * Handles parsing date range syntax like:
- * - createdOn=2025-09-15..2025-09-16 (date range)
- * - createdOn=2025-09-15T04:00:00Z..2025-09-16T03:59:59Z (timestamp range)
- * - createdOn=2025-09-15.. (from date onwards)
- * - createdOn=..2025-09-16 (until date)
- */
-export type DateRange = {
-    start?: Date;
-    end?: Date;
-};
-export type DateRangeSpecification = {
-    slug: string;
-    range: DateRange;
-};
-/**
- * Checks if a property specification contains date range syntax (..)
- */
-export declare function isDateRangeSpecification(spec: string): boolean;
-/**
- * Parses a date range specification into its components
- * @param spec - The specification string (e.g., "createdOn=2025-09-15..2025-09-16")
- */
-export declare function parseDateRangeSpecification(spec: string): DateRangeSpecification;
-/**
- * Parses a date string, handling both date-only and full timestamp formats
- * @param dateStr - Date string (e.g., "2025-09-15" or "2025-09-15T04:00:00Z")
- * @param boundType - Whether this is the 'start' or 'end' of a range (affects date-only handling)
- */
-export declare function parseDate(dateStr: string, boundType?: 'start' | 'end'): Date;
-/**
- * Converts a date range to JSURL BETWEEN format
- * @param range - The date range object
- * @param isEndOfRange - Whether this date represents the end of a range (affects date-only handling)
- */
-export declare function convertDateRangeToJSURL(range: DateRange): string;

package/dist/helpers/propertySpecifications/dateRanges.js

@@ -1,89 +0,0 @@
-"use strict";
-/**
- * Date Range Parsing Utilities
- *
- * Handles parsing date range syntax like:
- * - createdOn=2025-09-15..2025-09-16 (date range)
- * - createdOn=2025-09-15T04:00:00Z..2025-09-16T03:59:59Z (timestamp range)
- * - createdOn=2025-09-15.. (from date onwards)
- * - createdOn=..2025-09-16 (until date)
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertDateRangeToJSURL = exports.parseDate = exports.parseDateRangeSpecification = exports.isDateRangeSpecification = void 0;
-/**
- * Checks if a property specification contains date range syntax (..)
- */
-function isDateRangeSpecification(spec) {
-    return spec.includes('=') && spec.includes('..');
-}
-exports.isDateRangeSpecification = isDateRangeSpecification;
-/**
- * Parses a date range specification into its components
- * @param spec - The specification string (e.g., "createdOn=2025-09-15..2025-09-16")
- */
-function parseDateRangeSpecification(spec) {
-    const equalsIndex = spec.indexOf('=');
-    if (equalsIndex === -1) {
-        throw new Error(`Invalid date range specification: ${spec}`);
-    }
-    const slug = spec.substring(0, equalsIndex);
-    const rangeValue = spec.substring(equalsIndex + 1);
-    if (!slug || !rangeValue || !rangeValue.includes('..')) {
-        throw new Error(`Invalid date range specification: ${spec}`);
-    }
-    const [startStr, endStr] = rangeValue.split('..');
-    const range = {
-        start: startStr.trim() ? parseDate(startStr.trim(), 'start') : undefined,
-        end: endStr.trim() ? parseDate(endStr.trim(), 'end') : undefined,
-    };
-    // At least one bound must be specified
-    if (!range.start && !range.end) {
-        throw new Error(`Date range must have at least one bound: ${spec}`);
-    }
-    return { slug, range };
-}
-exports.parseDateRangeSpecification = parseDateRangeSpecification;
-/**
- * Parses a date string, handling both date-only and full timestamp formats
- * @param dateStr - Date string (e.g., "2025-09-15" or "2025-09-15T04:00:00Z")
- * @param boundType - Whether this is the 'start' or 'end' of a range (affects date-only handling)
- */
-function parseDate(dateStr, boundType = 'start') {
-    if (!dateStr.includes('T')) {
-        if (boundType === 'start') {
-            dateStr = `${dateStr}T00:00:00.000Z`;
-        }
-        else {
-            dateStr = `${dateStr}T23:59:59.999Z`;
-        }
-    }
-    const date = new Date(dateStr);
-    if (isNaN(date.getTime())) {
-        throw new Error(`Invalid date format: ${dateStr}`);
-    }
-    return date;
-}
-exports.parseDate = parseDate;
-/**
- * Converts a date range to JSURL BETWEEN format
- * @param range - The date range object
- * @param isEndOfRange - Whether this date represents the end of a range (affects date-only handling)
- */
-function convertDateRangeToJSURL(range) {
-    if (!range.start && !range.end) {
-        throw new Error('Date range must have at least one bound');
-    }
-    if (range.start && range.end) {
-        const startISO = range.start.toISOString();
-        const endISO = range.end.toISOString();
-        return `BETWEEN ${startISO} and ${endISO}`;
-    }
-    else if (range.start) {
-        return `>= ${range.start.toISOString()}`;
-    }
-    else {
-        const endISO = range.end.toISOString();
-        return `<= ${endISO}`;
-    }
-}
-exports.convertDateRangeToJSURL = convertDateRangeToJSURL;

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

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

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

@@ -1,95 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const dateRanges_1 = require("./dateRanges");
-describe('Date Range Specifications', () => {
-    describe('isDateRangeSpecification', () => {
-        it('should identify valid date range specifications', () => {
-            expect((0, dateRanges_1.isDateRangeSpecification)('createdOn=2025-09-15..2025-09-16')).toBe(true);
-            expect((0, dateRanges_1.isDateRangeSpecification)('updatedAt=2025-09-15T04:00:00Z..2025-09-16T03:59:59Z')).toBe(true);
-            expect((0, dateRanges_1.isDateRangeSpecification)('date=2025-09-15..')).toBe(true);
-            expect((0, dateRanges_1.isDateRangeSpecification)('date=..2025-09-16')).toBe(true);
-        });
-        it('should reject non-date-range specifications', () => {
-            expect((0, dateRanges_1.isDateRangeSpecification)('id=123')).toBe(false);
-            expect((0, dateRanges_1.isDateRangeSpecification)('name=test')).toBe(false);
-            expect((0, dateRanges_1.isDateRangeSpecification)('invalid')).toBe(false);
-            expect((0, dateRanges_1.isDateRangeSpecification)('field=value')).toBe(false);
-        });
-    });
-    describe('parseDate', () => {
-        it('should parse ISO timestamps correctly', () => {
-            const date = (0, dateRanges_1.parseDate)('2025-09-15T04:00:00Z');
-            expect(date.toISOString()).toBe('2025-09-15T04:00:00.000Z');
-        });
-        it('should parse date-only strings as start of day', () => {
-            const date = (0, dateRanges_1.parseDate)('2025-09-15', 'start');
-            expect(date.toISOString()).toBe('2025-09-15T00:00:00.000Z');
-        });
-        it('should parse date-only strings as end of day for end bound', () => {
-            const date = (0, dateRanges_1.parseDate)('2025-09-15', 'end');
-            expect(date.toISOString()).toBe('2025-09-15T23:59:59.999Z');
-        });
-        it('should throw for invalid date strings', () => {
-            expect(() => (0, dateRanges_1.parseDate)('invalid-date')).toThrow('Invalid date format');
-            expect(() => (0, dateRanges_1.parseDate)('2025-13-50')).toThrow('Invalid date format');
-        });
-    });
-    describe('parseDateRangeSpecification', () => {
-        it('should parse full date ranges', () => {
-            const result = (0, dateRanges_1.parseDateRangeSpecification)('createdOn=2025-09-15..2025-09-16');
-            expect(result.slug).toBe('createdOn');
-            expect(result.range.start).toEqual(new Date('2025-09-15T00:00:00.000Z'));
-            expect(result.range.end).toEqual(new Date('2025-09-16T23:59:59.999Z'));
-        });
-        it('should parse open-ended start ranges', () => {
-            const result = (0, dateRanges_1.parseDateRangeSpecification)('createdOn=2025-09-15..');
-            expect(result.slug).toBe('createdOn');
-            expect(result.range.start).toEqual(new Date('2025-09-15T00:00:00.000Z'));
-            expect(result.range.end).toBeUndefined();
-        });
-        it('should parse open-ended end ranges', () => {
-            const result = (0, dateRanges_1.parseDateRangeSpecification)('createdOn=..2025-09-16');
-            expect(result.slug).toBe('createdOn');
-            expect(result.range.start).toBeUndefined();
-            expect(result.range.end).toEqual(new Date('2025-09-16T23:59:59.999Z'));
-        });
-        it('should parse timestamp ranges', () => {
-            const result = (0, dateRanges_1.parseDateRangeSpecification)('createdOn=2025-09-15T04:00:00Z..2025-09-16T03:59:59Z');
-            expect(result.slug).toBe('createdOn');
-            expect(result.range.start).toEqual(new Date('2025-09-15T04:00:00.000Z'));
-            expect(result.range.end).toEqual(new Date('2025-09-16T03:59:59.000Z'));
-        });
-        it('should throw for invalid specifications', () => {
-            expect(() => (0, dateRanges_1.parseDateRangeSpecification)('invalid')).toThrow('Invalid date range specification');
-            expect(() => (0, dateRanges_1.parseDateRangeSpecification)('field=..')).toThrow('Date range must have at least one bound');
-            expect(() => (0, dateRanges_1.parseDateRangeSpecification)('field=invalid..date')).toThrow('Invalid date format');
-        });
-    });
-    describe('convertDateRangeToJSURL', () => {
-        it('should convert full ranges to BETWEEN format', () => {
-            const range = {
-                start: new Date('2025-09-15T00:00:00.000Z'),
-                end: new Date('2025-09-16T23:59:59.999Z'),
-            };
-            const result = (0, dateRanges_1.convertDateRangeToJSURL)(range);
-            expect(result).toBe('BETWEEN 2025-09-15T00:00:00.000Z and 2025-09-16T23:59:59.999Z');
-        });
-        it('should convert start-only ranges to >= format', () => {
-            const range = {
-                start: new Date('2025-09-15T00:00:00.000Z'),
-            };
-            const result = (0, dateRanges_1.convertDateRangeToJSURL)(range);
-            expect(result).toBe('>= 2025-09-15T00:00:00.000Z');
-        });
-        it('should convert end-only ranges to <= format', () => {
-            const range = {
-                end: new Date('2025-09-16T23:59:59.999Z'),
-            };
-            const result = (0, dateRanges_1.convertDateRangeToJSURL)(range);
-            expect(result).toBe('<= 2025-09-16T23:59:59.999Z');
-        });
-        it('should throw for empty ranges', () => {
-            expect(() => (0, dateRanges_1.convertDateRangeToJSURL)({})).toThrow('Date range must have at least one bound');
-        });
-    });
-});

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

@@ -1,27 +0,0 @@
-/**
- * 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
- * contrail entities get loader-processes -- createdOn=2025-09-15..2025-09-16
- */
-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

@@ -1,70 +0,0 @@
-"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
- * contrail entities get loader-processes -- createdOn=2025-09-15..2025-09-16
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isValidPropertySpecification = exports.parsePropertySpecificationsIntoMap = exports.parsePropertySpecification = void 0;
-const dateRanges_1 = require("./dateRanges");
-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) {
-        if ((0, dateRanges_1.isDateRangeSpecification)(spec)) {
-            const { slug, range } = (0, dateRanges_1.parseDateRangeSpecification)(spec);
-            const jsUrlValue = (0, dateRanges_1.convertDateRangeToJSURL)(range);
-            propertySpecBySlug.set(slug, jsUrlValue);
-            continue;
-        }
-        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 {
-        if ((0, dateRanges_1.isDateRangeSpecification)(maybeSpec)) {
-            (0, dateRanges_1.parseDateRangeSpecification)(maybeSpec);
-            return true;
-        }
-        const { slug, value } = parsePropertySpecification(maybeSpec);
-        return !!slug && !!value;
-    }
-    catch (e) {
-        return false;
-    }
-}
-exports.isValidPropertySpecification = isValidPropertySpecification;

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

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

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

@@ -1,266 +0,0 @@
-"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',
-        });
-    });
-});