@jnode/server 1.0.6 → 2.0.0

package/src/handlers.js

@@ -0,0 +1,246 @@
+/*
+@jnode/server/handlers.js
+v2
+
+Simple web server package for Node.js.
+
+by JustApple
+*/
+
+// dependencies
+const stream = require('stream');
+const fs = require('fs');
+const mime = require('./mime.json');
+const path = require('path');
+
+// data handler: string, buffer, or stream
+class DataHandler {
+    constructor(data, options = {}) {
+        this.data = data;
+        this.options = options;
+    }
+
+    async handle(ctx, env) {
+        if (typeof this.data === 'string') { // string
+            ctx.res.writeHead(this.options.statusCode ?? 200, {
+                'Content-Type': 'text/plain; charset=utf-8',
+                'Content-Length': Buffer.byteLength(this.data, 'utf8'),
+                ...this.options.headers
+            });
+            ctx.res.end(this.data, 'utf8');
+        } else if (this.data instanceof Uint8Array) { // buffer
+            ctx.res.writeHead(this.options.statusCode ?? 200, {
+                'Content-Type': 'application/octet-stream',
+                'Content-Length': this.data.length,
+                ...this.options.headers
+            });
+            ctx.res.end(this.data);
+        } else if (stream.isReadable(this.data)) { // stream
+            ctx.res.writeHead(this.options.statusCode ?? 200, {
+                'Content-Type': 'application/octet-stream',
+                ...this.options.headers
+            });
+
+            try {
+                await stream.promises.pipeline(this.data, ctx.res);
+            } catch (e) {
+                if (e.code === 'ERR_STREAM_PREMATURE_CLOSE') return;
+                throw e;
+            }
+        }
+    }
+}
+
+// file handler: local file
+class FileHandler {
+    constructor(file, options = {}) {
+        this.file = path.resolve(this.file);
+        this.options = options;
+
+        // range may be disabled by `options.disableRange` or when `statusCode` is set to non-200 value
+        this.options.disableRange = this.options.disableRange || (this.options.statusCode && this.options.statusCode !== 200);
+    }
+
+    async handle(ctx, env) {
+        let stats;
+        try {
+            stats = await fs.promises.stat(this.file);
+        } catch { throw 404; }
+
+        // folders are not allowed (if you need, try to make your own handler :D)
+        if (!stats.isFile()) throw 404;
+
+        // handle caching
+        if (this.options.cache) {
+            // set etag
+            if (!this._etag) this._etag = this.options.headers?.['ETag'] ?? `"${stats.size}-${stats.mtime.getTime()}"`;
+
+            // by etag
+            if (ctx.req.headers['if-none-match'] === this._etag) {
+                ctx.res.writeHead(304, {
+                    'Last-Modified': stats.mtime.toUTCString(),
+                    'ETag': this._etag,
+                    ...this.options.headers
+                });
+                ctx.res.end();
+                return;
+            }
+
+            // by mtime
+            const since = new Date(ctx.req.headers['if-modified-since'] ?? 0).getTime();
+            if (!isNaN(since) && stats.mtime.getTime() <= since) {
+                ctx.res.writeHead(304, {
+                    'Last-Modified': stats.mtime.toUTCString(),
+                    'ETag': this._etag,
+                    ...this.options.headers
+                });
+                ctx.res.end();
+                return;
+            }
+        }
+
+        // range
+        let start = 0;
+        let end = stats.size - 1;
+
+        // parse range header
+        let range = /^bytes=(\d*)-(\d*)$/.exec(ctx.req.headers.range || '');
+        if (this.options.disableRange || !(ctx.method === 'GET' || ctx.method === 'HEAD')) range = null;
+        if (range) {
+            // cache check
+            if (this.options.cache && ctx.req.headers['if-range']) {
+                if (ctx.req.headers['if-range'].startsWith('"') && ctx.req.headers['if-range'].endsWith('"')) { // etag
+                    if (ctx.req.headers['if-range'] !== this._etag) range = null;
+                } else { // mtime
+                    const since = new Date(ctx.req.headers['if-range']).getTime();
+                    if (isNaN(since) || stats.mtime.getTime() > since) range = null;
+                }
+            }
+
+            if (range[1] === '' && range[2] === '') throw 416; // invalid range
+
+            if (range[1] === '' && range[2] !== '') {
+                start = Math.max(stats.size - parseInt(range[2], 10), 0); // last n bytes
+            } else {
+                if (range[1] !== '') start = parseInt(range[1], 10);
+                if (range[2] !== '') end = Math.min(parseInt(range[2], 10), stats.size - 1);
+            }
+
+            if (start > end) throw 416;
+        }
+
+        // headers
+        ctx.res.writeHead(this.options.statusCode ?? (range ? 206 : 200), {
+            'Content-Type': mime[path.extname(this.file)] || 'application/octet-stream',
+            'Content-Length': range ? (end - start) + 1 : stats.size,
+            'Last-Modified': stats.mtime.toUTCString(),
+            ...(this._etag && { 'ETag': this._etag }),
+            ...(this.options.cache && { 'Cache-Control': 'max-age=' + (this.options.cache === true ? 'no-cache' : this.options.cache) }), // cache
+            ...(!this.options.disableRange && { 'Accept-Ranges': 'bytes' }),
+            ...(range && { 'Content-Range': `bytes ${start}-${end}/${stats.size}` }),
+            ...this.options.headers
+        });
+
+        // pipe stream or send with only headers
+        if (ctx.method === 'HEAD' && !this.options.disableHead) {
+            ctx.res.end();
+        } else {
+            // send with stream
+            try {
+                await stream.promises.pipeline(
+                    fs.createReadStream(this.file, {
+                        start, end,
+                        highWaterMark: this.options.highWaterMark || 64 * 1024
+                    }),
+                    ctx.res
+                );
+            } catch (e) {
+                if (e.code === 'ERR_STREAM_PREMATURE_CLOSE') return;
+                throw e;
+            }
+        }
+    }
+}
+
+// folder handler: local folder, continues from env.path
+class FolderHandler {
+    constructor(folder, options = {}) {
+        this.folder = path.resolve(folder);
+        this.options = options;
+    }
+
+    handle(ctx, env) {
+        const file = path.resolve(this.folder, ...env.path.slice(env.pathPointer));
+
+        // safety check
+        const rel = path.relative(this.folder, file);
+        if (rel.startsWith('..') || path.isAbsolute(rel)) throw 404;
+
+        // use a FileHandler
+        return (new FileHandler(file, this.options)).handle(ctx, env);
+    }
+}
+
+// JSON handler: JSON object
+class JSONHandler {
+    constructor(obj, options = {}) {
+        this.obj = obj;
+        this.options = options;
+    }
+
+    handle(ctx, env) {
+        const data = JSON.stringify(this.obj);
+
+        ctx.res.writeHead(this.options.statusCode ?? 200, {
+            'Content-Type': 'application/json; charset=utf-8',
+            'Content-Length': Buffer.byteLength(data, 'utf8'),
+            ...this.options.headers
+        });
+        ctx.res.end(data, 'utf8');
+    }
+}
+
+// redirect handler: 307 redirect
+class RedirectHandler {
+    constructor(location, options = {}) {
+        this.location = location;
+        this.options = options;
+    }
+
+    handle(ctx, env) {
+        ctx.res.writeHead(this.options.statusCode ?? 307, {
+            'Location': this.options.base ?
+                this.options.base +
+                (this.options.base.endsWith('/') ? '' : '/') +
+                env.path.slice(env.pathPointer).map(encodeURIComponent).join('/') :
+                this.location,
+            ...this.options.headers
+        });
+        ctx.res.end();
+    }
+}
+
+// function handler: custom function
+class FunctionHandler {
+    constructor(func) {
+        this.func = func;
+    }
+
+    handle(ctx, env) {
+        return this.func(ctx, env);
+    }
+}
+
+// export
+module.exports = {
+    DataHandler, TextHandler: DataHandler, FileHandler, FolderHandler, JSONHandler, RedirectHandler, FunctionHandler,
+    handlerConstructors: {
+        Data: (...args) => new DataHandler(...args),
+        Text: (...args) => new DataHandler(...args),
+        File: (...args) => new FileHandler(...args),
+        Folder: (...args) => new FolderHandler(...args),
+        JSON: (...args) => new JSONHandler(...args),
+        Redirect: (...args) => new RedirectHandler(...args),
+        Function: (...args) => new FunctionHandler(...args)
+    }
+};

package/src/index.js

@@ -1,17 +1,37 @@
 /*
-JustServer
+@jnode/server
+v2
 
 Simple web server package for Node.js.
 
 by JustNode Dev Team / JustApple
 */
 
-//export
+// router
+class Router {
+	constructor() {
+		console.warn('Hey! There is no need to use class `Router` directly, just use any object with a `.route(env, ctx)` method as a router.');
+		console.warn('Learn more at the documentation (README.md).');
+	}
+
+	route(env, ctx) { }
+}
+
+// handler
+class Handler {
+	constructor() {
+		console.warn('Hey! There is no need to use class `Handler` directly, just use any object with a `.handle(ctx, env)` method as a handler.');
+		console.warn('Learn more at the documentation (README.md).');
+	}
+
+	handle(ctx, env) { }
+}
+
+// export
 module.exports = {
-	Server: require('./server.js'),
-	processMap: require('./map.js'),
-	processHandle: require('./handle.js'),
-	processFinal: require('./final.js'),
-	processError: require('./error.js'),
-	mimeType: require('./mime.json')
+	mimeTypes: require('./mime.json'),
+	Router, Handler,
+	...require('./routers.js'),
+	...require('./handlers.js'),
+	...require('./server.js')
 };

package/src/routers.js

@@ -0,0 +1,210 @@
+/*
+@jnode/server/routers.js
+v2
+
+Simple web server package for Node.js.
+
+by JustApple
+*/
+
+// path router: the most important router, routes the request by path
+class PathRouter {
+    constructor(end = 404, map = {}) {
+        this.end = end;
+
+        // parse map
+        this.map = {};
+        for (let [key, value] of Object.entries(map)) {
+            // any path segment
+            if (key === '*') {
+                this.map['*'] = value;
+                continue;
+            }
+
+            key = key.trimStart();
+
+            const firstSlashIndex = key.indexOf('/');
+            if (firstSlashIndex === -1) continue;
+
+            // key format: '[@ (path end check)][METHOD (method check)]/path/segments'
+            // example: '@ GET /cat/names', 'POST /cats', '/api'
+            const routeEnd = key.startsWith('@');
+            const routeMethod = key.substring(routeEnd ? 1 : 0, firstSlashIndex).trim().toUpperCase();
+            const routePath = key.substring(firstSlashIndex).split('/').slice(1).map(decodeURIComponent);
+
+            // expand map
+            let current = this.map;
+            for (const segment of routePath) {
+                if (!current['/' + segment]) current['/' + segment] = {};
+                current = current['/' + segment];
+            }
+
+            // '*' for non-end check, '@' for end check
+            // '*' for any method, 'METHOD' for specific method
+            if (!current[routeEnd ? '@' : '*']) current[routeEnd ? '@' : '*'] = {};
+            current[routeEnd ? '@' : '*'][routeMethod || '*'] = value;
+        }
+    }
+
+    route(env, ctx) {
+        if (env.pathPointer >= env.path.length) return this.end;
+
+        let result = this.map['*'];
+        let resultPointer = env.pathPointer;
+        let current = this.map;
+        while (env.pathPointer < env.path.length) {
+            const segment = '/' + env.path[env.pathPointer];
+            if (!current[segment]) break;
+
+            // prepare fallback
+            if (current[segment]['*']?.['*'] || current[segment]['*']?.[ctx.method]) {
+                result = current[segment]['*'][ctx.method] ?? current[segment]['*']['*'];
+                resultPointer = env.pathPointer + 1;
+            }
+
+            current = current[segment];
+            env.pathPointer++;
+
+            // ends
+            if (env.pathPointer >= env.path.length && (current['@']?.['*'] || current['@']?.[ctx.method])) {
+                result = current['@'][ctx.method] ?? current['@']['*'];
+                resultPointer = env.pathPointer;
+            }
+        }
+
+        env.pathPointer = resultPointer;
+        return result;
+    }
+}
+
+// host router: routes the request by host
+class HostRouter {
+    constructor(end = 404, map = {}) {
+        this.end = end;
+
+        // parse map
+        this.map = {};
+        for (let [key, value] of Object.entries(map)) {
+            // any path segment
+            if (key === '*') {
+                this.map['*'] = value;
+                continue;
+            }
+
+            key = key.trimStart();
+
+            const firstDotIndex = key.indexOf('.');
+            if (firstDotIndex === -1) continue;
+
+            // key format: '[@ (domain end check)].domain.segments'
+            // example: '@ .com.example', '.com.example', '.localhost', '.1.0.0.127' (yes, that's how it works)
+            const routeEnd = key.startsWith('@');
+            const routeDomain = key.substring(firstDotIndex).split('.').slice(1);
+
+            // expand map
+            let current = this.map;
+            for (const segment of routeDomain) {
+                if (!current['.' + segment]) current['.' + segment] = {};
+                current = current['.' + segment];
+            }
+
+            // '*' for non-end check, '@' for end check
+            current[routeEnd ? '@' : '*'] = value;
+        }
+    }
+
+    route(env, ctx) {
+        if (env.hostPointer >= env.host.length) return this.end;
+
+        let result = this.map['*'];
+        let resultPointer = env.hostPointer;
+        let current = this.map;
+        while (env.hostPointer < env.host.length) {
+            const segment = '.' + env.host[env.hostPointer];
+            if (!current[segment]) break;
+
+            // prepare fallback
+            if (current[segment]['*']) {
+                result = current[segment]['*'];
+                resultPointer = env.hostPointer + 1;
+            }
+
+            current = current[segment];
+            env.hostPointer++;
+
+            // ends
+            if (env.hostPointer >= env.host.length && current['@']) {
+                result = current['@'];
+                resultPointer = env.hostPointer;
+            }
+        }
+
+        env.hostPointer = resultPointer;
+        return result;
+    }
+}
+
+// method router: routes the request by method
+class MethodRouter {
+    constructor(methodMap = {}) {
+        this.methodMap = methodMap;
+    }
+
+    route(env, ctx) {
+        return this.methodMap[ctx.method] || this.methodMap['*'] || 405;
+    }
+}
+
+// function router: a simple router that allows you to make custom routing logic
+class FunctionRouter {
+    constructor(fn) {
+        this.fn = fn;
+    }
+
+    route(env, ctx) {
+        return this.fn(env, ctx);
+    }
+}
+
+// path argument router: collects a path segment and save to `ctx.params`
+class PathArgRouter {
+    constructor(paramName, next) {
+        this.paramName = paramName;
+        this.next = next;
+    }
+
+    route(env, ctx) {
+        ctx.params[this.paramName] = env.path[env.pathPointer];
+        env.pathPointer++;
+
+        return this.next;
+    }
+}
+
+// host argument router: collects a host segment and save to `ctx.params`
+class HostArgRouter {
+    constructor(paramName, next) {
+        this.paramName = paramName;
+        this.next = next;
+    }
+
+    route(env, ctx) {
+        ctx.params[this.paramName] = env.host[env.hostPointer];
+        env.hostPointer++;
+
+        return this.next;
+    }
+}
+
+// export
+module.exports = {
+    PathRouter, HostRouter, MethodRouter, FunctionRouter, PathArgRouter, HostArgRouter,
+    routerConstructors: {
+        Path: (...args) => new PathRouter(...args),
+        Host: (...args) => new HostRouter(...args),
+        Method: (...args) => new MethodRouter(...args),
+        Function: (...args) => new FunctionRouter(...args),
+        PathArg: (...args) => new PathArgRouter(...args),
+        HostArg: (...args) => new HostArgRouter(...args)
+    }
+};