Գնահատել նախագիծը
← Բոլոր հրապարակումները

5 պատճառ, թե ինչու Drizzle ORM-ը գերազանցում է ավանդական JavaScript ORM-ներին

Բացահայտեք հինգ պատճառ, թե ինչու արժե ավելի ուշադիր նայել Drizzle ORM-ին, մասնավորապես արդյունավետության, հարցումների նկատմամբ լիարժեք վերահսկողության և մաքուր TypeScript ճարտարապետության առումով։

18 րոպե
typescriptJavaScriptORMDrizzle

TypeScript էկոհամակարգը արագ աճում է և ավանդական JavaScript ORM-ների (Object Relational Mapping) փոխարեն բերում է ավելի լավ, ավելի անվտանգ այլընտրանքներ։ Drizzle-ը և Prisma-ն դրանց թվում ամենաուշագրավներից են։ Թեև երկուսն էլ թույլ են տալիս մշակողներին աշխատել տվյալների բազաների հետ տիպով անվտանգ եղանակով, դրանք մարմնավորում են տարբեր փիլիսոփայություններ։

Այս հոդվածում ես կկենտրոնանամ 5 պատճառի վրա, թե ինչու Drizzle ORM-ն արժանի է ձեր ուշադրությանը, մասնավորապես.

  • արդյունավետություն,
  • հարցումների նկատմամբ լիարժեք վերահսկողություն,
  • մաքուր TypeScript ճարտարապետություն։

1. Առաջնակարգ մշակողի փորձ

Drizzle ORM-ը ստեղծված է այն մշակողների համար, ովքեր ուզում են լիակատար պատկերացում և վերահսկողություն իրենց տվյալների շերտի նկատմամբ՝ առանց կոդավորման հարմարավետությունը զոհաբերելու։

Այն տրամադրում է.

  • հիանալի IntelliSense աջակցություն՝ ավտոմատ լրացմամբ, տիպերի ածանցմամբ և ներկառուցված փաստաթղթերով,
  • տիպային անվտանգություն կոմպիլյացիայի ժամանակ, այնպես որ եթե հարցումը սխալ է, TypeScript-ը կզգուշացնի ձեզ,
  • կլիենտի ստեղծման քայլի բացակայություն, ինչը նշանակում է ավելի քիչ շարժվող մաս և ավելի արագ իտերացիա։

Վերջին կետի մասին. ի տարբերություն Prisma-ի նման ORM-ների, Drizzle-ին լրացուցիչ քայլ պետք չէ սխեմայից կլիենտ գրադարան ստեղծելու համար։ Prisma-ում տվյալների բազայի սխեման սահմանում եք .prisma ֆայլում, իսկ հետո, հատուկ TypeScript կլիենտ ստեղծելու համար, պետք է գործարկել հրամանը.

npx prisma generate

Ստացված կլիենտը ծառայում է որպես ինտերֆեյս դեպի տվյալների բազա և պետք է վերաստեղծվի սխեմայի յուրաքանչյուր փոփոխության ժամանակ։

Kysely-ն TypeScript էկոհամակարգի մեկ այլ հայտնի գրադարան է։ Դա թեթև, տիպով անվտանգ SQL query builder է, որը նույնպես նպատակ ունի հեշտացնել մշակողների կյանքը։ Prisma-ի նման՝ Kysely-ին առանձին քայլ է պետք տիպերի մասին տեղեկությունը կոդ ներմուծելու համար։ Մշակողները սովորաբար կա՛մ ինտերֆեյսները գրում են ձեռքով, կա՛մ ապավինում են արտաքին գործիքների, ինչպիսին kysely-codegen-ն է, որը ստուգում է տվյալների բազայի սխեման և իրական աղյուսակներից ստեղծում TypeScript սահմանումներ.

Այսպիսով, թեև Kysely-ն տալիս է մեծ ճկունություն և ուժեղ տիպավորում, այն նաև ավելացնում է լրացուցիչ քայլեր և գործիքակազմ՝ տիպերը տվյալների բազայի հետ համաձայնեցված պահելու համար։ Սխեման հաճախ գտնվում է հավելվածի կոդից դուրս, և երկուսը կապված պահելը կարող է սխալների աղբյուր լինել կամ հանգեցնել անհետևողական տիպավորման, եթե որևէ մեկը բաց թողնի ստեղծման քայլը։

Drizzle-ը այս ամենից ազատվում է։ Սխեմայի ֆայլերի և կոդի գեներացիայի վրա ապավինելու փոխարեն՝ Drizzle-ը մշակողներին թույլ է տալիս տվյալների բազայի սխեման սահմանել անմիջապես TypeScript-ով, և հարցումները գրվում են այդ սխեմայի դեմ՝ բնիկ TypeScript արտահայտություններով։ Չկա միջանկյալ կլիենտի շերտ, կոմպիլյացիայի քայլ և հնարավորություն, որ տիպերը հեռանան իրական սխեմայից։

Արդյունքը.

  • ավելի արագ իտերացիա (մշակողները կլիենտի ստեղծմանը սպասելու կարիք չունեն),
  • ավելի նիհար գործիքակազմեր,
  • ավելի քիչ սխալներ, որոնք առաջանում են սխեմաների և կլիենտների համաժամանակությունը կորցնելուց,
  • ավելի հարթ ադապտացիա նոր մշակողների համար (քանի որ այն, ինչ տեսնում են կոդում, հենց այն է, ինչ ստանում են)։

Drizzle-ի մոտեցումը մշակողի փորձը դարձնում է ավելի թափանցիկ և ուղիղ և ավելի լավ է համապատասխանում ժամանակակից TypeScript աշխատանքային հոսքերին։

Աղյուսակի սահմանումը կարող է այսպիսի տեսք ունենալ.

import { pgTable, uuid, varchar, timestamp } from 'drizzle-orm/pg-core';

export const users = pgTable('users', {
  id: uuid('id').primaryKey().defaultRandom(),
  email: varchar('email').notNull().unique()
  createdAt: timestamp('created_at')
.notNull()
.defaultNow(),
});

Իսկ այդ սխեմայի դեմ հարցումը կարող է այսպիսի տեսք ունենալ.

import { eq } from 'drizzle-orm';
import db from '../db';
import { users } from '../db/schema';

export const getAllUsers = async () => {
  return await db.select().from(users)
};

2. Հարցումների API. տիպավորված և պարզ

Drizzle-ը կիրառում է SQL-first մոտեցում՝ հարցումները պահելով ergonomic և հեշտ ընթեռնելի։ Այն մշակողներին չի ստիպում սովորել դոմենային սխեմայի լեզու։ Prisma-ի դեպքում, ընդհակառակը, մշակողները տվյալների բազաները նկարագրում են Prisma Schema Language-ով, և Prisma-ն այդ սխեմայից ստեղծում է TypeScript կլիենտ։ Դրա մասին ավելին կարող եք իմանալ Prisma-ի կայքում։

Prisma-ն թաքցնում է SQL-ը և առաջարկում է հարցումների API, որը կենտրոնացած է entity-ների հետ աշխատանքի վրա։ Հարցում գրելը նման է սովորական JavaScript-ին նմանվող օբյեկտների հետ աշխատելուն.

// Prisma query API

const users = await prisma.users.findMany({
  where: {
    OR: [
      { email: { contains: 'mail.com' } },
      { name: { startsWith: 'C' } }
    ],
    articles: { some: { published: true } }
  },
  select: {
    id: true,
    email: true,
    _count: { select: { articles: true } }
  },
  take: 5
});

Նման հարցումները թույլ են տալիս մշակողներին գործել բարձր մակարդակով։ Նրանք join-ների կամ հում SQL-ի մասին մտածելու կարիք չունեն. պարզապես նկարագրում են, թե ինչ են ուզում, և Prisma-ն հոգ է տանում մնացած ամեն ինչի մասին կապոտի տակ։

Drizzle-ն ընդունում է SQL հասկացությունները և առաջարկում է հարցումների API, որը զգացվում է որպես SQL գրել անմիջապես TypeScript-ով. արտահայտիչ, կանխատեսելի և տվյալների բազայի շերտին մոտ։

Ի տարբերություն Prisma-ի նման լուծումների, որոնք ապավինում են առանձին դոմենային լեզվի (DSL) և տիպավորված կլիենտ ստեղծելու կոդի գեներացիայի քայլի, Drizzle-ն աշխատում է ամբողջությամբ TypeScript կոդային բազայի ներսում։ Թե՛ տվյալների բազայի սխեման, թե՛ հարցումները սահմանվում են կոդով, և տիպային անվտանգությունը ածանցվում է անմիջապես այդ սահմանումներից՝ առանց արտաքին սխեմայի ֆայլերի կամ ստեղծված կլիենտների անհրաժեշտության։

Սա պարզեցնում է մշակման աշխատանքային հոսքը և վերացնում է տվյալների բազայի մոդելն ու կլիենտի API-ն համաժամանակեցված պահելու անհրաժեշտությունը։

Երբ ծրագրավորողը փոխում է սխեման, TypeScript տիպերը թարմացվում են ինքնուրույն, և լրացուցիչ քայլեր պետք չեն։ Սա ձեզ տալիս է ավելի շատ վերահսկողություն կատարվողի նկատմամբ.

// Drizzle query API

const users = await db.select({
  id: users.id,
  email: users.email,
  articleCount: sql`count(${articles.id})`
.as('article_count')
})
.from(users)
.leftJoin(articles, eq(users.id, articles.authorId))
.where(
  or(
    like(users.email, '%mail.com%'),
    like(users.name, 'C%')
  )
)
.groupBy(users.id, users.email)
.having(gt(sql`count(${articles.id})`, 0))
.limit(5);

Այս API-ն տրամադրում է.

  • կանխատեսելի վարք (կատարվում է միայն այն, ինչ գրում եք),
  • TypeScript-ի լիարժեք ծածկույթ,
  • ոչ մի թաքնված կախարդանք. լիարժեք տեսանելիություն, թե որ հարցումն է ուղարկվում։

Ավելին, քանի որ Drizzle հարցումները շատ նման են template literal-ներում կամ կառուցվածքային արտահայտություններում գրված հում SQL-ին, խմբագրիչի մի շարք ընդլայնումներ կարող են բարելավել մշակողի փորձը։ Visual Studio Code-ն, օրինակ, ունի այնպիսի ընդլայնումներ, ինչպիսիք են.

  • SQL Lit,
  • SQL tagged template literals։

Նման ընդլայնումները կարող են ստուգել SQL շարահյուսությունը կամ նշել տիպիկ սխալները անմիջապես խմբագրիչում, ինչը հեշտացնում է սխալները վաղ նկատելը՝ նույնիսկ մինչ հավելվածի գործարկումը։

Այդուհանդերձ, մշակողների կյանքը հեշտացնելու համար Drizzle-ը տրամադրում է նաև ավելի բարձր մակարդակի ռելյացիոն API.

const userWithArticles = await db.query.users.findFirst({
  where: eq(users.id, 1),
  with: {
    articles: {
      where: eq(articles.published, true),
      limit: 5
    }
  }
});

3. Prepared statements. արդյունավետության աճ

Drizzle-ն անմիջապես աջակցում է prepared statements, մշակողներին տալով արդյունավետությունը բարելավելու պարզ եղանակ, հատկապես serverless միջավայրերում։

Հասկանալու համար, թե ինչու են prepared statements-ը բարձրացնում արդյունավետությունը, տեսնենք, թե ինչ է կատարվում կապոտի տակ, երբ հարցումը կատարվում է Drizzle-ից կամ մեկ այլ ORM-ից։ Տվյալների բազայի դեմ հարցում կատարելը ներառում է մի քանի քայլ, ինչպես ցույց է տալիս ստորև նկարը.

executing query agains sql database

Վերևում ցուցադրված գործընթացը տեղի է ունենում ամեն անգամ, երբ SQL-ը կատարվում է query builder-ի միջոցով։ Սովորաբար սա մեծ խնդիր չէ և հազվադեպ է արդյունավետության խնդիրներ առաջացնում։ Բայց երբ մշակողները գործ ունեն շատ բարդ հարցումների հետ, օրինակ՝ բազմաթիվ join-ներով և դրույթների շարքով, վերլուծությունը, անալիզը և կոմպիլյացիան ավելորդ կերպով կրկնվում են յուրաքանչյուր կատարման ժամանակ։ Դա տեղի է ունենում նույնիսկ եթե հարցման կառուցվածքը մնում է նույնը, և փոխվում են միայն պարամետրերը։

Եթե 1-ին, 2-րդ և 3-րդ քայլերը կարելի լիներ կատարել նախապես և նրանց արդյունքները կրկին օգտագործել, վերադիրը կարող էր զգալիորեն կրճատվել։ Հնարքն այն է, որ շարունակենք աջակցել դինամիկ պարամետրերին՝ խուսափելով կրկնվող կոմպիլյացիայից։ Հենց դա են թույլ տալիս prepared statements-ը. դրանք առաջին քայլերի կրկնվող կատարումը փոխարինում են նախակոմպիլացված հարցման կառուցվածքով, որը runtime-ում ընդունում է դինամիկ մուտքեր.

prepare statement in executing query

Prepared statements-ը նշանակում են, որ.

  • տվյալների բազան կարող է նորից օգտագործել հարցման պլանը՝ կրճատելով վերլուծության ժամանակը,
  • հարցումների լատենտությունը նվազում է. հիանալի է cold start-երի համար,
  • խուսափում եք runtime string interpolation-ից կամ ձեռքով սանիտիզացիայից, որոնք երկուսն էլ SQL injection խոցելիությունների հաճախակի պատճառ են։ Prepared statements-ը հարցման կառուցվածքը պահում են տվյալներից առանձին, ուստի օգտատիրոջ մուտքը միշտ անվտանգ պարամետրիզացվում է և երբեք չի կատարվում որպես SQL տրամաբանության մաս։

Ահա, թե ինչ տեսք կարող է ունենալ prepared statement-ը.

const db = drizzle(...);
const prepared = db.select()
.from(users)
.prepare("statement_name");

const res1 = await prepared.execute();
const res2 = await prepared.execute();
const res3 = await prepared.execute();

Եվ ահա մեկը placeholder-ով (երբ դինամիկ runtime արժեք պետք է ներդնել).

const u1 = db
  .select()
  .from(users)
  .where(eq(users.id, sql.placeholder('id')))
  .prepare("u1");

await u1.execute({ id: 1 }) // SELECT * FROM users WHERE id = 1
await u1.execute({ id: 2 }) // SELECT * FROM users WHERE id = 2

Ի տարբերություն Prisma-ի, որը SQL-ը կառուցում և կատարում է runtime-ում կոմպիլյացված կլիենտի միջոցով, Drizzle-ի prepared statements-ը գտնվում են տվյալների բազայի ավելի մոտ և ապահովում են շատ ավելի արագ cold start ժամանակներ. վճռորոշ գործոն serverless տեղակայումներում, ինչպիսին AWS Lambda-ն է։

4. Ոչ մի runtime կախարդանք. մաքուր և դեկլարատիվ կոդ

Drizzle-ը ոչ մի ենթադրություն չի անում այն մասին, թե ինչպես պետք է վարվեն հարցումները։ Չկա թաքնված վիճակ, բարդ կլիենտի գեներացիա և վերացարկման շերտեր, որոնք կանգնած լինեն ձեր կոդի և SQL-ի միջև։

Prisma-ում սխեման սահմանվում է .prisma ֆայլում, որից հետո պետք է գործարկել CLI՝ կլիենտը ստեղծելու համար։ Kysely-ն ունի համանման գործընթաց, որտեղ տիպային անվտանգությունը սովորաբար ստացվում է TypeScript ինտերֆեյսներ տվյալների բազայի սխեմայից արտաքին գործիքներով ստեղծելով։ Ամեն դեպքում, սկզբնական սխեման և ստեղծված տիպերը համաժամանակեցված պահելը պահանջում է լրացուցիչ build քայլ և ավելի շատ գործիքներ։

Drizzle-ի դեպքում, ընդհակառակը.

  • ծրագրավորողները սխեման և հարցումները հայտարարում են սովորական TypeScript-ով,
  • չկա կլիենտի շերտ, որը կարող է սխալ հասկանալ, թե ինչ նկատի ուներ մշակողը,
  • հարցումները միշտ թափանցիկ են. SQL կառուցվածքը հենց այնտեղ է՝ տեսանելի կոդում։

Արդյունքը ավելի հուսալի վրիպազերծումն է և ավելի քիչ անակնկալներ production-ում։

Ավելի խորը համեմատության համար տե՛ս ստորև «Drizzle և Prisma. թարգմանության տարբեր ռազմավարություններ» բաժինը։

5. Մինիմալ և կոմպոզիցիոն նախագիծ

Drizzle-ը հետևում է մոդուլային, կոմպոզիցիոն նախագծման փիլիսոփայության։ Ամեն ինչ մեկ մոնոլիտ գործիքակազմի մեջ փաթեթավորելու փոխարեն՝ այն տրամադրում է փոքր, կենտրոնացած գործիքներ.

  • drizzle-orm. query builder-ը,
  • drizzle-kit. ընտրովի CLI միգրացիաների կառավարման համար,
  • ադապտերներ կոնկրետ տվյալների բազաների համար (օրինակ՝ pg, mysql, sqlite) – առանց ավելորդ ծանրաբեռնվածության։

Դրա շնորհիվ Drizzle-ը.

  • հեշտ է ինտեգրել ցանկացած backend ֆրեյմվորքի հետ (Express, Bun, Hono և այլն),
  • բավականաչափ թեթև է edge և serverless տեղակայումների համար,
  • կատարյալ ընտրություն է միկրոսերվիսային ճարտարապետության կամ մոդուլային monorepo-ների համար։

Այս մոդուլայնությունը հնարավորություն է տալիս ճկուն նախագծային դասավորությունների և մտահոգությունների մաքուր բաժանման։ Քանի որ Drizzle-ին չեն պետք ո՛չ կենտրոնացված կոդի գեներացիայի քայլ, ո՛չ մոնոլիտ կլիենտ, այն լավ տեղավորվում է սերվիսակենտրոն կամ շերտավորված ճարտարապետություններում։ Տվյալների բազայի փոխազդեցությունները որոշակի մոդուլներով կամ փաթեթներով սահմանափակելը դառնում է ավելի հեշտ՝ առանց գլոբալ runtime-ի կամ ընդհանուր կլիենտի ինստանսի պարտադրման։

Դրանից բացի, խուսափելով ամուր կապված վերացարկումներից և մնալով ստանդարտ TypeScript և SQL կառուցվածքների վրա, Drizzle-ը մնում է բավականին թեթև և հարմարվում է տարբեր կոնֆիգուրացիաներին՝ ավանդական սերվերային միջավայրերից մինչև edge runtime-ներ և serverless հարթակներ։

Drizzle և Prisma. թարգմանության տարբեր ռազմավարություններ

Թեև Drizzle-ը և Prisma-ն երկուսն էլ նպատակ ունեն հարթեցնել տվյալների բազայի հասանելիությունը, դրանք դա անում են սկզբունքորեն տարբեր ձևերով։

Prisma. օգտագործում է schema-first մոդել՝ առաջնահերթություն տալով պարզությանը և վերացարկմանը։ Մշակողները տվյալների մոդելը սահմանում են հատուկ սխեմայի լեզվով, և Prisma-ն ստեղծում է կլիենտ OOP ոճի API-ով։ Այն թաքցնում է SQL-ը, բայց դա կարող է նաև բերել արդյունավետության խնդիրներ, ավելի քիչ ճկունություն և «արտահոսող» վերացարկումներ։

Drizzle. որդեգրում է SQL-first, schema-as-code, TypeScript-native մոտեցում։ Նրա նշանաբանն է. «Եթե գիտեք SQL, գիտեք Drizzle»։ Այն շեշտը դնում է թափանցիկության, վերահսկողության և կանխատեսելիության վրա։ Չկա կլիենտի գեներացիա, թաքնված վարք և ոչ մի անսպասելի բան runtime-ում։ Դա կատարյալ գործիք է այն մշակողների համար, ովքեր ուզում են մնալ տվյալների բազային մոտ՝ վայելելով ուժեղ տիպավորում և IDE աջակցություն։

Տվյալների մոդելավորում

Տեսնենք հիմա, թե ինչպես է սահմանվում տվյալների բազայի սխեման և ինչպես կարող են մշակողները դրան հղվել տվյալներ հարցնելիս.

// Prisma ORM

model User {
  id         Int     @id @default(autoincrement())
  name       String?
  email      String  @unique
  articles Article[]
}

model Article {
  id        Int     @id @default(autoincrement())
  title     String
  content   String?
  published Boolean @default(false)
  authorId  Int?
  author    User?   @relation(fields: [authorId], references: [id])
}

Դրանից հետո Prisma-ն ստեղծում է տիպով անվտանգ կլիենտ, որը կարող եք օգտագործել ձեր կոդում.

import { PrismaClient } from '@prisma/client'
const prisma = new PrismaClient()

async function main() {
  const user = await prisma.user.create({
    data: {
      email: 'john@doe.com',
      name: 'John',
      articles: {
        create: { title: 'Article no. 1' }
      }
    },
    include: { articles: true }
  })
}

Այս դասավորությունը կոկիկ կերպով բաժանում է սխեման հավելվածի մնացած կոդից և ձեզ տալիս է ճշմարտության մեկ աղբյուր։ Թերությունն այն է, սակայն, որ մշակողները պետք է կոդի գեներացիայի քայլ գործարկեն սխեմայի յուրաքանչյուր փոփոխության ժամանակ։

Drizzle-ի մոտեցումը սխեմայի սահմանման համար ապավինում է ծրագրային TypeScript API-ին.

import {
  boolean,
  integer,
  pgTable,
  serial,
  text,
  uniqueIndex,
  varchar,
} from 'drizzle-orm/pg-core'

export const users = pgTable('users', {
  id: serial('id').primaryKey(),
  name: varchar('name', { length: 256 }),
  email: varchar('email', { length: 256 }).unique(),
})

export const articles = pgTable('articles', {
  id: serial('id').primaryKey(),
  title: varchar('title', { length: 256 }).notNull(),
  content: text('content'),
  published: boolean('published'),
  authorId: serial('author_id').references(() => users.id),
});

export const usersRelations = relations(users, ({ many }) => ({
  articles: many(articles)
}));

Drizzle-ի հետ ես կարող եմ այս սխեմայի օբյեկտներն օգտագործել անմիջապես իմ հարցումներում, օրինակ.

async function main() {
  const user = await db.insert(users)
    .values({ email: 'john@doe.com', name: 'John' })
    .returning();

  await db.insert(articles)
    .values(
      { title: 'Article no. 1', authorId: user.id }
    );

  const userWithArticles = await db.query.users
    .findFirst({
      where: (users, { eq }) => eq(users.id, user.id),
   with: { articles: true }
    });
}

Drizzle-ը ապավինում է TypeScript կոմպիլյատորին՝ սխեմայի հետ կապված խնդիրները բռնելու համար, ուստի հավելվածը անմիջապես արտացոլում է սխեմայի ցանկացած փոփոխություն՝ առանց վերակառուցման կամ կոդի գեներացիայի գործարկման։

Կապեր

Աղյուսակների միջև կապերի մշակումը տվյալների բազաների հետ աշխատանքի ավելի բարդ մասերից է, հատկապես TypeScript միջավայրում։ Այն, թե ինչպես են Prisma-ն և Drizzle-ը զբաղվում կապերով, բացահայտում է ORM-ի նախագծման նրանց հակադիր փիլիսոփայությունները։

Prisma-ն կապերը դիտարկում է որպես իր համակարգի հիմնական մաս։ Դրանք ներկառուցված են անմիջապես և՛ սխեմայի, և՛ ստեղծված կլիենտի մեջ։ Prisma Schema Language-ում մշակողները կապերը հայտարարում են հստակ, կառուցվածքային ձևով.

model User {
  id         Int        @id @default(autoincrement())
  articles   Article[]   // One-to-many relationship
  profile    Profile?    // One-to-one relationship
}

model Article {
  id       Int  @id @default(autoincrement())
  author   User @relation(fields: [authorId], references: [id])
  authorId Int
}

model Profile {
  id     Int  @id @default(autoincrement())
  user   User @relation(fields: [userId], references: [id])
  userId Int  @unique
}

Այս կապակենտրոն նախագիծը տարածվում է նաև այն վրա, թե ինչպես են մշակողները հարցումներ գրում։ Կապված տվյալները ստեղծվում, ստացվում և թարմացվում են կոկիկ, ներդրված շարահյուսությամբ.

const user = await prisma.user.create({
  data: {
    email: 'john@doe.com',
    articles: {
      create: [{ title: 'Article no. 1' }]
    },
    profile: {
      create: { bio: 'The programmer' }
    }
  }
});

// Querying with relationship filters
const users = await prisma.user.findMany({
  where: {
    articles: {
      some: { published: true }
    }
  }
});

Prisma-ի համակարգի ուժը կայանում է նրանում, թե որքան է այն պարզեցնում բարդ տվյալների գործողությունները։ Մշակողները կարող են բազմամակարդակ գործողություններ (օրինակ՝ կապված գրառումներ ստեղծել) կատարել մեկ հարցմամբ, մինչդեռ Prisma-ն կուլիսների հետևում պահպանում է տվյալների ամբողջականությունը և համահունչությունը։ Կարիք չկա ձեռքով զբաղվել արտաքին բանալիներով կամ գրել մի քանի հարցում՝ ամեն ինչ համահունչ պահելու համար։

Drizzle-ը գնում է այլ ճանապարհով։ Աղյուսակները և կապերը սահմանվում են առանձին. մշակողները աղյուսակները սահմանելու համար օգտագործում են schema builder-ը, իսկ դրանք կապելու համար՝ առանձին relations API.

export const users = pgTable('users', {
  id: serial('id').primaryKey(),
  email: text('email').notNull()
});

export const articles = pgTable('articles', {
  id: serial('id').primaryKey(),
  title: text('title').notNull(),
  authorId: serial('author_id').references(() => users.id)
});

// Relationship definitions
export const usersRelations = relations(users, ({ many }) => ({
  articles: many(articles)
}));

export const articlesRelations = relations(articles, ({ one }) => ({
  author: one(users, {
    fields: [articles.authorId],
    references: [users.id]
  })
}));

Այս նախագիծը ավելի բացահայտ է. այն տվյալների կառուցվածքը պահում է դրա ասոցիացիաներից առանձին։ Կապված տվյալներ հարցնելու համար Drizzle-ը տրամադրում է ռելյացիոն API, որը թույլ է տալիս մշակողներին կապված գրառումները բեռնել ինտուիտիվ եղանակով.

const userWithArticles = await db.query.users.findFirst({
  with: {
    articles: {
      where: eq(articles.published, true),
      limit: 5
    }
  }
});

Առանցքային տարբերությունն այն է, թե որքան սերտ են ինտեգրված կապերը։ Prisma-ն դրանք խորապես հյուսում է թե՛ կարդալու, թե՛ գրելու մեջ՝ ավտոմատացնելով ծանր աշխատանքի մեծ մասը։ Drizzle-ը ամեն ինչ պահում է ավելի առանձին և մշակողից ավելի գիտակցված մոտեցում է պահանջում՝ զիջելով որոշակի հարմարավետություն՝ դիմաց ստանալով մանրակրկիտ վերահսկողություն։

SQL տրանզակցիաները Drizzle ORM-ով

Տվյալների համահունչությունն ու ամբողջականությունը պահպանելը կարևոր է ցանկացած հավելվածում, որը կատարում է մի քանի փոխկապակցված տվյալների բազայի գործողություններ։ Երբ հարցումների խումբը պետք է կամ բոլորը հաջողվեն, կամ բոլորը ձախողվեն միասին, տրանզակցիոն վերահսկողությունը անփոխարինելի է։

Պատկերացրեք բովանդակություն հրապարակող համակարգ, որը նոր հոդվածները պահպանում է տվյալների բազայում։ Հոդվածի հրապարակումը կարող է ներառել.

  • հոդվածի գրառման ներդրում,
  • դրա կապումը հեղինակի հետ,
  • թեգերի հավաքածուի կցում։

Եթե հոդվածը ներդրվում է, բայց թեգերի վերագրումը ձախողվում է (ասենք, բացակայող արտաքին բանալու կամ սահմանափակման խախտման պատճառով), համակարգը կարող է մնալ թերի տվյալներով. որբ հոդված, որը զուրկ է ցանկացած համատեքստից։ Նման անհամապատասխանությունները դժվար է նկատել և շտկել հետո։

Նման խնդիրները կանխելու համար SQL տվյալների բազաները առաջարկում են տրանզակցիաներ, որոնք գործողությունների շարքը միավորում են մեկ ատոմար միավորի մեջ։ Տրանզակցիաները հետևում են ACID սկզբունքներին.

  • Atomicity (ատոմարություն). կամ տրանզակցիայի յուրաքանչյուր գործողություն հաջողվում է, կամ դրանցից ոչ մեկը ուժի մեջ չի մտնում։
  • Consistency (համահունչություն). տվյալների բազան վավեր վիճակում է և՛ տրանզակցիայից առաջ, և՛ հետո։
  • Isolation (մեկուսացում). համաժամանակյա տրանզակցիաները չեն խանգարում միմյանց միջանկյալ վիճակին։
  • Durability (դիմացկունություն). հաստատվելուց հետո փոփոխությունները գոյատևում են նույնիսկ համակարգի ձախողման դեպքում։

Տրանզակցիաներ Drizzle-ով

Drizzle ORM-ը լիովին աջակցում է տրանզակցիոն գործողություններ հիմքում ընկած տվյալների բազայի ադապտերի միջոցով։ PostgreSQL-ում դա արվում է պարզ, ինտուիտիվ API-ով, որտեղ տրանզակցիայի համատեքստը փոխանցվում է որպես մեկուսացված tx ինստանս (https://orm.drizzle.team/docs/transactions)։

Ստորև ներկայացված է տրանզակցիայի օրինակ, որը ներդնում է article, վերագրում է author և կցում է tags՝ այս ամենը գործողությունների մեկ բլոկի ներսում.

const db = drizzle(...);

await db.transaction(async (tx) => {
  const [article] = await tx
    .insert(articles)
    .values({
      title: 'Understanding Drizzle Transactions',
      published: true,
    })
    .returning();

  await tx.insert(articleAuthors).values({
    articleId: article.id,
    authorId: '7d4ae4dc-faac-4d48-9320-6865110aa0d5',
  });

  await tx.insert(articleTags).values([
    { articleId: article.id, tagId: 'typescript' },
    { articleId: article.id, tagId: 'database' },
  ]);
});

Եթե տրանզակցիայի բլոկի ներսում որևէ գործողություն ձախողվի, բոլոր նախորդ փոփոխությունները ավտոմատ կերպով հետ են գլորվում։ Դուք պետք չէ ինքներդ ROLLBACK կամ COMMIT հրամաններ տալ. Drizzle-ը դա անում է կապոտի տակ։

Այս տրանզակցիոն մոդելը ձեզ տալիս է.

  • Անվտանգություն. մասնակի գրառումները երբեք չեն պահպանվում։
  • Հստակություն. տրանզակցիոն մտադրությունը բացահայտ է և սահմանափակված։
  • Կոմպոզիցիոնություն. հավելվածի ցանկացած մաս կարող է անվտանգ օգտագործել տրանզակցիաներ՝ առանց տվյալների բազայի ինտերֆեյսը փոխելու։

Savepoint-ներ և ներդրված տրանզակցիաներ

Ավելի բարդ սցենարներում գուցե անհրաժեշտ լինի հաստատել կամ հետ գլորել տրանզակցիոն աշխատանքային հոսքի միայն որոշակի մասեր։ Հենց այստեղ են օգտակար լինում savepoint-ները և ներդրված տրանզակցիաները։

Drizzle ORM-ը աջակցում է ներդրված տրանզակցիոն գործողություններ՝ նորից օգտագործելով տրանզակցիոն բլոկին փոխանցված tx օբյեկտը։ Եթե ներդրված բլոկը ձախողվում է, միայն այդ մասն է հետ գլորվում. արտաքին տրանզակցիան անփոփոխ է մնում, եթե սխալը չի տարածվում։

Սա հնարավորություն է տալիս կառուցել մոդուլային, դիմացկուն տրանզակցիոն հոսքեր։ Ահա օրինակ.

const db = drizzle(...);

await db.transaction(async (tx) => {
  await tx.insert(logs).values(
    { message: 'Starting import...' }
  );

  try {
    await tx.transaction(async (tx2) => {
      await tx2.insert(importQueue).values(
        { fileId: '9bb1fceb' }
      );
      await tx2.insert(importResults).values(
        { fileId: 'cb1f1766', success: true }
      );
    });
  } catch (error) {
    await tx.insert(logs).values(
      { message: 'Import failed. Rolling back nested transaction.' }
    );
    // The nested transaction is rolled back, the outer one continues.
  }

  await tx.insert(logs).values(
    { message: 'Outer transaction continues...' }
  );
});

Այս կառուցվածքը.

  • կանխում է ձախողումների ավելորդ տարածումը,
  • օգնում է կողմնակի էֆեկտները պահել մոդուլային,
  • տալիս է մանրակրկիտ վերահսկողություն այն բանի վրա, թե ինչպես են վարվում հետ գլորումները։

Թեև Drizzle-ը թույլ է տալիս տրանզակցիայի բլոկները ներդնել, PostgreSQL-ը բնիկ չի աջակցում իսկական ներդրված տրանզակցիաներ։ PostgreSQL-ը թույլ է տալիս միայն մեկ ակտիվ տրանզակցիա յուրաքանչյուր միացման համար։ Ներդրումը նմանակելու համար Drizzle-ը ներքուստ օգտագործում է SQL savepoint-ներ։

Երբ կանչվում է ներդրված tx.transaction(...), Drizzle-ը տալիս է SAVEPOINT։ Եթե սխալ է բարձրացվում, այն կատարում է ROLLBACK TO SAVEPOINT. Արտաքին տրանզակցիան շարունակում է անփոփոխ, եթե սխալը կրկին չի նետվում։

Այս իրականացումը ապահովում է հետևողական մշակողի փորձ տվյալների բազայի տարբեր backend-ներում՝ միաժամանակ հարգելով այն, ինչ PostgreSQL-ի տրանզակցիաները իրականում կարող են անել։

Drizzle ORM-ի հասկացությունների գործնական ամփոփում

Հոդվածն ավարտելու համար նայենք հավելվածին, որը ես կառուցել եմ՝ ցուցադրելու վերը քննարկված Drizzle ORM-ի բոլոր առանցքային հասկացությունները։

Այս հոդվածում ընդգրկված հավելվածի հիմնական կողմերն են.

  • կարդալու և գրելու պատասխանատվությունների մաքուր բաժանում երկու առանձին սերվիսների միջոցով՝ writer և reader,
  • Drizzle ORM սխեմայի կենտրոնացված սահմանում, որը պահվում է shared մոդուլում,
  • տվյալների բազայի թույլտվությունների խիստ վերահսկողություն PostgreSQL մակարդակում՝ սահմանափակ արտոնություններով հատուկ տվյալների բազայի օգտատերերի միջոցով,
  • կրկին օգտագործելի, տիպով անվտանգ տվյալների հասանելիության և վավերացման տրամաբանություն, որը կիսում են երկու սերվիսները,
  • պարզ, բայց իմաստալից REST API endpoint-ներ կարդալու և գրելու գործողությունների համար,
  • docker-ի վրա հիմնված կոնֆիգուրացիա՝ սկզբնավորման սկրիպտներով, որոնք ստեղծում են օգտատերեր, դերեր և թույլտվություններ։

Նախագծի կառուցվածքը

Պահոցը բաժանված է երեք վերին մակարդակի թղթապանակների.

shared/

Այս թղթապանակը պարունակում է Drizzle ORM սխեմայի սահմանումները, վալիդատորները և միայն կարդալու endpoint-ների ընդհանուր տրամաբանությունը, օրինակ.

  • GET /users
  • GET /users/:id
  • GET /activities
  • GET /activities/:id

Այս endpoint-ներն օգտագործում են և՛ reader-ը, և՛ writer-ը։

reader/

Ինքնուրույն հավելված՝ միայն կարդալու հասանելիությամբ։ Այն ներմուծում է ընդհանուր սխեման և endpoint-ները, բայց տվյալների բազային միանում է որպես միայն կարդալու օգտատեր, որն ունի միայն SELECT արտոնություններ։

writer/

Երկրորդ ինքնուրույն սերվիսը, որը ներմուծում է ընդհանուր սխեման և կարդալու endpoint-ները և լրացուցիչ տրամադրում է գրելու գործողություններ, ինչպիսիք են.

  • POST /users
  • PUT /users/:id
  • PATCH /users/:id
  • DELETE /users/:id

Այն միանում է որպես writer օգտատեր՝ լիարժեք արտոնություններով (SELECT, INSERT, UPDATE, DELETE)։

Drizzle տրանզակցիաներ

Նախագիծը ցույց է տալիս, թե ինչպես են օգտագործվում Drizzle ORM տրանզակցիաները։ Սա պատկերում են երկու հիմնական օրինակ.

  • օգտատիրոջ ստեղծում ավտոմատ ակտիվությամբ միասին (POST /users),
  • օգտատիրոջ թարմացում ակտիվության հետևմամբ (PATCH /users/:id)։

Տվյալների բազայի դերեր և անվտանգություն

PostgreSQL կոնտեյները կարգավորված է docker-compose-ով, իսկ դերերը սկզբնավորվում են SQL սկրիպտներով (shared/sql/init-users.sql և shared/sql/grant-access.sql), որոնք.

  • ստեղծում են երկու առանձին օգտատեր՝ writer_user և reader_user,
  • writer-ին տալիս են լիարժեք արտոնություններ
  • reader-ին տալիս են միայն կարդալու հասանելիություն,
  • reader-ից հետ են վերցնում գրելու հետ կապված յուրաքանչյուր թույլտվություն,
  • կիրառում են այս արտոնությունները սխեմայի միգրացիայից հետո, որպեսզի դրանք ճիշտ կիրառվեն։

Այս կոնֆիգուրացիան ապահովում է մտահոգությունների խիստ բաժանում և կանխում է պատահական փոփոխությունները reader սերվիսում։

Պահոց և ինչպես գործարկել

Ամփոփում

Drizzle ORM-ը հիանալի տարբերակ է ժամանակակից TypeScript հավելվածներ կառուցելու համար՝ տվյալների շերտի նկատմամբ լիարժեք վերահսկողությամբ։ Այն միավորում է տիպային անվտանգությունը, արդյունավետությունը և պարզությունը այնպես, որ բնականորեն տեղավորվում է այսօրվա JavaScript էկոհամակարգում։

Drizzle-ը հատկապես արժե փորձել, երբ կառուցում եք միկրոսերվիսներ, տեղակայում եք edge-ում կամ պարզապես անհրաժեշտ է թեթև, կոմպոզիցիոն ORM։ Շատ հավանական է, որ կգրեք ավելի քիչ կոդ, ավելի քիչ սխալներ կանեք և նորից կվայելեք ձեր տվյալների բազայի շերտը։