@worknice/js-sdk 0.0.2 → 0.0.3

package/dist/helpers/handleTriggerIntegrationSyncWebhook.js

@@ -0,0 +1,600 @@
+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 validatePersonDataTransferLineBankAccounts from "../employee-records/validatePersonDataTransferLineBankAccounts.js";
+import validatePersonDataTransferLinePersonalDetails from "../employee-records/validatePersonDataTransferLinePersonalDetails.js";
+import validatePersonDataTransferLineResidentialAddress from "../employee-records/validatePersonDataTransferLineResidentialAddress.js";
+import isAfter from "../utils/isAfter.js";
+import handleRequestWithWorknice from "./handleRequestWithWorknice.js";
+const handleTriggerIntegrationSyncWebhook = async (request, {
+  createRemotePerson,
+  getApiToken,
+  getConfig,
+  getEnv,
+  getRemotePeople,
+  updateRemotePerson
+}, options) => handleRequestWithWorknice(
+  request,
+  {
+    getApiToken,
+    getEnv,
+    handleRequest: async (context) => {
+      const { logger, payload, worknice } = context;
+      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`);
+        const remotePeople = await getRemotePeople(contextWithIntegration);
+        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 = `${remotePerson.personalDetails?.givenName} ${remotePerson.personalDetails?.familyName}`;
+          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 "${remotePerson.personalDetails?.givenName} ${remotePerson.personalDetails?.familyName}" in ${config.appName} 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.employeeCode !== null && person.employeeCode === remotePerson.metadata.employeeCode || person.personalEmail !== null && person.personalEmail === remotePerson.personalDetails?.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 person "${matchingWorknicePerson.displayName}" in Worknice to person "${remotePersonName}" in ${config.appName} 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 person "${matchingWorknicePerson.displayName}" in Worknice and person "${remotePersonName}" in ${config.appName}.`
+                        );
+                      } 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 person "${matchingWorknicePerson.displayName}" in Worknice to person "${remotePersonName}" in ${config.appName}.`
+                        );
+                      }
+                    } 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 person "${remotePersonName}" in ${config.appName} to person "${matchingWorknicePerson.displayName}" in Worknice.`
+                        );
+                      } 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 person "${remotePersonName}" in ${config.appName} and automatically matched to person "${matchingWorknicePerson.displayName}" in Worknice.`
+                        );
+                      }
+                    }
+                  }
+                } 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 person "${remotePersonName}" in ${config.appName}.`
+                  );
+                }
+              }
+            }
+          } catch (error) {
+            logger.info(
+              `Unable to update person connection for person "${remotePersonName}" in ${config.appName} because of the following error:
+
+${error instanceof Error ? error.message : error}
+`
+            );
+          }
+        }
+        logger.dedent("Finished updating person connections.");
+        if (config.mode === "one-way" || config.mode === "two-way") {
+          const dataImport = await worknice.createDataImport({
+            integrationId: payload.integrationId
+          });
+          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
+            );
+            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}".`
+              );
+            }
+            const remotePersonName = `${remotePerson.personalDetails?.givenName} ${remotePerson.personalDetails?.familyName}`;
+            const worknicePersonDataTransferLine = {
+              ...worknicePersonToPersonDataTransferLine(worknicePerson),
+              metadata: {
+                deleted: false,
+                employeeCode: worknicePerson.employeeCode ?? null,
+                sourceId: worknicePerson.id,
+                targetId: remotePerson.metadata.sourceId,
+                updatedAt: worknicePerson.updatedAt
+              },
+              profile: {
+                profileEmail: worknicePerson.profileEmail ?? null
+              }
+            };
+            const myobPersonDataTransferLine = remotePerson;
+            const comparison = comparePersonDataTransferLines(
+              worknicePersonDataTransferLine,
+              myobPersonDataTransferLine
+            );
+            if (comparison.hasDifferences && (comparison.sections.bankAccounts.hasDifferences || comparison.sections.personalDetails.hasDifferences || comparison.sections.residentialAddress.hasDifferences)) {
+              const worknicePersonUpdatedAt = Temporal.Instant.from(worknicePerson.updatedAt);
+              const myobEmployeeUpdatedAt = Temporal.PlainDateTime.from(
+                remotePerson.metadata.updatedAt
+              ).toZonedDateTime(Temporal.TimeZone.from("UTC")).toInstant();
+              if (isAfter(worknicePersonUpdatedAt, myobEmployeeUpdatedAt)) {
+                if (config.mode === "two-way") {
+                  if (!updateRemotePerson) {
+                    throw Error(
+                      "No updateRemotePerson function supplied to handleTriggerIntegrationSyncWebhook."
+                    );
+                  }
+                  try {
+                    await updateRemotePerson(
+                      worknicePersonDataTransferLine,
+                      contextWithIntegration
+                    );
+                    logger.info(`Updated person "${remotePersonName}" in ${config.appName}.`);
+                  } catch (error) {
+                    logger.info(
+                      `Unable to update person "${remotePersonName}" in ${config.appName} because of the following error:
+
+${error instanceof Error ? error.message : error}
+`
+                    );
+                  }
+                }
+              } else {
+                try {
+                  const personalDetails = validatePersonDataTransferLinePersonalDetails(
+                    myobPersonDataTransferLine.personalDetails
+                  );
+                  const bankAccounts = validatePersonDataTransferLineBankAccounts(
+                    myobPersonDataTransferLine.bankAccounts
+                  );
+                  const residentialAddress = validatePersonDataTransferLineResidentialAddress(
+                    myobPersonDataTransferLine.residentialAddress
+                  );
+                  await worknice.createPersonDataImportLine({
+                    bankAccounts,
+                    config: {
+                      bankAccounts: config.syncFields?.bankAccounts ?? false,
+                      emergencyContacts: config.syncFields?.emergencyContacts ?? false,
+                      personalDetails: config.syncFields?.personalDetails ?? false,
+                      postalAddress: config.syncFields?.personalDetails ?? 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,
+                    emergencyContacts: null,
+                    personalDetails,
+                    personId: worknicePerson.id,
+                    postalAddress: null,
+                    residentialAddress,
+                    // TODO: Enable syncing super funds. See PROD-2216.
+                    superFunds: null,
+                    // TODO: Enable syncing tax details. See PROD-2375.
+                    taxDetails: null,
+                    // TODO: Enable syncing tenure. See PROD-1371.
+                    tenure: null
+                  });
+                  logger.info(`Updated person "${worknicePerson.displayName}" in Worknice.`);
+                } catch (error) {
+                  logger.info(
+                    `Unable to update person "${worknicePerson.displayName}" in Worknice because of the following error:
+
+${error instanceof Error ? error.message : error}
+`
+                  );
+                }
+              }
+            }
+          }
+          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) {
+            const worknicePerson = people.find(
+              (person) => person.id === personConnection.person.id
+            );
+            const remotePerson = remotePeople.find(
+              (person) => person.metadata.sourceId === personConnection.remote.id
+            );
+            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}".`
+              );
+            }
+            const remotePersonName = `${remotePerson.personalDetails?.givenName} ${remotePerson.personalDetails?.familyName}`;
+            logger.indent(
+              `Merging Worknice person "${worknicePerson.displayName}" with ${config.appName} person "${remotePersonName}"\u2026`
+            );
+            try {
+              const worknicePersonUpdatedAt = Temporal.Instant.from(worknicePerson.updatedAt);
+              const myobEmployeeUpdatedAt = Temporal.PlainDateTime.from(
+                remotePerson.metadata.updatedAt
+              ).toZonedDateTime(Temporal.TimeZone.from("UTC")).toInstant();
+              const [primaryDataTransferLine, secondaryDataTransferLine] = isAfter(
+                worknicePersonUpdatedAt,
+                myobEmployeeUpdatedAt
+              ) ? [worknicePersonToPersonDataTransferLine(worknicePerson), remotePerson] : [remotePerson, worknicePersonToPersonDataTransferLine(worknicePerson)];
+              const mergedDataTransferLine = mergePersonDataTransferLines(
+                primaryDataTransferLine,
+                secondaryDataTransferLine
+              );
+              const personalDetails = validatePersonDataTransferLinePersonalDetails(
+                mergedDataTransferLine.personalDetails
+              );
+              const bankAccounts = validatePersonDataTransferLineBankAccounts(
+                mergedDataTransferLine.bankAccounts
+              );
+              const residentialAddress = validatePersonDataTransferLineResidentialAddress(
+                mergedDataTransferLine.residentialAddress
+              );
+              await worknice.createPersonDataImportLine({
+                bankAccounts,
+                config: {
+                  bankAccounts: config.syncFields?.bankAccounts ?? false,
+                  emergencyContacts: config.syncFields?.emergencyContacts ?? false,
+                  personalDetails: config.syncFields?.personalDetails ?? false,
+                  postalAddress: config.syncFields?.personalDetails ?? 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,
+                emergencyContacts: null,
+                personalDetails,
+                personId: worknicePerson.id,
+                postalAddress: null,
+                residentialAddress,
+                // TODO: Enable syncing super funds. See PROD-2216.
+                superFunds: null,
+                // TODO: Enable syncing tax details. See PROD-2375.
+                taxDetails: null,
+                // TODO: Enable syncing tenure. See PROD-1371.
+                tenure: null
+              });
+              logger.info(`Updated person "${worknicePerson.displayName}" in Worknice.`);
+              if (config.mode === "two-way") {
+                if (!updateRemotePerson) {
+                  throw Error(
+                    "No updateRemotePerson function supplied to handleTriggerIntegrationSyncWebhook."
+                  );
+                }
+                await updateRemotePerson(
+                  {
+                    ...mergedDataTransferLine,
+                    metadata: {
+                      deleted: false,
+                      employeeCode: worknicePerson.employeeCode ?? null,
+                      sourceId: worknicePerson.id,
+                      targetId: remotePerson.metadata.sourceId,
+                      updatedAt: worknicePerson.updatedAt
+                    },
+                    profile: {
+                      profileEmail: worknicePerson.profileEmail ?? null
+                    }
+                  },
+                  contextWithIntegration
+                );
+                logger.info(`Updated person "${remotePersonName}" in ${config.appName}.`);
+              }
+              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.info(
+                `Unable to merge ${config.appName} person "${remotePersonName}" and Worknice person "${worknicePerson.displayName}" because of the following error:
+
+${error instanceof Error ? error.message : error}
+`
+              );
+              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 remote = await createRemotePerson(
+                  {
+                    ...worknicePersonToPersonDataTransferLine(worknicePerson),
+                    metadata: {
+                      deleted: false,
+                      employeeCode: worknicePerson.employeeCode ?? null,
+                      sourceId: worknicePerson.id,
+                      targetId: null,
+                      updatedAt: worknicePerson.updatedAt
+                    },
+                    profile: {
+                      profileEmail: worknicePerson.profileEmail ?? null
+                    }
+                  },
+                  contextWithIntegration
+                );
+                await worknice.updatePersonConnection({
+                  personConnectionId: personConnection.id,
+                  personId: personConnection.person.id,
+                  remote,
+                  status: ConnectionStatus.Merged
+                });
+                logger.info(`Added new person "${remote.name}" to ${config.appName}.`);
+              } catch (error) {
+                logger.info(
+                  `Unable to add person "${worknicePerson.displayName}" in Worknice to ${config.appName} because of the following error:
+
+${error instanceof Error ? error.message : error}
+`
+                );
+              }
+            }
+            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;
+      }
+    },
+    parsePayload: async ({ request: request2 }) => request2.json()
+  },
+  options
+);
+const worknicePersonToPersonDataTransferLine = (worknicePerson) => ({
+  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,
+  emergencyContacts: null,
+  personalDetails: worknicePerson.givenName ? {
+    dateOfBirth: worknicePerson.dateOfBirth ?? null,
+    familyName: worknicePerson.familyName ?? null,
+    gender: worknicePerson.gender ?? null,
+    givenName: worknicePerson.givenName ?? null,
+    otherGivenNames: worknicePerson.otherGivenNames ?? null,
+    personalEmail: worknicePerson.personalEmail ?? null,
+    personalPhone: worknicePerson.personalPhone ?? null
+  } : null,
+  postalAddress: 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 ?? null,
+    residentialAddressLine2: worknicePerson.residentialAddressLine2 ?? null,
+    residentialAddressPostcode: worknicePerson.residentialAddressPostcode ?? null,
+    residentialAddressState: worknicePerson.residentialAddressState ?? null
+  } : null,
+  // TODO: Enable syncing super funds. See PROD-2216.
+  superFunds: null,
+  // TODO: Enable syncing tax details. See PROD-2375.
+  taxDetails: null,
+  // TODO: Enable syncing tenure. See PROD-1371.
+  tenure: null
+});
+var handleTriggerIntegrationSyncWebhook_default = handleTriggerIntegrationSyncWebhook;
+export {
+  handleTriggerIntegrationSyncWebhook_default as default
+};
+//# sourceMappingURL=handleTriggerIntegrationSyncWebhook.js.map