Debate para devs 💬: ¿Cuál es el futuro de las bases de datos?

// Con Prisma (el ORM que no apesta)
import { PrismaClient } from '@prisma/client'
 
const prisma = new PrismaClient()
 
// Queries type-safe
async function buscarProductos(filtros) {
  return await prisma.producto.findMany({
    where: {
      especificaciones: {
        path: ['color'],
        equals: filtros.color
      },
      precio: {
        lte: filtros.precioMax
      }
    },
    include: {
      reviews: {
        orderBy: { fecha: 'desc' },
        take: 5
      }
    }
  })
}
 
// La magia: TypeScript sabe exactamente qué devuelve esto
const productos = await buscarProductos({ 
  color: 'rojo', 
  precioMax: 1000 
})

// Neon Serverless Postgres
import { neon } from '@neondatabase/serverless'
 
// HTTP-based, sin pool de conexiones
const sql = neon(process.env.DATABASE_URL)
 
export default async function handler(req) {
  // Cada query es HTTP, escala infinitamente
  const users = await sql`
    SELECT * FROM users 
    WHERE email = ${req.body.email}
  `
  
  return Response.json(users)
}

import { createClient } from '@libsql/client'
 
const db = createClient({
  url: 'libsql://your-db.turso.io',
  authToken: process.env.TURSO_TOKEN
})
 
// Esto corre en el edge, cerca del usuario
export default async function handler(req) {
  const result = await db.execute({
    sql: 'SELECT * FROM posts WHERE slug = ?',
    args: [req.params.slug]
  })
  
  // Latencia: <10ms desde cualquier parte del mundo
  return new Response(JSON.stringify(result))
}

// Dentro de un Cloudflare Worker
export default {
  async fetch(request, env) {
    const { results } = await env.DB.prepare(
      'SELECT * FROM products WHERE category = ?'
    ).bind('electronics').all()
    
    return Response.json(results)
  }
}

import { PineconeClient } from '@pinecone-database/pinecone'
import OpenAI from 'openai'
 
const pinecone = new PineconeClient()
await pinecone.init({
  apiKey: process.env.PINECONE_API_KEY,
  environment: 'us-west1-gcp'
})
 
const openai = new OpenAI()
 
// 1. Crear embeddings de tu documentación
async function indexarDocs(documentos) {
  const index = pinecone.Index('docs')
  
  for (const doc of documentos) {
    const embedding = await openai.embeddings.create({
      model: 'text-embedding-3-small',
      input: doc.contenido
    })
    
    await index.upsert([{
      id: doc.id,
      values: embedding.data[0].embedding,
      metadata: { texto: doc.contenido }
    }])
  }
}
 
// 2. Buscar contexto relevante
async function buscarContexto(pregunta) {
  const index = pinecone.Index('docs')
  
  const questionEmbedding = await openai.embeddings.create({
    model: 'text-embedding-3-small',
    input: pregunta
  })
  
  const results = await index.query({
    vector: questionEmbedding.data[0].embedding,
    topK: 5,
    includeMetadata: true
  })
  
  return results.matches.map(m => m.metadata.texto)
}
 
// 3. Usar en un chatbot
async function responderPregunta(pregunta) {
  const contexto = await buscarContexto(pregunta)
  
  const respuesta = await openai.chat.completions.create({
    model: 'gpt-4-turbo',
    messages: [
      {
        role: 'system',
        content: `Responde basándote en este contexto: ${contexto.join('\n')}`
      },
      { role: 'user', content: pregunta }
    ]
  })
  
  return respuesta.choices[0].message.content
}

import { QdrantClient } from '@qdrant/js-client-rest'
 
const client = new QdrantClient({ url: 'http://localhost:6333' })
 
// Mismo concepto, self-hosted, gratis
await client.upsert('docs', {
  points: [
    {
      id: 1,
      vector: [0.1, 0.2, 0.3, ...],
      payload: { texto: 'contenido del doc' }
    }
  ]
})

-- Postgres puede hacer queries de grafos
WITH RECURSIVE friends AS (
  SELECT id, name FROM users WHERE id = 1
  UNION
  SELECT u.id, u.name 
  FROM users u
  JOIN friendships f ON u.id = f.friend_id
  JOIN friends fr ON f.user_id = fr.id
)
SELECT * FROM friends;

import { PowerSyncDatabase } from '@powersync/web'
 
const db = new PowerSyncDatabase({
  schema: mySchema,
  database: { dbFilename: 'app.db' }
})
 
// Funciona offline
await db.execute('INSERT INTO todos (text) VALUES (?)', ['Comprar leche'])
 
// Sync automático cuando hay conexión
await db.connect({
  powerSyncUrl: 'https://myapp.powersync.com',
  token: userToken
})

// Stack recomendado 2024
const stack = {
  primary: 'Neon PostgreSQL',        // Datos transaccionales
  cache: 'Upstash Redis',            // Cache + rate limiting  
  search: 'Meilisearch',             // Full-text search
  ai: 'pgvector en Postgres',        // Embeddings (empieza simple)
  analytics: 'Tinybird',             // ClickHouse managed
  fileStorage: 'Cloudflare R2'       // S3-compatible, más barato
}

// lib/db.ts
import { PrismaClient } from '@prisma/client'
import { Redis } from '@upstash/redis'
 
export const prisma = new PrismaClient()
export const redis = Redis.fromEnv()
 
// Helper para cache con Redis
export async function cached<T>(
  key: string,
  fetcher: () => Promise<T>,
  ttl: number = 3600
): Promise<T> {
  const cached = await redis.get(key)
  if (cached) return cached as T
  
  const fresh = await fetcher()
  await redis.setex(key, ttl, JSON.stringify(fresh))
  return fresh
}
 
// Uso
const users = await cached(
  'users:active',
  () => prisma.user.findMany({ where: { active: true } }),
  300 // 5 minutos
)