@lazyneoaz/testfca 1.0.0

package/src/apis/getThreadList.js

@@ -0,0 +1,232 @@
+
+"use strict";
+
+const 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) => {
+      const p = d.node.messaging_actor;
+      return {
+        id: p.id,
+        name: p.name,
+        firstName: p.short_name,
+        vanity: p.username,
+        url: p.url,
+        thumbSrc: p.big_image_src?.uri,
+        profileUrl: p.big_image_src?.uri,
+        gender: p.gender,
+        type: p.__typename,
+        isFriend: p.is_viewer_friend,
+        isBirthday: !!p.is_birthday,
+        isEmployee: p.is_employee,
+        isMessengerUser: p.is_messenger_user,
+        isVerified: p.is_verified,
+        isMessageBlockedByViewer: p.is_message_blocked_by_viewer,
+        isViewerCoworker: p.is_viewer_coworker,
+        acceptsMessengerUserFeedback: p.accepts_messenger_user_feedback,
+        isMessengerPlatformBot: p.is_messenger_platform_bot,
+      };
+    }),
+    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() || 'all_reactions',
+    mentionsMuteMode: messageThread.mentions_mute_mode?.toLowerCase() || 'all_mentions',
+    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>>}
+ */
+module.exports = function (defaultFuncs, api, ctx) {
+  /**
+   * 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];
+    }
+    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: "3336396659757871",
+          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 || !Array.isArray(resData) || resData.length === 0) {
+        throw new Error("getThreadList: Invalid response from server");
+      }
+
+      const lastResult = resData[resData.length - 1];
+      if (lastResult && lastResult.error_results && lastResult.error_results > 0) {
+        throw new Error(JSON.stringify(resData[0]?.o0?.errors || "Unknown error"));
+      }
+
+      if (lastResult && lastResult.successful_results === 0) {
+        throw new Error("getThreadList: there was no successful_results");
+      }
+
+      if (!resData[0] || !resData[0].o0 || !resData[0].o0.data) {
+        throw new Error("getThreadList: Invalid data structure in response");
+      }
+
+      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/apis/getThreadPictures.js

@@ -0,0 +1,58 @@
+"use strict";
+
+const utils = require('../utils');
+
+module.exports = (defaultFuncs, api, ctx) => {
+  return async function getThreadPictures(threadID, offset, limit, callback) {
+    let resolveFunc = () => {};
+    let rejectFunc = () => {};
+    const returnPromise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      if (utils.getType(limit) === "Function") {
+        callback = limit;
+        limit = 50;
+      } else if (utils.getType(offset) === "Function") {
+        callback = offset;
+        offset = 0;
+        limit = 50;
+      } else {
+        callback = (err, result) => {
+          if (err) return rejectFunc(err);
+          resolveFunc(result);
+        };
+      }
+    }
+
+    offset = offset || 0;
+    limit = limit || 50;
+
+    try {
+      const form = {
+        thread_id: threadID,
+        offset: offset,
+        limit: limit
+      };
+
+      const res = await defaultFuncs.post(
+        "https://www.facebook.com/ajax/mercury/thread_images.php",
+        ctx.jar,
+        form
+      ).then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+      if (res && res.error) {
+        throw res;
+      }
+
+      return callback(null, res?.payload || res);
+    } catch (err) {
+      utils.error("getThreadPictures", err);
+      callback(err);
+    }
+
+    return returnPromise;
+  };
+};

package/src/apis/getUserID.js

@@ -0,0 +1,117 @@
+"use strict";
+
+const utils = require('../utils');
+
+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 = (defaultFuncs, api, ctx) => {
+  return async function getUID(link, callback) {
+    let resolveFunc = () => {};
+    let rejectFunc = () => {};
+    const returnPromise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      callback = (err, result) => {
+        if (err) return rejectFunc(err);
+        resolveFunc(result);
+      };
+    }
+
+    if (!link || typeof link !== 'string') {
+      const error = { error: "getUID: link parameter must be a non-empty string" };
+      utils.error("getUID", error);
+      return callback(error);
+    }
+
+    // Check if it's a profile URL
+    const isProfileUrl = link.match(/\.com/);
+    if (!isProfileUrl) {
+      // Treat as username/name, use search
+      try {
+        const form = {
+          value: link.toLowerCase(),
+          viewer: ctx.userID,
+          rsp: "search",
+          context: "search",
+          path: "/home.php",
+          request_id: ctx.clientID || utils.getGUID()
+        };
+
+        const res = await defaultFuncs.get("https://www.facebook.com/ajax/typeahead/search.php", ctx.jar, form)
+          .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+        if (res.error) {
+          throw res;
+        }
+
+        if (!res.payload || !res.payload.entries) {
+          const error = { 
+            error: "getUID: No results found. This may be due to Facebook security restrictions or account checkpoint.",
+            details: "Your account may require verification. Please visit facebook.com to verify."
+          };
+          throw error;
+        }
+
+        const data = res.payload.entries;
+        
+        if (data.length === 0) {
+          utils.warn(`getUID: No user found with name "${link}"`);
+        }
+
+        callback(null, data.map(formatData));
+      } catch (err) {
+        if (err.error && typeof err.error === 'string' && err.error.includes('checkpoint')) {
+          err.friendlyMessage = "Account checkpoint required - Please verify your account on facebook.com";
+        }
+        utils.error("getUID", err);
+        callback(err);
+      }
+      return returnPromise;
+    }
+
+    // Handle profile URL
+    try {
+      let uid;
+      if (link.includes('profile.php?id=')) {
+        uid = link.split('profile.php?id=')[1].split('&')[0];
+      } else {
+        // For username URLs, fetch the page to get userID
+        const res = await defaultFuncs.get(link, ctx.jar)
+          .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+        
+        const userIDMatch = res.match(/"userID":"(\d+)"/) || res.match(/"id":"(\d+)"/) || res.match(/entity_id["\s:]+(\d+)/);
+        if (userIDMatch) {
+          uid = userIDMatch[1];
+        } else {
+          throw new Error("Could not extract user ID from profile URL");
+        }
+      }
+
+      if (!uid || !/^\d+$/.test(uid)) {
+        throw new Error("Invalid user ID extracted");
+      }
+
+      callback(null, uid);
+    } catch (err) {
+      utils.error("getUID", err);
+      callback(err);
+    }
+
+    return returnPromise;
+  };
+};