@jnode/server 1.0.6 → 2.0.0

package/src/server.js

@@ -1,55 +1,216 @@
 /*
-JustServer/server.js
+@jnode/server/server.js
+v2
 
 Simple web server package for Node.js.
 
-by JustNode Dev Team / JustApple
+by JustApple
 */
 
-//load node packages
+// dependencies
 const http = require('http');
 const https = require('https');
-const { domainToUnicode } = require('url');
+const http2 = require('http2');
+const path = require('path');
+const stream = require('stream');
 const EventEmitter = require('events');
 
-//load classes and functions
-const processMap = require('./map.js');
-
-//http server
+// server class
 class Server extends EventEmitter {
-	constructor(map = {}, useHttps = false, options) {
-		super();
-		
-		this.map = map; //server map
-		this.server = (useHttps ? https : http).createServer(options); //create server
-		
-		//on normal request
-		this.server.on('request', (req, res) => {
-			//emit event
-			this.emit('request', req, res);
-			
-			//parse url
-			const url = new URL(req.url, 'http://localhost');
-			
-			//create path
-			let p = url.pathname.split('/').map((e) => decodeURIComponent(e));
-			p[0] = req.headers.host; //set root path to host
-			
-			//process map
-			processMap(req, res, this.map, p, {
-				url: url,
-				default: {},
-				time: Date.now(),
-				emitError: (...err) => { this.emit('error', ...err); }
-			});
-		});
-	}
-	
-	//listen a port to receive requests
-	listen(port, cb) {
-		return this.server.listen(port, cb);
-	}
+    constructor(router, options = {}) {
+        super();
+
+        this.router = router;
+        this.options = options;
+
+        // start a server
+        this.server = options.enableHTTP2 ?
+            ((options.key && options.cert) ?
+                http2.createSecureServer(options) :
+                http2.createServer(options)) :
+            ((options.key && options.cert) ?
+                https.createServer(options) :
+                http.createServer(options));
+
+        // request listener
+        // HTTP/2 also use the same event with the node:http2 Compatibility API
+        this.server.on('request', async (req, res) => {
+            let url;
+
+            try {
+                url = new URL(req.url, `http${options.key && options.cert ? 's' : ''}://${req.headers.host || req.headers[':authority']}`);
+            } catch (e) {
+                this.emit('warn', e);
+                res.writeHead(400, { 'Content-Type': 'text/plain; charset=utf-8' });
+                res.end('400 Bad Request', 'utf8');
+                return;
+            }
+
+            // the context object, mainly for handlers
+            const ctx = {
+                req, res, url,
+                server: this,
+                path: url.pathname,
+                host: url.hostname,
+                method: req.method,
+                headers: req.headers,
+                identity: { address: req.socket.remoteAddress, port: req.socket.remotePort },
+                params: Object.fromEntries(url.searchParams.entries()),
+                body: req
+            };
+
+            // the environment object, mainly for routers
+            const env = {
+                path: url.pathname.split('/').slice(1).map((i) => { try { return decodeURIComponent(i); } catch { return i; } }),
+                pathPointer: 0,
+                host: url.hostname.split('.').filter(Boolean).reverse(),
+                hostPointer: 0,
+                codeHandlers: this.options.codeHandlers || {},
+                i: 0
+            };
+
+            let handler;
+            try {
+                handler = await Server.route(this.router, env, ctx, this.options);
+                if (handler === undefined || handler === null) handler = 404;
+            } catch (e) { // error while routing
+                this.emit('e', e, env, ctx);
+                handler = 500;
+            }
+
+            await Server.handle(handler, env, ctx, this.options);
+        });
+    }
+
+    // route
+    static async route(router, env = {}, ctx = {}, options = {}) {
+        let r = router;
+        if (!env.i) env.i = 0;
+
+        while (typeof r?.route === 'function') {
+            env.i++;
+
+            if (env.i > (options.maxRoutingSteps || 50)) return 508; // 508 Loop Detected
+
+            r = await r.route(env, ctx);
+        }
+
+        return r;
+    }
+
+    // handle
+    static async handle(handler, env = {}, ctx = {}, options = {}) {
+        try {
+            if (typeof handler?.handle === 'function') { // handler
+                await handler.handle(ctx, env);
+            } else if (typeof handler === 'function') { // function
+                await handler(ctx, env);
+            } else if (typeof handler === 'string') { // string
+                ctx.res.writeHead(200, {
+                    'Content-Type': 'text/plain; charset=utf-8',
+                    'Content-Length': Buffer.byteLength(handler, 'utf8')
+                });
+                ctx.res.end(handler, 'utf8');
+            } else if (handler instanceof Uint8Array) { // buffer
+                ctx.res.writeHead(200, {
+                    'Content-Type': 'application/octet-stream',
+                    'Content-Length': handler.length
+                });
+                ctx.res.end(handler);
+            } else if (stream.isReadable(handler)) { // stream
+                ctx.res.writeHead(200, { 'Content-Type': 'application/octet-stream' });
+                await stream.promises.pipeline(handler, ctx.res);
+            } else if (typeof handler === 'number') { // status code
+                const code = handler;
+                handler = env.codeHandlers[code];
+
+                // handlers without code handlers
+                if (typeof handler?.handle === 'function') { // handler
+                    await handler.handle(ctx, env);
+                } else if (typeof handler === 'function') { // function
+                    await handler(ctx, env);
+                } else if (typeof handler === 'string') { // string
+                    ctx.res.writeHead(code, {
+                        'Content-Type': 'text/plain; charset=utf-8',
+                        'Content-Length': Buffer.byteLength(handler, 'utf8')
+                    });
+                    ctx.res.end(handler, 'utf8');
+                } else if (handler instanceof Uint8Array) { // buffer
+                    ctx.res.writeHead(code, {
+                        'Content-Type': 'application/octet-stream',
+                        'Content-Length': handler.length
+                    });
+                    ctx.res.end(handler);
+                } else if (stream.isReadable(handler)) { // stream
+                    ctx.res.writeHead(code, { 'Content-Type': 'application/octet-stream' });
+                    await stream.promises.pipeline(handler, ctx.res);
+                } else { // use default status code response
+                    try { ctx.res.writeHead(code, { 'Content-Type': 'text/plain; charset=utf-8' }); } catch { }
+                    try { ctx.res.end(`${code} ${http.STATUS_CODES[code] || 'Unknown'}`, 'utf8'); } catch { }
+                }
+            } else { // invalid handler
+                throw new Error('JNS: Invalid handler returned from router.');
+            }
+        } catch (e) { // error while handling
+            if (typeof e !== 'number') ctx.server.emit('e', e, env, ctx);
+
+            try {
+                const code = (typeof e === 'number') ? e : 500;
+                handler = env.codeHandlers[code];
+
+                // handlers without code handlers
+                if (typeof handler?.handle === 'function') { // handler
+                    await handler.handle(ctx, env);
+                } else if (typeof handler === 'function') { // function
+                    await handler(ctx, env);
+                } else if (typeof handler === 'string') { // string
+                    ctx.res.writeHead(code, {
+                        'Content-Type': 'text/plain; charset=utf-8',
+                        'Content-Length': Buffer.byteLength(handler, 'utf8')
+                    });
+                    ctx.res.end(handler, 'utf8');
+                } else if (handler instanceof Uint8Array) { // buffer
+                    ctx.res.writeHead(code, {
+                        'Content-Type': 'application/octet-stream',
+                        'Content-Length': handler.length
+                    });
+                    ctx.res.end(handler);
+                } else if (stream.isReadable(handler)) { // stream
+                    ctx.res.writeHead(code, { 'Content-Type': 'application/octet-stream' });
+                    await stream.promises.pipeline(handler, ctx.res);
+                } else { // use default status code response
+                    ctx.res.writeHead(code, { 'Content-Type': 'text/plain; charset=utf-8' });
+                    ctx.res.end(`${code} ${http.STATUS_CODES[code] || 'Unknown'}`, 'utf8');
+                }
+            } catch (e) { // error while handling the error while handling :)
+                ctx.server.emit('warn', e, env, ctx);
+                try { ctx.res.writeHead(500, { 'Content-Type': 'text/plain; charset=utf-8' }); } catch { }
+                try { ctx.res.end('500 Internal Server Error', 'utf8'); } catch { }
+            }
+        }
+    }
+
+    listen(...args) {
+        this.server.listen(...args);
+    }
+
+    close(...args) {
+        this.server.close(...args);
+    }
+
+    // throw an error event
+    throw(...args) {
+        this.emit('e', ...args);
+    }
+}
+
+// create server
+function createServer(router, options = {}) {
+    return new Server(router, options);
 }
 
-//export
-module.exports = Server;
+// export
+module.exports = {
+    Server,
+    createServer
+};

package/src/error.js

@@ -1,32 +0,0 @@
-/*
-JustServer/error.js
-
-Simple web server package for Node.js.
-
-by JustNode Dev Team / JustApple
-*/
-
-//load classes and functions
-const processFinal = require('./final.js');
-
-//process HandleObject error
-async function processError(req, res, map, p, e) {
-	try {
-		//500 error
-		return await processFinal(req, res, map['!500'] ?? e.default['!500'] ?? { //default error response
-			'+STATUS': 500,
-			'TEXT': '500 Internal server error.'
-		}, p, e);
-	} catch (err) {
-		//last error response
-		try { res.writeHead(500, { 'Content-Type': 'text/plain' }); } catch { }
-		try { res.end('500 Internal server error.'); } catch { }
-		
-		//emit error
-		e.emitError(err);
-		return;
-	}
-}
-
-//export
-module.exports = processError;

package/src/final.js

@@ -1,129 +0,0 @@
-/*
-JustServer/final.js
-
-Simple web server package for Node.js.
-
-by JustNode Dev Team / JustApple
-*/
-
-//load node packages
-const path = require('path');
-const fs = require('fs');
-const fsPromises = fs.promises;
-
-//load mime types
-const mimeTypes = require('./mime.json');
-
-//process FinalObject
-async function processFinal(req, res, map, p, e) {
-	//firewall
-	if (
-		(map['+FIREWALL'] ?? e.default['+FIREWALL']) &&
-		!(await (map['+FIREWALL'] ?? e.default['+FIREWALL'])(req, res, map, p, e))
-	) return;
-	
-	//custom function
-	if (map['FUNCTION']) return map['FUNCTION'](req, res, map, p, e);
-	
-	//text response (include empty text)
-	if (map['TEXT'] !== undefined) {
-		res.writeHead(map['+STATUS'] ?? 200, {
-			'Content-Type': 'text/plain; charset=UTF-8',
-			'Content-Length': Buffer.byteLength(map['TEXT']),
-			...map['+HEADERS']
-		});
-		res.end(map['TEXT'], 'utf8');
-		return;
-	}
-	
-	//buffer (binary) response
-	if (map['BUFFER']) {
-		res.writeHead(map['+STATUS'] ?? 200, {
-			'Content-Type': 'application/octet-stream',
-			'Content-Length': map['BUFFER'].length,
-			...map['+HEADERS']
-		});
-		res.end(map['BUFFER']);
-		return;
-	}
-	
-	//file response
-	if (map['FILE']) {
-		let fileSize;
-		
-		//get file size and check file exists
-		try {
-			fileSize = (await fsPromises.stat(map['FILE'])).size;
-		} catch (err) { return '!404'; } //return error
-		
-		//write head
-		res.writeHead(map['+STATUS'] ?? 200, {
-			'Content-Type': mimeTypes[path.extname(map['FILE'])] ?? 'application/octet-stream',
-			'Content-Length': fileSize,
-			...map['+HEADERS']
-		});
-		
-		//stream response
-		const readStream = fs.createReadStream(map['FILE']);
-		readStream.pipe(res);
-		
-		//wait for stream
-		return await new Promise((resolve, reject) => {
-			readStream.on('error', reject);
-			readStream.on('end', resolve);
-		});
-	}
-	
-	//folder
-	if (map['FOLDER']) {
-		//get file path
-		const file = path.resolve(map['FOLDER'], p.map((e) => encodeURIComponent(e)).join('/'));
-		
-		//check file path
-		if (path.relative(path.resolve(map['FOLDER']), file).startsWith('..')) return '!403';
-		
-		//check hidden file
-		if (
-			path.basename(file).startsWith('.') &&
-			!(map['__ALLOW_HIDDEN_FILE'] || e.default['__ALLOW_HIDDEN_FILE'])
-		) return '!404';
-		
-		let fileSize;
-		
-		//get file size and check file exists
-		try {
-			const stat = await fsPromises.stat(file);
-			if (stat.isDirectory()) return '!404'; //return error for directory
-			fileSize = stat.size;
-		} catch (err) { return '!404'; } //return error
-		
-		//write head
-		res.writeHead(map['+STATUS'] ?? 200, {
-			'Content-Type': mimeTypes[path.extname(file)] ?? 'application/octet-stream',
-			'Content-Length': fileSize,
-			...map['+HEADERS']
-		});
-		
-		//stream response
-		const readStream = fs.createReadStream(file);
-		readStream.pipe(res);
-				
-		//wait for stream
-		return await new Promise((resolve, reject) => {
-			readStream.on('error', reject);
-			readStream.on('end', resolve);
-		});
-	}
-	
-	//only headers or status code
-	if (map['+STATUS'] || map['+HEADERS']) {
-		res.writeHead(map['+STATUS'] ?? 200, map['+HEADERS']);
-		res.end();
-		return;
-	}
-	
-	return '!404';
-}
-
-//export
-module.exports = processFinal;

package/src/handle.js

@@ -1,88 +0,0 @@
-/*
-JustServer/handle.js
-
-Simple web server package for Node.js.
-
-by JustNode Dev Team / JustApple
-*/
-
-//load classes and functions
-const processFinal = require('./final.js');
-const processError = require('./error.js');
-
-//error handler function
-async function handleStatus(req, res, map, p, e, status) {
-	let statusCode;
-	let defaultMap;
-	
-	switch (status) {
-		case '!404':
-			statusCode = 404;
-			defaultMap = e.default['!404'] ?? {
-				'+STATUS': 404,
-				'TEXT': '404 Page not found.'
-			};
-				break;
-		case '!403':
-			statusCode = 403;
-			defaultMap = e.default['!403'] ?? {
-				'+STATUS': 403,
-				'TEXT': '403 Forbidden.'
-			};
-				break;
-		default:
-			return status; //if status is not a special error, return it directly
-	}
-	
-	return await processFinal(req, res, map[status] ?? defaultMap, p, e);
-}
-
-//process function with error handling
-async function safeProcessFinal(req, res, map, p, e, finalObject) {
-	try {
-		let status = await processFinal(req, res, finalObject, p, e);
-		
-		//handle special status codes
-		status = await handleStatus(req, res, map, p, e, status);
-		
-		//fall into loop error
-		if ((typeof status === 'string') && status.startsWith('!')) {
-			throw new Error('Process may fall into infinity loop.');
-		}
-		return status;
-	} catch (err) {
-		//emit error
-		e.emitError(err);
-		
-		//internal server error
-		return processError(req, res, map, p, e);
-	}
-}
-
-//process HandleObject
-async function processHandle(req, res, map, p, e) {
-	//protocol upgrade
-	if (
-		req.headers.connection &&
-		req.headers.connection.toLowerCase() === 'upgrade' &&
-		map['^' + req.headers.upgrade]
-	) {
-		return await safeProcessFinal(req, res, map, p, e, map['^' + req.headers.upgrade]);
-	}
-	
-	//method check
-	if (map['@' + req.method]) {
-		return await safeProcessFinal(req, res, map, p, e, map['@' + req.method]);
-	}
-	
-	//get final object by function
-	if (map['>']) {
-		return await safeProcessFinal(req, res, map, p, e, await map['>'](req, res, map, p, e));
-	}
-	
-	//process final
-	return await safeProcessFinal(req, res, map, p, e, map);
-}
-
-//export
-module.exports = processHandle;

package/src/map.js

@@ -1,50 +0,0 @@
-/*
-JustServer/map.js
-
-Simple web server package for Node.js.
-
-by JustNode Dev Team / JustApple
-*/
-
-//load classes and functions
-const processHandle = require('./handle.js');
-const processFinal = require('./final.js');
-const processError = require('./error.js');
-
-//process MapObject
-async function processMap(req, res, map, p, e) {
-	//overwrite default handle object
-	Object.assign(e.default, map['#']);
-	
-	//path ends, process HandleObject
-	if (p.length === 0) return await processHandle(req, res, map, p, e);
-	
-	//specific path
-	if (map['/' + p[0]]) return await processMap(req, res, map['/' + p.shift()], p, e);
-	
-	//any path
-	if (map['*']) {
-		p.shift(); //remove first one
-		return await processMap(req, res, map['*'], p, e);
-	}
-	
-	//any path following
-	if (map['**']) return await processHandle(req, res, map['**'], p, e);
-	
-	//page not found
-	try {
-		return await processFinal(req, res, map['!404'] ?? e.default['!404'] ?? { //default error response
-			'+STATUS': 404,
-			'TEXT': '404 Page not found.'
-		}, p, e);
-	} catch (err) {
-		//emit error
-		e.emitError(err);
-		
-		//internal server error
-		return processError(req, res, map, p, e);
-	}
-}
-
-//export
-module.exports = processMap;