@increase21/simplenodejs 1.0.0 → 1.0.2

package/dist/index.d.ts

@@ -1,3 +1,5 @@
 export { CreateSimpleJsHttpServer } from "./server";
 export * from "./utils/helpers";
+export * from "./utils/simpleController";
+export * from "./utils/simplePlugins";
 export { Middleware, ErrorMiddleware, SimpleJsServer } from "./typings/general";

package/dist/index.js

@@ -18,5 +18,5 @@ exports.CreateSimpleJsHttpServer = void 0;
 var server_1 = require("./server");
 Object.defineProperty(exports, "CreateSimpleJsHttpServer", { enumerable: true, get: function () { return server_1.CreateSimpleJsHttpServer; } });
 __exportStar(require("./utils/helpers"), exports);
-// Optional: plugins
-// export { SecurityPlugin } from "./plugins/SecurityPlugin";
+__exportStar(require("./utils/simpleController"), exports);
+__exportStar(require("./utils/simplePlugins"), exports);

package/dist/router.d.ts

@@ -1,7 +1,6 @@
-import { RequestObject, ResponseObject } from "./typings/context";
+import { RequestObject, ResponseObject } from "./typings/general";
 export interface ControllerMeta {
     name: string;
-    file: string;
     Controller: any;
 }
 export declare function loadControllers(root?: string): Map<string, ControllerMeta>;

package/dist/router.js

@@ -23,11 +23,14 @@ function loadControllers(root = "controllers") {
             //if it's file load the file
             else if (file.endsWith(".js") || file.endsWith(".ts")) {
                 const mod = require(full);
-                const Controller = mod.default;
-                if (Controller) {
-                    const key = full.replace(base, "").replace(/\\/g, "/").replace(/\.(ts|js)$/, "");
-                    map.set(key.toLowerCase(), { name: Controller.name, file: full, Controller });
-                }
+                // 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 });
             }
         }
     }
@@ -39,19 +42,34 @@ async function route(req, res, controllersDir) {
     // console.log("Router is called")
     const url = new URL(req.url, "http://localhost");
     const parts = url.pathname.replace(/^\/+|\/+$/g, "").split("/");
-    const controllerPath = "/" + parts.slice(0, -1).join("/");
-    const methodName = parts[parts.length - 1] || "index";
-    const id = parts[parts.length];
-    const meta = controllers.get(controllerPath.toLowerCase());
-    if (!meta)
-        return res.status(404).text("The requested resource does not exist");
+    let controllerPath = (parts.length > 2 ? "/" + parts.slice(0, 2).join("/") : `/${parts.join("/")}`).toLocaleLowerCase();
+    let methodName = parts.length > 2 ? parts[2] : "index";
+    let id = methodName !== "index" ? parts.slice(parts.indexOf(methodName) + 1) : null;
+    const meta = controllers.get(controllerPath);
+    //if the controller is not available or not found
+    if (!meta || !meta.name || !meta.Controller)
+        return res.status(404).json({ error: "The requested resource does not exist" });
     const ControllerClass = meta.Controller;
-    const controller = new ControllerClass(req, res);
+    const controller = new ControllerClass();
+    //if the endpoint not a function
     if (typeof controller[methodName] !== "function") {
-        return res.status(404).text("The requested resource does not exist");
+        //if it's using index
+        if (typeof controller["index"] === "function" && parts.length === 3) {
+            methodName = "index";
+            id = parts.slice(2);
+        }
+        else {
+            return res.status(404).json({ error: "The requested resource does not exist" });
+        }
+    }
+    //if the data require params but there's no matching params
+    if (id && id.length && (!controller[methodName].length || controller[methodName].length < id.length)) {
+        return res.status(404).json({ error: "The requested resource does not exist. Kindly check your url" });
     }
-    const result = await controller[methodName](id);
-    if (!res.writableEnded && result !== undefined) {
+    controller._bindContext({ req, res });
+    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));
     }

package/dist/server.d.ts

@@ -1,4 +1,3 @@
 import { IncomingMessage, ServerResponse } from "http";
-import { Middleware, RequestObject, ResponseObject, SimpleJsServer } from "./typings/general";
-export declare function compose(middlewares: Middleware[]): (req: RequestObject, res: ResponseObject) => Promise<void>;
+import { SimpleJsServer } from "./typings/general";
 export declare const CreateSimpleJsHttpServer: (handler?: (req: IncomingMessage, res: ServerResponse) => void) => SimpleJsServer;

package/dist/server.js

@@ -4,9 +4,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CreateSimpleJsHttpServer = void 0;
-exports.compose = compose;
 const http_1 = __importDefault(require("http"));
 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) => {
@@ -25,36 +26,16 @@ const extension = (req, res) => {
         res.setHeader('Content-Type', 'text/plain');
         res.end(param);
     };
+    req.id = node_crypto_1.default.randomUUID();
+    res.setHeader("X-Request-Id", req.id);
 };
-function compose(middlewares) {
-    return async function (req, res) {
-        let idx = -1;
-        async function dispatch(i) {
-            if (i <= idx)
-                throw new Error("next() called twice");
-            idx = i;
-            const fn = middlewares[i];
-            if (!fn)
-                return;
-            try {
-                await fn(req, res, () => dispatch(i + 1));
-            }
-            catch (err) {
-                if (!res.writableEnded) {
-                    res.status(500).json({ error: "Middleware error" });
-                }
-            }
-        }
-        await dispatch(0);
-    };
-}
 const CreateSimpleJsHttpServer = (handler) => {
     const middlewares = [];
     const errorMiddlewares = [];
     const plugins = [];
     const server = http_1.default.createServer(async (req, res) => {
         extension(req, res);
-        const run = compose(middlewares);
+        const run = (0, helpers_1.composeWithError)(middlewares, errorMiddlewares);
         try {
             handler && await handler(req, res);
             if (res.writableEnded)
@@ -66,11 +47,17 @@ const CreateSimpleJsHttpServer = (handler) => {
             await (0, router_1.route)(req, res);
         }
         catch (err) {
-            res.statusCode = 500;
-            res.end("Internal Server Error");
+            // 1. Run error middlewares
+            for (const mw of errorMiddlewares) {
+                await mw(err, req, res, () => { });
+            }
+            // 2. Safe HTTP response fallback
+            if (!res.headersSent) {
+                res.statusCode = 503;
+                res.end("Service unavailable at the moment");
+            }
         }
     });
-    server.setTimeout(60000); //60Seconds
     server.use = mw => { middlewares.push(mw); };
     server.useError = mw => errorMiddlewares.push(mw);
     server.register = async (plugin, opts) => {

package/dist/typings/general.d.ts

@@ -1,22 +1,47 @@
 import http, { IncomingMessage, ServerResponse } from "http";
 export type Next = () => Promise<void> | void;
 export type Plugin = (app: SimpleJsServer, opts?: any) => Promise<void> | void;
+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 interface SimpleJsServer extends http.Server {
     use(mw: Middleware): Promise<any> | void;
     useError: (mw: ErrorMiddleware) => void;
     register: (plugin: Plugin, opts?: any) => Promise<void>;
+    _environment: 'dev' | 'stag' | 'live';
 }
 export interface RequestObject extends IncomingMessage {
     body?: any;
     query?: any;
     _server_environment?: 'dev' | 'stag' | 'live';
-    _body_size?: 0;
+    id?: string;
 }
 export interface ResponseObject extends ServerResponse {
     status: (value: number) => ResponseObject;
     json: (value: object) => void;
     text: (value?: string) => void;
 }
+export interface SubRequestHandler {
+    post?: (params: PrivateMethodProps) => void;
+    put?: (params: PrivateMethodProps) => void;
+    get?: (params: PrivateMethodProps) => void;
+    delete?: (params: PrivateMethodProps) => void;
+    patch?: (params: PrivateMethodProps) => void;
+}
+export interface PrivateMethodProps {
+    body: ObjectPayload;
+    res: ResponseObject;
+    req: RequestObject;
+    query: ObjectPayload;
+    id?: string;
+    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

@@ -0,0 +1,8 @@
+export type SimpleJSRateLimitType = {
+    windowMs: number;
+    max: number;
+    keyGenerator?: (req: any) => string;
+};
+export type SimpleJSBodyParseType = {
+    limit?: string | number;
+};

package/dist/utils/helpers.d.ts

@@ -1,17 +1,10 @@
-import { RequestObject, ResponseObject } from "../typings/context";
-import { ErrorMiddleware, Middleware, SimpleJsServer } from "../typings/general";
+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: {
-    windowMs: number;
-    max: number;
-    keyGenerator?: (req: any) => string;
-}): (req: RequestObject, res: ResponseObject, next: () => Promise<any> | void) => Promise<void>;
-export declare function SetBodyParser(opts: {
-    limit?: string | number;
-    json?: boolean;
-}): (req: RequestObject, res: ResponseObject, next: () => Promise<any> | void) => 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>;
-export declare function SecurityPlugin(app: SimpleJsServer, opts: any): void;

package/dist/utils/helpers.js

@@ -7,15 +7,18 @@ exports.SetRequestCORS = SetRequestCORS;
 exports.SetRateLimiter = SetRateLimiter;
 exports.SetBodyParser = SetBodyParser;
 exports.composeWithError = composeWithError;
-exports.SecurityPlugin = SecurityPlugin;
 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": "Authorization",
-            "Access-Control-Allow-Methods": "GET, POST"
+            "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) {
@@ -23,13 +26,17 @@ function SetRequestCORS(opts) {
         }
         //allow credentials only when origin specified
         if (merged["Access-Control-Allow-Credentials"] === "true") {
-            merged["Access-Control-Allow-Origin"] = req.headers.origin || "null";
+            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).text();
+            res.status(204).end();
             return;
         }
         await next();
@@ -38,9 +45,18 @@ function SetRequestCORS(opts) {
 // 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 key = opts.keyGenerator?.(req) || req.socket.remoteAddress || "global";
-        const ip = req.headers["x-forwarded-for"] || req.socket.remoteAddress;
+        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) {
@@ -50,16 +66,10 @@ function SetRateLimiter(opts) {
         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;
         }
-        setInterval(() => {
-            const now = Date.now();
-            for (const [k, v] of store) {
-                if (now - v.ts > opts.windowMs * 2)
-                    store.delete(k);
-            }
-        }, opts.windowMs);
         await next();
     };
 }
@@ -157,8 +167,3 @@ function composeWithError(middlewares, errorMiddlewares) {
         await dispatch(0);
     };
 }
-function SecurityPlugin(app, opts) {
-    app.use(SetRequestCORS(opts.cors || []));
-    app.use(SetRateLimiter(opts.rateLimit || { windowMs: 1000, max: 100 }));
-    app.use(SetBodyParser(opts.body || { limit: "1mb" }));
-}

package/dist/utils/simpleController.d.ts

@@ -0,0 +1,18 @@
+import { RequestObject, ResponseObject } from "../typings/general";
+type HttpMethod = "get" | "post" | "put" | "patch" | "delete";
+type SubRequestHandler = Partial<Record<HttpMethod, (params: PrivateMethodProps) => any>>;
+interface PrivateMethodProps {
+    id?: string;
+    idMethod?: Partial<Record<HttpMethod, "required" | "optional">>;
+}
+export declare class SimpleNodeJsController {
+    protected req: RequestObject;
+    protected res: ResponseObject;
+    /** framework-internal method */
+    _bindContext(ctx: {
+        req: RequestObject;
+        res: ResponseObject;
+    }): void;
+    protected RunRequest(handlers: SubRequestHandler, params?: PrivateMethodProps): any;
+}
+export {};

package/dist/utils/simpleController.js

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

package/dist/utils/simplePlugins.d.ts

@@ -0,0 +1,9 @@
+import { SimpleJsServer } from "../typings/general";
+import { SimpleJSRateLimitType } from "../typings/simpletypes";
+export declare function SecurityPlugin(app: SimpleJsServer, opts: {
+    cors?: {
+        name: string;
+        value: string;
+    }[];
+    rateLimit?: SimpleJSRateLimitType;
+}): void;

package/dist/utils/simplePlugins.js

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

package/package.json

@@ -1,20 +1,32 @@
 {
   "name": "@increase21/simplenodejs",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Lightweight Node.js HTTP framework with middleware and plugins",
-  "main": "dist/index.js",
+  "dev": "dist/index.js",
+  "bugs": "https://github.com/increase21/simplenodejs/issues",
   "types": "dist/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/increase21/simplenodejs.git",
+    "directory": ""
+  },
   "files": [
     "dist/**/*"
   ],
   "scripts": {
     "build": "tsc",
-    "test": "node dist/test.js"
+    "test": "node dist/test.js",
+    "dev": "nodemon server.ts"
   },
-  "keywords": ["http", "framework", "node", "typescript"],
+  "keywords": [
+    "http",
+    "framework",
+    "node",
+    "typescript"
+  ],
   "author": "Increase Nkanta",
   "license": "MIT",
   "devDependencies": {
     "typescript": "^5.3.0"
   }
-}
+}

package/dist/typings/context.d.ts

@@ -1,18 +0,0 @@
-import { IncomingMessage, ServerResponse } from "http";
-export interface Context {
-    req: IncomingMessage;
-    res: ServerResponse;
-    body?: any;
-    params?: Record<string, string>;
-}
-export interface RequestObject extends IncomingMessage {
-    body?: any;
-    query?: any;
-    _server_environment?: 'dev' | 'stag' | 'live';
-    _body_size?: 0;
-}
-export interface ResponseObject extends ServerResponse {
-    status: (value: number) => ResponseObject;
-    json: (value: object) => void;
-    text: (value?: string) => void;
-}