fullstx 1.0.0

package/lib/response.js

@@ -0,0 +1,175 @@
+const path = require('path');
+
+const RESPONSE_POOL = [];
+const POOL_SIZE = 1000;
+
+class FullstxResponse {
+    constructor() {
+        this.raw = null;
+        this.req = null;
+        this.route = null;
+    }
+
+    init(rawRes, req) {
+        this.raw = rawRes;
+        this.req = req;
+        this.route = null;
+    }
+
+    get statusCode() {
+        return this.raw.statusCode;
+    }
+    set statusCode(val) {
+        this.raw.statusCode = val;
+    }
+
+    get headersSent() {
+        return this.raw.headersSent;
+    }
+
+    setHeader(name, value) {
+        this.raw.setHeader(name, value);
+        return this;
+    }
+
+    getHeader(name) {
+        return this.raw.getHeader(name);
+    }
+
+    removeHeader(name) {
+        this.raw.removeHeader(name);
+        return this;
+    }
+
+    writeHead(statusCode, headers) {
+        this.raw.writeHead(statusCode, headers);
+        return this;
+    }
+
+    write(chunk, encoding, callback) {
+        return this.raw.write(chunk, encoding, callback);
+    }
+
+    end(data, encoding, callback) {
+        return this.raw.end(data, encoding, callback);
+    }
+
+    on(event, listener) {
+        this.raw.on(event, listener);
+        return this;
+    }
+
+    status(code) {
+        this.raw.statusCode = code;
+        return this;
+    }
+
+    json(data, statusCode = 200) {
+        this.raw.writeHead(statusCode, { 'Content-Type': 'application/json' });
+        if (this.route && this.route.serializer) {
+            this.raw.end(this.route.serializer(data));
+        } else {
+            this.raw.end(JSON.stringify(data));
+        }
+    }
+
+    html(htmlStr, statusCode = 200) {
+        this.raw.writeHead(statusCode, { 'Content-Type': 'text/html' });
+        this.raw.end(htmlStr);
+    }
+
+    render(viewPath, data = {}) {
+        const ejs = require('ejs');
+        const fullPath = path.isAbsolute(viewPath) ? viewPath : path.join(process.cwd(), 'views', viewPath);
+        ejs.renderFile(fullPath, data, (err, str) => {
+            if (err) {
+                this.raw.writeHead(500, { 'Content-Type': 'text/plain' });
+                this.raw.end('Template rendering error: ' + err.message);
+            } else {
+                this.html(str);
+            }
+        });
+    }
+
+    sse(data, event = 'message') {
+        if (!this.raw.headersSent) {
+            this.raw.writeHead(200, {
+                'Content-Type': 'text/event-stream',
+                'Cache-Control': 'no-cache',
+                Connection: 'keep-alive'
+            });
+        }
+        this.raw.write(`event: ${event}\n`);
+        this.raw.write(`data: ${typeof data === 'object' ? JSON.stringify(data) : data}\n\n`);
+    }
+
+    redirect(url, statusCode = 302) {
+        this.raw.writeHead(statusCode, { Location: url });
+        this.raw.end();
+    }
+
+    header(key, value) {
+        this.raw.setHeader(key, value);
+        return this;
+    }
+
+    cookie(name, value, options = {}) {
+        let cookieString = `${name}=${encodeURIComponent(value)}`;
+        if (options.maxAge) cookieString += `; Max-Age=${options.maxAge}`;
+        if (options.domain) cookieString += `; Domain=${options.domain}`;
+        if (options.path) cookieString += `; Path=${options.path}`;
+        if (options.expires) cookieString += `; Expires=${options.expires.toUTCString()}`;
+        if (options.httpOnly) cookieString += `; HttpOnly`;
+        if (options.secure) cookieString += `; Secure`;
+        if (options.sameSite) cookieString += `; SameSite=${options.sameSite}`;
+
+        let existing = this.raw.getHeader('Set-Cookie');
+        if (!existing) {
+            existing = [];
+        } else if (!Array.isArray(existing)) {
+            existing = [existing];
+        }
+        existing.push(cookieString);
+        this.raw.setHeader('Set-Cookie', existing);
+        return this;
+    }
+
+    send(body) {
+        if (typeof body === 'object' && body !== null && !Buffer.isBuffer(body)) {
+            return this.json(body);
+        }
+        if (typeof body === 'string') {
+            if (!this.raw.getHeader('Content-Type')) {
+                this.raw.setHeader('Content-Type', 'text/html');
+            }
+        }
+        this.raw.end(body);
+    }
+}
+
+function getResponse(rawRes, req) {
+    if (RESPONSE_POOL.length > 0) {
+        const res = RESPONSE_POOL.pop();
+        res.init(rawRes, req);
+        return res;
+    }
+    const res = new FullstxResponse();
+    res.init(rawRes, req);
+    return res;
+}
+
+function releaseResponse(res) {
+    res.raw = null;
+    res.req = null;
+    res.route = null;
+
+    if (RESPONSE_POOL.length < POOL_SIZE) {
+        RESPONSE_POOL.push(res);
+    }
+}
+
+module.exports = {
+    FullstxResponse,
+    getResponse,
+    releaseResponse
+};

package/lib/websocket.js

@@ -0,0 +1,27 @@
+module.exports = function setupWebsocket(opts) {
+    let wsRedisPub = null;
+    let wsRedisSub = null;
+
+    if (opts.ws && opts.ws.redisUrl) {
+        try {
+            const { createClient } = require('redis');
+            wsRedisPub = createClient({ url: opts.ws.redisUrl });
+            wsRedisSub = createClient({ url: opts.ws.redisUrl });
+
+            wsRedisPub.on('error', (e) => console.error('[fullstx] WS Redis Pub Error:', e));
+            wsRedisSub.on('error', (e) => console.error('[fullstx] WS Redis Sub Error:', e));
+
+            wsRedisPub.connect().catch(() => {});
+            wsRedisSub
+                .connect()
+                .then(() => {
+                    console.log('[fullstx] WebSocket Redis Pub/Sub Adapter enabled.');
+                })
+                .catch(() => {});
+        } catch {
+            console.error('[fullstx] Failed to load redis for WS Pub/Sub');
+        }
+    }
+
+    return { wsRedisPub, wsRedisSub };
+};

package/package.json

@@ -0,0 +1,61 @@
+{
+    "name": "fullstx",
+    "version": "1.0.0",
+    "description": "A high-performance, custom backend framework with built-in hot-reload.",
+    "author": "fullstx developer",
+    "main": "./dist/index.js",
+    "module": "./dist/index.mjs",
+    "types": "./index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./index.d.ts",
+            "require": "./dist/index.js",
+            "import": "./dist/index.mjs"
+        }
+    },
+    "license": "MIT",
+    "bin": {
+        "create-fullstx": "./bin/create.js",
+        "fullstx-generate": "./bin/generate.js"
+    },
+    "scripts": {
+        "build": "tsup",
+        "test": "jest",
+        "test:watch": "jest --watch"
+    },
+    "devDependencies": {
+        "@eslint/js": "^10.0.1",
+        "autocannon": "^8.0.0",
+        "eslint": "^10.6.0",
+        "eslint-config-prettier": "^10.1.8",
+        "eslint-plugin-no-comments": "^1.2.1",
+        "eslint-plugin-prettier": "^5.5.6",
+        "globals": "^17.7.0",
+        "jest": "^29.7.0",
+        "prettier": "^3.9.3",
+        "semantic-release": "^25.0.5",
+        "supertest": "^7.2.2",
+        "tsup": "^8.5.1",
+        "typescript": "^6.0.3"
+    },
+    "dependencies": {
+        "@faker-js/faker": "^10.5.0",
+        "@sentry/node": "^10.62.0",
+        "browser-sync": "^3.0.4",
+        "bullmq": "^5.79.2",
+        "compression": "^1.8.1",
+        "dotenv": "^17.4.2",
+        "ejs": "^6.0.1",
+        "fast-json-stringify": "^7.0.0",
+        "jsonwebtoken": "^9.0.3",
+        "knex": "^3.3.0",
+        "multer": "^2.2.0",
+        "nodemailer": "^9.0.1",
+        "redis": "^6.0.1",
+        "sanitize-html": "^2.17.5",
+        "sqlite3": "^6.0.1",
+        "swagger-ui-dist": "^5.32.8",
+        "ws": "^8.21.0",
+        "zod": "^4.4.3"
+    }
+}

package/router.js

@@ -0,0 +1,47 @@
+const RadixRouter = require('./lib/radix-router');
+
+const radix = new RadixRouter();
+const middlewares = [];
+
+function insertRoute(method, path, options, handler) {
+    if (typeof options === 'function') {
+        handler = options;
+        options = {};
+    }
+    radix.insert(method, path, { handler, ...options });
+}
+
+function get(path, options, handler) {
+    insertRoute('GET', path, options, handler);
+}
+function post(path, options, handler) {
+    insertRoute('POST', path, options, handler);
+}
+function put(path, options, handler) {
+    insertRoute('PUT', path, options, handler);
+}
+function patch(path, options, handler) {
+    insertRoute('PATCH', path, options, handler);
+}
+function del(path, options, handler) {
+    insertRoute('DELETE', path, options, handler);
+}
+function use(fn) {
+    middlewares.push(fn);
+}
+
+function lookup(method, path) {
+    return radix.lookup(method, path);
+}
+
+module.exports = {
+    middlewares,
+    get,
+    post,
+    put,
+    patch,
+    del,
+    delete: del,
+    use,
+    lookup
+};

package/server.js

@@ -0,0 +1,193 @@
+const http = require('http');
+const fs = require('fs');
+const path = require('path');
+const { getRequest, releaseRequest } = require('./lib/request');
+const { getResponse, releaseResponse } = require('./lib/response');
+
+const MIME_TYPES = {
+    '.html': 'text/html',
+    '.css': 'text/css',
+    '.js': 'application/javascript',
+    '.json': 'application/json',
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.svg': 'image/svg+xml',
+    '.ico': 'image/x-icon'
+};
+
+function sanitizePayload(obj) {
+    if (obj === null || typeof obj !== 'object') return obj;
+    if (Array.isArray(obj)) return obj.map(sanitizePayload);
+    const proto = Object.getPrototypeOf(obj);
+    if (proto !== null && proto !== Object.prototype) return obj;
+    const sanitized = {};
+    for (const key in obj) {
+        if (key === '__proto__' || key === 'constructor') continue;
+        sanitized[key] = sanitizePayload(obj[key]);
+    }
+    return sanitized;
+}
+
+class RequestContext {
+    constructor() {
+        this.req = null;
+        this.res = null;
+        this.middlewares = null;
+        this.router = null;
+        this.staticDir = null;
+        this.i = 0;
+        this.next = this.next.bind(this);
+    }
+
+    init(req, res, middlewares, router, staticDir) {
+        this.req = req;
+        this.res = res;
+        this.middlewares = middlewares;
+        this.router = router;
+        this.staticDir = staticDir;
+        this.i = 0;
+    }
+
+    parseBody(callback) {
+        if (this.req.method === 'GET' || this.req.method === 'HEAD') {
+            this.req.body = {};
+            return callback();
+        }
+        let raw = '';
+        this.req.on('data', (chunk) => {
+            raw += chunk;
+        });
+        this.req.on('end', () => {
+            try {
+                const ct = (this.req.headers['content-type'] || '').split(';')[0].trim();
+                if (ct === 'application/x-www-form-urlencoded') {
+                    const params = new URLSearchParams(raw);
+                    const obj = {};
+                    for (const [k, v] of params.entries()) obj[k] = v;
+                    this.req.body = sanitizePayload(obj);
+                } else {
+                    this.req.body = raw ? sanitizePayload(JSON.parse(raw)) : {};
+                }
+            } catch {
+                this.req.body = raw || {};
+            }
+            callback();
+        });
+    }
+
+    serveStatic(callback) {
+        if (!this.staticDir) return callback();
+
+        let filePath = this.req.url === '/' ? '/index.html' : this.req.url;
+        filePath = path.join(this.staticDir, filePath);
+
+        if (!filePath.startsWith(this.staticDir)) {
+            return callback();
+        }
+
+        fs.readFile(filePath, (err, content) => {
+            if (err) return callback();
+            const ext = path.extname(filePath);
+            const contentType = MIME_TYPES[ext] || 'text/plain';
+            this.res.writeHead(200, { 'Content-Type': contentType });
+            this.res.end(content);
+        });
+    }
+
+    handleError(err) {
+        if (global.sentryCapture) global.sentryCapture(err);
+        console.error('[fullstx] Error:', err);
+        if (!this.res.headersSent) {
+            this.res.writeHead(500, { 'Content-Type': 'application/json' });
+            this.res.end(JSON.stringify({ error: 'Internal Server Error' }));
+        }
+    }
+
+    next(err) {
+        if (err) {
+            return this.handleError(err);
+        }
+
+        if (this.i < this.middlewares.length) {
+            try {
+                const mw = this.middlewares[this.i++];
+                const result = mw(this.req, this.res, this.next);
+                if (result instanceof Promise) {
+                    result.catch((e) => this.next(e));
+                }
+            } catch (e) {
+                this.next(e);
+            }
+        } else {
+            const route = this.router.lookup(this.req.method, this.req.pathname);
+            if (route && route.handler) {
+                this.res.route = route.routeConfig;
+                this.req.params = Object.assign(this.req.params || {}, route.params);
+                try {
+                    const result = route.handler(this.req, this.res);
+                    if (result instanceof Promise) {
+                        result.catch((e) => this.handleError(e));
+                    }
+                } catch (e) {
+                    this.handleError(e);
+                }
+            } else {
+                this.serveStatic(() => {
+                    if (!this.res.headersSent) {
+                        this.res.writeHead(404);
+                        this.res.end('404 Not Found');
+                    }
+                });
+            }
+        }
+    }
+}
+
+const CONTEXT_POOL = [];
+function getContext(req, res, middlewares, router, staticDir) {
+    if (CONTEXT_POOL.length > 0) {
+        const ctx = CONTEXT_POOL.pop();
+        ctx.init(req, res, middlewares, router, staticDir);
+        return ctx;
+    }
+    const ctx = new RequestContext();
+    ctx.init(req, res, middlewares, router, staticDir);
+    return ctx;
+}
+function releaseContext(ctx) {
+    ctx.req = null;
+    ctx.res = null;
+    ctx.middlewares = null;
+    ctx.router = null;
+    if (CONTEXT_POOL.length < 1000) CONTEXT_POOL.push(ctx);
+}
+
+function createServer(router, middlewares, options = {}) {
+    const staticDir = options.staticDir ? path.resolve(options.staticDir) : null;
+
+    const server = http.createServer((rawReq, rawRes) => {
+        const reqWrapper = getRequest(rawReq);
+        const resWrapper = getResponse(rawRes, reqWrapper);
+        const ctx = getContext(reqWrapper, resWrapper, middlewares, router, staticDir);
+
+        let released = false;
+        const releaseAll = () => {
+            if (released) return;
+            released = true;
+            setImmediate(() => {
+                releaseRequest(reqWrapper);
+                releaseResponse(resWrapper);
+                releaseContext(ctx);
+            });
+        };
+
+        rawRes.on('finish', releaseAll);
+        rawRes.on('close', releaseAll);
+
+        ctx.parseBody(ctx.next);
+    });
+
+    return server;
+}
+
+module.exports = createServer;

package/session.js

@@ -0,0 +1,109 @@
+const crypto = require('crypto');
+
+class MemoryStore {
+    constructor() {
+        this.sessions = new Map();
+    }
+    async get(sid) {
+        return this.sessions.get(sid);
+    }
+    async set(sid, data, ttl) {
+        this.sessions.set(sid, data);
+
+        setTimeout(() => this.sessions.delete(sid), ttl * 1000).unref();
+    }
+    async destroy(sid) {
+        this.sessions.delete(sid);
+    }
+}
+
+class RedisStore {
+    constructor(redisClient) {
+        this.client = redisClient;
+    }
+    async get(sid) {
+        const data = await this.client.get(`session:${sid}`);
+        return data ? JSON.parse(data) : null;
+    }
+    async set(sid, data, ttl) {
+        await this.client.set(`session:${sid}`, JSON.stringify(data), {
+            EX: ttl
+        });
+    }
+    async destroy(sid) {
+        await this.client.del(`session:${sid}`);
+    }
+}
+
+function generateSessionId() {
+    return crypto.randomBytes(32).toString('hex');
+}
+
+module.exports = function createSessionMiddleware(opts) {
+    if (!opts || !opts.session) return null;
+
+    const sessionOpts = Object.assign(
+        {
+            secret: 'fullstx-default-secret',
+            store: 'memory',
+            redisUrl: 'redis://localhost:6379',
+            cookieName: 'fullstx_sid',
+            ttl: 86400
+        },
+        opts.session
+    );
+
+    let store;
+    if (sessionOpts.store === 'redis') {
+        try {
+            const { createClient } = require('redis');
+            const client = createClient({ url: sessionOpts.redisUrl });
+            client.on('error', (err) => console.error('[fullstx] Session Redis Error:', err));
+            client.connect().catch((e) => console.error('[fullstx] Session Redis Connect Error:', e));
+            store = new RedisStore(client);
+            console.log('[fullstx] Session Store: Redis');
+        } catch {
+            console.warn('[fullstx] Failed to load redis for session, falling back to memory store.');
+            store = new MemoryStore();
+        }
+    } else {
+        store = new MemoryStore();
+    }
+
+    return async function sessionMiddleware(req, res, next) {
+        const sid = req.cookies && req.cookies[sessionOpts.cookieName];
+        let sessionData = null;
+
+        if (sid) {
+            sessionData = await store.get(sid);
+        }
+
+        const currentSid = sid || generateSessionId();
+
+        if (!sessionData) {
+            sessionData = {};
+        }
+
+        req.session = sessionData;
+        req.sessionID = currentSid;
+
+        if (!sid && res.cookie) {
+            res.cookie(sessionOpts.cookieName, currentSid, {
+                maxAge: sessionOpts.ttl,
+                httpOnly: true,
+                path: '/'
+            });
+        }
+
+        const originalEnd = res.end;
+        res.end = function (chunk, encoding, callback) {
+            store.set(currentSid, req.session, sessionOpts.ttl).catch((err) => {
+                console.error('[fullstx] Session Save Error:', err);
+            });
+
+            originalEnd.call(res, chunk, encoding, callback);
+        };
+
+        next();
+    };
+};