Multitenancy com Prisma e PostgreSQL: Row-Level Security vs Schema por Tenant

// schema.prisma
generator client {
  provider        = "prisma-client-js"
  previewFeatures = ["multiSchema"] // necessário apenas na estratégia 2
}
 
datasource db {
  provider = "postgresql"
  url      = env("DATABASE_URL")
}
 
model Tenant {
  id        String   @id @default(cuid())
  name      String
  slug      String   @unique
  createdAt DateTime @default(now()) @map("created_at")
  users     User[]
  projects  Project[]
 
  @@map("tenants")
}
 
model User {
  id       String @id @default(cuid())
  email    String
  tenantId String @map("tenant_id")
  tenant   Tenant @relation(fields: [tenantId], references: [id])
 
  // índice composto garante que email é único DENTRO do tenant
  @@unique([tenantId, email])
  @@map("users")
}
 
model Project {
  id       String @id @default(cuid())
  name     String
  tenantId String @map("tenant_id")
  tenant   Tenant @relation(fields: [tenantId], references: [id])
 
  @@index([tenantId])
  @@map("projects")
}

-- migrations/20240101_enable_rls.sql
 
-- RLS funciona com uma variável de sessão que a aplicação define antes de cada query
ALTER TABLE users ENABLE ROW LEVEL SECURITY;
ALTER TABLE projects ENABLE ROW LEVEL SECURITY;
 
-- Política: só retorna linhas cujo tenant_id bate com a variável de sessão
-- current_setting com 'true' no segundo argumento retorna string vazia se a variável não existir,
-- em vez de lançar erro (evita quebrar migrations e queries administrativas)
CREATE POLICY tenant_isolation_users ON users
  USING (tenant_id = current_setting('app.current_tenant_id', true))
  WITH CHECK (tenant_id = current_setting('app.current_tenant_id', true));
 
CREATE POLICY tenant_isolation_projects ON projects
  USING (tenant_id = current_setting('app.current_tenant_id', true))
  WITH CHECK (tenant_id = current_setting('app.current_tenant_id', true));
 
-- O superuser e o owner do banco ignoram RLS por padrão.
-- Crie um role separado para a aplicação para que RLS seja efetivo.
CREATE ROLE app_user LOGIN PASSWORD 'senha_segura';
GRANT USAGE ON SCHEMA public TO app_user;
GRANT SELECT, INSERT, UPDATE, DELETE ON ALL TABLES IN SCHEMA public TO app_user;
ALTER DEFAULT PRIVILEGES IN SCHEMA public GRANT SELECT, INSERT, UPDATE, DELETE ON TABLES TO app_user;

// src/lib/prisma-tenant.ts
import { PrismaClient } from "@prisma/client";
 
const prisma = new PrismaClient();
 
// $executeRawUnsafe é necessário aqui porque SET não aceita parâmetros $1.
// O tenantId vem do token JWT já validado, não de input do usuário.
// Se o tenantId vier de fonte não confiável, valide com regex /^[a-z0-9]+$/ antes.
export async function withTenant<T>(
  tenantId: string,
  callback: (tx: PrismaClient) => Promise<T>
): Promise<T> {
  return prisma.$transaction(async (tx) => {
    // SET LOCAL só vale dentro desta transaction, evitando vazamento entre requests
    await tx.$executeRawUnsafe(
      `SET LOCAL app.current_tenant_id = '${tenantId}'`
    );
    return callback(tx as unknown as PrismaClient);
  });
}

// src/routes/projects.ts
import { FastifyInstance } from "fastify";
import { withTenant } from "../lib/prisma-tenant";
 
export async function projectRoutes(app: FastifyInstance) {
  app.get("/projects", async (request, reply) => {
    // tenantId extraído do JWT pelo middleware de autenticação
    const tenantId = request.user.tenantId;
 
    const projects = await withTenant(tenantId, async (tx) => {
      // RLS filtra automaticamente: mesmo sem WHERE tenant_id,
      // o PostgreSQL só retorna linhas do tenant correto
      return tx.project.findMany({
        orderBy: { name: "asc" },
      });
    });
 
    return reply.send(projects);
  });
}

// src/lib/prisma-schema-tenant.ts
import { PrismaClient } from "@prisma/client";
 
// Cache de clients por tenant evita criar conexões a cada request.
// Em produção, limite o tamanho desse Map para não estourar memória
// com milhares de tenants (use LRU cache para mais de 100 tenants).
const clientCache = new Map<string, PrismaClient>();
 
export function getPrismaForTenant(tenantSlug: string): PrismaClient {
  const existing = clientCache.get(tenantSlug);
  if (existing) return existing;
 
  const databaseUrl = process.env.DATABASE_URL!;
  // search_path define qual schema o PostgreSQL usa por padrão nas queries
  const urlWithSchema = `${databaseUrl}&options=-c%20search_path%3Dtenant_${tenantSlug}`;
 
  const client = new PrismaClient({
    datasourceUrl: urlWithSchema,
  });
 
  clientCache.set(tenantSlug, client);
  return client;
}

// src/services/tenant-provisioning.ts
import { PrismaClient } from "@prisma/client";
import { exec } from "child_process";
import { promisify } from "util";
 
const execAsync = promisify(exec);
const adminPrisma = new PrismaClient();
 
export async function provisionTenant(slug: string): Promise<void> {
  // Valida slug para prevenir SQL injection no nome do schema
  if (!/^[a-z0-9_]+$/.test(slug)) {
    throw new Error("Slug do tenant contém caracteres inválidos");
  }
 
  const schemaName = `tenant_${slug}`;
 
  await adminPrisma.$executeRawUnsafe(
    `CREATE SCHEMA IF NOT EXISTS "${schemaName}"`
  );
 
  // prisma migrate deploy aplica todas as migrations pendentes no schema alvo
  const databaseUrl = `${process.env.DATABASE_URL}&options=-c%20search_path%3D${schemaName}`;
  await execAsync(`DATABASE_URL="${databaseUrl}" npx prisma migrate deploy`);
}

// ERRADO: depende 100% da aplicação para isolar dados.
// Um dev esquece o WHERE e vaza dados de todos os tenants.
async function getProjects(tenantId: string) {
  return prisma.project.findMany({
    where: { tenantId }, // se alguém remove esse where, vaza tudo
  });
}
 
// Um endpoint administrativo esquecido sem filtro:
app.get("/admin/all-projects", async () => {
  return prisma.project.findMany(); // retorna projetos de TODOS os tenants
});

// CORRETO: RLS garante isolamento no banco, independente da query
async function getProjects(tenantId: string) {
  return withTenant(tenantId, async (tx) => {
    // mesmo sem WHERE, RLS filtra. Defesa em profundidade.
    return tx.project.findMany();
  });
}

// ERRADO: tenantId vindo direto do header HTTP, sem validação
app.addHook("preHandler", async (request) => {
  const tenantId = request.headers["x-tenant-id"] as string;
  // SQL injection via header: x-tenant-id: '; DROP TABLE users; --
  await prisma.$executeRawUnsafe(
    `SET LOCAL app.current_tenant_id = '${tenantId}'`
  );
});

// CORRETO: tenantId vem do JWT validado + regex de segurança
app.addHook("preHandler", async (request) => {
  const tenantId = request.user.tenantId; // extraído do JWT verificado
  if (!/^[a-zA-Z0-9_-]+$/.test(tenantId)) {
    throw new Error("Tenant ID inválido");
  }
  // agora é seguro usar no SET
});

-- Parece correto, mas o superuser IGNORA todas as políticas RLS.
-- A aplicação roda sem filtro nenhum e você nem percebe.
-- Teste SEMPRE com o role da aplicação, não com o superuser.

// middleware.ts (Next.js)
import { NextRequest, NextResponse } from "next/server";
 
export function middleware(request: NextRequest) {
  // Resolve tenant pelo subdomínio: acme.app.com -> acme
  const hostname = request.headers.get("host") ?? "";
  const subdomain = hostname.split(".")[0];
 
  // Tenants conhecidos poderiam vir de um cache KV na edge
  const isValidTenant = /^[a-z0-9-]+$/.test(subdomain) && subdomain !== "www";
 
  if (!isValidTenant) {
    return NextResponse.redirect(new URL("/not-found", request.url));
  }
 
  // Injeta o tenantId no header para uso nos Server Components e Route Handlers
  const response = NextResponse.next();
  response.headers.set("x-tenant-id", subdomain);
  return response;
}
 
export const config = {
  matcher: ["/((?!_next/static|_next/image|favicon.ico).*)"],
};

// src/tests/tenant-isolation.test.ts
import { PrismaClient } from "@prisma/client";
import { withTenant } from "../lib/prisma-tenant";
 
const prisma = new PrismaClient();
 
async function verifyIsolation() {
  // Cria dois tenants com projetos
  const tenantA = await prisma.tenant.create({
    data: { name: "Tenant A", slug: "tenant-a" },
  });
  const tenantB = await prisma.tenant.create({
    data: { name: "Tenant B", slug: "tenant-b" },
  });
 
  await prisma.project.create({
    data: { name: "Projeto Secreto A", tenantId: tenantA.id },
  });
  await prisma.project.create({
    data: { name: "Projeto Secreto B", tenantId: tenantB.id },
  });
 
  // Query como Tenant A: deve ver APENAS seus projetos
  const projectsFromA = await withTenant(tenantA.id, async (tx) => {
    return tx.project.findMany();
  });
 
  if (projectsFromA.length !== 1 || projectsFromA[0].name !== "Projeto Secreto A") {
    throw new Error("VAZAMENTO: Tenant A viu dados que não deveria");
  }
 
  // Query como Tenant B: deve ver APENAS seus projetos
  const projectsFromB = await withTenant(tenantB.id, async (tx) => {
    return tx.project.findMany();
  });
 
  if (projectsFromB.length !== 1 || projectsFromB[0].name !== "Projeto Secreto B") {
    throw new Error("VAZAMENTO: Tenant B viu dados que não deveria");
  }
 
  console.log("Isolamento verificado: cada tenant vê apenas seus dados");
}
 
verifyIsolation().catch(console.error);