zyket 1.0.13 → 1.0.14

package/index.js

@@ -1,12 +1,14 @@
 const Kernel = require("./src/kernel");
 const Service = require("./src/services/Service");
-const { Handler, Middleware } = require("./src/services/socketio");
 const EnvManager = require("./src/utils/EnvManager");
 
+const {Route, Middleware} = require("./src/services/express");
+const { Handler, Guard } = require("./src/services/socketio");
+
+
 module.exports = {
-  Kernel,
-  Service,
-  Handler,
-  Middleware,
+  Kernel, Service,
+  Route, Middleware,
+  Handler, Guard,
   EnvManager
 }

package/package.json

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

package/src/services/express/Express.js

@@ -1,6 +1,11 @@
 const Service = require("../Service");
 const express = require("express");
 const cors = require("cors");
+const Route = require("./Route");
+const fs = require("fs");
+const path = require("path");
+const fg = require('fast-glob');
+const Middleware = require("./Middleware");
 
 
 module.exports = class Express extends Service {
@@ -26,8 +31,69 @@ module.exports = class Express extends Service {
       origin: '*'
     }))
 
+    const routes = await this.#loadRoutesFromFolder(path.join(process.cwd(), "src", "routes"));
+
+    routes.forEach((route) => {
+      const { post, get } = route;
+      for (const method of [post, get]) {
+        if(!method) continue;
+        const methodName = method === post ? 'post' : 'get';
+        this.#container.get('logger').debug(`Registering route: [${methodName}] ${route.path}`);
+        const middlewares = route?.middlewares?.[methodName] || [];
+        for (const mw of middlewares) {
+          // mw is instance of Middleware
+          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 => (req, res, next) => mw.handle({ container: this.#container, request: req, response: res, next })), 
+          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.on("request", this.#app);
 
     this.#container.get('logger').info(`Express is running on http://localhost:${httpServer.address().port}`);
   }
+
+  async #loadRoutesFromFolder(routesFolder) {
+    this.#createRoutesFolder(routesFolder);
+    const routes = (await fg('**/*.js', { cwd: routesFolder })).map((rt) => {
+    const route = require(path.join(routesFolder, rt));
+      if(!(route.prototype instanceof Route)) throw new Error(`${rt} is not a valid route`);
+      let routePath = `/${rt.replace('.js', '')}`;
+      routePath = routePath.replaceAll('index', '/');
+      routePath = routePath.replaceAll('//', '/');
+      routePath = routePath.replace(/\[([^\]]+)\]/g, ':$1');
+      
+      return new route(routePath);
+    });
+    return routes;
+  }
+
+  #createRoutesFolder(routesFolder, overwrite = false) {
+    if (fs.existsSync(routesFolder) && !overwrite) return;
+    this.#container.get('logger').info(`Creating routes folder at ${routesFolder}`);
+    fs.mkdirSync(routesFolder);
+    this.#container.get('template-manager').installFile('default/src/routes/index', path.join(routesFolder, "index.js"));
+    fs.mkdirSync(path.join(routesFolder, "[test]"));
+    this.#container.get('template-manager').installFile('default/src/routes/[test]/message', path.join(routesFolder, "[test]", "message.js"));
+    fs.mkdirSync(path.join(process.cwd(), "src", "middlewares"));
+    this.#container.get('template-manager').installFile('default/src/middlewares/default', path.join(process.cwd(), "src", "middlewares", "default.js"));
+  }
 }

package/src/services/express/Middleware.js

@@ -1,2 +1,8 @@
-export default class Middleware {
+module.exports = class Middleware {
+  constructor() {
+  }
+
+  handle({ container, request, response, next }) {
+    throw new Error("You should implement 'handle()' method on your route");
+  }
 }

package/src/services/express/Route.js

@@ -1,2 +1,7 @@
-export default class Route {
+module.exports = class Route {
+  path;
+
+  constructor(_path) {
+    this.path = _path;
+  }
 }

package/src/services/express/index.js

@@ -1,3 +1,5 @@
 module.exports = {
   Express: require("./Express"),
+  Route: require("./Route"),
+  Middleware: require("./Middleware"),
 }

package/src/services/index.js

@@ -10,6 +10,6 @@ module.exports = [
   process.env.DATABASE_URL ? ["database", Database, ["@service_container", process.env.DATABASE_URL]] : null,
   process.env.CACHE_URL ? ["cache", Cache, ["@service_container", process.env.CACHE_URL]] : null,
   (process.env.S3_ENDPOINT && process.env.S3_ACCESS_KEY && process.env.S3_SECRET_KEY) ? ["s3", S3, ["@service_container", process.env.S3_ENDPOINT, process.env.S3_PORT, process.env.S3_USE_SSL === "true", process.env.S3_ACCESS_KEY, process.env.S3_SECRET_KEY]] : null,
-  ["socketio", SocketIO, ["@service_container"]],
-  ["express", Express, ["@service_container"]]
+  process.env.DISABLE_SOCKET !== 'true' ? ["socketio", SocketIO, ["@service_container"]] : null,
+  process.env.DISABLE_EXPRESS !== 'true' ? ["express", Express, ["@service_container"]] : null
 ].filter(Boolean);

package/src/services/socketio/{Middleware.js → Guard.js}

@@ -1,4 +1,4 @@
-module.exports = class Middleware {
+module.exports = class Guard {
   name;
   
   constructor(name) {

package/src/services/socketio/SocketIO.js

@@ -4,13 +4,13 @@ const fs = require("fs");
 const path = require("path");
 const fg = require('fast-glob');
 const Handler = require("./Handler");
-const Middleware = require("./Middleware");
+const Guard = require("./Guard");
 
 
 module.exports = class SocketIO extends Service {
   #container;
   io;
-  middlewares = {};
+  guards = {};
   
   constructor(container) {
     super("socketio");
@@ -18,39 +18,39 @@ module.exports = class SocketIO extends Service {
   }
 
   async boot({ httpServer } = {}) {
-    const middlewares = await this.#loadMiddlewaresFromFolder(path.join(process.cwd(), "src", "middlewares"));
-    for (const middleware of middlewares) {
-      this.middlewares[middleware.name] = middleware;
+    const guards = await this.#loadGuardsFromFolder(path.join(process.cwd(), "src", "guards"));
+    for (const guard of guards) {
+      this.guards[guard.name] = guard;
     }
     const handlers = await this.#loadHandlersFromFolder(path.join(process.cwd(), "src", "handlers"));
     const connectionHandler = new (await this.#loadConnectionHandler())();
 
 
-    this.#container.get('logger').debug(`Middlewares: ${middlewares.map(mdl => mdl.name).join(", ")}`);
+    this.#container.get('logger').debug(`Guards: ${guards.map(mdl => mdl.name).join(", ")}`);
     this.#container.get('logger').debug(`Handlers: ${handlers.map(hdl => hdl.event).join(", ")}`);
     
     this.io = new Server({ cors: { origin: "*" }, maxHttpBufferSize: 10 * 1024 * 1024 });
 
     this.io.on("connection", (socket) => {
-      const connectionMiddlewares = (connectionHandler?.middlewares || []).map(mdl => this.middlewares[mdl])
-      for (const middleware of connectionMiddlewares) {
-        if(!middleware) {
-          this.#container.get('logger').warn(`You are using a middleware that does not exist`);
+      const connectionGuards = (connectionHandler?.guards || []).map(mdl => this.guards[mdl])
+      for (const guard of connectionGuards) {
+        if(!guard) {
+          this.#container.get('logger').warn(`You are using a guard that does not exist`);
           continue;
         }
-        middleware.handle({ container: this.#container, socket, io: this.io });
+        guard.handle({ container: this.#container, socket, io: this.io });
       }
       connectionHandler.handle({ container: this.#container, socket, io: this.io });
       handlers.forEach((handler) => {
-        const handlerMiddlewares = (handler?.middlewares || []).map(mdl => this.middlewares[mdl])
+        const handlerGuards = (handler?.guards || []).map(mdl => this.guards[mdl])
         socket.on(handler.event, async (data) => {
-          this.#container.get('logger').debug(`[${socket?.id}] Sent ${handler.event} with middlewares: ${handlerMiddlewares?.map(mdl => mdl?.name).join(", ")}`);
-          for (const middleware of handlerMiddlewares) {
-            if(!middleware) {
-              this.#container.get('logger').warn(`You are using a middleware that does not exist`);
+          this.#container.get('logger').debug(`[${socket?.id}] Sent ${handler.event} with guards: ${handlerGuards?.map(mdl => mdl?.name).join(", ")}`);
+          for (const guard of handlerGuards) {
+            if(!guard) {
+              this.#container.get('logger').warn(`You are using a guard that does not exist`);
               continue;
             }
-            await middleware.handle({ container: this.#container, socket, io: this.io });
+            await guard.handle({ container: this.#container, socket, io: this.io });
           }
           return await handler.handle({ container: this.#container, socket, data, io: this.io });
         });
@@ -71,9 +71,7 @@ module.exports = class SocketIO extends Service {
 
   async #loadHandlersFromFolder(handlersFolder) {
     this.#createHandlersFolder(handlersFolder);
-    // need to read all files and subfolders
     const handlers = (await fg('**/*.js', { cwd: handlersFolder, ignore: 'connection.js' })).map((hdr) => {
-      // should be type handler
       const handler = require(path.join(handlersFolder, hdr));
       if(!(handler.prototype instanceof Handler)) throw new Error(`${hdr} is not a valid handler`);
       return new handler(hdr.replace('.js', ''));
@@ -88,24 +86,22 @@ module.exports = class SocketIO extends Service {
     this.#container.get('template-manager').installFile('default/src/handlers/message', path.join(handlersFolder, "message.js"));
   }
 
-  async #loadMiddlewaresFromFolder(middlewaresFolder) {
-    this.#createMiddlewaresFolder(middlewaresFolder);
-    // need to read all files and subfolders
-    const middlewares = await fg('**/*.js', { cwd: middlewaresFolder })
+  async #loadGuardsFromFolder(guardsFolder) {
+    this.#createGuardsFolder(guardsFolder);
+    const guards = await fg('**/*.js', { cwd: guardsFolder })
     
-    return middlewares.map((mdl) => {
-      // should be type middleware
-      const middleware = require(path.join(middlewaresFolder, mdl));
-      if(!(middleware.prototype instanceof Middleware)) throw new Error(`${mdl} is not a valid middleware`);
-      return new middleware(mdl.replace('.js', ''));
+    return guards.map((gd) => {
+      const guard = require(path.join(guardsFolder, gd));
+      if(!(guard.prototype instanceof Guard)) throw new Error(`${gd} is not a valid guard`);
+      return new guard(gd.replace('.js', ''));
     });
   }
 
-  #createMiddlewaresFolder(middlewaresFolder, overwrite = false) {
-    if (fs.existsSync(middlewaresFolder) && !overwrite) return;
-    this.#container.get('logger').info(`Creating middlewares folder at ${middlewaresFolder}`);
-    fs.mkdirSync(middlewaresFolder);
-    this.#container.get('template-manager').installFile('default/src/middlewares/default', path.join(middlewaresFolder, "default.js"));
+  #createGuardsFolder(guardsFolder, overwrite = false) {
+    if (fs.existsSync(guardsFolder) && !overwrite) return;
+    this.#container.get('logger').info(`Creating guards folder at ${guardsFolder}`);
+    fs.mkdirSync(guardsFolder);
+    this.#container.get('template-manager').installFile('default/src/guards/default', path.join(guardsFolder, "default.js"));
   }
 
   stop() {

package/src/services/socketio/index.js

@@ -1,5 +1,5 @@
 module.exports = {
   SocketIO: require("./SocketIO"),
   Handler: require("./Handler"),
-  Middleware: require("./Middleware")
+  Guard: require("./Guard")
 }

package/src/templates/default/src/guards/default.js

@@ -0,0 +1,7 @@
+const { Guard } = require("zyket");
+
+module.exports = class DefaultGuard extends Guard {
+  async handle({ container, socket, io }) {
+    container.get("logger").info("Default guard");
+  }
+};

package/src/templates/default/src/handlers/message.js

@@ -1,7 +1,7 @@
 const { Handler } = require("zyket");
 
 module.exports = class MessageHandler extends Handler {
-  middlewares = ["default"];
+  guards = ["default"];
 
   async handle({ container, socket, data, io }) {
     container.get("logger").info("Message handler");

package/src/templates/default/src/middlewares/default.js

@@ -1,6 +1,8 @@
 const { Middleware } = require("zyket");
+
 module.exports = class DefaultMiddleware extends Middleware {
-  async handle({ container, socket, io }) {
+  async handle({ container, request, response, next }) {
     container.get("logger").info("Default middleware");
+    next();
   }
 };

package/src/templates/default/src/routes/[test]/message.js

@@ -0,0 +1,21 @@
+const { Route } = require("zyket");
+
+module.exports = class DefaultRoute extends Route {
+  async post({ container, request }) {
+    const { test } = request.params;
+    container.get("logger").info("Default route GET");
+
+    return {
+      test: "Hello World GET! Param: " + test
+    }
+  }
+
+  async get({ container, request }) {
+    const { test } = request.params;
+    container.get("logger").info("Default route GET");
+    
+    return {
+      test: "Hello World GET! Param: " + test
+    }
+  }
+};

package/src/templates/default/src/routes/index.js

@@ -0,0 +1,23 @@
+const { Route } = require("zyket");
+const DefaultMiddleware = require("../middlewares/default");
+
+module.exports = class DefaultRoute extends Route {
+  middlewares = {
+    post: [ new DefaultMiddleware() ],
+    get: [ new DefaultMiddleware() ]
+  }
+
+  async post({ container, request }) {
+    container.get("logger").info("Default route POST");
+    return {
+      test: "Hello World POST!"
+    }
+  }
+
+  async get({ container, request }) {
+    container.get("logger").info("Default route GET");
+    return {
+      test: "Hello World GET!"
+    }
+  }
+};

package/src/utils/EnvManager.js

@@ -15,6 +15,8 @@ module.exports = class EnvManager {
     const envsToCreate = {
       DEBUG: true,
       PORT: 3000,
+      DISABLE_SOCKET: false,
+      DISABLE_EXPRESS: false,
       DATABASE_URL: '',
       CACHE_URL: '',
       S3_ENDPOINT: '',