mock-config-server 1.0.1

package/README.md

@@ -0,0 +1,213 @@
+# 🎉 Mock Config Server
+
+tool that easily and quickly imitates server operation, create full fake api in few steps
+
+## Install
+
+Install with [npm](https://www.npmjs.com/) or [yarn](https://yarnpkg.com/)
+
+```bash
+$ npm i mock-config-server --save --dev
+# or
+$ yarn add mock-config-server --dev
+```
+
+## 🦉 Philosophy
+
+**🎉 Mock Config Server** it is a tool that, easily, quickly simulates the work of a server. The main difference from solutions such as [json-server](https://www.npmjs.com/package/json-server) and [mock-service-worker](https://mswjs.io/) is the ease of filling in data and flexible emulation of any and usual cases. Our goal is to create a simple and flexible system for users, with the help of which they can create, test, and support their products.
+
+## Features
+
+- **TypeScript support out of the box** - full typed package
+- **Full Rest Api support** - using simple configs of a certain format, you can easily simulate the operation of servers
+- **CORS setup** - turn on and off CORS, fully customizable when CORS is turned on
+- **Support for any kind of static** - server can return any type of static file if needed. Images, HTML, CSS, JSON, etc
+
+## Usage
+
+Install **🎉 Mock Config Server** with [npm](https://www.npmjs.com/) or [yarn](https://yarnpkg.com/)
+
+```bash
+$ npm i mock-config-server --save --dev
+# or
+$ yarn add mock-config-server --dev
+```
+
+Create a `mock-server.config.js` file with server configuration
+
+```javascript
+/** @type {import('mock-config-server').Mock.ServerConfig} */
+const mockServerConfig: Mock.ServerConfig = {
+  configs: [
+    {
+      path: '/user',
+      method: 'get',
+      routes: [{ data: { emoji: '🦁', name: 'Nursultan' } }]
+    }
+  ]
+};
+
+module.exports = mockServerConfig;
+```
+
+Start **🎉 Mock Config Server**
+
+```bash
+$ mock-config-server
+
+# 🎉 Mock Config Server is running at http://localhost:31299
+```
+
+## 🎭 Parameters for mock-server.config.(js|ts)
+
+- `configs` {Array<RequestConfig>} configs for mock requests, [read](#configs)
+- `staticPath?` {StaticPath} entity for working with static files, [read](#static-path)
+- `interceptors?` {Interceptors} functions to change request or response parameters, [read](#interceptors)
+- `cors?` {Cors} CORS settings object (default: `CORS is turn off`), [read](#cors)
+- `port?` {number} server port (default: `31299`)
+- `baseUrl?` {string} part of the url that will be substituted at the beginning of the request url (default: `'/'`)
+
+### Configs
+
+Configs are the fundamental part of the mock server. These configs are easy to fill and maintain. Config entities is an object with which you can emulate various application behaviors. You can specify `headers` | `query` | `params` | `body` to define what contract data you need to get. Using this mechanism, you can easily simulate the operation of the server and emulate various cases
+
+##### request config
+
+- `path` {string | RegExp} request path
+- `method` {GET | POST | DELETE | PUT | PATCH} rest api method
+- `routes` {RouteConfig} request routes
+- `interceptors?` {Interceptors} functions to change request or response parameters, [read](#interceptors)
+
+##### route config
+
+- `data` {any} mock data of request
+- `entities?` Object<headers | query | params | body> object that helps in data retrieval
+- `interceptors?` {Interceptors} functions to change request or response parameters, [read](#interceptors)
+
+##### entities
+
+```typescript
+interface Entities {
+  headers?: { [string]: string | number };
+  query?: { [string]: string | number };
+  params?: { [string]: string | number };
+  body?: any;
+}
+```
+
+##### Example
+
+```javascript
+/** @type {import('mock-config-server').MockServerConfig} */
+const mockServerConfig = {
+  configs: [
+    {
+      path: '/user',
+      method: 'get',
+      routes: [
+        {
+          entities: {
+            headers: { 'name-header': 'Nursultan' }
+          },
+          data: { emoji: '🦁', name: 'Nursultan' }
+        },
+        {
+          entities: {
+            headers: { 'name-header': 'Dmitriy' }
+          },
+          data: { emoji: '☄', name: 'Dmitriy' }
+        }
+      ]
+    }
+  ]
+};
+
+module.exports = mockServerConfig;
+```
+
+Now you can make a request with an additional header and get the desired result
+
+```javascript
+fetch('http://localhost:31299/user', {
+  headers: { 'name-header': 'Nursultan' }
+})
+  .then((response) => response.json())
+  .then((data) => console.log(data)); // {  emoji: '🦁', name: 'Nursultan' }
+```
+
+#### Static Path
+
+Entity for connecting statics to the server, like HTML, JSON, PNG, etc.
+
+- `string` path to your static files
+- `Object<{prefix, path}`
+  - `prefix` {string} path prefix for request
+  - `path` {string} path to your static files
+- `Array<string | Object<{prefix, path}>>`
+
+#### Cors
+
+Object with settings for [CORS](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS). You can flexibly configure the required origin, methods, headers, credentials, maxAge for the entire server. If you do not specify `CORS` settings, then it will be disabled.
+
+- `origin` {string | RegExp | Array<string | RegExp> | Function | Promise } available origins from which requests can be made
+- `methods?` {Array<GET | POST | DELETE | PUT | PATCH>} available methods (default: `*`)
+- `headers?` {Array<string>} available methods (default: `*`)
+- `credentials?` {boolean} param tells browsers whether to expose the response to the frontend JavaScript code (default: `true`)
+- `maxAge?` {number} how long the results can be cached (default: `3600`)
+
+#### Interceptors
+
+Functions to change request or response parameters
+
+- `request?` (params) => void
+- `response?` (data, params) => any
+
+##### Request
+
+- `params`
+  - `request` request object
+
+##### Response
+
+- `data` {any} mock data of request
+- `params`
+  - `request` request object
+  - `response` response object
+  - `setDelay` (delay) => Promise<void>
+    - `delay` {number} seconds of delay time
+  - `setStatusCode` (statusCode) => void
+    - `statusCode` {number} status code for response
+
+## ✨ Contributors
+
+<table>
+<tr>
+    <td align="center" style="word-wrap: break-word; width: 100.0; height: 100.0">
+        <a href="https://github.com/debabin">
+            <img src="https://avatars.githubusercontent.com/u/45297354?v=4"
+            width="100;"  
+            alt="debabin" />
+            <br />
+            <sub style="font-size:13px"><b>☄️ debabin</b></sub>
+        </a>
+    </td>
+    <td align="center" style="word-wrap: break-word; width: 100.0; height: 100.0">
+        <a href="https://github.com/MiaInturi">
+            <img src="https://avatars.githubusercontent.com/u/39031929?v=4"
+            width="100;"  
+            alt="MiaInturi" />
+            <br />
+            <sub style="font-size:13px"><b>👹 MiaInturi</b></sub>
+        </a>
+    </td> 
+      <td align="center" style="word-wrap: break-word; width: 100.0; height: 100.0">
+        <a href="https://github.com/RiceWithMeat">
+            <img src="https://avatars.githubusercontent.com/u/47690223?v=4"
+            width="100;"  
+            alt="RiceWithMeat" />
+            <br />
+            <sub style="font-size:13px"><b>🐘 RiceWithMeat</b></sub>
+        </a>
+    </td> 
+  </tr>
+</table>

package/dist/bin/mock-config-server.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin/mock-config-server.js

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const esbuild_1 = require("esbuild");
+const fs = __importStar(require("fs"));
+const src_1 = require("../src");
+const resolveExportsFromSourceCode_1 = require("./resolveExportsFromSourceCode");
+const start = async () => {
+    try {
+        const appPath = process.cwd();
+        const mockServerConfigFileRegex = /mock-server.config.(?:ts|js)/;
+        const mockServerConfigFile = fs
+            .readdirSync(appPath)
+            .find((file) => mockServerConfigFileRegex.test(file));
+        if (!mockServerConfigFile) {
+            throw new Error('Cannot find config file mock-server.config.(ts|js)');
+        }
+        const { outputFiles } = await (0, esbuild_1.build)({
+            entryPoints: [mockServerConfigFile],
+            bundle: true,
+            platform: 'node',
+            target: 'esnext',
+            minifySyntax: true,
+            minify: true,
+            write: false,
+            metafile: false
+        });
+        const mockServerConfigSourceCode = outputFiles[0]?.text;
+        if (!mockServerConfigSourceCode) {
+            throw new Error('Cannot handle source code of mock-server.config.(ts|js)');
+        }
+        const mockServerConfigExports = (0, resolveExportsFromSourceCode_1.resolveExportsFromSourceCode)(mockServerConfigSourceCode);
+        if (!mockServerConfigExports?.default) {
+            throw new Error('Cannot handle exports of mock-server.config.(ts|js)');
+        }
+        (0, src_1.startMockServer)(mockServerConfigExports.default);
+    }
+    catch (e) {
+        console.error(e.message);
+    }
+};
+start();

package/dist/bin/resolveExportsFromSourceCode.d.ts

@@ -0,0 +1 @@
+export declare const resolveExportsFromSourceCode: (sourceCode: string) => any;

package/dist/bin/resolveExportsFromSourceCode.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveExportsFromSourceCode = void 0;
+const resolveExportsFromSourceCode = (sourceCode) => {
+    // @ts-ignore
+    const moduleInstance = new module.constructor();
+    // eslint-disable-next-line no-underscore-dangle
+    moduleInstance._compile(sourceCode, '');
+    return moduleInstance.exports;
+};
+exports.resolveExportsFromSourceCode = resolveExportsFromSourceCode;

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from './src';

package/dist/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./src"), exports);

package/dist/jest.config.d.ts

@@ -0,0 +1,3 @@
+export = jestConfig;
+/** @type {import('ts-jest').JestConfigWithTsJest} */
+declare const jestConfig: import('ts-jest').JestConfigWithTsJest;

package/dist/jest.config.js

@@ -0,0 +1,7 @@
+"use strict";
+/** @type {import('ts-jest').JestConfigWithTsJest} */
+const jestConfig = {
+    preset: 'ts-jest',
+    testEnvironment: 'node'
+};
+module.exports = jestConfig;

package/dist/src/configs/isEntitiesEqual/isEntityValuesEqual.d.ts

@@ -0,0 +1,2 @@
+import type { Entities, EntitiesValues } from '../../utils/types';
+export declare const isEntityValuesEqual: <Entity extends Entities>(firstEntityValue: EntitiesValues[Entity], secondEntityValue: EntitiesValues[Entity]) => boolean;

package/dist/src/configs/isEntitiesEqual/isEntityValuesEqual.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEntityValuesEqual = void 0;
+const flat_1 = require("flat");
+const helpers_1 = require("../../utils/helpers");
+const isEntityValuesEqual = (firstEntityValue, secondEntityValue) => {
+    const isValuesArePlainObjects = (0, helpers_1.isPlainObject)(firstEntityValue) && (0, helpers_1.isPlainObject)(secondEntityValue);
+    if (isValuesArePlainObjects) {
+        const flattenFirstEntityValue = (0, flat_1.flatten)(firstEntityValue);
+        const flattenSecondEntityValue = (0, flat_1.flatten)(secondEntityValue);
+        return Object.keys(flattenFirstEntityValue).every((key) => 
+        // ✅ important:
+        // call 'toString' for ignore types of values
+        flattenFirstEntityValue[key].toString() === flattenSecondEntityValue[key]?.toString());
+    }
+    const isValuesAreArrays = Array.isArray(firstEntityValue) && Array.isArray(secondEntityValue);
+    if (isValuesAreArrays) {
+        const flattenFirstEntityValue = (0, flat_1.flatten)(firstEntityValue);
+        const flattenSecondEntityValue = (0, flat_1.flatten)(secondEntityValue);
+        return (Object.keys(flattenFirstEntityValue).length ===
+            Object.keys(flattenSecondEntityValue).length &&
+            Object.keys(flattenFirstEntityValue).every((key) => 
+            // ✅ important:
+            // call 'toString' for ignore types of values
+            flattenFirstEntityValue[key].toString() === flattenSecondEntityValue[key].toString()));
+    }
+    return firstEntityValue.toString() === secondEntityValue.toString();
+};
+exports.isEntityValuesEqual = isEntityValuesEqual;

package/dist/src/configs/isEntitiesEqual/isEntityValuesEqual.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/configs/isEntitiesEqual/isEntityValuesEqual.test.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const isEntityValuesEqual_1 = require("./isEntityValuesEqual");
+describe('isEntityValuesEqual', () => {
+    test('Primitive values should compare independent of their types', () => {
+        expect((0, isEntityValuesEqual_1.isEntityValuesEqual)(13, '13')).toBe(true);
+        expect((0, isEntityValuesEqual_1.isEntityValuesEqual)(true, 'true')).toBe(true);
+    });
+    test('Arrays should be full equal with nested objects (independent of primitive values types)', () => {
+        expect((0, isEntityValuesEqual_1.isEntityValuesEqual)([1, 2, 3], ['1', '2', '3'])).toBe(true);
+        expect((0, isEntityValuesEqual_1.isEntityValuesEqual)([{ key1: 'value1', key2: 'value2' }], [{ key2: 'value2', key1: 'value1' }])).toBe(true);
+        expect((0, isEntityValuesEqual_1.isEntityValuesEqual)([{ key1: 'value1', key2: 'value2' }], [{ key1: 'value1', key2: 'value2', key3: 'value3' }])).toBe(false);
+        expect((0, isEntityValuesEqual_1.isEntityValuesEqual)([{ key1: 'value1', key2: { nestedKey1: 'nestedValue1' } }], [{ key1: 'value1', key2: { nestedKey1: 'nestedValue1' } }])).toBe(true);
+        expect((0, isEntityValuesEqual_1.isEntityValuesEqual)([{ key1: 'value1', key2: { nestedKey1: 'nestedValue1' } }], [{ key1: 'value1', key2: { nestedKey1: 'nestedValue1', nestedKey2: 'nestedValue2' } }])).toBe(false);
+    });
+    test('Plain objects should compare by "second includes first" with nested objects', () => {
+        expect((0, isEntityValuesEqual_1.isEntityValuesEqual)({ key1: 'value1', key2: 'value2' }, { key1: 'value1', key2: 'value2', key3: 'value3' })).toBe(true);
+        expect((0, isEntityValuesEqual_1.isEntityValuesEqual)({ key1: 'value1', key2: 'value2', key3: 'value3' }, { key1: 'value1', key2: 'value2' })).toBe(false);
+        expect((0, isEntityValuesEqual_1.isEntityValuesEqual)({ key1: 'value1', key2: { nestedKey1: 'nestedValue1' } }, {
+            key1: 'value1',
+            key2: { nestedKey1: 'nestedValue1', nestedKey2: 'nestedValue2' },
+            key3: 'value3'
+        })).toBe(true);
+    });
+});

package/dist/src/configs/prepareRequestConfigs/prepareRequestConfigs.d.ts

@@ -0,0 +1,2 @@
+import type { RequestConfig } from '../../utils/types';
+export declare const prepareRequestConfigs: (requestConfigs: RequestConfig[]) => RequestConfig[];

package/dist/src/configs/prepareRequestConfigs/prepareRequestConfigs.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareRequestConfigs = void 0;
+const helpers_1 = require("../../utils/helpers");
+const calculateRouteConfigWeight = (routeConfig) => {
+    const { entities } = routeConfig;
+    if (!entities)
+        return 0;
+    let routeConfigWeight = 0;
+    const { headers, query, params, body } = entities;
+    if (headers)
+        routeConfigWeight += Object.keys(headers).length;
+    if (query)
+        routeConfigWeight += Object.keys(query).length;
+    if (params)
+        routeConfigWeight += Object.keys(params).length;
+    if (body)
+        routeConfigWeight += (0, helpers_1.isPlainObject)(body) ? Object.keys(body).length : 1;
+    return routeConfigWeight;
+};
+const prepareRequestConfigs = (requestConfigs) => {
+    requestConfigs.forEach((requestConfig) => {
+        requestConfig.routes.sort((first, second) => 
+        // ✅ important:
+        // Lift more specific configs for correct working of routes
+        calculateRouteConfigWeight(second) - calculateRouteConfigWeight(first));
+    });
+    return requestConfigs;
+};
+exports.prepareRequestConfigs = prepareRequestConfigs;

package/dist/src/configs/prepareRequestConfigs/prepareRequestConfigs.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/configs/prepareRequestConfigs/prepareRequestConfigs.test.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const prepareRequestConfigs_1 = require("./prepareRequestConfigs");
+describe('prepareRequestConfigs', () => {
+    test('Should not sort routes if they does not contain entities', () => {
+        const requestConfigs = [
+            {
+                path: '/user',
+                method: 'get',
+                routes: [
+                    {
+                        data: { name: 'John', surname: 'Doe' }
+                    },
+                    {
+                        data: { name: 'John', surname: 'Smith' }
+                    },
+                    {
+                        data: { name: 'John', surname: 'John' }
+                    }
+                ]
+            }
+        ];
+        expect((0, prepareRequestConfigs_1.prepareRequestConfigs)(requestConfigs)).toStrictEqual(requestConfigs);
+    });
+    test('Should sort routes by their specificity of entities', () => {
+        const requestConfigs = [
+            {
+                path: '/user',
+                method: 'get',
+                routes: [
+                    {
+                        entities: {
+                            headers: {
+                                header1: 'value'
+                            }
+                        },
+                        data: { name: 'John', surname: 'Doe' }
+                    },
+                    {
+                        entities: {
+                            headers: {
+                                header1: 'value',
+                                header2: 'value'
+                            }
+                        },
+                        data: { name: 'John', surname: 'Doe' }
+                    },
+                    {
+                        entities: {
+                            headers: {
+                                header1: 'value'
+                            },
+                            query: {
+                                query1: 'value',
+                                query2: 'value'
+                            }
+                        },
+                        data: { name: 'John', surname: 'Doe' }
+                    }
+                ]
+            }
+        ];
+        const expectedRequestConfigs = [
+            {
+                path: '/user',
+                method: 'get',
+                routes: [
+                    {
+                        entities: {
+                            headers: {
+                                header1: 'value'
+                            },
+                            query: {
+                                query1: 'value',
+                                query2: 'value'
+                            }
+                        },
+                        data: { name: 'John', surname: 'Doe' }
+                    },
+                    {
+                        entities: {
+                            headers: {
+                                header1: 'value',
+                                header2: 'value'
+                            }
+                        },
+                        data: { name: 'John', surname: 'Doe' }
+                    },
+                    {
+                        entities: {
+                            headers: {
+                                header1: 'value'
+                            }
+                        },
+                        data: { name: 'John', surname: 'Doe' }
+                    }
+                ]
+            }
+        ];
+        expect((0, prepareRequestConfigs_1.prepareRequestConfigs)(requestConfigs)).toStrictEqual(expectedRequestConfigs);
+    });
+    test('Should set not object body weight equals to one', () => {
+        const requestConfigs = [
+            {
+                path: '/user',
+                method: 'post',
+                routes: [
+                    {
+                        entities: {
+                            body: ['value', 'value', 'value']
+                        },
+                        data: { name: 'John', surname: 'Doe' }
+                    },
+                    {
+                        entities: {
+                            headers: {
+                                header1: 'value',
+                                header2: 'value'
+                            }
+                        },
+                        data: { name: 'John', surname: 'Doe' }
+                    }
+                ]
+            }
+        ];
+        const expectedRequestConfigs = [
+            {
+                path: '/user',
+                method: 'post',
+                routes: [
+                    {
+                        entities: {
+                            headers: {
+                                header1: 'value',
+                                header2: 'value'
+                            }
+                        },
+                        data: { name: 'John', surname: 'Doe' }
+                    },
+                    {
+                        entities: {
+                            body: ['value', 'value', 'value']
+                        },
+                        data: { name: 'John', surname: 'Doe' }
+                    }
+                ]
+            }
+        ];
+        expect((0, prepareRequestConfigs_1.prepareRequestConfigs)(requestConfigs)).toStrictEqual(expectedRequestConfigs);
+    });
+});

package/dist/src/cors/corsMiddleware/corsMiddleware.d.ts

@@ -0,0 +1,3 @@
+import type { Express } from 'express';
+import type { Cors } from '../../utils/types';
+export declare const corsMiddleware: (server: Express, cors: Cors) => Promise<void>;

package/dist/src/cors/corsMiddleware/corsMiddleware.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.corsMiddleware = void 0;
+const constants_1 = require("../../utils/constants");
+const getAllowedOrigins_1 = require("../getOrigins/getAllowedOrigins");
+const corsMiddleware = async (server, cors) => {
+    server.use(async (req, res, next) => {
+        if (Array.isArray(cors.origin) && !cors.origin.length) {
+            return next();
+        }
+        const allowedOrigins = await (0, getAllowedOrigins_1.getAllowedOrigins)(cors.origin);
+        const { origin } = req.headers;
+        if (!allowedOrigins?.length || !origin) {
+            return next();
+        }
+        const isAllowedOrigin = allowedOrigins.some((allowedOrigin) => {
+            if (typeof allowedOrigin === 'string') {
+                return allowedOrigin.includes(origin);
+            }
+            return allowedOrigin.test(origin);
+        });
+        if (isAllowedOrigin) {
+            res.setHeader('Access-Control-Allow-Origin', origin);
+            res.setHeader('Access-Control-Allow-Methods', cors.methods ?? constants_1.DEFAULT.CORS.METHODS);
+            res.setHeader('Access-Control-Allow-Headers', cors.headers ?? constants_1.DEFAULT.CORS.HEADERS);
+            res.setHeader('Access-Control-Allow-Credentials', `${cors.credentials ?? constants_1.DEFAULT.CORS.CREDENTIALS}`);
+            res.setHeader('Access-Control-Max-Age', cors.maxAge ?? constants_1.DEFAULT.CORS.MAX_AGE);
+        }
+        next();
+    });
+};
+exports.corsMiddleware = corsMiddleware;

package/dist/src/cors/corsMiddleware/corsMiddleware.test.d.ts

@@ -0,0 +1 @@
+export {};