dolphin-server-modules 1.5.1 → 1.5.3

package/DOLPHIN_MASTER_GUIDE_NEPALI.md

@@ -1,27 +1,30 @@
 # Dolphin Framework: Absolute Master Guide (100+ Pages Equivalent) 🐬🇳🇵
 
+> **Latest Version:** v1.4.7+ | **Updated:** 2026-04-03 | **License:** MIT
+
 यो डकुमेन्ट Dolphin Framework को आधिकारिक र विस्तृत गाइड हो। यसले तपाईँलाई एउटा साधारण कोड लेख्ने डेभलपरबाट "Framework Master" बनाउन मद्दत गर्नेछ।
 
 ---
 
 ## विषय सूची (Table of Contents)
-- [०. परिचय र दर्शन (Introduction & Philosophy)](#०-परिचय-र-दर्शन-introduction--philosophy)
-- [१. सेटअप र वातावरण (Setup & Environment)](#१-सेटअप-र-वातावरण-setup--environment)
-- [२. कोर सर्भर इन्जिन (Core Server Engine)](#२-कोर-सर्भर-इन्जिन-core-server-engine)
+
+- [०. परिचय र दर्शन](#०-परिचय-र-दर्शन)
+- [१. सेटअप र वातावरण](#१-सेटअप-र-वातावरण)
+- [२. कोर सर्भर इन्जिन](#२-कोर-सर्भर-इन्जिन)
 - [३. Unified Context (ctx) Deep Dive](#३-unified-context-ctx-deep-dive)
-- [४. एडभान्स्ड राउटिङ (Advanced Routing)](#४-एडभान्स्ड-राउटिङ-advanced-routing)
-- [५. मिडलवेयर आर्किटेक्चर (Middleware Architecture)](#५-मिडलवेयर-आर्किटेक्चर-middleware-architecture)
-- [६. डेटाबेस एड्याप्टर (Database Adapters)](#६-डेटाबेस-एड्याप्टर-database-adapters)
-- [७. Auth मोड्युल मास्टरक्लास (Auth Module Masterclass)](#७-auth-मोड्युल-मास्टरक्लास-auth-module-masterclass)
-- [८. अटोमेटेड CRUD इन्जिन (Automated CRUD Engine)](#८-अटोमेटेड-crud-इन्जिन-automated-crud-engine)
-- [९. Zod भ्यालिडेसन र सुरक्षा (Zod Validation)](#९-zod-भ्यालिडेसन-र-सुरक्षा-zod-validation)
+- [४. एडभान्स्ड राउटिङ](#४-एडभान्स्ड-राउटिङ)
+- [५. मिडलवेयर आर्किटेक्चर](#५-मिडलवेयर-आर्किटेक्चर)
+- [६. डेटाबेस एड्याप्टर](#६-डेटाबेस-एड्याप्टर)
+- [७. Auth मोड्युल मास्टरक्लास](#७-auth-मोड्युल-मास्टरक्लास)
+- [८. अटोमेटेड CRUD इन्जिन](#८-अटोमेटेड-crud-इन्जिन)
+- [९. Zod भ्यालिडेसन र सुरक्षा](#९-zod-भ्यालिडेसन-र-सुरक्षा)
 - [१०. रियल-वर्ल्ड प्रोजेक्ट: DolphinStore API](#१०-रियल-वर्ल्ड-प्रोजेक्ट-dolphinstore-api)
-- [११. स्केलिङ र पर्फर्मेन्स (Scaling & Performance)](#११-स्केलिङ-र-पर्फर्मेन्स-scaling--performance)
-- [१२. टेस्टिङ र डेभप्स (Testing & DevOps)](#१२-टेस्टिङ-र-डेभप्स-testing--devops)
-- [१३. भविष्य र योगदान (Future Roadmap)](#१३-भविष्य-र-योगदान-future-roadmap)
-- [१४. रियलटाइम र IoT मास्टरक्लास (Realtime & IoT Masterclass) [NEW]](#१४-रियलटाइम-र-iot-मास्टरक्लास-realtime--iot-masterclass-new)
-- [१५. इन्डिपेन्डेन्ट राउटिङ मास्टरक्लास (Independent Routing) [NEW]](#१५-इन्डिपेन्डेन्ट-राउटिङ-मास्टरक्लास-independent-routing-new)
-- [१६. स्वतन्त्र अटो-स्वैगर जेनेरेसन (Independent Auto-Swagger) [NEW]](#१६-स्वतन्त्र-अटो-स्वैगर-जेनेरेसन-independent-auto-swagger-new)
+- [११. स्केलिङ र पर्फर्मेन्स](#११-स्केलिङ-र-पर्फर्मेन्स)
+- [१२. टेस्टिङ र डेभप्स](#१२-टेस्टिङ-र-डेभप्स)
+- [१३. RealtimeCore: रियलटाइम पब/सब मास्टरक्लास](#१३-realtimecore-रियलटाइम-पबसब-मास्टरक्लास)
+- [१४. इन्डिपेन्डेन्ट राउटिङ](#१४-इन्डिपेन्डेन्ट-राउटिङ)
+- [१५. स्वतन्त्र अटो-स्वैगर जेनेरेसन](#१५-स्वतन्त्र-अटो-स्वैगर-जेनेरेसन)
+- [१६. API रेफरेन्स](#१६-api-रेफरेन्स)
 
 ---
 
@@ -31,41 +34,33 @@
 ब्याकइन्ड डेभलपमेन्टको दुनियाँमा एक्सप्रेस (Express) सबैभन्दा लोकप्रिय छ। तर एक्सप्रेस पूरानो भइसक्यो। यसमा धेरै अनावश्यक वजन (Bloat) छ र यो मोडर्न एउटा (Modern) `async/await` सँग सधैँ राम्रोसँग काम गर्दैन।
 
 **Dolphin को जन्म तीनवटा मुख्य कारणले भएको हो:**
-१. **Native Speed**: कुनै पनि बाहिरी लाइब्रेरी बिना नेटिभ `http` मा चल्ने।
-२. **Context-First**: `req` र `res` लाई एउटै ‘Context’ (ctx) मा मिलाएर कोडलाई सफा राख्ने।
-३. **Total Modularity**: तपाईँले Auth चाहनुहुन्छ? Auth मोड्युल मात्र लोड गर्नुहोस्। तपाईँलाई CRUD चाहनुहुन्न? त्यसलाई हटाउनुहोस्।
+1. **Native Speed**: कुनै पनि बाहिरी लाइब्रेरी बिना नेटिभ `http` मा चल्ने।
+2. **Context-First**: `req` र `res` लाई एउटै 'Context' (ctx) मा मिलाएर कोडलाई सफा राख्ने।
+3. **Total Modularity**: तपाईँले Auth चाहनुहुन्छ? Auth मोड्युल मात्र लोड गर्नुहोस्।
 
 ### पर्फर्मेन्स बेन्चमार्क
-हाम्रो आन्तरिक टेस्टिङ अनुसार:
 | Framework | Requests Per Second (RPS) | Latency (avg) |
 | :--- | :--- | :--- |
-| Express.js | ~१५,००० | १०ms |
-| Fastify | ~३५,००० | २ms |
-| **Dolphin (v1.4.7)** | **~४५,०००+** | **१.५ms** |
+| Express.js | ~15,000 | 10ms |
+| Fastify | ~35,000 | 2ms |
+| **Dolphin (v1.4.7+)** | **~45,000+** | **1.5ms** |
 
 ---
 
 ## १. सेटअप र वातावरण (Setup & Environment)
 
 ### १.१ आवश्यक चिजहरू (Prerequisites)
-- **Node.js**: v18.x वा सोभन्दा माथि (Dolphin ले मोडर्न फिचर प्रयोग गर्छ)।
+- **Node.js**: v18.x वा सोभन्दा माथि
 - **TypeScript**: Dolphin टाइप-सेफ छ, त्यसैले TS सिफारिस गरिन्छ।
-- **Package Manager**: npm, yarn, वा pnpm।
 
 ### १.२ प्रोजेक्ट सुरु गर्ने
-एउटा खाली फोल्डरमा जानुहोस् र तलको कमान्ड चलाउनुहोस्:
-
 ```bash
 mkdir dolphin-master-app && cd dolphin-master-app
 npm init -y
-npm install dolphin-server-modules mongoose zod
-# Development को लागि
+npm install dolphin-server-modules mongoose zod ioredis
 npm install -D typescript ts-node @types/node nodemon
-```
-
-### १.३ TypeScript कन्फिगर गर्ने (`tsconfig.json`)
-Dolphin को लागि तपाईँको `tsconfig.json` यस्तो हुनुपर्छ:
-```json
+१.३ TypeScript कन्फिगर (tsconfig.json)
+json
 {
   "compilerOptions": {
     "target": "ES2022",
@@ -78,603 +73,499 @@ Dolphin को लागि तपाईँको `tsconfig.json` यस्त
     "forceConsistentCasingInFileNames": true
   }
 }
-```
-
----
-
-## २. कोर सर्भर इन्जिन (Core Server Engine)
-
-Dolphin को हृदय (Heart) यसको नेटिभ सर्भर इन्जिन हो। यसले भारी बाहिरी डिपेन्डेन्सी प्रयोग नगरी सिधै `http.createServer` सँग कुराकानी गर्छ।
-
-### २.१ सर्भर कसरी बनाउने?
-```typescript
+२. कोर सर्भर इन्जिन (Core Server Engine)
+२.१ सर्भर कसरी बनाउने?
+typescript
 import { createDolphinServer } from 'dolphin-server-modules/server';
 
 const app = createDolphinServer();
 
-// पोर्ट ३००० मा सर्भर सुन्न सुरु गर्ने
 app.listen(3000, () => {
   console.log("Dolphin Engine Active! 🐬");
 });
-```
-
-### २.२ अन्डर द हुड (Under the Hood)
-Dolphin ले हरेक रिक्वेस्ट आउँदा एउटा नयाँ "Context" अब्जेक्ट बनाउँछ। यसले रिक्वेस्ट पाइलाइन (Request Pipeline) लाई एकदमै छिटो र सरल बनाउँछ। यसमा कुनै "Connect" वा "Express" को मिडलवेयर चेनको झन्झट हुँदैन यदि तपाईँ चाहनुहुन्न भने।
-
----
-
-## ३. Unified Context (ctx) Deep Dive
-
-Context (`ctx`) Dolphin को सबैभन्दा शक्तिशाली पक्ष हो। यसले रिक्वेस्ट र रेस्पोन्सलाई एउटै ठाउँमा ल्याउँछ।
-
-### ३.१ `ctx` भित्र के के हुन्छ?
-तपाईँको ह्यान्डलरमा `ctx` उपलब्ध हुन्छ:
-```typescript
+३. Unified Context (ctx) Deep Dive
+३.१ ctx भित्र के के हुन्छ?
+typescript
 app.get('/test', (ctx) => {
-  // ctx यहाँ छ!
-});
-```
-
-**मुख्य प्रोपर्टीहरू:**
-- `ctx.req`: नेटिभ `http.IncomingMessage` (जसमा `req.user` पनि थपिन सक्छ)।
-- `ctx.params`: URL प्यारामिटरहरू।
-- `ctx.query`: Query String (जस्तै: `?name=Dolphin`)।
-- `ctx.body`: POST/PUT रिक्वेस्टको डाटा।
-
-**मुख्य मेथडहरू:**
-- `ctx.json(obj)`: JSON डाटा पठाउन।
-- `ctx.status(code)`: HTTP स्टेटस कोड सेट गर्न।
-- `ctx.header(key, value)`: रेस्पोन्स हेडर सेट गर्न।
-- `ctx.text(str)`: सादा टेक्स्ट पठाउन।
-
-### ३.२ अटो-JSON रेस्पोन्स (Auto-JSON Response) - [NEW v1.4.7]
-Dolphin को पछिल्लो अपडेटमा, यदि तपाईँको ह्यान्डलरले एउटा अब्जेक्ट (Object) फिर्ता (return) गर्छ भने, सर्भरले त्यसलाई आफैँ JSON बनाएर पठाइदिन्छ। तपाईँले `ctx.json()` लेखिरहनु पर्दैन!
-
-```typescript
-// पुरानो तरीका:
-app.get('/old-way', (ctx) => {
-  ctx.json({ ok: true });
+  // ctx.params, ctx.query, ctx.body, ctx.req, ctx.res
 });
+मुख्य प्रोपर्टीहरू:
 
-// नयाँ सजिलो तरीका (v1.4.7):
-app.get('/new-way', (ctx) => {
-  return { ok: true, message: "Dolphin is smart!" };
-});
-```
+ctx.req: नेटिभ http.IncomingMessage
 
----
+ctx.params: URL प्यारामिटरहरू
 
-## ४. एडभान्स्ड राउटिङ (Advanced Routing)
+ctx.query: Query String
 
-Dolphin को राउटिङ सिस्टम एउटा "Hybrid matching" मा आधारित छ। यसले $O(1)$ र $O(L)$ म्याचिङको संयोजन गर्छ।
+ctx.body: POST/PUT डाटा
 
-### ४.१ राउटिङ कसरी काम गर्छ?
-यसले Radix Trees प्रयोग गर्छ। जसले गर्दा तपाईँको ५०० वटा रूट भए पनि वा ५ वटा भए पनि स्पिडमा कुनै फरक पर्दैन।
+मुख्य मेथडहरू:
 
-```typescript
-// १. सामान्य रूट (Static Route)
-app.get('/ping', (ctx) => ctx.json({ msg: 'pong' }));
+ctx.json(obj): JSON डाटा पठाउन
 
-// २. डाइनामिक रूट (Dynamic Route)
-app.get('/users/:id', (ctx) => {
-  const { id } = ctx.params;
-  ctx.json({ userId: id });
-});
+ctx.status(code): HTTP स्टेटस कोड
 
-// ३. मल्टी-प्यारामिटर (Multi Params)
-app.get('/posts/:categoryId/:postId', (ctx) => {
-  const { categoryId, postId } = ctx.params;
-  ctx.json({ categoryId, postId });
-});
-```
+ctx.header(key, value): रेस्पोन्स हेडर
 
-### ४.२ राउट प्रिफिक्सिङ (Route Prefixing)
-प्रोजेक्ट ठूलो हुँदा रूटहरूलाई अर्गनाइज गर्न मिल्छ:
-```typescript
-app.group('/api/v1', (group) => {
-  group.get('/users', (ctx) => ctx.json([]));
-  group.get('/stats', (ctx) => ctx.json({ active: 100 }));
-});
-```
+३.२ अटो-JSON रेस्पोन्स [v1.4.7]
+typescript
+// पुरानो:
+app.get('/old', (ctx) => { ctx.json({ ok: true }); });
 
----
+// नयाँ:
+app.get('/new', (ctx) => { return { ok: true }; });
+४. एडभान्स्ड राउटिङ (Advanced Routing)
+typescript
+// Static Route
+app.get('/ping', (ctx) => ({ msg: 'pong' }));
 
-## ५. मिडलवेयर आर्किटेक्चर (Middleware Architecture)
+// Dynamic Route
+app.get('/users/:id', (ctx) => ({ userId: ctx.params.id }));
 
-Dolphin को मिडलवेयर "Request Lifecycle" को बिचमा आउने एउटा हूक (Hook) हो।
-
-### ५.१ मिडलवेयरका प्रकार
-१. **Global Middleware**: सर्भरको हरेक रिक्वेस्टमा चल्ने।
-२. **Route-Specific Middleware**: कुनै एउटा निश्चित रूटमा मात्र चल्ने।
-३. **Express Adapter**: एक्सप्रेसको मिडलवेयरलाई Dolphin मा चलाउने।
-
-### ५.२ ग्लोबल मिडलवेयर बनाउने
-```typescript
+// Route Prefixing
+app.group('/api/v1', (group) => {
+  group.get('/users', (ctx) => ([]));
+});
+५. मिडलवेयर आर्किटेक्चर (Middleware Architecture)
+typescript
+// Global Middleware
 app.use((ctx, next) => {
-  const start = Date.now();
-  console.log(`[Dolphin] ${ctx.req.method} ${ctx.req.url} सुरु भयो...`);
-  
-  // अर्को मिडलवेयर वा रूट ह्यान्डलरमा पठाउने
+  console.log(`${ctx.req.method} ${ctx.req.url}`);
   if (next) next();
-
-  const duration = Date.now() - start;
-  console.log(`[Dolphin] ${ctx.req.url} सकियो! समय: ${duration}ms`);
 });
-```
 
-### ५.३ राउट-लेभल मिडलवेयर (Multi-Handler Support) - [NEW v1.4.7]
-अब तपाईँले एउटै राउटमा एक्सप्रेस जस्तै गरी धेरै मिडलवेयरहरू एकैसाथ राख्न सक्नुहुन्छ।
-
-```typescript
+// Multi-handler Support
 const isAdmin = (ctx, next) => {
-  if (ctx.req.user.role === 'admin') next();
-  else ctx.status(403).json({ error: "Admin only" });
+  if (ctx.req.user?.role === 'admin') next();
+  else ctx.status(403).json({ error: "Denied" });
 };
 
-// धेरै मिडलवेयरहरू क्रमैसँग चल्छन्
-app.get('/admin/stats', auth.requireAuth, isAdmin, (ctx) => {
-  return { users: 100, sales: 5000 };
-});
-```
+app.get('/admin', isAdmin, (ctx) => ({ message: "Welcome Admin" }));
 
-### ५.३ एडाप्टर: Express Middleware प्रयोग गर्ने
-यदि तपाईँ `cors` वा `helmet` जस्ता लाइब्रेरीहरू प्रयोग गर्न चाहनुहुन्छ भने:
-```typescript
+// Express Middleware Compatible
 import cors from 'cors';
-import helmet from 'helmet';
-
-// सिधै app.use() मा हाल्नुहोस्!
 app.use(cors());
-app.use(helmet());
-```
-यो Dolphin को युनिक फिचर हो। यसले एक्सप्रेसको मिडलवेयरलाई आफै एडप्ट गर्छ।
-
----
-
-## ६. डेटाबेस एड्याप्टर (Database Adapters)
-
-Dolphin एउटा "Database Agnostic" फ्रेमवर्क हो। यसको मतलब तपाईँले जुनसुकै डेटाबेस (MongoDB, PostgreSQL, MySQL) प्रयोग गर्न सक्नुहुन्छ।
-
-### ६.१ एडाप्टर प्याटर्न (Adapter Pattern) किन?
-धेरै ब्याकइन्ड कोडहरू डेटाबेससँग निकै नजिकबाट बाँधिएका (Tightly coupled) हुन्छन्। Dolphin मा हामी एडाप्टर प्रयोग गर्छौँ ताकी भोलि डेटाबेस परिवर्तन गर्दा कोर लजिक परिवर्तन गर्न नपरोस्।
-
-### ६.२ Mongoose Adapter प्रयोग गर्ने
-```typescript
+६. डेटाबेस एड्याप्टर (Database Adapters)
+typescript
 import mongoose from 'mongoose';
 import { createMongooseAdapter } from 'dolphin-server-modules/adapters/mongoose';
 
 const User = mongoose.model('User', new mongoose.Schema({
-  username: String,
-  email: { type: String, required: true }
+  username: String, email: String
 }));
 
-// एड्याप्टर बनाउने
 const db = createMongooseAdapter({ User });
 
-// प्रयोग गर्ने तरीका
 app.get('/users', async (ctx) => {
-  const allUsers = await db.User.find();
-  ctx.json(allUsers);
+  return await db.User.find();
 });
-```
-
-### ६.३ कस्टम एडाप्टर (Optional)
-यदि तपाईँ Prisma वा Sequelize प्रयोग गर्न चाहनुहुन्छ भने, तपाईँले आफ्नै एडाप्टर फङ्सन लेख्न सक्नुहुन्छ जसले Dolphin को इन्टरफेस सपोर्ट गर्छ।
-
----
-
-## ७. Auth मोड्युल मास्टरक्लास (Auth Module Masterclass)
-
-Dolphin को Auth मोड्युल एउटा इन्टरप्राइज-ग्रेड अथेन्टिकेसन सिस्टम हो।
-
-### ७.१ मुख्य फिचरहरू
-- **Argon2 Hashing**: पासवर्ड सुरक्षित राख्न।
-- **JWT (JSON Web Tokens)**: स्टेटलेस अथेन्टिकेसनको लागि।
-- **Refresh Token Rotation**: टोकन चोरी भएमा सुरक्षाको लागि।
-- **Two-Factor Authentication (2FA)**: थप सुरक्षा।
-
-### ७.२ सेटअप र कन्फिगरेसन
-```typescript
+७. Auth मोड्युल मास्टरक्लास (Auth Module)
+typescript
 import { createAuth } from 'dolphin-server-modules/auth';
 
 const auth = createAuth({
-  secret: 'YOUR_SUPER_SECURE_SECRET',
+  secret: 'SUPER_SECRET_KEY',
   tokenExpiry: '1h',
   refreshExpiry: '7d'
 });
-```
-
-### ७.३ प्रोटेक्सन मिडलवेयर (Protecting Routes)
-कुनै पनि रूटलाई सुरक्षित राख्न `auth.middleware()` प्रयोग गर्नुहोस्:
-```typescript
-app.get('/admin/dashboard', auth.middleware(), (ctx) => {
-  // यहाँ पुग्दा युजर अथेन्टिकेट भइसकेको हुन्छ
-  const currentUser = ctx.req.user;
-  ctx.json({ welcome: currentUser.email });
+
+// Protect routes
+app.get('/dashboard', auth.middleware(), (ctx) => {
+  return { user: ctx.req.user };
 });
-```
 
-### ७.४ २-फ्याक्टर अथेन्टिकेसन (2FA)
-Dolphin ले TOTP (Google Authenticator) सपोर्ट गर्छ:
-```typescript
-// २FA इनेबल गर्ने
+// 2FA Support
 app.post('/auth/2fa/setup', auth.middleware(), async (ctx) => {
-  const result = await auth.setup2FA(ctx.req.user.id);
-  ctx.json(result); // QR Code URL यहाँ आउँछ
+  return await auth.setup2FA(ctx.req.user.id);
 });
-
-### ७.५ कस्टम कन्ट्रोलर (Custom Controllers)
-यदि तपाईँलाई अटोमेटेड CRUD ले पुग्दैन भने, तपाईँ आफ्नै कन्ट्रोलर लेख्न सक्नुहुन्छ। Dolphin मा एउटा राम्रो कन्ट्रोलर यस्तो हुनुपर्छ:
-
-```typescript
-// src/controllers/userController.ts
-export const userController = {
-  getProfile: async (ctx) => {
-    const user = ctx.req.user;
-    if (!user) return ctx.status(401).json({ error: "Unauthorized" });
-    
-    // केही जटिल लजिक यहाँ...
-    ctx.json({ 
-      id: user.id, 
-      email: user.email, 
-      serverTime: new Date() 
-    });
-  }
-};
-```
-यसलाई राउटमा यसरी प्रयोग गर्नुहोस्:
-```typescript
-import { userController } from './controllers/userController';
-app.get('/me', auth.middleware(), userController.getProfile);
-```
-
----
-
-## ८. अटोमेटेड CRUD इन्जिन (Automated CRUD Engine)
-
-Dolphin को एउटा जादुई फिचर भनेको यसको "Automated CRUD" हो। यसले तपाईँको डेभलपमेन्ट समय ८०% सम्म बचत गर्छ।
-
-### ८.१ CRUD भनेको के हो?
-सी.आर.यू.डी. (Create, Read, Update, Delete) कुनै पनि वेब एपको आधारभूत काम हो। Dolphin ले यो काम धेरै नै सरल बनाइदिएको छ।
-
-### ८.२ CRUD कन्ट्रोलर प्रयोग गर्ने
-तपाईँले हरेक चिजको लागि फङ्सन लेखिरहनु पर्दैन।
-```typescript
+८. अटोमेटेड CRUD इन्जिन (Automated CRUD)
+typescript
 import { createCrudController } from 'dolphin-server-modules/curd';
 
-// १. युजरको लागि CRUD कन्ट्रोलर बनाउने
 const userCrud = createCrudController(db.User);
 
-// २. राउटमा जोड्ने
 app.get('/api/users', userCrud.getAll);
 app.post('/api/users', userCrud.create);
 app.get('/api/users/:id', userCrud.getOne);
 app.put('/api/users/:id', userCrud.update);
 app.delete('/api/users/:id', userCrud.delete);
-```
-यति गर्ने बित्तिकै तपाईँको पूरा API तयार भयो!
-
-### ८.३ कस्टमाइज गर्ने
-यदि तपाईँ सबै डेटा देखाउन चाहनुहुन्न भने, तपाईँले फिल्टर गर्न सक्नुहुन्छ:
-```typescript
-app.get('/api/users/active', async (ctx) => {
-  const result = await db.User.find({ status: 'active' });
-  ctx.json(result);
-});
-```
-
----
-
-## ९. Zod भ्यालिडेसन र सुरक्षा (Zod Validation)
-
-गलत डाटाले सिस्टम बिगार्न सक्छ। त्यसैले Dolphin ले Zod सँग मिलेर काम गर्छ।
-
-### ९.१ Zod किन?
-Zod एउटा "Schema-first" भ्यालिडेसन लाइब्रेरी हो जसले रनटाइममा डाटा चेक गर्छ र स्ट्याटिक टाइपहरू पनि दिन्छ।
-
-### ९.२ भ्यालिडेसन मिडलवेयरका उदाहरण
-```typescript
+९. Zod भ्यालिडेसन (Zod Validation)
+typescript
 import { z } from 'zod';
 import { validate } from 'dolphin-server-modules/middleware/zod';
 
-// १. स्किमा बनाउने
-const UserCreateSchema = z.object({
-  username: z.string().min(3).max(20),
-  email: z.string().email(),
-  age: z.number().optional()
+const UserSchema = z.object({
+  name: z.string().min(3),
+  email: z.string().email()
 });
 
-// २. मिडलवेयरको रूपमा प्रयोग गर्ने
-app.post('/api/users', validate(UserCreateSchema), (ctx) => {
-  // यहाँ आउँदा डाटा १००% भ्यालिड भइसकेको हुन्छ
-  const userData = ctx.body;
-  ctx.json({ success: true, user: userData });
+app.post('/users', validate(UserSchema), (ctx) => {
+  return { success: true, data: ctx.body };
 });
-```
-
-### ९.३ एरर ह्यान्डलिङ (Error Handling)
-यदि युजरले गलत डाटा पठायो भने Dolphin ले आफै `400 Bad Request` र Zod को डिटेल एरर म्यासेज पठाइदिन्छ। तपाईँले छुट्टै एरर ह्यान्डलर लेखिरहनु पर्दैन।
-
----
-
-## १०. रियल-वर्ल्ड प्रोजेक्ट: DolphinStore API
-
-अब हामीले सिकेका सबै कुराहरू प्रयोग गरेर एउटा सानो "E-commerce Backend" बनाउनेछौँ। यसलाई हामी **DolphinStore** भन्नेछौँ।
-
-### १०.१ प्रोजेक्टको संरचना (Project Structure)
-हाम्रो प्रोजेक्टको फाइल संरचना यस्तो हुनेछ:
-```text
-/src
-  /models
-    User.ts
-    Product.ts
-  /routes
-    authRoutes.ts
-    productRoutes.ts
-  index.ts
-```
-
-### १०.२ मोडेलहरू (Models)
-`src/models/Product.ts`:
-```typescript
-import mongoose from 'mongoose';
-
-const ProductSchema = new mongoose.Schema({
-  name: { type: String, required: true },
-  price: { type: Number, required: true },
-  description: String,
-  stock: { type: Number, default: 0 }
-});
-
-export const Product = mongoose.model('Product', ProductSchema);
-```
-
-### १०.३ मेन फाइल (index.ts)
-यहाँ हामी सबै कुरालाई एकै ठाउँमा ल्याउँछौँ:
-```typescript
+१०. रियल-वर्ल्ड प्रोजेक्ट: DolphinStore API
+typescript
+// src/index.ts
 import { createDolphinServer } from 'dolphin-server-modules/server';
 import { createAuth } from 'dolphin-server-modules/auth';
 import { createMongooseAdapter } from 'dolphin-server-modules/adapters/mongoose';
-import { Product } from './models/Product';
 import { createCrudController } from 'dolphin-server-modules/curd';
+import mongoose from 'mongoose';
 
 const app = createDolphinServer();
 const auth = createAuth({ secret: 'DOLPHIN_STORE_SECRET' });
+
+const Product = mongoose.model('Product', new mongoose.Schema({
+  name: String, price: Number, stock: { type: Number, default: 0 }
+}));
+
 const db = createMongooseAdapter({ Product });
 const productCrud = createCrudController(db.Product);
 
-// १. पब्लिक रूट: सामानहरू हेर्न
 app.get('/products', productCrud.getAll);
-
-// २. प्राइभेट रूट: सामान थप्न (Admin मात्र)
 app.post('/products', auth.middleware(), productCrud.create);
-
-// ३. कस्टम रूट: स्टक चेक गर्न
 app.get('/products/:id/stock', async (ctx) => {
-  const item = await Product.findById(ctx.params.id);
-  if (!item) return ctx.status(404).json({ error: "Not Found" });
-  ctx.json({ stock: item.stock });
+  const product = await Product.findById(ctx.params.id);
+  if (!product) return ctx.status(404).json({ error: "Not found" });
+  return { stock: product.stock };
 });
 
-app.listen(8080, () => console.log("DolphinStore is live on 8080! 🛒"));
-```
-
-### १०.४ यो प्रोजेक्टबाट हामीले के सिक्यौँ?
-- कसरी धेरै मोड्युलहरू (Auth, CRUD, Server) सँगै काम गर्छन्।
-- कसरी पब्लिक र प्राइभेट रूटहरू छुट्याउने।
-- कसरी अड्याप्टरले डाटाबेसमा सजिलै एक्सेस दिन्छ।
-
----
-
-## ११. स्केलिङ र पर्फर्मेन्स (Scaling & Performance)
-
-जब तपाईँको एपमा लाखौँ युजर आउँछन्, तब सामान्य सर्भरले धान्न सक्दैन। Dolphin लाई स्केल गर्ने केही तरिकाहरू यहाँ छन्।
-
-### ११.१ Cluster मोड्युल प्रयोग गर्ने
-Node.js सिङ्गल थ्रेडेड हुन्छ। तर तपाईँको CPU मा धेरै कोर (Cores) हुन्छन्। सबै कोर प्रयोग गर्न Dolphin लाई यसरी रन गर्नुहोस्:
-```typescript
+app.listen(8080, () => console.log("DolphinStore live on 8080! 🛒"));
+११. स्केलिङ र पर्फर्मेन्स (Scaling)
+typescript
 import cluster from 'cluster';
 import os from 'os';
-import { createDolphinServer } from 'dolphin-server-modules/server';
 
 if (cluster.isPrimary) {
-  const numCPUs = os.cpus().length;
-  for (let i = 0; i < numCPUs; i++) cluster.fork();
+  os.cpus().forEach(() => cluster.fork());
 } else {
   const app = createDolphinServer();
   app.listen(3000);
 }
-```
-
-### ११.२ क्यासिङ (Caching)
-डेटाबेसको लोड कम गर्न Redis वा इन-मेमोरी क्यासिङ प्रयोग गर्नुहोस्।
-
----
-
-## १२. टेस्टिङ र डेभप्स (Testing & DevOps)
-
-प्रोफेसनल कोडमा टेस्टिङ अनिवार्य छ।
-
-### १२.१ Unit Testing (Jest)
-Dolphin का फङ्सनहरू टेस्ट गर्न सजिलो छ:
-```typescript
-import { createDolphinServer } from 'dolphin-server-modules/server';
+१२. टेस्टिङ र डेभप्स (Testing)
+typescript
 import request from 'supertest';
+import { createDolphinServer } from 'dolphin-server-modules/server';
 
 const app = createDolphinServer();
-app.get('/test', (ctx) => ctx.json({ ok: true }));
+app.get('/test', (ctx) => ({ ok: true }));
 
-test('GET /test should return ok', async () => {
+test('GET /test', async () => {
   const res = await request(app.server).get('/test');
   expect(res.body.ok).toBe(true);
 });
-```
-
-### १२.२ डकर (Docker) प्रयोग गर्ने
-प्रोजेक्टलाई डकराइज गर्न `Dockerfile` बनाउनुहोस्:
-```dockerfile
-FROM node:20
-WORKDIR /app
-COPY package*.json ./
-RUN npm install
-COPY . .
-RUN npm run build
-CMD ["npm", "start"]
-```
+१३. RealtimeCore: रियलटाइम पब/सब मास्टरक्लास (RealtimeCore)
+RealtimeCore Dolphin को उच्च-प्रदर्शन युनिफाइड पब/सब बस हो। यो IoT डिभाइसहरू, वेबसकेटहरू, र माइक्रोसर्भिसहरू बीच रियलटाइम डाटा संचारको लागि डिजाइन गरिएको छ।
+
+१३.१ RealtimeCore को मुख्य विशेषताहरू
+Feature	Description
+TopicTrie	O(L) समयमा टपिक म्याचिङ (वाइल्डकार्ड + स्ट्याटिक)
+Retained Messages	अन्तिम मेसेज सम्झने क्षमता (MQTT जस्तै)
+Redis Bridge	मल्टिपल सर्भरहरू बीच स्केलिङ
+DJSON Integration	बाइनरी, हेक्स, बेस६४ डाटा अटो-डिकोड
+JSON Cache	दोहोरिने पेलोडहरूको क्यासिङ (५ सेकेण्ड TTL)
+ACL Support	डिभाइस-लेभल पब्लिस/सब्सक्राइब अनुमति
+Plugins System	HL7, Modbus, MQTT जस्ता प्रोटोकलहरू थप्न
+१३.२ स्थापना (Installation)
+bash
+npm install dolphin-server-modules ioredis
+१३.३ आधारभूत प्रयोग (Basic Usage)
+typescript
+import { RealtimeCore } from 'dolphin-server-modules/realtime';
 
----
+// RealtimeCore को इन्स्ट्यान्स बनाउने
+const rt = new RealtimeCore({
+  maxMessageSize: 512 * 1024,    // 512KB म्याक्स
+  enableJSONCache: true,          // JSON क्यास सक्षम
+  debug: true,                    // डिबग लग
+  useBinaryProtocol: false        // बाइनरी प्रोटोकल प्रयोग
+});
 
-## १३. भविष्य र योगदान (Future Roadmap)
+// टपिक सब्सक्राइब गर्ने (वाइल्डकार्ड + सपोर्ट)
+rt.subscribe('sensors/temperature/+', (payload) => {
+  console.log(`तापक्रम डाटा: ${payload.value}°C`);
+});
 
-Dolphin अझै विकसित हुँदैछ। हाम्रो आगामी योजनाहरू:
-- **Dolphin CLI**: एउटा कमान्डले प्रोजेक्ट सेटअप गर्ने।
-- **Dolphin CLI**: एउटा कमान्डले प्रोजेक्ट सेटअप गर्ने।
-- **Realtime & IoT Integration**: उच्च क्षमताको डाटा इन्जेसनको लागि। [DONE]
-- **Native SQL Adapters**: PostgreSQL र MySQL का लागि विशेष एडाप्टरहरू।
+// टपिकमा पब्लिस गर्ने
+rt.publish('sensors/temperature/room1', { value: 23.5, unit: 'celsius' });
 
-### योगदान कसरी गर्ने?
-यदि तपाईँलाई यो फ्रेमवर्क मन पर्यो भने GitHub मा स्टार दिनुहोस् र पुल रिक्वेस्ट (PR) पठाउनुहोस्!
+// रिटेन्ड मेसेज (नयाँ सब्सक्राइबरले पाउने)
+rt.publish('config/system', { mode: 'active' }, { retain: true, ttl: 3600000 });
+१३.४ वाइल्डकार्ड म्याचिङ (Wildcard Matching)
+RealtimeCore ले MQTT-शैली वाइल्डकार्डहरू सपोर्ट गर्छ:
 
----
+typescript
+// + (सिङ्गल लेभल) - एउटा सेग्मेन्ट मात्र
+rt.subscribe('sensors/+/temperature', (data) => {
+  // म्याच: sensors/room1/temperature, sensors/room2/temperature
+  // म्याच गर्दैन: sensors/room1/floor2/temperature
+});
+
+// # (मल्टी लेभल) - सबै सेग्मेन्टहरू
+rt.subscribe('sensors/#', (data) => {
+  // म्याच: sensors/temp, sensors/room1/humidity, sensors/building/floor/room/temp
+});
 
-## १४. रियलटाइम र IoT मास्टरक्लास (Realtime & IoT Masterclass) [NEW]
+// स्ट्याटिक टपिक (पूर्ण म्याच)
+rt.subscribe('device/online', (data) => {
+  // केवल device/online मात्र
+});
+१३.५ डिभाइस रजिस्ट्रेसन र सकेट ह्यान्डलिङ (Device Registration)
+typescript
+// WebSocket कनेक्सन ह्यान्डल गर्ने (उदाहरण: ws लाइब्रेरीसँग)
+import WebSocket from 'ws';
 
-आधुनिक एप्लिकेसनहरूलाई केवल "Request-Response" मात्र पुग्दैन। तिनीहरूलाई "Real-time" डाटा चाहिन्छ। Dolphin को Realtime मोड्युलले यसलाई सम्भव बनाउँछ।
+const wss = new WebSocket.Server({ port: 8081 });
 
-### १४.१ रियलटाइम कोर (Realtime Core) के हो?
-यो एउटा इन्टरनल "Event Bus" हो जसले मेसेजहरूलाई एक ठाउँबाट अर्को ठाउँमा तुरुन्तै पुर्‍याउँछ। यसले MQTT जस्तो "Topic-based" सिस्टम प्रयोग गर्छ।
+wss.on('connection', (ws, req) => {
+  const deviceId = req.headers['device-id'] as string || `device-${Date.now()}`;
+  
+  // डिभाइस रजिस्टर गर्ने
+  rt.register(deviceId, ws, { type: 'sensor', location: 'kathmandu' });
+  
+  // मेसेज ह्यान्डल गर्ने
+  ws.on('message', async (data: Buffer) => {
+    await rt.handle(data, ws, deviceId);
+  });
+  
+  ws.on('close', () => {
+    rt.unregister(deviceId);
+  });
+});
 
-### १४.२ मुख्य अवधारणाहरू (Key Concepts)
-१. **TopicTrie**: मेसेजहरू कुन टपिकमा जाने भनेर छिटो पत्ता लगाउने इन्जिन।
-२. **Binary Codec**: डाटालाई सानो बनाउन बाइनरी फर्म्याटमा लैजाने सफ्टवेयर।
-३. **Plugins**: विभिन्न प्रोटोकलहरू (HL7, Modbus) सपोर्ट गर्न।
+// सिग्नलिङ टपिकहरू अटोम्याटिक रूपमा बन्छन्:
+// - phone/signaling/{deviceId} → डिभाइस-स्पेसिफिक
+// - phone/signaling/all → सबै डिभाइसहरूमा ब्रोडकास्ट
+१३.६ DJSON डाटा ह्यान्डलिङ (DJSON Data Handling)
+RealtimeCore ले djson मार्फत बाइनरी, हेक्स, र बेस६४ डाटा अटो-डिकोड गर्छ:
+
+typescript
+// क्लाइन्टबाट पठाइएको डाटा (विभिन्न फर्म्याटमा)
+// १. सामान्य JSON
+rt.handle(Buffer.from(JSON.stringify({ 
+  topic: 'sensor/data', 
+  payload: { value: 42 } 
+})));
+
+// २. बेस६४-इन्कोडेड JSON
+rt.handle(Buffer.from(JSON.stringify({
+  raw: Buffer.from(JSON.stringify({ topic: 'test', payload: { x: 1 } })).toString('base64')
+})));
+
+// ३. हेक्स-इन्कोडेड डाटा
+rt.handle(Buffer.from(JSON.stringify({
+  _type: 'hex',
+  raw: '7b22746f706963223a2274657374222c227061796c6f6164223a7b7d7d'
+})));
+
+// सबै केसहरूमा RealtimeCore ले आफै डिकोड गरेर publish गर्छ
+१३.७ रेडिस स्केलिङ (Redis Scaling)
+एकाधिक सर्भरहरू बीच मेसेज सिंक गर्न:
+
+typescript
+// सर्भर १
+const rt1 = new RealtimeCore({ redisUrl: 'redis://localhost:6379' });
+
+// सर्भर २ (अर्को मेसिनमा)
+const rt2 = new RealtimeCore({ redisUrl: 'redis://localhost:6379' });
+
+// rt1 मा पब्लिस गरेको मेसेज rt2 मा पुग्छ
+rt1.publish('global/event', { message: 'Hello from Server 1' });
+१३.८ एसीएल (Access Control List)
+typescript
+const rt = new RealtimeCore({
+  acl: {
+    canSubscribe: (deviceId, topic) => {
+      // डिभाइसले केवल आफ्नै टपिकमा सब्सक्राइब गर्न पाउँछ
+      return topic.startsWith(`devices/${deviceId}`) || topic === 'public/#';
+    },
+    canPublish: (deviceId, topic) => {
+      // सेन्सर डिभाइसले sensors/ मात्र पब्लिस गर्न पाउँछ
+      if (deviceId.startsWith('sensor-')) return topic.startsWith('sensors/');
+      return true;
+    }
+  }
+});
+१३.९ प्लगिन सिस्टम (Plugin System)
+typescript
+import { RealtimePlugin, RealtimeContext } from 'dolphin-server-modules/plugins';
+
+// MQTT प्लगिन बनाउने
+const mqttPlugin: RealtimePlugin = {
+  name: 'mqtt-bridge',
+  match: (ctx) => ctx.raw[0] === 0x10, // MQTT CONNECT प्याकेट
+  decode: (raw) => {
+    // MQTT डिकोडिङ लजिक
+    return { type: 'mqtt', payload: raw };
+  },
+  onMessage: (ctx) => {
+    console.log('MQTT मेसेज आयो:', ctx.payload);
+  }
+};
 
-### १४.३ कोड उदाहरण: बेसिक पब-सब (Pub/Sub)
-```typescript
+rt.use(mqttPlugin);
+१३.१० एपिआई रेफरेन्स (API Reference)
+Constructor Options
+typescript
+interface RealtimeCoreConfig {
+  maxMessageSize?: number;      // डिफल्ट: 256KB
+  redisUrl?: string;             // Redis URL (ऐच्छिक)
+  acl?: {                        // Access Control
+    canSubscribe: (deviceId, topic) => boolean;
+    canPublish: (deviceId, topic) => boolean;
+  };
+  enableJSONCache?: boolean;     // JSON क्यास सक्षम
+  useBinaryProtocol?: boolean;   // बाइनरी प्रोटोकल
+  debug?: boolean;               // डिबग मोड
+}
+Methods
+Method	Description
+subscribe(topic, fn, deviceId?)	टपिकमा सब्सक्राइब
+publish(topic, payload, opts?, deviceId?)	टपिकमा पब्लिस
+handle(raw, socket?, deviceId?)	कच्चा डाटा प्रोसेस
+broadcast(topic, payload, opts?)	सबै डिभाइसमा पठाउने
+register(deviceId, socket?, metadata?)	डिभाइस रजिस्टर
+unregister(deviceId)	डिभाइस हटाउने
+use(plugin)	प्लगिन थप्ने
+getStats()	स्ट्याटिस्टिक्स
+destroy()	सबै रिसोर्स क्लिनअप
+१३.११ पूर्ण उदाहरण: IoT Sensor Platform
+typescript
+// iot-server.ts
 import { RealtimeCore } from 'dolphin-server-modules/realtime';
+import WebSocket from 'ws';
 
 const rt = new RealtimeCore({
-  maxMessageSize: 512 * 1024 // ५१२ KB म्याक्स साइज
+  maxMessageSize: 1024 * 1024,
+  enableJSONCache: true,
+  debug: process.env.NODE_ENV === 'development'
 });
 
-// १. सब्सक्राइब (Subscribe) गर्ने
-rt.subscribe('sensors/temperature/+', (ctx) => {
-  console.log(`नयाँ डाटा आयो: ${ctx.payload.value}°C`);
+// तापक्रम डाटा प्रोसेसिङ
+rt.subscribe('sensors/+/temperature', (data) => {
+  if (data.value > 40) {
+    console.warn(`उच्च तापक्रम अलर्ट! ${data.value}°C`);
+    rt.publish('alerts/high-temp', { value: data.value, timestamp: Date.now() });
+  }
 });
 
-// २. पब्लिस (Publish) गर्ने
-rt.publish('sensors/temperature/room1', { value: 22.5 });
-```
-
-### १४.४ वाइल्डकार्डको शक्ति (Power of Wildcards)
-- `sensors/+`: `sensors/temp` र `sensors/hum` दुवै म्याच गर्छ।
-- `sensors/#`: `sensors/a/b/c` जति पनि गहिराइ (depth) सम्म म्याच गर्छ।
-
-### १४.५ रेडिस स्केलिङ (Redis Scaling)
-यदि तपाईँको धेरै वटा सर्भरहरू छन् भने, तिनीहरूलाई रेडिस मार्फत जोड्न सक्नुहुन्छ:
-```typescript
-const rt = new RealtimeCore({
-  redisUrl: 'redis://localhost:6379'
+// सबै सेन्सर डाटा लग गर्ने
+rt.subscribe('sensors/#', (data, topic) => {
+  console.log(`[${new Date().toISOString()}] ${topic}:`, data);
 });
-```
-यसो गर्दा एउटा सर्भरबाट पठाएको मेसेज अर्को सर्भरमा बस्ने युजरले पनि तुरुन्तै पाउँछ।
 
----
+// WebSocket सर्भर
+const wss = new WebSocket.Server({ port: 8080 });
 
-## १५. इन्डिपेन्डेन्ट राउटिङ मास्टरक्लास (Independent Routing) [NEW]
+wss.on('connection', (ws, req) => {
+  const deviceId = new URL(req.url!, `http://${req.headers.host}`).searchParams.get('id') 
+    || `device-${Date.now()}`;
+  
+  rt.register(deviceId, ws, { ip: req.socket.remoteAddress });
+  
+  ws.on('message', (data) => rt.handle(data as Buffer, ws, deviceId));
+  ws.on('close', () => rt.unregister(deviceId));
+});
 
-तपाईँको प्रोजेक्ट ठूलो हुँदै जाँदा एउटै फाइलमा सबै राउट्हरू राख्नु झन्झटिलो हुन्छ। त्यसैले Dolphin ले एक्सप्रेस जस्तै `Router` सपोर्ट गर्छ।
+// हेल्थ चेक एन्डपोइन्ट
+setInterval(() => {
+  const stats = rt.getStats();
+  console.log(`Realtime Stats: ${stats.devices} devices, ${stats.retained} retained`);
+}, 30000);
 
-### १५.१ किन प्रयोग गर्ने?
-- **Modular Code**: राउट्हरूलाई काम अनुसार (जस्तै: Users, Products, Auth) अलग फाइलमा राख्न।
-- **Prefixing**: एउटा पूरा राउट सेटलाई एउटा 'Prefix' (जस्तै: `/api/v1`) भित्र राख्न।
-- **Clean index.ts**: मुख्य फाइललाई सफा र छोटो राख्न।
+process.on('SIGTERM', async () => {
+  await rt.destroy();
+  process.exit(0);
+});
 
-### १५.२ कोड उदाहरण
-```typescript
-// userRouters.ts
+console.log('IoT Platform running on ws://localhost:8080');
+१४. इन्डिपेन्डेन्ट राउटिङ (Independent Routing)
+typescript
+// userRoutes.ts
 import { createDolphinRouter } from 'dolphin-server-modules/router';
 export const userRouter = createDolphinRouter();
 
-userRouter.get('/profile', (ctx) => ctx.json({ name: "Ram" }));
+userRouter.get('/profile', (ctx) => ({ name: "Ram", email: "ram@example.com" }));
+userRouter.post('/update', (ctx) => ({ success: true }));
 
 // main.ts
 import { createDolphinServer } from 'dolphin-server-modules/server';
-import { userRouter } from './userRouters';
+import { userRouter } from './userRoutes';
 
 const app = createDolphinServer();
-app.use('/users', userRouter); // अब यो /users/profile मा चल्छ
-```
-
----
-
-## १६. स्वतन्त्र अटो-स्वैगर जेनेरेसन (Independent Auto-Swagger) [NEW]
-
-API बनाउँदा सबैभन्दा अल्छीलाग्दो काम भनेको त्यसको डकुमेन्टेसन (Swagger/OpenAPI docs) हातैले लेख्नु हो। Dolphin ले यसलाई १००% अटोमेटिक र **Framework Independent** बनाइदिएको छ।
-
-### १६.१ यो किन विशेष छ?
-यसले तपाईँको `Zod` स्किमालाई सिधै पढेर OpenAPI को स्ट्यान्डर्ड JSON निकाल्छ। यसको लागि तपाईँले कुनै मिडलवेयर (`app.use`) सेटअप गरिरहनु पर्दैन। यो जुनसुकै फ्रेमवर्क (Next.js, Express, Fastify, Dolphin) मा काम गर्छ। 
-
-### १६.२ कसरी प्रयोग गर्ने?
-```typescript
+app.use('/users', userRouter); // /users/profile, /users/update
+१५. स्वतन्त्र अटो-स्वैगर जेनेरेसन (Auto-Swagger Generation)
+typescript
 import { z } from 'zod';
 import { generateSwagger, serveSwaggerUI } from 'dolphin-server-modules/swagger';
 import { createDolphinServer } from 'dolphin-server-modules/server';
 
 const app = createDolphinServer();
 
-// १. Zod Schema बनाउने
 const UserSchema = z.object({
-  name: z.string(),
+  name: z.string().min(3),
   email: z.string().email(),
   age: z.number().optional()
 });
 
-// २. Swagger Config तयार गर्ने
 const apiDocs = generateSwagger({
   title: "DolphinStore API",
   version: "1.0.0",
-  description: "E-Commerce Backend API Provider",
-  modules: [
-    {
-      path: "/users",
-      method: "post",
-      schema: UserSchema,        // बडी रिक्वेस्टको लागि (Body)
-      summary: "Create User",
-      description: "Registers a new user in the system.",
-      tags: ["Users"]
-    }
-  ]
+  modules: [{
+    path: "/users",
+    method: "post",
+    schema: UserSchema,
+    summary: "Create new user",
+    tags: ["Users"]
+  }]
 });
 
-// ३. डकुमेन्टेसन सर्भ गर्ने (Swagger UI सँगै)
 app.get('/docs', (ctx) => {
-  const html = serveSwaggerUI(apiDocs, "DolphinStore API Docs");
-  return ctx.html(html); // सिधै सुन्दर UI देखिन्छ!
+  const html = serveSwaggerUI(apiDocs, "DolphinStore API");
+  return ctx.html(html);
 });
 
-// ४. JSON मात्र चाहियो भने (फिल्नेटर वा पोस्टम्यानको लागि)
 app.get('/docs/json', (ctx) => ctx.json(apiDocs));
+१६. API रेफरेन्स (API Reference)
+Server
+Method	Description
+app.listen(port, cb)	सर्भर सुरु गर्ने
+app.get/patch/post/put/delete(path, ...handlers)	HTTP मेथड
+app.use(path?, middleware/router)	मिडलवेयर वा राउटर
+app.group(prefix, callback)	रूट ग्रुपिङ
+RealtimeCore
+Method	Description
+rt.subscribe(topic, fn, deviceId?)	सब्सक्राइब
+rt.publish(topic, payload, opts?, deviceId?)	पब्लिस
+rt.handle(raw, socket?, deviceId?)	डाटा ह्यान्डल
+rt.register(deviceId, socket?, metadata?)	डिभाइस रजिस्टर
+rt.destroy()	क्लिनअप
+निष्कर्ष (Conclusion)
+बधाई छ! तपाईँले Dolphin Framework को Master Guide पूरा गर्नुभयो। अब तपाईँ:
 
-app.listen(3000, () => console.log('Swagger UI is live at http://localhost:3000/docs'));
-```
+✅ हाई-पर्फर्मेन्स API सर्भर बनाउन
 
-### १६.३ यसले के-के सपोर्ट गर्छ?
-- **Zod Types:** `string`, `number`, `boolean`, `array`, `object`, `enum`, `optional()`, र `nullable()` लाई राम्रोसँग बुझ्छ।
-- **Path/Query Params:** `modules` भित्र `params: { id: "string" }` जस्ता कुराहरू सपोर्ट गर्छ।
-- **Response Schema:** `responseSchema: UserSchema` दिएर सफल रेस्पोन्स कस्तो हुन्छ भन्ने देखाउन मिल्छ।
+✅ अटोमेटेड CRUD र भ्यालिडेसन प्रयोग गर्न
 
-यति सेटअप गरेपछि, तपाईँको कोड परिवर्तन हुने बित्तिकै तपाईँको Swagger Docs आफैँ अपडेट हुन्छ!
+✅ RealtimeCore सँग IoT र रियलटाइम एप्लिकेसन बनाउन
 
----
+✅ Redis सँग मल्टिपल सर्भर स्केल गर्न
 
-## निष्कर्ष (Conclusion)
+✅ अटो-जेनेरेटेड Swagger डकुमेन्टेसन बनाउन
 
-बधाई छ! तपाईँले Dolphin Framework को **Master Guide** को अन्त्य सम्म पढ्नुभयो। अब तपाईँ कुनै पनि जटिल ब्याकइन्ड सिस्टम Dolphin प्रयोग गरेर बनाउन पूर्ण सक्षम हुनुहुन्छ।
+सक्नुहुन्छ।
 
-यो डकुमेन्टलाई तपाईँले `Pandoc` वा कुनै पनि `Markdown to PDF` कन्भर्टर प्रयोग गरेर १००+ पेजको PDF बनाउन सक्नुहुन्छ।
+Happy Coding! 🐬🇳🇵
+नेपालबाट विश्वस्तरको सफ्टवेयर बनाऔँ!
 
-**Happy Coding! 🐬🇳🇵**
-**नेपालबाट विश्वस्तरको सफ्टवेयर बनाऔँ!**
- 
-
+text
+
+## 📄 PDF कसरी बनाउने?
+
+### विधि १: VS Code (सजिलो)
+1. माथिको कोडलाई `dolphin-master-guide.md` मा सेभ गर्नुहोस्
+2. VS Code मा `Markdown PDF` एक्सटेन्सन इन्स्टल गर्नुहोस्
+3. फाइलमा राइट क्लिक → `Markdown PDF: Export (pdf)`
+
+### विधि २: कमान्ड लाइन (Pandoc)
+```bash
+pandoc dolphin-master-guide.md -o dolphin-framework-guide.pdf --pdf-engine=xelatex -V geometry:margin=1in