turbo-express-js 1.0.0

package/lib/middlewares/static_middleware.js

@@ -0,0 +1,76 @@
+/**
+ * -->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>
+ *
+ * @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 fs = require("fs");
+const FileEndToContentType = require("../enum/FileEndToContentType");
+const RequestInterface = require("../types/RequestInterface");
+const ResponseInterface = require("../types/ResponseInterface");
+
+/**
+* 
+* @param {RequestInterface} req 
+* @param {ResponseInterface} res 
+* @param {*} next 
+*/
+module.exports = function static_middleware (req, res, next) 
+{
+ const filePathParam = req.url().split(req.current.path_parts.slice(0, req.current.path_parts.length - 1).join("/"))[1];
+ const correctHeaders = FileEndToContentType(filePathParam);
+
+ const filePath = require("path").resolve() + this.folder + filePathParam;
+
+ //console.log(filePath)
+
+ if(fs.existsSync(filePath) === false) {
+  res.OutgoingMessage.writeHead(200, { 'Content-Type': 'text/html', });
+  return res.OutgoingMessage.end("NOT FOUND || 404")
+ }
+
+ /**
+  * @doc if in global property {TurboExpressCaching} exist the filepath
+  * then send file from cache;
+  */
+ if(global["TurboExpressCaching"][filePath]) {
+  res.OutgoingMessage.writeHead(200, { 'Content-Type': correctHeaders, });
+  res.OutgoingMessage.end(global["TurboExpressCaching"][filePath]);
+  return;
+ }
+ 
+ /**
+  * @doc read file using nodejs streams;
+  * when stream is over, check if cache property is true, then
+  * if true save the buffer to global {TurboExpressCaching}
+  * in any case send the file to the client;
+  */
+ const stream = fs.createReadStream(filePath);
+
+ res.OutgoingMessage.writeHead(200, { 'Content-Type': correctHeaders });
+
+ let chunks = [];
+
+ stream.on("data", (chunk) => chunks.push(chunk))
+ stream.on("end", () => {
+   let fileData = Buffer.concat(chunks);
+   if(this.cache) global["TurboExpressCaching"][filePath] = fileData;
+   res.OutgoingMessage.end(fileData);
+ });
+
+ stream.on('error', (err) => {
+   res.OutgoingMessage.writeHead(404);
+   res.OutgoingMessage.end(err.message);
+ });
+
+}

package/lib/middlewares/validation_middleware.js

@@ -0,0 +1,39 @@
+/**
+ * -->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>
+ *
+ * @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 validation_middleware (req, res, next) 
+{
+  
+ const { validations } = this;
+
+ validations.map(v => req.addValidation(v));
+
+ const validationResult = await req.validateIncomingData();
+
+ if(validationResult === -1) return res.status(400).json({ errors: req._validation_errors });
+
+ next();
+
+}

package/lib/statictypes/RequestMethods.js

@@ -0,0 +1,85 @@
+/**
+ * -->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>
+ *
+ * @PerfecTEvolutioN
+ * @project - TurboExpress
+ * @name TurboExpress
+ * @namespace TurboExpress::StaticTypes::RequestMethods
+ * @license - MIT
+ * @author - Mike Karypidis
+ * @version - 1.0.0
+ * @link - https://npmjs.com/TurboExpress
+ * @github - https://github.com/TurboExpress
+ * 
+ * -->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>
+ */
+
+
+module.exports = class RequestMethods
+{
+
+  static GET = "get";
+  static POST = "post";
+  static PUT = "put";
+  static DELETE = "delete";
+  static HEAD = "head";
+  static PATCH = "patch";
+  static OPTIONS = "options";
+  static LINK = "link";
+  static UNLINK = "unlink";
+  static VIEW = "view";
+  static LOCK = "lock";
+  static UNLOCK = "unlock";
+  static COPY = "copy";
+  static PURGE = "purge";
+  static PROPFIND = "propfind"
+
+  http_methods = ["get", "post", "delete", "put", "head", "patch", "options", "link", "unlink", "view", "lock", "unlock", "copy", "purge", "propfind"];
+
+  get;
+  post;
+  put;
+  delete;
+  head;
+  patch;
+  options;
+  link;
+  unlink;
+  view;
+  lock;
+  unlock;
+  copy;
+  purge;
+  propfind;
+
+
+  constructor ()
+  {
+    this.get = RequestMethods.GET;
+    this.post = RequestMethods.POST;
+    this.put = RequestMethods.PUT;
+    this.delete = RequestMethods.DELETE;
+    this.head = RequestMethods.HEAD;
+    this.patch = RequestMethods.PATCH;
+    this.options = RequestMethods.OPTIONS;
+    this.link = RequestMethods.LINK;
+    this.unlink = RequestMethods.UNLINK;
+    this.view = RequestMethods.VIEW;
+    this.lock = RequestMethods.LOCK;
+    this.unlock = RequestMethods.UNLOCK;
+    this.copy = RequestMethods.COPY;
+    this.purge = RequestMethods.PURGE;
+    this.propfind = RequestMethods.PROPFIND;
+  }
+
+  /**
+   * 
+   * @param {Function} cb
+   * @returns {void} 
+   */
+  forEach (cb) 
+  {
+    this.http_methods.map(cb);
+  }
+
+}

package/lib/types/FileType.js

@@ -0,0 +1,55 @@
+/**
+ * -->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>
+ *
+ * @PerfecTEvolutioN
+ * @MikeKarypidis
+ * @project - TurboExpress
+ * @name Middleware
+ * @namespace TurboExpress::types::FileType
+ * @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
+ *
+ * -->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>
+ */
+
+/** @type */
+module.exports = class FileType
+{
+  /** @type {String}    */      name;
+  /** @type {String}    */      fileName;
+  /** @type {String}    */      extension;
+  /** @type {String}    */      mime_type;
+  /** @type {String}    */      description;
+  /** @type {boolean}   */      is_saved;
+  /** @type {boolean}   */      is_binary;
+  /** @type {boolean}   */      is_compressible;
+  /** @type {boolean}   */      is_encrypted;
+  /** @type {number}    */      buffer_size;
+  /** @type {Buffer}    */      buffer;
+  /** @type {String}    */      owner;
+  /** @type {*}         */      metadata;
+
+
+  save(path, cb)
+  {
+
+  }
+
+  saveSync (path)
+  {
+
+  }
+
+  /**
+   * @param {*} by 
+   */
+  fileExtension (by)
+  {
+
+  }
+
+}

package/lib/types/Middleware.js

@@ -0,0 +1,59 @@
+/**
+ * -->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>
+ *
+ * @PerfecTEvolutioN
+ * @MikeKarypidis
+ * @project - TurboExpress
+ * @name Middleware
+ * @namespace TurboExpress::ServerCallback
+ * @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
+ *
+ * -->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>
+ */
+
+module.exports = class Middleware 
+{
+
+  /**
+   * @doc all this properties will be used once to find if middleware is matching the route.
+   * if it does then the callbacks will be pushed at the begining of the route.callbacks
+   * 
+   * @useMinLength actually if path endwith /* that group all of these middlewares in their own category
+   * on server callback will be executed 2 matching functions
+   * 
+   * 1rst one is exact that mean it will try to match route that not end with /* and has the same length of path parts;
+   * 
+   * if the first not find something, only then it will go to the next function
+   * in the second function, here is where useMinLength = true group is used.
+   * 
+   * 
+   */
+
+
+  /** @type {String}                  */ path;
+  /** @type {String[]}                */ path_parts;
+  /** @type {Boolean}                 */ useMinlength;
+  /** @type {Number}                  */ size;
+  /** @type {Function[]}              */ callbacks = new Array();
+
+  /**
+   * todo validation check and warn for wrong type;
+   * @param {String} path
+   * @param {Function[]} callbacks
+   */
+  constructor(path, callbacks) 
+  {
+    this.path = path;
+    this.path_parts = path.split("/").filter((f) => f !== "");
+    this.useMinlength = path.endsWith("/*");
+    this.size = path.endsWith("/*")
+      ? this.path_parts.length - 1
+      : this.path_parts.length;
+    this.callbacks = callbacks || [];
+  }
+};

package/lib/types/RequestInterface.js

@@ -0,0 +1,398 @@
+/**
+ * -->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>
+ *
+ * @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
+ * 
+ * -->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>
+ */
+
+/**
+ * @typedef {Object} BasicAuth
+ * @property {String} user
+ * @property {String} pass
+ *
+ * @typedef {http.IncomingMessage} incme
+ */
+
+const http = require("http");
+const FileType = require("./FileType");
+const Route = require("./Route");
+const ValidationSchema = require("./ValidationSchema");
+
+
+/** @interface */
+module.exports = class RequestInterface 
+{
+  /** @type {http.IncomingMessage}                    */ IncomingMessage;
+  /** @type {Route}                                   */ current;
+  /** @type {import("../TurboServer")}                */ instance;
+  /** @type {Map<String, import("mongoose").Model>}   */ models;
+
+  /**
+   *  @type {Map<String, *>}
+   *  @doc protected variable
+   *  usually it will be Map<String, String>
+   *  but also can be <String, Number> or <String, Boolean>
+   */
+  _params;
+
+  /**
+   *  @type {Buffer}
+   *  @doc protected variable
+   */
+  _body = Buffer.alloc(0);
+
+  /**
+   *  @type {FileType[]}
+   *  @doc protected variable
+   */
+  _files = new Array();
+
+  /**
+   * @type {ValidationSchema[]}
+   * @doc protected variable
+   */
+  _validations = new Array();
+
+  /**
+   * @type {Map<String, any>}
+   * @doc protected variable
+   */
+  validData = new Map();
+
+  /**
+   * @type {ValidationSchema[]}
+   * @doc protected variable
+   */
+  _validation_errors = new Array();
+
+  /**
+   * @type {Boolean}
+   * @doc protected variable
+   */
+  bodyFetched = false;
+
+  /**
+   * @param {http.IncomingMessage} req
+   * @param {Route} current
+   * @param {import("../TurboServer")} instance
+   */
+  constructor(req, current, instance) 
+  {
+    this.current = current;
+    this.IncomingMessage = req;
+    this.state = new Map();
+    this.instance = instance;
+    this.models = instance.models;
+  }
+
+  addValidation (validation) {
+    if(validation instanceof ValidationSchema === true) {
+      this._validations.push(validation);
+    }
+  }
+
+  async execute_validation (res, injectedData, next) {
+    const r = await this.validateIncomingData();
+    if(r === -1) return res.status(400).json({ errors: this._validation_errors })
+    next();
+  }
+
+  runmethod_addvalidation (res, injectedData, next) {
+    this.addValidation(injectedData.validation);
+    next()
+  }
+
+  getAppState () {
+    return this.instance.appState;
+  }
+
+  validateDataObj () {
+    let obj = {};
+    this.validData.forEach((v, k) => obj[k] = v);
+    return obj;
+  }
+
+
+  /**
+   * 
+   * @param {String} name 
+   * @returns {import("mongoose").Model}
+   */
+  getModel (name) {
+    return this.models.get(name) || null;
+  }
+
+  files () {
+    
+  }
+
+  /**
+   * @returns {Number} 0 | -1 for error;
+   */
+  async validateIncomingData() {
+    await this.body();
+    for (let index = 0; index < this._validations.length; index++) await this._validations[index].validate(this);
+    if(this._validation_errors.length > 0) return -1;
+    return 0;
+  }
+
+  // ! methods not implemented //
+
+  /** @require_implemetation  @returns {String} token */
+  getBearerAuth() {
+    console.log("You have not implemeneted method 'getBearerAuth'");
+  }
+  /** @require_implemetation @returns {BasicAuth} {user:str, pass:str} */
+  getBasicAuth() {
+    console.log("You have not implemeneted method 'getBasicAuth'");
+  }
+  /** @require_implemetation @returns {Object}  */
+  getBearerJWTData() {
+    console.log("You have not implemeneted method 'getBearerJWTData'");
+  }
+  /** @require_implemetation @returns {Number} 0 ok or -1 for error */
+  validateFormdata() {
+    console.log("You have not implemeneted method 'validateFormdata'");
+  }
+
+  /**
+   * @interface_method
+   * @param {String | Buffer} rowData
+   * @returns {String} xml string
+   */
+  getXmlBody(rowData) {
+    console.log("You have not implemeneted method 'getXmlBody'");
+    return rowData;
+  }
+
+  /**
+   * @interface_method
+   * @doc - you can override this method;
+   * @param {String | Buffer} rowData
+   * @returns {Object | Object[]}
+   */
+  getFormUrlEncoded(rowData) {
+    console.log("You have not implemeneted method 'getFormUrlEncoded'");
+    return rowData;
+  }
+
+  /**
+   * @interface_method
+   * @doc - you can override this method;
+   * @param {String | Buffer} rowData
+   * @returns {*} default is string
+   */
+  getDefaultBody(rowData) {return rowData.toString()}
+
+  // ? implemented methods //
+
+  async genericBody() 
+  {
+    if(this.bodyFetched === true) return this._body.toString(); // on 1 milion loops -> gain ~100ms performance;
+    return new Promise((resolve, reject) => {
+      let data = [];
+      this.IncomingMessage.on("data", (e) => {
+        data.push(e);
+      });
+      this.IncomingMessage.on("end", (e) => {
+        this.bodyFetched = true;
+        this._body = Buffer.concat(data);
+        resolve(this._body.toString());
+      });
+    });
+  }
+
+  /**
+   * @doc some methods are not implmenent by default
+   * @returns {*} base on headers["content-type"]
+   */
+  async body() 
+  {
+    switch (this.headers()["content-type"]) {
+      case "application/json":
+        return this.getJsonBody(await this.genericBody());
+      case "application/javascript":
+        return this.getJavascriptBody(await this.genericBody());
+      case "application/xml":
+        return this.getXmlBody(await this.genericBody());
+      case "text/html":
+        return this.getHtmlBody(await this.genericBody());
+      case "text/plain":
+        return (await this.genericBody()).toString();
+      case "application/x-www-form-urlencoded":
+        return this.getFormUrlEncoded(await this.genericBody());
+      default:
+        return this.getDefaultBody(await this.genericBody());
+        break;
+    }
+  }
+
+  /**
+   * @param {String | Buffer} rowData
+   * @returns {Object | Object[]}
+   */
+  getJsonBody(rowData) 
+  {
+    return JSON.parse(rowData.toString());
+  }
+
+  /**
+   * @param {String | Buffer} rowData
+   * @returns {String}
+   */
+  getHtmlBody(rowData) 
+  {
+    return rowData.toString();
+  }
+
+  /**
+   * @doc - you can override this method;
+   * @param {String | Buffer} rowData
+   * @returns {String} string of javascript code;
+   */
+  getJavascriptBody(rowData) 
+  {
+    return rowData.toString();
+  }
+
+  /**
+   * @doc - the first time this function is running, will cache the params for next use;
+   * @returns {Map<String, Object>}
+   */
+  params() 
+  {
+    if (this._params) return this._params; // ! this line improving performance 2-3x times per 1000 lopping params();
+    this._params = new Map();
+    this.current.dynamic_path_parts.map((i) => {
+      this._params.set(i.property, this.current.current_path_parts[i.index]);
+    });
+    return this._params;
+  }
+
+  /**
+   * @doc - the first time this function is running, will cache the params for next use;
+   * @returns {Object} Object
+   */
+  paramsObj() 
+  {
+    let returnObj = new Object();
+    if (this._params) { // ! this line improving performance 2-3x times per 1000 lopping params();
+      this._params.forEach((v, k) => returnObj[k] = v);
+      return returnObj; 
+    }
+    this._params = new Map();
+    this.current.dynamic_path_parts.map((i) => {
+      this._params.set(i.property, this.current.current_path_parts[i.index]);
+    });
+    this._params.forEach((v, k) => returnObj[k] = v);
+    return returnObj; 
+  }
+
+  /** @returns {URLSearchParams} URLSearchParams */
+  queries() 
+  {
+    return new URLSearchParams(this.IncomingMessage.url.split("?")[1] || "");
+  }
+
+  /** @returns {Object} Object */
+  queriesObj ()
+  {
+    let queriesObj = new Object()
+    new URLSearchParams(this.IncomingMessage.url.split("?")[1] || "").forEach((v, k) => {
+      if(queriesObj[k]) {        
+        if(queriesObj[k] instanceof Array === true) {
+          queriesObj[k].push(v);
+        } else {
+          queriesObj[k] = [queriesObj[k], v];
+        }
+      } else {
+        queriesObj[k] = v
+      }
+    });
+    return queriesObj;
+  }
+
+  /** @returns {http.IncomingMessage.headers} http.IncomingMessage.headers */
+  headers() 
+  {
+    return this.IncomingMessage.headers;
+  }
+
+  /** @returns {String}  */
+  method() 
+  {
+    return this.current.method;
+  }
+
+  /** @returns {String}  */
+  httpVersion() 
+  {
+    return this.IncomingMessage.httpVersion;
+  }
+
+  /** @returns {String}  */
+  remoteAddress() 
+  {
+    return this.IncomingMessage.socket.remoteAddress;
+  }
+
+  /** @returns {Number}  */
+  remotePort() 
+  {
+    return this.IncomingMessage.socket.remotePort;
+  }
+
+  /** @returns {String}  */
+  localAddress() 
+  {
+    return this.IncomingMessage.socket.localAddress;
+  }
+
+  /** @returns {Number}  */
+  localPort() 
+  {
+    return this.IncomingMessage.socket.localPort;
+  }
+
+  /** @returns {String}  */
+  localPort() 
+  {
+    return this.IncomingMessage.socket.localPort;
+  }
+
+  /** @returns {String}  */
+  url() 
+  {
+    return this.IncomingMessage.url;
+  }
+
+  /**
+   * @param {String} key
+   * @param {*} value
+   * @returns {void}
+   */
+  setState(key, value) 
+  {
+    this.state.set(key, value);
+  }
+
+  /**
+   * @param {String} key
+   * @returns {* | null}
+   */
+  useState(key) 
+  {
+    return this.state.get(key) || null;
+  }
+  
+};