@worknice/js-sdk 0.0.8-rc.1 → 0.0.8-rc.2

package/dist/helpers/handleTriggerIntegrationSyncWebhook.js

@@ -0,0 +1,750 @@
+import isInstantAfter from "@worknice/utils/temporal/isInstantAfter";
+import isValidInstant from "@worknice/utils/temporal/isValidInstant";
+import { Temporal } from "temporal-polyfill";
+import { ConnectionStatus } from "../api/_types.js";
+import comparePersonDataTransferLines from "../employee-records/comparePersonDataTransferLines.js";
+import mergePersonDataTransferLines from "../employee-records/mergePersonDataTransferLines.js";
+import validatePersonDataTransferLine from "../employee-records/validatePersonDataTransferLine.js";
+import validatePersonDataTransferLineBankAccounts from "../employee-records/validatePersonDataTransferLineBankAccounts.js";
+import validatePersonDataTransferLineDateOfBirth from "../employee-records/validatePersonDataTransferLineDateOfBirth.js";
+import validatePersonDataTransferLineFullName from "../employee-records/validatePersonDataTransferLineFullName.js";
+import validatePersonDataTransferLineGender from "../employee-records/validatePersonDataTransferLineGender.js";
+import validatePersonDataTransferLinePersonalEmail from "../employee-records/validatePersonDataTransferLinePersonalEmail.js";
+import validatePersonDataTransferLinePersonalPhone from "../employee-records/validatePersonDataTransferLinePersonalPhone.js";
+import validatePersonDataTransferLineProfile from "../employee-records/validatePersonDataTransferLineProfile.js";
+import validatePersonDataTransferLineResidentialAddress from "../employee-records/validatePersonDataTransferLineResidentialAddress.js";
+import handleRequestWithWorknice from "./handleRequestWithWorknice.js";
+import validatePersonDataTransferLineTaxDetails from "../employee-records/validatePersonDataTransferLineTaxDetails.js";
+const handleTriggerIntegrationSyncWebhook = async (request, {
+  createRemotePerson,
+  getApiToken,
+  getConfig,
+  getEnv,
+  getRemotePeople,
+  updateRemotePerson
+}, options) => handleRequestWithWorknice(
+  request,
+  {
+    getApiToken,
+    handleRequest: async (context) => {
+      const { logger, payload, worknice } = context;
+      let cachedDataImport;
+      const getDataImport = async () => {
+        if (!cachedDataImport) {
+          cachedDataImport = await worknice.createDataImport({
+            integrationId: payload.integrationId
+          });
+        }
+        return cachedDataImport;
+      };
+      try {
+        logger.connect(worknice, payload.integrationId);
+        logger.indent("Retrieving Worknice data\u2026");
+        const integration = await worknice.getIntegration({
+          integrationId: payload.integrationId
+        });
+        if (integration.archived) {
+          logger.info("Integration is archived. Skipping sync.");
+          return;
+        }
+        if (integration.status !== "SYNCING") {
+          logger.info("Integration does not have a syncing status. Skipping sync.");
+          return;
+        }
+        logger.info("Retrieved integration from Worknice.");
+        const personConnections = await worknice.getPersonConnections({
+          integrationId: payload.integrationId
+        });
+        logger.info(`Retrieved ${personConnections.length} person connection(s) from Worknice.`);
+        const people = await worknice.getPeople({ orgId: integration.org.id });
+        logger.info(`Retrieved ${people.length} person(s) from Worknice.`);
+        logger.dedent("Completed retrieving Worknice data.");
+        const contextWithIntegration = {
+          ...context,
+          integration
+        };
+        logger.indent("Loading configuration details\u2026");
+        const config = await getConfig(contextWithIntegration);
+        logger.info(
+          config.automaticMatching ? "Automatic matching enabled." : "Automatic matching disabled."
+        );
+        logger.info(`Using a "${config.mode}" sync mode.`);
+        logger.dedent("Finished loading configuration details.");
+        logger.indent(`Retrieving ${config.appName} data\u2026`);
+        let remotePeople;
+        try {
+          remotePeople = await getRemotePeople(contextWithIntegration);
+        } catch (error) {
+          logger.info(`An error occurred while retrieving data from ${config.appName}.`);
+          throw error;
+        }
+        logger.info(`Retrieved ${remotePeople.length} people from ${config.appName}.`);
+        logger.dedent(`Completed retrieving ${config.appName} data.`);
+        logger.indent("Updating person connections\u2026");
+        for (const remotePerson of remotePeople) {
+          const remotePersonName = personToName(remotePerson);
+          try {
+            const remotePersonConnection = personConnections.find(
+              (connection) => connection.remote?.id === remotePerson.metadata.sourceId
+            );
+            if (remotePerson.metadata.deleted) {
+              if (remotePersonConnection) {
+                await worknice.deletePersonConnection({
+                  personConnectionId: remotePersonConnection.id
+                });
+                logger.info(
+                  `Deleted connection for ${config.appName} person "${remotePersonName}" because they have been terminated.`
+                );
+              }
+            } else {
+              if (remotePersonConnection && (remotePersonConnection.status === ConnectionStatus.Connected || remotePersonConnection.status === ConnectionStatus.Merged)) {
+                if (remotePersonConnection.remote?.name !== remotePersonName) {
+                  const connection = await worknice.updatePersonConnection({
+                    personConnectionId: remotePersonConnection.id,
+                    personId: remotePersonConnection.person.id,
+                    remote: {
+                      id: remotePerson.metadata.sourceId,
+                      name: remotePersonName
+                    },
+                    status: remotePersonConnection.status
+                  });
+                  personConnections.splice(
+                    personConnections.indexOf(remotePersonConnection),
+                    1,
+                    connection
+                  );
+                  logger.info(
+                    `Updated person connection remote name from "${remotePersonConnection.remote?.name}" to "${remotePersonName}".`
+                  );
+                }
+              } else {
+                if (remotePersonConnection && remotePersonConnection.remote?.name !== remotePersonName) {
+                  const connection = await worknice.updatePersonConnection({
+                    personConnectionId: remotePersonConnection.id,
+                    remote: {
+                      id: remotePerson.metadata.sourceId,
+                      name: remotePersonName
+                    },
+                    status: remotePersonConnection.status
+                  });
+                  personConnections.splice(
+                    personConnections.indexOf(remotePersonConnection),
+                    1,
+                    connection
+                  );
+                  logger.info(
+                    `Updated person connection remote name from "${remotePersonConnection.remote?.name}" to "${remotePersonName}".`
+                  );
+                }
+                const matchingWorknicePerson = people.find(
+                  (person) => person.id === remotePerson.metadata.targetId || person.employeeCode !== null && person.employeeCode === remotePerson.metadata.employeeCode || person.personalEmail !== null && person.personalEmail === remotePerson.personalEmail?.personalEmail || person.profileEmail !== null && person.profileEmail === remotePerson.profile?.profileEmail
+                ) ?? null;
+                if (config.automaticMatching === true && matchingWorknicePerson) {
+                  const personConnection = personConnections.find(
+                    (connection) => connection.person?.id === matchingWorknicePerson.id
+                  );
+                  if (personConnection?.status === ConnectionStatus.Connected || personConnection?.status === ConnectionStatus.Merged) {
+                    logger.info(
+                      `Unable to automatically match Worknice person "${matchingWorknicePerson.displayName}" to ${config.appName} person "${remotePersonName}" because the Worknice person has already been matched to a different ${config.appName} person.`
+                    );
+                  } else {
+                    if (personConnection) {
+                      if (remotePersonConnection) {
+                        await worknice.deletePersonConnection({
+                          personConnectionId: personConnection.id
+                        });
+                        personConnections.splice(personConnections.indexOf(personConnection), 1);
+                        const updatedConnection = await worknice.updatePersonConnection({
+                          personConnectionId: remotePersonConnection.id,
+                          personId: matchingWorknicePerson.id,
+                          remote: {
+                            id: remotePerson.metadata.sourceId,
+                            name: remotePersonName
+                          },
+                          status: ConnectionStatus.Connected
+                        });
+                        personConnections.splice(
+                          personConnections.indexOf(remotePersonConnection),
+                          1,
+                          updatedConnection
+                        );
+                        logger.info(
+                          `Automatically matched and combined person connections for Worknice person "${matchingWorknicePerson.displayName}" and ${config.appName} person "${remotePersonName}".`
+                        );
+                      } else {
+                        const updatedConnection = await worknice.updatePersonConnection({
+                          personConnectionId: personConnection.id,
+                          personId: personConnection.person.id,
+                          remote: {
+                            id: remotePerson.metadata.sourceId,
+                            name: remotePersonName
+                          },
+                          status: ConnectionStatus.Connected
+                        });
+                        personConnections.splice(
+                          personConnections.indexOf(personConnection),
+                          1,
+                          updatedConnection
+                        );
+                        logger.info(
+                          `Automatically matched existing person connection for Worknice person "${matchingWorknicePerson.displayName}" to ${config.appName} person "${remotePersonName}".`
+                        );
+                      }
+                    } else {
+                      if (remotePersonConnection) {
+                        const updatedConnection = await worknice.updatePersonConnection({
+                          personConnectionId: remotePersonConnection.id,
+                          personId: matchingWorknicePerson.id,
+                          remote: {
+                            ...remotePersonConnection.remote,
+                            name: remotePersonName
+                          },
+                          status: ConnectionStatus.Connected
+                        });
+                        personConnections.splice(
+                          personConnections.indexOf(remotePersonConnection),
+                          1,
+                          updatedConnection
+                        );
+                        logger.info(
+                          `Automatically matched existing person connection for ${config.appName} person "${remotePersonName}" to Worknice person "${matchingWorknicePerson.displayName}".`
+                        );
+                      } else {
+                        const newPersonConnection = await worknice.createPersonConnection({
+                          integrationId: payload.integrationId,
+                          personId: matchingWorknicePerson.id,
+                          remote: {
+                            id: remotePerson.metadata.sourceId,
+                            name: remotePersonName
+                          },
+                          status: ConnectionStatus.Connected
+                        });
+                        personConnections.push(newPersonConnection);
+                        logger.info(
+                          `Created new person connection for ${config.appName} person "${remotePersonName}" and automatically matched to Worknice person "${matchingWorknicePerson.displayName}".`
+                        );
+                      }
+                    }
+                  }
+                } else if (remotePersonConnection === void 0) {
+                  const newPersonConnection = await worknice.createPersonConnection({
+                    integrationId: payload.integrationId,
+                    remote: {
+                      id: remotePerson.metadata.sourceId,
+                      name: remotePersonName
+                    },
+                    status: ConnectionStatus.RemoteOnly
+                  });
+                  personConnections.push(newPersonConnection);
+                  logger.info(
+                    `New person connection created for ${config.appName} person "${remotePersonName}".`
+                  );
+                }
+              }
+            }
+          } catch (error) {
+            logger.indent(
+              `Unable to update person connection for ${config.appName} person "${remotePersonName}" because of the following error:`
+            );
+            logger.error(error);
+            logger.dedent();
+          }
+        }
+        logger.dedent("Finished updating person connections.");
+        if (config.mode === "one-way" || config.mode === "two-way") {
+          logger.indent("Updating people with connections marked as merged\u2026");
+          const mergedConnections = personConnections.filter(
+            (personConnection) => personConnection.status === ConnectionStatus.Merged
+          );
+          for (const personConnection of mergedConnections) {
+            const worknicePerson = people.find(
+              (person) => person.id === personConnection.person.id
+            );
+            const remotePerson = remotePeople.find(
+              (person) => person.metadata.sourceId === personConnection.remote.id
+            );
+            try {
+              if (!worknicePerson) {
+                throw Error(
+                  `Unable to find person in Worknice with the ID "${personConnection.person.id}".`
+                );
+              }
+              if (!remotePerson) {
+                throw Error(
+                  `Unable to find person in ${config.appName} with the ID "${personConnection.remote.id}".`
+                );
+              }
+            } catch (error) {
+              logger.indent(
+                `Unable to update Worknice person "${personConnection.person.displayName}" and/or ${config.appName} person "${personConnection.remote.name}" because of the following error:`
+              );
+              logger.error(error);
+              logger.dedent();
+              continue;
+            }
+            const remotePersonName = personToName(remotePerson);
+            const worknicePersonDataTransferLine = {
+              ...worknicePersonToPersonDataTransferLine(worknicePerson),
+              metadata: {
+                deleted: false,
+                employeeCode: worknicePerson.employeeCode ?? null,
+                sourceId: worknicePerson.id,
+                targetId: remotePerson.metadata.sourceId,
+                updatedAt: worknicePerson.updatedAt
+              }
+            };
+            const remotePersonDataTransferLine = remotePerson;
+            const comparison = comparePersonDataTransferLines(
+              worknicePersonDataTransferLine,
+              remotePersonDataTransferLine
+            );
+            if (comparison.hasDifferences && (config.syncFields?.bankAccounts && comparison.sections.bankAccounts.hasDifferences || config.syncFields?.dateOfBirth && comparison.sections.dateOfBirth.hasDifferences || config.syncFields?.fullName && comparison.sections.fullName.hasDifferences || config.syncFields?.gender && comparison.sections.gender.hasDifferences || config.syncFields?.personalEmail && comparison.sections.personalEmail.hasDifferences || config.syncFields?.personalPhone && comparison.sections.personalPhone.hasDifferences || config.syncFields?.residentialAddress && comparison.sections.residentialAddress.hasDifferences || config.syncFields?.taxDetails && comparison.sections.taxDetails.hasDifferences)) {
+              const worknicePersonUpdatedAt = Temporal.Instant.from(worknicePerson.updatedAt);
+              if (!isValidInstant(remotePerson.metadata.updatedAt)) {
+                throw Error(
+                  `Invalid updatedAt value for ${config.appName} person "${remotePersonName}". Must be in ISO 8601 format, including a date, a time, and a time zone offset.`,
+                  {
+                    cause: Error(`Unable to parse: ${remotePerson.metadata.updatedAt}`)
+                  }
+                );
+              }
+              const remotePersonUpdatedAt = Temporal.Instant.from(
+                remotePerson.metadata.updatedAt
+              );
+              if (isInstantAfter(worknicePersonUpdatedAt, remotePersonUpdatedAt)) {
+                if (config.mode === "two-way") {
+                  if (!updateRemotePerson) {
+                    throw Error(
+                      "No updateRemotePerson function supplied to handleTriggerIntegrationSyncWebhook."
+                    );
+                  }
+                  try {
+                    await updateRemotePerson(
+                      worknicePersonDataTransferLine,
+                      contextWithIntegration
+                    );
+                    logger.info(`Updated ${config.appName} person "${remotePersonName}".`);
+                  } catch (error) {
+                    logger.indent(
+                      `Unable to update ${config.appName} person "${remotePersonName}" because of the following error:`
+                    );
+                    logger.error(error);
+                    logger.dedent();
+                  }
+                }
+              } else {
+                try {
+                  const bankAccounts = validatePersonDataTransferLineBankAccounts(
+                    remotePersonDataTransferLine.bankAccounts
+                  );
+                  const dateOfBirth = validatePersonDataTransferLineDateOfBirth(
+                    remotePersonDataTransferLine.dateOfBirth
+                  );
+                  const fullName = validatePersonDataTransferLineFullName(
+                    remotePersonDataTransferLine.fullName
+                  );
+                  const gender = validatePersonDataTransferLineGender(
+                    remotePersonDataTransferLine.gender
+                  );
+                  const personalEmail = validatePersonDataTransferLinePersonalEmail(
+                    remotePersonDataTransferLine.personalEmail
+                  );
+                  const personalPhone = validatePersonDataTransferLinePersonalPhone(
+                    remotePersonDataTransferLine.personalPhone
+                  );
+                  const residentialAddress = validatePersonDataTransferLineResidentialAddress(
+                    remotePersonDataTransferLine.residentialAddress
+                  );
+                  const taxDetails = validatePersonDataTransferLineTaxDetails(
+                    remotePersonDataTransferLine.taxDetails
+                  );
+                  const dataImport = await getDataImport();
+                  await worknice.createPersonDataImportLine({
+                    bankAccounts,
+                    config: {
+                      bankAccounts: config.syncFields?.bankAccounts ?? false,
+                      dateOfBirth: config.syncFields?.dateOfBirth ?? false,
+                      emergencyContacts: config.syncFields?.emergencyContacts ?? false,
+                      fullName: config.syncFields?.fullName ?? false,
+                      gender: config.syncFields?.gender ?? false,
+                      personalEmail: config.syncFields?.personalEmail ?? false,
+                      personalPhone: config.syncFields?.personalPhone ?? false,
+                      postalAddress: config.syncFields?.postalAddress ?? false,
+                      profile: config.syncFields?.profile ?? false,
+                      remuneration: config.syncFields?.remuneration ?? false,
+                      residentialAddress: config.syncFields?.residentialAddress ?? false,
+                      superFunds: config.syncFields?.superFunds ?? false,
+                      taxDetails: config.syncFields?.taxDetails ?? false,
+                      tenure: config.syncFields?.tenure ?? false
+                    },
+                    dataImportId: dataImport.id,
+                    dateOfBirth,
+                    emergencyContacts: null,
+                    fullName,
+                    gender,
+                    personalEmail,
+                    personalPhone,
+                    personId: worknicePerson.id,
+                    postalAddress: null,
+                    residentialAddress,
+                    // TODO: Enable syncing super funds. See PROD-2216.
+                    superFunds: null,
+                    taxDetails,
+                    // TODO: Enable syncing tenure. See PROD-1371.
+                    tenure: null
+                  });
+                  logger.info(`Updated Worknice person "${worknicePerson.displayName}".`);
+                } catch (error) {
+                  logger.indent(
+                    `Unable to update Worknice person "${worknicePerson.displayName}" because of the following error:`
+                  );
+                  logger.error(error);
+                  logger.dedent();
+                }
+              }
+            }
+          }
+          logger.dedent("Finished updating people with connections marked as merged.");
+        }
+        logger.indent("Merging unmerged connections\u2026");
+        const connectedConnections = personConnections.filter(
+          (personConnection) => personConnection.status === ConnectionStatus.Connected
+        );
+        for (const personConnection of connectedConnections) {
+          let worknicePerson = people.find((person) => person.id === personConnection.person.id);
+          const remotePerson = remotePeople.find(
+            (person) => person.metadata.sourceId === personConnection.remote.id
+          );
+          try {
+            if (!worknicePerson) {
+              throw Error(
+                `Unable to find person in Worknice with the ID "${personConnection.person.id}".`
+              );
+            }
+            if (!remotePerson) {
+              throw Error(
+                `Unable to find person in ${config.appName} with the ID "${personConnection.remote.id}".`
+              );
+            }
+          } catch (error) {
+            logger.indent(
+              `Unable to merge Worknice person "${personConnection.person.displayName}" with ${config.appName} person "${personConnection.remote.name}" because of the following error:`
+            );
+            logger.error(error);
+            logger.dedent();
+            continue;
+          }
+          const remotePersonName = personToName(remotePerson);
+          logger.indent(
+            `Merging Worknice person "${worknicePerson.displayName}" with ${config.appName} person "${remotePersonName}"\u2026`
+          );
+          try {
+            if (config.mode === "one-way" || config.mode === "two-way") {
+              const worknicePersonUpdatedAt = Temporal.Instant.from(worknicePerson.updatedAt);
+              if (!isValidInstant(remotePerson.metadata.updatedAt)) {
+                throw Error(
+                  `Invalid updatedAt value for ${config.appName} person "${remotePersonName}". Must be in ISO 8601 format, including a date, a time, and a time zone offset.`,
+                  {
+                    cause: Error(`Unable to parse: ${remotePerson.metadata.updatedAt}`)
+                  }
+                );
+              }
+              const remotePersonUpdatedAt = Temporal.Instant.from(
+                remotePerson.metadata.updatedAt
+              );
+              const [primaryDataTransferLine, secondaryDataTransferLine] = isInstantAfter(
+                worknicePersonUpdatedAt,
+                remotePersonUpdatedAt
+              ) ? [worknicePersonToPersonDataTransferLine(worknicePerson), remotePerson] : [remotePerson, worknicePersonToPersonDataTransferLine(worknicePerson)];
+              const mergedDataTransferLine = mergePersonDataTransferLines(
+                primaryDataTransferLine,
+                secondaryDataTransferLine
+              );
+              const bankAccounts = validatePersonDataTransferLineBankAccounts(
+                mergedDataTransferLine.bankAccounts
+              );
+              const dateOfBirth = validatePersonDataTransferLineDateOfBirth(
+                mergedDataTransferLine.dateOfBirth
+              );
+              const fullName = validatePersonDataTransferLineFullName(
+                mergedDataTransferLine.fullName
+              );
+              const gender = validatePersonDataTransferLineGender(mergedDataTransferLine.gender);
+              const personalEmail = validatePersonDataTransferLinePersonalEmail(
+                mergedDataTransferLine.personalEmail
+              );
+              const personalPhone = validatePersonDataTransferLinePersonalPhone(
+                mergedDataTransferLine.personalPhone
+              );
+              const profile = validatePersonDataTransferLineProfile(
+                mergedDataTransferLine.profile
+              );
+              const residentialAddress = validatePersonDataTransferLineResidentialAddress(
+                mergedDataTransferLine.residentialAddress
+              );
+              const taxDetails = validatePersonDataTransferLineTaxDetails(
+                mergedDataTransferLine.taxDetails
+              );
+              const dataImport = await getDataImport();
+              await worknice.createPersonDataImportLine({
+                bankAccounts,
+                config: {
+                  bankAccounts: config.syncFields?.bankAccounts ?? false,
+                  dateOfBirth: config.syncFields?.dateOfBirth ?? false,
+                  emergencyContacts: config.syncFields?.emergencyContacts ?? false,
+                  fullName: config.syncFields?.fullName ?? false,
+                  gender: config.syncFields?.gender ?? false,
+                  personalEmail: config.syncFields?.personalEmail ?? false,
+                  personalPhone: config.syncFields?.personalPhone ?? false,
+                  postalAddress: config.syncFields?.postalAddress ?? false,
+                  profile: config.syncFields?.profile ?? false,
+                  remuneration: config.syncFields?.remuneration ?? false,
+                  residentialAddress: config.syncFields?.residentialAddress ?? false,
+                  superFunds: config.syncFields?.superFunds ?? false,
+                  taxDetails: config.syncFields?.taxDetails ?? false,
+                  tenure: config.syncFields?.tenure ?? false
+                },
+                dataImportId: dataImport.id,
+                dateOfBirth,
+                emergencyContacts: null,
+                fullName,
+                gender,
+                personalEmail,
+                personalPhone,
+                personId: worknicePerson.id,
+                postalAddress: null,
+                residentialAddress,
+                // TODO: Enable syncing super funds. See PROD-2216.
+                superFunds: null,
+                taxDetails,
+                // TODO: Enable syncing tenure. See PROD-1371.
+                tenure: null
+              });
+              worknicePerson = await worknice.updatePerson({
+                displayName: profile?.displayName,
+                employeeCode: remotePerson.metadata.employeeCode,
+                personId: worknicePerson.id,
+                profileEmail: profile?.profileEmail,
+                profilePhone: profile?.profilePhone
+              });
+              logger.info(`Updated Worknice person "${worknicePerson.displayName}".`);
+              if (config.mode === "two-way") {
+                if (!updateRemotePerson) {
+                  throw Error(
+                    "No updateRemotePerson function supplied to handleTriggerIntegrationSyncWebhook."
+                  );
+                }
+                await updateRemotePerson(
+                  {
+                    bankAccounts,
+                    dateOfBirth,
+                    emergencyContacts: null,
+                    fullName,
+                    gender,
+                    metadata: {
+                      deleted: false,
+                      employeeCode: worknicePerson.employeeCode ?? null,
+                      sourceId: worknicePerson.id,
+                      targetId: remotePerson.metadata.sourceId,
+                      updatedAt: worknicePerson.updatedAt
+                    },
+                    personalEmail,
+                    personalPhone,
+                    postalAddress: null,
+                    profile: {
+                      displayName: worknicePerson.displayName,
+                      profileEmail: worknicePerson.profileEmail ?? null,
+                      profilePhone: worknicePerson.profilePhone ?? null
+                    },
+                    residentialAddress,
+                    // TODO: Enable syncing super funds. See PROD-2216.
+                    superFunds: null,
+                    taxDetails,
+                    // TODO: Enable syncing tenure. See PROD-1371.
+                    tenure: null
+                  },
+                  contextWithIntegration
+                );
+                logger.info(`Updated ${config.appName} person "${remotePersonName}".`);
+              }
+            }
+            await worknice.updatePersonConnection({
+              personConnectionId: personConnection.id,
+              personId: personConnection.person.id,
+              remote: {
+                id: remotePerson.metadata.sourceId,
+                name: remotePersonName
+              },
+              status: ConnectionStatus.Merged
+            });
+            logger.dedent(`Finished merging.`);
+          } catch (error) {
+            logger.indent(
+              `Unable to merge ${config.appName} person "${remotePersonName}" and Worknice person "${worknicePerson.displayName}" because of the following error:`
+            );
+            logger.error(error);
+            logger.dedent();
+            logger.dedent();
+          }
+        }
+        logger.dedent("Finished merging unmerged connections.");
+        if (config.mode === "two-way") {
+          logger.indent(`Adding new people to ${config.appName}\u2026`);
+          const localOnlyConnections = personConnections.filter(
+            (personConnection) => personConnection.status === ConnectionStatus.LocalOnly
+          );
+          for (const personConnection of localOnlyConnections) {
+            const worknicePerson = people.find(
+              (person) => person.id === personConnection.person.id
+            );
+            if (!worknicePerson) {
+              throw Error(
+                `Unable to find person in Worknice with the ID "${personConnection.person.id}".`
+              );
+            }
+            try {
+              if (!createRemotePerson) {
+                throw Error(
+                  "No createRemotePerson function supplied to handleTriggerIntegrationSyncWebhook."
+                );
+              }
+              const { status, ...remote } = await createRemotePerson(
+                {
+                  ...worknicePersonToPersonDataTransferLine(worknicePerson),
+                  metadata: {
+                    deleted: false,
+                    employeeCode: worknicePerson.employeeCode ?? null,
+                    sourceId: worknicePerson.id,
+                    targetId: null,
+                    updatedAt: worknicePerson.updatedAt
+                  }
+                },
+                contextWithIntegration
+              );
+              if (personConnections.some((connection) => connection.remote?.id === remote.id)) {
+                throw Error(
+                  `A connection already exists for the ${config.appName} person "${remote.name}".`
+                );
+              }
+              await worknice.updatePersonConnection({
+                personConnectionId: personConnection.id,
+                personId: personConnection.person.id,
+                remote,
+                status: status ?? ConnectionStatus.Merged
+              });
+              logger.info(`Added new person "${remote.name}" to ${config.appName}.`);
+            } catch (error) {
+              logger.indent(
+                `Unable to add Worknice person "${worknicePerson.displayName}" to ${config.appName} because of the following error:`
+              );
+              logger.error(error);
+              logger.dedent();
+            }
+          }
+          logger.dedent(`Finished adding new people to ${config.appName}.`);
+        }
+        await worknice.completeSync({ integrationId: payload.integrationId });
+        logger.info("Sync completed.");
+      } catch (error) {
+        await worknice.completeSync({ integrationId: payload.integrationId });
+        throw error;
+      }
+    },
+    parseRequest: async (context) => {
+      const payload = await context.request.json();
+      return {
+        env: await getEnv({ ...context, payload }),
+        payload
+      };
+    }
+  },
+  options
+);
+const personToName = (person) => {
+  if ((person.fullName?.givenName ?? "").trim() !== "" && (person.fullName?.familyName ?? "").trim() !== "") {
+    return `${person.fullName?.givenName} ${person.fullName?.familyName}`;
+  }
+  if ((person.profile?.displayName ?? "").trim() !== "") {
+    return `${person.profile?.displayName}`;
+  }
+  return `(unnamed person ${person.metadata.sourceId})`;
+};
+const worknicePersonToPersonDataTransferLine = (worknicePerson) => ({
+  ...validatePersonDataTransferLine({
+    bankAccounts: worknicePerson.bankAccount1AllocationMethod ? {
+      bankAccount1Allocation: worknicePerson.bankAccount1Allocation ?? null,
+      bankAccount1AllocationMethod: worknicePerson.bankAccount1AllocationMethod,
+      bankAccount1Bsb: worknicePerson.bankAccount1Bsb ?? null,
+      bankAccount1Name: worknicePerson.bankAccount1Name ?? null,
+      bankAccount1Number: worknicePerson.bankAccount1Number ?? null,
+      bankAccount2Allocation: worknicePerson.bankAccount2Allocation ?? null,
+      bankAccount2AllocationMethod: worknicePerson.bankAccount2AllocationMethod ?? null,
+      bankAccount2Bsb: worknicePerson.bankAccount2Bsb ?? null,
+      bankAccount2Name: worknicePerson.bankAccount2Name ?? null,
+      bankAccount2Number: worknicePerson.bankAccount2Number ?? null,
+      bankAccount3Allocation: worknicePerson.bankAccount3Allocation ?? null,
+      bankAccount3AllocationMethod: worknicePerson.bankAccount3AllocationMethod ?? null,
+      bankAccount3Bsb: worknicePerson.bankAccount3Bsb ?? null,
+      bankAccount3Name: worknicePerson.bankAccount3Name ?? null,
+      bankAccount3Number: worknicePerson.bankAccount3Number ?? null,
+      bankAccount4Allocation: worknicePerson.bankAccount4Allocation ?? null,
+      bankAccount4AllocationMethod: worknicePerson.bankAccount4AllocationMethod ?? null,
+      bankAccount4Bsb: worknicePerson.bankAccount4Bsb ?? null,
+      bankAccount4Name: worknicePerson.bankAccount4Name ?? null,
+      bankAccount4Number: worknicePerson.bankAccount4Number ?? null,
+      bankAccount5Allocation: worknicePerson.bankAccount5Allocation ?? null,
+      bankAccount5AllocationMethod: worknicePerson.bankAccount5AllocationMethod ?? null,
+      bankAccount5Bsb: worknicePerson.bankAccount5Bsb ?? null,
+      bankAccount5Name: worknicePerson.bankAccount5Name ?? null,
+      bankAccount5Number: worknicePerson.bankAccount5Number ?? null
+    } : null,
+    dateOfBirth: worknicePerson.dateOfBirth ? { dateOfBirth: worknicePerson.dateOfBirth } : null,
+    emergencyContacts: null,
+    fullName: worknicePerson.givenName ? {
+      familyName: worknicePerson.familyName ?? null,
+      givenName: worknicePerson.givenName,
+      otherGivenNames: worknicePerson.otherGivenNames ?? null
+    } : null,
+    gender: worknicePerson.gender ? {
+      gender: worknicePerson.gender
+    } : null,
+    personalEmail: worknicePerson.personalEmail ? {
+      personalEmail: worknicePerson.personalEmail
+    } : null,
+    personalPhone: worknicePerson.personalPhone ? {
+      personalPhone: worknicePerson.personalPhone
+    } : null,
+    postalAddress: null,
+    profile: null,
+    residentialAddress: worknicePerson.residentialAddressLine1 ? {
+      residentialAddressCity: worknicePerson.residentialAddressCity ?? null,
+      // FIXME: This should not default to "Australia". See PROD-1085.
+      residentialAddressCountry: worknicePerson.residentialAddressCountry ?? "Australia",
+      residentialAddressLine1: worknicePerson.residentialAddressLine1,
+      residentialAddressLine2: worknicePerson.residentialAddressLine2 ?? null,
+      residentialAddressPostcode: worknicePerson.residentialAddressPostcode ?? null,
+      residentialAddressState: worknicePerson.residentialAddressState ?? null
+    } : null,
+    // TODO: Enable syncing super funds. See PROD-2216.
+    superFunds: null,
+    taxDetails: worknicePerson.taxFileNumberExemption ? {
+      hasLoanOrStudentDebt: worknicePerson.hasLoanOrStudentDebt ?? null,
+      residencyStatus: worknicePerson.residencyStatus ?? null,
+      taxFileNumber: worknicePerson.taxFileNumber ?? null,
+      taxFileNumberExemption: worknicePerson.taxFileNumberExemption ?? null,
+      taxFreeThresholdClaimed: worknicePerson.taxFreeThresholdClaimed ?? null
+    } : null,
+    // TODO: Enable syncing tenure. See PROD-1371.
+    tenure: null
+  }),
+  profile: {
+    displayName: worknicePerson.displayName,
+    profileEmail: worknicePerson.profileEmail ?? null,
+    profilePhone: worknicePerson.profilePhone ?? null
+  }
+});
+var handleTriggerIntegrationSyncWebhook_default = handleTriggerIntegrationSyncWebhook;
+export {
+  handleTriggerIntegrationSyncWebhook_default as default
+};
+//# sourceMappingURL=handleTriggerIntegrationSyncWebhook.js.map