zero-http 0.2.0

package/lib/body/rawBuffer.js

@@ -0,0 +1,74 @@
+/**
+ * @module body/rawBuffer
+ * @description Low-level helper that collects the raw request body into a
+ *              single Buffer, enforcing an optional byte-size limit.
+ */
+
+/**
+ * Parse a human-readable size string (e.g. `'10kb'`, `'2mb'`) into bytes.
+ *
+ * @param {string|number|null} limit - Size limit value.
+ * @returns {number|null} Byte limit, or `null` for unlimited.
+ */
+function parseLimit(limit)
+{
+    if (!limit && limit !== 0) return null;
+    if (typeof limit === 'number') return limit;
+    if (typeof limit === 'string')
+    {
+        const v = limit.trim().toLowerCase();
+        const num = Number(v.replace(/[^0-9.]/g, ''));
+        if (v.endsWith('kb')) return Math.floor(num * 1024);
+        if (v.endsWith('mb')) return Math.floor(num * 1024 * 1024);
+        if (v.endsWith('gb')) return Math.floor(num * 1024 * 1024 * 1024);
+        return Math.floor(num);
+    }
+    return null;
+}
+
+/**
+ * Collect the raw request body into a Buffer.
+ * Rejects with a `{ status: 413 }` error when `opts.limit` is exceeded.
+ *
+ * @param {import('../request')} req        - Wrapped request (must have `.raw` stream).
+ * @param {object}               [opts]
+ * @param {string|number|null}   [opts.limit] - Maximum body size.
+ * @returns {Promise<Buffer>} Resolved with the full body buffer.
+ */
+function rawBuffer(req, opts = {})
+{
+    const limit = parseLimit(opts.limit);
+    return new Promise((resolve, reject) =>
+    {
+        const chunks = [];
+        let total = 0;
+        function onData(c)
+        {
+            total += c.length;
+            if (limit && total > limit)
+            {
+                // stop reading and reject with a status property
+                req.raw.removeListener('data', onData);
+                req.raw.removeListener('end', onEnd);
+                req.raw.removeListener('error', onError);
+                const err = new Error('payload too large');
+                err.status = 413;
+                return reject(err);
+            }
+            chunks.push(c);
+        }
+        function onEnd()
+        {
+            resolve(Buffer.concat(chunks));
+        }
+        function onError(e)
+        {
+            reject(e);
+        }
+        req.raw.on('data', onData);
+        req.raw.on('end', onEnd);
+        req.raw.on('error', onError);
+    });
+}
+
+module.exports = rawBuffer;

package/lib/body/sendError.js

@@ -0,0 +1,17 @@
+/**
+ * Shared helper for sending HTTP error responses from body parsers.
+ * Centralizes the pattern used across all parsers so changes only happen in one place.
+ *
+ * @param {object} res    - The response wrapper (or raw response).
+ * @param {number} status - HTTP status code.
+ * @param {string} message - Error message string for the JSON body.
+ */
+function sendError(res, status, message)
+{
+    const raw = res.raw || res;
+    raw.statusCode = status;
+    raw.setHeader('Content-Type', 'application/json');
+    raw.end(JSON.stringify({ error: message }));
+}
+
+module.exports = sendError;

package/lib/body/text.js

@@ -0,0 +1,43 @@
+/**
+ * @module body/text
+ * @description Plain-text body-parsing middleware.
+ *              Reads the request body as a string and sets `req.body`.
+ */
+const rawBuffer = require('./rawBuffer');
+const isTypeMatch = require('./typeMatch');
+const sendError = require('./sendError');
+
+/**
+ * Create a plain-text body-parsing middleware.
+ *
+ * @param {object}          [options]
+ * @param {string|number}   [options.limit]              - Max body size.
+ * @param {string}          [options.encoding='utf8']    - Character encoding.
+ * @param {string|Function} [options.type='text/*']      - Content-Type to match.
+ * @returns {Function} Async middleware `(req, res, next) => void`.
+ */
+function text(options = {})
+{
+  const opts = options || {};
+  const limit = opts.limit || null;
+  const encoding = opts.encoding || 'utf8';
+  const typeOpt = opts.type || 'text/*';
+
+  return async (req, res, next) =>
+  {
+    const ct = (req.headers['content-type'] || '');
+    if (!isTypeMatch(ct, typeOpt)) return next();
+    try
+    {
+      const buf = await rawBuffer(req, { limit });
+      req.body = buf.toString(encoding);
+    } catch (err)
+    {
+      if (err && err.status === 413) return sendError(res, 413, 'payload too large');
+      req.body = '';
+    }
+    next();
+  };
+}
+
+module.exports = text;

package/lib/body/typeMatch.js

@@ -0,0 +1,22 @@
+/**
+ * Shared Content-Type matching utility for body parsers.
+ *
+ * @param {string}            contentType  - The request Content-Type header value.
+ * @param {string|function}   typeOpt      - MIME pattern to match against (e.g. 'application/json', 'text/*', '*​/*')
+ *                                           or a custom predicate `(ct) => boolean`.
+ * @returns {boolean}
+ */
+function isTypeMatch(contentType, typeOpt)
+{
+    if (!typeOpt) return true;
+    if (typeof typeOpt === 'function') return !!typeOpt(contentType);
+    if (!contentType) return false;
+    if (typeOpt === '*/*') return true;
+    if (typeOpt.endsWith('/*'))
+    {
+        return contentType.startsWith(typeOpt.slice(0, -1));
+    }
+    return contentType.indexOf(typeOpt) !== -1;
+}
+
+module.exports = isTypeMatch;

package/lib/body/urlencoded.js

@@ -0,0 +1,166 @@
+/**
+ * @module body/urlencoded
+ * @description URL-encoded body-parsing middleware.
+ *              Supports both flat (`URLSearchParams`) and extended
+ *              (nested bracket syntax) parsing modes.
+ */
+const rawBuffer = require('./rawBuffer');
+const isTypeMatch = require('./typeMatch');
+const sendError = require('./sendError');
+
+/**
+ * Append a value to an existing key, converting to an array when needed.
+ *
+ * @param {*}      prev - Previous value for the key (or `undefined`).
+ * @param {string} val  - New value to append.
+ * @returns {string|string[]} Merged value.
+ */
+function appendValue(prev, val)
+{
+    if (prev === undefined) return val;
+    if (Array.isArray(prev)) { prev.push(val); return prev; }
+    // convert existing scalar or object into array to hold multiple values
+    return [prev, val];
+}
+
+/**
+ * Create a URL-encoded body-parsing middleware.
+ *
+ * @param {object}          [options]
+ * @param {string|number}   [options.limit]     - Max body size (e.g. `'10kb'`).
+ * @param {string|Function} [options.type='application/x-www-form-urlencoded'] - Content-Type to match.
+ * @param {boolean}         [options.extended=false] - Use nested bracket parsing (e.g. `a[b][c]=1`).
+ * @returns {Function} Async middleware `(req, res, next) => void`.
+ */
+function urlencoded(options = {})
+{
+    const opts = options || {};
+    const limit = opts.limit || null;
+    const typeOpt = opts.type || 'application/x-www-form-urlencoded';
+    const extended = !!opts.extended;
+
+    return async (req, res, next) =>
+    {
+        const ct = (req.headers['content-type'] || '');
+        if (!isTypeMatch(ct, typeOpt)) return next();
+        try
+        {
+            const buf = await rawBuffer(req, { limit });
+            const txt = buf.toString('utf8');
+            if (!extended)
+            {
+                req.body = Object.fromEntries(new URLSearchParams(txt));
+            }
+            else
+            {
+                // extended parsing: support nested bracket syntax like a[b][c]=1 and arrays a[]=1
+                const out = {};
+                if (txt.trim() === '') { req.body = out; return next(); }
+                const pairs = txt.split('&');
+                for (const p of pairs)
+                {
+                    if (!p) continue;
+                    const eq = p.indexOf('=');
+                    let k, v;
+                    if (eq === -1) { k = decodeURIComponent(p.replace(/\+/g, ' ')); v = ''; }
+                    else { k = decodeURIComponent(p.slice(0, eq).replace(/\+/g, ' ')); v = decodeURIComponent(p.slice(eq + 1).replace(/\+/g, ' ')); }
+                    // parse key into parts
+                    const parts = [];
+                    const re = /([^\[\]]+)|\[(.*?)\]/g;
+                    let m;
+                    while ((m = re.exec(k)) !== null)
+                    {
+                        parts.push(m[1] || m[2]);
+                    }
+
+                    // set value into out following parts
+                    let cur = out;
+                    for (let i = 0; i < parts.length; i++)
+                    {
+                        const part = parts[i];
+                        const isLast = (i === parts.length - 1);
+
+                        if (part === '')
+                        {
+                            // array push
+                            if (isLast)
+                            {
+                                if (!Array.isArray(cur))
+                                {
+                                    // convert existing value to array if needed
+                                    if (Object.prototype.hasOwnProperty.call(cur, '0'))
+                                    {
+                                        // unlikely
+                                    }
+                                }
+                                cur.push(v);
+                                break;
+                            }
+                            // ensure cur is array and proceed to next index object
+                            if (!Array.isArray(cur))
+                            {
+                                // convert existing object to array if empty
+                                const keys = Object.keys(cur);
+                                if (keys.length === 0) cur = [];
+                                else { /* leave as object */ }
+                            }
+                            // push an object if next part is non-empty
+                            if (cur.length === 0 || typeof cur[cur.length - 1] !== 'object') cur.push({});
+                            cur = cur[cur.length - 1];
+                            continue;
+                        }
+
+                        // normal key
+                        if (isLast)
+                        {
+                            if (Array.isArray(cur))
+                            {
+                                // numeric key may indicate index
+                                const idx = Number(part);
+                                if (!Number.isNaN(idx)) cur[idx] = appendValue(cur[idx], v);
+                                else cur[part] = appendValue(cur[part], v);
+                            }
+                            else
+                            {
+                                cur[part] = appendValue(cur[part], v);
+                            }
+                        }
+                        else
+                        {
+                            if (Array.isArray(cur))
+                            {
+                                const idx = Number(part);
+                                if (!Number.isNaN(idx))
+                                {
+                                    if (!cur[idx]) cur[idx] = {};
+                                    cur = cur[idx];
+                                } else
+                                {
+                                    // treat non-numeric into last pushed object
+                                    if (cur.length === 0) cur.push({});
+                                    if (typeof cur[cur.length - 1] !== 'object') cur.push({});
+                                    cur = cur[cur.length - 1];
+                                    if (!cur[part]) cur[part] = {};
+                                    cur = cur[part];
+                                }
+                            }
+                            else
+                            {
+                                if (!cur[part]) cur[part] = {};
+                                cur = cur[part];
+                            }
+                        }
+                    }
+                }
+                req.body = out;
+            }
+        } catch (err)
+        {
+            if (err && err.status === 413) return sendError(res, 413, 'payload too large');
+            req.body = {};
+        }
+        next();
+    };
+}
+
+module.exports = urlencoded;

package/lib/cors.js

@@ -0,0 +1,72 @@
+/**
+ * @module cors
+ * @description CORS middleware.  Supports exact origins, wildcard `'*'`,
+ *              arrays of allowed origins, and suffix matching with a leading dot
+ *              (e.g. `'.example.com'` matches `sub.example.com`).
+ */
+
+/**
+ * Create a CORS middleware.
+ *
+ * @param {object}           [options]
+ * @param {string|string[]}  [options.origin='*']          - Allowed origin(s).  Use `'*'` for any,
+ *                                                           an array for a whitelist, or a string
+ *                                                           starting with `'.'` for suffix matching.
+ * @param {string}           [options.methods='GET,POST,PUT,DELETE,OPTIONS'] - Allowed HTTP methods.
+ * @param {string}           [options.allowedHeaders='Content-Type,Authorization'] - Allowed request headers.
+ * @param {boolean}          [options.credentials=false]   - Whether to set `Access-Control-Allow-Credentials`.
+ * @returns {Function} Middleware `(req, res, next) => void`.
+ */
+function cors(options = {})
+{
+    const allowOrigin = (options.hasOwnProperty('origin')) ? options.origin : '*';
+    const allowMethods = (options.methods || 'GET,POST,PUT,DELETE,OPTIONS');
+    const allowHeaders = (options.allowedHeaders || 'Content-Type,Authorization');
+
+    /**
+     * Resolve the Origin header value to echo back based on the configured
+     * allow-list.  Returns `null` when the origin should not be allowed.
+     *
+     * @param {string|undefined} reqOrigin - The request's `Origin` header.
+     * @returns {string|null} Origin value to set, or `null`.
+     */
+    function matchOrigin(reqOrigin)
+    {
+        if (!allowOrigin) return null; // origin explicitly disabled
+        if (typeof allowOrigin === 'string') return allowOrigin === '*' ? '*' : allowOrigin;
+        if (Array.isArray(allowOrigin))
+        {
+            if (!reqOrigin) return null;
+            for (const o of allowOrigin)
+            {
+                if (!o) continue;
+                if (o === reqOrigin) return reqOrigin;
+                // allow suffix match with leading dot (e.g. .example.com)
+                if (o[0] === '.' && reqOrigin.endsWith(o)) return reqOrigin;
+            }
+            return null;
+        }
+        return null;
+    }
+
+    return (req, res, next) =>
+    {
+        const reqOrigin = req.headers && (req.headers.origin || req.headers.Origin);
+        const originValue = matchOrigin(reqOrigin);
+
+        if (originValue)
+        {
+            res.set('Access-Control-Allow-Origin', originValue);
+            // allow credentials when matching specific origin
+            if (options.credentials) res.set('Access-Control-Allow-Credentials', 'true');
+        }
+
+        if (allowMethods) res.set('Access-Control-Allow-Methods', allowMethods);
+        if (allowHeaders) res.set('Access-Control-Allow-Headers', allowHeaders);
+
+        if (req.method === 'OPTIONS') return res.status(204).send();
+        next();
+    };
+}
+
+module.exports = cors;

package/lib/fetch.js

@@ -0,0 +1,218 @@
+/**
+ * @module fetch
+ * @description Minimal, zero-dependency server-side `fetch()` replacement.
+ *              Supports HTTP/HTTPS, JSON/URLSearchParams/Buffer/stream bodies,
+ *              download & upload progress callbacks, timeouts, and AbortSignal.
+ */
+const http = require('http');
+const https = require('https');
+const { URL } = require('url');
+
+const STATUS_CODES = http.STATUS_CODES;
+
+/**
+ * Perform an HTTP(S) request.
+ *
+ * @param {string} url  - Absolute URL to fetch.
+ * @param {object} [opts]
+ * @param {string}   [opts.method='GET']           - HTTP method.
+ * @param {object}   [opts.headers]                - Request headers.
+ * @param {string|Buffer|object|ReadableStream} [opts.body] - Request body.
+ * @param {number}   [opts.timeout]                - Request timeout in ms.
+ * @param {AbortSignal} [opts.signal]              - Abort signal for cancellation.
+ * @param {import('http').Agent} [opts.agent]      - Custom HTTP agent.
+ * @param {Function} [opts.onDownloadProgress]     - `({ loaded, total }) => void` callback.
+ * @param {Function} [opts.onUploadProgress]       - `({ loaded, total }) => void` callback.
+ * @returns {Promise<{ status: number, statusText: string, ok: boolean, headers: object, arrayBuffer: Function, text: Function, json: Function }>}
+ */
+function miniFetch(url, opts = {})
+{
+    return new Promise((resolve, reject) =>
+    {
+        try
+        {
+            const u = new URL(url);
+            const lib = u.protocol === 'https:' ? https : http;
+            const method = (opts.method || 'GET').toUpperCase();
+            const headers = Object.assign({}, opts.headers || {});
+
+            // Normalize body
+            let body = opts.body;
+            if (body && typeof body === 'object' && typeof body.toString === 'function' && body.constructor && body.constructor.name === 'URLSearchParams')
+            {
+                if (!headers['Content-Type'] && !headers['content-type']) headers['Content-Type'] = 'application/x-www-form-urlencoded';
+                body = body.toString();
+            }
+            else if (body && typeof body === 'object' && !Buffer.isBuffer(body) && !(body instanceof ArrayBuffer) && !(body instanceof Uint8Array) && !(body && typeof body.pipe === 'function'))
+            {
+                if (!headers['Content-Type'] && !headers['content-type']) headers['Content-Type'] = 'application/json';
+                body = Buffer.from(JSON.stringify(body), 'utf8');
+            }
+            else if (body instanceof ArrayBuffer)
+            {
+                body = Buffer.from(body);
+            }
+            else if (body instanceof Uint8Array && !Buffer.isBuffer(body))
+            {
+                body = Buffer.from(body);
+            }
+
+            // Set Content-Length for known-size bodies
+            if ((Buffer.isBuffer(body) || typeof body === 'string') && !headers['Content-Length'] && !headers['content-length'])
+            {
+                headers['Content-Length'] = String(Buffer.isBuffer(body) ? body.length : Buffer.byteLength(body));
+            }
+
+            const options = { method, headers };
+            if (opts.agent) options.agent = opts.agent;
+
+            const req = lib.request(u, options, (res) =>
+            {
+                const chunks = [];
+                let downloaded = 0;
+                const total = parseInt(res.headers['content-length'] || '0', 10) || null;
+
+                res.on('data', (c) =>
+                {
+                    chunks.push(c);
+                    downloaded += c.length;
+                    if (typeof opts.onDownloadProgress === 'function')
+                    {
+                        try { opts.onDownloadProgress({ loaded: downloaded, total }); } catch (e) { }
+                    }
+                });
+
+                res.on('end', () =>
+                {
+                    const buf = Buffer.concat(chunks);
+                    const status = res.statusCode;
+                    const rawHeaders = res.headers || {};
+                    const responseHeaders = {
+                        get(name)
+                        {
+                            if (!name) return undefined;
+                            const v = rawHeaders[name.toLowerCase()];
+                            return Array.isArray(v) ? v.join(', ') : v;
+                        },
+                        raw: rawHeaders,
+                    };
+
+                    resolve({
+                        status,
+                        statusText: STATUS_CODES[status] || '',
+                        ok: status >= 200 && status < 300,
+                        headers: responseHeaders,
+                        arrayBuffer: () => Promise.resolve(buf),
+                        text: () => Promise.resolve(buf.toString('utf8')),
+                        json: () =>
+                        {
+                            try { return Promise.resolve(JSON.parse(buf.toString('utf8'))); }
+                            catch (e) { return Promise.reject(e); }
+                        },
+                    });
+                });
+            });
+
+            req.on('error', reject);
+
+            // Timeout
+            if (typeof opts.timeout === 'number' && opts.timeout > 0)
+            {
+                req.setTimeout(opts.timeout, () =>
+                {
+                    const err = new Error('Request timed out');
+                    err.code = 'ETIMEOUT';
+                    req.destroy(err);
+                });
+            }
+
+            // AbortSignal support
+            let abortHandler;
+            if (opts.signal)
+            {
+                if (opts.signal.aborted)
+                {
+                    const err = new Error('Request aborted');
+                    err.name = 'AbortError';
+                    req.destroy(err);
+                    return;
+                }
+                abortHandler = () =>
+                {
+                    const err = new Error('Request aborted');
+                    err.name = 'AbortError';
+                    req.destroy(err);
+                };
+                if (typeof opts.signal.addEventListener === 'function') opts.signal.addEventListener('abort', abortHandler);
+                else if (typeof opts.signal.on === 'function') opts.signal.on('abort', abortHandler);
+            }
+
+            // Cleanup signal listener
+            const cleanup = () =>
+            {
+                if (opts.signal && abortHandler)
+                {
+                    try
+                    {
+                        if (typeof opts.signal.removeEventListener === 'function') opts.signal.removeEventListener('abort', abortHandler);
+                        else if (typeof opts.signal.off === 'function') opts.signal.off('abort', abortHandler);
+                    }
+                    catch (e) { }
+                }
+            };
+            req.on('close', cleanup);
+
+            // Write body
+            if (body && typeof body.pipe === 'function')
+            {
+                let uploaded = 0;
+                body.on('data', (chunk) =>
+                {
+                    uploaded += chunk.length;
+                    if (typeof opts.onUploadProgress === 'function')
+                    {
+                        try { opts.onUploadProgress({ loaded: uploaded, total: headers['Content-Length'] ? Number(headers['Content-Length']) : null }); } catch (e) { }
+                    }
+                });
+                body.on('error', (err) => req.destroy(err));
+                body.pipe(req);
+            }
+            else if (Buffer.isBuffer(body) || typeof body === 'string')
+            {
+                const buf = Buffer.isBuffer(body) ? body : Buffer.from(body);
+                const total = buf.length;
+                const CHUNK = 64 * 1024;
+                let sent = 0;
+
+                function writeNext()
+                {
+                    if (sent >= total) { req.end(); return; }
+                    const slice = buf.slice(sent, Math.min(sent + CHUNK, total));
+                    const ok = req.write(slice, () =>
+                    {
+                        sent += slice.length;
+                        if (typeof opts.onUploadProgress === 'function')
+                        {
+                            try { opts.onUploadProgress({ loaded: sent, total }); } catch (e) { }
+                        }
+                        writeNext();
+                    });
+                    if (!ok) req.once('drain', writeNext);
+                }
+                writeNext();
+            }
+            else if (body == null)
+            {
+                req.end();
+            }
+            else
+            {
+                req.write(String(body));
+                req.end();
+            }
+        }
+        catch (e) { reject(e); }
+    });
+}
+
+module.exports = miniFetch;

package/lib/logger.js

@@ -0,0 +1,68 @@
+/**
+ * Simple request-logging middleware.
+ * Logs method, url, status code, and response time.
+ *
+ * @param {object}  [opts]
+ * @param {function} [opts.logger]   - Custom log function (default: console.log).
+ * @param {boolean}  [opts.colors]   - Colorize output (default: true when TTY).
+ * @param {string}   [opts.format]   - 'tiny' | 'short' | 'dev' (default: 'dev').
+ * @returns {function} Middleware function.
+ */
+function logger(opts = {})
+{
+    const log = typeof opts.logger === 'function' ? opts.logger : console.log;
+    const useColors = opts.colors !== undefined ? opts.colors : (process.stdout.isTTY || false);
+    const format = opts.format || 'dev';
+
+    // ANSI color helpers
+    const c = {
+        reset: useColors ? '\x1b[0m' : '',
+        green: useColors ? '\x1b[32m' : '',
+        yellow: useColors ? '\x1b[33m' : '',
+        red: useColors ? '\x1b[31m' : '',
+        cyan: useColors ? '\x1b[36m' : '',
+        dim: useColors ? '\x1b[2m' : '',
+    };
+
+    function statusColor(code)
+    {
+        if (code >= 500) return c.red;
+        if (code >= 400) return c.yellow;
+        if (code >= 300) return c.cyan;
+        return c.green;
+    }
+
+    return (req, res, next) =>
+    {
+        const start = Date.now();
+
+        // Hook into the raw response 'finish' event
+        const raw = res.raw;
+        const onFinish = () =>
+        {
+            raw.removeListener('finish', onFinish);
+            const ms = Date.now() - start;
+            const status = raw.statusCode || res._status;
+            const sc = statusColor(status);
+
+            if (format === 'tiny')
+            {
+                log(`${req.method} ${req.url} ${status} - ${ms}ms`);
+            }
+            else if (format === 'short')
+            {
+                log(`${req.ip || '-'} ${req.method} ${req.url} ${sc}${status}${c.reset} ${ms}ms`);
+            }
+            else
+            {
+                // dev format
+                log(`  ${c.dim}${req.method}${c.reset} ${req.url} ${sc}${status}${c.reset} ${c.dim}${ms}ms${c.reset}`);
+            }
+        };
+        raw.on('finish', onFinish);
+
+        next();
+    };
+}
+
+module.exports = logger;