switch to nx monorepo

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

@@ -0,0 +1,15 @@
+import { IsOptional, IsString, IsUUID } from 'class-validator';
+
+export class CreatePageDto {
+  @IsOptional()
+  @IsUUID()
+  id?: string;
+
+  @IsOptional()
+  @IsString()
+  title?: string;
+
+  @IsOptional()
+  @IsString()
+  parentPageId?: string;
+}

apps/server/src/core/page/dto/delete-page.dto.ts

@@ -0,0 +1,6 @@
+import { IsUUID } from 'class-validator';
+
+export class DeletePageDto {
+  @IsUUID()
+  id: string;
+}

apps/server/src/core/page/dto/history-details.dto.ts

@@ -0,0 +1,6 @@
+import { IsUUID } from 'class-validator';
+
+export class HistoryDetailsDto {
+  @IsUUID()
+  id: string;
+}

apps/server/src/core/page/dto/move-page.dto.ts

@@ -0,0 +1,18 @@
+import { IsString, IsOptional, IsUUID } from 'class-validator';
+
+export class MovePageDto {
+  @IsUUID()
+  id: string;
+
+  @IsOptional()
+  @IsString()
+  after?: string;
+
+  @IsOptional()
+  @IsString()
+  before?: string;
+
+  @IsOptional()
+  @IsString()
+  parentId?: string | null;
+}

apps/server/src/core/page/dto/page-details.dto.ts

@@ -0,0 +1,6 @@
+import { IsUUID } from 'class-validator';
+
+export class PageDetailsDto {
+  @IsUUID()
+  id: string;
+}

apps/server/src/core/page/dto/page-history.dto.ts

@@ -0,0 +1,6 @@
+import { IsUUID } from 'class-validator';
+
+export class PageHistoryDto {
+  @IsUUID()
+  pageId: string;
+}

apps/server/src/core/page/dto/page-with-ordering.dto.ts

@@ -0,0 +1,5 @@
+import { Page } from '../entities/page.entity';
+
+export class PageWithOrderingDto extends Page {
+  childrenIds?: string[];
+}

apps/server/src/core/page/dto/update-page.dto.ts

@@ -0,0 +1,8 @@
+import { PartialType } from '@nestjs/mapped-types';
+import { CreatePageDto } from './create-page.dto';
+import { IsUUID } from 'class-validator';
+
+export class UpdatePageDto extends PartialType(CreatePageDto) {
+  @IsUUID()
+  id: string;
+}

apps/server/src/core/page/entities/page-history.entity.ts

@@ -0,0 +1,63 @@
+import {
+  Entity,
+  PrimaryGeneratedColumn,
+  Column,
+  CreateDateColumn,
+  UpdateDateColumn,
+  ManyToOne,
+  JoinColumn,
+} from 'typeorm';
+import { Workspace } from '../../workspace/entities/workspace.entity';
+import { Page } from './page.entity';
+import { User } from '../../user/entities/user.entity';
+
+@Entity('page_history')
+export class PageHistory {
+  @PrimaryGeneratedColumn('uuid')
+  id: string;
+
+  @Column({ type: 'uuid' })
+  pageId: string;
+
+  @ManyToOne(() => Page, (page) => page.pageHistory, { onDelete: 'CASCADE' })
+  @JoinColumn({ name: 'pageId' })
+  page: Page;
+
+  @Column({ length: 500, nullable: true })
+  title: string;
+
+  @Column({ type: 'jsonb', nullable: true })
+  content: string;
+
+  @Column({ nullable: true })
+  slug: string;
+
+  @Column({ nullable: true })
+  icon: string;
+
+  @Column({ nullable: true })
+  coverPhoto: string;
+
+  @Column({ type: 'int' })
+  version: number;
+
+  @Column({ type: 'uuid' })
+  lastUpdatedById: string;
+
+  @ManyToOne(() => User)
+  @JoinColumn({ name: 'lastUpdatedById' })
+  lastUpdatedBy: User;
+
+  @Column()
+  workspaceId: string;
+
+  @ManyToOne(() => Workspace, { onDelete: 'CASCADE' })
+  @JoinColumn({ name: 'workspaceId' })
+  workspace: Workspace;
+
+  @CreateDateColumn()
+  createdAt: Date;
+
+  @UpdateDateColumn()
+  updatedAt: Date;
+}

apps/server/src/core/page/entities/page-ordering.entity.ts

@@ -0,0 +1,46 @@
+import {
+  Entity,
+  PrimaryGeneratedColumn,
+  Column,
+  ManyToOne,
+  JoinColumn,
+  Unique,
+  CreateDateColumn,
+  UpdateDateColumn,
+  DeleteDateColumn,
+} from 'typeorm';
+import { Workspace } from '../../workspace/entities/workspace.entity';
+
+@Entity('page_ordering')
+@Unique(['entityId', 'entityType'])
+export class PageOrdering {
+  @PrimaryGeneratedColumn('uuid')
+  id: string;
+
+  @Column('uuid')
+  entityId: string;
+
+  @Column({ type: 'varchar', length: 50, nullable: false })
+  entityType: string;
+
+  @Column('uuid', { array: true })
+  childrenIds: string[];
+
+  @ManyToOne(() => Workspace, (workspace) => workspace.id, {
+    onDelete: 'CASCADE',
+  })
+  @JoinColumn({ name: 'workspaceId' })
+  workspace: Workspace;
+
+  @Column('uuid')
+  workspaceId: string;
+
+  @DeleteDateColumn({ nullable: true })
+  deletedAt: Date;
+
+  @CreateDateColumn()
+  createdAt: Date;
+
+  @UpdateDateColumn()
+  updatedAt: Date;
+}

apps/server/src/core/page/entities/page.entity.ts

@@ -0,0 +1,110 @@
+import {
+  Entity,
+  PrimaryGeneratedColumn,
+  Column,
+  CreateDateColumn,
+  UpdateDateColumn,
+  ManyToOne,
+  JoinColumn,
+  OneToMany,
+  DeleteDateColumn,
+} from 'typeorm';
+import { User } from '../../user/entities/user.entity';
+import { Workspace } from '../../workspace/entities/workspace.entity';
+import { Comment } from '../../comment/entities/comment.entity';
+import { PageHistory } from './page-history.entity';
+
+@Entity('pages')
+export class Page {
+  @PrimaryGeneratedColumn('uuid')
+  id: string;
+
+  @Column({ length: 500, nullable: true })
+  title: string;
+
+  @Column({ type: 'jsonb', nullable: true })
+  content: string;
+
+  @Column({ type: 'text', nullable: true })
+  html: string;
+
+  @Column({ type: 'bytea', nullable: true })
+  ydoc: any;
+
+  @Column({ nullable: true })
+  slug: string;
+
+  @Column({ nullable: true })
+  icon: string;
+
+  @Column({ nullable: true })
+  coverPhoto: string;
+
+  @Column({ length: 255, nullable: true })
+  editor: string;
+
+  @Column({ length: 255, nullable: true })
+  shareId: string;
+
+  @Column({ type: 'uuid', nullable: true })
+  parentPageId: string;
+
+  @Column()
+  creatorId: string;
+
+  @ManyToOne(() => User)
+  @JoinColumn({ name: 'creatorId' })
+  creator: User;
+
+  @Column({ type: 'uuid', nullable: true })
+  lastUpdatedById: string;
+
+  @ManyToOne(() => User)
+  @JoinColumn({ name: 'lastUpdatedById' })
+  lastUpdatedBy: User;
+
+  @Column({ type: 'uuid', nullable: true })
+  deletedById: string;
+
+  @ManyToOne(() => User)
+  @JoinColumn({ name: 'deletedById' })
+  deletedBy: User;
+
+  @Column()
+  workspaceId: string;
+
+  @ManyToOne(() => Workspace, { onDelete: 'CASCADE' })
+  @JoinColumn({ name: 'workspaceId' })
+  workspace: Workspace;
+
+  @Column({ type: 'boolean', default: false })
+  isLocked: boolean;
+
+  @Column({ length: 255, nullable: true })
+  status: string;
+
+  @Column({ type: 'date', nullable: true })
+  publishedAt: Date;
+
+  @CreateDateColumn()
+  createdAt: Date;
+
+  @UpdateDateColumn()
+  updatedAt: Date;
+
+  @DeleteDateColumn({ nullable: true })
+  deletedAt: Date;
+
+  @ManyToOne(() => Page, (page) => page.childPages)
+  @JoinColumn({ name: 'parentPageId' })
+  parentPage: Page;
+
+  @OneToMany(() => Page, (page) => page.parentPage, { onDelete: 'CASCADE' })
+  childPages: Page[];
+
+  @OneToMany(() => PageHistory, (pageHistory) => pageHistory.page)
+  pageHistory: PageHistory[];
+
+  @OneToMany(() => Comment, (comment) => comment.page)
+  comments: Comment[];
+}

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

@@ -0,0 +1,20 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { PageController } from './page.controller';
+import { PageService } from './services/page.service';
+
+describe('PageController', () => {
+  let controller: PageController;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [PageController],
+      providers: [PageService],
+    }).compile();
+
+    controller = module.get<PageController>(PageController);
+  });
+
+  it('should be defined', () => {
+    expect(controller).toBeDefined();
+  });
+});

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

@@ -0,0 +1,120 @@
+import {
+  Controller,
+  Post,
+  Body,
+  HttpCode,
+  HttpStatus,
+  UseGuards,
+} from '@nestjs/common';
+import { PageService } from './services/page.service';
+import { CreatePageDto } from './dto/create-page.dto';
+import { UpdatePageDto } from './dto/update-page.dto';
+import { JwtGuard } from '../auth/guards/JwtGuard';
+import { WorkspaceService } from '../workspace/services/workspace.service';
+import { MovePageDto } from './dto/move-page.dto';
+import { PageDetailsDto } from './dto/page-details.dto';
+import { DeletePageDto } from './dto/delete-page.dto';
+import { PageOrderingService } from './services/page-ordering.service';
+import { PageHistoryService } from './services/page-history.service';
+import { HistoryDetailsDto } from './dto/history-details.dto';
+import { PageHistoryDto } from './dto/page-history.dto';
+import { JwtUser } from '../../decorators/jwt-user.decorator';
+
+@UseGuards(JwtGuard)
+@Controller('pages')
+export class PageController {
+  constructor(
+    private readonly pageService: PageService,
+    private readonly pageOrderService: PageOrderingService,
+    private readonly pageHistoryService: PageHistoryService,
+    private readonly workspaceService: WorkspaceService,
+  ) {}
+
+  @HttpCode(HttpStatus.OK)
+  @Post('/details')
+  async getPage(@Body() input: PageDetailsDto) {
+    return this.pageService.findOne(input.id);
+  }
+
+  @HttpCode(HttpStatus.CREATED)
+  @Post('create')
+  async create(@JwtUser() jwtUser, @Body() createPageDto: CreatePageDto) {
+    const workspaceId = (
+      await this.workspaceService.getUserCurrentWorkspace(jwtUser.id)
+    ).id;
+    return this.pageService.create(jwtUser.id, workspaceId, createPageDto);
+  }
+
+  @HttpCode(HttpStatus.OK)
+  @Post('update')
+  async update(@JwtUser() jwtUser, @Body() updatePageDto: UpdatePageDto) {
+    return this.pageService.update(updatePageDto.id, updatePageDto, jwtUser.id);
+  }
+
+  @HttpCode(HttpStatus.OK)
+  @Post('delete')
+  async delete(@Body() deletePageDto: DeletePageDto) {
+    await this.pageService.delete(deletePageDto.id);
+  }
+
+  @HttpCode(HttpStatus.OK)
+  @Post('restore')
+  async restore(@Body() deletePageDto: DeletePageDto) {
+    await this.pageService.restore(deletePageDto.id);
+  }
+
+  @HttpCode(HttpStatus.OK)
+  @Post('move')
+  async movePage(@Body() movePageDto: MovePageDto) {
+    return this.pageOrderService.movePage(movePageDto);
+  }
+
+  @HttpCode(HttpStatus.OK)
+  @Post('recent')
+  async getRecentWorkspacePages(@JwtUser() jwtUser) {
+    const workspaceId = (
+      await this.workspaceService.getUserCurrentWorkspace(jwtUser.id)
+    ).id;
+    return this.pageService.getRecentWorkspacePages(workspaceId);
+  }
+
+  @HttpCode(HttpStatus.OK)
+  @Post()
+  async getWorkspacePages(@JwtUser() jwtUser) {
+    const workspaceId = (
+      await this.workspaceService.getUserCurrentWorkspace(jwtUser.id)
+    ).id;
+    return this.pageService.getSidebarPagesByWorkspaceId(workspaceId);
+  }
+
+  @HttpCode(HttpStatus.OK)
+  @Post('ordering')
+  async getWorkspacePageOrder(@JwtUser() jwtUser) {
+    const workspaceId = (
+      await this.workspaceService.getUserCurrentWorkspace(jwtUser.id)
+    ).id;
+    return this.pageOrderService.getWorkspacePageOrder(workspaceId);
+  }
+
+  @HttpCode(HttpStatus.OK)
+  @Post('tree')
+  async workspacePageTree(@JwtUser() jwtUser) {
+    const workspaceId = (
+      await this.workspaceService.getUserCurrentWorkspace(jwtUser.id)
+    ).id;
+
+    return this.pageOrderService.convertToTree(workspaceId);
+  }
+
+  @HttpCode(HttpStatus.OK)
+  @Post('/history')
+  async getPageHistory(@Body() dto: PageHistoryDto) {
+    return this.pageHistoryService.findHistoryByPageId(dto.pageId);
+  }
+
+  @HttpCode(HttpStatus.OK)
+  @Post('/history/details')
+  async get(@Body() dto: HistoryDetailsDto) {
+    return this.pageHistoryService.findOne(dto.id);
+  }
+}

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

@@ -0,0 +1,31 @@
+import { Module } from '@nestjs/common';
+import { PageService } from './services/page.service';
+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';
+import { PageOrderingService } from './services/page-ordering.service';
+import { PageOrdering } from './entities/page-ordering.entity';
+import { PageHistoryService } from './services/page-history.service';
+import { PageHistory } from './entities/page-history.entity';
+import { PageHistoryRepository } from './repositories/page-history.repository';
+
+@Module({
+  imports: [
+    TypeOrmModule.forFeature([Page, PageOrdering, PageHistory]),
+    AuthModule,
+    WorkspaceModule,
+  ],
+  controllers: [PageController],
+  providers: [
+    PageService,
+    PageOrderingService,
+    PageHistoryService,
+    PageRepository,
+    PageHistoryRepository,
+  ],
+  exports: [PageService, PageOrderingService, PageHistoryService],
+})
+export class PageModule {}

apps/server/src/core/page/page.util.ts

@@ -0,0 +1,81 @@
+import { MovePageDto } from './dto/move-page.dto';
+import { EntityManager } from 'typeorm';
+
+export enum OrderingEntity {
+  workspace = 'WORKSPACE',
+  page = 'PAGE',
+}
+
+export type TreeNode = {
+  id: string;
+  title: string;
+  icon?: string;
+  children?: TreeNode[];
+};
+
+export function orderPageList(arr: string[], payload: MovePageDto): void {
+  const { id, after, before } = payload;
+
+  // Removing the item we are moving from the array first.
+  const index = arr.indexOf(id);
+  if (index > -1) arr.splice(index, 1);
+
+  if (after) {
+    const afterIndex = arr.indexOf(after);
+    if (afterIndex > -1) {
+      arr.splice(afterIndex + 1, 0, id);
+    } else {
+      // Place the item at the end if the after ID is not found.
+      arr.push(id);
+    }
+  } else if (before) {
+    const beforeIndex = arr.indexOf(before);
+    if (beforeIndex > -1) {
+      arr.splice(beforeIndex, 0, id);
+    } else {
+      // Place the item at the end if the before ID is not found.
+      arr.push(id);
+    }
+  } else {
+    // If neither after nor before is provided, just add the id at the end
+    if (!arr.includes(id)) {
+      arr.push(id);
+    }
+  }
+}
+
+/**
+ * Remove an item from an array and save the entity
+ * @param entity - The entity instance (Page or Workspace)
+ * @param arrayField - The name of the field which is an array
+ * @param itemToRemove - The item to remove from the array
+ * @param manager - EntityManager instance
+ */
+export async function removeFromArrayAndSave<T>(
+  entity: T,
+  arrayField: string,
+  itemToRemove: any,
+  manager: EntityManager,
+) {
+  const array = entity[arrayField];
+  const index = array.indexOf(itemToRemove);
+  if (index > -1) {
+    array.splice(index, 1);
+    await manager.save(entity);
+  }
+}
+
+export function transformPageResult(result: any[]): any[] {
+  return result.map((row) => {
+    const processedRow = {};
+    for (const key in row) {
+      const newKey = key.split('_').slice(1).join('_');
+      if (newKey === 'childrenIds' && !row[key]) {
+        processedRow[newKey] = [];
+      } else {
+        processedRow[newKey] = row[key];
+      }
+    }
+    return processedRow;
+  });
+}

apps/server/src/core/page/repositories/page-history.repository.ts

@@ -0,0 +1,26 @@
+import { DataSource, Repository } from 'typeorm';
+import { Injectable } from '@nestjs/common';
+import { PageHistory } from '../entities/page-history.entity';
+
+@Injectable()
+export class PageHistoryRepository extends Repository<PageHistory> {
+  constructor(private dataSource: DataSource) {
+    super(PageHistory, dataSource.createEntityManager());
+  }
+
+  async findById(pageId: string) {
+    return this.findOne({
+      where: {
+        id: pageId,
+      },
+      relations: ['lastUpdatedBy'],
+      select: {
+        lastUpdatedBy: {
+          id: true,
+          name: true,
+          avatarUrl: true,
+        },
+      },
+    });
+  }
+}

apps/server/src/core/page/repositories/page.repository.ts

@@ -0,0 +1,56 @@
+import { DataSource, Repository } from 'typeorm';
+import { Injectable } from '@nestjs/common';
+import { Page } from '../entities/page.entity';
+
+@Injectable()
+export class PageRepository extends Repository<Page> {
+  constructor(private dataSource: DataSource) {
+    super(Page, dataSource.createEntityManager());
+  }
+
+  public baseFields = [
+    'page.id',
+    'page.title',
+    'page.slug',
+    'page.icon',
+    'page.coverPhoto',
+    'page.shareId',
+    'page.parentPageId',
+    'page.creatorId',
+    'page.lastUpdatedById',
+    'page.workspaceId',
+    'page.isLocked',
+    'page.status',
+    'page.publishedAt',
+    'page.createdAt',
+    'page.updatedAt',
+    'page.deletedAt',
+  ];
+
+  private async baseFind(pageId: string, selectFields: string[]) {
+    return this.dataSource
+      .createQueryBuilder(Page, 'page')
+      .where('page.id = :id', { id: pageId })
+      .select(selectFields)
+      .getOne();
+  }
+
+  async findById(pageId: string) {
+    return this.baseFind(pageId, this.baseFields);
+  }
+
+  async findWithYDoc(pageId: string) {
+    const extendedFields = [...this.baseFields, 'page.ydoc'];
+    return this.baseFind(pageId, extendedFields);
+  }
+
+  async findWithContent(pageId: string) {
+    const extendedFields = [...this.baseFields, 'page.content'];
+    return this.baseFind(pageId, extendedFields);
+  }
+
+  async findWithAllFields(pageId: string) {
+    const extendedFields = [...this.baseFields, 'page.content', 'page.ydoc'];
+    return this.baseFind(pageId, extendedFields);
+  }
+}

apps/server/src/core/page/services/page-history.service.ts

@@ -0,0 +1,61 @@
+import { BadRequestException, Injectable } from '@nestjs/common';
+import { PageHistory } from '../entities/page-history.entity';
+import { Page } from '../entities/page.entity';
+import { PageHistoryRepository } from '../repositories/page-history.repository';
+
+@Injectable()
+export class PageHistoryService {
+  constructor(private pageHistoryRepo: PageHistoryRepository) {
+  }
+
+  async findOne(historyId: string): Promise<PageHistory> {
+    const history = await this.pageHistoryRepo.findById(historyId);
+    if (!history) {
+      throw new BadRequestException('History not found');
+    }
+    return history;
+  }
+
+  async saveHistory(page: Page): Promise<void> {
+    const pageHistory = new PageHistory();
+    pageHistory.pageId = page.id;
+    pageHistory.title = page.title;
+    pageHistory.content = page.content;
+    pageHistory.slug = page.slug;
+    pageHistory.icon = page.icon;
+    pageHistory.version = 1; // TODO: make incremental
+    pageHistory.coverPhoto = page.coverPhoto;
+    pageHistory.lastUpdatedById = page.lastUpdatedById ?? page.creatorId;
+    pageHistory.workspaceId = page.workspaceId;
+
+    await this.pageHistoryRepo.save(pageHistory);
+  }
+
+  async findHistoryByPageId(pageId: string, limit = 50, offset = 0) {
+    const history = await this.pageHistoryRepo
+      .createQueryBuilder('history')
+      .where('history.pageId = :pageId', { pageId })
+      .leftJoinAndSelect('history.lastUpdatedBy', 'user')
+      .select([
+        'history.id',
+        'history.pageId',
+        'history.title',
+        'history.slug',
+        'history.icon',
+        'history.coverPhoto',
+        'history.version',
+        'history.lastUpdatedById',
+        'history.workspaceId',
+        'history.createdAt',
+        'history.updatedAt',
+        'user.id',
+        'user.name',
+        'user.avatarUrl',
+      ])
+      .orderBy('history.updatedAt', 'DESC')
+      .offset(offset)
+      .take(limit)
+      .getMany();
+    return history;
+  }
+}

apps/server/src/core/page/services/page-ordering.service.ts

@@ -0,0 +1,292 @@
+import {
+  BadRequestException,
+  forwardRef,
+  Inject,
+  Injectable,
+} from '@nestjs/common';
+import { PageRepository } from '../repositories/page.repository';
+import { Page } from '../entities/page.entity';
+import { MovePageDto } from '../dto/move-page.dto';
+import {
+  OrderingEntity,
+  orderPageList,
+  removeFromArrayAndSave,
+  TreeNode,
+} from '../page.util';
+import { DataSource, EntityManager } from 'typeorm';
+import { PageService } from './page.service';
+import { PageOrdering } from '../entities/page-ordering.entity';
+import { PageWithOrderingDto } from '../dto/page-with-ordering.dto';
+
+@Injectable()
+export class PageOrderingService {
+  constructor(
+    private pageRepository: PageRepository,
+    private dataSource: DataSource,
+    @Inject(forwardRef(() => PageService))
+    private pageService: PageService,
+  ) {}
+
+  async movePage(dto: MovePageDto): Promise<void> {
+    await this.dataSource.transaction(async (manager: EntityManager) => {
+      const movedPageId = dto.id;
+
+      const movedPage = await manager
+        .createQueryBuilder(Page, 'page')
+        .where('page.id = :movedPageId', { movedPageId })
+        .select(['page.id', 'page.workspaceId', 'page.parentPageId'])
+        .getOne();
+
+      if (!movedPage) throw new BadRequestException('Moved page not found');
+
+      if (!dto.parentId) {
+        if (movedPage.parentPageId) {
+          await this.removeFromParent(movedPage.parentPageId, dto.id, manager);
+        }
+        const workspaceOrdering = await this.getEntityOrdering(
+          movedPage.workspaceId,
+          OrderingEntity.workspace,
+          manager,
+        );
+
+        orderPageList(workspaceOrdering.childrenIds, dto);
+
+        await manager.save(workspaceOrdering);
+      } else {
+        const parentPageId = dto.parentId;
+
+        let parentPageOrdering = await this.getEntityOrdering(
+          parentPageId,
+          OrderingEntity.page,
+          manager,
+        );
+
+        if (!parentPageOrdering) {
+          parentPageOrdering = await this.createPageOrdering(
+            parentPageId,
+            OrderingEntity.page,
+            movedPage.workspaceId,
+            manager,
+          );
+        }
+
+        // Check if the parent was changed
+        if (movedPage.parentPageId && movedPage.parentPageId !== parentPageId) {
+          //if yes, remove moved page from old parent's children
+          await this.removeFromParent(movedPage.parentPageId, dto.id, manager);
+        }
+
+        // If movedPage didn't have a parent initially (was at root level), update the root level
+        if (!movedPage.parentPageId) {
+          await this.removeFromWorkspacePageOrder(
+            movedPage.workspaceId,
+            dto.id,
+            manager,
+          );
+        }
+
+        // Modify the children list of the new parentPage and save
+        orderPageList(parentPageOrdering.childrenIds, dto);
+        await manager.save(parentPageOrdering);
+      }
+
+      movedPage.parentPageId = dto.parentId || null;
+      await manager.save(movedPage);
+    });
+  }
+
+  async addPageToOrder(
+    workspaceId: string,
+    pageId: string,
+    parentPageId?: string,
+  ) {
+    await this.dataSource.transaction(async (manager: EntityManager) => {
+      if (parentPageId) {
+        await this.upsertOrdering(
+          parentPageId,
+          OrderingEntity.page,
+          pageId,
+          workspaceId,
+          manager,
+        );
+      } else {
+        await this.addToWorkspacePageOrder(workspaceId, pageId, manager);
+      }
+    });
+  }
+
+  async addToWorkspacePageOrder(
+    workspaceId: string,
+    pageId: string,
+    manager: EntityManager,
+  ) {
+    await this.upsertOrdering(
+      workspaceId,
+      OrderingEntity.workspace,
+      pageId,
+      workspaceId,
+      manager,
+    );
+  }
+
+  async removeFromParent(
+    parentId: string,
+    childId: string,
+    manager: EntityManager,
+  ): Promise<void> {
+    await this.removeChildFromOrdering(
+      parentId,
+      OrderingEntity.page,
+      childId,
+      manager,
+    );
+  }
+
+  async removeFromWorkspacePageOrder(
+    workspaceId: string,
+    pageId: string,
+    manager: EntityManager,
+  ) {
+    await this.removeChildFromOrdering(
+      workspaceId,
+      OrderingEntity.workspace,
+      pageId,
+      manager,
+    );
+  }
+
+  async removeChildFromOrdering(
+    entityId: string,
+    entityType: string,
+    childId: string,
+    manager: EntityManager,
+  ): Promise<void> {
+    const ordering = await this.getEntityOrdering(
+      entityId,
+      entityType,
+      manager,
+    );
+
+    if (ordering && ordering.childrenIds.includes(childId)) {
+      await removeFromArrayAndSave(ordering, 'childrenIds', childId, manager);
+    }
+  }
+
+  async removePageFromHierarchy(
+    page: Page,
+    manager: EntityManager,
+  ): Promise<void> {
+    if (page.parentPageId) {
+      await this.removeFromParent(page.parentPageId, page.id, manager);
+    } else {
+      await this.removeFromWorkspacePageOrder(
+        page.workspaceId,
+        page.id,
+        manager,
+      );
+    }
+  }
+
+  async upsertOrdering(
+    entityId: string,
+    entityType: string,
+    childId: string,
+    workspaceId: string,
+    manager: EntityManager,
+  ) {
+    let ordering = await this.getEntityOrdering(entityId, entityType, manager);
+
+    if (!ordering) {
+      ordering = await this.createPageOrdering(
+        entityId,
+        entityType,
+        workspaceId,
+        manager,
+      );
+    }
+
+    if (!ordering.childrenIds.includes(childId)) {
+      ordering.childrenIds.unshift(childId);
+      await manager.save(PageOrdering, ordering);
+    }
+  }
+
+  async getEntityOrdering(
+    entityId: string,
+    entityType: string,
+    manager,
+  ): Promise<PageOrdering> {
+    return manager
+      .createQueryBuilder(PageOrdering, 'ordering')
+      .setLock('pessimistic_write')
+      .where('ordering.entityId = :entityId', { entityId })
+      .andWhere('ordering.entityType = :entityType', {
+        entityType,
+      })
+      .getOne();
+  }
+
+  async createPageOrdering(
+    entityId: string,
+    entityType: string,
+    workspaceId: string,
+    manager: EntityManager,
+  ): Promise<PageOrdering> {
+    await manager.query(
+      `INSERT INTO page_ordering ("entityId", "entityType", "workspaceId", "childrenIds") 
+     VALUES ($1, $2, $3, '{}')
+     ON CONFLICT ("entityId", "entityType") DO NOTHING`,
+      [entityId, entityType, workspaceId],
+    );
+
+    return await this.getEntityOrdering(entityId, entityType, manager);
+  }
+
+  async getWorkspacePageOrder(workspaceId: string): Promise<PageOrdering> {
+    return await this.dataSource
+      .createQueryBuilder(PageOrdering, 'ordering')
+      .select(['ordering.id', 'ordering.childrenIds', 'ordering.workspaceId'])
+      .where('ordering.entityId = :workspaceId', { workspaceId })
+      .andWhere('ordering.entityType = :entityType', {
+        entityType: OrderingEntity.workspace,
+      })
+      .getOne();
+  }
+
+  async convertToTree(workspaceId: string): Promise<TreeNode[]> {
+    const workspaceOrder = await this.getWorkspacePageOrder(workspaceId);
+
+    const pageOrder = workspaceOrder ? workspaceOrder.childrenIds : undefined;
+    const pages = await this.pageService.getSidebarPagesByWorkspaceId(workspaceId);
+
+    const pageMap: { [id: string]: PageWithOrderingDto } = {};
+    pages.forEach((page) => {
+      pageMap[page.id] = page;
+    });
+
+    function buildTreeNode(id: string): TreeNode | undefined {
+      const page = pageMap[id];
+      if (!page) return;
+
+      const node: TreeNode = {
+        id: page.id,
+        title: page.title || '',
+        children: [],
+      };
+
+      if (page.icon) node.icon = page.icon;
+
+      if (page.childrenIds && page.childrenIds.length > 0) {
+        node.children = page.childrenIds
+          .map((childId) => buildTreeNode(childId))
+          .filter(Boolean) as TreeNode[];
+      }
+
+      return node;
+    }
+
+    return pageOrder
+      .map((id) => buildTreeNode(id))
+      .filter(Boolean) as TreeNode[];
+  }
+}

apps/server/src/core/page/services/page.service.spec.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { PageService } from './page.service';
+
+describe('PageService', () => {
+  let service: PageService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [PageService],
+    }).compile();
+
+    service = module.get<PageService>(PageService);
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+});

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

@@ -0,0 +1,267 @@
+import {
+  BadRequestException,
+  forwardRef,
+  Inject,
+  Injectable,
+  NotFoundException,
+} 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';
+import { DataSource, EntityManager } from 'typeorm';
+import { PageOrderingService } from './page-ordering.service';
+import { PageWithOrderingDto } from '../dto/page-with-ordering.dto';
+import { OrderingEntity, transformPageResult } from '../page.util';
+
+@Injectable()
+export class PageService {
+  constructor(
+    private pageRepository: PageRepository,
+    private dataSource: DataSource,
+    @Inject(forwardRef(() => PageOrderingService))
+    private pageOrderingService: PageOrderingService,
+  ) {}
+
+  async findWithBasic(pageId: string) {
+    return this.pageRepository.findOne({
+      where: { id: pageId },
+      select: ['id', 'title'],
+    });
+  }
+
+  async findById(pageId: string) {
+    return this.pageRepository.findById(pageId);
+  }
+
+  async findWithContent(pageId: string) {
+    return this.pageRepository.findWithContent(pageId);
+  }
+
+  async findWithYdoc(pageId: string) {
+    return this.pageRepository.findWithYDoc(pageId);
+  }
+
+  async findWithAllFields(pageId: string) {
+    return this.pageRepository.findWithAllFields(pageId);
+  }
+
+  async findOne(pageId: string): Promise<Page> {
+    const page = await this.findById(pageId);
+    if (!page) {
+      throw new BadRequestException('Page not found');
+    }
+
+    return page;
+  }
+
+  async create(
+    userId: string,
+    workspaceId: string,
+    createPageDto: CreatePageDto,
+  ): Promise<Page> {
+    const page = plainToInstance(Page, createPageDto);
+    page.creatorId = userId;
+    page.workspaceId = workspaceId;
+    page.lastUpdatedById = userId;
+
+    if (createPageDto.parentPageId) {
+      // TODO: make sure parent page belongs to same workspace and user has permissions
+      const parentPage = await this.pageRepository.findOne({
+        where: { id: createPageDto.parentPageId },
+        select: ['id'],
+      });
+
+      if (!parentPage) throw new BadRequestException('Parent page not found');
+    }
+
+    const createdPage = await this.pageRepository.save(page);
+
+    await this.pageOrderingService.addPageToOrder(
+      workspaceId,
+      createPageDto.id,
+      createPageDto.parentPageId,
+    );
+
+    return createdPage;
+  }
+
+  async update(
+    pageId: string,
+    updatePageDto: UpdatePageDto,
+    userId: string,
+  ): Promise<Page> {
+    const updateData = {
+      ...updatePageDto,
+      lastUpdatedById: userId,
+    };
+
+    const result = await this.pageRepository.update(pageId, updateData);
+    if (result.affected === 0) {
+      throw new BadRequestException(`Page not found`);
+    }
+
+    return await this.pageRepository.findById(pageId);
+  }
+
+  async updateState(
+    pageId: string,
+    content: any,
+    ydoc: any,
+    userId?: string, // TODO: fix this
+  ): Promise<void> {
+    await this.pageRepository.update(pageId, {
+      content: content,
+      ydoc: ydoc,
+      ...(userId && { lastUpdatedById: userId }),
+    });
+  }
+
+  async delete(pageId: string): Promise<void> {
+    await this.dataSource.transaction(async (manager: EntityManager) => {
+      const page = await manager
+        .createQueryBuilder(Page, 'page')
+        .where('page.id = :pageId', { pageId })
+        .select(['page.id', 'page.workspaceId'])
+        .getOne();
+
+      if (!page) {
+        throw new NotFoundException(`Page not found`);
+      }
+      await this.softDeleteChildrenRecursive(page.id, manager);
+      await this.pageOrderingService.removePageFromHierarchy(page, manager);
+
+      await manager.softDelete(Page, pageId);
+    });
+  }
+
+  private async softDeleteChildrenRecursive(
+    parentId: string,
+    manager: EntityManager,
+  ): Promise<void> {
+    const childrenPage = await manager
+      .createQueryBuilder(Page, 'page')
+      .where('page.parentPageId = :parentId', { parentId })
+      .select(['page.id', 'page.title', 'page.parentPageId'])
+      .getMany();
+
+    for (const child of childrenPage) {
+      await this.softDeleteChildrenRecursive(child.id, manager);
+      await manager.softDelete(Page, child.id);
+    }
+  }
+
+  async restore(pageId: string): Promise<void> {
+    await this.dataSource.transaction(async (manager: EntityManager) => {
+      const isDeleted = await manager
+        .createQueryBuilder(Page, 'page')
+        .where('page.id = :pageId', { pageId })
+        .withDeleted()
+        .getCount();
+
+      if (!isDeleted) {
+        return;
+      }
+
+      await manager.recover(Page, { id: pageId });
+
+      await this.restoreChildrenRecursive(pageId, manager);
+
+      // Fetch the page details to find out its parent and workspace
+      const restoredPage = await manager
+        .createQueryBuilder(Page, 'page')
+        .where('page.id = :pageId', { pageId })
+        .select([
+          'page.id',
+          'page.title',
+          'page.workspaceId',
+          'page.parentPageId',
+        ])
+        .getOne();
+
+      if (!restoredPage) {
+        throw new NotFoundException(`Restored page not found.`);
+      }
+
+      // add page back to its hierarchy
+      await this.pageOrderingService.addPageToOrder(
+        restoredPage.workspaceId,
+        pageId,
+        restoredPage.parentPageId,
+      );
+    });
+  }
+
+  private async restoreChildrenRecursive(
+    parentId: string,
+    manager: EntityManager,
+  ): Promise<void> {
+    const childrenPage = await manager
+      .createQueryBuilder(Page, 'page')
+      .setLock('pessimistic_write')
+      .where('page.parentPageId = :parentId', { parentId })
+      .select(['page.id', 'page.title', 'page.parentPageId'])
+      .withDeleted()
+      .getMany();
+
+    for (const child of childrenPage) {
+      await this.restoreChildrenRecursive(child.id, manager);
+      await manager.recover(Page, { id: child.id });
+    }
+  }
+
+  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 getSidebarPagesByWorkspaceId(
+    workspaceId: string,
+    limit = 200,
+  ): Promise<PageWithOrderingDto[]> {
+    const pages = await this.pageRepository
+      .createQueryBuilder('page')
+      .leftJoin(
+        'page_ordering',
+        'ordering',
+        'ordering.entityId = page.id AND ordering.entityType = :entityType',
+        { entityType: OrderingEntity.page },
+      )
+      .where('page.workspaceId = :workspaceId', { workspaceId })
+      .select([
+        'page.id',
+        'page.title',
+        'page.icon',
+        'page.parentPageId',
+        'ordering.childrenIds',
+        'page.creatorId',
+        'page.createdAt',
+      ])
+      .orderBy('page.createdAt', 'DESC')
+      .take(limit)
+      .getRawMany<PageWithOrderingDto[]>();
+
+    return transformPageResult(pages);
+  }
+
+  async getRecentWorkspacePages(
+    workspaceId: string,
+    limit = 20,
+    offset = 0,
+  ): Promise<Page[]> {
+    const pages = await this.pageRepository
+      .createQueryBuilder('page')
+      .where('page.workspaceId = :workspaceId', { workspaceId })
+      .select(this.pageRepository.baseFields)
+      .orderBy('page.updatedAt', 'DESC')
+      .offset(offset)
+      .take(limit)
+      .getMany();
+    return pages;
+  }
+}