Page module updates - WIP

server/src/core/page/dto/create-page.dto.ts

@@ -1,4 +1,4 @@
-import { IsOptional, IsString } from 'class-validator';
+import { IsOptional } from 'class-validator';
 
 export class CreatePageDto {
   @IsOptional()
@@ -8,11 +8,5 @@ export class CreatePageDto {
   content?: string;
 
   @IsOptional()
-  parentId?: string;
+  parentPageId?: string;
-
-  @IsString()
-  creatorId: string;
-
-  @IsString()
-  workspaceId: string;
 }

server/src/core/page/page.controller.ts

@@ -1,21 +1,60 @@
-import { Controller, Post, Body, Delete, Get, Param } from "@nestjs/common";
+import {
+  Controller,
+  Post,
+  Body,
+  Delete,
+  Get,
+  Param,
+  Req,
+  HttpCode,
+  HttpStatus,
+  UseGuards,
+} from '@nestjs/common';
 import { PageService } from './page.service';
 import { CreatePageDto } from './dto/create-page.dto';
+import { UpdatePageDto } from './dto/update-page.dto';
+import { FastifyRequest } from 'fastify';
+import { JwtGuard } from '../auth/guards/JwtGuard';
+import { WorkspaceService } from '../workspace/services/workspace.service';
 
+@UseGuards(JwtGuard)
 @Controller('page')
 export class PageController {
-  constructor(private readonly pageService: PageService) {}
+  constructor(
+    private readonly pageService: PageService,
+    private readonly workspaceService: WorkspaceService,
+  ) {}
 
-  @Post('create')
+  @Get('/info/:id')
-  async create(@Body() createPageDto: CreatePageDto) {
-    return this.pageService.create(createPageDto);
-  }
-
-  @Get('page/:id')
   async getPage(@Param('id') pageId: string) {
     return this.pageService.findById(pageId);
   }
 
+  @HttpCode(HttpStatus.CREATED)
+  @Post('create')
+  async create(
+    @Req() req: FastifyRequest,
+    @Body() createPageDto: CreatePageDto,
+  ) {
+    const jwtPayload = req['user'];
+    const userId = jwtPayload.sub;
+
+    const workspaceId = (
+      await this.workspaceService.getUserCurrentWorkspace(jwtPayload.sub)
+    ).id;
+
+    //const workspaceId = 'f9a12ec1-6b94-4191-b1d7-32ab93b330dc';
+    return this.pageService.create(userId, workspaceId, createPageDto);
+  }
+
+  @Post('update/:id')
+  async update(
+    @Param('id') pageId: string,
+    @Body() updatePageDto: UpdatePageDto,
+  ) {
+    return this.pageService.update(pageId, updatePageDto);
+  }
+
   @Delete('delete/:id')
   async delete(@Param('id') pageId: string) {
     await this.pageService.delete(pageId);

server/src/core/page/page.module.ts

@@ -4,9 +4,11 @@ import { PageController } from './page.controller';
 import { TypeOrmModule } from '@nestjs/typeorm';
 import { Page } from './entities/page.entity';
 import { PageRepository } from './repositories/page.repository';
+import { AuthModule } from '../auth/auth.module';
+import { WorkspaceModule } from '../workspace/workspace.module';
 
 @Module({
-  imports: [TypeOrmModule.forFeature([Page])],
+  imports: [TypeOrmModule.forFeature([Page]), AuthModule, WorkspaceModule],
   controllers: [PageController],
   providers: [PageService, PageRepository],
 })

server/src/core/page/page.service.ts

@@ -1,24 +1,59 @@
 import { Injectable } from '@nestjs/common';
 import { PageRepository } from './repositories/page.repository';
 import { CreatePageDto } from './dto/create-page.dto';
+import { Page } from './entities/page.entity';
+import { UpdatePageDto } from './dto/update-page.dto';
+import { plainToInstance } from 'class-transformer';
 
 @Injectable()
 export class PageService {
   constructor(private pageRepository: PageRepository) {}
 
-  async create(createPageDto: CreatePageDto) {
-    await this.pageRepository.save(createPageDto);
-  }
-
   async findById(pageId: string) {
     return this.pageRepository.findById(pageId);
   }
 
-  async delete(pageId: string) {
+  async create(
-    return this.pageRepository.softDelete(pageId);
+    userId: string,
+    workspaceId: string,
+    createPageDto: CreatePageDto,
+  ): Promise<Page> {
+    const page = plainToInstance(Page, createPageDto);
+    page.creatorId = userId;
+    page.workspaceId = workspaceId;
+
+    console.log(page);
+    return await this.pageRepository.save(page);
   }
 
-  async forceDelete(pageId: string) {
+  async update(pageId: string, updatePageDto: UpdatePageDto): Promise<Page> {
-    return this.pageRepository.delete(pageId);
+    const page = await this.pageRepository.preload({
+      id: pageId,
+      ...updatePageDto,
+    } as Page);
+
+    return await this.pageRepository.save(page);
+  }
+
+  async delete(pageId: string): Promise<void> {
+    await this.pageRepository.softDelete(pageId);
+  }
+
+  async forceDelete(pageId: string): Promise<void> {
+    await this.pageRepository.delete(pageId);
+  }
+
+  async lockOrUnlockPage(pageId: string, lock: boolean): Promise<Page> {
+    await this.pageRepository.update(pageId, { isLocked: lock });
+    return await this.pageRepository.findById(pageId);
+  }
+
+  async getRecentPages(limit = 10): Promise<Page[]> {
+    return await this.pageRepository.find({
+      order: {
+        createdAt: 'DESC',
+      },
+      take: limit,
+    });
   }
 }

server/src/core/workspace/services/workspace.service.ts

@@ -127,13 +127,7 @@ export class WorkspaceService {
     userId: string,
     workspaceId: string,
   ): Promise<void> {
-    const workspaceUser = await this.workspaceUserRepository.findOne({
+    await this.validateWorkspaceMember(userId, workspaceId);
-      where: { userId, workspaceId },
-    });
-
-    if (!workspaceUser) {
-      throw new BadRequestException('User is not a member of this workspace');
-    }
 
     await this.workspaceUserRepository.delete({
       userId,
@@ -183,4 +177,17 @@ export class WorkspaceService {
 
     return { users };
   }
+
+  async validateWorkspaceMember(
+    userId: string,
+    workspaceId: string,
+  ): Promise<void> {
+    const workspaceUser = await this.workspaceUserRepository.findOne({
+      where: { userId, workspaceId },
+    });
+
+    if (!workspaceUser) {
+      throw new BadRequestException('User is not a member of this workspace');
+    }
+  }
 }