// Import the necessary modules
    import { Injectable } from '@nestjs/common';
    import { PassportStrategy } from '@nestjs/passport';
    import { Strategy } from 'passport-local';
// Create a custom authentication strategy
    @Injectable()
    export class LocalStrategy extends PassportStrategy(Strategy) {  
    constructor() {    
    super({ usernameField: 'email' });  
    }  
    async validate(email: string, password: string): Promise {   
// Implement your authentication logic here  
    }
  }

// custom-auth.middleware.ts
  import { Injectable, NestMiddleware } from '@nestjs/common';
  @Injectable()
  export class CustomAuthMiddleware implements NestMiddleware {  
  use(req: Request, res: Response, next: Function) {    
  // Implement your custom authentication logic here    
  const isAuthenticated = /* Check if the user is authenticated */;    
  if (isAuthenticated) {      
  next(); 
  // Proceed to the next middleware or route handler   
  }else {
  res.status(403).json({ message: 'Unauthorized' });   
  }
  }
}

 // app.module.ts
 import { Module, MiddlewareConsumer, RequestMethod } from '@nestjs/common';
 import { CustomAuthMiddleware } from './custom-auth.middleware';
 import { AppController } from './app.controller';
 @Module({ 
 controllers: [AppController],
 })
 export class AppModule {  
 configure(consumer: MiddlewareConsumer) {   
 consumer      
 .apply(CustomAuthMiddleware)      
 .exclude({ path: 'public', method: RequestMethod.ALL }) 
 // Exclude public routes      
 .forRoutes('*'); 
 // Apply middleware to all routes 
 }
 }

// roles.guard.ts
import { CanActivate, ExecutionContext, Injectable } from '@nestjs/common';
@Injectable()
export class RolesGuard implements CanActivate {  
constructor(private readonly requiredRoles: string[]) {}  
canActivate(context: ExecutionContext): boolean {    
const { user } = context.switchToHttp().getRequest();    
// Check if the user has at least one of the required roles    
return this.requiredRoles.some(role => user.roles.includes(role));  
}
}

// app.controller.ts
import { Controller, Get, UseGuards } from '@nestjs/common';
import { RolesGuard } from './roles.guard'
@Controller('admin')
export class AdminController {  
@Get('resource')  
@UseGuards(RolesGuard)  
getAdminResource() {    
// This route is protected by the RolesGuard  
}
}

// attributes.guard.ts
import { CanActivate, ExecutionContext, Injectable } from '@nestjs/common';
@Injectable()
export class AttributesGuard implements CanActivate {  
constructor(private readonly requiredAttributes: string[]) {}  
canActivate(context: ExecutionContext): boolean {    
const { user, params } = context.switchToHttp().getRequest();    
// Check if the user has the necessary attributes to access this resource    
return 
this.requiredAttributes.every(attribute => user.attributes.includes(attribute));  
}
}

// app.controller.ts
import { Controller, Get, Param, UseGuards } from '@nestjs/common';
import { AttributesGuard } from './attributes.guard';
@Controller('resources')
export class ResourceController {  
@Get(':id')  
@UseGuards(AttributesGuard)  
getResource(@Param('id') resourceId: string) {    
// This route is protected by the AttributesGuard  
}
}

// policies.ts
export class ResourcePolicy {  
static canEdit(user, resource) {    
return user.id === resource.ownerId; 
}  
static canDelete(user, resource) {    
return user.id === resource.ownerId || user.isAdmin;  
}
}

// policies.guard.ts
import { CanActivate, ExecutionContext, Injectable } from '@nestjs/common';
import { ResourcePolicy } from './policies';
@Injectable()
export class PoliciesGuard implements CanActivate {  
constructor(private readonly policyMethod: Function) {}  
canActivate(context: ExecutionContext): boolean {    
const { user, params } = context.switchToHttp().getRequest();    
const resource = /* Fetch the resource based on params */    
return this.policyMethod(user, resource);  
}
}

// app.controller.ts
import { Controller, Delete, Get, Param, UseGuards } from '@nestjs/common';
import { PoliciesGuard } from './policies.guard';
import { ResourcePolicy } from './policies';
@Controller('resources')
export class ResourceController {  
@Delete(':id')  
@UseGuards(PoliciesGuard)  
deleteResource(@Param('id') resourceId: string) {    
// This route is protected by the PoliciesGuard with the     
ResourcePolicy.canDelete method 
}
}