@dongdev/fca-unofficial 3.0.31 → 4.0.1

package/src/api/threads/getThreadInfo.js

@@ -1,296 +0,0 @@
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-const { parseAndCheckLogin } = require('../../utils/client');
-const log = require('../../../func/logAdapter');
-
-function formatEventReminders(reminder) {
-  return {
-    reminderID: reminder.id,
-    eventCreatorID: reminder.lightweight_event_creator.id,
-    time: reminder.time,
-    eventType: reminder.lightweight_event_type.toLowerCase(),
-    locationName: reminder.location_name,
-    locationCoordinates: reminder.location_coordinates,
-    locationPage: reminder.location_page,
-    eventStatus: reminder.lightweight_event_status.toLowerCase(),
-    note: reminder.note,
-    repeatMode: reminder.repeat_mode.toLowerCase(),
-    eventTitle: reminder.event_title,
-    triggerMessage: reminder.trigger_message,
-    secondsToNotifyBefore: reminder.seconds_to_notify_before,
-    allowsRsvp: reminder.allows_rsvp,
-    relatedEvent: reminder.related_event,
-    members: reminder.event_reminder_members.edges.map((member) => ({
-      memberID: member.node.id,
-      state: member.guest_list_state.toLowerCase(),
-    })),
-  };
-}
-
-function formatThreadGraphQLResponse(data) {
-  if (data.errors) {
-    const details = data.errors.map(e => e.message || e).join(", ");
-    const error = new Error(`GraphQL error in getThreadInfo: ${details}`);
-    throw error;
-  }
-
-  const messageThread = data.message_thread;
-  if (!messageThread) {
-    throw new Error("No message_thread in GraphQL response");
-  }
-
-  const threadID =
-    messageThread.thread_key.thread_fbid ||
-    messageThread.thread_key.other_user_id;
-
-  const lastM = messageThread.last_message;
-  const snippetID =
-    lastM?.nodes?.[0]?.message_sender?.messaging_actor?.id || null;
-  const snippetText = lastM?.nodes?.[0]?.snippet || null;
-  const lastReadTimestamp =
-    messageThread.last_read_receipt?.nodes?.[0]?.timestamp_precise || null;
-
-  return {
-    threadID,
-    threadName: messageThread.name,
-    participantIDs: messageThread.all_participants.edges.map(
-      d => d.node.messaging_actor.id
-    ),
-    userInfo: messageThread.all_participants.edges.map(d => ({
-      id: d.node.messaging_actor.id,
-      name: d.node.messaging_actor.name,
-      firstName: d.node.messaging_actor.short_name,
-      vanity: d.node.messaging_actor.username,
-      url: d.node.messaging_actor.url,
-      thumbSrc: d.node.messaging_actor.big_image_src.uri,
-      profileUrl: d.node.messaging_actor.big_image_src.uri,
-      gender: d.node.messaging_actor.gender,
-      type: d.node.messaging_actor.__typename,
-      isFriend: d.node.messaging_actor.is_viewer_friend,
-      isBirthday: !!d.node.messaging_actor.is_birthday,
-    })),
-    unreadCount: messageThread.unread_count,
-    messageCount: messageThread.messages_count,
-    timestamp: messageThread.updated_time_precise,
-    muteUntil: messageThread.mute_until,
-    isGroup: messageThread.thread_type === "GROUP",
-    isSubscribed: messageThread.is_viewer_subscribed,
-    isArchived: messageThread.has_viewer_archived,
-    folder: messageThread.folder,
-    cannotReplyReason: messageThread.cannot_reply_reason,
-    eventReminders: messageThread.event_reminders
-      ? messageThread.event_reminders.nodes.map(formatEventReminders)
-      : null,
-    emoji: messageThread.customization_info?.emoji || null,
-    color: messageThread.customization_info?.outgoing_bubble_color
-      ? messageThread.customization_info.outgoing_bubble_color.slice(2)
-      : null,
-    threadTheme: messageThread.thread_theme,
-    nicknames:
-      messageThread.customization_info?.participant_customizations?.reduce(
-        (res, val) => {
-          if (val.nickname) res[val.participant_id] = val.nickname;
-          return res;
-        },
-        {}
-      ) || {},
-    adminIDs: messageThread.thread_admins,
-    approvalMode: Boolean(messageThread.approval_mode),
-    approvalQueue:
-      messageThread.group_approval_queue?.nodes?.map(a => ({
-        inviterID: a.inviter.id,
-        requesterID: a.requester.id,
-        timestamp: a.request_timestamp,
-        request_source: a.request_source,
-      })) || [],
-    reactionsMuteMode: messageThread.reactions_mute_mode?.toLowerCase(),
-    mentionsMuteMode: messageThread.mentions_mute_mode?.toLowerCase(),
-    isPinProtected: messageThread.is_pin_protected,
-    relatedPageThread: messageThread.related_page_thread,
-    name: messageThread.name,
-    snippet: snippetText,
-    snippetSender: snippetID,
-    snippetAttachments: [],
-    serverTimestamp: messageThread.updated_time_precise,
-    imageSrc: messageThread.image?.uri || null,
-    isCanonicalUser: messageThread.is_canonical_neo_user,
-    isCanonical: messageThread.thread_type !== "GROUP",
-    recipientsLoadable: true,
-    hasEmailParticipant: false,
-    readOnly: false,
-    canReply: messageThread.cannot_reply_reason == null,
-    lastMessageTimestamp:
-      messageThread.last_message?.timestamp_precise || null,
-    lastMessageType: "message",
-    lastReadTimestamp,
-    threadType: messageThread.thread_type === "GROUP" ? 2 : 1,
-    inviteLink: {
-      enable: messageThread.joinable_mode?.mode === 1,
-      link: messageThread.joinable_mode?.link || null,
-    },
-  };
-}
-
-module.exports = function (defaultFuncs, api, ctx) {
-  const dbFiles = fs.readdirSync(path.join(__dirname, "../../database"))
-    .filter(f => path.extname(f) === ".js")
-    .reduce((acc, file) => {
-      const mod = require(path.join(__dirname, "../../database", file));
-      acc[path.basename(file, ".js")] = typeof mod === "function" ? mod(api) : mod;
-      return acc;
-    }, {});
-
-  const { threadData } = dbFiles;
-  const { create, get, update } = threadData || {};
-  const FRESH_MS = 10 * 60 * 1000;
-  return function getThreadInfo(threadID, callback) {
-    let resolveFunc;
-    let rejectFunc;
-
-    const returnPromise = new Promise((resolve, reject) => {
-      resolveFunc = resolve;
-      rejectFunc = reject;
-    });
-
-    if (typeof callback !== "function") {
-      callback = (err, data) => {
-        if (err) {
-          return rejectFunc(err);
-        }
-        return resolveFunc(data);
-      };
-    }
-
-    const threadIDs = Array.isArray(threadID) ? threadID.map(String) : [String(threadID)];
-
-    const now = Date.now();
-
-    const loadFromDb = async ids => {
-      if (!threadData || typeof get !== "function") return { fresh: {}, stale: ids };
-      const fresh = {};
-      const stale = [];
-      const rows = await Promise.all(ids.map(id => get(id).catch(() => null)));
-      for (let i = 0; i < ids.length; i++) {
-        const id = ids[i];
-        const row = rows[i];
-        if (row && row.data) {
-          const updatedAt = row.updatedAt ? new Date(row.updatedAt).getTime() : 0;
-          if (updatedAt && now - updatedAt <= FRESH_MS) {
-            fresh[id] = row.data;
-          } else {
-            stale.push(id);
-          }
-        } else {
-          stale.push(id);
-        }
-      }
-      return { fresh, stale };
-    };
-
-    const fetchFromGraphQL = async ids => {
-      if (!ids.length) return {};
-      const queries = {};
-      ids.forEach((t, i) => {
-        queries["o" + i] = {
-          doc_id: "3449967031715030",
-          query_params: {
-            id: t,
-            message_limit: 0,
-            load_messages: false,
-            load_read_receipts: false,
-            before: null
-          }
-        };
-      });
-
-      const form = {
-        queries: JSON.stringify(queries),
-        batch_name: "MessengerGraphQLThreadFetcher"
-      };
-
-      const resData = await defaultFuncs
-        .post(
-          "https://www.facebook.com/api/graphqlbatch/",
-          ctx.jar,
-          form
-        )
-        .then(parseAndCheckLogin(ctx, defaultFuncs));
-
-      if (resData.error) {
-        throw resData;
-      }
-
-      const out = {};
-      for (let i = resData.length - 2; i >= 0; i--) {
-        const res = resData[i];
-        const oKey = Object.keys(res)[0];
-        const responseData = res[oKey];
-        try {
-          const info = formatThreadGraphQLResponse(responseData.data);
-          if (info && info.threadID) {
-            out[info.threadID] = info;
-          }
-        } catch (e) {
-          // Skip malformed entries but continue processing others
-          log.error("getThreadInfoGraphQL", e && e.message ? e.message : String(e));
-        }
-      }
-      return out;
-    };
-
-    (async () => {
-      try {
-        const { fresh, stale } = await loadFromDb(threadIDs);
-        let fetched = {};
-
-        if (stale.length) {
-          fetched = await fetchFromGraphQL(stale);
-
-          // Persist fetched data back to DB
-          if (threadData && (typeof create === "function" || typeof update === "function")) {
-            const tasks = [];
-            for (const id of stale) {
-              const info = fetched[id];
-              if (!info) continue;
-              const payload = { data: info };
-              if (typeof update === "function") {
-                tasks.push(update(id, payload).catch(() => null));
-              } else if (typeof create === "function") {
-                tasks.push(create(id, payload).catch(() => null));
-              }
-            }
-            if (tasks.length) {
-              try {
-                await Promise.all(tasks);
-              } catch {
-                // Swallow DB errors – not critical for API behavior
-              }
-            }
-          }
-        }
-
-        const resultMap = {};
-        for (const id of threadIDs) {
-          resultMap[id] = fresh[id] || fetched[id] || null;
-        }
-
-        const result = Array.isArray(threadID)
-          ? resultMap
-          : resultMap[threadIDs[0]] || null;
-
-        return callback(null, result);
-      } catch (err) {
-        // Horizon-style anti-get-info message to hint possible spam/limit
-        log.error(
-          "getThreadInfoGraphQL",
-          "Lỗi: getThreadInfoGraphQL Có Thể Do Bạn Spam Quá Nhiều, Hãy Thử Lại !"
-        );
-        return callback(err);
-      }
-    })();
-
-    return returnPromise;
-  };
-};

package/src/api/threads/getThreadList.js

@@ -1,293 +0,0 @@
-"use strict";
-
-const log = require("../../../func/logAdapter");
-const { parseAndCheckLogin } = require("../../utils/client");
-const { formatID, getType } = require("../../utils/format");
-function createProfileUrl(url, username, id) {
-  if (url) return url;
-  return (
-    "https://www.facebook.com/" + (username || formatID(id.toString()))
-  );
-}
-
-function formatParticipants(participants) {
-  return participants.edges.map(p => {
-    p = p.node.messaging_actor;
-    switch (p["__typename"]) {
-      case "User":
-        return {
-          accountType: p["__typename"],
-          userID: formatID(p.id.toString()), // do we need .toString()? when it is not a string?
-          name: p.name,
-          shortName: p.short_name,
-          gender: p.gender,
-          url: p.url, // how about making it profileURL
-          profilePicture: p.big_image_src.uri,
-          username: p.username || null,
-          // TODO: maybe better names for these?
-          isViewerFriend: p.is_viewer_friend, // true/false
-          isMessengerUser: p.is_messenger_user, // true/false
-          isVerified: p.is_verified, // true/false
-          isMessageBlockedByViewer: p.is_message_blocked_by_viewer, // true/false
-          isViewerCoworker: p.is_viewer_coworker, // true/false
-          isEmployee: p.is_employee // null? when it is something other? can someone check?
-        };
-      case "Page":
-        return {
-          accountType: p["__typename"],
-          userID: formatID(p.id.toString()), // or maybe... pageID?
-          name: p.name,
-          url: p.url,
-          profilePicture: p.big_image_src.uri,
-          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
-        };
-      case "ReducedMessagingActor":
-      case "UnavailableMessagingActor":
-        return {
-          accountType: p["__typename"],
-          userID: formatID(p.id.toString()),
-          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
-        };
-      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)
-        );
-        return {
-          accountType: p["__typename"],
-          userID: formatID(p.id.toString()),
-          name: p.name || `[unknown ${p["__typename"]}]` // probably it will always be something... but fallback to [unknown], just in case
-        };
-    }
-  });
-}
-
-// "FF8C0077" -> "8C0077"
-function formatColor(color) {
-  if (color && color.match(/^(?:[0-9a-fA-F]{8})$/g)) return color.slice(2);
-  return color;
-}
-
-function getThreadName(t) {
-  if (t.name || t.thread_key.thread_fbid) return t.name;
-
-  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;
-  }
-}
-
-function mapNicknames(customizationInfo) {
-  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;
-    return {
-      threadID: t.thread_key
-        ? 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
-      ),
-      threadTheme: t.thread_theme,
-      nicknames: mapNicknames(t.customization_info),
-      muteUntil: t.mute_until,
-      participants: formatParticipants(t.all_participants),
-      adminIDs: t.thread_admins.map(a => a.id),
-      folder: t.folder,
-      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"
-      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
-        ? 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
-      ),
-      threadType: t.thread_type === "GROUP" ? 2 : 1, // "GROUP" or "ONE_TO_ONE"
-      inviteLink: {
-        enable: t.joinable_mode ? t.joinable_mode.mode == 1 : false,
-        link: t.joinable_mode ? t.joinable_mode.link : null
-      }
-    };
-  });
-}
-
-module.exports = function(defaultFuncs, api, ctx) {
-  return function getThreadList(limit, timestamp, tags, callback) {
-    if (
-      !callback &&
-      (getType(tags) === "Function" ||
-        getType(tags) === "AsyncFunction")
-    ) {
-      callback = tags;
-      tags = [""];
-    }
-    if (
-      getType(limit) !== "Number" ||
-      !Number.isInteger(limit) ||
-      limit <= 0
-    )
-      throw { error: "getThreadList: limit must be a positive integer" };
-    if (
-      getType(timestamp) !== "Null" &&
-      (getType(timestamp) !== "Number" || !Number.isInteger(timestamp))
-    )
-      throw { error: "getThreadList: timestamp must be an integer or null" };
-    if (getType(tags) === "String") tags = [tags];
-    if (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 (
-      getType(callback) !== "Function" &&
-      getType(callback) !== "AsyncFunction"
-    ) {
-      callback = function(err, data) {
-        if (err) return rejectFunc(err);
-        resolveFunc(data);
-      };
-    }
-    const form = {
-      av: ctx.userID,
-      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"
-    };
-    defaultFuncs
-      .post("https://www.facebook.com/api/graphqlbatch/", ctx.jar, form)
-      .then(parseAndCheckLogin(ctx, defaultFuncs))
-      .then(resData => {
-        // Validate resData is an array and has elements
-        if (!resData || !Array.isArray(resData) || resData.length === 0) {
-          throw {
-            error: "getThreadList: Invalid response data - resData is not a valid array",
-            res: resData
-          };
-        }
-
-        // Validate last element exists and has required properties
-        const lastElement = resData[resData.length - 1];
-        if (!lastElement || typeof lastElement !== "object") {
-          throw {
-            error: "getThreadList: Invalid response data - last element is missing or invalid",
-            res: resData
-          };
-        }
-
-        if (lastElement.error_results > 0) {
-          // Check if first element and o0 exist before accessing errors
-          if (resData[0] && resData[0].o0 && resData[0].o0.errors) {
-            throw resData[0].o0.errors;
-          } else {
-            throw {
-              error: "getThreadList: Error results > 0 but error details not available",
-              res: resData
-            };
-          }
-        }
-
-        if (lastElement.successful_results === 0) {
-          throw {
-            error: "getThreadList: there was no successful_results",
-            res: resData
-          };
-        }
-
-        // Validate first element and nested data structure
-        if (!resData[0] || !resData[0].o0 || !resData[0].o0.data ||
-            !resData[0].o0.data.viewer || !resData[0].o0.data.viewer.message_threads ||
-            !Array.isArray(resData[0].o0.data.viewer.message_threads.nodes)) {
-          throw {
-            error: "getThreadList: Invalid response data structure - missing required fields",
-            res: resData
-          };
-        }
-
-        if (timestamp) {
-          const nodes = resData[0].o0.data.viewer.message_threads.nodes;
-          if (Array.isArray(nodes) && nodes.length > 0) {
-            nodes.shift();
-          }
-        }
-
-        callback(
-          null,
-          formatThreadList(resData[0].o0.data.viewer.message_threads.nodes)
-        );
-      })
-      .catch(err => {
-        log.error("getThreadList", err);
-        return callback(err);
-      });
-    return returnPromise;
-  };
-};

package/src/api/threads/getThreadPictures.js

@@ -1,78 +0,0 @@
-"use strict";
-
-const log = require("../../../func/logAdapter");
-const { parseAndCheckLogin } = require("../../utils/client");
-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(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(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;
-  };
-};