tsoa

node_modules/node-mocks-http/lib/headers.js

@@ -0,0 +1,137 @@
+/**
+ * This file implements the Web API Headers interface
+ * (https://developer.mozilla.org/en-US/docs/Web/API/Headers)
+ * while maintaining compatibility with Express.js style header access.
+ */
+const utils = require('./utils');
+
+const REFERER_HEADER_NAMES = ['referer', 'referrer'];
+
+/**
+ * Get a header value from the headers object.
+ * Because headers can be set in multiple ways, their names can be uppercased and lowercased.
+ *
+ * @param {Object} headers
+ * @param {string} name
+ * @returns
+ */
+function getHeaderValue(headers, name) {
+    const lowerName = name.toLowerCase();
+
+    return headers[
+        Object.keys(headers).find((key) => {
+            const lowerKey = key.toLowerCase();
+            return (
+                lowerKey === lowerName ||
+                (REFERER_HEADER_NAMES.includes(lowerKey) && REFERER_HEADER_NAMES.includes(lowerName))
+            );
+        })
+    ];
+}
+
+/**
+ * Creates a Headers object that implements both Express.js style access
+ * and the Web API Headers interface
+ *
+ * @param {Object} headers - Initial headers object
+ * @returns {HeaderWebAPI} - A proxy that implements the HeaderWebAPI interface
+ */
+function createHeaders(headers = {}) {
+    return new Proxy(utils.convertKeysToLowerCase(headers), {
+        get(target, prop) {
+            // Handle Headers interface methods
+            switch (prop) {
+                case 'get':
+                    return (name) => getHeaderValue(target, name);
+                case 'getAll':
+                    return (name) => {
+                        const value = getHeaderValue(target, name);
+                        if (!value) {
+                            return [];
+                        }
+                        return Array.isArray(value) ? value : [value];
+                    };
+                case 'has':
+                    return (name) => getHeaderValue(target, name) !== undefined;
+                case 'set':
+                    return (name, value) => {
+                        // eslint-disable-next-line no-param-reassign
+                        target[name.toLowerCase()] = value;
+                    };
+                case 'append':
+                    return (name, value) => {
+                        const lowerName = name.toLowerCase();
+                        if (lowerName in target) {
+                            const existingValue = target[lowerName];
+                            if (Array.isArray(existingValue)) {
+                                existingValue.push(value);
+                            } else {
+                                // eslint-disable-next-line no-param-reassign
+                                target[lowerName] = [existingValue, value];
+                            }
+                        } else {
+                            // eslint-disable-next-line no-param-reassign
+                            target[lowerName] = value;
+                        }
+                    };
+                case 'delete':
+                    return (name) => {
+                        // eslint-disable-next-line no-param-reassign
+                        delete target[name.toLowerCase()];
+                    };
+                case 'forEach':
+                    return (callback, thisArg) => {
+                        Object.entries(target).forEach(([key, value]) => {
+                            callback.call(thisArg, value, key, target);
+                        });
+                    };
+                case 'entries':
+                    return () => Object.entries(target)[Symbol.iterator]();
+                case 'keys':
+                    return () => Object.keys(target)[Symbol.iterator]();
+                case 'values':
+                    return () => Object.values(target)[Symbol.iterator]();
+                case Symbol.iterator:
+                    return (
+                        target[Symbol.iterator] ||
+                        function* iterator() {
+                            yield* Object.entries(target);
+                        }
+                    );
+                default:
+                    return typeof prop === 'string' ? getHeaderValue(target, prop) : target[prop];
+            }
+        },
+        set(target, prop, value) {
+            if (typeof prop === 'string') {
+                // eslint-disable-next-line no-param-reassign
+                target[prop.toLowerCase()] = value;
+                return true;
+            }
+            return false;
+        },
+        has(target, prop) {
+            if (typeof prop === 'string') {
+                return prop.toLowerCase() in target;
+            }
+            return prop in target;
+        },
+        deleteProperty(target, prop) {
+            if (typeof prop === 'string') {
+                // eslint-disable-next-line no-param-reassign
+                delete target[prop.toLowerCase()];
+                return true;
+            }
+            // eslint-disable-next-line no-param-reassign
+            return delete target[prop];
+        },
+        ownKeys(target) {
+            return Object.keys(target);
+        },
+        getOwnPropertyDescriptor(target, prop) {
+            return Object.getOwnPropertyDescriptor(target, prop);
+        }
+    });
+}
+
+module.exports = { createHeaders, getHeaderValue };