Webhooks API

trpc.webhooks.list.query({
  repoId: string
})

{
  id: string;
  url: string;
  secret: string | null;  // Masked as '********' if set
  events: string[];
  isActive: boolean;
  createdAt: Date;
  updatedAt: Date;
}[]

trpc.webhooks.get.query({
  id: string,     // Webhook UUID
  repoId: string  // Repository UUID
})

trpc.webhooks.create.mutate({
  repoId: string,
  url: string,           // HTTPS URL to receive webhooks
  secret?: string,       // Optional secret for signature verification
  events: string[]       // At least one event required
})

const webhook = await trpc.webhooks.create.mutate({
  repoId: 'repo-uuid',
  url: 'https://example.com/webhooks/git',
  secret: 'my-webhook-secret',
  events: ['push', 'pull_request']
});

trpc.webhooks.update.mutate({
  id: string,
  repoId: string,
  url?: string,
  secret?: string | null,   // null to remove secret
  events?: string[],
  isActive?: boolean
})

// Disable a webhook
await trpc.webhooks.update.mutate({
  id: 'webhook-uuid',
  repoId: 'repo-uuid',
  isActive: false
});

// Add new events
await trpc.webhooks.update.mutate({
  id: 'webhook-uuid',
  repoId: 'repo-uuid',
  events: ['push', 'pull_request', 'issue']
});

trpc.webhooks.delete.mutate({
  id: string,
  repoId: string
})

{
  success: boolean;
}

trpc.webhooks.test.mutate({
  id: string,
  repoId: string
})

{
  success: boolean;
  statusCode: number | null;
  message: string;
}

const result = await trpc.webhooks.test.mutate({
  id: 'webhook-uuid',
  repoId: 'repo-uuid'
});

if (result.success) {
  console.log('Webhook test successful!');
} else {
  console.log(`Failed: ${result.message}`);
}

{
  action: string;          // Event-specific action
  repository: {
    id: string;
    name: string;
    owner: string;
  };
  sender: {
    id: string;
    username: string;
  };
  timestamp: string;       // ISO 8601 format
}

{
  action: 'push';
  ref: string;             // e.g., 'refs/heads/main'
  before: string;          // Previous HEAD SHA
  after: string;           // New HEAD SHA
  commits: {
    id: string;
    message: string;
    author: {
      name: string;
      email: string;
    };
    timestamp: string;
  }[];
  pusher: {
    name: string;
    email: string;
  };
}

{
  action: 'opened' | 'closed' | 'merged' | 'synchronize' | 'reopened';
  number: number;
  pull_request: {
    id: string;
    title: string;
    body: string;
    state: 'open' | 'closed' | 'merged';
    head: {
      ref: string;
      sha: string;
    };
    base: {
      ref: string;
      sha: string;
    };
    author: {
      id: string;
      username: string;
    };
    createdAt: string;
    updatedAt: string;
    mergedAt?: string;
  };
}

{
  action: 'opened' | 'closed' | 'reopened' | 'edited';
  issue: {
    id: string;
    number: number;
    title: string;
    body: string;
    state: 'open' | 'closed';
    author: {
      id: string;
      username: string;
    };
    labels: string[];
    createdAt: string;
    updatedAt: string;
  };
}

import crypto from 'crypto';

function verifySignature(
  payload: string, 
  signature: string, 
  secret: string
): boolean {
  const expected = crypto
    .createHmac('sha256', secret)
    .update(payload)
    .digest('hex');
  
  return crypto.timingSafeEqual(
    Buffer.from(signature),
    Buffer.from(`sha256=${expected}`)
  );
}

// Express middleware example
app.post('/webhooks', (req, res) => {
  const signature = req.headers['x-wit-signature'];
  const payload = JSON.stringify(req.body);
  
  if (!verifySignature(payload, signature, process.env.WEBHOOK_SECRET)) {
    return res.status(401).send('Invalid signature');
  }
  
  // Process webhook
  const event = req.headers['x-wit-event'];
  console.log(`Received ${event} event`);
  
  res.status(200).send('OK');
});

// Create webhook for CI triggers
const webhook = await trpc.webhooks.create.mutate({
  repoId: 'repo-uuid',
  url: 'https://ci.example.com/hooks/wit',
  secret: process.env.CI_WEBHOOK_SECRET,
  events: ['push', 'pull_request']
});

// Test the webhook
const test = await trpc.webhooks.test.mutate({
  id: webhook.id,
  repoId: 'repo-uuid'
});

if (!test.success) {
  console.error('CI webhook failed:', test.message);
}

// Create webhook for Slack notifications
await trpc.webhooks.create.mutate({
  repoId: 'repo-uuid',
  url: 'https://your-app.com/webhooks/slack',
  events: ['push', 'pull_request', 'issue']
});

// Your webhook handler
app.post('/webhooks/slack', async (req, res) => {
  const event = req.headers['x-wit-event'];
  const payload = req.body;
  
  let message: string;
  
  switch (event) {
    case 'push':
      message = `📦 ${payload.pusher.name} pushed ${payload.commits.length} commits to ${payload.ref}`;
      break;
    case 'pull_request':
      message = `🔀 PR #${payload.number}: ${payload.pull_request.title} (${payload.action})`;
      break;
    case 'issue':
      message = `📋 Issue #${payload.issue.number}: ${payload.issue.title} (${payload.action})`;
      break;
    default:
      return res.status(200).send('OK');
  }
  
  await fetch(process.env.SLACK_WEBHOOK_URL, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ text: message })
  });
  
  res.status(200).send('OK');
});

import { trpc } from '@/lib/trpc';

function WebhookSettings({ repoId }: { repoId: string }) {
  const { data: webhooks, refetch } = trpc.webhooks.list.useQuery({ repoId });
  
  const createWebhook = trpc.webhooks.create.useMutation({
    onSuccess: () => refetch()
  });
  
  const deleteWebhook = trpc.webhooks.delete.useMutation({
    onSuccess: () => refetch()
  });
  
  const testWebhook = trpc.webhooks.test.useMutation();

  return (
    <div>
      <h2>Webhooks</h2>
      
      {webhooks?.map(wh => (
        <div key={wh.id}>
          <code>{wh.url}</code>
          <span>{wh.isActive ? '🟢 Active' : '🔴 Inactive'}</span>
          <button onClick={() => testWebhook.mutate({ id: wh.id, repoId })}>
            Test
          </button>
          <button onClick={() => deleteWebhook.mutate({ id: wh.id, repoId })}>
            Delete
          </button>
        </div>
      ))}
      
      <button onClick={() => createWebhook.mutate({
        repoId,
        url: 'https://example.com/webhook',
        events: ['push']
      })}>
        Add Webhook
      </button>
    </div>
  );
}