turbo-express-js 1.0.1 → 1.0.3

package/README.md

@@ -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 +1,66 @@
-const TurboServer = require("./lib/TurboServer");
-const { MongoClient } = require('mongodb');
-
+const TurboExpress = require("./lib/TurboServer");
 const RequestInterface = require("./lib/types/RequestInterface");
 const ResponseInterface = require("./lib/types/ResponseInterface");
-const Router = require("./lib/Router");
 
 
+const app = new TurboExpress(2);
 
-/**
- * 
- * @param {RequestInterface} req 
- * @param {ResponseInterface} res 
- * @param {Function} next 
- */
-async function mymiddleware (req, res, next)
-{
-  req.setState("testone", "some test here");
 
-  next();
-}
 
+TurboExpress.exeWorker(async () => 
+{
+  console.log("Hey")
+})
 
-const app = new TurboServer(2);
 
-app.get("/public/*",  TurboServer.Static({ folder: "/public", cache: true }));
-app.post("/upload",   TurboServer.Upload({ folder: "/storage", memory: true }));
+TurboExpress.exeMaster(async () => 
+{
 
 
-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());
+  console.log("Hello world");
 
-// 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
- */
 
+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 
- * @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});
+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.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.use("", router);
 
-app.logRoutes();
+app.get("/something1", homepage);
+// app.options("/something", (req, res) => res.send(""));
+// app.head("/something", (req, res) => res.send(""));
+// app.get("/", homepage);
 
-//console.log(app);
 
+// app.all("/*", (req, res) => {
+//   res.send("not")
+// })
 
 
+app.listen(3001, () => console.log("Server is running on port 3000"));

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,32 @@ module.exports = class TurboServer
     })
   }
 
+  /**
+   * Execute code only in master instance
+   * 
+   * @param {Function} cb 
+   */
+  static async exeMaster (cb)
+  {
+    if(cluster.isMaster)
+    {
+      await cb();
+    }
+  }
+
+  /**
+   * Execute code only in master instance
+   * 
+   * @param {Function} cb 
+   */
+  static async exeWorker (cb)
+  {
+    if(cluster.isWorker)
+    {
+      await cb();
+    }
+  }
+
 
 
   /** @type{http.Server}    */ #server;
@@ -181,6 +225,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 +267,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 +313,15 @@ module.exports = class TurboServer
   }
 
 
+  setAuthentication (authService) 
+  {
+    
+  }
+
+  /** @returns {http.Server} */
+  getServer () {
+    return this.#server;
+  }
 
 
   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);
 
 }