Multi-Service Integration

const issue = $input.first().json;

// Only process newly opened issues
if (issue.action !== 'opened') return [];

return [{
  json: {
    issueNumber: issue.issue.number,
    title: issue.issue.title,
    body: issue.issue.body?.substring(0, 500) || 'No description',
    author: issue.issue.user.login,
    authorAvatar: issue.issue.user.avatar_url,
    url: issue.issue.html_url,
    labels: (issue.issue.labels || []).map(l => l.name).join(', '),
    assignee: issue.issue.assignee?.login || 'unassigned',
    repository: issue.repository.full_name,
    createdAt: issue.issue.created_at
  }
}];

CREATE TABLE github_issues (
  id SERIAL PRIMARY KEY,
  issue_number INTEGER NOT NULL,
  title TEXT NOT NULL,
  body TEXT,
  author VARCHAR(255),
  url TEXT,
  labels TEXT,
  assignee VARCHAR(255),
  repository VARCHAR(255),
  status VARCHAR(50) DEFAULT 'open',
  created_at TIMESTAMP,
  processed_at TIMESTAMP DEFAULT NOW()
);

🐛 *New Issue #{{ $json.issueNumber }}*
*{{ $json.title }}*

{{ $json.body }}

Author: {{ $json.author }}
Labels: {{ $json.labels || 'none' }}
Assignee: {{ $json.assignee }}
<{{ $json.url }}|View on GitHub>

Schedule Trigger (daily at 9 AM)
  → PostgreSQL (query recent issues/events)
    → Code (format digest)
      → Slack (post digest)
      → Send Email (to team lead)

SELECT
  issue_number, title, author, assignee, labels, status, url
FROM github_issues
WHERE processed_at >= NOW() - INTERVAL '24 hours'
ORDER BY created_at DESC;

const issues = $input.all().map(i => i.json);

if (issues.length === 0) {
  return [{ json: { hasIssues: false, digest: 'No new issues in the last 24 hours. 🎉' } }];
}

const byStatus = {
  open: issues.filter(i => i.status === 'open'),
  closed: issues.filter(i => i.status === 'closed')
};

let digest = `📊 *Daily Issue Digest — ${new Date().toLocaleDateString()}*\n\n`;
digest += `Total: ${issues.length} | Open: ${byStatus.open.length} | Closed: ${byStatus.closed.length}\n\n`;

if (byStatus.open.length > 0) {
  digest += `*Open Issues:*\n`;
  byStatus.open.forEach(i => {
    digest += `• #${i.issue_number}: ${i.title} (${i.assignee}) — <${i.url}|view>\n`;
  });
}

return [{ json: { hasIssues: true, digest, issueCount: issues.length } }];

const email = $input.first().json;
return [{
  json: {
    from: email.from?.text || email.from,
    subject: email.subject,
    body: email.text?.substring(0, 2000) || '',
    receivedAt: email.date,
    messageId: email.messageId,
    hasAttachments: (email.attachments || []).length > 0,
    attachmentCount: (email.attachments || []).length
  }
}];

INSERT INTO inbound_emails (from_address, subject, body, received_at, message_id, has_attachments)
VALUES ($1, $2, $3, $4, $5, $6)
RETURNING id;

Method: POST
URL: https://api.yourservice.com/tickets
Headers:
  Authorization: Bearer {{ $credentials.apiToken }}
  Content-Type: application/json
Body:
{
  "source": "email",
  "from": "{{ $json.from }}",
  "subject": "{{ $json.subject }}",
  "body": "{{ $json.body }}",
  "external_id": "{{ $json.messageId }}"
}

SELECT * FROM orders
WHERE status = 'completed'
  AND notified = false
ORDER BY created_at ASC
LIMIT 10;

UPDATE orders SET notified = true WHERE id = {{ $json.id }};

const baseUrl = 'https://api.example.com/records';
const perPage = 100;
let page = 1;
let allRecords = [];
let hasMore = true;

while (hasMore) {
  const response = await fetch(`${baseUrl}?page=${page}&per_page=${perPage}`, {
    headers: { 'Authorization': 'Bearer YOUR_TOKEN' }
  });
  const data = await response.json();
  allRecords = allRecords.concat(data.results);
  hasMore = data.results.length === perPage;
  page++;
}

return allRecords.map(record => ({ json: record }));

const remaining = parseInt($input.first().json.headers['x-ratelimit-remaining']);
if (remaining < 5) {
  return [{ json: { ...$input.first().json, shouldWait: true, waitMs: 60000 } }];
}
return $input.all();