@dongdev/fca-unofficial 3.0.29 → 3.0.31

package/src/api/threads/getThreadInfo.js

@@ -1,438 +1,296 @@
-const fs = require("fs");
-const path = require("path");
-const logger = require("../../../func/logger");
-const { parseAndCheckLogin } = require("../../utils/client");
-const { formatID, getType } = require("../../utils/format");
+'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: String(reminder?.lightweight_event_type || "").toLowerCase(),
-    locationName: reminder?.location_name,
-    locationCoordinates: reminder?.location_coordinates,
-    locationPage: reminder?.location_page,
-    eventStatus: String(reminder?.lightweight_event_status || "").toLowerCase(),
-    note: reminder?.note,
-    repeatMode: String(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: Array.isArray(reminder?.event_reminder_members?.edges) ? reminder.event_reminder_members.edges.map(m => ({
-      memberID: m?.node?.id,
-      state: String(m?.guest_list_state || "").toLowerCase(),
-    })) : [],
+    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) return null;
-  if (data?.errors) return null;
-  const t = data.message_thread;
-  if (!t) return null;
-  const threadID = t?.thread_key?.thread_fbid || t?.thread_key?.other_user_id || null;
-  const lastM = t?.last_message;
-  const lastNode = Array.isArray(lastM?.nodes) && lastM.nodes[0] ? lastM.nodes[0] : null;
-  const snippetID = lastNode?.message_sender?.messaging_actor?.id || null;
-  const snippetText = lastNode?.snippet || null;
-  const lastRNode = Array.isArray(t?.last_read_receipt?.nodes) && t.last_read_receipt.nodes[0] ? t.last_read_receipt.nodes[0] : null;
-  const lastReadTimestamp = lastRNode?.timestamp_precise || null;
-  const participants = Array.isArray(t?.all_participants?.edges) ? t.all_participants.edges : [];
-  const approvals = Array.isArray(t?.group_approval_queue?.nodes) ? t.group_approval_queue.nodes : [];
-  const customInfo = t?.customization_info || {};
-  const bubble = customInfo?.outgoing_bubble_color;
-  const participantCustoms = Array.isArray(customInfo?.participant_customizations) ? customInfo.participant_customizations : [];
-  const nicknames = participantCustoms.reduce((res, val) => {
-    if (val?.nickname && val?.participant_id) res[val.participant_id] = val.nickname;
-    return res;
-  }, {});
+  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: t?.name || null,
-    participantIDs: participants.map(d => d?.node?.messaging_actor?.id).filter(Boolean),
-    userInfo: participants.map(d => ({
-      id: d?.node?.messaging_actor?.id || null,
-      name: d?.node?.messaging_actor?.name || null,
-      firstName: d?.node?.messaging_actor?.short_name || null,
-      vanity: d?.node?.messaging_actor?.username || null,
-      url: d?.node?.messaging_actor?.url || null,
-      thumbSrc: d?.node?.messaging_actor?.big_image_src?.uri || null,
-      profileUrl: d?.node?.messaging_actor?.big_image_src?.uri || null,
-      gender: d?.node?.messaging_actor?.gender || null,
-      type: d?.node?.messaging_actor?.__typename || null,
-      isFriend: !!d?.node?.messaging_actor?.is_viewer_friend,
-      isBirthday: !!d?.node?.messaging_actor?.is_birthday,
-    })),
-    unreadCount: t?.unread_count ?? 0,
-    messageCount: t?.messages_count ?? 0,
-    timestamp: t?.updated_time_precise || null,
-    muteUntil: t?.mute_until || null,
-    isGroup: t?.thread_type === "GROUP",
-    isSubscribed: !!t?.is_viewer_subscribed,
-    isArchived: !!t?.has_viewer_archived,
-    folder: t?.folder || null,
-    cannotReplyReason: t?.cannot_reply_reason || null,
-    eventReminders: Array.isArray(t?.event_reminders?.nodes) ? t.event_reminders.nodes.map(formatEventReminders) : [],
-    emoji: customInfo?.emoji || null,
-    color: bubble ? String(bubble).slice(2) : null,
-    threadTheme: t?.thread_theme || null,
-    nicknames,
-    adminIDs: Array.isArray(t?.thread_admins) ? t.thread_admins : [],
-    approvalMode: !!t?.approval_mode,
-    approvalQueue: approvals.map(a => ({
-      inviterID: a?.inviter?.id || null,
-      requesterID: a?.requester?.id || null,
-      timestamp: a?.request_timestamp || null,
-      request_source: a?.request_source || null,
+    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,
     })),
-    reactionsMuteMode: String(t?.reactions_mute_mode || "").toLowerCase(),
-    mentionsMuteMode: String(t?.mentions_mute_mode || "").toLowerCase(),
-    isPinProtected: !!t?.is_pin_protected,
-    relatedPageThread: t?.related_page_thread || null,
-    name: t?.name || null,
+    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: t?.updated_time_precise || null,
-    imageSrc: t?.image?.uri || null,
-    isCanonicalUser: !!t?.is_canonical_neo_user,
-    isCanonical: t?.thread_type !== "GROUP",
+    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: t?.cannot_reply_reason == null,
-    lastMessageTimestamp: t?.last_message ? t.last_message.timestamp_precise : null,
+    canReply: messageThread.cannot_reply_reason == null,
+    lastMessageTimestamp:
+      messageThread.last_message?.timestamp_precise || null,
     lastMessageType: "message",
     lastReadTimestamp,
-    threadType: t?.thread_type === "GROUP" ? 2 : 1,
+    threadType: messageThread.thread_type === "GROUP" ? 2 : 1,
     inviteLink: {
-      enable: t?.joinable_mode ? t.joinable_mode.mode == 1 : false,
-      link: t?.joinable_mode ? t.joinable_mode.link : null,
+      enable: messageThread.joinable_mode?.mode === 1,
+      link: messageThread.joinable_mode?.link || null,
     },
   };
 }
 
-const queue = [];
-let isProcessingQueue = false;
-const processingThreads = new Set();
-const queuedThreads = new Set();
-const cooldown = new Map();
-const inflight = new Map();
-let loopStarted = false;
-
 module.exports = function (defaultFuncs, api, ctx) {
-  const getMultiInfo = async function (threadIDs) {
-    const buildQueries = () => {
-      const form = {};
-      threadIDs.forEach((x, y) => {
-        form["o" + y] = {
+  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: x,
+            id: t,
             message_limit: 0,
             load_messages: false,
             load_read_receipts: false,
-            before: null,
-          },
+            before: null
+          }
         };
       });
-      return {
-        queries: JSON.stringify(form),
-        batch_name: "MessengerGraphQLThreadFetcher",
-      };
-    };
-    const maxAttempts = 3;
-    let lastErr = null;
-    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-      try {
-        const Submit = buildQueries();
-        const resData = await defaultFuncs.post("https://www.facebook.com/api/graphqlbatch/", ctx.jar, Submit).then(parseAndCheckLogin(ctx, defaultFuncs));
-        if (!Array.isArray(resData) || resData.length === 0) throw new Error("EmptyGraphBatch");
-        const tail = resData[resData.length - 1];
-        if (tail?.error_results && tail.error_results !== 0) throw new Error("GraphErrorResults");
-        const body = resData.slice(0, -1).sort((a, b) => Object.keys(a)[0].localeCompare(Object.keys(b)[0]));
-        const out = [];
-        body.forEach((x, y) => out.push(formatThreadGraphQLResponse(x["o" + y]?.data)));
-        const valid = out.some(d => !!d && !!d.threadID);
-        if (!valid) throw new Error("GraphNoData");
-        return { Success: true, Data: out };
-      } catch (e) {
-        lastErr = e;
-        if (attempt < maxAttempts) await new Promise(r => setTimeout(r, 300 * attempt));
-      }
-    }
-    return { Success: false, Data: null, Error: lastErr ? String(lastErr.message || lastErr) : "Unknown" };
-  };
-
-  const dbFiles = fs.readdirSync(path.join(__dirname, "../../database")).filter(f => path.extname(f) === ".js").reduce((acc, file) => {
-    acc[path.basename(file, ".js")] = require(path.join(__dirname, "../../database", file))(api);
-    return acc;
-  }, {});
-  const { threadData, userData } = dbFiles;
-  const { create, get, update, getAll } = threadData;
-  const { update: updateUser } = userData;
 
-  function isValidThread(d) {
-    return d && d.threadID;
-  }
-
-  async function upsertUsersFromThreadInfo(info) {
-    try {
-      if (!info || !Array.isArray(info.userInfo) || info.userInfo.length === 0) return;
-      const tasks = info.userInfo.filter(u => u && u.id).map(u => {
-        const data = {
-          id: u.id,
-          name: u.name || null,
-          firstName: u.firstName || null,
-          vanity: u.vanity || null,
-          url: u.url || null,
-          thumbSrc: u.thumbSrc || null,
-          profileUrl: u.profileUrl || null,
-          gender: u.gender || null,
-          type: u.type || null,
-          isFriend: !!u.isFriend,
-          isBirthday: !!u.isBirthday,
-        };
-        return updateUser(u.id, { data });
-      });
-      await Promise.allSettled(tasks);
-    } catch (e) {
-      logger(`upsertUsers error: ${e?.message || e}`, "warn");
-    }
-  }
+      const form = {
+        queries: JSON.stringify(queries),
+        batch_name: "MessengerGraphQLThreadFetcher"
+      };
 
-  async function createOrUpdateThread(id, data) {
-    const existing = await get(id);
-    if (existing) {
-      await update(id, { data });
-      return "update";
-    } else {
-      await create(id, { data });
-      return "create";
-    }
-  }
+      const resData = await defaultFuncs
+        .post(
+          "https://www.facebook.com/api/graphqlbatch/",
+          ctx.jar,
+          form
+        )
+        .then(parseAndCheckLogin(ctx, defaultFuncs));
 
-  async function fetchThreadInfo(tID, isNew) {
-    try {
-      const response = await getMultiInfo([tID]);
-      if (!response.Success || !response.Data || !isValidThread(response.Data[0])) {
-        cooldown.set(tID, Date.now() + 5 * 60 * 1000);
-        logger(`GraphQL empty for ${tID}, cooldown applied`, "warn");
-        return;
+      if (resData.error) {
+        throw resData;
       }
-      const threadInfo = response.Data[0];
-      await upsertUsersFromThreadInfo(threadInfo);
-      const op = await createOrUpdateThread(tID, threadInfo);
-      logger(`${op === "create" ? "Success create data thread" : "Success update data thread"}: ${tID}`, "info");
-    } catch (err) {
-      cooldown.set(tID, Date.now() + 5 * 60 * 1000);
-      logger(`fetchThreadInfo error ${tID}: ${err?.message || err}`, "error");
-    } finally {
-      queuedThreads.delete(tID);
-    }
-  }
 
-  async function checkAndUpdateThreads() {
-    try {
-      const allThreads = await getAll("threadID");
-      const existingThreadIDs = new Set(allThreads.map(t => t.threadID));
-      const now = Date.now();
-      for (const t of existingThreadIDs) {
-        const cd = cooldown.get(t);
-        if (cd && now < cd) continue;
-        const result = await get(t);
-        if (!result) continue;
-        const lastUpdated = new Date(result.updatedAt).getTime();
-        if ((now - lastUpdated) / (1000 * 60) > 10 && !queuedThreads.has(t)) {
-          queuedThreads.add(t);
-          queue.push(() => fetchThreadInfo(t, false));
+      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));
         }
       }
-    } catch (err) {
-      logger(`checkAndUpdateThreads error: ${err?.message || err}`, "error");
-    }
-  }
+      return out;
+    };
 
-  async function processQueue() {
-    if (isProcessingQueue) return;
-    isProcessingQueue = true;
-    while (queue.length > 0) {
-      const task = queue.shift();
+    (async () => {
       try {
-        await task();
-      } catch (err) {
-        logger(`Queue processing error: ${err?.message || err}`, "error");
-      }
-    }
-    isProcessingQueue = false;
-  }
+        const { fresh, stale } = await loadFromDb(threadIDs);
+        let fetched = {};
 
-  if (!loopStarted) {
-    loopStarted = true;
-    setInterval(() => {
-      checkAndUpdateThreads();
-      processQueue();
-    }, 10000);
-  }
+        if (stale.length) {
+          fetched = await fetchFromGraphQL(stale);
 
-  return async function getThreadInfoGraphQL(threadID, callback) {
-    let resolveFunc = function () { };
-    let rejectFunc = function () { };
-    const 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);
-      };
-    }
-    if (getType(threadID) !== "Array") threadID = [threadID];
-    const tid = String(threadID[0]);
-    try {
-      const cd = cooldown.get(tid);
-      if (cd && Date.now() < cd) {
-        const cachedCd = await get(tid);
-        if (cachedCd?.data && isValidThread(cachedCd.data)) {
-          await upsertUsersFromThreadInfo(cachedCd.data);
-          callback(null, cachedCd.data);
-          return returnPromise;
+          // 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 stub = {
-          threadID: tid,
-          threadName: null,
-          participantIDs: [],
-          userInfo: [],
-          unreadCount: 0,
-          messageCount: 0,
-          timestamp: null,
-          muteUntil: null,
-          isGroup: false,
-          isSubscribed: false,
-          isArchived: false,
-          folder: null,
-          cannotReplyReason: null,
-          eventReminders: [],
-          emoji: null,
-          color: null,
-          threadTheme: null,
-          nicknames: {},
-          adminIDs: [],
-          approvalMode: false,
-          approvalQueue: [],
-          reactionsMuteMode: "",
-          mentionsMuteMode: "",
-          isPinProtected: false,
-          relatedPageThread: null,
-          name: null,
-          snippet: null,
-          snippetSender: null,
-          snippetAttachments: [],
-          serverTimestamp: null,
-          imageSrc: null,
-          isCanonicalUser: false,
-          isCanonical: true,
-          recipientsLoadable: false,
-          hasEmailParticipant: false,
-          readOnly: false,
-          canReply: false,
-          lastMessageTimestamp: null,
-          lastMessageType: "message",
-          lastReadTimestamp: null,
-          threadType: 1,
-          inviteLink: { enable: false, link: null },
-          __status: "cooldown",
-        };
-        await createOrUpdateThread(tid, stub);
-        callback(null, stub);
-        return returnPromise;
-      }
 
-      const cached = await get(tid);
-      if (cached?.data && isValidThread(cached.data)) {
-        await upsertUsersFromThreadInfo(cached.data);
-        callback(null, cached.data);
-        return returnPromise;
-      }
+        const resultMap = {};
+        for (const id of threadIDs) {
+          resultMap[id] = fresh[id] || fetched[id] || null;
+        }
 
-      if (inflight.has(tid)) {
-        inflight.get(tid).then(data => callback(null, data)).catch(err => callback(err));
-        return returnPromise;
-      }
+        const result = Array.isArray(threadID)
+          ? resultMap
+          : resultMap[threadIDs[0]] || null;
 
-      const p = (async () => {
-        processingThreads.add(tid);
-        const response = await getMultiInfo([tid]);
-        if (response.Success && response.Data && isValidThread(response.Data[0])) {
-          const data = response.Data[0];
-          await upsertUsersFromThreadInfo(data);
-          await createOrUpdateThread(tid, data);
-          return data;
-        } else {
-          const stub = {
-            threadID: tid,
-            threadName: null,
-            participantIDs: [],
-            userInfo: [],
-            unreadCount: 0,
-            messageCount: 0,
-            timestamp: null,
-            muteUntil: null,
-            isGroup: false,
-            isSubscribed: false,
-            isArchived: false,
-            folder: null,
-            cannotReplyReason: null,
-            eventReminders: [],
-            emoji: null,
-            color: null,
-            threadTheme: null,
-            nicknames: {},
-            adminIDs: [],
-            approvalMode: false,
-            approvalQueue: [],
-            reactionsMuteMode: "",
-            mentionsMuteMode: "",
-            isPinProtected: false,
-            relatedPageThread: null,
-            name: null,
-            snippet: null,
-            snippetSender: null,
-            snippetAttachments: [],
-            serverTimestamp: null,
-            imageSrc: null,
-            isCanonicalUser: false,
-            isCanonical: true,
-            recipientsLoadable: false,
-            hasEmailParticipant: false,
-            readOnly: false,
-            canReply: false,
-            lastMessageTimestamp: null,
-            lastMessageType: "message",
-            lastReadTimestamp: null,
-            threadType: 1,
-            inviteLink: { enable: false, link: null },
-            __status: "unavailable",
-          };
-          cooldown.set(tid, Date.now() + 5 * 60 * 1000);
-          await createOrUpdateThread(tid, stub);
-          return stub;
-        }
-      })()
-        .finally(() => {
-          processingThreads.delete(tid);
-          inflight.delete(tid);
-        });
+        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);
+      }
+    })();
 
-      inflight.set(tid, p);
-      p.then(data => callback(null, data)).catch(err => callback(err));
-    } catch (err) {
-      callback(err);
-    }
     return returnPromise;
   };
 };