@increase21/simplenodejs 1.0.1 → 1.0.3

package/dist/index.d.ts

@@ -0,0 +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

@@ -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);
+__exportStar(require("./utils/simpleController"), exports);
+__exportStar(require("./utils/simplePlugins"), exports);

package/dist/router.d.ts

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

package/dist/router.js

@@ -0,0 +1,80 @@
+"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"));
+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;
+}
+function setControllersDir(dir) {
+    controllers = loadControllers(dir);
+}
+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("/");
+    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();
+    //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);
+        }
+        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" });
+    }
+    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

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

package/dist/server.js

@@ -0,0 +1,72 @@
+"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;
+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) => {
+        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);
+    };
+    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) => {
+        extension(req, res);
+        const run = (0, helpers_1.composeWithError)(middlewares, errorMiddlewares);
+        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) {
+            // 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.use = mw => { middlewares.push(mw); };
+    server.useError = mw => errorMiddlewares.push(mw);
+    server.registerPlugin = async (plugin) => {
+        plugins.push(plugin);
+        await plugin(server);
+    };
+    return server;
+};
+exports.CreateSimpleJsHttpServer = CreateSimpleJsHttpServer;

package/dist/typings/general.d.ts

@@ -0,0 +1,48 @@
+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;
+    registerPlugin: (plugin: Plugin) => Promise<void>;
+    _environment: 'dev' | 'stag' | 'live';
+}
+export interface RequestObject extends IncomingMessage {
+    body?: any;
+    query?: any;
+    id?: string;
+    _server_environment?: 'dev' | 'stag' | 'live';
+    _custom_data?: ObjectPayload;
+}
+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/general.js

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

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/typings/simpletypes.js

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

package/dist/utils/helpers.d.ts

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

package/dist/utils/helpers.js

@@ -0,0 +1,169 @@
+"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);
+                        //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);
+    };
+}

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 SimpleJsSecurityPlugin(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.SimpleJsSecurityPlugin = SimpleJsSecurityPlugin;
+const helpers_1 = require("./helpers");
+function SimpleJsSecurityPlugin(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,11 +1,25 @@
 {
   "name": "@increase21/simplenodejs",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "Lightweight Node.js HTTP framework with middleware and plugins",
   "dev": "dist/index.js",
+  "bugs": "https://github.com/increase21/simplenodejs/issues",
+  "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "require": "./dist/index.js",
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/increase21/simplenodejs.git",
+    "directory": ""
+  },
   "files": [
-    "dist/**/*"
+    "dist"
   ],
   "scripts": {
     "build": "tsc",