Multi-tenancy SaaS: pool vs silo vs hybrid

-- 1. Toda tabela tem tenant_id (UUID, com FK pra tenants)
CREATE TABLE tenants (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  name TEXT NOT NULL,
  plan TEXT NOT NULL DEFAULT 'pro',
  created_at TIMESTAMPTZ DEFAULT now()
);

CREATE TABLE orders (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  tenant_id UUID NOT NULL REFERENCES tenants(id) ON DELETE CASCADE,
  total NUMERIC(12,2),
  created_at TIMESTAMPTZ DEFAULT now()
);

-- 2. Index composto começando por tenant_id (planner usa como filtro inicial)
CREATE INDEX orders_tenant_created_idx ON orders (tenant_id, created_at DESC);

-- 3. Habilita RLS na tabela
ALTER TABLE orders ENABLE ROW LEVEL SECURITY;
ALTER TABLE orders FORCE ROW LEVEL SECURITY; -- pega até o owner

-- 4. Policy: cada SELECT/INSERT/UPDATE/DELETE filtra pelo session setting
CREATE POLICY tenant_isolation ON orders
  USING (tenant_id = current_setting('app.tenant_id', true)::uuid)
  WITH CHECK (tenant_id = current_setting('app.tenant_id', true)::uuid);

// middleware/tenant.ts
import { db } from '@/lib/db';

export async function withTenant<T>(
  tenantId: string,
  fn: () => Promise<T>,
): Promise<T> {
  return db.transaction(async (tx) => {
    // SET LOCAL escopa o setting à transação — limpa no commit/rollback
    await tx.execute(`SET LOCAL app.tenant_id = '${tenantId}'`);
    return fn();
  });
}

// uso em route handler
export async function GET(req: Request) {
  const tenantId = await getTenantFromJWT(req);
  return withTenant(tenantId, async () => {
    const orders = await db.select().from(orders); // RLS filtra automaticamente
    return Response.json(orders);
  });
}

-- Habilita extensão Citus
CREATE EXTENSION citus;

-- Marca tabela como distribuída por tenant_id
SELECT create_distributed_table('orders', 'tenant_id');
SELECT create_distributed_table('events', 'tenant_id');

-- Tabelas de referência (pequenas, replicadas em todos os shards)
SELECT create_reference_table('countries');

-- Query típica: por tenant_id → vai pra 1 shard só (single-node performance)
SELECT * FROM orders WHERE tenant_id = '...' AND created_at > now() - interval '7 days';

-- Cross-tenant: scatter-gather paralelizado
SELECT count(*) FROM orders WHERE created_at > now() - interval '1 day';

// Backend gera pre-signed URL com tenant_id validado
import { S3Client, PutObjectCommand } from '@aws-sdk/client-s3';
import { getSignedUrl } from '@aws-sdk/s3-request-presigner';

export async function getUploadUrl(tenantId: string, filename: string) {
  // tenant_id na key — backend SEMPRE controla
  const key = `${tenantId}/uploads/${crypto.randomUUID()}-${filename}`;
  const cmd = new PutObjectCommand({
    Bucket: 'meu-saas-prod',
    Key: key,
    ContentType: 'application/octet-stream',
  });
  const url = await getSignedUrl(s3Client, cmd, { expiresIn: 300 });
  return { url, key };
}

// Cliente uploada direto para S3 com PUT
// Servidor só sabe da key — armazena em DB ligada ao tenant_id
// Nunca aceita key que o cliente envia (poderia escrever em outro tenant)