జావాస్క్రిప్ట్ డెకరేటర్ల కంపోజిషన్: మెటాడేటా ఇన్హెరిటెన్స్ చైన్స్‌పై పట్టు సాధించడం

నిరంతరం అభివృద్ధి చెందుతున్న జావాస్క్రిప్ట్ డెవలప్‌మెంట్ ప్రపంచంలో, సొగసైన, నిర్వహించదగిన, మరియు స్కేలబుల్ కోడ్ రాయడం చాలా ముఖ్యం. ఆధునిక జావాస్క్రిప్ట్, ముఖ్యంగా టైప్‌స్క్రిప్ట్‌తో కలిపినప్పుడు, డెవలపర్లు మరింత వ్యక్తీకరణ మరియు పటిష్టమైన అప్లికేషన్‌లను రాయడానికి శక్తివంతమైన ఫీచర్లను అందిస్తుంది. అలాంటి ఒక ఫీచర్, డెకరేటర్లు, క్లాస్‌లను మరియు వాటి సభ్యులను డిక్లరేటివ్ పద్ధతిలో మెరుగుపరచడానికి ఒక గేమ్-ఛేంజర్‌గా ఉద్భవించింది. కంపోజిషన్ ప్యాటర్న్‌తో కలిపినప్పుడు, డెకరేటర్లు మెటాడేటాను నిర్వహించడానికి మరియు సంక్లిష్టమైన ఇన్హెరిటెన్స్ చైన్‌లను సృష్టించడానికి ఒక అధునాతన విధానాన్ని అందిస్తాయి, వీటిని తరచుగా మెటాడేటా ఇన్హెరిటెన్స్ చైన్‌లుగా పిలుస్తారు.

ఈ కథనం జావాస్క్రిప్ట్ డెకరేటర్ల కంపోజిషన్ ప్యాటర్న్‌లోకి లోతుగా వెళుతుంది, దాని ప్రాథమిక సూత్రాలు, ఆచరణాత్మక అప్లికేషన్‌లు, మరియు మీ సాఫ్ట్‌వేర్ ఆర్కిటెక్చర్‌పై అది చూపగల లోతైన ప్రభావాన్ని అన్వేషిస్తుంది. మనం డెకరేటర్ ఫంక్షనాలిటీ యొక్క సూక్ష్మ నైపుణ్యాల ద్వారా నావిగేట్ చేస్తాం, కంపోజిషన్ వాటి శక్తిని ఎలా పెంచుతుందో అర్థం చేసుకుంటాం, మరియు సంక్లిష్ట వ్యవస్థలను నిర్మించడానికి సమర్థవంతమైన మెటాడేటా ఇన్హెరిటెన్స్ చైన్‌లను ఎలా నిర్మించాలో వివరిస్తాం.

జావాస్క్రిప్ట్ డెకరేటర్లను అర్థం చేసుకోవడం

కంపోజిషన్‌లోకి వెళ్లే ముందు, డెకరేటర్లు అంటే ఏమిటి మరియు అవి జావాస్క్రిప్ట్‌లో ఎలా పనిచేస్తాయో గట్టిగా అర్థం చేసుకోవడం చాలా ముఖ్యం. డెకరేటర్లు ప్రపోజ్డ్ స్టేజ్ 3 ECMAScript ఫీచర్, ఇది టైప్‌స్క్రిప్ట్‌లో విస్తృతంగా ఆమోదించబడింది మరియు ప్రామాణీకరించబడింది. ఇవి ముఖ్యంగా క్లాస్‌లు, మెథడ్స్, ప్రాపర్టీలు, లేదా పారామీటర్లకు జతచేయగల ఫంక్షన్‌లు. వాటి ప్రాథమిక ఉద్దేశ్యం, డెకరేట్ చేయబడిన ఎలిమెంట్ యొక్క అసలు సోర్స్ కోడ్‌ను నేరుగా మార్చకుండా దాని ప్రవర్తనను సవరించడం లేదా మెరుగుపరచడం.

వాటి మూలంలో, డెకరేటర్లు హయ్యర్-ఆర్డర్ ఫంక్షన్‌లు. అవి డెకరేట్ చేయబడిన ఎలిమెంట్ గురించి సమాచారాన్ని అందుకుంటాయి మరియు దాని యొక్క కొత్త వెర్షన్‌ను తిరిగి ఇవ్వగలవు లేదా సైడ్ ఎఫెక్ట్‌లను చేయగలవు. సింటాక్స్ సాధారణంగా క్లాస్ లేదా మెంబర్ యొక్క డిక్లరేషన్‌కు ముందు '@' చిహ్నాన్ని, ఆ తర్వాత డెకరేటర్ ఫంక్షన్ పేరును ఉంచడం ద్వారా ఉంటుంది.

డెకరేటర్ ఫ్యాక్టరీలు

డెకరేటర్లతో ఒక సాధారణ మరియు శక్తివంతమైన ప్యాటర్న్ డెకరేటర్ ఫ్యాక్టరీల ఉపయోగం. డెకరేటర్ ఫ్యాక్టరీ అనేది డెకరేటర్‌ను తిరిగి ఇచ్చే ఒక ఫంక్షన్. ఇది మీ డెకరేటర్‌కు ఆర్గ్యుమెంట్‌లను పంపడానికి, దాని ప్రవర్తనను అనుకూలీకరించడానికి అనుమతిస్తుంది. ఉదాహరణకు, మీరు డెకరేటర్‌కు పంపిన ఆర్గ్యుమెంట్ ద్వారా నియంత్రించబడే వివిధ స్థాయిల వెర్బోసిటీతో మెథడ్ కాల్స్‌ను లాగ్ చేయాలనుకోవచ్చు.

            function logMethod(level: 'info' | 'warn' | 'error') {
  return function(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
    const originalMethod = descriptor.value;
    descriptor.value = function(...args: any[]) {
      console[level](`[${propertyKey}] Called with: ${JSON.stringify(args)}`);
      return originalMethod.apply(this, args);
    };
  };
}

class MyService {
  @logMethod('info')
  getData(id: number): string {
    return `Data for ${id}`;
  }
}

const service = new MyService();
service.getData(123);

            

              
                Copy
              
            
          

ఈ ఉదాహరణలో, logMethod ఒక డెకరేటర్ ఫ్యాక్టరీ. ఇది ఒక level ఆర్గ్యుమెంట్‌ను అంగీకరించి, అసలు డెకరేటర్ ఫంక్షన్‌ను తిరిగి ఇస్తుంది. ఆ తర్వాత తిరిగి ఇవ్వబడిన డెకరేటర్, పేర్కొన్న స్థాయితో దాని ఇన్వోకేషన్‌ను లాగ్ చేయడానికి getData మెథడ్‌ను సవరిస్తుంది.

కంపోజిషన్ యొక్క సారాంశం

కంపోజిషన్ ప్యాటర్న్ అనేది ఒక ప్రాథమిక డిజైన్ సూత్రం, ఇది సరళమైన, స్వతంత్ర భాగాలను కలపడం ద్వారా సంక్లిష్ట వస్తువులను లేదా కార్యాచరణలను నిర్మించడాన్ని నొక్కి చెబుతుంది. కఠినమైన క్లాస్ హైరార్కీ ద్వారా కార్యాచరణను ఇన్హెరిట్ చేయడానికి బదులుగా, కంపోజిషన్ వస్తువులను ఇతర వస్తువులకు బాధ్యతలను అప్పగించడానికి అనుమతిస్తుంది. ఇది ఫ్లెక్సిబిలిటీ, పునర్వినియోగం, మరియు సులభమైన టెస్టింగ్‌ను ప్రోత్సహిస్తుంది.

డెకరేటర్ల సందర్భంలో, కంపోజిషన్ అంటే ఒకే ఎలిమెంట్‌కు బహుళ డెకరేటర్లను వర్తింపజేయడం. జావాస్క్రిప్ట్ రన్‌టైమ్ మరియు టైప్‌స్క్రిప్ట్ కంపైలర్ ఈ డెకరేటర్ల అమలు క్రమాన్ని నిర్వహిస్తాయి. మీ డెకరేటెడ్ ఎలిమెంట్స్ ఎలా ప్రవర్తిస్తాయో అంచనా వేయడానికి ఈ క్రమాన్ని అర్థం చేసుకోవడం చాలా ముఖ్యం.

డెకరేటర్ ఎగ్జిక్యూషన్ ఆర్డర్

ఒకే క్లాస్ మెంబర్‌కు బహుళ డెకరేటర్లు వర్తింపజేసినప్పుడు, అవి ఒక నిర్దిష్ట క్రమంలో అమలు చేయబడతాయి. క్లాస్ మెథడ్స్, ప్రాపర్టీలు, మరియు పారామీటర్ల కోసం, అమలు క్రమం బయటి డెకరేటర్ నుండి లోపలికి ఉంటుంది. క్లాస్ డెకరేటర్ల కోసం కూడా, క్రమం బయటి నుండి లోపలికే ఉంటుంది.

కింది వాటిని పరిగణించండి:

            function firstDecorator() {
  console.log('firstDecorator: factory called');
  return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
    console.log('firstDecorator: applied');
    const originalMethod = descriptor.value;
    descriptor.value = function(...args: any[]) {
      console.log('firstDecorator: before original method');
      const result = originalMethod.apply(this, args);
      console.log('firstDecorator: after original method');
      return result;
    };
  };
}

function secondDecorator() {
  console.log('secondDecorator: factory called');
  return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
    console.log('secondDecorator: applied');
    const originalMethod = descriptor.value;
    descriptor.value = function(...args: any[]) {
      console.log('secondDecorator: before original method');
      const result = originalMethod.apply(this, args);
      console.log('secondDecorator: after original method');
      return result;
    };
  };
}

class MyClass {
  @firstDecorator()
  @secondDecorator()
  myMethod() {
    console.log('Executing myMethod');
  }
}

const instance = new MyClass();
instance.myMethod();

            

              
                Copy
              
            
          

మీరు ఈ కోడ్‌ను రన్ చేసినప్పుడు, మీరు ఈ క్రింది అవుట్‌పుట్‌ను గమనిస్తారు:

            
firstDecorator: factory called
secondDecorator: factory called
firstDecorator: applied
secondDecorator: applied
firstDecorator: before original method
secondDecorator: before original method
Executing myMethod
secondDecorator: after original method
firstDecorator: after original method

            

              
                Copy
              
            
          

ఫ్యాక్టరీలు ఎలా మొదట, పై నుండి క్రిందికి పిలువబడ్డాయో గమనించండి. ఆ తర్వాత, డెకరేటర్లు వర్తింపజేయబడ్డాయి, అవి కూడా పై నుండి క్రిందికి (బయటి నుండి లోపలికి). చివరగా, మెథడ్ ఇన్వోక్ అయినప్పుడు, డెకరేటర్లు లోపలి నుండి బయటికి అమలు చేయబడతాయి.

ఈ అమలు క్రమం బహుళ డెకరేటర్లు ఎలా పరస్పరం సంకర్షణ చెందుతాయో మరియు కంపోజిషన్ ఎలా పనిచేస్తుందో అర్థం చేసుకోవడానికి ప్రాథమికం. ప్రతి డెకరేటర్ ఎలిమెంట్ యొక్క డిస్క్రిప్టర్‌ను సవరిస్తుంది, మరియు వరుసలోని తదుపరి డెకరేటర్ ఇప్పటికే సవరించిన డిస్క్రిప్టర్‌ను అందుకుని, దాని స్వంత మార్పులను వర్తింపజేస్తుంది.

డెకరేటర్ల కంపోజిషన్ ప్యాటర్న్: మెటాడేటా ఇన్హెరిటెన్స్ చైన్‌లను నిర్మించడం

డెకరేటర్ల యొక్క నిజమైన శక్తి మనం వాటిని కంపోజ్ చేయడం ప్రారంభించినప్పుడు తెలుస్తుంది. డెకరేటర్ల కంపోజిషన్ ప్యాటర్న్, ఈ సందర్భంలో, కార్యాచరణ పొరలను సృష్టించడానికి బహుళ డెకరేటర్ల వ్యూహాత్మక అనువర్తనాన్ని సూచిస్తుంది, ఇది తరచుగా డెకరేట్ చేయబడిన ఎలిమెంట్‌ను ప్రభావితం చేసే మెటాడేటా చైన్‌కు దారితీస్తుంది. ఇది లాగింగ్, అథెంటికేషన్, ఆథరైజేషన్, వాలిడేషన్, మరియు క్యాచింగ్ వంటి క్రాస్-కటింగ్ కన్సర్న్‌లను అమలు చేయడానికి ప్రత్యేకంగా ఉపయోగపడుతుంది.

ఈ లాజిక్‌ను మీ కోడ్‌బేస్‌లో అక్కడక్కడా చెల్లాచెదురుగా ఉంచే బదులు, డెకరేటర్లు దాన్ని ఎన్‌క్యాప్సులేట్ చేయడానికి మరియు డిక్లరేటివ్‌గా వర్తింపజేయడానికి మిమ్మల్ని అనుమతిస్తాయి. మీరు బహుళ డెకరేటర్లను కలిపినప్పుడు, మీరు సమర్థవంతంగా ఒక మెటాడేటా ఇన్హెరిటెన్స్ చైన్ లేదా ఫంక్షనల్ పైప్‌లైన్‌ను నిర్మిస్తున్నారు.

మెటాడేటా ఇన్హెరిటెన్స్ చైన్ అంటే ఏమిటి?

మెటాడేటా ఇన్హెరిటెన్స్ చైన్ అనేది ఆబ్జెక్ట్-ఓరియెంటెడ్ సెన్స్‌లో సాంప్రదాయ క్లాస్ ఇన్హెరిటెన్స్ కాదు. బదులుగా, ఇది ఒక కాన్సెప్టువల్ చైన్, ఇక్కడ ప్రతి డెకరేటర్ డెకరేట్ చేయబడిన ఎలిమెంట్‌కు దాని స్వంత మెటాడేటా లేదా ప్రవర్తనను జోడిస్తుంది. ఈ మెటాడేటాను సిస్టమ్‌లోని ఇతర భాగాలు యాక్సెస్ చేయవచ్చు మరియు అర్థం చేసుకోవచ్చు, లేదా ఇది నేరుగా ఎలిమెంట్ యొక్క ప్రవర్తనను సవరించవచ్చు. 'ఇన్హెరిటెన్స్' అంశం, ప్రతి డెకరేటర్ దాని ముందు వర్తింపజేసిన డెకరేటర్లు అందించిన మార్పులు లేదా మెటాడేటాపై ఎలా నిర్మించబడుతుందో దాని నుండి వస్తుంది (లేదా మీరు డిజైన్ చేసే ఎగ్జిక్యూషన్ ఫ్లోను బట్టి దాని తర్వాత).

ఒక మెథడ్ ఇలా చేయవలసి ఉంటుందని ఊహించుకోండి:

• అథెంటికేట్ కావాలి.
• ఒక నిర్దిష్ట రోల్ కోసం ఆథరైజ్ కావాలి.
• దాని ఇన్‌పుట్ పారామీటర్లను వాలిడేట్ చేయాలి.
• దాని ఎగ్జిక్యూషన్‌ను లాగ్ చేయాలి.

డెకరేటర్లు లేకుండా, మీరు దీనిని మెథడ్‌లోనే నెస్ట్ చేయబడిన కండిషనల్ చెక్స్ లేదా హెల్పర్ ఫంక్షన్లతో అమలు చేయవచ్చు. డెకరేటర్లతో, మీరు దీనిని డిక్లరేటివ్‌గా సాధించవచ్చు:

            
@authenticate
@authorize('admin')
@validateInput({ schema: 'userSchema' })
@logExecution
class UserService {
  // ... methods ...
}

            

              
                Copy
              
            
          

ఈ దృశ్యంలో, ప్రతి డెకరేటర్ UserService లోని మెథడ్స్ యొక్క మొత్తం ప్రవర్తనకు దోహదపడుతుంది. అమలు క్రమం (ఇన్వోకేషన్ కోసం లోపలి నుండి బయటికి) ఈ కన్సర్న్‌లు ఏ క్రమంలో వర్తింపజేయబడతాయో నిర్దేశిస్తుంది. ఉదాహరణకు, మొదట అథెంటికేషన్ జరగవచ్చు, ఆపై ఆథరైజేషన్, తర్వాత వాలిడేషన్, మరియు చివరగా లాగింగ్. ప్రతి డెకరేటర్ ఇతరులను ప్రభావితం చేయగలదు లేదా చైన్ వెంట నియంత్రణను పంపగలదు.

డెకరేటర్ కంపోజిషన్ యొక్క ఆచరణాత్మక అప్లికేషన్‌లు

డెకరేటర్ల కంపోజిషన్ చాలా బహుముఖమైనది. ఇక్కడ కొన్ని సాధారణ మరియు శక్తివంతమైన వినియోగ సందర్భాలు ఉన్నాయి:

1. క్రాస్-కటింగ్ కన్సర్న్స్ (AOP - యాస్పెక్ట్-ఓరియెంటెడ్ ప్రోగ్రామింగ్)

జావాస్క్రిప్ట్‌లో యాస్పెక్ట్-ఓరియెంటెడ్ ప్రోగ్రామింగ్ సూత్రాలను అమలు చేయడానికి డెకరేటర్లు సహజంగా సరిపోతాయి. యాస్పెక్ట్స్ అంటే అప్లికేషన్ యొక్క వివిధ భాగాలలో వర్తింపజేయగల మాడ్యులర్ కార్యాచరణలు. ఉదాహరణలు:

• లాగింగ్: ముందు చూసినట్లుగా, మెథడ్ కాల్స్, ఆర్గ్యుమెంట్స్, మరియు రిటర్న్ విలువలను లాగ్ చేయడం.
• ఆడిటింగ్: ఎవరు ఏ చర్యను ఎప్పుడు చేశారో రికార్డ్ చేయడం.
• పెర్ఫార్మెన్స్ మానిటరింగ్: మెథడ్స్ యొక్క ఎగ్జిక్యూషన్ సమయాన్ని కొలవడం.
• ఎర్రర్ హ్యాండ్లింగ్: try-catch బ్లాక్‌లతో మెథడ్ కాల్స్‌ను చుట్టి, ప్రామాణిక ఎర్రర్ స్పందనలను అందించడం.
• క్యాచింగ్: ఆర్గ్యుమెంట్ల ఆధారంగా వాటి ఫలితాలను ఆటోమేటిక్‌గా కాష్ చేయడానికి మెథడ్స్‌ను డెకరేట్ చేయడం.

2. డిక్లరేటివ్ వాలిడేషన్

క్లాస్ ప్రాపర్టీలు లేదా మెథడ్ పారామీటర్లపై నేరుగా వాలిడేషన్ నియమాలను నిర్వచించడానికి డెకరేటర్లను ఉపయోగించవచ్చు. ఈ డెకరేటర్లను వేరే వాలిడేషన్ ఆర్కెస్ట్రేటర్ ద్వారా లేదా ఇతర డెకరేటర్ల ద్వారా ట్రిగ్గర్ చేయవచ్చు.

            
function Required(message: string = 'This field is required') {
  return function (target: any, propertyKey: string) {
    // Logic to register this as a validation rule for propertyKey
    // This might involve adding metadata to the class or target object.
    console.log(`@Required applied to ${propertyKey}`);
  };
}

function MinLength(length: number, message: string = `Minimum length is ${length}`)
  : PropertyDecorator {
  return function (target: any, propertyKey: string) {
    // Logic to register minLength validation
    console.log(`@MinLength(${length}) applied to ${propertyKey}`);
  };
}

class UserProfile {
  @Required()
  @MinLength(3)
  username: string;

  @Required('Email is mandatory')
  email: string;

  constructor(username: string, email: string) {
    this.username = username;
    this.email = email;
  }
}

// A hypothetical validator that reads metadata
function validate(instance: any) {
  const prototype = Object.getPrototypeOf(instance);
  for (const key in prototype) {
    if (prototype.hasOwnProperty(key) && Reflect.hasOwnMetadata(key, prototype, key)) {
      // This is a simplified example; real validation would need more sophisticated metadata handling.
      console.log(`Validating ${key}...`);
      // Access validation metadata and perform checks.
    }
  }
}

// To make this truly work, we'd need a way to store and retrieve metadata.
// TypeScript's Reflect Metadata API is often used for this.
// For demonstration, we'll simulate the effect:

// Let's use a conceptual metadata storage (requires Reflect.metadata or similar)
// For this example, we'll just log the application of decorators.

console.log('\nSimulating UserProfile validation:');
const user = new UserProfile('Alice', 'alice@example.com');
// validate(user); // In a real scenario, this would check the rules.

            

              
                Copy
              
            
          

టైప్‌స్క్రిప్ట్ యొక్క reflect-metadata ఉపయోగించి పూర్తి అమలులో, మీరు క్లాస్ ప్రోటోటైప్‌కు మెటాడేటాను జోడించడానికి డెకరేటర్లను ఉపయోగిస్తారు, ఆపై ఒక ప్రత్యేక వాలిడేషన్ ఫంక్షన్ ఈ మెటాడేటాను తనిఖీ చేయడానికి ఇంట్రోస్పెక్ట్ చేయగలదు.

3. డిపెండెన్సీ ఇంజెక్షన్ మరియు IoC

ఇన్వర్షన్ ఆఫ్ కంట్రోల్ (IoC) మరియు డిపెండెన్సీ ఇంజెక్షన్ (DI) ఉపయోగించే ఫ్రేమ్‌వర్క్‌లలో, ఇంజెక్షన్ కోసం క్లాస్‌లను మార్క్ చేయడానికి లేదా డిపెండెన్సీలను పేర్కొనడానికి డెకరేటర్లు సాధారణంగా ఉపయోగించబడతాయి. ఈ డెకరేటర్లను కంపోజ్ చేయడం వల్ల డిపెండెన్సీలు ఎలా మరియు ఎప్పుడు రిసాల్వ్ అవుతాయో మరింత సూక్ష్మంగా నియంత్రించడానికి వీలు కల్పిస్తుంది.

4. డొమైన్-స్పెసిఫిక్ లాంగ్వేజెస్ (DSLs)

క్లాస్‌లు మరియు మెథడ్స్‌కు నిర్దిష్ట అర్థాలను అందించడానికి డెకరేటర్లను ఉపయోగించవచ్చు, ఇది ఒక నిర్దిష్ట డొమైన్ కోసం ఒక చిన్న-భాషను సమర్థవంతంగా సృష్టిస్తుంది. డెకరేటర్లను కంపోజ్ చేయడం వల్ల DSL యొక్క వివిధ అంశాలను మీ కోడ్‌పై పొరలుగా వేయడానికి మిమ్మల్ని అనుమతిస్తుంది.

మెటాడేటా ఇన్హెరిటెన్స్ చైన్‌ను నిర్మించడం: ఒక లోతైన విశ్లేషణ

API ఎండ్‌పాయింట్ హ్యాండ్లింగ్ కోసం మెటాడేటా ఇన్హెరిటెన్స్ చైన్‌ను నిర్మించే ఒక మరింత అధునాతన ఉదాహరణను పరిశీలిద్దాం. మనం HTTP మెథడ్, రూట్, ఆథరైజేషన్ అవసరాలు, మరియు ఇన్‌పుట్ వాలిడేషన్ స్కీమాలను పేర్కొనే డెకరేటర్లతో ఎండ్‌పాయింట్‌లను నిర్వచించాలనుకుంటున్నాం.

మనకు ఈ డెకరేటర్లు అవసరం:

• @Get(path)
• @Post(path)
• @Put(path)
• @Delete(path)
• @Auth(strategy: string)
• @Validate(schema: object)

వీటిని కంపోజ్ చేయడంలో కీలకమైనది, అవి క్లాస్‌కు (లేదా రౌటర్/కంట్రోలర్ ఇన్‌స్టాన్స్‌కు) మెటాడేటాను ఎలా జోడిస్తాయి, దానిని తర్వాత ప్రాసెస్ చేయవచ్చు. మనం టైప్‌స్క్రిప్ట్ యొక్క ఎక్స్‌పెరిమెంటల్ డెకరేటర్లను మరియు ఈ మెటాడేటాను నిల్వ చేయడానికి reflect-metadata లైబ్రరీని ఉపయోగించవచ్చు.

మొదట, మీకు అవసరమైన టైప్‌స్క్రిప్ట్ కాన్ఫిగరేషన్‌లు ఉన్నాయని నిర్ధారించుకోండి:

            
{
  "compilerOptions": {
    "target": "es2017",
    "module": "commonjs",
    "experimentalDecorators": true,
    "emitDecoratorMetadata": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true
  }
}

            

              
                Copy
              
            
          

మరియు reflect-metadata ను ఇన్‌స్టాల్ చేయండి:

            
npm install reflect-metadata

            

              
                Copy
              
            
          

ఆ తర్వాత, మీ అప్లికేషన్ యొక్క ఎంట్రీ పాయింట్‌లో దాన్ని ఇంపోర్ట్ చేయండి:

            
import 'reflect-metadata';

            

              
                Copy
              
            
          

ఇప్పుడు, డెకరేటర్లను నిర్వచిద్దాం:

            
// --- Decorators for HTTP Methods ---

interface RouteInfo {
  method: 'get' | 'post' | 'put' | 'delete';
  path: string;
  authStrategy?: string;
  validationSchema?: object;
}

const httpMethodDecoratorFactory = (method: RouteInfo['method']) => (path: string): ClassDecorator => {
  return function (target: Function) {
    // Store route information on the class itself
    const existingRoutes: RouteInfo[] = Reflect.getMetadata('routes', target) || [];
    existingRoutes.push({ method, path });
    Reflect.defineMetadata('routes', existingRoutes, target);
  };
};

export const Get = httpMethodDecoratorFactory('get');
export const Post = httpMethodDecoratorFactory('post');
export const Put = httpMethodDecoratorFactory('put');
export const Delete = httpMethodDecoratorFactory('delete');

// --- Decorators for Metadata ---

export const Auth = (strategy: string): ClassDecorator => {
  return function (target: Function) {
    const existingRoutes: RouteInfo[] = Reflect.getMetadata('routes', target) || [];
    // Assume the last route added is the one we're decorating, or find it by path.
    // For simplicity, let's update all routes or the last one.
    if (existingRoutes.length > 0) {
      existingRoutes[existingRoutes.length - 1].authStrategy = strategy;
      Reflect.defineMetadata('routes', existingRoutes, target);
    } else {
      // This case might happen if Auth is applied before HTTP method decorator.
      // A more robust system would handle this ordering.
      console.warn('Auth decorator applied before HTTP method decorator.');
    }
  };
};

export const Validate = (schema: object): ClassDecorator => {
  return function (target: Function) {
    const existingRoutes: RouteInfo[] = Reflect.getMetadata('routes', target) || [];
    if (existingRoutes.length > 0) {
      existingRoutes[existingRoutes.length - 1].validationSchema = schema;
      Reflect.defineMetadata('routes', existingRoutes, target);
    } else {
      console.warn('Validate decorator applied before HTTP method decorator.');
    }
  };
};

// --- Decorator to mark a class as a Controller ---

export const Controller = (prefix: string): ClassDecorator => {
  return function (target: Function) {
    // This decorator could add metadata that identifies the class as a controller
    // and store the prefix for route generation.
    Reflect.defineMetadata('controllerPrefix', prefix, target);
  };
};

// --- Example Usage ---

// A dummy schema for validation
const userSchema = { type: 'object', properties: { name: { type: 'string' } } };

@Controller('/users')
class UserController {
  @Post('/')
  @Validate(userSchema)
  @Auth('jwt')
  createUser(user: any) {
    console.log('Creating user:', user);
    return { message: 'User created successfully' };
  }

  @Get('/:id')
  @Auth('session')
  getUser(id: string) {
    console.log('Fetching user:', id);
    return { id, name: 'John Doe' };
  }
}

// --- Metadata Processing (e.g., in your server setup) ---

function registerRoutes(App: any) {
  const controllers = [UserController]; // In a real app, discover controllers

  controllers.forEach(ControllerClass => {
    const prefix = Reflect.getMetadata('controllerPrefix', ControllerClass);
    const routes: RouteInfo[] = Reflect.getMetadata('routes', ControllerClass) || [];

    routes.forEach(route => {
      const fullPath = `${prefix}${route.path}`;
      console.log(`Registering route: ${route.method.toUpperCase()} ${fullPath}`);
      console.log(`  Auth: ${route.authStrategy || 'None'}`);
      console.log(`  Validation Schema: ${route.validationSchema ? 'Defined' : 'None'}`);

      // In a framework like Express, you'd do something like:
      // App[route.method](fullPath, async (req, res) => {
      //   if (route.authStrategy) { await authenticate(req, route.authStrategy); }
      //   if (route.validationSchema) { await validateRequest(req, route.validationSchema); }
      //   const controllerInstance = new ControllerClass();
      //   const result = await controllerInstance[methodName](...extractArgs(req)); // Need to map method name too
      //   res.json(result);
      // });
    });
  });
}

// Example of how you might use this in an Express-like app:
// const expressApp = require('express')();
// registerRoutes(expressApp);
// expressApp.listen(3000);

console.log('\n--- Route Registration Simulation ---');
registerRoutes(null); // Passing null as App for demonstration

            

              
                Copy
              
            
          

ఈ వివరణాత్మక ఉదాహరణలో:

• @Controller డెకరేటర్ ఒక క్లాస్‌ను కంట్రోలర్‌గా మార్క్ చేసి, దాని బేస్ పాత్‌ను నిల్వ చేస్తుంది.
• @Get, @Post, మొదలైనవి HTTP మెథడ్ మరియు పాత్‌ను నమోదు చేసే ఫ్యాక్టరీలు. ముఖ్యంగా, అవి క్లాస్ ప్రోటోటైప్‌కు మెటాడేటాను జోడిస్తాయి.
• @Auth మరియు @Validate డెకరేటర్లు ఆ క్లాస్‌లో అత్యంత ఇటీవల నిర్వచించిన రూట్‌తో అనుబంధించబడిన మెటాడేటాను సవరిస్తాయి. ఇది ఒక సరళీకరణ; ఒక మరింత పటిష్టమైన వ్యవస్థ డెకరేటర్లను నిర్దిష్ట మెథడ్స్‌కు స్పష్టంగా లింక్ చేస్తుంది.
• registerRoutes ఫంక్షన్ డెకరేట్ చేయబడిన కంట్రోలర్ల ద్వారా ఇటరేట్ అవుతుంది, మెటాడేటాను (ప్రిఫిక్స్ మరియు రూట్స్) తిరిగి పొందుతుంది, మరియు రిజిస్ట్రేషన్ ప్రక్రియను అనుకరిస్తుంది.

ఇది ఒక మెటాడేటా ఇన్హెరిటెన్స్ చైన్‌ను ప్రదర్శిస్తుంది. UserController క్లాస్ 'కంట్రోలర్' పాత్రను మరియు '/users' ప్రిఫిక్స్‌ను ఇన్హెరిట్ చేస్తుంది. దాని మెథడ్స్ HTTP వెర్బ్ మరియు పాత్ సమాచారాన్ని ఇన్హెరిట్ చేస్తాయి, ఆపై అథెంటికేషన్ మరియు వాలిడేషన్ కాన్ఫిగరేషన్‌లను ఇన్హెరిట్ చేస్తాయి. registerRoutes ఫంక్షన్ ఈ మెటాడేటా చైన్ యొక్క ఇంటర్‌ప్రెటర్‌గా పనిచేస్తుంది.

డెకరేటర్ కంపోజిషన్ యొక్క ప్రయోజనాలు

డెకరేటర్ల కంపోజిషన్ ప్యాటర్న్‌ను స్వీకరించడం వల్ల ముఖ్యమైన ప్రయోజనాలు ఉన్నాయి:

• స్వచ్ఛత మరియు చదవడానికి సులభంగా ఉండటం: కోడ్ మరింత డిక్లరేటివ్‌గా మారుతుంది. కన్సర్న్‌లు పునర్వినియోగ డెకరేటర్లలోకి వేరు చేయబడతాయి, ఇది మీ క్లాస్‌ల యొక్క ప్రధాన లాజిక్‌ను స్వచ్ఛంగా మరియు సులభంగా అర్థం చేసుకోవడానికి వీలు కల్పిస్తుంది.
• పునర్వినియోగం: డెకరేటర్లు అత్యంత పునర్వినియోగించదగినవి. ఉదాహరణకు, ఒక లాగింగ్ డెకరేటర్ మీ మొత్తం అప్లికేషన్‌లో లేదా వివిధ ప్రాజెక్ట్‌లలో కూడా ఏ మెథడ్‌కైనా వర్తింపజేయవచ్చు.
• నిర్వహణ సౌలభ్యం: ఒక క్రాస్-కటింగ్ కన్సర్న్‌ను అప్‌డేట్ చేయవలసి వచ్చినప్పుడు (ఉదా., లాగింగ్ ఫార్మాట్‌ను మార్చడం), మీరు దానిని అమలు చేసిన ప్రతిచోటా కాకుండా, కేవలం డెకరేటర్‌ను మాత్రమే సవరించాలి.
• టెస్ట్ చేయగల సామర్థ్యం: డెకరేటర్లను తరచుగా ఒంటరిగా పరీక్షించవచ్చు, మరియు డెకరేట్ చేయబడిన ఎలిమెంట్‌పై వాటి ప్రభావాన్ని సులభంగా ధృవీకరించవచ్చు.
• విస్తరణ సామర్థ్యం: కొత్త ఫంక్షనాలిటీలను ఇప్పటికే ఉన్న కోడ్‌ను మార్చకుండా కొత్త డెకరేటర్లను సృష్టించడం ద్వారా జోడించవచ్చు.
• బాయిలర్‌ప్లేట్ తగ్గడం: రూట్‌లను సెటప్ చేయడం, అథెంటికేషన్ చెక్స్‌ను నిర్వహించడం, లేదా వాలిడేషన్‌లను చేయడం వంటి పునరావృత పనులను ఆటోమేట్ చేస్తుంది.

సవాళ్లు మరియు పరిగణనలు

శక్తివంతమైనదే అయినప్పటికీ, డెకరేటర్ కంపోజిషన్ దాని సంక్లిష్టతలు లేకుండా లేదు:

• నేర్చుకోవడంలో కష్టం: డెకరేటర్లు, డెకరేటర్ ఫ్యాక్టరీలు, ఎగ్జిక్యూషన్ ఆర్డర్, మరియు మెటాడేటా రిఫ్లెక్షన్‌ను అర్థం చేసుకోవడానికి నేర్చుకోవడానికి సమయం పడుతుంది.
• టూలింగ్ మరియు మద్దతు: డెకరేటర్లు ఇంకా ఒక ప్రతిపాదన దశలోనే ఉన్నాయి, మరియు టైప్‌స్క్రిప్ట్‌లో విస్తృతంగా ఆమోదించబడినప్పటికీ, వాటి స్థానిక జావాస్క్రిప్ట్ మద్దతు ఇంకా రావాల్సి ఉంది. మీ బిల్డ్ టూల్స్ మరియు టార్గెట్ ఎన్విరాన్‌మెంట్‌లు సరిగ్గా కాన్ఫిగర్ చేయబడ్డాయని నిర్ధారించుకోండి.
• డీబగ్గింగ్: బహుళ డెకరేటర్లతో కోడ్‌ను డీబగ్ చేయడం కొన్నిసార్లు మరింత సవాలుగా ఉంటుంది, ఎందుకంటే ఎగ్జిక్యూషన్ ఫ్లో సాధారణ కోడ్ కంటే తక్కువ సూటిగా ఉంటుంది. సోర్స్ మ్యాప్స్ మరియు డీబగ్గర్ సామర్థ్యాలు అవసరం.
• ఓవర్‌హెడ్: డెకరేటర్ల అధిక వినియోగం, ముఖ్యంగా సంక్లిష్టమైనవి, అదనపు ఇండైరెక్షన్ మరియు మెటాడేటా మానిప్యులేషన్ కారణంగా కొంత పనితీరు ఓవర్‌హెడ్‌ను పరిచయం చేయవచ్చు. పనితీరు కీలకమైతే మీ అప్లికేషన్‌ను ప్రొఫైల్ చేయండి.
• మెటాడేటా నిర్వహణ సంక్లిష్టత: సంక్లిష్ట వ్యవస్థల కోసం, డెకరేటర్లు ఎలా పరస్పరం సంకర్షణ చెందుతాయి మరియు మెటాడేటాను పంచుకుంటాయో నిర్వహించడం సంక్లిష్టంగా మారవచ్చు. మెటాడేటా కోసం ఒక సు-నిర్వచించబడిన వ్యూహం చాలా ముఖ్యం.

డెకరేటర్ కంపోజిషన్ కోసం గ్లోబల్ బెస్ట్ ప్రాక్టీసెస్

వివిధ అంతర్జాతీయ బృందాలు మరియు ప్రాజెక్ట్‌లలో డెకరేటర్ కంపోజిషన్‌ను సమర్థవంతంగా ఉపయోగించుకోవడానికి, ఈ గ్లోబల్ బెస్ట్ ప్రాక్టీసెస్‌ను పరిగణించండి:

• డెకరేటర్ నామకరణం మరియు వాడకాన్ని ప్రామాణీకరించండి: డెకరేటర్ల కోసం స్పష్టమైన నామకరణ సంప్రదాయాలను (ఉదా., `@` ప్రిఫిక్స్, వివరణాత్మక పేర్లు) ఏర్పాటు చేయండి మరియు వాటి ఉద్దేశించిన ప్రయోజనం మరియు పారామీటర్లను డాక్యుమెంట్ చేయండి. ఇది గ్లోబల్ టీమ్‌లో స్థిరత్వాన్ని నిర్ధారిస్తుంది.
• మెటాడేటా కాంట్రాక్ట్‌లను డాక్యుమెంట్ చేయండి: డెకరేటర్లు నిర్దిష్ట మెటాడేటా కీలు లేదా నిర్మాణాలపై ఆధారపడి ఉంటే (reflect-metadata ఉదాహరణలో వలె), ఈ కాంట్రాక్ట్‌లను స్పష్టంగా డాక్యుమెంట్ చేయండి. ఇది ఇంటిగ్రేషన్ సమస్యలను నివారించడంలో సహాయపడుతుంది.
• డెకరేటర్లను ఫోకస్డ్‌గా ఉంచండి: ప్రతి డెకరేటర్ ఆదర్శంగా ఒకే ఒక్క కన్సర్న్‌ను పరిష్కరించాలి. చాలా పనులు చేసే మోనోలిథిక్ డెకరేటర్లను సృష్టించడం మానుకోండి. ఇది సింగిల్ రెస్పాన్సిబిలిటీ ప్రిన్సిపల్‌కు కట్టుబడి ఉంటుంది.
• కాన్ఫిగర్ చేయగల సామర్థ్యం కోసం డెకరేటర్ ఫ్యాక్టరీలను ఉపయోగించండి: ప్రదర్శించినట్లుగా, ఫ్యాక్టరీలు డెకరేటర్లను ఫ్లెక్సిబుల్‌గా మరియు కాన్ఫిగర్ చేయగలిగేలా చేయడానికి అవసరం, ఇది కోడ్ డూప్లికేషన్ లేకుండా వివిధ వినియోగ సందర్భాలకు అనుగుణంగా మార్చడానికి అనుమతిస్తుంది.
• పనితీరు ప్రభావాలను పరిగణించండి: డెకరేటర్లు చదవడానికి సులభతరం చేసినప్పటికీ, ముఖ్యంగా అధిక-త్రూపుట్ దృశ్యాలలో సంభావ్య పనితీరు ప్రభావాల గురించి జాగ్రత్తగా ఉండండి. అవసరమైన చోట ప్రొఫైల్ మరియు ఆప్టిమైజ్ చేయండి. ఉదాహరణకు, వేలాది సార్లు వర్తింపజేయబడిన డెకరేటర్లలో గణనపరంగా ఖరీదైన ఆపరేషన్లను నివారించండి.
• స్పష్టమైన ఎర్రర్ హ్యాండ్లింగ్: ఎర్రర్లను త్రో చేయగల డెకరేటర్లు సమాచార సందేశాలను అందిస్తాయని నిర్ధారించుకోండి, ముఖ్యంగా అంతర్జాతీయ బృందాలతో పనిచేస్తున్నప్పుడు, ఎర్రర్ల మూలాలను అర్థం చేసుకోవడం సవాలుగా ఉంటుంది.
• టైప్‌స్క్రిప్ట్ యొక్క టైప్ సేఫ్టీని ఉపయోగించుకోండి: టైప్‌స్క్రిప్ట్‌ను ఉపయోగిస్తుంటే, దాని టైప్ సిస్టమ్‌ను డెకరేటర్లలో మరియు అవి ఉత్పత్తి చేసే మెటాడేటాలో ఉపయోగించుకోండి, ఇది కంపైల్ సమయంలో లోపాలను పట్టుకోవడానికి, ప్రపంచవ్యాప్తంగా డెవలపర్‌లకు రన్‌టైమ్ ఆశ్చర్యాలను తగ్గిస్తుంది.
• ఫ్రేమ్‌వర్క్‌లతో తెలివిగా ఇంటిగ్రేట్ చేయండి: అనేక ఆధునిక జావాస్క్రిప్ట్ ఫ్రేమ్‌వర్క్‌లు (నెస్ట్‌జెఎస్, యాంగ్యులర్ వంటివి) డెకరేటర్ల కోసం అంతర్నిర్మిత మద్దతు మరియు స్థాపించబడిన ప్యాటర్న్‌లను కలిగి ఉంటాయి. ఆ పర్యావరణ వ్యవస్థలలో పనిచేస్తున్నప్పుడు ఈ ప్యాటర్న్‌లను అర్థం చేసుకుని, వాటికి కట్టుబడి ఉండండి.
• కోడ్ రివ్యూల సంస్కృతిని ప్రోత్సహించండి: డెకరేటర్ల అప్లికేషన్ మరియు కంపోజిషన్ నిశితంగా పరిశీలించబడే పూర్తి కోడ్ రివ్యూలను ప్రోత్సహించండి. ఇది విభిన్న బృందాలలో జ్ఞానాన్ని వ్యాప్తి చేయడానికి మరియు సంభావ్య సమస్యలను ముందుగానే పట్టుకోవడానికి సహాయపడుతుంది.
• సమగ్ర ఉదాహరణలను అందించండి: సంక్లిష్ట డెకరేటర్ కంపోజిషన్‌ల కోసం, అవి ఎలా పనిచేస్తాయో మరియు పరస్పరం సంకర్షణ చెందుతాయో వివరించే స్పష్టమైన, రన్ చేయగల ఉదాహరణలను అందించండి. ఇది ఏ నేపథ్యం నుండి అయినా కొత్త జట్టు సభ్యులను ఆన్‌బోర్డ్ చేయడానికి అమూల్యమైనది.

ముగింపు

జావాస్క్రిప్ట్ డెకరేటర్ల కంపోజిషన్ ప్యాటర్న్, ముఖ్యంగా మెటాడేటా ఇన్హెరిటెన్స్ చైన్‌లను నిర్మించడంగా అర్థం చేసుకున్నప్పుడు, సాఫ్ట్‌వేర్ డిజైన్‌కు ఒక అధునాతన మరియు శక్తివంతమైన విధానాన్ని సూచిస్తుంది. ఇది డెవలపర్‌లను ఇంపెరేటివ్, చిక్కుబడిన కోడ్ నుండి మరింత డిక్లరేటివ్, మాడ్యులర్, మరియు నిర్వహించదగిన ఆర్కిటెక్చర్ వైపు వెళ్ళడానికి అనుమతిస్తుంది. వ్యూహాత్మకంగా డెకరేటర్లను కంపోజ్ చేయడం ద్వారా, మనం సొగసైన పద్ధతిలో క్రాస్-కటింగ్ కన్సర్న్‌లను అమలు చేయవచ్చు, మన కోడ్ యొక్క వ్యక్తీకరణను మెరుగుపరచవచ్చు, మరియు మార్పులకు మరింత నిరోధకత కలిగిన వ్యవస్థలను సృష్టించవచ్చు.

డెకరేటర్లు జావాస్క్రిప్ట్ పర్యావరణ వ్యవస్థకు సాపేక్షంగా కొత్త అదనంగా ఉన్నప్పటికీ, వాటి స్వీకరణ, ముఖ్యంగా టైప్‌స్క్రిప్ట్ ద్వారా, వేగంగా పెరుగుతోంది. వాటి కంపోజిషన్‌లో నైపుణ్యం సాధించడం, కాలపరీక్షకు నిలబడే పటిష్టమైన, స్కేలబుల్, మరియు సొగసైన అప్లికేషన్‌లను నిర్మించడంలో ఒక ముఖ్యమైన అడుగు. ఈ ప్యాటర్న్‌ను స్వీకరించండి, దాని సామర్థ్యాలతో ప్రయోగాలు చేయండి, మరియు మీ జావాస్క్రిప్ట్ డెవలప్‌మెంట్‌లో ఒక కొత్త స్థాయి సొగసును అన్‌లాక్ చేయండి.