@builder6/rooms 3.0.4 → 3.0.6

package/src/rooms/rooms.service.ts

@@ -1,723 +0,0 @@
-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 { isArray, 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;
-  comment?: CreateCommentParams;
-  metadata?: object;
-  resolved?: boolean;
-  roomId?: string;
-  userId?: string;
-  participantIds?: string[];
-  space?: string;
-}
-
-export interface CreateCommentParams {
-  id?: string;
-  attachmentIds: string[];
-  body: object;
-  roomId?: string;
-  threadId?: string;
-  userId?: string;
-  space?: string;
-}
-
-export interface Attachment {
-  id: string;
-  mimeType: string;
-  name: string;
-  size: number;
-  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 getToken({
-    spaceId,
-    userId,
-    perms,
-  }: {
-    spaceId: string;
-    userId: string;
-    perms: object;
-  }) {
-    const payload = {
-      k: 'acc',
-      pid: spaceId,
-      sid: spaceId,
-      uid: userId,
-      mcpr: 10,
-      perms: perms,
-      jti: 'S4EMiESTDe6k',
-    };
-    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,
-      });
-    }
-
-    // 如果当前用户不在 room 中，创建一个 room member
-    let member = await this.getRoomMember(roomId, userId);
-    if (!member) {
-      member = await this.createRoomMember({
-        userId,
-        roomId,
-        notifications: room.defaultNotifications,
-        scopes: room.defaultScopes,
-      });
-    }
-
-    const scopes = readonly ? READ_ACCESS : member.scopes;
-
-    const perms = {
-      [roomId]: scopes,
-    };
-
-    return await this.getToken({
-      spaceId,
-      userId,
-      perms,
-    });
-  }
-
-  async getAttachmentById(attachmentId: string): Promise<Attachment> {
-    // 模拟从数据库获取附件
-    // 实际实现中应替换为数据库查询
-    const attachment = await this.mongodbService.findOne(
-      'cfs.files.filerecord',
-      {
-        _id: attachmentId,
-      },
-    );
-    if (attachment === null) {
-      return null;
-    }
-    return {
-      id: attachmentId,
-      mimeType: attachment.original.type,
-      name: attachment.original.name,
-      size: attachment.original.size,
-      type: 'attachment',
-    };
-  }
-
-  async resolveUsers({ userIds }: { userIds: string[] }) {
-    const users = [];
-
-    for (const userId of userIds) {
-      const user = await this.mongodbService.findOne(
-        'users',
-        {
-          _id: userId,
-        },
-        {
-          projection: {
-            name: 1,
-          },
-        },
-      );
-      users.push({
-        name: user ? user.name : 'Unknown',
-        avatar: `${process.env.B6_HOST}/api/v6/users/${userId}/avatar`,
-      });
-    }
-
-    return users;
-  }
-
-  // 按照 email, name, username 搜索用户, 返回 userId 数组
-  async searchUsers(spaceId: string, keyword: string): Promise<string[]> {
-    let query: any = {
-      space: spaceId,
-    };
-    if (keyword) {
-      query = {
-        space: spaceId,
-        $or: [
-          { username: { $regex: keyword, $options: 'i' } },
-          { email: { $regex: keyword, $options: 'i' } },
-          { name: { $regex: keyword, $options: 'i' } },
-        ],
-      };
-    }
-    // 最多返回5行
-    const spaceUsers = await this.mongodbService.find('space_users', query, {
-      limit: 5,
-      projection: {
-        name: 1,
-        user: 1,
-      },
-    });
-
-    return spaceUsers.map((spaceUser) => spaceUser.user as string);
-  }
-
-  async getThread({ roomId, threadId }: { roomId: string; threadId: string }) {
-    const thread = await this.mongodbService.findOne('b6_threads', {
-      roomId: roomId,
-      _id: threadId,
-    });
-
-    if (!thread) {
-      return null;
-    }
-
-    const comments = await this.getComments(roomId, threadId);
-    thread.comments = comments;
-    return thread;
-  }
-
-  async getThreads(roomId: string, since?: Date) {
-    const queryOptions = { roomId: roomId } as any;
-    if (since) {
-      queryOptions.updatedAt = { $gt: since };
-    }
-    const threads = await this.mongodbService.find('b6_threads', queryOptions);
-
-    for (const thread of threads) {
-      const comments = await this.getComments(roomId, thread.id);
-      thread.comments = comments;
-    }
-    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({
-          roomId: notification.roomId,
-          threadId: 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,
-      threadId: threadId,
-    });
-
-    for (const comment of comments) {
-      comment.attachments = [];
-      if (isArray(comment.attachmentIds)) {
-        for (const attachmentId of comment.attachmentIds) {
-          const attachment = await this.getAttachmentById(attachmentId);
-          if (attachment) {
-            comment.attachments.push(attachment);
-          }
-        }
-      }
-    }
-    return comments;
-  }
-
-  async createThread({
-    id = uuidv4(),
-    comment,
-    metadata,
-    resolved = false,
-    roomId,
-    userId,
-    space
-  }: CreateThreadParams) {
-    const newThread = {
-      createdAt: new Date().toISOString(),
-      updatedAt: new Date().toISOString(),
-      _id: id,
-      id,
-      resolved,
-      metadata,
-      type: 'thread',
-      roomId,
-      userId,
-      participantIds: [userId],
-    };
-
-    const result = await this.mongodbService.insertOne('b6_threads', newThread);
-
-    const newComment = await this.createComment({
-      id: comment.id || uuidv4(),
-      attachmentIds: comment.attachmentIds,
-      body: comment.body,
-      roomId,
-      threadId: id,
-      userId,
-      space,
-    });
-    result.comments = [newComment];
-
-    return result;
-  }
-
-  async updateThread(threadId, thread?: CreateThreadParams) {
-    const newThread = {
-      updatedAt: new Date().toISOString(),
-      ...thread,
-    };
-
-    const result = await this.mongodbService.findOneAndUpdateData(
-      'b6_threads',
-      { _id: threadId },
-      newThread,
-    );
-
-    return result;
-  }
-
-  async createComment({
-    id,
-    attachmentIds,
-    body,
-    roomId,
-    threadId,
-    userId,
-    space,
-  }: CreateCommentParams) {
-    const newComment = {
-      createdAt: new Date().toISOString(),
-      _id: id,
-      id,
-      reactions: [],
-      roomId,
-      threadId,
-      userId,
-      type: 'comment',
-      attachmentIds,
-      body,
-      space,
-    };
-
-    const result = await this.mongodbService.insertOne(
-      'b6_comments',
-      newComment,
-    );
-    result.attachments = [];
-
-    for (const attachmentId of attachmentIds) {
-      const attachment = await this.getAttachmentById(attachmentId);
-      if (attachment) {
-        result.attachments.push(attachment);
-      } else {
-        throw new Error(`Attachment not found ${attachmentId}`);
-      }
-    }
-
-    // 如果有 @ mention 的时候，自动创建 b6_inbox_notifications 记录。
-    const { content } = body as CommentBody;
-    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));
-      }
-    }
-
-    // Update Thread participantIds
-    const thread = await this.getThread({ roomId, threadId });
-    if (thread) {
-      thread.participantIds = uniq(
-        (thread.participantIds || []).concat([userId]).concat(mentionUsers),
-      );
-      // participantIds 取唯一值并保存到 thread
-      await this.updateThread(threadId, {
-        participantIds: thread.participantIds,
-      });
-    }
-
-    let onThreadMentionPromises: Promise<any>[];
-    if (mentionUsers && mentionUsers.length > 0) {
-      const uniqUsers = uniq(mentionUsers).filter(
-        (mentionedUserId) => mentionedUserId !== userId,
-      );
-      onThreadMentionPromises = uniqUsers.map((mentionedUserId) => {
-        return this.notificationsService.onThreadNotification({
-          userId: mentionedUserId,
-          roomId,
-          fromUserId: userId,
-          threadId,
-          type: 'mention',
-          spaceId: space,
-        });
-      });
-      await Promise.all([].concat(onThreadMentionPromises));
-    }
-
-    const participantIds = thread.participantIds.filter((participantUserId) => {
-      return (
-        participantUserId !== userId &&
-        !mentionUsers.includes(participantUserId)
-      );
-    });
-    const onThreadReplyPromises: Promise<any>[] = participantIds.map(
-      (participantUserId) => {
-        return this.notificationsService.onThreadNotification({
-          userId: participantUserId,
-          roomId,
-          fromUserId: userId,
-          threadId,
-          type: 'reply',
-          spaceId: space,
-        });
-      },
-    );
-    await Promise.all([].concat(onThreadReplyPromises));
-
-    delete result['_id'];
-    delete result['attachmentIds'];
-    return result;
-  }
-
-  async updateComment(
-    commentId,
-    { attachmentIds, body, userId }: CreateCommentParams,
-  ) {
-    const newComment = {
-      updatedAt: new Date().toISOString(),
-      type: 'comment',
-      attachmentIds,
-      body,
-      userId,
-    };
-
-    const result = (await this.mongodbService.findOneAndUpdateData(
-      'b6_comments',
-      { _id: commentId },
-      newComment,
-    )) as any;
-    result.attachments = [];
-
-    for (const attachmentId of attachmentIds) {
-      const attachment = await this.getAttachmentById(attachmentId);
-      if (attachment) {
-        result.attachments.push(attachment);
-      } else {
-        throw new Error(`Attachment not found ${attachmentId}`);
-      }
-    }
-
-    delete result['_id'];
-    delete result['attachmentIds'];
-    return result;
-  }
-
-  async deleteComment(commentId) {
-    // TODO: 应该先删除附件。
-
-    const result = await this.mongodbService.deleteOne('b6_comments', {
-      _id: commentId,
-    });
-
-    return result;
-  }
-
-  /* 评论点赞 
-  保存在 comments 中，格式如下： 
-  comment: {
-    _id,
-    reactions: [
-      {
-          "emoji": "🥵",
-          "createdAt": "2024-12-05T01:49:22.395Z",
-          "users": [
-              {
-                  "id": "user-5"
-              }
-              {
-                  "id": "user-6"
-              }
-          ]
-      },
-    ]
-    reactions 数组中的每个元素表示一个用户的点赞，其中 emoji 为表情，createdAt 为点赞时间，users 为点赞用户列表。
-    创建时，如果 reactions 中已经有相同 emoji 的点赞，则直接添加到 users 中，否则创建一个新的点赞。
-  }
-  */ async createReaction(
-    commentId: string,
-    { userId, emoji }: { userId: string; emoji: string },
-  ) {
-    const comment = await this.mongodbService.findOne('b6_comments', {
-      _id: commentId,
-    });
-    if (!comment) {
-      throw new Error('Comment not found');
-    }
-
-    // 查找是否已经存在相同 emoji 的 reaction
-    let reaction = comment.reactions.find(
-      (reaction) => reaction.emoji === emoji,
-    );
-    if (reaction) {
-      // 如果存在，检查用户是否已经点赞，避免重复添加
-      const userExists = reaction.users.some((user) => user.id === userId);
-      if (!userExists) {
-        reaction.users.push({ id: userId });
-      }
-    } else {
-      // 如果不存在，创建新的 reaction 并推入 reactions 数组
-      reaction = {
-        emoji,
-        createdAt: new Date().toISOString(),
-        users: [{ id: userId }],
-      };
-      comment.reactions.push(reaction);
-    }
-
-    // 更新数据库
-    await this.mongodbService.findOneAndUpdateData(
-      'b6_comments',
-      { _id: commentId },
-      comment,
-    );
-
-    return {
-      emoji,
-      createdAt: reaction.createdAt,
-      userId,
-    };
-  }
-
-  async deleteReaction(
-    commentId: string,
-    { userId, emoji }: { userId: string; emoji: string },
-  ) {
-    const comment = await this.mongodbService.findOne('b6_comments', {
-      _id: commentId,
-    });
-    if (!comment) {
-      throw new Error('Comment not found');
-    }
-
-    const reaction = comment.reactions.find(
-      (reaction) => reaction.emoji === emoji,
-    );
-    if (!reaction) {
-      throw new Error('Reaction not found');
-    }
-
-    reaction.users = reaction.users.filter((user) => user.id !== userId);
-
-    comment.reactions = comment.reactions.filter(
-      (reaction) => reaction.users.length > 0,
-    );
-
-    await this.mongodbService.findOneAndUpdateData(
-      'b6_comments',
-      { _id: commentId },
-      comment,
-    );
-
-    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({
-        notifications: room.defaultNotifications,
-        scopes: room.defaultScopes,
-        ...member,
-      });
-      room.members.push(newMember);
-    }
-
-    return room;
-  }
-
-  async createRoomMember(member: RoomMemberDTO) {
-    const { _id, userId, roomId, roles = [], notifications, scopes } = member;
-    const newMember = {
-      _id,
-      userId,
-      roles,
-      roomId,
-      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;
-  }
-
-  async resolveRoomsInfo({ roomIds }: { roomIds: string[] }) {
-    const result = [];
-    for (const roomId of roomIds) {
-      const room = await this.resolveRoomInfo({ roomId });
-      result.push(room);
-    }
-
-    return result;
-  }
-
-  async resolveRoomInfo({ roomId }: { roomId: string }) {
-    if (
-      roomId &&
-      roomId.split(':').length === 3 &&
-      roomId.split(':')[0] === 'objects'
-    ) {
-      const [, objectName, recordId] = roomId.split(':');
-      const record = await this.mongodbService.findOne(
-        objectName,
-        {
-          _id: recordId,
-        },
-        {
-          projection: {
-            name: 1,
-          },
-        },
-      );
-
-      return {
-        id: roomId,
-        name: record ? record.name : roomId,
-        url: record
-          ? `${process.env.B6_ROOT_URL}/app/-/${objectName}/view/${recordId}`
-          : null,
-      };
-    } else {
-      return {
-        id: roomId,
-        name: roomId,
-        url: `${process.env.B6_HOST}/b6/rooms/${roomId}`,
-      };
-    }
-  }
-
-  async getInboxNotification({ inboxNotificationId, userId }) {
-    const notification = await this.notificationsService.getInboxNotification({
-      inboxNotificationId,
-      userId,
-    });
-    return notification;
-  }
-}

package/tsconfig.json

@@ -1,10 +0,0 @@
-{
-  "extends": "../../tsconfig.json",
-  "compilerOptions": {
-    "jsx": "react",
-    "target": "es6",
-    "outDir": "./dist",
-    "rootDir": "./src"
-  },
-  "exclude": ["node_modules", "test", "dist", "**/*spec.ts"]
-}