Zapier Twitter monitor event REST hook trigger

async function subscribeHook(z, bundle) {
  const response = await xquikRequest(z, {
    method: "POST",
    url: `${BASE_URL}/webhooks`,
    body: {
      url: bundle.targetUrl,
      eventTypes: bundle.inputData.eventTypes,
    },
  });

  return {
    id: response.data.id,
    secret: response.data.secret,
    eventTypes: response.data.eventTypes,
  };
}

async function unsubscribeHook(z, bundle) {
  const response = await xquikRequest(z, {
    method: "DELETE",
    url: `${BASE_URL}/webhooks/${bundle.subscribeData.id}`,
  });

  return response.data;
}

const { createHmac, timingSafeEqual } = require("node:crypto");

const FIVE_MINUTES_MS = 5 * 60 * 1000;

function readRawHeader(headers, requestedName) {
  const wanted = requestedName.toLowerCase();

  for (const [name, value] of Object.entries(headers || {})) {
    const normalized = name.toLowerCase().replace(/^http-/, "");
    if (normalized === wanted) {
      return String(value);
    }
  }

  return "";
}

function verifyXquikWebhook(z, bundle) {
  const rawBody = bundle.rawRequest?.content;
  const headers = bundle.rawRequest?.headers;
  const secret = bundle.subscribeData?.secret;
  const timestamp = readRawHeader(headers, "x-xquik-timestamp");
  const nonce = readRawHeader(headers, "x-xquik-nonce");
  const signature = readRawHeader(headers, "x-xquik-signature");

  if (!rawBody || !secret || !timestamp || !nonce || !signature) {
    throw new z.errors.Error(
      "Webhook rejected. Signing fields are missing.",
      "XquikWebhookVerificationError",
      400,
    );
  }

  const timestampMs = Number(timestamp);
  if (!Number.isFinite(timestampMs) || Math.abs(Date.now() - timestampMs) > FIVE_MINUTES_MS) {
    throw new z.errors.Error(
      "Webhook rejected. Timestamp is stale or invalid.",
      "XquikWebhookVerificationError",
      400,
    );
  }

  const signingString = `${timestamp}.${nonce}.${rawBody}`;
  const expected = "sha256=" + createHmac("sha256", secret).update(signingString).digest("hex");
  const expectedBuffer = Buffer.from(expected);
  const actualBuffer = Buffer.from(signature);

  if (
    expectedBuffer.length !== actualBuffer.length ||
    !timingSafeEqual(expectedBuffer, actualBuffer)
  ) {
    throw new z.errors.Error(
      "Webhook rejected. Signature does not match.",
      "XquikWebhookVerificationError",
      400,
    );
  }

  return JSON.parse(rawBody);
}

function performMonitorEvent(z, bundle) {
  const payload = verifyXquikWebhook(z, bundle);

  return [
    {
      id: payload.streamEventId || payload.deliveryId || String(payload.timestamp),
      delivery_id: payload.deliveryId || null,
      stream_event_id: payload.streamEventId || null,
      event_type: payload.eventType,
      occurred_at: payload.occurredAt || payload.timestamp,
      username: payload.username || null,
      tweet_id: payload.data?.id || null,
      text: payload.data?.text || null,
      author_username: payload.data?.author?.userName || payload.username || null,
    },
  ];
}

async function performList(z) {
  const response = await xquikRequest(z, {
    method: "GET",
    url: `${BASE_URL}/events`,
    params: { limit: 1 },
  });

  return (response.data.events || []).slice(0, 1).map((event) => ({
    id: event.id,
    delivery_id: null,
    stream_event_id: event.id,
    event_type: event.type,
    occurred_at: event.occurredAt,
    username: event.username || null,
    tweet_id: event.data?.id || null,
    text: event.data?.text || null,
    author_username: event.data?.author?.userName || event.username || null,
  }));
}