@increase21/simplenodejs 1.0.0

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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.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";

package/dist/router.d.ts

@@ -0,0 +1,8 @@
+import { RequestObject, ResponseObject } from "./typings/context";
+export interface ControllerMeta {
+    name: string;
+    file: string;
+    Controller: any;
+}
+export declare function loadControllers(root?: string): Map<string, ControllerMeta>;
+export declare function route(req: RequestObject, res: ResponseObject, controllersDir?: string): Promise<void>;

package/dist/router.js

@@ -0,0 +1,58 @@
+"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.route = route;
+// router.ts
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+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 (Controller) {
+                    const key = full.replace(base, "").replace(/\\/g, "/").replace(/\.(ts|js)$/, "");
+                    map.set(key.toLowerCase(), { name: Controller.name, file: full, Controller });
+                }
+            }
+        }
+    }
+    walk(base);
+    return map;
+}
+const controllers = loadControllers();
+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");
+    const ControllerClass = meta.Controller;
+    const controller = new ControllerClass(req, res);
+    if (typeof controller[methodName] !== "function") {
+        return res.status(404).text("The requested resource does not exist");
+    }
+    const result = await controller[methodName](id);
+    if (!res.writableEnded && result !== undefined) {
+        res.setHeader("Content-Type", "application/json");
+        res.end(JSON.stringify(result));
+    }
+}

package/dist/server.d.ts

@@ -0,0 +1,4 @@
+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>;
+export declare const CreateSimpleJsHttpServer: (handler?: (req: IncomingMessage, res: ServerResponse) => void) => SimpleJsServer;

package/dist/server.js

@@ -0,0 +1,82 @@
+"use strict";
+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.compose = compose;
+const http_1 = __importDefault(require("http"));
+const router_1 = require("./router");
+const extension = (req, res) => {
+    //for response status
+    res.status = (code) => {
+        if (!/^\d+/.test(String(code)) || typeof code !== "number")
+            throw new Error("Status code expected to be number but got " + typeof code);
+        res.statusCode = code ? 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);
+    };
+};
+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);
+        try {
+            handler && await handler(req, res);
+            if (res.writableEnded)
+                return;
+            await run(req, res);
+            //if the request has ended stop here
+            if (res.writableEnded)
+                return;
+            await (0, router_1.route)(req, res);
+        }
+        catch (err) {
+            res.statusCode = 500;
+            res.end("Internal Server Error");
+        }
+    });
+    server.setTimeout(60000); //60Seconds
+    server.use = mw => { middlewares.push(mw); };
+    server.useError = mw => errorMiddlewares.push(mw);
+    server.register = async (plugin, opts) => {
+        plugins.push(plugin);
+        await plugin(server, opts);
+    };
+    return server;
+};
+exports.CreateSimpleJsHttpServer = CreateSimpleJsHttpServer;

package/dist/typings/context.d.ts

@@ -0,0 +1,18 @@
+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;
+}

package/dist/typings/context.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/typings/general.d.ts

@@ -0,0 +1,22 @@
+import http, { IncomingMessage, ServerResponse } from "http";
+export type Next = () => Promise<void> | void;
+export type Plugin = (app: SimpleJsServer, opts?: any) => Promise<void> | void;
+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>;
+}
+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;
+}
+export type AcceptHeaderValue = 'application/media' | 'application/text';

package/dist/typings/general.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/helpers.d.ts

@@ -0,0 +1,17 @@
+import { RequestObject, ResponseObject } from "../typings/context";
+import { ErrorMiddleware, Middleware, SimpleJsServer } from "../typings/general";
+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 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

@@ -0,0 +1,164 @@
+"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;
+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"
+        };
+        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") {
+            merged["Access-Control-Allow-Origin"] = req.headers.origin || "null";
+        }
+        for (const [key, value] of Object.entries(merged)) {
+            res.setHeader(key, value);
+        }
+        if (req.method === "OPTIONS") {
+            res.status(204).text();
+            return;
+        }
+        await next();
+    };
+}
+// core/rateLimit.ts
+function SetRateLimiter(opts) {
+    const store = new Map();
+    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 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.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();
+    };
+}
+// 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);
+                        //parse query
+                        if (req.query) {
+                            req.query = JSON.parse(JSON.stringify(node_querystring_1.default.parse(req.query)));
+                        }
+                    }
+                    else {
+                        req.body = body;
+                    }
+                    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) {
+    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) {
+                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);
+    };
+}
+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/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@increase21/simplenodejs",
+  "version": "1.0.0",
+  "description": "Lightweight Node.js HTTP framework with middleware and plugins",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist/**/*"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "node dist/test.js"
+  },
+  "keywords": ["http", "framework", "node", "typescript"],
+  "author": "Increase Nkanta",
+  "license": "MIT",
+  "devDependencies": {
+    "typescript": "^5.3.0"
+  }
+}