NestJS Injection scopes : Types of scopes in NestJs In Hindi

If tutorials available on this website are helpful for you, please whitelist this website in your ad blocker😭 or Donate to help us ❤️ pay for the web hosting to keep the website running.

NestJS में Injection Scopes का concept आपके providers को specific lifetime के साथ manage करने के लिए use होता है। By default, providers NestJS में singleton होते हैं, लेकिन कभी-कभी आपको different instances कि need होती है हर request या transient scope के लिए।

Injection scopes आपको providers का lifecycle define करने कि flexibility देते हैं, जिससे आप application के behavior को optimize कर सकते हैं।

इस topic में हम समझेंगे कि Injection Scopes क्या होते हैं, कैसे different scopes का use किया जाता है, और कैसे यह आपके NestJS application के performance और behavior को affect करते हैं।

●●●

What are Injection Scopes In NestJs

NestJS में Injection Scope का concept provider के lifecycle को define करता है। Providers को different scopes के साथ define करके आप उनका instance कब और कैसे create होगा, इससे control कर सकते हैं।

Types of Injection Scopes In NestJs

NestJS में mainly 3 scopes होते हैं -

1. Singleton Scope (Default) : Provider का एक ही instance pure application के लिए share होता है।

2. Request Scope : Provider का हर incoming request के लिए नया instance बनता है।

3. Transient Scope : Provider का हर injection के लिए new instance create होता है।

●●●

NestJs Singleton Injection Scope

Singleton Scope NestJS का default scope होता है। इसमें एक ही instance pure application के लिए share होता है। हर बार जब आप provider को inject करते हैं, तो वही instance use होता है जो application के start hone पर create किया गया था।

Example of Singleton Scope

File : src/services/logging.service.ts

Copy
import { Injectable } from '@nestjs/common';

@Injectable()
export class LoggingService {
  log(message: string) {
    console.log(`[Singleton Log] ${message}`);
  }
}

LoggingService singleton scope का use करता है, तो application के हर part में same instance share होता है।

Behavior of Singleton Scope

File : src/app.controller.ts

Copy
import { Controller, Get } from '@nestjs/common';
import { LoggingService } from './services/logging.service';

@Controller()
export class AppController {
  constructor(private readonly loggingService: LoggingService) {}

  @Get('log')
  logMessage() {
    this.loggingService.log('Request received');
    return 'Logged successfully!';
  }
}

LoggingService का एक ही instance create होता है, और हर request के लिए वही instance use होता है।

●●●

NestJs Request Injection Scope

Request Scope में provider का हर incoming HTTP request के लिए नया instance बनता है। यह scope तब useful होता है जब आपको provider का अलग instance हर request के लिए चाहिए हो, जैसे user-specific data को handle करना।

Example of Request Scope

File : src/services/request-scoped.service.ts

Copy
import { Injectable, Scope } from '@nestjs/common';

@Injectable({ scope: Scope.REQUEST })
export class RequestScopedService {
  private readonly id: number;

  constructor() {
    this.id = Math.random();  // Random ID generate kar rahe hain
  }

  getId() {
    return this.id;
  }
}

यहां

• RequestScopedService को Scope.REQUEST के साथ define किया गया है, तो हर request पर एक नया instance create होता है।

• हर request के लिए एक unique ID generate हो रही है।

Use Request Scope In Controller

File : src/app.controller.ts

Copy
import { Controller, Get } from '@nestjs/common';
import { RequestScopedService } from './services/request-scoped.service';

@Controller()
export class AppController {
  constructor(private readonly requestScopedService: RequestScopedService) {}

  @Get('request-id')
  getRequestId() {
    return `Request ID: ${this.requestScopedService.getId()}`;
  }
}

दिए गए example में हर बार जब getRequestId() method call होता है, तो एक नया instance create होता है और different ID return होती है।

●●●

NestJs Transient Injection Scope

Transient Scope का use तब होता है जब आपको हर बार provider inject hone पर नया instance create करना हो।

इसका मतलब यह है कि जब भी provider को inject किया जाता है, उसका एक नया instance बनता है, चाहे एक ही request के अंदर multiple times inject किया गया हो।

Example of Transient Scope

File : src/services/transient-scoped.service.ts

Copy
import { Injectable, Scope } from '@nestjs/common';

@Injectable({ scope: Scope.TRANSIENT })
export class TransientScopedService {
  private readonly id: number;

  constructor() {
    this.id = Math.random();  // Random ID generate kar rahe hain
  }

  getId() {
    return this.id;
  }
}

यहां TransientScopedService को Scope.TRANSIENT के साथ define किया गया है, तो जब भी inject किया जाता है, एक नया instance बनता है।

Use Request Scope In Controller

File : src/app.controller.ts

Copy
import { Controller, Get, Inject } from '@nestjs/common';
import { TransientScopedService } from './services/transient-scoped.service';

@Controller()
export class AppController {
  constructor(
    @Inject(TransientScopedService) private readonly transientScopedService1: TransientScopedService,
    @Inject(TransientScopedService) private readonly transientScopedService2: TransientScopedService,
  ) {}

  @Get('transient-id')
  getTransientIds() {
    const id1 = this.transientScopedService1.getId();
    const id2 = this.transientScopedService2.getId();
    return `ID 1: ${id1}, ID 2: ${id2}`;
  }
}

TransientScopedService का हर injection पर एक नया instance बनता है। transientScopedService1 और transientScopedService2 दो अलग instances हैं।

●●●

NestJS create injection scope

चलिए अब एक example देखते हैं जिसमे हम तीनो scopes का एक साथ use करते हैं और उनका behavior observe करते हैं।

Step 1 : Logging Service (Singleton)

Location : src/services/logging.service.ts

Copy
import { Injectable } from '@nestjs/common';

@Injectable()
export class LoggingService {
  log(message: string) {
    console.log(`[Singleton Log] ${message}`);
  }
}

Step 2 : Request Scoped Service

Location : src/services/request-scoped.service.ts

Copy
import { Injectable, Scope } from '@nestjs/common';

@Injectable({ scope: Scope.REQUEST })
export class RequestScopedService {
  private readonly id: number;

  constructor() {
    this.id = Math.random();
  }

  getId() {
    return this.id;
  }
}

Step 3 : Transient Scoped Service

Location : src/services/transient-scoped.service.ts

Copy
import { Injectable, Scope } from '@nestjs/common';

@Injectable({ scope: Scope.TRANSIENT })
export class TransientScopedService {
  private readonly id: number;

  constructor() {
    this.id = Math.random();
  }

  getId() {
    return this.id;
  }
}

Step 4 : Use of Controller

Location : src/app.controller.ts

Copy
import { Controller, Get, Inject } from '@nestjs/common';
import { LoggingService } from './services/logging.service';
import { RequestScopedService } from './services/request-scoped.service';
import { TransientScopedService } from './services/transient-scoped.service';

@Controller()
export class AppController {
  constructor(
    private readonly loggingService: LoggingService,
    private readonly requestScopedService: RequestScopedService,
    @Inject(TransientScopedService) private readonly transientScopedService1: TransientScopedService,
    @Inject(TransientScopedService) private readonly transientScopedService2: TransientScopedService,
  ) {}

  @Get('scopes')
  getScopes() {
    this.loggingService.log('This is a singleton scope.');
    const requestId = this.requestScopedService.getId();
    const transientId1 = this.transientScopedService1.getId();
    const transientId2 = this.transientScopedService2.getId();
    
    return {
      requestScopedId: requestId,
      transientScopedId1: transientId1,
      transientScopedId2: transientId2,
    };
  }
}

यहां

• LoggingService singleton scope में है, तो सभी requests के लिए एक ही instance share होता है।

• RequestScopedService हर request के लिए अलग instance create करता है।

• TransientScopedService हर बार inject hone पर एक नया instance बनाता है, चाहे एक ही request के अंदर दो जगह inject किया गया हो।

●●●

NestJs Scope Hierarchy

NestJS में scopes कि एक hierarchy होती है। अगर कोई higher scope (जैसे Request) के अंदर कोई lower scope (जैसे Singleton) का provider inject होता है, तो NestJS automatically scope को adjust कर लेता है।

For example -

• Singleton के अंदर कोई Request-scoped provider inject होता है, तो singleton provider request-specific नहीं बनेगा।

• Request-scoped provider के अंदर कोई Singleton provider inject होता है, तो वो singleton provider हर request के लिए same रहेगा।

●●●

NestJs Injection Scopes Best Practices

• Use Singleton by Default : जब तक आपको specific request-based या transient behavior नहीं चाहिए, providers को singleton scope में रखें। यह memory और performance के लिए efficient होता है।

• Request-Scoped Providers for Request-Specific Data : जब आपको user-specific या request-specific data handle करना हो (जैसे authentication, session management), तब Request Scope का use करें।

• Transient Scope for Independent Instances : जब हर बार एक unique instance चाहिए, जैसे logging या complex objects create करते वक्त, Transient Scope का use करें।

• Avoid Overusing Request and Transient Scopes : हर बार नया instance banana memory और performance पर load dal सकता है, तो इनका use सिर्फ तब करें जब need हो।

●●●

Conclusion

NestJS में Injection Scopes आपको application के behavior और performance को control करने का एक powerful तरीका देते हैं। Different scopes के through आप providers का lifecycle manage कर सकते हैं, जो आपको ज़्यादा flexibility और scalability provide करता है।