import { PrismaClient } from '@prisma/client';
import { z } from 'zod';
const prisma = new PrismaClient();
// Zod rezolvă problema BigInt-ului și a timestamp-urilor venite din raw SQL
const SpenderReportSchema = z.object({
userId: z.string().uuid(),
orderCount: z.coerce.number(),
totalSpent: z.coerce.number(),
lastOrderDate: z.coerce.date(),
});
export type SpenderReport = z.infer<typeof SpenderReportSchema>;
export async function getTopSpenders(minSpent: number, limit: number): Promise<SpenderReport[]> {
// Prisma parametrează nativ variabilele minSpent și limit -> zero SQL injection
const rawRows = await prisma.$queryRaw<unknown>`
SELECT
u.id AS "userId",
COUNT(o.id) AS "orderCount",
SUM(o.amount) AS "totalSpent",
MAX(o."createdAt") AS "lastOrderDate"
FROM "User" u
INNER JOIN "Order" o ON o."userId" = u.id
WHERE o.status = 'PAID'
GROUP BY u.id
HAVING SUM(o.amount) >= ${minSpent}
ORDER BY "totalSpent" DESC
LIMIT ${limit};
`;
return z.array(SpenderReportSchema).parse(rawRows);
}Prisma e excelent pentru 80% din CRUD-ul zilnic, dar crapă subtil când ai rapoarte complexe sau agregări grele. La un proiect de e-commerce cu vreo 140k comenzi pe lună, un endpoint de analytics dura 1.8 secunde pentru că Prisma genera join-uri oribile și aducea coloane inutile în memorie. Coborând direct la $queryRaw, am tăiat timpul la sub 90ms dintr-o singură mișcare.
Totuși, în clipa în care scrii SQL de mână într-o aplicație TypeScript, pierzi cele două mari avantaje ale ORM-ului: tipurile automate și protecția implicită la greșeli de începător.
Când lași ORM-ul deoparte
Nu rescrie totul în SQL brut doar pentru că poți. Trade-off-ul e direct: câștigi viteză brută și acces la funcții specifice Postgres (cum ar fi window functions, CTE-uri recursive sau full-text search nativ prin tsvector), dar pierzi refactoring-ul automat când schimbi coloane în schema.prisma.
Cobor la $queryRaw doar când:
- Am agregări condiționate cu
FILTER (WHERE ...)sauGROUP BYcompus pe tabele legate. - Prisma încearcă să rezolve relațiile prin multiple query-uri separate în loc de un singur
LEFT JOINoptimizat. - Trebuie să fac bulk insert sau update cu logică de
ON CONFLICT DO UPDATEspecifică unui dialect.
Capcana de SQL Injection: Template literals nu sunt ce par
Cea mai mare confuzie pe care o văd la juniori și mid devs vine din sintaxa de tagged template. În mod normal, în JavaScript, ${variabila} bagă valoarea direct ca text. Dacă faci asta în SQL, ești vulnerabil la injection instant.
Prisma folosește un Tagged Template sub capotă (Prisma.sql). Asta înseamnă că atunci când scrii prisma.$queryRaw`SELECT * FROM users WHERE id = ${userId}`, Prisma nu concatenează string-ul. Îl transformă într-un query pregătit (prepared statement) cu parametri: SELECT * FROM users WHERE id = $1.
Unde apare dezastrul? Când cineva folosește $queryRawUnsafe dintr-o comoditate sau când încearcă să dinamizeze numele tabelelor sau clauza de ORDER BY. Dacă ai neapărat nevoie de identificatori dinamici (nume de coloane sortate), folosește Prisma.raw() doar după ce ai trecut string-ul printr-un whitelist strict de valori permise.
TypeScript te minte la raw queries, Zod nu
Prisma îți permite să pasezi un generic: prisma.$queryRaw<UserReport[]>.
Problema e că acel generic este o minciună convenabilă. Este un simplu type assertion (as UserReport[]). Dacă baza de date întoarce BigInt (pe care Postgres îl dă mereu la COUNT și pe care JSON.stringify nu știe să-l serializeze), TypeScript nu va zice nimic la build, dar o să-ți crape runtime-ul în producție cu TypeError: Do not know how to serialize a BigInt.
Soluția mea standard: tipizez rezultatul ca unknown și îl trec printr-o schemă strictă de Zod folosind z.coerce. Astfel rezolv la runtime serializarea numerelor mari, datele de tip timestamp și eventualele valori null neașteptate venite din join-uri.
Voi cum gestionați raportarea grea: coborâți la raw SQL în Prisma, folosiți Kysely ca query builder peste aceeași conexiune, sau mutați totul în views/read replicas dedicate?