Bases de datos en Next.js: ORM, patrones y Edge Runtime

import 'server-only';
import { PrismaClient } from '@prisma/client';

const prismaClientSingleton = () => {
  return new PrismaClient({
    log: process.env.NODE_ENV === 'development' ? ['query', 'error', 'warn'] : ['error'],
  });
};

type PrismaClientSingleton = ReturnType<typeof prismaClientSingleton>;

const globalForPrisma = globalThis as unknown as {
  prisma: PrismaClientSingleton | undefined;
};

// Reutilizamos la instancia en desarrollo o creamos una nueva en producción
export const db = globalForPrisma.prisma ?? prismaClientSingleton();

if (process.env.NODE_ENV !== 'production') {
  globalForPrisma.prisma = db;
}

import 'server-only';
import { neon } from '@neondatabase/serverless';
import { drizzle } from 'drizzle-orm/neon-http';
import { pgTable, serial, text, timestamp, integer } from 'drizzle-orm/pg-core';
import { eq } from 'drizzle-orm';

// Esquema declarativo de tabla en TypeScript puro
export const usersTable = pgTable('users', {
  id: serial('id').primaryKey(),
  name: text('name').notNull(),
  email: text('email').notNull().unique(),
  balance: integer('balance').default(0).notNull(),
  createdAt: timestamp('created_at').defaultNow().notNull(),
});

// Inicialización de cliente HTTP: no requiere Singleton y no retiene sockets TCP abiertos
const sql = neon(process.env.DATABASE_URL!);
export const db = drizzle(sql);

// Consulta segura y fuertemente tipada
export async function getActiveUsers() {
  return db
    .select({
      id: usersTable.id,
      name: usersTable.name,
      email: usersTable.email,
    })
    .from(usersTable)
    .limit(50);
}

import { db } from '@/lib/db';
import { Suspense } from 'react';

interface UsersPageProps {
  searchParams: Promise<{ role?: string }>;
}

export default async function UsersPage({ searchParams }: UsersPageProps) {
  // En Next.js 15+, searchParams es una Promise asíncrona
  const { role } = await searchParams;

  const users = await db.user.findMany({
    where: role ? { role } : undefined,
    orderBy: { createdAt: 'desc' },
    select: { id: true, name: true, email: true }, // Protección: seleccionar solo campos públicos
    take: 50,
  });

  if (users.length === 0) {
    return (
      <div className="p-8 text-center text-text-muted">
        No se encontraron usuarios.
      </div>
    );
  }

  return (
    <div className="space-y-4">
      <h1 className="text-2xl font-bold text-text-primary">Lista de usuarios</h1>
      <ul className="divide-y divide-border rounded-lg border border-border">
        {users.map((user) => (
          <li key={user.id} className="p-4 flex justify-between items-center">
            <span className="font-medium text-text-primary">{user.name}</span>
            <span className="text-xs text-text-muted font-mono">{user.email}</span>
          </li>
        ))}
      </ul>
    </div>
  );
}

'use server';

import { z } from 'zod';
import { db } from '@/lib/db';
import { auth } from '@/lib/auth';
import { revalidatePath } from 'next/cache';

const CheckoutSchema = z.object({
  amount: z.coerce.number().positive('El importe debe ser superior a cero').max(1_000_000),
  description: z.string().min(3).max(255).optional(),
});

export type CheckoutState = {
  status: 'idle' | 'success' | 'error';
  message?: string;
};

export async function checkoutAction(
  prevState: CheckoutState,
  formData: FormData
): Promise<CheckoutState> {
  // 1. Obtención segura del usuario desde la sesión en el servidor (prevención de IDOR)
  const session = await auth();
  if (!session?.user?.id) {
    return { status: 'error', message: 'Se requiere inicio de sesión.' };
  }

  // 2. Validación de entradas mediante Zod
  const validated = CheckoutSchema.safeParse({
    amount: formData.get('amount'),
    description: formData.get('description') || undefined,
  });

  if (!validated.success) {
    return {
      status: 'error',
      message: validated.error.issues[0].message,
    };
  }

  const { amount, description } = validated.data;
  const userId = session.user.id;

  try {
    // 3. Transacción atómica en la base de datos
    await db.$transaction(async (tx) => {
      // Bloqueo y verificación de saldo disponible
      const user = await tx.user.findUnique({
        where: { id: userId },
        select: { balance: true },
      });

      if (!user || user.balance < amount) {
        throw new Error('INSUFFICIENT_FUNDS'); // Provoca ROLLBACK automático
      }

      // Deducción del saldo
      await tx.user.update({
        where: { id: userId },
        data: { balance: { decrement: amount } },
      });

      // Creación del registro del pedido
      await tx.order.create({
        data: {
          userId,
          amount,
          status: 'COMPLETED',
          description: description ?? 'Pago de pedido',
        },
      });
    });

    // 4. Invalidación de caché en el servidor
    revalidatePath('/dashboard/orders');
    return { status: 'success', message: '¡Pago completado con éxito!' };

  } catch (err: unknown) {
    const isFundsError = err instanceof Error && err.message === 'INSUFFICIENT_FUNDS';
    return {
      status: 'error',
      message: isFundsError ? 'Saldo insuficiente en la cuenta.' : 'Error al procesar el pago.',
    };
  }
}

import 'server-only';
import { cache } from 'react';
import { db } from '@/lib/db';
import { auth } from '@/lib/auth';
import { redirect } from 'next/navigation';

// Interfaz DTO: define de forma estricta los atributos autorizados para el cliente
export interface UserProfileDTO {
  id: string;
  name: string;
  email: string;
  avatarUrl: string | null;
}

// React cache() memoiza el resultado de la Promise durante el renderizado del request
export const getCurrentUser = cache(async (): Promise<UserProfileDTO | null> => {
  const session = await auth();
  if (!session?.user?.id) return null;

  const user = await db.user.findUnique({
    where: { id: session.user.id },
    select: {
      id: true,
      name: true,
      email: true,
      avatarUrl: true,
      // passwordHash: EXCLUIDO — jamás se filtrará en el RSC Flight Payload
    },
  });

  return user;
});

export const requireAdmin = cache(async () => {
  const session = await auth();
  if (!session?.user?.id) {
    redirect('/login');
  }

  const user = await db.user.findUnique({
    where: { id: session.user.id },
    select: { role: true },
  });

  if (user?.role !== 'ADMIN') {
    redirect('/unauthorized');
  }
});