@builder6/rooms 0.10.8 → 0.11.1

package/src/rooms/emails/thread-notification.tsx

@@ -0,0 +1,583 @@
+import type {
+  BaseRoomInfo,
+  BaseUserMeta,
+  CommentBody,
+  CommentData,
+  DRI,
+  DU,
+  InboxNotificationData,
+  OptionalPromise,
+  ResolveUsersArgs,
+} from "@liveblocks/core";
+import {
+  generateCommentUrl,
+  getMentionedIdsFromCommentBody,
+} from "@liveblocks/core";
+import type { Liveblocks, ThreadNotificationEvent } from "@liveblocks/node";
+import type React from "react";
+
+import type {
+  ConvertCommentBodyAsHtmlStyles,
+  ConvertCommentBodyAsReactComponents,
+} from "./comment-body";
+import {
+  convertCommentBodyAsHtml,
+  convertCommentBodyAsReact,
+} from "./comment-body";
+import type { CommentDataWithBody } from "./comment-with-body";
+import { filterCommentsWithBody } from "./comment-with-body";
+import { createBatchUsersResolver } from "./lib/batch-users-resolver";
+
+/** @internal */
+export const getUnreadComments = ({
+  comments,
+  inboxNotification,
+  userId,
+}: {
+  comments: CommentData[];
+  inboxNotification: InboxNotificationData;
+  userId: string;
+}): CommentDataWithBody[] => {
+  const commentsWithBody = filterCommentsWithBody(comments);
+  const readAt = inboxNotification.readAt;
+
+  return commentsWithBody
+    // .filter((c) => c.userId !== userId)
+    // .filter((c) =>
+    //   readAt
+    //     ? c.createdAt > readAt && c.createdAt <= inboxNotification.notifiedAt
+    //     : c.createdAt <= inboxNotification.notifiedAt
+    // );
+};
+
+/** @internal */
+export const getLastUnreadCommentWithMention = ({
+  comments,
+  mentionedUserId,
+}: {
+  comments: CommentDataWithBody[];
+  mentionedUserId: string;
+}): CommentDataWithBody | null => {
+  return (
+    Array.from(comments)
+      .reverse()
+      .filter((c) => c.userId !== mentionedUserId)
+      .find((c) => {
+        const mentionedUserIds = getMentionedIdsFromCommentBody(c.body);
+        return mentionedUserIds.includes(mentionedUserId);
+      }) ?? null
+  );
+};
+
+export type ThreadNotificationData =
+  | { type: "unreadMention"; comment: CommentDataWithBody }
+  | { type: "unreadReplies"; comments: CommentDataWithBody[] };
+
+/** @internal */
+export const extractThreadNotificationData = async ({
+  client,
+  event,
+}: {
+  client: Liveblocks;
+  event: ThreadNotificationEvent;
+}): Promise<ThreadNotificationData | null> => {
+  const { threadId, roomId, userId, inboxNotificationId } = event.data;
+  const [thread, inboxNotification] = await Promise.all([
+    client.getThread({ roomId, threadId }),
+    client.getInboxNotification({ inboxNotificationId, userId }),
+  ]);
+
+  const unreadComments = getUnreadComments({
+    comments: thread.comments,
+    inboxNotification,
+    userId,
+  });
+
+  if (unreadComments.length <= 0) {
+    return null;
+  }
+
+  const lastUnreadCommentWithMention = getLastUnreadCommentWithMention({
+    comments: unreadComments,
+    mentionedUserId: userId,
+  });
+  if (lastUnreadCommentWithMention !== null) {
+    return { type: "unreadMention", comment: lastUnreadCommentWithMention };
+  }
+
+  return {
+    type: "unreadReplies",
+    comments: unreadComments,
+  };
+};
+
+export type CommentEmailBaseData = {
+  id: string;
+  threadId: string;
+  roomId: string;
+  userId: string;
+  createdAt: Date;
+  url?: string;
+  rawBody: CommentBody;
+};
+
+export type ResolveRoomInfoArgs = {
+  /**
+   * The ID of the room to resolve
+   */
+  roomId: string;
+};
+
+type PrepareThreadNotificationEmailBaseDataOptions = {
+  /**
+   * A function that returns room info from room IDs.
+   */
+  resolveRoomInfo?: (
+    args: ResolveRoomInfoArgs
+  ) => OptionalPromise<DRI | undefined>;
+};
+
+export type ThreadNotificationEmailBaseData = (
+  | { type: "unreadMention"; comment: CommentEmailBaseData }
+  | { type: "unreadReplies"; comments: CommentEmailBaseData[] }
+) & { roomInfo: DRI };
+
+/** @internal */
+export const makeCommentEmailBaseData = ({
+  roomInfo,
+  comment,
+}: {
+  roomInfo: BaseRoomInfo | undefined;
+  comment: CommentDataWithBody;
+}): CommentEmailBaseData => {
+  const url = roomInfo?.url
+    ? generateCommentUrl({
+        roomUrl: roomInfo?.url,
+        commentId: comment.id,
+      })
+    : undefined;
+
+  return {
+    id: comment.id,
+    userId: comment.userId,
+    threadId: comment.threadId,
+    roomId: comment.roomId,
+    createdAt: comment.createdAt,
+    url,
+    rawBody: comment.body,
+  };
+};
+
+/** @internal */
+export const prepareThreadNotificationEmailBaseData = async ({
+  client,
+  event,
+  options = {},
+}: {
+  client: Liveblocks;
+  event: ThreadNotificationEvent;
+  options?: PrepareThreadNotificationEmailBaseDataOptions;
+}): Promise<ThreadNotificationEmailBaseData | null> => {
+  const { roomId } = event.data;
+
+  const roomInfo = options.resolveRoomInfo
+    ? await options.resolveRoomInfo({ roomId })
+    : undefined;
+  const resolvedRoomInfo: DRI = {
+    ...roomInfo,
+    name: roomInfo?.name ?? roomId,
+  };
+
+  const data = await extractThreadNotificationData({ client, event });
+  if (data === null) {
+    return null;
+  }
+
+  switch (data.type) {
+    case "unreadMention":
+      return {
+        type: "unreadMention",
+        comment: makeCommentEmailBaseData({
+          roomInfo,
+          comment: data.comment,
+        }),
+        roomInfo: resolvedRoomInfo,
+      };
+    case "unreadReplies": {
+      return {
+        type: "unreadReplies",
+        comments: data.comments.map((comment) =>
+          makeCommentEmailBaseData({ roomInfo, comment })
+        ),
+        roomInfo: resolvedRoomInfo,
+      };
+    }
+  }
+};
+
+/** @internal */
+const resolveAuthorsInfo = async <U extends BaseUserMeta>({
+  comments,
+  resolveUsers,
+}: {
+  comments: CommentEmailBaseData[];
+  resolveUsers?: (
+    args: ResolveUsersArgs
+  ) => OptionalPromise<(U["info"] | undefined)[] | undefined>;
+}): Promise<Map<string, U["info"]>> => {
+  const resolvedAuthors = new Map<string, U["info"]>();
+  if (!resolveUsers) {
+    return resolvedAuthors;
+  }
+
+  const userIds = comments.map((c) => c.userId);
+  const users = await resolveUsers({ userIds });
+
+  for (const [index, userId] of userIds.entries()) {
+    const user = users?.[index];
+    if (user) {
+      resolvedAuthors.set(userId, user);
+    }
+  }
+
+  return resolvedAuthors;
+};
+
+export type CommentEmailAsHtmlData<U extends BaseUserMeta = DU> = Omit<
+  CommentEmailBaseData,
+  "userId" | "rawBody"
+> & {
+  author: U;
+  htmlBody: string;
+};
+
+export type CommentEmailAsReactData<U extends BaseUserMeta = DU> = Omit<
+  CommentEmailBaseData,
+  "userId" | "rawBody"
+> & {
+  author: U;
+  reactBody: React.ReactNode;
+};
+
+type ThreadNotificationEmailUnreadRepliesData<
+  U extends BaseUserMeta,
+  C extends CommentEmailAsHtmlData<U> | CommentEmailAsReactData<U>,
+> = {
+  type: "unreadReplies";
+  comments: C[];
+};
+
+type ThreadNotificationEmailUnreadMentionsData<
+  U extends BaseUserMeta,
+  C extends CommentEmailAsHtmlData<U> | CommentEmailAsReactData<U>,
+> = {
+  type: "unreadMention";
+  comment: C;
+};
+
+// Note: export for testing helpers
+export type ThreadNotificationEmailData<
+  U extends BaseUserMeta,
+  C extends CommentEmailAsHtmlData<U> | CommentEmailAsReactData<U>,
+> = (
+  | ThreadNotificationEmailUnreadRepliesData<U, C>
+  | ThreadNotificationEmailUnreadMentionsData<U, C>
+) & { roomInfo: DRI };
+
+export type PrepareThreadNotificationEmailAsHtmlOptions<
+  U extends BaseUserMeta = DU,
+> = PrepareThreadNotificationEmailBaseDataOptions & {
+  /**
+   * A function that returns info from user IDs.
+   */
+  resolveUsers?: (
+    args: ResolveUsersArgs
+  ) => OptionalPromise<(U["info"] | undefined)[] | undefined>;
+  /**
+   * The styles used to customize the html elements in the resulting html safe string inside a comment body.
+   * Each styles has priority over the base styles inherited.
+   */
+  styles?: Partial<ConvertCommentBodyAsHtmlStyles>;
+};
+
+export type ThreadNotificationEmailDataAsHtml = ThreadNotificationEmailData<
+  BaseUserMeta,
+  CommentEmailAsHtmlData
+>;
+
+/**
+ * Prepares data from a `ThreadNotificationEvent` and convert comment bodies as an html safe string.
+ *
+ * @param client The `Liveblocks` node client
+ * @param event The `ThreadNotificationEvent` received in the webhook handler
+ * @param options The optional options to provide to resolve users, resolve room info
+ * and customize comment bodies html elements styles with inline CSS.
+ *
+ * It returns a `ThreadNotificationEmailDataAsHtml` or `null` if there are no unread comments (mention or replies).
+ *
+ * @example
+ * import { Liveblocks} from "@liveblocks/node"
+ * import { prepareThreadNotificationEmailAsHtml } from "@liveblocks/emails"
+ *
+ * const liveblocks = new Liveblocks({ secret: "sk_..." })
+ * const emailData = prepareThreadNotificationEmailAsHtml(
+ *  liveblocks,
+ *  event,
+ *  {
+ *    resolveUsers,
+ *    resolveRoomInfo,
+ *    styles,
+ *  }
+ * )
+ *
+ */
+export async function prepareThreadNotificationEmailAsHtml(
+  client: Liveblocks,
+  event: ThreadNotificationEvent,
+  options: PrepareThreadNotificationEmailAsHtmlOptions<BaseUserMeta> = {}
+): Promise<ThreadNotificationEmailDataAsHtml | null> {
+  const data = await prepareThreadNotificationEmailBaseData({
+    client,
+    event,
+    options: { resolveRoomInfo: options.resolveRoomInfo },
+  });
+
+  if (data === null) {
+    return null;
+  }
+
+  const batchUsersResolver = createBatchUsersResolver<BaseUserMeta>({
+    resolveUsers: options.resolveUsers,
+    callerName: "prepareThreadNotificationEmailAsHtml",
+  });
+
+  switch (data.type) {
+    case "unreadMention": {
+      const { comment } = data;
+
+      const authorsInfoPromise = resolveAuthorsInfo({
+        comments: [comment],
+        resolveUsers: batchUsersResolver.resolveUsers,
+      });
+      const commentBodyPromise = convertCommentBodyAsHtml(comment.rawBody, {
+        resolveUsers: batchUsersResolver.resolveUsers,
+        styles: options.styles,
+      });
+
+      await batchUsersResolver.resolve();
+
+      const [authorsInfo, commentBodyHtml] = await Promise.all([
+        authorsInfoPromise,
+        commentBodyPromise,
+      ]);
+      const authorInfo = authorsInfo.get(comment.userId);
+
+      return {
+        type: "unreadMention",
+        comment: {
+          id: comment.id,
+          threadId: comment.threadId,
+          roomId: comment.roomId,
+          author: authorInfo
+            ? { id: comment.userId, info: authorInfo }
+            : { id: comment.userId, info: { name: comment.userId } },
+          createdAt: comment.createdAt,
+          url: comment.url,
+          htmlBody: commentBodyHtml,
+        },
+        roomInfo: data.roomInfo,
+      };
+    }
+    case "unreadReplies": {
+      const { comments } = data;
+
+      const authorsInfoPromise = resolveAuthorsInfo({
+        comments,
+        resolveUsers: batchUsersResolver.resolveUsers,
+      });
+      const commentBodiesPromises = comments.map((c) =>
+        convertCommentBodyAsHtml(c.rawBody, {
+          resolveUsers: batchUsersResolver.resolveUsers,
+          styles: options.styles,
+        })
+      );
+
+      await batchUsersResolver.resolve();
+
+      const [authorsInfo, ...commentBodies] = await Promise.all([
+        authorsInfoPromise,
+        ...commentBodiesPromises,
+      ]);
+
+      return {
+        type: "unreadReplies",
+        comments: comments.map((comment, index) => {
+          const authorInfo = authorsInfo.get(comment.userId);
+          const commentBodyHtml = commentBodies[index];
+
+          return {
+            id: comment.id,
+            threadId: comment.threadId,
+            roomId: comment.roomId,
+            author: authorInfo
+              ? { id: comment.userId, info: authorInfo }
+              : { id: comment.userId, info: { name: comment.userId } },
+            createdAt: comment.createdAt,
+            url: comment.url,
+            htmlBody: commentBodyHtml ?? "",
+          };
+        }),
+        roomInfo: data.roomInfo,
+      };
+    }
+  }
+}
+
+export type PrepareThreadNotificationEmailAsReactOptions<
+  U extends BaseUserMeta = DU,
+> = PrepareThreadNotificationEmailBaseDataOptions & {
+  /**
+   * A function that returns info from user IDs.
+   */
+  resolveUsers?: (
+    args: ResolveUsersArgs
+  ) => OptionalPromise<(U["info"] | undefined)[] | undefined>;
+  /**
+   * The components used to customize the resulting React nodes inside a comment body.
+   * Each components has priority over the base components inherited internally defined.
+   */
+  components?: Partial<ConvertCommentBodyAsReactComponents<U>>;
+};
+
+export type ThreadNotificationEmailDataAsReact = ThreadNotificationEmailData<
+  BaseUserMeta,
+  CommentEmailAsReactData
+>;
+
+/**
+ * Prepares data from a `ThreadNotificationEvent` and convert comment bodies as React nodes.
+ *
+ * @param client The `Liveblocks` node client
+ * @param event The `ThreadNotificationEvent` received in the webhook handler
+ * @param options The optional options to provide to resolve users, resolve room info and customize comment bodies React components.
+ *
+ * It returns a `ThreadNotificationEmailDataAsReact` or `null` if there are no unread comments (mention or replies).
+ *
+ * @example
+ * import { Liveblocks} from "@liveblocks/node"
+ * import { prepareThreadNotificationEmailAsReact } from "@liveblocks/emails"
+ *
+ * const liveblocks = new Liveblocks({ secret: "sk_..." })
+ * const emailData = prepareThreadNotificationEmailAsReact(
+ *  liveblocks,
+ *  event,
+ *  {
+ *    resolveUsers,
+ *    resolveRoomInfo,
+ *    components,
+ *  }
+ * )
+ *
+ */
+export async function prepareThreadNotificationEmailAsReact(
+  client: Liveblocks,
+  event: ThreadNotificationEvent,
+  options: PrepareThreadNotificationEmailAsReactOptions<BaseUserMeta> = {}
+): Promise<ThreadNotificationEmailDataAsReact | null> {
+  const data = await prepareThreadNotificationEmailBaseData({
+    client,
+    event,
+    options: { resolveRoomInfo: options.resolveRoomInfo },
+  });
+
+  if (data === null) {
+    return null;
+  }
+
+  const batchUsersResolver = createBatchUsersResolver<BaseUserMeta>({
+    resolveUsers: options.resolveUsers,
+    callerName: "prepareThreadNotificationEmailAsReact",
+  });
+
+  switch (data.type) {
+    case "unreadMention": {
+      const { comment } = data;
+
+      const authorsInfoPromise = resolveAuthorsInfo({
+        comments: [comment],
+        resolveUsers: batchUsersResolver.resolveUsers,
+      });
+
+      const commentBodyPromise = convertCommentBodyAsReact(comment.rawBody, {
+        resolveUsers: batchUsersResolver.resolveUsers,
+        components: options.components,
+      });
+
+      await batchUsersResolver.resolve();
+
+      const [authorsInfo, commentBodyReact] = await Promise.all([
+        authorsInfoPromise,
+        commentBodyPromise,
+      ]);
+      const authorInfo = authorsInfo.get(comment.userId);
+
+      return {
+        type: "unreadMention",
+        comment: {
+          id: comment.id,
+          threadId: comment.threadId,
+          roomId: comment.roomId,
+          author: authorInfo
+            ? { id: comment.userId, info: authorInfo }
+            : { id: comment.userId, info: { name: comment.userId } },
+          createdAt: comment.createdAt,
+          url: comment.url,
+          reactBody: commentBodyReact,
+        },
+        roomInfo: data.roomInfo,
+      };
+    }
+    case "unreadReplies": {
+      const { comments } = data;
+      const authorsInfoPromise = resolveAuthorsInfo({
+        comments,
+        resolveUsers: batchUsersResolver.resolveUsers,
+      });
+
+      const commentBodiesPromises = comments.map((c) =>
+        convertCommentBodyAsReact(c.rawBody, {
+          resolveUsers: batchUsersResolver.resolveUsers,
+          components: options.components,
+        })
+      );
+
+      await batchUsersResolver.resolve();
+
+      const [authorsInfo, ...commentBodies] = await Promise.all([
+        authorsInfoPromise,
+        ...commentBodiesPromises,
+      ]);
+
+      return {
+        type: "unreadReplies",
+        comments: comments.map((comment, index) => {
+          const authorInfo = authorsInfo.get(comment.userId);
+          const commentBodyReact = commentBodies[index];
+
+          return {
+            id: comment.id,
+            threadId: comment.threadId,
+            roomId: comment.roomId,
+            author: authorInfo
+              ? { id: comment.userId, info: authorInfo }
+              : { id: comment.userId, info: { name: comment.userId } },
+            createdAt: comment.createdAt,
+            url: comment.url,
+            reactBody: commentBodyReact ?? null,
+          };
+        }),
+        roomInfo: data.roomInfo,
+      };
+    }
+  }
+}

package/src/rooms/globals/augmentation.ts

@@ -5,14 +5,14 @@ import type { BaseRoomInfo } from '../protocol/BaseRoomInfo';
 import type { BaseUserMeta } from '../protocol/BaseUserMeta';
 import type { BaseMetadata } from '../protocol/Comments';
 
-declare global {
-  /**
-   * Namespace for user-defined Liveblocks types.
-   */
-  export interface Liveblocks {
-    [key: string]: unknown;
-  }
-}
+// declare global {
+//   /**
+//    * Namespace for user-defined Liveblocks types.
+//    */
+//   export interface Liveblocks {
+//     [key: string]: unknown;
+//   }
+// }
 
 // NOTE: When extending this list, make sure to also add respective error
 // message docs (in ../../docs/pages/errors/*.mdx).

package/src/rooms/liveblocks.service.ts

@@ -0,0 +1,25 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { RoomsService } from './rooms.service';
+import { NotificationsService } from './notifications.service';
+
+@Injectable()
+export class LiveblocksService {
+  constructor(
+    private roomsService: RoomsService,
+    private notificationService: NotificationsService,
+  ) {}
+  private readonly logger = new Logger(LiveblocksService.name);
+
+  async getThread({ roomId, threadId }) {
+    const thread = await this.roomsService.getThread({ roomId, threadId });
+    return thread;
+  }
+
+  async getInboxNotification({ inboxNotificationId, userId }) {
+    const notification = await this.notificationService.getInboxNotification({
+      inboxNotificationId,
+      userId,
+    });
+    return notification;
+  }
+}

package/src/rooms/notifications.service.ts

@@ -66,6 +66,13 @@ export class NotificationsService {
     }
   }
 
+  async getInboxNotification({ inboxNotificationId, userId }) {
+    return this.mongodbService.findOne('b6_inbox_notifications', {
+      _id: inboxNotificationId,
+      // userId,
+    });
+  }
+
   async createInboxNotification({
     _id,
     userId,
@@ -75,16 +82,21 @@ export class NotificationsService {
     roomId,
     threadId,
   }: InboxNotificationDTO) {
-    return this.mongodbService.insertOne('b6_inbox_notifications', {
-      _id,
-      id: _id,
-      userId,
-      kind,
-      notifiedAt,
-      readAt,
-      roomId,
-      threadId,
-    });
+    const result = await this.mongodbService.insertOne(
+      'b6_inbox_notifications',
+      {
+        _id,
+        id: _id,
+        userId,
+        kind,
+        notifiedAt,
+        readAt,
+        roomId,
+        threadId,
+      },
+    );
+
+    return result;
   }
 
   async findNotifications({