Build a Two-Way Sync

async function handleGiftCreated(event) {
  const gift = event.data;

  // If this gift came from one of our own submissions, we already know
  // about it. Update our existing record to capture the Virtuous Gift ID.
  if (gift.transactionSource === 'YourPlatform') {
    await db.partnerGifts.update(
      { transactionId: gift.transactionId },
      { virtuousGiftId: gift.id, status: 'confirmed' }
    );
    return;
  }

  // Otherwise, this gift was created by someone else — manual entry,
  // another integration, or the Virtuous UI. Capture it on our side.
  await ingestVirtuousOriginatedGift(gift);
}

async function maybeSubmitPartnerChange(partnerRecord) {
  // If the last modification was an inbound sync from Virtuous within the
  // last few minutes, this "change" is just a reflection of what Virtuous
  // told us. Suppress the outbound submission.
  if (partnerRecord.sync_state === 'virtuous_pending') {
    return;
  }

  const timeSinceLastInbound = Date.now() - new Date(partnerRecord.last_sync_at).getTime();
  if (timeSinceLastInbound < 60_000) {
    // Within 60 seconds of an inbound sync — likely echo of that sync
    return;
  }

  await queueOutboundSubmission(partnerRecord);
}

await db.partner_contacts.update(
  { id: partnerContact.id },
  {
    status: 'submitted',
    submitted_at: new Date(),
    sync_state: 'partner_pending',         // waiting for Virtuous to confirm
  }
);

await db.partner_contacts.update(
  { id: partnerContact.id },
  {
    virtuous_contact_id: event.data.id,
    virtuous_modified_at: event.data.modifiedDateTimeUtc,
    sync_state: 'in_sync',
    last_sync_at: new Date(),
  }
);

async function processVirtuousEvent(event) {
  switch (event.eventType) {
    case 'contact.created':
    case 'contact.updated':
      await applyContactToPartner(event.data);
      break;
    case 'gift.created':
    case 'gift.updated':
      await applyGiftToPartner(event.data);
      break;
    case 'gift.deleted':
      await applyGiftDeletionToPartner(event.data);
      break;
    // ... other event types your integration handles
  }
}

async function applyContactToPartner(contact) {
  // 1. If this Contact has a contactReference for our platform, look up
  //    the existing partner record.
  const ourRef = (contact.contactReferences || []).find(
    (r) => r.source === 'YourPlatform'
  );

  let partnerRecord;
  if (ourRef) {
    partnerRecord = await db.partner_contacts.findOne({ id: ourRef.id });
  } else if (contact.id) {
    partnerRecord = await db.partner_contacts.findOne({ virtuous_contact_id: contact.id });
  }

  // 2. If this Contact was merged into another, remap.
  if (contact.mergedIntoContactId) {
    await db.partner_contacts.update(
      { virtuous_contact_id: contact.id },
      { virtuous_contact_id: contact.mergedIntoContactId, mergedFrom: contact.id }
    );
    return;
  }

  // 3. Apply the inbound change, setting state to suppress an outbound echo.
  if (partnerRecord) {
    await db.partner_contacts.update(
      { id: partnerRecord.id },
      {
        name: contact.name,
        email: extractPrimaryEmail(contact),
        virtuous_modified_at: contact.modifiedDateTimeUtc,
        sync_state: 'virtuous_pending',
        last_sync_at: new Date(),
      }
    );
  } else {
    // No local record — create one from the Virtuous data.
    await db.partner_contacts.insert({
      virtuous_contact_id: contact.id,
      name: contact.name,
      email: extractPrimaryEmail(contact),
      virtuous_modified_at: contact.modifiedDateTimeUtc,
      sync_state: 'in_sync',
      last_sync_at: new Date(),
    });
  }

  // 4. After a short cooldown, transition back to in_sync.
  // (This is typically done by a background job, not synchronously.)
}

async function applyVirtuousChange(virtuousRecord, partnerRecord) {
  const virtuousTime = new Date(virtuousRecord.modifiedDateTimeUtc);
  const partnerTime = new Date(partnerRecord.partner_modified_at);

  if (virtuousTime > partnerTime) {
    // Virtuous wins — apply
    await applyInbound(virtuousRecord, partnerRecord);
  } else {
    // Partner side wins — submit the partner change instead
    await queueOutboundSubmission(partnerRecord);
  }
}