wooks 0.0.1-beta.4 → 0.0.1-beta.6

package/dist/wooks.cjs.prod.js

@@ -10,6 +10,7 @@ var fs = require('fs');
 var path = require('path');
 var url = require('url');
 var net = require('net');
+var nodeFetchNative = require('node-fetch-native');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e["default"] : e; }
 
@@ -18,8 +19,15 @@ var path__default = /*#__PURE__*/_interopDefaultLegacy(path);
 
 const banner = () => `[wooks][${new Date().toISOString().replace('T', ' ').replace(/\.\d{3}z$/i, '')}] `;
 
-function panic(error) {
+function warn(text) {
+    console.warn('' + banner() + text + '');
+}
+function logError(error) {
     console.error('' + '' + banner() + error + '');
+}
+
+function panic(error) {
+    logError(error);
     return new Error(error);
 }
 
@@ -195,6 +203,9 @@ class BaseWooksResponseRenderer {
         if (typeof response.body === 'undefined') {
             return '';
         }
+        if (response.body instanceof Uint8Array) {
+            return response.body;
+        }
         if (typeof response.body === 'object') {
             if (!response.getContentType())
                 response.setContentType(contentTypes.application.json);
@@ -232,11 +243,10 @@ function useRequest() {
         return reqCache.reqId;
     }
     function getIp(options) {
-        var _a, _b, _c;
-        if (options === null || options === void 0 ? void 0 : options.trustProxy) {
+        if (options?.trustProxy) {
             if (typeof reqCache.forwardedIp !== 'string') {
                 if (typeof req.headers[xForwardedFor] === 'string' && req.headers[xForwardedFor]) {
-                    reqCache.forwardedIp = (_a = req.headers[xForwardedFor].split(',').shift()) === null || _a === void 0 ? void 0 : _a.trim();
+                    reqCache.forwardedIp = req.headers[xForwardedFor].split(',').shift()?.trim();
                 }
                 else {
                     return getIp();
@@ -246,16 +256,15 @@ function useRequest() {
         }
         else {
             if (typeof reqCache.remoteIp !== 'string') {
-                reqCache.remoteIp = ((_b = req.socket) === null || _b === void 0 ? void 0 : _b.remoteAddress) || ((_c = req.connection) === null || _c === void 0 ? void 0 : _c.remoteAddress) || '';
+                reqCache.remoteIp = req.socket?.remoteAddress || req.connection?.remoteAddress || '';
             }
             return reqCache.remoteIp;
         }
     }
     function getIpList() {
-        var _a, _b;
         if (!reqCache.ipList) {
             reqCache.ipList = {
-                remoteIp: ((_a = req.socket) === null || _a === void 0 ? void 0 : _a.remoteAddress) || ((_b = req.connection) === null || _b === void 0 ? void 0 : _b.remoteAddress) || '',
+                remoteIp: req.socket?.remoteAddress || req.connection?.remoteAddress || '',
                 forwarded: (req.headers[xForwardedFor] || '').split(',').map(s => s.trim()),
             };
         }
@@ -318,10 +327,10 @@ function useSetHeaders() {
         delete cache[name];
     }
     function setContentType(value) {
-        setHeader('Content-Type', value);
+        setHeader('content-type', value);
     }
     function enableCors(origin = '*') {
-        setHeader('Access-Control-Allow-Origin', origin);
+        setHeader('access-control-allow-origin', origin);
     }
     return {
         setHeader,
@@ -378,13 +387,13 @@ function useAuthorization() {
         authorization,
         authType,
         authRawCredentials,
-        isBasic: () => { var _a; return ((_a = authType()) === null || _a === void 0 ? void 0 : _a.toLocaleLowerCase()) === 'basic'; },
-        isBearer: () => { var _a; return ((_a = authType()) === null || _a === void 0 ? void 0 : _a.toLocaleLowerCase()) === 'bearer'; },
+        isBasic: () => authType()?.toLocaleLowerCase() === 'basic',
+        isBearer: () => authType()?.toLocaleLowerCase() === 'bearer',
         basicCredentials: () => {
             if (authorization) {
                 if (typeof cache.basicCredentials === 'undefined') {
                     const type = authType();
-                    if ((type === null || type === void 0 ? void 0 : type.toLocaleLowerCase()) === 'basic') {
+                    if (type?.toLocaleLowerCase() === 'basic') {
                         const creds = Buffer.from(authRawCredentials() || '', 'base64').toString('ascii');
                         const [username, password] = creds.split(':');
                         cache.basicCredentials = { username, password };
@@ -455,16 +464,16 @@ const renderPragmaNoCache = (v) => v ? 'no-cache' : '';
 function useSetCacheControl() {
     const { setHeader } = useSetHeaders();
     const setAge = (value) => {
-        setHeader('Age', renderAge(value));
+        setHeader('age', renderAge(value));
     };
     const setExpires = (value) => {
-        setHeader('Expires', renderExpires(value));
+        setHeader('expires', renderExpires(value));
     };
     const setPragmaNoCache = (value = true) => {
-        setHeader('Pragma', renderPragmaNoCache(value));
+        setHeader('pragma', renderPragmaNoCache(value));
     };
     const setCacheControl = (data) => {
-        setHeader('Cache-Control', renderCacheControl(data));
+        setHeader('cache-control', renderCacheControl(data));
     };
     return {
         setExpires,
@@ -825,12 +834,12 @@ function useRespCookie(name) {
         attrs: {},
     };
     Object.defineProperty(hook, 'value', {
-        get: () => { var _a; return (_a = getCookie(name)) === null || _a === void 0 ? void 0 : _a.value; },
-        set: (value) => { var _a; return setCookie(name, value, (_a = getCookie(name)) === null || _a === void 0 ? void 0 : _a.attrs); },
+        get: () => getCookie(name)?.value,
+        set: (value) => setCookie(name, value, getCookie(name)?.attrs),
     });
     Object.defineProperty(hook, 'attrs', {
-        get: () => { var _a; return (_a = getCookie(name)) === null || _a === void 0 ? void 0 : _a.attrs; },
-        set: (attrs) => { var _a; return setCookie(name, ((_a = getCookie(name)) === null || _a === void 0 ? void 0 : _a.value) || '', attrs); },
+        get: () => getCookie(name)?.attrs,
+        set: (attrs) => setCookie(name, getCookie(name)?.value || '', attrs),
     });
     return hook;
 }
@@ -861,6 +870,135 @@ function useStatus() {
     return hook;
 }
 
+class IterableRecords {
+    [Symbol.iterator]() {
+        return this;
+    }
+    index = 0;
+    next() {
+        return { value: undefined, done: true };
+    }
+}
+class CookiesIterable extends IterableRecords {
+    cookies;
+    constructor(cookiesString) {
+        super();
+        this.cookies = cookiesString.split(/,\s(?!\d{2}[\s-])/);
+    }
+    next() {
+        const str = this.cookies[this.index++];
+        const ind = str ? str.indexOf('=') : 0;
+        return this.index <= this.cookies.length ?
+            { value: [str.slice(0, ind), str.slice(ind + 1)], done: false } :
+            { value: undefined, done: true };
+    }
+}
+class HeadersIterable extends IterableRecords {
+    entries;
+    constructor(headers) {
+        super();
+        this.entries = Object.entries(headers);
+    }
+    next() {
+        return this.index < this.entries.length ?
+            { value: this.entries[this.index++], done: false } :
+            { value: undefined, done: true };
+    }
+}
+function applyProxyControls(records, controls, additionalBlockers) {
+    let result = {};
+    const { allow, block, overwrite } = controls;
+    const defaultedAllow = allow || '*';
+    if (defaultedAllow) {
+        for (const [name, value] of records) {
+            const add = block !== '*' && (defaultedAllow === '*' ||
+                (defaultedAllow.find(item => typeof item === 'string' && name.toLowerCase() === item.toLowerCase() || item instanceof RegExp && item.test(name)))) && (!block || !block.find(item => typeof item === 'string' && name.toLowerCase() === item.toLowerCase() || item instanceof RegExp && item.test(name))) && (!additionalBlockers || !additionalBlockers.includes(name));
+            if (add) {
+                result[name] = value;
+            }
+        }
+    }
+    if (overwrite) {
+        if (typeof overwrite === 'function') {
+            result = overwrite(result);
+        }
+        else {
+            result = { ...result, ...overwrite };
+        }
+    }
+    return result;
+}
+
+const reqHeadersToBlock = [
+    'connection',
+    'accept-encoding',
+    'content-length',
+    'upgrade-insecure-requests',
+    'cookie',
+];
+const resHeadersToBlock = [
+    'transfer-encoding',
+    'content-encoding',
+    'set-cookie',
+];
+function useProxy() {
+    const status = useStatus();
+    const { setHeader, headers: setHeadersObject } = useSetHeaders();
+    const { req } = useCurrentWooksContext().getCtx();
+    return async function proxy(target, opts) {
+        const targetUrl = new URL(target);
+        const path = targetUrl.pathname || '/';
+        const url = new URL(path, targetUrl.origin).toString() + (targetUrl.search);
+        const modifiedHeaders = { ...req.headers, host: targetUrl.hostname };
+        const headers = opts?.reqHeaders ? applyProxyControls(new HeadersIterable(modifiedHeaders), opts?.reqHeaders, reqHeadersToBlock) : {};
+        const cookies = opts?.reqCookies && req.headers.cookie ? applyProxyControls(new CookiesIterable(req.headers.cookie), opts?.reqCookies) : null;
+        if (cookies) {
+            headers.cookie = Object.entries(cookies).map(v => v.join('=')).join('; ');
+        }
+        const method = opts?.method || req.method;
+        if (opts?.debug) {
+            console.log();
+            warn(`[proxy] ${''}${req.method} ${req.url}${''} → ${''}${method} ${url}${''}`);
+            console.log('' + 'headers:', JSON.stringify(headers, null, '  '), '');
+        }
+        const resp = await nodeFetchNative.fetch(url, {
+            method,
+            body: ['GET', 'HEAD'].includes(method) ? undefined : req,
+            headers: headers,
+        });
+        status.value = resp.status;
+        if (opts?.debug) {
+            console.log();
+            warn(`[proxy] ${resp.status} ${''}${req.method} ${req.url}${''} → ${''}${method} ${url}${''}`);
+            console.log(`${''}response headers:${''}`);
+        }
+        const resHeaders = opts?.resHeaders ? applyProxyControls(resp.headers.entries(), opts?.resHeaders, resHeadersToBlock) : null;
+        const resCookies = opts?.resCookies ? applyProxyControls(new CookiesIterable(resp.headers.get('set-cookie') || ''), opts?.resCookies) : null;
+        if (resHeaders) {
+            for (const [name, value] of Object.entries(resHeaders)) {
+                if (name) {
+                    setHeader(name, value);
+                    if (opts?.debug) {
+                        console.log(`\t${''}${name}=${''}${value}${''}`);
+                    }
+                }
+            }
+        }
+        if (resCookies) {
+            setHeadersObject['set-cookie'] = (setHeadersObject['set-cookie'] || []);
+            for (const [name, value] of Object.entries(resCookies)) {
+                if (name) {
+                    setHeadersObject['set-cookie'].push(`${name}=${value}`);
+                    if (opts?.debug) {
+                        console.log(`\t${''}${''}set-cookie=${''}${name}=${value}${''}`);
+                    }
+                }
+            }
+        }
+        return resp;
+    };
+}
+
 const httpStatusCodes = {
     [100]: 'Continue',
     [101]: 'Switching protocols',
@@ -1001,12 +1139,15 @@ const defaultStatus = {
     DELETE: exports.EHttpStatusCode.Accepted,
 };
 const baseRenderer = new BaseWooksResponseRenderer();
+const FetchResponse = Response;
 class BaseWooksResponse {
+    renderer;
     constructor(renderer = baseRenderer) {
         this.renderer = renderer;
-        this._status = 0;
-        this._headers = {};
     }
+    _status = 0;
+    _body;
+    _headers = {};
     get status() {
         return this._status;
     }
@@ -1028,10 +1169,10 @@ class BaseWooksResponse {
         return this;
     }
     getContentType() {
-        return this._headers['Content-Type'];
+        return this._headers['content-type'];
     }
     setContentType(value) {
-        this._headers['Content-Type'] = value;
+        this._headers['content-type'] = value;
         return this;
     }
     enableCors(origin = '*') {
@@ -1039,15 +1180,15 @@ class BaseWooksResponse {
         return this;
     }
     setCookie(name, value, attrs) {
-        const cookies = this._headers['Set-Cookie'] = (this._headers['Set-Cookie'] || []);
+        const cookies = this._headers['set-cookie'] = (this._headers['set-cookie'] || []);
         cookies.push(renderCookie(name, { value, attrs: attrs || {} }));
         return this;
     }
     setCacheControl(data) {
-        this.setHeader('Cache-Control', renderCacheControl(data));
+        this.setHeader('cache-control', renderCacheControl(data));
     }
     setCookieRaw(rawValue) {
-        const cookies = this._headers['Set-Cookie'] = (this._headers['Set-Cookie'] || []);
+        const cookies = this._headers['set-cookie'] = (this._headers['set-cookie'] || []);
         cookies.push(rawValue);
         return this;
     }
@@ -1064,17 +1205,18 @@ class BaseWooksResponse {
     mergeHeaders() {
         const { headers } = useSetHeaders();
         const { cookies, removeCookie } = useSetCookies();
-        const newCookies = (this._headers['Set-Cookie'] || []);
+        const newCookies = (this._headers['set-cookie'] || []);
         for (const cookie of newCookies) {
             removeCookie(cookie.slice(0, cookie.indexOf('=')));
         }
         this._headers = {
+            server: `Wooks v${"0.0.1-beta.5"}`,
             ...headers,
             ...this._headers,
         };
         const setCookie = [...newCookies, ...cookies()];
         if (setCookie && setCookie.length) {
-            this._headers['Set-Cookie'] = setCookie;
+            this._headers['set-cookie'] = setCookie;
         }
         return this;
     }
@@ -1118,15 +1260,36 @@ class BaseWooksResponse {
                 stream.pipe(res);
             }
         }
+        else if (this.body instanceof FetchResponse) {
+            this.mergeStatus('ok');
+            if (method === 'HEAD') {
+                res.end();
+            }
+            else {
+                void respondWithFetch(this.body.body, res);
+            }
+        }
         else {
             const renderedBody = this.renderer.render(this);
             this.mergeStatus(renderedBody);
             res.writeHead(this.status, {
-                'Content-Length': Buffer.byteLength(renderedBody),
+                'content-length': Buffer.byteLength(renderedBody),
                 ...this._headers,
             }).end(method !== 'HEAD' ? renderedBody : '');
         }
     }
+}
+async function respondWithFetch(fetchBody, res) {
+    if (fetchBody) {
+        try {
+            for await (const chunk of fetchBody) {
+                res.write(chunk);
+            }
+        }
+        catch (e) {
+        }
+    }
+    res.end();
 }
 
 const preStyles = 'font-family: monospace;'
@@ -1146,7 +1309,7 @@ class WooksErrorRenderer extends BaseWooksResponseRenderer {
             `<head><title>${data.statusCode} ${httpStatusCodes[data.statusCode]}</title></head>` +
             `<body><center><h1>${data.statusCode} ${httpStatusCodes[data.statusCode]}</h1></center>` +
             `<center><h4>${data.message}</h1></center><hr color="#666">` +
-            `<center style="color: #666;"> wooks v${"0.0.1-beta.3"} </center>` +
+            `<center style="color: #666;"> Wooks v${"0.0.1-beta.5"} </center>` +
             `${keys.length ? `<pre style="${preStyles}">${JSON.stringify({ ...data, statusCode: undefined, message: undefined, error: undefined }, null, '  ')}</pre>` : ''}` +
             '</body></html>';
     }
@@ -1167,9 +1330,8 @@ class WooksErrorRenderer extends BaseWooksResponseRenderer {
             + `${keys.length ? (',' + keys.map(k => `"${escapeQuotes(k)}":${JSON.stringify(data[k])}`).join(',')) : ''}}`;
     }
     render(response) {
-        var _a;
         const { acceptsJson, acceptsText, acceptsHtml } = useAccept();
-        response.status = ((_a = response.body) === null || _a === void 0 ? void 0 : _a.statusCode) || 500;
+        response.status = response.body?.statusCode || 500;
         if (acceptsJson()) {
             return this.renderJson(response);
         }
@@ -1189,6 +1351,8 @@ function escapeQuotes(s) {
 }
 
 class WooksError extends Error {
+    code;
+    _body;
     constructor(code = 500, _body = '') {
         super(typeof _body === 'string' ? _body : _body.message);
         this.code = code;
@@ -1206,6 +1370,7 @@ class WooksError extends Error {
             error: httpStatusCodes[this.code],
         };
     }
+    renderer;
     attachRenderer(renderer) {
         this.renderer = renderer;
     }
@@ -1239,6 +1404,10 @@ function createResponseFrom(data) {
 }
 
 class Wooks {
+    options;
+    router;
+    server;
+    _uncoughtExceptionHandler;
     constructor(options) {
         this.options = options;
         this.router = new router.ProstoRouter();
@@ -1251,22 +1420,20 @@ class Wooks {
     }
     listen(port, hostname, cb) {
         return new Promise((resolve, reject) => {
-            var _a;
             const myCb = () => {
-                var _a;
                 const fn = typeof hostname === 'function' ? hostname : cb;
                 process.on('uncaughtException', this._uncoughtExceptionHandler);
                 if (fn) {
                     fn();
                 }
-                (_a = this.server) === null || _a === void 0 ? void 0 : _a.off('error', reject);
+                this.server?.off('error', reject);
                 resolve();
             };
             try {
                 this.server = createServer({
                     port,
                 }, this.processRequest.bind(this), typeof hostname === 'string' ? hostname : '', myCb);
-                (_a = this.server) === null || _a === void 0 ? void 0 : _a.on('error', reject);
+                this.server?.on('error', reject);
             }
             catch (e) {
                 reject(e);
@@ -1275,8 +1442,7 @@ class Wooks {
     }
     close() {
         return new Promise((resolve, reject) => {
-            var _a;
-            (_a = this.server) === null || _a === void 0 ? void 0 : _a.close((err) => {
+            this.server?.close((err) => {
                 if (err)
                     return reject(err);
                 process.off('uncaughtException', this._uncoughtExceptionHandler);
@@ -1285,11 +1451,10 @@ class Wooks {
         });
     }
     processRequest(req, res) {
-        var _a;
         const found = this.router.lookup(req.method, req.url);
         const ctx = {
             __setHeader: {
-                Server: 'wooks v' + "0.0.1-beta.3",
+                Server: 'wooks v' + "0.0.1-beta.5",
             },
         };
         if (found) {
@@ -1298,22 +1463,20 @@ class Wooks {
             const { restoreCtx } = useCurrentWooksContext();
             this.processHandlers(req, res, found)
                 .catch((e) => {
-                var _a;
                 this.printError('Internal error, please report: ', e);
                 restoreCtx();
-                (_a = createResponseFrom(e)) === null || _a === void 0 ? void 0 : _a.respond();
+                createResponseFrom(e)?.respond();
                 clearCurrentWooksContext();
                 console.error('' + '' + banner(), e, '');
             });
         }
         else {
             setCurrentWooksContext(req, res, {}, ctx);
-            (_a = createResponseFrom(new WooksError(404))) === null || _a === void 0 ? void 0 : _a.respond();
+            createResponseFrom(new WooksError(404))?.respond();
             clearCurrentWooksContext();
         }
     }
     async processHandlers(req, res, found) {
-        var _a, _b;
         const { restoreCtx } = useCurrentWooksContext();
         for (const [i, handler] of found.route.handlers.entries()) {
             const isLastHandler = found.route.handlers.length === i + 1;
@@ -1323,7 +1486,7 @@ class Wooks {
                 clearCurrentWooksContext();
                 const result = await promise;
                 restoreCtx();
-                (_a = createResponseFrom(result)) === null || _a === void 0 ? void 0 : _a.respond();
+                createResponseFrom(result)?.respond();
                 clearCurrentWooksContext();
                 break;
             }
@@ -1331,7 +1494,7 @@ class Wooks {
                 this.printError('Uncought route handler exception: ' + (req.url || '') + '\n', e);
                 if (isLastHandler) {
                     restoreCtx();
-                    (_b = createResponseFrom(e)) === null || _b === void 0 ? void 0 : _b.respond();
+                    createResponseFrom(e)?.respond();
                     clearCurrentWooksContext();
                 }
             }
@@ -2587,7 +2750,7 @@ async function serveFile(filePath, options = {}) {
         return '';
     }
     setHeader('etag', etag);
-    setHeader('Last-Modified', lastModified.toUTCString());
+    setHeader('last-modified', lastModified.toUTCString());
     if (options.cacheControl !== undefined) {
         setCacheControl(options.cacheControl);
     }
@@ -2604,7 +2767,7 @@ async function serveFile(filePath, options = {}) {
         }
         else if (options.index) {
             if (filePath[filePath.length - 1] !== '/' && url && url[url.length - 1] !== '/') {
-                return new BaseWooksResponse().setStatus(302).setHeader('Location', url + '/');
+                return new BaseWooksResponse().setStatus(302).setHeader('location', url + '/');
             }
             restoreCtx();
             return serveFile(path__default.join(filePath, options.index), {
@@ -2613,7 +2776,7 @@ async function serveFile(filePath, options = {}) {
             });
         }
         removeHeader('etag');
-        removeHeader('Last-Modified');
+        removeHeader('last-modified');
         throw new WooksError(404);
     }
     let range = headers.range;
@@ -2638,13 +2801,13 @@ async function serveFile(filePath, options = {}) {
             range = '';
         }
         else {
-            setHeader('Content-Range', `bytes ${start}-${end}/${fileStats.size}`);
+            setHeader('content-range', `bytes ${start}-${end}/${fileStats.size}`);
             status(206);
         }
     }
-    setHeader('Accept-Ranges', 'bytes');
-    setHeader('Content-Type', getMimeType(normalizedPath) || 'application/octet-stream');
-    setHeader('Content-Length', size);
+    setHeader('accept-ranges', 'bytes');
+    setHeader('content-type', getMimeType(normalizedPath) || 'application/octet-stream');
+    setHeader('content-length', size);
     if (options.headers) {
         for (const header of Object.keys(options.headers)) {
             setHeader(header, options.headers[header]);
@@ -2722,6 +2885,7 @@ exports.useCacheObject = useCacheObject;
 exports.useCookies = useCookies;
 exports.useCurrentWooksContext = useCurrentWooksContext;
 exports.useHeaders = useHeaders;
+exports.useProxy = useProxy;
 exports.useRequest = useRequest;
 exports.useRespCookie = useRespCookie;
 exports.useRespHeader = useRespHeader;

package/dist/wooks.d.ts

@@ -35,12 +35,12 @@ export declare class BaseWooksResponse<BodyType = unknown> {
     setHeader(name: string, value: string): this;
     getHeader(name: string): string | string[];
     protected mergeHeaders(): this;
-    protected mergeStatus(renderedBody: string): this;
+    protected mergeStatus(renderedBody: string | Uint8Array): this;
     respond(): void;
 }
 
 export declare class BaseWooksResponseRenderer<T = unknown> implements TWooksResponseRenderer<T> {
-    render(response: BaseWooksResponse<T>): string;
+    render(response: BaseWooksResponse<T>): string | Uint8Array;
 }
 
 export declare function clearCacheObject(name: symbol | string): void;
@@ -423,8 +423,23 @@ export declare interface TWooksHook<T = string> {
 export declare interface TWooksOptions {
 }
 
+export declare interface TWooksProxyControls {
+    overwrite?: Record<string, string> | ((data: Record<string, string>) => Record<string, string>);
+    allow?: (string | RegExp)[] | '*';
+    block?: (string | RegExp)[] | '*';
+}
+
+export declare interface TWooksProxyOptions {
+    method?: string;
+    reqHeaders?: TWooksProxyControls;
+    reqCookies?: TWooksProxyControls;
+    resHeaders?: TWooksProxyControls;
+    resCookies?: TWooksProxyControls;
+    debug?: boolean;
+}
+
 export declare interface TWooksResponseRenderer<T = unknown> {
-    render: (response: BaseWooksResponse<T>) => string;
+    render: (response: BaseWooksResponse<T>) => string | Uint8Array;
 }
 
 export declare function useAccept(): {
@@ -476,6 +491,8 @@ export declare function useCurrentWooksContext(): {
 
 export declare function useHeaders(): IncomingHttpHeaders;
 
+export declare function useProxy(): (target: string, opts?: TWooksProxyOptions) => Promise<Response>;
+
 export declare function useRequest(): {
     rawRequest: IncomingMessage;
     url: string | undefined;
@@ -533,7 +550,7 @@ export declare function useSetHeaders(): {
     setHeader: (name: string, value: string | number) => void;
     removeHeader: (name: string) => void;
     setContentType: (value: string) => void;
-    headers: Record<string, string>;
+    headers: Record<string, string | string[]>;
     enableCors: (origin?: string) => void;
 };