Sanity CMS Integration

// schemas/post.ts
defineField({
  name: 'sightAiId',
  title: 'Sight AI ID',
  type: 'string',
  readOnly: true,
  hidden: true,
}),

SIGHT_AI_WEBHOOK_SECRET=...   # from Sight AI webhook settings
SANITY_PROJECT_ID=...
SANITY_DATASET=production
SANITY_WRITE_TOKEN=sk...

// app/api/webhooks/sight-ai/route.ts
import { NextResponse } from 'next/server';
import { createClient } from '@sanity/client';
import crypto from 'node:crypto';

const REPLAY_WINDOW_MS = 5 * 60 * 1000;

const sanity = createClient({
  projectId: process.env.SANITY_PROJECT_ID!,
  dataset: process.env.SANITY_DATASET!,
  token: process.env.SANITY_WRITE_TOKEN!,
  apiVersion: '2024-01-01',
  useCdn: false,
});

export async function GET() {
  return NextResponse.json({ status: 'ok', endpoint: 'sight-ai' });
}

export async function POST(request: Request) {
  const secret =
    process.env.SIGHT_AI_WEBHOOK_SECRET ?? process.env.SIGHTAI_WEBHOOK_SECRET;

  if (!secret) {
    return NextResponse.json({ error: 'Webhook not configured' }, { status: 503 });
  }

  const rawBody = await request.text();

  const signature = request.headers.get('x-sightai-signature') ?? '';
  if (!verifySignature(rawBody, signature, secret)) {
    return NextResponse.json({ error: 'Invalid signature' }, { status: 401 });
  }

  const timestampHeader = request.headers.get('x-sightai-timestamp');
  const timestamp = Number(timestampHeader);
  if (
    !Number.isFinite(timestamp) ||
    Math.abs(Date.now() - timestamp) > REPLAY_WINDOW_MS
  ) {
    return NextResponse.json({ error: 'Timestamp out of range' }, { status: 401 });
  }

  let payload: SightAiWebhookPayload;
  try {
    payload = JSON.parse(rawBody);
  } catch {
    return NextResponse.json({ error: 'Invalid JSON' }, { status: 400 });
  }

  if (payload.test === true) {
    return NextResponse.json({ ok: true, test: true });
  }

  const { article, event_id } = payload;
  if (!article?.id || !article.slug || !article.title || !article.content) {
    return NextResponse.json({ error: 'Missing required article fields' }, { status: 400 });
  }

  const existingId = await sanity.fetch<string | null>(
    `*[_type == "post" && sightAiId == $id][0]._id`,
    { id: article.id },
  );

  const mainImage = await resolveMainImage(existingId, article.main_image_url);

  const doc = {
    _type: 'post',
    ...(existingId ? { _id: existingId } : {}),
    sightAiId: article.id,
    title: article.title,
    slug: { _type: 'slug', current: article.slug },
    bodyHtml: article.content,
    excerpt: article.summary ?? undefined,
    seo: {
      title: article.seo_title ?? undefined,
      description: article.seo_meta_description ?? undefined,
    },
    authorName: article.author_name ?? undefined,
    category: article.category ?? undefined,
    targetKeyword: article.target_keyword ?? undefined,
    featured: article.is_featured,
    publishedAt: article.published_at ?? undefined,
    ...(mainImage ? { mainImage } : {}),
  };

  const result = await sanity.createOrReplace(doc);

  return NextResponse.json({
    ok: true,
    operation: existingId ? 'updated' : 'created',
    sanityId: result._id,
    sightAiId: article.id,
    event_id,
  });
}

async function resolveMainImage(
  existingDocId: string | null,
  imageUrl: string | null | undefined,
) {
  if (!imageUrl) return undefined;

  if (existingDocId) {
    const existing = await sanity.fetch<{ mainImage?: unknown } | null>(
      `*[_id == $id][0]{ mainImage }`,
      { id: existingDocId },
    );
    if (existing?.mainImage) return undefined;
  }

  const response = await fetch(imageUrl);
  if (!response.ok) return undefined;

  const buffer = Buffer.from(await response.arrayBuffer());
  const filename = imageUrl.split('/').pop()?.split('?')[0] ?? 'featured.jpg';

  const asset = await sanity.assets.upload('image', buffer, { filename });
  return {
    _type: 'image',
    asset: { _type: 'reference', _ref: asset._id },
  };
}

function verifySignature(rawBody: string, header: string, secret: string) {
  if (!header.startsWith('sha256=')) return false;

  const expected = crypto
    .createHmac('sha256', secret)
    .update(rawBody, 'utf8')
    .digest('hex');

  const provided = header.slice('sha256='.length);
  if (expected.length !== provided.length) return false;

  return crypto.timingSafeEqual(
    Buffer.from(expected, 'hex'),
    Buffer.from(provided, 'hex'),
  );
}

type SightAiWebhookPayload = {
  test?: boolean;
  event_id?: string;
  event: 'article.ready' | string;
  timestamp: string;
  site: { id: string; name: string; host: string };
  article: {
    id: string;
    slug: string;
    title: string;
    content: string;
    summary?: string | null;
    seo_title?: string | null;
    seo_meta_description?: string | null;
    target_keyword?: string | null;
    main_image_url?: string | null;
    thumbnail_image_url?: string | null;
    article_type: string;
    category?: string | null;
    author_name?: string | null;
    read_time_minutes?: number | null;
    is_featured: boolean;
    published_at?: string | null;
    created_at: string;
    updated_at: string;
  };
};

npm install @sanity/client

curl https://yourdomain.com/api/webhooks/sight-ai
# → {"status":"ok","endpoint":"sight-ai"}

defineField({
  name: 'bodyHtml',
  title: 'Body (HTML)',
  type: 'text',
}),