@increase21/simplenodejs 1.0.15 → 1.0.16

package/README.md

@@ -190,9 +190,20 @@ app.use(async (req, res, next) => {
 Registers a global error handler.
 
 ### Signature
+app.useError() registers global error-handling middleware.
+It catches all errors thrown anywhere in the request lifecycle — including:
+	•	Errors thrown inside middlewares
+	•	Errors thrown inside controllers / route handlers
+	•	Async errors (throw or rejected promises)
+	•	Validation errors
+	•	Custom application errors
+
+This gives you a single, centralized place to log, format, and return consistent error responses across your entire system.
 
 ```ts
-(err: any, req: RequestObject, res: ResponseObject, next: () => void) => void
+app.useError((err, req, res, next) => {
+  // handle error
+});
 ```
 
 ---

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export { SimpleNodeJsController } from "./utils/simpleController";
 export { CreateSimpleJsHttpServer } from "./server";
-export { SetRequestCORS, SetRateLimiter, SetBodyParser } from "./utils/helpers";
+export { SetRequestCORS, SetRateLimiter, SetBodyParser } from "./utils/simpleMiddleware";
 export * from "./utils/simplePlugins";
 export type { SimpleJsPrivateMethodProps } from "./typings/general";

package/dist/index.js

@@ -19,8 +19,8 @@ var simpleController_1 = require("./utils/simpleController");
 Object.defineProperty(exports, "SimpleNodeJsController", { enumerable: true, get: function () { return simpleController_1.SimpleNodeJsController; } });
 var server_1 = require("./server");
 Object.defineProperty(exports, "CreateSimpleJsHttpServer", { enumerable: true, get: function () { return server_1.CreateSimpleJsHttpServer; } });
-var helpers_1 = require("./utils/helpers");
-Object.defineProperty(exports, "SetRequestCORS", { enumerable: true, get: function () { return helpers_1.SetRequestCORS; } });
-Object.defineProperty(exports, "SetRateLimiter", { enumerable: true, get: function () { return helpers_1.SetRateLimiter; } });
-Object.defineProperty(exports, "SetBodyParser", { enumerable: true, get: function () { return helpers_1.SetBodyParser; } });
+var simpleMiddleware_1 = require("./utils/simpleMiddleware");
+Object.defineProperty(exports, "SetRequestCORS", { enumerable: true, get: function () { return simpleMiddleware_1.SetRequestCORS; } });
+Object.defineProperty(exports, "SetRateLimiter", { enumerable: true, get: function () { return simpleMiddleware_1.SetRateLimiter; } });
+Object.defineProperty(exports, "SetBodyParser", { enumerable: true, get: function () { return simpleMiddleware_1.SetBodyParser; } });
 __exportStar(require("./utils/simplePlugins"), exports);

package/dist/server.js

@@ -42,10 +42,10 @@ const CreateSimpleJsHttpServer = (handler, opts) => {
     if (opts?.controllersDir)
         (0, router_1.setControllersDir)(opts.controllersDir);
     const server = http_1.default.createServer(async (req, res) => {
-        extension(req, res);
-        const run = (0, helpers_1.composeWithError)(middlewares, errorMiddlewares);
         try {
-            handler && await handler(req, res);
+            extension(req, res);
+            const run = (0, helpers_1.composeWithError)(middlewares);
+            // handler && await handler(req, res)
             if (res.writableEnded)
                 return;
             await run(req, res);
@@ -62,7 +62,7 @@ const CreateSimpleJsHttpServer = (handler, opts) => {
             // 2. Safe HTTP response fallback
             if (!res.headersSent) {
                 res.statusCode = 503;
-                res.end("Service unavailable at the moment");
+                res.end("No Error Handlers: Service unavailable at the moment");
             }
         }
     });

package/dist/typings/general.d.ts

@@ -1,16 +1,16 @@
 import http, { IncomingMessage, ServerResponse } from "http";
-export type Next = () => Promise<void> | void;
-export type Plugin = (app: SimpleJsServer, opts?: any) => Promise<void> | void;
+export type Next = () => Promise<any> | void;
+export type Plugin = (app: SimpleJsServer, opts?: any) => Promise<any> | void;
 export type HttpMethod = "get" | "post" | "put" | "patch" | "delete";
 export type ObjectPayload = {
     [key: string]: any;
 };
-export type Middleware = (req: RequestObject, res: ResponseObject, next: () => Promise<void> | void) => Promise<void> | void;
-export type ErrorMiddleware = (err: any, req: RequestObject, res: ResponseObject, next: Next) => Promise<void> | void;
+export type Middleware = (req: RequestObject, res: ResponseObject, next: () => Promise<any> | void, errorHandler?: () => void) => Promise<any> | void;
+export type ErrorMiddleware = (err: any, req: RequestObject, res: ResponseObject, next: Next) => Promise<boolean> | void;
 export interface SimpleJsServer extends http.Server {
     use(mw: Middleware): Promise<any> | void;
     useError: (mw: ErrorMiddleware) => void;
-    registerPlugin: (plugin: Plugin) => Promise<void>;
+    registerPlugin: (plugin: Plugin) => Promise<any> | void;
     _environment: 'dev' | 'stag' | 'live';
 }
 export interface RequestObject extends IncomingMessage {

package/dist/utils/helpers.d.ts

@@ -1,10 +1,3 @@
-import { RequestObject, ResponseObject } from "../typings/general";
-import { ErrorMiddleware, Middleware } from "../typings/general";
-import { SimpleJSBodyParseType, SimpleJSRateLimitType } from "../typings/simpletypes";
-export declare function SetRequestCORS(opts: {
-    name: string;
-    value: string;
-}[]): (req: RequestObject, res: ResponseObject, next: any) => Promise<void>;
-export declare function SetRateLimiter(opts: SimpleJSRateLimitType): (req: RequestObject, res: ResponseObject, next: () => Promise<any> | void) => Promise<void>;
-export declare function SetBodyParser(opts: SimpleJSBodyParseType): (req: RequestObject, res: ResponseObject, next: () => Promise<any> | void) => Promise<void>;
-export declare function composeWithError(middlewares: Middleware[], errorMiddlewares: ErrorMiddleware[]): (req: RequestObject, res: ResponseObject) => Promise<void>;
+import { Middleware, RequestObject, ResponseObject } from "../typings/general";
+export declare function composeWithError(middlewares: Middleware[]): (req: RequestObject, res: ResponseObject) => Promise<void>;
+export declare function throwHttpError(code: number, message: string): void;

package/dist/utils/helpers.js

@@ -1,169 +1,34 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SetRequestCORS = SetRequestCORS;
-exports.SetRateLimiter = SetRateLimiter;
-exports.SetBodyParser = SetBodyParser;
 exports.composeWithError = composeWithError;
-const node_querystring_1 = __importDefault(require("node:querystring"));
-// core/cors.ts
-function SetRequestCORS(opts) {
-    return async (req, res, next) => {
-        const defaults = {
-            "Access-Control-Allow-Origin": "*",
-            "Access-Control-Allow-Headers": "Origin, X-Requested-With, Content-Type, Accept, Authorization",
-            "Access-Control-Allow-Methods": "GET, POST, DELETE, PUT, PATCH",
-            "X-Content-Type-Options": "nosniff",
-            "X-Frame-Options": "DENY",
-            "Referrer-Policy": "no-referrer",
-            "Content-Security-Policy": "default-src 'none'",
-        };
-        let merged = { ...defaults };
-        for (const { name, value } of opts) {
-            merged[name] = value; // overrides defaults if same key
-        }
-        //allow credentials only when origin specified
-        if (merged["Access-Control-Allow-Credentials"] === "true") {
-            const origin = req.headers.origin;
-            res.status(403).end();
-            if (!origin)
-                return;
-            merged["Access-Control-Allow-Origin"] = origin;
-        }
-        for (const [key, value] of Object.entries(merged)) {
-            res.setHeader(key, value);
-        }
-        if (req.method === "OPTIONS") {
-            res.status(204).end();
-            return;
-        }
-        await next();
-    };
-}
-// core/rateLimit.ts
-function SetRateLimiter(opts) {
-    const store = new Map();
-    const timer = setInterval(() => {
-        const now = Date.now();
-        for (const [k, v] of store) {
-            if (now - v.ts > opts.windowMs * 2)
-                store.delete(k);
-        }
-    }, opts.windowMs);
-    timer.unref();
-    return async (req, res, next) => {
-        const rawIp = req.headers["x-forwarded-for"] || req.socket.remoteAddress || "unknown";
-        const ip = Array.isArray(rawIp) ? rawIp[0] : String(rawIp).split(",")[0].trim();
-        const key = String(opts.keyGenerator?.(req) || ip || "unknown");
-        const now = Date.now();
-        const entry = store.get(key) || { count: 0, ts: now };
-        if (now - entry.ts > opts.windowMs) {
-            entry.count = 0;
-            entry.ts = now;
-        }
-        entry.count++;
-        store.set(key, entry);
-        if (entry.count > opts.max) {
-            res.setHeader("Retry-After", Math.ceil(opts.windowMs / 1000));
-            res.status(429).json({ error: "Too Many Requests" });
-            return;
-        }
-        await next();
-    };
-}
-// core/body.ts
-function SetBodyLimit(limit = "1mb") {
-    if (typeof limit === "number")
-        return limit;
-    const match = /^(\d+)(kb|mb)?$/i.exec(limit);
-    if (!match)
-        return 1024 * 1024;
-    const n = parseInt(match[1], 10);
-    const unit = match[2]?.toLowerCase();
-    if (unit === "kb")
-        return n * 1024;
-    if (unit === "mb")
-        return n * 1024 * 1024;
-    return n;
-}
-function SetBodyParser(opts) {
-    const maxSize = SetBodyLimit(opts.limit);
-    return async (req, res, next) => {
-        return new Promise(resolve => {
-            let size = 0;
-            let body = "";
-            req.on("data", chunk => {
-                size += chunk.length;
-                if (maxSize && size > maxSize) {
-                    if (!res.writableEnded) {
-                        res.status(413).json({ error: "Payload too large" });
-                    }
-                    req.destroy();
-                    req.socket.destroy();
-                    return;
-                }
-                //add the body
-                body += chunk;
-            });
-            req.on("end", () => {
-                if (res.writableEnded)
-                    return resolve();
-                try {
-                    if (body && !["application/text", "application/media"].includes(req.headers.accept)) {
-                        req.body = JSON.parse(body);
-                    }
-                    else {
-                        req.body = body;
-                    }
-                    //parse query
-                    if (req.query) {
-                        req.query = JSON.parse(JSON.stringify(node_querystring_1.default.parse(req.query)));
-                    }
-                    resolve(next());
-                }
-                catch (e) {
-                    res.status(400).json({ error: "Invalid request body" });
-                    return resolve();
-                }
-            });
-            req.on("error", () => {
-                if (!res.writableEnded) {
-                    res.status(400).json({ error: "Request stream error" });
-                }
-                resolve();
-            });
-        });
-    };
-}
-function composeWithError(middlewares, errorMiddlewares) {
+exports.throwHttpError = throwHttpError;
+function composeWithError(middlewares) {
     return async function (req, res) {
         let idx = -1;
         async function dispatch(i) {
             if (i <= idx)
                 throw new Error("next() called twice");
             idx = i;
+            if (res.writableEnded)
+                return;
             const fn = middlewares[i];
             if (!fn)
                 return;
-            try {
-                await fn(req, res, () => dispatch(i + 1));
-            }
-            catch (err) {
-                await dispatchError(err, 0);
-            }
-        }
-        async function dispatchError(err, i) {
-            const fn = errorMiddlewares[i];
-            if (!fn) {
-                if (!res.writableEnded) {
-                    res.status(500).json({ error: "Unhandled error", detail: String(err) });
-                }
-                return;
-            }
-            await fn(err, req, res, () => dispatchError(err, i + 1));
-        }
-        await dispatch(0);
+            let called = false;
+            const next = async () => {
+                if (called)
+                    throw new Error("next() called multiple times in the same middleware");
+                called = true;
+                return dispatch(i + 1);
+            };
+            return await fn(req, res, next);
+        }
+        return await dispatch(0);
     };
 }
+function throwHttpError(code, message) {
+    const error = new Error(message);
+    error.statusCode = code;
+    error.toJSON = () => ({ code, error: message });
+    throw error;
+}

package/dist/utils/simpleController.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SimpleNodeJsController = void 0;
+const helpers_1 = require("./helpers");
 class SimpleNodeJsController {
     /** framework-internal method */
     __bindContext(ctx) {
@@ -16,17 +17,15 @@ class SimpleNodeJsController {
     RunRequest(handlers, params) {
         const method = this.req.method?.toLowerCase();
         if (!method)
-            return this.res.status(400).json({ code: 400, error: "Invalid HTTP Method" });
+            return (0, helpers_1.throwHttpError)(400, "Invalid HTTP Method");
         const runFn = handlers[method];
         if (typeof runFn !== "function")
-            return this.res.status(405).json({ code: 405, error: "Method Not Allowed" });
+            return (0, helpers_1.throwHttpError)(405, "Method Not Allowed");
         // ID validation rules
-        if (params && params.id && (!params.idMethod || !params.idMethod[method])) {
-            return this.res.status(404).json({ code: 404, error: "Resource not found" });
-        }
-        if (params && params.idMethod?.[method] === "required" && !params.id) {
-            return this.res.status(404).json({ code: 404, error: "Resource not found" });
-        }
+        if (params && params.id && (!params.idMethod || !params.idMethod[method]))
+            return (0, helpers_1.throwHttpError)(404, "Resource not found");
+        if (params && params.idMethod?.[method] === "required" && !params.id)
+            return (0, helpers_1.throwHttpError)(404, "Resource not found");
         return runFn({
             ...(params || {}), req: this.req,
             res: this.res, query: this.query,

package/dist/utils/simpleMiddleware.d.ts

@@ -0,0 +1,8 @@
+import { RequestObject, ResponseObject } from "../typings/general";
+import { SimpleJSBodyParseType, SimpleJSRateLimitType } from "../typings/simpletypes";
+export declare function SetRequestCORS(opts: {
+    name: string;
+    value: string;
+}[]): (req: RequestObject, res: ResponseObject, next: any) => Promise<void>;
+export declare function SetRateLimiter(opts: SimpleJSRateLimitType): (req: RequestObject, res: ResponseObject, next: () => Promise<any> | void) => Promise<void>;
+export declare function SetBodyParser(opts: SimpleJSBodyParseType): (req: RequestObject, res: ResponseObject, next: () => Promise<any> | void) => Promise<void>;

package/dist/utils/simpleMiddleware.js

@@ -0,0 +1,144 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetRequestCORS = SetRequestCORS;
+exports.SetRateLimiter = SetRateLimiter;
+exports.SetBodyParser = SetBodyParser;
+const node_querystring_1 = __importDefault(require("node:querystring"));
+const helpers_1 = require("./helpers");
+// core/cors.ts
+function SetRequestCORS(opts) {
+    return async (req, res, next) => {
+        const defaults = {
+            "Access-Control-Allow-Origin": "*",
+            "Access-Control-Allow-Headers": "Origin, X-Requested-With, Content-Type, Accept, Authorization",
+            "Access-Control-Allow-Methods": "GET, POST, DELETE, PUT, PATCH",
+            "X-Content-Type-Options": "nosniff",
+            "X-Frame-Options": "DENY",
+            "Referrer-Policy": "no-referrer",
+            "Content-Security-Policy": "default-src 'none'",
+        };
+        let merged = { ...defaults };
+        for (const { name, value } of opts) {
+            merged[name] = value; // overrides defaults if same key
+        }
+        //allow credentials only when origin specified
+        if (merged["Access-Control-Allow-Credentials"] === "true") {
+            const origin = req.headers.origin;
+            if (!origin) {
+                (0, helpers_1.throwHttpError)(403, "CORS Error: Origin header is required when Access-Control-Allow-Credentials is true");
+                return;
+            }
+            merged["Access-Control-Allow-Origin"] = origin;
+        }
+        for (const [key, value] of Object.entries(merged)) {
+            res.setHeader(key, value);
+        }
+        if (req.method === "OPTIONS") {
+            res.status(204).end();
+            return;
+        }
+        await next();
+    };
+}
+// core/rateLimit.ts
+function SetRateLimiter(opts) {
+    const store = new Map();
+    const timer = setInterval(() => {
+        const now = Date.now();
+        for (const [k, v] of store) {
+            if (now - v.ts > opts.windowMs * 2)
+                store.delete(k);
+        }
+    }, opts.windowMs);
+    timer.unref();
+    return async (req, res, next) => {
+        const rawIp = req.headers["x-forwarded-for"] || req.socket.remoteAddress || "unknown";
+        const ip = Array.isArray(rawIp) ? rawIp[0] : String(rawIp).split(",")[0].trim();
+        const key = String(opts.keyGenerator?.(req) || ip || "unknown");
+        const now = Date.now();
+        const entry = store.get(key) || { count: 0, ts: now };
+        if (now - entry.ts > opts.windowMs) {
+            entry.count = 0;
+            entry.ts = now;
+        }
+        entry.count++;
+        store.set(key, entry);
+        if (entry.count > opts.max) {
+            res.setHeader("Retry-After", Math.ceil(opts.windowMs / 1000));
+            if (!res.writableEnded)
+                (0, helpers_1.throwHttpError)(429, "Too Many Requests");
+            return;
+        }
+        await next();
+    };
+}
+// core/body.ts
+function SetBodyLimit(limit = "1mb") {
+    if (typeof limit === "number")
+        return limit;
+    const match = /^(\d+)(kb|mb)?$/i.exec(limit);
+    if (!match)
+        return 1024 * 1024;
+    const n = parseInt(match[1], 10);
+    const unit = match[2]?.toLowerCase();
+    if (unit === "kb")
+        return n * 1024;
+    if (unit === "mb")
+        return n * 1024 * 1024;
+    return n;
+}
+//For 
+function SetBodyParser(opts) {
+    const maxSize = SetBodyLimit(opts.limit);
+    return (req, res, next) => new Promise((resolve, reject) => {
+        //get the content type of the request
+        const contentType = req.headers["content-type"] || "";
+        // Skip multipart/form-data (file uploads)
+        if (contentType.includes("multipart/form-data"))
+            return resolve(next());
+        let size = 0;
+        let body = "";
+        req.on("data", chunk => {
+            size += chunk.length;
+            if (maxSize && size > maxSize) {
+                reject({ code: 413, error: "Payload Too Large" });
+                if (!res.writableEnded)
+                    res.status(413).end("Payload Too Large");
+                req.destroy();
+                req.socket.destroy();
+                return;
+            }
+            //add the body
+            body += chunk;
+        });
+        req.on("end", () => {
+            if (res.writableEnded)
+                return resolve();
+            try {
+                if (body && contentType.includes("application/json")) {
+                    req.body = JSON.parse(body);
+                }
+                else {
+                    req.body = body;
+                }
+                //parse query
+                if (req.query) {
+                    req.query = JSON.parse(JSON.stringify(node_querystring_1.default.parse(req.query)));
+                }
+                resolve(next());
+            }
+            catch (e) {
+                if (!res.writableEnded)
+                    reject({ code: 400, error: "Invalid request body" });
+            }
+        });
+        req.on("error", () => {
+            if (!res.writableEnded)
+                reject({ code: 400, error: "Request stream error" });
+        });
+    });
+}
+;

package/dist/utils/simplePlugins.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SimpleJsSecurityPlugin = SimpleJsSecurityPlugin;
-const helpers_1 = require("./helpers");
+const simpleMiddleware_1 = require("./simpleMiddleware");
 function SimpleJsSecurityPlugin(app, opts) {
-    opts.cors && app.use((0, helpers_1.SetRequestCORS)(opts.cors || []));
-    opts.rateLimit && app.use((0, helpers_1.SetRateLimiter)(opts.rateLimit || { windowMs: 1000, max: 100 }));
+    opts.cors && app.use((0, simpleMiddleware_1.SetRequestCORS)(opts.cors || []));
+    opts.rateLimit && app.use((0, simpleMiddleware_1.SetRateLimiter)(opts.rateLimit || { windowMs: 1000, max: 100 }));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@increase21/simplenodejs",
-  "version": "1.0.15",
+  "version": "1.0.16",
   "description": "Lightweight Node.js HTTP framework with middleware and plugins",
   "dev": "dist/index.js",
   "bugs": "https://github.com/increase21/simplenodejs/issues",