Zapier

npm install -g zapier-platform-cli
zapier login
zapier init xquik-zapier --template minimal
cd xquik-zapier
npm install

const BASE_URL = "https://xquik.com/api/v1";

function addApiKeyHeader(request, z, bundle) {
  request.headers = request.headers || {};
  request.headers["x-api-key"] = bundle.authData.apiKey;
  return request;
}

async function testAuth(z) {
  const response = await z.request({
    method: "GET",
    url: `${BASE_URL}/account`,
  });

  return response.data;
}

module.exports = {
  authentication: {
    type: "custom",
    fields: [{ key: "apiKey", label: "Xquik API Key", required: true }],
    test: testAuth,
  },
  beforeRequest: [addApiKeyHeader],
};

function xquikErrorMessage(status, data, headers) {
  if (status === 401) {
    return "Authentication failed. Check the Xquik API key.";
  }

  if (status === 402) {
    return "Subscription or credits required. Update billing in Xquik.";
  }

  if (status === 429) {
    const retryAfter = headers?.["retry-after"];
    return retryAfter
      ? `Rate limited. Retry after ${retryAfter} seconds.`
      : "Rate limited. Retry after the cooldown period.";
  }

  return data?.message || data?.error || "Xquik request failed.";
}

function throwForXquikError(z, response) {
  if (response.status < 400) {
    return;
  }

  throw new z.errors.Error(
    xquikErrorMessage(response.status, response.data, response.headers),
    "XquikError",
    response.status,
  );
}

async function performSearchTweets(z, bundle) {
  const response = await z.request({
    method: "GET",
    url: `${BASE_URL}/x/tweets/search`,
    params: {
      q: bundle.inputData.q,
      limit: bundle.inputData.limit || 25,
    },
  });

  throwForXquikError(z, response);
  return response.data.tweets || [];
}

module.exports = {
  key: "search_tweets",
  noun: "Tweet",
  display: {
    label: "Search Tweets",
    description: "Find recent tweets that match a search query.",
  },
  operation: {
    inputFields: [
      { key: "q", label: "Query", required: true, type: "string" },
      { key: "limit", label: "Limit", required: false, type: "integer" },
    ],
    perform: performSearchTweets,
    sample: {
      id: "1840000000000000000",
      text: "Example tweet text",
      author: { username: "xquikcom" },
      url: "https://x.com/xquikcom/status/1840000000000000000",
    },
    outputFields: [
      { key: "id", label: "Tweet ID" },
      { key: "text", label: "Text" },
      { key: "author__username", label: "Author Username" },
      { key: "url", label: "URL" },
    ],
  },
};

async function performNewMatchingTweet(z, bundle) {
  const response = await z.request({
    method: "GET",
    url: `${BASE_URL}/x/tweets/search`,
    params: {
      q: bundle.inputData.q,
      limit: 25,
    },
  });

  throwForXquikError(z, response);
  return response.data.tweets || [];
}

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

  throwForXquikError(z, response);
  return { id: response.data.id };
}

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

  throwForXquikError(z, response);
  return response.data;
}

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

  return [
    {
      id: payload.streamEventId || payload.deliveryId,
      deliveryId: payload.deliveryId,
      eventType: payload.eventType,
      occurredAt: payload.occurredAt,
      username: payload.username,
      tweetId: payload.data?.id,
      text: payload.data?.text,
      authorUserName: payload.data?.author?.userName || payload.username,
    },
  ];
}

async function performCompletedExtractions(z) {
  const response = await z.request({
    method: "GET",
    url: `${BASE_URL}/extractions`,
    params: { status: "completed", limit: 25 },
  });

  throwForXquikError(z, response);
  return response.data.extractions || [];
}

async function performWebhookFailures(z, bundle) {
  const response = await z.request({
    method: "GET",
    url: `${BASE_URL}/webhooks/${bundle.inputData.webhookId}/deliveries`,
  });

  throwForXquikError(z, response);
  return (response.data.deliveries || []).filter(
    (delivery) => delivery.status === "failed",
  );
}

zapier-platform test
zapier-platform validate