zyket 1.0.30 → 1.0.32

package/index.js

@@ -7,6 +7,9 @@ const { Handler, Guard } = require("./src/services/socketio");
 const Schedule = require("./src/services/scheduler/Schedule");
 const Event = require("./src/services/events/Event");
 const Worker = require("./src/services/bullmq/Worker");
+const BullBoardExtension = require("./src/extensions/bullboard");
+const Extension = require("./src/extensions/Extension");
+const InteractiveStorageExtension = require("./src/extensions/interactive-storage");
 
 
 module.exports = {
@@ -16,5 +19,7 @@ module.exports = {
   Handler, Guard,
   Schedule, Event,
   Worker,
-  EnvManager
+  EnvManager,
+  BullBoardExtension, InteractiveStorageExtension,
+  Extension
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zyket",
-  "version": "1.0.30",
+  "version": "1.0.32",
   "main": "index.js",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
@@ -13,6 +13,7 @@
   "license": "ISC",
   "description": "",
   "dependencies": {
+    "@bull-board/express": "^6.14.2",
     "bullmq": "^5.63.0",
     "colors": "^1.4.0",
     "cors": "^2.8.5",
@@ -21,6 +22,7 @@
     "fast-glob": "^3.3.3",
     "mariadb": "^3.4.5",
     "minio": "^8.0.6",
+    "multer": "^2.0.2",
     "node-cron": "^4.2.1",
     "node-dependency-injection": "^3.2.4",
     "prompts": "^2.4.2",

package/src/extensions/Extension.js

@@ -0,0 +1,11 @@
+module.exports = class Extension {
+  name;
+
+  constructor(_Name) {
+    this.name = _Name;
+  }
+
+  load(container) {
+    throw new Error("Load method not implemented");
+  }
+}

package/src/extensions/bullboard/index.js

@@ -0,0 +1,28 @@
+const Extension = require('../Extension');
+const { createBullBoard } = require('@bull-board/api')
+const { BullMQAdapter } = require('@bull-board/api/bullMQAdapter')
+const { ExpressAdapter } = require('@bull-board/express')
+
+module.exports = class BullBoardExtension  extends Extension {
+  path;
+
+  constructor({ path = '/bullboard' } = {}) {
+    super("BullBoardExtension");
+    this.path = path || '/bullboard';
+  }
+
+  load(container) {
+    if (!container.get('bullmq')) return container.get('logger').warn('BullBoardExtension: bullmq service not found, skipping BullBoard setup');
+    const bull = container.get('bullmq')
+    const serverAdapter = new ExpressAdapter()
+    serverAdapter.setBasePath(this.path)
+
+    createBullBoard({
+      queues: Object.values(bull.queues).map(queue => new BullMQAdapter(queue)),
+      serverAdapter
+    })
+
+    const app = container.get('express').app()
+    app.use(this.path, serverAdapter.getRouter())
+  }
+}

package/src/extensions/interactive-storage/index.js

@@ -0,0 +1,161 @@
+const Extension = require('../Extension');
+const multer = require('multer');
+
+// Import route handlers
+const uploadHandler = require('./routes/upload');
+const browseHandler = require('./routes/browse');
+const downloadHandler = require('./routes/download');
+const infoHandler = require('./routes/info');
+const deleteHandler = require('./routes/delete');
+const createFolderHandler = require('./routes/create-folder');
+const deleteFolderHandler = require('./routes/delete-folder');
+
+module.exports = class InteractiveStorageExtension extends Extension {
+  path;
+  bucketName;
+  maxFileSize;
+  middlewares;
+
+  constructor({ path = '/storage', bucketName = 'dropbox', maxFileSize = 100 * 1024 * 1024, middlewares = [] } = {}) {
+    super("InteractiveStorageExtension");
+    this.path = path || '/storage';
+    this.bucketName = bucketName;
+    this.maxFileSize = maxFileSize; // Default 100MB
+    this.middlewares = middlewares || [];
+  }
+
+  load(container) {
+    if (!container.get('s3')) return container.get('logger').warn('InteractiveStorageExtension: s3 service not found, skipping InteractiveStorage setup');
+    if (!container.get('express')) return container.get('logger').warn('InteractiveStorageExtension: express service not found, skipping InteractiveStorage setup');
+
+    const app = container.get('express').app();
+    const s3 = container.get('s3');
+    const logger = container.get('logger');
+
+    // Ensure bucket exists
+    this.#ensureBucket(s3, logger);
+
+    // Configure multer for file uploads (memory storage)
+    const upload = multer({
+      storage: multer.memoryStorage(),
+      limits: {
+        fileSize: this.maxFileSize
+      }
+    });
+
+    // Bind helper methods
+    const normalizePath = this.#normalizePath.bind(this);
+    const listFiles = this.#listFiles.bind(this);
+    const listFilesAndFolders = this.#listFilesAndFolders.bind(this);
+    const getFileStat = this.#getFileStat.bind(this);
+
+    // Register routes
+    app.post(`${this.path}/upload`, upload.array('files'), uploadHandler(s3, this.bucketName, logger, normalizePath));
+    app.get(`${this.path}/browse`, browseHandler(s3, this.bucketName, logger, normalizePath, listFilesAndFolders));
+    app.get(`${this.path}/download/:fileName`, downloadHandler(s3, this.bucketName, logger, getFileStat));
+    app.get(`${this.path}/info/:fileName`, infoHandler(s3, this.bucketName, logger, getFileStat));
+    app.delete(`${this.path}/delete`, deleteHandler(s3, this.bucketName, logger));
+    app.post(`${this.path}/create-folder`, createFolderHandler(s3, this.bucketName, logger, normalizePath));
+    app.delete(`${this.path}/delete-folder`, deleteFolderHandler(s3, this.bucketName, logger, normalizePath, listFiles));
+
+    logger.info(`InteractiveStorage extension loaded at ${this.path}`);
+  }
+
+  async #ensureBucket(s3, logger) {
+    try {
+      const buckets = await s3.listBuckets();
+      const bucketExists = buckets.some(bucket => bucket.name === this.bucketName);
+      
+      if (!bucketExists) {
+        await s3.createBucket(this.bucketName);
+        logger.info(`Created S3 bucket: ${this.bucketName}`);
+      }
+    } catch (error) {
+      logger.error(`Error ensuring bucket exists: ${error.message}`);
+    }
+  }
+
+  async #listFiles(s3, prefix = '') {
+    return new Promise((resolve, reject) => {
+      const files = [];
+      const stream = s3.client.listObjectsV2(this.bucketName, prefix, true);
+      
+      stream.on('data', (obj) => {
+        files.push({
+          name: obj.name,
+          size: obj.size,
+          lastModified: obj.lastModified,
+          etag: obj.etag
+        });
+      });
+      
+      stream.on('end', () => resolve(files));
+      stream.on('error', reject);
+    });
+  }
+
+  async #listFilesAndFolders(s3, prefix = '') {
+    return new Promise((resolve, reject) => {
+      const items = [];
+      const folders = new Set();
+      
+      const stream = s3.client.listObjectsV2(this.bucketName, prefix, false);
+      
+      stream.on('data', (obj) => {
+        if (obj.prefix) {
+          // This is a folder
+          const folderName = obj.prefix.slice(prefix.length).replace(/\/$/, '');
+          if (folderName && !folderName.includes('/')) {
+            folders.add(folderName);
+          }
+        } else if (obj.name) {
+          // This is a file
+          const fileName = obj.name.slice(prefix.length);
+          
+          // Skip folder markers and files in subfolders
+          if (fileName === '.folder' || fileName.includes('/')) {
+            return;
+          }
+          
+          items.push({
+            type: 'file',
+            name: fileName,
+            fullPath: obj.name,
+            size: obj.size,
+            lastModified: obj.lastModified,
+            etag: obj.etag
+          });
+        }
+      });
+      
+      stream.on('end', () => {
+        // Add folders to items
+        folders.forEach(folder => {
+          items.unshift({
+            type: 'folder',
+            name: folder,
+            fullPath: prefix + folder
+          });
+        });
+        
+        resolve(items);
+      });
+      
+      stream.on('error', reject);
+    });
+  }
+
+  #normalizePath(path) {
+    // Remove leading/trailing slashes and normalize
+    return path.replace(/^\/+|\/+$/g, '').replace(/\/+/g, '/');
+  }
+
+  async #getFileStat(s3, fileName) {
+    return new Promise((resolve, reject) => {
+      s3.client.statObject(this.bucketName, fileName, (err, stat) => {
+        if (err) return reject(err);
+        resolve(stat);
+      });
+    });
+  }
+}

package/src/extensions/interactive-storage/routes/browse.js

@@ -0,0 +1,18 @@
+module.exports = (s3, bucketName, logger, normalizePath, listFilesAndFolders) => async (req, res) => {
+  try {
+    const folder = req.query.folder || '';
+    const prefix = folder ? normalizePath(folder) + '/' : '';
+    
+    const items = await listFilesAndFolders(s3, prefix);
+    
+    res.json({
+      success: true,
+      bucket: bucketName,
+      currentPath: folder,
+      items: items
+    });
+  } catch (error) {
+    logger.error(`Error browsing files: ${error.message}`);
+    res.status(500).json({ success: false, message: error.message });
+  }
+};

package/src/extensions/interactive-storage/routes/create-folder.js

@@ -0,0 +1,26 @@
+module.exports = (s3, bucketName, logger, normalizePath) => async (req, res) => {
+  try {
+    const { folderPath } = req.body;
+    
+    if (!folderPath) {
+      return res.status(400).json({ success: false, message: 'Folder path is required' });
+    }
+
+    const normalizedPath = normalizePath(folderPath);
+    const folderMarker = `${normalizedPath}/.folder`;
+    
+    // Create an empty marker file to represent the folder
+    await s3.saveFile(bucketName, folderMarker, Buffer.from(''), 'text/plain');
+    
+    logger.info(`Created folder: ${normalizedPath}`);
+    
+    res.json({
+      success: true,
+      message: 'Folder created successfully',
+      folderPath: normalizedPath
+    });
+  } catch (error) {
+    logger.error(`Error creating folder: ${error.message}`);
+    res.status(500).json({ success: false, message: error.message });
+  }
+};

package/src/extensions/interactive-storage/routes/delete-folder.js

@@ -0,0 +1,44 @@
+module.exports = (s3, bucketName, logger, normalizePath, listFiles) => async (req, res) => {
+  try {
+    const { folderPath } = req.body;
+    
+    if (!folderPath) {
+      return res.status(400).json({ success: false, message: 'Folder path is required' });
+    }
+
+    const normalizedPath = normalizePath(folderPath);
+    const prefix = `${normalizedPath}/`;
+    
+    // List all files in the folder
+    const files = await listFiles(s3, prefix);
+    
+    if (files.length === 0) {
+      return res.json({
+        success: true,
+        message: 'Folder is empty or does not exist',
+        deletedCount: 0
+      });
+    }
+
+    // Delete all files
+    const deletePromises = files.map(file => 
+      s3.removeFile(bucketName, file.name).catch(err => ({ error: err.message, fileName: file.name }))
+    );
+
+    const results = await Promise.all(deletePromises);
+    const errors = results.filter(r => r && r.error);
+    const successCount = results.length - errors.length;
+
+    logger.info(`Deleted folder ${normalizedPath} with ${successCount} files`);
+
+    res.json({
+      success: errors.length === 0,
+      message: `Deleted folder and ${successCount} files`,
+      deletedCount: successCount,
+      errors: errors.length > 0 ? errors : undefined
+    });
+  } catch (error) {
+    logger.error(`Error deleting folder: ${error.message}`);
+    res.status(500).json({ success: false, message: error.message });
+  }
+};

package/src/extensions/interactive-storage/routes/delete.js

@@ -0,0 +1,32 @@
+module.exports = (s3, bucketName, logger) => async (req, res) => {
+  try {
+    const { fileName, fileNames } = req.body;
+    
+    // Support both single file and multiple files
+    const filesToDelete = fileNames || (fileName ? [fileName] : []);
+    
+    if (!Array.isArray(filesToDelete) || filesToDelete.length === 0) {
+      return res.status(400).json({ success: false, message: 'fileName or fileNames array is required' });
+    }
+
+    const deletePromises = filesToDelete.map(file => 
+      s3.removeFile(bucketName, file).catch(err => ({ error: err.message, fileName: file }))
+    );
+
+    const results = await Promise.all(deletePromises);
+    const errors = results.filter(r => r && r.error);
+    const successCount = results.length - errors.length;
+
+    logger.info(`Deleted ${successCount} file(s) from S3 dropbox`);
+
+    res.json({
+      success: errors.length === 0,
+      message: `Deleted ${successCount} of ${filesToDelete.length} file(s)`,
+      deletedCount: successCount,
+      errors: errors.length > 0 ? errors : undefined
+    });
+  } catch (error) {
+    logger.error(`Error deleting files: ${error.message}`);
+    res.status(500).json({ success: false, message: error.message });
+  }
+};

package/src/extensions/interactive-storage/routes/download.js

@@ -0,0 +1,30 @@
+module.exports = (s3, bucketName, logger, getFileStat) => async (req, res) => {
+  try {
+    const { fileName } = req.params;
+    
+    // Get file info first
+    const stat = await getFileStat(s3, fileName);
+    
+    // Set response headers
+    res.setHeader('Content-Type', stat.metaData?.['content-type'] || 'application/octet-stream');
+    res.setHeader('Content-Disposition', `attachment; filename="${fileName}"`);
+    res.setHeader('Content-Length', stat.size);
+
+    // Stream the file
+    await new Promise((resolve, reject) => {
+      s3.client.getObject(bucketName, fileName, (err, stream) => {
+        if (err) return reject(err);
+        stream.pipe(res);
+        stream.on('end', resolve);
+        stream.on('error', reject);
+      });
+    });
+
+    logger.info(`Downloaded file: ${fileName}`);
+  } catch (error) {
+    logger.error(`Error downloading file: ${error.message}`);
+    if (!res.headersSent) {
+      res.status(404).json({ success: false, message: 'File not found' });
+    }
+  }
+};

package/src/extensions/interactive-storage/routes/info.js

@@ -0,0 +1,20 @@
+module.exports = (s3, bucketName, logger, getFileStat) => async (req, res) => {
+  try {
+    const { fileName } = req.params;
+    const stat = await getFileStat(s3, fileName);
+    
+    res.json({
+      success: true,
+      file: {
+        name: fileName,
+        size: stat.size,
+        lastModified: stat.lastModified,
+        etag: stat.etag,
+        contentType: stat.metaData?.['content-type']
+      }
+    });
+  } catch (error) {
+    logger.error(`Error getting file info: ${error.message}`);
+    res.status(404).json({ success: false, message: 'File not found' });
+  }
+};

package/src/extensions/interactive-storage/routes/upload.js

@@ -0,0 +1,34 @@
+module.exports = (s3, bucketName, logger, normalizePath) => async (req, res) => {
+  try {
+    if (!req.files || req.files.length === 0) {
+      return res.status(400).json({ success: false, message: 'No files uploaded' });
+    }
+
+    const folder = req.body.folder || '';
+    const folderPath = folder ? normalizePath(folder) + '/' : '';
+
+    const uploadPromises = req.files.map(async (file) => {
+      const fileName = `${folderPath}${Date.now()}-${file.originalname}`;
+      await s3.saveFile(bucketName, fileName, file.buffer, file.mimetype);
+      return {
+        originalName: file.originalname,
+        fileName: fileName,
+        folder: folder,
+        size: file.size,
+        mimeType: file.mimetype
+      };
+    });
+
+    const uploadedFiles = await Promise.all(uploadPromises);
+    logger.info(`Uploaded ${uploadedFiles.length} file(s) to S3 dropbox`);
+
+    res.json({
+      success: true,
+      message: 'Files uploaded successfully',
+      files: uploadedFiles
+    });
+  } catch (error) {
+    logger.error(`Error uploading files: ${error.message}`);
+    res.status(500).json({ success: false, message: error.message });
+  }
+};

package/src/kernel/index.js

@@ -3,18 +3,22 @@ const EnvManager = require("../utils/EnvManager");
 const fs = require("fs");
 const path = require("path");
 const HTTPServer = require("./HTTPServer");
+const Extension = require("../extensions/Extension");
 
 module.exports = class Kernel {
   container;
   #services;
   #onSocketConnection;
   #httpServer;
+  #extensions = [];
 
   constructor({ 
-    services = []
+    services = [],
+    extensions = [],
   } = { }) {
     this.container = new ContainerBuilder();
     this.#services = services;
+    this.#extensions = extensions;
 
     // create src folder if not exists
     if (!fs.existsSync(path.join(process.cwd(), "src"))) {
@@ -41,6 +45,16 @@ module.exports = class Kernel {
       });
     }
 
+    for (const extension of this.#extensions) {
+      if (!(extension instanceof Extension)) {
+        throw new Error(`Extension ${extension.name} is not an instance of Extension class`);
+      }
+      this.container.get('logger').debug(`Loading extension ${extension.name}`);
+      await extension.load(this.container);
+    }
+
+
+
     return this;
   }
 
@@ -58,4 +72,8 @@ module.exports = class Kernel {
 
     this.container.compile();
   }
+
+  async #loadExtensions() {
+    // Load extensions if any
+  }
 }

package/src/services/database/index.js

@@ -57,6 +57,24 @@ module.exports = class Database extends Service {
     }
   }
 
+  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);
+    }
+  }
+
   #createModelsFolder() {
     const path = 'src/models';
     if (!fs.existsSync(path)) fs.mkdirSync(path);