turbo-express-js 1.0.8 → 1.0.9

package/README.md

@@ -1,22 +1,26 @@
-# TurboServer - A Fast and Powerful Node.js Web Server Framework
+# Turbo Express JS 🚀
 
-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.
+**Minimalistic, Fast and Powerful Node.js Framework**  
+**(Express + JSON Parser + CORS + Cookie Parser + Upload + Validation + Authentication)**
+
+> 🔄 Express compatible structure, but OOP driven and built-in all middlewares.
 
 > Made with ❤️ by Mike Karypidis
 
-#
+## ✨ Features
 
-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.
+- Zero external dependency setup (JSON, CORS, Cookie, Upload built-in)
+- Extendable `Request` and `Response` (OOP interfaces)
+- Authentication system out of the box
+- Validation middleware out of the box
+- Clustering support (spawn multiple workers)
+- Post-controller middleware execution
+- Locales (i18n) ready
 
-#
+---
 
-## Installation
+
+## 🔧 Installation
 
 To install TurboServer, simply run the following command:
 
@@ -24,7 +28,7 @@ To install TurboServer, simply run the following command:
 npm install turbo-express-js
 ```
 
-## Getting Started
+## 👌 Getting Started
 
 Here's a simple example of how to create a basic server using TurboServer:
 
@@ -32,7 +36,7 @@ Here's a simple example of how to create a basic server using TurboServer:
 
   const TurboServer = require('turboserver');
 
-  const app = new TurboServer(1);
+  const app = new TurboServer();
 
   app.get('/', (req, res) => {
     res.send('Hello, World!');
@@ -43,15 +47,61 @@ Here's a simple example of how to create a basic server using TurboServer:
   });
 ```
 
+# 🔬 Comparison: Express.js vs Turbo Express JS
+
+| Feature | Express.js | Turbo Express JS |
+|:---|:---|:---|
+| Built-in JSON Body Parsing | ❌ | ✅ |
+| Built-in CORS Middleware | ❌ | ✅ |
+| Built-in File Upload Support | ❌ | ✅ |
+| Authentication System | ❌ | ✅ |
+| OOP Request/Response Extendable | ❌ | ✅ |
+| Cluster Support | ❌ (manual) | ✅ (out of the box) |
+| Validation Middleware | ❌ | ✅ |
+| Post-Controller Middlewares | ❌ | ✅ |
+| Locales (i18n) | ❌ | ✅ |
+| Performance Focus | ✅ | ✅ |
+
+## 📦 TypeScript Support
+
+Turbo Express JS works perfectly with TypeScript.  
+It includes a ready-to-use `index.d.ts` file with support for:
+
+- Request/Response interfaces
+- Class-based routing
+- Autocomplete & type checking
+- Full OOP method overriding
+
+### ✅ Basic Example in TypeScript
+
+```ts
+// main.ts
+import TurboServer = require("turbo-express-js");
+
+const app = new TurboServer();
+
+app.get("/", (req, res) => {
+  res.send("Hello from TypeScript + Turbo Express JS!");
+});
+
+app.listen(3000, () => {
+  console.log("TurboExpress running on http://localhost: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.
 
+``` javascript
+  const app = new TurboServer(2);
+```
+
 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
+# 🔍 Middlewares
 TurboServer includes a number of built-in middlewares that you can use to add functionality to your application. Here are some of out of the box middlewares:
 
 1. Cors middleware

package/changelog.md

@@ -11,4 +11,9 @@
 
 # 1.0.7 stable
   1. [18/8/2023] update TurboExpress.Cors() fix bug that throw an error if it not recieve props
-  2. [18/8/2023] update documentations
+  2. [18/8/2023] update documentations
+
+# 1.0.8 docs changes
+
+# 1.0.9
+  1. [25/4/2025] update clusters, 0 argument mean no clusters.

package/index.d.ts

@@ -0,0 +1,124 @@
+// index.d.ts
+/// <reference types="node" />
+
+import { IncomingMessage, ServerResponse } from "http";
+
+export = TurboServer;
+
+declare class TurboServer {
+  constructor(clusterslength?: number);
+
+  static Router: typeof Router;
+  static AuthenticationService: any;
+  static ValidationTypes: any;
+  static ExpressServices: any;
+  static TurboExpressDefault: any;
+  static Log: any;
+  static Util: any;
+
+  static Static(options?: { folder?: string; cache?: boolean }): Function;
+  static Cors(options?: { origins?: string[]; credentials?: boolean; methods?: string[]; headers?: string[] }): Function;
+  static Upload(options?: { folder?: string; memory?: boolean }): Function;
+  static Validation(options?: any): Function;
+  static RunMethod(options?: { exe: any[] }): Function;
+  static Authentication(options?: { authentication_service: any }): Function;
+  static BuildForm(options?: any): Function;
+  static exeMaster(callback: () => Promise<void>): Promise<void>;
+  static exeWorker(callback: () => Promise<void>): Promise<void>;
+
+  Request: typeof RequestInterface;
+  Response: typeof ResponseInterface;
+  
+  use(path: string, ...callbacks: Function[]): void;
+  useEndMiddleware(path: string, ...callbacks: Function[]): void;
+
+  get(path: string, ...callbacks: Function[]): void;
+  post(path: string, ...callbacks: Function[]): void;
+  put(path: string, ...callbacks: Function[]): void;
+  delete(path: string, ...callbacks: Function[]): void;
+  head(path: string, ...callbacks: Function[]): void;
+  patch(path: string, ...callbacks: Function[]): void;
+  options(path: string, ...callbacks: Function[]): void;
+  link(path: string, ...callbacks: Function[]): void;
+  unlink(path: string, ...callbacks: Function[]): void;
+  view(path: string, ...callbacks: Function[]): void;
+  lock(path: string, ...callbacks: Function[]): void;
+  unlock(path: string, ...callbacks: Function[]): void;
+  copy(path: string, ...callbacks: Function[]): void;
+  purge(path: string, ...callbacks: Function[]): void;
+  propfind(path: string, ...callbacks: Function[]): void;
+  all(path: string, ...callbacks: Function[]): void;
+
+  getServer(): import("http").Server;
+  setLocales(localeDirectory: string): void;
+  listen(port: number, callback?: () => void): void;
+  logRoutes(): void;
+}
+
+declare class Router {
+  constructor(path?: string);
+  
+  get(path: string, ...callbacks: Function[]): void;
+  post(path: string, ...callbacks: Function[]): void;
+  put(path: string, ...callbacks: Function[]): void;
+  delete(path: string, ...callbacks: Function[]): void;
+  head(path: string, ...callbacks: Function[]): void;
+  patch(path: string, ...callbacks: Function[]): void;
+  options(path: string, ...callbacks: Function[]): void;
+  link(path: string, ...callbacks: Function[]): void;
+  unlink(path: string, ...callbacks: Function[]): void;
+  view(path: string, ...callbacks: Function[]): void;
+  lock(path: string, ...callbacks: Function[]): void;
+  unlock(path: string, ...callbacks: Function[]): void;
+  copy(path: string, ...callbacks: Function[]): void;
+  purge(path: string, ...callbacks: Function[]): void;
+  propfind(path: string, ...callbacks: Function[]): void;
+
+  use(path: string, ...callbacks: Function[]): void;
+}
+
+declare class RequestInterface {
+  IncomingMessage: IncomingMessage;
+  models: Map<string, any>;
+  content_type: string;
+  current_locale: string;
+  ValidationError: any;
+  _body: Buffer;
+  _files: any[];
+  _validations: any[];
+  _validation_errors: any[];
+  _body_hash: any;
+
+  params(): Map<string, any>;
+  paramsObj(): Record<string, any>;
+  queries(): URLSearchParams;
+  queriesObj(): Record<string, any>;
+  headers(): IncomingMessage["headers"];
+  method(): string;
+  url(): string;
+  httpVersion(): string;
+  remoteAddress(): string;
+  remotePort(): number;
+  localAddress(): string;
+  localPort(): number;
+  
+  body(): Promise<any>;
+  body_hash(): any;
+  files(): any[];
+
+  setState(key: string, value: any): void;
+  useState(key: string): any;
+  getStateObj(): Record<string, any>;
+
+  getText(key: string): string | null;
+}
+
+declare class ResponseInterface {
+  OutgoingMessage: ServerResponse;
+  models: Map<string, any>;
+
+  status(code: number): this;
+  send(body: string, contentType?: string): void;
+  json(data: object): void;
+  header(key: string, value: string): void;
+}

package/index.js

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

package/index.test.js

@@ -2,12 +2,10 @@ const TurboExpress = require("./lib/TurboServer");
 const RequestInterface = require("./lib/types/RequestInterface");
 const ResponseInterface = require("./lib/types/ResponseInterface");
 
-const app = new TurboExpress(1);
+const app = new TurboExpress();
 
-// 6976355584
+// console.log("testing development...")
 
-// app.get("/", (req, res) => {req.}, (req, res) => {req.});
+app.get("asd", ()=>{  })
 
-// app.use("/asd", new TurboExpress.Router)
-
-app.listen(3001, () => console.log("Server is running on port 3000"));
+app.listen(3001, () => console.log("Service is running"));

package/lib/TurboServer.js

@@ -221,6 +221,7 @@ module.exports = class TurboServer
   /** @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();
+  /** @type {Boolean}                                      */     useClusters      =   true;
 
   /**
    * @param {Number} CLUSTERSLENGTH
@@ -230,6 +231,15 @@ module.exports = class TurboServer
    */
   constructor (CLUSTERSLENGTH)
   {
+    if(!CLUSTERSLENGTH)
+    {
+      global["TurboExpress"] = new Object();
+      global["TurboExpressCaching"] = new Object();
+      this.#server = http.createServer(ServerCallback.bind(this));
+      this.Request = RequestInterface;
+      this.Response = ResponseInterface;
+      this.useClusters = false;
+    } 
     if (cluster.isMaster) {
       for (let i = 0; i < CLUSTERSLENGTH; i++) { cluster.fork() }
     } else {
@@ -249,39 +259,39 @@ module.exports = class TurboServer
    */
 
   /** @param {String} path; @param {TurboExpressCallback[]} callbacks  */
-  get(path, ...callbacks){if(!cluster.isMaster) {this.__get_routes.push(new Route(path, RequestMethods.GET, callbacks, this.__middlewares_begin, this.__middlewares_end));}}
+  get(path, ...callbacks){if(!cluster.isMaster || this.useClusters === false) {this.__get_routes.push(new Route(path, RequestMethods.GET, callbacks, this.__middlewares_begin, this.__middlewares_end));}}
   /** @param {String} path; @param {TurboExpressCallback[]} callbacks  */
-  post(path, ...callbacks){if(!cluster.isMaster) {this.__post_routes.push(new Route(path, RequestMethods.POST, callbacks, this.__middlewares_begin, this.__middlewares_end));}}
+  post(path, ...callbacks){if(!cluster.isMaster || this.useClusters === false) {this.__post_routes.push(new Route(path, RequestMethods.POST, callbacks, this.__middlewares_begin, this.__middlewares_end));}}
   /** @param {String} path; @param {TurboExpressCallback[]} callbacks  */
-  put(path, ...callbacks){if(!cluster.isMaster) {this.__put_routes.push(new Route(path, RequestMethods.PUT, callbacks, this.__middlewares_begin, this.__middlewares_end));}}
+  put(path, ...callbacks){if(!cluster.isMaster || this.useClusters === false) {this.__put_routes.push(new Route(path, RequestMethods.PUT, callbacks, this.__middlewares_begin, this.__middlewares_end));}}
   /** @param {String} path; @param {TurboExpressCallback[]} callbacks  */
-  delete(path, ...callbacks){if(!cluster.isMaster) {this.__delete_routes.push(new Route(path, RequestMethods.DELETE, callbacks, this.__middlewares_begin, this.__middlewares_end));}}
+  delete(path, ...callbacks){if(!cluster.isMaster || this.useClusters === false) {this.__delete_routes.push(new Route(path, RequestMethods.DELETE, callbacks, this.__middlewares_begin, this.__middlewares_end));}}
   /** @param {String} path; @param {TurboExpressCallback[]} callbacks  */
-  head(path, ...callbacks){if(!cluster.isMaster) {this.__head_routes.push(new Route(path, RequestMethods.HEAD, callbacks, this.__middlewares_begin, this.__middlewares_end));}}
+  head(path, ...callbacks){if(!cluster.isMaster || this.useClusters === false) {this.__head_routes.push(new Route(path, RequestMethods.HEAD, callbacks, this.__middlewares_begin, this.__middlewares_end));}}
   /** @param {String} path; @param {TurboExpressCallback[]} callbacks  */
-  patch(path, ...callbacks){if(!cluster.isMaster) {this.__patch_routes.push(new Route(path, RequestMethods.PATCH, callbacks, this.__middlewares_begin, this.__middlewares_end));}}
+  patch(path, ...callbacks){if(!cluster.isMaster || this.useClusters === false) {this.__patch_routes.push(new Route(path, RequestMethods.PATCH, callbacks, this.__middlewares_begin, this.__middlewares_end));}}
   /** @param {String} path; @param {TurboExpressCallback[]} callbacks  */
-  options(path, ...callbacks){if(!cluster.isMaster) {this.__options_routes.push(new Route(path, RequestMethods.OPTIONS, callbacks, this.__middlewares_begin, this.__middlewares_end));}}
+  options(path, ...callbacks){if(!cluster.isMaster || this.useClusters === false) {this.__options_routes.push(new Route(path, RequestMethods.OPTIONS, callbacks, this.__middlewares_begin, this.__middlewares_end));}}
   /** @param {String} path; @param {TurboExpressCallback[]} callbacks  */
-  link(path, ...callbacks){if(!cluster.isMaster) {this.__link_routes.push(new Route(path, RequestMethods.LINK, callbacks, this.__middlewares_begin, this.__middlewares_end));}}
+  link(path, ...callbacks){if(!cluster.isMaster || this.useClusters === false) {this.__link_routes.push(new Route(path, RequestMethods.LINK, callbacks, this.__middlewares_begin, this.__middlewares_end));}}
   /** @param {String} path; @param {TurboExpressCallback[]} callbacks  */
-  unlink(path, ...callbacks){if(!cluster.isMaster) {this.__unlink_routes.push(new Route(path, RequestMethods.UNLINK, callbacks, this.__middlewares_begin, this.__middlewares_end));}}
+  unlink(path, ...callbacks){if(!cluster.isMaster || this.useClusters === false) {this.__unlink_routes.push(new Route(path, RequestMethods.UNLINK, callbacks, this.__middlewares_begin, this.__middlewares_end));}}
   /** @param {String} path; @param {TurboExpressCallback[]} callbacks  */
-  view(path, ...callbacks){if(!cluster.isMaster) {this.__view_routes.push(new Route(path, RequestMethods.VIEW, callbacks, this.__middlewares_begin, this.__middlewares_end));}}
+  view(path, ...callbacks){if(!cluster.isMaster || this.useClusters === false) {this.__view_routes.push(new Route(path, RequestMethods.VIEW, callbacks, this.__middlewares_begin, this.__middlewares_end));}}
   /** @param {String} path; @param {TurboExpressCallback[]} callbacks  */
-  lock(path, ...callbacks){if(!cluster.isMaster) {this.__lock_routes.push(new Route(path, RequestMethods.LOCK, callbacks, this.__middlewares_begin, this.__middlewares_end));}}
+  lock(path, ...callbacks){if(!cluster.isMaster || this.useClusters === false) {this.__lock_routes.push(new Route(path, RequestMethods.LOCK, callbacks, this.__middlewares_begin, this.__middlewares_end));}}
   /** @param {String} path; @param {TurboExpressCallback[]} callbacks  */
-  unlock(path, ...callbacks){if(!cluster.isMaster) {this.__unlock_routes.push(new Route(path, RequestMethods.UNLOCK, callbacks, this.__middlewares_begin, this.__middlewares_end));}}
+  unlock(path, ...callbacks){if(!cluster.isMaster || this.useClusters === false) {this.__unlock_routes.push(new Route(path, RequestMethods.UNLOCK, callbacks, this.__middlewares_begin, this.__middlewares_end));}}
   /** @param {String} path; @param {TurboExpressCallback[]} callbacks  */
-  copy(path, ...callbacks){if(!cluster.isMaster) {this.__copy_routes.push(new Route(path, RequestMethods.COPY, callbacks, this.__middlewares_begin, this.__middlewares_end));}}
+  copy(path, ...callbacks){if(!cluster.isMaster || this.useClusters === false) {this.__copy_routes.push(new Route(path, RequestMethods.COPY, callbacks, this.__middlewares_begin, this.__middlewares_end));}}
   /** @param {String} path; @param {TurboExpressCallback[]} callbacks  */
-  purge(path, ...callbacks){if(!cluster.isMaster) {this.__purge_routes.push(new Route(path, RequestMethods.PURGE, callbacks, this.__middlewares_begin, this.__middlewares_end));}}
+  purge(path, ...callbacks){if(!cluster.isMaster || this.useClusters === false) {this.__purge_routes.push(new Route(path, RequestMethods.PURGE, callbacks, this.__middlewares_begin, this.__middlewares_end));}}
   /** @param {String} path; @param {TurboExpressCallback[]} callbacks  */
-  propfind(path, ...callbacks){if(!cluster.isMaster) {this.__propfind_routes.push(new Route(path, RequestMethods.PROPFIND, callbacks, this.__middlewares_begin, this.__middlewares_end));}}
+  propfind(path, ...callbacks){if(!cluster.isMaster || this.useClusters === false) {this.__propfind_routes.push(new Route(path, RequestMethods.PROPFIND, callbacks, this.__middlewares_begin, this.__middlewares_end));}}
 
   /** @param {String} path; @param {TurboExpressCallback[]} callbacks  */
   all(path, ...callbacks){
-    if(!cluster.isMaster) {
+    if(!cluster.isMaster || this.useClusters === false) {
       const rMethods = new RequestMethods();
       rMethods.forEach((m) => this[`__${m}_routes`].push(new Route(path, m, callbacks, this.__middlewares_begin, this.__middlewares_end)));
     }
@@ -353,8 +363,8 @@ module.exports = class TurboServer
   listen (port, cb)
   {
     /** will listen not on master cluster ... */
-    if(!cluster.isMaster) {
-      this.#server.listen(port, cb ? cb : () => console.log("server is running"))
+    if(!cluster.isMaster || this.useClusters === false) {
+      this.#server.listen(port, cb || (() => console.log("server is running " + port)))
     } 
   }
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "turbo-express-js",
-  "version": "1.0.8",
-  "description": "turbo express performance security easy to use web server framework ",
+  "version": "1.0.9",
+  "description": "Turbo Express JS - Performance, Security, Easy-to-use Web Server Framework",
   "main": "index.js",
   "directories": {
     "lib": "lib"
@@ -20,6 +20,7 @@
     "cors": "nodemon samples/cors.test.js",
     "validation_override": "nodemon samples/validation_override.test.js"
   },
+  "types": "index.d.ts",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/breathfunwithmindte/turbo-express.git"
@@ -27,16 +28,20 @@
   "keywords": [
     "web",
     "server",
-    "framwork",
+    "framework",
     "lightweight",
     "minimalistic",
     "superfast",
-    "fast"
+    "fast",
+    "nodejs",
+    "express",
+    "turbo",
+    "turbo-express"
   ],
   "author": "Mike Karypidis",
   "license": "MIT",
   "bugs": {
     "url": "https://github.com/breathfunwithmindte/turbo-express/issues"
   },
-  "homepage": "https://github.com/breathfunwithmindte/turbo-express#readme"
+  "homepage": "https://github.com/mikekarypidis/turbo-express-js"
 }