એક module એ @Module() decorator સાથે સજ્જિત એક class છે જે સંબંધિત components — controllers, providers/services — ને એક સુસંગત એકમમાં જૂથબદ્ધ કરે છે। Modules એ છે કે કેવી રીતે NestJS એક application ને features માં સંગઠિત કરે છે, અને દરેક Nest app ના પાસે ઓછામાં ઓછો એક root AppModule હોય છે.
import { Module } from "@nestjs/common";
@Module({
controllers: [UsersController], // controllers belonging to this module
providers: [UsersService], // providers (services) this module creates
imports: [DatabaseModule], // OTHER modules whose exports this module needs
exports: [UsersService], // what this module makes available to importers
})
export class UsersModule {}
controllers → the controllers (request handlers) in this module
providers → the providers/services defined and instantiated here (for DI)
imports → other modules whose EXPORTED providers this module can use
exports → the subset of THIS module's providers shared with importing modules
Modules એક DI scope બનાવે છે: એક provider તેના module ની અંદર ઉપલબ્ધ છે, અને અન્ય modules કે જેમણે તેને import કર્યું હોય તો અન્ય modules માટે પણ ઉપલબ્ધ છે જો તે exported હોય.
@Module({
imports: [UsersModule, AuthModule, DatabaseModule], // compose feature modules
})
export class AppModule {} // the root — bootstrapped to start the app
દરેક app ના પાસે એક root AppModule છે જે feature modules ને import કરે છે, આખી application ને સંયોજિત કરે છે.
src/
app.module.ts (root — imports feature modules)
users/
users.module.ts (groups users controller + service)
users.controller.ts
users.service.ts
auth/
auth.module.ts
database/
database.module.ts (shared infrastructure)
નિયમ એ છે કે એક module પ્રતિ feature/domain (users, auth, products), સંબંધિત code ને એક જગ્યાએ રાખીને અને dependencies સ્પષ્ટ રાખીને.
// UsersModule exports UsersService...
@Module({ providers: [UsersService], exports: [UsersService] })
export class UsersModule {}
// ...so AuthModule can use it by importing UsersModule
@Module({ imports: [UsersModule] }) // now AuthModule can inject UsersService
export class AuthModule {}
દૂસરા module માંથી એક provider ને ઉપયોગ કરવા માટે, પ્રદાન કરતો module તેને export કરવો જોઈએ અને વપરાશ કરતો module તે પ્રદાન કરતા module ને import કરવો જોઈએ — dependencies ને સ્પષ્ટ કરીને.
Modules એ દરેક NestJS application ની સાંગઠનિક મરીજ છે — તે સંબંધિત controllers અને providers ને સુસંગત feature એકમોમાં જૂથબદ્ધ કરે છે અને dependency-injection સીમાઓ વ્યાખ્યાયિત કરે છે.
ચાર properties (controllers, providers, imports, exports) ને સમજવું અને ખાસ કરીને modules વચ્ચે providers શેર કરવાનો import/export mechanism આવશ્યક છે: તે છે કે કેવી રીતે NestJS modular, loosely-coupled architecture હાંસલ કરે છે જ્યાં દરેક feature આત્મનિર્ભર છે અને dependencies સ્પષ્ટ છે.
Feature-આધારિત module structure (એક module પ્રતિ domain) એ Nest apps ને scalability અને maintainability માટે સંગઠિત કરવાનો પ્રમાણભૂત રીત છે.
Modules, controllers અને providers સાથે મળીને, NestJS ના મૂળ architecture બનાવે છે, તેમને મૂળભૂત જ્ઞાન બનાવે છે — આ શીખવું કે કેવી રીતે app ને modules માં બંધારણ બનાવવું અને providers ને imports/exports દ્વારા વચ્ચે તારવીર કરવું તે અપરિહાર્ય છે કોઈ પણ બિન-તુચ્છ NestJS application બનાવવા માટે અને તે એક વારંવાર થતો મૂંઝવણનો બિંદુ છે જે શરૂઆતમાં સારી રીતે સમજવો જોઈએ.