@builder6/rooms 0.9.3 → 0.10.2

package/src/rooms/rooms.controller.ts

@@ -1,5 +1,6 @@
-import { AuthGuard } from '@builder6/core';
+import { AuthGuard, FilesService } from '@builder6/core';
 import { RoomsService } from './rooms.service';
+import { omit, uniqBy } from 'lodash';
 import {
   Controller,
   Get,
@@ -18,9 +19,10 @@ import { JwtService } from '@nestjs/jwt';
 import { RoomsGuard } from './rooms.guard';
 import * as rawBody from 'raw-body';
 import { Request } from 'express';
-import { FilesService } from '@builder6/core';
 import { RoomsGateway } from './rooms.gateway';
 import { ServerMsgCode } from './protocol/ServerMsg';
+import { READ_ACCESS } from './dtos/rooms.dto';
+import { NotificationsService } from './notifications.service';
 
 @Controller('v2/c/')
 export class RoomsController {
@@ -29,6 +31,7 @@ export class RoomsController {
     private filesService: FilesService,
     private jwtService: JwtService,
     private roomsGateway: RoomsGateway,
+    private notificationsService: NotificationsService,
   ) {}
 
   @UseGuards(AuthGuard)
@@ -38,18 +41,12 @@ export class RoomsController {
     @Req() req: Request,
   ) {
     const user = req['user'];
-    const { room = 'undefined', permission = 'read' } = body;
-    let perm = ['room:read'];
-    if (permission === 'write') {
-      perm = ['room:write'];
-    }
-    const perms = {
-      [room]: perm,
-    };
-    return await this.roomsService.getToken({
+    const { room = 'test', permission = 'read' } = body;
+    return await this.roomsService.getRoomToken({
       spaceId: user.space,
       userId: user.user,
-      perms: perms,
+      roomId: room,
+      readonly: permission === 'read',
     });
   }
 
@@ -78,11 +75,18 @@ export class RoomsController {
 
   @UseGuards(RoomsGuard)
   @Get('rooms/:roomId/threads')
-  async getThreads(@Param('roomId') roomId: string) {
+  async getThreads(@Req() req: Request, @Param('roomId') roomId: string) {
     const threads = await this.roomsService.getThreads(roomId);
+    const inboxNotifications =
+      await this.notificationsService.findNotifications({
+        userId: req['jwt'].uid,
+        roomId,
+      });
     return {
       data: threads,
-      inboxNotifications: [],
+      inboxNotifications: inboxNotifications.map((inboxNotification) =>
+        omit(inboxNotification, ['userId', '_id']),
+      ),
       meta: {
         nextCursor: null,
         requestedAt: new Date().toISOString() as string,
@@ -98,14 +102,23 @@ export class RoomsController {
   @UseGuards(RoomsGuard)
   @Get('rooms/:roomId/threads/delta')
   async getThreadsDelta(
+    @Req() req: Request,
     @Param('roomId') roomId: string,
     @Query('since') since: string,
   ) {
     const sinceDate = new Date(since);
     const threads = await this.roomsService.getThreads(roomId, sinceDate);
+    const inboxNotifications =
+      await this.notificationsService.findNotifications({
+        userId: req['jwt'].uid,
+        roomId,
+        sinceDate,
+      });
     return {
       data: threads,
-      inboxNotifications: [],
+      inboxNotifications: inboxNotifications.map((inboxNotification) =>
+        omit(inboxNotification, ['userId', '_id']),
+      ),
       meta: {
         nextCursor: null,
         requestedAt: new Date().toISOString() as string,
@@ -156,7 +169,18 @@ export class RoomsController {
     @Param('threadId') threadId: string,
   ) {
     const thread = await this.roomsService.getThread(roomId, threadId);
-    return { thread };
+    const inboxNotifications =
+      await this.notificationsService.findNotifications({
+        userId: req['jwt'].uid,
+        roomId,
+        threadId,
+      });
+    return {
+      thread,
+      inboxNotification: inboxNotifications[0]
+        ? omit(inboxNotifications[0], ['userId', '_id'])
+        : undefined,
+    };
   }
 
   @UseGuards(RoomsGuard)
@@ -269,7 +293,98 @@ export class RoomsController {
     return {};
   }
 
+  // 获取通知
+  @UseGuards(RoomsGuard)
+  @Get('inbox-notifications')
+  async getInboxNotifications(
+    @Req() req: Request,
+    @Query('unread') unread: string,
+    @Query('limit') limit: string,
+  ) {
+    const userId = req['jwt'].uid;
+    const requestedAt = new Date();
+    const notifications = await this.notificationsService.findNotifications({
+      userId,
+      unread: unread === 'true',
+      limit: Number(limit),
+    });
+    const threads = await this.roomsService.getThreadsByIds(
+      uniqBy(
+        notifications,
+        (notification) => `${notification.roomId}-${notification.threadId}`,
+      ),
+    );
+    return {
+      inboxNotifications: notifications.map((notification) =>
+        omit(notification, ['userId', '_id']),
+      ),
+      threads,
+      meta: {
+        nextCursor: null,
+        requestedAt,
+      },
+      deletedThreads: [],
+      deletedInboxNotifications: [],
+    };
+  }
+
+  // 获取增量通知
+  @UseGuards(RoomsGuard)
+  @Get('inbox-notifications/delta')
+  async getInboxNotificationsSince(
+    @Req() req: Request,
+    @Query('since') since: string,
+  ) {
+    const userId = req['jwt'].uid;
+    const sinceDate = new Date(since);
+    const requestedAt = new Date();
+    const notifications = await this.notificationsService.findNotifications({
+      userId,
+      sinceDate,
+    });
+    const threads = await this.roomsService.getThreadsByIds(
+      uniqBy(
+        notifications,
+        (notification) => `${notification.roomId}-${notification.threadId}`,
+      ),
+    );
+    return {
+      inboxNotifications: notifications.map((notification) =>
+        omit(notification, ['userId', '_id']),
+      ),
+      threads,
+      meta: { requestedAt },
+      deletedThreads: [],
+      deletedInboxNotifications: [],
+    };
+  }
+
+  // read
+  @UseGuards(RoomsGuard)
+  @Post('rooms/:roomId/inbox-notifications/read')
+  async read(
+    @Req() req: Request,
+    @Param('roomId') roomId: string,
+    @Body('inboxNotificationIds') inboxNotificationIds: string[],
+  ) {
+    const userId = req['jwt'].uid;
+    const notifications = await this.notificationsService.markAsRead(
+      roomId,
+      userId,
+      inboxNotificationIds,
+    );
+    return {
+      data:
+        notifications?.length > 0
+          ? notifications.map((notification) =>
+              omit(notification, ['userId', '_id']),
+            )
+          : undefined,
+    };
+  }
+
   // 获取下载Url
+  @UseGuards(RoomsGuard)
   @Post('rooms/:roomId/attachments/presigned-urls')
   async presignedUrls(@Body('attachmentIds') attachmentIds: string[]) {
     const urls = await Promise.all(
@@ -284,6 +399,7 @@ export class RoomsController {
   }
 
   // 上传文件
+  @UseGuards(RoomsGuard)
   @Put('rooms/:roomId/attachments/:attachmentId/upload/:fileName')
   async uploadFile(
     @Param('roomId') roomId: string,

package/src/rooms/rooms.gateway.ts

@@ -11,6 +11,7 @@ import * as url from 'url';
 import { v4 as uuidv4 } from 'uuid';
 import { ServerMsgCode, ServerMsg } from './protocol/ServerMsg';
 import { JwtService } from '@nestjs/jwt';
+import { RoomsService } from './rooms.service';
 
 interface RoomState {
   roomId: string;
@@ -37,7 +38,10 @@ export class RoomsGateway implements OnGatewayConnection {
   private redis: Redis;
   private pubRedis: Redis;
 
-  constructor(private jwtService: JwtService) {
+  constructor(
+    private jwtService: JwtService,
+    private roomsService: RoomsService,
+  ) {
     this.redis = new Redis('redis://localhost:6379');
     this.pubRedis = new Redis('redis://localhost:6379');
   }
@@ -113,6 +117,12 @@ export class RoomsGateway implements OnGatewayConnection {
     payload: { roomId: string; userId: string },
   ) {
     const { roomId, userId } = payload;
+
+    const room = await this.roomsService.getRoom(roomId);
+    if (!room) {
+      throw new Error('Room not found');
+    }
+
     let roomState = this.roomStates.get(roomId);
 
     if (!roomState) {
@@ -142,11 +152,14 @@ export class RoomsGateway implements OnGatewayConnection {
       Object.keys(roomState.connections).map(async (connId) => {
         const connection = roomState.connections[parseInt(connId)];
         const roomId = connection.roomId;
-        const scopes = await this.getUserScopes(roomId, connection.userId);
+        const member = await this.roomsService.getRoomMember(
+          roomId,
+          connection.userId,
+        );
         return {
           connectionId: parseInt(connId),
           userId: connection.userId,
-          scopes,
+          scopes: member.scopes,
         };
       }),
     );
@@ -155,7 +168,7 @@ export class RoomsGateway implements OnGatewayConnection {
       type: ServerMsgCode.ROOM_STATE, // 使用 ServerMsgCode 枚举
       actor: connectionId,
       nonce: nonce,
-      scopes: await this.getUserScopes(roomId, userId),
+      scopes: room.defaultScopes,
       users: users.reduce(
         (acc, user) => {
           acc[user.connectionId] = {

package/src/rooms/rooms.guard.ts

@@ -10,7 +10,7 @@ import { JwtService } from '@nestjs/jwt';
 @Injectable()
 export class RoomsGuard implements CanActivate {
   constructor(
-    private roomsService: RoomsService,
+    // private roomsService: RoomsService,
     private jwtService: JwtService,
   ) {}
 

package/src/rooms/rooms.module.ts

@@ -6,6 +6,10 @@ import { JwtModule } from '@nestjs/jwt';
 import { AuthModule } from '@builder6/core';
 import { RoomsGateway } from './rooms.gateway';
 import { FilesModule } from '@builder6/core';
+import { PagesModule } from '@builder6/pages';
+import { NotificationsService } from './notifications.service';
+import { RoomsAppController } from './app.controller';
+import { RoomsMoleculer } from './rooms.moleculer';
 
 /* 按照 liveblocks.io 规范实现的API */
 @Module({
@@ -13,12 +17,13 @@ import { FilesModule } from '@builder6/core';
     AuthModule,
     MongodbModule,
     FilesModule,
+    PagesModule,
     JwtModule.register({
       secret: process.env.B6_JWT_SECRET || 'secret',
       signOptions: { expiresIn: '60s' },
     }),
   ],
-  controllers: [RoomsController],
-  providers: [RoomsService, RoomsGateway],
+  controllers: [RoomsAppController, RoomsController],
+  providers: [RoomsService, RoomsGateway, NotificationsService, RoomsMoleculer],
 })
 export class RoomsModule {}

package/src/rooms/rooms.moleculer.ts

@@ -0,0 +1,78 @@
+import { Service, Context, ServiceBroker } from 'moleculer';
+import { Injectable } from '@nestjs/common';
+import { InjectBroker } from '@builder6/moleculer';
+import { RoomsService } from './rooms.service';
+
+@Injectable()
+export class RoomsMoleculer extends Service {
+  constructor(
+    private readonly roomsService: RoomsService,
+    @InjectBroker() broker: ServiceBroker,
+  ) {
+    super(broker);
+
+    this.parseServiceSchema({
+      name: '@builder6/rooms',
+      settings: {},
+      actions: {
+        createComment: this.createComment,
+        createThread: this.createThread,
+      },
+      created: this.serviceCreated,
+      started: this.serviceStarted,
+      stopped: this.serviceStopped,
+    });
+  }
+
+  serviceCreated() {}
+
+  async serviceStarted() {}
+
+  async serviceStopped() {}
+
+  async createThread(ctx: Context) {
+    const { id, comment, metadata, resolved, roomId, userId } =
+      ctx.params as any;
+    try {
+      const result = this.roomsService.createThread({
+        id,
+        comment,
+        metadata,
+        resolved,
+        roomId,
+        userId,
+      });
+      return result;
+    } catch (error) {
+      console.error(error);
+      return {
+        error: {
+          message: error.message,
+        },
+      };
+    }
+  }
+
+  async createComment(ctx: Context) {
+    const { id, attachmentIds, body, roomId, threadId, userId } =
+      ctx.params as any;
+    try {
+      const result = this.roomsService.createComment({
+        id,
+        attachmentIds,
+        body,
+        roomId,
+        threadId,
+        userId,
+      });
+      return result;
+    } catch (error) {
+      console.error(error);
+      return {
+        error: {
+          message: error.message,
+        },
+      };
+    }
+  }
+}

package/src/rooms/rooms.service.ts

@@ -1,6 +1,12 @@
 import { MongodbService } from '@builder6/core';
 import { JwtService } from '@nestjs/jwt';
 import { Injectable } from '@nestjs/common';
+import { READ_ACCESS, RoomDTO } from './dtos/rooms.dto';
+import { RoomMemberDTO } from './dtos/room_members.dto';
+import { uniq } from 'lodash';
+import { NotificationsService } from './notifications.service';
+import { v4 as uuidv4 } from 'uuid';
+import { CommentBody, CommentBodyMention } from './protocol/Comments';
 
 export interface CreateThreadParams {
   id?: string;
@@ -28,17 +34,23 @@ export interface Attachment {
   type: string;
 }
 
+export enum CommentType {
+  Paragraph = 'paragraph',
+}
+
+export enum CommentBodyInlineType {
+  Mention = 'mention',
+  Link = 'link',
+}
+
 @Injectable()
 export class RoomsService {
   constructor(
     private mongodbService: MongodbService,
     private jwtService: JwtService,
+    private notificationsService: NotificationsService,
   ) {}
 
-  async getRoom(roomId: string) {
-    return { _id: roomId };
-  }
-
   async getToken({
     spaceId,
     userId,
@@ -54,14 +66,52 @@ export class RoomsService {
       sid: spaceId,
       uid: userId,
       mcpr: 10,
-      perms: {},
+      perms: perms,
       jti: 'S4EMiESTDe6k',
     };
-    payload.perms = perms || {};
     const token = await this.jwtService.signAsync(payload);
     return { token };
   }
 
+  async getRoomToken({
+    roomId,
+    spaceId,
+    userId,
+    readonly = false,
+  }: {
+    roomId: string;
+    spaceId: string;
+    userId: string;
+    readonly: boolean;
+  }) {
+    let room = await this.getRoom(roomId);
+    if (!room) {
+      room = await this.createRoom({
+        _id: roomId,
+        name: 'Room ' + roomId,
+      });
+    }
+
+    let member = await this.getRoomMember(roomId, userId);
+    if (!member) {
+      member = await this.createRoomMember(room, {
+        userId,
+      });
+    }
+
+    const scopes = readonly ? READ_ACCESS : member.scopes;
+
+    const perms = {
+      [roomId]: scopes,
+    };
+
+    return await this.getToken({
+      spaceId,
+      userId,
+      perms,
+    });
+  }
+
   async getAttachmentById(attachmentId: string): Promise<Attachment> {
     // 模拟从数据库获取附件
     // 实际实现中应替换为数据库查询
@@ -147,6 +197,30 @@ export class RoomsService {
     return threads;
   }
 
+  async getThreadsByIds(
+    notifications: {
+      id: string;
+      userId: string;
+      kind: string;
+      notifiedAt?: Date;
+      readAt?: Date;
+      roomId: string;
+      threadId: string;
+    }[],
+  ) {
+    const threadPromises = [];
+    for (let i = 0; i < notifications.length; i++) {
+      const notification = notifications[i];
+      threadPromises.push(
+        this.getThread(notification.roomId, notification.threadId),
+      );
+    }
+    if (threadPromises.length > 0) {
+      return Promise.all(threadPromises);
+    }
+    return [];
+  }
+
   async getComments(roomId: string, threadId: string) {
     const comments = await this.mongodbService.find('b6_comments', {
       roomId: roomId,
@@ -245,6 +319,35 @@ export class RoomsService {
       result.attachments.push(attachment);
     }
 
+    // 如果有 @ mention 的时候，自动创建 b6_notifications 记录。
+    const { content } = body as CommentBody;
+    let notificationsPromises: Promise<any>[];
+    const mentionUsers: string[] = [];
+    for (const message of content) {
+      if (message.type === CommentType.Paragraph) {
+        message.children
+          .filter(
+            (child: CommentBodyMention) =>
+              child?.type === CommentBodyInlineType.Mention,
+          )
+          .forEach((child: CommentBodyMention) => mentionUsers.push(child.id));
+      }
+    }
+    if (mentionUsers && mentionUsers.length > 0) {
+      notificationsPromises = uniq(mentionUsers).map((userId) => {
+        return this.notificationsService.createThreadNotification({
+          _id: uuidv4(),
+          id: uuidv4(),
+          userId,
+          kind: 'thread',
+          notifiedAt: new Date(),
+          readAt: null,
+          roomId,
+          threadId,
+        });
+      });
+      await Promise.all(notificationsPromises);
+    }
     delete result['_id'];
     delete result['attachmentIds'];
     return result;
@@ -387,4 +490,105 @@ export class RoomsService {
 
     return null;
   }
+
+  async createRoom({
+    _id,
+    name,
+    description = '',
+    membershipType = 'standard',
+    members = [],
+    defaultNotifications = ['replies', 'mentions'],
+    defaultScopes = ['room:write'],
+  }: RoomDTO): Promise<RoomDTO> {
+    const newRoom = {
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+      _id,
+      name,
+      description,
+      membershipType,
+      defaultNotifications,
+      defaultScopes,
+    };
+
+    const room = await this.mongodbService.insertOne('b6_rooms', newRoom);
+
+    // 循环 members，执行 createRoomMember，并保存到 result.members
+    room.members = [];
+    for (const member of members) {
+      const newMember = await this.createRoomMember(room, member);
+      room.members.push(newMember);
+    }
+
+    return room;
+  }
+
+  async createRoomMember(room: RoomDTO, member: RoomMemberDTO) {
+    const {
+      _id,
+      userId,
+      roles = [],
+      notifications = room.defaultNotifications,
+      scopes = room.defaultScopes,
+    } = member;
+    const newMember = {
+      _id,
+      userId,
+      roles,
+      roomId: room._id,
+      notifications,
+      scopes,
+      createdAt: new Date().toISOString(),
+    };
+
+    const result = await this.mongodbService.insertOne(
+      'b6_room_members',
+      newMember,
+    );
+    return result;
+  }
+
+  async getRoom(roomId: string) {
+    const room = await this.mongodbService.findOne('b6_rooms', {
+      _id: roomId,
+    });
+
+    if (!room) {
+      return null;
+    }
+
+    room.members = await this.getRoomMembers(roomId);
+    return room;
+  }
+
+  async getRoomMembers(roomId: string) {
+    const members = await this.mongodbService.find('b6_room_members', {
+      roomId,
+    });
+
+    return members;
+  }
+
+  async getRoomMember(roomId: string, userId: string) {
+    const member = await this.mongodbService.findOne('b6_room_members', {
+      roomId,
+      userId,
+    });
+
+    return member;
+  }
+
+  async getMyRooms(userId: string) {
+    const roomMembers = await this.mongodbService.find('b6_room_members', {
+      userId,
+    });
+
+    const rooms = [];
+    for (const roomMember of roomMembers) {
+      const room = await this.getRoom(roomMember.roomId);
+      rooms.push(room);
+    }
+
+    return rooms;
+  }
 }

package/.eslintrc.js

@@ -1,25 +0,0 @@
-module.exports = {
-  parser: '@typescript-eslint/parser',
-  parserOptions: {
-    project: 'tsconfig.json',
-    tsconfigRootDir: __dirname,
-    sourceType: 'module',
-  },
-  plugins: ['@typescript-eslint/eslint-plugin'],
-  extends: [
-    'plugin:@typescript-eslint/recommended',
-    'plugin:prettier/recommended',
-  ],
-  root: true,
-  env: {
-    node: true,
-    jest: true,
-  },
-  ignorePatterns: ['.eslintrc.js'],
-  rules: {
-    '@typescript-eslint/interface-name-prefix': 'off',
-    '@typescript-eslint/explicit-function-return-type': 'off',
-    '@typescript-eslint/explicit-module-boundary-types': 'off',
-    '@typescript-eslint/no-explicit-any': 'off',
-  },
-};