@dongdev/fca-unofficial 0.0.6 → 0.0.8

package/lib/database/models/index.js

@@ -0,0 +1,47 @@
+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/lib/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/lib/database/threadData.js

@@ -0,0 +1,93 @@
+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/lib/logger.js

@@ -0,0 +1,96 @@
+const chalk = require('chalk');
+const gradient = require("gradient-string");
+const themes = [
+  'blue',
+  'dream2',
+  'dream',
+  'test',
+  'fiery',
+  'rainbow',
+  'pastel',
+  'cristal',
+  'red',
+  'aqua',
+  'pink',
+  'retro',
+  'sunlight',
+  'teen',
+  'summer',
+  'flower',
+  'ghost',
+  'hacker'
+];
+const theme = themes[Math.floor(Math.random() * themes.length)];
+let co;
+let error;
+if (theme.toLowerCase() === 'blue') {
+  co = gradient([{ color: "#1affa3", pos: 0.2 }, { color: "cyan", pos: 0.4 }, { color: "pink", pos: 0.6 }, { color: "cyan", pos: 0.8 }, { color: '#1affa3', pos: 1 }]);
+  error = chalk.red.bold;
+} else if (theme == "dream2") {
+  cra = gradient("blue", "pink")
+  co = gradient("#a200ff", "#21b5ff", "#a200ff")
+} else if (theme.toLowerCase() === 'dream') {
+  co = gradient([{ color: "blue", pos: 0.2 }, { color: "pink", pos: 0.3 }, { color: "gold", pos: 0.6 }, { color: "pink", pos: 0.8 }, { color: "blue", pos: 1 }]);
+  error = chalk.red.bold;
+} else if (theme.toLowerCase() === 'fiery') {
+  co = gradient("#fc2803", "#fc6f03", "#fcba03");
+  error = chalk.red.bold;
+} else if (theme.toLowerCase() === 'rainbow') {
+  co = gradient.rainbow
+  error = chalk.red.bold;
+} else if (theme.toLowerCase() === 'pastel') {
+  co = gradient.pastel
+  error = chalk.red.bold;
+} else if (theme.toLowerCase() === 'cristal') {
+  co = gradient.cristal
+  error = chalk.red.bold;
+} else if (theme.toLowerCase() === 'red') {
+  co = gradient("red", "orange");
+  error = chalk.red.bold;
+} else if (theme.toLowerCase() === 'aqua') {
+  co = gradient("#0030ff", "#4e6cf2");
+  error = chalk.blueBright;
+} else if (theme.toLowerCase() === 'pink') {
+  cra = gradient('purple', 'pink');
+  co = gradient("#d94fff", "purple");
+} else if (theme.toLowerCase() === 'retro') {
+  cra = gradient("#d94fff", "purple");
+  co = gradient.retro;
+} else if (theme.toLowerCase() === 'sunlight') {
+  cra = gradient("#f5bd31", "#f5e131");
+  co = gradient("orange", "#ffff00", "#ffe600");
+} else if (theme.toLowerCase() === 'teen') {
+  cra = gradient("#00a9c7", "#853858", "#853858", "#00a9c7");
+  co = gradient.teen;
+} else if (theme.toLowerCase() === 'summer') {
+  cra = gradient("#fcff4d", "#4de1ff");
+  co = gradient.summer;
+} else if (theme.toLowerCase() === 'flower') {
+  cra = gradient("blue", "purple", "yellow", "#81ff6e");
+  co = gradient.pastel;
+} else if (theme.toLowerCase() === 'ghost') {
+  cra = gradient("#0a658a", "#0a7f8a", "#0db5aa");
+  co = gradient.mind;
+} else if (theme === 'hacker') {
+  cra = chalk.hex('#4be813');
+  co = gradient('#47a127', '#0eed19', '#27f231');
+} else {
+  co = gradient("#243aff", "#4687f0", "#5800d4");
+  error = chalk.red.bold;
+}
+module.exports = (text, type) => {
+  switch (type) {
+    case "warn":
+      process.stderr.write(co(`\r[ FCA-WARN ] > ${text}`) + '\n');
+      break;
+    case "error":
+      process.stderr.write(chalk.bold.hex("#ff0000").bold(`\r[ FCA-ERROR ]`) + ` > ${text}` + '\n');
+      break;
+    case "info":
+      process.stderr.write(chalk.bold(co(`\r[ FCA-UNO ] > ${text}`) + '\n'));
+      break;
+    default:
+      process.stderr.write(chalk.bold(co(`\r${String(type).toUpperCase()} ${text}`) + '\n'));
+      break;
+  }
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dongdev/fca-unofficial",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "description": "A Facebook chat API without XMPP, will not be deprecated after April 30th, 2015.",
   "main": "index.js",
   "repository": {
@@ -10,13 +10,18 @@
   "author": "Avery, David, Maude, Benjamin, UIRI, DongDev",
   "license": "MIT",
   "dependencies": {
-    "bluebird": "^2.11.0",
+    "axios": "^1.8.4",
+    "bluebird": "^3.7.2",
+    "chalk": "^4.1.2",
     "cheerio": "^1.0.0-rc.10",
     "duplexify": "^4.1.3",
+    "gradient-string": "^2.0.2",
     "https-proxy-agent": "^4.0.0",
-    "mqtt": "^4.3.7",
+    "mqtt": "^4.3.8",
     "npmlog": "^1.2.0",
     "request": "^2.53.0",
+    "sequelize": "^6.37.6",
+    "sqlite3": "^5.1.7",
     "ws": "^8.18.1"
   },
   "devDependencies": {