turbo-express-js 1.0.0 → 1.0.2

package/README.md

@@ -1,10 +1,10 @@
 # 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.
+  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.
+  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.
 
 #
 
@@ -51,7 +51,7 @@ Static
 The Static middleware serves static files from a specified folder:
 
 ``` javascript
-  app.use(TurboServer.Static({ folder: '/public' }));
+  app.use("/*", TurboServer.Static({ folder: '/public' }));
 ```
 
 
@@ -69,7 +69,7 @@ The Upload middleware handles file uploads:
 The Validation middleware validates incoming requests against a specified schema (can validate by namespaces<params, query, body>):
 
 ``` javascript
-  app.use(TurboServer.Validation({ 
+  app.use("/user/new", TurboServer.Validation({ 
   validations: [
     new TurboServer.ValidationSchema("username", [
       { name: TurboServer.ValidationMethodType.MINLENGTH, value: 3 }, 
@@ -87,7 +87,21 @@ The Authentication middleware handles user authentication:
 *work in progress still
 
 ``` javascript
-  app.use(TurboServer.Authentication());
+  const mongoose = require("mongoose");
+
+  const conn = mongoose.createConnection("mongodb://localhost:27017/testtest");
+
+  const userModel = conn.model("User", new mongoose.Schema({
+    username: String,
+    password: String
+  }))
+
+  const authService = new TurboServer.JWTBcryptMongoDBAuthService({ UserModel: userModel, useDbUser: true });
+
+  app.post("/login", async (req, res) => await authService.simpleLogin(req, res));
+  app.post("/login-double", async (req, res) => await authService.doubleLoginWorkflow(req, res));
+
+  app.use("/api/v1/*", TurboServer.Authentication({ authentication_service: authService }));
 ```
 
 ## BuildForm
@@ -97,7 +111,7 @@ The BuildForm middleware parses some sort of model and can generate list of fiel
 *work in progress still
 
 ``` javascript
-  app.use(TurboServer.BuildForm());
+  app.use("/api/v1/user/new", TurboServer.BuildForm());
 ```
 
 ## Cors
@@ -107,7 +121,7 @@ The Cors middleware adds CORS headers to responses:
 *work in progress still
 
 ``` javascript
-  app.use(TurboServer.Cors());
+  app.use("/*", TurboServer.Cors());
 ```
 
 
@@ -125,7 +139,7 @@ Here's an example of a custom middleware function that logs the request method a
     next();
   }
 
-  app.use(logger);
+  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.

package/{bin.test.js → bin/bin.test.js}

@@ -56,4 +56,41 @@ app.get("/hello1/:username",
   ] }),
   
   
-  hello);
+  hello);
+
+
+
+
+
+// ! $# BUILDING AUTHENTICATION SERVICE
+
+class MyAuth extends TurboServer.AuthenticationService {
+
+  constructor() {
+    super();
+    this.devLogs = true;
+    this.nonBlocking = true;
+    this.useDbUser = true;
+    //console.log(this);
+  }
+
+  async find_user (login_value) {
+    if(login_value === "@kristina-trash") return { id: 1, username: "@kristina~trash", email: "kristina@perfect-evolution.eu" }
+    return null;
+  }
+  async compare_password (user, password) {
+    // console.log(user)
+    return true;
+  }
+
+
+
+
+  setMemory1 (key, value) {}
+  getMemory1 (key) {}
+
+  
+
+}
+
+const authService = new MyAuth()

package/bin/cors.test.js

@@ -0,0 +1,49 @@
+const TurboExpress = require("./lib/TurboServer");
+const RequestInterface = require("./lib/types/RequestInterface");
+const ResponseInterface = require("./lib/types/ResponseInterface");
+
+
+const app = new TurboExpress(2);
+
+
+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" } })
+}
+app.get("/something", homepage);
+// app.options("/something", (req, res) => res.send(""));
+// app.head("/something", (req, res) => res.send(""));
+// app.get("/", homepage);
+
+app.all("/something", homepage);
+
+
+app.listen(3001, () => console.log("Server is running on port 3000"));

package/bin/dynamicpath.test.js

@@ -0,0 +1,50 @@
+const TurboExpress = require("./lib/TurboServer");
+const RequestInterface = require("./lib/types/RequestInterface");
+const ResponseInterface = require("./lib/types/ResponseInterface");
+
+
+const app = new TurboExpress(2);
+
+
+TurboExpress.exeMaster(async () => 
+{
+
+
+  console.log("Hello world");
+
+
+});
+
+
+class MyResponse extends ResponseInterface
+{
+  mymethod () {
+    console.log("my method")
+  }
+}
+
+app.Response = MyResponse;
+
+/**
+ * 
+ * @param {RequestInterface} req 
+ * @param {ResponseInterface} res 
+ */
+function homepage (req, res) {
+  const r = TurboExpress.SystemService.match_route(req.instance, req, res, [
+    { method: "get", path: "/:username/some" }
+  ], "", req.url().split("?")[0])
+
+  if(r) {
+    r.res.mymethod();
+    r.res.send("matched")
+  } else {
+    res.send("not")
+  }
+
+}
+app.get("/*", homepage);
+app.get("/", homepage);
+
+
+app.listen(3000, () => console.log("Server is running on port 3000"));

package/bin/middleware.test.js

@@ -0,0 +1,44 @@
+const TurboExpress = require("./lib/TurboServer");
+const RequestInterface = require("./lib/types/RequestInterface");
+const ResponseInterface = require("./lib/types/ResponseInterface");
+
+
+const app = new TurboExpress(2);
+
+
+TurboExpress.exeMaster(async () => 
+{
+
+
+  console.log("Hello world");
+
+
+});
+
+
+class MyResponse extends ResponseInterface
+{
+  mymethod () {
+    console.log("my method")
+  }
+}
+
+app.Response = MyResponse;
+
+app.use("/*", (req, res, next) => {console.log("middleware"), next()})
+app.useEndMiddleware("/*", (req, res, next) => console.log("end middleware"))
+/**
+ * 
+ * @param {RequestInterface} req 
+ * @param {ResponseInterface} res 
+ */
+function homepage (req, res, next) {
+  console.log("controller")
+  res.status(200).json({ user: { username: "kristina" } })
+  next()
+}
+app.get("/something", homepage);
+// app.get("/", homepage);
+
+
+app.listen(3001, () => console.log("Server is running on port 3000"));

package/bin/preprod.test.js

@@ -0,0 +1,107 @@
+const TurboServer = require("./lib/TurboServer");
+
+const RequestInterface = require("./lib/types/RequestInterface");
+const ResponseInterface = require("./lib/types/ResponseInterface");
+const Router = require("./lib/Router");
+
+
+(async () => {
+
+})();
+
+
+const app = new TurboServer(1);
+
+global.TURBO_EXPRESS = {
+  enviroment: "development"
+}
+
+const mongoose = require("mongoose");
+
+const conn = mongoose.createConnection("mongodb://localhost:27017/testtest");
+
+const userModel = conn.model("User", new mongoose.Schema({
+  username: String,
+  password: String
+}))
+
+;(async () => {
+  console.log(await userModel.find());
+})();
+
+
+for (const key in object) {
+  if (Object.hasOwnProperty.call(object, key)) {
+    const element = object[key];
+    
+  }
+}
+
+
+TurboServer.Log.dev("something");
+
+
+
+
+app.get("/hi11", (req, res) => {});
+
+
+
+app.post("/login", async (req, res) => await authService.simpleLogin(req, res));
+
+app.post("/login-double", async (req, res) => await authService.doubleLoginWorkflow(req, res));
+
+const authService = new TurboServer.JWTBcryptMongoDBAuthService({
+  UserModel: userModel, useDbUser: true 
+});
+
+app.use("/asd*", TurboServer.Authentication({ authentication_service: authService }))
+
+app.get("/something", (req, res) => {
+  let obj = {}
+  req.state.forEach((v, k) => obj[k] = v)
+  res.status(200).json(obj);
+} )
+
+app.get("/protected-route", async (req, res, next) => await authService.authenticated(req, res, next), (req, res) => {
+  let obj = {}
+  req.state.forEach((v, k) => obj[k] = v)
+  res.status(200).json(obj);
+} )
+
+/**
+ * 
+ * @param {RequestInterface} req 
+ * @param {ResponseInterface} res 
+ */
+function mydynamiccontroller (req, res) {
+
+  req.setState("something", 123123)
+
+  const result = TurboServer.SystemService.match_route(req, res, [
+    { method: "get", path: "/user/:username/read" },
+    { method: "post", path: "/user/new" }
+  ], "/api/v1/:projectname/", req.url().split("?")[0]);
+
+  if(!result) return res.status(404).json({ message: "not found || 404" })
+
+  console.log(result.res.status(200).json({params: result.req.paramsObj(), query: result.req.queriesObj(), url: result.req.url(), state: result.req.getStateObj()}));
+
+  //res.send("okk")
+}
+
+app.get("/api/v1/:projectname/*", mydynamiccontroller);
+
+
+/**
+ * 
+ * @param {RequestInterface} req 
+ * @param {ResponseInterface} res 
+ */
+function controller (req, res) {
+  res.send(req.paramsObj().username)
+}
+
+app.get("/:username", controller);
+
+app.listen(5000);

package/index.test.js

@@ -1,116 +0,0 @@
-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/TurboServer.js

@@ -23,7 +23,7 @@ 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 { matching_route, matching_nonexact_route, Log } = require("./utils");
 const Route = require("./types/Route");
 const Middleware= require("./types/Middleware");
 const RequestMethods = require("./statictypes/RequestMethods");
@@ -37,13 +37,25 @@ 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 AuthenticationService = require("./services/AuthenticationService");
+const SystemService = require("./services/SystemService");
+const JWTBcryptMongoDBAuthService = require("./types/default/JWTBcryptMongoDBAuthService");
 
 
 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;
+
 
   /**
    * @typedef {Object} StaticOptions
@@ -60,8 +72,10 @@ module.exports = class TurboServer
 
   /**
    * @typedef {Object} CorsOptions
-   * @property {String} folder - default /public
-   * @property {Boolean} cache - default false
+   * @property {String[]}   origins     - default ["*"]
+   * @property {Boolean}    credentials - default true
+   * @property {String[]}   methods     - default [GET,HEAD,PUT,PATCH,POST,DELETE,OPTIONS]
+   * @property {String[]}   headers     - default *
    * 
    * @param {CorsOptions} CorsOptions 
    * @returns 
@@ -69,7 +83,10 @@ module.exports = class TurboServer
   static Cors (CorsOptions)
   {
     return cors_middleware.bind({
-
+      origins: CorsOptions.origins ? CorsOptions.origins : ["*"],
+      methods: CorsOptions.methods ? CorsOptions.methods : ["GET", "HEAD", "PUT", "PATCH", "POST", "DELETE", "OPTIONS"],
+      credentials: CorsOptions.credentials === false ? false : true,
+      headers: CorsOptions.headers || []
     })
   }
 
@@ -129,6 +146,7 @@ module.exports = class TurboServer
   /**
    * 
    * @typedef  {Object} AuthenticationOptions
+   * @property {AuthenticationService} authentication_service
    * 
    * @param {AuthenticationOptions} AuthenticationOptions 
    * @returns 
@@ -136,7 +154,7 @@ module.exports = class TurboServer
   static Authentication (AuthenticationOptions={})
   {
     return authentication_middleware.bind({ 
-      
+      authentication_service: AuthenticationOptions.authentication_service  
     })
   }
 
@@ -153,6 +171,19 @@ module.exports = class TurboServer
     })
   }
 
+  /**
+   * Execute code only in master instance
+   * 
+   * @param {Function} cb 
+   */
+  static async exeMaster (cb)
+  {
+    if(cluster.isMaster)
+    {
+      await cb();
+    }
+  }
+
 
 
   /** @type{http.Server}    */ #server;
@@ -181,6 +212,9 @@ module.exports = class TurboServer
   /** @type{RequestInterface}                              */     Request;
   /** @type{ResponseInterface}                             */     Response;
 
+
+  /** // todo this in server memory is still in development, need somehow share them between all processes that running on multi cluster server  */
+
   /** @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
@@ -220,6 +254,13 @@ module.exports = class TurboServer
   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));}}
 
+  all(path, ...callbacks){
+    if(!cluster.isMaster) {
+      const rMethods = new RequestMethods();
+      rMethods.forEach((m) => this[`__${m}_routes`].push(new Route(path, m, callbacks, this.__middlewares_begin, this.__middlewares_end)));
+    }
+  }
+
   use(path, ...callbackOrRouter)
   {
     if(callbackOrRouter[0] instanceof Router === true) {
@@ -259,6 +300,10 @@ module.exports = class TurboServer
   }
 
 
+  setAuthentication (authService) 
+  {
+    
+  }
 
 
   logRoutes ()

package/lib/middlewares/authentication_middleware.js

@@ -23,11 +23,11 @@ const ResponseInterface = require("../types/ResponseInterface");
 * @param {ResponseInterface} res 
 * @param {*} next 
 */
-module.exports = function authentication_middleware (req, res, next) 
+module.exports = async function authentication_middleware (req, res, next) 
 {
 
-  // comming soon;
+  const { authentication_service } = this;
 
-  res.send("comming soon - authentication middleware");
+  return await authentication_service.authenticated(req, res, next);
 
 }

package/lib/middlewares/cors_middleware.js

@@ -25,9 +25,26 @@ const ResponseInterface = require("../types/ResponseInterface");
 */
 module.exports = function cors_middleware (req, res, next) 
 {
+  const { origins, methods, credentials, headers } = this;
 
-  // comming soon;
+  res.header("Access-Control-Allow-Origin", origins.join(","));
+  res.header("Access-Control-Allow-Credentials", credentials);
+  res.header("Access-Control-Allow-Methods", methods.join(","));
+  res.header("Access-Control-Max-Age", 3600);
 
-  res.send("comming soon - cors middleware");
+  let allowedHeaders = "";
+  const headers_req = req.headers();
+  for (const key in headers_req) {
+    if (Object.hasOwnProperty.call(headers_req, key)) {
+      if(key.toLowerCase() === "access-control-request-headers") { allowedHeaders = allowedHeaders + headers_req[key] + "," } else {
+        allowedHeaders = allowedHeaders + key + ","
+      }
+    }
+  }
+  res.header("Access-Control-Allow-Headers", (allowedHeaders + headers.join(",")).substring(
+    0, (allowedHeaders + headers.join(",")).length - 1
+  ));
+
+  next();
 
 }