@dongdev/fca-unofficial 1.0.20 → 2.0.1

package/src/{getThreadList.js → api/threads/getThreadList.js}

@@ -1,15 +1,17 @@
 "use strict";
 
-const utils = require("../utils");
+const utils = require("../../utils");
 const log = require("npmlog");
 
 function createProfileUrl(url, username, id) {
   if (url) return url;
-  return "https://www.facebook.com/" + (username || utils.formatID(id.toString()));
+  return (
+    "https://www.facebook.com/" + (username || utils.formatID(id.toString()))
+  );
 }
 
 function formatParticipants(participants) {
-  return participants.edges.map((p) => {
+  return participants.edges.map(p => {
     p = p.node.messaging_actor;
     switch (p["__typename"]) {
       case "User":
@@ -21,7 +23,7 @@ function formatParticipants(participants) {
           gender: p.gender,
           url: p.url, // how about making it profileURL
           profilePicture: p.big_image_src.uri,
-          username: (p.username || null),
+          username: p.username || null,
           // TODO: maybe better names for these?
           isViewerFriend: p.is_viewer_friend, // true/false
           isMessengerUser: p.is_messenger_user, // true/false
@@ -37,13 +39,13 @@ function formatParticipants(participants) {
           name: p.name,
           url: p.url,
           profilePicture: p.big_image_src.uri,
-          username: (p.username || null),
+          username: p.username || null,
           // uhm... better names maybe?
           acceptsMessengerUserFeedback: p.accepts_messenger_user_feedback, // true/false
           isMessengerUser: p.is_messenger_user, // true/false
           isVerified: p.is_verified, // true/false
           isMessengerPlatformBot: p.is_messenger_platform_bot, // true/false
-          isMessageBlockedByViewer: p.is_message_blocked_by_viewer, // true/false
+          isMessageBlockedByViewer: p.is_message_blocked_by_viewer // true/false
         };
       case "ReducedMessagingActor":
       case "UnavailableMessagingActor":
@@ -53,15 +55,19 @@ function formatParticipants(participants) {
           name: p.name,
           url: createProfileUrl(p.url, p.username, p.id), // in this case p.url is null all the time
           profilePicture: p.big_image_src.uri, // in this case it is default facebook photo, we could determine gender using it
-          username: (p.username || null), // maybe we could use it to generate profile URL?
-          isMessageBlockedByViewer: p.is_message_blocked_by_viewer, // true/false
+          username: p.username || null, // maybe we could use it to generate profile URL?
+          isMessageBlockedByViewer: p.is_message_blocked_by_viewer // true/false
         };
       default:
-        log.warn("getThreadList", "Found participant with unsupported typename. Please open an issue at https://github.com/Schmavery/facebook-chat-api/issues\n" + JSON.stringify(p, null, 2));
+        log.warn(
+          "getThreadList",
+          "Found participant with unsupported typename. Please open an issue at https://github.com/Schmavery/facebook-chat-api/issues\n" +
+            JSON.stringify(p, null, 2)
+        );
         return {
           accountType: p["__typename"],
           userID: utils.formatID(p.id.toString()),
-          name: p.name || `[unknown ${p["__typename"]}]`, // probably it will always be something... but fallback to [unknown], just in case
+          name: p.name || `[unknown ${p["__typename"]}]` // probably it will always be something... but fallback to [unknown], just in case
         };
     }
   });
@@ -78,30 +84,40 @@ function getThreadName(t) {
 
   for (let po of t.all_participants.edges) {
     let p = po.node;
-    if (p.messaging_actor.id === t.thread_key.other_user_id) return p.messaging_actor.name;
+    if (p.messaging_actor.id === t.thread_key.other_user_id)
+      return p.messaging_actor.name;
   }
 }
 
 function mapNicknames(customizationInfo) {
-  return (customizationInfo && customizationInfo.participant_customizations) ? customizationInfo.participant_customizations.map(u => {
-    return {
-      "userID": u.participant_id,
-      "nickname": u.nickname
-    };
-  }) : [];
+  return customizationInfo && customizationInfo.participant_customizations
+    ? customizationInfo.participant_customizations.map(u => {
+        return {
+          userID: u.participant_id,
+          nickname: u.nickname
+        };
+      })
+    : [];
 }
 
 function formatThreadList(data) {
   return data.map(t => {
-    let lastMessageNode = (t.last_message && t.last_message.nodes && t.last_message.nodes.length > 0) ? t.last_message.nodes[0] : null;
+    let lastMessageNode =
+      t.last_message && t.last_message.nodes && t.last_message.nodes.length > 0
+        ? t.last_message.nodes[0]
+        : null;
     return {
-      threadID: t.thread_key ? utils.formatID(t.thread_key.thread_fbid || t.thread_key.other_user_id) : null, // shall never be null
+      threadID: t.thread_key
+        ? utils.formatID(t.thread_key.thread_fbid || t.thread_key.other_user_id)
+        : null, // shall never be null
       name: getThreadName(t),
       unreadCount: t.unread_count,
       messageCount: t.messages_count,
       imageSrc: t.image ? t.image.uri : null,
       emoji: t.customization_info ? t.customization_info.emoji : null,
-      color: formatColor(t.customization_info ? t.customization_info.outgoing_bubble_color : null),
+      color: formatColor(
+        t.customization_info ? t.customization_info.outgoing_bubble_color : null
+      ),
       threadTheme: t.thread_theme,
       nicknames: mapNicknames(t.customization_info),
       muteUntil: t.mute_until,
@@ -111,22 +127,37 @@ function formatThreadList(data) {
       isGroup: t.thread_type === "GROUP",
       customizationEnabled: t.customization_enabled, // false for ONE_TO_ONE with Page or ReducedMessagingActor
       participantAddMode: t.participant_add_mode_as_string, // "ADD" if "GROUP" and null if "ONE_TO_ONE"
-      montageThread: t.montage_thread ? Buffer.from(t.montage_thread.id, "base64").toString() : null, // base64 encoded string "message_thread:0000000000000000"
+      montageThread: t.montage_thread
+        ? Buffer.from(t.montage_thread.id, "base64").toString()
+        : null, // base64 encoded string "message_thread:0000000000000000"
       reactionsMuteMode: t.reactions_mute_mode,
       mentionsMuteMode: t.mentions_mute_mode,
       isArchived: t.has_viewer_archived,
       isSubscribed: t.is_viewer_subscribed,
       timestamp: t.updated_time_precise, // in miliseconds
       snippet: lastMessageNode ? lastMessageNode.snippet : null,
-      snippetAttachments: lastMessageNode ? lastMessageNode.extensible_attachment : null, // TODO: not sure if it works
-      snippetSender: lastMessageNode ? utils.formatID((lastMessageNode.message_sender.messaging_actor.id || "").toString()) : null,
-      lastMessageTimestamp: lastMessageNode ? lastMessageNode.timestamp_precise : null, // timestamp in miliseconds
-      lastReadTimestamp: (t.last_read_receipt && t.last_read_receipt.nodes.length > 0)
-        ? (t.last_read_receipt.nodes[0] ? t.last_read_receipt.nodes[0].timestamp_precise : null)
+      snippetAttachments: lastMessageNode
+        ? lastMessageNode.extensible_attachment
+        : null, // TODO: not sure if it works
+      snippetSender: lastMessageNode
+        ? utils.formatID(
+            (lastMessageNode.message_sender.messaging_actor.id || "").toString()
+          )
         : null,
+      lastMessageTimestamp: lastMessageNode
+        ? lastMessageNode.timestamp_precise
+        : null, // timestamp in miliseconds
+      lastReadTimestamp:
+        t.last_read_receipt && t.last_read_receipt.nodes.length > 0
+          ? t.last_read_receipt.nodes[0]
+            ? t.last_read_receipt.nodes[0].timestamp_precise
+            : null
+          : null,
       cannotReplyReason: t.cannot_reply_reason,
       approvalMode: Boolean(t.approval_mode),
-      participantIDs: formatParticipants(t.all_participants).map(participant => participant.userID),
+      participantIDs: formatParticipants(t.all_participants).map(
+        participant => participant.userID
+      ),
       threadType: t.thread_type === "GROUP" ? 2 : 1, // "GROUP" or "ONE_TO_ONE"
       inviteLink: {
         enable: t.joinable_mode ? t.joinable_mode.mode == 1 : false,
@@ -136,57 +167,82 @@ function formatThreadList(data) {
   });
 }
 
-module.exports = function (defaultFuncs, api, ctx) {
+module.exports = function(defaultFuncs, api, ctx) {
   return function getThreadList(limit, timestamp, tags, callback) {
-    if (!callback && (utils.getType(tags) === "Function" || utils.getType(tags) === "AsyncFunction")) {
+    if (
+      !callback &&
+      (utils.getType(tags) === "Function" ||
+        utils.getType(tags) === "AsyncFunction")
+    ) {
       callback = tags;
       tags = [""];
     }
-    if (utils.getType(limit) !== "Number" || !Number.isInteger(limit) || limit <= 0) throw { error: "getThreadList: limit must be a positive integer" };
-    if (utils.getType(timestamp) !== "Null" && (utils.getType(timestamp) !== "Number" || !Number.isInteger(timestamp))) throw { error: "getThreadList: timestamp must be an integer or null" };
+    if (
+      utils.getType(limit) !== "Number" ||
+      !Number.isInteger(limit) ||
+      limit <= 0
+    )
+      throw { error: "getThreadList: limit must be a positive integer" };
+    if (
+      utils.getType(timestamp) !== "Null" &&
+      (utils.getType(timestamp) !== "Number" || !Number.isInteger(timestamp))
+    )
+      throw { error: "getThreadList: timestamp must be an integer or null" };
     if (utils.getType(tags) === "String") tags = [tags];
-    if (utils.getType(tags) !== "Array") throw { error: "getThreadList: tags must be an array" };
-    var resolveFunc = function () { };
-    var rejectFunc = function () { };
-    var returnPromise = new Promise(function (resolve, reject) {
+    if (utils.getType(tags) !== "Array")
+      throw { error: "getThreadList: tags must be an array" };
+    var resolveFunc = function() {};
+    var rejectFunc = function() {};
+    var returnPromise = new Promise(function(resolve, reject) {
       resolveFunc = resolve;
       rejectFunc = reject;
     });
-    if (utils.getType(callback) !== "Function" && utils.getType(callback) !== "AsyncFunction") {
-      callback = function (err, data) {
+    if (
+      utils.getType(callback) !== "Function" &&
+      utils.getType(callback) !== "AsyncFunction"
+    ) {
+      callback = function(err, data) {
         if (err) return rejectFunc(err);
         resolveFunc(data);
       };
     }
     const form = {
-      "av": ctx.globalOptions.pageID,
-      "queries": JSON.stringify({
-        "o0": {
-          "doc_id": "3336396659757871",
-          "query_params": {
-            "limit": limit + (timestamp ? 1 : 0),
-            "before": timestamp,
-            "tags": tags,
-            "includeDeliveryReceipts": true,
-            "includeSeqID": false
+      av: ctx.globalOptions.pageID,
+      queries: JSON.stringify({
+        o0: {
+          doc_id: "3336396659757871",
+          query_params: {
+            limit: limit + (timestamp ? 1 : 0),
+            before: timestamp,
+            tags: tags,
+            includeDeliveryReceipts: true,
+            includeSeqID: false
           }
         }
       }),
-      "batch_name": "MessengerGraphQLThreadlistFetcher"
+      batch_name: "MessengerGraphQLThreadlistFetcher"
     };
     defaultFuncs
       .post("https://www.facebook.com/api/graphqlbatch/", ctx.jar, form)
       .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
-      .then((resData) => {
-        if (resData[resData.length - 1].error_results > 0) throw resData[0].o0.errors;
-        if (resData[resData.length - 1].successful_results === 0) throw { error: "getThreadList: there was no successful_results", res: resData };
+      .then(resData => {
+        if (resData[resData.length - 1].error_results > 0)
+          throw resData[0].o0.errors;
+        if (resData[resData.length - 1].successful_results === 0)
+          throw {
+            error: "getThreadList: there was no successful_results",
+            res: resData
+          };
         if (timestamp) resData[0].o0.data.viewer.message_threads.nodes.shift();
-        callback(null, formatThreadList(resData[0].o0.data.viewer.message_threads.nodes));
+        callback(
+          null,
+          formatThreadList(resData[0].o0.data.viewer.message_threads.nodes)
+        );
       })
-      .catch((err) => {
+      .catch(err => {
         log.error("getThreadList", err);
         return callback(err);
       });
     return returnPromise;
   };
-};
+};

package/src/api/threads/getThreadPictures.js

@@ -0,0 +1,79 @@
+"use strict";
+
+const utils = require("../../utils");
+const log = require("npmlog");
+
+module.exports = function(defaultFuncs, api, ctx) {
+  return function getThreadPictures(threadID, offset, limit, callback) {
+    let resolveFunc = function() {};
+    let rejectFunc = function() {};
+    const returnPromise = new Promise(function(resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      callback = function(err, friendList) {
+        if (err) {
+          return rejectFunc(err);
+        }
+        resolveFunc(friendList);
+      };
+    }
+
+    let form = {
+      thread_id: threadID,
+      offset: offset,
+      limit: limit
+    };
+
+    defaultFuncs
+      .post(
+        "https://www.facebook.com/ajax/messaging/attachments/sharedphotos.php",
+        ctx.jar,
+        form
+      )
+      .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+      .then(function(resData) {
+        if (resData.error) {
+          throw resData;
+        }
+        return Promise.all(
+          resData.payload.imagesData.map(function(image) {
+            form = {
+              thread_id: threadID,
+              image_id: image.fbid
+            };
+            return defaultFuncs
+              .post(
+                "https://www.facebook.com/ajax/messaging/attachments/sharedphotos.php",
+                ctx.jar,
+                form
+              )
+              .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+              .then(function(resData) {
+                if (resData.error) {
+                  throw resData;
+                }
+                // the response is pretty messy
+                const queryThreadID =
+                  resData.jsmods.require[0][3][1].query_metadata.query_path[0]
+                    .message_thread;
+                const imageData =
+                  resData.jsmods.require[0][3][1].query_results[queryThreadID]
+                    .message_images.edges[0].node.image2;
+                return imageData;
+              });
+          })
+        );
+      })
+      .then(function(resData) {
+        callback(null, resData);
+      })
+      .catch(function(err) {
+        log.error("Error in getThreadPictures", err);
+        callback(err);
+      });
+    return returnPromise;
+  };
+};

package/src/api/users/getUserID.js

@@ -0,0 +1,66 @@
+"use strict";
+
+const utils = require("../../utils");
+const log = require("npmlog");
+
+function formatData(data) {
+  return {
+    userID: utils.formatID(data.uid.toString()),
+    photoUrl: data.photo,
+    indexRank: data.index_rank,
+    name: data.text,
+    isVerified: data.is_verified,
+    profileUrl: data.path,
+    category: data.category,
+    score: data.score,
+    type: data.type
+  };
+}
+
+module.exports = function(defaultFuncs, api, ctx) {
+  return function getUserID(name, callback) {
+    let resolveFunc = function() {};
+    let rejectFunc = function() {};
+    const returnPromise = new Promise(function(resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      callback = function(err, friendList) {
+        if (err) {
+          return rejectFunc(err);
+        }
+        resolveFunc(friendList);
+      };
+    }
+
+    const form = {
+      value: name.toLowerCase(),
+      viewer: ctx.i_userID || ctx.userID,
+      rsp: "search",
+      context: "search",
+      path: "/home.php",
+      request_id: utils.getGUID()
+    };
+
+    defaultFuncs
+      .get("https://www.facebook.com/ajax/typeahead/search.php", ctx.jar, form)
+      .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+      .then(function(resData) {
+        if (resData.error) {
+          throw resData;
+        }
+
+        const data = resData.payload.entries;
+
+        callback(null, data.map(formatData));
+      })
+      .catch(function(err) {
+        log.error("getUserID", err);
+        return callback(err);
+      });
+
+    return returnPromise;
+  };
+};

package/src/api/users/getUserInfo.js

@@ -0,0 +1,88 @@
+"use strict";
+const { parseAndCheckLogin } = require("../../utils/client");
+var log = require("npmlog");
+module.exports = function(defaultFuncs, api, ctx) {
+  function formatData(data) {
+    const retObj = {};
+    for (const actor of data.messaging_actors || []) {
+      retObj[actor.id] = {
+        name: actor.name,
+        firstName: actor.short_name || null,
+        vanity: actor.username || null,
+        thumbSrc: actor.big_image_src?.uri || null,
+        profileUrl: actor.url || null,
+        gender: actor.gender || null,
+        type: actor.__typename || null,
+        isFriend: actor.is_viewer_friend || false,
+        isMessengerUser: actor.is_messenger_user || false,
+        isMessageBlockedByViewer: actor.is_message_blocked_by_viewer || false,
+        workInfo: actor.work_info || null,
+        messengerStatus: actor.messenger_account_status_category || null
+      };
+    }
+    return retObj;
+  }
+  return function getUserInfoGraphQL(id, callback) {
+    let resolveFunc, rejectFunc;
+    const returnPromise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+    if (typeof callback !== "function") {
+      callback = (err, data) => {
+        if (err) return rejectFunc(err);
+        resolveFunc(data);
+      };
+    }
+    const ids = Array.isArray(id) ? id : [id];
+    var form = {
+      queries: JSON.stringify({
+        o0: {
+          doc_id: "5009315269112105",
+          query_params: {
+            ids: ids
+          }
+        }
+      }),
+      batch_name: "MessengerParticipantsFetcher"
+    };
+    defaultFuncs
+      .post("https://www.facebook.com/api/graphqlbatch/", ctx.jar, form)
+      .then(parseAndCheckLogin(ctx, defaultFuncs))
+      .then(function(resData) {
+        if (!resData || resData.length === 0) {
+          throw new Error("Empty response from server");
+        }
+        if (resData.error) {
+          throw resData.error;
+        }
+        const response = resData[0];
+        console.log(response);
+        if (!response || !response.o0) {
+          throw new Error("Invalid response format");
+        }
+        if (response.o0.errors && response.o0.errors.length > 0) {
+          throw new Error(response.o0.errors[0].message || "GraphQL error");
+        }
+        const result = response.o0.data;
+        if (
+          !result ||
+          !result.messaging_actors ||
+          result.messaging_actors.length === 0
+        ) {
+          log.warn("getUserInfo", "No user data found for the provided ID(s)");
+          return callback(null, {});
+        }
+        const formattedData = formatData(result);
+        return callback(null, formattedData);
+      })
+      .catch(err => {
+        log.error(
+          "getUserInfoGraphQL",
+          "Error: " + (err.message || "Unknown error occurred")
+        );
+        callback(err);
+      });
+    return returnPromise;
+  };
+};

package/src/core/sendReqMqtt.js

@@ -0,0 +1,63 @@
+"use strict";
+
+function lsRequest(ctx, payload, options, callback) {
+  return new Promise((resolve, reject) => {
+    const cb = typeof options === "function" ? options : callback;
+    const opts = typeof options === "object" && options ? options : {};
+    if (!ctx || !ctx.mqttClient) {
+      const err = new Error("Not connected to MQTT");
+      if (cb) cb(err);
+      return reject(err);
+    }
+    if (typeof ctx.wsReqNumber !== "number") ctx.wsReqNumber = 0;
+    const reqID = typeof opts.request_id === "number" ? opts.request_id : ++ctx.wsReqNumber;
+    const timeoutMs = typeof opts.timeout === "number" ? opts.timeout : 20000;
+    const qos = typeof opts.qos === "number" ? opts.qos : 1;
+    const retain = !!opts.retain;
+    const reqTopic = "/ls_req";
+    const respTopic = opts.respTopic || "/ls_resp";
+    const form = JSON.stringify({
+      app_id: opts.app_id || "",
+      payload: typeof payload === "string" ? payload : JSON.stringify(payload),
+      request_id: reqID,
+      type: opts.type == null ? 3 : opts.type
+    });
+    let timer = null;
+    const handleRes = (topic, message) => {
+      if (topic !== respTopic) return;
+      let msg;
+      try {
+        msg = JSON.parse(message.toString());
+      } catch {
+        return;
+      }
+      if (msg.request_id !== reqID) return;
+      if (typeof opts.filter === "function" && !opts.filter(msg)) return;
+      ctx.mqttClient.removeListener("message", handleRes);
+      if (timer) clearTimeout(timer);
+      try {
+        msg.payload = typeof msg.payload === "string" ? JSON.parse(msg.payload) : msg.payload;
+      } catch { }
+      const out = { success: true, response: msg.payload, raw: msg };
+      if (cb) cb(null, out);
+      resolve(out);
+    };
+    ctx.mqttClient.on("message", handleRes);
+    timer = setTimeout(() => {
+      ctx.mqttClient.removeListener("message", handleRes);
+      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);
+      }
+    });
+  });
+};
+
+module.exports = sendReqMqtt;

package/{lib → src}/database/models/index.js

@@ -1,13 +1,13 @@
-const { Sequelize } = require('sequelize');
-const fs = require('fs');
-const path = require('path');
-const databasePath = path.join(process.cwd(), 'Fca_Database');
+const { Sequelize } = require("sequelize");
+const fs = require("fs");
+const path = require("path");
+const databasePath = path.join(process.cwd(), "Fca_Database");
 if (!fs.existsSync(databasePath)) {
   fs.mkdirSync(databasePath, { recursive: true });
 }
 const sequelize = new Sequelize({
-  dialect: 'sqlite',
-  storage: path.join(databasePath, 'database.sqlite'),
+  dialect: "sqlite",
+  storage: path.join(databasePath, "database.sqlite"),
   logging: false,
   pool: {
     max: 5,
@@ -24,7 +24,9 @@ const sequelize = new Sequelize({
   isolationLevel: Sequelize.Transaction.ISOLATION_LEVELS.READ_COMMITTED
 });
 const models = {};
-fs.readdirSync(__dirname).filter(file => file.endsWith('.js') && file !== 'index.js').forEach(file => {
+fs.readdirSync(__dirname)
+  .filter(file => file.endsWith(".js") && file !== "index.js")
+  .forEach(file => {
     const model = require(path.join(__dirname, file))(sequelize);
     models[model.name] = model;
   });
@@ -37,11 +39,11 @@ models.sequelize = sequelize;
 models.Sequelize = Sequelize;
 models.syncAll = async () => {
   try {
-    await sequelize.sync({ force: false }); 
+    await sequelize.sync({ force: false });
   } catch (error) {
-    console.error('Failed to synchronize models:', error);
+    console.error("Failed to synchronize models:", error);
     throw error;
   }
 };
 
-module.exports = models;
+module.exports = models;

package/{lib → src}/database/models/thread.js

@@ -9,23 +9,23 @@ module.exports = function(sequelize) {
         type: DataTypes.INTEGER,
         allowNull: false,
         autoIncrement: true,
-        primaryKey: true,
+        primaryKey: true
       },
       threadID: {
         type: DataTypes.STRING,
         allowNull: false,
-        unique: true,
+        unique: true
       },
       data: {
         type: DataTypes.JSONB,
-        allowNull: true,
+        allowNull: true
       }
     },
     {
       sequelize,
       modelName: "Thread",
-      timestamps: true,
+      timestamps: true
     }
   );
   return Thread;
-};
+};