import { PrismaClient } from '@prisma/client';
import { z } from 'zod';
const prisma = new PrismaClient();
const MonthlyRevenueSchema = z.object({
month: z.date(),
total_amount: z.coerce.number(),
orders_count: z.coerce.number(),
});
export type MonthlyRevenue = z.infer<typeof MonthlyRevenueSchema>;
export async function getRevenueReport(storeId: string, minAmount: number) {
// 1. Tagged template-ul transformă variabilele în parametri bindați ($1, $2)
const rawData = await prisma.$queryRaw`
SELECT
DATE_TRUNC('month', "createdAt") as month,
SUM("amount") as total_amount,
COUNT("id") as orders_count
FROM "Order"
WHERE "storeId" = ${storeId}
GROUP BY 1
HAVING SUM("amount") >= ${minAmount}
ORDER BY 1 DESC
`;
// 2. Validăm runtime. Zod forțează conversia corectă pentru BigInt / Decimal
return z.array(MonthlyRevenueSchema).parse(rawData);
}Am jurat mulți ani că țin Prisma pur în tot proiectul, până când am lovit un perete la o aplicație cu peste 3 milioane de tranzacții. Un raport de vânzări scris prin ORM-ul standard scotea un monstru de query cu 6 JOIN-uri inutile și dura 1.4 secunde; rescris de mână cu un recursive CTE și o fereastră analitică, a scăzut la 42ms. Când ai nevoie de viteză sau sintaxă specifică de Postgres, $queryRaw este singura scăpare rațională.
Când lași ORM-ul și cobori la metal
Prisma este excelent pentru operațiuni CRUD și mutații simple unde vrei include și select sigure. Devine groaznic când ai nevoie de:
- Window functions (
ROW_NUMBER(),RANK(),LEAD/LAG). - Recursive CTE-uri pentru structuri arborescente.
- Agregări complexe pe tabele masive unde vrei să controlezi planul de execuție și index scan-ul.
Trade-off-ul e direct: câștigi control total pe performanță, dar pierzi maparea automată a relațiilor, iar dacă schimbi o coloană prin migrare, TypeScript nu te mai avertizează la build time că query-ul tău e bușit.
Iluzia securității și capcana SQL injection
Mulți dezvoltatori cred eronat că template string-ul din $queryRaw face concatenare brută. Nu o face. Prisma folosește tagged templates pentru a transforma variabilele în parametri pregătiți ($1, $2 în Postgres):
// ASTA ESTE SAFE (Prisma parameterizează automat status-ul)
const status = 'ACTIVE';
await prisma.$queryRaw`SELECT * FROM "User" WHERE status = ${status}`;
Problema apare când devii leneș sau ai filtre dinamice și apelezi la $queryRawUnsafe, sau când folosești Prisma.raw() pentru identificatori (nume de tabele, coloane pentru ORDER BY) veniți direct din query params-urile unui API. Regula e simplă: dacă numele coloanei vine din exterior, trece-l printr-un whitelist dur (un enum sau un array static), niciodată prin Prisma.raw(req.query.sort).
TypeScript te minte: de ce generic-ul din Prisma nu e suficient
Prisma te lasă să scrii prisma.$queryRaw<UserStats[]> și ai impresia că ești safe. Nu ești. Genericul din TypeScript este doar o aserțiune de tip (type cast mascat). Dacă baza de date întoarce un bigint serializat ca string, un null pe o coloană unde nu te așteptai, sau driverul Node formatează data altfel, TypeScript tace și aplicația crapă în runtime când accesezi proprietatea.
Soluția sănătoasă este să tratezi ieșirea din $queryRaw ca unknown și să o treci printr-o schemă Zod. Dacă DB-ul întoarce o structură neașteptată, prefer să arunc o eroare clară la deserializare decât să am date corupte în business logic.
Voi ce convenție aveți în echipă când ORM-ul devine gâtuit: rescrieți raw în repository sau mutați agregările grele direct în View-uri și proceduri stocate în Postgres?