zyket 1.0.31 → 1.0.33

package/index.js

@@ -9,6 +9,7 @@ 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 = {
@@ -19,5 +20,6 @@ module.exports = {
   Schedule, Event,
   Worker,
   EnvManager,
-  BullBoardExtension, Extension
+  BullBoardExtension, InteractiveStorageExtension,
+  Extension
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zyket",
-  "version": "1.0.31",
+  "version": "1.0.33",
   "main": "index.js",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
@@ -22,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/interactive-storage/index.js

@@ -0,0 +1,163 @@
+const Extension = require('../Extension');
+
+// Import route classes
+const UploadRoute = require('./routes/upload');
+const BrowseRoute = require('./routes/browse');
+const DownloadRoute = require('./routes/download');
+const InfoRoute = require('./routes/info');
+const DeleteRoute = require('./routes/delete');
+const CreateFolderRoute = require('./routes/create-folder');
+const DeleteFolderRoute = require('./routes/delete-folder');
+const MulterMiddleware = require('./middlewares/MulterMiddleware');
+
+module.exports = class InteractiveStorageExtension extends Extension {
+  static bucketName;
+  path;
+  maxFileSize;
+  middlewares;
+
+  constructor({ path = '/storage', bucketName = 'dropbox', maxFileSize = 100 * 1024 * 1024, middlewares = [] } = {}) {
+    super("InteractiveStorageExtension");
+    this.path = path || '/storage';
+    InteractiveStorageExtension.bucketName = bucketName;
+    this.maxFileSize = maxFileSize;
+    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 express = container.get('express');
+    const s3 = container.get('s3');
+    const logger = container.get('logger');
+
+    // Ensure bucket exists
+    this.#ensureBucket(s3, logger);
+
+    // 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);
+
+    // Create route instances
+    const routes = [
+      new UploadRoute(`${this.path}/upload`, s3, InteractiveStorageExtension.bucketName, normalizePath),
+      new BrowseRoute(`${this.path}/browse`, s3, InteractiveStorageExtension.bucketName, normalizePath, listFilesAndFolders),
+      new DownloadRoute(`${this.path}/download/:fileName`, s3, InteractiveStorageExtension.bucketName, getFileStat),
+      new InfoRoute(`${this.path}/info/:fileName`, s3, InteractiveStorageExtension.bucketName, getFileStat),
+      new DeleteRoute(`${this.path}/delete`, s3, InteractiveStorageExtension.bucketName),
+      new CreateFolderRoute(`${this.path}/create-folder`, s3, InteractiveStorageExtension.bucketName, normalizePath),
+      new DeleteFolderRoute(`${this.path}/delete-folder`, s3, InteractiveStorageExtension.bucketName, normalizePath, listFiles)
+    ];
+
+    // Add multer middleware to upload route
+    routes[0].middlewares = {
+      post: [new MulterMiddleware(this.maxFileSize)]
+    };
+
+    // Register routes using the express service pattern
+    express.registerRoutes(routes);
+
+    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 === InteractiveStorageExtension.bucketName);
+      
+      if (!bucketExists) {
+        await s3.createBucket(InteractiveStorageExtension.bucketName);
+        logger.info(`Created S3 bucket: ${InteractiveStorageExtension.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(InteractiveStorageExtension.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(InteractiveStorageExtension.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(InteractiveStorageExtension.bucketName, fileName, (err, stat) => {
+        if (err) return reject(err);
+        resolve(stat);
+      });
+    });
+  }
+}

package/src/extensions/interactive-storage/middlewares/MulterMiddleware.js

@@ -0,0 +1,31 @@
+const { Middleware } = require('../../../services/express');
+const multer = require('multer');
+
+module.exports = class MulterMiddleware extends Middleware {
+  upload;
+
+  constructor(maxFileSize = 100 * 1024 * 1024) {
+    super();
+    this.upload = multer({
+      storage: multer.memoryStorage(),
+      limits: {
+        fileSize: maxFileSize
+      }
+    });
+  }
+
+  async handle({ container, request, response, next }) {
+    const uploadMiddleware = this.upload.array('files');
+    
+    return new Promise((resolve, reject) => {
+      uploadMiddleware(request, response, (err) => {
+        if (err) {
+          container.get('logger').error(`Multer error: ${err.message}`);
+          return reject(err);
+        }
+        next();
+        resolve();
+      });
+    });
+  }
+};

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

@@ -0,0 +1,31 @@
+const { Route } = require('../../../services/express');
+
+module.exports = class BrowseRoute extends Route {
+  s3;
+  bucketName;
+  normalizePath;
+  listFilesAndFolders;
+
+  constructor(path, s3, bucketName, normalizePath, listFilesAndFolders) {
+    super(path);
+    this.s3 = s3;
+    this.bucketName = bucketName;
+    this.normalizePath = normalizePath;
+    this.listFilesAndFolders = listFilesAndFolders;
+  }
+
+  async get({ container, request }) {
+    const logger = container.get('logger');
+    const folder = request.query.folder || '';
+    const prefix = folder ? this.normalizePath(folder) + '/' : '';
+    
+    const items = await this.listFilesAndFolders(this.s3, prefix);
+    
+    return {
+      success: true,
+      bucket: this.bucketName,
+      currentPath: folder,
+      items: items
+    };
+  }
+};

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

@@ -0,0 +1,37 @@
+const { Route } = require('../../../services/express');
+
+module.exports = class CreateFolderRoute extends Route {
+  s3;
+  bucketName;
+  normalizePath;
+
+  constructor(path, s3, bucketName, normalizePath) {
+    super(path);
+    this.s3 = s3;
+    this.bucketName = bucketName;
+    this.normalizePath = normalizePath;
+  }
+
+  async post({ container, request }) {
+    const logger = container.get('logger');
+    const { folderPath } = request.body;
+    
+    if (!folderPath) {
+      return { success: false, message: 'Folder path is required', status: 400 };
+    }
+
+    const normalizedPath = this.normalizePath(folderPath);
+    const folderMarker = `${normalizedPath}/.folder`;
+    
+    // Create an empty marker file to represent the folder
+    await this.s3.saveFile(this.bucketName, folderMarker, Buffer.from(''), 'text/plain');
+    
+    logger.info(`Created folder: ${normalizedPath}`);
+    
+    return {
+      success: true,
+      message: 'Folder created successfully',
+      folderPath: normalizedPath
+    };
+  }
+};

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

@@ -0,0 +1,57 @@
+const { Route } = require('../../../services/express');
+
+module.exports = class DeleteFolderRoute extends Route {
+  s3;
+  bucketName;
+  normalizePath;
+  listFiles;
+
+  constructor(path, s3, bucketName, normalizePath, listFiles) {
+    super(path);
+    this.s3 = s3;
+    this.bucketName = bucketName;
+    this.normalizePath = normalizePath;
+    this.listFiles = listFiles;
+  }
+
+  async delete({ container, request }) {
+    const logger = container.get('logger');
+    const { folderPath } = request.body;
+    
+    if (!folderPath) {
+      return { success: false, message: 'Folder path is required', status: 400 };
+    }
+
+    const normalizedPath = this.normalizePath(folderPath);
+    const prefix = `${normalizedPath}/`;
+    
+    // List all files in the folder
+    const files = await this.listFiles(this.s3, prefix);
+    
+    if (files.length === 0) {
+      return {
+        success: true,
+        message: 'Folder is empty or does not exist',
+        deletedCount: 0
+      };
+    }
+
+    // Delete all files
+    const deletePromises = files.map(file => 
+      this.s3.removeFile(this.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`);
+
+    return {
+      success: errors.length === 0,
+      message: `Deleted folder and ${successCount} files`,
+      deletedCount: successCount,
+      errors: errors.length > 0 ? errors : undefined
+    };
+  }
+};

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

@@ -0,0 +1,41 @@
+const { Route } = require('../../../services/express');
+
+module.exports = class DeleteRoute extends Route {
+  s3;
+  bucketName;
+
+  constructor(path, s3, bucketName) {
+    super(path);
+    this.s3 = s3;
+    this.bucketName = bucketName;
+  }
+
+  async delete({ container, request }) {
+    const logger = container.get('logger');
+    const { fileName, fileNames } = request.body;
+    
+    // Support both single file and multiple files
+    const filesToDelete = fileNames || (fileName ? [fileName] : []);
+    
+    if (!Array.isArray(filesToDelete) || filesToDelete.length === 0) {
+      return { success: false, message: 'fileName or fileNames array is required', status: 400 };
+    }
+
+    const deletePromises = filesToDelete.map(file => 
+      this.s3.removeFile(this.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`);
+
+    return {
+      success: errors.length === 0,
+      message: `Deleted ${successCount} of ${filesToDelete.length} file(s)`,
+      deletedCount: successCount,
+      errors: errors.length > 0 ? errors : undefined
+    };
+  }
+};

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

@@ -0,0 +1,47 @@
+const { Route } = require('../../../services/express');
+
+module.exports = class DownloadRoute extends Route {
+  s3;
+  bucketName;
+  getFileStat;
+
+  constructor(path, s3, bucketName, getFileStat) {
+    super(path);
+    this.s3 = s3;
+    this.bucketName = bucketName;
+    this.getFileStat = getFileStat;
+  }
+
+  async get({ container, request, response }) {
+    const logger = container.get('logger');
+    const { fileName } = request.params;
+    
+    try {
+      // Get file info first
+      const stat = await this.getFileStat(this.s3, fileName);
+      
+      // Set response headers
+      response.setHeader('Content-Type', stat.metaData?.['content-type'] || 'application/octet-stream');
+      response.setHeader('Content-Disposition', `attachment; filename="${fileName}"`);
+      response.setHeader('Content-Length', stat.size);
+
+      // Stream the file
+      await new Promise((resolve, reject) => {
+        this.s3.client.getObject(this.bucketName, fileName, (err, stream) => {
+          if (err) return reject(err);
+          stream.pipe(response);
+          stream.on('end', resolve);
+          stream.on('error', reject);
+        });
+      });
+
+      logger.info(`Downloaded file: ${fileName}`);
+      
+      // Return null to indicate response was handled manually
+      return null;
+    } catch (error) {
+      logger.error(`Error downloading file: ${error.message}`);
+      return { success: false, message: 'File not found', status: 404 };
+    }
+  }
+};

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

@@ -0,0 +1,37 @@
+const { Route } = require('../../../services/express');
+
+module.exports = class InfoRoute extends Route {
+  s3;
+  bucketName;
+  getFileStat;
+
+  constructor(path, s3, bucketName, getFileStat) {
+    super(path);
+    this.s3 = s3;
+    this.bucketName = bucketName;
+    this.getFileStat = getFileStat;
+  }
+
+  async get({ container, request }) {
+    const logger = container.get('logger');
+    
+    try {
+      const { fileName } = request.params;
+      const stat = await this.getFileStat(this.s3, fileName);
+      
+      return {
+        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}`);
+      return { success: false, message: 'File not found', status: 404 };
+    }
+  }
+};

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

@@ -0,0 +1,46 @@
+const { Route } = require('../../../services/express');
+
+module.exports = class UploadRoute extends Route {
+  s3;
+  bucketName;
+  normalizePath;
+
+  constructor(path, s3, bucketName, normalizePath) {
+    super(path);
+    this.s3 = s3;
+    this.bucketName = bucketName;
+    this.normalizePath = normalizePath;
+  }
+
+  async post({ container, request }) {
+    const logger = container.get('logger');
+    
+    if (!request.files || request.files.length === 0) {
+      return { success: false, message: 'No files uploaded', status: 400 };
+    }
+
+    const folder = request.body.folder || '';
+    const folderPath = folder ? this.normalizePath(folder) + '/' : '';
+
+    const uploadPromises = request.files.map(async (file) => {
+      const fileName = `${folderPath}${Date.now()}-${file.originalname}`;
+      await this.s3.saveFile(this.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`);
+
+    return {
+      success: true,
+      message: 'Files uploaded successfully',
+      files: uploadedFiles
+    };
+  }
+};

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);

package/src/services/express/Express.js

@@ -94,11 +94,57 @@ module.exports = class Express extends Service {
         }
     });
 
+    // Attach Express to HTTP server - this allows dynamic route registration
+    this.#httpServer.removeAllListeners("request");
     this.#httpServer.on("request", this.#app);
 
     this.#container.get('logger').info(`Express is running on http://localhost:${httpServer.address().port}`);
   }
 
+  async registerRoutes(routes) {
+    const methods = ['post', 'get', 'put', 'delete']
+    for (const route of routes) {
+      for (const methodName of methods) {
+        const method = route[methodName];
+        if(!method) continue;
+        this.#container.get('logger').debug(`Registering route: [${methodName}] ${route.path}`);
+        const middlewares = route?.middlewares?.[methodName] || [];
+        for (const mw of middlewares) {
+          if (!(mw instanceof Middleware)) {
+            throw new Error(`Middleware for route ${route.path} is not an instance of Middleware`);
+          }
+        }
+        this.#app[methodName](
+          route.path, 
+          ...middlewares.map(mw => async (req, res, next) => {
+            try { 
+              await mw.handle({ container: this.#container, request: req, response: res, next })
+            } catch (error) {
+              this.#container.get('logger').error(`Error in middleware for route [${methodName}] ${route.path}: ${error.message}`);
+              return res.status(500).json({ success: false, message: error.message || 'Internal Server Error' });
+            }
+          }),
+          async (req, res) => {
+            try {
+              const routeResponse = await route[methodName]({ container: this.#container, request: req, response: res });
+              const status = routeResponse?.status || 200;
+              return res.status(status).json({
+                ...routeResponse,
+                success: routeResponse?.success !== false,
+              });
+            } catch (error) {
+              this.#container.get('logger').error(`Error in route [${methodName}] ${route.path}: ${error.message}`);
+              return res.status(500).json({ success: false, message: error.message || 'Internal Server Error' });
+            }
+          });
+      }
+    }
+    
+    this.#httpServer.removeAllListeners("request");
+    this.#httpServer.on("request", this.#app);
+
+  }
+
   async #loadRoutesFromFolder(routesFolder) {
     this.#createRoutesFolder(routesFolder);
     const routes = (await fg('**/*.js', { cwd: routesFolder })).map((rt) => {