dx-server 0.0.1 → 0.0.3

package/README.md

@@ -0,0 +1,183 @@
+# dx-server - modern, unopinionated, and satisfactory server
+
+## Install
+```bash
+yarn add dx-server jchain
+```
+
+## Usage
+
+Check below sample with comment for more details.
+
+Sample additionally requires: `yarn install express morgan`
+
+```javascript
+import {Server} from 'http'
+import {promisify} from 'util'
+import chain from 'jchain'
+import {
+	makeContext, requestContext, responseContext,
+
+	expressContext, setHtml, setJson,
+
+	bufferBodyContext,
+	jsonBodyContext,
+	queryContext,
+	rawBodyContext,
+	textBodyContext,
+	urlencodedBodyContext,
+
+	router,
+	expressApp, expressRouter, chainExpressMiddlewares,
+} from 'dx-server'
+import express from 'express'
+import morgan from 'morgan'
+
+// it is best practice to create custom error class for non-system error
+class ServerError extends Error {
+	name = 'ServerError'
+
+	constructor(message, status = 400, code = 'unknown') {
+		super(message)
+		this.status = status
+		this.code = code
+	}
+}
+
+// makeContext is a convenient way to create context
+const authContext = makeContext(() => {
+	const req = requestContext.value
+	// determine if user is authenticated
+	// for e.g.
+	if (req.headers.authorization) {
+		return {id: 1, name: 'joe'}
+	}
+})
+
+const requireAuth = () => {
+	if (!authContext.value) throw new ServerError('unauthorized', 401, 'unauthorized')
+}
+
+const serverChain = chain(
+	expressContext.chain({jsonBeautify: true}), // allows to use setHtml, setJson, setRaw, setBuffer, setFile, setRedirect, etc.
+	bufferBodyContext.chain(), // use raw buffer body as Buffer use bufferBodyContext.value. This is required for jsonBodyContext, urlencodedBodyContext, textBodyContext, rawBodyContext
+	jsonBodyContext.chain(), // to get body parsed as json use jsonBodyContext.value. Only available if content-type is application/json
+	urlencodedBodyContext.chain(), // to get body parsed as urlencoded use urlencodedBodyContext.value. Only available if content-type is application/x-www-form-urlencoded
+	textBodyContext.chain(), // to get body parsed as text use textBodyContext.value. Only available if content-type is text/plain
+	rawBodyContext.chain(), // to get body as raw use rawBodyContext.value. Only available if content-type is application/octet-stream
+	queryContext.chain(), // to get query params use queryContext.value. Query is parsed via 'qs' package. If no query, return empty object {}
+	next => {
+		// this is the difference between express and dx-server
+		// req, res can be accessed from anywhere via context which uses NodeJS's AsyncLocalStorage under the hood
+		responseContext.value.setHeader('Cache-Control', 'no-cache')
+		next()
+	},
+	async next => {
+		// global error catching for all following middlewares
+		try {
+			await next()
+		} catch (e) {
+			// only app error message should be shown to user
+			if (e instanceof ServerError) setHtml(`${e.message} (code: ${e.code})`, {status: e.status})
+			else {
+				// report system error
+				console.error(e)
+				setHtml('internal server error (code: internal)', {status: 500})
+			}
+		}
+	},
+	await expressApp(app => {
+		// any express feature can be used
+		// required express installed, with for e.g., `yarn add express`
+		app.set('trust proxy', true)
+		if (process.env.NODE_ENV !== 'production') app.set('json spaces', 2)
+	}),
+	chainExpressMiddlewares(
+		morgan('common'), // in future, we will provide native implementation of express middlewares
+		// cookies, session, etc.
+		// session({
+		// 	secret: '123',
+		// 	resave: false,
+		// 	store: redisStore,
+		// 	saveUninitialized: true,
+		// 	// cookie: { secure: true }
+		// }),
+	),
+	await expressRouter(router => {
+		// setup express router
+		router.use('/public', express.static('public'))
+	}),
+	authContext.chain(),
+	// example of catching error for all /api/* routes
+	router.post({
+		async '/api'({next}) {
+			try {
+				await next()
+			} catch (e) {
+				// only app error message should be shown to user
+				if (e instanceof ServerError) setJson({
+					error: e.message,
+					code: e.code,
+				}, {status: e.status})
+				else {
+					// report system error
+					console.error(e)
+					setJson({
+						message: 'internal server error',
+						code: 'internal'
+					}, {status: 500})
+				}
+			}
+		}
+	}, {end: false}), // note: {end: false} is required to match all /api/* routes. This option is passed directly to path-to-regexp
+	router.post({
+		'/api/sample-public-api'() { // sample POST router
+			setJson({name: 'joe'})
+		},
+		'/api/me'() { // sample private router
+			requireAuth()
+			setJson({name: authContext.value.name})
+		},
+	}),
+	router.get({ // sample GET router
+		'/'() {
+			setHtml('ok')
+		},
+		'/health'() {
+			setHtml('ok')
+		}
+	}),
+	router.post({ // api not found router
+		'/api'() {
+			throw new ServerError('not found', 404, 'not_found')
+		}
+	}, {end: false}),
+	() => { // not found router
+		throw new ServerError('not found', 404, 'not_found')
+	},
+)
+
+const tcpServer = new Server()
+	.on('request', async (req, res) => {
+		try {
+			await chain(
+				requestContext.chain(req), // required for most middlewares
+				responseContext.chain(res), // required for most middlewares
+				serverChain,
+			)()
+		} catch (e) {
+			console.error(e)
+		}
+	})
+
+const port = +(process.env.PORT ?? 3000)
+await promisify(tcpServer.listen.bind(tcpServer))(port)
+console.log(`server is listening at ${port}`)
+```
+
+## TODO
+Until these middlewares are available as native dx-server middlewares, express middlewares can be used with `expressApp()`
+- [ ] native static file serve, like 'static-serve'
+- [ ] logger like morgan
+- [ ] cookie, session
+- [ ] cors

package/cjs/body.d.ts

@@ -0,0 +1,30 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="qs" />
+export declare const bufferBodyContext: {
+    readonly value: Buffer | undefined;
+    chain(params_0?: {
+        limit?: number | undefined;
+    } | undefined): <V>(next: () => V) => Promise<any>;
+};
+export declare const jsonBodyContext: {
+    readonly value: any;
+    chain(): <V>(next: () => V) => Promise<any>;
+};
+export declare const rawBodyContext: {
+    readonly value: Buffer | undefined;
+    chain(): <V>(next: () => V) => Promise<any>;
+};
+export declare const textBodyContext: {
+    readonly value: string | undefined;
+    chain(): <V>(next: () => V) => Promise<any>;
+};
+export declare const urlencodedBodyContext: {
+    readonly value: import("qs").ParsedQs | undefined;
+    chain(params_0?: {
+        simplify?: boolean | undefined;
+    } | undefined): <V>(next: () => V) => Promise<any>;
+};
+export declare const queryContext: {
+    readonly value: import("qs").ParsedQs;
+    chain(): <V>(next: () => V) => Promise<any>;
+};

package/cjs/body.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.queryContext = exports.urlencodedBodyContext = exports.textBodyContext = exports.rawBodyContext = exports.jsonBodyContext = exports.bufferBodyContext = void 0;
+const stream_js_1 = require("./stream.js");
+const qs_1 = require("qs");
+const contentType_js_1 = require("./contentType.js");
+const context_js_1 = require("./context.js");
+exports.bufferBodyContext = (0, context_js_1.makeContext)(async ({ limit = 100 << 10, // 100kb
+ } = {}) => {
+    const req = context_js_1.requestContext.value;
+    /**
+     * Check if a request has a request body.
+     * A request with a body __must__ either have `transfer-encoding`
+     * or `content-length` headers set.
+     * http://www.w3.org/Protocols/rfc2616/rfc2616-sec4.html#sec4.3
+     */
+    // https://github.com/jshttp/type-is/blob/cdcfe23e9833872e425b0aaf71ca0311373b6116/index.js#L92
+    const contentLengthParsed = parseInt(req.headers['content-length'] ?? '', 10);
+    if (req.headers['transfer-encoding'] === undefined
+        && isNaN(contentLengthParsed))
+        return;
+    const contentLength = isNaN(contentLengthParsed) ? undefined : contentLengthParsed;
+    // read
+    const encoding = (req.headers['content-encoding'] ?? 'identity').toLowerCase();
+    const stream = (0, stream_js_1.getContentStream)(req, encoding);
+    return await (0, stream_js_1.readStream)(stream, {
+        length: encoding === 'identity' ? contentLength : undefined,
+        limit,
+    });
+});
+const forceGetContentTypeParams = (expected) => {
+    const req = context_js_1.requestContext.value;
+    const contentTypeRaw = req.headers['content-type'];
+    if (!contentTypeRaw)
+        return;
+    const { mediaType, parameters } = (0, contentType_js_1.parseContentType)(contentTypeRaw);
+    if (mediaType !== expected)
+        return;
+    return parameters;
+};
+const forceGetCharset = (expected) => {
+    const parameters = forceGetContentTypeParams(expected);
+    if (!parameters)
+        return;
+    // assert charset per RFC 7159 sec 8.1
+    const charset = parameters.charset?.toLowerCase() || 'utf-8';
+    if (!charset.startsWith('utf-'))
+        throw new Error(`unsupported charset "${charset.toUpperCase()}"`);
+    return charset;
+};
+exports.jsonBodyContext = (0, context_js_1.makeContext)(async () => {
+    const charset = forceGetCharset('application/json');
+    if (!charset)
+        return;
+    const buffer = exports.bufferBodyContext.value;
+    if (buffer) {
+        const str = buffer.toString(charset);
+        return str ? JSON.parse(str) : undefined;
+    }
+});
+exports.rawBodyContext = (0, context_js_1.makeContext)(async () => {
+    if (!forceGetContentTypeParams('application/octet-stream'))
+        return;
+    return exports.bufferBodyContext.value;
+});
+exports.textBodyContext = (0, context_js_1.makeContext)(async () => {
+    const charset = forceGetCharset('text/plain');
+    if (!charset)
+        return;
+    const buffer = exports.bufferBodyContext.value;
+    if (buffer)
+        return buffer.toString(charset);
+});
+exports.urlencodedBodyContext = (0, context_js_1.makeContext)(async ({ simplify } = {}) => {
+    const charset = forceGetCharset('application/x-www-form-urlencoded');
+    if (!charset)
+        return;
+    const buffer = exports.bufferBodyContext.value;
+    if (buffer) {
+        const str = buffer.toString(charset);
+        return simplify
+            ? Object.fromEntries(new URLSearchParams(str))
+            : (0, qs_1.parse)(str);
+    }
+});
+exports.queryContext = (0, context_js_1.makeContext)(() => {
+    const req = context_js_1.requestContext.value;
+    const query = req.url?.split('?', 2)?.[1];
+    return query ? (0, qs_1.parse)(query) : {};
+});
+//# sourceMappingURL=data:application/json;base64,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

package/cjs/contentType.d.ts

@@ -0,0 +1,4 @@
+export declare function parseContentType(header: string): {
+    mediaType: string;
+    parameters: Record<string, string>;
+};

package/cjs/contentType.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseContentType = void 0;
+// https://github.com/jshttp/content-type/blob/d02574e9640bd4370f148c767b1b877b5a300070/index.js#L106
+/**
+ * RegExp to match type in RFC 7231 sec 3.1.1.1
+ *
+ * media-type = type "/" subtype
+ * type       = token
+ * subtype    = token
+ */
+const TYPE_REGEXP = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+\/[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;
+/**
+ * RegExp to match *( ";" parameter ) in RFC 7231 sec 3.1.1.1
+ *
+ * parameter     = token "=" ( token / quoted-string )
+ * token         = 1*tchar
+ * tchar         = "!" / "#" / "$" / "%" / "&" / "'" / "*"
+ *               / "+" / "-" / "." / "^" / "_" / "`" / "|" / "~"
+ *               / DIGIT / ALPHA
+ *               ; any VCHAR, except delimiters
+ * quoted-string = DQUOTE *( qdtext / quoted-pair ) DQUOTE
+ * qdtext        = HTAB / SP / %x21 / %x23-5B / %x5D-7E / obs-text
+ * obs-text      = %x80-FF
+ * quoted-pair   = "\" ( HTAB / SP / VCHAR / obs-text )
+ */
+const PARAM_REGEXP = /; *([!#$%&'*+.^_`|~0-9A-Za-z-]+) *= *("(?:[\u000b\u0020\u0021\u0023-\u005b\u005d-\u007e\u0080-\u00ff]|\\[\u000b\u0020-\u00ff])*"|[!#$%&'*+.^_`|~0-9A-Za-z-]+) */g; // eslint-disable-line no-control-regex
+const TEXT_REGEXP = /^[\u000b\u0020-\u007e\u0080-\u00ff]+$/; // eslint-disable-line no-control-regex
+const TOKEN_REGEXP = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;
+/**
+ * RegExp to match quoted-pair in RFC 7230 sec 3.2.6
+ *
+ * quoted-pair = "\" ( HTAB / SP / VCHAR / obs-text )
+ * obs-text    = %x80-FF
+ */
+const QESC_REGEXP = /\\([\u000b\u0020-\u00ff])/g; // eslint-disable-line no-control-regex
+function parseContentType(header) {
+    let index = header.indexOf(';');
+    const mediaType = index !== -1
+        ? header.slice(0, index).trim()
+        : header.trim();
+    if (!TYPE_REGEXP.test(mediaType))
+        throw new TypeError(`invalid media type: ${mediaType}`);
+    const parameters = {};
+    // parse parameters
+    if (index !== -1) {
+        let key;
+        let match;
+        let value;
+        const regexp = new RegExp(PARAM_REGEXP);
+        regexp.lastIndex = index;
+        while ((match = regexp.exec(header))) {
+            if (match.index !== index)
+                throw new TypeError('invalid parameter format');
+            index += match[0].length;
+            key = match[1].toLowerCase();
+            value = match[2];
+            if (value.charCodeAt(0) === 0x22 /* " */) {
+                // remove quotes
+                value = value.slice(1, -1);
+                // remove escapes
+                if (value.indexOf('\\') !== -1)
+                    value = value.replace(QESC_REGEXP, '$1');
+            }
+            parameters[key] = value;
+        }
+        if (index !== header.length)
+            throw new TypeError('invalid parameter format');
+    }
+    return { mediaType, parameters };
+}
+exports.parseContentType = parseContentType;
+/**
+ * RegExp to match chars that must be quoted-pair in RFC 7230 sec 3.2.6
+ */
+const QUOTE_REGEXP = /([\\"])/g;
+function qstring(str) {
+    // no need to quote tokens
+    if (TOKEN_REGEXP.test(str))
+        return str;
+    if (str.length > 0 && !TEXT_REGEXP.test(str))
+        throw new TypeError(`invalid parameter value: ${str}`);
+    return `"${str.replace(QUOTE_REGEXP, '\\$1')}"`;
+}
+function formatContentType({ mediaType, parameters }) {
+    if (!mediaType || !TYPE_REGEXP.test(mediaType))
+        throw new TypeError(`invalid type: ${mediaType}`);
+    return `${mediaType}${parameters
+        ? Object.keys(parameters).sort().map(key => `; ${key}=${qstring(parameters[key])}`).join('')
+        : ''}`;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/cjs/context.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="node" resolution-mode="require"/>
+import { Promisable } from 'type-fest';
+import { IncomingMessage, ServerResponse } from 'node:http';
+export declare const makeContext: <T, Params extends any[] = unknown[]>(maker: (...params: Params) => Promisable<T>, end?: (result: any, value: T) => any) => {
+    readonly value: T;
+    chain(...params: Params): <V>(next: () => V) => Promise<any>;
+};
+export declare const requestContext: {
+    readonly value: IncomingMessage;
+    chain(params_0: IncomingMessage): <V>(next: () => V) => Promise<any>;
+};
+export declare const responseContext: {
+    readonly value: ServerResponse<IncomingMessage>;
+    chain(params_0: ServerResponse<IncomingMessage>): <V>(next: () => V) => Promise<any>;
+};

package/cjs/context.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.responseContext = exports.requestContext = exports.makeContext = void 0;
+const node_async_hooks_1 = require("node:async_hooks");
+const jmisc_1 = require("jmisc");
+const makeContext = (maker, end = jmisc_1.identity) => {
+    const asyncLocalStorage = new node_async_hooks_1.AsyncLocalStorage();
+    return {
+        get value() {
+            return asyncLocalStorage.getStore();
+        },
+        chain(...params) {
+            return async (next) => {
+                const value = await maker(...params);
+                return end(await asyncLocalStorage.run(value, next), value);
+            };
+        },
+    };
+};
+exports.makeContext = makeContext;
+// method: verb
+// url: full url without server, protocol, port.
+// headers: if headers are repeated, they are joined by comma. Header names are lowercased.
+// rawHeaders: list of header name and value in a flat array. Case is preserved.
+exports.requestContext = (0, exports.makeContext)(jmisc_1.identity);
+exports.responseContext = (0, exports.makeContext)(jmisc_1.identity);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29udGV4dC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9jb250ZXh0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLHVEQUFrRDtBQUdsRCxpQ0FBOEI7QUFFdkIsTUFBTSxXQUFXLEdBQUcsQ0FDMUIsS0FBMkMsRUFDM0MsTUFBc0MsZ0JBQVEsRUFDN0MsRUFBRTtJQUNILE1BQU0saUJBQWlCLEdBQUcsSUFBSSxvQ0FBaUIsRUFBSyxDQUFBO0lBQ3BELE9BQU87UUFDTixJQUFJLEtBQUs7WUFDUixPQUFPLGlCQUFpQixDQUFDLFFBQVEsRUFBRyxDQUFBO1FBQ3JDLENBQUM7UUFDRCxLQUFLLENBQUMsR0FBRyxNQUFjO1lBQ3RCLE9BQU8sS0FBSyxFQUFLLElBQWEsRUFBRSxFQUFFO2dCQUNqQyxNQUFNLEtBQUssR0FBRyxNQUFNLEtBQUssQ0FBQyxHQUFHLE1BQU0sQ0FBQyxDQUFBO2dCQUNwQyxPQUFPLEdBQUcsQ0FBQyxNQUFNLGlCQUFpQixDQUFDLEdBQUcsQ0FBQyxLQUFLLEVBQUUsSUFBSSxDQUFDLEVBQUUsS0FBSyxDQUFDLENBQUE7WUFDNUQsQ0FBQyxDQUFBO1FBQ0YsQ0FBQztLQUNELENBQUE7QUFDRixDQUFDLENBQUE7QUFoQlksUUFBQSxXQUFXLGVBZ0J2QjtBQUVELGVBQWU7QUFDZixnREFBZ0Q7QUFDaEQsMkZBQTJGO0FBQzNGLGdGQUFnRjtBQUNuRSxRQUFBLGNBQWMsR0FBRyxJQUFBLG1CQUFXLEVBQXFDLGdCQUFRLENBQUMsQ0FBQTtBQUMxRSxRQUFBLGVBQWUsR0FBRyxJQUFBLG1CQUFXLEVBQW1DLGdCQUFRLENBQUMsQ0FBQSJ9

package/cjs/error.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.notFoundApi = exports.notFound = exports.catchApiError = exports.catchError = void 0;
+const express_js_1 = require("./express.js");
+const route_js_1 = require("./route.js");
+const catchError = async (next) => {
+    try {
+        await next();
+    }
+    catch (e) {
+        console.error(e);
+        (0, express_js_1.setHtml)('internal server error', { status: 500 });
+    }
+};
+exports.catchError = catchError;
+exports.catchApiError = route_js_1.router.post({
+    async '/api'({ next }) {
+        try {
+            await next();
+        }
+        catch (e) {
+            console.error(e);
+            (0, express_js_1.setJson)({
+                message: 'internal server error',
+                code: 'internal_server_error'
+            }, { status: 500 });
+        }
+    }
+}, { end: false });
+const notFound = () => {
+    (0, express_js_1.setHtml)('not found', { status: 404 });
+};
+exports.notFound = notFound;
+exports.notFoundApi = route_js_1.router.post({
+    '/api'() {
+        (0, express_js_1.setJson)({
+            message: 'not found',
+            code: 'not_found'
+        }, { status: 404 });
+    }
+}, { end: false });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXJyb3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvZXJyb3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQ0EsNkNBQTZDO0FBQzdDLHlDQUFpQztBQUUxQixNQUFNLFVBQVUsR0FBZSxLQUFLLEVBQUMsSUFBSSxFQUFDLEVBQUU7SUFDbEQsSUFBSTtRQUNILE1BQU0sSUFBSSxFQUFFLENBQUE7S0FDWjtJQUFDLE9BQU8sQ0FBQyxFQUFFO1FBQ1gsT0FBTyxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsQ0FBQTtRQUNoQixJQUFBLG9CQUFPLEVBQUMsdUJBQXVCLEVBQUUsRUFBQyxNQUFNLEVBQUUsR0FBRyxFQUFDLENBQUMsQ0FBQTtLQUMvQztBQUNGLENBQUMsQ0FBQTtBQVBZLFFBQUEsVUFBVSxjQU90QjtBQUVZLFFBQUEsYUFBYSxHQUFHLGlCQUFNLENBQUMsSUFBSSxDQUFDO0lBQ3hDLEtBQUssQ0FBQyxNQUFNLENBQUMsRUFBQyxJQUFJLEVBQUM7UUFDbEIsSUFBSTtZQUNILE1BQU0sSUFBSSxFQUFFLENBQUE7U0FDWjtRQUFDLE9BQU8sQ0FBQyxFQUFFO1lBQ1gsT0FBTyxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsQ0FBQTtZQUNoQixJQUFBLG9CQUFPLEVBQUM7Z0JBQ1AsT0FBTyxFQUFFLHVCQUF1QjtnQkFDaEMsSUFBSSxFQUFFLHVCQUF1QjthQUM3QixFQUFFLEVBQUMsTUFBTSxFQUFFLEdBQUcsRUFBQyxDQUFDLENBQUE7U0FDakI7SUFDRixDQUFDO0NBQ0QsRUFBRSxFQUFDLEdBQUcsRUFBRSxLQUFLLEVBQUMsQ0FBQyxDQUFBO0FBRVQsTUFBTSxRQUFRLEdBQWUsR0FBRyxFQUFFO0lBQ3hDLElBQUEsb0JBQU8sRUFBQyxXQUFXLEVBQUUsRUFBQyxNQUFNLEVBQUUsR0FBRyxFQUFDLENBQUMsQ0FBQTtBQUNwQyxDQUFDLENBQUE7QUFGWSxRQUFBLFFBQVEsWUFFcEI7QUFDWSxRQUFBLFdBQVcsR0FBRyxpQkFBTSxDQUFDLElBQUksQ0FBQztJQUN0QyxNQUFNO1FBQ0wsSUFBQSxvQkFBTyxFQUFDO1lBQ1AsT0FBTyxFQUFFLFdBQVc7WUFDcEIsSUFBSSxFQUFFLFdBQVc7U0FDakIsRUFBRSxFQUFDLE1BQU0sRUFBRSxHQUFHLEVBQUMsQ0FBQyxDQUFBO0lBQ2xCLENBQUM7Q0FDRCxFQUFFLEVBQUMsR0FBRyxFQUFFLEtBQUssRUFBQyxDQUFDLENBQUEifQ==

package/cjs/etag.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import type { IncomingMessage } from 'node:http';
+export declare function entityTag(buf: Buffer, weak?: boolean): string;
+export declare function statTag(stat: any): string;
+export declare function isFreshETag(req: IncomingMessage, etag: string): true | undefined;
+export declare function isFreshModifiedSince(req: IncomingMessage, lastModified: string): boolean | undefined;

package/cjs/etag.js

@@ -0,0 +1,100 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isFreshModifiedSince = exports.isFreshETag = exports.statTag = exports.entityTag = void 0;
+// etag: https://github.com/jshttp/etag/blob/b9f0642256e63654287299d205bc6ced71b1a228/index.js#L39
+const node_crypto_1 = __importDefault(require("node:crypto"));
+function entityTag(buf, weak) {
+    // pre-computed empty
+    return buf.length
+        ? `${buf.length.toString(16)}-${node_crypto_1.default
+            .createHash('sha1')
+            .update(buf)
+            .digest('base64')
+            .substring(0, 27)}"`
+        : `${weak ? 'W/' : ''}"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk"`;
+    // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/ETag#directives
+    // weak W/ vs strong eTag
+    // same weak eTag: 2 resources might be semantically equivalent, but not byte-for-byte identical
+}
+exports.entityTag = entityTag;
+const CACHE_CONTROL_NO_CACHE_REGEXP = /(?:^|,)\s*?no-cache\s*?(?:,|$)/;
+function statTag(stat) {
+    const mtime = stat.mtime.getTime().toString(16);
+    const size = stat.size.toString(16);
+    return `"${size}-${mtime}"`;
+}
+exports.statTag = statTag;
+// https://github.com/jshttp/fresh/blob/05254186fd7428915224db46144fc94293a7df7d/index.js#L33
+function isFreshETag(req, etag) {
+    const noneMatch = req.headers['if-none-match'];
+    if (!noneMatch)
+        return;
+    // Always return stale when Cache-Control: no-cache
+    // to support end-to-end reload requests
+    // https://tools.ietf.org/html/rfc2616#section-14.9.4
+    const cacheControl = req.headers['cache-control'];
+    if (cacheControl && CACHE_CONTROL_NO_CACHE_REGEXP.test(cacheControl))
+        return;
+    if (noneMatch && noneMatch !== '*') {
+        if (!etag)
+            return;
+        let etagStale = true;
+        for (const match of parseTokenList(noneMatch)) {
+            if (match === etag || match === `W/${etag}` || `W/${match}` === etag) {
+                etagStale = false;
+                break;
+            }
+        }
+        if (etagStale)
+            return;
+    }
+    return true;
+}
+exports.isFreshETag = isFreshETag;
+function isFreshModifiedSince(req, lastModified) {
+    const modifiedSince = req.headers['if-modified-since'];
+    if (!modifiedSince)
+        return;
+    // Always return stale when Cache-Control: no-cache
+    // to support end-to-end reload requests
+    // https://tools.ietf.org/html/rfc2616#section-14.9.4
+    const cacheControl = req.headers['cache-control'];
+    if (cacheControl && CACHE_CONTROL_NO_CACHE_REGEXP.test(cacheControl))
+        return;
+    if (modifiedSince && lastModified) {
+        const lastModifiedDate = Date.parse(lastModified);
+        const modifiedSinceDate = Date.parse(modifiedSince);
+        return !isNaN(lastModifiedDate) && !isNaN(modifiedSinceDate) && lastModifiedDate <= modifiedSinceDate;
+    }
+    return true;
+}
+exports.isFreshModifiedSince = isFreshModifiedSince;
+function parseTokenList(str) {
+    let end = 0;
+    const list = [];
+    let start = 0;
+    // gather tokens
+    for (let i = 0, len = str.length; i < len; i++) {
+        switch (str.charCodeAt(i)) {
+            case 0x20: /*   */
+                if (start === end) {
+                    start = end = i + 1;
+                }
+                break;
+            case 0x2c: /* , */
+                list.push(str.substring(start, end));
+                start = end = i + 1;
+                break;
+            default:
+                end = i + 1;
+                break;
+        }
+    }
+    // final token
+    list.push(str.substring(start, end));
+    return list;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/cjs/express.d.ts

@@ -0,0 +1,49 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { Writable } from 'node:stream';
+export declare const expressContext: {
+    readonly value: {
+        charset?: BufferEncoding | undefined;
+        jsonBeautify?: boolean | undefined;
+        disableEtag?: boolean | undefined;
+    } & ({
+        type: 'text';
+        data: string;
+    } | {
+        type: 'html';
+        data: string;
+    } | {
+        type: 'buffer';
+        data: Buffer;
+    } | {
+        type: 'json';
+        data: any;
+    } | {
+        type: 'redirect';
+        data: string;
+    } | {
+        type: 'stream';
+        data: Writable;
+    });
+    chain(params_0?: {
+        jsonBeautify?: boolean | undefined;
+        disableEtag?: boolean | undefined;
+    } | undefined): <V>(next: () => V) => Promise<any>;
+};
+export declare function setText(text: string, { status }?: {
+    status?: number;
+}): void;
+export declare function setHtml(html: string, opts?: {
+    status?: number;
+}): void;
+export declare function setBuffer(buffer: Buffer, { status }?: {
+    status?: number;
+}): void;
+export declare function setStream(stream: Writable, { status }?: {
+    status?: number;
+}): void;
+export declare function setJson(json: any, { status, beautify }?: {
+    status?: number;
+    beautify?: boolean;
+}): void;
+export declare function setRedirect(url: string, status: 301 | 302): void;