@contrail/cli 3.4.5 → 3.4.6-alpha.cffb28e

package/node_modules/@contrail/loader/lib/common/size-range-helpers.spec.js

@@ -0,0 +1,320 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const size_range_helpers_1 = require("./size-range-helpers");
+describe('size-range-helpers', () => {
+    let sizeRangeSanitizer;
+    beforeEach(() => {
+        sizeRangeSanitizer = new size_range_helpers_1.SizeRangeSanitizer();
+    });
+    describe('validateOneDimensionalSizeRanges', () => {
+        it('it should raise a warning when an entity has a value that does not exist in a one dimensional template', () => {
+            const sizeRangeTemplate = {
+                sizeRange: {
+                    sizes: ['S', 'M', 'L'],
+                },
+            };
+            const entity = {
+                [size_range_helpers_1.SIZE_RANGE_SLUG]: {
+                    sizes: ['S', 'M', 'XL'],
+                },
+            };
+            sizeRangeSanitizer.validateOneDimensionalSizeRanges(sizeRangeTemplate, entity);
+            expect(entity[size_range_helpers_1.SIZE_RANGE_SLUG]).toEqual({ sizes: ['S', 'M'] });
+            expect(sizeRangeSanitizer.getWarnings().length).toBe(1);
+            expect(sizeRangeSanitizer.getWarnings()[0]).toEqual({
+                errorMessage: 'Invalid sizes found for size range template',
+                sizeRangeTemplate,
+                passedSizeRangeSizes: ['XL'],
+                sizeRangeDimension: null,
+            });
+        });
+        it('should return validation warning if the size range template is in invalid (bad format)', () => {
+            const sizeRangeTemplate = {};
+            const entity = {
+                [size_range_helpers_1.SIZE_RANGE_SLUG]: {
+                    sizes: ['S', 'M', 'XL'],
+                },
+            };
+            sizeRangeSanitizer.validateOneDimensionalSizeRanges(sizeRangeTemplate, entity);
+            expect(entity[size_range_helpers_1.SIZE_RANGE_SLUG]).toEqual({ sizes: [] });
+            expect(sizeRangeSanitizer.getWarnings().length).toBe(1);
+            expect(sizeRangeSanitizer.getWarnings()[0]).toEqual({
+                errorMessage: 'Invalid sizes found for size range template',
+                sizeRangeTemplate: {},
+                passedSizeRangeSizes: ['S', 'M', 'XL'],
+                sizeRangeDimension: null,
+            });
+        });
+        it('should not return warning on empty entity', () => {
+            const sizeRangeTemplate = {
+                sizeRange: {
+                    sizes: ['S', 'M', 'L'],
+                },
+            };
+            const entity = {};
+            sizeRangeSanitizer.validateOneDimensionalSizeRanges(sizeRangeTemplate, entity);
+            expect(entity[size_range_helpers_1.SIZE_RANGE_SLUG]).toBeUndefined();
+            expect(sizeRangeSanitizer.getWarnings().length).toBe(0);
+        });
+    });
+    describe('validateTwoDimensionalSizeRanges', () => {
+        it('should return warning for each dimension if the entity includes size ranges that are not in the template.', () => {
+            const sizeRangeTemplate = {
+                sizeRange: {
+                    sizes: {
+                        dimension1: ['S', 'M', 'L'],
+                        dimension2: ['Red', 'Blue', 'Green'],
+                        dimension3: ['foo', 'bar'],
+                    },
+                },
+            };
+            const entity = {
+                [size_range_helpers_1.SIZE_RANGE_SLUG]: {
+                    sizes: {
+                        dimension1: ['S', 'M', 'BAD'],
+                        dimension2: ['Red', 'Green', 'BAD_TWO'],
+                        dimension3: ['foo'],
+                    },
+                },
+            };
+            sizeRangeSanitizer.validateTwoDimensionalSizeRanges(sizeRangeTemplate, entity);
+            expect(entity[size_range_helpers_1.SIZE_RANGE_SLUG]).toEqual({
+                sizes: {
+                    dimension1: ['S', 'M'],
+                    dimension2: ['Red', 'Green'],
+                    dimension3: ['foo'],
+                },
+            });
+            expect(sizeRangeSanitizer.getWarnings().length).toBe(2);
+            expect(sizeRangeSanitizer.getWarnings()[0]).toEqual({
+                errorMessage: 'Invalid size.',
+                sizeRangeTemplate,
+                passedSizeRangeSizes: ['BAD'],
+                sizeRangeDimension: 'dimension1',
+            });
+            expect(sizeRangeSanitizer.getWarnings()[1]).toEqual({
+                errorMessage: 'Invalid size.',
+                sizeRangeTemplate,
+                passedSizeRangeSizes: ['BAD_TWO'],
+                sizeRangeDimension: 'dimension2',
+            });
+        });
+        it('Should return a validation warning if the size range template is in the wrong format', () => {
+            const sizeRangeTemplate = {
+                sizeRange: {
+                    sizes: {
+                        dimension1: 'InvalidFormat',
+                    },
+                },
+            };
+            const entity = {
+                [size_range_helpers_1.SIZE_RANGE_SLUG]: {
+                    sizes: {
+                        dimension1: ['S', 'M', 'XL'],
+                    },
+                },
+            };
+            sizeRangeSanitizer.validateTwoDimensionalSizeRanges(sizeRangeTemplate, entity);
+            expect(entity[size_range_helpers_1.SIZE_RANGE_SLUG]).toEqual({
+                sizes: {
+                    dimension1: ['S', 'M', 'XL'],
+                },
+            });
+            expect(sizeRangeSanitizer.getWarnings().length).toBe(2);
+            expect(sizeRangeSanitizer.getWarnings()[0]).toEqual({
+                errorMessage: 'Invalid size range format for template',
+                sizeRangeTemplate,
+                passedSizeRangeSizes: null,
+                sizeRangeDimension: null,
+            });
+        });
+        it('Should return validation warning if the entity size range is in the wrong format', () => {
+            const sizeRangeTemplate = {
+                sizeRange: {
+                    sizes: {
+                        dimension1: ['S', 'M', 'L'],
+                    },
+                },
+            };
+            const entity = {
+                [size_range_helpers_1.SIZE_RANGE_SLUG]: {
+                    sizes: {
+                        dimension1: ['S', 'M', 'XL'],
+                        dimension2: 'InvalidFormat',
+                    },
+                },
+            };
+            sizeRangeSanitizer.validateTwoDimensionalSizeRanges(sizeRangeTemplate, entity);
+            expect(entity[size_range_helpers_1.SIZE_RANGE_SLUG]).toEqual({
+                sizes: {
+                    dimension1: ['S', 'M'],
+                },
+            });
+            expect(sizeRangeSanitizer.getWarnings().length).toBe(2);
+            expect(sizeRangeSanitizer.getWarnings()[0]).toEqual({
+                errorMessage: 'Dimension is not in the correct format. Must be an array of strings.',
+                sizeRangeTemplate,
+                passedSizeRangeSizes: 'InvalidFormat',
+                sizeRangeDimension: 'dimension2',
+            });
+        });
+    });
+    describe('cleanSizeRangeInEntity', () => {
+        it('should not return a warning if the entity is empty', () => {
+            const entity = {};
+            const sizeRangeTemplates = [];
+            sizeRangeSanitizer.cleanSizeRangeInEntity(entity, sizeRangeTemplates);
+            expect(sizeRangeSanitizer.getWarnings().length).toBe(0);
+        });
+        it('should record a warning if no size range template is found for the given SIZE_RANGE_TEMPLATE_SLUG_ID', () => {
+            const entity = {
+                [size_range_helpers_1.SIZE_RANGE_TEMPLATE_SLUG_ID]: 'template1',
+            };
+            const sizeRangeTemplates = [];
+            sizeRangeSanitizer.cleanSizeRangeInEntity(entity, sizeRangeTemplates);
+            expect(sizeRangeSanitizer.getWarnings().length).toBe(1);
+            expect(sizeRangeSanitizer.getWarnings()[0]).toEqual({
+                errorMessage: 'No size range template found for template1',
+                sizeRangeTemplate: null,
+                passedSizeRangeSizes: null,
+                sizeRangeDimension: null,
+            });
+        });
+        it('should return validation warning if the entity has an invalid size range not in the template', () => {
+            const entity = {
+                [size_range_helpers_1.SIZE_RANGE_TEMPLATE_SLUG_ID]: 'template1',
+                [size_range_helpers_1.SIZE_RANGE_SLUG]: {
+                    sizes: ['S', 'M', 'XL'],
+                },
+            };
+            const sizeRangeTemplates = [
+                {
+                    id: 'template1',
+                    sizeRange: {
+                        sizes: ['S', 'M', 'L'],
+                    },
+                },
+            ];
+            sizeRangeSanitizer.cleanSizeRangeInEntity(entity, sizeRangeTemplates);
+            expect(entity[size_range_helpers_1.SIZE_RANGE_SLUG]).toEqual({ sizes: ['S', 'M'] });
+            expect(sizeRangeSanitizer.getWarnings().length).toBe(1);
+            expect(sizeRangeSanitizer.getWarnings()[0]).toEqual({
+                errorMessage: 'Invalid sizes found for size range template',
+                sizeRangeTemplate: {
+                    id: 'template1',
+                    sizeRange: {
+                        sizes: ['S', 'M', 'L'],
+                    },
+                },
+                passedSizeRangeSizes: ['XL'],
+                sizeRangeDimension: null,
+            });
+        });
+        it('should return validation warning if the entity includes size ranges not in the template', () => {
+            const entity = {
+                [size_range_helpers_1.SIZE_RANGE_TEMPLATE_SLUG_ID]: 'template1',
+                [size_range_helpers_1.SIZE_RANGE_SLUG]: {
+                    sizes: {
+                        dimension1: ['S', 'M', 'BAD'],
+                        dimension2: ['Red', 'Green', 'BAD_TWO'],
+                    },
+                },
+            };
+            const sizeRangeTemplates = [
+                {
+                    id: 'template1',
+                    sizeRange: {
+                        sizes: {
+                            dimension1: ['S', 'M', 'L'],
+                            dimension2: ['Red', 'Blue', 'Green'],
+                        },
+                    },
+                },
+            ];
+            sizeRangeSanitizer.cleanSizeRangeInEntity(entity, sizeRangeTemplates);
+            expect(entity[size_range_helpers_1.SIZE_RANGE_SLUG]).toEqual({
+                sizes: {
+                    dimension1: ['S', 'M'],
+                    dimension2: ['Red', 'Green'],
+                },
+            });
+            expect(sizeRangeSanitizer.getWarnings().length).toBe(2);
+            expect(sizeRangeSanitizer.getWarnings()[0]).toEqual({
+                errorMessage: 'Invalid size.',
+                sizeRangeTemplate: {
+                    id: 'template1',
+                    sizeRange: {
+                        sizes: {
+                            dimension1: ['S', 'M', 'L'],
+                            dimension2: ['Red', 'Blue', 'Green'],
+                        },
+                    },
+                },
+                passedSizeRangeSizes: ['BAD'],
+                sizeRangeDimension: 'dimension1',
+            });
+            expect(sizeRangeSanitizer.getWarnings()[1]).toEqual({
+                errorMessage: 'Invalid size.',
+                sizeRangeTemplate: {
+                    id: 'template1',
+                    sizeRange: {
+                        sizes: {
+                            dimension1: ['S', 'M', 'L'],
+                            dimension2: ['Red', 'Blue', 'Green'],
+                        },
+                    },
+                },
+                passedSizeRangeSizes: ['BAD_TWO'],
+                sizeRangeDimension: 'dimension2',
+            });
+        });
+        it('should return a validation error if the size range template does not have size ranges (bad format)', () => {
+            const entity = {
+                [size_range_helpers_1.SIZE_RANGE_TEMPLATE_SLUG_ID]: 'template1',
+            };
+            const sizeRangeTemplates = [
+                {
+                    id: 'template1',
+                    sizeRange: {},
+                },
+            ];
+            sizeRangeSanitizer.cleanSizeRangeInEntity(entity, sizeRangeTemplates);
+            expect(sizeRangeSanitizer.getWarnings().length).toBe(1);
+            expect(sizeRangeSanitizer.getWarnings()[0]).toEqual({
+                errorMessage: 'Encountered a size range template with a bad format.',
+                sizeRangeTemplate: {
+                    id: 'template1',
+                    sizeRange: {},
+                },
+                passedSizeRangeSizes: null,
+                sizeRangeDimension: null,
+            });
+        });
+        it('should return a validation error if the size range template has no sizes (bad format)', () => {
+            const entity = {
+                [size_range_helpers_1.SIZE_RANGE_TEMPLATE_SLUG_ID]: 'template1',
+            };
+            const sizeRangeTemplates = [
+                {
+                    id: 'template1',
+                    sizeRange: {
+                        sizes: {},
+                    },
+                },
+            ];
+            sizeRangeSanitizer.cleanSizeRangeInEntity(entity, sizeRangeTemplates);
+            expect(sizeRangeSanitizer.getWarnings().length).toBe(1);
+            expect(sizeRangeSanitizer.getWarnings()[0]).toEqual({
+                errorMessage: 'Encountered an Unknown size range template format',
+                sizeRangeTemplate: {
+                    id: 'template1',
+                    sizeRange: {
+                        sizes: {},
+                    },
+                },
+                passedSizeRangeSizes: null,
+                sizeRangeDimension: null,
+            });
+        });
+    });
+});

package/node_modules/@contrail/loader/lib/common/type-helper.d.ts

@@ -0,0 +1,18 @@
+import { PropertyType, Type, TypeProperty } from '@contrail/types';
+import { TypesByPath } from './entities-helper';
+import { EntitiesClient } from '@contrail/entity-types';
+export declare function getTypePropertySlugs(objType: Type): string[];
+export declare function getTypePropertyToValueType(objType: Type): {
+    [key: string]: PropertyType;
+};
+export declare function getObjectReferenceTypeProperties(objType: Type): TypeProperty[];
+export declare function getUserListTypeProperties(objType: Type): TypeProperty[];
+export declare function reduceToFamilyProperties(entity: any, type: Type): any;
+export declare function setFamilyOverride(entity: any, property: TypeProperty): any;
+export declare function setOptionOverrides(entity: any, type: {
+    typeProperties?: TypeProperty[];
+}): any;
+export declare function setOptionOverride(entity: any, property: TypeProperty): any;
+export declare function buildTypesByPath(client: EntitiesClient, typePaths: string[], requiredNonTypeProperties: string[], entityType: string, typesByTypePath?: Record<string, Type>): Promise<TypesByPath>;
+export declare function buildTypesByPathForPipeline(client: EntitiesClient, typePaths: string[]): Promise<TypesByPath>;
+export declare function removeFamilyLevelPropsFromOption(item: any, type: Type): void;

package/node_modules/@contrail/loader/lib/common/type-helper.js

@@ -0,0 +1,232 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeFamilyLevelPropsFromOption = exports.buildTypesByPathForPipeline = exports.buildTypesByPath = exports.setOptionOverride = exports.setOptionOverrides = exports.setFamilyOverride = exports.reduceToFamilyProperties = exports.getUserListTypeProperties = exports.getObjectReferenceTypeProperties = exports.getTypePropertyToValueType = exports.getTypePropertySlugs = void 0;
+const util_1 = require("@contrail/util");
+const types_1 = require("@contrail/types");
+const entity_types_1 = require("@contrail/entity-types");
+const pLimit = require('p-limit');
+function getTypePropertySlugs(objType) {
+    const typeProperties = objType?.typeProperties?.map((property) => property.slug);
+    return typeProperties ?? [];
+}
+exports.getTypePropertySlugs = getTypePropertySlugs;
+function getTypePropertyToValueType(objType) {
+    const typePropertyToValueType = {};
+    objType?.typeProperties?.map((property) => (typePropertyToValueType[property.slug] = property.propertyType));
+    return typePropertyToValueType;
+}
+exports.getTypePropertyToValueType = getTypePropertyToValueType;
+function getObjectReferenceTypeProperties(objType) {
+    return objType?.typeProperties?.filter((property) => property.propertyType === types_1.PropertyType.ObjectReference) ?? [];
+}
+exports.getObjectReferenceTypeProperties = getObjectReferenceTypeProperties;
+function getUserListTypeProperties(objType) {
+    return objType?.typeProperties?.filter((property) => property.propertyType === types_1.PropertyType.UserList) ?? [];
+}
+exports.getUserListTypeProperties = getUserListTypeProperties;
+function reduceToFamilyProperties(entity, type) {
+    let reducedItem = util_1.ObjectUtil.cloneDeep(entity);
+    const typeProperties = type?.typeProperties ?? [];
+    if (typeProperties.length === 0) {
+        return entity;
+    }
+    for (const property of type.typeProperties) {
+        if (!property.propertyLevel ||
+            property.propertyLevel === types_1.PropertyLevel.FAMILY ||
+            property.propertyLevel === types_1.PropertyLevel.ALL ||
+            property.propertyLevel === types_1.PropertyLevel.OVERRIDABLE ||
+            ['federatedId', 'typePath', 'typeId'].includes(property.slug)) {
+            reducedItem = setFamilyOverride(reducedItem, property);
+            continue;
+        }
+        let slugToRemove = property.slug;
+        if (property.propertyType === types_1.PropertyType.ObjectReference || property.propertyType === types_1.PropertyType.UserList) {
+            slugToRemove = slugToRemove + 'Id';
+        }
+        delete reducedItem[slugToRemove];
+    }
+    const typePropsSlugs = new Set(typeProperties.map((prop) => prop.slug));
+    if (typePropsSlugs.size > 0) {
+        Object.keys(reducedItem).forEach((key) => {
+            if (!isValidOptionProperty(key, typePropsSlugs)) {
+                delete reducedItem[key];
+            }
+        });
+    }
+    return reducedItem;
+}
+exports.reduceToFamilyProperties = reduceToFamilyProperties;
+function setFamilyOverride(entity, property) {
+    if (property.propertyLevel !== types_1.PropertyLevel.OVERRIDABLE) {
+        return entity;
+    }
+    if (entity[property.slug + 'Family'] !== undefined) {
+        entity[property.slug] = entity[property.slug + 'Family'];
+        delete entity[property.slug + 'Family'];
+    }
+    if (entity[property.slug + 'FamilyId'] !== undefined) {
+        entity[property.slug + 'Id'] = entity[property.slug + 'FamilyId'];
+        delete entity[property.slug + 'FamilyId'];
+    }
+    return entity;
+}
+exports.setFamilyOverride = setFamilyOverride;
+function setOptionOverrides(entity, type) {
+    for (const property of type?.typeProperties) {
+        entity = setOptionOverride(entity, property);
+    }
+    return entity;
+}
+exports.setOptionOverrides = setOptionOverrides;
+function setOptionOverride(entity, property) {
+    if (property.propertyLevel !== 'overridable') {
+        return entity;
+    }
+    if (entity[property.slug + 'Option'] !== undefined) {
+        entity[property.slug] = entity[property.slug + 'Option'];
+        delete entity[property.slug + 'Option'];
+    }
+    if (entity[property.slug + 'OptionId'] !== undefined) {
+        entity[property.slug + 'Id'] = entity[property.slug + 'OptionId'];
+        delete entity[property.slug + 'OptionId'];
+    }
+    return entity;
+}
+exports.setOptionOverride = setOptionOverride;
+async function buildTypesByPath(client, typePaths, requiredNonTypeProperties, entityType, typesByTypePath) {
+    const results = {};
+    await Promise.all(typePaths.map(async (typePath) => {
+        let type;
+        let error = null;
+        const cachedType = typesByTypePath?.[typePath];
+        if (cachedType) {
+            type = cachedType;
+        }
+        else {
+            const result = await getType(client, entityType, typePath);
+            type = result.objectType;
+            error = result.error;
+        }
+        results[typePath] = {
+            type,
+            allPropertiesSlugs: getTypePropertySlugs(type).concat(requiredNonTypeProperties),
+            typePropertyToValueType: getTypePropertyToValueType(type),
+            objectReferenceProperties: getObjectReferenceTypeProperties(type),
+            userListProperties: getUserListTypeProperties(type),
+            error,
+        };
+    }));
+    return results;
+}
+exports.buildTypesByPath = buildTypesByPath;
+async function getType(client, entityType, typePath) {
+    let error = null;
+    const fallbackTypePath = entityType;
+    const resolvedTypePath = typePath ?? fallbackTypePath;
+    const resolvedPathParams = resolvedTypePath.split(':');
+    if (!resolvedPathParams.length) {
+        error = {
+            message: `Invalid Type: ${typePath}`,
+            issueType: entity_types_1.IssueType.INVALID_DATA,
+        };
+        console.error(`Invalid Type: ${typePath}`);
+    }
+    const root = resolvedPathParams[0];
+    const suffix = `roots/${root}/path/${resolvedTypePath}`;
+    const objectType = await client.get({
+        entityName: 'type',
+        suffix,
+        relations: ['typeProperties'],
+    });
+    if (!objectType) {
+        console.error(`Invalid Type: ${typePath}`);
+        error = {
+            message: `Invalid Type: ${typePath}`,
+            issueType: entity_types_1.IssueType.INVALID_DATA,
+        };
+    }
+    return { error, objectType };
+}
+async function buildTypesByPathForPipeline(client, typePaths) {
+    const uniquePaths = new Set(typePaths);
+    const limit = pLimit(10);
+    const results = {};
+    await Promise.all(Array.from(uniquePaths).map((typePath) => limit(async () => {
+        const { type, error } = await getTypeForPipeline(client, typePath);
+        results[typePath] = {
+            type,
+            allPropertiesSlugs: getTypePropertySlugs(type),
+            typePropertyToValueType: getTypePropertyToValueType(type),
+            objectReferenceProperties: getObjectReferenceTypeProperties(type),
+            userListProperties: getUserListTypeProperties(type),
+            error,
+        };
+    })));
+    return results;
+}
+exports.buildTypesByPathForPipeline = buildTypesByPathForPipeline;
+async function getTypeForPipeline(client, typePath) {
+    const pathParts = typePath.split(':');
+    const root = pathParts[0];
+    const suffix = `roots/${root}/path/${typePath}`;
+    let error = null;
+    let type = null;
+    try {
+        type = await client.get({
+            entityName: 'type',
+            suffix,
+            relations: ['typeProperties'],
+        });
+    }
+    catch (e) {
+        console.debug(`Failed to fetch type for path "${typePath}":`, e);
+    }
+    if (!type) {
+        error = {
+            message: `Invalid Type: ${typePath}`,
+            issueType: entity_types_1.IssueType.INVALID_DATA,
+        };
+    }
+    return { type, error };
+}
+function isValidOptionProperty(key, typePropsSlugs) {
+    if (key.endsWith('Option')) {
+        return typePropsSlugs.has(key);
+    }
+    return true;
+}
+function removeFamilyLevelPropsFromOption(item, type) {
+    const { familyProps, optionProps } = (type?.typeProperties ?? []).reduce((acc, x) => {
+        if (x.propertyLevel === 'family') {
+            acc.familyProps.push(x);
+        }
+        else {
+            acc.optionProps.push(x);
+        }
+        return acc;
+    }, { familyProps: [], optionProps: [] });
+    const badProps = [];
+    for (const familyProp of familyProps) {
+        const isReferenceProp = [
+            types_1.PropertyType.ObjectReference,
+            types_1.PropertyType.UserList,
+            types_1.PropertyType.TypeReference,
+        ].includes(familyProp.propertyType);
+        const propSlug = isReferenceProp ? familyProp.slug + 'Id' : familyProp.slug;
+        if (item[propSlug] !== undefined) {
+            badProps.push(propSlug);
+        }
+    }
+    const optionPropsSet = new Set(optionProps.map((prop) => prop.slug));
+    if (optionPropsSet.size > 0) {
+        Object.keys(item).forEach((key) => {
+            if (key.endsWith('Family') && !optionPropsSet.has(key)) {
+                badProps.push(key);
+            }
+        });
+    }
+    for (const badProp of badProps) {
+        delete item[badProp];
+    }
+}
+exports.removeFamilyLevelPropsFromOption = removeFamilyLevelPropsFromOption;

package/node_modules/@contrail/loader/lib/common/type-helper.spec.d.ts

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

package/node_modules/@contrail/loader/lib/common/type-helper.spec.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const type_helper_1 = require("./type-helper");
+const entity_types_1 = require("@contrail/entity-types");
+const types_1 = require("@contrail/types");
+let dynamicGetRootAndPath = () => null;
+class MockEntitiesClient extends entity_types_1.EntitiesClient {
+    get = jest.fn((options) => {
+        return dynamicGetRootAndPath();
+    });
+    async getAllReferences(references, relations) {
+        return new Map();
+    }
+    create(options) {
+        return {};
+    }
+    batchCreate(options) {
+        return {};
+    }
+    update(options) {
+        return {};
+    }
+    batchUpdate(options) {
+        return {};
+    }
+    delete(options) {
+        return {};
+    }
+    batchDelete(options) {
+        return {};
+    }
+}
+describe('buildTypesByPath', () => {
+    let client;
+    let typePaths;
+    beforeEach(() => {
+        client = new MockEntitiesClient();
+        typePaths = ['root:path1', 'root:path2'];
+    });
+    it('should build typesByPath for a single property', async () => {
+        const mockType = {
+            typeProperties: [{ slug: 'prop1', propertyType: types_1.PropertyType.String }],
+        };
+        dynamicGetRootAndPath = () => mockType;
+        const requiredNonTypeProperties = [];
+        const result = await (0, type_helper_1.buildTypesByPath)(client, ['root:path1'], requiredNonTypeProperties, entity_types_1.EntityType.COLOR);
+        expect(result).toEqual({
+            'root:path1': {
+                type: mockType,
+                allPropertiesSlugs: ['prop1'],
+                typePropertyToValueType: { prop1: types_1.PropertyType.String },
+                objectReferenceProperties: [],
+                userListProperties: [],
+                error: null,
+            },
+        });
+    });
+    it('should support multiple properties', async () => {
+        const mockType = {
+            typeProperties: [
+                { slug: 'prop1', propertyType: types_1.PropertyType.String },
+                { slug: 'prop2', propertyType: types_1.PropertyType.ObjectReference },
+            ],
+        };
+        dynamicGetRootAndPath = () => mockType;
+        const requiredNonTypeProperties = [];
+        const result = await (0, type_helper_1.buildTypesByPath)(client, ['root:path1'], requiredNonTypeProperties, entity_types_1.EntityType.CUSTOM_ENTITY);
+        expect(result).toEqual({
+            'root:path1': {
+                type: mockType,
+                allPropertiesSlugs: ['prop1', 'prop2'],
+                typePropertyToValueType: {
+                    prop1: types_1.PropertyType.String,
+                    prop2: types_1.PropertyType.ObjectReference,
+                },
+                objectReferenceProperties: [{ slug: 'prop2', propertyType: types_1.PropertyType.ObjectReference }],
+                userListProperties: [],
+                error: null,
+            },
+        });
+    });
+    it('should include non-required type properties in the list of properties slugs if they are provided', async () => {
+        const mockType = {
+            typeProperties: [{ slug: 'prop1', propertyType: types_1.PropertyType.String }],
+        };
+        dynamicGetRootAndPath = () => mockType;
+        const requiredNonTypeProperties = ['federated_mapping', 'some_other_prop'];
+        const result = await (0, type_helper_1.buildTypesByPath)(client, ['root:path1'], requiredNonTypeProperties, entity_types_1.EntityType.COLOR);
+        expect(result).toEqual({
+            'root:path1': {
+                type: mockType,
+                allPropertiesSlugs: ['prop1', 'federated_mapping', 'some_other_prop'],
+                typePropertyToValueType: { prop1: types_1.PropertyType.String },
+                objectReferenceProperties: [],
+                userListProperties: [],
+                error: null,
+            },
+        });
+    });
+    it('should throw an error if type is invalid', async () => {
+        dynamicGetRootAndPath = () => null;
+        const requiredNonTypeProperties = ['federated_mapping', 'some_other_prop'];
+        const result = await (0, type_helper_1.buildTypesByPath)(client, typePaths, requiredNonTypeProperties, entity_types_1.EntityType.CUSTOM_ENTITY);
+        typePaths.forEach((typePath) => {
+            expect(result[typePath].error).toBeDefined();
+            expect(result[typePath].error.issueType).toBe(entity_types_1.IssueType.INVALID_DATA);
+            expect(result[typePath].error.message).toBe(`Invalid Type: ${typePath}`);
+        });
+    });
+});