turbo-express-js 1.0.0

package/lib/ServerCallback.js

@@ -0,0 +1,65 @@
+/**
+ * -->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>
+ *
+ * @PerfecTEvolutioN
+ * @project - TurboExpress
+ * @name ServerCallback
+ * @namespace TurboExpress::ServerCallback
+ * @license - MIT
+ * @author - Mike Karypidis
+ * @version - 1.0.0
+ * @link - https://npmjs.com/TurboExpress
+ * @github - https://github.com/TurboExpress
+ *
+ * -->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>
+ * 
+ * this is the primary callback that will be executed on each server connection;
+ * TurboExpress is written on top of nodejs<http> package, and on .createServer(...) we are passing this callback
+ * 
+ */
+
+const RequestInterface = require("./types/RequestInterface");
+const ResponseInterface = require("./types/ResponseInterface");
+const http = require("http");
+const { matching_route, matching_nonexact_route } = require("./utils"); 
+
+/**
+ *
+ * @param {http.IncomingMessage} req
+ * @param {http.OutgoingMessage} res
+ * @returns
+ */
+module.exports = async function ServerCallback(req, res) 
+{
+  const [path, query] = req.url.split("?");
+
+  let curr = matching_route(path, this[`__${req.method.toLowerCase()}_routes`]);
+
+  if (!curr) {
+    curr = matching_nonexact_route(
+      path,
+      this[`__${req.method.toLowerCase()}_routes`]
+    );
+  }
+
+  if (!curr) return res.end("~ Page Not Found || 404 ~");
+
+  /** @type {RequestInterface} new instance of <T extends RequestInterface> */
+  const request = new this.Request(req, curr, this);
+
+  /** @type {ResponseInterface} new instance of <T extends ResponseInterface> */
+  const response = new this.Response(res, curr, this);
+
+  let nextRun = true; // ! also not cost performance
+
+  const next = () => nextRun = true; // ! also not cost performance   *creating a new function callback for each connection  *there is no need to be static
+
+  for (let i = 0; i < curr.callbacks.length; i++) {
+    if(!nextRun) break;
+    nextRun = false; // ! not cost perfomance tested with 1000 middlewares running next() function and without next function and if checks here.;
+    await curr.callbacks[i](request, response, next);
+  }
+  
+  //console.log("request finished\n")
+
+};

package/lib/TurboServer.js

@@ -0,0 +1,278 @@
+/**
+ * -->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>
+ *
+ * @PerfecTEvolutioN
+ * @MikeKarypidis
+ * @project - TurboServer
+ * @name TurboServer
+ * @license - MIT
+ * @copyright - ©2022 PerfectEvolution Corporation;
+ * @author - Mike Karypidis
+ * @version - 1.0.0
+ * @link - https://turboserverjs.org
+ * @github - https://github.com/breathfunwithmindte/turbo-server.git
+ * 
+ * -->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>
+ * 
+ * here the primary class of TurboExpress framework - TurboServer class;
+ * 
+ */
+
+const http = require("http");
+const Router = require("./Router");
+const cluster = require("cluster");
+const RequestInterface = require("./types/RequestInterface");
+const ResponseInterface = require("./types/ResponseInterface");
+const { matching_route, matching_nonexact_route } = require("./utils");
+const Route = require("./types/Route");
+const Middleware= require("./types/Middleware");
+const RequestMethods = require("./statictypes/RequestMethods");
+const ServerCallback = require("./ServerCallback");
+const static_middleware = require("./middlewares/static_middleware");
+const attachment_middleware = require("./middlewares/attachment_middleware");
+const ValidationSchema = require("./types/ValidationSchema");
+const ValidationMethodType = require("./enum/ValidationMethodType");
+const validation_middleware = require("./middlewares/validation_middleware");
+const runmethod_middleware = require("./middlewares/runmethod_middleware");
+const buildform_middleware = require("./middlewares/buildform_middleware");
+const authentication_middleware = require("./middlewares/authentication_middleware");
+const cors_middleware = require("./middlewares/cors_middleware");
+
+
+module.exports = class TurboServer
+{
+  static Router = Router;
+  static ValidationSchema = ValidationSchema;
+  static ValidationMethodType = ValidationMethodType;
+
+  /**
+   * @typedef {Object} StaticOptions
+   * @property {String} folder - default /public
+   * @property {Boolean} cache - default false
+   * 
+   * @param {StaticOptions} StaticOptions 
+   * @returns 
+   */
+  static Static (StaticOptions={})
+  {
+    return static_middleware.bind({ folder: StaticOptions.folder || "/public", cache: StaticOptions.cache || false })
+  }
+
+  /**
+   * @typedef {Object} CorsOptions
+   * @property {String} folder - default /public
+   * @property {Boolean} cache - default false
+   * 
+   * @param {CorsOptions} CorsOptions 
+   * @returns 
+   */
+  static Cors (CorsOptions)
+  {
+    return cors_middleware.bind({
+
+    })
+  }
+
+  /**
+   * @typedef {Object} AttachmentOptions
+   * @property {String} folder - default /storage
+   * @property {Boolean} memory - default true
+   * @property {Boolean} as_middleware - default true
+   * 
+   * @param {AttachmentOptions} AttachmentOptions 
+   * @returns 
+   */
+  static Upload (AttachmentOptions={})
+  {
+    return attachment_middleware.bind({ 
+      folder: AttachmentOptions.folder || "/storage", memory: AttachmentOptions.memory || true, as_middleware: AttachmentOptions.as_middleware || true 
+    })
+  }
+
+  /**
+   * Add validations to request instance and executes the validateData method of the same instance.
+   * If there is an error, it throws the response with that error.
+   * 
+   * @typedef  {Object} ValidationOptions
+   * @property {ValidationSchema[]}  validations
+   * 
+   * @param {ValidationOptions} ValidationOptions 
+   * @returns 
+   */
+  static Validation (ValidationOptions={})
+  {
+    return validation_middleware.bind({ 
+      validations: ValidationOptions.validations
+    })
+  }
+
+  /**
+   * @typedef   {Object}  ExeMethodType
+   * @property  {string}  belong
+   * @property  {string}  methodname
+   * @property  {*}       inject
+   * @property  {boolean} isAsync
+   * 
+   * @typedef  {Object} RunMethodOptions
+   * @property {ExeMethodType[]}  exe
+   * 
+   * @param {RunMethodOptions} RunMethodOptions 
+   * @returns 
+   */
+  static RunMethod (RunMethodOptions={})
+  {
+    return runmethod_middleware.bind({ 
+      exe: RunMethodOptions.exe
+    })
+  }
+
+  /**
+   * 
+   * @typedef  {Object} AuthenticationOptions
+   * 
+   * @param {AuthenticationOptions} AuthenticationOptions 
+   * @returns 
+   */
+  static Authentication (AuthenticationOptions={})
+  {
+    return authentication_middleware.bind({ 
+      
+    })
+  }
+
+  /**
+   * @typedef   {Object}  BuildFormOptions
+   * 
+   * @param {BuildFormOptions} BuildFormOptions 
+   * @returns 
+   */
+  static BuildForm (BuildFormOptions={})
+  {
+    return buildform_middleware.bind({ 
+      
+    })
+  }
+
+
+
+  /** @type{http.Server}    */ #server;
+
+  // spliting the list of routes base on method, so later have less items in list to search for each connection
+  /** @type{Route[]}       */ __get_routes = [];       
+  /** @type{Route[]}       */ __post_routes = [];
+  /** @type{Route[]}       */ __put_routes = [];
+  /** @type{Route[]}       */ __delete_routes = [];
+  /** @type{Route[]}       */ __head_routes = [];
+  /** @type{Route[]}       */ __patch_routes = [];
+  /** @type{Route[]}       */ __options_routes = [];
+  /** @type{Route[]}       */ __link_routes = [];
+  /** @type{Route[]}       */ __unlink_routes = [];
+  /** @type{Route[]}       */ __view_routes = [];
+  /** @type{Route[]}       */ __lock_routes = [];
+  /** @type{Route[]}       */ __unlock_routes = [];
+  /** @type{Route[]}       */ __copy_routes = [];
+  /** @type{Route[]}       */ __purge_routes = [];
+  /** @type{Route[]}       */ __propfind_routes = [];
+
+  /** @type{Middleware[]}   */ __middlewares_begin = [];
+  /** @type{Middleware[]}   */ __middlewares_end = [];
+  
+  // * interfaces
+  /** @type{RequestInterface}                              */     Request;
+  /** @type{ResponseInterface}                             */     Response;
+
+  /** @type {Map<String, Object>}                          */     appState         =   new Map();
+  /** @type {Map<String, import("mongoose").Model}         */     models           =   new Map();
+  /** @type {Map<String, import("mongoose").Model}         */     sqlModels        =   new Map(); // TODO later
+
+  /**
+   * @param {Number} CLUSTERSLENGTH
+   * @doc - here on constructor will be created a server instance;
+   * createServer method of http class will get the primary servercallback and bind this of current instance;
+   * the method listen of current instance should be invoked to listen on some port;
+   */
+  constructor (CLUSTERSLENGTH)
+  {
+    if (cluster.isMaster) {
+      for (let i = 0; i < CLUSTERSLENGTH; i++) { cluster.fork() }
+    } else {
+      global["TurboExpress"] = new Object();
+      global["TurboExpressCaching"] = new Object();
+      this.#server = http.createServer(ServerCallback.bind(this));
+      this.Request = RequestInterface;
+      this.Response = ResponseInterface;
+    }
+  }
+
+  get(path, ...callbacks){if(!cluster.isMaster) {this.__get_routes.push(new Route(path, RequestMethods.GET, callbacks, this.__middlewares_begin, this.__middlewares_end));}}
+  post(path, ...callbacks){if(!cluster.isMaster) {this.__post_routes.push(new Route(path, RequestMethods.POST, callbacks, this.__middlewares_begin, this.__middlewares_end));}}
+  put(path, ...callbacks){if(!cluster.isMaster) {this.__put_routes.push(new Route(path, RequestMethods.PUT, callbacks, this.__middlewares_begin, this.__middlewares_end));}}
+  delete(path, ...callbacks){if(!cluster.isMaster) {this.__delete_routes.push(new Route(path, RequestMethods.DELETE, callbacks, this.__middlewares_begin, this.__middlewares_end));}}
+  head(path, ...callbacks){if(!cluster.isMaster) {this.__head_routes.push(new Route(path, RequestMethods.HEAD, callbacks, this.__middlewares_begin, this.__middlewares_end));}}
+  patch(path, ...callbacks){if(!cluster.isMaster) {this.__patch_routes.push(new Route(path, RequestMethods.PATCH, callbacks, this.__middlewares_begin, this.__middlewares_end));}}
+  options(path, ...callbacks){if(!cluster.isMaster) {this.__options_routes.push(new Route(path, RequestMethods.OPTIONS, callbacks, this.__middlewares_begin, this.__middlewares_end));}}
+  link(path, ...callbacks){if(!cluster.isMaster) {this.__link_routes.push(new Route(path, RequestMethods.LINK, callbacks, this.__middlewares_begin, this.__middlewares_end));}}
+  unlink(path, ...callbacks){if(!cluster.isMaster) {this.__unlink_routes.push(new Route(path, RequestMethods.UNLINK, callbacks, this.__middlewares_begin, this.__middlewares_end));}}
+  view(path, ...callbacks){if(!cluster.isMaster) {this.__view_routes.push(new Route(path, RequestMethods.VIEW, callbacks, this.__middlewares_begin, this.__middlewares_end));}}
+  lock(path, ...callbacks){if(!cluster.isMaster) {this.__lock_routes.push(new Route(path, RequestMethods.LOCK, callbacks, this.__middlewares_begin, this.__middlewares_end));}}
+  unlock(path, ...callbacks){if(!cluster.isMaster) {this.__unlock_routes.push(new Route(path, RequestMethods.UNLOCK, callbacks, this.__middlewares_begin, this.__middlewares_end));}}
+  copy(path, ...callbacks){if(!cluster.isMaster) {this.__copy_routes.push(new Route(path, RequestMethods.COPY, callbacks, this.__middlewares_begin, this.__middlewares_end));}}
+  purge(path, ...callbacks){if(!cluster.isMaster) {this.__purge_routes.push(new Route(path, RequestMethods.PURGE, callbacks, this.__middlewares_begin, this.__middlewares_end));}}
+  propfind(path, ...callbacks){if(!cluster.isMaster) {this.__propfind_routes.push(new Route(path, RequestMethods.PROPFIND, callbacks, this.__middlewares_begin, this.__middlewares_end));}}
+
+  use(path, ...callbackOrRouter)
+  {
+    if(callbackOrRouter[0] instanceof Router === true) {
+      callbackOrRouter[0].inject(path, this);
+    } else {
+      this.__middlewares_begin.push(new Middleware(path, callbackOrRouter));
+    }
+  }
+
+  useEndMiddleware (path, ...callbacks)
+  {
+    this.__middlewares_end.push(new Middleware(path, callbacks));
+  }
+
+
+
+  /**
+   * todo method for deleting routes in runtime.
+   * can be used inside controllers - dynamic change routes from: example: server admin panel
+   * 
+   * @param {String} method 
+   * @param {String} path 
+   */
+  deleteRoute (method, path) {
+
+  }
+
+  /**
+   * todo method for find route in runtime.
+   * can be used inside controllers - dynamic change routes from: example: server admin panel
+   * 
+   * @param {String} method 
+   * @param {String} path 
+   */
+  getRoute (method, path) {
+
+  }
+
+
+
+
+  logRoutes ()
+  {
+    let arr = [...this.__get_routes, ...this.__post_routes, ...this.__put_routes, ...this.__delete_routes];
+    console.table(arr);
+  }
+
+  listen (port, cb)
+  {
+    /** will listen not on master cluster ... */
+    if(!cluster.isMaster) {
+      this.#server.listen(port, cb ? cb : () => console.log("server is running"))
+    } 
+  }
+
+}

package/lib/enum/FileEndToContentType.js

@@ -0,0 +1,35 @@
+/**
+ * 
+ * @param {String} fileName
+ * @returns {String | null} 
+ */
+module.exports = (fileName) => {
+  switch ("." + fileName.split(".")[fileName.split(".").length - 1]) {
+    case ".pdf": return "application/pdf";
+    case ".doc": return "application/msword";
+    case ".xls": return "application/vnd.ms-excel";
+    case ".ppt": return "application/vnd.ms-powerpoint";
+    case ".zip": return "application/zip";
+    case ".mp3": return "audio/mpeg";
+    case ".ogg": return "audio/ogg";
+    case ".wav": return "audio/x-wav";
+    case ".csv": return "text/csv";
+    case ".html": return "text/html";
+    case ".txt": return "text/plain";
+    case ".bmp": return "image/bmp";
+    case ".gif": return "image/gif";
+    case ".jpg": return "image/jpeg";
+    case ".jpeg": return "image/jpeg";
+    case ".png": return "image/png";
+    case ".mp4": return "video/mp4";
+    case ".webm": return "video/webm";
+    case ".swf": return "application/x-shockwave-flash";
+    case ".tar": return "application/x-tar";
+    case ".gz": return "application/x-gzip";
+    case ".7z": return "application/x-7z-compressed";
+    case ".rar": return "application/x-rar-compressed";
+    case ".exe": return "application/octet-stream";
+    case ".json": return "application/json";
+    default: return null;
+  }
+}

package/lib/enum/ValidationMethodType.js

@@ -0,0 +1,6 @@
+module.exports = {
+  "MINLENGTH": "minlength",
+  "MAXLENGTH": "maxlength",
+  "ONEOF": "oneof",
+  "SIZE": "size"
+}

package/lib/middlewares/attachment_middleware.js

@@ -0,0 +1,89 @@
+/**
+ * -->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>
+ *
+ * @PerfecTEvolutioN
+ * @project - TurboExpress
+ * @name TurboExpress
+ * @namespace TurboExpress::middlewares::static_middleware
+ * @license - MIT
+ * @author - Mike Karypidis
+ * @version - 1.0.0
+ * @link - https://npmjs.com/TurboExpress
+ * @github - https://github.com/TurboExpress
+ * 
+ * -->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>
+ */
+
+const FileType = require("../types/FileType");
+const RequestInterface = require("../types/RequestInterface");
+const ResponseInterface = require("../types/ResponseInterface");
+const multiparty = require("multiparty")
+
+/**
+* 
+* @param {RequestInterface} req 
+* @param {ResponseInterface} res 
+* @param {*} next 
+*/
+module.exports = function attachment_middleware (req, res, next) 
+{
+  console.log("attachment middleware");
+
+  const { memory, folder } = this;
+  console.log(memory, folder);
+
+  const httpRequest = req.IncomingMessage;  //http.IncomingMessage
+  const httpResponse = res.OutgoingMessage; //http.OutgoingMessage
+
+  const files = new Array();
+
+  if(memory)
+  {
+    /** @type{Buffer[]} */ const FilesBuffers = new Array(); 
+    const form = new multiparty.Form({ autoFields: true });
+
+    form.on("part", (part) => {
+      let buffer = Buffer.alloc(0);
+      const mine_type = part.headers["content-type"] || "";
+      const turboExpressFile = new FileType();
+      turboExpressFile.name = part.name;
+      turboExpressFile.fileName = part.filename;
+      turboExpressFile.is_binary = true;
+      turboExpressFile.is_compressible = false;
+      turboExpressFile.is_encrypted = false;
+      turboExpressFile.extension = mine_type.split("/")[1] || "not-found"
+      turboExpressFile.mime_type = mine_type;
+      turboExpressFile.buffer_size = part.byteCount;
+      turboExpressFile.metadata = {}
+      turboExpressFile.description = `File with name = {${turboExpressFile.fileName}}, sent with name = {${turboExpressFile.name}} and stored into server memory;`
+      turboExpressFile.owner = null;
+
+      console.log(turboExpressFile)
+
+      part.on("data", (chunk) => {
+        console.log("$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$")
+        buffer = Buffer.concat([buffer, chunk]);
+      })
+
+      part.on("end", () => {
+        console.log("ennennenen")
+        turboExpressFile.buffer = buffer;
+        turboExpressFile.buffer_size = buffer.length;
+        req._files.push(turboExpressFile);
+      })
+
+    })
+    form.parse(req.IncomingMessage);
+
+    form.on("close", () => {
+      console.log(req._files, "@@@")
+    })
+
+  } 
+  else 
+  {
+    throw new Error("Currently method to store files not in memory and handle large files, is not implemented.")
+  }
+
+ 
+}

package/lib/middlewares/authentication_middleware.js

@@ -0,0 +1,33 @@
+/**
+ * -->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>
+ *
+ * @PerfecTEvolutioN
+ * @project - TurboExpress
+ * @name TurboExpress
+ * @namespace TurboExpress::middlewares::authentication_middleware
+ * @license - MIT
+ * @author - Mike Karypidis
+ * @version - 1.0.0
+ * @link - https://npmjs.com/TurboExpress
+ * @github - https://github.com/TurboExpress
+ * 
+ * -->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>
+ */
+
+const RequestInterface = require("../types/RequestInterface");
+const ResponseInterface = require("../types/ResponseInterface");
+
+/**
+* 
+* @param {RequestInterface} req 
+* @param {ResponseInterface} res 
+* @param {*} next 
+*/
+module.exports = function authentication_middleware (req, res, next) 
+{
+
+  // comming soon;
+
+  res.send("comming soon - authentication middleware");
+
+}

package/lib/middlewares/buildform_middleware.js

@@ -0,0 +1,33 @@
+/**
+ * -->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>
+ *
+ * @PerfecTEvolutioN
+ * @project - TurboExpress
+ * @name TurboExpress
+ * @namespace TurboExpress::middlewares::authentication_middleware
+ * @license - MIT
+ * @author - Mike Karypidis
+ * @version - 1.0.0
+ * @link - https://npmjs.com/TurboExpress
+ * @github - https://github.com/TurboExpress
+ * 
+ * -->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>
+ */
+
+const RequestInterface = require("../types/RequestInterface");
+const ResponseInterface = require("../types/ResponseInterface");
+
+/**
+* 
+* @param {RequestInterface} req 
+* @param {ResponseInterface} res 
+* @param {*} next 
+*/
+module.exports = function buildform_middleware (req, res, next) 
+{
+
+  // comming soon;
+
+  res.send("comming soon - buildform middleware");
+
+}

package/lib/middlewares/cors_middleware.js

@@ -0,0 +1,33 @@
+/**
+ * -->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>
+ *
+ * @PerfecTEvolutioN
+ * @project - TurboExpress
+ * @name TurboExpress
+ * @namespace TurboExpress::middlewares::static_middleware
+ * @license - MIT
+ * @author - Mike Karypidis
+ * @version - 1.0.0
+ * @link - https://npmjs.com/TurboExpress
+ * @github - https://github.com/TurboExpress
+ * 
+ * -->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>
+ */
+
+const RequestInterface = require("../types/RequestInterface");
+const ResponseInterface = require("../types/ResponseInterface");
+
+/**
+* 
+* @param {RequestInterface} req 
+* @param {ResponseInterface} res 
+* @param {*} next 
+*/
+module.exports = function cors_middleware (req, res, next) 
+{
+
+  // comming soon;
+
+  res.send("comming soon - cors middleware");
+
+}

package/lib/middlewares/runmethod_middleware.js

@@ -0,0 +1,51 @@
+/**
+ * -->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>
+ *
+ * @PerfecTEvolutioN
+ * @project - TurboExpress
+ * @name TurboExpress
+ * @namespace TurboExpress::middlewares::static_middleware
+ * @license - MIT
+ * @author - Mike Karypidis
+ * @version - 1.0.0
+ * @link - https://npmjs.com/TurboExpress
+ * @github - https://github.com/TurboExpress
+ * 
+ * -->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>
+ */
+
+const RequestInterface = require("../types/RequestInterface");
+const ResponseInterface = require("../types/ResponseInterface");
+
+/**
+* 
+* @param {RequestInterface} req 
+* @param {ResponseInterface} res 
+* @param {*} next 
+*/
+module.exports = async function runmethod_middleware (req, res, next) 
+{
+  let continueExecuting = true;
+  const nextExe = () => continueExecuting = true;
+
+  for (let index = 0; index < this.exe.length; index++) {
+    if(continueExecuting === false) break;
+    continueExecuting = false;
+    //console.log(this.exe[index]);
+    if(this.exe[index].isAsync) {
+      if(this.exe[index].belong === "req") {
+        await req[this.exe[index].methodname](res, this.exe[index].inject, nextExe)
+      } else {
+        await res[this.exe[index].methodname](req, this.exe[index].inject, nextExe)
+      }
+    } else {
+      if(this.exe[index].belong === "req") {
+        req[this.exe[index].methodname](res, this.exe[index].inject, nextExe)
+      } else {
+        res[this.exe[index].methodname](req, this.exe[index].inject, nextExe)
+      }
+    }
+    
+  }
+  if(continueExecuting) next()
+}