@frontmcp/utils 1.10.15 → 1.11.0-rc.1

package/browser/storage/adapters/upstash.mjs

@@ -0,0 +1,299 @@
+// libs/utils/src/storage/adapters/upstash.ts
+import { StorageConfigError, StorageConnectionError } from "../errors.mjs";
+import { COMPARE_AND_DELETE_SCRIPT, COMPARE_AND_EXPIRE_SCRIPT } from "../utils/compare-and-delete.mjs";
+import { validateTTL } from "../utils/ttl.mjs";
+import { BaseStorageAdapter } from "./base.mjs";
+async function loadUpstashRedis() {
+  try {
+    const mod = await import("@upstash/redis");
+    const resolved = typeof mod.Redis === "function" ? mod : mod.default;
+    if (!resolved || typeof resolved.Redis !== "function") throw new Error("Redis missing");
+    return resolved;
+  } catch {
+    throw new Error(
+      "@upstash/redis is required for Upstash storage adapter. Install it with: npm install @upstash/redis"
+    );
+  }
+}
+var PUBSUB_POLL_INTERVAL_MS = 100;
+var UpstashStorageAdapter = class extends BaseStorageAdapter {
+  backendName = "upstash";
+  client;
+  options;
+  keyPrefix;
+  pubSubEnabled;
+  // Pub/sub state
+  subscriptionHandlers = /* @__PURE__ */ new Map();
+  pollingIntervals = /* @__PURE__ */ new Map();
+  constructor(options = {}) {
+    super();
+    const url = options.url ?? process.env["UPSTASH_REDIS_REST_URL"];
+    const token = options.token ?? process.env["UPSTASH_REDIS_REST_TOKEN"];
+    if (!url || !token) {
+      throw new StorageConfigError(
+        "upstash",
+        "UPSTASH_REDIS_REST_URL and UPSTASH_REDIS_REST_TOKEN must be provided via options or environment variables."
+      );
+    }
+    this.options = { ...options, url, token };
+    this.keyPrefix = options.keyPrefix ?? "";
+    this.pubSubEnabled = options.enablePubSub ?? false;
+  }
+  // ============================================
+  // Connection Lifecycle
+  // ============================================
+  async connect() {
+    if (this.connected) return;
+    try {
+      const { Redis } = await loadUpstashRedis();
+      const url = this.options.url;
+      const token = this.options.token;
+      if (!url || !token) {
+        throw new StorageConfigError("upstash", "URL and token are required");
+      }
+      this.client = new Redis({ url, token, automaticDeserialization: false });
+      await this.client.exists("__healthcheck__");
+      this.connected = true;
+    } catch (e) {
+      throw new StorageConnectionError(
+        "Failed to connect to Upstash Redis",
+        e instanceof Error ? e : void 0,
+        "upstash"
+      );
+    }
+  }
+  async disconnect() {
+    if (!this.connected) return;
+    for (const interval of this.pollingIntervals.values()) {
+      clearInterval(interval);
+    }
+    this.pollingIntervals.clear();
+    this.subscriptionHandlers.clear();
+    this.client = void 0;
+    this.connected = false;
+  }
+  async ping() {
+    if (!this.client) return false;
+    try {
+      await this.client.exists("__healthcheck__");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  // ============================================
+  // Connection Helpers
+  // ============================================
+  /**
+   * Get the connected Upstash client, throwing if not connected.
+   */
+  getConnectedClient() {
+    this.ensureConnected();
+    if (!this.client) {
+      throw new StorageConnectionError("Upstash client not connected", void 0, "upstash");
+    }
+    return this.client;
+  }
+  // ============================================
+  // Core Operations
+  // ============================================
+  async get(key) {
+    return this.getConnectedClient().get(this.prefixKey(key));
+  }
+  async doSet(key, value, options) {
+    const client = this.getConnectedClient();
+    const prefixedKey = this.prefixKey(key);
+    const setOptions = {};
+    if (options?.ttlSeconds) {
+      setOptions.ex = options.ttlSeconds;
+    }
+    if (options?.ifNotExists) {
+      setOptions.nx = true;
+    } else if (options?.ifExists) {
+      setOptions.xx = true;
+    }
+    await client.set(prefixedKey, value, Object.keys(setOptions).length > 0 ? setOptions : void 0);
+  }
+  async delete(key) {
+    const result = await this.getConnectedClient().del(this.prefixKey(key));
+    return result > 0;
+  }
+  async deleteIfEquals(key, expectedValue) {
+    const deleted = await this.getConnectedClient().eval(
+      COMPARE_AND_DELETE_SCRIPT,
+      [this.prefixKey(key)],
+      [expectedValue]
+    );
+    return deleted === 1;
+  }
+  async expireIfEquals(key, expectedValue, ttlSeconds) {
+    validateTTL(ttlSeconds);
+    const extended = await this.getConnectedClient().eval(
+      COMPARE_AND_EXPIRE_SCRIPT,
+      [this.prefixKey(key)],
+      [expectedValue, String(ttlSeconds)]
+    );
+    return extended === 1;
+  }
+  async exists(key) {
+    const result = await this.getConnectedClient().exists(this.prefixKey(key));
+    return result > 0;
+  }
+  // ============================================
+  // Batch Operations
+  // ============================================
+  async mget(keys) {
+    if (keys.length === 0) return [];
+    const prefixedKeys = keys.map((k) => this.prefixKey(k));
+    return this.getConnectedClient().mget(...prefixedKeys);
+  }
+  async mdelete(keys) {
+    if (keys.length === 0) return 0;
+    const prefixedKeys = keys.map((k) => this.prefixKey(k));
+    return this.getConnectedClient().del(...prefixedKeys);
+  }
+  // ============================================
+  // TTL Operations
+  // ============================================
+  async expire(key, ttlSeconds) {
+    validateTTL(ttlSeconds);
+    const result = await this.getConnectedClient().expire(this.prefixKey(key), ttlSeconds);
+    return result === 1;
+  }
+  async ttl(key) {
+    const result = await this.getConnectedClient().ttl(this.prefixKey(key));
+    if (result === -2) return null;
+    return result;
+  }
+  // ============================================
+  // Key Enumeration
+  // ============================================
+  async keys(pattern = "*") {
+    const client = this.getConnectedClient();
+    const prefixedPattern = this.prefixKey(pattern);
+    const result = [];
+    let cursor = 0;
+    do {
+      const [nextCursor, keys] = await client.scan(cursor, {
+        match: prefixedPattern,
+        count: 100
+      });
+      const parsedCursor = typeof nextCursor === "string" ? parseInt(nextCursor, 10) : nextCursor;
+      cursor = Number.isNaN(parsedCursor) ? 0 : parsedCursor;
+      for (const key of keys) {
+        result.push(this.unprefixKey(key));
+      }
+    } while (cursor !== 0);
+    return result;
+  }
+  // ============================================
+  // Atomic Operations
+  // ============================================
+  async incr(key) {
+    return this.getConnectedClient().incr(this.prefixKey(key));
+  }
+  async decr(key) {
+    return this.getConnectedClient().decr(this.prefixKey(key));
+  }
+  async incrBy(key, amount) {
+    return this.getConnectedClient().incrby(this.prefixKey(key), amount);
+  }
+  // ============================================
+  // Pub/Sub (via list-based polling)
+  // ============================================
+  supportsPubSub() {
+    return this.pubSubEnabled;
+  }
+  async publish(channel, message) {
+    if (!this.pubSubEnabled) {
+      return super.publish(channel, message);
+    }
+    const prefixedChannel = this.prefixKey(`__pubsub__:${channel}`);
+    const listKey = `${prefixedChannel}:queue`;
+    await this.getConnectedClient().lpush(listKey, message);
+    return 1;
+  }
+  async subscribe(channel, handler) {
+    const client = this.getConnectedClient();
+    if (!this.pubSubEnabled) {
+      return super.subscribe(channel, handler);
+    }
+    const prefixedChannel = this.prefixKey(`__pubsub__:${channel}`);
+    if (!this.subscriptionHandlers.has(prefixedChannel)) {
+      this.subscriptionHandlers.set(prefixedChannel, /* @__PURE__ */ new Set());
+      const listKey = `${prefixedChannel}:queue`;
+      const interval = setInterval(async () => {
+        try {
+          const message = await client.rpop(listKey);
+          if (message) {
+            const handlers2 = this.subscriptionHandlers.get(prefixedChannel);
+            if (handlers2) {
+              for (const h of handlers2) {
+                try {
+                  h(message, channel);
+                } catch {
+                }
+              }
+            }
+          }
+        } catch {
+        }
+      }, PUBSUB_POLL_INTERVAL_MS);
+      if (interval.unref) {
+        interval.unref();
+      }
+      this.pollingIntervals.set(prefixedChannel, interval);
+    }
+    const handlers = this.subscriptionHandlers.get(prefixedChannel);
+    if (handlers) {
+      handlers.add(handler);
+    }
+    return async () => {
+      const handlers2 = this.subscriptionHandlers.get(prefixedChannel);
+      if (handlers2) {
+        handlers2.delete(handler);
+        if (handlers2.size === 0) {
+          this.subscriptionHandlers.delete(prefixedChannel);
+          const interval = this.pollingIntervals.get(prefixedChannel);
+          if (interval) {
+            clearInterval(interval);
+            this.pollingIntervals.delete(prefixedChannel);
+          }
+        }
+      }
+    };
+  }
+  /**
+   * Publish using list-based approach (for polling subscribers).
+   * This is an alternative to native PUBLISH when subscribers are polling.
+   */
+  async publishToQueue(channel, message) {
+    const prefixedChannel = this.prefixKey(`__pubsub__:${channel}`);
+    const listKey = `${prefixedChannel}:queue`;
+    await this.getConnectedClient().lpush(listKey, message);
+  }
+  getPubSubSuggestion() {
+    return "Enable pub/sub by setting enablePubSub: true in the adapter options.";
+  }
+  // ============================================
+  // Internal Helpers
+  // ============================================
+  /**
+   * Add prefix to a key.
+   */
+  prefixKey(key) {
+    return this.keyPrefix + key;
+  }
+  /**
+   * Remove prefix from a key.
+   */
+  unprefixKey(key) {
+    if (this.keyPrefix && key.startsWith(this.keyPrefix)) {
+      return key.slice(this.keyPrefix.length);
+    }
+    return key;
+  }
+};
+export {
+  UpstashStorageAdapter
+};

package/browser/storage/adapters/vercel-kv.mjs

@@ -0,0 +1,226 @@
+// libs/utils/src/storage/adapters/vercel-kv.ts
+import { StorageConfigError, StorageConnectionError } from "../errors.mjs";
+import { COMPARE_AND_DELETE_SCRIPT, COMPARE_AND_EXPIRE_SCRIPT } from "../utils/compare-and-delete.mjs";
+import { validateTTL } from "../utils/ttl.mjs";
+import { BaseStorageAdapter } from "./base.mjs";
+async function loadVercelKv() {
+  try {
+    const mod = await import("@vercel/kv");
+    const resolved = typeof mod.createClient === "function" ? mod : mod.default;
+    if (!resolved || typeof resolved.createClient !== "function") throw new Error("createClient missing");
+    return resolved;
+  } catch {
+    throw new Error("@vercel/kv is required for Vercel KV storage adapter. Install it with: npm install @vercel/kv");
+  }
+}
+async function createVercelKvClient(connection = {}) {
+  const url = connection.url ?? process.env["KV_REST_API_URL"];
+  const token = connection.token ?? process.env["KV_REST_API_TOKEN"];
+  if (!url || !token) {
+    throw new StorageConfigError("vercel-kv", "Pass url and token, or set KV_REST_API_URL and KV_REST_API_TOKEN.");
+  }
+  const { createClient } = await loadVercelKv();
+  return createClient({ url, token, cache: void 0, automaticDeserialization: false });
+}
+var VercelKvStorageAdapter = class extends BaseStorageAdapter {
+  backendName = "vercel-kv";
+  client;
+  options;
+  keyPrefix;
+  constructor(options = {}) {
+    super();
+    const url = options.url ?? process.env["KV_REST_API_URL"];
+    const token = options.token ?? process.env["KV_REST_API_TOKEN"];
+    if (!url || !token) {
+      throw new StorageConfigError(
+        "vercel-kv",
+        "KV_REST_API_URL and KV_REST_API_TOKEN must be provided via options or environment variables."
+      );
+    }
+    this.options = { ...options, url, token };
+    this.keyPrefix = options.keyPrefix ?? "";
+  }
+  // ============================================
+  // Connection Lifecycle
+  // ============================================
+  async connect() {
+    if (this.connected) return;
+    try {
+      this.client = await createVercelKvClient({ url: this.options.url, token: this.options.token });
+      await this.client.exists("__healthcheck__");
+      this.connected = true;
+    } catch (e) {
+      throw new StorageConnectionError(
+        "Failed to connect to Vercel KV",
+        e instanceof Error ? e : void 0,
+        "vercel-kv"
+      );
+    }
+  }
+  async disconnect() {
+    this.client = void 0;
+    this.connected = false;
+  }
+  async ping() {
+    if (!this.client) return false;
+    try {
+      await this.client.exists("__healthcheck__");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  // ============================================
+  // Connection Helpers
+  // ============================================
+  /**
+   * Get the connected Vercel KV client, throwing if not connected.
+   */
+  getConnectedClient() {
+    this.ensureConnected();
+    if (!this.client) {
+      throw new StorageConnectionError("Vercel KV client not connected", void 0, "vercel-kv");
+    }
+    return this.client;
+  }
+  // ============================================
+  // Core Operations
+  // ============================================
+  async get(key) {
+    return this.getConnectedClient().get(this.prefixKey(key));
+  }
+  async doSet(key, value, options) {
+    const client = this.getConnectedClient();
+    const prefixedKey = this.prefixKey(key);
+    const setOptions = {};
+    if (options?.ttlSeconds) {
+      setOptions.ex = options.ttlSeconds;
+    }
+    if (options?.ifNotExists) {
+      setOptions.nx = true;
+    } else if (options?.ifExists) {
+      setOptions.xx = true;
+    }
+    await client.set(prefixedKey, value, Object.keys(setOptions).length > 0 ? setOptions : void 0);
+  }
+  async delete(key) {
+    const result = await this.getConnectedClient().del(this.prefixKey(key));
+    return result > 0;
+  }
+  async deleteIfEquals(key, expectedValue) {
+    const deleted = await this.getConnectedClient().eval(
+      COMPARE_AND_DELETE_SCRIPT,
+      [this.prefixKey(key)],
+      [expectedValue]
+    );
+    return deleted === 1;
+  }
+  async expireIfEquals(key, expectedValue, ttlSeconds) {
+    validateTTL(ttlSeconds);
+    const extended = await this.getConnectedClient().eval(
+      COMPARE_AND_EXPIRE_SCRIPT,
+      [this.prefixKey(key)],
+      [expectedValue, String(ttlSeconds)]
+    );
+    return extended === 1;
+  }
+  async exists(key) {
+    const result = await this.getConnectedClient().exists(this.prefixKey(key));
+    return result > 0;
+  }
+  // ============================================
+  // Batch Operations
+  // ============================================
+  async mget(keys) {
+    if (keys.length === 0) return [];
+    const prefixedKeys = keys.map((k) => this.prefixKey(k));
+    return this.getConnectedClient().mget(...prefixedKeys);
+  }
+  async mdelete(keys) {
+    if (keys.length === 0) return 0;
+    const prefixedKeys = keys.map((k) => this.prefixKey(k));
+    return this.getConnectedClient().del(...prefixedKeys);
+  }
+  // ============================================
+  // TTL Operations
+  // ============================================
+  async expire(key, ttlSeconds) {
+    validateTTL(ttlSeconds);
+    const result = await this.getConnectedClient().expire(this.prefixKey(key), ttlSeconds);
+    return result === 1;
+  }
+  async ttl(key) {
+    const result = await this.getConnectedClient().ttl(this.prefixKey(key));
+    if (result === -2) return null;
+    return result;
+  }
+  // ============================================
+  // Key Enumeration
+  // ============================================
+  async keys(pattern = "*") {
+    const client = this.getConnectedClient();
+    const prefixedPattern = this.prefixKey(pattern);
+    try {
+      const result = [];
+      let cursor = 0;
+      do {
+        const [nextCursor, keys] = await client.scan(cursor, {
+          match: prefixedPattern,
+          count: 100
+        });
+        const parsedCursor = typeof nextCursor === "string" ? parseInt(nextCursor, 10) : nextCursor;
+        cursor = Number.isNaN(parsedCursor) ? 0 : parsedCursor;
+        for (const key of keys) {
+          result.push(this.unprefixKey(key));
+        }
+      } while (cursor !== 0);
+      return result;
+    } catch {
+      const allKeys = await client.keys(prefixedPattern);
+      return allKeys.map((k) => this.unprefixKey(k));
+    }
+  }
+  // ============================================
+  // Atomic Operations
+  // ============================================
+  async incr(key) {
+    return this.getConnectedClient().incr(this.prefixKey(key));
+  }
+  async decr(key) {
+    return this.getConnectedClient().decr(this.prefixKey(key));
+  }
+  async incrBy(key, amount) {
+    return this.getConnectedClient().incrby(this.prefixKey(key), amount);
+  }
+  // ============================================
+  // Pub/Sub (NOT SUPPORTED)
+  // ============================================
+  supportsPubSub() {
+    return false;
+  }
+  getPubSubSuggestion() {
+    return "Vercel KV is REST-based and does not support pub/sub. Use Upstash adapter for pub/sub support.";
+  }
+  // ============================================
+  // Internal Helpers
+  // ============================================
+  /**
+   * Add prefix to a key.
+   */
+  prefixKey(key) {
+    return this.keyPrefix + key;
+  }
+  /**
+   * Remove prefix from a key.
+   */
+  unprefixKey(key) {
+    if (this.keyPrefix && key.startsWith(this.keyPrefix)) {
+      return key.slice(this.keyPrefix.length);
+    }
+    return key;
+  }
+};
+export {
+  VercelKvStorageAdapter,
+  createVercelKvClient
+};

package/browser/storage/change-feed.mjs

@@ -0,0 +1,189 @@
+// libs/utils/src/storage/change-feed.ts
+var DEFAULT_CHANGE_FEED_POLL_INTERVAL_MS = 250;
+var DEFAULT_CHANGE_FEED_COALESCE_MS = 50;
+var TOPIC_PREFIX = "feed:";
+var TopicFeed = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  closed = false;
+  listeners = /* @__PURE__ */ new Map();
+  pending = /* @__PURE__ */ new Map();
+  subscribe(topic, listener) {
+    let topicListeners = this.listeners.get(topic);
+    if (!topicListeners) {
+      topicListeners = /* @__PURE__ */ new Set();
+      this.listeners.set(topic, topicListeners);
+      this.watch(topic);
+    }
+    const subscribed = topicListeners;
+    subscribed.add(listener);
+    return () => {
+      if (!subscribed.delete(listener) || subscribed.size > 0 || this.listeners.get(topic) !== subscribed) return;
+      this.listeners.delete(topic);
+      this.unwatch(topic);
+    };
+  }
+  async close() {
+    this.closed = true;
+    for (const timer of this.pending.values()) clearTimeout(timer);
+    this.pending.clear();
+    for (const topic of this.listeners.keys()) this.unwatch(topic);
+    this.listeners.clear();
+  }
+  /** Tell the listeners of `topic` that it changed, once per coalescing window. */
+  changed(topic) {
+    if (this.closed || this.pending.has(topic) || !this.listeners.has(topic)) return;
+    const timer = setTimeout(() => {
+      this.pending.delete(topic);
+      for (const listener of [...this.listeners.get(topic) ?? []]) {
+        try {
+          listener();
+        } catch (error) {
+          this.options.onError?.(error);
+        }
+      }
+    }, this.options.coalesceMs ?? DEFAULT_CHANGE_FEED_COALESCE_MS);
+    timer.unref?.();
+    this.pending.set(topic, timer);
+  }
+};
+var LocalChangeFeed = class extends TopicFeed {
+  kind = "local";
+  async publish(topic) {
+    this.changed(topic);
+  }
+  watch() {
+    return;
+  }
+  unwatch() {
+    return;
+  }
+};
+var PubSubChangeFeed = class extends TopicFeed {
+  constructor(storage, options) {
+    super(options);
+    this.storage = storage;
+    this.stopReconnectListener = storage.onPubSubReconnect?.(() => {
+      for (const topic of this.channels.keys()) this.changed(topic);
+    });
+  }
+  storage;
+  kind = "pubsub";
+  channels = /* @__PURE__ */ new Map();
+  stopReconnectListener;
+  async close() {
+    this.stopReconnectListener?.();
+    await super.close();
+  }
+  async publish(topic) {
+    await this.storage.publish(TOPIC_PREFIX + topic, "");
+  }
+  watch(topic) {
+    const subscription = this.storage.subscribe(TOPIC_PREFIX + topic, () => this.changed(topic)).catch((error) => {
+      this.options.onError?.(error);
+      return void 0;
+    });
+    this.channels.set(topic, subscription);
+  }
+  unwatch(topic) {
+    const subscription = this.channels.get(topic);
+    this.channels.delete(topic);
+    void subscription?.then((unsubscribe) => unsubscribe?.()).catch((error) => this.options.onError?.(error));
+  }
+};
+var pollingFeeds = /* @__PURE__ */ new Set();
+var PollingChangeFeed = class extends TopicFeed {
+  constructor(storage, options) {
+    super(options);
+    this.storage = storage;
+    pollingFeeds.add(this);
+  }
+  storage;
+  kind = "poll";
+  /** The counter each followed topic had when last read; `undefined` until its first read. */
+  seen = /* @__PURE__ */ new Map();
+  timer;
+  polling = false;
+  lastVersion;
+  failing = false;
+  async publish(topic) {
+    const count = String(await this.storage.incr(TOPIC_PREFIX + topic));
+    if (this.seen.has(topic)) this.seen.set(topic, count);
+    const counterKey = this.storage.prefix + TOPIC_PREFIX + topic;
+    for (const feed of pollingFeeds) feed.published(counterKey);
+  }
+  async close() {
+    pollingFeeds.delete(this);
+    await super.close();
+    clearTimeout(this.timer);
+    this.timer = void 0;
+  }
+  /** A feed of this process incremented `counterKey`. */
+  published(counterKey) {
+    const ownPrefix = this.storage.prefix + TOPIC_PREFIX;
+    if (!counterKey.startsWith(ownPrefix)) return;
+    const topic = counterKey.slice(ownPrefix.length);
+    if (this.seen.has(topic)) this.changed(topic);
+  }
+  watch(topic) {
+    this.seen.set(topic, void 0);
+    void this.storage.get(TOPIC_PREFIX + topic).then(
+      (count) => {
+        if (this.seen.has(topic) && this.seen.get(topic) === void 0) this.seen.set(topic, count);
+      },
+      (error) => this.options.onError?.(error)
+    );
+    this.schedule();
+  }
+  unwatch(topic) {
+    this.seen.delete(topic);
+    if (this.seen.size > 0) return;
+    clearTimeout(this.timer);
+    this.timer = void 0;
+  }
+  schedule() {
+    if (this.timer || this.polling || this.closed || this.seen.size === 0) return;
+    this.timer = setTimeout(() => {
+      this.timer = void 0;
+      void this.poll();
+    }, this.options.pollIntervalMs ?? DEFAULT_CHANGE_FEED_POLL_INTERVAL_MS);
+    this.timer.unref?.();
+  }
+  async poll() {
+    this.polling = true;
+    try {
+      const version = await this.storage.root.dataVersion?.();
+      if (version !== this.lastVersion) {
+        const topics = [...this.seen.keys()];
+        const counts = await this.storage.mget(topics.map((topic) => TOPIC_PREFIX + topic));
+        this.lastVersion = version;
+        topics.forEach((topic, index) => this.compare(topic, counts[index]));
+      }
+      this.failing = false;
+    } catch (error) {
+      if (!this.failing && !this.closed) this.options.onError?.(error);
+      this.failing = true;
+    } finally {
+      this.polling = false;
+      this.schedule();
+    }
+  }
+  compare(topic, count) {
+    if (!this.seen.has(topic)) return;
+    const before = this.seen.get(topic);
+    this.seen.set(topic, count);
+    if (before !== void 0 && before !== count) this.changed(topic);
+  }
+};
+function createChangeFeed(storage, options = {}) {
+  if (storage.supportsPubSub()) return new PubSubChangeFeed(storage, options);
+  if (storage.root.dataVersion) return new PollingChangeFeed(storage, options);
+  return new LocalChangeFeed(options);
+}
+export {
+  DEFAULT_CHANGE_FEED_COALESCE_MS,
+  DEFAULT_CHANGE_FEED_POLL_INTERVAL_MS,
+  createChangeFeed
+};