JwtStrategy requires a secret or key

src/site/slider/dto/slider-create.dto.ts

+import { IsNotEmpty } from "class-validator";
+
+export class CreateSliderDto {
+    @IsNotEmpty()
+    title: string;
+    @IsNotEmpty()
+    description: string;
+    @IsNotEmpty()
+    imagename:string;
+    link: string
+}
\ No newline at end of file

src/site/slider/slider.controller.ts

+
+import { JsonResponseStatus, DataJson } from './../../JsonResponseStatus';
+import { CreateSliderDto } from './dto/slider-create.dto';
+import { SliderService } from './slider.service';
+import { Body, Controller, Delete, Get, Param, Patch, Post } from '@nestjs/common';
+import { Slider } from './slider.entity';
+
+@Controller('slider')
+export class SliderController {
+    constructor(private sliderService: SliderService) { }
+
+    @Get()
+    async GetAllSliders():Promise<DataJson>{
+        const slider = await this.sliderService.GetAllSliders();
+       return JsonResponseStatus.Success(slider)
+    }
+
+    @Get('/:id')
+    GetByidSlider(id: string): Promise<Slider> {
+        return this.sliderService.GetByIdSlider(id);
+    }
+
+    @Get('/:active')
+    GetActiveSlider(): Promise<Slider[]> {
+        return this.sliderService.GetActiveSlider();
+    }
+
+    @Post()
+    CreateSlider(@Body() slider: CreateSliderDto): Promise<Slider> {
+        return this.sliderService.CreateSlider(slider);
+    }
+
+    @Patch('/:id/update')
+    UpdateSlider(@Param('id') id: string, @Body() updateSlider: CreateSliderDto): Promise<Slider> {
+        return this.sliderService.UpdateSlider(id, updateSlider);
+    }
+
+    @Delete('/:id')
+    RemoveSlider(@Param('id') id: string): Promise<void> {
+        return this.sliderService.RemoveSlider(id);
+    }
+}

src/site/slider/slider.entity.ts

+import { BaceEntity } from '../../bace.entity';
+import { Column, Entity } from "typeorm";
+
+@Entity()
+export class Slider extends BaceEntity{
+    @Column()
+    imagename:string
+    @Column()
+    title:string;
+    @Column()
+    description:string
+    @Column()
+    link:string
+}
\ No newline at end of file

src/site/slider/slider.module.ts

+import { SliderRepository } from './slider.repository';
+import { Module } from '@nestjs/common';
+import { SliderService } from './slider.service';
+import { SliderController } from './slider.controller';
+import { TypeOrmModule } from '@nestjs/typeorm';
+
+@Module({
+  providers: [SliderService],
+  controllers: [SliderController],
+  imports:[TypeOrmModule.forFeature([SliderRepository])]
+})
+export class SliderModule {}

src/site/slider/slider.repository.ts

+import { Slider } from './slider.entity';
+import { EntityRepository, Repository } from "typeorm";
+
+@EntityRepository(Slider)
+export class SliderRepository extends Repository<Slider>{
+
+}
\ No newline at end of file

src/site/slider/slider.service.ts

+import { CreateSliderDto } from './dto/slider-create.dto';
+import { Slider } from './slider.entity';
+
+
+import { Injectable, NotFoundException } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { SliderRepository } from './slider.repository';
+
+@Injectable()
+export class SliderService {
+
+    constructor(@InjectRepository(SliderRepository) private sliderRepository: SliderRepository) { }
+
+    private date: Date = new Date();
+
+
+    async GetAllSliders(): Promise<Slider[]> {
+        const qurey = await this.sliderRepository.createQueryBuilder('slider').getMany();
+        return qurey;
+    }
+
+    async GetByIdSlider(id: string): Promise<Slider> {
+        const slider = await this.sliderRepository.findOne(id);
+        if (!slider) {
+            throw new NotFoundException(`User with ID "${id}" not found !`);
+        }
+        return slider;
+    }
+
+
+    async CreateSlider(createSliderDto: CreateSliderDto): Promise<Slider> {
+        const {imagename, title, description, link } = createSliderDto;
+        const slider = this.sliderRepository.create({
+            title,
+            description,
+            link,
+            imagename
+        });
+        await this.sliderRepository.save(slider);
+        return slider
+    }
+
+    async UpdateSlider(id: string, updateSliderDto: CreateSliderDto): Promise<Slider> {
+        const { imagename,title, description, link } = updateSliderDto;
+        const slide = await this.GetByIdSlider(id);
+        slide.title = title;
+        slide.description = description;
+        slide.link = link;
+        slide.imagename=imagename;
+        slide.lastupdatedate = this.date;
+        this.sliderRepository.save(slide);
+        return slide;
+    }
+
+    async RemoveSlider(id: string): Promise<void> {
+        const slide = await this.GetByIdSlider(id);
+        slide.isdelete = true;
+        await this.sliderRepository.save(slide);
+    }
+
+    async GetActiveSlider(): Promise<Slider[]> {
+        const slider = await this.sliderRepository.createQueryBuilder('slider');
+        slider.where('slider.isdelete = :isdelete', {false:Boolean});
+        return  slider.getMany();
+    }
+}

src/typeorm.config.ts

+import { TypeOrmModuleOptions } from '@nestjs/typeorm';
+
+import * as config from 'config';
+
+const dbConfig = config.get('db');
+export const typeOrmConfig: TypeOrmModuleOptions = {
+      type: dbConfig.type,
+      host:process.env.RDS_HOSTNAME || dbConfig.host,
+      port:process.env.RDS_PORT || dbConfig.port,
+      username:process.env.RDS_USERNAME || dbConfig.username,
+      password:process.env.RDS_PASSWORD || dbConfig.password,
+      database:process.env.RDS_DB_NAME || dbConfig.databace,
+      entities: [__dirname + '/../**/*.entity{.ts,.js}'],
+      synchronize:process.env.TYPEORM_SYNC || dbConfig.synchronize,
+      autoLoadEntities:true,
+};

src/users/dto/sing-in.dto.ts

+import { IsNotEmpty } from 'class-validator';
+export class AuthCredentialsDto {
+    @IsNotEmpty()
+    email: string;
+    @IsNotEmpty()
+    password: string;
+}
\ No newline at end of file

src/users/dto/users.dto.ts

+import { IsNotEmpty } from 'class-validator';
+
+export class CreateUserDto {
+  @IsNotEmpty()
+  email: string;
+  @IsNotEmpty()
+  password: string;
+  @IsNotEmpty()
+  fristname: string;
+  @IsNotEmpty()
+  lastname: string;
+  @IsNotEmpty()
+  address: string;
+}

src/users/get-user.decorator.ts

+import { User } from './user.entity';
+import { createParamDecorator, ExecutionContext } from "@nestjs/common"
+
+export const GetUser = createParamDecorator((_data, ctx: ExecutionContext): User => {
+    const req = ctx.switchToHttp().getRequest();
+    return req.user
+});

src/users/jwt-payload.interface.ts

+export interface JwtPayload {
+    email: string;
+}
\ No newline at end of file

src/users/jwt.strategy.ts

+import { ConfigService } from '@nestjs/config';
+
+
+import { User } from './user.entity';
+import { JwtPayload } from './jwt-payload.interface';
+import { UsersRepository } from './users.repository';
+import { Injectable, UnauthorizedException } from '@nestjs/common';
+import { PassportStrategy } from '@nestjs/passport';
+import { ExtractJwt, Strategy } from 'passport-jwt';
+import { InjectRepository } from '@nestjs/typeorm';
+import * as config from 'config';
+
+@Injectable()
+export class JwtStrategy extends PassportStrategy(Strategy) {
+    constructor(
+        @InjectRepository(UsersRepository)
+        private userRepository: UsersRepository,
+        private configService:ConfigService) {
+        super({
+            jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
+            secretOrkey: process.env.JWT_SECRET || config.get('jwt.secret'),
+        });
+    }
+
+    async validate(payload:JwtPayload):Promise<User>{
+        const {email} = payload;
+        const user:User = await this.userRepository.findOne({email});
+
+        if(!user){
+            throw new UnauthorizedException()
+        }
+        return user;
+    }
+}
\ No newline at end of file

src/users/roles/roles.controller.ts

+import { Controller } from '@nestjs/common';
+
+@Controller('roles')
+export class RolesController {}

src/users/roles/roles.entity.ts

+import { BaceEntity } from './../../bace.entity';
+import { Column, Entity, JoinTable, ManyToMany, PrimaryGeneratedColumn } from "typeorm";
+import { User } from "../user.entity";
+@Entity()
+export class Roles extends BaceEntity {
+    
+    @Column()
+    name: string;
+    @Column()
+    title: string;
+
+    @ManyToMany(() => User)
+    @JoinTable()
+    users:User[];
+
+}
\ No newline at end of file

src/users/roles/roles.module.ts

+import { RolesRepasitory } from './roles.repository';
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { RolesController } from './roles.controller';
+import { RolesService } from './roles.service';
+
+@Module({
+  controllers: [RolesController],
+  providers: [RolesService],
+  imports:[TypeOrmModule.forFeature([RolesRepasitory])]
+})
+export class RolesModule {}

src/users/roles/roles.repository.ts

+import { Roles } from './roles.entity';
+import { EntityRepository, Repository } from "typeorm";
+
+@EntityRepository(Roles)
+export class RolesRepasitory extends Repository<Roles>{
+
+}
\ No newline at end of file

src/users/roles/roles.service.ts

+import { Injectable } from '@nestjs/common';
+
+@Injectable()
+export class RolesService {}

src/users/user-roles/user-roles.controller.ts

+import { Controller } from '@nestjs/common';
+
+@Controller('user-roles')
+export class UserRolesController {}

src/users/user-roles/user-roles.module.ts

+import { Module } from '@nestjs/common';
+import { UserRolesController } from './user-roles.controller';
+import { UserRolesService } from './user-roles.service';
+
+@Module({
+  controllers: [UserRolesController],
+  providers: [UserRolesService]
+})
+export class UserRolesModule {}

src/users/user-roles/user-roles.service.ts

+import { Injectable } from '@nestjs/common';
+
+@Injectable()
+export class UserRolesService {}