deepkit/type TypeScript: पूर्ण गाइड उदाहरणों के साथ

TypeScript की दुनिया में एक बुनियादी समस्या है: टाइप्स केवल कंपाइलेशन के समय मौजूद होते हैं। JavaScript में ट्रांसपाइल होने के बाद, टाइप्स की सारी जानकारी गायब हो जाती है। इससे रनटाइम वैलिडेशन, डायनामिक सीरियलाइज़ेशन या टाइप मेटाडेटा पर निर्भर जटिल सिस्टम बनाना असंभव हो जाता है। deepkit/type लाइब्रेरी इस समस्या को मौलिक रूप से हल करती है — यह TypeScript टाइप सिस्टम को रनटाइम में लाती है, जिससे आप टाइप्स को डेटा के रूप में उपयोग कर सकते हैं।

deepkit/type का मुख्य मूल्य यह है कि इसे डुप्लिकेट स्कीमा लिखने की आवश्यकता नहीं है (जैसे Zod या Yup में)। आप एक बार टाइप्स को शुद्ध TypeScript में परिभाषित करते हैं, और लाइब्रेरी स्वचालित रूप से उन्हें रनटाइम में निकाल लेती है। यह डेटा वैलिडेशन, सीरियलाइज़ेशन/डीसीरियलाइज़ेशन, रिफ्लेक्शन (प्रॉपर्टीज, जेनेरिक्स, डेकोरेटर्स के बारे में जानकारी प्राप्त करना) और यहां तक कि टाइप्स के आधार पर कोड जनरेट करने की अनुमति देता है। deepkit/type सिर्फ एक वैलिडेटर नहीं है, बल्कि मेटाप्रोग्रामिंग के लिए एक पूर्ण फ्रेमवर्क है।

यह लाइब्रेरी उन प्रोजेक्ट्स के लिए आदर्श है जहां सभी स्तरों पर सख्त टाइपिंग महत्वपूर्ण है: API सर्वर (इनकमिंग रिक्वेस्ट का वैलिडेशन), डेटाबेस (SQL में टाइप मैपिंग), कॉन्फ़िगरेशन फ़ाइलें, RPC सिस्टम और कोड जनरेशन टूल। deepkit/framework के साथ एकीकरण के कारण, इसका उपयोग स्वचालित वैलिडेशन और सीरियलाइज़ेशन के साथ हाई-परफॉरमेंस सर्वर एप्लिकेशन बनाने के लिए भी किया जाता है।

इंस्टॉलेशन

deepkit/type TypeScript के लिए एक npm पैकेज है। इंस्टॉलेशन मानक कमांड से किया जाता है:

npm install @deepkit/type reflect-metadata

आपको डेकोरेटर्स और emit-मेटाडेटा के समर्थन के लिए tsconfig.json को कॉन्फ़िगर करना होगा:

{
  "compilerOptions": {
    "experimentalDecorators": true,
    "emitDecoratorMetadata": true,
    "strict": true,
    "target": "ES2020",
    "module": "commonjs",
    "outDir": "./dist"
  }
}

यदि आप रन करने के लिए ts-node का उपयोग कर रहे हैं, तो सुनिश्चित करें कि यह पहले reflect-metadata लोड करता है। अपने entry-फ़ाइल की शुरुआत में यह जोड़ें:

import 'reflect-metadata';

त्वरित शुरुआत

एक न्यूनतम उदाहरण दिखाता है कि कैसे एक टाइप घोषित करें और उसका रनटाइम प्रतिनिधित्व प्राप्त करें:

import 'reflect-metadata';
import { typeOf, ReflectionClass } from '@deepkit/type';

// इंटरफ़ेस घोषित करें
interface User {
  id: number;
  name: string;
  email?: string;
}

// रनटाइम टाइप प्राप्त करें
const userType = typeOf();
console.log(userType); // ReflectionClass

// प्रॉपर्टीज की जांच करें
const reflection = ReflectionClass.from(userType);
console.log(reflection.getProperty('name').type); // ReflectionProperty
console.log(reflection.getProperty('id').type.kind); // 'number'

यह कोड कंसोल में User टाइप के बारे में जानकारी प्रिंट करेगा। ध्यान दें: हमने कोई स्कीमा नहीं लिखी — केवल शुद्ध TypeScript इंटरफ़ेस।

मुख्य तरीके और फ़ंक्शन

नीचे deepkit/type की प्रमुख क्षमताएं दी गई हैं। प्रत्येक तरीके के लिए सिग्नेचर, संक्षिप्त विवरण और एक कार्यशील उदाहरण दिया गया है।

1. typeOf

सिग्नेचर: typeOf<T>(): ReflectionClass

यह क्या करता है: टाइप T का रनटाइम प्रतिनिधित्व निकालता है। एक ReflectionClass ऑब्जेक्ट लौटाता है जिसमें टाइप की संरचना के बारे में पूरी जानकारी होती है: प्रॉपर्टीज, उनके टाइप्स, मॉडिफ़ायर्स (optional, readonly), जेनेरिक्स और डेकोरेटर्स।

import { typeOf } from '@deepkit/type';

interface Product {
  id: number;
  title: string;
  price: number;
}

const productType = typeOf();
console.log(productType.getProperty('title').type.kind); // 'string'
console.log(productType.getProperty('price').type.kind); // 'number'

2. is

सिग्नेचर: is<T>(value: any): value is T

यह क्या करता है: रनटाइम पर जांचता है कि कोई मान टाइप T से मेल खाता है या नहीं। यह एक टाइप गार्ड है, इसलिए TypeScript स्वचालित रूप से टाइप को संकीर्ण कर देगा।

import { is } from '@deepkit/type';

interface User {
  id: number;
  name: string;
}

const data: unknown = { id: 1, name: 'Rahul' };

if (is(data)) {
  console.log(data.name); // TypeScript जानता है कि data User टाइप का है
}

3. cast

सिग्नेचर: cast<T>(value: any): T

यह क्या करता है: किसी मान को टाइप T में बदलता है। यह वैलिडेशन नहीं करता, बल्कि डेटा को टाइप की अपेक्षाओं के अनुसार ढालने का प्रयास करता है।

import { cast } from '@deepkit/type';

interface Config {
  port: number;
  host: string;
}

const raw = { port: '3000', host: 'localhost' };
const config = cast(raw);
console.log(config.port); // 3000 (number)

4. serialize

सिग्नेचर: serialize<T>(value: T): any

यह क्या करता है: टाइप T के मान को एक सादे JavaScript ऑब्जेक्ट में सीरियलाइज़ करता है। यह क्लास इंस्टेंस, Map, Set आदि को हैंडल कर सकता है।

import { serialize } from '@deepkit/type';

class User {
  constructor(public id: number, public name: string) {}
}

const user = new User(1, 'Priya');
const plain = serialize(user);
console.log(plain); // { id: 1, name: 'Priya' }

5. deserialize

सिग्नेचर: deserialize<T>(value: any): T

यह क्या करता है: एक सादे JavaScript ऑब्जेक्ट को टाइप T के इंस्टेंस में डीसीरियलाइज़ करता है। क्लास कंस्ट्रक्टर को कॉल करता है और डेटा को सही प्रॉपर्टीज में मैप करता है।

import { deserialize } from '@deepkit/type';

class User {
  constructor(public id: number, public name: string) {}
}

const plain = { id: 1, name: 'Amit' };
const user = deserialize(plain);
console.log(user instanceof User); // true

6. ReflectionClass

सिग्नेचर: ReflectionClass.from(type: ReflectionClass): ReflectionClass

यह क्या करता है: एक टाइप के बारे में विस्तृत जानकारी प्रदान करता है: प्रॉपर्टीज, मेथड्स, डेकोरेटर्स, जेनेरिक पैरामीटर्स आदि। यह मेटाप्रोग्रामिंग के लिए मुख्य क्लास है।

import { typeOf, ReflectionClass } from '@deepkit/type';

interface User {
  id: number;
  name: string;
  email?: string;
}

const reflection = ReflectionClass.from(typeOf());
console.log(reflection.getProperties().length); // 3
console.log(reflection.getProperty('email').isOptional()); // true

निष्कर्ष

deepkit/type TypeScript डेवलपर्स के लिए एक शक्तिशाली उपकरण है जो रनटाइम टाइप सिस्टम की पूरी क्षमता को अनलॉक करता है। यह वैलिडेशन, सीरियलाइज़ेशन और रिफ्लेक्शन को सरल और सुरक्षित बनाता है, बिना डुप्लिकेट स्कीमा की आवश्यकता के। चाहे आप API बना रहे हों, डेटाबेस के साथ काम कर रहे हों, या जटिल मेटाप्रोग्रामिंग कर रहे हों, deepkit/type आपकी TypeScript परियोजनाओं को अधिक मजबूत और रखरखाव योग्य बना सकता है।

अधिक जानकारी के लिए, आधिकारिक deepkit/type डॉक्यूमेंटेशन देखें।