shadowx-fca 2.3.0 → 2.5.0

package/src/friend.js

@@ -0,0 +1,243 @@
+"use strict";
+
+const utils = require('../utils');
+
+/**
+ * S4hiilAns4ri
+ * @description A module for managing friend-related actions like listing friends, handling requests, and getting suggestions.
+ * @param {Object} defaultFuncs The default functions provided by the API wrapper.
+ * @param {Object} api The full API object.
+ * @param {Object} ctx The context object containing the user's session state (e.g., userID, jar, fb_dtsg).
+ * @returns {Object} A `friendModule` object with methods for friend interactions.
+ */
+module.exports = function (defaultFuncs, api, ctx) {
+
+  /**
+   * A private helper function to standardize friend data from various GraphQL endpoints.
+   * @private
+   * @param {Object} data The raw data object from a GraphQL response.
+   * @param {('requests'|'suggestions'|'list')} type The type of data to format, which determines the path to the user list.
+   * @returns {Array<Object>} An array of formatted friend objects, each containing `userID`, `name`, `profilePicture`, `socialContext`, and `url`.
+   */
+  function formatFriends(data, type) {
+    const viewer = data?.data?.viewer;
+    let edges;
+    if (type === 'requests' && viewer?.friend_requests?.edges) {
+        edges = viewer.friend_requests.edges;
+    } else if (type === 'suggestions' && viewer?.people_you_may_know?.edges) {
+        edges = viewer.people_you_may_know.edges;
+    } else if (type === 'list' && data?.data?.node?.all_collections?.nodes[0]?.style_renderer?.collection?.pageItems?.edges) {
+        edges = data.data.node.all_collections.nodes[0].style_renderer.collection.pageItems.edges;
+    } else {
+        return [];
+    }
+    return edges.map(edge => {
+        const node = edge.node;
+        return {
+            userID: node.id || node.node?.id,
+            name: node.name || node.title?.text,
+            profilePicture: node.profile_picture?.uri || node.image?.uri,
+            socialContext: node.social_context?.text || node.subtitle_text?.text,
+            url: node.url
+        };
+    });
+  }
+
+  const friendModule = {
+    /**
+     * @namespace api.friend
+     * @description A collection of functions for interacting with friends.
+     * @license Ex-it
+     * @author S4hiilAns4ri
+     */
+
+    /**
+     * Fetches the list of incoming friend requests.
+     * @async
+     * @returns {Promise<Array<Object>>} A promise that resolves to an array of friend request objects.
+     * @throws {Error} If the API request fails or returns an error.
+     */
+    requests: async function() {
+      try {
+        const form = {
+          av: ctx.userID,
+          __user: ctx.userID,
+          __a: "1",
+          fb_dtsg: ctx.fb_dtsg,
+          jazoest: ctx.jazoest,
+          lsd: ctx.lsd,
+          fb_api_caller_class: "RelayModern",
+          fb_api_req_friendly_name: "FriendingCometRootContentQuery",
+          variables: JSON.stringify({ scale: 3 }),
+          doc_id: "9103543533085580"
+        };
+        const res = await defaultFuncs.post("https://www.facebook.com/api/graphql/", ctx.jar, form, {});
+        if (res.data.errors) throw new Error(JSON.stringify(res.data.errors));
+        return formatFriends(res.data, 'requests');
+      } catch (err) {
+        throw err;
+      }
+    },
+
+    /**
+     * Accepts a friend request.
+     * @async
+     * @param {string} identifier The user ID or name of the person whose friend request is to be accepted. If a name is provided, the function will search through pending requests.
+     * @returns {Promise<Object>} A promise that resolves to the API response data upon successful acceptance.
+     * @throws {Error} If the identifier is missing, the user is not found in requests, or the API call fails.
+     */
+    accept: async function(identifier) {
+      try {
+          if (!identifier) throw new Error("A name or user ID is required.");
+          let targetUserID = identifier;
+          if (isNaN(identifier)) {
+              const requests = await friendModule.requests();
+              const found = requests.find(req => req.name.toLowerCase().includes(identifier.toLowerCase()));
+              if (!found) throw new Error(`Could not find any friend request matching "${identifier}".`);
+              targetUserID = found.userID;
+          }
+          const variables = {
+              input: {
+                  friend_requester_id: targetUserID,
+                  friending_channel: "FRIENDS_HOME_MAIN",
+                  actor_id: ctx.userID,
+                  client_mutation_id: Math.floor(Math.random() * 10 + 1).toString()
+              },
+              scale: 3
+          };
+          const form = {
+              av: ctx.userID,
+              __user: ctx.userID,
+              __a: "1",
+              fb_dtsg: ctx.fb_dtsg,
+              jazoest: ctx.jazoest,
+              lsd: ctx.lsd,
+              fb_api_caller_class: "RelayModern",
+              fb_api_req_friendly_name: "FriendingCometFriendRequestConfirmMutation",
+              variables: JSON.stringify(variables),
+              doc_id: "24630768433181357"
+          };
+          const res = await defaultFuncs.post("https://www.facebook.com/api/graphql/", ctx.jar, form, {});
+          if (res.data.errors) throw new Error(JSON.stringify(res.data.errors));
+          return res.data.data;
+      } catch (err) {
+          if (err.message?.includes("1431004")) {
+              throw new Error("I cannot accept this friend request right now. There might be a problem with the account or you need to wait.");
+          }
+          throw err;
+      }
+    },
+
+    /**
+     * Fetches the friend list for a given user ID.
+     * @async
+     * @param {string} [userID=ctx.userID] The ID of the user whose friend list to fetch. Defaults to the logged-in user.
+     * @returns {Promise<Array<Object>>} A promise that resolves to an array of formatted friend objects.
+     * @throws {Error} If the API request fails.
+     */
+    list: async function(userID = ctx.userID) {
+        try {
+            const sectionToken = Buffer.from(`app_section:${userID}:2356318349`).toString('base64');
+            const variables = {
+                collectionToken: null,
+                scale: 2,
+                sectionToken: sectionToken,
+                useDefaultActor: false,
+                userID: userID
+            };
+            const form = {
+                av: ctx.userID,
+                __user: ctx.userID,
+                __a: "1",
+                fb_dtsg: ctx.fb_dtsg,
+                jazoest: ctx.jazoest,
+                lsd: ctx.lsd,
+                fb_api_caller_class: "RelayModern",
+                fb_api_req_friendly_name: "ProfileCometTopAppSectionQuery",
+                variables: JSON.stringify(variables),
+                doc_id: "24492266383698794"
+            };
+            const res = await defaultFuncs.post("https://www.facebook.com/api/graphql/", ctx.jar, form, {});
+            if (res.data.errors) throw new Error(JSON.stringify(res.data.errors));
+            return formatFriends(res.data, 'list');
+        } catch(err) {
+            throw err;
+        }
+    },
+
+    /**
+     * @namespace api.friend.suggest
+     * @description Functions for managing friend suggestions.
+     */
+    suggest: {
+        /**
+         * Fetches a list of suggested friends (People You May Know).
+         * @async
+         * @param {number} [limit=30] The maximum number of suggestions to fetch.
+         * @returns {Promise<Array<Object>>} A promise that resolves to an array of suggested friend objects.
+         * @throws {Error} If the API request fails.
+         */
+        list: async function(limit = 30) {
+          try {
+              const form = {
+                  av: ctx.userID,
+                  __user: ctx.userID,
+                  __a: "1",
+                  fb_dtsg: ctx.fb_dtsg,
+                  jazoest: ctx.jazoest,
+                  lsd: ctx.lsd,
+                  fb_api_caller_class: "RelayModern",
+                  fb_api_req_friendly_name: "FriendingCometPYMKPanelPaginationQuery",
+                  variables: JSON.stringify({ count: limit, cursor: null, scale: 3 }),
+                  doc_id: "9917809191634193"
+              };
+              const res = await defaultFuncs.post("https://www.facebook.com/api/graphql/", ctx.jar, form, {});
+              if (res.data.errors) throw new Error(JSON.stringify(res.data.errors));
+              return formatFriends(res.data, 'suggestions');
+          } catch(err) {
+              throw err;
+          }
+        },
+        /**
+         * Sends a friend request to a user.
+         * @async
+         * @param {string} userID The ID of the user to send the friend request to.
+         * @returns {Promise<Object>} A promise that resolves to the API response data on success.
+         * @throws {Error} If the userID is missing or the API request fails.
+         */
+        request: async function(userID) {
+            try {
+                if (!userID) throw new Error("userID is required.");
+                const variables = {
+                    input: {
+                        friend_requestee_ids: [userID],
+                        friending_channel: "FRIENDS_HOME_MAIN",
+                        actor_id: ctx.userID,
+                        client_mutation_id: Math.floor(Math.random() * 10 + 1).toString()
+                    },
+                    scale: 3
+                };
+                const form = {
+                    av: ctx.userID,
+                    __user: ctx.userID,
+                    __a: "1",
+                    fb_dtsg: ctx.fb_dtsg,
+                    jazoest: ctx.jazoest,
+                    lsd: ctx.lsd,
+                    fb_api_caller_class: "RelayModern",
+                    fb_api_req_friendly_name: "FriendingCometFriendRequestSendMutation",
+                    variables: JSON.stringify(variables),
+                    doc_id: "23982103144788355"
+                };
+                const res = await defaultFuncs.post("https://www.facebook.com/api/graphql/", ctx.jar, form, {});
+                if (res.data.errors) throw new Error(JSON.stringify(res.data.errors));
+                return res.data.data;
+            } catch(err) {
+                throw err;
+            }
+        }
+    }
+  };
+  
+  return friendModule;
+};

package/src/gcmember.js

@@ -0,0 +1,122 @@
+"use strict";
+
+const utils = require('../utils');
+
+module.exports = function (defaultFuncs, api, ctx) {
+  /**
+   * Author: S4hiilAns4ri (github.com/S4hiilAns4ri) 
+   * Mqtt
+   * Adds or removes members from a group chat with pre-checking.
+   *
+   * @param {"add" | "remove"} action The action to perform.
+   * @param {string|string[]} userIDs The user ID or array of user IDs.
+   * @param {string} threadID The ID of the group chat.
+   * @param {Function} [callback] Optional callback function.
+   * @returns {Promise<object>} A promise that resolves with information about the action.
+   */
+  return async function gcmember(action, userIDs, threadID, callback) {
+    let _callback;
+    if (typeof threadID === 'function') {
+        _callback = threadID;
+        threadID = null;
+    } else if (typeof callback === 'function') {
+        _callback = callback;
+    }
+    
+    let resolvePromise, rejectPromise;
+    const returnPromise = new Promise((resolve, reject) => {
+        resolvePromise = resolve;
+        rejectPromise = reject;
+    });
+
+    if (typeof _callback != "function") {
+      _callback = (err, data) => {
+        // Note: We will now rarely use the 'err' parameter for validation errors
+        if (err) return rejectPromise(err);
+        resolvePromise(data);
+      }
+    }
+
+    try {
+        const validActions = ["add", "remove"];
+        action = action ? action.toLowerCase() : "";
+
+        // --- ERROR CHECKS NOW RETURN AN OBJECT INSTEAD OF THROWING ---
+        if (!validActions.includes(action)) {
+            return _callback(null, { type: "error_gc", error: `Invalid action. Must be one of: ${validActions.join(", ")}` });
+        }
+        if (!userIDs || userIDs.length === 0) {
+            return _callback(null, { type: "error_gc", error: "userIDs is required." });
+        }
+        if (!threadID) {
+            return _callback(null, { type: "error_gc", error: "threadID is required." });
+        }
+        if (!ctx.mqttClient) {
+            return _callback(null, { type: "error_gc", error: "Not connected to MQTT" });
+        }
+
+        const threadInfo = await api.getThreadInfo(threadID);
+        if (!threadInfo) {
+            return _callback(null, { type: "error_gc", error: "Could not retrieve thread information." });
+        }
+        if (threadInfo.isGroup === false) {
+            return _callback(null, { type: "error_gc", error: "This feature is only for group chats, not private messages." });
+        }
+        
+        const currentMembers = threadInfo.participantIDs;
+        const usersToModify = Array.isArray(userIDs) ? userIDs : [userIDs];
+        let queryPayload, query;
+        let finalUsers = usersToModify;
+        
+        ctx.wsReqNumber = (ctx.wsReqNumber || 0) + 1;
+        ctx.wsTaskNumber = (ctx.wsTaskNumber || 0) + 1;
+
+        if (action === 'add') {
+            const usersToAdd = usersToModify.filter(id => !currentMembers.includes(id));
+            if (usersToAdd.length === 0) {
+                return _callback(null, { type: "error_gc", error: "All specified users are already in the group." });
+            }
+            finalUsers = usersToAdd;
+            queryPayload = { thread_key: parseInt(threadID), contact_ids: finalUsers.map(id => parseInt(id)), sync_group: 1 };
+            query = { label: "23", payload: JSON.stringify(queryPayload), queue_name: threadID, task_id: ctx.wsTaskNumber };
+        
+        } else { // action is 'remove'
+            const userToRemove = usersToModify[0];
+            if (!currentMembers.includes(userToRemove)) {
+                return _callback(null, { type: "error_gc", error: `User with ID ${userToRemove} is not in this group chat.` });
+            }
+            finalUsers = [userToRemove];
+            queryPayload = { thread_id: threadID, contact_id: userToRemove, sync_group: 1 };
+            query = { label: "140", payload: JSON.stringify(queryPayload), queue_name: "remove_participant_v2", task_id: ctx.wsTaskNumber };
+        }
+
+        const context = {
+          app_id: ctx.appID,
+          payload: { epoch_id: parseInt(utils.generateOfflineThreadingID()), tasks: [query], version_id: "24631415369801570" },
+          request_id: ctx.wsReqNumber,
+          type: 3
+        };
+        context.payload = JSON.stringify(context.payload);
+
+        ctx.mqttClient.publish('/ls_req', JSON.stringify(context), { qos: 1, retain: false }, (err) => {
+          if (err) return _callback(err); // For network errors, we still reject
+          
+          const gcmemberInfo = {
+            type: "gc_member_update",
+            threadID: threadID,
+            userIDs: finalUsers,
+            action: action,
+            senderID: ctx.userID,
+            BotID: ctx.userID,
+            timestamp: Date.now(),
+          };
+          return _callback(null, gcmemberInfo);
+        });
+    } catch (err) {
+      
+        return _callback(null, { type: "error_gc", error: err.message || "An unknown error occurred." });
+    }
+
+    return returnPromise;
+  };
+};

package/src/getUserInfo.js

@@ -1,66 +1,245 @@
 "use strict";
+// sahilchat-fca — Author: S4hiilAns4ri (github.com/S4hiilAns4ri)
+const utils = require('../utils');
+const _ = require('lodash');
+const deepdash = require('deepdash');
+deepdash(_);
 
-var utils = require("../utils");
-var log = require("npmlog");
+/**
+ * @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;
+}
 
-function formatData(data) {
-  var retObj = {};
+/**
+ * @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;
+}
 
-  for (var prop in data) {
-    // eslint-disable-next-line no-prototype-builtins
-    if (data.hasOwnProperty(prop)) {
-      var innerObj = data[prop];
-      retObj[prop] = {
-        name: innerObj.name,
-        firstName: innerObj.firstName,
-        vanity: innerObj.vanity,
-        thumbSrc: innerObj.thumbSrc,
-        profileUrl: innerObj.uri,
-        gender: innerObj.gender,
-        type: innerObj.type,
-        isFriend: innerObj.is_friend,
-        isBirthday: !!innerObj.is_birthday
-      };
+/**
+ * @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;
+}
 
-  return retObj;
+/**
+ * @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;
+  }
 }
 
-module.exports = function (defaultFuncs, api, ctx) {
-  return function getUserInfo(id, callback) {
-    var resolveFunc = function () { };
-    var rejectFunc = function () { };
-    var returnPromise = new Promise(function (resolve, reject) {
+/**
+ * @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;
+  }
+}
+
+module.exports = (defaultFuncs, api, ctx) => {
+  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 = () => {};
+    let rejectFunc = () => {};
+    const returnPromise = new Promise((resolve, reject) => {
       resolveFunc = resolve;
       rejectFunc = reject;
     });
 
+    if (typeof usePayload === 'function') {
+      callback = usePayload;
+      usePayload = true;
+    }
+    if (usePayload === undefined) usePayload = true;
     if (!callback) {
-      callback = function (err, userInfo) {
+      callback = (err, data) => {
         if (err) return rejectFunc(err);
-        resolveFunc(userInfo);
+        resolveFunc(data);
       };
     }
 
-    if (utils.getType(id) !== "Array") id = [id];
+    const originalIdIsArray = Array.isArray(id);
+    const ids = originalIdIsArray ? id : [id];
 
-    var form = {};
-    id.map(function (v, i) {
-      form["ids[" + i + "]"] = v;
-    });
-    defaultFuncs
-      .post("https://www.facebook.com/chat/user_info/", ctx.jar, form)
-      .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
-      .then(function (resData) {
-        if (resData.error) throw resData;
-        return callback(null, formatData(resData.payload.profiles));
-      })
-      .catch(function (err) {
-        log.error("getUserInfo", err);
-        return callback(err);
-      });
+    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;
   };
 };