feat: notifications (#1947)

* feat: notifications
* feat: watchers

* improvements

* handle page move for watchers

* make watchers non-blocking

* more

apps/server/src/core/watcher/dto/watcher.dto.ts

@@ -0,0 +1,7 @@
+import { IsString, IsNotEmpty } from 'class-validator';
+
+export class WatcherPageDto {
+  @IsString()
+  @IsNotEmpty()
+  pageId: string;
+}

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

@@ -0,0 +1,99 @@
+/***
+ import {
+  Body,
+  Controller,
+  ForbiddenException,
+  HttpCode,
+  HttpStatus,
+  NotFoundException,
+  Post,
+  UseGuards,
+} from '@nestjs/common';
+import { WatcherService } from './watcher.service';
+import { AuthUser } from '../../common/decorators/auth-user.decorator';
+import { AuthWorkspace } from '../../common/decorators/auth-workspace.decorator';
+import { JwtAuthGuard } from '../../common/guards/jwt-auth.guard';
+import { User, Workspace } from '@docmost/db/types/entity.types';
+import { WatcherPageDto } from './dto/watcher.dto';
+import { PageRepo } from '@docmost/db/repos/page/page.repo';
+import SpaceAbilityFactory from '../casl/abilities/space-ability.factory';
+import {
+  SpaceCaslAction,
+  SpaceCaslSubject,
+} from '../casl/interfaces/space-ability.type';
+
+
+@UseGuards(JwtAuthGuard)
+@Controller('pages')
+export class WatcherController {
+  constructor(
+    private readonly watcherService: WatcherService,
+    private readonly pageRepo: PageRepo,
+    private readonly spaceAbility: SpaceAbilityFactory,
+  ) {}
+
+  @HttpCode(HttpStatus.OK)
+  @Post('watch')
+  async watchPage(
+    @Body() dto: WatcherPageDto,
+    @AuthUser() user: User,
+    @AuthWorkspace() workspace: Workspace,
+  ) {
+    const page = await this.pageRepo.findById(dto.pageId);
+    if (!page) {
+      throw new NotFoundException('Page not found');
+    }
+
+    const ability = await this.spaceAbility.createForUser(user, page.spaceId);
+    if (ability.cannot(SpaceCaslAction.Read, SpaceCaslSubject.Page)) {
+      throw new ForbiddenException();
+    }
+
+    await this.watcherService.watchPage(
+      user.id,
+      page.id,
+      page.spaceId,
+      workspace.id,
+    );
+
+    return { watching: true };
+  }
+
+  @HttpCode(HttpStatus.OK)
+  @Post('unwatch')
+  async unwatchPage(@Body() dto: WatcherPageDto, @AuthUser() user: User) {
+    const page = await this.pageRepo.findById(dto.pageId);
+    if (!page) {
+      throw new NotFoundException('Page not found');
+    }
+
+    const ability = await this.spaceAbility.createForUser(user, page.spaceId);
+    if (ability.cannot(SpaceCaslAction.Read, SpaceCaslSubject.Page)) {
+      throw new ForbiddenException();
+    }
+
+    await this.watcherService.unwatchPage(user.id, page.id);
+
+    return { watching: false };
+  }
+
+  @HttpCode(HttpStatus.OK)
+  @Post('watch-status')
+  async getWatchStatus(@Body() dto: WatcherPageDto, @AuthUser() user: User) {
+    const page = await this.pageRepo.findById(dto.pageId);
+    if (!page) {
+      throw new NotFoundException('Page not found');
+    }
+
+    const ability = await this.spaceAbility.createForUser(user, page.spaceId);
+    if (ability.cannot(SpaceCaslAction.Read, SpaceCaslSubject.Page)) {
+      throw new ForbiddenException();
+    }
+
+    const watching = await this.watcherService.isWatchingPage(user.id, page.id);
+
+    return { watching };
+  }
+
+}
+***/

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

@@ -0,0 +1,11 @@
+import { Module } from '@nestjs/common';
+import { WatcherService } from './watcher.service';
+import { CaslModule } from '../casl/casl.module';
+
+@Module({
+  imports: [CaslModule],
+  controllers: [],
+  providers: [WatcherService],
+  exports: [WatcherService],
+})
+export class WatcherModule {}

apps/server/src/core/watcher/watcher.service.ts

@@ -0,0 +1,99 @@
+import { Injectable } from '@nestjs/common';
+import {
+  WatcherRepo,
+  WatcherType,
+} from '@docmost/db/repos/watcher/watcher.repo';
+import { PaginationOptions } from '@docmost/db/pagination/pagination-options';
+import { KyselyTransaction } from '@docmost/db/types/kysely.types';
+import { InsertableWatcher } from '@docmost/db/types/entity.types';
+
+@Injectable()
+export class WatcherService {
+  constructor(private readonly watcherRepo: WatcherRepo) {}
+
+  async watchPage(
+    userId: string,
+    pageId: string,
+    spaceId: string,
+    workspaceId: string,
+    trx?: KyselyTransaction,
+  ) {
+    const watcher: InsertableWatcher = {
+      userId,
+      pageId,
+      spaceId,
+      workspaceId,
+      type: WatcherType.PAGE,
+      addedById: userId,
+    };
+    return this.watcherRepo.upsert(watcher, trx);
+  }
+
+  async addPageWatchers(
+    userIds: string[],
+    pageId: string,
+    spaceId: string,
+    workspaceId: string,
+    trx?: KyselyTransaction,
+  ) {
+    if (userIds.length === 0) return;
+
+    const watchers: InsertableWatcher[] = userIds.map((userId) => ({
+      userId,
+      pageId,
+      spaceId,
+      workspaceId,
+      type: WatcherType.PAGE,
+      addedById: userId,
+    }));
+
+    return this.watcherRepo.insertMany(watchers, trx);
+  }
+
+  async unwatchPage(userId: string, pageId: string) {
+    return this.watcherRepo.mute(userId, pageId);
+  }
+
+  async isWatchingPage(userId: string, pageId: string): Promise<boolean> {
+    return this.watcherRepo.isWatching(userId, pageId);
+  }
+
+  async getPageWatchers(pageId: string, pagination: PaginationOptions) {
+    return this.watcherRepo.findPageWatchers(pageId, pagination);
+  }
+
+  async getPageWatcherIds(
+    pageId: string,
+    trx?: KyselyTransaction,
+  ): Promise<string[]> {
+    return this.watcherRepo.getPageWatcherIds(pageId, trx);
+  }
+
+  async countPageWatchers(pageId: string): Promise<number> {
+    return this.watcherRepo.countPageWatchers(pageId);
+  }
+
+  async cleanupOnSpaceAccessChange(
+    userIds: string[],
+    spaceId: string,
+    opts?: { trx?: KyselyTransaction },
+  ): Promise<void> {
+    const { trx } = opts;
+    await this.watcherRepo.deleteByUsersWithoutSpaceAccess(userIds, spaceId, {
+      trx,
+    });
+  }
+
+  async movePageWatchersToSpace(
+    pageIds: string[],
+    spaceId: string,
+    opts?: { trx?: KyselyTransaction },
+  ): Promise<void> {
+    await this.watcherRepo.updateSpaceIdByPageIds(spaceId, pageIds, opts);
+    await this.watcherRepo.deleteByPageIdsWithoutSpaceAccess(
+      pageIds,
+      spaceId,
+      opts,
+    );
+  }
+}