turbo-express-js 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 breathfunwithmindte
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,187 @@
+# TurboServer - A Fast and Powerful Node.js Web Framework
+
+    TurboServer is inspired by Express.js and offers a similar API to make it easy for developers familiar with Express to get started. In fact, TurboServer offers many of the same features and middleware that Express does, making it a great choice for developers who want a fast and efficient alternative to Express.
+
+#
+
+    Additionally, TurboServer is built with an OOP architecture in mind, with Request and Response classes acting as interfaces. This makes it easy for developers to add new methods or override default functionality, leading to increased scalability and flexibility for your web applications.
+
+#
+
+## Installation
+
+To install TurboServer, simply run the following command:
+
+```
+npm install turboserver
+```
+
+## Getting Started
+
+Here's a simple example of how to create a basic server using TurboServer:
+
+``` javascript
+
+  const TurboServer = require('turboserver');
+
+  const app = new TurboServer(1);
+
+  app.get('/', (req, res) => {
+    res.send('Hello, World!');
+  });
+
+  app.listen(3000, () => {
+    console.log('Server started on port 3000');
+  });
+```
+
+# Clustering
+
+TurboServer is built to support clustering out of the box. By passing a number to the TurboServer constructor, you can specify how many worker processes to spawn for your application.
+
+In the example above, const app = new TurboServer(2) tells TurboServer to start two worker processes for the server. This allows the server to handle multiple requests simultaneously, improving the performance and scalability of your application.
+
+To take full advantage of the clustering feature, it's important to make sure your application is stateless and doesn't rely on local variables or in-memory storage. With proper configuration, clustering can help your application handle a large number of requests with ease.
+
+## Middlewares
+
+TurboServer includes a number of built-in middlewares that you can use to add functionality to your application. Here are some of the most commonly used middlewares:
+Static
+
+The Static middleware serves static files from a specified folder:
+
+``` javascript
+  app.use(TurboServer.Static({ folder: '/public' }));
+```
+
+
+# Upload
+
+The Upload middleware handles file uploads:
+
+
+``` javascript
+ app.post('/upload', TurboServer.Upload({ folder: '/storage' }));
+```
+
+## Validation
+
+The Validation middleware validates incoming requests against a specified schema (can validate by namespaces<params, query, body>):
+
+``` javascript
+  app.use(TurboServer.Validation({ 
+  validations: [
+    new TurboServer.ValidationSchema("username", [
+      { name: TurboServer.ValidationMethodType.MINLENGTH, value: 3 }, 
+      { name: TurboServer.ValidationMethodType.MAXLENGTH, value: 14 },
+      { name: TurboServer.ValidationMethodType.ONEOF, value: ["Xristina"] }
+    ], true, "Default Value", "body")
+  ]
+}));
+```
+
+## Authentication
+
+The Authentication middleware handles user authentication:
+
+*work in progress still
+
+``` javascript
+  app.use(TurboServer.Authentication());
+```
+
+## BuildForm
+
+The BuildForm middleware parses some sort of model and can generate list of fields for external app (reactJS, nextJS) or for template engine like EJS:
+
+*work in progress still
+
+``` javascript
+  app.use(TurboServer.BuildForm());
+```
+
+## Cors
+
+The Cors middleware adds CORS headers to responses:
+
+*work in progress still
+
+``` javascript
+  app.use(TurboServer.Cors());
+```
+
+
+## Custom Middleware
+
+In addition to the built-in middlewares, TurboServer allows you to create your own custom middlewares for your application. Custom middleware functions can be used to add functionality to your application that is specific to your needs.
+
+To create a custom middleware function, simply define a function that takes three parameters: the request object, the response object, and the next function. The next function is a callback that is used to pass control to the next middleware function in the chain.
+
+Here's an example of a custom middleware function that logs the request method and URL to the console:
+
+``` javascript
+  function logger(req, res, next) {
+    console.log(`${req.method()} ${req.url()}`);
+    next();
+  }
+
+  app.use(logger);
+```
+
+In the above example, we define a logger function that logs the request method and URL to the console, and then calls the next function to pass control to the next middleware function in the chain. We then use the app.use method to add the logger function as a middleware function for all routes in our application.
+
+You can define as many custom middleware functions as you need, and they will be executed in the order in which they are added to the middleware stack.
+
+## Custom Middleware after controller
+
+In TurboServer, you can define middleware that will run after the controller method has completed. This can be useful for tasks such as logging, error handling, or any other post-processing that needs to be done after the response has been sent.
+
+To define an end middleware in TurboServer, you can use the useEndMiddleware method. This method takes a path pattern and one or more middleware functions as arguments. The middleware functions will be executed in the order they are passed to the method.
+
+Here is an example of how to define an end middleware in TurboServer:
+
+``` javascript
+  app.useEndMiddleware("/api/*", (req, res, next) => {
+    console.log("End middleware #1");
+    next();
+  }, (req, res, next) => {
+    console.log("End middleware #2");
+    next();
+  });
+```
+
+#
+
+## Router
+
+TurboServer offers a built-in Router to handle different HTTP methods and routes. The Router class is similar to the express.Router class, but it has some additional features. Here's a simple example of how to create a router and use it with TurboServer:
+
+``` javascript
+  const TurboServer = require('turboserver');
+
+  const app = new TurboServer(2);
+  const router = new TurboServer.Router();
+
+  router.get("/admin/:username", (req, res) => { res.send(req.params().get("username")) });
+
+  app.use('/api', router);
+
+  app.listen(3000, () => {
+    console.log('Server started on port 3000');
+  });
+
+```
+
+## About the Author
+
+Our lead developer is a top-tier expert web and software engineer with mastery in over 20 programming languages, including Java, PHP, JavaScript, Golang, C, C++, and Python. With years of experience, they have built numerous open-source projects in these languages, including web, mobile, and desktop applications, as well as libraries and frameworks. Their expertise and passion for technology have been the driving force behind the creation of TurboServer, and they continue to work tirelessly to make it the fastest and most efficient web framework available.
+
+#
+
+## Conclusion
+
+TurboServer is a powerful and fast Node.js web framework that makes it easy to build high-performance web applications. With its built-in middlewares and simple API, it's a great choice for any project.
+
+#
+
+First deployment: 14/05/2023

package/benchmarks/image.md

@@ -0,0 +1,35 @@
+
+# turbo express
+
+//app.get("/public/something/*", TurboServer.Static({ folder: "/public", cache: true }))
+
+oha http://localhost:5000/public/something/testass.jpg -n 1000
+Summary:
+  Success rate:	1.0000
+  Total:	0.0666 secs
+  Slowest:	0.0492 secs
+  Fastest:	0.0001 secs
+  Average:	0.0029 secs
+  Requests/sec:	15018.7871
+
+  Total data:	104.55 MiB
+  Size/request:	107.06 KiB
+  Size/sec:	1.53 GiB
+
+
+# expressjs
+
+// app.use("/public/something/*", require("express").static(require("path").resolve() + "/public"))
+
+oha http://localhost:5001/testass.jpg -n 1000
+Summary:
+  Success rate:	1.0000
+  Total:	0.2664 secs
+  Slowest:	0.0755 secs
+  Fastest:	0.0017 secs
+  Average:	0.0131 secs
+  Requests/sec:	3754.2075
+
+  Total data:	104.55 MiB
+  Size/request:	107.06 KiB
+  Size/sec:	392.51 MiB

package/benchmarks/video.md

@@ -0,0 +1,35 @@
+
+# turbo express
+
+//app.get("/public/something/*", TurboServer.Static({ folder: "/public", cache: true }))
+
+oha http://localhost:5000/public/something/sample.mp4 -n 1000
+Summary:
+  Success rate:	1.0000
+  Total:	8.2990 secs
+  Slowest:	1.1018 secs
+  Fastest:	0.0914 secs
+  Average:	0.4102 secs
+  Requests/sec:	120.4966
+
+  Total data:	40.57 GiB
+  Size/request:	41.55 MiB
+  Size/sec:	4.89 GiB
+
+
+# expressjs
+
+// app.use("/public/something/*", require("express").static(require("path").resolve() + "/public"))
+
+oha http://localhost:5001/sample.mp4 -n 1000
+Summary:
+  Success rate:	1.0000
+  Total:	26.2146 secs
+  Slowest:	2.7239 secs
+  Fastest:	1.0497 secs
+  Average:	1.3067 secs
+  Requests/sec:	38.1467
+
+  Total data:	40.57 GiB
+  Size/request:	41.55 MiB
+  Size/sec:	1.55 GiB

package/bin.test.js

@@ -0,0 +1,59 @@
+
+// ? testing with thousends of middleware 
+
+// for (let i = 0; i < 10000; i++) {
+  
+//   app.use("/a/*", (req, res, next) => {
+//     next()
+//     req.setState("something", "helloow rold")
+//     console.log("something middleware is running 111");
+//   }, (req, res, next) => {
+//     next()
+//     req.setState("something", "helloow rold 222")
+//     console.log("something middleware is running 222");
+//   })
+    
+//   }
+  
+//   app.get("/a/hello", (req, res) => {
+//     res.send(req.useState("something"));
+//   })
+
+// ! result: not cost any performance;\
+
+
+// ? testing middleware after route 
+
+// app.use("/somepath", (req, res, next) => {console.log("wowoowow middleware is running"); next()});
+
+// app.get("somepath", mycallaback)
+
+// app.use("/somepath", (req, res, next) => {console.log("wowoowow middleware is running"); next()});
+
+// ! result: middleware will not run if it set after the route\
+
+
+
+
+
+
+
+
+// ! using runmethod to execute validations;
+
+
+app.get("/hello1/:username", 
+  TurboServer.RunMethod({ exe: [
+    { belong: "req", methodname: "runmethod_addvalidation", inject: { validation: new TurboServer.ValidationSchema("username", [
+      { name: TurboServer.ValidationMethodType.MINLENGTH, value: 3 }, 
+      { name: TurboServer.ValidationMethodType.MAXLENGTH, value: 14 },
+      { name: TurboServer.ValidationMethodType.ONEOF, value: ["XristinaMike"] }
+    ], true, "hello", "params") } },
+
+    { belong: "req", methodname: "execute_validation", inject: {}, isAsync: true }
+  
+  
+  ] }),
+  
+  
+  hello);

package/express.test.js

@@ -0,0 +1,73 @@
+const app = require("express")()
+
+const cluster = require("cluster")
+const router = require("express").Router();
+
+if (cluster.isMaster) {
+  for (let i = 0; i < 7; i++) { cluster.fork() }
+} else {
+  let p = "/"
+  //app.use(require("express").static(require("path").resolve() + "/public"));
+  console.log("running")
+  app.listen(5001)
+
+
+  app.get("/hi", (req, res) => res.send("hi"));
+
+  return;
+
+  for (let i = 0; i < 11; i++) {
+    router.get(p, (req, res) => res.send(`Current ${i}`));
+    p = p + ":a/"
+  }
+
+  app.use("/public/something/*", require("express").static(require("path").resolve() + "/public"))
+
+  
+
+  async function mycallaback (req, res) {
+    const r = req.body
+  
+    res.status(201).json({ body: r, aq: [
+      {params: req.params, queries: req.query},{params: req.params, queries: req.query},{params: req.params, queries: req.query},
+      {params: req.params, queries: req.query},{params: req.params, queries: req.query},
+      {params: req.params, queries: req.query},{params: req.params, queries: req.query},{params: req.params, queries: req.query},
+      {params: req.params, queries: req.query},{params: req.params, queries: req.query},
+      {params: req.params, queries: req.query},{params: req.params, queries: req.query},{params: req.params, queries: req.query},
+      {params: req.params, queries: req.query},{params: req.params, queries: req.query},
+      {params: req.params, queries: req.query},{params: req.params, queries: req.query},{params: req.params, queries: req.query},
+      {params: req.params, queries: req.query},{params: req.params, queries: req.query},
+      {params: req.params, queries: req.query},{params: req.params, queries: req.query},
+      {params: req.params, queries: req.query},{params: req.params, queries: req.query},{params: req.params, queries: req.query},
+      {params: req.params, queries: req.query},{params: req.params, queries: req.query},
+      {params: req.params, queries: req.query},{params: req.params, queries: req.query},{params: req.params, queries: req.query},
+      {params: req.params, queries: req.query},{params: req.params, queries: req.query},
+      {params: req.params, queries: req.query},{params: req.params, queries: req.query},{params: req.params, queries: req.query},
+      {params: req.params, queries: req.query},{params: req.params, queries: req.query},
+      {params: req.params, queries: req.query},{params: req.params, queries: req.query},
+      {params: req.params, queries: req.query},{params: req.params, queries: req.query},{params: req.params, queries: req.query},
+      {params: req.params, queries: req.query},{params: req.params, queries: req.query},
+      {params: req.params, queries: req.query},{params: req.params, queries: req.query},{params: req.params, queries: req.query},
+      {params: req.params, queries: req.query},{params: req.params, queries: req.query},
+      {params: req.params, queries: req.query},{params: req.params, queries: req.query},{params: req.params, queries: req.query},
+      {params: req.params, queries: req.query},{params: req.params, queries: req.query},
+    ] });
+  }
+
+  app.use(require("express").static("/public"));
+
+  app.get("/about/:something", mycallaback)  
+  
+
+  app.use(require("express").json())
+  app.use((req, res, next) => next());
+  app.use((req, res, next) => next());
+  app.use((req, res, next) => next());
+  app.use((req, res, next) => next());
+  app.use((req, res, next) => next());
+  app.use((req, res, next) => next());
+  app.use((req, res, next) => next());
+  app.use(router);
+
+}
+

package/index.js

@@ -0,0 +1,3 @@
+const TurboServer = require("./lib/TurboServer");
+
+module.exports = TurboServer;

package/index.test.js

@@ -0,0 +1,116 @@
+const TurboServer = require("./lib/TurboServer");
+const { MongoClient } = require('mongodb');
+
+const RequestInterface = require("./lib/types/RequestInterface");
+const ResponseInterface = require("./lib/types/ResponseInterface");
+const Router = require("./lib/Router");
+
+
+
+/**
+ * 
+ * @param {RequestInterface} req 
+ * @param {ResponseInterface} res 
+ * @param {Function} next 
+ */
+async function mymiddleware (req, res, next)
+{
+  req.setState("testone", "some test here");
+
+  next();
+}
+
+
+const app = new TurboServer(2);
+
+app.get("/public/*",  TurboServer.Static({ folder: "/public", cache: true }));
+app.post("/upload",   TurboServer.Upload({ folder: "/storage", memory: true }));
+
+
+app.use("/*", TurboServer.Validation({ validations: [
+  new TurboServer.ValidationSchema("username", [
+    { name: TurboServer.ValidationMethodType.MINLENGTH, value: 3 }, 
+    { name: TurboServer.ValidationMethodType.MAXLENGTH, value: 14 },
+    { name: TurboServer.ValidationMethodType.ONEOF, value: ["XristinaMike"] }
+  ], true, "hello", "body")
+]}));
+app.use("/*", TurboServer.Authentication());
+app.use("/*", TurboServer.BuildForm());
+app.use("/*", TurboServer.Cors());
+
+// run method of request without running controller callback
+app.get("/hello/:username", TurboServer.RunMethod({ exe: [{ belog: "req", methodname: "fetchUsers", isAsync: true, inject: { somedata: "hello world some data injected to that method" } }] }));
+
+app.get("/", (req, res) => res.status(200).json({}))
+
+/**
+ * @AUTHENTICATION MIDDLEWARE
+ * @BUILD FORM MIDDLEWARE
+ */
+
+
+/**
+ * 
+ * @param {RequestInterface} req 
+ * @param {ResponseInterface} res 
+ * @param {Function} next 
+ */
+async function hello (req, res, next)
+{
+  console.log(app.__link_routes = app.__link_routes.filter(f => f.path == "asdasd"))
+  console.log(app.__link_routes)
+  
+  console.log("####", "hello")
+  console.log(req.validData)
+  next()
+  res.status(201).json({result: 1, something: req.validateDataObj(), app: req.instance});
+}
+
+
+app.useEndMiddleware("/*", (req, res, next) => {console.log("middleware running after the controller method - #1"); next()}, (req, res, next) => {console.log("last middleware #2"); next()});
+
+
+app.use("/*", TurboServer.Cors({  }))
+
+app.get("/a/ok", (req, res) => {
+  res.send("hello")
+})
+
+app.get("/hello/:username", 
+  TurboServer.RunMethod({ exe: [{ belog: "req", methodname: "something", isAsync: true, inject: { somedata: "hello world some data" } }] }), 
+  TurboServer.Validation({ validations: [
+  new TurboServer.ValidationSchema("username", [
+    { name: TurboServer.ValidationMethodType.MINLENGTH, value: 3 }, 
+    { name: TurboServer.ValidationMethodType.MAXLENGTH, value: 14 },
+    { name: TurboServer.ValidationMethodType.ONEOF, value: ["XristinaMike"] }
+  ], true, "hello", "params")
+] }), hello);
+
+app.get("/hello1/:username", hello);
+
+  app.link("/hello1/:username", 
+  TurboServer.Validation({ validations: [
+    new TurboServer.ValidationSchema("username", [
+      { name: TurboServer.ValidationMethodType.MINLENGTH, value: 3 }, 
+      { name: TurboServer.ValidationMethodType.MAXLENGTH, value: 14 },
+      { name: TurboServer.ValidationMethodType.ONEOF, value: ["XristinaMike"] }
+    ], true, "hello", "params")
+  ]}),
+
+  hello);
+
+  const admin_router = new TurboServer.Router();
+
+  admin_router.get("/admin/:username", (req, res) => { res.send(req.params().get("username")) });
+  
+  app.use("/api/v1/", admin_router)
+
+
+app.listen(5000);
+
+app.logRoutes();
+
+//console.log(app);
+
+
+

package/lib/Router.js

@@ -0,0 +1,100 @@
+/**
+ * -->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>-->>
+ *
+ * @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 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 TurboServer = require("./TurboServer");
+
+module.exports = class Router 
+{
+  /**
+   * @typedef {Object} RouterMiddleware
+   * @property {String} path
+   * @property {Function[]} callbacks
+   * 
+   * @typedef {Object} RouterRoute
+   * @property {String} path;
+   * @property {Function[]} callbacks;
+   * @property {String} method
+   */
+
+  /** @type {String} path */
+  path = "";
+
+  /** @type{RouterRoute[]} routes */
+  routes = new Array();
+
+  /** @type{RouterMiddleware[]} middlewares */
+  middlewares = new Array();
+
+  /** @type{Middleware[]} __middlewares_begin  */
+   __middlewares_begin = new Array(); // final middlewares - actually will be set after the final path is passed;
+
+  /** @param {string | null} path */
+  constructor (path) { this.path = path || ""; }
+
+  get(path, ...callbacks){ this.routes.push({ path: path, callbacks: callbacks, method: RequestMethods.GET }) }
+  post(path, ...callbacks){ this.routes.push({ path: path, callbacks: callbacks, method: RequestMethods.POST }) }
+  put(path, ...callbacks){ this.routes.push({ path: path, callbacks: callbacks, method: RequestMethods.PUT }) }
+  delete(path, ...callbacks){ this.routes.push({ path: path, callbacks: callbacks, method: RequestMethods.DELETE }) }
+  head(path, ...callbacks){ this.routes.push({ path: path, callbacks: callbacks, method: RequestMethods.HEAD }) }
+  patch(path, ...callbacks){ this.routes.push({ path: path, callbacks: callbacks, method: RequestMethods.PATCH }) }
+  options(path, ...callbacks){ this.routes.push({ path: path, callbacks: callbacks, method: RequestMethods.OPTIONS }) }
+  link(path, ...callbacks){ this.routes.push({ path: path, callbacks: callbacks, method: RequestMethods.LINK }) }
+  unlink(path, ...callbacks){ this.routes.push({ path: path, callbacks: callbacks, method: RequestMethods.UNLINK }) }
+  view(path, ...callbacks){ this.routes.push({ path: path, callbacks: callbacks, method: RequestMethods.VIEW }) }
+  lock(path, ...callbacks){ this.routes.push({ path: path, callbacks: callbacks, method: RequestMethods.LOCK }) }
+  unlock(path, ...callbacks){ this.routes.push({ path: path, callbacks: callbacks, method: RequestMethods.UNLOCK }) }
+  copy(path, ...callbacks){ this.routes.push({ path: path, callbacks: callbacks, method: RequestMethods.COPY }) }
+  purge(path, ...callbacks){ this.routes.push({ path: path, callbacks: callbacks, method: RequestMethods.PURGE }) }
+  propfind(path, ...callbacks){ this.routes.push({ path: path, callbacks: callbacks, method: RequestMethods.PROPFIND }) }
+
+  use(path, ...callbackOrRouter) 
+  {
+    this.middlewares.push({path: path, callbacks: callbackOrRouter});
+    if (callbackOrRouter instanceof Router) throw new Error("Router use cannot accept another instance of Router.");
+  }
+
+  /**
+   * This method transfer routes/middlewares from router to the main application instance.
+   * 
+   * @binding routers/middlewares to the main application;
+   * @param {String} path
+   * @param {TurboServer} self
+   */
+  inject (path, self)
+  {
+    this.__middlewares_begin = this.middlewares.map(m => new Middleware(this.path + path + m.path, m.callbacks));
+    const rm = new RequestMethods();
+    rm.forEach((method) => {
+        const rts = this.routes.filter(f => f.method === method);
+        rts.map(froute => self[`__${method}_routes`].push(new Route(this.path + path + froute.path, method, froute.callbacks, this.__middlewares_begin, [])))
+    })
+  }
+
+};