barehttp 1.0.0 → 2.1.0

package/lib/server.d.ts

@@ -0,0 +1,154 @@
+import { ServerOptions } from 'ws';
+import { Ajv } from 'ajv';
+import { BareRequest, CacheOpts } from './request.js';
+import { CookiesManagerOptions } from './middlewares/cookies/cookie-manager.js';
+import { HttpMethodsUnion, StatusCodesUnion } from './utils/index.js';
+import { CorsOptions } from './middlewares/cors/cors.js';
+import { WebSocketServer } from './websocket.js';
+import { Server } from 'http';
+type Middleware = (flow: BareRequest) => Promise<void> | void;
+type Handler<H extends {
+    [key: string]: string | undefined;
+}> = (flow: BareRequest<H>) => any;
+type ErrorHandler = (err: any, flow: BareRequest, status?: StatusCodesUnion) => void;
+type IP = `${number}.${number}.${number}.${number}`;
+type RouteOpts<C> = {
+    disableCache?: C extends true ? C : undefined;
+    cache?: C extends true ? undefined : CacheOpts;
+    /**
+     * Request timeout handler in `ms`
+     */
+    timeout?: number;
+    builtInRuntime?: {
+        output?: boolean;
+    };
+    middlewares?: Array<Middleware>;
+};
+type BareOptions<A extends IP> = {
+    /**
+     * Declare a global middlewares array
+     * Default: []
+     */
+    middlewares?: Array<Middleware>;
+    /**
+     * Opt-out request body parsing (de-serialization)
+     * Default `false`
+     */
+    doNotParseBody?: boolean;
+    /**
+     * Opt-in to have a custom swagger per route generation
+     * Default `false`
+     */
+    /**
+     * Opt-in to have a custom runtime JSON Schema checker per routes
+     * Default `false`
+     */
+    enableSchemaValidation?: boolean;
+    serverPort?: number;
+    declaredRoutesPaths?: Array<string>;
+    /**
+     * Address to bind the web server to
+     * Default '0.0.0.0'
+     */
+    serverAddress?: A | 'localhost';
+    setRandomPort?: boolean;
+    /**
+     * Enable request context storage
+     * Default `false`
+     */
+    context?: boolean;
+    /**
+     * Enable request/response predefined logging
+     * Default `false`
+     */
+    logging?: boolean;
+    errorHandlerMiddleware?: ErrorHandler;
+    /**
+     * Request time format in `seconds` or `milliseconds`
+     * Default - disabled
+     */
+    requestTimeFormat?: 's' | 'ms';
+    /**
+     * Control over cookies.
+     * This will enable automatic cookies decoding
+     */
+    cookies?: boolean;
+    cookiesOptions?: CookiesManagerOptions;
+    /**
+     * Log the resolved reverse DNS first hop for remote ip of the client (first proxy)
+     */
+    reverseDns?: boolean;
+    /**
+     * WebSocket server exposure
+     */
+    ws?: boolean;
+    wsOptions?: Omit<ServerOptions, 'host' | 'port' | 'server' | 'noServer'> & {
+        closeHandler?: (server: WebSocketServer) => Promise<void>;
+    };
+    /**
+     * Enable Cors
+     */
+    cors?: boolean | CorsOptions;
+};
+type ExtractRouteParams<T extends string> = T extends `${string}:${infer Param}/${infer Rest}` ? {
+    [K in Param | keyof ExtractRouteParams<Rest>]: string;
+} : T extends `${string}:${infer Param}` ? {
+    [K in Param]: string;
+} : {
+    [k: string]: string;
+};
+interface HandlerExposed<K> {
+    <R extends `/${string}`, C>(setUp: K extends 'declare' ? {
+        route: R;
+        options?: RouteOpts<C>;
+        handler: Handler<ExtractRouteParams<R>>;
+        methods: Array<HttpMethodsUnion>;
+    } : {
+        route: R;
+        options?: RouteOpts<C>;
+        handler: Handler<ExtractRouteParams<R>>;
+    }): BareServer<any> & Routes;
+}
+export type RouteReport = {
+    hits: number;
+    success: number;
+    fails: number;
+};
+export type Routes = {
+    [K in HttpMethodsUnion | 'declare']: HandlerExposed<K>;
+};
+export type BareHttpType<A extends IP = any> = BareServer<A> & Routes;
+export declare class BareServer<A extends IP> {
+    #private;
+    private bareOptions;
+    server: Server;
+    ws?: WebSocketServer;
+    ajv?: Ajv;
+    route: Readonly<Routes>;
+    constructor(bareOptions?: BareOptions<A>);
+    private applyLaunchOptions;
+    private applyMiddlewares;
+    /**
+     * This handler is used in async generated middlewares runtime function
+     */
+    private resolveMiddleware;
+    private setRoute;
+    private handleRoute;
+    private resolveResponse;
+    private encodeRoute;
+    private explodeRoute;
+    private basicErrorHandler;
+    private stopWs;
+    private attachGracefulHandlers;
+    private attachRoutesDeclarator;
+    get runtimeRoute(): Readonly<Routes>;
+    start(cb?: (address: string) => void): Promise<void>;
+    stop(cb?: (e?: Error) => void): Promise<void>;
+    loadRoutesSchemas(): void;
+    use(middleware: Middleware): this;
+    getMiddlewares(): Middleware[];
+    setCustomErrorHandler(eh: ErrorHandler): void;
+    getServerPort(): number;
+    getRoutes(): string[];
+}
+export { BareServer as BareHttp };

package/lib/server.js

@@ -0,0 +1,396 @@
+import Router from 'find-my-way';
+import { Ajv } from 'ajv';
+import { BareRequest } from './request.js';
+import { logMe } from './logger/index.js';
+import { context, enableContext, newContext } from './context/index.js';
+import { HttpMethods, } from './utils/index.js';
+import { Cors } from './middlewares/cors/cors.js';
+import { WebSocketServer } from './websocket.js';
+import { generateRouteSchema } from './schemas/generator.js';
+import dns from 'dns';
+import { createServer } from 'http';
+export class BareServer {
+    bareOptions;
+    server;
+    ws;
+    ajv;
+    route = {};
+    #middlewares = [];
+    #routes = new Map();
+    #routesLib = new Map();
+    #router = Router({ ignoreTrailingSlash: true });
+    #errorHandler = this.basicErrorHandler;
+    #corsInstance;
+    #port = 3000;
+    #host = '0.0.0.0';
+    #globalMiddlewaresRun = (_) => _;
+    #routeMiddlewaresStore = new Map();
+    #routeRuntimeSchemas = new Map();
+    constructor(bareOptions = {}) {
+        this.bareOptions = bareOptions;
+        // init
+        this.server = createServer(this.#listener.bind(this));
+        this.attachGracefulHandlers();
+        this.attachRoutesDeclarator();
+        this.applyLaunchOptions();
+        this.loadRoutesSchemas();
+        return this;
+    }
+    #listener = (request, response) => {
+        const flow = new BareRequest(request, response, this.bareOptions);
+        // init and attach request uuid to the context
+        if (this.bareOptions.context) {
+            newContext('request');
+            context.current?.store.set('id', flow.ID.code);
+        }
+        // execute global middlewares on the request
+        this.applyMiddlewares(flow)
+            .catch((e) => {
+            this.#errorHandler(e, flow, 400);
+        })
+            .then(() => {
+            // if middlewares sent the response back, stop here
+            if (flow.sent)
+                return;
+            this.#router.lookup(flow._originalRequest, flow._originalResponse);
+        });
+    };
+    /**
+     * This function generates previously defined middlewares for the sequential execution
+     */
+    #writeMiddlewares = () => {
+        const lines = [];
+        let order = 0;
+        const maxOrder = this.#middlewares.length;
+        const AsyncFunction = Object.getPrototypeOf(async function () { }).constructor;
+        if (maxOrder > 0) {
+            while (order <= maxOrder - 1) {
+                lines.push(`if (flow.sent) return;`);
+                lines.push(`await this.resolveMiddleware(flow, ${order});`);
+                order++;
+            }
+        }
+        const text = lines.join('\n');
+        this.#globalMiddlewaresRun = new AsyncFunction('flow', text);
+    };
+    applyLaunchOptions = () => {
+        const { bareOptions: bo } = this;
+        if (bo.setRandomPort) {
+            this.#port = undefined;
+        }
+        else {
+            this.#port = +(bo.serverPort || process.env.PORT || 3000);
+        }
+        this.#host = typeof bo.serverAddress === 'string' ? bo.serverAddress : '0.0.0.0';
+        // context setting
+        if (bo.context)
+            enableContext();
+        // ws attachment
+        if (bo.ws) {
+            this.ws = new WebSocketServer(this.server, bo.wsOptions);
+        }
+        // middlewares settings
+        if (bo.errorHandlerMiddleware) {
+            this.#errorHandler = bo.errorHandlerMiddleware;
+        }
+        if (this.bareOptions.cors) {
+            const corsOpts = typeof this.bareOptions.cors === 'object' ? this.bareOptions.cors : {};
+            this.#corsInstance = new Cors(corsOpts);
+        }
+        this.#middlewares.push(...(bo.middlewares || []));
+    };
+    async applyMiddlewares(flow) {
+        if (this.bareOptions.cors) {
+            this.resolveMiddleware(flow, 0, this.#corsInstance?.corsMiddleware.bind(this.#corsInstance));
+        }
+        if (this.bareOptions.doNotParseBody !== true) {
+            // invoke body stream consumption
+            await flow['readBody']();
+        }
+        // attach cookies middleware
+        if (this.bareOptions.cookies) {
+            flow['attachCookieManager'](this.bareOptions.cookiesOptions);
+            flow['populateCookies']();
+        }
+        // to test in cloud provider
+        // this should resolve the name of the first hop from the dns chain
+        if (this.bareOptions.reverseDns) {
+            const remoteClient = await dns.promises.reverse(flow.remoteIp);
+            flow['setRemoteClient'](remoteClient[0]);
+        }
+        if (this.#middlewares.length)
+            await this.#globalMiddlewaresRun(flow);
+    }
+    /**
+     * This handler is used in async generated middlewares runtime function
+     */
+    async resolveMiddleware(flow, order, middleware) {
+        try {
+            const toExecute = middleware || this.#middlewares[order];
+            const response = toExecute(flow);
+            if (response instanceof Promise)
+                await response;
+        }
+        catch (e) {
+            this.#errorHandler(e, flow);
+        }
+    }
+    setRoute(method, route, isRuntime, handler, opts) {
+        const encode = this.encodeRoute(method, route);
+        const handleFn = (req, _, routeParams) => {
+            this.handleRoute(req, checkParams(routeParams), handler, opts);
+        };
+        this.#routesLib.set(encode, handleFn);
+        if (isRuntime) {
+            this.#router.reset();
+            this.#routesLib.forEach((handlerFn, route) => {
+                const [m, r] = this.explodeRoute(route);
+                this.#router.on(m, r, handlerFn);
+            });
+        }
+        else {
+            this.#router.on(method, route, handleFn);
+        }
+    }
+    handleRoute(req, routeParams, handle, routeOpts) {
+        const flow = req.flow;
+        if (!flow) {
+            throw new Error(`No flow been found to route this request, theres a sync mistake in the server.`); // should NEVER happen
+        }
+        // populate with route params
+        if (routeParams)
+            flow['setParams'](routeParams);
+        // apply possible route options
+        if (routeOpts) {
+            if (routeOpts.disableCache)
+                flow.disableCache();
+            if (routeOpts.cache)
+                flow.setCache(routeOpts.cache);
+            if (routeOpts.timeout)
+                flow['attachTimeout'](routeOpts.timeout);
+        }
+        // TODO: implement per route middlewares!
+        try {
+            const routeReturn = handle(flow);
+            if (flow.sent)
+                return;
+            if (routeReturn instanceof Promise) {
+                routeReturn
+                    .then((result) => this.resolveResponse(flow, result, req.url, req.method?.toLowerCase(), routeOpts?.builtInRuntime?.output))
+                    .catch((e) => {
+                    this.#errorHandler(e, flow);
+                });
+                return;
+            }
+            this.resolveResponse(flow, routeReturn, req.url, req.method?.toLowerCase(), routeOpts?.builtInRuntime?.output);
+        }
+        catch (e) {
+            this.#errorHandler(e, flow);
+        }
+    }
+    resolveResponse(flow, response, url, method, builtInRuntime) {
+        if (!builtInRuntime || !method || !url) {
+            flow.send(response);
+            return;
+        }
+        const schema = this.#routeRuntimeSchemas.get(`${method}-${url}`);
+        const check = schema?.compiled(response);
+        if ((schema && check) || !schema)
+            flow.send(response);
+        else {
+            logMe.error('Response schema error!', {
+                method,
+                url,
+                errors: schema?.compiled.errors,
+                received: response,
+            });
+            flow
+                .status(500)
+                .send({ message: `Response schema error, please communicate to server administrator.` });
+        }
+    }
+    encodeRoute(method, route) {
+        if (route.endsWith('/'))
+            route = route.slice(0, -1);
+        return `${method}?${route}`;
+    }
+    explodeRoute(route) {
+        return route.split('?');
+    }
+    basicErrorHandler(e, flow, status) {
+        flow.status(status ?? 500).json({ ...e, message: e.message, stack: e.stack });
+    }
+    async stopWs() {
+        if (!this.ws)
+            return;
+        if (this.bareOptions.wsOptions?.closeHandler) {
+            await this.bareOptions.wsOptions.closeHandler(this.ws);
+        }
+        this.ws._internal.close();
+    }
+    attachGracefulHandlers() {
+        const graceful = async (code = 0) => {
+            await this.stop();
+            process.exit(code);
+        };
+        // Stop graceful
+        process.on('uncaughtException', (err) => {
+            console.error(err);
+            graceful(1);
+        });
+        process.on('unhandledRejection', (err) => {
+            console.error(err);
+        });
+        process.on('SIGTERM', () => graceful(0));
+        process.on('SIGINT', () => graceful(0));
+    }
+    attachRoutesDeclarator() {
+        for (const method of [...Object.keys(HttpMethods), 'declare']) {
+            this.route[method] = (routeSetUp) => {
+                checkRouteSetUp(routeSetUp, method);
+                if (method === 'declare') {
+                    for (const m of new Set(routeSetUp.methods))
+                        this.setRoute(HttpMethods[m], routeSetUp.route, false, routeSetUp.handler, routeSetUp.options);
+                }
+                else {
+                    this.setRoute(HttpMethods[method], routeSetUp.route, false, routeSetUp.handler, routeSetUp.options);
+                }
+                return this;
+            };
+        }
+    }
+    // ========= PUBLIC APIS ==========
+    // TODO: add working options setter
+    // setOption<B extends BareOptions<any>, O extends keyof B>(option: O, arg: B[O]) {
+    //   throw new Error('Not implemented')
+    // }
+    get runtimeRoute() {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const self = this;
+        return new Proxy({}, {
+            get(_, key) {
+                if (typeof key === 'symbol')
+                    return this;
+                if (!self.server?.listening) {
+                    console.warn('Runtime route declaration can be done only while the server is running. Follow documentation for more details');
+                    return this;
+                }
+                if ([...Object.keys(HttpMethods), 'declare'].includes(key)) {
+                    return (routeSetUp) => {
+                        checkRouteSetUp(routeSetUp, key);
+                        if (key === 'declare') {
+                            for (const m of new Set(routeSetUp.methods))
+                                self.setRoute(HttpMethods[m], routeSetUp.route, true, routeSetUp.handler, routeSetUp.options);
+                        }
+                        else {
+                            self.setRoute(HttpMethods[key], routeSetUp.route, true, routeSetUp.handler, routeSetUp.options);
+                        }
+                        return this;
+                    };
+                }
+                return this;
+            },
+        });
+    }
+    start(cb) {
+        this.#writeMiddlewares();
+        this.ws?.['_start']();
+        return new Promise((res) => 
+        // https://nodejs.org/api/net.html#net_server_listen_port_host_backlog_callback
+        this.server.listen(this.#port, this.#host, undefined, () => {
+            cb?.(`http://0.0.0.0:${this.#port}`);
+            res();
+        }));
+    }
+    async stop(cb) {
+        // TODO: to solve problem announcing to clients the disconnect
+        // for (const flow of this.#flows.values()) {
+        //   if (!flow.sent) {
+        //     flow.status(500);
+        //     flow.send('Server terminated');
+        //   }
+        // }
+        if (!this.ws)
+            await this.stopWs();
+        if (!this.server?.listening)
+            return;
+        await new Promise((res, rej) => {
+            this.server.close((e) => {
+                if (e) {
+                    rej(e);
+                    cb?.(e);
+                }
+                else {
+                    cb?.();
+                    res();
+                }
+            });
+        });
+    }
+    loadRoutesSchemas() {
+        if (!this.bareOptions.enableSchemaValidation) {
+            return;
+        }
+        if (this.bareOptions.declaredRoutesPaths?.length) {
+            this.ajv = new Ajv({ strict: true });
+            for (const path of this.bareOptions.declaredRoutesPaths) {
+                const schemas = generateRouteSchema(path);
+                for (const schema of schemas) {
+                    this.#routeRuntimeSchemas.set(`${schema.methodName}-${schema.route}`, {
+                        raw: schema.jsonSchema,
+                        compiled: this.ajv.compile(schema.jsonSchema),
+                    });
+                }
+            }
+        }
+    }
+    use(middleware) {
+        this.#middlewares.push(middleware);
+        return this;
+    }
+    getMiddlewares() {
+        return this.#middlewares;
+    }
+    setCustomErrorHandler(eh) {
+        this.#errorHandler = eh;
+    }
+    getServerPort() {
+        return this.server.address().port;
+    }
+    getRoutes() {
+        return [...this.#routes.keys()];
+    }
+}
+function checkRouteSetUp(routeSetUp, key) {
+    if (typeof routeSetUp.route !== 'string') {
+        throw new TypeError(`A route path for the method ${key} is not a a string`);
+    }
+    else if (routeSetUp.route[0] !== '/') {
+        throw new SyntaxError(`A route path should start with '/' for route ${routeSetUp.route} for method ${key}`);
+    }
+    else if (routeSetUp.route[1] === '/') {
+        throw new SyntaxError(`Declared route ${routeSetUp.route} for method ${key} is not correct, review the syntax`);
+    }
+    else if (typeof routeSetUp.handler !== 'function') {
+        throw new TypeError(`Handler for the route ${routeSetUp.route} for method ${key} is not a function`);
+    }
+    else if (routeSetUp.options?.timeout &&
+        typeof routeSetUp.options.timeout !== 'number' &&
+        !Number.isFinite(routeSetUp.options.timeout)) {
+        throw new TypeError(`Only numeric values are valid per-route timeout, submitted ${routeSetUp.options.timeout}`);
+    }
+}
+function checkParams(params) {
+    if (!params || Object.keys(params).length === 0)
+        return params;
+    for (const [param, value] of Object.entries(params)) {
+        if (value === undefined)
+            continue;
+        if (/(\.\/)(\.\.)(\\.)/.test(decodeURI(value))) {
+            logMe.warn(`Param ${param} value ${value} was redacted because contained dangerous characters`);
+            param[param] = 'REDACTED';
+        }
+    }
+    return params;
+}
+export { BareServer as BareHttp };

package/lib/utils/content-type.d.ts

@@ -0,0 +1,54 @@
+export declare const ContentType: {
+    readonly 'application/EDI-X12': "application/EDI-X12";
+    readonly 'application/EDIFACT': "application/EDIFACT";
+    readonly 'application/javascript': "application/javascript";
+    readonly 'application/octet-stream': "application/octet-stream";
+    readonly 'application/ogg': "application/ogg";
+    readonly 'application/pdf': "application/pdf";
+    readonly 'application/xhtml+xml': "application/xhtml+xml";
+    readonly 'application/x-shockwave-flash': "application/x-shockwave-flash";
+    readonly 'application/json': "application/json";
+    readonly 'application/ld+json': "application/ld+json";
+    readonly 'application/xml': "application/xml";
+    readonly 'application/zip': "application/zip";
+    readonly 'application/x-www-form-urlencoded': "application/x-www-form-urlencoded";
+    readonly 'audio/mpeg': "audio/mpeg";
+    readonly 'audio/x-ms-wma': "audio/x-ms-wma";
+    readonly 'audio/vnd.rn-realaudio': "audio/vnd.rn-realaudio";
+    readonly 'audio/x-wav': "audio/x-wav";
+    readonly 'image/gif': "image/gif";
+    readonly 'image/jpeg': "image/jpeg";
+    readonly 'image/png': "image/png";
+    readonly 'image/tiff': "image/tiff";
+    readonly 'image/vnd.microsoft.icon': "image/vnd.microsoft.icon";
+    readonly 'image/x-icon': "image/x-icon";
+    readonly 'image/vnd.djvu': "image/vnd.djvu";
+    readonly 'image/svg+xml': "image/svg+xml";
+    readonly 'multipart/mixed': "multipart/mixed";
+    readonly 'multipart/alternative': "multipart/alternative";
+    readonly 'multipart/related': "multipart/related";
+    readonly 'multipart/form-data': "multipart/form-data";
+    readonly 'text/css': "text/css";
+    readonly 'text/csv': "text/csv";
+    readonly 'text/html': "text/html";
+    readonly 'text/plain': "text/plain";
+    readonly 'text/xml': "text/xml";
+    readonly 'video/mpeg': "video/mpeg";
+    readonly 'video/mp4': "video/mp4";
+    readonly 'video/quicktime': "video/quicktime";
+    readonly 'video/x-ms-wmv': "video/x-ms-wmv";
+    readonly 'video/x-msvideo': "video/x-msvideo";
+    readonly 'video/x-flv': "video/x-flv";
+    readonly 'video/webm': "video/webm";
+    readonly 'application/vnd.oasis.opendocument.text': "application/vnd.oasis.opendocument.text";
+    readonly 'application/vnd.oasis.opendocument.spreadsheet': "application/vnd.oasis.opendocument.spreadsheet";
+    readonly 'application/vnd.oasis.opendocument.presentation': "application/vnd.oasis.opendocument.presentation";
+    readonly 'application/vnd.oasis.opendocument.graphics': "application/vnd.oasis.opendocument.graphics";
+    readonly 'application/vnd.ms-excel': "application/vnd.ms-excel";
+    readonly 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet': "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
+    readonly 'application/vnd.ms-powerpoint': "application/vnd.ms-powerpoint";
+    readonly 'application/vnd.openxmlformats-officedocument.presentationml.presentation': "application/vnd.openxmlformats-officedocument.presentationml.presentation";
+    readonly 'application/msword': "application/msword";
+    readonly 'application/vnd.openxmlformats-officedocument.wordprocessingml.document': "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
+    readonly 'application/vnd.mozilla.xul+xml': "application/vnd.mozilla.xul+xml";
+};

package/lib/utils/content-type.js

@@ -0,0 +1,54 @@
+export const ContentType = {
+    'application/EDI-X12': 'application/EDI-X12',
+    'application/EDIFACT': 'application/EDIFACT',
+    'application/javascript': 'application/javascript',
+    'application/octet-stream': 'application/octet-stream',
+    'application/ogg': 'application/ogg',
+    'application/pdf': 'application/pdf',
+    'application/xhtml+xml': 'application/xhtml+xml',
+    'application/x-shockwave-flash': 'application/x-shockwave-flash',
+    'application/json': 'application/json',
+    'application/ld+json': 'application/ld+json',
+    'application/xml': 'application/xml',
+    'application/zip': 'application/zip',
+    'application/x-www-form-urlencoded': 'application/x-www-form-urlencoded',
+    'audio/mpeg': 'audio/mpeg',
+    'audio/x-ms-wma': 'audio/x-ms-wma',
+    'audio/vnd.rn-realaudio': 'audio/vnd.rn-realaudio',
+    'audio/x-wav': 'audio/x-wav',
+    'image/gif': 'image/gif',
+    'image/jpeg': 'image/jpeg',
+    'image/png': 'image/png',
+    'image/tiff': 'image/tiff',
+    'image/vnd.microsoft.icon': 'image/vnd.microsoft.icon',
+    'image/x-icon': 'image/x-icon',
+    'image/vnd.djvu': 'image/vnd.djvu',
+    'image/svg+xml': 'image/svg+xml',
+    'multipart/mixed': 'multipart/mixed',
+    'multipart/alternative': 'multipart/alternative',
+    'multipart/related': 'multipart/related', // (using by MHTML (HTML mail).)
+    'multipart/form-data': 'multipart/form-data',
+    'text/css': 'text/css',
+    'text/csv': 'text/csv',
+    'text/html': 'text/html',
+    'text/plain': 'text/plain',
+    'text/xml': 'text/xml',
+    'video/mpeg': 'video/mpeg',
+    'video/mp4': 'video/mp4',
+    'video/quicktime': 'video/quicktime',
+    'video/x-ms-wmv': 'video/x-ms-wmv',
+    'video/x-msvideo': 'video/x-msvideo',
+    'video/x-flv': 'video/x-flv',
+    'video/webm': 'video/webm',
+    'application/vnd.oasis.opendocument.text': 'application/vnd.oasis.opendocument.text',
+    'application/vnd.oasis.opendocument.spreadsheet': 'application/vnd.oasis.opendocument.spreadsheet',
+    'application/vnd.oasis.opendocument.presentation': 'application/vnd.oasis.opendocument.presentation',
+    'application/vnd.oasis.opendocument.graphics': 'application/vnd.oasis.opendocument.graphics',
+    'application/vnd.ms-excel': 'application/vnd.ms-excel',
+    'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+    'application/vnd.ms-powerpoint': 'application/vnd.ms-powerpoint',
+    'application/vnd.openxmlformats-officedocument.presentationml.presentation': 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+    'application/msword': 'application/msword',
+    'application/vnd.openxmlformats-officedocument.wordprocessingml.document': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+    'application/vnd.mozilla.xul+xml': 'application/vnd.mozilla.xul+xml',
+};

package/lib/utils/http-methods.d.ts

@@ -0,0 +1,11 @@
+export declare const HttpMethods: {
+    readonly get: "GET";
+    readonly post: "POST";
+    readonly put: "PUT";
+    readonly delete: "DELETE";
+    readonly patch: "PATCH";
+    readonly options: "OPTIONS";
+    readonly head: "HEAD";
+};
+export type HttpMethodsUnion = keyof typeof HttpMethods;
+export type HttpMethodsUnionUppercase = typeof HttpMethods[keyof typeof HttpMethods];

package/lib/utils/http-methods.js

@@ -0,0 +1,9 @@
+export const HttpMethods = {
+    get: 'GET',
+    post: 'POST',
+    put: 'PUT',
+    delete: 'DELETE',
+    patch: 'PATCH',
+    options: 'OPTIONS',
+    head: 'HEAD',
+};

package/lib/utils/index.d.ts

@@ -0,0 +1,4 @@
+export { StatusPhrases } from './status-phrases.js';
+export { StatusCodes, StatusCodesUnion } from './status-codes.js';
+export { HttpMethods, HttpMethodsUnion, HttpMethodsUnionUppercase } from './http-methods.js';
+export { JSONStringify, JSONParse } from './safe-json.js';