zyket 1.0.12 → 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.12",
+  "version": "1.0.14",
   "main": "index.js",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
@@ -14,7 +14,9 @@
   "description": "",
   "dependencies": {
     "colors": "^1.4.0",
+    "cors": "^2.8.5",
     "dotenv": "^16.4.7",
+    "express": "^5.1.0",
     "fast-glob": "^3.3.3",
     "mariadb": "^3.4.0",
     "minio": "^8.0.5",

package/src/kernel/HTTPServer.js

@@ -0,0 +1,32 @@
+const http = require('http')
+
+module.exports = class HTTPServer {
+  #server
+  #port
+
+  constructor ({ port }) {
+    if (!port || typeof port !== 'number' || port < 1) {
+      throw new Error('port must be a positive number')
+    }
+
+    this.#port = port
+    this.#server = http.createServer()
+  }
+
+  start () {
+    if (this.isStarted) {
+      throw new Error('Server is already started. Review your code')
+    }
+    console.log(`HTTP Server listening on port ${this.#port}`)
+
+    this.#server.listen(this.#port, () => {})
+  }
+
+  get server () {
+    return this.#server
+  }
+
+  get isStarted () {
+    return this.#server?.listening === true
+  }
+}

package/src/kernel/index.js

@@ -2,15 +2,16 @@ const {ContainerBuilder} = require("node-dependency-injection");
 const EnvManager = require("../utils/EnvManager");
 const fs = require("fs");
 const path = require("path");
+const HTTPServer = require("./HTTPServer");
 
 module.exports = class Kernel {
   container;
   #services;
   #onSocketConnection;
+  #httpServer;
 
   constructor({ 
-    services = [],
-    onConnection = () => { },
+    services = []
   } = { }) {
     this.container = new ContainerBuilder();
     this.#services = services;
@@ -24,14 +25,20 @@ module.exports = class Kernel {
   async boot(clearConsole = true, secretsPath = `${process.cwd()}/.env`) {
     EnvManager.load(secretsPath, false);
     if(clearConsole) process.stdout.write("\u001b[2J\u001b[0;0H");
+    this.#httpServer = new HTTPServer({ port: Number(process.env.PORT) || 3000 });
+    await this.#httpServer.start();
+
     const services = require("../services");
 
     await this.#registerServices(services);
     await this.#registerServices(this.#services);
 
+
     for (const [name] of [...services, ...this.#services]) {
       this.container.get('logger').debug(`Booting service ${name}`);
-      await this.container.get(name).boot();
+      await this.container.get(name).boot({
+        httpServer: this.#httpServer.server,
+      });
     }
   }
 

package/src/services/express/Express.js

@@ -0,0 +1,99 @@
+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 {
+  #container;
+  #app;
+  #httpServer;
+
+  constructor(container) {
+    super("express");
+    this.#container = container;
+  }
+
+  async boot({ httpServer } = {}) {
+    if (!httpServer) {
+      throw new Error("HTTP server is not available");
+    }
+
+    this.#httpServer = httpServer;
+    this.#app = express();
+
+    this.#app.use(express.json({ limit: `100mb` }))
+    this.#app.use(cors({
+      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

@@ -0,0 +1,8 @@
+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

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

package/src/services/express/index.js

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

package/src/services/index.js

@@ -2,6 +2,7 @@ const Database = require("./database");
 const Cache = require("./cache");
 const S3 = require("./s3");
 const { SocketIO } = require("./socketio");
+const { Express } = require("./express");
 
 module.exports = [
   ["logger", require("./logger"), ["@service_container", process.env.LOG_DIRECTORY || `${process.cwd()}/logs`, process.env.DEBUG === "true"]],
@@ -9,5 +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", process.env.PORT || 3000]],
+  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,63 +4,61 @@ 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 {
-  port;
   #container;
   io;
-  middlewares = {};
+  guards = {};
   
-  constructor(container, port, onConnection = () => { }) {
+  constructor(container) {
     super("socketio");
-    this.port = port || 3000;
     this.#container = container;
   }
 
-  async boot() {
-    const middlewares = await this.#loadMiddlewaresFromFolder(path.join(process.cwd(), "src", "middlewares"));
-    for (const middleware of middlewares) {
-      this.middlewares[middleware.name] = middleware;
+  async boot({ httpServer } = {}) {
+    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 });
         });
       });
     });
 
-    this.io.listen(this.port);
-    this.#container.get('logger').info(`Socket.IO is running on port ws://localhost:${this.port}`);
+    this.io.listen(httpServer);
+    this.#container.get('logger').info(`Socket.IO is running on ws://localhost:${httpServer.address().port}`);
   }
 
   async #loadConnectionHandler() {
@@ -73,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', ''));
@@ -90,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: '',