bb-fca 2.0.0

package/src/deltas/apis/threads/getThreadList.ts

@@ -0,0 +1,224 @@
+// @ChoruOfficial
+'use strict';
+
+import utils = require('../../../utils');
+
+/**
+ * Formats an event reminder object from a GraphQL response.
+ * @param {Object} reminder The raw event reminder object.
+ * @returns {Object} A formatted event reminder object.
+ */
+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(function(member) {
+      return {
+        memberID: member.node.id,
+        state: member.guest_list_state.toLowerCase(),
+      };
+    }),
+  };
+}
+
+/**
+ * Formats a thread object from a GraphQL response.
+ * @param {Object} messageThread The raw message_thread object from GraphQL.
+ * @returns {Object | null} A formatted thread object or null if data is invalid.
+ */
+function formatThreadGraphQLResponse(messageThread) {
+  if (!messageThread || !messageThread.thread_key) return null;
+
+  const threadID = messageThread.thread_key.thread_fbid
+    ? 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 lastR = messageThread.last_read_receipt;
+  const lastReadTimestamp = lastR?.nodes?.[0]?.timestamp_precise || null;
+
+  return {
+    threadID: 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
+      ? messageThread.customization_info.emoji
+      : null,
+    color:
+      messageThread.customization_info &&
+      messageThread.customization_info.outgoing_bubble_color
+        ? messageThread.customization_info.outgoing_bubble_color.slice(2)
+        : null,
+    threadTheme: messageThread.thread_theme,
+    nicknames:
+      messageThread.customization_info &&
+      messageThread.customization_info.participant_customizations
+        ? messageThread.customization_info.participant_customizations.reduce(
+            (res, val) => {
+              if (val.nickname) res[val.participant_id] = val.nickname;
+              return res;
+            },
+            {},
+          )
+        : {},
+    adminIDs: messageThread.thread_admins.map((a) => a.id),
+    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 ? 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
+      ? messageThread.last_message.timestamp_precise
+      : null,
+    lastMessageType: 'message',
+    lastReadTimestamp: lastReadTimestamp,
+    threadType: messageThread.thread_type == 'GROUP' ? 2 : 1,
+    inviteLink: {
+      enable: messageThread.joinable_mode?.mode == 1,
+      link: messageThread.joinable_mode?.link || null,
+    },
+  };
+}
+
+/**
+ * @param {Object} defaultFuncs
+ * @param {Object} api
+ * @param {Object} ctx
+ * @returns {function(limit: number, timestamp: number | null, tags: string[]): Promise<Array<Object>>}
+ */
+export default function(defaultFuncs: any, api: any, ctx: any) {
+  /**
+   * Retrieves a list of threads.
+   * @param {number} limit - The number of threads to retrieve.
+   * @param {number|null} timestamp - A timestamp to start fetching threads before. Use null for the most recent.
+   * @param {string[]} tags - An array of tags to filter threads by (e.g., ["INBOX", "ARCHIVED"]).
+   * @returns {Promise<Object[]>} A promise that resolves with an array of formatted thread objects.
+   */
+  return async function getThreadList(
+    limit,
+    timestamp = null,
+    tags = ['INBOX'],
+  ) {
+    if (
+      utils.getType(limit) !== 'Number' ||
+      !Number.isInteger(limit) ||
+      limit <= 0
+    ) {
+      throw new Error('getThreadList: limit must be a positive integer.');
+    }
+    if (
+      utils.getType(timestamp) !== 'Null' &&
+      (utils.getType(timestamp) !== 'Number' || !Number.isInteger(timestamp))
+    ) {
+      throw new Error('getThreadList: timestamp must be an integer or null.');
+    }
+    if (utils.getType(tags) === 'String') {
+      tags = [tags] as any;
+    }
+    if (utils.getType(tags) !== 'Array') {
+      throw new Error('getThreadList: tags must be an array.');
+    }
+
+    const form = {
+      av: ctx.i_userID || ctx.userID,
+      queries: JSON.stringify({
+        o0: {
+          doc_id: '3426149104143726',
+          query_params: {
+            limit: limit + (timestamp ? 1 : 0),
+            before: timestamp,
+            tags: tags,
+            includeDeliveryReceipts: true,
+            includeSeqID: false,
+          },
+        },
+      }),
+      batch_name: 'MessengerGraphQLThreadlistFetcher',
+    };
+
+    try {
+      const resData = await defaultFuncs
+        .post('https://www.facebook.com/api/graphqlbatch/', ctx.jar, form)
+        .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+      if (resData[resData.length - 1].error_results > 0) {
+        throw new Error(JSON.stringify(resData[0].o0.errors));
+      }
+
+      if (resData[resData.length - 1].successful_results === 0) {
+        throw new Error('getThreadList: there was no successful_results');
+      }
+
+      let nodes = resData[0].o0.data.viewer.message_threads.nodes;
+      if (timestamp) {
+        nodes.shift();
+      }
+
+      return nodes.map(formatThreadGraphQLResponse);
+    } catch (err) {
+      utils.error('getThreadList', err);
+      throw err;
+    }
+  };
+}

package/src/deltas/apis/users/getUserInfo.ts

@@ -0,0 +1,244 @@
+// @ChoruOfficial
+import utils = require("../../../utils");
+import _ from "lodash";
+import deepdash from "deepdash";
+deepdash(_);
+
+/**
+ * @param {object} data
+ * @param {string} userID
+ * @returns {object|null}
+ */
+function findMainUserObject(data, userID) {
+  let mainUserObject = null;
+  if (!Array.isArray(data)) return null;
+  function deepFind(obj) {
+    if (mainUserObject || typeof obj !== 'object' || obj === null) return;
+    if (obj.id === userID && obj.__typename === 'User' && obj.profile_tabs) {
+      mainUserObject = obj;
+      return;
+    }
+    for (const k in obj) {
+      if (obj.hasOwnProperty(k)) {
+        deepFind(obj[k]);
+      }
+    }
+  }
+  deepFind({ all: data });
+  return mainUserObject;
+}
+
+/**
+ * @param {object} socialContext
+ * @param {string} keyword
+ * @returns {string|null}
+ */
+function findSocialContextText(socialContext, keyword) {
+  if (socialContext && Array.isArray(socialContext.content)) {
+    for (const item of socialContext.content) {
+      const text = item?.text?.text;
+      if (text && text.toLowerCase().includes(keyword.toLowerCase())) {
+        return text;
+      }
+    }
+  }
+  return null;
+}
+
+/**
+ * @param {Array<Object>} dataArray
+ * @param {string} key
+ * @returns {any}
+ */
+function findFirstValueByKey(dataArray, key) {
+  if (!Array.isArray(dataArray)) return null;
+  let found = null;
+  function deepSearch(obj) {
+    if (found !== null || typeof obj !== 'object' || obj === null) return;
+    if (obj.hasOwnProperty(key)) {
+      found = obj[key];
+      return;
+    }
+    for (const k in obj) {
+      if (obj.hasOwnProperty(k)) {
+        deepSearch(obj[k]);
+      }
+    }
+  }
+  for (const obj of dataArray) {
+    deepSearch(obj);
+  }
+  return found;
+}
+
+/**
+ * @param {Array<Object>} allJsonData
+ * @returns {string|null}
+ */
+function findBioFromProfileTiles(allJsonData) {
+  try {
+    const bio = findFirstValueByKey(allJsonData, 'profile_status_text');
+    return bio?.text || null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * @param {Array<Object>} allJsonData
+ * @returns {string|null}
+ */
+function findLiveCityFromProfileTiles(allJsonData) {
+  try {
+    const result = _.findDeep(allJsonData, (value, key, parent) => {
+      return key === 'text' &&
+        typeof value === 'string' &&
+        value.includes('Lives in') &&
+        parent?.ranges?.[0]?.entity?.category_type === "CITY_WITH_ID";
+    });
+
+    if (result) {
+      return result.value;
+    }
+
+    return null;
+  } catch (err) {
+    return null;
+  }
+}
+
+export default function(defaultFuncs: any, api: any, ctx: any) {
+  function createDefaultUser(id) {
+    return {
+      id,
+      name: "Facebook User",
+      firstName: "Facebook",
+      lastName: null,
+      vanity: id,
+      profilePicUrl: `https://graph.facebook.com/${id}/picture?width=720&height=720&access_token=6628568379%7Cc1e620fa708a1d5696fb991c1bde5662`,
+      profileUrl: `https://www.facebook.com/profile.php?id=${id}`,
+      gender: "no specific gender",
+      type: "user",
+      isFriend: false,
+      isBirthday: false
+    };
+  }
+
+  return function getUserInfo(id, usePayload, callback, groupFields = []) {
+    let resolveFunc: Function = () => {};
+    let rejectFunc: Function = () => {};
+    const returnPromise = new Promise<any>((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (typeof usePayload === 'function') {
+      callback = usePayload;
+      usePayload = true;
+    }
+    if (usePayload === undefined) usePayload = true;
+    if (!callback) {
+      callback = (err, data) => {
+        if (err) return rejectFunc(err);
+        resolveFunc(data);
+      };
+    }
+
+    const originalIdIsArray = Array.isArray(id);
+    const ids = originalIdIsArray ? id : [id];
+
+    if (usePayload) {
+      const form = {};
+      ids.forEach((v, i) => { form[`ids[${i}]`] = v; });
+      const getGenderString = (code) => code === 1 ? "male" : code === 2 ? "female" : "no specific gender";
+      defaultFuncs.post("https://www.facebook.com/chat/user_info/", ctx.jar, form)
+        .then(resData => utils.parseAndCheckLogin(ctx, defaultFuncs)(resData))
+        .then(resData => {
+          if (resData?.error && resData?.error !== 3252001) throw resData;
+          const retObj = {};
+          const profiles = resData?.payload?.profiles;
+          if (profiles) {
+            for (const prop in profiles) {
+              if (profiles.hasOwnProperty(prop)) {
+                const inner = profiles[prop];
+                const nameParts = inner.name ? inner.name.split(' ') : [];
+                retObj[prop] = {
+                  id: prop,
+                  name: inner.name,
+                  firstName: inner.firstName,
+                  lastName: nameParts.length > 1 ? nameParts[nameParts.length - 1] : null,
+                  vanity: inner.vanity,
+                  profilePicUrl: `https://graph.facebook.com/${prop}/picture?width=720&height=720&access_token=6628568379%7Cc1e620fa708a1d5696fb991c1bde5662`,
+                  profileUrl: inner.uri,
+                  gender: getGenderString(inner.gender),
+                  type: inner.type,
+                  isFriend: inner.is_friend,
+                  isBirthday: !!inner.is_birthday,
+                  searchTokens: inner.searchTokens,
+                  alternateName: inner.alternateName
+                };
+              }
+            }
+          } else {
+            for (const prop of ids) {
+              retObj[prop] = createDefaultUser(prop);
+            }
+          }
+          return originalIdIsArray ? callback(null, Object.values(retObj)) : callback(null, retObj[ids[0]]);
+        }).catch(err => {
+          utils.error("getUserInfo (payload)", err);
+          return callback(err);
+        });
+    } else {
+      const fetchProfile = async (userID) => {
+        try {
+          const url = `https://www.facebook.com/${userID}`;
+          const allJsonData = await utils.json(url, ctx.jar, null, ctx.globalOptions, ctx);
+          if (!allJsonData || allJsonData.length === 0) throw new Error(`Could not find JSON data for ID: ${userID}`);
+          const mainUserObject = findMainUserObject(allJsonData, userID);
+          if (!mainUserObject) throw new Error(`Could not isolate main user object for ID: ${userID}`);
+          const get = (obj, path) => {
+            if (!obj || !path) return null;
+            return path.split('.').reduce((prev, curr) => (prev ? prev[curr] : undefined), obj);
+          };
+          const name = mainUserObject.name;
+          const nameParts = name ? name.split(' ') : [];
+          const result = {
+            id: mainUserObject.id,
+            name: name,
+            firstName: nameParts[0] || get(mainUserObject, 'short_name') || get(findFirstValueByKey(allJsonData, 'profile_owner'), 'short_name'),
+            lastName: nameParts.length > 1 ? nameParts[nameParts.length - 1] : null,
+            vanity: get(mainUserObject, 'vanity') || get(findFirstValueByKey(allJsonData, 'props'), 'userVanity') || null,
+            profileUrl: mainUserObject.url,
+            profilePicUrl: `https://graph.facebook.com/${userID}/picture?width=720&height=720&access_token=6628568379%7Cc1e620fa708a1d5696fb991c1bde5662`,
+            gender: mainUserObject.gender,
+            type: mainUserObject.__typename,
+            isFriend: mainUserObject.is_viewer_friend,
+            isBirthday: !!mainUserObject.is_birthday,
+            isVerified: !!mainUserObject.show_verified_badge_on_profile,
+            bio: findBioFromProfileTiles(allJsonData) || get(findFirstValueByKey(allJsonData, 'delegate_page'), 'best_description.text'),
+            live_city: findLiveCityFromProfileTiles(allJsonData),
+            headline: get(mainUserObject, 'contextual_headline.text') || get(findFirstValueByKey(allJsonData, 'meta_verified_section'), 'headline'),
+            followers: findSocialContextText(mainUserObject.profile_social_context, "followers"),
+            following: findSocialContextText(mainUserObject.profile_social_context, "following"),
+            coverPhoto: get(mainUserObject, 'cover_photo.photo.image.uri')
+          };
+          return result;
+        } catch (err) {
+          utils.error(`Failed to fetch profile for ${userID}: ${err.message}`, err);
+          return createDefaultUser(userID);
+        }
+      };
+
+      Promise.all(ids.map(fetchProfile))
+        .then(results => {
+          return originalIdIsArray ? callback(null, results) : callback(null, results[0] || null);
+        })
+        .catch(err => {
+          utils.error("getUserInfo (fetch)", err);
+          callback(err);
+        });
+    }
+    return returnPromise;
+  };
+};