Prisma JavaScript (Node.js) के लिए: पूर्ण गाइड उदाहरण सहित

Prisma एक आधुनिक ORM (Object-Relational Mapping) है जो Node.js और TypeScript के लिए डेटाबेस के साथ काम करने का तरीका पूरी तरह बदल देता है। पारंपरिक ORM के विपरीत, Prisma एक डिक्लेरेटिव डेटा मॉडल, ऑटोमैटिक टाइप-सेफ क्लाइंट जनरेशन और माइग्रेशन के लिए एक शक्तिशाली टूल प्रदान करता है। अगर आप मैन्युअल SQL क्वेरी लिखने, डेटा टाइप की उलझन और जटिल ORM कॉन्फ़िगरेशन से थक गए हैं, तो Prisma आपके लिए वरदान साबित होगा।

Prisma की आवश्यकता क्यों है? सबसे पहले, यह डेटाबेस स्तर पर टाइप-सेफ्टी सुनिश्चित करता है। इसका मतलब है कि गलत फील्ड टाइप या गायब रिलेशनशिप से जुड़ी त्रुटियां रनटाइम के बजाय कंपाइल टाइम पर ही पकड़ी जाएंगी। दूसरा, Prisma CRUD ऑपरेशन, फ़िल्टरिंग, सॉर्टिंग और डेटा एग्रीगेशन के लिए सहज API प्रदान करता है। तीसरा, यह आपके डेटा स्कीमा के आधार पर ऑटोमैटिक डॉक्यूमेंटेशन जनरेट करता है और माइग्रेशन के ज़रिए स्कीमा बदलावों को आसानी से मैनेज करने देता है।

Prisma मुख्य रिलेशनल डेटाबेस को सपोर्ट करता है: PostgreSQL, MySQL, SQLite, SQL Server, MongoDB (Document मोड में)। अपनी आर्किटेक्चर की बदौलत, यह छोटे प्रोजेक्ट से लेकर एंटरप्राइज़ एप्लिकेशन तक के लिए एकदम सही है। इस लेख में हम विस्तार से इंस्टॉलेशन, मुख्य तरीके और Node.js वातावरण में Prisma के वास्तविक उपयोग के उदाहरण देखेंगे।

इंस्टॉलेशन

Prisma की इंस्टॉलेशन दो चरणों में होती है: CLI (Command Line Interface) इंस्टॉल करना और प्रोजेक्ट को इनिशियलाइज़ करना। अपने प्रोजेक्ट के टर्मिनल में निम्नलिखित कमांड चलाएं:

npm install prisma --save-dev
npm install @prisma/client

इंस्टॉलेशन के बाद प्रोजेक्ट में Prisma को इनिशियलाइज़ करें:

npx prisma init

यह कमांड prisma नामक डायरेक्टरी बनाएगा जिसमें schema.prisma फ़ाइल होगी, और एनवायरनमेंट वेरिएबल के लिए .env फ़ाइल बनाएगा। .env फ़ाइल में अपने डेटाबेस का कनेक्शन स्ट्रिंग दर्ज करें। उदाहरण के लिए, PostgreSQL के लिए:

DATABASE_URL="postgresql://user:password@localhost:5432/mydb"

MySQL के लिए:

DATABASE_URL="mysql://user:password@localhost:3306/mydb"

SQLite (फ़ाइल-आधारित डेटाबेस) के लिए:

DATABASE_URL="file:./dev.db"

त्वरित शुरुआत: न्यूनतम कार्यशील उदाहरण

चलिए एक सरल यूज़र मॉडल बनाते हैं और बुनियादी ऑपरेशन करते हैं। prisma/schema.prisma फ़ाइल को एडिट करें:

// prisma/schema.prisma
generator client {
  provider = "prisma-client-js"
}

datasource db {
  provider = "sqlite" // या "postgresql", "mysql"
  url      = env("DATABASE_URL")
}

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

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

अब डेटाबेस में टेबल बनाने के लिए माइग्रेशन चलाएं:

npx prisma migrate dev --name init

सफल माइग्रेशन के बाद Prisma Client जनरेट करें:

npx prisma generate

अब index.js फ़ाइल बनाएं और एक सरल स्क्रिप्ट लिखें:

// index.js
const { PrismaClient } = require('@prisma/client');

const prisma = new PrismaClient();

async function main() {
  // नया यूज़र बनाएं
  const user = await prisma.user.create({
    data: {
      email: 'alice@example.com',
      name: 'Alice',
    },
  });
  console.log('यूज़र बनाया गया:', user);

  // यूज़र के लिए पोस्ट बनाएं
  const post = await prisma.post.create({
    data: {
      title: 'पहला पोस्ट',
      content: 'यह मेरा पहला पोस्ट है!',
      authorId: user.id,
    },
  });
  console.log('पोस्ट बनाया गया:', post);

  // सभी यूज़र उनके पोस्ट के साथ प्राप्त करें
  const allUsers = await prisma.user.findMany({
    include: { posts: true },
  });
  console.log('सभी यूज़र:', JSON.stringify(allUsers, null, 2));
}

main()
  .catch((e) => console.error(e))
  .finally(async () => await prisma.$disconnect());

इस स्क्रिप्ट को चलाएं:

node index.js

आपको कंसोल में निर्मित यूज़र, पोस्ट और सभी यूज़र की सूची उनके पोस्ट के साथ दिखाई देगी। बधाई हो! आपने Prisma का उपयोग करके अपना पहला CRUD ऑपरेशन सफलतापूर्वक पूरा कर लिया है।

Prisma के मुख्य तरीके

Prisma Client CRUD ऑपरेशन के लिए कई शक्तिशाली तरीके प्रदान करता है। आइए सबसे महत्वपूर्ण तरीकों को उदाहरण सहित देखें:

create - नया रिकॉर्ड बनाएं

एक नया रिकॉर्ड बनाने के लिए create तरीके का उपयोग करें:

const newUser = await prisma.user.create({
  data: {
    email: 'bob@example.com',
    name: 'Bob',
  },
});

findUnique - विशिष्ट आईडी से रिकॉर्ड खोजें

किसी अनोखे फील्ड (जैसे id या email) के आधार पर एक रिकॉर्ड प्राप्त करें:

const user = await prisma.user.findUnique({
  where: { email: 'alice@example.com' },
});

findMany - एकाधिक रिकॉर्ड प्राप्त करें

सभी रिकॉर्ड या फ़िल्टर किए गए रिकॉर्ड प्राप्त करें:

// सभी यूज़र प्राप्त करें
const allUsers = await prisma.user.findMany();

// फ़िल्टर के साथ: केवल वे यूज़र जिनके पास पोस्ट हैं
const usersWithPosts = await prisma.user.findMany({
  where: { posts: { some: {} } },
  include: { posts: true },
});

update - रिकॉर्ड अपडेट करें

किसी मौजूदा रिकॉर्ड को अपडेट करें:

const updatedUser = await prisma.user.update({
  where: { id: 1 },
  data: { name: 'Alice Johnson' },
});

delete - रिकॉर्ड हटाएं

किसी रिकॉर्ड को हटाएं:

const deletedUser = await prisma.user.delete({
  where: { id: 1 },
});

upsert - बनाएं या अपडेट करें

अगर रिकॉर्ड मौजूद है तो अपडेट करें, नहीं तो नया बनाएं:

const upsertUser = await prisma.user.upsert({
  where: { email: 'alice@example.com' },
  update: { name: 'Alice Updated' },
  create: { email: 'alice@example.com', name: 'Alice' },
});

उन्नत सुविधाएं

रिलेशनशिप और नेस्टेड क्वेरी

Prisma में रिलेशनशिप को संभालना बहुत आसान है। आप एक ही क्वेरी में संबंधित डेटा को शामिल कर सकते हैं:

// यूज़र को उनके पोस्ट के साथ प्राप्त करें
const userWithPosts = await prisma.user.findUnique({
  where: { id: 1 },
  include: { posts: true },
});

// नेस्टेड क्रिएशन: यूज़र और उसके पोस्ट एक साथ बनाएं
const userWithNewPost = await prisma.user.create({
  data: {
    email: 'charlie@example.com',
    name: 'Charlie',
    posts: {
      create: { title: 'चार्ली का पहला पोस्ट', content: 'नमस्ते दुनिया!' },
    },
  },
  include: { posts: true },
});

फ़िल्टरिंग और सॉर्टिंग

डेटा को फ़िल्टर और सॉर्ट करने के लिए Prisma शक्तिशाली ऑपरेटर प्रदान करता है:

// प्रकाशित पोस्ट को शीर्षक के अनुसार सॉर्ट करके प्राप्त करें
const publishedPosts = await prisma.post.findMany({
  where: { published: true },
  orderBy: { title: 'asc' },
  take: 10, // केवल 10 पोस्ट लें
});

// कंटेंट में किसी शब्द वाले पोस्ट खोजें
const searchPosts = await prisma.post.findMany({
  where: {
    content: { contains: 'Prisma' },
  },
});

एग्रीगेशन और ग्रुपिंग

डेटा पर एग्रीगेट फ़ंक्शन लागू करें:

// कुल यूज़र की संख्या प्राप्त करें
const userCount = await prisma.user.count();

// प्रति यूज़र पोस्ट की औसत संख्या
const avgPosts = await prisma.post.aggregate({
  _count: { authorId: true },
});

निष्कर्ष

Prisma Node.js और TypeScript डेवलपर्स के लिए एक गेम-चेंजर है। यह डेटाबेस इंटरैक्शन को सरल, सुरक्षित और अधिक उत्पादक बनाता है। इस गाइड में हमने इंस्टॉलेशन, बुनियादी CRUD ऑपरेशन, रिलेशनशिप, फ़िल्टरिंग और एग्रीगेशन को कवर किया है। Prisma की आधिकारिक डॉक्यूमेंटेशन में और भी कई उन्नत सुविधाएं हैं, जैसे ट्रांजैक्शन, मिडलवेयर और कस्टम क्वेरी।

अब आपकी बारी है! अपने प्रोजेक्ट में Prisma आज़माएं और देखें कि यह आपके डेटाबेस वर्कफ़्लो को कैसे बेहतर बनाता है। हैप्पी कोडिंग!