surya-sahil-fca 1.0.0

package/src/api/messaging/stickers.js

@@ -0,0 +1,257 @@
+"use strict";
+
+/**
+ * Sticker API Module
+ * Provides access to Facebook's GraphQL-based sticker endpoints.
+ * Made by @ChoruOfficial
+ */
+
+const utils = require('../../../utils');
+/**
+ * Format the sticker pack list (store or tray)
+ * @param {object} data - Raw GraphQL response
+ * @returns {{ packs: Array<{id: string, name: string, thumbnail: string}>, page_info: object, store_id?: string }}
+ */
+function formatPackList(data) {
+    const trayPacks = data?.data?.picker_plugins?.sticker_picker?.sticker_store?.tray_packs?.edges;
+    const storePacks = data?.data?.viewer?.sticker_store?.available_packs?.edges;
+    
+    const packData = storePacks || trayPacks;
+    if (!packData || !packData.edges) return { packs: [], page_info: { has_next_page: false } };
+
+    const formattedPacks = packData.edges.map(edge => edge.node ? ({
+        id: edge.node.id,
+        name: edge.node.name,
+        thumbnail: edge.node.thumbnail_image?.uri
+    }) : null).filter(Boolean);
+
+    return {
+        packs: formattedPacks,
+        page_info: packData.page_info,
+        store_id: data?.data?.viewer?.sticker_store?.id
+    };
+}
+
+/**
+ * Format search result stickers
+ * @param {object} data - Raw GraphQL response
+ * @returns {Array<Object>}
+ */
+function formatStickerSearchResults(data) {
+    const stickers = data?.data?.sticker_search?.sticker_results?.edges;
+    if (!stickers) return [];
+    return stickers.map(edge => edge.node ? ({
+        type: "sticker",
+        ID: edge.node.id,
+        url: edge.node.image?.uri,
+        animatedUrl: edge.node.animated_image?.uri,
+        packID: edge.node.pack?.id,
+        label: edge.node.label || edge.node.accessibility_label,
+        stickerID: edge.node.id
+    }) : null).filter(Boolean);
+}
+
+/**
+ * Format sticker pack content
+ * @param {object} data - Raw GraphQL response
+ * @returns {Array<Object>}
+ */
+function formatStickerPackResults(data) {
+    const stickers = data?.data?.sticker_pack?.stickers?.edges;
+    if (!stickers) return [];
+    return stickers.map(edge => edge.node ? ({
+        type: "sticker",
+        ID: edge.node.id,
+        url: edge.node.image?.uri,
+        animatedUrl: edge.node.animated_image?.uri,
+        packID: edge.node.pack?.id,
+        label: edge.node.label || edge.node.accessibility_label,
+        stickerID: edge.node.id
+    }) : null).filter(Boolean);
+}
+
+/**
+ * Format AI-generated stickers
+ * @param {object} data - Raw GraphQL response
+ * @returns {Array<Object>}
+ */
+function formatAiStickers(data) {
+    const stickers = data?.data?.xfb_trending_generated_ai_stickers?.nodes;
+    if (!stickers) return [];
+    return stickers.map(node => ({
+        type: "sticker",
+        ID: node.id,
+        url: node.url,
+        label: node.label,
+        stickerID: node.id
+    })).filter(Boolean);
+}
+
+module.exports = function(defaultFuncs, api, ctx) {
+    /**
+     * Make a GraphQL request and handle login and error checking
+     * @param {object} form - Form data for the request
+     * @returns {Promise<object>}
+     */
+    async function makeRequest(form) {
+        const resData = await defaultFuncs.post("https://www.facebook.com/api/graphql/", ctx.jar, form)
+            .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+        if (!resData) throw new Error("GraphQL request returned no data.");
+        if (resData.errors) {
+            utils.error("StickerAPI GraphQL Error", resData.errors[0].message);
+            throw resData.errors[0];
+        }
+        return resData;
+    }
+
+    return {
+        /**
+         * Search for stickers by keyword
+         * @param {string} query - Search term
+         * @returns {Promise<Array<Object>>}
+         */
+        search: async function(query) {
+            const form = {
+                fb_api_caller_class: 'RelayModern',
+                fb_api_req_friendly_name: 'CometStickerPickerSearchResultsRootQuery',
+                variables: JSON.stringify({
+                    scale: 3,
+                    search_query: query,
+                    sticker_height: 128,
+                    sticker_width: 128,
+                    stickerInterface: "MESSAGES"
+                }),
+                doc_id: '24004987559125954'
+            };
+            const res = await makeRequest(form);
+            return formatStickerSearchResults(res);
+        },
+
+        /**
+         * List user's sticker packs
+         * @returns {Promise<Array<Object>>}
+         */
+        listPacks: async function() {
+            const form = {
+                fb_api_caller_class: 'RelayModern',
+                fb_api_req_friendly_name: 'CometStickerPickerCardQuery',
+                variables: JSON.stringify({ scale: 3, stickerInterface: "MESSAGES" }),
+                doc_id: '10095807770482952'
+            };
+            const res = await makeRequest(form);
+            return formatPackList(res).packs;
+        },
+
+        /**
+         * Get all available sticker packs from the store (with pagination)
+         * @returns {Promise<Array<Object>>}
+         */
+        getStorePacks: async function() {
+            utils.log("Starting to fetch all sticker packs from store...");
+            let allPacks = [];
+
+            const initialForm = {
+                fb_api_caller_class: 'RelayModern',
+                fb_api_req_friendly_name: 'CometStickersStoreDialogQuery',
+                variables: JSON.stringify({}),
+                doc_id: '29237828849196584'
+            };
+            let res = await makeRequest(initialForm);
+            let { packs, page_info, store_id } = formatPackList(res);
+            allPacks.push(...packs);
+            utils.log(`Fetched first page with ${packs.length} packs.`);
+
+            while (page_info && page_info.has_next_page) {
+                utils.log("Fetching next page with cursor:", page_info.end_cursor);
+
+                const paginatedForm = {
+                    fb_api_caller_class: 'RelayModern',
+                    fb_api_req_friendly_name: 'CometStickersStorePackListPaginationQuery',
+                    variables: JSON.stringify({
+                        count: 20,
+                        cursor: page_info.end_cursor,
+                        id: store_id
+                    }),
+                    doc_id: '9898634630218439'
+                };
+                res = await makeRequest(paginatedForm);
+                let paginatedResult = formatPackList(res);
+                allPacks.push(...paginatedResult.packs);
+                page_info = paginatedResult.page_info;
+                utils.log(`Fetched ${paginatedResult.packs.length} more packs. Total now: ${allPacks.length}`);
+            }
+
+            utils.log(`Finished fetching. Total unique packs found: ${allPacks.length}`);
+            return allPacks;
+        },
+
+        /**
+         * Merge user's and store sticker packs into one list
+         * @returns {Promise<Array<Object>>}
+         */
+        listAllPacks: async function() {
+            const [myPacks, storePacks] = await Promise.all([
+                this.listPacks(),
+                this.getStorePacks()
+            ]);
+            const allPacksMap = new Map();
+            myPacks.forEach(pack => allPacksMap.set(pack.id, pack));
+            storePacks.forEach(pack => allPacksMap.set(pack.id, pack));
+            return Array.from(allPacksMap.values());
+        },
+
+        /**
+         * Add a sticker pack by ID
+         * @param {string} packID - The ID of the sticker pack
+         * @returns {Promise<Object>}
+         */
+        addPack: async function(packID) {
+            const form = {
+                fb_api_caller_class: 'RelayModern',
+                fb_api_req_friendly_name: 'CometStickersStorePackMutationAddMutation',
+                variables: JSON.stringify({
+                    input: {
+                        pack_id: packID,
+                        actor_id: ctx.userID,
+                        client_mutation_id: Math.round(Math.random() * 10).toString()
+                    }
+                }),
+                doc_id: '9877489362345320'
+            };
+            const res = await makeRequest(form);
+            return res.data.sticker_pack_add.sticker_pack;
+        },
+
+        /**
+         * Get all stickers in a pack
+         * @param {string} packID - Sticker pack ID
+         * @returns {Promise<Array<Object>>}
+         */
+        getStickersInPack: async function(packID) {
+            const form = {
+                fb_api_caller_class: 'RelayModern',
+                fb_api_req_friendly_name: 'CometStickerPickerPackContentRootQuery',
+                variables: JSON.stringify({ packID, stickerWidth: 128, stickerHeight: 128, scale: 3 }),
+                doc_id: '23982341384707469'
+            };
+            const res = await makeRequest(form);
+            return formatStickerPackResults(res);
+        },
+
+        /**
+         * Get trending AI-generated stickers
+         * @param {{ limit?: number }} options - Options object
+         * @returns {Promise<Array<Object>>}
+         */
+        getAiStickers: async function({ limit = 10 } = {}) {
+            const form = {
+                fb_api_caller_class: 'RelayModern',
+                fb_api_req_friendly_name: 'CometStickerPickerStickerGeneratedCardQuery',
+                variables: JSON.stringify({ limit }),
+                doc_id: '24151467751156443'
+            };
+            const res = await makeRequest(form);
+            return formatAiStickers(res);
+        }
+    };
+};

package/src/core/sendReqMqtt.js

@@ -0,0 +1,96 @@
+"use strict";
+
+function sendReqMqtt(ctx, payload, options, callback) {
+  return new Promise((resolve, reject) => {
+    const cb = typeof options === "function" ? options : callback;
+    const opts = typeof options === "object" && options ? options : {};
+    if (!ctx || !ctx.mqttClient) {
+      const err = new Error("Not connected to MQTT");
+      if (cb) cb(err);
+      return reject(err);
+    }
+    if (typeof ctx.wsReqNumber !== "number") ctx.wsReqNumber = 0;
+    const reqID = typeof opts.request_id === "number" ? opts.request_id : ++ctx.wsReqNumber;
+    const timeoutMs = typeof opts.timeout === "number" ? opts.timeout : 20000;
+    const qos = typeof opts.qos === "number" ? opts.qos : 1;
+    const retain = !!opts.retain;
+    const reqTopic = "/ls_req";
+    const respTopic = opts.respTopic || "/ls_resp";
+    const form = JSON.stringify({
+      app_id: opts.app_id || "",
+      payload: typeof payload === "string" ? payload : JSON.stringify(payload),
+      request_id: reqID,
+      type: opts.type == null ? 3 : opts.type
+    });
+    let timer = null;
+    let cleaned = false;
+
+    // Cleanup function to ensure listeners and timers are always removed
+    const cleanup = () => {
+      if (cleaned) return;
+      cleaned = true;
+      try {
+        if (timer) {
+          clearTimeout(timer);
+          timer = null;
+        }
+        if (ctx.mqttClient && typeof ctx.mqttClient.removeListener === "function") {
+          ctx.mqttClient.removeListener("message", handleRes);
+        }
+      } catch (err) {
+        // Ignore cleanup errors
+      }
+    };
+
+    const handleRes = (topic, message) => {
+      if (topic !== respTopic) return;
+      let msg;
+      try {
+        msg = JSON.parse(message.toString());
+      } catch {
+        return;
+      }
+      if (msg.request_id !== reqID) return;
+      if (typeof opts.filter === "function" && !opts.filter(msg)) return;
+      cleanup();
+      try {
+        msg.payload = typeof msg.payload === "string" ? JSON.parse(msg.payload) : msg.payload;
+      } catch { }
+      const out = { success: true, response: msg.payload, raw: msg };
+      if (cb) cb(null, out);
+      resolve(out);
+    };
+
+    try {
+      ctx.mqttClient.on("message", handleRes);
+    } catch (err) {
+      cleanup();
+      const error = new Error("Failed to attach message listener");
+      if (cb) cb(error);
+      return reject(error);
+    }
+
+    timer = setTimeout(() => {
+      cleanup();
+      const err = new Error("MQTT response timeout");
+      if (cb) cb(err);
+      reject(err);
+    }, timeoutMs);
+
+    try {
+      ctx.mqttClient.publish(reqTopic, form, { qos, retain }, (err) => {
+        if (err) {
+          cleanup();
+          if (cb) cb(err);
+          reject(err);
+        }
+      });
+    } catch (err) {
+      cleanup();
+      if (cb) cb(err);
+      reject(err);
+    }
+  });
+}
+
+module.exports = sendReqMqtt;

package/src/database/models/index.js

@@ -0,0 +1,49 @@
+const { Sequelize } = require("sequelize");
+const fs = require("fs");
+const path = require("path");
+const databasePath = path.join(process.cwd(), "Fca_Database");
+if (!fs.existsSync(databasePath)) {
+  fs.mkdirSync(databasePath, { recursive: true });
+}
+const sequelize = new Sequelize({
+  dialect: "sqlite",
+  storage: path.join(databasePath, "database.sqlite"),
+  logging: false,
+  pool: {
+    max: 5,
+    min: 0,
+    acquire: 30000,
+    idle: 10000
+  },
+  retry: {
+    max: 3
+  },
+  dialectOptions: {
+    timeout: 5000
+  },
+  isolationLevel: Sequelize.Transaction.ISOLATION_LEVELS.READ_COMMITTED
+});
+const models = {};
+fs.readdirSync(__dirname)
+  .filter(file => file.endsWith(".js") && file !== "index.js")
+  .forEach(file => {
+    const model = require(path.join(__dirname, file))(sequelize);
+    models[model.name] = model;
+  });
+Object.keys(models).forEach(modelName => {
+  if (models[modelName].associate) {
+    models[modelName].associate(models);
+  }
+});
+models.sequelize = sequelize;
+models.Sequelize = Sequelize;
+models.syncAll = async () => {
+  try {
+    await sequelize.sync({ force: false });
+  } catch (error) {
+    console.error("Failed to synchronize models:", error);
+    throw error;
+  }
+};
+
+module.exports = models;

package/src/database/models/thread.js

@@ -0,0 +1,31 @@
+module.exports = function(sequelize) {
+  const { Model, DataTypes } = require("sequelize");
+
+  class Thread extends Model {}
+
+  Thread.init(
+    {
+      num: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        autoIncrement: true,
+        primaryKey: true
+      },
+      threadID: {
+        type: DataTypes.STRING,
+        allowNull: false,
+        unique: true
+      },
+      data: {
+        type: DataTypes.JSONB,
+        allowNull: true
+      }
+    },
+    {
+      sequelize,
+      modelName: "Thread",
+      timestamps: true
+    }
+  );
+  return Thread;
+};

package/src/database/models/user.js

@@ -0,0 +1,32 @@
+module.exports = function (sequelize) {
+  const { Model, DataTypes } = require("sequelize");
+
+  class User extends Model { }
+
+  User.init(
+    {
+      num: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        autoIncrement: true,
+        primaryKey: true
+      },
+      userID: {
+        type: DataTypes.STRING,
+        allowNull: false,
+        unique: true
+      },
+      data: {
+        type: DataTypes.JSONB,
+        allowNull: true
+      }
+    },
+    {
+      sequelize,
+      modelName: "User",
+      timestamps: true
+    }
+  );
+
+  return User;
+};

package/src/database/threadData.js

@@ -0,0 +1,98 @@
+const { Thread } = require("./models");
+
+const validateThreadID = threadID => {
+  if (typeof threadID !== "string" && typeof threadID !== "number") {
+    throw new Error("Invalid threadID: must be a string or number.");
+  }
+  return String(threadID);
+};
+const validateData = data => {
+  if (!data || typeof data !== "object" || Array.isArray(data)) {
+    throw new Error("Invalid data: must be a non-empty object.");
+  }
+};
+
+module.exports = function(bot) {
+  return {
+    async create(threadID, data) {
+      try {
+        let thread = await Thread.findOne({ where: { threadID } });
+        if (thread) {
+          return { thread: thread.get(), created: false };
+        }
+        thread = await Thread.create({ threadID, ...data });
+        return { thread: thread.get(), created: true };
+      } catch (error) {
+        throw new Error(`Failed to create thread: ${error.message}`);
+      }
+    },
+
+    async get(threadID) {
+      try {
+        threadID = validateThreadID(threadID);
+        const thread = await Thread.findOne({ where: { threadID } });
+        return thread ? thread.get() : null;
+      } catch (error) {
+        throw new Error(`Failed to get thread: ${error.message}`);
+      }
+    },
+
+    async update(threadID, data) {
+      try {
+        threadID = validateThreadID(threadID);
+        validateData(data);
+        const thread = await Thread.findOne({ where: { threadID } });
+
+        if (thread) {
+          await thread.update(data);
+          return { thread: thread.get(), created: false };
+        } else {
+          const newThread = await Thread.create({ ...data, threadID });
+          return { thread: newThread.get(), created: true };
+        }
+      } catch (error) {
+        throw new Error(`Failed to update thread: ${error.message}`);
+      }
+    },
+
+    async del(threadID) {
+      try {
+        if (!threadID) {
+          throw new Error("threadID is required and cannot be undefined");
+        }
+        threadID = validateThreadID(threadID);
+        if (!threadID) {
+          throw new Error("Invalid threadID");
+        }
+        const result = await Thread.destroy({ where: { threadID } });
+        if (result === 0) {
+          throw new Error("No thread found with the specified threadID");
+        }
+        return result;
+      } catch (error) {
+        throw new Error(`Failed to delete thread: ${error.message}`);
+      }
+    },
+    async delAll() {
+      try {
+        return await Thread.destroy({ where: {} });
+      } catch (error) {
+        throw new Error(`Failed to delete all threads: ${error.message}`);
+      }
+    },
+    async getAll(keys = null) {
+      try {
+        const attributes =
+          typeof keys === "string"
+            ? [keys]
+            : Array.isArray(keys)
+            ? keys
+            : undefined;
+        const threads = await Thread.findAll({ attributes });
+        return threads.map(thread => thread.get());
+      } catch (error) {
+        throw new Error(`Failed to get all threads: ${error.message}`);
+      }
+    }
+  };
+};

package/src/database/userData.js

@@ -0,0 +1,89 @@
+const { User } = require("./models");
+
+const validateUserID = userID => {
+  if (typeof userID !== "string" && typeof userID !== "number") {
+    throw new Error("Invalid userID: must be a string or number.");
+  }
+  return String(userID);
+};
+const validateData = data => {
+  if (!data || typeof data !== "object" || Array.isArray(data)) {
+    throw new Error("Invalid data: must be a non-empty object.");
+  }
+};
+
+module.exports = function (bot) {
+  return {
+    async create(userID, data) {
+      try {
+        userID = validateUserID(userID);
+        validateData(data);
+        let user = await User.findOne({ where: { userID } });
+        if (user) return { user: user.get(), created: false };
+        const payload = Object.prototype.hasOwnProperty.call(data, "data") ? data : { data };
+        user = await User.create({ userID, ...payload });
+        return { user: user.get(), created: true };
+      } catch (error) {
+        throw new Error(`Failed to create user: ${error.message}`);
+      }
+    },
+
+    async get(userID) {
+      try {
+        userID = validateUserID(userID);
+        const user = await User.findOne({ where: { userID } });
+        return user ? user.get() : null;
+      } catch (error) {
+        throw new Error(`Failed to get user: ${error.message}`);
+      }
+    },
+
+    async update(userID, data) {
+      try {
+        userID = validateUserID(userID);
+        validateData(data);
+        const payload = Object.prototype.hasOwnProperty.call(data, "data") ? data : { data };
+        const user = await User.findOne({ where: { userID } });
+        if (user) {
+          await user.update(payload);
+          return { user: user.get(), created: false };
+        } else {
+          const newUser = await User.create({ userID, ...payload });
+          return { user: newUser.get(), created: true };
+        }
+      } catch (error) {
+        throw new Error(`Failed to update user: ${error.message}`);
+      }
+    },
+
+    async del(userID) {
+      try {
+        if (!userID) throw new Error("userID is required and cannot be undefined");
+        userID = validateUserID(userID);
+        const result = await User.destroy({ where: { userID } });
+        if (result === 0) throw new Error("No user found with the specified userID");
+        return result;
+      } catch (error) {
+        throw new Error(`Failed to delete user: ${error.message}`);
+      }
+    },
+
+    async delAll() {
+      try {
+        return await User.destroy({ where: {} });
+      } catch (error) {
+        throw new Error(`Failed to delete all users: ${error.message}`);
+      }
+    },
+
+    async getAll(keys = null) {
+      try {
+        const attributes = typeof keys === "string" ? [keys] : Array.isArray(keys) ? keys : undefined;
+        const users = await User.findAll({ attributes });
+        return users.map(u => u.get());
+      } catch (error) {
+        throw new Error(`Failed to get all users: ${error.message}`);
+      }
+    }
+  };
+};