Webhook Integration Guide

export const runtime = 'edge';

export async function POST(request: Request) {
  const token = (request.headers.get('Authorization') || '')
    .replace(/^Bearer\s+/i, '');
  if (token !== process.env.LINKLOOM_WEBHOOK_SECRET)
    return Response.json({ error: 'Unauthorized' }, { status: 401 });

  const p: any = await request.json();
  if (!p?.slug || !p?.title || !p?.content)
    return Response.json({ error: 'Missing fields' }, { status: 400 });

  const slug = p.slug.toLowerCase().replace(/[^a-z0-9-_]/g, '-');
  const branch = process.env.GITHUB_BRANCH || 'main';
  const path = `${process.env.CONTENT_PATH || 'content/blog'}/${slug}.md`;
  const repo = process.env.GITHUB_REPO!;
  const gh = {
    Authorization: `Bearer ${process.env.GITHUB_TOKEN}`,
    Accept: 'application/vnd.github+json',
    'User-Agent': 'linkloom-webhook',
  };

  const fm = `---
title: ${JSON.stringify(p.title)}
${p.excerpt ? `description: ${JSON.stringify(p.excerpt)}\n` : ''}\${p.author ? `author: ${JSON.stringify(p.author)}\n` : ''}\${p.published_at ? `date: ${JSON.stringify(p.published_at)}\n` : ''}\${p.request_id ? `request_id: ${JSON.stringify(p.request_id)}\n` : ''}---

${p.content}
`;

  const get = await fetch(
    `https://api.github.com/repos/${repo}/contents/${path}?ref=${branch}`,
    { headers: gh }
  );
  let sha: string | undefined;
  if (get.status === 200) {
    const d: any = await get.json();
    sha = d.sha;
    const ex = Buffer.from(d.content, 'base64').toString();
    const rid = ex.match(/^request_id:\s*"?([^"\n]+)"?/m)?.[1];
    if (p.request_id && rid === p.request_id)
      return Response.json({ success: true, duplicate: true });
  }

  const put = await fetch(
    `https://api.github.com/repos/${repo}/contents/${path}`,
    {
      method: 'PUT',
      headers: { ...gh, 'Content-Type': 'application/json' },
      body: JSON.stringify({
        message: sha ? `Update: ${p.title}` : `Add: ${p.title}`,
        content: Buffer.from(fm).toString('base64'),
        branch,
        ...(sha ? { sha } : {}),
      }),
    }
  );
  if (!put.ok)
    return Response.json({ error: 'Commit failed' }, { status: 502 });
  return Response.json({
    success: true,
    action: sha ? 'updated' : 'published',
  });
}

import type { Handler } from '@netlify/functions';

export const handler: Handler = async (event) => {
  const token = (event.headers.authorization || '')
    .replace(/^Bearer\s+/i, '');
  if (token !== process.env.LINKLOOM_WEBHOOK_SECRET)
    return {
      statusCode: 401,
      body: JSON.stringify({ error: 'Unauthorized' }),
    };

  const p = JSON.parse(event.body || '{}');
  if (!p?.slug || !p?.title || !p?.content)
    return {
      statusCode: 400,
      body: JSON.stringify({ error: 'Missing fields' }),
    };

  // Same GitHub commit logic as Cloudflare/Vercel examples
  // 1. Build markdown frontmatter + content
  // 2. Check existing file via GitHub API (idempotency)
  // 3. PUT to GitHub Contents API to create/update

  return {
    statusCode: 200,
    body: JSON.stringify({ success: true }),
  };
};

const express = require('express');
const router = express.Router();
const db = require('../db');

router.post('/receive-content', async (req, res) => {
  const token = (req.headers.authorization || '')
    .replace(/^Bearer\s+/i, '');
  if (token !== process.env.LINKLOOM_WEBHOOK_SECRET)
    return res.status(401).json({ error: 'Unauthorized' });

  const {
    title, content, excerpt, author, published_at, site_name,
    cover_image_url, slug, url_path, category, request_id,
  } = req.body;

  if (!slug || !title || !content)
    return res.status(400).json({ error: 'Missing fields' });

  try {
    if (request_id) {
      const ex = await db.query(
        'SELECT id FROM posts WHERE request_id = $1',
        [request_id]
      );
      if (ex.rows.length)
        return res.json({
          success: true,
          duplicate: true,
          content_id: ex.rows[0].id,
        });
    }

    const result = await db.query(
      `INSERT INTO posts (
        request_id, title, slug, content, excerpt, author,
        category_name, category_slug, url_path, cover_image_url,
        source_site, published_at, status
      ) VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13)
      RETURNING id`,
      [
        request_id, title, slug, content, excerpt, author,
        category?.name, category?.slug, url_path, cover_image_url,
        site_name, published_at, 'published',
      ]
    );

    res.json({
      success: true,
      action: 'published',
      content_id: result.rows[0].id,
      url_path,
    });
  } catch (e) {
    res.status(500).json({ error: 'Server error' });
  }
});

module.exports = router;

<?php
header('Content-Type: application/json');

$token = str_replace('Bearer ', '', $_SERVER['HTTP_AUTHORIZATION'] ?? '');
if (!getenv('LINKLOOM_WEBHOOK_SECRET') || $token !== getenv('LINKLOOM_WEBHOOK_SECRET')) {
    http_response_code(401);
    echo json_encode(['error' => 'Unauthorized']);
    exit;
}

$p = json_decode(file_get_contents('php://input'), true);
if (empty($p['slug']) || empty($p['title']) || empty($p['content'])) {
    http_response_code(400);
    echo json_encode(['error' => 'Missing fields']);
    exit;
}

try {
    $pdo = new PDO(
        'mysql:host=' . getenv('DB_HOST') . ';dbname=' . getenv('DB_NAME'),
        getenv('DB_USER'),
        getenv('DB_PASS')
    );
    $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);

    if (!empty($p['request_id'])) {
        $s = $pdo->prepare('SELECT id FROM posts WHERE request_id = ?');
        $s->execute([$p['request_id']]);
        if ($ex = $s->fetch()) {
            echo json_encode([
                'success' => true,
                'duplicate' => true,
                'content_id' => $ex['id'],
            ]);
            exit;
        }
    }

    $s = $pdo->prepare(
        'INSERT INTO posts (
            request_id, title, slug, content, excerpt, author,
            category_name, url_path, cover_image_url, source_site,
            published_at, status, created_at
        ) VALUES (?,?,?,?,?,?,?,?,?,?,?,"published",NOW())'
    );
    $s->execute([
        $p['request_id'], $p['title'], $p['slug'], $p['content'],
        $p['excerpt'] ?? null, $p['author'] ?? null,
        $p['category']['name'] ?? null, $p['url_path'] ?? null,
        $p['cover_image_url'] ?? null, $p['site_name'] ?? null,
        $p['published_at'] ?? null,
    ]);

    echo json_encode([
        'success' => true,
        'action' => 'published',
        'content_id' => $pdo->lastInsertId(),
    ]);
} catch (Exception $e) {
    http_response_code(500);
    echo json_encode(['error' => $e->getMessage()]);
}

import json, os
from django.http import JsonResponse
from django.views.decorators.csrf import csrf_exempt
from django.views.decorators.http import require_POST
from .models import Post

@csrf_exempt
@require_POST
def receive_content(request):
    auth = request.headers.get('Authorization', '')
    token = auth.replace('Bearer ', '', 1) if auth.startswith('Bearer ') else ''
    secret = os.environ.get('LINKLOOM_WEBHOOK_SECRET')
    if not secret or token != secret:
        return JsonResponse({'error': 'Unauthorized'}, status=401)

    payload = json.loads(request.body)
    if not all([payload.get('slug'), payload.get('title'), payload.get('content')]):
        return JsonResponse({'error': 'Missing fields'}, status=400)

    request_id = payload.get('request_id')
    if request_id:
        existing = Post.objects.filter(request_id=request_id).first()
        if existing:
            return JsonResponse({
                'success': True,
                'duplicate': True,
                'content_id': str(existing.id),
            })

    cat = payload.get('category', {})
    post, created = Post.objects.update_or_create(
        slug=payload['slug'],
        defaults={
            'request_id': request_id,
            'title': payload['title'],
            'content': payload['content'],
            'excerpt': payload.get('excerpt', ''),
            'author': payload.get('author', ''),
            'category_name': cat.get('name', ''),
            'url_path': payload.get('url_path', ''),
            'cover_image_url': payload.get('cover_image_url', ''),
            'source_site': payload.get('site_name', ''),
            'published_at': payload.get('published_at'),
            'status': 'published',
        },
    )

    return JsonResponse({
        'success': True,
        'action': 'published' if created else 'updated',
        'content_id': str(post.id),
    })

<?php
/**
 * Plugin Name: LinkLoom Webhook Receiver
 * Description: Receives content from LinkLoom and creates WordPress posts.
 */
add_action('rest_api_init', function () {
    register_rest_route('linkloom/v1', '/receive-content', [
        'methods'             => 'POST',
        'callback'            => 'linkloom_receive',
        'permission_callback' => '__return_true',
    ]);
});

function linkloom_receive(WP_REST_Request $req) {
    $token = str_replace('Bearer ', '', $req->get_header('Authorization') ?? '');
    if (empty(LINKLOOM_WEBHOOK_SECRET) || $token !== LINKLOOM_WEBHOOK_SECRET)
        return new WP_REST_Response(['error' => 'Unauthorized'], 401);

    $p = $req->get_json_params();
    $slug    = sanitize_title($p['slug'] ?? '');
    $title   = sanitize_text_field($p['title'] ?? '');
    $content = wp_kses_post($p['content'] ?? '');
    if (empty($slug) || empty($title) || empty($content))
        return new WP_REST_Response(['error' => 'Missing fields'], 400);

    $rid = sanitize_text_field($p['request_id'] ?? '');
    if ($rid) {
        $ex = get_posts([
            'meta_key'    => '_linkloom_rid',
            'meta_value'  => $rid,
            'post_type'   => 'post',
            'numberposts' => 1,
        ]);
        if (!empty($ex))
            return new WP_REST_Response([
                'success'    => true,
                'duplicate'  => true,
                'content_id' => $ex[0]->ID,
            ]);
    }

    $existing = get_page_by_path($slug, OBJECT, 'post');
    $data = [
        'post_title'   => $title,
        'post_content' => $content,
        'post_name'    => $slug,
        'post_status'  => 'publish',
        'post_excerpt' => $p['excerpt'] ?? '',
    ];

    if ($existing) {
        $data['ID'] = $existing->ID;
        $pid = wp_update_post($data);
        $act = 'updated';
    } else {
        $pid = wp_insert_post($data);
        $act = 'published';
    }

    if (is_wp_error($pid))
        return new WP_REST_Response(['error' => $pid->get_error_message()], 500);

    if ($rid) update_post_meta($pid, '_linkloom_rid', $rid);

    if (!empty($p['category']['name'])) {
        $cat = get_cat_ID($p['category']['name']);
        if (!$cat) $cat = wp_create_category($p['category']['name']);
        wp_set_post_categories($pid, [$cat]);
    }

    return new WP_REST_Response([
        'success'    => true,
        'action'     => $act,
        'content_id' => $pid,
        'url'        => get_permalink($pid),
    ]);
}