Sync drafts to your CMS

const API = "https://api.semji.com/v1";
const HEADERS = {
  Authorization: `Bearer ${process.env.SEMJI_API_KEY}`,
  "Content-Type": "application/json",
};
const WORKSPACE_ID = process.env.WORKSPACE_ID;

// Implement these against your CMS and storage:
declare function pushToCms(content: { htmlSanitized: string | null }): Promise<string>;
declare function rememberCmsRecord(contentId: string, cmsRecordId: string): Promise<void>;
declare function lookupCmsRecord(contentId: string): Promise<string>;
declare function fetchCmsState(cmsRecordId: string): Promise<{ isPublic: boolean; publicUrl: string }>;

class ApiError extends Error {
  constructor(readonly status: number, message: string) {
    super(message);
  }
}

async function api(path: string, init: RequestInit = {}) {
  const response = await fetch(`${API}${path}`, { ...init, headers: HEADERS });
  if (!response.ok) {
    throw new ApiError(response.status, `${init.method ?? "GET"} ${path} → ${response.status}`);
  }
  return response.json();
}

// --- status lookup -----------------------------------------------------------

async function loadStatusIds() {
  const { data: statuses } = await api(`/workspaces/${WORKSPACE_ID}/content-statuses`);
  const byLabel = new Map(statuses.map((s) => [s.label.toLowerCase(), s.id]));
  return { readyId: byLabel.get("ready to publish"), sentId: byLabel.get("sent to cms") };
}

// --- helpers -----------------------------------------------------------------

async function listByStatus(statusId: string) {
  const drafts = [];
  for (let page = 1; ; page++) {
    const query = new URLSearchParams({
      "contentStatusId[]": statusId,
      sort: "-updatedAt",
      limit: "100",
      page: String(page),
    });
    const { data, pagination } = await api(`/workspaces/${WORKSPACE_ID}/contents?${query}`);
    drafts.push(...data);
    if (!pagination.hasMore) return drafts;
  }
}

async function transitionTo(contentId: string, statusId: string) {
  for (let attempt = 1; attempt <= 3; attempt++) {
    const { version } = await api(`/contents/${contentId}`);
    try {
      await api(`/contents/${contentId}`, {
        method: "PUT",
        body: JSON.stringify({ contentStatusId: statusId, version }),
      });
      return;
    } catch (error) {
      // 409: someone saved the draft between our GET and PUT — refetch and retry
      if (!(error instanceof ApiError) || error.status !== 409 || attempt === 3) throw error;
    }
  }
}

// --- step 2 & 3: ready to publish → sent to CMS ------------------------------

async function pushReadyDrafts(readyId: string, sentId: string) {
  for (const draft of await listByStatus(readyId)) {
    const content = await api(`/contents/${draft.id}`);
    let cmsRecordId: string;
    try {
      cmsRecordId = await pushToCms(content); // push htmlSanitized, not html
    } catch (error) {
      console.error(`CMS push failed for ${draft.id}:`, error);
      continue; // stays in "ready to publish" — retried next tick
    }
    await rememberCmsRecord(content.id, cmsRecordId);
    await transitionTo(content.id, sentId);
  }
}

// --- step 4: sent to CMS → published -----------------------------------------

async function finalizePublished(sentId: string) {
  for (const draft of await listByStatus(sentId)) {
    const cmsRecordId = await lookupCmsRecord(draft.id);
    const cmsState = await fetchCmsState(cmsRecordId);
    if (!cmsState.isPublic) continue;
    await api(`/contents/${draft.id}/publish`, {
      method: "POST",
      body: JSON.stringify({ url: cmsState.publicUrl }),
    });
  }
}

// --- main loop ---------------------------------------------------------------

while (true) {
  const { readyId, sentId } = await loadStatusIds();
  await pushReadyDrafts(readyId, sentId);
  await finalizePublished(sentId);
  await new Promise((resolve) => setTimeout(resolve, 600_000)); // 10 minutes
}

import express from "express";

const API = "https://api.semji.com/v1";
const HEADERS = { Authorization: `Bearer ${process.env.SEMJI_API_KEY}` };

// Implement against your CMS — create or update by URL (idempotent)
declare function upsertCmsArticle(article: {
  title: string | null;
  html: string | null;
  metaDescription: string | null;
  url: string;
}): Promise<void>;

const app = express();
app.use(express.json());

app.post("/webhooks/semji", (req, res) => {
  res.sendStatus(204); // ack immediately — Semji does not retry failed deliveries
  if (req.body?.event_type !== "content_published") return;
  handleContentPublished(req.body.data.id).catch(console.error);
});

async function handleContentPublished(contentId: string) {
  // Re-fetch with your API key — the webhook payload itself is not signed
  const response = await fetch(`${API}/contents/${contentId}`, { headers: HEADERS });
  if (!response.ok) return;
  const content = await response.json();
  if (!content.publishedAt) return;

  await upsertCmsArticle({
    title: content.title,
    html: content.htmlSanitized,
    metaDescription: content.metaDescription,
    url: content.page.url,
  });
}

app.listen(3000);