@dongdev/fca-unofficial 3.0.0 → 3.0.3

package/src/api/socket/middleware/index.js

@@ -0,0 +1,216 @@
+"use strict";
+const logger = require("../../../func/logger");
+
+/**
+ * Middleware system for filtering and processing events before they are emitted
+ *
+ * Middleware functions receive (event, next) where:
+ * - event: The event object (can be modified)
+ * - next: Function to call to continue to next middleware
+ *   - next() - continue to next middleware
+ *   - next(false) or next(null) - stop processing, don't emit event
+ *   - next(error) - emit error instead
+ */
+module.exports = function createMiddlewareSystem() {
+  const middlewareStack = [];
+
+  /**
+   * Add middleware to the stack
+   * @param {Function|string} middleware - Middleware function or name for named middleware
+   * @param {Function} [fn] - Middleware function (if first param is name)
+   * @returns {Function} Unsubscribe function
+   */
+  function use(middleware, fn) {
+    let middlewareFn, name;
+
+    if (typeof middleware === "string" && typeof fn === "function") {
+      name = middleware;
+      middlewareFn = fn;
+    } else if (typeof middleware === "function") {
+      middlewareFn = middleware;
+      name = `middleware_${middlewareStack.length}`;
+    } else {
+      throw new Error("Middleware must be a function or (name, function)");
+    }
+
+    const wrapped = {
+      name,
+      fn: middlewareFn,
+      enabled: true
+    };
+
+    middlewareStack.push(wrapped);
+    logger(`Middleware "${name}" added`, "info");
+
+    // Return unsubscribe function
+    return function remove() {
+      const index = middlewareStack.indexOf(wrapped);
+      if (index !== -1) {
+        middlewareStack.splice(index, 1);
+        logger(`Middleware "${name}" removed`, "info");
+      }
+    };
+  }
+
+  /**
+   * Remove middleware by name or function
+   * @param {string|Function} identifier - Name or function to remove
+   * @returns {boolean} True if removed
+   */
+  function remove(identifier) {
+    if (typeof identifier === "string") {
+      const index = middlewareStack.findIndex(m => m.name === identifier);
+      if (index !== -1) {
+        const removed = middlewareStack.splice(index, 1)[0];
+        logger(`Middleware "${removed.name}" removed`, "info");
+        return true;
+      }
+      return false;
+    } else if (typeof identifier === "function") {
+      const index = middlewareStack.findIndex(m => m.fn === identifier);
+      if (index !== -1) {
+        const removed = middlewareStack.splice(index, 1)[0];
+        logger(`Middleware "${removed.name}" removed`, "info");
+        return true;
+      }
+      return false;
+    }
+    return false;
+  }
+
+  /**
+   * Remove all middleware
+   */
+  function clear() {
+    const count = middlewareStack.length;
+    middlewareStack.length = 0;
+    logger(`All middleware cleared (${count} removed)`, "info");
+  }
+
+  /**
+   * Get list of middleware names
+   * @returns {string[]} Array of middleware names
+   */
+  function list() {
+    return middlewareStack.filter(m => m.enabled).map(m => m.name);
+  }
+
+  /**
+   * Enable/disable middleware by name
+   * @param {string} name - Middleware name
+   * @param {boolean} enabled - Enable or disable
+   * @returns {boolean} True if found and updated
+   */
+  function setEnabled(name, enabled) {
+    const middleware = middlewareStack.find(m => m.name === name);
+    if (middleware) {
+      middleware.enabled = enabled;
+      logger(`Middleware "${name}" ${enabled ? "enabled" : "disabled"}`, "info");
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Process event through middleware stack
+   * @param {*} event - Event object
+   * @param {Function} finalCallback - Callback to call after all middleware
+   * @returns {Promise} Promise that resolves when processing is complete
+   */
+  function process(event, finalCallback) {
+    if (!middlewareStack.length) {
+      return finalCallback(null, event);
+    }
+
+    let index = 0;
+    const enabledMiddleware = middlewareStack.filter(m => m.enabled);
+
+    function next(err) {
+      // Error occurred, stop processing
+      if (err && err !== false && err !== null) {
+        return finalCallback(err, null);
+      }
+
+      // Explicitly stopped (next(false) or next(null))
+      if (err === false || err === null) {
+        return finalCallback(null, null); // null event means don't emit
+      }
+
+      // No more middleware, call final callback
+      if (index >= enabledMiddleware.length) {
+        return finalCallback(null, event);
+      }
+
+      // Get next middleware
+      const middleware = enabledMiddleware[index++];
+
+      try {
+        // Call middleware with event and next
+        const result = middleware.fn(event, next);
+
+        // If middleware returns a promise, handle it
+        if (result && typeof result.then === "function") {
+          result
+            .then(() => next())
+            .catch(err => next(err));
+        } else if (result === false || result === null) {
+          // Middleware returned false/null, stop processing
+          finalCallback(null, null);
+        }
+        // If middleware called next() synchronously, it will continue
+      } catch (err) {
+        logger(`Middleware "${middleware.name}" error: ${err && err.message ? err.message : String(err)}`, "error");
+        next(err);
+      }
+    }
+
+    // Start processing
+    next();
+  }
+
+  /**
+   * Wrap a callback with middleware processing
+   * @param {Function} callback - Original callback (err, event)
+   * @returns {Function} Wrapped callback
+   */
+  function wrapCallback(callback) {
+    return function wrappedCallback(err, event) {
+      if (err) {
+        // Errors bypass middleware
+        return callback(err, null);
+      }
+
+      if (!event) {
+        return callback(null, null);
+      }
+
+      // Process event through middleware
+      process(event, (middlewareErr, processedEvent) => {
+        if (middlewareErr) {
+          return callback(middlewareErr, null);
+        }
+
+        // If processedEvent is null, middleware blocked the event
+        if (processedEvent === null) {
+          return; // Don't emit
+        }
+
+        // Emit processed event
+        callback(null, processedEvent);
+      });
+    };
+  }
+
+  return {
+    use,
+    remove,
+    clear,
+    list,
+    setEnabled,
+    process,
+    wrapCallback,
+    get count() {
+      return middlewareStack.filter(m => m.enabled).length;
+    }
+  };
+};

package/src/api/users/getUserInfo.js

@@ -268,11 +268,18 @@ module.exports = function (defaultFuncs, api, ctx) {
     isProcessingQueue = false;
   }
 
-  setInterval(() => {
+  // Store interval reference for cleanup
+  const updateInterval = setInterval(() => {
     checkAndUpdateUsers();
     processQueue();
   }, 10000);
 
+  // Store interval in ctx for cleanup on logout/stop
+  if (!ctx._userInfoIntervals) {
+    ctx._userInfoIntervals = [];
+  }
+  ctx._userInfoIntervals.push(updateInterval);
+
   return function getUserInfo(idsOrId, callback) {
     let resolveFunc, rejectFunc;
     const returnPromise = new Promise((resolve, reject) => { resolveFunc = resolve; rejectFunc = reject; });

package/src/core/sendReqMqtt.js

@@ -1,6 +1,6 @@
 "use strict";
 
-function lsRequest(ctx, payload, options, callback) {
+function sendReqMqtt(ctx, payload, options, callback) {
   return new Promise((resolve, reject) => {
     const cb = typeof options === "function" ? options : callback;
     const opts = typeof options === "object" && options ? options : {};
@@ -23,6 +23,25 @@ function lsRequest(ctx, payload, options, callback) {
       type: opts.type == null ? 3 : opts.type
     });
     let timer = null;
+    let cleaned = false;
+
+    // Cleanup function to ensure listeners and timers are always removed
+    const cleanup = () => {
+      if (cleaned) return;
+      cleaned = true;
+      try {
+        if (timer) {
+          clearTimeout(timer);
+          timer = null;
+        }
+        if (ctx.mqttClient && typeof ctx.mqttClient.removeListener === "function") {
+          ctx.mqttClient.removeListener("message", handleRes);
+        }
+      } catch (err) {
+        // Ignore cleanup errors
+      }
+    };
+
     const handleRes = (topic, message) => {
       if (topic !== respTopic) return;
       let msg;
@@ -33,8 +52,7 @@ function lsRequest(ctx, payload, options, callback) {
       }
       if (msg.request_id !== reqID) return;
       if (typeof opts.filter === "function" && !opts.filter(msg)) return;
-      ctx.mqttClient.removeListener("message", handleRes);
-      if (timer) clearTimeout(timer);
+      cleanup();
       try {
         msg.payload = typeof msg.payload === "string" ? JSON.parse(msg.payload) : msg.payload;
       } catch { }
@@ -42,22 +60,37 @@ function lsRequest(ctx, payload, options, callback) {
       if (cb) cb(null, out);
       resolve(out);
     };
-    ctx.mqttClient.on("message", handleRes);
+
+    try {
+      ctx.mqttClient.on("message", handleRes);
+    } catch (err) {
+      cleanup();
+      const error = new Error("Failed to attach message listener");
+      if (cb) cb(error);
+      return reject(error);
+    }
+
     timer = setTimeout(() => {
-      ctx.mqttClient.removeListener("message", handleRes);
+      cleanup();
       const err = new Error("MQTT response timeout");
       if (cb) cb(err);
       reject(err);
     }, timeoutMs);
-    ctx.mqttClient.publish(reqTopic, form, { qos, retain }, (err) => {
-      if (err) {
-        if (timer) clearTimeout(timer);
-        ctx.mqttClient.removeListener("message", handleRes);
-        if (cb) cb(err);
-        reject(err);
-      }
-    });
+
+    try {
+      ctx.mqttClient.publish(reqTopic, form, { qos, retain }, (err) => {
+        if (err) {
+          cleanup();
+          if (cb) cb(err);
+          reject(err);
+        }
+      });
+    } catch (err) {
+      cleanup();
+      if (cb) cb(err);
+      reject(err);
+    }
   });
-};
+}
 
 module.exports = sendReqMqtt;

package/src/utils/format.js

@@ -574,7 +574,8 @@ function formatDeltaMessage(m) {
     mentions: mentions,
     timestamp: md.timestamp,
     isGroup: !!md.threadKey.threadFbId,
-    participantIDs: m.participants || []
+    participantIDs: (m.participants || []).map((/** @type {any} */ p) => formatID(p.toString())),
+    isUnread: md.isUnread !== undefined ? md.isUnread : false
   };
 }
 
@@ -585,6 +586,8 @@ function formatID(id) {
 
 function formatMessage(m) {
   var originalMessage = m.message ? m.message : m;
+  var body = originalMessage.body || "";
+  var args = body == "" ? [] : body.trim().split(/\s+/);
   var obj = {
     type: "message",
     senderName: originalMessage.sender_name,
@@ -597,7 +600,8 @@ function formatMessage(m) {
         return formatID(v.toString());
       })
       : [formatID(originalMessage.sender_fbid)],
-    body: originalMessage.body || "",
+    body: body,
+    args: args,
     threadID: formatID(
       (
         originalMessage.thread_fbid || originalMessage.other_user_fbid