Integrate with Eventbrite

async function refreshMightyToken(stored) {
  const response = await fetch(`https://${MIGHTY_SUBDOMAIN}.mn.co/oauth/token`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
    body: new URLSearchParams({
      grant_type: 'refresh_token',
      refresh_token: stored.refreshToken,
      client_id: MIGHTY_CLIENT_ID,
      client_secret: MIGHTY_CLIENT_SECRET,
    }),
  });
  if (!response.ok) throw new Error(`Token refresh failed: ${response.status}`);

  const token = await response.json();
  // Refresh tokens rotate. Save the new pair before you use the new access token.
  await saveTokens({
    accessToken: token.access_token,
    refreshToken: token.refresh_token,
    expiresAt: Date.now() + token.expires_in * 1000,
  });
  return token.access_token;
}

async function mighty(query, variables) {
  const accessToken = await getValidMightyAccessToken(); // refreshes when expired

  const response = await fetch(
    `https://api.mn.co/networks/${MIGHTY_SUBDOMAIN}/graphql`,
    {
      method: 'POST',
      headers: {
        Authorization: `Bearer ${accessToken}`,
        'Content-Type': 'application/json',
        'User-Agent': 'eventbrite-sync/1.0 (+https://integrations.example.com)',
      },
      body: JSON.stringify({ query, variables }),
    }
  );

  const { data, errors } = await response.json();
  if (errors?.length) throw new Error(errors.map((e) => e.message).join('; '));
  return data;
}

app.post('/eventbrite/webhook/:secret', express.json(), async (req, res) => {
  if (!webhookSecretMatches(req.params.secret)) return res.sendStatus(404);

  try {
    // Wait for the job to be stored before acknowledging. A 200 sent before
    // the enqueue finishes can be followed by a lost job.
    await enqueue({ action: req.body.config.action, apiUrl: req.body.api_url }); // your job queue
    res.sendStatus(200);
  } catch (err) {
    console.error(err);
    res.sendStatus(500);
  }
});

// Your queue worker. Throw on failure so your queue's retry policy runs.
async function processJob({ action, apiUrl }) {
  if (action === 'order.placed') await handleOrderPlaced(apiUrl);
  if (action === 'event.published' || action === 'event.updated') {
    await handleEventWebhook(action, apiUrl);
  }
}

const CREATE_INVITES = `
  mutation InviteAttendees($input: CreateInvitesInput!) {
    createInvites(input: $input) {
      count
      ignoredRecipients
      mode
      errors
    }
  }
`;

// Above this many email recipients in one call, createInvites switches to
// async mode: invalid addresses are dropped silently instead of returned as
// a retryable error. Stay at or under it to keep every call in sync mode.
const MAX_SYNC_RECIPIENTS = 10;

async function handleOrderPlaced(apiUrl) {
  const order = await eventbrite(`${apiUrl}?expand=attendees,event`);

  // Invite each attendee once, even if one buyer bought several tickets for the same person.
  const recipients = [
    ...new Map(
      order.attendees
        .filter((attendee) => attendee.profile?.email)
        .map(({ profile }) => [
          profile.email.toLowerCase(),
          { email: profile.email, firstName: profile.first_name, lastName: profile.last_name },
        ])
    ).values(),
  ];
  if (recipients.length === 0) return;

  // Most orders fit in a single call; this only chunks when one order has an
  // unusually large party.
  for (let i = 0; i < recipients.length; i += MAX_SYNC_RECIPIENTS) {
    await sendInvites(recipients.slice(i, i + MAX_SYNC_RECIPIENTS), order);
  }
}

async function sendInvites(recipients, order, alreadyRetried = false) {
  const { createInvites } = await mighty(CREATE_INVITES, {
    input: {
      spaceId: ATTENDEE_SPACE_ID,
      recipients,
      message: `Thanks for registering for ${order.event?.name?.text ?? 'our event'}! Join the conversation with other attendees.`,
    },
  });

  // A batch of MAX_SYNC_RECIPIENTS or fewer runs synchronously, where one
  // invalid address rejects the whole batch (count: 0). Drop the listed
  // addresses and retry once so the rest of the attendees still get invited.
  const invalidMatch = createInvites.errors.find((error) => error.startsWith('Invalid Emails:'));
  if (invalidMatch && !alreadyRetried) {
    const invalidEmails = invalidMatch
      .slice('Invalid Emails:'.length)
      .split(',')
      .map((email) => email.trim().toLowerCase());
    const retryRecipients = recipients.filter((r) => !invalidEmails.includes(r.email.toLowerCase()));
    console.warn(`Retrying without invalid addresses: ${invalidEmails.join(', ')}`);
    if (retryRecipients.length === 0) return;
    return sendInvites(retryRecipients, order, true);
  }

  if (createInvites.errors.length) {
    throw new Error(createInvites.errors.join('; '));
  }
  console.log(`Invited ${createInvites.count}; skipped ${createInvites.ignoredRecipients.length}`);
}

async function eventbrite(url) {
  const response = await fetch(url, {
    headers: { Authorization: `Bearer ${EVENTBRITE_PRIVATE_TOKEN}` },
  });
  if (!response.ok) throw new Error(`Eventbrite ${response.status} for ${url}`);
  return response.json();
}

const CREATE_EVENT = `
  mutation MirrorEvent($input: CreateEventInput!) {
    createEvent(input: $input) {
      event { id url }
      errors
    }
  }
`;

const UPDATE_EVENT = `
  mutation UpdateMirroredEvent($input: UpdateEventInput!) {
    updateEvent(input: $input) {
      event { id }
      errors
    }
  }
`;

function toMightyEvent(ebEvent) {
  return {
    title: ebEvent.name.text,
    description: `${ebEvent.description?.text ?? ''}\n\nGet tickets: ${ebEvent.url}`.trim(),
    startsAt: ebEvent.start.utc,
    endsAt: ebEvent.end.utc,
    timeZone: ebEvent.start.timezone,
    eventType: ebEvent.online_event ? 'online_meeting' : 'local',
    link: ebEvent.url,
  };
}

async function handleEventWebhook(action, apiUrl) {
  const ebEvent = await eventbrite(apiUrl);
  const mirror = await lookupMirror(ebEvent.id); // from your database

  if (mirror && !mirror.mightyEventId) {
    // Another worker has claimed this event and is still creating it. Fail so
    // your queue retries this job after the Mighty event ID is saved.
    throw new Error(`Mirrored event for ${ebEvent.id} is still being created`);
  }

  if (mirror) {
    const { updateEvent } = await mighty(UPDATE_EVENT, {
      input: { id: mirror.mightyEventId, ...toMightyEvent(ebEvent) },
    });
    if (updateEvent.errors.length) throw new Error(updateEvent.errors.join('; '));
    return;
  }

  // Without a saved mapping, only a published, live event should create a
  // new mirrored event. An event.updated webhook with no mapping means the
  // mirrored event was never created (or its record was lost) — skip it
  // instead of creating a duplicate later.
  if (action !== 'event.published' || ebEvent.status !== 'live') return;

  // Two deliveries of the same webhook can both reach this point before either
  // saves a mapping. Claim the Eventbrite event ID first with an insert guarded
  // by a unique key (for example, INSERT ... ON CONFLICT DO NOTHING). Only the
  // worker whose insert succeeds creates the event.
  const claimed = await claimMirror(ebEvent.id);
  if (!claimed) return;

  let createEvent;
  try {
    ({ createEvent } = await mighty(CREATE_EVENT, {
      input: { spaceId: EVENTS_SPACE_ID, ...toMightyEvent(ebEvent) },
    }));
  } catch (err) {
    await releaseMirrorClaim(ebEvent.id); // nothing was created, so a retry can claim it again
    throw err;
  }
  if (createEvent.errors.length) {
    await releaseMirrorClaim(ebEvent.id);
    throw new Error(createEvent.errors.join('; '));
  }

  await saveMirroredEventId(ebEvent.id, createEvent.event.id);
}