Webhooks

{
  "timestamp": "2026-10-01T09:15:42",
  "type": "MODIFIED",
  "micrositeId": "<your microsite id>",
  "bookingReference": "TST-1464"
}

Platform ── POST {timestamp, type, micrositeId, bookingReference} ──► https://hooks.example.com/webhooks/bookings/<secret>

receiver
  1. compare the path secret in constant time              wrong secret: 403
  2. map micrositeId to one canonical microsite id
  3. store the event under a hash of the body              exact re-delivery: no-op
  4. CREATED, MODIFIED, CANCELED: queue one sync job per (canonical microsite, bookingReference)
     any other type: store only
  5. answer 2xx fast, for every type
        │
        ▼
worker
  GET /booking/getBookings/{micrositeId}/{bookingReference}?lang=EN
     404: try your other microsites         401 or 403: re-authenticate once, then alert
     5xx, 429, timeout: retry later
  normalise hotelservice[], distribution[] and manualServices
  idempotent upsert keyed by booking, service and passenger ids

sweep (hourly)
  walk the reference sequence past your high-water mark and probe getBookings,
  to catch lost deliveries and microsites without an endpoint

import { createHash, timingSafeEqual } from 'node:crypto';

type BookingWebhook = {
  timestamp: string;
  type: string; // CREATED, MODIFIED, CANCELED, CLIENT_REQUEST, REFUND, or a future type
  micrositeId: string;
  bookingReference: string;
};

// Every microsite id that can see the same bookings maps to one canonical id.
const CANONICAL_MICROSITE: Record<string, string> = {
  'second-microsite-id': 'main-microsite-id',
};
export const canonical = (micrositeId: string) => CANONICAL_MICROSITE[micrositeId] ?? micrositeId;

const SYNC_TYPES = new Set(['CREATED', 'MODIFIED', 'CANCELED']);
const sha256 = (s: string) => createHash('sha256').update(s).digest();

// Constant-time compare. Hashing first gives both sides the same length.
function secretMatches(given: string): boolean {
  return timingSafeEqual(sha256(given), sha256(process.env.NAVA_WEBHOOK_SECRET!));
}

export async function handleBookingWebhook(pathSecret: string, rawBody: string) {
  if (!secretMatches(pathSecret)) return { status: 403 };

  let body: BookingWebhook;
  try {
    body = JSON.parse(rawBody);
  } catch {
    return { status: 400 };
  }
  if (!body?.bookingReference || !body?.micrositeId) return { status: 400 };

  // Unique index on dedupKey: an exact re-delivery inserts nothing.
  const dedupKey = sha256(rawBody).toString('hex');
  const isNew = await events.insertIfAbsent({ dedupKey, ...body, receivedAt: new Date() });

  if (isNew && SYNC_TYPES.has(body.type)) {
    // One waiting job per booking: a burst of events becomes one fetch.
    await queue.addUnique(`sync:${canonical(body.micrositeId)}:${body.bookingReference}`, {
      micrositeId: body.micrositeId,
      bookingReference: body.bookingReference,
    });
  }
  return { status: 200 }; // every type gets a 2xx, including CLIENT_REQUEST, REFUND and unknown ones
}

const BASE = process.env.NAVA_BASE_URL!;
const MY_MICROSITES = ['main-microsite-id', 'second-microsite-id'];

// The trip and the microsite that resolved it, or null when every microsite answers 404.
export async function findTrip(token: string, ref: string, preferred?: string) {
  const order = preferred ? [preferred, ...MY_MICROSITES.filter((m) => m !== preferred)] : MY_MICROSITES;
  for (const micrositeId of order) {
    const res = await fetch(
      `${BASE}/booking/getBookings/${encodeURIComponent(micrositeId)}/${encodeURIComponent(ref)}?lang=EN`,
      { headers: { 'auth-token': token, 'Accept-Encoding': 'gzip' }, signal: AbortSignal.timeout(60_000) },
    );
    if (res.status === 404) continue; // not in this microsite
    if (!res.ok) throw new Error(`getBookings ${ref} failed with HTTP ${res.status}`); // retry the job later
    const trip = await res.json();
    if (trip?.auditData?.authToken) trip.auditData.authToken = '[REDACTED]';
    return { micrositeId, trip };
  }
  return null;
}

export async function syncJob(job: { micrositeId: string; bookingReference: string }) {
  const token = await getBackOfficeToken(); // cached; one forced re-auth on 401 or 403
  const found = await findTrip(token, job.bookingReference, job.micrositeId);
  if (!found) return; // unknown reference: log it for review
  await upsertTrip(canonical(job.micrositeId), found.trip); // idempotent, see Reading bookings
}

// Hourly. Finds bookings past the high-water mark that no webhook announced.
export async function sweep(token: string, prefix: string, highWaterMark: number, k: number) {
  let last = highWaterMark;
  let misses = 0;
  for (let n = highWaterMark + 1; misses < k; n++) {
    const ref = `${prefix}-${n}`;
    const found = await findTrip(token, ref); // throws on 5xx, 429 and timeouts: the run stops there
    if (found) {
      await queue.addUnique(`sync:${canonical(found.micrositeId)}:${ref}`, { micrositeId: found.micrositeId, bookingReference: ref });
      last = n;
      misses = 0;
    } else {
      misses++; // a real 404 in every microsite
    }
  }
  return last; // store it as the new high-water mark
}