zyket 1.0.32 → 1.0.34

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zyket",
-  "version": "1.0.32",
+  "version": "1.0.34",
   "main": "index.js",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"

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

@@ -1,26 +1,26 @@
 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');
+// 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;
-  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
+    InteractiveStorageExtension.bucketName = bucketName;
+    this.maxFileSize = maxFileSize;
     this.middlewares = middlewares || [];
   }
 
@@ -28,35 +28,37 @@ module.exports = class InteractiveStorageExtension extends Extension {
     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 express = container.get('express');
     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));
+    // 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}`);
   }
@@ -64,11 +66,11 @@ module.exports = class InteractiveStorageExtension extends Extension {
   async #ensureBucket(s3, logger) {
     try {
       const buckets = await s3.listBuckets();
-      const bucketExists = buckets.some(bucket => bucket.name === this.bucketName);
+      const bucketExists = buckets.some(bucket => bucket.name === InteractiveStorageExtension.bucketName);
       
       if (!bucketExists) {
-        await s3.createBucket(this.bucketName);
-        logger.info(`Created S3 bucket: ${this.bucketName}`);
+        await s3.createBucket(InteractiveStorageExtension.bucketName);
+        logger.info(`Created S3 bucket: ${InteractiveStorageExtension.bucketName}`);
       }
     } catch (error) {
       logger.error(`Error ensuring bucket exists: ${error.message}`);
@@ -78,7 +80,7 @@ module.exports = class InteractiveStorageExtension extends Extension {
   async #listFiles(s3, prefix = '') {
     return new Promise((resolve, reject) => {
       const files = [];
-      const stream = s3.client.listObjectsV2(this.bucketName, prefix, true);
+      const stream = s3.client.listObjectsV2(InteractiveStorageExtension.bucketName, prefix, true);
       
       stream.on('data', (obj) => {
         files.push({
@@ -99,7 +101,7 @@ module.exports = class InteractiveStorageExtension extends Extension {
       const items = [];
       const folders = new Set();
       
-      const stream = s3.client.listObjectsV2(this.bucketName, prefix, false);
+      const stream = s3.client.listObjectsV2(InteractiveStorageExtension.bucketName, prefix, false);
       
       stream.on('data', (obj) => {
         if (obj.prefix) {
@@ -152,7 +154,7 @@ module.exports = class InteractiveStorageExtension extends Extension {
 
   async #getFileStat(s3, fileName) {
     return new Promise((resolve, reject) => {
-      s3.client.statObject(this.bucketName, fileName, (err, stat) => {
+      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

@@ -1,18 +1,31 @@
-module.exports = (s3, bucketName, logger, normalizePath, listFilesAndFolders) => async (req, res) => {
-  try {
-    const folder = req.query.folder || '';
-    const prefix = folder ? normalizePath(folder) + '/' : '';
+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 listFilesAndFolders(s3, prefix);
+    const items = await this.listFilesAndFolders(this.s3, prefix);
     
-    res.json({
+    return {
       success: true,
-      bucket: bucketName,
+      bucket: this.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

@@ -1,26 +1,37 @@
-module.exports = (s3, bucketName, logger, normalizePath) => async (req, res) => {
-  try {
-    const { folderPath } = req.body;
+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 res.status(400).json({ success: false, message: 'Folder path is required' });
+      return { success: false, message: 'Folder path is required', status: 400 };
     }
 
-    const normalizedPath = normalizePath(folderPath);
+    const normalizedPath = this.normalizePath(folderPath);
     const folderMarker = `${normalizedPath}/.folder`;
     
     // Create an empty marker file to represent the folder
-    await s3.saveFile(bucketName, folderMarker, Buffer.from(''), 'text/plain');
+    await this.s3.saveFile(this.bucketName, folderMarker, Buffer.from(''), 'text/plain');
     
     logger.info(`Created folder: ${normalizedPath}`);
     
-    res.json({
+    return {
       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

@@ -1,28 +1,44 @@
-module.exports = (s3, bucketName, logger, normalizePath, listFiles) => async (req, res) => {
-  try {
-    const { folderPath } = req.body;
+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 res.status(400).json({ success: false, message: 'Folder path is required' });
+      return { success: false, message: 'Folder path is required', status: 400 };
     }
 
-    const normalizedPath = normalizePath(folderPath);
+    const normalizedPath = this.normalizePath(folderPath);
     const prefix = `${normalizedPath}/`;
     
     // List all files in the folder
-    const files = await listFiles(s3, prefix);
+    const files = await this.listFiles(this.s3, prefix);
     
     if (files.length === 0) {
-      return res.json({
+      return {
         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 }))
+      this.s3.removeFile(this.bucketName, file.name).catch(err => ({ error: err.message, fileName: file.name }))
     );
 
     const results = await Promise.all(deletePromises);
@@ -31,14 +47,11 @@ module.exports = (s3, bucketName, logger, normalizePath, listFiles) => async (re
 
     logger.info(`Deleted folder ${normalizedPath} with ${successCount} files`);
 
-    res.json({
+    return {
       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

@@ -1,16 +1,28 @@
-module.exports = (s3, bucketName, logger) => async (req, res) => {
-  try {
-    const { fileName, fileNames } = req.body;
+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 res.status(400).json({ success: false, message: 'fileName or fileNames array is required' });
+      return { success: false, message: 'fileName or fileNames array is required', status: 400 };
     }
 
     const deletePromises = filesToDelete.map(file => 
-      s3.removeFile(bucketName, file).catch(err => ({ error: err.message, fileName: file }))
+      this.s3.removeFile(this.bucketName, file).catch(err => ({ error: err.message, fileName: file }))
     );
 
     const results = await Promise.all(deletePromises);
@@ -19,14 +31,11 @@ module.exports = (s3, bucketName, logger) => async (req, res) => {
 
     logger.info(`Deleted ${successCount} file(s) from S3 dropbox`);
 
-    res.json({
+    return {
       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

@@ -1,30 +1,47 @@
-module.exports = (s3, bucketName, logger, getFileStat) => async (req, res) => {
-  try {
-    const { fileName } = req.params;
-    
-    // Get file info first
-    const stat = await getFileStat(s3, fileName);
+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;
     
-    // 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);
+    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) => {
-      s3.client.getObject(bucketName, fileName, (err, stream) => {
-        if (err) return reject(err);
-        stream.pipe(res);
-        stream.on('end', resolve);
-        stream.on('error', reject);
+      // 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}`);
-  } catch (error) {
-    logger.error(`Error downloading file: ${error.message}`);
-    if (!res.headersSent) {
-      res.status(404).json({ success: false, message: 'File not found' });
+      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

@@ -1,20 +1,37 @@
-module.exports = (s3, bucketName, logger, getFileStat) => async (req, res) => {
-  try {
-    const { fileName } = req.params;
-    const stat = await getFileStat(s3, fileName);
+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');
     
-    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' });
+    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

@@ -1,15 +1,30 @@
-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 { 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 = req.body.folder || '';
-    const folderPath = folder ? normalizePath(folder) + '/' : '';
+    const folder = request.body.folder || '';
+    const folderPath = folder ? this.normalizePath(folder) + '/' : '';
 
-    const uploadPromises = req.files.map(async (file) => {
+    const uploadPromises = request.files.map(async (file) => {
       const fileName = `${folderPath}${Date.now()}-${file.originalname}`;
-      await s3.saveFile(bucketName, fileName, file.buffer, file.mimetype);
+      await this.s3.saveFile(this.bucketName, fileName, file.buffer, file.mimetype);
       return {
         originalName: file.originalname,
         fileName: fileName,
@@ -22,13 +37,10 @@ module.exports = (s3, bucketName, logger, normalizePath) => async (req, res) =>
     const uploadedFiles = await Promise.all(uploadPromises);
     logger.info(`Uploaded ${uploadedFiles.length} file(s) to S3 dropbox`);
 
-    res.json({
+    return {
       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/services/database/index.js

@@ -1,4 +1,4 @@
-const { Sequelize } = require("sequelize");
+const { Sequelize, Op } = require("sequelize");
 const Service = require("../Service");
 const fg = require('fast-glob');
 const fs = require('fs');
@@ -8,6 +8,9 @@ module.exports = class Database extends Service {
   #container;
   #databaseUrl;
   sequelize
+  Op = Op;
+  Sequelize = Sequelize;
+  
   models = {}
 
   constructor(container, databaseUrl) {

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) => {