Serverless handler for Sequel → Contentful

// package.json deps:
//  "contentful-management": "^11",
//  "node-fetch": "^3",
//  "slugify": "^1"

import contentful from 'contentful-management';
import fetch from 'node-fetch';
import slugify from 'slugify';

const client = contentful.createClient({ accessToken: process.env.CTF_CMA_TOKEN });

const SPACE_ID = process.env.CTF_SPACE_ID;
const ENV_ID = process.env.CTF_ENV_ID || 'master';
const CONTENT_TYPE_ID = process.env.CONTENT_TYPE_ID || 'event';
const DEFAULT_LOCALE = process.env.DEFAULT_LOCALE || 'en-US';
const PUBLIC_EVENT_URL_BASE = process.env.PUBLIC_EVENT_URL_BASE;

// Express-style handler signature; adapt for your platform
export default async function handler(req, res) {
  try {
    // --- 1) Basic auth: shared secret ---
    const given =
      req.headers['x-shared-secret'] ||
      new URL(req.url, 'http://localhost').searchParams.get('secret');
    if (given !== process.env.WEBHOOK_SHARED_SECRET) {
      return res.status(401).json({ error: 'unauthorized' });
    }

    // --- 2) Determine action: create | update | delete ---
    const action =
      (req.headers['x-sequel-action'] || '').toLowerCase() ||
      new URL(req.url, 'http://localhost').searchParams.get('action') ||
      ''; // set per webhook URL in Sequel

    // --- 3) Parse payload ---
    // Ensure your platform gives you parsed JSON (e.g., Vercel/Next API routes do; otherwise add a JSON body parser)
    const body = req.body || {};
    const details = body.details || {};
    if (!details.eventId) return res.status(400).json({ error: 'missing eventId' });

    const space = await client.getSpace(SPACE_ID);
    const env = await space.getEnvironment(ENV_ID);

    // --- Helpers ---
    const toSlug = (name, fallback) =>
      slugify(name || fallback, { lower: true, strict: true });

    async function ensureBannerAsset(url, title) {
      if (!url) return null;
      // Create asset that points to a remote URL; then process and publish
      const asset = await env.createAsset({
        fields: {
          title: { [DEFAULT_LOCALE]: title || 'Event banner' },
          file: {
            [DEFAULT_LOCALE]: {
              upload: url,                // remote URL
              fileName: `banner-${details.eventId}.jpg`,
              contentType: 'image/jpeg'   // adjust if not JPG
            }
          }
        }
      });
      await asset.processForAllLocales();     // wait/process binary
      const processed = await env.getAsset(asset.sys.id);
      return await processed.publish();       // publish asset
    }

    async function findEntryByExternalId(externalId) {
      const q = await env.getEntries({
        content_type: CONTENT_TYPE_ID,
        [`fields.externalCMSItemId`]: externalId,
        limit: 1
      });
      return q.items[0] || null;
    }

    // --- 4) DELETE flow ---
    if (action === 'delete') {
      const externalId = details.externalCMSItemId || details.eventId;
      const entry = await findEntryByExternalId(externalId);
      if (entry) {
        try { if (entry.isPublished()) await entry.unpublish(); } catch {}
        await env.deleteEntry(entry.sys.id);
      }
      return res.json({ ok: true, deleted: !!entry });
    }

    // --- 5) CREATE / UPDATE flow ---
    const slug = toSlug(details.eventName, details.eventId);
    const banner = await ensureBannerAsset(details.bannerUrl, details.eventName);

    // Build field payload (mind locales)
    const fields = {
      title:             { [DEFAULT_LOCALE]: details.eventName || '' },
      slug:              { [DEFAULT_LOCALE]: slug },
      description:       { [DEFAULT_LOCALE]: details.description || '' }, // Rich Text? see note below
      startDate:         { [DEFAULT_LOCALE]: details.startDate || null },
      endDate:           { [DEFAULT_LOCALE]: details.endDate || null },
      timezone:          { [DEFAULT_LOCALE]: details.timezone || '' },
      sequelEventId:     { [DEFAULT_LOCALE]: details.eventId },
      externalCMSItemId: { [DEFAULT_LOCALE]: (details.externalCMSItemId || details.eventId) },
      ...(banner
        ? { banner: { [DEFAULT_LOCALE]: { sys: { type: 'Link', linkType: 'Asset', id: banner.sys.id } } } }
        : {})
    };

    // If we already stored the Contentful entry id back into Sequel, updates will carry externalCMSItemId
    let entry = null;
    if (action === 'update' && (details.externalCMSItemId || details.eventId)) {
      entry = await findEntryByExternalId(details.externalCMSItemId || details.eventId);
    }

    if (!entry) {
      entry = await env.createEntry(CONTENT_TYPE_ID, { fields }); // creates as draft
    } else {
      entry.fields = { ...entry.fields, ...fields };
      entry = await entry.update();
    }

    // Publish (Contentful requires a separate publish step)
    if (!entry.isPublished()) entry = await entry.publish();

    // --- 6) Round-trip to Sequel once (after first create) ---
    if (!details.externalCMSItemId && PUBLIC_EVENT_URL_BASE) {
      const publicUrl = `${PUBLIC_EVENT_URL_BASE}/${slug}`;
      await fetch(`https://api.introvoke.com/api/v3/events/${details.eventId}/wpcms`, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
          'Authorization': `Bearer ${process.env.SEQUEL_API_TOKEN}`
        },
        body: JSON.stringify({ postId: entry.sys.id, postUrl: publicUrl })
      });
    }

    return res.json({ ok: true, entryId: entry.sys.id, published: true });
  } catch (err) {
    console.error(err);
    return res.status(500).json({ error: err.message });
  }
}