@builder6/rooms 3.0.5 → 3.0.6

package/src/rooms/lib/Json.ts

@@ -1,34 +0,0 @@
-/**
- * Represents an indefinitely deep arbitrary JSON data structure. There are
- * four types that make up the Json family:
- *
- * - Json         any legal JSON value
- * - JsonScalar   any legal JSON leaf value (no lists or objects)
- * - JsonArray    a JSON value whose outer type is an array
- * - JsonObject   a JSON value whose outer type is an object
- *
- */
-export type Json = JsonScalar | JsonArray | JsonObject;
-export type JsonScalar = string | number | boolean | null;
-export type JsonArray = Json[];
-/**
- * Any valid JSON object.
- */
-export type JsonObject = { [key: string]: Json | undefined };
-
-export function isJsonScalar(data: Json): data is JsonScalar {
-  return (
-    data === null ||
-    typeof data === 'string' ||
-    typeof data === 'number' ||
-    typeof data === 'boolean'
-  );
-}
-
-export function isJsonArray(data: Json): data is JsonArray {
-  return Array.isArray(data);
-}
-
-export function isJsonObject(data: Json): data is JsonObject {
-  return !isJsonScalar(data) && !isJsonArray(data);
-}

package/src/rooms/lib/utils.ts

@@ -1,240 +0,0 @@
-import type { Json } from './Json';
-
-declare const brand: unique symbol;
-export type Brand<T, TBrand extends string> = T & { [brand]: TBrand };
-
-export type DistributiveOmit<T, K extends PropertyKey> = T extends any
-  ? Omit<T, K>
-  : never;
-
-// export type DistributivePick<T, K extends keyof T> = T extends any
-//   ? Pick<T, K>
-//   : never;
-
-/**
- * Throw an error, but as an expression instead of a statement.
- */
-export function raise(msg: string): never {
-  throw new Error(msg);
-}
-
-export function isPlainObject(
-  blob: unknown,
-): blob is { [key: string]: unknown } {
-  // Implementation borrowed from pojo decoder, see
-  // https://github.com/nvie/decoders/blob/78849f843193647eb6b5307240387bdcff7161fb/src/lib/objects.js#L10-L41
-  return (
-    blob !== null &&
-    typeof blob === 'object' &&
-    Object.prototype.toString.call(blob) === '[object Object]'
-  );
-}
-
-/**
- * Drop-in replacement for Object.entries() that retains better types.
- */
-export function entries<
-  O extends { [key: string]: unknown },
-  K extends keyof O,
->(obj: O): [K, O[K]][] {
-  return Object.entries(obj) as [K, O[K]][];
-}
-
-/**
- * Drop-in replacement for Object.keys() that retains better types.
- */
-export function keys<O extends { [key: string]: unknown }, K extends keyof O>(
-  obj: O,
-): K[] {
-  return Object.keys(obj) as K[];
-}
-
-/**
- * Drop-in replacement for Object.values() that retains better types.
- */
-export function values<O extends Record<string, unknown>>(
-  obj: O,
-): O[keyof O][] {
-  return Object.values(obj) as O[keyof O][];
-}
-
-/**
- * Creates a new object by mapping a function over all values. Keys remain the
- * same. Think Array.prototype.map(), but for values in an object.
- */
-export function mapValues<V, O extends Record<string, unknown>>(
-  obj: O,
-  mapFn: (value: O[keyof O], key: keyof O) => V,
-): { [K in keyof O]: V } {
-  const result = {} as { [K in keyof O]: V };
-  for (const pair of Object.entries(obj)) {
-    const key: keyof O = pair[0];
-    if (key === '__proto__') {
-      // Avoid setting dangerous __proto__ keys
-      continue;
-    }
-    const value = pair[1] as O[keyof O];
-    result[key] = mapFn(value, key);
-  }
-  return result;
-}
-
-/**
- * Alternative to JSON.parse() that will not throw in production. If the passed
- * string cannot be parsed, this will return `undefined`.
- */
-export function tryParseJson(rawMessage: string): Json | undefined {
-  try {
-    // eslint-disable-next-line no-restricted-syntax
-    return JSON.parse(rawMessage) as Json;
-  } catch (e) {
-    return undefined;
-  }
-}
-
-/**
- * Deep-clones a JSON-serializable value.
- *
- * NOTE: We should be able to replace `deepClone` by `structuredClone` once
- * we've upgraded to Node 18.
- */
-export function deepClone<T extends Json>(value: T): T {
-  // NOTE: In this case, the combination of JSON.parse() and JSON.stringify
-  // won't lead to type unsafety, so this use case is okay.
-  // eslint-disable-next-line no-restricted-syntax
-  return JSON.parse(JSON.stringify(value)) as T;
-}
-
-/**
- * Decode base64 string.
- */
-export function b64decode(b64value: string): string {
-  try {
-    const formattedValue = b64value.replace(/-/g, '+').replace(/_/g, '/');
-    const decodedValue = decodeURIComponent(
-      atob(formattedValue)
-        .split('')
-        .map(function (c) {
-          return '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2);
-        })
-        .join(''),
-    );
-
-    return decodedValue;
-  } catch (err) {
-    return atob(b64value);
-  }
-}
-
-/**
- * Mutates the array in-place by removing the first occurrence of `item` from
- * the array.
- */
-export function remove<T>(array: T[], item: T): void {
-  for (let i = 0; i < array.length; i++) {
-    if (array[i] === item) {
-      array.splice(i, 1);
-      break;
-    }
-  }
-}
-
-/**
- * Removes null and undefined values from the array, and reflects this in the
- * output type.
- */
-export function compact<T>(items: readonly T[]): NonNullable<T>[] {
-  return items.filter(
-    (item: T): item is NonNullable<T> => item !== null && item !== undefined,
-  );
-}
-
-export type RemoveUndefinedValues<T> = {
-  [K in keyof T]-?: Exclude<T[K], undefined>;
-};
-
-/**
- * Returns a new object instance where all explictly-undefined values are
- * removed.
- */
-export function compactObject<O extends Record<string, unknown>>(
-  obj: O,
-): RemoveUndefinedValues<O> {
-  const newObj = { ...obj };
-  Object.keys(obj).forEach((k) => {
-    const key = k as keyof O;
-    if (newObj[key] === undefined) {
-      delete newObj[key];
-    }
-  });
-  return newObj as RemoveUndefinedValues<O>;
-}
-
-/**
- * Returns a promise that resolves after the given number of milliseconds.
- */
-export function wait(millis: number): Promise<void> {
-  return new Promise((res) => setTimeout(res, millis));
-}
-
-/**
- * Returns whatever the given promise returns, but will be rejected with
- * a "Timed out" error if the given promise does not return or reject within
- * the given timeout period (in milliseconds).
- */
-export async function withTimeout<T>(
-  promise: Promise<T>,
-  millis: number,
-  errmsg: string,
-): Promise<T> {
-  let timerID: ReturnType<typeof setTimeout> | undefined;
-  const timer$ = new Promise<never>((_, reject) => {
-    timerID = setTimeout(() => {
-      reject(new Error(errmsg));
-    }, millis);
-  });
-  return (
-    Promise
-      // Race the given promise against the timer. Whichever one finishes
-      // first wins the race.
-      .race([promise, timer$])
-
-      // Either way, clear the timeout, no matter who won
-      .finally(() => clearTimeout(timerID))
-  );
-}
-
-/**
- * Memoize a promise factory, so that each subsequent call will return the same
- * pending or success promise. If the promise rejects, will retain that failed
- * promise for a small time period, after which the next attempt will reset the
- * memoized value.
- */
-export function memoizeOnSuccess<T>(
-  factoryFn: () => Promise<T>,
-): () => Promise<T> {
-  let cached: Promise<T> | null = null;
-  return () => {
-    if (cached === null) {
-      cached = factoryFn().catch((err) => {
-        //
-        // Keep returning the failed promise for any calls to the memoized
-        // promise for the next 5 seconds. This time period is a bit arbitrary,
-        // but exists to make this play nicely with frameworks like React.
-        //
-        // In React, after a component is suspended and its promise is
-        // rejected, React will re-render the component, and expect the next
-        // call to this function to return the rejected promise, so its error
-        // can be shown. If we immediately reset this value, then such next
-        // render would instantly trigger a new promise which would trigger an
-        // infinite loop and keeping the component in loading state forever.
-        //
-        setTimeout(() => {
-          cached = null;
-        }, 5_000);
-        throw err;
-      });
-    }
-    return cached;
-  };
-}

package/src/rooms/liveblocks.service.ts

@@ -1,25 +0,0 @@
-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

@@ -1,235 +0,0 @@
-import { MongodbService } from '@builder6/core';
-import { InjectBroker } from '@builder6/moleculer';
-import { Injectable, Logger } from '@nestjs/common';
-import { v4 as uuidv4 } from 'uuid';
-import { ServiceBroker } from 'moleculer';
-import { InboxNotificationDTO } from './dtos/inbox_notifications.dto';
-import { isArray } from 'lodash';
-import { EmailNotificationService } from './emailNotification.service';
-
-@Injectable()
-export class NotificationsService {
-  private readonly logger = new Logger(NotificationsService.name);
-  constructor(
-    private mongodbService: MongodbService,
-    private emailNotificationService: EmailNotificationService,
-    @InjectBroker() private readonly broker: ServiceBroker,
-  ) {}
-
-  async onThreadNotification({
-    roomId,
-    userId,
-    fromUserId,
-    threadId,
-    type = 'mention',
-    spaceId,
-  }: {
-    roomId: string;
-    userId: string;
-    fromUserId: string;
-    threadId: string;
-    type: 'mention' | 'reply';
-    spaceId: string;
-  }) {
-    // Create Inbox Notification
-    const notification = await this.createOrUpdateInboxNotification({
-      userId,
-      kind: 'thread',
-      roomId,
-      threadId,
-    });
-
-    // Create Email Notification
-    await this.emailNotificationService.sendThreadNotificationEmail({
-      roomId,
-      threadId,
-      userId,
-      fromUserId,
-      inboxNotificationId: notification._id,
-      spaceId,
-    });
-
-    // Emitting Moleculer Message and Steedos Notification
-    if (roomId && roomId.split(':').length === 3) {
-      const [objects, objectName, recordId] = roomId.split(':');
-      if (objects === 'objects') {
-        if (type === 'mention') {
-          this.logger.log(
-            `Emitting ${objectName}.mentioned, recordId:${recordId} userId:${userId}`,
-          );
-          this.broker.emit(`${objectName}.mentioned`, {
-            recordId,
-            userId,
-            fromUserId,
-          });
-        }
-      }
-    }
-  }
-
-  async getInboxNotification({ inboxNotificationId, userId }) {
-    return this.mongodbService.findOne('b6_inbox_notifications', {
-      _id: inboxNotificationId,
-      // userId,
-    });
-  }
-
-  deleteNotifications({ userId }: { userId: string }) {
-    return this.mongodbService.deleteMany('b6_inbox_notifications', {
-      userId,
-    });
-  }
-
-  async createOrUpdateInboxNotification({
-    kind = 'thread',
-    userId,
-    roomId,
-    threadId,
-  }: any) {
-    let notification = await this.mongodbService.findOne(
-      'b6_inbox_notifications',
-      {
-        roomId,
-        threadId,
-        userId,
-      },
-    );
-    if (!notification) {
-      const _id = uuidv4();
-      notification = await this.mongodbService.insertOne(
-        'b6_inbox_notifications',
-        {
-          _id,
-          id: _id,
-          userId,
-          kind,
-          notifiedAt: new Date(),
-          readAt: null,
-          roomId,
-          threadId,
-        },
-      );
-    } else {
-      await this.mongodbService.findOneAndUpdateData(
-        'b6_inbox_notifications',
-        {
-          _id: notification._id,
-        },
-        {
-          notifiedAt: new Date(),
-        },
-      );
-    }
-
-    return notification;
-  }
-
-  async findNotifications({
-    userId,
-    unread,
-    limit,
-    sinceDate,
-    roomId,
-    threadId,
-  }: {
-    userId: string;
-    unread?: boolean;
-    limit?: number;
-    sinceDate?: Date;
-    roomId?: string;
-    threadId?: string;
-  }) {
-    const queryOptions = { userId } as {
-      userId: string;
-      readAt: null | undefined;
-      notifiedAt: { $gt: Date } | undefined;
-      roomId?: string;
-      threadId?: string;
-      id: { $in: string[] } | undefined;
-    };
-    if (unread) queryOptions.readAt = null;
-    if (sinceDate) {
-      queryOptions.notifiedAt = { $gt: sinceDate };
-    }
-    if (roomId) queryOptions.roomId = roomId;
-    if (threadId) queryOptions.threadId = threadId;
-    const collection = (await this.mongodbService.getCollection(
-      'b6_inbox_notifications',
-    )) as any;
-    const query = collection.find(queryOptions).sort({ notifiedAt: 1 });
-    if (limit) query.limit(limit);
-    return query.toArray();
-  }
-
-  async markAsRead({
-    roomId,
-    userId,
-    inboxNotificationIds,
-  }: {
-    roomId?: string;
-    userId: string;
-    inboxNotificationIds: string[] | 'all';
-  }) {
-    const queryOptions = { userId } as {
-      roomId?: string;
-      userId: string;
-      _id: { $in: string[] };
-    };
-    if (roomId) queryOptions.roomId = roomId;
-    if (isArray(inboxNotificationIds)) {
-      queryOptions._id = { $in: inboxNotificationIds as string[] };
-    }
-    const collection = (await this.mongodbService.getCollection(
-      'b6_inbox_notifications',
-    )) as any;
-    return collection.updateMany(queryOptions, {
-      $set: { readAt: new Date() },
-    });
-  }
-
-  async createSteedosNotification({
-    objectName,
-    recordId,
-    name,
-    body,
-    fromUserId,
-    userId,
-  }: {
-    objectName: string;
-    recordId: string;
-    name?: string;
-    body: string;
-    fromUserId: string;
-    userId: string;
-  }) {
-    const record = await this.mongodbService.findOne(
-      objectName,
-      {
-        _id: recordId,
-      },
-      {
-        projection: {
-          name: 1,
-          space: 1,
-          owner: 1,
-        },
-      },
-    );
-
-    return await this.mongodbService.insertOne('notifications', {
-      name: name || record.name,
-      body,
-      related_to: {
-        o: objectName,
-        ids: [recordId],
-      },
-      related_name: record.name,
-      from: fromUserId,
-      space: record.space,
-      owner: userId,
-      is_read: false,
-      created: new Date(),
-      created_by: fromUserId,
-    });
-  }
-}

package/src/rooms/protocol/AuthToken.ts

@@ -1,126 +0,0 @@
-import type { Json } from '../lib/Json';
-import { b64decode, isPlainObject, tryParseJson } from '../lib/utils';
-import type { IUserInfo } from './BaseUserMeta';
-
-export enum Permission {
-  Read = 'room:read',
-  Write = 'room:write',
-  PresenceWrite = 'room:presence:write',
-  CommentsWrite = 'comments:write',
-  CommentsRead = 'comments:read',
-}
-
-export type LiveblocksPermissions = Record<string, Permission[]>;
-
-export enum TokenKind {
-  SECRET_LEGACY = 'sec-legacy',
-  ACCESS_TOKEN = 'acc',
-  ID_TOKEN = 'id',
-}
-
-/**
- * Infers from the given scopes whether the user can write the document (e.g.
- * Storage and/or YDoc).
- */
-export function canWriteStorage(scopes: readonly string[]): boolean {
-  return scopes.includes(Permission.Write);
-}
-
-export function canComment(scopes: readonly string[]): boolean {
-  return (
-    scopes.includes(Permission.CommentsWrite) ||
-    scopes.includes(Permission.Write)
-  );
-}
-
-type JwtMeta = {
-  iat: number;
-  exp: number;
-};
-
-/**
- * Legacy Secret Token.
- */
-export type LegacySecretToken = {
-  k: TokenKind.SECRET_LEGACY;
-  roomId: string;
-  scopes: string[];
-
-  // Extra payload as defined by the customer's own authorization
-  id?: string;
-  info?: IUserInfo;
-
-  // IMPORTANT: All other fields on the JWT token are deliberately treated as
-  // opaque, and not relied on by the client.
-  [other: string]: Json | undefined;
-} & JwtMeta;
-
-/**
- * New authorization Access Token.
- */
-export type AccessToken = {
-  k: TokenKind.ACCESS_TOKEN;
-  pid: string; // project id
-  uid: string; // user id
-  perms: LiveblocksPermissions; // permissions
-  ui?: IUserInfo; // user info
-} & JwtMeta;
-
-/**
- * New authorization ID Token.
- */
-export type IDToken = {
-  k: TokenKind.ID_TOKEN;
-  pid: string; // project id
-  uid: string; // user id
-  gids?: string[]; // group ids
-  ui?: IUserInfo; // user info
-} & JwtMeta;
-
-export type AuthToken = AccessToken | IDToken | LegacySecretToken;
-
-// The "rich" token is data we obtain by parsing the JWT token and making all
-// metadata on it accessible. It's done right after hitting the backend, but
-// before the promise will get returned, so it's an inherent part of the
-// authentication step.
-export type ParsedAuthToken = {
-  readonly raw: string; // The raw JWT value, unchanged
-  readonly parsed: AuthToken; // Rich data on the JWT value
-};
-
-function isValidAuthTokenPayload(
-  data: Json,
-): data is AccessToken | IDToken | LegacySecretToken {
-  return (
-    isPlainObject(data) &&
-    (data.k === TokenKind.ACCESS_TOKEN ||
-      data.k === TokenKind.ID_TOKEN ||
-      data.k === TokenKind.SECRET_LEGACY)
-  );
-}
-
-/**
- * Parses a raw JWT token string, which allows reading the metadata/payload of
- * the token.
- *
- * NOTE: Doesn't do any validation, so always treat the metadata as other user
- * input: never trust these values for anything important.
- */
-export function parseAuthToken(rawTokenString: string): ParsedAuthToken {
-  const tokenParts = rawTokenString.split('.');
-  if (tokenParts.length !== 3) {
-    throw new Error('Authentication error: invalid JWT token');
-  }
-
-  const payload = tryParseJson(b64decode(tokenParts[1]));
-  if (!(payload && isValidAuthTokenPayload(payload))) {
-    throw new Error(
-      'Authentication error: expected a valid token but did not get one. Hint: if you are using a callback, ensure the room is passed when creating the token. For more information: https://liveblocks.io/docs/api-reference/liveblocks-client#createClientCallback',
-    );
-  }
-
-  return {
-    raw: rawTokenString,
-    parsed: payload,
-  };
-}

package/src/rooms/protocol/Authentication.ts

@@ -1,18 +0,0 @@
-export type CustomAuthenticationResult =
-  | { token: string; error?: never }
-  | { token?: never; error: 'forbidden'; reason: string } // Will stop retrying and disconnect
-  | { token?: never; error: string; reason: string }; // Will log the error and keep retrying
-
-export type Authentication =
-  | {
-      type: 'public';
-      publicApiKey: string;
-    }
-  | {
-      type: 'private';
-      url: string;
-    }
-  | {
-      type: 'custom';
-      callback: (room?: string) => Promise<CustomAuthenticationResult>;
-    };

package/src/rooms/protocol/BaseActivitiesData.ts

@@ -1,5 +0,0 @@
-import type { ActivityData } from './InboxNotifications';
-
-export type BaseActivitiesData = {
-  [key: `$${string}`]: ActivityData;
-};

package/src/rooms/protocol/BaseRoomInfo.ts

@@ -1,15 +0,0 @@
-import type { Json } from '../lib/Json';
-
-export type BaseRoomInfo = {
-  [key: string]: Json | undefined;
-
-  /**
-   * The name of the room.
-   */
-  name?: string;
-
-  /**
-   * The URL of the room.
-   */
-  url?: string;
-};