@cexy/hoonfca 1.0.1 → 1.0.3

package/src/apis/getThreadHistory.js

@@ -1,239 +0,0 @@
-"use strict";
-
-const utils = require('../utils');
-
-
-/**
- * Formats a single attachment object from a GraphQL response.
- * @param {Object} attachment The raw attachment object.
- * @returns {Object} A formatted attachment object.
- */
-function formatAttachmentsGraphQLResponse(attachment) {
-    switch (attachment.__typename) {
-        case "MessageImage":
-            return {
-                type: "photo",
-                ID: attachment.legacy_attachment_id,
-                filename: attachment.filename,
-                thumbnailUrl: attachment.thumbnail.uri,
-                previewUrl: attachment.preview.uri,
-                previewWidth: attachment.preview.width,
-                previewHeight: attachment.preview.height,
-                largePreviewUrl: attachment.large_preview.uri,
-                largePreviewHeight: attachment.large_preview.height,
-                largePreviewWidth: attachment.large_preview.width,
-                url: attachment.large_preview.uri,
-                width: attachment.original_dimensions.x,
-                height: attachment.original_dimensions.y,
-                name: attachment.filename
-            };
-        case "MessageAnimatedImage":
-            return {
-                type: "animated_image",
-                ID: attachment.legacy_attachment_id,
-                filename: attachment.filename,
-                previewUrl: attachment.preview_image.uri,
-                previewWidth: attachment.preview_image.width,
-                previewHeight: attachment.preview_image.height,
-                url: attachment.animated_image.uri,
-                width: attachment.animated_image.width,
-                height: attachment.animated_image.height,
-                name: attachment.filename,
-                facebookUrl: attachment.animated_image.uri,
-            };
-        case "MessageVideo":
-            return {
-                type: "video",
-                ID: attachment.legacy_attachment_id,
-                filename: attachment.filename,
-                duration: attachment.playable_duration_in_ms,
-                thumbnailUrl: attachment.large_image.uri,
-                previewUrl: attachment.large_image.uri,
-                previewWidth: attachment.large_image.width,
-                previewHeight: attachment.large_image.height,
-                url: attachment.playable_url,
-                width: attachment.original_dimensions.x,
-                height: attachment.original_dimensions.y,
-                videoType: attachment.video_type.toLowerCase(),
-            };
-        case "MessageFile":
-            return {
-                type: "file",
-                ID: attachment.message_file_fbid,
-                filename: attachment.filename,
-                url: attachment.url,
-                isMalicious: attachment.is_malicious,
-                contentType: attachment.content_type,
-                name: attachment.filename,
-            };
-        case "MessageAudio":
-            return {
-                type: "audio",
-                ID: attachment.url_shimhash,
-                filename: attachment.filename,
-                duration: attachment.playable_duration_in_ms,
-                audioType: attachment.audio_type,
-                url: attachment.playable_url,
-                isVoiceMail: attachment.is_voicemail,
-            };
-        default:
-            return {
-                type: "unknown",
-                error: "Don't know about attachment type " + attachment.__typename,
-            };
-    }
-}
-
-/**
- * Formats a share (extensible) attachment from a GraphQL response.
- * @param {Object} attachment The raw extensible attachment object.
- * @returns {Object} A formatted share attachment object.
- */
-function formatExtensibleAttachment(attachment) {
-    if (attachment.story_attachment) {
-        return {
-            type: "share",
-            ID: attachment.legacy_attachment_id,
-            url: attachment.story_attachment.url,
-            title: attachment.story_attachment.title_with_entities.text,
-            description: attachment.story_attachment.description && attachment.story_attachment.description.text,
-            source: attachment.story_attachment.source == null ? null : attachment.story_attachment.source.text,
-            image: attachment.story_attachment.media?.image?.uri,
-            width: attachment.story_attachment.media?.image?.width,
-            height: attachment.story_attachment.media?.image?.height,
-            playable: attachment.story_attachment.media?.is_playable,
-            duration: attachment.story_attachment.media?.playable_duration_in_ms,
-            playableUrl: attachment.story_attachment.media?.playable_url,
-            subattachments: attachment.story_attachment.subattachments,
-            properties: attachment.story_attachment.properties.reduce((obj, cur) => {
-                obj[cur.key] = cur.value.text;
-                return obj;
-            }, {}),
-        };
-    }
-    return { type: "unknown", error: "Don't know what to do with extensible_attachment." };
-}
-
-/**
- * Formats the response from a GraphQL message history query.
- * @param {Object} data The raw GraphQL response data.
- * @returns {Array<Object>} An array of formatted message objects.
- */
-function formatMessagesGraphQLResponse(data) {
-    const messageThread = data.o0.data.message_thread;
-    if (!messageThread) return [];
-
-    const threadID = messageThread.thread_key.thread_fbid ? messageThread.thread_key.thread_fbid : messageThread.thread_key.other_user_id;
-
-    return messageThread.messages.nodes.map(d => {
-        switch (d.__typename) {
-            case "UserMessage":
-                const mentions = {};
-                if (d.message?.ranges) {
-                    d.message.ranges.forEach(e => {
-                        mentions[e.entity.id] = d.message.text.substring(e.offset, e.offset + e.length);
-                    });
-                }
-                return {
-                    type: "message",
-                    attachments: d.sticker ? [{
-                        type: "sticker",
-                        ID: d.sticker.id,
-                        url: d.sticker.url,
-                        packID: d.sticker.pack?.id,
-                        frameCount: d.sticker.frame_count,
-                        frameRate: d.sticker.frame_rate,
-                        framesPerRow: d.sticker.frames_per_row,
-                        framesPerCol: d.sticker.frames_per_col,
-                        stickerID: d.sticker.id,
-                    }] : (d.blob_attachments || []).map(formatAttachmentsGraphQLResponse).concat(d.extensible_attachment ? [formatExtensibleAttachment(d.extensible_attachment)] : []),
-                    body: d.message?.text || "",
-                    isGroup: messageThread.thread_type === "GROUP",
-                    messageID: d.message_id,
-                    senderID: d.message_sender.id,
-                    threadID: threadID,
-                    timestamp: d.timestamp_precise,
-                    mentions: mentions,
-                    isUnread: d.unread,
-                    messageReactions: d.message_reactions?.map(r => ({ reaction: r.reaction, userID: r.user.id })) || [],
-                };
-            case "ThreadNameMessage":
-            case "ThreadImageMessage":
-            case "ParticipantLeftMessage":
-            case "ParticipantsAddedMessage":
-            case "GenericAdminTextMessage": {
-
-
-                return {
-                    type: "event",
-                    messageID: d.message_id,
-                    threadID: threadID,
-                    isGroup: messageThread.thread_type === "GROUP",
-                    senderID: d.message_sender.id,
-                    author: d.message_sender.id,
-                    timestamp: d.timestamp_precise,
-                    snippet: d.snippet,
-                    logMessageType: utils.getAdminTextMessageType(d.extensible_message_admin_text_type || d.__typename),
-                    logMessageData: d.extensible_message_admin_text || d,
-                };
-            }
-            default:
-                return { type: "unknown", error: "Unknown message type " + d.__typename, raw: d };
-        }
-    });
-}
-
-/**
- * @param {Object} defaultFuncs
- * @param {Object} api
- * @param {Object} ctx
- * @returns {function(threadID: string, amount: number, timestamp: number | null): Promise<Array<Object>>}
- */
-module.exports = function (defaultFuncs, api, ctx) {
-    /**
-     * Retrieves the message history for a specific thread.
-     * @param {string} threadID The ID of the thread to fetch history from.
-     * @param {number} amount The number of messages to retrieve.
-     * @param {number | null} timestamp The timestamp to start fetching messages before.
-     * @returns {Promise<Array<Object>>} A promise that resolves with an array of formatted message objects.
-     */
-    return async function getThreadHistory(threadID, amount, timestamp) {
-        if (!threadID || !amount) {
-            throw new Error("getThreadHistory: threadID and amount are required.");
-        }
-
-        const form = {
-            av: ctx.globalOptions.pageID,
-            queries: JSON.stringify({
-                o0: {
-                    doc_id: "1498317363570230",
-                    query_params: {
-                        id: threadID,
-                        message_limit: amount,
-                        load_messages: 1,
-                        load_read_receipts: false,
-                        before: timestamp || null,
-                    },
-                },
-            }),
-        };
-
-        try {
-            const resData = await defaultFuncs.post("https://www.facebook.com/api/graphqlbatch/", ctx.jar, form);
-            const parsedData = await utils.parseAndCheckLogin(ctx, defaultFuncs)(resData);
-
-            if (parsedData.error || (Array.isArray(parsedData) && parsedData[parsedData.length - 1].error_results !== 0)) {
-                throw parsedData;
-            }
-            
-            if (!Array.isArray(parsedData) || !parsedData[0] || !parsedData[0].o0 || !parsedData[0].o0.data) {
-                throw { error: "getThreadHistory: Malformed response from GraphQL.", res: parsedData };
-            }
-
-            return formatMessagesGraphQLResponse(parsedData[0]);
-        } catch (err) {
-            utils.error("getThreadHistory", err);
-            throw err;
-        }
-    };
-};

package/src/apis/getThreadInfo.js

@@ -1,267 +0,0 @@
-
-"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} data The raw GraphQL data for a thread.
- * @returns {Object | null} A formatted thread object or null if data is invalid.
- * @throws {Error} If Facebook returns a GraphQL error
- */
-function formatThreadGraphQLResponse(data) {
-  // Check for GraphQL errors and throw with details instead of silently returning null
-  if (data.errors) {
-    const details = data.errors.map(e => e.message || e).join(', ');
-    const error = new Error(`GraphQL error in getThreadInfo: ${details}`);
-    Object.assign(error, {
-      details: details,
-      fullErrors: data.errors
-    });
-    utils.error("formatThreadGraphQLResponse", error);
-    throw error;
-  }
-  
-  const messageThread = data.message_thread;
-  if (!messageThread) {
-    const error = new Error("No message_thread in GraphQL response - thread may not exist or access may be restricted");
-    Object.assign(error, {
-      details: "The GraphQL query returned successfully but contained no message_thread data"
-    });
-    utils.error("formatThreadGraphQLResponse", error);
-    throw error;
-  }
-
-  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(
-            function (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 ? 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
-        ? messageThread.joinable_mode.mode == 1
-        : false,
-      link: messageThread.joinable_mode
-        ? messageThread.joinable_mode.link
-        : null,
-    },
-  };
-}
-
-/**
- * @param {Object} defaultFuncs
- * @param {Object} api
- * @param {Object} ctx
- * @returns {function(threadID: string | string[]): Promise<Object>}
- */
-module.exports = function (defaultFuncs, api, ctx) {
-  /**
-   * Retrieves information about one or more threads.
-   * @param {string|string[]} threadID A single thread ID or an array of thread IDs.
-   * @returns {Promise<Object>} A promise that resolves with an object of thread info, or a single thread object if one ID was passed.
-   */
-  return async function getThreadInfo(threadID) {
-    const threadIDs = Array.isArray(threadID) ? threadID : [threadID];
-
-    // Validate thread IDs
-    if (!ctx.validator.validateIDArray(threadIDs, ctx.validator.isValidThreadID)) {
-      throw new Error("Invalid thread ID(s)");
-    }
-    
-    let form = {};
-    threadIDs.forEach((t, i) => {
-      form["o" + i] = {
-        doc_id: "3449967031715030",
-        query_params: {
-          id: t,
-          message_limit: 0,
-          load_messages: false,
-          load_read_receipts: false,
-          before: null,
-        },
-      };
-    });
-
-    form = {
-      queries: JSON.stringify(form),
-      batch_name: "MessengerGraphQLThreadFetcher",
-    };
-
-    try {
-        const resData = await defaultFuncs
-            .post("https://www.facebook.com/api/graphqlbatch/", ctx.jar, form)
-            .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
-
-        if (resData.error) {
-            throw resData;
-        }
-
-        const threadInfos = {};
-        for (let i = resData.length - 2; i >= 0; i--) {
-            const res = resData[i];
-            
-            // Check for error_results and throw instead of silently continuing
-            if (res.error_results) {
-                const error = new Error(`Facebook returned error_results for thread query: ${res.error_results} errors`);
-                Object.assign(error, {
-                    error_count: res.error_results,
-                    thread_index: i
-                });
-                utils.error("getThreadInfo", error);
-                throw error;
-            }
-            
-            const oKey = Object.keys(res)[0];
-            const responseData = res[oKey];
-            
-            // Check for errors in the response object
-            if (responseData.errors || responseData.error_results) {
-                const details = responseData.errors 
-                    ? JSON.stringify(responseData.errors) 
-                    : `error_results: ${responseData.error_results}`;
-                const error = new Error(`GraphQL error in thread response: ${details}`);
-                Object.assign(error, {
-                    details: details,
-                    thread_index: i,
-                    fullErrors: responseData.errors
-                });
-                utils.error("getThreadInfo", error);
-                throw error;
-            }
-            
-            const threadInfo = formatThreadGraphQLResponse(responseData.data);
-            if (threadInfo) {
-                threadInfos[threadInfo.threadID || threadID[threadID.length - 1 - i]] = threadInfo;
-            }
-        }
-
-        // Cache the thread infos
-        for (const id in threadInfos) {
-          ctx.cache.set(`thread_${id}`, threadInfos[id]);
-        }
-
-        return Array.isArray(threadID) ? threadInfos : Object.values(threadInfos)[0] || null;
-    } catch (err) {
-        utils.error("getThreadInfo", err);
-        throw err;
-    }
-  };
-};