@adityanair98/api-oracle 0.5.0

package/src/entries/email/resend.json

@@ -0,0 +1,89 @@
+{
+  "name": "Resend",
+  "slug": "resend",
+  "category": "email",
+  "subcategory": "transactional-email",
+  "website": "https://resend.com",
+  "description": "Resend is a developer-first email API built for modern applications. It offers a clean REST API, first-class TypeScript SDK, and native React Email integration — making it the fastest way to ship beautiful transactional emails.",
+  "useCases": [
+    {
+      "task": "Send transactional emails with dynamic templates",
+      "fit": "perfect"
+    },
+    {
+      "task": "Send password reset and account verification emails",
+      "fit": "perfect"
+    },
+    {
+      "task": "Send welcome and onboarding emails",
+      "fit": "perfect"
+    },
+    {
+      "task": "Send bulk marketing email campaigns",
+      "fit": "partial"
+    }
+  ],
+  "auth": {
+    "method": "api_key",
+    "setupSteps": [
+      "Sign up at resend.com",
+      "Navigate to API Keys in the dashboard",
+      "Click 'Create API Key' and give it a name",
+      "Add and verify your sending domain under Domains (or use onboarding@resend.dev for testing)",
+      "Copy the API key and set it as the RESEND_API_KEY environment variable"
+    ],
+    "envVarName": "RESEND_API_KEY",
+    "codeSnippet": "const resend = new Resend(process.env.RESEND_API_KEY);"
+  },
+  "pricing": {
+    "model": "freemium",
+    "freeTier": "3,000 emails/month, 1 custom domain",
+    "startingPrice": "$20/month for 50,000 emails",
+    "costPer": "$0.0004 per email above plan limit",
+    "pricingUrl": "https://resend.com/pricing"
+  },
+  "rateLimits": {
+    "tier": "free tier",
+    "limit": "10 emails/second, 3,000 emails/month",
+    "notes": "Paid plans have higher throughput. Rate limit headers are returned on every response.",
+    "retryStrategy": "Respect Retry-After header on 429 responses; use exponential backoff starting at 1s"
+  },
+  "sdk": {
+    "primaryLanguage": "typescript",
+    "installCommand": "npm install --save-exact resend",
+    "importStatement": "import { Resend } from 'resend';",
+    "otherLanguages": ["python", "ruby", "go", "php", "elixir", "rust"]
+  },
+  "codeExamples": [
+    {
+      "title": "Send a basic transactional email",
+      "language": "typescript",
+      "code": "import { Resend } from 'resend';\n\nconst resend = new Resend(process.env.RESEND_API_KEY);\n\nconst { data, error } = await resend.emails.send({\n  from: 'Acme <noreply@acme.com>',\n  to: ['user@example.com'],\n  subject: 'Your order has shipped!',\n  html: '<h1>Your order is on the way</h1><p>Track it at <a href=\"https://acme.com/track\">acme.com/track</a></p>',\n});\n\nif (error) {\n  throw new Error(`Failed to send email: ${error.message}`);\n}\n\nconsole.log('Email sent, id:', data?.id);",
+      "notes": "The 'from' address must use a verified domain. For testing without domain verification, use 'onboarding@resend.dev' as the from address."
+    },
+    {
+      "title": "Send with React Email component",
+      "language": "typescript",
+      "code": "import { Resend } from 'resend';\nimport { WelcomeEmail } from './emails/WelcomeEmail';\n\nconst resend = new Resend(process.env.RESEND_API_KEY);\n\nconst { data, error } = await resend.emails.send({\n  from: 'Acme <noreply@acme.com>',\n  to: ['user@example.com'],\n  subject: 'Welcome to Acme!',\n  react: <WelcomeEmail username=\"Jane\" verifyUrl=\"https://acme.com/verify/abc123\" />,\n});\n\nif (error) throw new Error(error.message);\nconsole.log('Sent:', data?.id);",
+      "notes": "Requires @react-email/components and react as peer dependencies. Run: npm install --save-exact @react-email/components react"
+    }
+  ],
+  "gotchas": [
+    "The 'from' address must use a verified domain — you cannot send from gmail.com or other shared domains. Use 'onboarding@resend.dev' only for initial testing, not in production.",
+    "Free tier is limited to 1 custom domain. If you need to send from multiple domains (e.g., different brands or staging vs. production), you must upgrade to a paid plan.",
+    "Resend is optimized for transactional email — bulk marketing campaigns to cold lists are against their terms of service and may result in account suspension."
+  ],
+  "reliability": {
+    "uptimeGuarantee": "99.99% SLA on paid plans",
+    "statusPageUrl": "https://status.resend.com",
+    "notes": "Resend routes through multiple delivery providers. Average delivery time is under 5 seconds. Bounce and complaint handling is automatic."
+  },
+  "qualityScore": 9,
+  "qualityJustification": "Best-in-class developer experience with the cleanest API in the email space. First-class TypeScript, excellent React Email integration, honest pricing, and fast onboarding. Slight deduction for limited free tier domain count and no bulk email support.",
+  "alternatives": ["sendgrid", "postmark", "mailgun"],
+  "complementary": ["clerk", "stripe"],
+  "bestFor": "Developer-first transactional email with React Email templates and minimal setup",
+  "lastVerified": "2026-02-25",
+  "entryVersion": 1,
+  "addedBy": "claude-code-session-1"
+}

package/src/entries/email/sendgrid.json

@@ -0,0 +1,90 @@
+{
+  "name": "SendGrid",
+  "slug": "sendgrid",
+  "category": "email",
+  "subcategory": "transactional-email",
+  "website": "https://sendgrid.com",
+  "description": "SendGrid (by Twilio) is an enterprise-grade cloud email platform supporting both transactional and marketing email at massive scale. It is the industry standard for high-volume senders, with deep analytics, deliverability tools, and a comprehensive REST API.",
+  "useCases": [
+    {
+      "task": "Send high-volume transactional emails at enterprise scale",
+      "fit": "perfect"
+    },
+    {
+      "task": "Send marketing campaigns to large email lists",
+      "fit": "perfect"
+    },
+    {
+      "task": "Send password reset and verification emails",
+      "fit": "good"
+    },
+    {
+      "task": "Manage email templates with dynamic content",
+      "fit": "good"
+    }
+  ],
+  "auth": {
+    "method": "api_key",
+    "setupSteps": [
+      "Sign up at sendgrid.com (or use your Twilio account)",
+      "Go to Settings > API Keys",
+      "Create a new API key with 'Full Access' or scoped permissions",
+      "Verify your sender identity under Settings > Sender Authentication",
+      "Set SENDGRID_API_KEY environment variable"
+    ],
+    "envVarName": "SENDGRID_API_KEY",
+    "codeSnippet": "const sgMail = require('@sendgrid/mail');\nsgMail.setApiKey(process.env.SENDGRID_API_KEY);"
+  },
+  "pricing": {
+    "model": "freemium",
+    "freeTier": "100 emails/day forever (shared IP)",
+    "startingPrice": "$19.95/month for 50,000 emails",
+    "costPer": "Varies by plan; Essentials plan ~$0.0004/email",
+    "pricingUrl": "https://sendgrid.com/pricing"
+  },
+  "rateLimits": {
+    "tier": "free tier",
+    "limit": "100 emails/day, 600 requests/minute on API",
+    "notes": "Free tier uses shared IP pool which can affect deliverability. Dedicated IPs available on Pro plans at extra cost.",
+    "retryStrategy": "Implement exponential backoff for 429 and 503 responses; SendGrid recommends retry with jitter"
+  },
+  "sdk": {
+    "primaryLanguage": "typescript",
+    "installCommand": "npm install --save-exact @sendgrid/mail",
+    "importStatement": "import sgMail from '@sendgrid/mail';",
+    "otherLanguages": ["python", "ruby", "java", "go", "php", "csharp"]
+  },
+  "codeExamples": [
+    {
+      "title": "Send a basic email",
+      "language": "typescript",
+      "code": "import sgMail from '@sendgrid/mail';\n\nsgMail.setApiKey(process.env.SENDGRID_API_KEY!);\n\ntry {\n  await sgMail.send({\n    to: 'user@example.com',\n    from: 'noreply@yourdomain.com', // Must be verified\n    subject: 'Your order confirmation',\n    text: 'Thank you for your order!',\n    html: '<p>Thank you for your order!</p>',\n  });\n  console.log('Email sent successfully');\n} catch (error) {\n  console.error('SendGrid error:', error);\n  throw error;\n}",
+      "notes": "The 'from' address must be a verified sender. Set up Sender Authentication in the dashboard before sending."
+    },
+    {
+      "title": "Send with a dynamic template",
+      "language": "typescript",
+      "code": "import sgMail from '@sendgrid/mail';\n\nsgMail.setApiKey(process.env.SENDGRID_API_KEY!);\n\nawait sgMail.send({\n  to: 'user@example.com',\n  from: 'noreply@yourdomain.com',\n  templateId: 'd-your-template-id-here',\n  dynamicTemplateData: {\n    username: 'Jane',\n    resetUrl: 'https://app.com/reset/abc123',\n    expiresIn: '1 hour',\n  },\n});",
+      "notes": "Create templates in the SendGrid dashboard under Email API > Dynamic Templates. Template IDs start with 'd-'."
+    }
+  ],
+  "gotchas": [
+    "Free tier (100 emails/day) uses a shared IP pool — deliverability is lower than paid tiers with dedicated IPs. Expect higher spam rates on shared IPs.",
+    "Sender authentication (domain authentication via DNS records) is required for good deliverability. Setting up SPF, DKIM, and DMARC records is mandatory for production.",
+    "The @sendgrid/mail SDK uses CommonJS require() internally, which can cause issues in pure ESM projects. Use dynamic import or configure your bundler accordingly.",
+    "SendGrid's free tier is being deprecated and replaced by Twilio's free trial — check current free tier limits as they may have changed."
+  ],
+  "reliability": {
+    "uptimeGuarantee": "99.95% SLA on Pro and Premier plans",
+    "statusPageUrl": "https://status.sendgrid.com",
+    "notes": "SendGrid is battle-tested at multi-billion email/month scale. Global infrastructure with multiple data centers."
+  },
+  "qualityScore": 7,
+  "qualityJustification": "Industry standard with unmatched scale and ecosystem, but the API and SDK feel dated compared to newer alternatives. The free tier limit (100/day) is very low, setup complexity is higher, and the Twilio acquisition has introduced some organizational complexity. Still the best choice for enterprise scale.",
+  "alternatives": ["resend", "postmark", "mailgun"],
+  "complementary": ["stripe", "twilio"],
+  "bestFor": "High-volume transactional and marketing email at enterprise scale with deep analytics",
+  "lastVerified": "2026-02-25",
+  "entryVersion": 1,
+  "addedBy": "claude-code-session-1"
+}

package/src/entries/forms/formspark.json

@@ -0,0 +1,85 @@
+{
+  "name": "Formspark",
+  "slug": "formspark",
+  "category": "forms",
+  "subcategory": "form-backend",
+  "website": "https://formspark.io",
+  "description": "Formspark is a form backend service — point your HTML form action to a Formspark endpoint and submissions are collected, spam-filtered, and forwarded to your email or webhook. No server-side code required. Ideal for static sites and JAMstack apps that need form submission handling without building a backend.",
+  "useCases": [
+    {
+      "task": "Add a contact form to a static site without a backend",
+      "fit": "perfect"
+    },
+    {
+      "task": "Collect form submissions and receive email notifications",
+      "fit": "perfect"
+    },
+    {
+      "task": "Set up form-to-webhook integration for automation",
+      "fit": "good"
+    }
+  ],
+  "auth": {
+    "method": "api_key",
+    "setupSteps": [
+      "Create a Formspark account at formspark.io",
+      "Click 'Create a form' in the dashboard and give it a name",
+      "Copy the Form ID shown in the dashboard (e.g., abc12345)",
+      "Use the Form ID in your form action URL: https://submit.formspark.io/f/{FORM_ID}",
+      "Set FORMSPARK_FORM_ID environment variable with the copied Form ID"
+    ],
+    "envVarName": "FORMSPARK_FORM_ID",
+    "codeSnippet": "const response = await fetch(`https://submit.formspark.io/f/${process.env.FORMSPARK_FORM_ID}`, {\n  method: 'POST',\n  headers: {\n    'Content-Type': 'application/json',\n    Accept: 'application/json',\n  },\n  body: JSON.stringify({\n    email: 'user@example.com',\n    message: 'Hello from my app!',\n  }),\n});\n\nif (!response.ok) {\n  throw new Error(`Formspark submission failed: ${response.status}`);\n}\n\nconsole.log('Form submitted successfully');"
+  },
+  "pricing": {
+    "model": "freemium",
+    "freeTier": "Free: 250 submissions/month for lifetime",
+    "startingPrice": "$9/month (Solo) for 3,000 submissions/month, 5 forms, custom domain",
+    "costPer": null,
+    "pricingUrl": "https://formspark.io/#pricing"
+  },
+  "rateLimits": {
+    "tier": "free tier",
+    "limit": "250 submissions/month, no per-second rate limit documented",
+    "notes": "Formspark applies spam filtering using hCaptcha and honeypot fields. Custom spam rules available on paid plans. Email notifications sent per-submission on all plans.",
+    "retryStrategy": "Submit forms once and handle user feedback on success/error. Use the JSON API for custom error handling in JavaScript-submitted forms."
+  },
+  "sdk": {
+    "primaryLanguage": "typescript",
+    "installCommand": "npm install --save-exact @formspark/use-formspark",
+    "importStatement": "import { useFormspark } from '@formspark/use-formspark';",
+    "otherLanguages": ["javascript"]
+  },
+  "codeExamples": [
+    {
+      "title": "Simple HTML form submission",
+      "language": "typescript",
+      "code": "import React, { FormEvent, useState } from 'react';\n\nconst FORMSPARK_FORM_ID = process.env.NEXT_PUBLIC_FORMSPARK_FORM_ID!;\n\ninterface ContactFormData {\n  name: string;\n  email: string;\n  message: string;\n}\n\nexport function ContactForm(): JSX.Element {\n  const [formData, setFormData] = useState<ContactFormData>({\n    name: '',\n    email: '',\n    message: '',\n  });\n  const [status, setStatus] = useState<'idle' | 'submitting' | 'success' | 'error'>('idle');\n\n  const handleSubmit = async (e: FormEvent<HTMLFormElement>): Promise<void> => {\n    e.preventDefault();\n    setStatus('submitting');\n\n    try {\n      const response = await fetch(\n        `https://submit.formspark.io/f/${FORMSPARK_FORM_ID}`,\n        {\n          method: 'POST',\n          headers: {\n            'Content-Type': 'application/json',\n            Accept: 'application/json',\n          },\n          body: JSON.stringify(formData),\n        }\n      );\n\n      if (!response.ok) {\n        throw new Error(`Submission failed with status: ${response.status}`);\n      }\n\n      setStatus('success');\n      setFormData({ name: '', email: '', message: '' });\n    } catch (err) {\n      console.error('Form submission error:', err);\n      setStatus('error');\n    }\n  };\n\n  return (\n    <form onSubmit={handleSubmit}>\n      <input\n        type=\"text\"\n        placeholder=\"Your name\"\n        value={formData.name}\n        onChange={(e) => setFormData((prev) => ({ ...prev, name: e.target.value }))}\n        required\n      />\n      <input\n        type=\"email\"\n        placeholder=\"Your email\"\n        value={formData.email}\n        onChange={(e) => setFormData((prev) => ({ ...prev, email: e.target.value }))}\n        required\n      />\n      <textarea\n        placeholder=\"Your message\"\n        value={formData.message}\n        onChange={(e) => setFormData((prev) => ({ ...prev, message: e.target.value }))}\n        required\n      />\n      <button type=\"submit\" disabled={status === 'submitting'}>\n        {status === 'submitting' ? 'Sending...' : 'Send Message'}\n      </button>\n      {status === 'success' && <p>Message sent successfully!</p>}\n      {status === 'error' && <p>Something went wrong. Please try again.</p>}\n    </form>\n  );\n}",
+      "notes": "Use NEXT_PUBLIC_ prefix for the form ID in Next.js so it's available client-side. The Formspark JSON API accepts any key-value pairs — all submitted fields appear in the notification email and dashboard."
+    },
+    {
+      "title": "React hook for Formspark submission",
+      "language": "typescript",
+      "code": "import React, { FormEvent } from 'react';\nimport { useFormspark } from '@formspark/use-formspark';\n\nconst FORMSPARK_FORM_ID = process.env.NEXT_PUBLIC_FORMSPARK_FORM_ID!;\n\ninterface NewsletterFormData {\n  email: string;\n  firstName?: string;\n}\n\nexport function NewsletterSignup(): JSX.Element {\n  const [submit, submitting] = useFormspark({\n    formId: FORMSPARK_FORM_ID,\n  });\n\n  const [email, setEmail] = React.useState('');\n  const [firstName, setFirstName] = React.useState('');\n  const [done, setDone] = React.useState(false);\n\n  const handleSubmit = async (e: FormEvent<HTMLFormElement>): Promise<void> => {\n    e.preventDefault();\n\n    const data: NewsletterFormData = { email };\n    if (firstName) data.firstName = firstName;\n\n    await submit(data);\n    setDone(true);\n    setEmail('');\n    setFirstName('');\n  };\n\n  if (done) {\n    return <p>Thanks for subscribing!</p>;\n  }\n\n  return (\n    <form onSubmit={handleSubmit}>\n      <input\n        type=\"text\"\n        placeholder=\"First name (optional)\"\n        value={firstName}\n        onChange={(e) => setFirstName(e.target.value)}\n      />\n      <input\n        type=\"email\"\n        placeholder=\"Email address\"\n        value={email}\n        onChange={(e) => setEmail(e.target.value)}\n        required\n      />\n      {/* Honeypot field to catch bots — must remain hidden */}\n      <input type=\"text\" name=\"_honeypot\" style={{ display: 'none' }} />\n      <button type=\"submit\" disabled={submitting}>\n        {submitting ? 'Subscribing...' : 'Subscribe'}\n      </button>\n    </form>\n  );\n}",
+      "notes": "The useFormspark hook from @formspark/use-formspark handles loading state automatically. The `submitting` boolean is true while the request is in-flight. Adding a hidden `_honeypot` input field helps filter bot submissions."
+    }
+  ],
+  "gotchas": [
+    "Formspark's free tier is 250 submissions PER MONTH total across all forms. A popular contact form can exhaust this in days. Plan your pricing tier before going to production.",
+    "File upload fields are NOT supported by Formspark. If your form includes file attachments, you need to handle file uploads separately (to Cloudinary or S3) and submit only the URL via Formspark.",
+    "Formspark sends email notifications per submission — with a busy form receiving 100 submissions/day, that's 100 emails. Set up a webhook to a service like Zapier or n8n to filter and batch notifications instead."
+  ],
+  "reliability": {
+    "uptimeGuarantee": null,
+    "statusPageUrl": "https://status.formspark.io",
+    "notes": "AWS-backed infrastructure. No published SLA. Suitable for contact forms and lead capture but not for mission-critical data collection pipelines."
+  },
+  "qualityScore": 7,
+  "qualityJustification": "Best-in-class for simple form backends — minimal setup, reliable delivery, spam filtering included. The lifetime free tier (250 submissions/month) is rare and genuinely useful. File uploads and lack of SLA are the main limitations.",
+  "alternatives": ["typeform"],
+  "complementary": ["vercel", "netlify", "resend"],
+  "bestFor": "Adding form submission handling to static sites and JAMstack apps without any server-side code — contact forms, lead capture, feedback collection",
+  "lastVerified": "2026-02-25",
+  "entryVersion": 1,
+  "addedBy": "claude-code-session-4"
+}

package/src/entries/forms/typeform.json

@@ -0,0 +1,98 @@
+{
+  "name": "Typeform",
+  "slug": "typeform",
+  "category": "forms",
+  "subcategory": "conversational-forms",
+  "website": "https://developer.typeform.com",
+  "description": "Typeform provides conversational, one-question-at-a-time forms with high completion rates. The Typeform API allows developers to create forms programmatically, retrieve responses, and set up webhooks for real-time form submission handling. Used for surveys, lead capture, onboarding questionnaires, and feedback collection.",
+  "useCases": [
+    {
+      "task": "Embed a conversational survey or questionnaire into an app",
+      "fit": "perfect"
+    },
+    {
+      "task": "Retrieve form responses programmatically for analysis",
+      "fit": "perfect"
+    },
+    {
+      "task": "Trigger actions on form submission via webhook",
+      "fit": "good"
+    },
+    {
+      "task": "Create forms programmatically with the Typeform API",
+      "fit": "good"
+    }
+  ],
+  "auth": {
+    "method": "api_key",
+    "setupSteps": [
+      "Create a Typeform account at typeform.com",
+      "Click your profile avatar in the top-right corner",
+      "Go to Profile \u2192 Personal tokens",
+      "Click 'Generate a new token', give it a name, and copy the token",
+      "Set TYPEFORM_API_TOKEN environment variable with the copied token"
+    ],
+    "envVarName": "TYPEFORM_API_TOKEN",
+    "codeSnippet": "const response = await fetch('https://api.typeform.com/me', {\n  headers: {\n    Authorization: `Bearer ${process.env.TYPEFORM_API_TOKEN}`,\n  },\n});\nconst data = await response.json();\nconsole.log('Typeform user:', data);"
+  },
+  "pricing": {
+    "model": "freemium",
+    "freeTier": "Free: 10 questions/form, 10 responses/month, basic logic",
+    "startingPrice": "$25/month (Basic) for unlimited responses and questions, 1 user",
+    "costPer": null,
+    "pricingUrl": "https://www.typeform.com/pricing/"
+  },
+  "rateLimits": {
+    "tier": "free tier",
+    "limit": "REST API: 5 requests/second; Responses API: 1,000 items per page max",
+    "notes": "Webhooks deliver responses in near-real-time (usually <10 seconds). The Responses API uses cursor-based pagination for large result sets. Typeform rate limits are per-user, not per-form.",
+    "retryStrategy": "Implement retry on 429 responses. Typeform webhooks include a checksum header for verification \u2014 always validate before processing."
+  },
+  "sdk": {
+    "primaryLanguage": "typescript",
+    "installCommand": "npm install --save-exact @typeform/api-client",
+    "importStatement": "import { createClient } from '@typeform/api-client';",
+    "otherLanguages": [
+      "javascript",
+      "python"
+    ]
+  },
+  "codeExamples": [
+    {
+      "title": "Retrieve form responses",
+      "language": "typescript",
+      "code": "import { createClient } from '@typeform/api-client';\n\nconst typeformClient = createClient({\n  token: process.env.TYPEFORM_API_TOKEN!,\n});\n\nconst FORM_ID = 'your-form-id';\n\ninterface TypeformResponse {\n  response_id: string;\n  submitted_at: string;\n  answers: Array<{\n    field: { id: string; type: string };\n    type: string;\n    text?: string;\n    choice?: { label: string };\n    number?: number;\n  }>;\n}\n\nasync function getFormResponses(): Promise<void> {\n  const result = await typeformClient.responses.list({\n    uid: FORM_ID,\n    pageSize: 100,\n    sort: 'submitted_at,desc',\n  });\n\n  console.log(`Total responses: ${result.total_items}`);\n\n  for (const response of result.items as TypeformResponse[]) {\n    console.log(`Response ID: ${response.response_id}`);\n    console.log(`Submitted at: ${response.submitted_at}`);\n\n    for (const answer of response.answers) {\n      const value = answer.text ?? answer.choice?.label ?? answer.number ?? 'N/A';\n      console.log(`  Field ${answer.field.id} (${answer.type}): ${value}`);\n    }\n  }\n}\n\ngetFormResponses().catch(console.error);",
+      "notes": "The @typeform/api-client wraps the REST API. Use the `pageSize` and `before` cursor parameters for paginating through large response sets. The `sort` parameter supports field,direction syntax."
+    },
+    {
+      "title": "Handle Typeform webhook submission",
+      "language": "typescript",
+      "code": "import express, { Request, Response } from 'express';\nimport crypto from 'crypto';\n\nconst app = express();\n\n// Use raw body parser to allow signature verification\napp.use(\n  '/webhooks/typeform',\n  express.raw({ type: 'application/json' })\n);\n\ninterface TypeformWebhookPayload {\n  form_response: {\n    form_id: string;\n    token: string;\n    submitted_at: string;\n    answers: Array<{\n      field: { id: string; ref: string; type: string };\n      type: string;\n      text?: string;\n      email?: string;\n      choice?: { label: string };\n    }>;\n  };\n}\n\nfunction verifyTypeformSignature(\n  rawBody: Buffer,\n  signatureHeader: string,\n  secret: string\n): boolean {\n  const hmac = crypto.createHmac('sha256', secret);\n  hmac.update(rawBody);\n  const digest = `sha256=${hmac.digest('base64')}`;\n  return crypto.timingSafeEqual(\n    Buffer.from(digest),\n    Buffer.from(signatureHeader)\n  );\n}\n\napp.post('/webhooks/typeform', (req: Request, res: Response): void => {\n  const signature = req.headers['typeform-signature'] as string;\n  const webhookSecret = process.env.TYPEFORM_WEBHOOK_SECRET!;\n\n  if (!signature || !verifyTypeformSignature(req.body as Buffer, signature, webhookSecret)) {\n    res.status(401).json({ error: 'Invalid signature' });\n    return;\n  }\n\n  // Return 200 immediately before processing\n  res.status(200).json({ received: true });\n\n  const payload = JSON.parse((req.body as Buffer).toString()) as TypeformWebhookPayload;\n  const { form_response } = payload;\n\n  console.log(`Form submission received for form: ${form_response.form_id}`);\n  console.log(`Submission token: ${form_response.token}`);\n  console.log(`Submitted at: ${form_response.submitted_at}`);\n\n  for (const answer of form_response.answers) {\n    const value = answer.text ?? answer.email ?? answer.choice?.label ?? 'N/A';\n    console.log(`  [${answer.field.ref}]: ${value}`);\n  }\n});\n\napp.listen(3000, () => console.log('Webhook server running on port 3000'));",
+      "notes": "Always return 200 immediately after signature verification to prevent Typeform from retrying. Process the payload asynchronously. The TYPEFORM_WEBHOOK_SECRET is set in the Typeform dashboard when creating the webhook. Use express.raw() (not express.json()) to preserve the raw body for HMAC verification."
+    }
+  ],
+  "gotchas": [
+    "Typeform's free plan limits responses to 10/month per form \u2014 this is a hard limit. Once exceeded, respondents see an error. For production forms with any real traffic, the free tier is insufficient.",
+    "The embedded Typeform widget loads a full JavaScript bundle (~500KB) from typeform.com servers. This significantly impacts page load performance. Use the @typeform/embed-react package with lazy loading, or consider a native form library for performance-critical pages.",
+    "Typeform webhook payloads are NOT retried indefinitely \u2014 if your endpoint returns an error, Typeform retries a limited number of times before giving up. Use a queue (like Inngest or Trigger.dev) to process webhook events asynchronously and return 200 immediately.",
+    "Logic jumps and Hidden Fields in Typeform are configured in the form builder UI, NOT in the API. You cannot programmatically add conditional logic when creating a form via API \u2014 the logic must be added in the Typeform interface after creation."
+  ],
+  "reliability": {
+    "uptimeGuarantee": "99.9% uptime SLA (Business+)",
+    "statusPageUrl": "https://status.typeform.com",
+    "notes": "Globally distributed infrastructure. Webhook delivery is near-real-time but not guaranteed \u2014 implement idempotency keys for critical workflows."
+  },
+  "qualityScore": 7,
+  "qualityJustification": "Highest form completion rates in the industry due to the conversational one-question format. Strong API for retrieving responses. Main friction: the 10-response free tier is impractical for testing, the embed bundle is heavy, and the API for creating forms with logic is limited.",
+  "alternatives": [
+    "formspark"
+  ],
+  "complementary": [
+    "resend",
+    "supabase"
+  ],
+  "bestFor": "Conversational surveys and forms where completion rate is the priority \u2014 lead capture, NPS surveys, onboarding questionnaires",
+  "lastVerified": "2026-02-25",
+  "entryVersion": 1,
+  "addedBy": "claude-code-session-4"
+}

package/src/entries/infrastructure/aws-s3.json

@@ -0,0 +1,104 @@
+{
+  "name": "AWS S3",
+  "slug": "aws-s3",
+  "category": "infrastructure",
+  "subcategory": "object-storage",
+  "website": "https://aws.amazon.com/s3/",
+  "description": "AWS S3 is the industry-standard object storage service \u2014 massively durable (11 nines), infinitely scalable, and the API that every competing storage service has adopted as the universal interface.",
+  "useCases": [
+    {
+      "task": "Store and serve files, images, and documents at scale",
+      "fit": "perfect"
+    },
+    {
+      "task": "Host static website assets with CDN",
+      "fit": "perfect"
+    },
+    {
+      "task": "Store application backups and logs",
+      "fit": "perfect"
+    },
+    {
+      "task": "Store large media files for video streaming pipeline",
+      "fit": "good"
+    }
+  ],
+  "auth": {
+    "method": "api_key",
+    "setupSteps": [
+      "Create an AWS account at aws.amazon.com",
+      "Go to IAM \u2192 Users \u2192 Create user",
+      "Attach a policy with S3 permissions (e.g. AmazonS3FullAccess or a custom policy)",
+      "Go to the user's Security credentials tab \u2192 Create access key",
+      "Copy the Access Key ID and Secret Access Key",
+      "Set AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, and AWS_REGION environment variables"
+    ],
+    "envVarName": "AWS_ACCESS_KEY_ID",
+    "codeSnippet": "import { S3Client } from '@aws-sdk/client-s3';\n\nconst s3 = new S3Client({\n  region: process.env.AWS_REGION!,\n  credentials: {\n    accessKeyId: process.env.AWS_ACCESS_KEY_ID!,\n    secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY!,\n  },\n});"
+  },
+  "pricing": {
+    "model": "usage_based",
+    "freeTier": "12 months free: 5GB standard storage, 20K GET requests, 2K PUT requests (new AWS accounts only)",
+    "startingPrice": "$0.023/GB-month (S3 Standard, us-east-1)",
+    "costPer": "$0.023/GB-month storage, $0.0004/1K PUT requests, $0.0004/1K GET requests, $0.09/GB data transfer out",
+    "pricingUrl": "https://aws.amazon.com/s3/pricing/"
+  },
+  "rateLimits": {
+    "tier": "no hard limits",
+    "limit": "3,500 PUT/COPY/POST/DELETE requests/second per prefix, 5,500 GET/HEAD requests/second per prefix (auto-scaling with request patterns)",
+    "notes": "S3 automatically scales request rate based on traffic patterns. Rate limits apply per key prefix, so distributing objects across multiple prefixes multiplies throughput linearly.",
+    "retryStrategy": "AWS SDK has built-in exponential backoff retry. For high throughput, use multiple key prefixes to distribute load across partitions."
+  },
+  "sdk": {
+    "primaryLanguage": "typescript",
+    "installCommand": "npm install --save-exact @aws-sdk/client-s3 @aws-sdk/s3-request-presigner",
+    "importStatement": "import { S3Client, PutObjectCommand, GetObjectCommand } from '@aws-sdk/client-s3';",
+    "otherLanguages": [
+      "python",
+      "java",
+      "go",
+      "ruby",
+      "php"
+    ]
+  },
+  "codeExamples": [
+    {
+      "title": "Upload a file to S3",
+      "language": "typescript",
+      "code": "import { S3Client, PutObjectCommand } from '@aws-sdk/client-s3';\n\nconst s3 = new S3Client({\n  region: process.env.AWS_REGION!,\n  credentials: {\n    accessKeyId: process.env.AWS_ACCESS_KEY_ID!,\n    secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY!,\n  },\n});\n\nasync function uploadFile(\n  bucketName: string,\n  key: string,\n  body: Buffer | string,\n  contentType: string\n): Promise<string> {\n  const command = new PutObjectCommand({\n    Bucket: bucketName,\n    Key: key,\n    Body: body,\n    ContentType: contentType,\n  });\n\n  await s3.send(command);\n\n  return `https://${bucketName}.s3.${process.env.AWS_REGION}.amazonaws.com/${key}`;\n}\n\n// Usage\nconst url = await uploadFile(\n  'my-app-bucket',\n  'uploads/profile-picture.jpg',\n  imageBuffer,\n  'image/jpeg'\n);\nconsole.log('Uploaded to:', url);",
+      "notes": "The Key is the full object path within the bucket. ContentType should always be set \u2014 browsers use it to decide how to handle the file. Objects are private by default; use PutObjectAcl or a bucket policy to make them public."
+    },
+    {
+      "title": "Generate a presigned URL for temporary access",
+      "language": "typescript",
+      "code": "import { S3Client, GetObjectCommand } from '@aws-sdk/client-s3';\nimport { getSignedUrl } from '@aws-sdk/s3-request-presigner';\n\nconst s3 = new S3Client({\n  region: process.env.AWS_REGION!,\n  credentials: {\n    accessKeyId: process.env.AWS_ACCESS_KEY_ID!,\n    secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY!,\n  },\n});\n\nasync function getPresignedDownloadUrl(\n  bucketName: string,\n  key: string,\n  expiresInSeconds: number = 3600\n): Promise<string> {\n  const command = new GetObjectCommand({\n    Bucket: bucketName,\n    Key: key,\n  });\n\n  const signedUrl = await getSignedUrl(s3, command, {\n    expiresIn: expiresInSeconds,\n  });\n\n  return signedUrl;\n}\n\n// Usage: generate a URL valid for 1 hour\nconst downloadUrl = await getPresignedDownloadUrl(\n  'my-app-bucket',\n  'uploads/invoice-2024.pdf',\n  3600\n);\nconsole.log('Temporary URL (expires in 1 hour):', downloadUrl);",
+      "notes": "Presigned URLs allow temporary, authenticated access to private objects without exposing credentials. expiresIn is in seconds; max is 7 days (604800). Use presigned PUT URLs to allow direct browser-to-S3 uploads without routing through your server."
+    }
+  ],
+  "gotchas": [
+    "S3 objects are private by default. To make them publicly accessible you must either set a bucket policy or generate presigned URLs. 'Making a bucket public' is an account-level setting you must explicitly enable \u2014 Block Public Access is on by default and must be turned off at both the account and bucket level before a bucket policy can grant public access.",
+    "Egress (data transfer OUT from S3 to the internet) costs $0.09/GB. For apps serving many large files, this adds up quickly. Use CloudFront CDN in front of S3 to reduce egress costs, or migrate to Cloudflare R2 (zero egress fees) for high-traffic files.",
+    "S3 eventual consistency was a historical gotcha, but since December 2020, S3 offers strong read-after-write consistency for all operations. However, S3 is still NOT a database \u2014 don't use it for frequently-updated objects that require atomic operations.",
+    "IAM permissions are complex. A common mistake is giving s3:* to an IAM user \u2014 instead, scope permissions tightly: s3:PutObject and s3:GetObject on specific bucket ARNs. Never use root account credentials in application code."
+  ],
+  "reliability": {
+    "uptimeGuarantee": "99.999999999% (11 nines) durability, 99.99% availability SLA for S3 Standard",
+    "statusPageUrl": "https://status.aws.amazon.com",
+    "notes": "Data is replicated across a minimum of 3 Availability Zones within the selected AWS region. S3 Standard-IA, Glacier, and other storage classes have different durability and availability SLAs."
+  },
+  "qualityScore": 9,
+  "qualityJustification": "The industry standard for object storage. 11-nines durability, massive ecosystem support, and the S3 API is the universal interface adopted by all competitors. Egress costs and IAM complexity are the main friction points, but nothing comes close for reliability and ecosystem breadth.",
+  "alternatives": [
+    "cloudflare-r2",
+    "digital-ocean-spaces",
+    "cloudinary"
+  ],
+  "complementary": [
+    "cloudflare-workers",
+    "vercel"
+  ],
+  "bestFor": "Storing any type of file at scale \u2014 from user uploads to application backups \u2014 with the most widely supported API in cloud infrastructure",
+  "lastVerified": "2026-02-25",
+  "entryVersion": 1,
+  "addedBy": "claude-code-session-4"
+}

package/src/entries/infrastructure/cloudflare-r2.json

@@ -0,0 +1,92 @@
+{
+  "name": "Cloudflare R2",
+  "slug": "cloudflare-r2",
+  "category": "infrastructure",
+  "subcategory": "object-storage",
+  "website": "https://cloudflare.com/products/r2/",
+  "description": "Cloudflare R2 is S3-compatible object storage with zero egress fees, making it the ideal replacement for AWS S3 when serving files to end users where data transfer costs are a concern.",
+  "useCases": [
+    {
+      "task": "Store and serve user-uploaded files without egress fees",
+      "fit": "perfect"
+    },
+    {
+      "task": "Replace AWS S3 for a high-traffic media storage use case",
+      "fit": "perfect"
+    },
+    {
+      "task": "Store static assets served via Cloudflare CDN",
+      "fit": "perfect"
+    },
+    {
+      "task": "Archive backups with low storage costs",
+      "fit": "good"
+    }
+  ],
+  "auth": {
+    "method": "api_key",
+    "setupSteps": [
+      "Log in to the Cloudflare dashboard at dash.cloudflare.com",
+      "Navigate to R2 Object Storage and create a bucket",
+      "Note your Account ID from the right sidebar",
+      "Go to R2 → Manage R2 API Tokens → Create API Token",
+      "Select Object Read & Write permissions for the desired bucket(s)",
+      "Copy the Access Key ID and Secret Access Key — the secret is shown only once",
+      "Set CLOUDFLARE_R2_ACCESS_KEY_ID, R2_SECRET_ACCESS_KEY, R2_ACCOUNT_ID, and R2_BUCKET_NAME environment variables"
+    ],
+    "envVarName": "CLOUDFLARE_R2_ACCESS_KEY_ID",
+    "codeSnippet": "import { S3Client } from '@aws-sdk/client-s3';\n\nconst r2 = new S3Client({\n  region: 'auto',\n  endpoint: `https://${process.env.R2_ACCOUNT_ID}.r2.cloudflarestorage.com`,\n  credentials: {\n    accessKeyId: process.env.CLOUDFLARE_R2_ACCESS_KEY_ID!,\n    secretAccessKey: process.env.R2_SECRET_ACCESS_KEY!,\n  },\n});"
+  },
+  "pricing": {
+    "model": "freemium",
+    "freeTier": "10GB storage/month, 1M Class A operations (writes), 10M Class B operations (reads) — all free forever",
+    "startingPrice": "$0.015/GB-month after free tier",
+    "costPer": "$0.015/GB-month storage, $4.50/million Class A ops, $0.36/million Class B ops. Egress: $0 always.",
+    "pricingUrl": "https://developers.cloudflare.com/r2/pricing/"
+  },
+  "rateLimits": {
+    "tier": "no published hard limits",
+    "limit": "Consistent with S3 performance. No egress rate limiting. Bound by account bandwidth limits.",
+    "notes": "R2 does not publish specific per-bucket request rate limits. Performance is generally consistent with S3. Contact Cloudflare enterprise support for guaranteed throughput requirements.",
+    "retryStrategy": "Use exponential backoff on 429/503 responses. R2 uses the same error codes as S3."
+  },
+  "sdk": {
+    "primaryLanguage": "typescript",
+    "installCommand": "npm install --save-exact @aws-sdk/client-s3",
+    "importStatement": "import { S3Client, PutObjectCommand, GetObjectCommand } from '@aws-sdk/client-s3';",
+    "otherLanguages": ["python", "go", "ruby", "java"]
+  },
+  "codeExamples": [
+    {
+      "title": "Upload to R2 using S3-compatible SDK",
+      "language": "typescript",
+      "code": "import { S3Client, PutObjectCommand } from '@aws-sdk/client-s3';\n\nconst r2 = new S3Client({\n  region: 'auto',\n  endpoint: `https://${process.env.R2_ACCOUNT_ID}.r2.cloudflarestorage.com`,\n  credentials: {\n    accessKeyId: process.env.CLOUDFLARE_R2_ACCESS_KEY_ID!,\n    secretAccessKey: process.env.R2_SECRET_ACCESS_KEY!,\n  },\n});\n\nasync function uploadToR2(\n  key: string,\n  body: Buffer | string,\n  contentType: string\n): Promise<void> {\n  const command = new PutObjectCommand({\n    Bucket: process.env.R2_BUCKET_NAME!,\n    Key: key,\n    Body: body,\n    ContentType: contentType,\n  });\n\n  await r2.send(command);\n  console.log(`Uploaded ${key} to R2 bucket ${process.env.R2_BUCKET_NAME}`);\n}\n\n// Usage\nawait uploadToR2(\n  'avatars/user-456.png',\n  imageBuffer,\n  'image/png'\n);",
+      "notes": "The only difference from AWS S3 is the endpoint URL and region: 'auto'. The rest of the SDK API is identical. You do NOT need the @aws-sdk/s3-request-presigner separately — it is already compatible with R2."
+    },
+    {
+      "title": "Generate presigned URL for R2 object",
+      "language": "typescript",
+      "code": "import { S3Client, GetObjectCommand } from '@aws-sdk/client-s3';\nimport { getSignedUrl } from '@aws-sdk/s3-request-presigner';\n\nconst r2 = new S3Client({\n  region: 'auto',\n  endpoint: `https://${process.env.R2_ACCOUNT_ID}.r2.cloudflarestorage.com`,\n  credentials: {\n    accessKeyId: process.env.CLOUDFLARE_R2_ACCESS_KEY_ID!,\n    secretAccessKey: process.env.R2_SECRET_ACCESS_KEY!,\n  },\n});\n\nasync function getR2PresignedUrl(\n  key: string,\n  expiresInSeconds: number = 3600\n): Promise<string> {\n  const command = new GetObjectCommand({\n    Bucket: process.env.R2_BUCKET_NAME!,\n    Key: key,\n  });\n\n  const signedUrl = await getSignedUrl(r2, command, {\n    expiresIn: expiresInSeconds,\n  });\n\n  return signedUrl;\n}\n\n// Usage: temporary download link valid for 15 minutes\nconst url = await getR2PresignedUrl('documents/report-q4.pdf', 900);\nconsole.log('Presigned R2 URL:', url);",
+      "notes": "Presigned URLs for R2 work identically to S3. The signed URL points to the R2 endpoint, not amazonaws.com. If the bucket is configured with a public custom domain, use that domain for public objects instead of presigned URLs."
+    }
+  ],
+  "gotchas": [
+    "R2 does NOT support all S3 features. Notably missing: S3 lifecycle policies with transition between storage classes, S3 Select, S3 Batch Operations, and Object Lock. Check the R2/S3 API compatibility matrix at developers.cloudflare.com before migrating from S3.",
+    "Public bucket access in R2 requires connecting the bucket to a Cloudflare domain (a custom domain or the r2.dev subdomain). Unlike S3, you cannot make individual objects public via ACLs — the entire bucket must be configured for public access via the dashboard.",
+    "R2 stores data in Cloudflare's infrastructure but does NOT support cross-region replication or S3-style Multi-Region Access Points. All data within a bucket is stored in a single Cloudflare datacenter location (though served globally via Cloudflare's CDN when using public access).",
+    "The R2 free tier (10GB) is per-account, not per-bucket. If you use R2 across multiple projects under the same Cloudflare account, they all share the same 10GB monthly free storage allocation."
+  ],
+  "reliability": {
+    "uptimeGuarantee": "Cloudflare does not publish a specific durability SLA for R2, but uses erasure coding across multiple datacenters",
+    "statusPageUrl": "https://www.cloudflarestatus.com",
+    "notes": "R2 is backed by Cloudflare's global network infrastructure. Erasure coding provides data durability. No explicit 11-nines durability guarantee unlike S3, but Cloudflare's infrastructure is generally considered highly reliable."
+  },
+  "qualityScore": 8,
+  "qualityJustification": "The zero egress fee model is genuinely transformative for apps that serve many files to users — can cut storage costs by 80%+ compared to S3 for read-heavy workloads. S3-compatible API means existing code works with minimal changes. Main limitation is missing advanced S3 features and the single-region storage model.",
+  "alternatives": ["aws-s3", "digital-ocean-spaces", "cloudinary"],
+  "complementary": ["cloudflare-workers", "vercel", "netlify"],
+  "bestFor": "Object storage for user-uploaded files and media when egress costs are a concern — zero egress fees make it dramatically cheaper than S3 for high-traffic files",
+  "lastVerified": "2026-02-25",
+  "entryVersion": 1,
+  "addedBy": "claude-code-session-4"
+}