@builder6/rooms 3.0.4 → 3.0.6

package/src/rooms/emailNotification.service.tsx

@@ -1,126 +0,0 @@
-import { forwardRef, Inject, Injectable, Logger } from '@nestjs/common';
-import { ConfigService } from '@nestjs/config';
-import { ThreadNotificationEvent } from '@liveblocks/node';
-import { prepareThreadNotificationEmailAsReact } from './emails';
-import * as React from 'react';
-import { render } from '@react-email/render';
-import { EmailService } from '@builder6/email';
-import UnreadRepliesEmail from '../emails/UnreadReplies';
-import UnreadMentionEmail from '../emails/UnreadMention';
-import { RoomsService } from './rooms.service';
-
-@Injectable()
-export class EmailNotificationService {
-  private readonly logger = new Logger(EmailNotificationService.name);
-
-  constructor(
-    @Inject(forwardRef(() => RoomsService))
-    private roomsService: RoomsService,
-    private configService: ConfigService,
-    private emailService: EmailService,
-  ) {}
-
-  async sendThreadNotificationEmail({
-    roomId,
-    threadId,
-    userId,
-    fromUserId,
-    inboxNotificationId,
-    spaceId,
-  }: {
-    roomId: string;
-    threadId: string;
-    userId: string;
-    fromUserId?: string;
-    inboxNotificationId: string;
-    spaceId: string;
-  }) {
-    const event: ThreadNotificationEvent = {
-      type: 'notification',
-      data: {
-        channel: 'email',
-        kind: 'thread',
-        projectId: 'my-project-id',
-        roomId,
-        userId,
-        threadId,
-        inboxNotificationId,
-        createdAt: new Date().toISOString(),
-      },
-    };
-    const emailData = await prepareThreadNotificationEmailAsReact(
-      this.roomsService as any,
-      event,
-      {
-        resolveUsers: async ({ userIds }) => {
-          return await this.roomsService.resolveUsers({ userIds });
-        },
-        resolveRoomInfo: async ({ roomId }) => {
-          const room = await this.roomsService.resolveRoomInfo({
-            roomId,
-          });
-          return room;
-        },
-      },
-    );
-    if (!emailData) {
-      return;
-    }
-
-    const fromUsers = await this.roomsService.resolveUsers({
-      userIds: [fromUserId],
-    });
-
-    const fromUser = fromUsers[0] || { name: 'Somebody' };
-    const company = {
-      name: this.configService.get('tenant.name'),
-      url: this.configService.get('host'),
-      logoUrl: this.configService.get('tenant.logo.url'),
-    };
-    const room = {
-      name: emailData.roomInfo.name,
-      url: emailData.roomInfo.url,
-    };
-
-    let email;
-    let subject;
-
-    switch (emailData.type) {
-      // Handle unread replies use case
-      case 'unreadReplies': {
-        email = (
-          <UnreadRepliesEmail
-            company={company}
-            room={room}
-            comments={emailData.comments}
-          />
-        );
-        subject = `[${company.name}] ${fromUser.name} replyed you: ${room.name}`;
-        break;
-      }
-      // Handle last unread comment with mention use case
-      case 'unreadMention': {
-        email = (
-          <UnreadMentionEmail
-            company={company}
-            room={room}
-            comment={emailData.comment}
-          />
-        );
-        subject = `[${company.name}] ${fromUser.name} mentioned you: ${room.name}`;
-        break;
-      }
-    }
-
-    const html = await render(email);
-
-    await this.emailService.sendMailToUsers({
-      spaceId,
-      toUserIds: [userId],
-      fromUserId,
-      subject: subject,
-      html,
-    });
-    return html;
-  }
-}

package/src/rooms/emails/comment-body.tsx

@@ -1,342 +0,0 @@
-import type {
-  BaseUserMeta,
-  CommentBody,
-  CommentBodyLink,
-  CommentBodyMention,
-  CommentBodyText,
-  DU,
-  OptionalPromise,
-  ResolveUsersArgs,
-} from "@liveblocks/core";
-import {
-  html,
-  htmlSafe,
-  isCommentBodyLink,
-  isCommentBodyMention,
-  isCommentBodyText,
-  resolveUsersInCommentBody,
-  stringifyCommentBody,
-  toAbsoluteUrl,
-} from "@liveblocks/core";
-import * as React from "react";
-
-import type { CSSProperties } from "./lib/css-properties";
-import { toInlineCSSString } from "./lib/css-properties";
-
-export type CommentBodyContainerComponentProps = {
-  /**
-   * The blocks of the comment body
-   */
-  children: React.ReactNode;
-};
-
-export type CommentBodyParagraphComponentProps = {
-  /**
-   * The text content of the paragraph.
-   */
-  children: React.ReactNode;
-};
-
-export type CommentBodyTextComponentProps = {
-  /**
-   * The text element.
-   */
-  element: CommentBodyText;
-};
-
-export type CommentBodyLinkComponentProps = {
-  /**
-   * The link element.
-   */
-  element: CommentBodyLink;
-
-  /**
-   * The absolute URL of the link.
-   */
-  href: string;
-};
-
-export type CommentBodyMentionComponentProps<U extends BaseUserMeta = DU> = {
-  /**
-   * The mention element.
-   */
-  element: CommentBodyMention;
-
-  /**
-   * The mention's user info, if the `resolvedUsers` option was provided.
-   */
-  user?: U["info"];
-};
-
-export type ConvertCommentBodyAsReactComponents<U extends BaseUserMeta = DU> = {
-  /**
-   *
-   * The component used to act as a container to wrap comment body blocks,
-   */
-  Container: React.ComponentType<CommentBodyContainerComponentProps>;
-  /**
-   * The component used to display paragraphs.
-   */
-  Paragraph: React.ComponentType<CommentBodyParagraphComponentProps>;
-
-  /**
-   * The component used to display text elements.
-   */
-  Text: React.ComponentType<CommentBodyTextComponentProps>;
-
-  /**
-   * The component used to display links.
-   */
-  Link: React.ComponentType<CommentBodyLinkComponentProps>;
-
-  /**
-   * The component used to display mentions.
-   */
-  Mention: React.ComponentType<CommentBodyMentionComponentProps<U>>;
-};
-
-const baseComponents: ConvertCommentBodyAsReactComponents<BaseUserMeta> = {
-  Container: ({ children }) => <div>{children}</div>,
-  Paragraph: ({ children }) => <p>{children}</p>,
-  Text: ({ element }) => {
-    // Note: construction following the schema 👇
-    // <code><s><em><strong>{element.text}</strong></s></em></code>
-    let children: React.ReactNode = element.text;
-
-    if (element.bold) {
-      children = <strong>{children}</strong>;
-    }
-
-    if (element.italic) {
-      children = <em>{children}</em>;
-    }
-
-    if (element.strikethrough) {
-      children = <s>{children}</s>;
-    }
-
-    if (element.code) {
-      children = <code>{children}</code>;
-    }
-
-    return <span>{children}</span>;
-  },
-  Link: ({ element, href }) => (
-    <a href={href} target="_blank" rel="noopener noreferrer">
-      {element.text ?? element.url}
-    </a>
-  ),
-  Mention: ({ element, user }) => (
-    <span data-mention>@{user?.name ?? element.id}</span>
-  ),
-};
-
-export type ConvertCommentBodyAsReactOptions<U extends BaseUserMeta = DU> = {
-  /**
-   * The components used to customize the resulting React nodes. Each components has
-   * priority over the base components inherited.
-   */
-  components?: Partial<ConvertCommentBodyAsReactComponents<U>>;
-  /**
-   * A function that returns user info from user IDs.
-   */
-  resolveUsers?: (
-    args: ResolveUsersArgs
-  ) => OptionalPromise<(U["info"] | undefined)[] | undefined>;
-};
-
-/**
- * Convert a `CommentBody` into React elements
- */
-export async function convertCommentBodyAsReact(
-  body: CommentBody,
-  options?: ConvertCommentBodyAsReactOptions<BaseUserMeta>
-): Promise<React.ReactNode> {
-  const Components = {
-    ...baseComponents,
-    ...options?.components,
-  };
-  const resolvedUsers = await resolveUsersInCommentBody(
-    body,
-    options?.resolveUsers
-  );
-
-  const blocks = body.content.map((block, index) => {
-    switch (block.type) {
-      case "paragraph": {
-        const children = block.children.map((inline, inlineIndex) => {
-          if (isCommentBodyMention(inline)) {
-            return inline.id ? (
-              <Components.Mention
-                key={`lb-comment-body-mention-${inlineIndex}`}
-                element={inline}
-                user={resolvedUsers.get(inline.id)}
-              />
-            ) : null;
-          }
-
-          if (isCommentBodyLink(inline)) {
-            const href = toAbsoluteUrl(inline.url) ?? inline.url;
-            return (
-              <Components.Link
-                key={`lb-comment-body-link-${inlineIndex}`}
-                element={inline}
-                href={href}
-              />
-            );
-          }
-
-          if (isCommentBodyText(inline)) {
-            return (
-              <Components.Text
-                key={`lb-comment-body-text-${inlineIndex}`}
-                element={inline}
-              />
-            );
-          }
-
-          return null;
-        });
-
-        return (
-          <Components.Paragraph key={`lb-comment-body-paragraph-${index}`}>
-            {children}
-          </Components.Paragraph>
-        );
-      }
-      default:
-        console.warn(
-          `Unsupported comment body block type: "${JSON.stringify(block.type)}"`
-        );
-        return null;
-    }
-  });
-
-  return (
-    <Components.Container key={"lb-comment-body-container"}>
-      {blocks}
-    </Components.Container>
-  );
-}
-
-export type ConvertCommentBodyAsHtmlStyles = {
-  /**
-   * The default inline CSS styles used to display paragraphs.
-   */
-  paragraph: CSSProperties;
-  /**
-   * The default inline CSS styles used to display text `<strong />` elements.
-   */
-  strong: CSSProperties;
-  /**
-   * The default inline CSS styles used to display text `<code />` elements.
-   */
-  code: CSSProperties;
-  /**
-   * The default inline CSS styles used to display links.
-   */
-  mention: CSSProperties;
-  /**
-   * The default inline CSS styles used to display mentions.
-   */
-  link: CSSProperties;
-};
-
-const baseStyles: ConvertCommentBodyAsHtmlStyles = {
-  paragraph: {
-    fontSize: "14px",
-  },
-  strong: {
-    fontWeight: 500,
-  },
-  code: {
-    fontFamily:
-      'ui-monospace, Menlo, Monaco, "Cascadia Mono", "Segoe UI Mono", "Roboto Mono", "Oxygen Mono", "Ubuntu Mono", "Source Code Pro", "Fira Mono", "Droid Sans Mono", "Consolas", "Courier New", monospace',
-    backgroundColor: "rgba(0,0,0,0.05)",
-    border: "solid 1px rgba(0,0,0,0.1)",
-    borderRadius: "4px",
-  },
-  mention: {
-    color: "blue",
-  },
-  link: {
-    textDecoration: "underline",
-  },
-};
-
-export type ConvertCommentBodyAsHtmlOptions<U extends BaseUserMeta = DU> = {
-  /**
-   * The styles used to customize the html elements in the resulting html safe string.
-   * Each styles has priority over the base styles inherited.
-   */
-  styles?: Partial<ConvertCommentBodyAsHtmlStyles>;
-  /**
-   * A function that returns user info from user IDs.
-   */
-  resolveUsers?: (
-    args: ResolveUsersArgs
-  ) => OptionalPromise<(U["info"] | undefined)[] | undefined>;
-};
-
-/**
- * Convert a `CommentBody` into an html safe string
- * with inline css styles
- */
-export async function convertCommentBodyAsHtml(
-  body: CommentBody,
-  options?: ConvertCommentBodyAsHtmlOptions<BaseUserMeta>
-): Promise<string> {
-  const styles = { ...baseStyles, ...options?.styles };
-
-  const htmlBody = await stringifyCommentBody(body, {
-    format: "html",
-    resolveUsers: options?.resolveUsers,
-    elements: {
-      // NOTE: using prettier-ignore to preserve template strings
-      paragraph: ({ children }) =>
-        // prettier-ignore
-        children ? html`<p style="${toInlineCSSString(styles.paragraph)}">${htmlSafe(children)}</p>` : children,
-      text: ({ element }) => {
-        // Note: construction following the schema 👇
-        // <code><s><em><strong>{element.text}</strong></s></em></code>
-        let children = element.text;
-
-        if (!children) {
-          return children;
-        }
-
-        if (element.bold) {
-          // prettier-ignore
-          children = html`<strong style="${toInlineCSSString(styles.strong)}">${children}</strong>`;
-        }
-
-        if (element.italic) {
-          // prettier-ignore
-          children = html`<em>${children}</em>`;
-        }
-
-        if (element.strikethrough) {
-          // prettier-ignore
-          children = html`<s>${children}</s>`;
-        }
-
-        if (element.code) {
-          // prettier-ignore
-          children = html`<code style="${toInlineCSSString(styles.code)}">${children}</code>`;
-        }
-
-        return children;
-      },
-      link: ({ element, href }) => {
-        // prettier-ignore
-        return html`<a href="${href}" target="_blank" rel="noopener noreferrer" style="${toInlineCSSString(styles.link)}">${element.text ?? element.url}</a>`;
-      },
-      mention: ({ element, user }) => {
-        // prettier-ignore
-        return html`<span data-mention style="${toInlineCSSString(styles.mention)}">@${user?.name ?? element.id}</span>`;
-      },
-    },
-  });
-
-  return htmlBody;
-}

package/src/rooms/emails/comment-with-body.ts

@@ -1,24 +0,0 @@
-import type { CommentBody, CommentData } from "@liveblocks/core";
-
-export type CommentDataWithBody = Omit<CommentData, "body" | "deletedAt"> & {
-  body: CommentBody;
-  deletedAt?: never;
-};
-
-const isCommentDataWithBody = (
-  comment: CommentData
-): comment is CommentDataWithBody => {
-  return comment.body !== undefined && comment.deletedAt === undefined;
-};
-
-export function filterCommentsWithBody(
-  comments: CommentData[]
-): CommentDataWithBody[] {
-  const commentsWithBody: CommentDataWithBody[] = [];
-  for (const comment of comments) {
-    if (isCommentDataWithBody(comment)) {
-      commentsWithBody.push(comment);
-    }
-  }
-  return commentsWithBody;
-}

package/src/rooms/emails/index.ts

@@ -1,25 +0,0 @@
-import { detectDupes } from "@liveblocks/core";
-
-export type {
-  CommentBodyContainerComponentProps,
-  CommentBodyLinkComponentProps,
-  CommentBodyMentionComponentProps,
-  CommentBodyParagraphComponentProps,
-  CommentBodyTextComponentProps,
-  ConvertCommentBodyAsHtmlStyles,
-  ConvertCommentBodyAsReactComponents,
-} from "./comment-body";
-export type {
-  CommentEmailAsHtmlData,
-  CommentEmailAsReactData,
-  PrepareThreadNotificationEmailAsHtmlOptions,
-  PrepareThreadNotificationEmailAsReactOptions,
-  ResolveRoomInfoArgs,
-  ThreadNotificationEmailDataAsHtml,
-  ThreadNotificationEmailDataAsReact,
-} from "./thread-notification";
-export {
-  prepareThreadNotificationEmailAsHtml,
-  prepareThreadNotificationEmailAsReact,
-} from "./thread-notification";
-export type { ResolveUsersArgs } from "@liveblocks/core";

package/src/rooms/emails/lib/batch-users-resolver.ts

@@ -1,120 +0,0 @@
-import type {
-  BaseUserMeta,
-  DU,
-  OptionalPromise,
-  ResolveUsersArgs,
-} from "@liveblocks/core";
-import { Promise_withResolvers } from "@liveblocks/core";
-
-import { createDevelopmentWarning } from "./warning";
-
-type ResolveUserOptionalPromise<U extends BaseUserMeta> = (
-  args: ResolveUsersArgs
-) => OptionalPromise<(U["info"] | undefined)[] | undefined>;
-
-/**
- * Batch calls to `resolveUsers` to one and only call.
- * It will avoid any performances issues and invocation timeouts on our customers' webhook handlers.
- *
- * This batch call will stack pending promises referring to `resolveUsers` in a map, resolve all users given in args at once
- * and then resolve pending promises all at once.
- */
-class BatchUsersResolver<U extends BaseUserMeta> {
-  private isResolved: boolean;
-  private markAsResolved: () => void;
-  private resolvePromise: Promise<void>;
-
-  private primeResolveUsersFn: ResolveUserOptionalPromise<U> | undefined;
-  private usersById: Map<string, U["info"] | undefined>;
-
-  private warnAsAlreadyResolved: () => void;
-
-  constructor(resolveUsers: ResolveUserOptionalPromise<U> | undefined) {
-    const { promise, resolve } = Promise_withResolvers<void>();
-
-    this.isResolved = false;
-    this.markAsResolved = resolve;
-    this.resolvePromise = promise;
-
-    this.primeResolveUsersFn = resolveUsers;
-    this.usersById = new Map();
-
-    this.warnAsAlreadyResolved = createDevelopmentWarning(
-      true,
-      "Batch users resolver promise already resolved. It can only resolve once."
-    );
-  }
-
-  resolveUsers = async (
-    args: ResolveUsersArgs
-  ): Promise<(U["info"] | undefined)[] | undefined> => {
-    if (this.isResolved) {
-      this.warnAsAlreadyResolved();
-      return undefined;
-    }
-
-    // Note: register all user Ids
-    for (const userId of args.userIds) {
-      this.usersById.set(userId, undefined);
-    }
-
-    // Note: waiting until the batch promise is resolved
-    await this.resolvePromise;
-
-    // Note: once the batch promise is resolved
-    // we can return safely resolved users
-    return args.userIds.map((userId) => this.usersById.get(userId));
-  };
-
-  async resolve(): Promise<void> {
-    if (this.isResolved) {
-      this.warnAsAlreadyResolved();
-      return;
-    }
-
-    // Note: set an array of unique user ids
-    const userIds = Array.from(this.usersById.keys());
-    const users = await this.primeResolveUsersFn?.({ userIds });
-
-    for (const [index, userId] of userIds.entries()) {
-      const user = users?.[index];
-      this.usersById.set(userId, user);
-    }
-
-    this.isResolved = true;
-    this.markAsResolved();
-  }
-}
-
-export type CreateBatchUsersResolverReturnType<U extends BaseUserMeta> = {
-  resolveUsers: (
-    args: ResolveUsersArgs
-  ) => Promise<(U["info"] | undefined)[] | undefined>;
-  resolve: () => Promise<void>;
-};
-
-export function createBatchUsersResolver<U extends BaseUserMeta = DU>({
-  resolveUsers,
-  callerName,
-}: {
-  resolveUsers?: (
-    args: ResolveUsersArgs
-  ) => OptionalPromise<(U["info"] | undefined)[] | undefined>;
-  callerName: string;
-}): CreateBatchUsersResolverReturnType<U> {
-  const warnIfNoResolveUsers = createDevelopmentWarning(
-    () => !resolveUsers,
-    `Set "resolveUsers" option in "${callerName}" to specify users info`
-  );
-  const batchUsersResolver = new BatchUsersResolver(resolveUsers);
-
-  const resolve = async (): Promise<void> => {
-    warnIfNoResolveUsers();
-    await batchUsersResolver.resolve();
-  };
-
-  return {
-    resolveUsers: batchUsersResolver.resolveUsers,
-    resolve,
-  } as const;
-}