@liveblocks/node 2.21.0-emails3 → 2.22.0

package/dist/index.js

@@ -3,22 +3,91 @@ import { detectDupes } from "@liveblocks/core";
 
 // src/version.ts
 var PKG_NAME = "@liveblocks/node";
-var PKG_VERSION = "2.21.0-emails3";
+var PKG_VERSION = "2.22.0";
 var PKG_FORMAT = "esm";
 
 // src/client.ts
 import {
+  checkBounds,
+  ClientMsgCode,
   convertToCommentData,
   convertToCommentUserReaction,
   convertToInboxNotificationData,
   convertToThreadData,
+  createManagedPool,
   createUserNotificationSettings,
+  LiveObject,
+  makeAbortController,
   objectToQuery,
   tryParseJson,
   url as url2,
   urljoin
 } from "@liveblocks/core";
 
+// src/lib/itertools.ts
+async function asyncConsume(iterable) {
+  const result = [];
+  for await (const item of iterable) {
+    result.push(item);
+  }
+  return result;
+}
+async function runConcurrently(iterable, fn, concurrency) {
+  const queue = /* @__PURE__ */ new Set();
+  for await (const item of iterable) {
+    if (queue.size >= concurrency) {
+      await Promise.race(queue);
+    }
+    const promise = (async () => {
+      try {
+        await fn(item);
+      } finally {
+        queue.delete(promise);
+      }
+    })();
+    queue.add(promise);
+  }
+  if (queue.size > 0) {
+    await Promise.all(queue);
+  }
+}
+
+// src/lib/ndjson.ts
+var LineStream = class extends TransformStream {
+  constructor() {
+    let buffer = "";
+    super({
+      transform(chunk, controller) {
+        buffer += chunk;
+        if (buffer.includes("\n")) {
+          const lines = buffer.split("\n");
+          for (let i = 0; i < lines.length - 1; i++) {
+            if (lines[i].length > 0) {
+              controller.enqueue(lines[i]);
+            }
+          }
+          buffer = lines[lines.length - 1];
+        }
+      },
+      flush(controller) {
+        if (buffer.length > 0) {
+          controller.enqueue(buffer);
+        }
+      }
+    });
+  }
+};
+var NdJsonStream = class extends TransformStream {
+  constructor() {
+    super({
+      transform(line, controller) {
+        const json = JSON.parse(line);
+        controller.enqueue(json);
+      }
+    });
+  }
+};
+
 // src/Session.ts
 import { url } from "@liveblocks/core";
 
@@ -407,8 +476,8 @@ var Liveblocks = class {
     if (!res.ok) {
       throw await LiveblocksError.from(res);
     }
-    const data = await res.json();
-    const rooms = data.data.map((room) => {
+    const page = await res.json();
+    const rooms = page.data.map((room) => {
       const lastConnectionAt = room.lastConnectionAt ? new Date(room.lastConnectionAt) : void 0;
       const createdAt = new Date(room.createdAt);
       return {
@@ -418,10 +487,42 @@ var Liveblocks = class {
       };
     });
     return {
-      ...data,
+      ...page,
       data: rooms
     };
   }
+  /**
+   * Iterates over all rooms that match the given criteria.
+   *
+   * The difference with .getRooms() is that pagination will happen
+   * automatically under the hood, using the given `pageSize`.
+   *
+   * @param criteria.userId (optional) A filter on users accesses.
+   * @param criteria.groupIds (optional) A filter on groups accesses. Multiple groups can be used.
+   * @param criteria.query.roomId (optional) A filter by room ID.
+   * @param criteria.query.metadata (optional) A filter by metadata.
+   *
+   * @param options.pageSize (optional) The page size to use for each request.
+   * @param options.signal (optional) An abort signal to cancel the request.
+   */
+  async *iterRooms(criteria, options) {
+    const { signal } = options ?? {};
+    const pageSize = checkBounds("pageSize", options?.pageSize ?? 40, 20);
+    let cursor = void 0;
+    while (true) {
+      const { nextCursor, data } = await this.getRooms(
+        { ...criteria, startingAfter: cursor, limit: pageSize },
+        { signal }
+      );
+      for (const item of data) {
+        yield item;
+      }
+      if (!nextCursor) {
+        break;
+      }
+      cursor = nextCursor;
+    }
+  }
   /**
    * Creates a new room with the given id.
    * @param roomId The id of the room to create.
@@ -457,6 +558,51 @@ var Liveblocks = class {
       createdAt
     };
   }
+  /**
+   * Returns a room with the given id, or creates one with the given creation
+   * options if it doesn't exist yet.
+   *
+   * @param roomId The id of the room.
+   * @param params.defaultAccesses The default accesses for the room if the room will be created.
+   * @param params.groupsAccesses (optional) The group accesses for the room if the room will be created. Can contain a maximum of 100 entries. Key length has a limit of 40 characters.
+   * @param params.usersAccesses (optional) The user accesses for the room if the room will be created. Can contain a maximum of 100 entries. Key length has a limit of 40 characters.
+   * @param params.metadata (optional) The metadata for the room if the room will be created. Supports upto a maximum of 50 entries. Key length has a limit of 40 characters. Value length has a limit of 256 characters.
+   * @param options.signal (optional) An abort signal to cancel the request.
+   * @returns The room.
+   */
+  async getOrCreateRoom(roomId, params, options) {
+    try {
+      return await this.createRoom(roomId, params, options);
+    } catch (err) {
+      if (err instanceof LiveblocksError && err.status === 409) {
+        return await this.getRoom(roomId, options);
+      } else {
+        throw err;
+      }
+    }
+  }
+  /**
+   * Updates or creates a new room with the given properties.
+   *
+   * @param roomId The id of the room to update or create.
+   * @param params.defaultAccesses The default accesses for the room.
+   * @param params.groupsAccesses (optional) The group accesses for the room. Can contain a maximum of 100 entries. Key length has a limit of 40 characters.
+   * @param params.usersAccesses (optional) The user accesses for the room. Can contain a maximum of 100 entries. Key length has a limit of 40 characters.
+   * @param params.metadata (optional) The metadata for the room. Supports upto a maximum of 50 entries. Key length has a limit of 40 characters. Value length has a limit of 256 characters.
+   * @param options.signal (optional) An abort signal to cancel the request.
+   * @returns The room.
+   */
+  async upsertRoom(roomId, params, options) {
+    try {
+      return await this.createRoom(roomId, params, options);
+    } catch (err) {
+      if (err instanceof LiveblocksError && err.status === 409) {
+        return await this.updateRoom(roomId, params, options);
+      } else {
+        throw err;
+      }
+    }
+  }
   /**
    * Returns a room with the given id.
    * @param roomId The id of the room to return.
@@ -567,6 +713,27 @@ var Liveblocks = class {
     }
     return await res.json();
   }
+  async #requestStorageMutation(roomId, options) {
+    const resp = await this.#post(
+      url2`/v2/rooms/${roomId}/request-storage-mutation`,
+      {},
+      options
+    );
+    if (!resp.ok) {
+      throw await LiveblocksError.from(resp);
+    }
+    if (resp.headers.get("content-type") !== "application/x-ndjson") {
+      throw new Error("Unexpected response content type");
+    }
+    if (resp.body === null) {
+      throw new Error("Unexpected null body in response");
+    }
+    const stream = resp.body.pipeThrough(new TextDecoderStream()).pipeThrough(new LineStream()).pipeThrough(new NdJsonStream());
+    const iter = stream[Symbol.asyncIterator]();
+    const { actor } = await iter.next();
+    const nodes = await asyncConsume(iter);
+    return { actor, nodes };
+  }
   /**
    * Initializes a room’s Storage. The room must already exist and have an empty Storage.
    * Calling this endpoint will disconnect all users from the room if there are any.
@@ -1016,7 +1183,7 @@ var Liveblocks = class {
     const { roomId, threadId } = params;
     const res = await this.#post(
       url2`/v2/rooms/${roomId}/threads/${threadId}/mark-as-resolved`,
-      {},
+      { userId: params.data.userId },
       options
     );
     if (!res.ok) {
@@ -1036,7 +1203,7 @@ var Liveblocks = class {
     const { roomId, threadId } = params;
     const res = await this.#post(
       url2`/v2/rooms/${roomId}/threads/${threadId}/mark-as-unresolved`,
-      {},
+      { userId: params.data.userId },
       options
     );
     if (!res.ok) {
@@ -1156,17 +1323,51 @@ var Liveblocks = class {
     }
     const res = await this.#get(
       url2`/v2/users/${userId}/inbox-notifications`,
-      { query },
+      {
+        query,
+        limit: params?.limit,
+        startingAfter: params?.startingAfter
+      },
       options
     );
     if (!res.ok) {
       throw await LiveblocksError.from(res);
     }
-    const { data } = await res.json();
+    const page = await res.json();
     return {
-      data: data.map(convertToInboxNotificationData)
+      ...page,
+      data: page.data.map(convertToInboxNotificationData)
     };
   }
+  /**
+   * Iterates over all inbox notifications for a user.
+   *
+   * The difference with .getInboxNotifications() is that pagination will
+   * happen automatically under the hood, using the given `pageSize`.
+   *
+   * @param criteria.userId The user ID to get the inbox notifications from.
+   * @param criteria.query The query to filter inbox notifications by. It is based on our query language and can filter by unread.
+   * @param options.pageSize (optional) The page size to use for each request.
+   * @param options.signal (optional) An abort signal to cancel the request.
+   */
+  async *iterInboxNotifications(criteria, options) {
+    const { signal } = options ?? {};
+    const pageSize = checkBounds("pageSize", options?.pageSize ?? 50, 10);
+    let cursor = void 0;
+    while (true) {
+      const { nextCursor, data } = await this.getInboxNotifications(
+        { ...criteria, startingAfter: cursor, limit: pageSize },
+        { signal }
+      );
+      for (const item of data) {
+        yield item;
+      }
+      if (!nextCursor) {
+        break;
+      }
+      cursor = nextCursor;
+    }
+  }
   /**
    * Gets the user's room notification settings.
    * @param params.userId The user ID to get the room notifications from.
@@ -1338,6 +1539,121 @@ var Liveblocks = class {
       throw await LiveblocksError.from(res);
     }
   }
+  /**
+   * Retrieves the current Storage contents for the given room ID and calls the
+   * provided callback function, in which you can mutate the Storage contents
+   * at will.
+   *
+   * If you need to run the same mutation across multiple rooms, prefer using
+   * `.massMutateStorage()` instead of looping over room IDs yourself.
+   */
+  async mutateStorage(roomId, callback, options) {
+    return this.#_mutateOneRoom(roomId, void 0, callback, options);
+  }
+  /**
+   * Retrieves the Storage contents for each room that matches the given
+   * criteria and calls the provided callback function, in which you can mutate
+   * the Storage contents at will.
+   *
+   * You can use the `criteria` parameter to select which rooms to process by
+   * their metadata. If you pass `{}` (empty object), all rooms will be
+   * selected and processed.
+   *
+   * This method will execute mutations in parallel, using the specified
+   * `concurrency` value. If you which to run the mutations serially, set
+   * `concurrency` to 1.
+   */
+  async massMutateStorage(criteria, callback, massOptions) {
+    const concurrency = checkBounds(
+      "concurrency",
+      massOptions?.concurrency ?? 8,
+      1,
+      20
+    );
+    const pageSize = Math.max(20, concurrency * 4);
+    const { signal } = massOptions ?? {};
+    const rooms = this.iterRooms(criteria, { pageSize, signal });
+    const options = { signal };
+    await runConcurrently(
+      rooms,
+      (roomData) => this.#_mutateOneRoom(roomData.id, roomData, callback, options),
+      concurrency
+    );
+  }
+  async #_mutateOneRoom(roomId, room, callback, options) {
+    const debounceInterval = 200;
+    const { signal, abort } = makeAbortController(options?.signal);
+    let opsBuffer = [];
+    let outstandingFlush$ = void 0;
+    let lastFlush = performance.now();
+    const flushIfNeeded = (force) => {
+      if (opsBuffer.length === 0)
+        return;
+      if (outstandingFlush$) {
+        return;
+      }
+      const now = performance.now();
+      if (!(force || now - lastFlush > debounceInterval)) {
+        return;
+      }
+      lastFlush = now;
+      const ops = opsBuffer;
+      opsBuffer = [];
+      outstandingFlush$ = this.#sendMessage(
+        roomId,
+        [{ type: ClientMsgCode.UPDATE_STORAGE, ops }],
+        { signal }
+      ).catch((err) => {
+        abort(err);
+      }).finally(() => {
+        outstandingFlush$ = void 0;
+      });
+    };
+    try {
+      const resp = await this.#requestStorageMutation(roomId, { signal });
+      const { actor, nodes } = resp;
+      const pool = createManagedPool(roomId, {
+        getCurrentConnectionId: () => actor,
+        onDispatch: (ops, _reverse, _storageUpdates) => {
+          if (ops.length === 0) return;
+          for (const op of ops) {
+            opsBuffer.push(op);
+          }
+          flushIfNeeded(
+            /* force */
+            false
+          );
+        }
+      });
+      const root = LiveObject._fromItems(nodes, pool);
+      const callback$ = callback({ room, root });
+      flushIfNeeded(
+        /* force */
+        true
+      );
+      await callback$;
+    } catch (e) {
+      abort();
+      throw e;
+    } finally {
+      await outstandingFlush$;
+      flushIfNeeded(
+        /* force */
+        true
+      );
+      await outstandingFlush$;
+    }
+  }
+  async #sendMessage(roomId, messages, options) {
+    const res = await this.#post(
+      url2`/v2/rooms/${roomId}/send-message`,
+      { messages },
+      { signal: options?.signal }
+    );
+    if (!res.ok) {
+      throw await LiveblocksError.from(res);
+    }
+  }
 };
 var LiveblocksError = class _LiveblocksError extends Error {
   status;