turbo-express-js 1.0.0

package/lib/types/ResponseInterface.js

@@ -0,0 +1,94 @@
+/**
+ * -->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>
+ *
+ * @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
+ * 
+ * -->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>
+ */
+
+const http = require("http");
+const Route = require("./Route");
+
+module.exports = class ResponseInterface 
+{
+  /** @type{http.OutgoingMessage}                     */   OutgoingMessage;
+  /** @type {Route}                                   */   current;
+  /** @type {import("../TurboServer")}                */   instance;
+  /** @type {Map<String, import("mongoose").Model>}   */   models;
+
+  /**
+   * @param {http.OutgoingMessage} res
+   * @param {Route} current
+   * @param {import("../TurboServer")} instance
+   */
+  constructor(res, current, instance) 
+  {
+    this.current = current;
+    this.OutgoingMessage = res;
+    this.statusCode = 200;
+    this.response = new Object();
+    this.instance = instance;
+    this.models = instance.models;
+  }
+
+  status(status) 
+  {
+    this.statusCode = !isNaN(status) ? Number(status) : 500;
+    return this;
+  }
+
+  send(string, contentType) 
+  {
+    this.OutgoingMessage.writeHead(this.statusCode, {
+      "Content-Type": contentType || "text/html",
+    });
+    this.OutgoingMessage.end(string);
+  }
+
+  json(data) 
+  {
+    this.OutgoingMessage.writeHead(this.statusCode, {
+      "Content-Type": "application/json",
+    });
+    this.OutgoingMessage.end(JSON.stringify(data));
+  }
+
+  /** @require_implemetation  @returns {void} should implement 1) convert object to xml 2) send response 3) close the connection */
+  xml() {
+    console.log("You have not implemeneted method 'xml'");
+  }
+  /** @require_implemetation @returns {BasicAuth} comming soon */
+  sendFile() {
+    console.log("You have not implemeneted method 'sendFile'");
+  }
+  /** @require_implemetation @returns {Object} broadact data to specific users, works with web sockets connections  */
+  broadcast() {
+    console.log("You have not implemeneted method 'broadcast'");
+  }
+  /** @require_implemetation @returns {Number} broadact data to specific user, works with web sockets connections */
+  broadcastTo() {
+    console.log("You have not implemeneted method 'broadcastTo'");
+  }
+
+  /** @doc - require to be implemented */
+  useRedis() {
+    console.log("You have not implemeneted method 'useRedis'");
+  }
+  /** @doc - require to be implemented */
+  storeRedis() {
+    console.log("You have not implemeneted method 'storeRedis'");
+  }
+  /** @doc - require to be implemented */
+  refreshRedis() {
+    console.log("You have not implemeneted method 'refreshRedis'");
+  }
+};

package/lib/types/ResponseMongo.js

@@ -0,0 +1,35 @@
+/**
+ * -->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>
+ *
+ * @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
+ * 
+ * -->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>
+ */
+
+// todo implmenet some basic methods for mongodb;
+
+const ResponseInterface = require("./ResponseInterface");
+
+module.exports = class ResponseMongo extends ResponseInterface
+{
+
+  sendCollRead () {}
+
+  sendCollWrite () {}
+
+  sendCollUpdate () {}
+
+  sendCollDelete () {}
+
+  exeRaadOperation(Model, )
+
+}

package/lib/types/Route.js

@@ -0,0 +1,97 @@
+/**
+ * -->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>
+ *
+ * @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
+ * 
+ * -->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>
+ */
+
+const { matching_route_middlewares } = require("../utils")
+const Middleware = require("./Middleware")
+
+module.exports = class Route 
+{
+
+  /**
+   * @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.
+   * 
+   * 
+   */
+
+  /**
+   * @typedef {Object} DynamicPathPart;
+   * @property {Number} index;
+   * @property {String} property;
+   */
+
+  /** @type {String}                  */  path
+  /** @type {String}                  */  method
+  /** @type {String[]}                */  path_parts
+  /** @type {DynamicPathPart[]}       */  dynamic_path_parts
+  /** @type {Boolean}                 */  useMinlength
+  /** @type {Number}                  */  size
+  /** @type {Function[]}              */  callbacks = [] 
+  /** @type {String[]}                */  current_path_parts = [];  
+
+  /**
+   * todo validation check and warn for wrong type;
+   * @param {String} path 
+   * @param {Function[]} callbacks 
+   * @param {Middleware[]} middlewares
+   * @param {Middleware[]} middlewares_end
+   */
+  constructor(path, method, callbacks, middlewares, middlewares_end) {
+    this.path = path;
+    this.method = method;
+    this.path_parts = path.split("/").filter(f => f !== "");
+    this.dynamic_path_parts = this.#setDynamicPathParts();
+    this.useMinlength = path.endsWith("/*");
+    this.size = path.endsWith("/*") ? this.path_parts.length - 1 : this.path_parts.length;
+    this.useMiddlewares(middlewares)
+    callbacks.map(c => {
+      if(c instanceof Function) return this.callbacks.push(c);
+      throw new Error("Callback should be instance of function");
+    })
+    this.useMiddlewares(middlewares_end)
+    //console.log(this)
+  }
+
+  setCurrentPathParts (current_path_parts) { this.current_path_parts = current_path_parts; }
+  getCurrentPathParts () { return this.current_path_parts; }
+
+  #setDynamicPathParts ()
+  {
+    let tmpArr = []
+    for (let i = 0; i < this.path_parts.length; i++) {
+      if(this.path_parts[i].startsWith(":")) { tmpArr.push({ index: i, property: this.path_parts[i].substring(1, this.path_parts[i].length) }) }
+    }
+    return tmpArr;
+  }
+
+  /**
+   * @param {Middleware[]} middlewares 
+   */
+  useMiddlewares (middlewares)
+  {
+    matching_route_middlewares(this.path_parts, this.useMinlength, this.size, middlewares).map(m => m.callbacks.map(mc => this.callbacks.push(mc)))
+  }
+
+}

package/lib/types/RunMethodType.js

@@ -0,0 +1,49 @@
+/**
+ * -->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>
+ *
+ * @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 RunMethodType 
+{
+
+  /**
+   * 
+   * 
+   */
+
+
+  /** @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/ValidationError.js

@@ -0,0 +1,56 @@
+/**
+ * -->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>
+ *
+ * @PerfecTEvolutioN
+ * @MikeKarypidis
+ * @project - TurboExpress
+ * @name ValidationError
+ * @namespace TurboExpress::types::ValidationError
+ * @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 ValidationError
+{
+
+  /** @type {String}                  */ namespace;
+  /** @type {String}                  */ property;
+  /** @type {*}                       */ value;
+  /** @type {String[]}                */ errors = new Array();
+
+  /**
+   * 
+   * @param {String} path
+   * @param {Function[]} callbacks
+   */
+  constructor(namespace, property) 
+  {
+    this.namespace = namespace;
+    this.property = property;
+    this.value = null;
+  }
+
+  /**
+   * @param {String} error 
+   */
+  addError (error)
+  {
+    this.errors.push(error);
+  }
+
+  setValue(value) {
+    if(value === undefined) this.value = null;
+    this.value = value;
+  }
+
+
+};

package/lib/types/ValidationSchema.js

@@ -0,0 +1,139 @@
+/**
+ * -->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>
+ *
+ * @PerfecTEvolutioN
+ * @MikeKarypidis
+ * @project - TurboExpress
+ * @name ValidationSchema
+ * @namespace TurboExpress::types::ValidationSchema
+ * @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
+ *
+ * -->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>
+ * 
+ * For each property, we are set a new validation schema instance;
+ * 
+ */
+
+const ValidationMethodType = require("../enum/ValidationMethodType");
+const RequestInterface = require("./RequestInterface");
+const ValidationError = require("./ValidationError");
+
+/**
+ * @typedef {Object} ValidationType
+ * @property {String} name;
+ * @property {String} value;
+ */
+
+/** @Type */
+module.exports = class ValidationSchema
+{
+
+  /** @type {String}                  */ namespace;
+  /** @type {String}                  */ property;
+  /** @type {ValidationType[]}        */ validations;
+  /** @type {Boolean}                 */ is_required;
+  /** @type {*}                       */ default_value;
+
+  /**
+   * @param {String}              property - is required
+   * @param {ValidationType[]}    validations - is required
+   * @param {Boolean}             is_required - default false
+   * @param {*}                   default_value
+   * @param {String}              namespace - default is body
+   */
+  constructor(property, validations, is_required=true, default_value=null, namespace="body") 
+  {
+    this.namespace = namespace;
+    this.default_value = default_value;
+    this.validations = validations instanceof Array === true ? validations : [];
+    if(typeof property === "string") {
+      this.property = property;
+    } else {
+      throw new Error("property is required and should be type of string.");
+    }
+    this.is_required = typeof is_required === "boolean" ? is_required : false;
+  }
+
+  /**
+   * This method is async in case we want to intergrate it with database
+   * like is doc exist with that id.
+   * This is out of the box of the default implemetations.
+   * 
+   * @param {RequestInterface} req 
+   */
+  async validate (req)
+  {
+    const vError = new ValidationError(this.namespace, this.property);
+    let currentValue = await this.getCurrentValue(req);
+    if(currentValue === undefined) {
+      if(this.default_value) {
+        currentValue = this.default_value;
+      }
+      if(this.is_required && (currentValue === undefined || currentValue === null)) {
+        vError.addError(`Property ${this.property} is required.`);
+        req._validation_errors.push(vError);
+        return console.log("~~~~~~~~~`");
+      }
+    }
+    if(currentValue === undefined && this.is_required === false) return;
+    this.validations.map((validation, vindex) => {
+      switch (validation.name) {
+        case ValidationMethodType.MINLENGTH:
+          if(currentValue.length < validation.value) {
+            vError.addError(`Property ${this.property} min length is ${validation.value}`)
+          }
+          break;
+
+        case ValidationMethodType.MAXLENGTH:
+          if(currentValue.length > validation.value) {
+            vError.addError(`Property ${this.property} max length is ${validation.value}`)
+          }
+          break;
+
+        case ValidationMethodType.ONEOF:
+          if(validation.value instanceof Array === true && !validation.value.some(s => s === currentValue)) {
+            vError.addError(`Property ${this.property} should be one of: < ${validation.value.join(",")} >`)
+          }
+          break;
+
+        case ValidationMethodType.SIZE:
+          console.log("min size here", validation.value);
+          
+          break;
+      
+        default:
+          break;
+      }
+    })
+    if(vError.errors.length > 0) {
+      vError.setValue(currentValue);
+      req._validation_errors.push(vError);
+    } else {
+      req.validData.set(this.property, currentValue);
+    }
+  }
+
+
+  /**
+   * 
+   * @param {RequestInterface} req 
+   */
+  async getCurrentValue (req)
+  {
+    if(this.namespace === "query") {
+      return req.queriesObj()[this.property];
+    } else if(this.namespace === "body") {
+      const body = await req.body();
+      return body[this.property];
+    } else if(this.namespace === "params") {
+      return req.params().get(this.property);
+    }
+  }
+
+
+};

package/lib/types/ValidationStaticTypes.js

@@ -0,0 +1,34 @@
+/**
+ * -->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>
+ *
+ * @PerfecTEvolutioN
+ * @MikeKarypidis
+ * @project - TurboExpress
+ * @name ValidationStaticTypes
+ * @namespace TurboExpress::types::ValidationStaticTypes
+ * @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
+ *
+ * -->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>
+ * 
+ * For each property, we are set a new validation schema instance;
+ * 
+ */
+
+/** @StaticType */
+module.exports = class ValidationStaticTypes
+{
+  static MINLENGTH = "MINLENGTH";
+  static MAXLENGTH = "MAXLENGTH";
+  static ISREQUIRED = "ISREQUIRED";
+  static ONEOF = "ONEOF";
+  static NOTONEOF = "NOTONEOF";
+  static REGEX = "REGEX";
+  static RANGE = "RANGE";
+  static FUNCTION = "FUNCTION";
+}
+

package/lib/utils.js

@@ -0,0 +1,111 @@
+const Middleware = require("./types/Middleware");
+const Route = require("./types/Route");
+
+/**
+ * @param {String} current_path 
+ * @param {Route[]} routes 
+ * @returns {Route | null}
+ */
+module.exports.matching_route = (current_path, routes) => {
+
+  const path_parts = current_path.split("/").filter(f => f !== "");
+  let samelength = routes.filter(f=> f.size === path_parts.length && !f.useMinlength)
+  let curr = null;
+  for (let index = 0; index < samelength.length; index++) {
+    let ok = true;
+    path_parts.map((p, i) => {
+      if(samelength[index].path_parts[i].startsWith(":")) return;
+      if(p !== samelength[index].path_parts[i]) ok = false;
+    });
+    if(ok) { curr = samelength[index]; break; }
+  }
+  if(curr) curr.setCurrentPathParts(path_parts);
+  return curr;
+
+}
+
+
+/**
+ * @param {String} current_path 
+ * @param {Route[]} routes 
+ * @returns {Route | null}
+ */
+ module.exports.matching_nonexact_route = (current_path, routes) => {
+
+  const path_parts = current_path.split("/").filter(f => f !== "");
+  let nonexactroutes = routes.filter(f => f.useMinlength && f.size < path_parts.length).sort((a, b) => b.size - a.size);
+  let globalnotfound = routes.find(f => f.size === 1 && f.path_parts[0] === "*");
+  if(globalnotfound) { nonexactroutes.push(globalnotfound); }
+  let curr = null;
+  for (let index = 0; index < nonexactroutes.length; index++) {
+    let ok = true;
+    path_parts.map((p, i) => {
+      if(i === path_parts.length - 1) return;
+      if(i > nonexactroutes[index].path_parts.length - 2) return // route.path_parts are smaller in length than current path;
+      if(nonexactroutes[index].path_parts[i].startsWith(":")) return; // dynamic route
+      if(p !== nonexactroutes[index].path_parts[i]) ok = false;
+    });
+    if(ok) { curr = nonexactroutes[index]; break; }
+  }
+  if(curr) curr.setCurrentPathParts(path_parts);
+  return curr;
+
+}
+
+
+/**
+ * @param {String[]}        current_path 
+ * @param {Boolean}         current_useMinLength 
+ * @param {Number}          current_length
+ * @param {Middleware[]}    middlewares
+ * @returns {Middleware[]}
+ */
+ module.exports.matching_route_middlewares = (current_path_parts, current_useMinLength, current_length, middlewares) => 
+ {
+  const matchedMiddlewares = []
+  for (let m = 0; m < middlewares.length; m++) {
+    if(middlewares[m].useMinlength === false) 
+    {
+      if(current_useMinLength) continue;
+      if(middlewares[m].size !== current_length) continue;
+      let checker = true;
+      for (let i = 0; i < current_path_parts.length; i++) {
+        if(current_path_parts[i].startsWith(":") && middlewares[m].path_parts[i].startsWith(":")) continue;
+        if(current_path_parts[i] !== middlewares[m].path_parts[i]) {
+          checker = false;
+          break;
+        }
+      }
+      if(checker) {matchedMiddlewares.push(middlewares[m]); }
+
+    } else 
+    {
+      if(current_useMinLength) 
+      {
+        if( !(middlewares[m].size <= current_length) ) continue;
+        let checker = true;
+        for (let i = 0; i < middlewares[m].size; i++) {
+          if(current_path_parts[i].startsWith(":") && middlewares[m].path_parts[i].startsWith(":")) continue;
+          if(current_path_parts[i] !== middlewares[m].path_parts[i]) {
+            checker = false;
+            break;
+          }
+        }
+        if(checker) {matchedMiddlewares.push(middlewares[m]); }
+      } else 
+      {
+        if( !(middlewares[m].size < current_length) ) continue;
+        let checker = true;
+        for (let i = 0; i < middlewares[m].size; i++) {
+          if(current_path_parts[i].startsWith(":") && middlewares[m].path_parts[i].startsWith(":")) continue;
+          if(current_path_parts[i] !== middlewares[m].path_parts[i]) {
+            checker = false;
+            break;
+          }
+        }
+        if(checker) {matchedMiddlewares.push(middlewares[m]); }
+      }
+    }
+  }
+  return matchedMiddlewares;
+}

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "turbo-express-js",
+  "version": "1.0.0",
+  "description": "turbo express performance security easy to use web server framework ",
+  "main": "index.js",
+  "directories": {
+    "lib": "lib"
+  },
+  "dependencies": {
+
+  },
+  "peerDependencies": {
+    "multiparty": "^4.2.3"
+  },
+  "devDependencies": {},
+  "scripts": {
+    "start": "nodemon index.test.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/breathfunwithmindte/turbo-express.git"
+  },
+  "keywords": [
+    "web",
+    "server",
+    "framwork",
+    "lightweight",
+    "minimalistic",
+    "superfast",
+    "fast"
+  ],
+  "author": "Mike Karypidis",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/breathfunwithmindte/turbo-express/issues"
+  },
+  "homepage": "https://github.com/breathfunwithmindte/turbo-express#readme"
+}

package/samples/README.md

@@ -0,0 +1 @@
+# comming soon samples 

package/todo.md

@@ -0,0 +1,11 @@
+# cors middleware                           [DONE]  
+# authentication middleware jwt             [DONE]
+# build form                                [DONE]
+
+# middlewares after                         [DONE]
+
+# debug one more
+
+--- deploy ---
+
+# 

package/version_management.md

@@ -0,0 +1,13 @@
+# ALL CHANGES THAT HAPPENDS WILL BE REGISTERED HERE AND ON THE GITHUB.
+
+
+
+
+
+
+
+# 1.0.1
+  ... comming soon ...
+
+# 1.0.0
+  deploy