db relationships

Author: solomonaboyeji

makefile

@@ -0,0 +1,6 @@
+refresh-db:
+	docker-compose -f docker/docker-compose.yml rm -v
+	docker-compose -f docker/docker-compose.yml build
+
+start-db:
+	docker-compose -f docker/docker-compose.yml up

src/app.module.ts

@@ -1,18 +1,19 @@
+import { APP_FILTER } from '@nestjs/core';
 import * as Joi from '@hapi/joi';
-import { Module, NotFoundException } from '@nestjs/common';
+import { Module } from '@nestjs/common';
 import { ConfigModule } from '@nestjs/config';
 import { PostsModule } from './posts/posts.module';
 import { DatabaseModule } from './database/database.module';
+import { CategoriesModule } from './categories/categories.module';
 import { AuthenticationModule } from './authentication/authentication.module';
+import { CustomHttpExceptionFilter } from './utils/exceptionsLogger.filter';
 import { UserModule } from './users/users.module';
-import { APP_FILTER } from '@nestjs/core';
-import { ExceptionsLoggerFilter, CustomHttpExceptionFilter } from './utils/exceptionsLogger.filter';
 
 @Module({
   // modules in the application
   // importing a module here instructs nestjs where to get 
   // the controllers and providers (services) for that module
-  imports: [PostsModule, ConfigModule.forRoot({
+  imports: [ConfigModule.forRoot({
     //ConfigModule reads from the .env file and Joi converts 
     // them to ts datatypes
     validationSchema: Joi.object({
@@ -25,7 +26,11 @@ import { ExceptionsLoggerFilter, CustomHttpExceptionFilter } from './utils/excep
       JWT_SECRET: Joi.string().required(),
       JWT_EXPIRATION_TIME: Joi.string().required(),
     })
-  }), DatabaseModule, AuthenticationModule],
+  }), DatabaseModule,
+    AuthenticationModule,
+    CategoriesModule,
+    PostsModule,
+    UserModule],
 
   // controllers to instantiate
   controllers: [],

src/authentication/authentication.controller.ts

@@ -1,5 +1,5 @@
-import { Body, Req, Controller, HttpCode, Post, UseGuards, Res, Get, SerializeOptions, UseInterceptors, ClassSerializerInterceptor } from '@nestjs/common';
-import { Request, Response } from 'express';
+import { Body, Req, Controller, HttpCode, Post, UseGuards, Res, Get } from '@nestjs/common';
+import { Response } from 'express';
 
 import { AuthenticationService } from "./authentication.service";
 import { LocalAuthenticationGuard } from './guards/localAuthentication.guard';
@@ -8,23 +8,14 @@ import RequestWithUser from "./requestWithUser.interface";
 import JwtAuthenticationGuard from "./guards/jwt-authentication.guard";
 
 @Controller('authentication')
-@UseInterceptors(ClassSerializerInterceptor)
-// * By default, all properties of our entities are exposed.
-// * We can change this strategy by providing additional options to 
-// * the class-transformer.
-// * This will force you to use the Expose() on the entities variables you want
-// * to expose to the user
-@SerializeOptions({
-    strategy: 'excludeAll'
-})
 export class AuthenticationController {
     constructor(
         private readonly authenticationService: AuthenticationService
     ) { }
 
     @UseGuards(JwtAuthenticationGuard)
     @Get()
-    authentmicatedMe(@Req() request: RequestWithUser) {
+    authenticatedMe(@Req() request: RequestWithUser) {
         const user = request.user;
         user.password = undefined;
         return user;
@@ -38,16 +29,10 @@ export class AuthenticationController {
     @HttpCode(200)
     @UseGuards(LocalAuthenticationGuard)
     @Post('log-in')
-    async login(@Req() request: RequestWithUser, @Res() response: Response) {
+    async login(@Req() request: RequestWithUser) {
         const user = request.user
-
-        // * this will be set to the caller's cookie and they do not need to manage it them 
-        // * Might not be useful for cli or api client apps
-
-        const cookie = this.authenticationService.getCookieWithJwtToken(user.id);
-        response.set('Set-Cookie', cookie)
-
-        // user.password = undefined;
-        return response.send(user)
+        return {
+            "access_token": this.authenticationService.getBearerToken(user.id)
+        }
     }
 }

src/authentication/authentication.module.ts

@@ -1,13 +1,13 @@
+import { JwtModule } from "@nestjs/jwt";
 import { Module } from "@nestjs/common";
+import { ConfigModule, ConfigService } from '@nestjs/config';
 import { PassportModule } from "@nestjs/passport";
 
+import { UserModule } from "src/users/users.module";
 import { LocalStrategy } from "./strategies/local.strategy";
 import { AuthenticationService } from "./authentication.service";
-import { UserModule } from "src/users/users.module";
 import { AuthenticationController } from './authentication.controller';
-import { ConfigModule, ConfigService } from '@nestjs/config';
-import { JwtModule } from "@nestjs/jwt";
-import { JwtInCookieStrategy } from './strategies/jwt.cookie.strategy';
+import { JWTFromAuthHeaderStrategy } from './strategies/jwt.header.strategy';
 
 @Module({
     imports: [
@@ -24,7 +24,7 @@ import { JwtInCookieStrategy } from './strategies/jwt.cookie.strategy';
             })
         })
     ],
-    providers: [AuthenticationService, LocalStrategy, JwtInCookieStrategy],
+    providers: [AuthenticationService, LocalStrategy, JWTFromAuthHeaderStrategy],
     controllers: [AuthenticationController]
 })
 export class AuthenticationModule { }

src/authentication/authentication.service.ts

@@ -3,7 +3,7 @@ import { HttpException, HttpStatus, Inject } from '@nestjs/common';
 
 
 import RegisterDto from './dto/register.dto';
-import User from 'src/users/user.entity';
+import User from 'src/users/entities/user.entity';
 import { UsersService } from '../users/users.service';
 import { PostgresErrorCode } from './../database/postgresErrorCodes.enum';
 import { JwtService } from '@nestjs/jwt';
@@ -27,12 +27,17 @@ export class AuthenticationService {
         return `Authentication=; HttpOnly; Path=/; Max-Age=0`;
     }
 
-    public getCookieWithJwtToken(userId: number) {
+    public getCookieWithJwtToken(userId: string) {
         const payload: TokenPayload = { userId };
         const token = this.jwtService.sign(payload)
         return `Authentication=${token}; HttpOnly; Path=/; Max-Age=${this.configService.get('JWT_EXPIRATION_TIME')}`;
     }
 
+    public getBearerToken(userId: string) {
+        const payload: TokenPayload = { userId };
+        return this.jwtService.sign(payload)
+    }
+
     public async register(registrationData: RegisterDto): Promise<User> {
         const hashedPassword = await bcrypt.hash(registrationData.password, NUMBER_OF_ROUNDS)
 
@@ -52,11 +57,11 @@ export class AuthenticationService {
         }
     }
 
-    public async getAuthenticatedUser(email: string, plainTextPassword: string) {
+    public async getAuthenticatedUser(email: string, plainTextPassword: string): Promise<User> {
         try {
             const user = await this.usersService.getByEmail(email)
             await this.verifyPassword(plainTextPassword, user.password)
-            user.password = undefined;
+            delete user.password
             return user;
         } catch (error) {
             throw new HttpException('Wrong credentials provided', HttpStatus.BAD_REQUEST)

src/authentication/dto/register.dto.ts

@@ -12,6 +12,11 @@ export class RegisterDto {
     @IsNotEmpty()
     @MinLength(7)
     password: string;
+
+
+    // address DTO is not here, cascade was set to true in
+    // user entity file making it possible to send address alongside
+    // why this is so, I do not know as at now.
 }
 
 export default RegisterDto;

src/authentication/requestWithUser.interface.ts

@@ -1,4 +1,4 @@
-import User from "src/users/user.entity";
+import User from "src/users/entities/user.entity";
 
 interface RequestWithUser extends Request {
     user: User

src/authentication/strategies/jwt.header.strategy.ts

@@ -0,0 +1,25 @@
+import { Request } from 'express';
+import { ExtractJwt, Strategy } from "passport-jwt";
+import { PassportStrategy } from "@nestjs/passport";
+import { Injectable } from "@nestjs/common";
+import { ConfigService } from "@nestjs/config";
+
+import { UsersService } from "src/users/users.service";
+import TokenPayload from "../tokenPayload.interface";
+
+@Injectable()
+export class JWTFromAuthHeaderStrategy extends PassportStrategy(Strategy) {
+    constructor(
+        private readonly configService: ConfigService,
+        private readonly userService: UsersService,
+    ) {
+        super({
+            jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
+            secretOrKey: configService.get('JWT_SECRET')
+        })
+    }
+
+    async validate(payload: TokenPayload) {
+        return this.userService.getById(payload.userId)
+    }
+}

src/authentication/strategies/local.strategy.ts

@@ -3,7 +3,7 @@ import { PassportStrategy } from "@nestjs/passport";
 import { Injectable } from "@nestjs/common";
 
 import { AuthenticationService } from "../authentication.service";
-import User from "src/users/user.entity";
+import User from "src/users/entities/user.entity";
 
 @Injectable()
 export class LocalStrategy extends PassportStrategy(Strategy) {

src/authentication/tokenPayload.interface.ts

@@ -1,3 +1,3 @@
 export default interface TokenPayload {
-    userId: number
+    userId: string
 }

src/categories/categories.controller.ts

@@ -0,0 +1,44 @@
+import { Body, Controller, Delete, Get, Param, Patch, Post, Req, UseGuards, ClassSerializerInterceptor, UseInterceptors } from '@nestjs/common';
+import JwtAuthenticationGuard from '../authentication/guards/jwt-authentication.guard';
+import FindOneParams from 'src/utils/findOneParams';
+import RequestWithUser from 'src/authentication/requestWithUser.interface';
+import CategoryService from './categories.service';
+import CreateCategoryDTO from './dto/createCategory.dto';
+import UpdateCategory from './dto/UpdateCategory.dto';
+
+@Controller('categories')
+export default class CategoriesController {
+    constructor(
+        private readonly categoriesService: CategoryService
+    ) { }
+
+
+    // GET /categories
+    @Get()
+    async getAllPosts() {
+        return await this.categoriesService.getAllCategories();
+    }
+
+    // // GET /posts/123
+    @Get(':id')
+    async getPostById(@Param() { id }: FindOneParams) {
+        return this.categoriesService.getCategoryById((id))
+    }
+
+    @Post()
+    @UseGuards(JwtAuthenticationGuard)
+    async createCategory(@Body() category: CreateCategoryDTO, @Req() req: RequestWithUser) {
+        return await this.categoriesService.createCategory(category);
+    }
+
+
+    @Patch(':id')
+    async updateCategory(@Param() { id }: FindOneParams, @Body() category: UpdateCategory) {
+        return this.categoriesService.updateCategory(id, category);
+    }
+
+    @Delete(':id')
+    async deletePost(@Param() { id }: FindOneParams) {
+        await this.categoriesService.deleteCategory(id)
+    }
+}

src/categories/categories.module.ts

@@ -0,0 +1,14 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+
+import CategoriesController from './categories.controller';
+import CategoryService from './categories.service';
+import Category from './category.entity';
+
+@Module({
+    imports: [TypeOrmModule.forFeature([Category])],
+    controllers: [CategoriesController],
+    providers: [CategoryService],
+    exports: [CategoryService]
+})
+export class CategoriesModule { }

src/categories/categories.service.ts

@@ -0,0 +1,83 @@
+import { InjectRepository } from '@nestjs/typeorm';
+import { Injectable, NotFoundException, HttpStatus } from '@nestjs/common';
+
+import { In, Repository } from 'typeorm';
+import Category from './category.entity';
+import createCategoryDto from './dto/createCategory.dto';
+import CategoryNotFoundException from 'src/exceptions/notFoundExceptions';
+import DuplicateResourceException from 'src/exceptions/duplicateResource.exception';
+import UpdateCategory from './dto/UpdateCategory.dto';
+
+@Injectable()
+export default class CategoryService {
+
+    constructor(
+        @InjectRepository(Category)
+        private categoriesRepository: Repository<Category>
+    ) { }
+
+
+    async getCategoriesByIds(categories: string[]): Promise<Category[]> {
+        const returnedCategories = await this.categoriesRepository.find({
+            where: { id: In(categories) }
+            // order: { createDate: "ASC" }
+        })
+
+        if (returnedCategories.length == categories.length) {
+            return returnedCategories
+        }
+
+        throw new NotFoundException(`Some of the categories you supplied were not found ${categories}`)
+    }
+
+    async getAllCategories() {
+        // return each post with their posts
+        return this.categoriesRepository.find({ relations: ['posts'] });
+    }
+
+    async createCategory(category: createCategoryDto) {
+        try {
+            await this.getCategoryByName(category.name)
+            throw new DuplicateResourceException(`There is a category with this name ${category.name}`)
+        } catch (e) {
+            if (!(e instanceof CategoryNotFoundException)) {
+                throw e
+            }
+        }
+        const newCategory = this.categoriesRepository.create({ ...category })
+        await this.categoriesRepository.save(newCategory);
+        return newCategory
+    }
+
+    private async getCategoryByName(name: string) {
+        const category = await this.categoriesRepository.findOne({ where: { name: name } })
+        if (category) {
+            return category
+        }
+        throw new CategoryNotFoundException(name)
+    }
+
+    async updateCategory(id: string, category: UpdateCategory): Promise<Category> {
+        const updateResult = await this.categoriesRepository.update(id, category)
+        if (!updateResult.affected) {
+            throw new CategoryNotFoundException(id)
+        }
+        return await this.getCategoryById(id);
+    }
+
+    async getCategoryById(id: string) {
+        const category = await this.categoriesRepository.findOne({ where: { id: id } })
+        if (category) {
+            return category
+        }
+        throw new CategoryNotFoundException(id)
+    }
+
+    async deleteCategory(id: string) {
+        const deleteResponse = await this.categoriesRepository.delete(id)
+        console.log(deleteResponse.affected)
+        if (!deleteResponse.affected) {
+            throw new CategoryNotFoundException(id)
+        }
+    }
+}

src/categories/category.entity.ts

@@ -0,0 +1,17 @@
+import { Column, Entity, ManyToMany, PrimaryGeneratedColumn } from "typeorm";
+import Post from 'src/posts/post.entity';
+
+@Entity()
+class Category {
+    @PrimaryGeneratedColumn('uuid')
+    public id: string
+
+    @Column()
+    public name: string;
+
+    // Bi-Direction, we do not use JoinTable here since it has been used at the other side
+    @ManyToMany(() => Post, (post: Post) => post.categories)
+    public posts: Post[];
+}
+
+export default Category;