@liveblocks/server 1.2.0 → 1.2.1

package/dist/index.js

@@ -12,16 +12,139 @@ var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "
 // src/decoders/ClientMsg.ts
 import { ClientMsgCode } from "@liveblocks/core";
 import {
-  array,
+  array as array2,
   boolean,
   constant as constant2,
+  jsonObject,
+  nonEmptyString,
   number,
   object as object2,
-  optional as optional2,
-  string as string2,
+  optional as optional3,
+  string as string3,
   taggedUnion as taggedUnion2
 } from "decoders";
 
+// src/protocol/feedMessages.ts
+var FeedMsgCode = {
+  // Server → client (50x)
+  FEEDS_LIST: 500,
+  FEEDS_ADDED: 501,
+  FEEDS_UPDATED: 502,
+  FEED_DELETED: 503,
+  FEED_MESSAGES_LIST: 504,
+  FEED_MESSAGES_ADDED: 505,
+  FEED_MESSAGES_UPDATED: 506,
+  FEED_MESSAGES_DELETED: 507,
+  FEED_REQUEST_FAILED: 508,
+  // Client → server (51x)
+  FETCH_FEEDS: 510,
+  FETCH_FEED_MESSAGES: 511,
+  ADD_FEED: 512,
+  UPDATE_FEED: 513,
+  DELETE_FEED: 514,
+  ADD_FEED_MESSAGE: 515,
+  UPDATE_FEED_MESSAGE: 516,
+  DELETE_FEED_MESSAGE: 517
+};
+var FeedRequestErrorCode = {
+  INTERNAL: "INTERNAL",
+  FEED_ALREADY_EXISTS: "FEED_ALREADY_EXISTS",
+  FEED_NOT_FOUND: "FEED_NOT_FOUND",
+  FEED_MESSAGE_NOT_FOUND: "FEED_MESSAGE_NOT_FOUND"
+};
+
+// src/protocol/feedErrors.ts
+function feedRequestFailed(requestId, code, reason) {
+  return {
+    type: FeedMsgCode.FEED_REQUEST_FAILED,
+    requestId: requestId ?? "",
+    code,
+    reason
+  };
+}
+function mapFeedError(err) {
+  if (!(err instanceof Error)) {
+    return { code: FeedRequestErrorCode.INTERNAL };
+  }
+  const m = err.message;
+  if (m.includes("already exists")) {
+    return { code: FeedRequestErrorCode.FEED_ALREADY_EXISTS, reason: m };
+  }
+  if (m.includes("Feed message") && m.includes("not found")) {
+    return { code: FeedRequestErrorCode.FEED_MESSAGE_NOT_FOUND, reason: m };
+  }
+  if (m.includes("not found")) {
+    return { code: FeedRequestErrorCode.FEED_NOT_FOUND, reason: m };
+  }
+  return { code: FeedRequestErrorCode.INTERNAL, reason: m };
+}
+function feedFailureServerMsg(requestId, err) {
+  const mapped = mapFeedError(err);
+  return feedRequestFailed(requestId, mapped.code, mapped.reason);
+}
+
+// src/protocol/ProtocolVersion.ts
+import { enum_ } from "decoders";
+var ProtocolVersion = /* @__PURE__ */ ((ProtocolVersion2) => {
+  ProtocolVersion2[ProtocolVersion2["V7"] = 7] = "V7";
+  ProtocolVersion2[ProtocolVersion2["V8"] = 8] = "V8";
+  return ProtocolVersion2;
+})(ProtocolVersion || {});
+var protocolVersionDecoder = enum_(ProtocolVersion).describe(
+  "Unsupported protocol version"
+);
+
+// src/decoders/feedMetadata.ts
+import {
+  array,
+  either,
+  identifier,
+  nullable,
+  optional,
+  poja,
+  record,
+  select,
+  sized,
+  string
+} from "decoders";
+var MAX_METADATA_COUNT = 50;
+var MAX_METADATA_VALUE_LIST_LENGTH = 50;
+var feedMetadataIdDecoder = sized(identifier, { min: 1, max: 40 });
+var metadataStringValue = sized(string, { max: 256 });
+function createRoomMetadataValueDecoder() {
+  return select(
+    either(string, poja).describe("Must be string or string[]"),
+    (x) => typeof x === "string" ? metadataStringValue : array(metadataStringValue).refine(
+      (value) => value.length <= MAX_METADATA_VALUE_LIST_LENGTH,
+      `Must be at most ${MAX_METADATA_VALUE_LIST_LENGTH} items`
+    )
+  );
+}
+var roomMetadataValueDecoder = createRoomMetadataValueDecoder();
+var feedMetadataNullableValueDecoder = nullable(roomMetadataValueDecoder);
+var feedMetadataRecordForCreate = record(
+  feedMetadataIdDecoder,
+  roomMetadataValueDecoder
+).refine(
+  (value) => Object.keys(value).length <= MAX_METADATA_COUNT,
+  `Must be at most ${MAX_METADATA_COUNT} items`
+);
+var optionalFeedMetadataDecoder = optional(feedMetadataRecordForCreate);
+var feedMetadataUpdateDecoder = record(
+  feedMetadataIdDecoder,
+  feedMetadataNullableValueDecoder
+);
+var feedMetadataRecordForFilter = record(
+  feedMetadataIdDecoder,
+  feedMetadataNullableValueDecoder
+).refine(
+  (value) => Object.keys(value).length <= MAX_METADATA_COUNT,
+  `Must be at most ${MAX_METADATA_COUNT} items`
+);
+var fetchFeedsMetadataFilterDecoder = optional(
+  feedMetadataRecordForFilter
+);
+
 // src/decoders/jsonYolo.ts
 import { unknown } from "decoders";
 var jsonYolo = unknown;
@@ -32,67 +155,67 @@ var jsonObjectYolo = jsonYolo.refine(
 
 // src/decoders/Op.ts
 import { OpCode } from "@liveblocks/core";
-import { constant, object, optional, string, taggedUnion } from "decoders";
+import { constant, object, optional as optional2, string as string2, taggedUnion } from "decoders";
 var updateObjectOp = object({
   type: constant(OpCode.UPDATE_OBJECT),
-  opId: string,
-  id: string,
+  opId: string2,
+  id: string2,
   data: jsonObjectYolo
 });
 var createObjectOp = object({
   type: constant(OpCode.CREATE_OBJECT),
-  opId: string,
-  id: string,
-  parentId: string,
-  parentKey: string,
+  opId: string2,
+  id: string2,
+  parentId: string2,
+  parentKey: string2,
   data: jsonObjectYolo,
-  intent: optional(constant("set")),
-  deletedId: optional(string)
+  intent: optional2(constant("set")),
+  deletedId: optional2(string2)
 });
 var createListOp = object({
   type: constant(OpCode.CREATE_LIST),
-  opId: string,
-  id: string,
-  parentId: string,
-  parentKey: string,
-  intent: optional(constant("set")),
-  deletedId: optional(string)
+  opId: string2,
+  id: string2,
+  parentId: string2,
+  parentKey: string2,
+  intent: optional2(constant("set")),
+  deletedId: optional2(string2)
 });
 var createMapOp = object({
   type: constant(OpCode.CREATE_MAP),
-  opId: string,
-  id: string,
-  parentId: string,
-  parentKey: string,
-  intent: optional(constant("set")),
-  deletedId: optional(string)
+  opId: string2,
+  id: string2,
+  parentId: string2,
+  parentKey: string2,
+  intent: optional2(constant("set")),
+  deletedId: optional2(string2)
 });
 var createRegisterOp = object({
   type: constant(OpCode.CREATE_REGISTER),
-  opId: string,
-  id: string,
-  parentId: string,
-  parentKey: string,
+  opId: string2,
+  id: string2,
+  parentId: string2,
+  parentKey: string2,
   data: jsonYolo,
-  intent: optional(constant("set")),
-  deletedId: optional(string)
+  intent: optional2(constant("set")),
+  deletedId: optional2(string2)
 });
 var deleteCrdtOp = object({
   type: constant(OpCode.DELETE_CRDT),
-  opId: string,
-  id: string
+  opId: string2,
+  id: string2
 });
 var setParentKeyOp = object({
   type: constant(OpCode.SET_PARENT_KEY),
-  opId: string,
-  id: string,
-  parentKey: string
+  opId: string2,
+  id: string2,
+  parentKey: string2
 });
 var deleteObjectKeyOp = object({
   type: constant(OpCode.DELETE_OBJECT_KEY),
-  opId: string,
-  id: string,
-  key: string
+  opId: string2,
+  id: string2,
+  key: string2
 });
 var op = taggedUnion("type", {
   [OpCode.UPDATE_OBJECT]: updateObjectOp,
@@ -114,7 +237,7 @@ var ROOT_YDOC_ID = "root";
 var updatePresenceClientMsg = object2({
   type: constant2(ClientMsgCode.UPDATE_PRESENCE),
   data: jsonObjectYolo,
-  targetActor: optional2(number)
+  targetActor: optional3(number)
 });
 var broadcastEventClientMsg = object2({
   type: constant2(ClientMsgCode.BROADCAST_EVENT),
@@ -125,21 +248,77 @@ var fetchStorageClientMsg = object2({
 });
 var updateStorageClientMsg = object2({
   type: constant2(ClientMsgCode.UPDATE_STORAGE),
-  ops: array(op)
+  ops: array2(op)
 });
 var fetchYDocClientMsg = object2({
   type: constant2(ClientMsgCode.FETCH_YDOC),
-  vector: string2.refineType(),
-  guid: optional2(guidDecoder),
+  vector: string3.refineType(),
+  guid: optional3(guidDecoder),
   // Don't specify to update the root doc
-  v2: optional2(boolean)
+  v2: optional3(boolean)
 });
 var updateYDocClientMsg = object2({
   type: constant2(ClientMsgCode.UPDATE_YDOC),
-  update: string2.refineType(),
-  guid: optional2(guidDecoder),
+  update: string3.refineType(),
+  guid: optional3(guidDecoder),
   // Don't specify to update the root doc
-  v2: optional2(boolean)
+  v2: optional3(boolean)
+});
+var fetchFeedsClientMsg = object2({
+  type: constant2(FeedMsgCode.FETCH_FEEDS),
+  requestId: string3,
+  cursor: optional3(string3),
+  since: optional3(number),
+  limit: optional3(number),
+  metadata: fetchFeedsMetadataFilterDecoder
+});
+var fetchFeedMessagesClientMsg = object2({
+  type: constant2(FeedMsgCode.FETCH_FEED_MESSAGES),
+  requestId: string3,
+  feedId: nonEmptyString,
+  cursor: optional3(string3),
+  since: optional3(number),
+  limit: optional3(number)
+});
+var addFeedClientMsg = object2({
+  type: constant2(FeedMsgCode.ADD_FEED),
+  feedId: string3,
+  metadata: optionalFeedMetadataDecoder,
+  timestamp: optional3(number),
+  requestId: optional3(string3)
+});
+var updateFeedClientMsg = object2({
+  type: constant2(FeedMsgCode.UPDATE_FEED),
+  feedId: string3,
+  metadata: feedMetadataUpdateDecoder,
+  requestId: optional3(string3)
+});
+var deleteFeedClientMsg = object2({
+  type: constant2(FeedMsgCode.DELETE_FEED),
+  feedId: string3,
+  requestId: optional3(string3)
+});
+var addFeedMessageClientMsg = object2({
+  type: constant2(FeedMsgCode.ADD_FEED_MESSAGE),
+  feedId: string3,
+  data: jsonObject,
+  id: optional3(string3),
+  timestamp: optional3(number),
+  requestId: optional3(string3)
+});
+var updateFeedMessageClientMsg = object2({
+  type: constant2(FeedMsgCode.UPDATE_FEED_MESSAGE),
+  feedId: string3,
+  messageId: string3,
+  data: jsonObject,
+  timestamp: optional3(number),
+  requestId: optional3(string3)
+});
+var deleteFeedMessageClientMsg = object2({
+  type: constant2(FeedMsgCode.DELETE_FEED_MESSAGE),
+  feedId: string3,
+  messageId: string3,
+  requestId: optional3(string3)
 });
 var clientMsgDecoder = taggedUnion2("type", {
   [ClientMsgCode.UPDATE_PRESENCE]: updatePresenceClientMsg,
@@ -147,7 +326,15 @@ var clientMsgDecoder = taggedUnion2("type", {
   [ClientMsgCode.FETCH_STORAGE]: fetchStorageClientMsg,
   [ClientMsgCode.UPDATE_STORAGE]: updateStorageClientMsg,
   [ClientMsgCode.FETCH_YDOC]: fetchYDocClientMsg,
-  [ClientMsgCode.UPDATE_YDOC]: updateYDocClientMsg
+  [ClientMsgCode.UPDATE_YDOC]: updateYDocClientMsg,
+  [FeedMsgCode.FETCH_FEEDS]: fetchFeedsClientMsg,
+  [FeedMsgCode.FETCH_FEED_MESSAGES]: fetchFeedMessagesClientMsg,
+  [FeedMsgCode.ADD_FEED]: addFeedClientMsg,
+  [FeedMsgCode.UPDATE_FEED]: updateFeedClientMsg,
+  [FeedMsgCode.DELETE_FEED]: deleteFeedClientMsg,
+  [FeedMsgCode.ADD_FEED_MESSAGE]: addFeedMessageClientMsg,
+  [FeedMsgCode.UPDATE_FEED_MESSAGE]: updateFeedMessageClientMsg,
+  [FeedMsgCode.DELETE_FEED_MESSAGE]: deleteFeedMessageClientMsg
 }).describe("Must be a valid client message");
 var transientClientMsgDecoder = taggedUnion2("type", {
   // [ClientMsgCode.UPDATE_PRESENCE]: updatePresenceClientMsg,
@@ -628,17 +815,6 @@ function makeMetadataDB(driver) {
   };
 }
 
-// src/protocol/ProtocolVersion.ts
-import { enum_ } from "decoders";
-var ProtocolVersion = /* @__PURE__ */ ((ProtocolVersion2) => {
-  ProtocolVersion2[ProtocolVersion2["V7"] = 7] = "V7";
-  ProtocolVersion2[ProtocolVersion2["V8"] = 8] = "V8";
-  return ProtocolVersion2;
-})(ProtocolVersion || {});
-var protocolVersionDecoder = enum_(ProtocolVersion).describe(
-  "Unsupported protocol version"
-);
-
 // src/Room.ts
 import {
   assertNever as assertNever3,
@@ -646,12 +822,12 @@ import {
   nodeStreamToCompactNodes,
   OpCode as OpCode3,
   raise as raise3,
-  ServerMsgCode as ServerMsgCode2,
+  ServerMsgCode as CoreServerMsgCode,
   tryParseJson,
   WebsocketCloseCodes as CloseCode
 } from "@liveblocks/core";
 import { Mutex, tryAcquire } from "async-mutex";
-import { array as array2, formatInline } from "decoders";
+import { array as array3, formatInline } from "decoders";
 import { chunked } from "itertools";
 import { nanoid as nanoid2 } from "nanoid";
 
@@ -845,16 +1021,21 @@ function hasStaticDataAt(node, key) {
   return node.type === CrdtType4.OBJECT && Object.prototype.hasOwnProperty.call(node.data, key) && node.data[key] !== void 0;
 }
 var InMemoryDriver = class {
+  // Key: `${feedId}:${messageId}`
   constructor(options) {
     __publicField(this, "_nextActor");
     __publicField(this, "_nodes");
     __publicField(this, "_metadb");
     __publicField(this, "_ydb");
     __publicField(this, "_leasedSessions");
+    __publicField(this, "_feeds");
+    __publicField(this, "_feedMessages");
     this._nodes = /* @__PURE__ */ new Map();
     this._metadb = /* @__PURE__ */ new Map();
     this._ydb = /* @__PURE__ */ new Map();
     this._leasedSessions = /* @__PURE__ */ new Map();
+    this._feeds = /* @__PURE__ */ new Map();
+    this._feedMessages = /* @__PURE__ */ new Map();
     this._nextActor = options?.initialActor ?? -1;
     for (const [key, value] of options?.initialNodes ?? []) {
       this._nodes.set(key, value);
@@ -894,6 +1075,180 @@ var InMemoryDriver = class {
   takeRowsWritten() {
     return 0;
   }
+  // ---------------------------------------------------------------------------
+  // Feed APIs
+  // ---------------------------------------------------------------------------
+  async list_feeds(options) {
+    const limit = Math.min(options?.limit ?? 20, 100);
+    const since = options?.since;
+    const cursor = options?.cursor;
+    const metadata = options?.metadata;
+    let feeds = [];
+    for (const [_, feed] of this._feeds.entries()) {
+      if (metadata !== void 0) {
+        const feedMetadata = feed.metadata;
+        let matches = true;
+        for (const [key, value] of Object.entries(metadata)) {
+          if (feedMetadata[key] !== value) {
+            matches = false;
+            break;
+          }
+        }
+        if (!matches) continue;
+      }
+      if (since !== void 0 && feed.createdAt < since) {
+        continue;
+      }
+      feeds.push(feed);
+    }
+    feeds.sort((a, b) => {
+      if (b.createdAt !== a.createdAt) {
+        return b.createdAt - a.createdAt;
+      }
+      return b.feedId.localeCompare(a.feedId);
+    });
+    if (cursor !== void 0) {
+      try {
+        const decoded = JSON.parse(
+          decodeURIComponent(
+            escape(atob(cursor.replace(/-/g, "+").replace(/_/g, "/")))
+          )
+        );
+        const [cursorFeedId, cursorCreatedAt] = decoded;
+        feeds = feeds.filter((s) => {
+          return s.createdAt < cursorCreatedAt || s.createdAt === cursorCreatedAt && s.feedId < cursorFeedId;
+        });
+      } catch {
+      }
+    }
+    let nextCursor;
+    if (feeds.length > limit) {
+      feeds = feeds.slice(0, limit);
+      const last = feeds[feeds.length - 1];
+      if (last) {
+        const cursorData = [last.feedId, last.createdAt];
+        nextCursor = btoa(
+          unescape(encodeURIComponent(JSON.stringify(cursorData)))
+        ).replace("/", "_").replace("+", "-").replace(/=+$/, "");
+      }
+    }
+    return { feeds, nextCursor };
+  }
+  async get_feed(feedId) {
+    const feed = this._feeds.get(feedId);
+    if (feed === void 0) {
+      return void 0;
+    }
+    return feed;
+  }
+  async create_feed(feed) {
+    if (this._feeds.has(feed.feedId)) {
+      throw new Error(`Feed ${feed.feedId} already exists`);
+    }
+    this._feeds.set(feed.feedId, {
+      feedId: feed.feedId,
+      metadata: feed.metadata,
+      createdAt: feed.createdAt,
+      updatedAt: feed.updatedAt
+    });
+  }
+  async update_feed_metadata(feedId, metadata) {
+    const existing = this._feeds.get(feedId);
+    if (existing === void 0) {
+      throw new Error(`Feed ${feedId} not found`);
+    }
+    this._feeds.set(feedId, {
+      ...existing,
+      metadata
+    });
+  }
+  async delete_feed(feedId) {
+    const messageKeys = [];
+    for (const [key] of this._feedMessages.entries()) {
+      if (key.startsWith(`${feedId}:`)) {
+        messageKeys.push(key);
+      }
+    }
+    for (const key of messageKeys) {
+      this._feedMessages.delete(key);
+    }
+    this._feeds.delete(feedId);
+  }
+  async list_feed_messages(feedId, options) {
+    const limit = Math.min(options?.limit ?? 20, 100);
+    const since = options?.since;
+    const cursor = options?.cursor;
+    let messages = [];
+    const prefix = `${feedId}:`;
+    for (const [key, message] of this._feedMessages.entries()) {
+      if (key.startsWith(prefix)) {
+        if (since !== void 0 && message.createdAt < since) {
+          continue;
+        }
+        messages.push(message);
+      }
+    }
+    messages.sort((a, b) => {
+      if (b.createdAt !== a.createdAt) {
+        return b.createdAt - a.createdAt;
+      }
+      return b.id.localeCompare(a.id);
+    });
+    if (cursor !== void 0) {
+      try {
+        const decoded = JSON.parse(
+          decodeURIComponent(
+            escape(atob(cursor.replace(/-/g, "+").replace(/_/g, "/")))
+          )
+        );
+        const [cursorMessageId, cursorCreatedAt] = decoded;
+        messages = messages.filter((m) => {
+          return m.createdAt < cursorCreatedAt || m.createdAt === cursorCreatedAt && m.id < cursorMessageId;
+        });
+      } catch {
+      }
+    }
+    let nextCursor;
+    if (messages.length > limit) {
+      messages = messages.slice(0, limit);
+      const last = messages[messages.length - 1];
+      if (last) {
+        const cursorData = [last.id, last.createdAt];
+        nextCursor = btoa(
+          unescape(encodeURIComponent(JSON.stringify(cursorData)))
+        ).replace("/", "_").replace("+", "-").replace(/=+$/, "");
+      }
+    }
+    return { messages, nextCursor };
+  }
+  async add_feed_message(feedId, message) {
+    const feed = this._feeds.get(feedId);
+    if (feed === void 0) {
+      throw new Error(`Feed ${feedId} not found`);
+    }
+    this._feedMessages.set(`${feedId}:${message.id}`, message);
+  }
+  async update_feed_message(feedId, messageId, data, timestamp) {
+    const key = `${feedId}:${messageId}`;
+    const message = this._feedMessages.get(key);
+    if (message === void 0) {
+      throw new Error(`Feed message ${messageId} not found in feed ${feedId}`);
+    }
+    const effectiveTimestamp = timestamp ?? Date.now();
+    if (effectiveTimestamp < message.updatedAt) {
+      return message;
+    }
+    const updatedMessage = {
+      ...message,
+      updatedAt: effectiveTimestamp,
+      data
+    };
+    this._feedMessages.set(key, updatedMessage);
+    return updatedMessage;
+  }
+  async delete_feed_message(feedId, messageId) {
+    this._feedMessages.delete(`${feedId}:${messageId}`);
+  }
   next_actor() {
     return ++this._nextActor;
   }
@@ -1672,7 +2027,8 @@ function isLeasedSessionExpired(leasedSession) {
 }
 
 // src/Room.ts
-var messagesDecoder = array2(clientMsgDecoder);
+var messagesDecoder = array3(clientMsgDecoder);
+var ServerMsgCode2 = { ...CoreServerMsgCode, ...FeedMsgCode };
 var HIGHEST_PROTOCOL_VERSION = Math.max(
   ...Object.values(ProtocolVersion).filter(
     (v) => typeof v === "number"
@@ -2368,6 +2724,87 @@ var Room = class {
       await this.deleteLeasedSession(session, ctx, defer);
     }
   }
+  // ---------------------------------------------------------------------------
+  // Feed APIs
+  // ---------------------------------------------------------------------------
+  /**
+   * List feeds with pagination and filtering.
+   */
+  async listFeeds(options) {
+    return await this.driver.list_feeds(options);
+  }
+  /**
+   * Get a specific feed by feed ID.
+   */
+  async getFeed(feedId) {
+    return await this.driver.get_feed(feedId);
+  }
+  /**
+   * Create a new feed.
+   * If timestamp is not provided, current server time is used.
+   */
+  async createFeed(feed) {
+    const now = feed.timestamp ?? Date.now();
+    const fullFeed = {
+      ...feed,
+      createdAt: now,
+      updatedAt: now
+    };
+    await this.driver.create_feed(fullFeed);
+    return fullFeed;
+  }
+  /**
+   * Update a feed's metadata.
+   */
+  async updateFeedMetadata(feedId, metadata) {
+    await this.driver.update_feed_metadata(feedId, metadata);
+  }
+  /**
+   * Delete a feed.
+   */
+  async deleteFeed(feedId) {
+    await this.driver.delete_feed(feedId);
+  }
+  /**
+   * List feed messages for a feed with pagination.
+   */
+  async listFeedMessages(feedId, options) {
+    return await this.driver.list_feed_messages(feedId, options);
+  }
+  /**
+   * Add a message to a feed.
+   * If message id is not provided, a unique ID is automatically generated.
+   * If timestamp is not provided, current server time is used.
+   */
+  async addFeedMessage(feedId, message) {
+    const now = message.timestamp ?? Date.now();
+    const fullMessage = {
+      id: message.id ?? nanoid2(),
+      createdAt: now,
+      updatedAt: now,
+      data: message.data
+    };
+    await this.driver.add_feed_message(feedId, fullMessage);
+    return fullMessage;
+  }
+  /**
+   * Update a feed message's data.
+   * Returns the updated message.
+   */
+  async updateFeedMessage(feedId, messageId, data, timestamp) {
+    return await this.driver.update_feed_message(
+      feedId,
+      messageId,
+      data,
+      timestamp ?? Date.now()
+    );
+  }
+  /**
+   * Delete a feed message.
+   */
+  async deleteFeedMessage(feedId, messageId) {
+    await this.driver.delete_feed_message(feedId, messageId);
+  }
   /**
    * Will send the given ServerMsg through all Session, except the Session
    * where the message originates from.
@@ -2704,6 +3141,176 @@ var Room = class {
         }
         break;
       }
+      case FeedMsgCode.FETCH_FEEDS: {
+        const fetchMsg = msg;
+        const [result, err] = await tryCatch(
+          this.listFeeds({
+            cursor: fetchMsg.cursor,
+            since: fetchMsg.since,
+            limit: fetchMsg.limit,
+            metadata: fetchMsg.metadata
+          })
+        );
+        if (err) {
+          replyImmediately(feedFailureServerMsg(fetchMsg.requestId, err));
+          break;
+        }
+        replyImmediately({
+          type: FeedMsgCode.FEEDS_LIST,
+          requestId: fetchMsg.requestId,
+          feeds: result.feeds,
+          nextCursor: result.nextCursor
+        });
+        break;
+      }
+      case FeedMsgCode.FETCH_FEED_MESSAGES: {
+        const fetchMsg = msg;
+        const [result, err] = await tryCatch(
+          this.listFeedMessages(fetchMsg.feedId, {
+            cursor: fetchMsg.cursor,
+            since: fetchMsg.since,
+            limit: fetchMsg.limit
+          })
+        );
+        if (err) {
+          replyImmediately(feedFailureServerMsg(fetchMsg.requestId, err));
+          break;
+        }
+        replyImmediately({
+          type: FeedMsgCode.FEED_MESSAGES_LIST,
+          requestId: fetchMsg.requestId,
+          feedId: fetchMsg.feedId,
+          messages: result.messages,
+          nextCursor: result.nextCursor
+        });
+        break;
+      }
+      case FeedMsgCode.ADD_FEED: {
+        const addMsg = msg;
+        const [feed, err] = await tryCatch(
+          this.createFeed({
+            feedId: addMsg.feedId,
+            metadata: addMsg.metadata ?? {},
+            timestamp: addMsg.timestamp
+          })
+        );
+        if (err) {
+          replyImmediately(feedFailureServerMsg(addMsg.requestId, err));
+          break;
+        }
+        const feedsMsg = {
+          type: FeedMsgCode.FEEDS_ADDED,
+          feeds: [feed]
+        };
+        replyImmediately(feedsMsg);
+        scheduleFanOut(feedsMsg);
+        break;
+      }
+      case FeedMsgCode.UPDATE_FEED: {
+        const updateMsg = msg;
+        const [, metaErr] = await tryCatch(
+          this.updateFeedMetadata(updateMsg.feedId, updateMsg.metadata)
+        );
+        if (metaErr) {
+          replyImmediately(feedFailureServerMsg(updateMsg.requestId, metaErr));
+          break;
+        }
+        const feed = await this.getFeed(updateMsg.feedId);
+        if (!feed) {
+          replyImmediately(
+            feedRequestFailed(
+              updateMsg.requestId,
+              FeedRequestErrorCode.FEED_NOT_FOUND
+            )
+          );
+          break;
+        }
+        const feedsMsg = {
+          type: FeedMsgCode.FEEDS_UPDATED,
+          feeds: [feed]
+        };
+        replyImmediately(feedsMsg);
+        scheduleFanOut(feedsMsg);
+        break;
+      }
+      case FeedMsgCode.DELETE_FEED: {
+        const deleteMsg = msg;
+        const [, err] = await tryCatch(this.deleteFeed(deleteMsg.feedId));
+        if (err) {
+          replyImmediately(feedFailureServerMsg(deleteMsg.requestId, err));
+          break;
+        }
+        const feedDeletedMsg = {
+          type: FeedMsgCode.FEED_DELETED,
+          feedId: deleteMsg.feedId
+        };
+        replyImmediately(feedDeletedMsg);
+        scheduleFanOut(feedDeletedMsg);
+        break;
+      }
+      case FeedMsgCode.ADD_FEED_MESSAGE: {
+        const addMsg = msg;
+        const [message, err] = await tryCatch(
+          this.addFeedMessage(addMsg.feedId, {
+            data: addMsg.data,
+            id: addMsg.id,
+            timestamp: addMsg.timestamp
+          })
+        );
+        if (err) {
+          replyImmediately(feedFailureServerMsg(addMsg.requestId, err));
+          break;
+        }
+        const feedMessagesMsg = {
+          type: FeedMsgCode.FEED_MESSAGES_ADDED,
+          feedId: addMsg.feedId,
+          messages: [message]
+        };
+        replyImmediately(feedMessagesMsg);
+        scheduleFanOut(feedMessagesMsg);
+        break;
+      }
+      case FeedMsgCode.UPDATE_FEED_MESSAGE: {
+        const updateMsg = msg;
+        const [message, err] = await tryCatch(
+          this.updateFeedMessage(
+            updateMsg.feedId,
+            updateMsg.messageId,
+            updateMsg.data,
+            updateMsg.timestamp
+          )
+        );
+        if (err) {
+          replyImmediately(feedFailureServerMsg(updateMsg.requestId, err));
+          break;
+        }
+        const feedMessagesMsg = {
+          type: FeedMsgCode.FEED_MESSAGES_UPDATED,
+          feedId: updateMsg.feedId,
+          messages: [message]
+        };
+        replyImmediately(feedMessagesMsg);
+        scheduleFanOut(feedMessagesMsg);
+        break;
+      }
+      case FeedMsgCode.DELETE_FEED_MESSAGE: {
+        const deleteMsg = msg;
+        const [, err] = await tryCatch(
+          this.deleteFeedMessage(deleteMsg.feedId, deleteMsg.messageId)
+        );
+        if (err) {
+          replyImmediately(feedFailureServerMsg(deleteMsg.requestId, err));
+          break;
+        }
+        const feedMessagesMsg = {
+          type: FeedMsgCode.FEED_MESSAGES_DELETED,
+          feedId: deleteMsg.feedId,
+          messageIds: [deleteMsg.messageId]
+        };
+        replyImmediately(feedMessagesMsg);
+        scheduleFanOut(feedMessagesMsg);
+        break;
+      }
       default: {
         try {
           return assertNever3(msg, "Unrecognized client msg");
@@ -2720,6 +3327,8 @@ export {
   BrowserSession,
   ConsoleTarget,
   DefaultMap,
+  FeedMsgCode,
+  FeedRequestErrorCode,
   InMemoryDriver,
   LogLevel,
   LogTarget,
@@ -2732,12 +3341,19 @@ export {
   ackIgnoredOp,
   clientMsgDecoder,
   concatUint8Arrays,
+  feedFailureServerMsg,
+  feedMetadataIdDecoder,
+  feedMetadataUpdateDecoder,
+  feedRequestFailed,
+  fetchFeedsMetadataFilterDecoder,
   guidDecoder,
   isLeasedSessionExpired,
   jsonObjectYolo,
   jsonYolo,
   makeInMemorySnapshot,
   makeMetadataDB,
+  mapFeedError,
+  optionalFeedMetadataDecoder,
   plainLsonToNodeStream,
   protocolVersionDecoder,
   quote,