turbo-express-js 1.0.2 → 1.0.4

package/bin/attachmentupload.test.js

@@ -0,0 +1,26 @@
+
+/**
+ * 
+ * @param {RequestInterface} req 
+ * @param {ResponseInterface} res 
+ */
+async function controller (req, res)
+{
+  //console.log(req._validation_errors)
+
+  req._files.map(f => f.unlink());
+
+  res.status(200).json({
+    body: await req.body(),
+    body_hash: req.body_hash(),
+    valid_data: req.validDataObj(),
+    files: req.files(),
+
+    //bb: req.validDataObj(),
+    cont: req.content_type
+  })
+}
+
+app.use("/*", TurboExpress.Upload({ memory: true, folder: "/public" }));
+
+app.post("/api/v1/test", controller);

package/bin/custombadrequesterror.test.js

@@ -0,0 +1,11 @@
+class MyValidationError extends TurboExpress.ValidationTypes.ValidationError
+{
+  
+}
+
+class MyRequest extends RequestInterface
+{
+  ValidationError = MyValidationError
+}
+
+app.Request = MyRequest;

package/bin/exemasterworker.test.js

@@ -0,0 +1,66 @@
+const TurboExpress = require("./lib/TurboServer");
+const RequestInterface = require("./lib/types/RequestInterface");
+const ResponseInterface = require("./lib/types/ResponseInterface");
+
+
+const app = new TurboExpress(2);
+
+
+
+TurboExpress.exeWorker(async () => 
+{
+  console.log("Hey")
+})
+
+
+TurboExpress.exeMaster(async () => 
+{
+
+
+  console.log("Hello world");
+
+
+});
+
+
+class MyResponse extends ResponseInterface
+{
+  mymethod () {
+    console.log("my method")
+  }
+}
+
+app.Response = MyResponse;
+
+app.use("/*", TurboExpress.Cors({
+   origins: ["http://localhost:3000"]
+}));
+/**
+ * 
+ * @param {RequestInterface} req 
+ * @param {ResponseInterface} res 
+ */
+function homepage (req, res) {
+  console.log("controller")
+  res.header("something", "wowowowo")
+  res.status(200).json({ user: { username: "kristina" } })
+}
+
+const router = new TurboExpress.Router();
+router.use("/*", TurboExpress.Cors({}))
+router.get("/something", homepage)
+
+app.use("", router);
+
+app.get("/something1", homepage);
+// app.options("/something", (req, res) => res.send(""));
+// app.head("/something", (req, res) => res.send(""));
+// app.get("/", homepage);
+
+
+// app.all("/*", (req, res) => {
+//   res.send("not")
+// })
+
+
+app.listen(3001, () => console.log("Server is running on port 3000"));

package/index.test.js

@@ -0,0 +1,31 @@
+const TurboExpress = require("./lib/TurboServer");
+const RequestInterface = require("./lib/types/RequestInterface");
+const ResponseInterface = require("./lib/types/ResponseInterface");
+
+
+const app = new TurboExpress(1);
+
+
+class MyValidationError extends TurboExpress.ValidationTypes.ValidationError
+{
+  
+}
+
+class MyRequest extends RequestInterface
+{
+  ValidationError = MyValidationError
+}
+
+app.Request = MyRequest;
+
+app.setLocales("/locales")
+
+
+app.get("/public/*", TurboExpress.Static({ folder: "/public" }))
+
+// 6976355584
+
+
+app.get("/", () => {});
+
+app.listen(3001, () => console.log("Server is running on port 3000"));

package/lib/TurboServer.js

@@ -23,23 +23,16 @@ const Router = require("./Router");
 const cluster = require("cluster");
 const RequestInterface = require("./types/RequestInterface");
 const ResponseInterface = require("./types/ResponseInterface");
-const { matching_route, matching_nonexact_route, Log } = require("./utils");
+const Util = 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");
+const { static_middleware, attachment_middleware, validation_middleware, runmethod_middleware, buildform_middleware, authentication_middleware, cors_middleware } = require("./middlewares");
 const AuthenticationService = require("./services/AuthenticationService");
-const SystemService = require("./services/SystemService");
-const JWTBcryptMongoDBAuthService = require("./types/default/JWTBcryptMongoDBAuthService");
+const SystemTypes = require("./types/SystemTypes");
+const ValidationTypes = require("./types/ValidationTypes");
+const ExpressServices = require("./services");
 
 
 module.exports = class TurboServer
@@ -47,15 +40,12 @@ module.exports = class TurboServer
   static Router = Router;
   static AuthenticationService = AuthenticationService;
 
-  static ValidationSchema = ValidationSchema;
-  static ValidationMethodType = ValidationMethodType;
-  
-  static SystemService = SystemService;
-  static JWTBcryptMongoDBAuthService = JWTBcryptMongoDBAuthService;
-
 
-  static Log = Log;
+  static ValidationTypes = ValidationTypes;
+  static ExpressServices = ExpressServices;
 
+  static Log = Util.Log;
+  static Util = Util;
 
   /**
    * @typedef {Object} StaticOptions
@@ -94,16 +84,13 @@ module.exports = class TurboServer
    * @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 
-    })
+    return attachment_middleware.bind({ folder: AttachmentOptions.folder || "/storage", memory: AttachmentOptions.memory || true })
   }
 
   /**
@@ -111,7 +98,7 @@ module.exports = class TurboServer
    * If there is an error, it throws the response with that error.
    * 
    * @typedef  {Object} ValidationOptions
-   * @property {ValidationSchema[]}  validations
+   * @property {import("./types/ValidationSchema")[]}  validations
    * 
    * @param {ValidationOptions} ValidationOptions 
    * @returns 
@@ -146,7 +133,7 @@ module.exports = class TurboServer
   /**
    * 
    * @typedef  {Object} AuthenticationOptions
-   * @property {AuthenticationService} authentication_service
+   * @property {import("./services/AuthenticationService")} authentication_service
    * 
    * @param {AuthenticationOptions} AuthenticationOptions 
    * @returns 
@@ -184,6 +171,19 @@ module.exports = class TurboServer
     }
   }
 
+  /**
+   * Execute code only in master instance
+   * 
+   * @param {Function} cb 
+   */
+  static async exeWorker (cb)
+  {
+    if(cluster.isWorker)
+    {
+      await cb();
+    }
+  }
+
 
 
   /** @type{http.Server}    */ #server;
@@ -218,6 +218,7 @@ module.exports = class TurboServer
   /** @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
+  /** @type {import("./services/LocaleService")}           */     localeService    =   new ExpressServices.LocaleService();
 
   /**
    * @param {Number} CLUSTERSLENGTH
@@ -305,6 +306,16 @@ module.exports = class TurboServer
     
   }
 
+  setLocales (locale_directory)
+  {
+    this.localeService.fillLocales(locale_directory);
+  }
+
+  /** @returns {http.Server} */
+  getServer () {
+    return this.#server;
+  }
+
 
   logRoutes ()
   {

package/lib/middlewares/attachment_middleware.js

@@ -25,65 +25,19 @@ const multiparty = require("multiparty")
 * @param {ResponseInterface} res 
 * @param {*} next 
 */
-module.exports = function attachment_middleware (req, res, next) 
+module.exports = async 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)
+  if(this.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, "@@@")
+    await req.body();
+    req._files.map(f => {
+      if(req.body_hash()[f.name]) {
+        req._body_hash[f.name] = f.save(this.folder);
+      }
     })
-
-  } 
-  else 
-  {
-    throw new Error("Currently method to store files not in memory and handle large files, is not implemented.")
+    next();
+  } else {
+    console.log("Attachment middleware is not implemented for large files that require streaming os.write yet");
+    res.send("Attachment middleware is not implemented for large files that require streaming os.write yet");
   }
-
- 
 }

package/lib/middlewares/index.js

@@ -0,0 +1,17 @@
+const attachment_middleware = require("./attachment_middleware");
+const authentication_middleware = require("./authentication_middleware");
+const buildform_middleware = require("./buildform_middleware");
+const cors_middleware = require("./cors_middleware");
+const runmethod_middleware = require("./runmethod_middleware");
+const static_middleware = require("./static_middleware");
+const validation_middleware = require("./validation_middleware");
+
+module.exports = {
+  attachment_middleware,
+  authentication_middleware,
+  buildform_middleware,
+  cors_middleware,
+  runmethod_middleware,
+  static_middleware,
+  validation_middleware
+}

package/lib/services/FormDataService.js

@@ -0,0 +1,112 @@
+/**
+ * -->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>
+ *
+ * @PerfecTEvolutioN
+ * @MikeKarypidis
+ * @project - TurboExpress
+ * @name Middleware
+ * @namespace TurboExpress::services::AuthenticationService
+ * @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 multiparty = require("multiparty")
+const FileType = require("../types/FileType");
+
+
+module.exports = class FormDataService
+{
+
+  /** @type {import("../types/RequestInterface")} */ req;
+  /** @type {Boolean}                             */ log;
+  /** @type {Boolean}                             */ idk;
+
+  constructor(props) { this.req = props.req; this.log = props["log"] || false }
+  
+
+  async memory_read ()
+  {
+    const _body_hash = new Object();
+    return new Promise((resolve, reject) => {
+      const form = new multiparty.Form({  });
+      form.on("part", (part) => {
+        let buffer = Buffer.alloc(0);
+        let mine_type = part.headers["content-type"] || "";
+        let turboExpressFile = new FileType();
+        turboExpressFile.name = part.name;
+        turboExpressFile.file_name = part.filename || "nofilename";
+        turboExpressFile.is_binary= true;
+        turboExpressFile.extension = mine_type.split("/")[1] || "not-found"
+        turboExpressFile.mime_type = mine_type;
+        turboExpressFile.buffer_size = part.byteCount;
+        turboExpressFile.description = `File with name = {${turboExpressFile.file_name}}, sent with name = {${turboExpressFile.name}} and stored into server memory;`
+        
+        part.on("data", (chunk) => buffer = Buffer.concat([buffer, chunk]));
+        part.on("error", (err) => console.log(err))
+        part.on("end", () => {
+          turboExpressFile.buffer = buffer;
+          turboExpressFile.buffer_size = buffer.length;
+          this.req._files.push(turboExpressFile)
+          _body_hash[part.name] = `attachment::${turboExpressFile.id}`
+        })
+      })
+      form.on("error", (err) => {
+        console.log(err);
+        reject(err);
+      })
+      form.on("field", (name, value) => _body_hash[name] = this.#getValueByType(value));
+      form.on("progress", (...props) => {/** console.log(props) */})
+      form.on("close", () => {
+        if(this.log === true) console.log("Form data service completed without error, body hash is ~> ", _body_hash);
+        resolve(_body_hash);
+      })
+      form.parse(this.req.IncomingMessage);
+    })
+  }
+
+
+  #getValueByType (value)
+  {
+    if(typeof value !== "string") return null
+    if(value.toLowerCase() === "true") return true;
+    if(value.toLowerCase() === "false") return false;
+    if(value.toLowerCase() === "nil" || value.toLowerCase() === "null") return null;
+    if(!isNaN(Number(value))) return Number(value);
+    return value;
+  }
+
+}
+
+
+
+// ! store files
+// async memory_read ()
+// {
+//   const _body_hash = new Object();
+//   return new Promise((resolve, reject) => {
+//     const form = new multiparty.Form({
+//       autoFields: true,
+//       autoFiles: true,
+//       uploadDir: require("path").resolve() + "/samples"
+//     });
+//     // form.on("part", (part) => {
+//     //   console.log(part);
+//     //   //part.on("data", () => {console.log("dataa")})
+//     //   //part.on("end", (...e) => { console.log("end", e)})
+//     // })
+//     form.on("error", (err) => {
+//       console.log(err);
+//       reject(err);
+//     })
+//     form.on("field", (name, value) => _body_hash[name] = this.#getValueByType(value));
+//     form.on("progress", (...props) => {/** console.log(props) */})
+//     form.on("close", () => resolve(_body_hash))
+//     form.parse(this.req.IncomingMessage);
+//   })
+// }

package/lib/services/LocaleService.js

@@ -0,0 +1,46 @@
+const fs = require("fs");
+
+module.exports = class LocaleService
+{
+
+  /** @type {String[]}                         */ allowed_locales = new Array();
+  /** @type {Map<String, Map<String, String>>} */ locales = new Map();
+
+ 
+  /**
+   * 
+   * @param {String} directory 
+   */
+  fillLocales (directory)
+  {
+    fs.readdirSync(require("path").resolve() + directory).map(f => {
+      if(fs.statSync(require("path").resolve() + directory + "/" + f).isFile() === false)
+      {
+        this.allowed_locales.push(f);
+        const localeMap = new Map();
+        fs.readdirSync(require("path").resolve() + directory + "/" + f).map(j => {
+          const content = JSON.parse(fs.readFileSync(require("path").resolve() + directory + "/" + f + "/" + j, "utf-8"));
+          for (const key in content) if (Object.hasOwnProperty.call(content, key)) { localeMap.set(key, content[key]) }
+          this.locales.set(f, localeMap);
+        })
+      }
+    })
+    console.log(this)
+  }
+
+  /**
+   * 
+   * @param {String} locale 
+   * @param {String} key 
+   * @returns {String | null}
+   */
+  get (locale, key)
+  {
+    if(this.locales.has(locale))
+    {
+      return this.locales.get(locale).get(key) || null
+    }
+    return null;
+  }
+
+}

package/lib/services/index.js

@@ -0,0 +1,13 @@
+const AuthenticationService = require("./AuthenticationService");
+const FormDataService = require("./FormDataService");
+const LocaleService = require("./LocaleService");
+const SystemService = require("./SystemService");
+
+
+module.exports = class ExpressService
+{
+  static AuthenticationService = AuthenticationService;
+  static FormDataService = FormDataService;
+  static SystemService = SystemService;
+  static LocaleService = LocaleService;
+}

package/lib/statictypes/ContentType.js

@@ -0,0 +1,51 @@
+/**
+ * -->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>
+ *
+ * @PerfecTEvolutioN
+ * @project - TurboExpress
+ * @name TurboExpress
+ * @namespace TurboExpress::StaticTypes::ContentType
+ * @license - MIT
+ * @author - Mike Karypidis
+ * @version - 1.0.0
+ * @link - https://npmjs.com/TurboExpress
+ * @github - https://github.com/TurboExpress
+ * 
+ * -->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>
+ */
+
+module.exports = class ContentType
+{
+  static UNSET = "unset";
+  static UNKNOWN = "unknown";
+  static APPLICATION_JSON = "application/json";
+  static APPLICATION_JAVASCRIPT = "application/javascript";
+  static APPLICATION_XML = "application/xml";
+  static TEXT_HTML = "text/html";
+  static TEXT_PLAIN = "text/plain";
+  static APPLICATION_XWWWFORM_URLENCODED = "application/x-www-form-urlencoded"
+  static FORMDATA = "multipart/form-data"
+
+  static GET_CONTENT_TYPE (content_type)
+  {
+    if(!content_type) return ContentType.UNKNOWN;
+    if(content_type.includes("multipart/form-data")) return ContentType.FORMDATA;
+    switch (content_type) {
+      case "application/json":
+        return ContentType.APPLICATION_JSON;
+      case "application/javascript":
+        return ContentType.APPLICATION_JAVASCRIPT;
+      case "application/xml":
+        return ContentType.APPLICATION_XML;
+      case "text/html":
+        return ContentType.TEXT_HTML;
+      case "text/plain":
+        return ContentType.TEXT_PLAIN;
+      case "application/x-www-form-urlencoded":
+        return ContentType.APPLICATION_XWWWFORM_URLENCODED;
+      default:
+        return ContentType.UNKNOWN;
+    }
+  }
+
+}

package/lib/types/FileType.js

@@ -16,40 +16,63 @@
  * -->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>
  */
 
+const { random_string } = require("../utils");
+
 /** @type */
 module.exports = class FileType
 {
+  /** @type {String}    */      id;
   /** @type {String}    */      name;
-  /** @type {String}    */      fileName;
+  /** @type {String}    */      file_name;
   /** @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 {String}    */      description = "";
+  /** @type {String}    */      saved_url = "";
+  /** @type {boolean}   */      is_saved = false;
+  /** @type {boolean}   */      is_binary = true;
+  /** @type {boolean}   */      is_compressible = false;
+  /** @type {boolean}   */      is_encrypted = false;
   /** @type {number}    */      buffer_size;
   /** @type {Buffer}    */      buffer;
-  /** @type {String}    */      owner;
-  /** @type {*}         */      metadata;
-
+  /** @type {String}    */      owner = null;
+  /** @type {*}         */      metadata = {};
 
-  save(path, cb)
+  constructor ()
   {
-
+    this.id = random_string(14);
   }
 
-  saveSync (path)
-  {
 
+  save(path)
+  {
+    try {
+      require("fs").writeFileSync(`${require("path").resolve()}${path}/${this.id}.${this.extension}`, this.buffer);
+      this.is_saved = true;
+      this.saved_url = `${path}/${this.id}.${this.extension}`;
+      return this.saved_url;
+    } catch (error) {
+      this.is_saved = false;
+      return error.toString();
+    }
   }
 
-  /**
-   * @param {*} by 
-   */
-  fileExtension (by)
+  unlink ()
   {
+    if(this.is_saved)
+    {
+      try {
+        require("fs").unlinkSync(`${require("path").resolve()}${this.saved_url}`);
+        this.is_saved = false;
+        this.saved_url = "";
+      } catch (error) {
+        console.log(error);
+      }
+    }
+  }
 
+  build ()
+  {
+    return {...this, buffer: null}
   }
 
 }