Integración con bases de datos

Configuración inicial

Conexión

// config/database.js
import mongoose from 'mongoose'

const connectDB = async () => {
  try {
    await mongoose.connect(process.env.MONGODB_URI)
    console.log('MongoDB conectado')
  } catch (error) {
    console.error('Error conectando a MongoDB:', error)
    process.exit(1)
  }
}

export default connectDB

Modelo

// models/User.js
import mongoose from 'mongoose'

const userSchema = new mongoose.Schema({
  name: { type: String, required: true },
  email: { type: String, required: true, unique: true },
  password: { type: String, required: true },
  createdAt: { type: Date, default: Date.now }
})

export const User = mongoose.models.User || mongoose.model('User', userSchema)

Uso

// pages/api/users.js
import { User } from '@/models/User'

export async function GET(req) {
  try {
    const users = await User.find({})
    return Response.json({ users })
  } catch (error) {
    return Response.json({ error: error.message }, { status: 500 })
  }
}

Configuración inicial

Conexión

// lib/supabase.js
import { createClient } from '@supabase/supabase-js'

const supabaseUrl = process.env.NEXT_PUBLIC_SUPABASE_URL
const supabaseKey = process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY

export const supabase = createClient(supabaseUrl, supabaseKey)

Modelo

// No necesitas definir modelos explícitamente en Supabase
// Ejemplo de estructura de tabla:
/*
  create table users (
    id uuid default uuid_generate_v4() primary key,
    name text not null,
    email text unique not null,
    created_at timestamp with time zone default timezone('utc'::text, now())
  );
*/

Uso

// components/UserList.jsx
import { supabase } from '@/lib/supabase'

export async function getUsers() {
  try {
    const { data, error } = await supabase
      .from('users')
      .select('*')
    
    if (error) throw error
    return data
  } catch (error) {
    console.error('Error:', error)
    return null
  }
}

Configuración inicial

Conexión

// convex/_generated/api.js
import { ConvexProvider, ConvexReactClient } from 'convex/react'

const convex = new ConvexReactClient(process.env.NEXT_PUBLIC_CONVEX_URL)

export function ConvexClientProvider({ children }) {
  return (
    <ConvexProvider client={convex}>
      {children}
    </ConvexProvider>
  )
}

Modelo

// convex/schema.ts
import { defineSchema, defineTable } from 'convex/server'
import { v } from 'convex/values'

export default defineSchema({
  users: defineTable({
    name: v.string(),
    email: v.string(),
    createdAt: v.number()
  })
})

Uso

// convex/users.js
import { query, mutation } from './_generated/server'

export const getUsers = query(async ({ db }) => {
  return await db.query('users').collect()
})

export const createUser = mutation(async ({ db }, { name, email }) => {
  await db.insert('users', {
    name,
    email,
    createdAt: Date.now()
  })
})

Configuración inicial

Conexión

// lib/mysql.js
import mysql from 'mysql2/promise'

export async function query({ query, values = [] }) {
  const connection = await mysql.createConnection({
    host: process.env.MYSQL_HOST,
    database: process.env.MYSQL_DATABASE,
    user: process.env.MYSQL_USER,
    password: process.env.MYSQL_PASSWORD
  })

  try {
    const [results] = await connection.execute(query, values)
    connection.end()
    return results
  } catch (error) {
    throw Error(error.message)
    return null
  }
}

Modelo

-- schema.sql
CREATE TABLE users (
  id INT AUTO_INCREMENT PRIMARY KEY,
  name VARCHAR(255) NOT NULL,
  email VARCHAR(255) UNIQUE NOT NULL,
  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

Uso

// pages/api/users.js
import { query } from '@/lib/mysql'

export async function GET(req) {
  try {
    const users = await query({
      query: 'SELECT * FROM users'
    })
    return Response.json({ users })
  } catch (error) {
    return Response.json({ error: error.message }, { status: 500 })
  }
}

Configuración inicial

Conexión

// lib/prisma.js
import { PrismaClient } from '@prisma/client'

const globalForPrisma = global as unknown as { prisma: PrismaClient }

export const prisma = globalForPrisma.prisma || new PrismaClient()

if (process.env.NODE_ENV !== 'production') globalForPrisma.prisma = prisma

Modelo

// prisma/schema.prisma
datasource db {
  provider = "postgresql"
  url      = env("DATABASE_URL")
}

generator client {
  provider = "prisma-client-js"
}

model User {
  id        Int      @id @default(autoincrement())
  name      String
  email     String   @unique
  createdAt DateTime @default(now())
}

Uso

// pages/api/users.js
import { prisma } from '@/lib/prisma'

export async function GET(req) {
  try {
    const users = await prisma.user.findMany()
    return Response.json({ users })
  } catch (error) {
    return Response.json({ error: error.message }, { status: 500 })
  }
}