@segment/action-destinations 3.301.1-staging-c2af298f5 → 3.302.0

package/dist/destinations/hubspot/upsertObject/hubspot-api.js

@@ -1,9 +1,55 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HubspotClient = void 0;
+exports.HubspotClient = exports.SchemaMatch = exports.AssociationSyncMode = exports.SyncMode = void 0;
 const actions_core_1 = require("@segment/actions-core");
 const properties_1 = require("../properties");
 const constants_1 = require("./constants");
+const OBJECT_NOT_FOUND_ERROR_RESPONSE = 'Unable to infer object type';
+exports.SyncMode = {
+    Upsert: 'upsert',
+    Add: 'add',
+    Update: 'update'
+};
+exports.AssociationSyncMode = {
+    Upsert: 'upsert',
+    Read: 'read'
+};
+const BatchRequestType = {
+    Upsert: 'upsert',
+    Create: 'create',
+    Update: 'update',
+    Read: 'read'
+};
+const HSPropTypeFieldType = {
+    StringText: 'string:text',
+    NumberNumber: 'number:number',
+    DateTimeDate: 'datetime:date',
+    DateDate: 'date:date',
+    EnumerationBooleanCheckbox: 'enumeration:booleancheckbox'
+};
+const HSPropType = {
+    Date: 'date',
+    String: 'string',
+    DateTime: 'datetime',
+    Number: 'number',
+    Enumeration: 'enumeration'
+};
+const HSPropFieldType = {
+    Text: 'text',
+    Number: 'number',
+    Date: 'date',
+    BooleanCheckbox: 'booleancheckbox'
+};
+exports.SchemaMatch = {
+    FullMatch: 'full_match',
+    PropertiesMissing: 'properties_missing',
+    NoMatch: 'no_match',
+    Mismatch: 'mismatch'
+};
+const ReadType = {
+    ReturnRecordsWithIds: 'return_records_with_ids',
+    ReturnRecordsWithoutIds: 'return_records_without_ids'
+};
 var AssociationCategory;
 (function (AssociationCategory) {
     AssociationCategory["HUBSPOT_DEFINED"] = "HUBSPOT_DEFINED";
@@ -11,200 +57,254 @@ var AssociationCategory;
     AssociationCategory["INTEGRATOR_DEFINED"] = "INTEGRATOR_DEFINED";
 })(AssociationCategory || (AssociationCategory = {}));
 class HubspotClient {
-    constructor(request, fromObjectType, fromIdFieldName, syncMode, associationSyncMode, fromPropertyGroup) {
+    constructor(request, objectType, syncMode, associationSyncMode, propertyGroup) {
         this.request = request;
+        this.objectType = objectType;
+        this.syncMode = syncMode;
         this.associationSyncMode = associationSyncMode;
-        this.fromObjectType = fromObjectType;
-        this.fromIdFieldName = fromIdFieldName;
-        this.hubspotSyncMode = this.mapHubspotSyncMode(syncMode);
-        this.fromPropertyGroup = fromPropertyGroup;
+        this.propertyGroup = propertyGroup;
     }
-    mapHubspotSyncMode(syncMode) {
-        switch (syncMode) {
-            case 'upsert':
-                return 'upsert';
-            case 'add':
-                return 'create';
-            case 'update':
-                return 'update';
-            default:
-                throw new Error('Invalid sync mode');
+    cleanProp(str) {
+        str = str.toLowerCase().replace(/[^a-z0-9_]/g, '_');
+        if (!/^[a-z]/.test(str)) {
+            throw new actions_core_1.PayloadValidationError(`Property ${str} in event has an invalid name. Property names must start with a letter.`);
         }
+        return str;
     }
-    async propertiesFromHSchema(fetchProperties, fetchSensitiveProperties) {
-        const requests = [];
-        if (fetchProperties) {
-            requests.push(this.request(`${properties_1.HUBSPOT_BASE_URL}/crm/v3/properties/${this.fromObjectType}`, {
-                method: 'GET',
-                skipResponseCloning: true
-            }));
+    cleanObj(obj) {
+        const cleanObj = {};
+        if (obj === undefined) {
+            return undefined;
         }
-        if (fetchSensitiveProperties) {
-            requests.push(this.request(`${properties_1.HUBSPOT_BASE_URL}/crm/v3/properties/${this.fromObjectType}?dataSensitivity=sensitive`, {
-                method: 'GET',
-                skipResponseCloning: true
-            }));
-        }
-        try {
-            const responses = await Promise.all(requests);
-            const result = {
-                properties: [],
-                sensitiveProperties: []
-            };
-            if (fetchProperties && requests.length > 0) {
-                const propertiesResponse = responses.shift();
-                result.properties =
-                    propertiesResponse?.data.results.map((item) => ({
-                        name: item.name,
-                        type: item.type,
-                        fieldType: item.fieldType,
-                        hasUniqueValue: item.hasUniqueValue
-                    })) ?? [];
-            }
-            if (fetchSensitiveProperties && requests.length > 0) {
-                const sensitivePropertiesResponse = responses.shift();
-                result.sensitiveProperties =
-                    sensitivePropertiesResponse?.data.results.map((item) => ({
-                        name: item.name,
-                        type: item.type,
-                        fieldType: item.fieldType,
-                        hasUniqueValue: item.hasUniqueValue
-                    })) ?? [];
+        Object.keys(obj).forEach((key) => {
+            const value = obj[key];
+            const cleanKey = this.cleanProp(key);
+            cleanObj[cleanKey] =
+                typeof value === 'object' && value !== null ? JSON.stringify(value) : value;
+        });
+        return cleanObj;
+    }
+    cleanProps(payloads) {
+        const copy = JSON.parse(JSON.stringify(payloads));
+        copy.forEach((payload) => {
+            payload.properties = this.cleanObj(payload.properties);
+            payload.sensitive_properties = this.cleanObj(payload.sensitive_properties);
+        });
+        return copy;
+    }
+    format(value) {
+        switch (typeof value) {
+            case 'object':
+                return { type: HSPropType.String, fieldType: HSPropFieldType.Text };
+            case 'number':
+                return { type: HSPropType.Number, fieldType: HSPropFieldType.Number };
+            case 'boolean':
+                return { type: HSPropType.Enumeration, fieldType: HSPropFieldType.BooleanCheckbox };
+            case 'string': {
+                const date = new Date(value);
+                if (isNaN(date.getTime())) {
+                    return { type: HSPropType.String, fieldType: HSPropFieldType.Text };
+                }
+                else {
+                    const year = date.getUTCFullYear();
+                    const month = date.getUTCMonth();
+                    const day = date.getUTCDate();
+                    const hours = date.getUTCHours();
+                    const minutes = date.getUTCMinutes();
+                    const seconds = date.getUTCSeconds();
+                    const milliseconds = date.getUTCMilliseconds();
+                    if (hours === 0 && minutes === 0 && seconds === 0 && milliseconds === 0) {
+                        const reconstructedDate = new Date(Date.UTC(year, month, day));
+                        if (reconstructedDate.getTime() === date.getTime()) {
+                            return { type: HSPropType.Date, fieldType: HSPropFieldType.Date };
+                        }
+                    }
+                    return { type: HSPropType.DateTime, fieldType: HSPropFieldType.Date };
+                }
             }
-            return result;
-        }
-        catch (err) {
-            throw new actions_core_1.IntegrationError(`readProperties() failed: ${err?.response?.data?.message ?? 'Unknown error: readProperties() failed'}`, 'HUBSPOT_READ_PROPERTIES_FAILED', 400);
+            case undefined:
+            default:
+                throw new actions_core_1.IntegrationError('Property must be an object, boolean, string or number', 'HUBSPOT_PROPERTY_VALUE_UNDEFINED', 400);
         }
     }
-    hubspotStringType(str) {
-        const date = new Date(str);
-        if (isNaN(date.getTime())) {
-            return 'string';
+    formatHS(type, fieldType) {
+        if (type === 'date' && fieldType === 'date') {
+            return HSPropTypeFieldType.DateDate;
         }
-        const year = date.getUTCFullYear();
-        const month = date.getUTCMonth();
-        const day = date.getUTCDate();
-        const hours = date.getUTCHours();
-        const minutes = date.getUTCMinutes();
-        const seconds = date.getUTCSeconds();
-        const milliseconds = date.getUTCMilliseconds();
-        if (hours === 0 && minutes === 0 && seconds === 0 && milliseconds === 0) {
-            const reconstructedDate = new Date(Date.UTC(year, month, day));
-            if (reconstructedDate.getTime() === date.getTime()) {
-                return 'date';
-            }
-            else {
-                return 'datetime';
-            }
+        else if (type === 'string' && fieldType === 'text') {
+            return HSPropTypeFieldType.StringText;
         }
-        return 'datetime';
+        else if (type === 'number' && fieldType === 'number') {
+            return HSPropTypeFieldType.NumberNumber;
+        }
+        else if (type === 'datetime' && fieldType === 'date') {
+            return HSPropTypeFieldType.DateTimeDate;
+        }
+        else if (type === 'enumeration' && fieldType === 'booleancheckbox') {
+            return HSPropTypeFieldType.EnumerationBooleanCheckbox;
+        }
+        throw new actions_core_1.IntegrationError('Property type not supported', 'HUBSPOT_PROPERTY_TYPE_NOT_SUPPORTED', 400);
     }
-    uniquePayloadsProperties(payloads) {
-        const uniqueProperties = Object.values(payloads.reduce((acc, payload) => {
-            if (payload.properties) {
-                Object.keys(payload.properties).forEach((propName) => {
-                    if (payload.properties) {
-                        const value = payload.properties[propName];
-                        const type = typeof payload.properties[propName];
-                        const format = type === 'string' ? this.hubspotStringType(value) : 'string';
-                        acc[propName] = {
-                            name: propName,
-                            type,
-                            format
-                        };
-                    }
-                });
-            }
-            return acc;
-        }, {}));
-        const uniqueSensitiveProperties = Object.values(payloads.reduce((acc, payload) => {
-            if (payload.sensitiveProperties) {
-                Object.keys(payload.sensitiveProperties).forEach((propName) => {
-                    if (payload.sensitiveProperties) {
-                        const value = payload.sensitiveProperties[propName];
-                        const type = typeof payload.sensitiveProperties[propName];
-                        const format = type === 'string' ? this.hubspotStringType(value) : 'string';
+    schema(payloads) {
+        const extractProperties = (propertyType) => {
+            return Object.values(payloads.reduce((acc, payload) => {
+                const properties = payload[propertyType];
+                if (properties) {
+                    Object.entries(properties).forEach(([propName, value]) => {
+                        const typeData = this.format(value);
                         acc[propName] = {
                             name: propName,
-                            type,
-                            format
+                            type: typeData.type,
+                            fieldType: typeData.fieldType,
+                            typeFieldType: this.formatHS(typeData.type, typeData.fieldType)
                         };
-                    }
-                });
-            }
-            return acc;
-        }, {}));
+                    });
+                }
+                return acc;
+            }, {}));
+        };
+        const properties = extractProperties('properties');
+        const sensitiveProperties = extractProperties('sensitive_properties');
         return {
-            uniqueProperties,
-            uniqueSensitiveProperties
+            object_details: {
+                object_type: this.objectType,
+                id_field_name: payloads[0].object_details.id_field_name
+            },
+            properties,
+            sensitiveProperties
+        };
+    }
+    async schemaDiffCache(schema) {
+        let data = JSON.stringify(`${schema}`);
+        data = data.replace(data, '');
+        console.log(`${data}`);
+        const schemaDiff = {
+            match: 'no_match',
+            object_details: {
+                object_type: schema.object_details.object_type,
+                id_field_name: schema.object_details.id_field_name
+            },
+            missingProperties: [],
+            missingSensitiveProperties: []
         };
+        return Promise.resolve(schemaDiff);
     }
-    propertiesToCreateInHSSchema(uniquePayloadProperties, hubspotProperties) {
-        return uniquePayloadProperties.filter((prop) => !hubspotProperties.find((p) => p.name === prop.name));
+    async saveSchemaToCache(schema) {
+        let data = JSON.stringify(`${schema}`);
+        data = data.replace(data, '');
+        console.log(`${data}`);
     }
-    cleanProperties(payloads) {
-        const deepCopy = JSON.parse(JSON.stringify(payloads));
-        deepCopy.forEach((payload) => {
-            if (payload.properties) {
-                payload.properties = Object.keys(payload.properties).reduce((acc, prop) => {
-                    const lowerCasedProp = prop.toLowerCase();
-                    if (payload.properties && typeof payload.properties[prop] === 'object') {
-                        acc[lowerCasedProp] = JSON.stringify(payload.properties[prop], null, 2);
+    determineMissingPropsAndMatchType(response, properties) {
+        switch (response.status) {
+            case 'fulfilled': {
+                const results = response.value?.data.results ?? [];
+                const missingProps = [];
+                properties.forEach((prop) => {
+                    const match = results.find((item) => {
+                        return item.name === prop.name;
+                    });
+                    if (match && (match.fieldType !== prop.fieldType || match.type !== prop.type)) {
+                        throw new actions_core_1.IntegrationError(`Payload property with name ${prop.name} has a different type to the property in HubSpot. Expected: type = ${prop.type} fieldType = ${prop.fieldType}. Received: type = ${match.type} fieldType = ${match.fieldType}`, 'HUBSPOT_PROPERTY_TYPE_MISMATCH', 400);
                     }
-                    else {
-                        acc[lowerCasedProp] = payload.properties ? payload.properties[prop] : undefined;
+                    if (!match) {
+                        missingProps.push({
+                            name: prop.name,
+                            type: prop.type,
+                            fieldType: prop.fieldType,
+                            typeFieldType: prop.typeFieldType
+                        });
                     }
-                    return acc;
-                }, {});
+                });
+                return {
+                    missingProps,
+                    match: missingProps.length === 0 ? exports.SchemaMatch.FullMatch : exports.SchemaMatch.PropertiesMissing
+                };
             }
-            if (payload.sensitiveProperties) {
-                payload.sensitiveProperties = Object.keys(payload.sensitiveProperties).reduce((acc, prop) => {
-                    const lowerCasedProp = prop.toLowerCase();
-                    if (payload.sensitiveProperties && typeof payload.sensitiveProperties[prop] === 'object') {
-                        acc[lowerCasedProp] = JSON.stringify(payload.sensitiveProperties[prop], null, 2);
-                    }
-                    else {
-                        acc[lowerCasedProp] = payload.sensitiveProperties ? payload.sensitiveProperties[prop] : undefined;
-                    }
-                    return acc;
-                }, {});
+            case 'rejected': {
+                if (response.reason?.message.startsWith(OBJECT_NOT_FOUND_ERROR_RESPONSE)) {
+                    return { missingProps: [], match: exports.SchemaMatch.NoMatch };
+                }
+                else {
+                    throw new actions_core_1.IntegrationError(`Error fetching Hubspot property data: ${response.reason?.message}`, 'HUBSPOT_PROPERTY_FETCH_ERROR', 400);
+                }
             }
-        });
-        return deepCopy;
+        }
     }
-    async ensurePropertiesInHSSchema(properties, sensitiveProperties) {
-        if (!this.fromPropertyGroup) {
+    async schemaDiffHubspot(schema) {
+        const requests = [];
+        const hasProps = schema.properties.length;
+        const hasSensitiveProps = schema.sensitiveProperties.length;
+        if (hasProps) {
+            requests.push(this.request(`${properties_1.HUBSPOT_BASE_URL}/crm/v3/properties/${this.objectType}`, {
+                method: 'GET',
+                skipResponseCloning: true
+            }));
+        }
+        if (hasSensitiveProps) {
+            requests.push(this.request(`${properties_1.HUBSPOT_BASE_URL}/crm/v3/properties/${this.objectType}?dataSensitivity=sensitive`, {
+                method: 'GET',
+                skipResponseCloning: true
+            }));
+        }
+        const responses = await Promise.allSettled(requests);
+        const schemaDiff = {
+            object_details: {
+                object_type: schema.object_details.object_type,
+                id_field_name: schema.object_details.id_field_name
+            }
+        };
+        if (hasProps && requests.length > 0) {
+            const response = responses.shift();
+            const { missingProps, match } = this.determineMissingPropsAndMatchType(response, schema.properties);
+            schemaDiff.missingProperties = missingProps;
+            schemaDiff.match = match;
+        }
+        if (hasSensitiveProps && requests.length > 0) {
+            const response = responses.shift();
+            const { missingProps, match } = this.determineMissingPropsAndMatchType(response, schema.sensitiveProperties);
+            schemaDiff.missingSensitiveProperties = missingProps;
+            if (schemaDiff.match === exports.SchemaMatch.NoMatch && schemaDiff.match !== exports.SchemaMatch.NoMatch) {
+                throw new actions_core_1.IntegrationError('Unable to fetch property data from Hubspot', 'HUBSPOT_PROPERTIES_ERROR', 400);
+            }
+            if (schemaDiff.match === exports.SchemaMatch.FullMatch) {
+                schemaDiff.match = match;
+            }
+        }
+        return schemaDiff;
+    }
+    async createProperties(schemaDiff) {
+        if (!this.propertyGroup) {
             throw new actions_core_1.PayloadValidationError('"Property Group" is a required field when creating properties on an Object Schema in Hubspot');
         }
-        if ((!properties || properties.length === 0) && (!sensitiveProperties || sensitiveProperties.length === 0)) {
+        if (schemaDiff.missingProperties.length === 0 || schemaDiff.missingSensitiveProperties.length === 0) {
             return;
         }
-        const generateInputMapping = (prop, sensitive) => {
-            switch (prop.type) {
-                case 'number':
+        const { missingProperties: props, missingSensitiveProperties: sensitiveProps } = schemaDiff;
+        const input = (prop, sensitive) => {
+            switch (prop.typeFieldType) {
+                case HSPropTypeFieldType.NumberNumber:
                     return {
                         name: prop.name,
                         label: prop.name,
-                        groupName: this.fromPropertyGroup,
+                        groupName: this.propertyGroup,
                         type: 'number',
                         dataSensitivity: sensitive === true ? 'sensitive' : undefined,
                         fieldType: 'number'
                     };
-                case 'object':
+                case HSPropTypeFieldType.StringText:
                     return {
                         name: prop.name,
                         label: prop.name,
-                        groupName: this.fromPropertyGroup,
+                        groupName: this.propertyGroup,
                         type: 'string',
                         dataSensitivity: sensitive === true ? 'sensitive' : undefined,
                         fieldType: 'text'
                     };
-                case 'boolean':
+                case HSPropTypeFieldType.EnumerationBooleanCheckbox:
                     return {
                         name: prop.name,
                         label: prop.name,
-                        groupName: this.fromPropertyGroup,
+                        groupName: this.propertyGroup,
                         type: 'enumeration',
                         dataSensitivity: sensitive === true ? 'sensitive' : undefined,
                         fieldType: 'booleancheckbox',
@@ -225,232 +325,245 @@ class HubspotClient {
                             }
                         ]
                     };
-                case 'string':
-                    switch (prop.format) {
-                        case 'string':
-                            return {
-                                name: prop.name,
-                                label: prop.name,
-                                groupName: this.fromPropertyGroup,
-                                type: 'string',
-                                dataSensitivity: sensitive === true ? 'sensitive' : undefined,
-                                fieldType: 'text'
-                            };
-                        case 'date':
-                            return {
-                                name: prop.name,
-                                label: prop.name,
-                                groupName: this.fromPropertyGroup,
-                                type: 'date',
-                                dataSensitivity: sensitive === true ? 'sensitive' : undefined,
-                                fieldType: 'date'
-                            };
-                        case 'datetime':
-                            return {
-                                name: prop.name,
-                                label: prop.name,
-                                groupName: this.fromPropertyGroup,
-                                type: 'datetime',
-                                dataSensitivity: sensitive === true ? 'sensitive' : undefined,
-                                fieldType: 'date'
-                            };
-                    }
+                case HSPropTypeFieldType.DateTimeDate:
+                    return {
+                        name: prop.name,
+                        label: prop.name,
+                        groupName: this.propertyGroup,
+                        type: 'datetime',
+                        dataSensitivity: sensitive === true ? 'sensitive' : undefined,
+                        fieldType: 'date'
+                    };
+                case HSPropTypeFieldType.DateDate:
+                    return {
+                        name: prop.name,
+                        label: prop.name,
+                        groupName: this.propertyGroup,
+                        type: 'date',
+                        dataSensitivity: sensitive === true ? 'sensitive' : undefined,
+                        fieldType: 'date'
+                    };
             }
-            throw new actions_core_1.PayloadValidationError('Invalid property type');
         };
         const json = {
-            inputs: [
-                ...properties.map((prop) => generateInputMapping(prop, false)),
-                ...sensitiveProperties.map((prop) => generateInputMapping(prop, true))
-            ]
+            inputs: [...props.map((p) => input(p, false)), ...sensitiveProps.map((p) => input(p, true))]
         };
-        await this.request(`${properties_1.HUBSPOT_BASE_URL}/crm/v3/properties/${this.fromObjectType}/batch/create`, {
+        await this.request(`${properties_1.HUBSPOT_BASE_URL}/crm/v3/properties/${this.objectType}/batch/create`, {
             method: 'POST',
             skipResponseCloning: true,
             json
         });
     }
-    groupAssociations(associations, groupBy) {
-        const groupedAssociations = [];
-        const groups = associations.reduce((acc, association) => {
-            const key = groupBy.map((prop) => association[prop]).join('_');
-            if (!acc[key]) {
-                acc[key] = [];
-            }
-            acc[key].push(association);
-            return acc;
-        }, {});
-        for (const key in groups) {
-            const items = groups[key];
-            for (let i = 0; i < items.length; i += constants_1.MAX_HUBSPOT_BATCH_SIZE) {
-                groupedAssociations.push(items.slice(i, i + constants_1.MAX_HUBSPOT_BATCH_SIZE));
-            }
-        }
-        return groupedAssociations;
-    }
-    getAssociationsFromPayloads(payloads) {
-        const payloadsDeepCopy = JSON.parse(JSON.stringify(payloads));
-        const allAssociations = [];
-        payloadsDeepCopy.forEach((payload) => {
-            const associations = payload.associations ?? [];
-            associations.forEach((association) => {
-                association.from_record_id = payload.object_details.from_record_id;
-                allAssociations.push(association);
-            });
-        });
-        return allAssociations;
-    }
     async batchObjectRequest(action, objectType, data) {
         return this.request(`${properties_1.HUBSPOT_BASE_URL}/crm/v3/objects/${objectType}/batch/${action}`, {
             method: 'POST',
             json: data
         });
     }
-    async ensureToRecordsOnHubspot(associations) {
-        const associationsDeepCopy = JSON.parse(JSON.stringify(associations));
-        let requests;
-        let groupedAssociations;
-        switch (this.associationSyncMode) {
-            case 'upsert': {
-                groupedAssociations = this.groupAssociations(associationsDeepCopy, ['to_object_type']);
-                requests = groupedAssociations.map(async (associations) => {
-                    const { to_object_type: toObjectType } = associations[0];
-                    return await this.batchObjectRequest(this.associationSyncMode, toObjectType, {
-                        inputs: associations.map((association) => {
-                            return {
-                                idProperty: association.to_id_field_name,
-                                id: association.to_id_field_value,
-                                properties: {
-                                    [association.to_id_field_name]: association.to_id_field_value
-                                }
-                            };
-                        })
-                    });
-                });
-                break;
+    async sendFromRecords(payloads) {
+        switch (this.syncMode) {
+            case exports.SyncMode.Upsert: {
+                return await this.upsertRecords(payloads, this.objectType);
             }
-            case 'read': {
-                groupedAssociations = this.groupAssociations(associationsDeepCopy, ['to_object_type', 'to_id_field_name']);
-                requests = groupedAssociations.map(async (associations) => {
-                    const { to_object_type: toObjectType, to_id_field_name: toIdFieldName } = associations[0];
-                    return await this.batchObjectRequest(this.associationSyncMode, toObjectType, {
-                        idProperty: toIdFieldName,
-                        properties: [toIdFieldName],
-                        inputs: associations.map((association) => {
-                            return {
-                                id: association.to_id_field_value
-                            };
-                        })
-                    });
-                });
-                break;
+            case exports.SyncMode.Update: {
+                return await this.updateRecords(payloads, this.objectType);
+            }
+            case exports.SyncMode.Add: {
+                return await this.addRecords(payloads, this.objectType);
             }
         }
-        const responses = await Promise.all(requests);
-        responses.forEach((response, index) => {
-            const associations = groupedAssociations[index];
-            response?.data?.results.forEach((result) => {
-                associations
-                    .filter((association) => association.to_id_field_value == result.properties[association.to_id_field_name])
-                    .forEach((association) => (association.to_record_id = result.id));
-            });
+    }
+    async readRecords(payloads, objectType, readType) {
+        const idFieldName = payloads[0].object_details.id_field_name;
+        const readResponse = await this.batchObjectRequest(BatchRequestType.Read, objectType, {
+            properties: [idFieldName],
+            idProperty: idFieldName,
+            inputs: payloads.map((payload) => {
+                return { id: payload.object_details.id_field_value };
+            })
         });
-        switch (this.associationSyncMode) {
-            case 'upsert': {
-                return groupedAssociations.flat().filter((association) => association.to_record_id);
-            }
-            case 'read': {
-                return groupedAssociations.flat();
-            }
+        switch (readType) {
+            case ReadType.ReturnRecordsWithIds:
+                return this.returnRecordsWithIds(payloads, readResponse);
+            case ReadType.ReturnRecordsWithoutIds:
+                return this.returnRecordsWithoutIds(payloads, readResponse);
         }
     }
-    insertRecordIds(payloads, response) {
-        const payloadsDeepCopy = JSON.parse(JSON.stringify(payloads));
+    async upsertRecords(payloads, objectType) {
+        const response = await this.batchObjectRequest(BatchRequestType.Upsert, objectType, {
+            inputs: payloads.map(({ object_details: { id_field_value }, properties, sensitive_properties }) => {
+                const idFieldName = payloads[0].object_details.id_field_name;
+                return {
+                    idProperty: idFieldName,
+                    id: id_field_value,
+                    properties: { ...properties, ...sensitive_properties, [idFieldName]: id_field_value }
+                };
+            })
+        });
+        return this.returnRecordsWithIds(payloads, response);
+    }
+    async updateRecords(payloads, objectType) {
+        const existingRecords = (await this.readRecords(payloads, objectType, ReadType.ReturnRecordsWithIds));
+        const response = await this.batchObjectRequest(BatchRequestType.Update, this.objectType, {
+            inputs: existingRecords.map(({ object_details: { id_field_value }, properties, sensitive_properties }) => {
+                const idFieldName = payloads[0].object_details.id_field_name;
+                return {
+                    idProperty: idFieldName,
+                    id: id_field_value,
+                    properties: { ...properties, ...sensitive_properties }
+                };
+            })
+        });
+        return this.returnRecordsWithIds(existingRecords, response);
+    }
+    async addRecords(payloads, objectType) {
+        const recordsToCreate = (await this.readRecords(payloads, objectType, ReadType.ReturnRecordsWithoutIds));
+        const response = await this.batchObjectRequest(BatchRequestType.Create, this.objectType, {
+            inputs: recordsToCreate.map(({ object_details: { id_field_value: fromIdFieldValue }, properties, sensitive_properties }) => {
+                const idFieldName = payloads[0].object_details.id_field_name;
+                return {
+                    idProperty: idFieldName,
+                    properties: { ...properties, ...sensitive_properties, [idFieldName]: fromIdFieldValue }
+                };
+            })
+        });
+        return this.returnRecordsWithIds(recordsToCreate, response);
+    }
+    returnRecordsWithIds(payloads, response) {
         response?.data?.results.forEach((result) => {
-            payloadsDeepCopy
+            payloads
                 .filter((p) => {
-                return (p.object_details.from_id_field_value == result.properties[p.object_details.from_id_field_name]);
+                return p.object_details.id_field_value == result.properties[p.object_details.id_field_name];
             })
                 .forEach((p) => {
-                return (p.object_details.from_record_id = result.id);
+                const pw = { ...p, object_details: { ...p.object_details, record_id: result.id } };
+                if (pw.associations) {
+                    pw.associations.forEach((association) => {
+                        association.from_record_id = result.id;
+                    });
+                }
             });
         });
-        return payloadsDeepCopy;
+        return payloads;
     }
-    async ensureFromRecordsOnHubspot(payloads) {
-        const payloadsDeepCopy = JSON.parse(JSON.stringify(payloads));
-        let response;
-        switch (this.hubspotSyncMode) {
-            case 'upsert': {
-                response = await this.batchObjectRequest(this.hubspotSyncMode, this.fromObjectType, {
-                    inputs: payloadsDeepCopy.map(({ object_details: { from_id_field_value }, properties, sensitiveProperties }) => {
-                        return {
-                            idProperty: this.fromIdFieldName,
-                            id: from_id_field_value,
-                            properties: { ...properties, ...sensitiveProperties, [this.fromIdFieldName]: from_id_field_value }
-                        };
-                    })
-                });
-                return this.insertRecordIds(payloadsDeepCopy, response).filter((payload) => payload.object_details.from_id_field_value);
+    returnRecordsWithoutIds(payloads, response) {
+        const missingRecords = payloads.filter((payload) => {
+            return !response.data.results.some((result) => {
+                return result.properties[payload.object_details.id_field_name] === payload.object_details.id_field_value;
+            });
+        });
+        return missingRecords;
+    }
+    createAssociationPayloads(payloads) {
+        const associationPayloads = payloads.flatMap((payload) => Array.isArray(payload.associations)
+            ? payload.associations.map((association) => ({
+                object_details: {
+                    object_type: association.object_type,
+                    id_field_name: association.id_field_name,
+                    id_field_value: association.id_field_value,
+                    from_record_id: association.from_record_id
+                },
+                association_details: {
+                    association_label: association.association_label
+                }
+            }))
+            : []);
+        return this.groupPayloads(associationPayloads, ['object_type', 'id_field_name']);
+    }
+    groupPayloads(associations, groupBy) {
+        const groupedPayloads = [];
+        const groups = associations.reduce((acc, payload) => {
+            const key = groupBy.map((prop) => payload.object_details[prop]).join('_');
+            if (!acc[key]) {
+                acc[key] = [];
             }
-            case 'update': {
-                const readResponse = await this.batchObjectRequest('read', this.fromObjectType, {
-                    properties: [this.fromIdFieldName],
-                    idProperty: this.fromIdFieldName,
-                    inputs: payloadsDeepCopy.map((payload) => {
-                        return { id: payload.object_details.from_id_field_value };
-                    })
-                });
-                const existingRecords = this.insertRecordIds(payloadsDeepCopy, readResponse).filter((payload) => payload.object_details.from_record_id);
-                response = await this.batchObjectRequest(this.hubspotSyncMode, this.fromObjectType, {
-                    inputs: existingRecords.map(({ object_details: { from_id_field_value }, properties, sensitiveProperties }) => {
-                        return {
-                            idProperty: this.fromIdFieldName,
-                            id: from_id_field_value,
-                            properties: { ...properties, ...sensitiveProperties }
-                        };
-                    })
-                });
-                return this.insertRecordIds(existingRecords, response).filter((payload) => payload.object_details.from_id_field_value);
+            acc[key].push(payload);
+            return acc;
+        }, {});
+        for (const key in groups) {
+            const items = groups[key];
+            for (let i = 0; i < items.length; i += constants_1.MAX_HUBSPOT_BATCH_SIZE) {
+                groupedPayloads.push(items.slice(i, i + constants_1.MAX_HUBSPOT_BATCH_SIZE));
             }
-            case 'create': {
-                const readResponse = await this.batchObjectRequest('read', this.fromObjectType, {
-                    properties: [this.fromIdFieldName],
-                    idProperty: this.fromIdFieldName,
-                    inputs: payloadsDeepCopy.map((payload) => {
-                        return { id: payload.object_details.from_id_field_value };
-                    })
-                });
-                const nonExistingRecords = this.insertRecordIds(payloadsDeepCopy, readResponse).filter((payload) => !payload.object_details.from_record_id);
-                response = await this.batchObjectRequest(this.hubspotSyncMode, this.fromObjectType, {
-                    inputs: nonExistingRecords.map(({ object_details: { from_id_field_value: fromIdFieldValue }, properties, sensitiveProperties }) => {
-                        return {
-                            idProperty: this.fromIdFieldName,
-                            properties: { ...properties, ...sensitiveProperties, [this.fromIdFieldName]: fromIdFieldValue }
-                        };
-                    })
-                });
-                return this.insertRecordIds(nonExistingRecords, response).filter((payload) => payload.object_details.from_id_field_value);
+        }
+        return groupedPayloads;
+    }
+    async sendAssociatedRecords(payloads) {
+        switch (this.associationSyncMode) {
+            case exports.AssociationSyncMode.Upsert: {
+                return await this.upsertAssociatedRecords(payloads);
+            }
+            case exports.AssociationSyncMode.Read: {
+                return await this.readAssociatedRecords(payloads);
             }
         }
     }
+    async readAssociatedRecords(groupedPayloads) {
+        const requests = groupedPayloads.map(async (payloads) => {
+            const { object_type: objectType } = payloads[0].object_details;
+            return await this.batchObjectRequest(exports.AssociationSyncMode.Read, objectType, {
+                idProperty: payloads[0].object_details.id_field_name,
+                properties: [payloads[0].object_details.id_field_name],
+                inputs: payloads.map((payload) => {
+                    return {
+                        id: payload.object_details.id_field_value
+                    };
+                })
+            });
+        });
+        const responses = await Promise.all(requests);
+        return this.returnAssociatedRecordsWithIds(groupedPayloads, responses);
+    }
+    async upsertAssociatedRecords(groupedPayloads) {
+        const requests = groupedPayloads.map(async (payloads) => {
+            const { object_type: objectType } = payloads[0].object_details;
+            return await this.batchObjectRequest(exports.AssociationSyncMode.Upsert, objectType, {
+                inputs: payloads.map((payload) => {
+                    return {
+                        idProperty: payload.object_details.id_field_name,
+                        id: payload.object_details.id_field_value,
+                        properties: {
+                            [payload.object_details.id_field_name]: payload.object_details.id_field_value
+                        }
+                    };
+                })
+            });
+        });
+        const responses = await Promise.all(requests);
+        return this.returnAssociatedRecordsWithIds(groupedPayloads, responses);
+    }
+    returnAssociatedRecordsWithIds(groupedPayloads, responses) {
+        responses.forEach((response, index) => {
+            const payloads = groupedPayloads[index];
+            response?.data?.results.forEach((result) => {
+                payloads
+                    .filter((payload) => payload.object_details.id_field_value ==
+                    result.properties[payload.object_details.id_field_name])
+                    .forEach((payload) => (payload.object_details.record_id = result.id));
+            });
+        });
+        return groupedPayloads
+            .flat()
+            .filter((payload) => payload.object_details.record_id);
+    }
     async batchAssociationsRequest(body, toObjectType) {
-        return this.request(`${properties_1.HUBSPOT_BASE_URL}/crm/v4/associations/${this.fromObjectType}/${toObjectType}/batch/create`, {
+        return this.request(`${properties_1.HUBSPOT_BASE_URL}/crm/v4/associations/${this.objectType}/${toObjectType}/batch/create`, {
             method: 'POST',
             json: body
         });
     }
-    async ensureAssociations(associations) {
-        const associationsDeepCopy = JSON.parse(JSON.stringify(associations));
-        const groupedAssociations = this.groupAssociations(associationsDeepCopy, ['to_object_type']);
+    async sendAssociations(payloads) {
+        const groupedPayloads = this.groupPayloads(payloads, [
+            'object_type'
+        ]);
         function getAssociationType(associationLabel) {
             const [associationCategory, associationTypeId] = associationLabel.split(':');
             return { associationCategory, associationTypeId };
         }
-        const requests = groupedAssociations.map(async (group) => {
-            const toObjectType = group[0].to_object_type;
-            const inputs = group.map((association) => {
-                const { associationCategory, associationTypeId } = getAssociationType(association.association_label);
+        const requests = groupedPayloads.map(async (payloads) => {
+            const toObjectType = payloads[0].object_details.object_type;
+            const inputs = payloads.map((payload) => {
+                const { associationCategory, associationTypeId } = getAssociationType(payload.association_details.association_label);
                 const input = {
                     types: [
                         {
@@ -459,10 +572,10 @@ class HubspotClient {
                         }
                     ],
                     from: {
-                        id: association.from_record_id ?? ''
+                        id: payload.object_details.from_record_id
                     },
                     to: {
-                        id: association.to_record_id ?? ''
+                        id: payload.object_details.record_id
                     }
                 };
                 return input;