@contrail/cli 3.4.5 → 3.4.6-alpha.cffb28e

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

@@ -0,0 +1,33 @@
+import { Type, TypeProperty, PropertyType } from '@contrail/types';
+import { EntitiesClient, GeneralIssueDetails } from '@contrail/entity-types';
+export declare enum EntitiesLambdaCallType {
+    GET = "GET",
+    CREATE = "CREATE",
+    UPDATE = "UPDATE",
+    DELETE = "DELETE",
+    BATCHCREATE = "BATCHCREATE",
+    BATCHUPDATE = "BATCHUPDATE"
+}
+export interface TypesByPath {
+    [key: string]: {
+        type: Type;
+        allPropertiesSlugs: string[];
+        typePropertyToValueType: {
+            [key: string]: PropertyType;
+        };
+        objectReferenceProperties: TypeProperty[];
+        userListProperties: TypeProperty[];
+        error?: GeneralIssueDetails;
+    };
+}
+export declare function retryOnTimeout(client: EntitiesClient, callType: EntitiesLambdaCallType, callParams: any, maxRetries?: number): Promise<any>;
+export declare function UpdateNeeded(incoming: any, existing: any, fieldsToSkip?: any[], fieldsToSkipIfOnlyOnExisting?: any[], type?: Type): boolean;
+export declare function compareIncomingAndExisting(incoming: any, existing: any, fieldsToSkip?: any[], fieldsToSkipIfOnlyOnExisting?: any[], type?: Type): import("@contrail/util").ObjectDiff[];
+export declare function parseDateOrNumberKey(obj: any, key: any, propertyType?: any): void;
+export declare function assignObjectReferences(client: EntitiesClient, typePaths: string[], typesByPath: TypesByPath, incomingEntities: any[]): Promise<GeneralIssueDetails[]>;
+export declare function getUsersInOrg(client: EntitiesClient): Promise<any>;
+export declare function assignUserLists(client: EntitiesClient, typePaths: string[], typesByPath: TypesByPath, incomingEntities: any[]): Promise<void>;
+export declare function getPropertyVariants(entity: any, slug: string, returnType?: 'values' | 'keyValue'): Array<any> | Array<{
+    key: string;
+    value: any;
+}>;

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

@@ -0,0 +1,300 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPropertyVariants = exports.assignUserLists = exports.getUsersInOrg = exports.assignObjectReferences = exports.parseDateOrNumberKey = exports.compareIncomingAndExisting = exports.UpdateNeeded = exports.retryOnTimeout = exports.EntitiesLambdaCallType = void 0;
+const util_1 = require("@contrail/util");
+const types_1 = require("@contrail/types");
+const entity_types_1 = require("@contrail/entity-types");
+const lodash_1 = require("lodash");
+const pLimit = require('p-limit');
+var EntitiesLambdaCallType;
+(function (EntitiesLambdaCallType) {
+    EntitiesLambdaCallType["GET"] = "GET";
+    EntitiesLambdaCallType["CREATE"] = "CREATE";
+    EntitiesLambdaCallType["UPDATE"] = "UPDATE";
+    EntitiesLambdaCallType["DELETE"] = "DELETE";
+    EntitiesLambdaCallType["BATCHCREATE"] = "BATCHCREATE";
+    EntitiesLambdaCallType["BATCHUPDATE"] = "BATCHUPDATE";
+})(EntitiesLambdaCallType = exports.EntitiesLambdaCallType || (exports.EntitiesLambdaCallType = {}));
+async function retryOnTimeout(client, callType, callParams, maxRetries = 3) {
+    let callCount = 0;
+    let done = false;
+    let response;
+    if (!client) {
+        throw new Error('No client to use.');
+    }
+    while (!done && callCount <= maxRetries) {
+        try {
+            if (callCount > 0) {
+                console.debug('Retrying call - Attempt: ', callCount);
+            }
+            switch (callType) {
+                case EntitiesLambdaCallType.GET:
+                    response = await client.get(callParams);
+                    break;
+                case EntitiesLambdaCallType.CREATE:
+                    response = await client.create(callParams);
+                    break;
+                case EntitiesLambdaCallType.UPDATE:
+                    response = await client.update(callParams);
+                    break;
+                case EntitiesLambdaCallType.DELETE:
+                    response = await client.delete(callParams);
+                    break;
+                case EntitiesLambdaCallType.BATCHCREATE:
+                    response = await client.batchCreate(callParams);
+                    break;
+                case EntitiesLambdaCallType.BATCHUPDATE:
+                    response = await client.batchUpdate(callParams);
+                    break;
+                default:
+                    throw Error('Invalid EntitiesLambdaCallType');
+            }
+            done = true;
+        }
+        catch (e) {
+            if (e instanceof entity_types_1.TimeoutError && callCount + 1 <= maxRetries) {
+                console.warn(`Lambda call failed due to timeout. callType: ${callType}, callParams: `, callParams);
+            }
+            else {
+                console.error('Failed Lambda call. ', e);
+                throw e;
+            }
+        }
+        callCount++;
+    }
+    return response;
+}
+exports.retryOnTimeout = retryOnTimeout;
+function UpdateNeeded(incoming, existing, fieldsToSkip = [], fieldsToSkipIfOnlyOnExisting = [], type) {
+    console.debug('Comparing existing and incoming objects: ', JSON.stringify(incoming), ' existing: ', JSON.stringify(existing));
+    const diffs = compareIncomingAndExisting(incoming, existing, fieldsToSkip, fieldsToSkipIfOnlyOnExisting, type);
+    if (diffs?.length > 0) {
+        console.debug('objectDiffs: ', diffs);
+        return true;
+    }
+    console.debug('No updates needed.');
+    return false;
+}
+exports.UpdateNeeded = UpdateNeeded;
+function compareIncomingAndExisting(incoming, existing, fieldsToSkip = [], fieldsToSkipIfOnlyOnExisting = [], type) {
+    const slimExisting = {};
+    const keys = Object.keys(incoming);
+    const cloneIncoming = util_1.ObjectUtil.cloneDeep(incoming);
+    for (const key of keys) {
+        parseDateOrNumberKey(cloneIncoming, key);
+        slimExisting[key] = existing[key];
+        parseDateOrNumberKey(slimExisting, key);
+    }
+    for (const fieldToSkip of fieldsToSkip) {
+        delete slimExisting[fieldToSkip];
+        delete cloneIncoming[fieldToSkip];
+    }
+    if (type) {
+        const typePropertiesToSkip = type?.typeProperties
+            ?.filter((x) => [types_1.PropertyType.ObjectReference, types_1.PropertyType.TypeReference, types_1.PropertyType.UserList].includes(x.propertyType))
+            ?.map((x) => x.slug);
+        for (const typePropertyToSkip of typePropertiesToSkip) {
+            delete slimExisting[typePropertyToSkip];
+            delete cloneIncoming[typePropertyToSkip];
+        }
+    }
+    for (const fieldToSkipIfOnlyOnExisting of fieldsToSkipIfOnlyOnExisting) {
+        if (Object.prototype.hasOwnProperty.call(slimExisting, fieldToSkipIfOnlyOnExisting) &&
+            !Object.prototype.hasOwnProperty.call(cloneIncoming, fieldToSkipIfOnlyOnExisting)) {
+            delete slimExisting[fieldToSkipIfOnlyOnExisting];
+            delete cloneIncoming[fieldToSkipIfOnlyOnExisting];
+        }
+    }
+    const objectDiffs = util_1.ObjectUtil.compareDeep(slimExisting, cloneIncoming, '');
+    return objectDiffs;
+}
+exports.compareIncomingAndExisting = compareIncomingAndExisting;
+function parseDateOrNumberKey(obj, key, propertyType) {
+    const value = obj[key];
+    if (!propertyType) {
+        if (value != null && value instanceof Date) {
+            obj[key] = `${value.toISOString()}`;
+        }
+        else if (value != null && typeof value === 'string' && value !== '') {
+            const parse = Number(value);
+            if (!isNaN(parse)) {
+                obj[key] = parse;
+            }
+        }
+    }
+    else {
+        if (value != null && propertyType === types_1.PropertyType.Date) {
+            if (value instanceof Date) {
+                obj[key] = `${value.toISOString()}`;
+            }
+            else {
+                console.warn('PropertyType.Date is set but the value is not a Date object', value);
+                obj[key] = null;
+            }
+        }
+        else if (propertyType === types_1.PropertyType.Number) {
+            const parse = Number(value);
+            if (!isNaN(parse)) {
+                obj[key] = parse;
+            }
+        }
+    }
+}
+exports.parseDateOrNumberKey = parseDateOrNumberKey;
+async function assignObjectReferences(client, typePaths, typesByPath, incomingEntities) {
+    const limit = pLimit(5);
+    const allObjectReferenceColumnsWithRootType = [];
+    for (const typePath of typePaths ?? []) {
+        const typeObj = typesByPath[typePath];
+        if (!(typeObj?.objectReferenceProperties?.length > 0)) {
+            console.debug(`No ObjectReferences for ${typePath}, skipping.`);
+            continue;
+        }
+        for (const objectReferenceProperty of typeObj?.objectReferenceProperties ?? []) {
+            const slug = objectReferenceProperty.slug;
+            const rootType = objectReferenceProperty.referencedTypeRootSlug;
+            const referencedTypePath = objectReferenceProperty.referencedTypePath;
+            allObjectReferenceColumnsWithRootType.push({
+                slug,
+                rootType,
+                referencedTypePath,
+            });
+        }
+    }
+    const allORFedIdsByType = {};
+    for (const entity of incomingEntities) {
+        for (const allORColumnWithRootType of allObjectReferenceColumnsWithRootType) {
+            const slug = allORColumnWithRootType.slug;
+            const levelVariants = getPropertyVariants(entity, slug, 'values');
+            for (let fedId of levelVariants) {
+                if (!allORFedIdsByType[allORColumnWithRootType.rootType]) {
+                    allORFedIdsByType[allORColumnWithRootType.rootType] = [];
+                }
+                if (!fedId.startsWith('custom-entity:') &&
+                    allORColumnWithRootType.referencedTypePath.includes('custom-entity')) {
+                    fedId = `${allORColumnWithRootType.referencedTypePath}:${fedId}`;
+                }
+                allORFedIdsByType[allORColumnWithRootType.rootType].push(fedId);
+            }
+        }
+    }
+    const allORByFedId = {};
+    for (const rootType of Object.keys(allORFedIdsByType)) {
+        const fedIds = [...new Set(allORFedIdsByType[rootType])];
+        const chunks = (0, lodash_1.chunk)(fedIds, 200);
+        const federatedPromises = [];
+        for (const chunk of chunks) {
+            if (!chunk?.length) {
+                continue;
+            }
+            const federatedPromise = limit(async () => {
+                try {
+                    const currentORBatch = await retryOnTimeout(client, EntitiesLambdaCallType.GET, {
+                        entityName: rootType,
+                        federatedIds: (0, lodash_1.uniq)(chunk),
+                        skipHydrateRelationships: true,
+                    });
+                    if (!currentORBatch) {
+                    }
+                    if (currentORBatch?.length > 0) {
+                        for (const currentOR of currentORBatch) {
+                            allORByFedId[currentOR.federatedId] = currentOR;
+                        }
+                    }
+                }
+                catch (e) {
+                    console.error('Failed to get ObjectReferences by FederatedIds', e);
+                    throw new Error(`'Failed to get ObjectReferences by FederatedIds: ${e}`);
+                }
+            });
+            federatedPromises.push(federatedPromise);
+        }
+        await Promise.all(federatedPromises);
+        console.info(`ObjectReferences lookup complete. ${Object.keys(allORByFedId)?.length} Object References retrieved`);
+    }
+    const objectReferenceWarnings = new Set();
+    for (const entity of incomingEntities) {
+        for (const allORColumnWithRootType of allObjectReferenceColumnsWithRootType) {
+            const slug = allORColumnWithRootType.slug;
+            const levelVariants = getPropertyVariants(entity, slug, 'keyValue');
+            for (const variant of levelVariants) {
+                let fedId = variant.value;
+                if (!fedId)
+                    continue;
+                if (!fedId.startsWith('custom-entity:') &&
+                    allORColumnWithRootType.referencedTypePath.includes('custom-entity')) {
+                    fedId = `${allORColumnWithRootType.referencedTypePath}:${fedId}`;
+                }
+                const objectReference = allORByFedId[fedId];
+                if (!objectReference) {
+                    objectReferenceWarnings.add(`ObjectReference not found for ${slug} with value ${fedId}`);
+                    continue;
+                }
+                entity[variant.key + 'Id'] = objectReference.id;
+                delete entity[variant.key];
+            }
+        }
+    }
+    return Array.from(objectReferenceWarnings).map((warning) => ({
+        message: warning,
+        issueType: entity_types_1.IssueType.INVALID_DATA,
+    }));
+}
+exports.assignObjectReferences = assignObjectReferences;
+async function getUsersInOrg(client) {
+    return await client.get({ entityName: 'user', relation: 'usersInOrg' });
+}
+exports.getUsersInOrg = getUsersInOrg;
+async function assignUserLists(client, typePaths, typesByPath, incomingEntities) {
+    const hasUserListProps = (typePaths ?? []).some((typePath) => {
+        const typeObj = typesByPath[typePath];
+        return typeObj?.userListProperties?.length > 0;
+    });
+    if (!hasUserListProps) {
+        console.debug(`No user list properties for this load, skipping.`);
+        return;
+    }
+    const users = await getUsersInOrg(client);
+    const userEmailToIdMap = [];
+    for (const user of users) {
+        userEmailToIdMap[user.email] = user.id;
+    }
+    for (const typePath of typePaths ?? []) {
+        const typeObj = typesByPath[typePath];
+        if (!(typeObj?.userListProperties?.length > 0)) {
+            console.debug(`No user lists for ${typePath}, skipping.`);
+            continue;
+        }
+        for (const entity of incomingEntities) {
+            for (const userListProperty of typeObj.userListProperties ?? []) {
+                const slug = userListProperty.slug;
+                const value = entity[slug];
+                if (!value) {
+                    continue;
+                }
+                let userId = userEmailToIdMap[value];
+                if (!userId) {
+                    userId = null;
+                }
+                entity[slug + 'Id'] = userId;
+                delete entity[slug];
+            }
+        }
+    }
+}
+exports.assignUserLists = assignUserLists;
+function getPropertyVariants(entity, slug, returnType = 'values') {
+    const hasFamilyOrOption = entity.hasOwnProperty(`${slug}Family`) || entity.hasOwnProperty(`${slug}Option`);
+    const variants = [];
+    if (entity.hasOwnProperty(`${slug}Family`)) {
+        variants.push(returnType === 'values' ? entity[`${slug}Family`] : { key: `${slug}Family`, value: entity[`${slug}Family`] });
+    }
+    if (entity.hasOwnProperty(`${slug}Option`)) {
+        variants.push(returnType === 'values' ? entity[`${slug}Option`] : { key: `${slug}Option`, value: entity[`${slug}Option`] });
+    }
+    if (!hasFamilyOrOption && entity.hasOwnProperty(slug)) {
+        variants.push(returnType === 'values' ? entity[slug] : { key: slug, value: entity[slug] });
+    }
+    return variants;
+}
+exports.getPropertyVariants = getPropertyVariants;

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

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

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

@@ -0,0 +1,287 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Helpers = __importStar(require("./entities-helper"));
+const types_1 = require("@contrail/types");
+const entities_helper_1 = require("./entities-helper");
+describe('Entities Helper', () => {
+    let mockClient;
+    beforeEach(() => {
+        mockClient = {
+            create: jest.fn().mockResolvedValue({ id: 'mock-id' }),
+            update: jest.fn().mockResolvedValue({}),
+            getAllReferences: jest.fn(),
+            get: jest.fn().mockResolvedValue([
+                { id: 1, email: 'user1@example.com' },
+                { id: 2, email: 'user2@example.com' },
+                { id: 3, email: 'user3@example.com' },
+            ]),
+            delete: jest.fn(),
+            batchCreate: jest.fn(),
+            batchUpdate: jest.fn(),
+            batchDelete: jest.fn(),
+        };
+    });
+    describe('compareIncomingAndExisting', () => {
+        it('should compare incoming and existing objects and return the differences', () => {
+            const incoming = { id: 1, name: 'John Doe', age: 30 };
+            const existing = { id: 1, name: 'Jane Smith', email: 'jane@example.com' };
+            const fieldsToSkip = ['email'];
+            const fieldsToSkipIfOnlyOnExisting = ['age'];
+            const result = Helpers.compareIncomingAndExisting(incoming, existing, fieldsToSkip, fieldsToSkipIfOnlyOnExisting);
+            expect(result).toEqual([
+                { oldValue: 'Jane Smith', newValue: 'John Doe', propertyName: 'name' },
+                { oldValue: null, newValue: 30, propertyName: 'age' },
+            ]);
+        });
+        it('should handle comparing a property that was an array and is now an object', () => {
+            const incoming = { id: 1, pets: { foo: 'bar' } };
+            const existing = { id: 1, pets: ['dog', 'cat'] };
+            const result = Helpers.compareIncomingAndExisting(incoming, existing, [], []);
+            expect(result).toEqual([
+                {
+                    oldValue: ['dog', 'cat'],
+                    newValue: { foo: 'bar' },
+                    propertyName: 'pets',
+                },
+            ]);
+        });
+        it('should compare incoming and existing objects and return the differences', () => {
+            const incoming = { id: 1, colorActive: false };
+            const existing = { id: 1, colorActive: true };
+            const result = Helpers.compareIncomingAndExisting(incoming, existing);
+            expect(result).toEqual([{ oldValue: true, newValue: false, propertyName: 'colorActive' }]);
+        });
+        it('should handle empty fieldsToSkip and fieldsToSkipIfOnlyOnExisting arrays', () => {
+            const incoming = { id: 1, name: 'John Doe', age: 30 };
+            const existing = { id: 1, name: 'Jane Smith', email: 'jane@example.com' };
+            const result = Helpers.compareIncomingAndExisting(incoming, existing);
+            expect(result).toEqual([
+                { oldValue: 'Jane Smith', newValue: 'John Doe', propertyName: 'name' },
+                { oldValue: null, newValue: 30, propertyName: 'age' },
+            ]);
+        });
+        it('should compare incoming and existing objects and return the differences - ignoring object references', () => {
+            const incoming = {
+                id: 1,
+                colorActive: false,
+                objRef: 'obj1',
+                objRefId: '123',
+            };
+            const existing = { id: 1, colorActive: true, objRefId: '123' };
+            const type = {
+                typeProperties: [{ slug: 'objRef', propertyType: types_1.PropertyType.ObjectReference }],
+            };
+            const result = Helpers.compareIncomingAndExisting(incoming, existing, [], [], type);
+            expect(result).toEqual([{ oldValue: true, newValue: false, propertyName: 'colorActive' }]);
+        });
+    });
+    describe('Helpers.assignUserLists', () => {
+        it('should assign user lists to incoming entities', async () => {
+            const typePaths = ['path1', 'path2'];
+            const typesByPath = {
+                path1: {
+                    userListProperties: [{ slug: 'userList1' }, { slug: 'userList2' }],
+                },
+                path2: { userListProperties: [{ slug: 'userList3' }] },
+            };
+            const incomingEntities = [
+                {
+                    id: 1,
+                    userList1: 'user1@example.com',
+                    userList2: 'user2@example.com',
+                },
+                { id: 2, userList3: 'user3@example.com' },
+            ];
+            await Helpers.assignUserLists(mockClient, typePaths, typesByPath, incomingEntities);
+            expect(incomingEntities).toEqual([
+                { id: 1, userList1Id: 1, userList2Id: 2 },
+                { id: 2, userList3Id: 3 },
+            ]);
+        });
+        it('should skip assigning user lists if no user list properties are defined', async () => {
+            const typePaths = ['path1', 'path2'];
+            const typesByPath = { path1: {}, path2: {} };
+            const incomingEntities = [
+                {
+                    id: 1,
+                    userList1: 'user1@example.com',
+                    userList2: 'user2@example.com',
+                },
+                { id: 2, userList3: 'user3@example.com' },
+            ];
+            await Helpers.assignUserLists(mockClient, typePaths, typesByPath, incomingEntities);
+            expect(incomingEntities).toEqual([
+                {
+                    id: 1,
+                    userList1: 'user1@example.com',
+                    userList2: 'user2@example.com',
+                },
+                { id: 2, userList3: 'user3@example.com' },
+            ]);
+        });
+        it('should skip assigning user lists if no user list properties are defined for a specific type path', async () => {
+            const typePaths = ['path1', 'path2'];
+            const typesByPath = {
+                path1: {
+                    userListProperties: [{ slug: 'userList1' }, { slug: 'userList2' }],
+                },
+                path2: {},
+            };
+            const incomingEntities = [
+                {
+                    id: 1,
+                    userList1: 'user1@example.com',
+                    userList2: 'user2@example.com',
+                },
+                { id: 2, userList3: 'user3@example.com' },
+            ];
+            await Helpers.assignUserLists(mockClient, typePaths, typesByPath, incomingEntities);
+            expect(incomingEntities).toEqual([
+                { id: 1, userList1Id: 1, userList2Id: 2 },
+                { id: 2, userList3: 'user3@example.com' },
+            ]);
+        });
+    });
+    describe('Helpers.assignObjectReferences', () => {
+        it('should assign object references to incoming entities', async () => {
+            const typePaths = ['path1', 'path2'];
+            const typesByPath = {
+                path1: {
+                    objectReferenceProperties: [
+                        {
+                            slug: 'objRef1',
+                            referencedTypeRootSlug: 'type1',
+                            referencedTypePath: 'path1',
+                        },
+                        {
+                            slug: 'objRef2',
+                            referencedTypeRootSlug: 'type2',
+                            referencedTypePath: 'path2',
+                        },
+                    ],
+                },
+                path2: {
+                    objectReferenceProperties: [
+                        {
+                            slug: 'objRef3',
+                            referencedTypeRootSlug: 'type3',
+                            referencedTypePath: 'custom-entity/path3',
+                        },
+                    ],
+                },
+            };
+            const incomingEntities = [
+                { id: 1, objRef1: 'ref1', objRef2: 'ref2' },
+                { id: 2, objRef3: 'ref3' },
+            ];
+            mockClient.get.mockResolvedValueOnce([
+                { federatedId: 'ref1', id: 1 },
+                { federatedId: 'ref2', id: 2 },
+                {
+                    federatedId: 'custom-entity/path3:ref3',
+                    id: 3,
+                },
+            ]);
+            await Helpers.assignObjectReferences(mockClient, typePaths, typesByPath, incomingEntities);
+            expect(incomingEntities).toEqual([
+                { id: 1, objRef1Id: 1, objRef2Id: 2 },
+                { id: 2, objRef3Id: 3 },
+            ]);
+        });
+        it('should skip assigning object references if no object reference properties are defined', async () => {
+            const typePaths = ['path1', 'path2'];
+            const typesByPath = { path1: {}, path2: {} };
+            const incomingEntities = [
+                { id: 1, objRef1: 'ref1', objRef2: 'ref2' },
+                { id: 2, objRef3: 'ref3' },
+            ];
+            await Helpers.assignObjectReferences(mockClient, typePaths, typesByPath, incomingEntities);
+            expect(incomingEntities).toEqual([
+                { id: 1, objRef1: 'ref1', objRef2: 'ref2' },
+                { id: 2, objRef3: 'ref3' },
+            ]);
+        });
+        it('should handle custom entity references correctly', async () => {
+            const typePaths = ['path1'];
+            const typesByPath = {
+                path1: {
+                    objectReferenceProperties: [
+                        {
+                            slug: 'customRef',
+                            referencedTypeRootSlug: 'custom',
+                            referencedTypePath: 'custom-entity/type1',
+                        },
+                    ],
+                },
+            };
+            const incomingEntities = [{ id: 1, customRef: 'ref1' }];
+            mockClient.get.mockResolvedValueOnce([{ federatedId: 'custom-entity/type1:ref1', id: 1 }]);
+            await Helpers.assignObjectReferences(mockClient, typePaths, typesByPath, incomingEntities);
+            expect(incomingEntities).toEqual([{ id: 1, customRefId: 1 }]);
+        });
+    });
+    describe('parseDateOrNumberKey', () => {
+        it('should parse date key', () => {
+            const someDate = new Date('2022-01-01T00:00:00.000Z');
+            const obj = { date: someDate };
+            (0, entities_helper_1.parseDateOrNumberKey)(obj, 'date');
+            expect(obj.date).toEqual(someDate.toISOString());
+        });
+        it('should parse date key when property type is defined', () => {
+            const someDate = new Date('2022-01-01T00:00:00.000Z');
+            const obj = { date: someDate };
+            (0, entities_helper_1.parseDateOrNumberKey)(obj, 'date');
+            expect(obj.date).toEqual(someDate.toISOString());
+        });
+        it('should parse number key', () => {
+            const obj = { number: '123' };
+            (0, entities_helper_1.parseDateOrNumberKey)(obj, 'number');
+            expect(obj.number).toEqual(123);
+        });
+        it('should not parse if key is already a number', () => {
+            const obj = { number: 123 };
+            (0, entities_helper_1.parseDateOrNumberKey)(obj, 'number');
+            expect(obj.number).toEqual(123);
+        });
+        it('should not parse if key is not a string', () => {
+            const obj = { date: null, number: null };
+            (0, entities_helper_1.parseDateOrNumberKey)(obj, 'date');
+            (0, entities_helper_1.parseDateOrNumberKey)(obj, 'number');
+            expect(obj.date).toEqual(null);
+            expect(obj.number).toEqual(null);
+        });
+        it('should not parse null date even if the property type is defined', () => {
+            const obj = { date: null };
+            (0, entities_helper_1.parseDateOrNumberKey)(obj, 'date', types_1.PropertyType.Date);
+            expect(obj.date).toEqual(null);
+        });
+        it('should not parse non-date-object date-property object', () => {
+            const obj = { date: { foo: 'bar' } };
+            (0, entities_helper_1.parseDateOrNumberKey)(obj, 'date', types_1.PropertyType.Date);
+            expect(obj.date).toEqual(null);
+        });
+    });
+});

package/node_modules/@contrail/loader/lib/common/entity-builder-helpers.d.ts

@@ -0,0 +1,6 @@
+import { PropertyType } from '@contrail/types';
+export interface SomeObject {
+    [key: string]: any;
+}
+export declare function addProperty(propertyName: string, allPropertiesSlugs: string[], valueType: PropertyType, object: any, value: any): SomeObject;
+export declare function shouldSkipProperty(value: any, valueType: string): boolean;