@increase21/simplenodejs 1.0.19 → 1.0.21

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export { SimpleNodeJsController } from "./utils/simpleController";
-export { CreateSimpleJsHttpServer } from "./server";
-export { SetRequestCORS, SetRateLimiter, SetBodyParser } from "./utils/simpleMiddleware";
+export { CreateSimpleJsHttpServer, CreateSimpleJsHttpsServer } from "./server";
+export { SetCORS, SetHSTS, SetCSP, SetFrameGuard, SetNoSniff, SetReferrerPolicy, SetPermissionsPolicy, SetCOEP, SetCOOP, SetHelmet, SetRateLimiter, SetBodyParser, } from "./utils/simpleMiddleware";
 export * from "./utils/simplePlugins";
-export type { SimpleJsPrivateMethodProps, Middleware as SimpleJsMiddleware } from "./typings/general";
+export type { SimpleJsPrivateMethodProps, Middleware as SimpleJsMiddleware, SimpleJsHttpsServer } from "./typings/general";

package/dist/index.js

@@ -14,13 +14,23 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SetBodyParser = exports.SetRateLimiter = exports.SetRequestCORS = exports.CreateSimpleJsHttpServer = exports.SimpleNodeJsController = void 0;
+exports.SetBodyParser = exports.SetRateLimiter = exports.SetHelmet = exports.SetCOOP = exports.SetCOEP = exports.SetPermissionsPolicy = exports.SetReferrerPolicy = exports.SetNoSniff = exports.SetFrameGuard = exports.SetCSP = exports.SetHSTS = exports.SetCORS = exports.CreateSimpleJsHttpsServer = exports.CreateSimpleJsHttpServer = exports.SimpleNodeJsController = void 0;
 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; } });
+Object.defineProperty(exports, "CreateSimpleJsHttpsServer", { enumerable: true, get: function () { return server_1.CreateSimpleJsHttpsServer; } });
 var simpleMiddleware_1 = require("./utils/simpleMiddleware");
-Object.defineProperty(exports, "SetRequestCORS", { enumerable: true, get: function () { return simpleMiddleware_1.SetRequestCORS; } });
+Object.defineProperty(exports, "SetCORS", { enumerable: true, get: function () { return simpleMiddleware_1.SetCORS; } });
+Object.defineProperty(exports, "SetHSTS", { enumerable: true, get: function () { return simpleMiddleware_1.SetHSTS; } });
+Object.defineProperty(exports, "SetCSP", { enumerable: true, get: function () { return simpleMiddleware_1.SetCSP; } });
+Object.defineProperty(exports, "SetFrameGuard", { enumerable: true, get: function () { return simpleMiddleware_1.SetFrameGuard; } });
+Object.defineProperty(exports, "SetNoSniff", { enumerable: true, get: function () { return simpleMiddleware_1.SetNoSniff; } });
+Object.defineProperty(exports, "SetReferrerPolicy", { enumerable: true, get: function () { return simpleMiddleware_1.SetReferrerPolicy; } });
+Object.defineProperty(exports, "SetPermissionsPolicy", { enumerable: true, get: function () { return simpleMiddleware_1.SetPermissionsPolicy; } });
+Object.defineProperty(exports, "SetCOEP", { enumerable: true, get: function () { return simpleMiddleware_1.SetCOEP; } });
+Object.defineProperty(exports, "SetCOOP", { enumerable: true, get: function () { return simpleMiddleware_1.SetCOOP; } });
+Object.defineProperty(exports, "SetHelmet", { enumerable: true, get: function () { return simpleMiddleware_1.SetHelmet; } });
 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/router.d.ts

@@ -1,5 +1,3 @@
 import { RequestObject, ResponseObject } from "./typings/general";
-import { SimpleJsControllerMeta } from "./typings/simpletypes";
-export declare function loadControllers(root?: string): Map<string, SimpleJsControllerMeta>;
 export declare function setControllersDir(dir: string): void;
-export declare function route(req: RequestObject, res: ResponseObject): Promise<void>;
+export declare function route(req: RequestObject, res: ResponseObject): Promise<ResponseObject | undefined>;

package/dist/router.js

@@ -1,67 +1,40 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadControllers = loadControllers;
 exports.setControllersDir = setControllersDir;
 exports.route = route;
-// router.ts
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
 const helpers_1 = require("./utils/helpers");
+const simpleController_1 = require("./utils/simpleController");
 let controllers = new Map();
-function loadControllers(root = "controllers") {
-    const base = node_path_1.default.resolve(process.cwd(), root);
-    const map = new Map();
-    //walk up
-    function walk(dir) {
-        //get all the file in the directory
-        for (const file of node_fs_1.default.readdirSync(dir)) {
-            //add the file name and path
-            const full = node_path_1.default.join(dir, file);
-            //load direct and reload the files
-            if (node_fs_1.default.statSync(full).isDirectory())
-                walk(full);
-            //if it's file load the file
-            else if (file.endsWith(".js") || file.endsWith(".ts")) {
-                const mod = require(full);
-                // const Controller = mod.default;
-                if (!full.startsWith(base))
-                    return;
-                const Controller = require(full)?.default;
-                if (typeof Controller !== "function")
-                    return;
-                const key = full.replace(base, "").replace(/\\/g, "/").replace(/\.(ts|js)$/, "");
-                map.set(key.toLowerCase(), { name: Controller.name, Controller });
-            }
-        }
-    }
-    walk(base);
-    return map;
-}
+const UNSAFE_METHODS = new Set([
+    ...Object.getOwnPropertyNames(Object.prototype),
+    ...Object.getOwnPropertyNames(simpleController_1.SimpleNodeJsController.prototype),
+]);
 function setControllersDir(dir) {
-    controllers = loadControllers(dir);
+    controllers = (0, helpers_1.loadControllers)(dir);
 }
 async function route(req, res) {
     let parts = req._end_point_path || [];
-    let controllerPath = (parts.length > 2 ? "/" + parts.slice(0, 2).join("/") : `/${parts.join("/")}`).toLocaleLowerCase();
+    let controllerPath = (parts.length > 2 ? "/" + parts.slice(0, 2).join("/") : `/${parts.join("/")}`).toLowerCase().replace(/\-{1}\w{1}/g, match => match.replace("-", "").toUpperCase());
     let methodName = parts.length > 2 ? parts[2] : "index";
-    let id = methodName !== "index" ? parts.slice(parts.indexOf(methodName) + 1) : null;
+    let id = methodName !== "index" ? parts.slice(3).join("/") : null;
+    let httpMethod = (req.method || "").toLowerCase();
     const meta = controllers.get(controllerPath);
     //if the controller is not available or not found
     if (!meta || !meta.name || !meta.Controller)
         return (0, helpers_1.throwHttpError)(404, "The requested resource does not exist");
     const ControllerClass = meta.Controller;
     const controller = new ControllerClass();
-    //Update the method name to the framework pathen
+    //Update the method name to the framework pattern
     methodName = (methodName || "").replace(/\-{1}\w{1}/g, match => match.replace("-", "").toUpperCase());
+    // Block Object.prototype methods (constructor, toString, etc.) and __private convention
+    if (methodName.startsWith("__") || UNSAFE_METHODS.has(methodName)) {
+        return (0, helpers_1.throwHttpError)(404, "The requested resource does not exist");
+    }
     //if the endpoint not a function
     if (typeof controller[methodName] !== "function") {
-        //if it's using index
         if (typeof controller["index"] === "function" && parts.length === 3) {
             methodName = "index";
-            id = parts.slice(2);
+            id = parts.slice(2).join("/"); // pass the rest of the path as ID;
         }
         else {
             return (0, helpers_1.throwHttpError)(404, "The requested resource does not exist");
@@ -73,13 +46,26 @@ async function route(req, res) {
     }
     //bind the controller to use the global properties
     controller.__bindContext({ req, res });
-    ////if there's protected function to run
-    if (typeof controller.__checkContext === "function")
-        controller.__checkContext();
-    const result = await controller[methodName](...(id || []));
-    //if it's not responded
-    if (!res.writableEnded && result) {
-        res.setHeader("Content-Type", "application/json");
-        res.end(JSON.stringify(result));
-    }
+    let result = await controller[methodName](id);
+    //if the cycle has ended
+    if (res.writableEnded)
+        return;
+    //if the controller returned nothing and response is not ended, end it
+    if (!result && !res.writableEnded)
+        return res.end();
+    //if there's no method defined for the http verb, return 405
+    if (result && typeof result[httpMethod] !== "function")
+        return (0, helpers_1.throwHttpError)(405, "Method Not Allowed");
+    // ID validation rules
+    if (id && (!result.id || !result.id[httpMethod]))
+        return (0, helpers_1.throwHttpError)(404, "Resource not found");
+    if (result.id && result.id[httpMethod] === "required" && !id)
+        return (0, helpers_1.throwHttpError)(404, "Resource not found");
+    result = await result[httpMethod]({
+        req, res, query: controller.query, body: controller.body,
+        id: id, customData: controller._custom_data
+    });
+    //if not responded
+    if (!res.writableEnded)
+        res.end("");
 }

package/dist/server.d.ts

@@ -1,5 +1,9 @@
-import { IncomingMessage, ServerResponse } from "http";
-import { SimpleJsServer } from "./typings/general";
-export declare const CreateSimpleJsHttpServer: (handler?: (req: IncomingMessage, res: ServerResponse) => void, opts?: {
-    controllersDir: string;
-}) => SimpleJsServer;
+import https from "node:https";
+import { SimpleJsHttpsServer, SimpleJsServer } from "./typings/general";
+type ServerOptions = {
+    controllersDir?: string;
+    tlsOpts?: https.ServerOptions;
+};
+export declare const CreateSimpleJsHttpServer: (opts?: ServerOptions) => SimpleJsServer;
+export declare const CreateSimpleJsHttpsServer: (opts?: ServerOptions) => SimpleJsHttpsServer;
+export {};

package/dist/server.js

@@ -3,75 +3,80 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CreateSimpleJsHttpServer = void 0;
+exports.CreateSimpleJsHttpsServer = exports.CreateSimpleJsHttpServer = void 0;
 const http_1 = __importDefault(require("http"));
+const node_https_1 = __importDefault(require("node:https"));
+const node_querystring_1 = __importDefault(require("node:querystring"));
 const router_1 = require("./router");
 const node_crypto_1 = __importDefault(require("node:crypto"));
 const helpers_1 = require("./utils/helpers");
 const extension = (req, res) => {
-    //for response status
     res.status = (code) => {
-        if (!/^\d+/.test(String(code)) || typeof code !== "number")
+        if (typeof code !== "number")
             throw new Error("Status code expected to be number but got " + typeof code);
-        res.statusCode = code ? code : 200;
+        res.statusCode = code ?? 200;
         return res;
     };
-    ///convert the response to JSON
     res.json = (param) => {
         res.setHeader('Content-Type', 'application/json');
         res.end(JSON.stringify(param));
     };
-    //convert the response to text/plain
     res.text = (param) => {
         res.setHeader('Content-Type', 'text/plain');
         res.end(param);
     };
     const url = new URL(req.url, "http://localhost");
-    req.query = url.search ? url.search.substring(1) : '';
-    //endpoint path
+    req.query = url.search ? node_querystring_1.default.parse(url.search.substring(1)) : {};
     req._end_point_path = url.pathname.replace(/^\/+|\/+$/g, "").split("/");
-    //adding the request ID
     req.id = node_crypto_1.default.randomUUID();
     res.setHeader("X-Request-Id", req.id);
 };
-const CreateSimpleJsHttpServer = (handler, opts) => {
-    const middlewares = [];
-    const errorMiddlewares = [];
-    const plugins = [];
-    //set the director of the controller
-    if (opts?.controllersDir)
-        (0, router_1.setControllersDir)(opts.controllersDir);
-    const server = http_1.default.createServer(async (req, res) => {
+function buildRequestHandler(middlewares, errorMiddlewares) {
+    return async (req, res) => {
         try {
             extension(req, res);
-            const run = (0, helpers_1.composeWithError)(middlewares);
-            // handler && await handler(req, res)
             if (res.writableEnded)
                 return;
+            const run = (0, helpers_1.composeMiddleware)(middlewares);
             await run(req, res);
-            //if the request has ended stop here
             if (res.writableEnded)
                 return;
             await (0, router_1.route)(req, res);
         }
         catch (err) {
-            // 1. Run error middlewares
-            for (const mw of errorMiddlewares) {
-                await mw(err, req, res, () => { });
-            }
-            // 2. Safe HTTP response fallback
+            await (0, helpers_1.runErrorMiddlewares)(err, errorMiddlewares, req, res);
             if (!res.headersSent) {
-                res.statusCode = 503;
-                res.end("No Error Handlers: Service unavailable at the moment");
+                let errorCode = (err || {}).code;
+                res.statusCode = errorCode || 503;
+                res.end(errorCode ? err.error : "Service unavailable");
             }
         }
-    });
-    server.use = mw => { middlewares.push(mw); };
-    server.useError = mw => errorMiddlewares.push(mw);
-    server.registerPlugin = async (plugin) => {
-        plugins.push(plugin);
-        await plugin(server);
     };
+}
+function attachServerMethods(server, middlewares, errorMiddlewares, opts) {
+    server.use = mw => { middlewares.push(mw); };
+    server.useError = mw => { errorMiddlewares.push(mw); };
+    server.registerPlugin = async (plugin) => { await plugin(server); };
+}
+const CreateSimpleJsHttpServer = (opts) => {
+    const middlewares = [];
+    const errorMiddlewares = [];
+    if (opts && opts.controllersDir)
+        (0, router_1.setControllersDir)(opts.controllersDir);
+    const server = http_1.default.createServer(buildRequestHandler(middlewares, errorMiddlewares));
+    attachServerMethods(server, middlewares, errorMiddlewares, opts);
     return server;
 };
 exports.CreateSimpleJsHttpServer = CreateSimpleJsHttpServer;
+const CreateSimpleJsHttpsServer = (opts) => {
+    const middlewares = [];
+    const errorMiddlewares = [];
+    if (!opts?.tlsOpts)
+        throw new Error("CreateSimpleJsHttpsServer requires opts.tlsOpts");
+    if (opts.controllersDir)
+        (0, router_1.setControllersDir)(opts.controllersDir);
+    const server = node_https_1.default.createServer(opts.tlsOpts, buildRequestHandler(middlewares, errorMiddlewares));
+    attachServerMethods(server, middlewares, errorMiddlewares, opts);
+    return server;
+};
+exports.CreateSimpleJsHttpsServer = CreateSimpleJsHttpsServer;

package/dist/typings/general.d.ts

@@ -1,4 +1,5 @@
 import http, { IncomingMessage, ServerResponse } from "http";
+import https from "node:https";
 export type Next = () => Promise<any> | void;
 export type Plugin = (app: SimpleJsServer, opts?: any) => Promise<any> | void;
 export type HttpMethod = "get" | "post" | "put" | "patch" | "delete";
@@ -11,14 +12,17 @@ export interface SimpleJsServer extends http.Server {
     use(mw: Middleware): Promise<any> | void;
     useError: (mw: ErrorMiddleware) => void;
     registerPlugin: (plugin: Plugin) => Promise<any> | void;
-    _environment: 'dev' | 'stag' | 'live';
+}
+export interface SimpleJsHttpsServer extends https.Server {
+    use(mw: Middleware): Promise<any> | void;
+    useError: (mw: ErrorMiddleware) => void;
+    registerPlugin: (plugin: Plugin) => Promise<any> | void;
 }
 export interface RequestObject extends IncomingMessage {
     body?: any;
     query?: any;
     id?: string;
     _end_point_path?: string[];
-    _server_environment?: 'dev' | 'stag' | 'live';
     _custom_data?: ObjectPayload;
 }
 export interface ResponseObject extends ServerResponse {
@@ -26,26 +30,11 @@ export interface ResponseObject extends ServerResponse {
     json: (value: object) => void;
     text: (value?: string) => void;
 }
-export interface SubRequestHandler {
-    post?: (params: SimpleJsPrivateMethodProps) => void;
-    put?: (params: SimpleJsPrivateMethodProps) => void;
-    get?: (params: SimpleJsPrivateMethodProps) => void;
-    delete?: (params: SimpleJsPrivateMethodProps) => void;
-    patch?: (params: SimpleJsPrivateMethodProps) => void;
-}
 export interface SimpleJsPrivateMethodProps {
     body: ObjectPayload;
     res: ResponseObject;
     req: RequestObject;
     query: ObjectPayload;
-    id?: string;
+    id?: string | null;
     customData?: any;
-    idMethod?: {
-        post?: 'required' | 'optional';
-        get?: 'required' | 'optional';
-        put?: 'required' | 'optional';
-        delete?: 'required' | 'optional';
-        patch?: 'required' | 'optional';
-    };
 }
-export type AcceptHeaderValue = 'application/media' | 'application/text';

package/dist/typings/simpletypes.d.ts

@@ -1,6 +1,8 @@
+import { HttpMethod, SimpleJsPrivateMethodProps } from "./general";
 export type SimpleJSRateLimitType = {
     windowMs: number;
     max: number;
+    trustProxy?: boolean;
     keyGenerator?: (req: any) => string;
 };
 export type SimpleJSBodyParseType = {
@@ -10,3 +12,11 @@ export interface SimpleJsControllerMeta {
     name: string;
     Controller: any;
 }
+export interface SubRequestHandler {
+    post?: (params: SimpleJsPrivateMethodProps) => void;
+    put?: (params: SimpleJsPrivateMethodProps) => void;
+    get?: (params: SimpleJsPrivateMethodProps) => void;
+    delete?: (params: SimpleJsPrivateMethodProps) => void;
+    patch?: (params: SimpleJsPrivateMethodProps) => void;
+    id?: Partial<Record<HttpMethod, "required" | "optional">>;
+}

package/dist/utils/helpers.d.ts

@@ -1,3 +1,6 @@
-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;
+import { ErrorMiddleware, Middleware, RequestObject, ResponseObject } from "../typings/general";
+import { SimpleJsControllerMeta } from "../typings/simpletypes";
+export declare function composeMiddleware(middlewares: Middleware[]): (req: RequestObject, res: ResponseObject) => Promise<void>;
+export declare function runErrorMiddlewares(err: unknown, errorMiddlewares: ErrorMiddleware[], req: RequestObject, res: ResponseObject): Promise<void>;
+export declare function throwHttpError(code: number, message: string): never;
+export declare function loadControllers(root?: string): Map<string, SimpleJsControllerMeta>;

package/dist/utils/helpers.js

@@ -1,8 +1,15 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.composeWithError = composeWithError;
+exports.composeMiddleware = composeMiddleware;
+exports.runErrorMiddlewares = runErrorMiddlewares;
 exports.throwHttpError = throwHttpError;
-function composeWithError(middlewares) {
+exports.loadControllers = loadControllers;
+const node_path_1 = __importDefault(require("node:path"));
+const node_fs_1 = __importDefault(require("node:fs"));
+function composeMiddleware(middlewares) {
     return async function (req, res) {
         let idx = -1;
         async function dispatch(i) {
@@ -26,8 +33,49 @@ function composeWithError(middlewares) {
         return await dispatch(0);
     };
 }
+async function runErrorMiddlewares(err, errorMiddlewares, req, res) {
+    let idx = 0;
+    async function next() {
+        const mw = errorMiddlewares[idx++];
+        if (!mw || res.writableEnded)
+            return;
+        await mw(err, req, res, next);
+    }
+    await next();
+}
 function throwHttpError(code, message) {
     const error = new Error(message);
-    error.toJSON = () => ({ code, error: message });
+    error.code = code;
     throw error;
 }
+function loadControllers(root = "controllers") {
+    const base = node_path_1.default.resolve(process.cwd(), root);
+    const realBase = node_fs_1.default.realpathSync(base); // resolve the base itself (may be a symlink)
+    const map = new Map();
+    function walk(dir) {
+        for (const file of node_fs_1.default.readdirSync(dir)) {
+            const full = node_path_1.default.join(dir, file);
+            let realFull;
+            try {
+                realFull = node_fs_1.default.realpathSync(full); // resolve actual disk path, following all symlinks
+            }
+            catch {
+                continue; // skip broken symlinks
+            }
+            // Block anything whose real path is outside the controllers directory
+            if (!realFull.startsWith(realBase + node_path_1.default.sep))
+                continue;
+            if (node_fs_1.default.statSync(full).isDirectory())
+                walk(full);
+            else if (file.endsWith(".js") || file.endsWith(".ts")) {
+                const Controller = require(full)?.default;
+                if (typeof Controller !== "function")
+                    continue;
+                const key = full.slice(base.length).replace(/\\/g, "/").replace(/\.(ts|js)$/, "");
+                map.set(key.toLowerCase(), { name: Controller.name, Controller });
+            }
+        }
+    }
+    walk(base);
+    return map;
+}

package/dist/utils/simpleController.d.ts

@@ -1,5 +1,5 @@
-import { HttpMethod, ObjectPayload, RequestObject, ResponseObject, SimpleJsPrivateMethodProps } from "../typings/general";
-type SubRequestHandler = Partial<Record<HttpMethod, (params: SimpleJsPrivateMethodProps) => any>>;
+import { HttpMethod, ObjectPayload, RequestObject, ResponseObject } from "../typings/general";
+import { SubRequestHandler } from "../typings/simpletypes";
 export declare class SimpleNodeJsController {
     protected req: RequestObject;
     protected res: ResponseObject;
@@ -7,13 +7,11 @@ export declare class SimpleNodeJsController {
     protected query: ObjectPayload;
     protected method: HttpMethod;
     protected _custom_data: any;
-    /** framework-internal method */
+    /** @internal */
     __bindContext(ctx: {
         req: RequestObject;
         res: ResponseObject;
     }): void;
-    /** framework-internal method */
-    __checkContext(): void;
-    protected RunRequest(handlers: SubRequestHandler, params?: Partial<SimpleJsPrivateMethodProps>): any;
+    protected __checkContext(): void;
+    protected __run(handlers: SubRequestHandler): SubRequestHandler;
 }
-export {};

package/dist/utils/simpleController.js

@@ -1,9 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SimpleNodeJsController = void 0;
-const helpers_1 = require("./helpers");
 class SimpleNodeJsController {
-    /** framework-internal method */
+    /** @internal */
     __bindContext(ctx) {
         this.req = ctx.req;
         this.res = ctx.res;
@@ -11,27 +10,11 @@ class SimpleNodeJsController {
         this.query = ctx.req.query;
         this.method = (ctx.req.method || "").toLocaleLowerCase();
         this._custom_data = ctx.req._custom_data;
+        this.__checkContext();
     }
-    /** framework-internal method */
     __checkContext() { }
-    RunRequest(handlers, params) {
-        const method = this.req.method?.toLowerCase();
-        if (!method)
-            return (0, helpers_1.throwHttpError)(400, "Invalid HTTP Method");
-        const runFn = handlers[method];
-        if (typeof runFn !== "function")
-            return (0, helpers_1.throwHttpError)(405, "Method Not Allowed");
-        // ID validation rules
-        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,
-            customData: this._custom_data,
-            body: this.body,
-        });
+    __run(handlers) {
+        return handlers;
     }
 }
 exports.SimpleNodeJsController = SimpleNodeJsController;

package/dist/utils/simpleMiddleware.d.ts

@@ -1,8 +1,36 @@
 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 SetCORS(opts?: {
+    origin?: string;
+    methods?: string;
+    headers?: string;
+    credentials?: boolean;
+}): (req: RequestObject, res: ResponseObject, next: any) => Promise<void>;
+export declare function SetHSTS(opts?: {
+    maxAge?: number;
+    includeSubDomains?: boolean;
+    preload?: boolean;
+}): (_req: RequestObject, res: ResponseObject, next: any) => Promise<void>;
+export declare function SetCSP(policy?: string): (_req: RequestObject, res: ResponseObject, next: any) => Promise<void>;
+export declare function SetFrameGuard(action?: "DENY" | "SAMEORIGIN"): (_req: RequestObject, res: ResponseObject, next: any) => Promise<void>;
+export declare function SetNoSniff(): (_req: RequestObject, res: ResponseObject, next: any) => Promise<void>;
+export declare function SetReferrerPolicy(policy?: string): (_req: RequestObject, res: ResponseObject, next: any) => Promise<void>;
+export declare function SetPermissionsPolicy(policy?: string): (_req: RequestObject, res: ResponseObject, next: any) => Promise<void>;
+export declare function SetCOEP(value?: string): (_req: RequestObject, res: ResponseObject, next: any) => Promise<void>;
+export declare function SetCOOP(value?: string): (_req: RequestObject, res: ResponseObject, next: any) => Promise<void>;
+export declare function SetHelmet(opts?: {
+    hsts?: false | {
+        maxAge?: number;
+        includeSubDomains?: boolean;
+        preload?: boolean;
+    };
+    csp?: false | string;
+    frameGuard?: false | "DENY" | "SAMEORIGIN";
+    noSniff?: false;
+    referrerPolicy?: false | string;
+    permissionsPolicy?: false | string;
+    coep?: false | string;
+    coop?: false | 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>;