zyket 1.2.10 → 1.2.12

package/src/services/bullmq/index.js

@@ -1,93 +1,93 @@
-const Service = require("../Service");
-const { Queue, QueueEvents, Worker: BullWorker } = require("bullmq");
-const Worker = require("./Worker");
-const fs = require("fs");
-const path = require("path");
-const fg = require('fast-glob');
-
-module.exports = class BullMQ extends Service  {
-  #container
-  queues = {};
-  queuesEvents = {};
-
-  constructor(container) {
-    super("queues");
-    this.#container = container;
-  }
-
-  async boot() {
-    const queusConfig = this.#getActivatedQueues();
-
-    for (const queueName of queusConfig) {
-      this.queues[queueName] = new Queue(queueName, this.#connection());
-      this.queuesEvents[queueName] = new QueueEvents(queueName, this.#connection());
-      await this.#container.get('logger').info(`Queue ${queueName} initialized`);
-    }
-
-    const workers = await this.#loadWorkersFromFolder(path.join(process.cwd(), "src", "workers"));
-
-    for (const wkr of workers) {
-      if(!wkr.queueName) {
-        this.#container.get('logger').warn(`Worker ${wkr.name} has no queueName defined, skipping...`);
-        continue;
-      }
-      if (!this.queues[wkr.queueName]) {
-        this.#container.get('logger').warn(`Queue ${wkr.queueName} not found for worker ${wkr.name}, skipping...`);
-        continue;
-      }
-      new BullWorker(
-        wkr.queueName,
-        async (job) => wkr.handle({ container: this.#container, job }),
-        this.#connection()
-      );
-      this.#container.get('logger').info(`Worker ${wkr.name} for queue ${wkr.queueName} initialized`);
-    }
-  }
-
-  async addJob(queueName, jobName, data, opts = {}, waitForCompletion = false) {
-    if (!this.queues[queueName]) throw new Error(`Queue ${queueName} not found`);
-    const job = await this.queues[queueName].add(jobName, data, opts);
-    if (!waitForCompletion) return job;
-
-    return new Promise((resolve, reject) => {
-      const queueEvent = this.queuesEvents[queueName];
-      job.waitUntilFinished(queueEvent, 1000 * 60).then((result) => {
-        resolve(result);
-      }).catch((err) => {
-        reject(err);
-      });
-    });
-  }
-
-  async #loadWorkersFromFolder(workersFolder) {
-    this.#createWorkersFolder(workersFolder);
-    const workers = (await fg('**/*.js', { cwd: workersFolder })).map((wkr) => {
-      const worker = require(path.join(workersFolder, wkr));
-      if(!(worker.prototype instanceof Worker)) {
-        this.#container.get('logger').warn(`File ${wkr} does not export a valid Worker class, skipping...`);
-        return null;
-      }
-      return new worker(wkr.replace('.js', ''));
-    }).filter(wkr => wkr !== null);
-    return workers;
-  }
-
-  #createWorkersFolder(workersFolder, overwrite = false) {
-    if (fs.existsSync(workersFolder) && !overwrite) return;
-    this.#container.get('logger').info(`Creating workers folder at ${workersFolder}`);
-    fs.mkdirSync(workersFolder);
-  }
-
-  #getActivatedQueues() {
-    const list = process.env.QUEUES || "";
-    return list.split(",").map(q => q.trim()).filter(q => q.length);
-  }
-
-  #connection() {
-    return {
-        connection: {
-          url: process.env.CACHE_URL || "redis://localhost:6379"
-        }
-    };
-  }
+const Service = require("../Service");
+const { Queue, QueueEvents, Worker: BullWorker } = require("bullmq");
+const Worker = require("./Worker");
+const fs = require("fs");
+const path = require("path");
+const fg = require('fast-glob');
+
+module.exports = class BullMQ extends Service  {
+  #container
+  queues = {};
+  queuesEvents = {};
+
+  constructor(container) {
+    super("queues");
+    this.#container = container;
+  }
+
+  async boot() {
+    const queusConfig = this.#getActivatedQueues();
+
+    for (const queueName of queusConfig) {
+      this.queues[queueName] = new Queue(queueName, this.#connection());
+      this.queuesEvents[queueName] = new QueueEvents(queueName, this.#connection());
+      await this.#container.get('logger').info(`Queue ${queueName} initialized`);
+    }
+
+    const workers = await this.#loadWorkersFromFolder(path.join(process.cwd(), "src", "workers"));
+
+    for (const wkr of workers) {
+      if(!wkr.queueName) {
+        this.#container.get('logger').warn(`Worker ${wkr.name} has no queueName defined, skipping...`);
+        continue;
+      }
+      if (!this.queues[wkr.queueName]) {
+        this.#container.get('logger').warn(`Queue ${wkr.queueName} not found for worker ${wkr.name}, skipping...`);
+        continue;
+      }
+      new BullWorker(
+        wkr.queueName,
+        async (job) => wkr.handle({ container: this.#container, job }),
+        this.#connection()
+      );
+      this.#container.get('logger').info(`Worker ${wkr.name} for queue ${wkr.queueName} initialized`);
+    }
+  }
+
+  async addJob(queueName, jobName, data, opts = {}, waitForCompletion = false) {
+    if (!this.queues[queueName]) throw new Error(`Queue ${queueName} not found`);
+    const job = await this.queues[queueName].add(jobName, data, opts);
+    if (!waitForCompletion) return job;
+
+    return new Promise((resolve, reject) => {
+      const queueEvent = this.queuesEvents[queueName];
+      job.waitUntilFinished(queueEvent, 1000 * 60).then((result) => {
+        resolve(result);
+      }).catch((err) => {
+        reject(err);
+      });
+    });
+  }
+
+  async #loadWorkersFromFolder(workersFolder) {
+    this.#createWorkersFolder(workersFolder);
+    const workers = (await fg('**/*.js', { cwd: workersFolder })).map((wkr) => {
+      const worker = require(path.join(workersFolder, wkr));
+      if(!(worker.prototype instanceof Worker)) {
+        this.#container.get('logger').warn(`File ${wkr} does not export a valid Worker class, skipping...`);
+        return null;
+      }
+      return new worker(wkr.replace('.js', ''));
+    }).filter(wkr => wkr !== null);
+    return workers;
+  }
+
+  #createWorkersFolder(workersFolder, overwrite = false) {
+    if (fs.existsSync(workersFolder) && !overwrite) return;
+    this.#container.get('logger').info(`Creating workers folder at ${workersFolder}`);
+    fs.mkdirSync(workersFolder);
+  }
+
+  #getActivatedQueues() {
+    const list = process.env.QUEUES || "";
+    return list.split(",").map(q => q.trim()).filter(q => q.length);
+  }
+
+  #connection() {
+    return {
+        connection: {
+          url: process.env.CACHE_URL || "redis://localhost:6379"
+        }
+    };
+  }
 }

package/src/services/cache/index.js

@@ -1,97 +1,97 @@
-const Service = require("../Service");
-const { createClient } = require("redis");
-
-module.exports = class Cache extends Service {
-  #container;
-  #client;
-  #useRedis;
-  #memoryCache;
-  #expirations;
-
-  constructor(container, url) {
-    super("cache");
-    this.#container = container;
-    // Check if URL is a valid Redis URL (starts with redis://)
-    // Empty string, 'memory', or 'in-memory' will use in-memory cache
-    this.#useRedis = !!url && url.startsWith('redis://');
-    
-    if (this.#useRedis) {
-      this.#client = createClient({ url });
-    } else {
-      // Use in-memory cache
-      this.#memoryCache = new Map();
-      this.#expirations = new Map();
-    }
-  }
-
-  async boot() {
-    if (this.#useRedis) {
-      await this.#client.connect();
-      this.#container.get('logger').info('Cache service using Redis');
-    } else {
-      this.#container.get('logger').info('Cache service using in-memory cache');
-    }
-  }
-
-  async set(key, value) {
-    if (this.#useRedis) {
-      return await this.#client.set(key, value);
-    } else {
-      this.#memoryCache.set(key, value);
-      return 'OK';
-    }
-  }
-
-  async get(key) {
-    if (this.#useRedis) {
-      return await this.#client.get(key);
-    } else {
-      // Check if the key has expired
-      if (this.#expirations.has(key)) {
-        const expireTime = this.#expirations.get(key);
-        if (Date.now() > expireTime) {
-          this.#memoryCache.delete(key);
-          this.#expirations.delete(key);
-          return null;
-        }
-      }
-      return this.#memoryCache.get(key) || null;
-    }
-  }
-
-  async del(key) {
-    if (this.#useRedis) {
-      return await this.#client.del(key);
-    } else {
-      this.#expirations.delete(key);
-      return this.#memoryCache.delete(key) ? 1 : 0;
-    }
-  }
-
-  async keys(pattern) {
-    if (this.#useRedis) {
-      return await this.#client.keys(pattern);
-    } else {
-      // Simple pattern matching for memory cache
-      const regex = new RegExp('^' + pattern.replace(/\*/g, '.*') + '$');
-      return Array.from(this.#memoryCache.keys()).filter(key => regex.test(key));
-    }
-  }
-
-  async expire(key, seconds) {
-    if (this.#useRedis) {
-      return await this.#client.expire(key, seconds);
-    } else {
-      if (this.#memoryCache.has(key)) {
-        const expireTime = Date.now() + (seconds * 1000);
-        this.#expirations.set(key, expireTime);
-        return 1;
-      }
-      return 0;
-    }
-  }
-
-  get client() {
-    return this.#useRedis ? this.#client : null;
-  }
+const Service = require("../Service");
+const { createClient } = require("redis");
+
+module.exports = class Cache extends Service {
+  #container;
+  #client;
+  #useRedis;
+  #memoryCache;
+  #expirations;
+
+  constructor(container, url) {
+    super("cache");
+    this.#container = container;
+    // Check if URL is a valid Redis URL (starts with redis://)
+    // Empty string, 'memory', or 'in-memory' will use in-memory cache
+    this.#useRedis = !!url && url.startsWith('redis://');
+    
+    if (this.#useRedis) {
+      this.#client = createClient({ url });
+    } else {
+      // Use in-memory cache
+      this.#memoryCache = new Map();
+      this.#expirations = new Map();
+    }
+  }
+
+  async boot() {
+    if (this.#useRedis) {
+      await this.#client.connect();
+      this.#container.get('logger').info('Cache service using Redis');
+    } else {
+      this.#container.get('logger').info('Cache service using in-memory cache');
+    }
+  }
+
+  async set(key, value) {
+    if (this.#useRedis) {
+      return await this.#client.set(key, value);
+    } else {
+      this.#memoryCache.set(key, value);
+      return 'OK';
+    }
+  }
+
+  async get(key) {
+    if (this.#useRedis) {
+      return await this.#client.get(key);
+    } else {
+      // Check if the key has expired
+      if (this.#expirations.has(key)) {
+        const expireTime = this.#expirations.get(key);
+        if (Date.now() > expireTime) {
+          this.#memoryCache.delete(key);
+          this.#expirations.delete(key);
+          return null;
+        }
+      }
+      return this.#memoryCache.get(key) || null;
+    }
+  }
+
+  async del(key) {
+    if (this.#useRedis) {
+      return await this.#client.del(key);
+    } else {
+      this.#expirations.delete(key);
+      return this.#memoryCache.delete(key) ? 1 : 0;
+    }
+  }
+
+  async keys(pattern) {
+    if (this.#useRedis) {
+      return await this.#client.keys(pattern);
+    } else {
+      // Simple pattern matching for memory cache
+      const regex = new RegExp('^' + pattern.replace(/\*/g, '.*') + '$');
+      return Array.from(this.#memoryCache.keys()).filter(key => regex.test(key));
+    }
+  }
+
+  async expire(key, seconds) {
+    if (this.#useRedis) {
+      return await this.#client.expire(key, seconds);
+    } else {
+      if (this.#memoryCache.has(key)) {
+        const expireTime = Date.now() + (seconds * 1000);
+        this.#expirations.set(key, expireTime);
+        return 1;
+      }
+      return 0;
+    }
+  }
+
+  get client() {
+    return this.#useRedis ? this.#client : null;
+  }
 }

package/src/services/database/index.js

@@ -1,128 +1,128 @@
-const { Sequelize, Op } = require("sequelize");
-const Service = require("../Service");
-const fg = require('fast-glob');
-const fs = require('fs');
-const path = require('path');
-const { Umzug, SequelizeStorage } = require('umzug')
-
-module.exports = class Database extends Service {
-  #container;
-  #databaseUrl;
-  sequelize
-  Op = Op;
-  Sequelize = Sequelize;
-  
-  models = {}
-
-  constructor(container, databaseUrl) {
-    super('database');
-    this.#container = container;
-    this.#databaseUrl = databaseUrl;
-  }
-  
-  async boot() {
-    this.#createModelsFolder();
-    const dialect = process.env.DATABASE_DIALECT || 'mariadb';
-    const options = {
-      dialect,
-      logging: (msg) => this.#container.get('logger').debug(msg),
-      operatorsAliases: 0,
-    };
-
-    // SQLite doesn't support connection pooling
-    if (dialect !== 'sqlite') {
-      options.pool = {
-        max: 40,
-        min: 0,
-        acquire: 30000,
-        idle: 10000
-      };
-    }
-
-    // For SQLite, handle storage option
-    if (dialect === 'sqlite') {
-      // If using sqlite dialect, the database URL should be a file path
-      // or ':memory:' for in-memory database
-      this.sequelize = new Sequelize({
-        dialect: 'sqlite',
-        storage: this.#databaseUrl.replace('sqlite://', '') || ':memory:',
-        logging: (msg) => this.#container.get('logger').debug(msg),
-        operatorsAliases: 0,
-      });
-    } else {
-      this.sequelize = new Sequelize(this.#databaseUrl, options);
-    }
-
-    await this.sequelize.authenticate();
-
-    await this.#loadModels();
-    
-    this.#container.get('logger').debug(`Database modesl loaded: ${Object.keys(this.models).join(", ")}`);
-  }
-
-  async #loadModels() {
-    const models = await fg('*.js', { cwd: path.join(process.cwd(), "src", "models") });
-    for (const model of models) {
-      const modelPath = path.join(process.cwd(), "src", "models", model);
-      const modelFunc = require(modelPath);
-      if (typeof modelFunc !== 'function') {
-        this.#container.get('logger').error(`Model ${model} is not a function`);
-        continue;
-      }
-      const modelInstance = modelFunc({sequelize: this.sequelize, container: this.#container, Sequelize});
-      this.models[model.replace('.js', '')] = modelInstance;
-    }
-
-    for (const model of Object.values(this.models)) {
-      if (model.associate) {
-        model.associate(this.models);
-      }
-    }
-  }
-
-  async loadModel(model) {
-    if (typeof model !== 'function') {
-      this.#container.get('logger').error(`Model ${model} is not a function`);
-      throw new Error(`Model ${model} is not a function`);
-    }
-
-    const modelInstance = model({sequelize: this.sequelize, container: this.#container, Sequelize});
-    if(this.models[modelInstance.name]) {
-      this.#container.get('logger').warn(`Model ${modelInstance.name} is already loaded, cannot load it again`);
-      throw new Error(`Model ${modelInstance.name} is already loaded, cannot load it again`);
-    }
-    this.models[modelInstance.name] = modelInstance;
-
-    if (modelInstance.associate) {
-      modelInstance.associate(this.models);
-    }
-  }
-
-  async runMigrations(migrationsPath = 'src/models/migrations') {
-    const umzug = new Umzug({
-      migrations: { glob: `${migrationsPath}/*.js` },
-      context: {
-        queryInterface: this.#container.get('database').sequelize.getQueryInterface(),
-        container: this.#container
-      },
-      storage: new SequelizeStorage({ sequelize: this.#container.get('database').sequelize }),
-      logger: console
-    })
-
-    return await umzug.up()
-  }
-
-  #createModelsFolder() {
-    const path = 'src/models';
-    if (!fs.existsSync(path)) fs.mkdirSync(path);
-  }
-
-  sync() {
-    return this.sequelize.sync();
-  }
-
-  forceSync() {
-    return this.sequelize.sync({ force: true });
-  }
-
+const { Sequelize, Op } = require("sequelize");
+const Service = require("../Service");
+const fg = require('fast-glob');
+const fs = require('fs');
+const path = require('path');
+const { Umzug, SequelizeStorage } = require('umzug')
+
+module.exports = class Database extends Service {
+  #container;
+  #databaseUrl;
+  sequelize
+  Op = Op;
+  Sequelize = Sequelize;
+  
+  models = {}
+
+  constructor(container, databaseUrl) {
+    super('database');
+    this.#container = container;
+    this.#databaseUrl = databaseUrl;
+  }
+  
+  async boot() {
+    this.#createModelsFolder();
+    const dialect = process.env.DATABASE_DIALECT || 'mariadb';
+    const options = {
+      dialect,
+      logging: (msg) => this.#container.get('logger').debug(msg),
+      operatorsAliases: 0,
+    };
+
+    // SQLite doesn't support connection pooling
+    if (dialect !== 'sqlite') {
+      options.pool = {
+        max: 40,
+        min: 0,
+        acquire: 30000,
+        idle: 10000
+      };
+    }
+
+    // For SQLite, handle storage option
+    if (dialect === 'sqlite') {
+      // If using sqlite dialect, the database URL should be a file path
+      // or ':memory:' for in-memory database
+      this.sequelize = new Sequelize({
+        dialect: 'sqlite',
+        storage: this.#databaseUrl.replace('sqlite://', '') || ':memory:',
+        logging: (msg) => this.#container.get('logger').debug(msg),
+        operatorsAliases: 0,
+      });
+    } else {
+      this.sequelize = new Sequelize(this.#databaseUrl, options);
+    }
+
+    await this.sequelize.authenticate();
+
+    await this.#loadModels();
+    
+    this.#container.get('logger').debug(`Database modesl loaded: ${Object.keys(this.models).join(", ")}`);
+  }
+
+  async #loadModels() {
+    const models = await fg('*.js', { cwd: path.join(process.cwd(), "src", "models") });
+    for (const model of models) {
+      const modelPath = path.join(process.cwd(), "src", "models", model);
+      const modelFunc = require(modelPath);
+      if (typeof modelFunc !== 'function') {
+        this.#container.get('logger').error(`Model ${model} is not a function`);
+        continue;
+      }
+      const modelInstance = modelFunc({sequelize: this.sequelize, container: this.#container, Sequelize});
+      this.models[model.replace('.js', '')] = modelInstance;
+    }
+
+    for (const model of Object.values(this.models)) {
+      if (model.associate) {
+        model.associate(this.models);
+      }
+    }
+  }
+
+  async loadModel(model) {
+    if (typeof model !== 'function') {
+      this.#container.get('logger').error(`Model ${model} is not a function`);
+      throw new Error(`Model ${model} is not a function`);
+    }
+
+    const modelInstance = model({sequelize: this.sequelize, container: this.#container, Sequelize});
+    if(this.models[modelInstance.name]) {
+      this.#container.get('logger').warn(`Model ${modelInstance.name} is already loaded, cannot load it again`);
+      throw new Error(`Model ${modelInstance.name} is already loaded, cannot load it again`);
+    }
+    this.models[modelInstance.name] = modelInstance;
+
+    if (modelInstance.associate) {
+      modelInstance.associate(this.models);
+    }
+  }
+
+  async runMigrations(migrationsPath = 'src/models/migrations') {
+    const umzug = new Umzug({
+      migrations: { glob: `${migrationsPath}/*.js` },
+      context: {
+        queryInterface: this.#container.get('database').sequelize.getQueryInterface(),
+        container: this.#container
+      },
+      storage: new SequelizeStorage({ sequelize: this.#container.get('database').sequelize }),
+      logger: console
+    })
+
+    return await umzug.up()
+  }
+
+  #createModelsFolder() {
+    const path = 'src/models';
+    if (!fs.existsSync(path)) fs.mkdirSync(path);
+  }
+
+  sync() {
+    return this.sequelize.sync();
+  }
+
+  forceSync() {
+    return this.sequelize.sync({ force: true });
+  }
+
 }

package/src/services/events/Event.js

@@ -1,7 +1,7 @@
-module.exports = class Event {
-  name;
-  
-  constructor(name) {
-    this.name = name;
-  }
+module.exports = class Event {
+  name;
+  
+  constructor(name) {
+    this.name = name;
+  }
 }