@adityanair98/api-oracle 0.5.0

package/src/entries/communication/stream-chat.json

@@ -0,0 +1,94 @@
+{
+  "name": "Stream Chat",
+  "slug": "stream-chat",
+  "category": "communication",
+  "subcategory": "in-app-chat",
+  "website": "https://getstream.io/chat",
+  "description": "Stream Chat is a managed chat API and SDK that provides everything needed to build in-app messaging: message persistence, user presence, reactions, threads, moderation, search, and pre-built UI components for React, React Native, iOS, and Android. It handles the full chat infrastructure so you can focus on your product.",
+  "useCases": [
+    {
+      "task": "Build in-app chat between users in a marketplace or social app",
+      "fit": "perfect"
+    },
+    {
+      "task": "Add team messaging and channels to a SaaS product",
+      "fit": "perfect"
+    },
+    {
+      "task": "Build customer support live chat",
+      "fit": "perfect"
+    },
+    {
+      "task": "Add group messaging with reactions and threads",
+      "fit": "perfect"
+    },
+    {
+      "task": "Simple one-directional notifications",
+      "fit": "partial"
+    }
+  ],
+  "auth": {
+    "method": "api_key",
+    "setupSteps": [
+      "Sign up at getstream.io",
+      "Create a new app in the Stream dashboard",
+      "Copy your App ID, API Key, and API Secret",
+      "Set STREAM_API_KEY and STREAM_API_SECRET environment variables",
+      "Generate user tokens server-side using the StreamChat SDK"
+    ],
+    "envVarName": "STREAM_API_SECRET",
+    "codeSnippet": "import { StreamChat } from 'stream-chat';\nconst serverClient = StreamChat.getInstance(process.env.STREAM_API_KEY!, process.env.STREAM_API_SECRET!);"
+  },
+  "pricing": {
+    "model": "freemium",
+    "freeTier": "Up to 1,000 MAU, unlimited messages",
+    "startingPrice": "$399/month for up to 10,000 MAU",
+    "costPer": "Varies by plan; approximately $0.04/MAU above plan limit",
+    "pricingUrl": "https://getstream.io/chat/pricing"
+  },
+  "rateLimits": {
+    "tier": "all tiers",
+    "limit": "Depends on plan; default API rate limits apply per endpoint",
+    "notes": "Stream handles WebSocket connections internally. Message rate limits are per channel. High-volume channels (broadcast) have different limits than 1:1 conversations.",
+    "retryStrategy": "Stream's client SDK handles reconnection and message retry automatically. Use server-side retry for API calls with exponential backoff."
+  },
+  "sdk": {
+    "primaryLanguage": "typescript",
+    "installCommand": "npm install --save-exact stream-chat stream-chat-react",
+    "importStatement": "import { StreamChat } from 'stream-chat';\nimport { Chat, Channel, MessageList, MessageInput } from 'stream-chat-react';",
+    "otherLanguages": ["react-native", "swift", "android", "python", "go", "ruby", "php"]
+  },
+  "codeExamples": [
+    {
+      "title": "Create a channel and send a message (server-side)",
+      "language": "typescript",
+      "code": "import { StreamChat } from 'stream-chat';\n\nconst serverClient = StreamChat.getInstance(\n  process.env.STREAM_API_KEY!,\n  process.env.STREAM_API_SECRET!\n);\n\n// Upsert users\nawait serverClient.upsertUsers([\n  { id: 'user-1', name: 'Alice' },\n  { id: 'user-2', name: 'Bob' },\n]);\n\n// Create or get a direct message channel\nconst channel = serverClient.channel('messaging', 'alice-bob-dm', {\n  members: ['user-1', 'user-2'],\n  name: 'Alice & Bob',\n  created_by_id: 'user-1',\n});\nawait channel.create();\n\n// Send a message\nconst response = await channel.sendMessage({\n  text: 'Hey Bob! How are you?',\n  user_id: 'user-1',\n});\n\nconsole.log('Message sent:', response.message.id);",
+      "notes": "Channel IDs must be unique per channel type. 'messaging' is for DMs and group chats; 'livestream' is for broadcast channels. Avoid spaces in channel IDs."
+    },
+    {
+      "title": "React chat component with pre-built UI",
+      "language": "typescript",
+      "code": "import { StreamChat } from 'stream-chat';\nimport { Chat, Channel, ChannelHeader, MessageList, MessageInput, Thread, Window } from 'stream-chat-react';\nimport 'stream-chat-react/dist/css/v2/index.css';\n\nconst client = StreamChat.getInstance(process.env.NEXT_PUBLIC_STREAM_API_KEY!);\n\n// Token generated server-side: serverClient.createToken(userId)\nawait client.connectUser(\n  { id: 'user-1', name: 'Alice' },\n  userToken // Generated server-side\n);\n\nconst channel = client.channel('messaging', 'alice-bob-dm');\n\nexport function ChatUI() {\n  return (\n    <Chat client={client}>\n      <Channel channel={channel}>\n        <Window>\n          <ChannelHeader />\n          <MessageList />\n          <MessageInput />\n        </Window>\n        <Thread />\n      </Channel>\n    </Chat>\n  );\n}",
+      "notes": "The pre-built React components handle everything: message rendering, infinite scroll, file uploads, emoji reactions, thread replies. Fully customizable via CSS and props."
+    }
+  ],
+  "gotchas": [
+    "User tokens MUST be generated server-side using your API Secret. The API Secret must never be exposed in client-side code. Set up a token endpoint that your app calls to authenticate users.",
+    "Stream's pricing jumps significantly at scale ($399/month for 10k MAU). The free tier (1,000 MAU) is only suitable for prototypes. Calculate your MAU carefully before committing.",
+    "Channel queries can return stale data if you're not handling the real-time events correctly. Always listen to channel events (message.new, member.added, etc.) to keep your state current.",
+    "Stream stores all message history on their servers. If you have data residency requirements (GDPR, HIPAA), check which regions are available and configure accordingly."
+  ],
+  "reliability": {
+    "uptimeGuarantee": "99.999% uptime SLA on Growth and Enterprise plans",
+    "statusPageUrl": "https://status.getstream.io",
+    "notes": "Stream powers billions of messages for companies like Reddit, Duolingo, and Mercari. Global infrastructure with 99.999% SLA on paid plans."
+  },
+  "qualityScore": 9,
+  "qualityJustification": "Best-in-class chat API with the most complete feature set: reactions, threads, read receipts, file uploads, moderation, search, and excellent pre-built React components. TypeScript support is excellent. Pricing is the main drawback — it gets expensive quickly at scale.",
+  "alternatives": ["sendbird", "ably"],
+  "complementary": ["clerk", "pusher", "uploadthing"],
+  "bestFor": "Building full-featured in-app chat with pre-built UI components, message history, and reactions — for marketplaces, social apps, and SaaS",
+  "lastVerified": "2026-02-25",
+  "entryVersion": 1,
+  "addedBy": "claude-code-session-2"
+}

package/src/entries/database/firebase.json

@@ -0,0 +1,88 @@
+{
+  "name": "Firebase",
+  "slug": "firebase",
+  "category": "database",
+  "subcategory": "app-platform",
+  "website": "https://firebase.google.com",
+  "description": "Firebase is Google's comprehensive app development platform providing Firestore (NoSQL document database), Authentication, Cloud Storage, Cloud Functions, Hosting, and Analytics. It is especially strong for mobile apps and real-time applications where offline-first behavior and Google ecosystem integration matter.",
+  "useCases": [
+    {
+      "task": "Build a mobile app backend with offline-first data sync",
+      "fit": "perfect"
+    },
+    {
+      "task": "Add user authentication with multiple social providers",
+      "fit": "perfect"
+    },
+    {
+      "task": "Store and sync real-time data across multiple clients",
+      "fit": "perfect"
+    },
+    {
+      "task": "Host a static web app with serverless functions",
+      "fit": "good"
+    },
+    {
+      "task": "Complex SQL queries or relational data models",
+      "fit": "partial"
+    }
+  ],
+  "auth": {
+    "method": "oauth2",
+    "setupSteps": [
+      "Create a project at console.firebase.google.com",
+      "Add a web or mobile app to your project",
+      "Copy the Firebase config object (apiKey, authDomain, projectId, etc.)",
+      "For server-side: go to Project Settings > Service Accounts and download a service account JSON",
+      "Set FIREBASE_SERVICE_ACCOUNT_KEY as the JSON string (or path) in your environment"
+    ],
+    "envVarName": "FIREBASE_SERVICE_ACCOUNT_KEY",
+    "codeSnippet": "import { initializeApp } from 'firebase/app';\nconst app = initializeApp({\n  apiKey: process.env.NEXT_PUBLIC_FIREBASE_API_KEY!,\n  authDomain: process.env.NEXT_PUBLIC_FIREBASE_AUTH_DOMAIN!,\n  projectId: process.env.NEXT_PUBLIC_FIREBASE_PROJECT_ID!,\n});"
+  },
+  "pricing": {
+    "model": "freemium",
+    "freeTier": "Spark plan: 1GB Firestore storage, 50k reads/day, 20k writes/day, 1GB storage",
+    "startingPrice": "Blaze plan: pay-as-you-go (no monthly fee beyond free tier)",
+    "costPer": "Firestore: $0.06/100k reads, $0.18/100k writes, $0.06/GB/month storage",
+    "pricingUrl": "https://firebase.google.com/pricing"
+  },
+  "rateLimits": {
+    "tier": "Spark (free)",
+    "limit": "50,000 document reads/day, 20,000 writes/day, 20,000 deletes/day",
+    "notes": "Blaze (pay-as-you-go) has no daily limits but costs per operation. Cloud Functions require Blaze plan. Firestore has a 1MB document size limit.",
+    "retryStrategy": "Firebase SDK handles automatic retries with exponential backoff. Cloud Firestore has built-in offline persistence that queues writes."
+  },
+  "sdk": {
+    "primaryLanguage": "typescript",
+    "installCommand": "npm install --save-exact firebase",
+    "importStatement": "import { initializeApp } from 'firebase/app';\nimport { getFirestore, collection, query, where, getDocs } from 'firebase/firestore';",
+    "otherLanguages": ["swift", "android", "flutter", "python", "go", "java", "ruby"]
+  },
+  "codeExamples": [
+    {
+      "title": "Read and write to Firestore",
+      "language": "typescript",
+      "code": "import { initializeApp } from 'firebase/app';\nimport { getFirestore, collection, addDoc, query, where, getDocs, serverTimestamp } from 'firebase/firestore';\n\nconst app = initializeApp({\n  apiKey: process.env.NEXT_PUBLIC_FIREBASE_API_KEY!,\n  authDomain: process.env.NEXT_PUBLIC_FIREBASE_AUTH_DOMAIN!,\n  projectId: process.env.NEXT_PUBLIC_FIREBASE_PROJECT_ID!,\n});\nconst db = getFirestore(app);\n\n// Write a document\nconst docRef = await addDoc(collection(db, 'posts'), {\n  title: 'Hello Firestore',\n  userId: 'user-123',\n  createdAt: serverTimestamp(),\n});\nconsole.log('Written document ID:', docRef.id);\n\n// Query with filter\nconst q = query(\n  collection(db, 'posts'),\n  where('userId', '==', 'user-123')\n);\nconst snapshot = await getDocs(q);\nsnapshot.forEach(doc => console.log(doc.id, doc.data()));",
+      "notes": "Document IDs are auto-generated by addDoc(). For custom IDs use setDoc(). Firestore queries are limited to fields that have been indexed — complex queries may require composite indexes."
+    }
+  ],
+  "gotchas": [
+    "Cloud Functions (required for any server-side logic) require the Blaze (pay-as-you-go) plan, even if you're within the free tier limits. You cannot deploy functions on the free Spark plan.",
+    "Firestore does not support OR queries across different fields, JOIN-like operations, or full-text search. You may need to denormalize your data model significantly compared to a relational database.",
+    "The Firebase SDK bundle size is large. Using tree-shaking and the modular SDK (firebase/app, firebase/firestore) is essential for web performance — the legacy compat SDK imports everything.",
+    "Firestore Security Rules are a separate mini-language and are easy to get wrong. A misconfigured rule can either lock out legitimate users or expose all your data. Test rules thoroughly with the Firebase Emulator."
+  ],
+  "reliability": {
+    "uptimeGuarantee": "99.95% uptime SLA (Google Cloud SLA)",
+    "statusPageUrl": "https://status.firebase.google.com",
+    "notes": "Firebase runs on Google Cloud infrastructure with global multi-region replication for Firestore. Extremely reliable at scale."
+  },
+  "qualityScore": 8,
+  "qualityJustification": "Excellent for mobile-first applications with offline sync and real-time requirements. The NoSQL data model and deep Google/Android integration are genuine advantages. Web developer experience has improved with modular SDK. Main limitations: no SQL, complex security rules, and vendor lock-in.",
+  "alternatives": ["supabase", "neon"],
+  "complementary": ["stripe", "resend", "clerk"],
+  "bestFor": "Mobile-first apps needing offline-first sync, real-time data, and deep Google ecosystem integration (Android, Google Auth, Analytics)",
+  "lastVerified": "2026-02-25",
+  "entryVersion": 1,
+  "addedBy": "claude-code-session-2"
+}

package/src/entries/database/neon.json

@@ -0,0 +1,94 @@
+{
+  "name": "Neon",
+  "slug": "neon",
+  "category": "database",
+  "subcategory": "serverless-postgres",
+  "website": "https://neon.tech",
+  "description": "Neon is a serverless PostgreSQL platform that separates storage and compute, allowing databases to scale to zero when idle (no charges when not in use). It provides instant branching for development workflows, a serverless driver optimized for edge functions, and full PostgreSQL compatibility — making it the best serverless Postgres option for cost-conscious teams.",
+  "useCases": [
+    {
+      "task": "Run a serverless PostgreSQL database that scales to zero",
+      "fit": "perfect"
+    },
+    {
+      "task": "Add a Postgres database to a Next.js or serverless application",
+      "fit": "perfect"
+    },
+    {
+      "task": "Create database branches for development and preview environments",
+      "fit": "perfect"
+    },
+    {
+      "task": "Use Drizzle or Prisma ORM with a hosted Postgres database",
+      "fit": "perfect"
+    },
+    {
+      "task": "High-throughput OLTP workloads requiring consistent low latency",
+      "fit": "good"
+    }
+  ],
+  "auth": {
+    "method": "api_key",
+    "setupSteps": [
+      "Sign up at neon.tech",
+      "Create a new project (choose a region)",
+      "Go to the Dashboard and find your connection string",
+      "Copy the connection string (includes host, database, user, password)",
+      "Set DATABASE_URL environment variable with the connection string"
+    ],
+    "envVarName": "DATABASE_URL",
+    "codeSnippet": "import { neon } from '@neondatabase/serverless';\nconst sql = neon(process.env.DATABASE_URL!);"
+  },
+  "pricing": {
+    "model": "freemium",
+    "freeTier": "1 project, 0.5GB storage, 190 compute hours/month (scales to zero)",
+    "startingPrice": "$19/month (Launch plan) for 10GB storage, 300 compute hours",
+    "costPer": "Launch: $0.16/GB-month storage, $0.10/compute-hour above included amount",
+    "pricingUrl": "https://neon.tech/pricing"
+  },
+  "rateLimits": {
+    "tier": "free tier",
+    "limit": "0.5 compute units (shared CPU), 190 compute hours/month",
+    "notes": "Neon scales to zero after a period of inactivity (default 5 minutes on free tier). The first query after scaling to zero has a cold start of 100-500ms. Pro plan has configurable scale-to-zero.",
+    "retryStrategy": "Implement retry logic for cold start scenarios (connection timeout on first request). The @neondatabase/serverless driver handles HTTP connections for edge environments."
+  },
+  "sdk": {
+    "primaryLanguage": "typescript",
+    "installCommand": "npm install --save-exact @neondatabase/serverless",
+    "importStatement": "import { neon } from '@neondatabase/serverless';",
+    "otherLanguages": ["python", "go", "java", "ruby"]
+  },
+  "codeExamples": [
+    {
+      "title": "Query with the serverless driver",
+      "language": "typescript",
+      "code": "import { neon } from '@neondatabase/serverless';\n\nconst sql = neon(process.env.DATABASE_URL!);\n\n// Tagged template literal syntax (safe against SQL injection)\nconst userId = 'user-123';\nconst users = await sql`\n  SELECT id, name, email, created_at\n  FROM users\n  WHERE id = ${userId}\n  LIMIT 1\n`;\n\nconsole.log('User:', users[0]);\n\n// Insert with RETURNING\nconst [newPost] = await sql`\n  INSERT INTO posts (title, body, user_id)\n  VALUES (${'Hello World'}, ${'My first post'}, ${userId})\n  RETURNING *\n`;\n\nconsole.log('Created post:', newPost.id);",
+      "notes": "The tagged template literal syntax automatically parameterizes values, preventing SQL injection. Use the neon() client for edge/serverless functions. For Node.js with connection pooling, use Pool from @neondatabase/serverless."
+    },
+    {
+      "title": "Use with Drizzle ORM",
+      "language": "typescript",
+      "code": "import { neon } from '@neondatabase/serverless';\nimport { drizzle } from 'drizzle-orm/neon-http';\nimport { users, posts } from './schema';\nimport { eq, desc } from 'drizzle-orm';\n\nconst sql = neon(process.env.DATABASE_URL!);\nconst db = drizzle(sql);\n\n// Type-safe query with Drizzle\nconst recentPosts = await db\n  .select({\n    id: posts.id,\n    title: posts.title,\n    authorName: users.name,\n  })\n  .from(posts)\n  .leftJoin(users, eq(posts.userId, users.id))\n  .orderBy(desc(posts.createdAt))\n  .limit(10);\n\nconsole.log('Recent posts:', recentPosts);",
+      "notes": "Drizzle with neon-http adapter is optimized for serverless. Install: npm install --save-exact drizzle-orm drizzle-kit. Define your schema in a separate file."
+    }
+  ],
+  "gotchas": [
+    "Neon scales to zero by default, which means the first query after idle has a cold start latency of 100-500ms. For user-facing requests, this can be noticeable. Configure a longer scale-to-zero timeout or keep-alive pings if cold starts are unacceptable.",
+    "The free tier's 190 compute hours/month sounds generous, but if your database doesn't scale to zero (e.g., you keep it warm), you'll use ~190/730 = ~26% of a compute unit continuously, exhausting the free tier in roughly 26% of a month at full utilization.",
+    "Neon uses a different connection pooler (PgBouncer) than standard Postgres. When using Prisma, use the pooled connection string (ends in ?pgbouncer=true) for the application and the direct connection string for migrations.",
+    "Neon database branches are NOT like git branches that you can merge. Schema changes on a branch don't automatically apply to the parent branch. Branching is mainly for isolated development/testing environments."
+  ],
+  "reliability": {
+    "uptimeGuarantee": "99.95% uptime SLA on paid plans",
+    "statusPageUrl": "https://neonstatus.com",
+    "notes": "Neon stores data on AWS S3 with multi-AZ redundancy. Automatic failover and point-in-time recovery on paid plans."
+  },
+  "qualityScore": 8,
+  "qualityJustification": "Best serverless Postgres for cost-sensitive projects — scale-to-zero billing means you only pay for actual usage. Full PostgreSQL compatibility with no compromises (unlike MySQL-based alternatives). Database branching is genuinely useful for CI/CD. Cold start latency is the main tradeoff.",
+  "alternatives": ["supabase", "planetscale", "firebase", "upstash"],
+  "complementary": ["clerk", "stripe", "resend", "supabase"],
+  "bestFor": "Serverless PostgreSQL that scales to zero — ideal for applications with variable traffic, preview environments, and teams using Drizzle or Prisma",
+  "lastVerified": "2026-02-25",
+  "entryVersion": 1,
+  "addedBy": "claude-code-session-2"
+}

package/src/entries/database/planetscale.json

@@ -0,0 +1,95 @@
+{
+  "name": "PlanetScale",
+  "slug": "planetscale",
+  "category": "database",
+  "subcategory": "serverless-mysql",
+  "website": "https://planetscale.com",
+  "description": "PlanetScale is a serverless MySQL-compatible database platform built on Vitess (the technology powering YouTube's database). It offers horizontal sharding, non-blocking schema changes via branching, and a connection architecture optimized for serverless environments — without the operational overhead of managing MySQL.",
+  "useCases": [
+    {
+      "task": "Run MySQL-compatible database workloads at scale without operations",
+      "fit": "perfect"
+    },
+    {
+      "task": "Deploy schema changes safely without table locks in production",
+      "fit": "perfect"
+    },
+    {
+      "task": "Use a serverless-optimized database with connection pooling built in",
+      "fit": "perfect"
+    },
+    {
+      "task": "Use Prisma ORM with a hosted MySQL database",
+      "fit": "perfect"
+    },
+    {
+      "task": "Run complex PostgreSQL-specific features or extensions",
+      "fit": "partial"
+    }
+  ],
+  "auth": {
+    "method": "api_key",
+    "setupSteps": [
+      "Sign up at planetscale.com",
+      "Create a new database",
+      "Create a branch (main is your production branch)",
+      "Go to the branch's Connect tab",
+      "Select your connection method (e.g., Prisma, general) and generate credentials",
+      "Set DATABASE_URL environment variable with the provided connection string"
+    ],
+    "envVarName": "DATABASE_URL",
+    "codeSnippet": "// In .env: DATABASE_URL='mysql://username:password@host/dbname?sslaccept=strict'\n// With Prisma:\nimport { PrismaClient } from '@prisma/client';\nconst prisma = new PrismaClient();"
+  },
+  "pricing": {
+    "model": "freemium",
+    "freeTier": "1 database, 5GB storage, 1 billion row reads/month, 10M row writes/month",
+    "startingPrice": "$39/month (Scaler plan) for 10GB storage, 100B row reads",
+    "costPer": "Scaler: $39/month/database; additional storage at $2.50/GB/month",
+    "pricingUrl": "https://planetscale.com/pricing"
+  },
+  "rateLimits": {
+    "tier": "free tier (Hobby)",
+    "limit": "1 billion row reads/month, 10M row writes/month, 1,000 concurrent connections",
+    "notes": "PlanetScale uses a serverless driver that supports HTTP connections, eliminating traditional connection pool limits for serverless functions.",
+    "retryStrategy": "Use PlanetScale's @planetscale/database serverless driver for edge/serverless environments; it uses fetch() over HTTP instead of TCP connections"
+  },
+  "sdk": {
+    "primaryLanguage": "typescript",
+    "installCommand": "npm install --save-exact @planetscale/database",
+    "importStatement": "import { connect } from '@planetscale/database';",
+    "otherLanguages": ["python", "go", "ruby", "java", "php"]
+  },
+  "codeExamples": [
+    {
+      "title": "Query with the serverless driver",
+      "language": "typescript",
+      "code": "import { connect } from '@planetscale/database';\n\nconst conn = connect({\n  url: process.env.DATABASE_URL!,\n});\n\n// Execute a query\nconst results = await conn.execute(\n  'SELECT * FROM users WHERE email = ? LIMIT 1',\n  ['jane@example.com']\n);\n\nconsole.log('User:', results.rows[0]);\n\n// Insert a record\nconst insert = await conn.execute(\n  'INSERT INTO users (name, email, created_at) VALUES (?, ?, NOW())',\n  ['Jane Smith', 'jane@example.com']\n);\n\nconsole.log('Inserted ID:', insert.insertId);",
+      "notes": "The @planetscale/database driver uses HTTP (fetch) instead of TCP connections — it works in Vercel Edge Functions, Cloudflare Workers, and any serverless environment."
+    },
+    {
+      "title": "Use with Prisma ORM",
+      "language": "typescript",
+      "code": "// prisma/schema.prisma\n// datasource db {\n//   provider     = \"mysql\"\n//   url          = env(\"DATABASE_URL\")\n//   relationMode = \"prisma\"  // Required for PlanetScale (no FK constraints)\n// }\n\nimport { PrismaClient } from '@prisma/client';\n\nconst prisma = new PrismaClient();\n\n// Use normally\nconst users = await prisma.user.findMany({\n  where: { active: true },\n  orderBy: { createdAt: 'desc' },\n  take: 10,\n});\n\nconsole.log('Active users:', users.length);",
+      "notes": "Set relationMode = 'prisma' in your Prisma schema — PlanetScale disables foreign key constraints at the database level (Vitess limitation). Prisma emulates referential integrity in the client."
+    }
+  ],
+  "gotchas": [
+    "PlanetScale disables foreign key constraints at the database level (Vitess architecture). If you use Prisma, you must set relationMode = 'prisma' in your schema. This affects referential integrity — your app must handle cascading deletes manually.",
+    "PlanetScale's branching model means schema changes go through a deploy request process. You cannot run ALTER TABLE in production directly. This is safer but adds workflow complexity for teams used to running raw migrations.",
+    "The Hobby (free) plan was discontinued in 2024 for new signups. Existing Hobby users were grandfathered. New users start on Scaler ($39/month). Verify current pricing before committing.",
+    "Connection strings contain credentials — never commit them to git. Use environment variables and rotate credentials via the PlanetScale dashboard if compromised."
+  ],
+  "reliability": {
+    "uptimeGuarantee": "99.999% uptime SLA on paid plans",
+    "statusPageUrl": "https://www.planetscalestatus.com",
+    "notes": "Built on Vitess (used by YouTube, Slack, GitHub). Automatic failover, point-in-time recovery, and daily automated backups on paid plans."
+  },
+  "qualityScore": 8,
+  "qualityJustification": "Excellent MySQL-compatible serverless database with genuinely innovative schema branching workflow. The serverless HTTP driver is a real differentiator for edge deployments. No foreign key constraints is a significant limitation. Pricing change (removing free tier) reduced accessibility for indie developers.",
+  "alternatives": ["supabase", "neon"],
+  "complementary": ["stripe", "clerk", "resend"],
+  "bestFor": "Production-scale MySQL workloads in serverless/edge environments with safe schema migrations via branch-based deployments",
+  "lastVerified": "2026-02-25",
+  "entryVersion": 1,
+  "addedBy": "claude-code-session-2"
+}

package/src/entries/database/supabase.json

@@ -0,0 +1,94 @@
+{
+  "name": "Supabase",
+  "slug": "supabase",
+  "category": "database",
+  "subcategory": "postgres-platform",
+  "website": "https://supabase.com",
+  "description": "Supabase is an open-source Firebase alternative built on PostgreSQL. It bundles a hosted Postgres database, authentication, file storage, edge functions, and real-time subscriptions into a single platform — making it the fastest way to build a full-stack backend without managing infrastructure.",
+  "useCases": [
+    {
+      "task": "Build a full-stack app backend with database, auth, and storage",
+      "fit": "perfect"
+    },
+    {
+      "task": "Add a managed PostgreSQL database to a Next.js application",
+      "fit": "perfect"
+    },
+    {
+      "task": "Get real-time database updates pushed to the client",
+      "fit": "perfect"
+    },
+    {
+      "task": "Replace Firebase with an open-source, SQL-based alternative",
+      "fit": "perfect"
+    },
+    {
+      "task": "Run complex SQL analytics queries",
+      "fit": "good"
+    }
+  ],
+  "auth": {
+    "method": "api_key",
+    "setupSteps": [
+      "Sign up at supabase.com",
+      "Create a new project (choose a region and set a database password)",
+      "Go to Project Settings > API to find your Project URL and keys",
+      "Copy the Project URL and anon public key (safe for browser) and service_role key (server only)",
+      "Set NEXT_PUBLIC_SUPABASE_URL, NEXT_PUBLIC_SUPABASE_ANON_KEY, and SUPABASE_SERVICE_ROLE_KEY"
+    ],
+    "envVarName": "SUPABASE_SERVICE_ROLE_KEY",
+    "codeSnippet": "import { createClient } from '@supabase/supabase-js';\nconst supabase = createClient(\n  process.env.NEXT_PUBLIC_SUPABASE_URL!,\n  process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!\n);"
+  },
+  "pricing": {
+    "model": "freemium",
+    "freeTier": "2 free projects, 500MB database, 1GB storage, 50MB file uploads",
+    "startingPrice": "$25/month (Pro plan) per project",
+    "costPer": "Pro: $25/project/month includes 8GB DB, 100GB storage, 5GB bandwidth",
+    "pricingUrl": "https://supabase.com/pricing"
+  },
+  "rateLimits": {
+    "tier": "free tier",
+    "limit": "500MB database, projects paused after 1 week of inactivity",
+    "notes": "Free projects are paused after 7 days of inactivity (no requests). You must manually unpause them. Pro projects are never paused.",
+    "retryStrategy": "Use connection pooling (PgBouncer built-in) for serverless functions. Implement exponential backoff for transient errors."
+  },
+  "sdk": {
+    "primaryLanguage": "typescript",
+    "installCommand": "npm install --save-exact @supabase/supabase-js",
+    "importStatement": "import { createClient } from '@supabase/supabase-js';",
+    "otherLanguages": ["python", "dart", "swift", "kotlin", "rust"]
+  },
+  "codeExamples": [
+    {
+      "title": "Query data from a table",
+      "language": "typescript",
+      "code": "import { createClient } from '@supabase/supabase-js';\n\nconst supabase = createClient(\n  process.env.NEXT_PUBLIC_SUPABASE_URL!,\n  process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!\n);\n\n// Fetch all posts with author name\nconst { data, error } = await supabase\n  .from('posts')\n  .select(`\n    id,\n    title,\n    body,\n    created_at,\n    author:users(name, avatar_url)\n  `)\n  .eq('published', true)\n  .order('created_at', { ascending: false })\n  .limit(10);\n\nif (error) throw new Error(error.message);\nconsole.log('Posts:', data);",
+      "notes": "Supabase uses Row Level Security (RLS) to control data access. Enable RLS on all tables and create policies, otherwise the anon key gives full table access."
+    },
+    {
+      "title": "Subscribe to real-time changes",
+      "language": "typescript",
+      "code": "import { createClient } from '@supabase/supabase-js';\n\nconst supabase = createClient(\n  process.env.NEXT_PUBLIC_SUPABASE_URL!,\n  process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!\n);\n\n// Subscribe to INSERT events on 'messages' table\nconst channel = supabase\n  .channel('messages-changes')\n  .on(\n    'postgres_changes',\n    { event: 'INSERT', schema: 'public', table: 'messages' },\n    (payload) => {\n      console.log('New message:', payload.new);\n    }\n  )\n  .subscribe();\n\n// Unsubscribe when done\nreturn () => supabase.removeChannel(channel);",
+      "notes": "Realtime works via WebSockets. It requires enabling Realtime for the specific table in the Supabase dashboard (Table Editor > Realtime). Only works when RLS is enabled."
+    }
+  ],
+  "gotchas": [
+    "Row Level Security (RLS) is disabled by default. If you use the anon key (which is safe to expose in the browser), every user can read and write all rows in all tables unless you enable RLS and write policies. This is the #1 security mistake with Supabase.",
+    "Free tier projects are paused after 7 days of inactivity. The first request after pausing triggers an unpausing process that can take 20-30 seconds. This surprises teams demoing their apps.",
+    "Supabase uses connection pooling via PgBouncer, but serverless functions (Vercel, Netlify) can still exhaust connection limits under load. Use the session-mode connection string (not transaction-mode) for full PostgreSQL feature support.",
+    "The Supabase Auth user IDs are UUIDs stored in auth.users (a separate schema). You typically create a public.users table and use a database trigger to sync users on signup — don't forget this step."
+  ],
+  "reliability": {
+    "uptimeGuarantee": "99.9% uptime SLA on Pro plan and above",
+    "statusPageUrl": "https://status.supabase.com",
+    "notes": "Supabase infrastructure is hosted on AWS. Multiple regions available. Pro plan includes daily database backups (7-day retention)."
+  },
+  "qualityScore": 9,
+  "qualityJustification": "The best Firebase alternative for developers who prefer SQL. Excellent TypeScript SDK, generous free tier, and the combination of auth + storage + database + realtime in one platform reduces infrastructure complexity dramatically. RLS requirement is a feature, not a bug, but does add onboarding complexity.",
+  "alternatives": ["firebase", "neon", "planetscale", "upstash"],
+  "complementary": ["resend", "stripe", "clerk"],
+  "bestFor": "Full-stack Next.js/React apps needing a managed Postgres database with auth, storage, and real-time built in — the open-source Firebase alternative",
+  "lastVerified": "2026-02-25",
+  "entryVersion": 1,
+  "addedBy": "claude-code-session-2"
+}

package/src/entries/database/upstash.json

@@ -0,0 +1,94 @@
+{
+  "name": "Upstash",
+  "slug": "upstash",
+  "category": "database",
+  "subcategory": "serverless-redis",
+  "website": "https://upstash.com",
+  "description": "Upstash provides serverless Redis and Kafka optimized for edge and serverless environments. With per-request pricing and a REST API, it is the go-to solution for caching, rate limiting, session storage, and queuing in Next.js, Vercel Edge Functions, and Cloudflare Workers where persistent TCP connections are not available.",
+  "useCases": [
+    {
+      "task": "Add Redis caching to a serverless or edge function",
+      "fit": "perfect"
+    },
+    {
+      "task": "Implement rate limiting for API routes",
+      "fit": "perfect"
+    },
+    {
+      "task": "Store session data or ephemeral state in serverless apps",
+      "fit": "perfect"
+    },
+    {
+      "task": "Queue background jobs with Redis lists",
+      "fit": "good"
+    },
+    {
+      "task": "Use as primary persistent database",
+      "fit": "partial"
+    }
+  ],
+  "auth": {
+    "method": "api_key",
+    "setupSteps": [
+      "Sign up at upstash.com",
+      "Create a new Redis database (choose region, enable TLS)",
+      "Go to the database details page",
+      "Copy the UPSTASH_REDIS_REST_URL and UPSTASH_REDIS_REST_TOKEN",
+      "Set UPSTASH_REDIS_REST_URL and UPSTASH_REDIS_REST_TOKEN environment variables"
+    ],
+    "envVarName": "UPSTASH_REDIS_REST_TOKEN",
+    "codeSnippet": "import { Redis } from '@upstash/redis';\nconst redis = new Redis({\n  url: process.env.UPSTASH_REDIS_REST_URL!,\n  token: process.env.UPSTASH_REDIS_REST_TOKEN!,\n});"
+  },
+  "pricing": {
+    "model": "freemium",
+    "freeTier": "10,000 commands/day, 256MB max database size",
+    "startingPrice": "$0.20 per 100k commands (Pay-as-you-go, no monthly fee)",
+    "costPer": "$0.20 per 100,000 commands; $0.25/GB storage/month",
+    "pricingUrl": "https://upstash.com/pricing"
+  },
+  "rateLimits": {
+    "tier": "free tier",
+    "limit": "10,000 daily commands; 1MB max request/response size",
+    "notes": "Upstash uses a REST API over HTTP — there are no TCP connection limits. Free tier has a daily command quota. Pro plan has higher quotas and bandwidth.",
+    "retryStrategy": "HTTP-based requests; implement standard exponential backoff for 429 and 5xx responses"
+  },
+  "sdk": {
+    "primaryLanguage": "typescript",
+    "installCommand": "npm install --save-exact @upstash/redis",
+    "importStatement": "import { Redis } from '@upstash/redis';",
+    "otherLanguages": ["python", "go"]
+  },
+  "codeExamples": [
+    {
+      "title": "Cache API responses with TTL",
+      "language": "typescript",
+      "code": "import { Redis } from '@upstash/redis';\n\nconst redis = new Redis({\n  url: process.env.UPSTASH_REDIS_REST_URL!,\n  token: process.env.UPSTASH_REDIS_REST_TOKEN!,\n});\n\nasync function getCachedUser(userId: string): Promise<User | null> {\n  const cacheKey = `user:${userId}`;\n  \n  // Try cache first\n  const cached = await redis.get<User>(cacheKey);\n  if (cached) return cached;\n  \n  // Cache miss — fetch from database\n  const user = await db.users.findUnique({ where: { id: userId } });\n  if (!user) return null;\n  \n  // Cache for 5 minutes\n  await redis.setex(cacheKey, 300, user);\n  return user;\n}",
+      "notes": "Upstash Redis serializes/deserializes JSON automatically via the @upstash/redis client. Use typed generics (get<User>) for type safety."
+    },
+    {
+      "title": "Rate limiting with sliding window",
+      "language": "typescript",
+      "code": "import { Ratelimit } from '@upstash/ratelimit';\nimport { Redis } from '@upstash/redis';\n\nconst ratelimit = new Ratelimit({\n  redis: Redis.fromEnv(),\n  limiter: Ratelimit.slidingWindow(10, '10 s'), // 10 requests per 10 seconds\n  analytics: true,\n});\n\n// In your API route / middleware\nexport async function middleware(request: Request) {\n  const ip = request.headers.get('x-forwarded-for') ?? 'anonymous';\n  const { success, remaining, reset } = await ratelimit.limit(ip);\n  \n  if (!success) {\n    return new Response('Too Many Requests', {\n      status: 429,\n      headers: { 'Retry-After': String(Math.round((reset - Date.now()) / 1000)) },\n    });\n  }\n  \n  return NextResponse.next();\n}",
+      "notes": "Install @upstash/ratelimit separately: npm install --save-exact @upstash/ratelimit. Redis.fromEnv() reads UPSTASH_REDIS_REST_URL and UPSTASH_REDIS_REST_TOKEN automatically."
+    }
+  ],
+  "gotchas": [
+    "Upstash Redis uses a REST API (HTTP), not the native Redis TCP protocol. This means you cannot use the standard 'redis' or 'ioredis' npm packages — you must use @upstash/redis. Libraries that depend on a standard Redis connection (like Bull/BullMQ) won't work directly.",
+    "The free tier (10k commands/day) is exhausted quickly in development with hot reload. A Next.js app with frequent refreshes can easily burn through the daily quota during development. Consider using a separate dev database.",
+    "Upstash Redis is eventually consistent for replicated (global) databases. If you need strong consistency (e.g., distributed locks), use a single-region database.",
+    "Data is not persisted forever by default — Redis has eviction policies. Make sure your eviction policy (noeviction, allkeys-lru, etc.) matches your use case."
+  ],
+  "reliability": {
+    "uptimeGuarantee": "99.99% uptime SLA on paid plans",
+    "statusPageUrl": "https://status.upstash.com",
+    "notes": "Upstash uses AWS and GCP infrastructure. Global replication available for low-latency reads worldwide. REST API works in edge environments where TCP is not available."
+  },
+  "qualityScore": 8,
+  "qualityJustification": "The best serverless Redis solution — the HTTP REST API is a genuine differentiator for edge/serverless environments. @upstash/ratelimit is excellent. Pricing is very competitive with pay-per-use. The incompatibility with standard Redis clients is the main limitation.",
+  "alternatives": ["supabase", "neon"],
+  "complementary": ["supabase", "neon", "clerk"],
+  "bestFor": "Serverless Redis for caching, rate limiting, and session storage in Next.js, Vercel Edge Functions, and Cloudflare Workers",
+  "lastVerified": "2026-02-25",
+  "entryVersion": 1,
+  "addedBy": "claude-code-session-2"
+}