@adityanair98/api-oracle 0.5.0

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

@@ -0,0 +1,92 @@
+{
+  "name": "Cloudflare Workers",
+  "slug": "cloudflare-workers",
+  "category": "infrastructure",
+  "subcategory": "edge-compute",
+  "website": "https://workers.cloudflare.com",
+  "description": "Cloudflare Workers is a serverless JavaScript/TypeScript platform that runs at the edge in 300+ global locations with sub-millisecond cold starts, powered by V8 isolates instead of containers.",
+  "useCases": [
+    {
+      "task": "Run TypeScript/JavaScript logic at the edge closest to users",
+      "fit": "perfect"
+    },
+    {
+      "task": "Build API middleware (auth, rate limiting, routing) at CDN level",
+      "fit": "perfect"
+    },
+    {
+      "task": "Transform responses before they reach the client",
+      "fit": "perfect"
+    },
+    {
+      "task": "Run lightweight background tasks triggered by Cloudflare queues",
+      "fit": "good"
+    }
+  ],
+  "auth": {
+    "method": "api_key",
+    "setupSteps": [
+      "Create a Cloudflare account at cloudflare.com",
+      "Navigate to Workers & Pages in the dashboard",
+      "Install the Wrangler CLI: npm install -g wrangler",
+      "Run wrangler login to authenticate via browser OAuth",
+      "Create a new Worker project: wrangler init my-worker",
+      "Deploy with wrangler deploy — no manual API token needed for CLI deployments",
+      "For CI/CD, create an API token at dash.cloudflare.com/profile/api-tokens with Workers Scripts Edit permission"
+    ],
+    "envVarName": "CLOUDFLARE_API_TOKEN",
+    "codeSnippet": "// Minimal Cloudflare Worker handler (TypeScript)\nexport default {\n  async fetch(request: Request, env: Env): Promise<Response> {\n    return new Response('Hello from the edge!', { status: 200 });\n  },\n};\n\n// Env interface — bindings declared in wrangler.toml\ninterface Env {\n  MY_KV: KVNamespace;\n  MY_BUCKET: R2Bucket;\n  MY_SECRET: string;\n}"
+  },
+  "pricing": {
+    "model": "freemium",
+    "freeTier": "100,000 requests/day, 10ms CPU time per request, unlimited Workers",
+    "startingPrice": "$5/month (Workers Paid) for 10M requests + 30M CPU milliseconds",
+    "costPer": "$0.50/million requests after 10M included, $0.02/million CPU-ms after 30M included",
+    "pricingUrl": "https://developers.cloudflare.com/workers/platform/pricing/"
+  },
+  "rateLimits": {
+    "tier": "free tier",
+    "limit": "100K req/day (free), 10ms CPU time/request (free). Paid: 10M req/month, 30s max CPU duration per request (Unbound Workers)",
+    "notes": "The 10ms CPU limit on the free plan is CPU execution time, not wall-clock time. I/O (fetch calls, KV reads) does not count toward this limit. Paid Workers Standard gets 30ms CPU; Unbound Workers can run up to 15 minutes.",
+    "retryStrategy": "Workers execute synchronously — implement circuit breakers in worker code. Use Durable Objects for stateful retry logic."
+  },
+  "sdk": {
+    "primaryLanguage": "typescript",
+    "installCommand": "npm install --save-exact wrangler @cloudflare/workers-types --save-dev",
+    "importStatement": "export default { async fetch(request: Request, env: Env): Promise<Response> {",
+    "otherLanguages": ["javascript", "rust", "python"]
+  },
+  "codeExamples": [
+    {
+      "title": "Basic Worker with routing",
+      "language": "typescript",
+      "code": "interface Env {\n  API_SECRET: string;\n}\n\nfunction jsonResponse(data: unknown, status = 200): Response {\n  return new Response(JSON.stringify(data), {\n    status,\n    headers: { 'Content-Type': 'application/json' },\n  });\n}\n\nexport default {\n  async fetch(request: Request, env: Env): Promise<Response> {\n    const url = new URL(request.url);\n    const { pathname } = url;\n\n    // Simple router\n    if (pathname === '/api/health' && request.method === 'GET') {\n      return jsonResponse({ status: 'ok', region: request.cf?.colo });\n    }\n\n    if (pathname === '/api/echo' && request.method === 'POST') {\n      const body = await request.json();\n      return jsonResponse({ echo: body });\n    }\n\n    if (pathname.startsWith('/api/')) {\n      return jsonResponse({ error: 'Not found' }, 404);\n    }\n\n    // Pass non-API requests through to origin\n    return fetch(request);\n  },\n};",
+      "notes": "Use new URL(request.url) to parse the URL — the global URL constructor is available in Workers. request.cf contains Cloudflare metadata like the datacenter (colo), country, and ASN. Workers run on every incoming request without a cold start penalty."
+    },
+    {
+      "title": "Worker with R2 storage integration",
+      "language": "typescript",
+      "code": "interface Env {\n  MEDIA_BUCKET: R2Bucket;\n}\n\nexport default {\n  async fetch(request: Request, env: Env): Promise<Response> {\n    const url = new URL(request.url);\n    // Expected path: /media/<object-key>\n    const key = url.pathname.replace('/media/', '');\n\n    if (!key) {\n      return new Response('Missing key', { status: 400 });\n    }\n\n    if (request.method === 'GET') {\n      // Serve file from R2\n      const object = await env.MEDIA_BUCKET.get(key);\n\n      if (!object) {\n        return new Response('Object not found', { status: 404 });\n      }\n\n      const headers = new Headers();\n      object.writeHttpMetadata(headers);\n      headers.set('etag', object.httpEtag);\n      headers.set('Cache-Control', 'public, max-age=31536000');\n\n      return new Response(object.body, { headers });\n    }\n\n    if (request.method === 'PUT') {\n      // Upload file to R2\n      await env.MEDIA_BUCKET.put(key, request.body, {\n        httpMetadata: {\n          contentType: request.headers.get('Content-Type') ?? 'application/octet-stream',\n        },\n      });\n\n      return new Response(JSON.stringify({ key, uploaded: true }), {\n        status: 201,\n        headers: { 'Content-Type': 'application/json' },\n      });\n    }\n\n    return new Response('Method not allowed', { status: 405 });\n  },\n};",
+      "notes": "R2 bindings are declared in wrangler.toml: [[r2_buckets]] binding = 'MEDIA_BUCKET' bucket_name = 'my-bucket'. The env.MEDIA_BUCKET object provides get(), put(), delete(), and list() methods directly — no SDK needed inside a Worker."
+    }
+  ],
+  "gotchas": [
+    "The Workers runtime is NOT Node.js. Many Node.js APIs (fs, path, net, Node's built-in crypto) are not available. Use the Web Crypto API (crypto.subtle) instead of Node's crypto module. Check the Workers compatibility list at developers.cloudflare.com before assuming a Node.js package will work.",
+    "The CPU time limit is 10ms on the free plan per request. This is CPU execution time, not wall-clock time (network I/O and waiting on fetch calls does not count). CPU-intensive operations like image processing, complex regex on large strings, or parsing large JSON payloads will hit this limit and throw an error.",
+    "Workers use V8 isolates, not VMs or containers. There is NO persistent memory between requests. Any module-level variables are reset between requests (or shared unpredictably within the same isolate). Use KV, Durable Objects, or R2 for any state that must persist.",
+    "wrangler dev runs a local simulation that is NOT 100% identical to the production edge environment. Edge cases with headers, TLS fingerprinting, Cloudflare-specific request properties (request.cf), and some Workers APIs behave differently locally. Always test with wrangler dev --remote for critical behavior before deploying."
+  ],
+  "reliability": {
+    "uptimeGuarantee": "99.9% uptime SLA (Workers Standard), globally redundant across 300+ PoPs",
+    "statusPageUrl": "https://www.cloudflarestatus.com",
+    "notes": "Requests automatically route to the nearest available Cloudflare datacenter. If one PoP is degraded, traffic is rerouted with automatic failover. Workers deployments are globally propagated within seconds."
+  },
+  "qualityScore": 9,
+  "qualityJustification": "Sub-millisecond cold starts (V8 isolates vs containers) make it the fastest serverless platform available. The global network means code runs within milliseconds of any user. The 100K free daily requests is genuinely useful for production traffic. Main limitation is the constrained runtime (not Node.js).",
+  "alternatives": ["vercel", "netlify", "fly-io"],
+  "complementary": ["cloudflare-r2", "upstash", "neon", "supabase"],
+  "bestFor": "Low-latency edge logic: API routing, auth middleware, A/B testing, content transformation — runs in 300+ global locations with near-zero cold starts",
+  "lastVerified": "2026-02-25",
+  "entryVersion": 1,
+  "addedBy": "claude-code-session-4"
+}

package/src/entries/infrastructure/digital-ocean-spaces.json

@@ -0,0 +1,87 @@
+{
+  "name": "DigitalOcean Spaces",
+  "slug": "digital-ocean-spaces",
+  "category": "infrastructure",
+  "subcategory": "object-storage",
+  "website": "https://www.digitalocean.com/products/spaces",
+  "description": "DigitalOcean Spaces is S3-compatible object storage with a built-in CDN, flat predictable pricing, and seamless integration for teams already running apps on DigitalOcean.",
+  "useCases": [
+    {
+      "task": "Store and serve user-uploaded files with built-in CDN",
+      "fit": "perfect"
+    },
+    {
+      "task": "Simple object storage for a DigitalOcean-hosted application",
+      "fit": "perfect"
+    },
+    {
+      "task": "Migrate from S3 to a simpler, flat-rate pricing model",
+      "fit": "good"
+    }
+  ],
+  "auth": {
+    "method": "api_key",
+    "setupSteps": [
+      "Log in to your DigitalOcean account at cloud.digitalocean.com",
+      "Navigate to Spaces Object Storage and click Create a Space",
+      "Choose a region and bucket name, then click Create Space",
+      "Go to API → Spaces Keys → Generate New Key",
+      "Name the key and copy the Access Key and Secret Key — the secret is shown only once",
+      "Set DO_SPACES_KEY, DO_SPACES_SECRET, DO_SPACES_REGION, and DO_SPACES_BUCKET environment variables"
+    ],
+    "envVarName": "DO_SPACES_KEY",
+    "codeSnippet": "import { S3Client } from '@aws-sdk/client-s3';\n\nconst spacesClient = new S3Client({\n  region: process.env.DO_SPACES_REGION!,\n  endpoint: `https://${process.env.DO_SPACES_REGION}.digitaloceanspaces.com`,\n  credentials: {\n    accessKeyId: process.env.DO_SPACES_KEY!,\n    secretAccessKey: process.env.DO_SPACES_SECRET!,\n  },\n});"
+  },
+  "pricing": {
+    "model": "paid",
+    "freeTier": null,
+    "startingPrice": "$5/month for 250GB storage + 1TB outbound transfer",
+    "costPer": "$0.02/GB additional storage, $0.01/GB additional transfer, $0.004/10K PUT requests, $0.004/10K GET requests after 10K included per month",
+    "pricingUrl": "https://www.digitalocean.com/pricing/spaces-object-storage"
+  },
+  "rateLimits": {
+    "tier": "standard tier",
+    "limit": "No published request rate limits. 1TB transfer/month included. CDN bandwidth is separate from Spaces bandwidth.",
+    "notes": "DigitalOcean does not publish specific per-bucket request rate limits for Spaces. Transfer limits apply to data out from Spaces directly; CDN transfer is metered separately if CDN is enabled.",
+    "retryStrategy": "Use exponential backoff on errors. The S3-compatible API uses standard S3 error codes and retry patterns."
+  },
+  "sdk": {
+    "primaryLanguage": "typescript",
+    "installCommand": "npm install --save-exact @aws-sdk/client-s3",
+    "importStatement": "import { S3Client, PutObjectCommand } from '@aws-sdk/client-s3';",
+    "otherLanguages": ["python", "go", "ruby", "php"]
+  },
+  "codeExamples": [
+    {
+      "title": "Upload to DigitalOcean Spaces",
+      "language": "typescript",
+      "code": "import { S3Client, PutObjectCommand } from '@aws-sdk/client-s3';\n\nconst spacesClient = new S3Client({\n  region: process.env.DO_SPACES_REGION!,\n  endpoint: `https://${process.env.DO_SPACES_REGION}.digitaloceanspaces.com`,\n  credentials: {\n    accessKeyId: process.env.DO_SPACES_KEY!,\n    secretAccessKey: process.env.DO_SPACES_SECRET!,\n  },\n});\n\nasync function uploadToSpaces(\n  key: string,\n  body: Buffer | string,\n  contentType: string,\n  isPublic = false\n): Promise<string> {\n  const command = new PutObjectCommand({\n    Bucket: process.env.DO_SPACES_BUCKET!,\n    Key: key,\n    Body: body,\n    ContentType: contentType,\n    ACL: isPublic ? 'public-read' : 'private',\n  });\n\n  await spacesClient.send(command);\n\n  // Public URL format for Spaces\n  const region = process.env.DO_SPACES_REGION!;\n  const bucket = process.env.DO_SPACES_BUCKET!;\n  return `https://${bucket}.${region}.digitaloceanspaces.com/${key}`;\n}\n\n// Usage: upload a publicly readable image\nconst publicUrl = await uploadToSpaces(\n  'images/product-hero.jpg',\n  imageBuffer,\n  'image/jpeg',\n  true\n);\nconsole.log('Uploaded to Spaces:', publicUrl);",
+      "notes": "Unlike S3, Spaces supports ACL (Access Control List) at the object level with public-read. The endpoint URL format is {region}.digitaloceanspaces.com. The bucket name is included in the path, not the subdomain, when constructing the endpoint for the S3 client."
+    },
+    {
+      "title": "Enable CDN for a Spaces bucket and get CDN URL",
+      "language": "typescript",
+      "code": "import { S3Client, PutObjectCommand } from '@aws-sdk/client-s3';\n\nconst spacesClient = new S3Client({\n  region: process.env.DO_SPACES_REGION!,\n  endpoint: `https://${process.env.DO_SPACES_REGION}.digitaloceanspaces.com`,\n  credentials: {\n    accessKeyId: process.env.DO_SPACES_KEY!,\n    secretAccessKey: process.env.DO_SPACES_SECRET!,\n  },\n});\n\n// CDN must be enabled on the Space via the DigitalOcean dashboard first.\n// Once enabled, the CDN endpoint follows this pattern:\nfunction getCdnUrl(key: string): string {\n  const bucket = process.env.DO_SPACES_BUCKET!;\n  const region = process.env.DO_SPACES_REGION!;\n  // Default CDN endpoint: {bucket}.{region}.cdn.digitaloceanspaces.com\n  return `https://${bucket}.${region}.cdn.digitaloceanspaces.com/${key}`;\n}\n\nasync function uploadAndGetCdnUrl(\n  key: string,\n  body: Buffer,\n  contentType: string\n): Promise<{ originUrl: string; cdnUrl: string }> {\n  const command = new PutObjectCommand({\n    Bucket: process.env.DO_SPACES_BUCKET!,\n    Key: key,\n    Body: body,\n    ContentType: contentType,\n    ACL: 'public-read',\n    // Set cache headers for CDN\n    CacheControl: 'public, max-age=31536000',\n  });\n\n  await spacesClient.send(command);\n\n  const bucket = process.env.DO_SPACES_BUCKET!;\n  const region = process.env.DO_SPACES_REGION!;\n\n  return {\n    originUrl: `https://${bucket}.${region}.digitaloceanspaces.com/${key}`,\n    cdnUrl: getCdnUrl(key),\n  };\n}\n\n// Usage\nconst { originUrl, cdnUrl } = await uploadAndGetCdnUrl(\n  'assets/logo.png',\n  logoBuffer,\n  'image/png'\n);\nconsole.log('Origin URL:', originUrl);\nconsole.log('CDN URL:', cdnUrl);",
+      "notes": "CDN must be enabled on the Space in the DigitalOcean dashboard before CDN URLs will work. The CDN endpoint is {bucket}.{region}.cdn.digitaloceanspaces.com. Set CacheControl headers at upload time to control how long the CDN caches objects."
+    }
+  ],
+  "gotchas": [
+    "Spaces CDN uses DigitalOcean's CDN network (powered by Cloudflare in some regions, other providers in others). It does NOT automatically integrate with your own Cloudflare DNS — routing traffic through both Spaces CDN and Cloudflare's proxy can cause caching conflicts and unexpected behavior.",
+    "The $5/month flat rate includes 250GB + 1TB transfer per Space (bucket). If you create multiple Spaces, each Space is billed separately at $5/month minimum. There is no account-level pooling of storage or transfer across multiple Spaces.",
+    "Spaces is only available in select DigitalOcean regions: NYC3, SFO3, AMS3, SGP1, FRA1. You cannot create a Space in every DigitalOcean region. Choose your Space region to be geographically close to your Droplets or App Platform apps to avoid inter-region transfer costs.",
+    "Spaces does not support all S3 API features: no S3 Select, no Object Lock, no S3 Batch Operations. Object versioning must be enabled at Space creation time — it cannot be enabled on an existing Space. Review the S3 compatibility guide at docs.digitalocean.com before migrating from S3."
+  ],
+  "reliability": {
+    "uptimeGuarantee": "99.9% uptime SLA",
+    "statusPageUrl": "https://status.digitalocean.com",
+    "notes": "Spaces data is replicated across multiple availability zones within the selected region. No cross-region replication is available."
+  },
+  "qualityScore": 7,
+  "qualityJustification": "Predictable flat pricing ($5/month for 250GB + 1TB) is its strongest selling point for teams that hate surprise bills. S3-compatible API means existing code works with minimal changes. However, Cloudflare R2 has a better free tier and zero egress fees, making Spaces most compelling for teams already invested in the DigitalOcean ecosystem.",
+  "alternatives": ["aws-s3", "cloudflare-r2", "cloudinary"],
+  "complementary": ["railway"],
+  "bestFor": "Simple object storage with predictable flat pricing for teams already using DigitalOcean infrastructure",
+  "lastVerified": "2026-02-25",
+  "entryVersion": 1,
+  "addedBy": "claude-code-session-4"
+}

package/src/entries/integration/nango.json

@@ -0,0 +1,90 @@
+{
+  "name": "Nango",
+  "slug": "nango",
+  "category": "integration",
+  "subcategory": "oauth-integrations",
+  "website": "https://www.nango.dev",
+  "description": "Nango is an open-source platform for building and managing OAuth integrations with 200+ APIs. It handles the OAuth flow, token refresh, credential storage, and provides a unified API to make authenticated requests to third-party services on behalf of your users.",
+  "useCases": [
+    {
+      "task": "Add 'Connect your GitHub/Salesforce/HubSpot' integration to your app",
+      "fit": "perfect"
+    },
+    {
+      "task": "Store and auto-refresh OAuth tokens for users' connected accounts",
+      "fit": "perfect"
+    },
+    {
+      "task": "Sync data from third-party APIs into your database on a schedule",
+      "fit": "good"
+    },
+    {
+      "task": "Build a white-label integration marketplace for your SaaS product",
+      "fit": "good"
+    }
+  ],
+  "auth": {
+    "method": "api_key",
+    "setupSteps": [
+      "Create an account at app.nango.dev",
+      "Create a new environment (dev or prod) in the Nango dashboard",
+      "Copy the secret key from Settings → Secret Key",
+      "Set the NANGO_SECRET_KEY environment variable in your backend",
+      "Configure integrations in the dashboard: add each OAuth provider (e.g., GitHub, Salesforce) with its client ID and client secret obtained from that provider's developer portal",
+      "Install the Nango Node SDK: npm install --save-exact @nangohq/node"
+    ],
+    "envVarName": "NANGO_SECRET_KEY",
+    "codeSnippet": "import Nango from '@nangohq/node';\n\nconst nango = new Nango({ secretKey: process.env.NANGO_SECRET_KEY });\n\n// Retrieve a connection's access token to make API calls on behalf of a user\nconst connection = await nango.getConnection('github', 'user-123');\nconst accessToken = connection.credentials.access_token;"
+  },
+  "pricing": {
+    "model": "freemium",
+    "freeTier": "Free: unlimited OAuth connections, 100 syncs/month, community support",
+    "startingPrice": "$250/month (Scale) for unlimited syncs, SLAs, and priority support",
+    "costPer": null,
+    "pricingUrl": "https://www.nango.dev/pricing"
+  },
+  "rateLimits": {
+    "tier": "free tier",
+    "limit": "Unlimited OAuth connections on all plans. Syncs (scheduled data pulls from third-party APIs) limited to 100/month on the free tier.",
+    "notes": "Nango proxies API requests through its infrastructure, so rate limits of the underlying third-party API still apply. Nango itself does not impose additional rate limits on proxy API calls. Token refresh is automatic and does not count against limits.",
+    "retryStrategy": "Nango handles OAuth token refresh automatically on every request. For sync failures, configure retry logic in the nango.yaml sync definition. For proxy calls, implement retry with exponential backoff in your application code since Nango passes through API errors."
+  },
+  "sdk": {
+    "primaryLanguage": "typescript",
+    "installCommand": "npm install --save-exact @nangohq/node",
+    "importStatement": "import Nango from '@nangohq/node';",
+    "otherLanguages": ["javascript", "python"]
+  },
+  "codeExamples": [
+    {
+      "title": "Initiate OAuth flow and retrieve access token",
+      "language": "typescript",
+      "code": "// --- Frontend: initiate the OAuth connection for a user ---\n// Install the frontend SDK: npm install --save-exact @nangohq/frontend\nimport Nango from '@nangohq/frontend';\n\nconst nango = new Nango();\n\nasync function connectGitHub(userId: string): Promise<void> {\n  // Your backend endpoint generates a session token for this user\n  const response = await fetch('/api/nango/session', {\n    method: 'POST',\n    headers: { 'Content-Type': 'application/json' },\n    body: JSON.stringify({ userId }),\n  });\n  const { sessionToken } = await response.json() as { sessionToken: string };\n\n  // Opens the OAuth popup — Nango handles the full OAuth flow\n  await nango.auth('github', sessionToken);\n  console.log('GitHub connected successfully!');\n}\n\n// --- Backend: generate a session token and use the connection ---\nimport Nango from '@nangohq/node';\n\nconst nango = new Nango({ secretKey: process.env.NANGO_SECRET_KEY });\n\n// Generate a session token (call this from your /api/nango/session endpoint)\nasync function createNangoSession(userId: string): Promise<string> {\n  const session = await nango.createConnectSession({\n    end_user: { id: userId },\n    // Optionally restrict which integrations the user can connect\n    allowed_integrations: ['github'],\n  });\n  return session.data.token;\n}\n\n// After the user connects, retrieve their access token to make API calls\nasync function getGitHubAccessToken(userId: string): Promise<string> {\n  const connection = await nango.getConnection('github', userId);\n  // Nango automatically refreshes the token if it has expired\n  const accessToken = (connection.credentials as { access_token: string }).access_token;\n  return accessToken;\n}\n\n// Use the token to call the GitHub API directly\nconst token = await getGitHubAccessToken('user-123');\nconst ghResponse = await fetch('https://api.github.com/user', {\n  headers: { Authorization: `Bearer ${token}` },\n});\nconst githubUser = await ghResponse.json();\nconsole.log('GitHub user:', githubUser);",
+      "notes": "The connection_id (second argument to getConnection) should be your own user's ID — this is how Nango maps stored tokens back to your users. Use consistent IDs (e.g., your database user UUID) so you can always retrieve the right token. Nango automatically refreshes expired tokens on every getConnection() call."
+    },
+    {
+      "title": "Make a proxied API call on behalf of a user",
+      "language": "typescript",
+      "code": "import Nango from '@nangohq/node';\n\nconst nango = new Nango({ secretKey: process.env.NANGO_SECRET_KEY });\n\ninterface GitHubRepo {\n  id: number;\n  name: string;\n  full_name: string;\n  private: boolean;\n  html_url: string;\n  stargazers_count: number;\n}\n\n// Use nango.proxy() to make authenticated API calls without managing tokens\nasync function getUserRepos(userId: string): Promise<GitHubRepo[]> {\n  const response = await nango.proxy<GitHubRepo[]>({\n    providerConfigKey: 'github',  // The integration name in your Nango dashboard\n    connectionId: userId,          // Your user's ID (maps to their stored token)\n    method: 'GET',\n    endpoint: '/user/repos',\n    params: {\n      sort: 'updated',\n      per_page: '30',\n    },\n  });\n\n  return response.data;\n}\n\n// Example: list repos for a connected GitHub user\nconst repos = await getUserRepos('user-123');\nconsole.log(`Found ${repos.length} repositories:`);\nfor (const repo of repos) {\n  console.log(`  - ${repo.full_name} (${repo.stargazers_count} stars)`);\n}\n\n// You can also make POST requests via proxy\nasync function createIssue(\n  userId: string,\n  owner: string,\n  repoName: string,\n  title: string,\n  body: string\n): Promise<void> {\n  await nango.proxy({\n    providerConfigKey: 'github',\n    connectionId: userId,\n    method: 'POST',\n    endpoint: `/repos/${owner}/${repoName}/issues`,\n    data: { title, body },\n  });\n}",
+      "notes": "nango.proxy() automatically injects the correct Authorization header using the stored and refreshed token for that connection. The endpoint is relative to the base URL configured for the integration in Nango. This approach keeps token handling entirely in Nango — your application code never needs to handle token refresh logic."
+    }
+  ],
+  "gotchas": [
+    "Nango does NOT provide pre-configured OAuth credentials. You must register your own OAuth app with each third-party provider (GitHub, Salesforce, HubSpot, etc.) and supply the client ID and client secret to Nango. Integrating 10 providers means registering 10 separate OAuth apps across 10 developer portals — budget time for this setup work.",
+    "The open-source self-hosted version of Nango has fewer features than the cloud offering. Scheduled sync orchestration, the pre-built integration templates marketplace, and some advanced proxy features are cloud-only. Review the feature comparison at docs.nango.dev before committing to self-hosting.",
+    "Nango stores OAuth access tokens and refresh tokens on their servers (or your self-hosted instance). You are trusting Nango with credentials that grant access to your users' third-party accounts. Review Nango's security documentation, encryption at rest policies, and ensure this arrangement complies with your security requirements and terms of service with end users."
+  ],
+  "reliability": {
+    "uptimeGuarantee": "99.9% SLA (Scale tier and above)",
+    "statusPageUrl": "https://www.nangostatus.dev",
+    "notes": "Open-source self-hosted option available for full control. Cloud version uses isolated credential storage per customer environment. Token refresh happens automatically in Nango's infrastructure, decoupled from your application availability."
+  },
+  "qualityScore": 8,
+  "qualityJustification": "Solves the hardest part of third-party integrations — OAuth token lifecycle management and refresh — elegantly. 200+ pre-built integration configurations save significant OAuth boilerplate. The proxy API and connection model are well-designed. For teams building product integrations, Nango is substantially faster than implementing OAuth yourself for each provider.",
+  "alternatives": [],
+  "complementary": ["supabase", "neon", "clerk", "auth0"],
+  "bestFor": "Building product integrations that let users connect their third-party accounts (GitHub, Salesforce, HubSpot) via OAuth, without managing token storage and refresh yourself",
+  "lastVerified": "2026-02-25",
+  "entryVersion": 1,
+  "addedBy": "claude-code-session-4"
+}

package/src/entries/integration/zapier.json

@@ -0,0 +1,92 @@
+{
+  "name": "Zapier",
+  "slug": "zapier",
+  "category": "integration",
+  "subcategory": "no-code-automation",
+  "website": "https://zapier.com",
+  "description": "Zapier is the dominant no-code automation platform connecting 6,000+ apps with trigger-action workflows (\"Zaps\"). For developers, Zapier offers Webhooks for triggering Zaps programmatically or sending data from custom apps into any of 6,000+ connected services.",
+  "useCases": [
+    {
+      "task": "Trigger actions in 6,000+ apps from a webhook or API call",
+      "fit": "perfect"
+    },
+    {
+      "task": "Connect two SaaS tools without writing any code",
+      "fit": "perfect"
+    },
+    {
+      "task": "Forward form submissions or payments to CRM and email",
+      "fit": "good"
+    },
+    {
+      "task": "Build a custom Zapier integration for your own product",
+      "fit": "good"
+    }
+  ],
+  "auth": {
+    "method": "api_key",
+    "setupSteps": [
+      "Create an account at zapier.com",
+      "Create a new Zap and search for 'Webhooks by Zapier' as the trigger",
+      "Select 'Catch Hook' as the trigger event to get an instant webhook URL",
+      "Copy the webhook URL shown — this is your ZAPIER_WEBHOOK_URL endpoint",
+      "Send a test POST request to the webhook URL to confirm the trigger fires",
+      "Add action steps in the Zap editor (e.g., add row to Google Sheets, post to Slack)",
+      "Publish the Zap to activate it"
+    ],
+    "envVarName": "ZAPIER_WEBHOOK_URL",
+    "codeSnippet": "const response = await fetch(process.env.ZAPIER_WEBHOOK_URL, {\n  method: 'POST',\n  headers: { 'Content-Type': 'application/json' },\n  body: JSON.stringify({ event: 'user.signed_up', email: 'user@example.com' }),\n});\nif (!response.ok) {\n  throw new Error(`Zapier webhook failed: ${response.status}`);\n}\n// Zapier returns 200 with 'Accepted' on success"
+  },
+  "pricing": {
+    "model": "freemium",
+    "freeTier": "Free: 100 tasks/month, 5 Zaps, 15-minute polling interval",
+    "startingPrice": "$19.99/month (Starter) for 750 tasks/month, 20 Zaps, 15-minute polling",
+    "costPer": null,
+    "pricingUrl": "https://zapier.com/pricing"
+  },
+  "rateLimits": {
+    "tier": "free tier",
+    "limit": "100 tasks/month on free plan; tasks are counted per action step (a 3-step Zap consumes 3 tasks per run)",
+    "notes": "Webhook triggers (Catch Hook) are real-time and instant on all plans. Polling triggers on the free plan check every 15 minutes; paid plans support 1-minute polling. Task count resets monthly.",
+    "retryStrategy": "Zapier automatically retries failed tasks up to 3 times before marking them errored. Failed tasks appear in Task History and can be manually replayed from the Zapier dashboard. Implement idempotency in your receiving endpoint to handle replays safely."
+  },
+  "sdk": {
+    "primaryLanguage": "typescript",
+    "installCommand": "npm install --save-exact node-fetch",
+    "importStatement": "import fetch from 'node-fetch';",
+    "otherLanguages": ["javascript", "python", "ruby"]
+  },
+  "codeExamples": [
+    {
+      "title": "Send data to a Zapier webhook",
+      "language": "typescript",
+      "code": "interface ZapierWebhookPayload {\n  [key: string]: string | number | boolean | null;\n}\n\nasync function triggerZap(payload: ZapierWebhookPayload): Promise<void> {\n  const webhookUrl = process.env.ZAPIER_WEBHOOK_URL;\n  if (!webhookUrl) {\n    throw new Error('ZAPIER_WEBHOOK_URL environment variable is not set');\n  }\n\n  const response = await fetch(webhookUrl, {\n    method: 'POST',\n    headers: {\n      'Content-Type': 'application/json',\n    },\n    body: JSON.stringify(payload),\n  });\n\n  if (!response.ok) {\n    throw new Error(`Zapier webhook request failed: ${response.status} ${response.statusText}`);\n  }\n\n  // Zapier responds with plain text 'Accepted' on success\n  const body = await response.text();\n  console.log('Zap triggered:', body);\n}\n\n// Example: trigger a Zap when a user signs up\nawait triggerZap({\n  event: 'user.signed_up',\n  email: 'jane@example.com',\n  name: 'Jane Smith',\n  plan: 'free',\n  signedUpAt: new Date().toISOString(),\n});\n// Zapier will now execute all action steps in the Zap:\n// e.g., add row to Google Sheets, send Slack notification, create HubSpot contact",
+      "notes": "The webhook URL is specific to each Zap — copy it from the 'Catch Hook' trigger step in the Zap editor. Any JSON-serializable fields you send become available as variables in Zap action steps. Field names become the variable names visible in the Zapier editor."
+    },
+    {
+      "title": "Receive a webhook FROM Zapier in your app",
+      "language": "typescript",
+      "code": "import express, { Request, Response } from 'express';\n\ninterface ZapierWebhookBody {\n  event?: string;\n  [key: string]: unknown;\n}\n\nconst app = express();\napp.use(express.json());\n\n// Zapier sends data to your app using the 'Webhooks by Zapier' action\n// Configure the Zap to POST to your endpoint URL\napp.post('/webhooks/zapier', (req: Request, res: Response): void => {\n  const body = req.body as ZapierWebhookBody;\n\n  console.log('Received Zapier webhook:', body);\n\n  // Zapier checks for a 2xx status to consider the action successful\n  // If you return 4xx/5xx, Zapier will retry and eventually mark the task errored\n  const event = body.event ?? 'unknown';\n\n  switch (event) {\n    case 'new_lead':\n      // Handle new CRM lead forwarded from HubSpot via Zapier\n      console.log('New lead received from Zapier:', body);\n      break;\n    case 'payment_received':\n      // Handle payment notification forwarded from Stripe via Zapier\n      console.log('Payment notification from Zapier:', body);\n      break;\n    default:\n      console.log('Unhandled Zapier event:', event);\n  }\n\n  // Always return 200 quickly — Zapier has a short timeout (~10s)\n  res.status(200).json({ received: true });\n});\n\napp.listen(3000, () => console.log('Listening for Zapier webhooks on port 3000'));",
+      "notes": "Zapier expects a 2xx response within roughly 10 seconds. If your processing takes longer, immediately return 200 and process asynchronously (queue the job). Zapier does not sign its webhook requests by default — if you need to verify the source, use a secret in the URL path or a shared header value configured in the Zap's webhook action settings."
+    }
+  ],
+  "gotchas": [
+    "Zapier's free plan uses 15-minute polling for most app triggers — this is NOT real-time automation. For instant reactions (e.g., new Stripe payment triggers an email), you need a paid plan or must use 'Webhooks by Zapier' as the trigger, which IS instant on all plans.",
+    "Tasks are counted per action step, not per Zap run. A Zap with 4 action steps consumes 4 tasks every time it runs. An apparently simple automation can drain your monthly quota surprisingly fast — audit your multi-step Zaps before hitting task limits.",
+    "Zapier is optimized for non-developers. When you need complex logic (loops, conditional branches, data transformation beyond basic formatting), the built-in tools (Formatter, Filter, Paths) become limiting quickly. For code-heavy workflows with branching logic, dedicated workflow engines are more appropriate.",
+    "Data sent through Zapier passes through Zapier's servers. Do NOT send sensitive PII, credentials, or HIPAA-covered data through Zapier unless your plan includes a Business Associate Agreement (BAA) and you have reviewed their data handling and retention policies."
+  ],
+  "reliability": {
+    "uptimeGuarantee": "99.9% SLA (Business and Company plans)",
+    "statusPageUrl": "https://status.zapier.com",
+    "notes": "Zapier's core infrastructure is mature and reliable. The primary failure mode is third-party API changes breaking individual Zaps — Zapier cannot control external API stability. Monitor Task History for errored tasks and set up Zapier error notifications."
+  },
+  "qualityScore": 7,
+  "qualityJustification": "Unmatched breadth with 6,000+ integrations — if you need to connect two SaaS tools with no code, nothing beats it. For developers, the webhook trigger is simple and genuinely useful. Main drawbacks: task-based pricing gets expensive at scale, 15-minute polling on the free tier is frustrating, and it is not designed for complex programmatic workflows with conditional logic.",
+  "alternatives": [],
+  "complementary": ["stripe", "resend", "typeform", "cal-com", "shopify-api"],
+  "bestFor": "No-code automation between SaaS tools, or programmatically triggering actions across 6,000+ apps via webhooks without building direct API integrations",
+  "lastVerified": "2026-02-25",
+  "entryVersion": 1,
+  "addedBy": "claude-code-session-4"
+}

package/src/entries/maps/google-maps.json

@@ -0,0 +1,89 @@
+{
+  "name": "Google Maps Platform",
+  "slug": "google-maps",
+  "category": "maps",
+  "subcategory": "maps-and-navigation",
+  "website": "https://developers.google.com/maps",
+  "description": "Google Maps Platform is the world's most comprehensive mapping service, providing Maps, Places, Routes, and Geolocation APIs backed by Google's unmatched global map data. It is the default choice when place data accuracy, POI coverage, and user familiarity are the top priorities.",
+  "useCases": [
+    {
+      "task": "Add a Google Maps embed to a webpage",
+      "fit": "perfect"
+    },
+    {
+      "task": "Autocomplete address input fields with real-time suggestions",
+      "fit": "perfect"
+    },
+    {
+      "task": "Validate and geocode user addresses",
+      "fit": "perfect"
+    },
+    {
+      "task": "Calculate distance and travel time between locations",
+      "fit": "perfect"
+    },
+    {
+      "task": "Find nearby places (restaurants, stores) by category",
+      "fit": "perfect"
+    }
+  ],
+  "auth": {
+    "method": "api_key",
+    "setupSteps": [
+      "Go to console.cloud.google.com",
+      "Create or select a project",
+      "Go to APIs & Services > Enable APIs and enable the specific APIs you need (Maps JS, Places, Geocoding, etc.)",
+      "Go to APIs & Services > Credentials and create an API Key",
+      "Restrict the API key to specific APIs and HTTP referrers/IP addresses",
+      "Set GOOGLE_MAPS_API_KEY (and NEXT_PUBLIC_GOOGLE_MAPS_API_KEY for browser use)"
+    ],
+    "envVarName": "GOOGLE_MAPS_API_KEY",
+    "codeSnippet": "// Browser: load via script tag\n// <script src=\"https://maps.googleapis.com/maps/api/js?key=API_KEY&libraries=places\"></script>\n// Server: use @googlemaps/google-maps-services-js\nimport { Client } from '@googlemaps/google-maps-services-js';\nconst client = new Client({});"
+  },
+  "pricing": {
+    "model": "freemium",
+    "freeTier": "$200/month free credit (resets monthly)",
+    "startingPrice": "$200 free credit covers ~28,000 map loads or 40,000 geocoding requests",
+    "costPer": "Maps: $7/1,000 loads; Geocoding: $5/1,000 requests; Places: $17-32/1,000 requests",
+    "pricingUrl": "https://developers.google.com/maps/billing-and-pricing/pricing"
+  },
+  "rateLimits": {
+    "tier": "default",
+    "limit": "50 requests/second (Geocoding); 100 requests/second (Places); varies by API",
+    "notes": "Rate limits are per API key. QPS limits can be increased via the Google Cloud Console.",
+    "retryStrategy": "Respect Retry-After headers and implement exponential backoff for OVER_QUERY_LIMIT responses"
+  },
+  "sdk": {
+    "primaryLanguage": "typescript",
+    "installCommand": "npm install --save-exact @googlemaps/google-maps-services-js @types/google.maps",
+    "importStatement": "import { Client } from '@googlemaps/google-maps-services-js';",
+    "otherLanguages": ["python", "java", "go", "ruby", "node"]
+  },
+  "codeExamples": [
+    {
+      "title": "Geocode an address (server-side)",
+      "language": "typescript",
+      "code": "import { Client } from '@googlemaps/google-maps-services-js';\n\nconst client = new Client({});\n\nconst response = await client.geocode({\n  params: {\n    address: '1600 Amphitheatre Parkway, Mountain View, CA',\n    key: process.env.GOOGLE_MAPS_API_KEY!,\n  },\n});\n\nconst result = response.data.results[0];\nif (!result) throw new Error('Address not found');\n\nconst { lat, lng } = result.geometry.location;\nconsole.log(`Lat: ${lat}, Lng: ${lng}`);\nconsole.log('Formatted:', result.formatted_address);",
+      "notes": "Server-side geocoding uses your unrestricted API key. For browser use, add the Maps JavaScript API with Places library. Always restrict your browser API key to specific domains."
+    }
+  ],
+  "gotchas": [
+    "The $200/month free credit sounds generous, but the Places API (New) can cost $17-32 per 1,000 requests, meaning it's exhausted in ~6,000-11,000 requests. Caching results is essential.",
+    "You need to enable EACH API separately in the Google Cloud Console — Maps JavaScript API, Geocoding API, Places API, and Directions API are all separate products with separate billing.",
+    "API keys must be restricted. An unrestricted key leaked in your frontend code can be used by anyone and run up charges. Restrict browser keys to your domain and server keys to specific APIs.",
+    "The Places Autocomplete API has a minimum character threshold and the widget UI is hard to customize compared to Mapbox. If you need full design control over the autocomplete dropdown, Mapbox's Geocoding API is more flexible."
+  ],
+  "reliability": {
+    "uptimeGuarantee": "99.9% uptime SLA",
+    "statusPageUrl": "https://status.cloud.google.com",
+    "notes": "Google Maps has the most comprehensive global coverage and is the most reliable mapping platform. Infrastructure is backed by Google Cloud."
+  },
+  "qualityScore": 8,
+  "qualityJustification": "Unmatched data quality and global coverage, especially for POI data and place information. The $200/month free credit covers many use cases. Billing complexity, Places API cost, and harder API key management are the main drawbacks compared to Mapbox.",
+  "alternatives": ["mapbox"],
+  "complementary": ["supabase", "stripe", "clerk"],
+  "bestFor": "Address autocomplete, geocoding, and place search where Google's superior data coverage and user familiarity are the top priorities",
+  "lastVerified": "2026-02-25",
+  "entryVersion": 1,
+  "addedBy": "claude-code-session-2"
+}

package/src/entries/maps/mapbox.json

@@ -0,0 +1,87 @@
+{
+  "name": "Mapbox",
+  "slug": "mapbox",
+  "category": "maps",
+  "subcategory": "maps-and-navigation",
+  "website": "https://www.mapbox.com",
+  "description": "Mapbox is a developer-focused mapping platform providing interactive maps, geocoding, routing, navigation, and spatial data visualization. It is the preferred choice for applications needing highly customizable maps, offline navigation, or custom map styles — used by Snap, Instacart, and many data visualization tools.",
+  "useCases": [
+    {
+      "task": "Add interactive, customizable maps to a web or mobile app",
+      "fit": "perfect"
+    },
+    {
+      "task": "Geocode addresses and search for places",
+      "fit": "perfect"
+    },
+    {
+      "task": "Build turn-by-turn navigation in a mobile app",
+      "fit": "perfect"
+    },
+    {
+      "task": "Display data visualizations on a map (heatmaps, clusters)",
+      "fit": "perfect"
+    },
+    {
+      "task": "Simple embedded Google-style map on a webpage",
+      "fit": "good"
+    }
+  ],
+  "auth": {
+    "method": "api_key",
+    "setupSteps": [
+      "Sign up at mapbox.com",
+      "Go to your Account page to find your default public access token",
+      "For server-side use, create a secret token with appropriate scopes",
+      "Set MAPBOX_ACCESS_TOKEN environment variable (or NEXT_PUBLIC_MAPBOX_TOKEN for browser)"
+    ],
+    "envVarName": "MAPBOX_ACCESS_TOKEN",
+    "codeSnippet": "import mapboxgl from 'mapbox-gl';\nmapboxgl.accessToken = process.env.NEXT_PUBLIC_MAPBOX_TOKEN!;"
+  },
+  "pricing": {
+    "model": "freemium",
+    "freeTier": "50,000 map loads/month, 100,000 geocoding/month",
+    "startingPrice": "$50/month for higher usage (pay-as-you-go above free tier)",
+    "costPer": "$5 per 1,000 map loads above free tier; $0.75 per 1,000 geocoding requests",
+    "pricingUrl": "https://www.mapbox.com/pricing"
+  },
+  "rateLimits": {
+    "tier": "all tiers",
+    "limit": "600 requests/minute for Geocoding API (default)",
+    "notes": "Map loads are counted per session (not per tile). Higher rate limits available on paid plans.",
+    "retryStrategy": "Implement exponential backoff for 429 responses. Cache geocoding results to avoid redundant API calls."
+  },
+  "sdk": {
+    "primaryLanguage": "typescript",
+    "installCommand": "npm install --save-exact mapbox-gl @types/mapbox-gl",
+    "importStatement": "import mapboxgl from 'mapbox-gl';\nimport 'mapbox-gl/dist/mapbox-gl.css';",
+    "otherLanguages": ["swift", "android", "react-native", "python"]
+  },
+  "codeExamples": [
+    {
+      "title": "Render an interactive map in React",
+      "language": "typescript",
+      "code": "import { useRef, useEffect } from 'react';\nimport mapboxgl from 'mapbox-gl';\nimport 'mapbox-gl/dist/mapbox-gl.css';\n\nmapboxgl.accessToken = process.env.NEXT_PUBLIC_MAPBOX_TOKEN!;\n\nexport function Map() {\n  const mapContainer = useRef<HTMLDivElement>(null);\n  const map = useRef<mapboxgl.Map | null>(null);\n\n  useEffect(() => {\n    if (map.current || !mapContainer.current) return;\n\n    map.current = new mapboxgl.Map({\n      container: mapContainer.current,\n      style: 'mapbox://styles/mapbox/streets-v12',\n      center: [-74.0060, 40.7128], // NYC\n      zoom: 12,\n    });\n\n    // Add a marker\n    new mapboxgl.Marker()\n      .setLngLat([-74.0060, 40.7128])\n      .addTo(map.current);\n\n    return () => map.current?.remove();\n  }, []);\n\n  return <div ref={mapContainer} style={{ height: '400px', width: '100%' }} />;\n}",
+      "notes": "Remember to import 'mapbox-gl/dist/mapbox-gl.css' — without it, the map UI controls won't render. In Next.js, add this to your layout or global CSS."
+    }
+  ],
+  "gotchas": [
+    "Mapbox GL JS requires WebGL. It does not work in environments without WebGL support (some headless browsers, server-side rendering). Use dynamic imports in Next.js to prevent SSR issues.",
+    "The Mapbox access token is public-facing (must be in client-side code). Always restrict your public token to specific URLs in the Mapbox dashboard to prevent unauthorized usage from stealing your quota.",
+    "Map loads are counted per web session, not per page view. A single user session that initializes the map once counts as one load. But if your SPA reinitializes the map on every route change, you'll burn through quota quickly.",
+    "Custom map styles using Mapbox Studio look great but can be complex to maintain. For most apps, the built-in styles (streets-v12, satellite-streets-v12) are sufficient and require no maintenance."
+  ],
+  "reliability": {
+    "uptimeGuarantee": "99.9% uptime SLA",
+    "statusPageUrl": "https://status.mapbox.com",
+    "notes": "Mapbox serves tiles from a global CDN. Core map rendering is client-side (WebGL), so partial API outages rarely affect the user experience."
+  },
+  "qualityScore": 8,
+  "qualityJustification": "Best choice for custom map styling and data visualization on maps. More developer-friendly than Google Maps with better pricing for most use cases. The 50k free map loads/month is sufficient for most apps. Requires WebGL and has a steeper initial learning curve than Google Maps.",
+  "alternatives": ["google-maps"],
+  "complementary": ["supabase", "stripe"],
+  "bestFor": "Custom, interactive maps with data visualization, heatmaps, and highly styled cartography for web and mobile apps",
+  "lastVerified": "2026-02-25",
+  "entryVersion": 1,
+  "addedBy": "claude-code-session-2"
+}