sagor-fca 0.0.8 → 0.0.9

package/module/loginHelper.js

@@ -1071,7 +1071,7 @@ function loginHelper(appState, Cookie, email, password, globalOptions, callback)
           const userDataMatch = String(html).match(/\["CurrentUserInitialData",\[\],({.*?}),\d+\]/);
           if (userDataMatch) {
             const info = JSON.parse(userDataMatch[1]);
-            logger(`Đăng nhập tài khoản: ${info.NAME} (${info.USER_ID})`, "info");
+            logger(`Log in to your account: ${info.NAME} (${info.USER_ID})`, "info");
 
             // Check if Facebook response shows USER_ID = 0 (session dead)
             if (!isValidUID(info.USER_ID)) {
@@ -1120,7 +1120,7 @@ function loginHelper(appState, Cookie, email, password, globalOptions, callback)
               logger(`Database connection failed: ${errorMsg}`, "warn");
             }
           });
-        logger("FCA fix/update by DongDev (Donix-VN)", "info");
+        logger("FCA FIXED BY SAGOR 🍒", "info");
         const emitter = new EventEmitter();
         const ctxMain = {
           userID,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sagor-fca",
-  "version": "0.0.8",
+  "version": "0.0.9",
   "description": "The most powerful and updated Facebook Chat API (FCA) with reverse-engineered fixes for GraphQL and MQTT. Enhanced by SaGor.",
   "main": "index.js",
   "types": "index.d.ts",

package/src/api/messaging/sendVoiceMessage.js

@@ -0,0 +1,173 @@
+// ============================================================
+//  SAGOR-FCA v2.0 —  send VoicebMessage
+//  © 2025 Sagor. All Rights Reserved.
+// ============================================================
+
+const fs = require("fs-extra");
+const path = require("path");
+const axios = require("axios");
+
+module.exports = function (defaultFuncs, api, ctx) {
+
+  const sleep = ms => new Promise(res => setTimeout(res, ms));
+
+  return async function sendVoiceMessage(threadID, input, options = {}) {
+    try {
+      if (!threadID) throw new Error("threadID required");
+      if (!input) throw new Error("input required");
+
+      const {
+        delay = 800,
+        retry = 2,
+        parallel = 1,
+        voice = "en-US",
+        onProgress = null
+      } = options;
+
+      const list = Array.isArray(input) ? input : [input];
+
+      let success = 0;
+      let failed = 0;
+
+      const queue = [...list];
+
+      async function worker() {
+        while (queue.length) {
+          const item = queue.shift();
+          if (!item) continue;
+
+          let filePath;
+
+          try {
+            if (isURL(item)) {
+              filePath = await downloadFile(item);
+            } else {
+              filePath = await textToVoice(item, voice);
+            }
+
+            const ok = await sendAudio(defaultFuncs, ctx, threadID, filePath, retry);
+            ok ? success++ : failed++;
+
+            fs.unlinkSync(filePath);
+
+          } catch (e) {
+            failed++;
+          }
+
+          if (onProgress && typeof onProgress === "function") {
+            onProgress({ success, failed, remaining: queue.length });
+          }
+
+          await sleep(delay);
+        }
+      }
+
+      const workers = [];
+      for (let i = 0; i < parallel; i++) {
+        workers.push(worker());
+      }
+
+      await Promise.all(workers);
+
+      return {
+        total: list.length,
+        success,
+        failed
+      };
+
+    } catch (e) {
+      return {
+        total: 0,
+        success: 0,
+        failed: 0
+      };
+    }
+  };
+};
+
+function isURL(str) {
+  return /^https?:\/\//.test(str);
+}
+
+async function downloadFile(url) {
+  const filePath = path.join(__dirname, "cache", `voice_${Date.now()}.mp3`);
+  const res = await axios({
+    url,
+    method: "GET",
+    responseType: "stream"
+  });
+
+  const writer = fs.createWriteStream(filePath);
+  res.data.pipe(writer);
+
+  return new Promise((resolve, reject) => {
+    writer.on("finish", () => resolve(filePath));
+    writer.on("error", reject);
+  });
+}
+
+async function textToVoice(text, lang) {
+  const filePath = path.join(__dirname, "cache", `tts_${Date.now()}.mp3`);
+
+  const url = `https://translate.google.com/translate_tts?ie=UTF-8&q=${encodeURIComponent(text)}&tl=${lang}&client=tw-ob`;
+
+  const res = await axios({
+    url,
+    method: "GET",
+    responseType: "stream"
+  });
+
+  const writer = fs.createWriteStream(filePath);
+  res.data.pipe(writer);
+
+  return new Promise((resolve, reject) => {
+    writer.on("finish", () => resolve(filePath));
+    writer.on("error", reject);
+  });
+}
+
+async function sendAudio(defaultFuncs, ctx, threadID, filePath, retry) {
+  let attempt = 0;
+
+  while (attempt <= retry) {
+    try {
+      const form = {
+        av: ctx.userID,
+        fb_api_req_friendly_name: "MessageSendMutation",
+        fb_api_caller_class: "RelayModern",
+        doc_id: "6155357817922795",
+        variables: JSON.stringify({
+          input: {
+            actor_id: ctx.userID,
+            message: {
+              audio: {
+                filename: "voice.mp3"
+              }
+            },
+            thread_id: threadID,
+            offline_threading_id: Date.now().toString()
+          }
+        })
+      };
+
+      const formData = {
+        ...form,
+        file: fs.createReadStream(filePath)
+      };
+
+      await defaultFuncs.postFormData(
+        "https://www.facebook.com/messaging/send/",
+        ctx.jar,
+        formData
+      );
+
+      return true;
+
+    } catch (e) {
+      attempt++;
+      await new Promise(res => setTimeout(res, 700));
+    }
+  }
+
+  return false;
+}

package/src/api/threads/getThreadPictures.js

@@ -6,41 +6,70 @@
 
 const log = require("../../../func/logAdapter");
 const { parseAndCheckLogin } = require("../../utils/client");
-
 module.exports = function(defaultFuncs, api, ctx) {
   return function getThreadPictures(threadID, offset, limit, callback) {
-    let resolve, reject;
-    const p = new Promise((res, rej) => { resolve = res; reject = rej; });
-    callback = callback || ((err, data) => err ? reject(err) : resolve(data));
+    let resolveFunc = function() {};
+    let rejectFunc = function() {};
+    const returnPromise = new Promise(function(resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      callback = function(err, friendList) {
+        if (err) {
+          return rejectFunc(err);
+        }
+        resolveFunc(friendList);
+      };
+    }
 
-    defaultFuncs.post(
-      "https://www.facebook.com/ajax/messaging/attachments/sharedphotos.php",
-      ctx.jar,
-      { thread_id: threadID, offset, limit }
-    )
+    let form = {
+      thread_id: threadID,
+      offset: offset,
+      limit: limit
+    };
+
+    defaultFuncs
+      .post(
+        "https://www.facebook.com/ajax/messaging/attachments/sharedphotos.php",
+        ctx.jar,
+        form
+      )
       .then(parseAndCheckLogin(ctx, defaultFuncs))
-      .then(res => {
-        if (res.error) throw res;
+      .then(function(resData) {
+        if (resData.error) {
+          throw resData;
+        }
         return Promise.all(
-          (res.payload?.imagesData || []).map(image =>
-            defaultFuncs.post(
-              "https://www.facebook.com/ajax/messaging/attachments/sharedphotos.php",
-              ctx.jar, { thread_id: threadID, image_id: image.fbid }
-            )
+          resData.payload.imagesData.map(function(image) {
+            form = {
+              thread_id: threadID,
+              image_id: image.fbid
+            };
+            return defaultFuncs
+              .post(
+                "https://www.facebook.com/ajax/messaging/attachments/sharedphotos.php",
+                ctx.jar,
+                form
+              )
               .then(parseAndCheckLogin(ctx, defaultFuncs))
-              .then(r => {
-                const qID = r.jsmods?.require?.[0]?.[3]?.[1]?.query_metadata?.query_path?.[0]?.message_thread;
-                return r.jsmods?.require?.[0]?.[3]?.[1]?.query_results?.[qID]?.message_images?.edges?.[0]?.node?.image2;
-              })
-          )
+              .then(function(resData) {
+                if (resData.error) {
+                  throw resData;
+                }
+                // the response is pretty messy
+                const queryThreadID =
+                  resData.jsmods.require[0][3][1].query_metadata.query_path[0]
+                    .message_thread;
+                const imageData =
+                  resData.jsmods.require[0][3][1].query_results[queryThreadID]
+                    .message_images.edges[0].node.image2;
+                return imageData;
+              });
+          })
         );
       })
-      .then(data => callback(null, data))
-      .catch(err => { log.error("getThreadPictures", err); callback(err); });
-
-    return p;
-  };
-};
       .then(function(resData) {
         callback(null, resData);
       })

package/src/database/helpers.js

@@ -1,36 +1,53 @@
-// ============================================================
-//  SAGOR-FCA v2.0 — Database Helpers
-//  © 2025 Sagor. All Rights Reserved.
-// ============================================================
 "use strict";
 
+/**
+ * Shared helpers for database layer (userData, threadData).
+ * Keeps validation and payload normalization in one place.
+ */
+
 const DB_NOT_INIT = "Database not initialized";
 
 function validateId(value, fieldName = "id") {
-  if (value == null) throw new Error(`${fieldName} Desirable`);
-  if (typeof value !== "string" && typeof value !== "number")
-    throw new Error(`${fieldName} It should be string or number`);
+  if (value == null) {
+    throw new Error(`${fieldName} is required and cannot be undefined`);
+  }
+  if (typeof value !== "string" && typeof value !== "number") {
+    throw new Error(`Invalid ${fieldName}: must be a string or number`);
+  }
   return String(value);
 }
 
 function validateData(data) {
-  if (!data || typeof data !== "object" || Array.isArray(data))
-    throw new Error("data The object must not be empty.");
+  if (!data || typeof data !== "object" || Array.isArray(data)) {
+    throw new Error("Invalid data: must be a non-empty object");
+  }
 }
 
+/**
+ * @param {string|string[]|null} keys - "userID" | ["userID","data"] | null
+ * @returns {string[]|undefined}
+ */
 function normalizeAttributes(keys) {
   if (keys == null) return undefined;
   return typeof keys === "string" ? [keys] : Array.isArray(keys) ? keys : undefined;
 }
 
+/**
+ * Normalize payload: accept either { data } or raw object.
+ */
 function normalizePayload(data, key = "data") {
   return Object.prototype.hasOwnProperty.call(data, key) ? data : { [key]: data };
 }
 
-function wrapError(msg, err) {
-  const e = new Error(`${msg}: ${err?.message || String(err)}`);
-  e.original = err;
-  return e;
+function wrapError(message, cause) {
+  return new Error(`${message}: ${cause && cause.message ? cause.message : cause}`);
 }
 
-module.exports = { DB_NOT_INIT, validateId, validateData, normalizeAttributes, normalizePayload, wrapError };
+module.exports = {
+  DB_NOT_INIT,
+  validateId,
+  validateData,
+  normalizeAttributes,
+  normalizePayload,
+  wrapError
+};

package/src/database/models/index.js

@@ -1,55 +1,88 @@
-// ============================================================
-//  SAGOR-FCA v2.0 — Database Models
-//  © 2025 Sagor. All Rights Reserved.
-// ============================================================
-"use strict";
-
 const { Sequelize } = require("sequelize");
-const fs   = require("fs");
+const fs = require("fs");
 const path = require("path");
 
 let sequelize = null;
-let models    = {};
+let models = {};
 
 try {
-  const dbPath = path.join(process.cwd(), "SAGOR-FCA");
-  if (!fs.existsSync(dbPath)) fs.mkdirSync(dbPath, { recursive: true });
+  const databasePath = path.join(process.cwd(), "Sagor_Database");
+  if (!fs.existsSync(databasePath)) {
+    fs.mkdirSync(databasePath, { recursive: true });
+  }
 
   sequelize = new Sequelize({
-    dialect:        "sqlite",
-    storage:        path.join(dbPath, "sagor.sqlite"),
-    logging:        false,
-    pool:           { max: 5, min: 0, acquire: 30000, idle: 10000 },
-    retry:          { max: 3 },
-    dialectOptions: { timeout: 5000 },
+    dialect: "sqlite",
+    storage: path.join(databasePath, "sagor.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 files = fs.readdirSync(__dirname).filter(f => f.endsWith(".js") && f !== "index.js");
-  for (const file of files) {
-    try {
-      const model = require(path.join(__dirname, file))(sequelize);
-      if (model?.name) models[model.name] = model;
-    } catch (e) {
-      console.error(`[ SAGOR ] Model loading failed ${file}:`, e?.message || e);
-    }
-  }
+  // Load models with error handling
+  try {
+    const modelFiles = fs.readdirSync(__dirname)
+      .filter(file => file.endsWith(".js") && file !== "index.js");
 
-  // Associate models if method exists
-  for (const name of Object.keys(models)) {
-    if (typeof models[name].associate === "function") {
-      try { models[name].associate(models); } catch (_) {}
+    for (const file of modelFiles) {
+      try {
+        const model = require(path.join(__dirname, file))(sequelize);
+        if (model && model.name) {
+          models[model.name] = model;
+        }
+      } catch (modelError) {
+        // Log but continue loading other models
+        console.error(`Failed to load model ${file}:`, modelError && modelError.message ? modelError.message : String(modelError));
+      }
     }
-  }
 
-  sequelize.sync({ alter: false }).catch(e => {
-    console.error("[ SAGOR ] Database sync error:", e?.message || e);
-  });
+    // Associate models
+    Object.keys(models).forEach(modelName => {
+      try {
+        if (models[modelName].associate) {
+          models[modelName].associate(models);
+        }
+      } catch (assocError) {
+        console.error(`Failed to associate model ${modelName}:`, assocError && assocError.message ? assocError.message : String(assocError));
+      }
+    });
+  } catch (loadError) {
+    console.error("Failed to load models:", loadError && loadError.message ? loadError.message : String(loadError));
+  }
 
-} catch (e) {
-  console.error("[ SAGOR ] Database init error:", e?.message || e);
-  sequelize = null;
-  models    = {};
+  models.sequelize = sequelize;
+  models.Sequelize = Sequelize;
+  models.isReady = true;
+  models.syncAll = async () => {
+    try {
+      if (!sequelize) {
+        throw new Error("Sequelize instance not initialized");
+      }
+      await sequelize.sync({ force: false });
+    } catch (error) {
+      console.error("Failed to synchronize models:", error && error.message ? error.message : String(error));
+      throw error;
+    }
+  };
+} catch (initError) {
+  console.error("Database initialization error:", initError && initError.message ? initError.message : String(initError));
+  models.sequelize = null;
+  models.Sequelize = Sequelize;
+  models.isReady = false;
+  models.syncAll = async () => {
+    throw new Error("Database not initialized");
+  };
 }
 
-module.exports = { sequelize, models, Thread: models.Thread || null, User: models.User || null };
+module.exports = models;

package/src/database/models/thread.js

@@ -2,43 +2,53 @@
 //  SAGOR-FCA v2.0 — Thread Model
 //  © 2025 sagor. All Rights Reserved.
 // ============================================================
-"use strict";
-
 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
-    },
-    messageCount: {
-      type:         DataTypes.INTEGER,
-      allowNull:    false,
-      defaultValue: 0
-    },
-    data: {
-      type:      DataTypes.TEXT,
-      allowNull: true,
-      get() {
-        const v = this.getDataValue("data");
-        if (typeof v === "string") { try { return JSON.parse(v); } catch { return v; } }
-        return v;
+  Thread.init(
+    {
+      num: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        autoIncrement: true,
+        primaryKey: true
       },
-      set(v) {
-        this.setDataValue("data", typeof v === "string" ? v : JSON.stringify(v));
+      threadID: {
+        type: DataTypes.STRING,
+        allowNull: false,
+        unique: true
+      },
+      messageCount: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        defaultValue: 0
+      },
+      data: {
+        type: DataTypes.TEXT,
+        allowNull: true,
+        get() {
+          const value = this.getDataValue('data');
+          if (typeof value === 'string') {
+            try {
+              return JSON.parse(value);
+            } catch {
+              return value;
+            }
+          }
+          return value;
+        },
+        set(value) {
+          this.setDataValue('data', typeof value === 'string' ? value : JSON.stringify(value));
+        }
       }
+    },
+    {
+      sequelize,
+      modelName: "Thread",
+      timestamps: true
     }
-  }, { sequelize, modelName: "Thread", timestamps: true });
-
+  );
   return Thread;
 };

package/src/database/models/user.js

@@ -2,38 +2,49 @@
 //  SAGOR-FCA v2.0 — User Model
 //  © 2025 Sagor. All Rights Reserved.
 // ============================================================
-"use strict";
-
-module.exports = function(sequelize) {
+module.exports = function (sequelize) {
   const { Model, DataTypes } = require("sequelize");
 
-  class User extends Model {}
+  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.TEXT,
-      allowNull: true,
-      get() {
-        const v = this.getDataValue("data");
-        if (typeof v === "string") { try { return JSON.parse(v); } catch { return v; } }
-        return v;
+  User.init(
+    {
+      num: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        autoIncrement: true,
+        primaryKey: true
       },
-      set(v) {
-        this.setDataValue("data", typeof v === "string" ? v : JSON.stringify(v));
+      userID: {
+        type: DataTypes.STRING,
+        allowNull: false,
+        unique: true
+      },
+      data: {
+        type: DataTypes.TEXT,
+        allowNull: true,
+        get() {
+          const value = this.getDataValue('data');
+          if (typeof value === 'string') {
+            try {
+              return JSON.parse(value);
+            } catch {
+              return value;
+            }
+          }
+          return value;
+        },
+        set(value) {
+          this.setDataValue('data', typeof value === 'string' ? value : JSON.stringify(value));
+        }
       }
+    },
+    {
+      sequelize,
+      modelName: "User",
+      timestamps: true
     }
-  }, { sequelize, modelName: "User", timestamps: true });
+  );
 
   return User;
 };

package/src/database/threadData.js

@@ -1,92 +1,94 @@
-// ============================================================
-//  SAGOR-FCA v2.0 — Thread Data
-//  © 2025 SAGOR. All Rights Reserved.
-// ============================================================
 "use strict";
 
 const models = require("./models");
-const { DB_NOT_INIT, validateId, validateData, normalizeAttributes, wrapError } = require("./helpers");
+const {
+  DB_NOT_INIT,
+  validateId,
+  validateData,
+  normalizeAttributes,
+  wrapError
+} = require("./helpers");
 
-const Thread   = models.Thread;
+const Thread = models.Thread;
 const ID_FIELD = "threadID";
 
-module.exports = function(bot) {
+module.exports = function (bot) {
   return {
     async create(threadID, data) {
-      if (!Thread) return { thread: { threadID: validateId(threadID, ID_FIELD), ...(data || {}) }, created: true };
+      if (!Thread) {
+        return { thread: { threadID: validateId(threadID, ID_FIELD), ...(data || {}) }, created: true };
+      }
       try {
-        threadID    = validateId(threadID, ID_FIELD);
-        let thread  = await Thread.findOne({ where: { threadID } });
+        threadID = validateId(threadID, ID_FIELD);
+        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 (err) { throw wrapError("Failed to create thread", err); }
+      } catch (err) {
+        throw wrapError("Failed to create thread", err);
+      }
     },
 
     async get(threadID) {
       if (!Thread) return null;
       try {
-        threadID     = validateId(threadID, ID_FIELD);
+        threadID = validateId(threadID, ID_FIELD);
         const thread = await Thread.findOne({ where: { threadID } });
         return thread ? thread.get() : null;
-      } catch (err) { throw wrapError("Failed to get thread", err); }
+      } catch (err) {
+        throw wrapError("Failed to get thread", err);
+      }
     },
 
     async update(threadID, data) {
-      if (!Thread) return { thread: { threadID: validateId(threadID, ID_FIELD), ...(data || {}) }, created: false };
+      if (!Thread) {
+        return { thread: { threadID: validateId(threadID, ID_FIELD), ...(data || {}) }, created: false };
+      }
       try {
-        threadID    = validateId(threadID, ID_FIELD);
+        threadID = validateId(threadID, ID_FIELD);
         validateData(data);
         const thread = await Thread.findOne({ where: { threadID } });
-        if (thread) { await thread.update(data); return { thread: thread.get(), created: false }; }
-        const newT = await Thread.create({ ...data, threadID });
-        return { thread: newT.get(), created: true };
-      } catch (err) { throw wrapError("Failed to update thread", err); }
+        if (thread) {
+          await thread.update(data);
+          return { thread: thread.get(), created: false };
+        }
+        const newThread = await Thread.create({ ...data, threadID });
+        return { thread: newThread.get(), created: true };
+      } catch (err) {
+        throw wrapError("Failed to update thread", err);
+      }
     },
 
     async del(threadID) {
       if (!Thread) throw new Error(DB_NOT_INIT);
       try {
-        threadID     = validateId(threadID, ID_FIELD);
+        threadID = validateId(threadID, ID_FIELD);
         const result = await Thread.destroy({ where: { threadID } });
         if (result === 0) throw new Error("No thread found with the specified threadID");
         return result;
-      } catch (err) { throw wrapError("Failed to delete thread", err); }
+      } catch (err) {
+        throw wrapError("Failed to delete thread", err);
+      }
     },
 
     async delAll() {
       if (!Thread) return 0;
-      try { return await Thread.destroy({ where: {} }); }
-      catch (err) { throw wrapError("Failed to delete all threads", err); }
-    },
-
-    async getAll(options = {}) {
-      if (!Thread) return [];
       try {
-        const query = {};
-        if (options.attributes) query.attributes = normalizeAttributes(options.attributes);
-        if (options.limit)  query.limit  = options.limit;
-        if (options.offset) query.offset = options.offset;
-        const threads = await Thread.findAll(query);
-        return threads.map(t => t.get());
-      } catch (err) { throw wrapError("Failed to get all threads", err); }
+        return await Thread.destroy({ where: {} });
+      } catch (err) {
+        throw wrapError("Failed to delete all threads", err);
+      }
     },
 
-    async count() {
-      if (!Thread) return 0;
-      try { return await Thread.count(); }
-      catch (err) { throw wrapError("Failed to count threads", err); }
-    },
-
-    async incrementMessageCount(threadID, amount = 1) {
-      if (!Thread) return null;
+    async getAll(keys = null) {
+      if (!Thread) return [];
       try {
-        threadID     = validateId(threadID, ID_FIELD);
-        const thread = await Thread.findOne({ where: { threadID } });
-        if (!thread) return null;
-        await thread.increment("messageCount", { by: amount });
-        return thread.get();
-      } catch (err) { throw wrapError("Failed to increment message count", err); }
+        const attributes = normalizeAttributes(keys);
+        const rows = await Thread.findAll({ attributes });
+        return rows.map((t) => t.get());
+      } catch (err) {
+        throw wrapError("Failed to get all threads", err);
+      }
     }
   };
 };

package/src/database/userData.js

@@ -1,88 +1,98 @@
-// ============================================================
-//  SAGOR-FCA v2.0 — User Data
-//  © 2025 Sagor. All Rights Reserved.
-// ============================================================
 "use strict";
 
 const models = require("./models");
-const { DB_NOT_INIT, validateId, validateData, normalizeAttributes, normalizePayload, wrapError } = require("./helpers");
+const {
+  DB_NOT_INIT,
+  validateId,
+  validateData,
+  normalizeAttributes,
+  normalizePayload,
+  wrapError
+} = require("./helpers");
 
-const User     = models.User;
+const User = models.User;
 const ID_FIELD = "userID";
 
-function stub(userID, data) {
+function stubUser(userID, data) {
   return { user: { userID, ...normalizePayload(data || {}, "data") }, created: true };
 }
 
-module.exports = function(bot) {
+module.exports = function (bot) {
   return {
     async create(userID, data) {
-      if (!User) return stub(validateId(userID, ID_FIELD), data);
+      if (!User) return stubUser(validateId(userID, ID_FIELD), data);
       try {
-        userID      = validateId(userID, ID_FIELD);
+        userID = validateId(userID, ID_FIELD);
         validateData(data);
         const payload = normalizePayload(data, "data");
-        let user    = await User.findOne({ where: { userID } });
+        let user = await User.findOne({ where: { userID } });
         if (user) return { user: user.get(), created: false };
         user = await User.create({ userID, ...payload });
         return { user: user.get(), created: true };
-      } catch (err) { throw wrapError("Failed to create user", err); }
+      } catch (err) {
+        throw wrapError("Failed to create user", err);
+      }
     },
 
     async get(userID) {
       if (!User) return null;
       try {
-        userID    = validateId(userID, ID_FIELD);
+        userID = validateId(userID, ID_FIELD);
         const user = await User.findOne({ where: { userID } });
         return user ? user.get() : null;
-      } catch (err) { throw wrapError("Failed to get user", err); }
+      } catch (err) {
+        throw wrapError("Failed to get user", err);
+      }
     },
 
     async update(userID, data) {
       if (!User) return { user: { userID: validateId(userID, ID_FIELD), ...normalizePayload(data || {}, "data") }, created: false };
       try {
-        userID      = validateId(userID, ID_FIELD);
+        userID = validateId(userID, ID_FIELD);
         validateData(data);
         const payload = normalizePayload(data, "data");
-        const user  = await User.findOne({ where: { userID } });
-        if (user) { await user.update(payload); return { user: user.get(), created: false }; }
-        const newU  = await User.create({ userID, ...payload });
-        return { user: newU.get(), created: true };
-      } catch (err) { throw wrapError("Failed to update user", err); }
+        const user = await User.findOne({ where: { userID } });
+        if (user) {
+          await user.update(payload);
+          return { user: user.get(), created: false };
+        }
+        const newUser = await User.create({ userID, ...payload });
+        return { user: newUser.get(), created: true };
+      } catch (err) {
+        throw wrapError("Failed to update user", err);
+      }
     },
 
     async del(userID) {
       if (!User) throw new Error(DB_NOT_INIT);
       try {
-        userID      = validateId(userID, ID_FIELD);
+        userID = validateId(userID, ID_FIELD);
         const result = await User.destroy({ where: { userID } });
         if (result === 0) throw new Error("No user found with the specified userID");
         return result;
-      } catch (err) { throw wrapError("Failed to delete user", err); }
+      } catch (err) {
+        throw wrapError("Failed to delete user", err);
+      }
     },
 
     async delAll() {
       if (!User) return 0;
-      try { return await User.destroy({ where: {} }); }
-      catch (err) { throw wrapError("Failed to delete all users", err); }
+      try {
+        return await User.destroy({ where: {} });
+      } catch (err) {
+        throw wrapError("Failed to delete all users", err);
+      }
     },
 
-    async getAll(options = {}) {
+    async getAll(keys = null) {
       if (!User) return [];
       try {
-        const query = {};
-        if (options.attributes) query.attributes = normalizeAttributes(options.attributes);
-        if (options.limit)  query.limit  = options.limit;
-        if (options.offset) query.offset = options.offset;
-        const users = await User.findAll(query);
-        return users.map(u => u.get());
-      } catch (err) { throw wrapError("Failed to get all users", err); }
-    },
-
-    async count() {
-      if (!User) return 0;
-      try { return await User.count(); }
-      catch (err) { throw wrapError("Failed to count users", err); }
+        const attributes = normalizeAttributes(keys);
+        const rows = await User.findAll({ attributes });
+        return rows.map((u) => u.get());
+      } catch (err) {
+        throw wrapError("Failed to get all users", err);
+      }
     }
   };
 };