Module

							import { Module } from '@nestjs/common';

							@Module({
								imports: [DatabaseModule],
								controllers: [MeetupController],
								providers: [MeetupService],
								exports: [MeetupService],
							})
							export class MeetupModule {}

													

Controller

							import { Controller, Get } from '@nestjs/common';

							@Controller('meetup')
							export class MeetupController {
							  @Get()
							  findAll(): string {
								return 'Hello Meetup';
							  }
							}
	
					

Provider

	

							import { Injectable } from '@nestjs/common';
							
							@Injectable()
							export class MeetupService {
							  private readonly meetups: string[] = [];
							
							  create(meetup: string) {
								this.meetups.push(meetup);
							  }
							
							  findAll(): string[] {
								return this.meetups;
							  }
							}
		
						

Guards

							

									import { Injectable, 
										CanActivate, 
										ExecutionContext } from '@nestjs/common';
									import { Observable } from 'rxjs';
									
									@Injectable()
									export class AuthGuard implements CanActivate {
									  canActivate(
										context: ExecutionContext,
									  ): boolean | Promise | Observable {
										const request = context.switchToHttp().getRequest();
										return validateRequest(request);
									  }
									}
									
					

Pipes

							
		
									@Injectable()
									export class ValidationPipe implements PipeTransform {
									  transform(value: any, metadata: ArgumentMetadata) {
										return value;
									  }
									}
						
					

Interceptors

											  
					@Injectable()
					export class TransformInterceptor implements NestInterceptor {
					  intercept(context: ExecutionContext, next: CallHandler): Observable {
					    return next.handle().pipe(map(data => ({ data })));
					  }
					}

					/*

					{
					  "data": []
					}

					*/
							

Middleware

								
										
										@Module({
										  imports: [MeetupModule],
										})
										export class AppModule implements NestModule {
										  configure(consumer: MiddlewareConsumer) {
											consumer
											  .apply(LoggerMiddleware)
											  .forRoutes({ 
												  path: 'meetup', 
												  method: RequestMethod.GET 
												});
										  }
										}
							
						

									
		
										const app = await NestFactory.create(AppModule);
										app.use(logger);
										await app.listen(3000);
								
							

Exception Filter

									
											

											@Catch(HttpException)
											export class HttpExceptionFilter implements ExceptionFilter {
											  catch(exception: HttpException, host: ArgumentsHost) {
												const ctx = host.switchToHttp();
												const response = ctx.getResponse();
												const request = ctx.getRequest();
												const status = exception.getStatus();
											
												response
												  .status(status)
												  .json({
													statusCode: status,
													timestamp: new Date().toISOString(),
													path: request.url,
												  });
											  }
											}