eduardweb.
Prisma ORMAvansat#typescript#prisma#postgresql#backend#zod

Prisma $queryRaw: de la agregări lente la SQL curat și type-safe cu Zod

De Sorin Tudor, 24 oct. 2026 · 30 vizualizări · 2 like-uri

Postat 24 oct. 2026
typescript
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 ...) sau GROUP BY compus pe tabele legate.
  • Prisma încearcă să rezolve relațiile prin multiple query-uri separate în loc de un singur LEFT JOIN optimizat.
  • Trebuie să fac bulk insert sau update cu logică de ON CONFLICT DO UPDATE specifică 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?

Răspunsuri 0

Se încarcă răspunsurile…

Loghează-te pentru a răspunde

Doar membrii comunității pot lăsa comentarii.