@memberjunction/actions-apollo 2.79.0 → 2.80.0

package/dist/accounts.js

@@ -32,69 +32,234 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LoadApolloAccountsEnrichmentAction = exports.ApolloAccountsEnrichmentAction = void 0;
+exports.LoadApolloAccountsEnrichmentAction = exports.ApolloEnrichmentAccountsAction = void 0;
 const actions_1 = require("@memberjunction/actions");
 const global_1 = require("@memberjunction/global");
 const Config = __importStar(require("./config"));
 const core_1 = require("@memberjunction/core");
 const axios_1 = __importDefault(require("axios"));
-// ApolloEnrichContact this Action would use the www.apollo.io enrichment service and enrich a "contact" type of record. The parameters to this Action would be:
-// EntityName - entity in question that contacts "contact" types of records
-// EmailField - string - field name in the target entity that contains the email to be used for lookups
-// FirstNameField - string 
-// LastNameField - string
-// AccountNameField - string
-// EnrichmentFieldMapping - JSON - this JSON string would contain mappings for the wide array of enrichment outputs. The idea is that the outputs could include a wide array of things and this would map any of the scalar values that Apollo.io provides back to entity field names in the target entity
-// EducationHistoryEntityName - string - optional - this would contain the name of the entity that will be used to stored the retrieved education history for each contact
-// EmploymentHistoryEntityName - string - optional - would contain the name of the entity that will be used to store the retrieved employment history for each contact
-// ApolloEnrichAccount - same idea and pattern as above, but would be for Account style entities
-// Would appreciate feedback on (a) the approach to how we package this stuff and (b) the approach to params noted above.
-let ApolloAccountsEnrichmentAction = class ApolloAccountsEnrichmentAction extends actions_1.BaseAction {
+/**
+ * Action that enriches account records using Apollo.io's organization and people data
+ *
+ * This action performs comprehensive account enrichment by:
+ * 1. Enriching organization data (address, phone, social profiles, etc.)
+ * 2. Creating technology stack records for the organization
+ * 3. Finding and enriching contacts associated with the organization
+ * 4. Creating employment/education history for contacts
+ *
+ * @example
+ * ```typescript
+ * // Basic account enrichment
+ * await runAction({
+ *   ActionName: 'ApolloEnrichmentAccountsAction',
+ *   Params: [{
+ *     Name: 'AccountEntityFieldMappings',
+ *     Value: JSON.stringify({
+ *       EntityName: 'Accounts',
+ *       Filter: 'Domain IS NOT NULL AND EnrichedAt IS NULL',
+ *       DomainField: 'Domain',
+ *       AccountIDField: 'ID',
+ *       EnrichedAtField: 'EnrichedAt'
+ *     })
+ *   }]
+ * });
+ *
+ * // Full enrichment with contacts and technologies
+ * await runAction({
+ *   ActionName: 'ApolloEnrichmentAccountsAction',
+ *   Params: [{
+ *     Name: 'AccountEntityFieldMappings',
+ *     Value: JSON.stringify(accountConfig)
+ *   }, {
+ *     Name: 'ContactEntityFieldMappings',
+ *     Value: JSON.stringify(contactConfig)
+ *   }, {
+ *     Name: 'AccountTechnologyEntityFieldMappings',
+ *     Value: JSON.stringify(technologyConfig)
+ *   }]
+ * });
+ * ```
+ */
+let ApolloEnrichmentAccountsAction = class ApolloEnrichmentAccountsAction extends actions_1.BaseAction {
     constructor() {
         super(...arguments);
+        /**
+         * Job titles to exclude when creating contact records
+         * These are typically not decision-makers or relevant contacts
+         */
         this.ExcludeTitles = ['member', 'student member', 'student', 'volunteer'];
     }
+    /**
+     * Main entry point for the Apollo account enrichment action
+     *
+     * @param params - The action parameters containing:
+     *   - AccountEntityFieldMappings: Required JSON configuration for account entity field mappings
+     *   - ContactEntityFieldMappings: Optional JSON configuration for contact entity field mappings
+     *   - AccountTechnologyEntityFieldMappings: Optional JSON configuration for technology tracking
+     *   - TechnologyCategoryEntityFieldMappings: Optional JSON configuration for technology categories
+     *   - ContactEducationHistoryEntityFieldMappings: Optional JSON configuration for education history
+     *
+     * @returns Promise<ActionResultSimple> indicating success/failure and any error messages
+     */
     async InternalRunAction(params) {
+        try {
+            // Validate API configuration
+            const configValidation = this.validateConfiguration();
+            if (!configValidation.success) {
+                return configValidation.error;
+            }
+            // Extract and validate parameters
+            const paramValidation = this.extractAndValidateParameters(params);
+            if (!paramValidation.success) {
+                return paramValidation.error;
+            }
+            const actionParams = paramValidation.data;
+            // Process all account records
+            return await this.processAllAccountRecords(actionParams, params.ContextUser, 1);
+        }
+        catch (error) {
+            (0, core_1.LogError)('Unexpected error in ApolloAccountsEnrichmentAction', undefined, error);
+            return {
+                Success: false,
+                Message: `Unexpected error: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                ResultCode: "FAILED"
+            };
+        }
+    }
+    /**
+     * Validates that the Apollo.io API key is configured properly
+     * @returns Validation result with success flag and potential error details
+     */
+    validateConfiguration() {
         if (!Config.ApolloAPIKey) {
-            throw new Error('Apollo.io API key not found');
+            return {
+                success: false,
+                error: {
+                    Success: false,
+                    Message: 'Apollo.io API key not found in configuration',
+                    ResultCode: "CONFIGURATION_ERROR"
+                }
+            };
         }
-        const accountEntityFieldNamesParam = params.Params.find(p => p.Name === 'AccountEntityFieldNameJSON');
-        const accountTechnologyEntityFieldNamesParam = params.Params.find(p => p.Name === 'AccountTechnologyEntityFieldNameJSON');
-        const technologyCategoryEntityFieldNamesParam = params.Params.find(p => p.Name === 'TechnologyCategoryEntityFieldNameJSON');
-        const ContactEntityFieldNamesParam = params.Params.find(p => p.Name === 'ContactEntityFieldNameJSON');
-        const ContactEducationHistoryEntityFieldNamesParam = params.Params.find(p => p.Name === 'ContactEducationHistoryEntityFieldNameJSON');
-        let accountEntityFieldNames = null;
-        let accountTechnologyEntityFieldNames = null;
-        let technologyCategoryEntityFieldNames = null;
-        let ContactEntityFieldNames = null;
-        let ContactEducationHistoryEntityFieldNames = null;
-        if (!accountEntityFieldNamesParam) {
-            throw new Error('AccountEntityFieldNames parameter not found');
+        return { success: true };
+    }
+    /**
+     * Extracts and validates all action parameters from the request
+     *
+     * @param params - The action parameters containing JSON configurations
+     * @returns Object with success flag, validated parameters, or error details
+     */
+    extractAndValidateParameters(params) {
+        const accountEntityFieldsParam = this.getRequiredParam(params, 'AccountEntityFieldMappings');
+        if (!accountEntityFieldsParam) {
+            return {
+                success: false,
+                error: {
+                    Success: false,
+                    Message: 'Missing required parameter: AccountEntityFieldMappings',
+                    ResultCode: "VALIDATION_ERROR"
+                }
+            };
         }
-        if (accountEntityFieldNamesParam && accountEntityFieldNamesParam.Value) {
-            accountEntityFieldNames = JSON.parse(accountEntityFieldNamesParam.Value);
-            if (accountEntityFieldNames) {
-                throw new Error('accountEntityFieldNames is empty');
+        let accountEntityFields;
+        try {
+            accountEntityFields = this.parseJSONParam(accountEntityFieldsParam.Value);
+            if (!accountEntityFields) {
+                throw new Error('Parsed AccountEntityFieldMappings is empty');
             }
         }
-        if (accountTechnologyEntityFieldNamesParam && accountTechnologyEntityFieldNamesParam.Value) {
-            accountTechnologyEntityFieldNames = JSON.parse(accountTechnologyEntityFieldNamesParam.Value) || null;
+        catch (error) {
+            return {
+                success: false,
+                error: {
+                    Success: false,
+                    Message: 'Invalid AccountEntityFieldMappings parameter: must be valid JSON or object',
+                    ResultCode: "VALIDATION_ERROR"
+                }
+            };
         }
-        if (technologyCategoryEntityFieldNamesParam && technologyCategoryEntityFieldNamesParam.Value) {
-            technologyCategoryEntityFieldNames = JSON.parse(technologyCategoryEntityFieldNamesParam.Value) || null;
+        // Extract optional parameters
+        const accountTechnologyEntityFields = this.parseOptionalJSONParam(params, 'AccountTechnologyEntityFieldMappings');
+        const technologyCategoryEntityFields = this.parseOptionalJSONParam(params, 'TechnologyCategoryEntityFieldMappings');
+        const contactEntityFields = this.parseOptionalJSONParam(params, 'ContactEntityFieldMappings');
+        const contactEducationHistoryEntityFields = this.parseOptionalJSONParam(params, 'ContactEducationHistoryEntityFieldMappings');
+        return {
+            success: true,
+            data: {
+                accountEntityFields,
+                accountTechnologyEntityFields,
+                technologyCategoryEntityFields,
+                contactEntityFields,
+                contactEducationHistoryEntityFields
+            }
+        };
+    }
+    /**
+     * Gets a required parameter from the action parameters
+     * @param params - The action parameters
+     * @param paramName - Name of the required parameter
+     * @returns The parameter if found, null otherwise
+     */
+    getRequiredParam(params, paramName) {
+        const param = params.Params.find(p => p.Name === paramName);
+        return param || null;
+    }
+    /**
+     * Parses an optional JSON parameter with error handling
+     * @param params - The action parameters
+     * @param paramName - Name of the optional JSON parameter
+     * @returns Parsed object of type T or null if not provided/invalid
+     */
+    parseOptionalJSONParam(params, paramName) {
+        const param = params.Params.find(p => p.Name === paramName);
+        if (!param || !param.Value) {
+            return null;
         }
-        if (ContactEntityFieldNamesParam && ContactEntityFieldNamesParam.Value) {
-            ContactEntityFieldNames = JSON.parse(ContactEntityFieldNamesParam.Value) || null;
+        try {
+            return this.parseJSONParam(param.Value) || null;
         }
-        if (ContactEducationHistoryEntityFieldNamesParam && ContactEducationHistoryEntityFieldNamesParam.Value) {
-            ContactEducationHistoryEntityFieldNames = JSON.parse(ContactEducationHistoryEntityFieldNamesParam.Value) || null;
+        catch (error) {
+            (0, core_1.LogError)(`Error parsing ${paramName}`, undefined, error);
+            return null;
         }
+    }
+    /**
+     * Parses a parameter value that may be a JSON string or already parsed object
+     * Handles the case where action parameters ending with JSON can be either strings or objects
+     *
+     * @param value - The parameter value to parse (string or object)
+     * @returns Parsed object of type T
+     * @throws Error if value cannot be parsed as JSON (when it's a string)
+     */
+    parseJSONParam(value) {
+        // If value is already an object (not a string), return it directly
+        if (typeof value === 'object' && value !== null) {
+            return value;
+        }
+        // If value is a string, try to parse it as JSON
+        if (typeof value === 'string') {
+            return JSON.parse(value);
+        }
+        // For other types, try to convert to string first then parse
+        return JSON.parse(String(value));
+    }
+    /**
+     * Recursively processes all account records that match the filter criteria
+     * Uses batching and concurrency control to handle large datasets efficiently
+     *
+     * @param actionParams - Validated action parameters with entity field mappings
+     * @param contextUser - User context for data access and security
+     * @param executionCount - Current execution count to prevent infinite recursion (max 5)
+     * @returns Promise indicating overall success/failure of the batch
+     */
+    async processAllAccountRecords(actionParams, contextUser, executionCount = 1) {
         const md = new core_1.Metadata();
         const rv = new core_1.RunView();
+        // Initial query to get accounts to process
         const runViewResult = await rv.RunView({
-            EntityName: accountEntityFieldNames.EntityName,
-            ExtraFilter: accountEntityFieldNames.ExtraFilter,
-        }, params.ContextUser);
+            EntityName: actionParams.accountEntityFields.EntityName,
+            ExtraFilter: actionParams.accountEntityFields.Filter,
+        }, contextUser);
         if (!runViewResult.Success) {
             return {
                 Success: false,
@@ -103,226 +268,339 @@ let ApolloAccountsEnrichmentAction = class ApolloAccountsEnrichmentAction extend
             };
         }
         const results = runViewResult.Results;
-        const resultLength = runViewResult.Results.length;
-        const tasks = []; // to hold promises
+        const resultLength = results.length;
+        if (resultLength === 0) {
+            (0, core_1.LogStatus)('+++ Completed domain enrichment, no records left to process.');
+            return {
+                Success: true,
+                Message: "ApolloAccountsEnrichment executed successfully.",
+                ResultCode: "SUCCESS"
+            };
+        }
+        // Check execution limit to prevent infinite recursion
+        if (executionCount >= 5) {
+            (0, core_1.LogStatus)(`+++ Reached maximum execution limit (${executionCount}), stopping to prevent infinite recursion.`);
+            return {
+                Success: true,
+                Message: `ApolloAccountsEnrichment stopped after ${executionCount} executions to prevent infinite recursion. ${resultLength} records may remain unprocessed.`,
+                ResultCode: "SUCCESS"
+            };
+        }
+        // Process accounts in concurrent groups
+        await this.processAccountGroups(results, actionParams, md, contextUser);
+        // Check if there are more records to process by running the query again
+        (0, core_1.LogStatus)(`--- Checking for remaining records... (execution ${executionCount + 1}/5)`);
+        return await this.processAllAccountRecords(actionParams, contextUser, executionCount + 1);
+    }
+    /**
+     * Processes account records in concurrent groups to optimize performance
+     * Respects the configured concurrency limit to avoid overwhelming APIs
+     *
+     * @param results - Array of account records to process
+     * @param actionParams - Configuration parameters for enrichment
+     * @param md - Metadata instance for entity operations
+     * @param contextUser - User context for data access
+     */
+    async processAccountGroups(results, actionParams, md, contextUser) {
+        const tasks = [];
+        const resultLength = results.length;
         for (const [index, record] of results.entries()) {
             const processParams = {
                 Record: record,
-                AccountEntity: accountEntityFieldNames,
-                AccountTechnologyEntity: accountTechnologyEntityFieldNames,
-                TechnologyCategoryEntity: technologyCategoryEntityFieldNames,
-                ContactEntity: ContactEntityFieldNames,
-                ContactEducationHistoryEntity: ContactEducationHistoryEntityFieldNames
+                AccountEntity: actionParams.accountEntityFields,
+                AccountTechnologyEntity: actionParams.accountTechnologyEntityFields || null,
+                TechnologyCategoryEntity: actionParams.technologyCategoryEntityFields || null,
+                ContactEntity: actionParams.contactEntityFields || null,
+                ContactEducationHistoryEntity: actionParams.contactEducationHistoryEntityFields || null
             };
-            const task = this.ProcessSingleDomain(processParams, index, resultLength, md, params.ContextUser);
+            const task = this.ProcessSingleDomain(processParams, index, resultLength, md, contextUser);
             tasks.push(task);
             if (tasks.length === Config.ConcurrentGroups || index + 1 >= resultLength) {
-                // if we started n tasks or reached the end of the result array, await all started tasks
                 await Promise.all(tasks);
-                // clear tasks
                 tasks.length = 0;
             }
         }
-        if (resultLength > 0) {
-            // restart the process once more to see if any records remaining
-            (0, core_1.LogStatus)('--- Records left, RESTARTING PROCESS...');
-            return await this.InternalRunAction(params);
-        }
-        else {
-            (0, core_1.LogStatus)('+++ Completed domain enrichment, no records left to process.');
-            return {
-                Success: true,
-                Message: "ApolloAccountsEnrichment executed successfully.",
-                ResultCode: "SUCCESS"
-            };
-        }
     }
+    /**
+     * Processes a single domain for both organization and people enrichment
+     * This is the main orchestration method for enriching one account
+     *
+     * @param params - Domain processing parameters with entity configurations
+     * @param startRow - Current row number for progress tracking
+     * @param totalRows - Total number of rows for progress tracking
+     * @param md - Metadata instance for entity operations
+     * @param currentUser - User context for data access
+     * @returns Promise<boolean> indicating success/failure of domain processing
+     */
     async ProcessSingleDomain(params, startRow, totalRows, md, currentUser) {
         const record = params.Record;
-        const accountID = record[params.AccountEntity.AccountIDName];
-        const domain = record[params.AccountEntity.DomainParamName];
-        const enrichOrganizationResult = await this.EnrichOrganization(params, startRow, totalRows, md, currentUser);
-        const createAndEnrichPeopleResult = await this.CreateAndEnrichPeople(params, accountID, domain, startRow, md, currentUser);
+        const accountID = record[params.AccountEntity.AccountIDField];
+        const domain = record[params.AccountEntity.DomainField];
+        const enrichOrganizationResult = await this.enrichOrganization(params, startRow, totalRows, md, currentUser);
+        const createAndEnrichPeopleResult = await this.createAndEnrichPeople(params, accountID, domain, startRow, md, currentUser);
         return enrichOrganizationResult && createAndEnrichPeopleResult;
     }
-    async EnrichOrganization(params, startRow, totalRows, md, currentUser) {
-        const record = params.Record;
-        const orgQueryString = {
-            api_key: Config.ApolloAPIKey,
-            domain: record[params.AccountEntity.DomainParamName]
-        };
-        const headers = {
-            'Cache-Control': 'no-cache',
-            'Content-Type': 'application/json'
-        };
-        // get the organization enrichment data first
-        const orgResponse = await this.WrapApolloCall('get', 'organizations/enrich', null, { params: orgQueryString, headers: headers });
-        if (!orgResponse || orgResponse.status !== 200) {
-            return false;
-        }
-        // here we want to iterate through all the results and update the contacts with the enriched data if
-        // the API returned a match
-        const result = orgResponse.data;
-        let bSuccess = true;
-        if (result && result.organization) {
-            const organization = result.organization;
-            // use the entity object to load up the account and then update some of the fields in it
-            const accountEntity = await md.GetEntityObject(params.AccountEntity.EntityName, currentUser);
-            accountEntity.SetMany(record);
-            if (params.AccountEntity.AddressFieldName) {
-                accountEntity.Set(params.AccountEntity.AddressFieldName, organization.street_address);
-            }
-            if (params.AccountEntity.CityFieldNameName) {
-                accountEntity.Set(params.AccountEntity.CityFieldNameName, organization.city);
-            }
-            if (params.AccountEntity.CityFieldNameName) {
-                accountEntity.Set(params.AccountEntity.CityFieldNameName, organization.city);
-            }
-            if (params.AccountEntity.StateProvinceFieldName) {
-                //accountEntity.Set(params.StateProvinceFieldName, organization.state);
-            }
-            if (params.AccountEntity.PostalCodeFieldName) {
-                accountEntity.Set(params.AccountEntity.PostalCodeFieldName, organization.postal_code);
-            }
-            if (params.AccountEntity.DescriptionFieldName) {
-                accountEntity.Set(params.AccountEntity.DescriptionFieldName, organization.short_description);
-            }
-            if (params.AccountEntity.PhoneNumberFieldName) {
-                accountEntity.Set(params.AccountEntity.PhoneNumberFieldName, organization.phone);
-            }
-            if (params.AccountEntity.CountryFieldName) {
-                accountEntity.Set(params.AccountEntity.CountryFieldName, organization.country);
-            }
-            if (params.AccountEntity.LinkedInFieldName) {
-                accountEntity.Set(params.AccountEntity.LinkedInFieldName, organization.linkedin_url);
-            }
-            if (params.AccountEntity.LogoURLFieldName) {
-                accountEntity.Set(params.AccountEntity.LogoURLFieldName, organization.logo_url);
-            }
-            if (params.AccountEntity.FacebookFieldName) {
-                accountEntity.Set(params.AccountEntity.FacebookFieldName, organization.facebook_url);
+    /**
+     * Enriches organization data using Apollo.io's organization enrichment endpoint
+     * Updates account record with company information and triggers technology processing
+     *
+     * @param params - Domain processing parameters
+     * @param startRow - Current row for progress tracking
+     * @param totalRows - Total rows for progress tracking
+     * @param md - Metadata instance for entity operations
+     * @param currentUser - User context for data access
+     * @returns Promise<boolean> indicating success/failure
+     */
+    async enrichOrganization(params, startRow, totalRows, md, currentUser) {
+        try {
+            const record = params.Record;
+            const orgQueryString = {
+                api_key: Config.ApolloAPIKey,
+                domain: record[params.AccountEntity.DomainField]
+            };
+            const headers = {
+                'Cache-Control': 'no-cache',
+                'Content-Type': 'application/json'
+            };
+            // Get the organization enrichment data
+            const orgResponse = await this.WrapApolloCall('get', 'organizations/enrich', null, { params: orgQueryString, headers: headers });
+            if (!orgResponse || orgResponse.status !== 200) {
+                return false;
             }
-            if (params.AccountEntity.TwitterFieldName) {
-                accountEntity.Set(params.AccountEntity.TwitterFieldName, organization.twitter_url);
+            const result = orgResponse.data;
+            let bSuccess = true;
+            if (result && result.organization) {
+                bSuccess = await this.updateAccountWithOrganizationData(result.organization, params, record, md, currentUser);
+                if (params.AccountTechnologyEntity && bSuccess) {
+                    const accountID = record[params.AccountEntity.AccountIDField];
+                    bSuccess = bSuccess && await this.CreateAccountTechnologyRecords(params, accountID, result.organization.current_technologies, md, currentUser);
+                }
             }
-            if (params.AccountEntity.EnrichedAtField) {
-                accountEntity.Set(params.AccountEntity.EnrichedAtField, new Date());
+            else {
+                // No match found, but still update enriched timestamp
+                (0, core_1.LogStatus)(`  > No matches found for this domain: ${params.Record[params.AccountEntity.DomainField]}`);
+                bSuccess = await this.updateAccountEnrichedTimestamp(params, record, md, currentUser);
             }
-            // no field for twitter, add this mapping when that's done
-            //accountEntity.Twitter = result.organization.twitter_url;
+            return bSuccess;
+        }
+        catch (error) {
+            (0, core_1.LogError)('Error enriching organization', undefined, error);
+            return false;
+        }
+    }
+    /**
+     * Updates an account entity with enriched organization data from Apollo.io
+     * Maps Apollo organization fields to the configured account entity fields
+     *
+     * @param organization - Apollo organization data
+     * @param params - Processing parameters with field mappings
+     * @param record - Current account record data
+     * @param md - Metadata instance for entity operations
+     * @param currentUser - User context for data access
+     * @returns Promise<boolean> indicating save success/failure
+     */
+    async updateAccountWithOrganizationData(organization, params, record, md, currentUser) {
+        try {
+            const accountEntity = await md.GetEntityObject(params.AccountEntity.EntityName, core_1.CompositeKey.FromID(record.ID), currentUser);
+            // Set organization data fields
+            this.setFieldIfExists(accountEntity, params.AccountEntity.AddressField, organization.street_address);
+            this.setFieldIfExists(accountEntity, params.AccountEntity.CityField, organization.city);
+            this.setFieldIfExists(accountEntity, params.AccountEntity.StateProvinceField, organization.state);
+            this.setFieldIfExists(accountEntity, params.AccountEntity.PostalCodeField, organization.postal_code);
+            this.setFieldIfExists(accountEntity, params.AccountEntity.DescriptionField, organization.short_description);
+            this.setFieldIfExists(accountEntity, params.AccountEntity.PhoneNumberField, organization.phone);
+            this.setFieldIfExists(accountEntity, params.AccountEntity.CountryField, organization.country);
+            this.setFieldIfExists(accountEntity, params.AccountEntity.LinkedInField, organization.linkedin_url);
+            this.setFieldIfExists(accountEntity, params.AccountEntity.LogoURLField, organization.logo_url);
+            this.setFieldIfExists(accountEntity, params.AccountEntity.FacebookField, organization.facebook_url);
+            this.setFieldIfExists(accountEntity, params.AccountEntity.TwitterField, organization.twitter_url);
+            this.setFieldIfExists(accountEntity, params.AccountEntity.EnrichedAtField, new Date());
             const saveResult = await accountEntity.Save();
             if (!saveResult) {
                 (0, core_1.LogError)('Error updating account record with enriched data', undefined, accountEntity.LatestResult);
             }
-            if (params.AccountTechnologyEntity) {
-                // now, attempt to create technology records for linking to the account
-                const accountID = record[params.AccountEntity.AccountIDName];
-                bSuccess = bSuccess && await this.CreateAccountTechnologyRecords(params, accountID, result.organization.current_technologies, md, currentUser);
-            }
-            return bSuccess;
+            return saveResult;
+        }
+        catch (error) {
+            (0, core_1.LogError)('Error updating account with organization data', undefined, error);
+            return false;
         }
-        else {
-            // missing records == details.length means no matches were found
-            (0, core_1.LogStatus)(`  > No matches found for this domain: ${params.Record[params.AccountEntity.DomainParamName]}`);
-            // even though there was no match, we still update the LastEnrichedAt field on the account otherwise we'll keep on attempting to run this each
-            // time this process goes through the list of accounts.
-            const accountEntity = await md.GetEntityObject('Accounts', currentUser);
-            accountEntity.SetMany(params.Record);
+    }
+    /**
+     * Updates the enrichment timestamp on an account even when no data was found
+     * Prevents repeated attempts to enrich accounts with no Apollo data
+     *
+     * @param params - Processing parameters with field mappings
+     * @param record - Current account record data
+     * @param md - Metadata instance for entity operations
+     * @param currentUser - User context for data access
+     * @returns Promise<boolean> indicating save success/failure
+     */
+    async updateAccountEnrichedTimestamp(params, record, md, currentUser) {
+        try {
+            const accountEntity = await md.GetEntityObject('Accounts', core_1.CompositeKey.FromID(record.ID), currentUser);
             accountEntity.Set(params.AccountEntity.EnrichedAtField, new Date());
             const saveResult = await accountEntity.Save();
             if (!saveResult) {
-                (0, core_1.LogError)('Error updating account record with enriched data', undefined, accountEntity.LatestResult);
+                (0, core_1.LogError)('Error updating account record with enriched timestamp', undefined, accountEntity.LatestResult);
             }
             return saveResult;
         }
-    }
-    async CreateAccountTechnologyRecords(params, accountID, technologies, md, currentUser) {
-        let bSuccess = true;
-        const ATEntity = params.AccountTechnologyEntity;
-        if (!ATEntity) {
+        catch (error) {
+            (0, core_1.LogError)('Error updating account enriched timestamp', undefined, error);
             return false;
         }
-        const rv = new core_1.RunView();
-        const runViewResult = await rv.RunView({
-            EntityName: `${ATEntity.EntityName}`,
-            ExtraFilter: `${ATEntity.AccountIDFieldName} = ${accountID}`
-        }, currentUser);
-        if (!runViewResult.Success) {
-            (0, core_1.LogError)('Error querying for existing Account Technologies', undefined, runViewResult.ErrorMessage);
-            return false;
+    }
+    /**
+     * Safely sets a field on an entity if the field name is defined and value is not null
+     * Prevents errors from undefined field mappings
+     *
+     * @param entity - Target entity to update
+     * @param fieldName - Name of the field (can be undefined)
+     * @param value - Value to set (checked for null/undefined)
+     */
+    setFieldIfExists(entity, fieldName, value) {
+        if (fieldName && value != null) {
+            entity.Set(fieldName, value);
         }
-        for (const technology of technologies) {
-            const categoryId = await this.GetOrCreateTechnologyCategoryId(params, technology.category, md, currentUser);
-            const row = runViewResult.Results.find((r) => r.Category.trim().toLowerCase() === technology.category.trim().toLowerCase() && r.Technology.trim().toLowerCase() === technology.name.trim().toLowerCase());
-            if (!row || row.length === 0) {
-                const at = await md.GetEntityObject(ATEntity.EntityName, currentUser);
-                at.Set(ATEntity.AccountIDFieldName, accountID);
-                at.Set(ATEntity.TechnologyIDFieldName, await this.GetOrCreateTechnologyId(technology.name, categoryId, md, currentUser));
-                bSuccess = bSuccess && await at.Save();
-            }
-            else {
-                row.matchFound = true;
-            }
-        }
-        // finally, go through all the rows in existingRows, and for any that have matchFound === true, skip
-        // but for rest update them to have their EndedAt = NOW
-        const fieldName = ATEntity.MatchFoundFieldName;
-        for (const record of runViewResult.Results) {
-            if (!record[fieldName]) {
-                const entity = await md.GetEntityObject(fieldName, currentUser);
-                entity.SetMany(record);
-                entity.Set(ATEntity.EndedUseAtFieldName, new Date());
-                const saveResult = await entity.Save();
-                if (!saveResult) {
-                    (0, core_1.LogError)('Error updating Account Technology record with enriched data', undefined, entity.LatestResult);
+    }
+    /**
+     * Creates or updates technology records associated with an account
+     * Manages the relationship between accounts and their technology stack
+     * Marks old technologies as ended if no longer detected
+     *
+     * @param params - Processing parameters with technology entity configuration
+     * @param accountID - ID of the account to associate technologies with
+     * @param technologies - Array of technology data from Apollo
+     * @param md - Metadata instance for entity operations
+     * @param currentUser - User context for data access
+     * @returns Promise<boolean> indicating overall success/failure
+     */
+    async CreateAccountTechnologyRecords(params, accountID, technologies, md, currentUser) {
+        if (!params.AccountTechnologyEntity || !technologies || technologies.length === 0) {
+            return true;
+        }
+        try {
+            let bSuccess = true;
+            const ATEntity = params.AccountTechnologyEntity;
+            if (ATEntity.TechnologyIDField && ATEntity.TechnologyField && ATEntity.CategoryField) {
+                const rv = new core_1.RunView();
+                const runViewResult = await rv.RunView({
+                    EntityName: ATEntity.EntityName,
+                    ExtraFilter: `${ATEntity.AccountIDField} = ${accountID}`
+                }, currentUser);
+                if (!runViewResult.Success) {
+                    (0, core_1.LogError)('Error querying for existing Account Technologies', undefined, runViewResult.ErrorMessage);
+                    return false;
+                }
+                // Process each technology
+                for (const technology of technologies) {
+                    const categoryId = await this.getOrCreateTechnologyCategoryId(params, technology.category, md, currentUser);
+                    const existingRow = runViewResult.Results.find((r) => r[ATEntity.CategoryField]?.trim().toLowerCase() === technology.category.trim().toLowerCase() &&
+                        r[ATEntity.TechnologyField]?.trim().toLowerCase() === technology.name.trim().toLowerCase());
+                    if (!existingRow) {
+                        // Create new technology record
+                        const at = await md.GetEntityObject(ATEntity.EntityName, currentUser);
+                        at.NewRecord();
+                        at.Set(ATEntity.AccountIDField, accountID);
+                        at.Set(ATEntity.TechnologyIDField, await this.getOrCreateTechnologyId(technology.name, categoryId, md, currentUser));
+                        bSuccess = bSuccess && await at.Save();
+                    }
+                    else {
+                        existingRow.matchFound = true;
+                    }
+                }
+                // Mark unmatched technologies as ended
+                for (const record of runViewResult.Results) {
+                    if (!record.matchFound) {
+                        const entity = await md.GetEntityObject(ATEntity.EntityName, core_1.CompositeKey.FromID(record.ID), currentUser);
+                        entity.Set(ATEntity.EndedUseAtField, new Date());
+                        const saveResult = await entity.Save();
+                        if (!saveResult) {
+                            (0, core_1.LogError)('Error updating Account Technology record', undefined, entity.LatestResult);
+                        }
+                        bSuccess = bSuccess && saveResult;
+                    }
                 }
-                bSuccess = bSuccess && saveResult;
             }
+            return bSuccess;
+        }
+        catch (error) {
+            (0, core_1.LogError)('Error creating account technology records', undefined, error);
+            return false;
         }
-        return bSuccess;
     }
-    async GetOrCreateTechnologyCategoryId(params, categoryName, md, currentUser) {
+    /**
+     * Gets or creates a technology category record by name
+     * Ensures technology categories exist before creating technology records
+     *
+     * @param params - Processing parameters with category entity configuration
+     * @param categoryName - Name of the technology category
+     * @param md - Metadata instance for entity operations
+     * @param currentUser - User context for data access
+     * @returns Promise<number> - ID of the category (0 if error)
+     */
+    async getOrCreateTechnologyCategoryId(params, categoryName, md, currentUser) {
         const TCEntity = params.TechnologyCategoryEntity;
         if (!TCEntity) {
             return 0;
         }
-        const rv = new core_1.RunView();
-        const runViewResult = await rv.RunView({
-            EntityName: TCEntity.EntityName,
-            ExtraFilter: `${TCEntity.NameFieldName} = '${this.EscapeSingleQuotes(categoryName)}'`
-        }, currentUser);
-        if (!runViewResult.Success) {
-            (0, core_1.LogError)('Error querying for existing Technology Categories', undefined, runViewResult.ErrorMessage);
-            return 0;
-        }
-        if (runViewResult.Results.length > 0) {
-            return runViewResult.Results[0].ID;
+        try {
+            const rv = new core_1.RunView();
+            const runViewResult = await rv.RunView({
+                EntityName: TCEntity.EntityName,
+                ExtraFilter: `${TCEntity.NameField} = '${this.EscapeSingleQuotes(categoryName)}'`
+            }, currentUser);
+            if (!runViewResult.Success) {
+                (0, core_1.LogError)('Error querying for existing Technology Categories', undefined, runViewResult.ErrorMessage);
+                return 0;
+            }
+            if (runViewResult.Results.length > 0) {
+                return runViewResult.Results[0].ID;
+            }
+            // Create new record
+            const entity = await md.GetEntityObject(TCEntity.EntityName, currentUser);
+            entity.NewRecord();
+            entity.Set(TCEntity.NameField, categoryName);
+            const saveResult = await entity.Save();
+            if (!saveResult) {
+                (0, core_1.LogError)('Error creating new Technology Category record', undefined, entity.LatestResult);
+                return 0;
+            }
+            return entity.Get(TCEntity.IDField);
         }
-        //create a new record
-        const entity = await md.GetEntityObject(TCEntity.EntityName, currentUser);
-        entity.Set(TCEntity.NameFieldName, categoryName);
-        const saveResult = await entity.Save();
-        if (!saveResult) {
-            (0, core_1.LogError)('Error creating new Technology Category record', undefined, entity.LatestResult);
+        catch (error) {
+            (0, core_1.LogError)('Error getting or creating technology category', undefined, error);
             return 0;
         }
-        return entity.Get(TCEntity.IDFieldName);
     }
-    async GetOrCreateTechnologyId(name, categoryId, md, currentUser) {
-        const rv = new core_1.RunView();
-        const runViewResult = await rv.RunView({
-            EntityName: 'Technologies',
-            ExtraFilter: `Name = '${this.EscapeSingleQuotes(name)}' AND CategoryID = ${categoryId}`
-        }, currentUser);
-        if (!runViewResult.Success) {
-            (0, core_1.LogError)('Error querying for existing Technologies', undefined, runViewResult.ErrorMessage);
-            return 0;
-        }
-        if (runViewResult.Results.length > 0) {
-            return runViewResult.Results[0].ID;
-        }
-        else {
+    /**
+     * Gets or creates a technology record by name and category
+     * Maintains referential integrity between technologies and categories
+     *
+     * @param name - Name of the technology
+     * @param categoryId - ID of the technology category
+     * @param md - Metadata instance for entity operations
+     * @param currentUser - User context for data access
+     * @returns Promise<number> - ID of the technology (0 if error)
+     */
+    async getOrCreateTechnologyId(name, categoryId, md, currentUser) {
+        try {
+            const rv = new core_1.RunView();
+            const runViewResult = await rv.RunView({
+                EntityName: 'Technologies',
+                ExtraFilter: `Name = '${this.EscapeSingleQuotes(name)}' AND CategoryID = ${categoryId}`
+            }, currentUser);
+            if (!runViewResult.Success) {
+                (0, core_1.LogError)('Error querying for existing Technologies', undefined, runViewResult.ErrorMessage);
+                return 0;
+            }
+            if (runViewResult.Results.length > 0) {
+                return runViewResult.Results[0].ID;
+            }
+            // Create new technology record
             const technologyEntity = await md.GetEntityObject('Technologies', currentUser);
+            technologyEntity.NewRecord();
             technologyEntity.Set('Name', name);
             technologyEntity.Set('CategoryID', categoryId);
             const saveResult = await technologyEntity.Save();
@@ -332,212 +610,342 @@ let ApolloAccountsEnrichmentAction = class ApolloAccountsEnrichmentAction extend
             }
             return technologyEntity.Get('ID');
         }
+        catch (error) {
+            (0, core_1.LogError)('Error getting or creating technology', undefined, error);
+            return 0;
+        }
     }
-    async CreateAndEnrichPeople(params, accountID, domain, startRow, md, currentUser) {
-        let APIparams = {
-            api_key: Config.ApolloAPIKey,
-            reveal_personal_emails: true,
-            q_organization_domains: domain,
-            page: 1
-        };
-        const headers = {
-            'Cache-Control': 'no-cache',
-            'Content-Type': 'application/json'
-        };
-        const response = await this.WrapApolloCall('post', 'mixed_people/search', APIparams, { headers: headers });
-        if (!response || response.status !== 200) {
-            (0, core_1.LogError)(`Error fetching data from Apollo.io: ${response.statusText}`);
-            return false;
+    /**
+     * Searches for and enriches people associated with an organization's domain
+     * Uses Apollo's people search to find contacts at the organization
+     * Handles pagination to retrieve all available contacts (up to configured limit)
+     *
+     * @param params - Processing parameters with contact entity configuration
+     * @param accountID - ID of the account to associate contacts with
+     * @param domain - Organization domain to search for people
+     * @param startRow - Current row for progress tracking
+     * @param md - Metadata instance for entity operations
+     * @param currentUser - User context for data access
+     * @returns Promise<boolean> indicating success/failure of people processing
+     */
+    async createAndEnrichPeople(params, accountID, domain, startRow, md, currentUser) {
+        if (!params.ContactEntity) {
+            return true; // No contact processing needed
         }
-        // here we want to iterate through all the results and update the contacts with the enriched data if
-        // the API returned a match
-        const data = response.data;
-        const allPeople = data.people;
-        for (let i = 1; i < data.pagination.total_pages && i < (Config.MaxPeopleToEnrichPerOrg / 10); i++) {
-            //get additional pages
-            APIparams.page = i + 1;
-            const nextResponse = await this.WrapApolloCall('post', 'mixed_people/search', params, { headers: headers });
-            if (nextResponse.status !== 200) {
-                console.error(`Error fetching data from Apollo.io: ${nextResponse.statusText}`);
+        try {
+            const APIparams = {
+                api_key: Config.ApolloAPIKey,
+                reveal_personal_emails: true,
+                q_organization_domains: domain,
+                page: 1
+            };
+            const headers = {
+                'Cache-Control': 'no-cache',
+                'Content-Type': 'application/json'
+            };
+            const response = await this.WrapApolloCall('post', 'mixed_people/search', APIparams, { headers: headers });
+            if (!response || response.status !== 200) {
+                (0, core_1.LogError)(`Error fetching data from Apollo.io: ${response?.statusText}`);
                 return false;
             }
-            else {
-                // here we want to iterate through all the results and update the contacts with the enriched data if
-                // the API returned a match
+            const data = response.data;
+            const allPeople = data.people;
+            // Fetch additional pages
+            for (let i = 1; i < data.pagination.total_pages && i < (Config.MaxPeopleToEnrichPerOrg / 10); i++) {
+                APIparams.page = i + 1;
+                const nextResponse = await this.WrapApolloCall('post', 'mixed_people/search', APIparams, { headers: headers });
+                if (nextResponse.status !== 200) {
+                    console.error(`Error fetching data from Apollo.io: ${nextResponse.statusText}`);
+                    return false;
+                }
                 const nextResult = nextResponse.data;
                 allPeople.push(...nextResult.people);
             }
+            if (allPeople.length === 0) {
+                (0, core_1.LogStatus)(`No people found for this domain: ${domain}`);
+                return true;
+            }
+            // Process all people
+            let bSuccess = true;
+            for (let i = 0; i < allPeople.length; i++) {
+                const person = allPeople[i];
+                if (this.shouldSkipPerson(person, domain)) {
+                    continue;
+                }
+                bSuccess = bSuccess && await this.createAndEnrichContact(params, accountID, person, md, currentUser, i, allPeople.length);
+            }
+            return bSuccess;
+        }
+        catch (error) {
+            (0, core_1.LogError)('Error creating and enriching people', undefined, error);
+            return false;
         }
-        let bSuccess = true;
-        if (allPeople.length === 0) {
-            (0, core_1.LogStatus)(`No people found for this domain: ${domain}`);
+    }
+    /**
+     * Determines if a person should be skipped during contact creation
+     * Filters out people with missing data or excluded job titles
+     *
+     * @param person - Person data from Apollo search response
+     * @param domain - Expected domain for email validation
+     * @returns boolean - true if person should be skipped
+     */
+    shouldSkipPerson(person, domain) {
+        // Check for missing required data
+        if (!person.last_name || !person.email || person.email.split('@')[1] !== domain) {
+            (0, core_1.LogStatus)(`Skipping person: ${person.first_name} ${person.last_name} because email is missing or does not match domain`);
             return true;
         }
-        let i = 0;
-        for (const person of allPeople) {
-            // first, check to make sure that the person has an email and the domain matches the 
-            // account domain, we don't want people who's primary email doesn't match the domain
-            if (!person.last_name || !person.email || person.email.split('@')[1] !== domain) {
-                // skip this person
-                (0, core_1.LogStatus)(`Skipping person: ${person.first_name} ${person.last_name}, accountID: ${accountID} because email is missing or does not match domain`);
-            }
-            else if (this.IsExcludedTitle(person.title)) {
-                (0, core_1.LogStatus)(`Skipping person: ${person.first_name} ${person.last_name}, accountID: ${accountID} because title is excluded`);
-            }
-            else {
-                bSuccess = bSuccess && await this.CreateAndEnrichContact(params, accountID, person, md, currentUser, i, allPeople.length);
-            }
-            i++;
+        // Check for excluded titles
+        if (this.IsExcludedTitle(person.title)) {
+            (0, core_1.LogStatus)(`Skipping person: ${person.first_name} ${person.last_name} because title is excluded`);
+            return true;
         }
-        return bSuccess;
+        return false;
     }
-    async CreateAndEnrichContact(params, accountID, person, md, currentUser, sequence, total) {
+    /**
+     * Creates or updates a contact record with enriched data from Apollo
+     * Handles contact deduplication and data validation
+     *
+     * @param params - Processing parameters with contact entity configuration
+     * @param accountID - ID of the account to associate contact with
+     * @param person - Person data from Apollo search response
+     * @param md - Metadata instance for entity operations
+     * @param currentUser - User context for data access
+     * @param sequence - Current contact number for progress tracking
+     * @param total - Total contacts for progress tracking
+     * @returns Promise<boolean> indicating success/failure
+     */
+    async createAndEnrichContact(params, accountID, person, md, currentUser, sequence, total) {
         const CEntity = params.ContactEntity;
         if (!CEntity) {
             return false;
         }
         try {
             (0, core_1.LogStatus)(`Enriching contact for person: ${person.first_name} ${person.last_name}, accountID: ${accountID} (${sequence} of ${total})`);
-            // first check to see if there is an existing contact record for this person
-            const contact = await this.GetOrCreateContact(params, accountID, person, md, currentUser);
+            const contact = await this.getOrCreateContact(params, accountID, person, md, currentUser);
             if (!contact) {
                 return false;
             }
-            // now we have a contact entity object and we can enrich it. 
-            contact.Set(CEntity.FirstNameFieldName, person.first_name);
-            contact.Set(CEntity.LastNameFieldName, person.last_name);
-            contact.Set(CEntity.TitleFieldName, person.title);
-            if (person.email) {
-                contact.Set(CEntity.EmailFieldName, person.email);
-            }
-            contact.Set(CEntity.FacebookFieldName, person.facebook_url);
-            contact.Set(CEntity.LinkedInFieldName, person.linkedin_url);
-            contact.Set(CEntity.TwitterFieldName, person.twitter_url);
-            //contact.Set("PhoneNumber", person.?.length > 0 ? person.phone_numbers[0].raw_number : null;
-            contact.Set(CEntity.PhotoFieldName, person.photo_url);
-            contact.Set(CEntity.LastEnrichedAtFieldName, new Date());
-            const saveResult = contact.Save();
+            // Update contact with enriched data
+            this.updateContactFields(contact, person, CEntity);
+            const saveResult = await contact.Save();
             if (!saveResult) {
                 (0, core_1.LogError)('Error updating contact record with enriched data', undefined, contact.LatestResult);
                 return false;
             }
-            return await contact.Save() && await this.CreateUpdateContactEmploymentAndEducationHistory(params, contact.Get("ID"), person, md, currentUser);
+            // Update employment and education history if configured
+            if (params.ContactEducationHistoryEntity) {
+                return await this.createUpdateContactEmploymentAndEducationHistory(params, contact.Get("ID"), person, md, currentUser);
+            }
+            return true;
         }
-        catch (e) {
-            (0, core_1.LogError)(e);
+        catch (error) {
+            (0, core_1.LogError)('Error creating and enriching contact', undefined, error);
             return false;
         }
     }
-    async GetOrCreateContact(params, accountID, person, md, currentUser) {
+    /**
+     * Updates contact entity fields with person data from Apollo
+     * Maps Apollo person fields to the configured contact entity fields
+     *
+     * @param contact - Contact entity to update
+     * @param person - Person data from Apollo
+     * @param CEntity - Contact entity field name mappings
+     */
+    updateContactFields(contact, person, CEntity) {
+        contact.Set(CEntity.FirstNameField, person.first_name);
+        contact.Set(CEntity.LastNameField, person.last_name);
+        contact.Set(CEntity.TitleField, person.title);
+        if (person.email) {
+            contact.Set(CEntity.EmailField, person.email);
+        }
+        this.setFieldIfExists(contact, CEntity.FacebookField, person.facebook_url);
+        this.setFieldIfExists(contact, CEntity.LinkedInField, person.linkedin_url);
+        this.setFieldIfExists(contact, CEntity.TwitterField, person.twitter_url);
+        this.setFieldIfExists(contact, CEntity.ProfilePictureURLField, person.photo_url);
+        contact.Set(CEntity.EnrichedAtField, new Date());
+    }
+    /**
+     * Gets an existing contact or creates a new one with conflict detection
+     * Prevents duplicate contacts across different accounts
+     * Supports matching by email or name combination
+     *
+     * @param params - Processing parameters with contact entity configuration
+     * @param accountID - ID of the account to associate contact with
+     * @param person - Person data from Apollo
+     * @param md - Metadata instance for entity operations
+     * @param currentUser - User context for data access
+     * @returns Promise<BaseEntity | null> - Contact entity or null if conflict/error
+     */
+    async getOrCreateContact(params, accountID, person, md, currentUser) {
         const CEntity = params.ContactEntity;
         if (!CEntity) {
             return null;
         }
-        const rv = new core_1.RunView();
-        const runViewResult = await rv.RunView({
-            EntityName: CEntity.EntityName,
-            ExtraFilter: `${CEntity.EmailFieldName}  = '${this.EscapeSingleQuotes(person.email)}' AND ${CEntity.AccountIDFieldName} <> ${accountID}`
-        }, currentUser);
-        if (!runViewResult.Success) {
-            (0, core_1.LogError)('Error querying for existing Contacts', undefined, runViewResult.ErrorMessage);
-            return null;
-        }
-        if (runViewResult.Results.length > 0) {
-            const results = runViewResult.Results;
-            (0, core_1.LogError)(`*** SKIPPING new contact record for ${person.first_name} ${person.last_name} because they are already associated with AccountID: ${results[0].AccountID} - ContactID: ${results[0].ID}`);
-            return null;
-        }
-        // ok, now that we know this person is not associated with another account, check to see if there is an existing record in the vwContacts view FOR this account, could do this more efficiently with a single SQL
-        // query, but this is easier to read and understand
-        const contactsViewResult = await rv.RunView({
-            EntityName: CEntity.EntityName,
-            ExtraFilter: `(${CEntity.EmailFieldName} = '${this.EscapeSingleQuotes(person.email)}' OR (${CEntity.FirstNameFieldName} = '${this.EscapeSingleQuotes(person.first_name)}' AND ${CEntity.LastNameFieldName} = '${this.EscapeSingleQuotes(person.last_name)}')) AND
-                        ${CEntity.AccountIDFieldName} = ${accountID}`
-        }, currentUser);
-        if (!contactsViewResult.Success) {
-            (0, core_1.LogError)('Error querying for existing Contacts', undefined, contactsViewResult.ErrorMessage);
+        try {
+            const rv = new core_1.RunView();
+            // Check if contact exists with different account
+            const conflictResult = await rv.RunView({
+                EntityName: CEntity.EntityName,
+                ExtraFilter: `${CEntity.EmailField} = '${this.EscapeSingleQuotes(person.email)}' AND ${CEntity.AccountIDField} <> ${accountID}`
+            }, currentUser);
+            if (!conflictResult.Success) {
+                (0, core_1.LogError)('Error querying for existing Contacts', undefined, conflictResult.ErrorMessage);
+                return null;
+            }
+            if (conflictResult.Results.length > 0) {
+                const existing = conflictResult.Results[0];
+                (0, core_1.LogError)(`*** SKIPPING new contact record for ${person.first_name} ${person.last_name} because they are already associated with AccountID: ${existing.AccountID} - ContactID: ${existing.ID}`);
+                return null;
+            }
+            // Check if contact exists for this account
+            const existingResult = await rv.RunView({
+                EntityName: CEntity.EntityName,
+                ExtraFilter: `(${CEntity.EmailField} = '${this.EscapeSingleQuotes(person.email)}' OR (${CEntity.FirstNameField} = '${this.EscapeSingleQuotes(person.first_name)}' AND ${CEntity.LastNameField} = '${this.EscapeSingleQuotes(person.last_name)}')) AND ${CEntity.AccountIDField} = ${accountID}`
+            }, currentUser);
+            if (!existingResult.Success) {
+                (0, core_1.LogError)('Error querying for existing Contacts', undefined, existingResult.ErrorMessage);
+                return null;
+            }
+            let contactEntity = null;
+            if (existingResult.Results.length > 0) {
+                // Update existing contact
+                contactEntity = await md.GetEntityObject(CEntity.EntityName, existingResult.Results[0].ID, currentUser);
+                contactEntity.Set(CEntity.EmailField, person.email);
+            }
+            else {
+                // Create new contact
+                (0, core_1.LogStatus)(`   > Creating new contact record for ${person.first_name} ${person.last_name}`);
+                contactEntity = await md.GetEntityObject(CEntity.EntityName, currentUser);
+                contactEntity.NewRecord();
+                contactEntity.Set(CEntity.EmailField, person.email);
+                contactEntity.Set(CEntity.AccountIDField, accountID);
+                contactEntity.Set(CEntity.ActivityCountField, 0);
+                contactEntity.Set(CEntity.EmailSourceField, Config.EmailSourceName);
+            }
+            return contactEntity;
+        }
+        catch (error) {
+            (0, core_1.LogError)('Error getting or creating contact', undefined, error);
             return null;
         }
-        const contactEntity = await md.GetEntityObject(CEntity.EntityName, currentUser);
-        if (contactsViewResult.Results.length > 0) {
-            contactEntity.SetMany(contactsViewResult.Results[0]);
-            contactEntity.Set(CEntity.EmailFieldName, person.email);
-        }
-        else {
-            (0, core_1.LogStatus)(`   > Creating new contact record for ${person.first_name} ${person.last_name}`);
-            contactEntity.NewRecord();
-            contactEntity.Set(CEntity.EmailFieldName, person.email);
-            contactEntity.Set(CEntity.AccountIDFieldName, accountID);
-            contactEntity.Set(CEntity.ActivityCountFieldName, 0);
-            contactEntity.Set(CEntity.EmailSourceFieldName, Config.EmailSourceName);
-        }
-        return contactEntity;
     }
-    async CreateUpdateContactEmploymentAndEducationHistory(params, contactID, person, md, currentUser) {
+    /**
+     * Creates or updates employment and education history records for a contact
+     * Processes Apollo employment history data to create education records
+     *
+     * @param params - Processing parameters with education entity configuration
+     * @param contactID - ID of the contact to create history for
+     * @param person - Person data containing employment history
+     * @param md - Metadata instance for entity operations
+     * @param currentUser - User context for data access
+     * @returns Promise<boolean> indicating success/failure
+     */
+    async createUpdateContactEmploymentAndEducationHistory(params, contactID, person, md, currentUser) {
         const CEntity = params.ContactEducationHistoryEntity;
-        if (!CEntity) {
-            return false;
+        if (!CEntity || !person.employment_history) {
+            return true;
         }
-        let bSuccess = true;
-        const rv = new core_1.RunView();
-        for (const history of person.employment_history) {
-            if (history.degree && history.degree.length > 0) {
-                const EHRunViewResult = await rv.RunView({
-                    EntityName: CEntity.EntityName,
-                    ExtraFilter: `${CEntity.ContactIDFieldName} = ${contactID} AND ${CEntity.InstitutionFieldName} = '${this.EscapeSingleQuotes(history.organization_name)}' AND ${CEntity.DegreeFieldName} = '${this.EscapeSingleQuotes(history.degree)}'`
-                }, currentUser);
-                if (!EHRunViewResult.Success) {
-                    (0, core_1.LogError)('Error querying for existing Employment History', undefined, EHRunViewResult.ErrorMessage);
-                    bSuccess = false;
-                }
-                const historyEntity = await md.GetEntityObject(CEntity.EntityName, currentUser);
-                if (EHRunViewResult.Results.length > 0) {
-                    historyEntity.SetMany(EHRunViewResult.Results[0]);
-                }
-                else {
-                    historyEntity.NewRecord();
-                    historyEntity.Set(CEntity.ContactIDFieldName, contactID);
-                }
-                historyEntity.Set(CEntity.InstitutionFieldName, history.organization_name);
-                historyEntity.Set(CEntity.DegreeFieldName, history.degree);
-                historyEntity.Set(CEntity.GradeLevelFieldName, !isNaN(history.grade_level) ? parseInt(history.grade_level) : 0);
-                if (this.IsValidDate(history.start_date)) {
-                    historyEntity.Set(CEntity.StartDateFieldName, new Date(history.start_date));
-                }
-                if (this.IsValidDate(history.end_date)) {
-                    historyEntity.Set(CEntity.EndDateFieldName, new Date(history.end_date));
-                }
-                historyEntity.Set(CEntity.IsCurrentFieldName, history.current);
-                const saveResult = await historyEntity.Save();
-                if (!saveResult) {
-                    (0, core_1.LogError)('Error saving Employment History record', undefined, historyEntity.LatestResult);
-                    bSuccess = false;
+        try {
+            let bSuccess = true;
+            const rv = new core_1.RunView();
+            for (const history of person.employment_history) {
+                if (history.degree && history.degree.length > 0) {
+                    const EHRunViewResult = await rv.RunView({
+                        EntityName: CEntity.EntityName,
+                        ExtraFilter: `${CEntity.ContactIDField} = ${contactID} AND ${CEntity.InstitutionField} = '${this.EscapeSingleQuotes(history.organization_name)}' AND ${CEntity.DegreeField} = '${this.EscapeSingleQuotes(history.degree)}'`
+                    }, currentUser);
+                    if (!EHRunViewResult.Success) {
+                        (0, core_1.LogError)('Error querying for existing Employment History', undefined, EHRunViewResult.ErrorMessage);
+                        bSuccess = false;
+                        continue;
+                    }
+                    let historyEntity = null;
+                    if (EHRunViewResult.Results.length > 0) {
+                        historyEntity = await md.GetEntityObject(CEntity.EntityName, core_1.CompositeKey.FromID(EHRunViewResult.Results[0].ID), currentUser);
+                    }
+                    else {
+                        historyEntity = await md.GetEntityObject(CEntity.EntityName, currentUser);
+                        historyEntity.NewRecord();
+                        historyEntity.Set(CEntity.ContactIDField, contactID);
+                    }
+                    // Set history data
+                    historyEntity.Set(CEntity.InstitutionField, history.organization_name);
+                    historyEntity.Set(CEntity.DegreeField, history.degree);
+                    historyEntity.Set(CEntity.GradeLevelField, !isNaN(history.grade_level) ? parseInt(history.grade_level) : 0);
+                    if (this.IsValidDate(history.start_date)) {
+                        historyEntity.Set(CEntity.StartDateField, new Date(history.start_date));
+                    }
+                    if (this.IsValidDate(history.end_date)) {
+                        historyEntity.Set(CEntity.EndDateField, new Date(history.end_date));
+                    }
+                    historyEntity.Set(CEntity.IsCurrentField, history.current);
+                    const saveResult = await historyEntity.Save();
+                    if (!saveResult) {
+                        (0, core_1.LogError)('Error saving Employment History record', undefined, historyEntity.LatestResult);
+                        bSuccess = false;
+                    }
                 }
             }
+            return bSuccess;
+        }
+        catch (error) {
+            (0, core_1.LogError)('Error creating/updating contact employment and education history', undefined, error);
+            return false;
         }
-        return bSuccess;
     }
+    /**
+     * Validates if a date string represents a valid date
+     * Used for employment/education history date validation
+     *
+     * @param dateString - Date string to validate
+     * @returns boolean - true if valid date
+     */
     IsValidDate(dateString) {
         if (dateString && dateString.length > 0) {
             const date = new Date(dateString);
             return date instanceof Date && !isNaN(date.getTime());
         }
-        else {
-            return false;
-        }
+        return false;
     }
+    /**
+     * Checks if a job title should be excluded from contact creation
+     * Filters out non-business contacts like students and volunteers
+     *
+     * @param title - Job title to check
+     * @returns boolean - true if title should be excluded
+     */
     IsExcludedTitle(title) {
         if (!title) {
             return false;
         }
         return this.ExcludeTitles.includes(title.toLowerCase());
     }
+    /**
+     * Escapes single quotes in strings for SQL query safety
+     * Prevents SQL injection in dynamic filter construction
+     *
+     * @param str - String to escape
+     * @returns string - Escaped string with doubled single quotes
+     */
     EscapeSingleQuotes(str) {
         if (str) {
             return str.replace(/'/g, "''");
         }
         return '';
     }
+    /**
+     * Wraps Apollo.io API calls with retry logic for rate limiting
+     * Handles 429 (Too Many Requests) responses with exponential backoff
+     *
+     * @param method - HTTP method ('get' or 'post')
+     * @param endpoint - Apollo API endpoint path
+     * @param data - Request payload for POST requests
+     * @param config - Axios configuration object
+     * @param retryAttempts - Number of retry attempts remaining (default: 1)
+     * @returns Promise<AxiosResponse> - Apollo API response
+     * @throws Error if rate limit exceeded or other API errors
+     */
     async WrapApolloCall(method, endpoint, data, config, retryAttempts = 1) {
         try {
             const url = `${Config.ApolloAPIEndpoint}/${endpoint}`;
@@ -571,15 +979,27 @@ let ApolloAccountsEnrichmentAction = class ApolloAccountsEnrichmentAction extend
             }
         }
     }
+    /**
+     * Utility method for creating delays in async operations
+     * Used for rate limit backoff and API throttling
+     *
+     * @param ms - Number of milliseconds to wait
+     * @returns Promise that resolves after the specified delay
+     */
     async Timeout(ms) {
         return new Promise(resolve => setTimeout(resolve, ms));
     }
 };
-exports.ApolloAccountsEnrichmentAction = ApolloAccountsEnrichmentAction;
-exports.ApolloAccountsEnrichmentAction = ApolloAccountsEnrichmentAction = __decorate([
-    (0, global_1.RegisterClass)(actions_1.BaseAction, "Apollo Enrichment - Accounts")
-], ApolloAccountsEnrichmentAction);
+exports.ApolloEnrichmentAccountsAction = ApolloEnrichmentAccountsAction;
+exports.ApolloEnrichmentAccountsAction = ApolloEnrichmentAccountsAction = __decorate([
+    (0, global_1.RegisterClass)(actions_1.BaseAction, "ApolloEnrichmentAccountsAction")
+], ApolloEnrichmentAccountsAction);
+/**
+ * Loader function to ensure the ApolloEnrichmentAccountsAction class is included in the bundle
+ * Prevents tree shaking from removing this action class
+ */
 function LoadApolloAccountsEnrichmentAction() {
+    // Stub function to prevent tree shaking
 }
 exports.LoadApolloAccountsEnrichmentAction = LoadApolloAccountsEnrichmentAction;
 //# sourceMappingURL=accounts.js.map