mock-config-server 1.0.1

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

@@ -0,0 +1,86 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = __importDefault(require("express"));
+const supertest_1 = __importDefault(require("supertest"));
+const corsMiddleware_1 = require("./corsMiddleware");
+describe('corsMiddleware', () => {
+    test('Should set default cors for request if does not set custom cors settings', async () => {
+        const server = (0, express_1.default)();
+        const cors = {
+            origin: ['https://test.com', 'https://uncorrectDomain.com']
+        };
+        (0, corsMiddleware_1.corsMiddleware)(server, cors);
+        const response = await (0, supertest_1.default)(server).get('/').set({ origin: 'https://test.com' });
+        expect(response.headers).toMatchObject({
+            'access-control-allow-headers': '*',
+            'access-control-allow-methods': '*',
+            'access-control-allow-origin': 'https://test.com',
+            'access-control-max-age': '3600',
+            'access-control-allow-credentials': 'true'
+        });
+    });
+    test('Should not set cors for request if origin does not match', async () => {
+        const server = (0, express_1.default)();
+        const cors = {
+            origin: 'https://uncorrectDomain.com'
+        };
+        (0, corsMiddleware_1.corsMiddleware)(server, cors);
+        const response = await (0, supertest_1.default)(server).get('/').set({ origin: 'https://test.com' });
+        expect(response.headers).not.toHaveProperty('access-control-allow-headers');
+        expect(response.headers).not.toHaveProperty('access-control-allow-methods');
+        expect(response.headers).not.toHaveProperty('access-control-allow-origin');
+        expect(response.headers).not.toHaveProperty('access-control-max-age');
+        expect(response.headers).not.toHaveProperty('access-control-allow-credentials');
+    });
+    test('Should set allow headers to access-control-allow-headers', async () => {
+        const server = (0, express_1.default)();
+        const cors = {
+            origin: 'https://test.com',
+            headers: ['header1', 'header2']
+        };
+        (0, corsMiddleware_1.corsMiddleware)(server, cors);
+        const response = await (0, supertest_1.default)(server).get('/').set({ origin: 'https://test.com' });
+        expect(response.headers).toMatchObject({
+            'access-control-allow-headers': 'header1, header2'
+        });
+    });
+    test('Should set methods to access-control-allow-methods', async () => {
+        const server = (0, express_1.default)();
+        const cors = {
+            origin: 'https://test.com',
+            methods: ['GET', 'POST']
+        };
+        (0, corsMiddleware_1.corsMiddleware)(server, cors);
+        const response = await (0, supertest_1.default)(server).get('/').set({ origin: 'https://test.com' });
+        expect(response.headers).toMatchObject({
+            'access-control-allow-methods': 'GET, POST'
+        });
+    });
+    test('Should set methods to access-control-allow-credentials', async () => {
+        const server = (0, express_1.default)();
+        const cors = {
+            origin: 'https://test.com',
+            credentials: false
+        };
+        (0, corsMiddleware_1.corsMiddleware)(server, cors);
+        const response = await (0, supertest_1.default)(server).get('/').set({ origin: 'https://test.com' });
+        expect(response.headers).toMatchObject({
+            'access-control-allow-credentials': 'false'
+        });
+    });
+    test('Should set max-age to access-control-max-age', async () => {
+        const server = (0, express_1.default)();
+        const cors = {
+            origin: 'https://test.com',
+            maxAge: 10000
+        };
+        (0, corsMiddleware_1.corsMiddleware)(server, cors);
+        const response = await (0, supertest_1.default)(server).get('/').set({ origin: 'https://test.com' });
+        expect(response.headers).toMatchObject({
+            'access-control-max-age': '10000'
+        });
+    });
+});

package/dist/src/cors/getOrigins/getAllowedOrigins.d.ts

@@ -0,0 +1,2 @@
+import type { Cors } from '../../utils/types';
+export declare const getAllowedOrigins: (origin: Cors['origin']) => Promise<(string | RegExp)[]>;

package/dist/src/cors/getOrigins/getAllowedOrigins.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAllowedOrigins = void 0;
+const getAllowedOrigins = async (origin) => {
+    if (Array.isArray(origin)) {
+        return origin;
+    }
+    if (typeof origin === 'string' || origin instanceof RegExp) {
+        return [origin];
+    }
+    if (typeof origin === 'function') {
+        return (0, exports.getAllowedOrigins)(await origin());
+    }
+    throw new Error('Invalid cors origin format');
+};
+exports.getAllowedOrigins = getAllowedOrigins;

package/dist/src/cors/getOrigins/getAllowedOrigins.test.d.ts

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

package/dist/src/cors/getOrigins/getAllowedOrigins.test.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const getAllowedOrigins_1 = require("./getAllowedOrigins");
+describe('getAllowedOrigins', () => {
+    test('Function should return array if get string or RegExp parameter', async () => {
+        expect((0, getAllowedOrigins_1.getAllowedOrigins)(/origin/g)).resolves.toEqual([/origin/g]);
+        expect((0, getAllowedOrigins_1.getAllowedOrigins)('https://origin.com')).resolves.toEqual(['https://origin.com']);
+    });
+    test('Function should return array if get array parameter', () => {
+        expect((0, getAllowedOrigins_1.getAllowedOrigins)([/origin/g, 'https://origin.com'])).resolves.toEqual([
+            /origin/g,
+            'https://origin.com'
+        ]);
+    });
+    test('Function should return array if get function parameter', () => {
+        expect((0, getAllowedOrigins_1.getAllowedOrigins)(() => [/origin/g, 'https://origin.com'])).resolves.toEqual([
+            /origin/g,
+            'https://origin.com'
+        ]);
+    });
+    test('Function should return array if get promise parameter', () => {
+        expect((0, getAllowedOrigins_1.getAllowedOrigins)(() => Promise.resolve([/origin/g, 'https://origin.com']))).resolves.toEqual([/origin/g, 'https://origin.com']);
+    });
+});

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

@@ -0,0 +1,2 @@
+import type { Express } from 'express';
+export declare const noCorsMiddleware: (server: Express) => Promise<void>;

package/dist/src/cors/noCorsMiddleware/noCorsMiddleware.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noCorsMiddleware = void 0;
+const constants_1 = require("../../utils/constants");
+const noCorsMiddleware = async (server) => {
+    server.use(async (_req, res, next) => {
+        res.setHeader('Access-Control-Allow-Origin', constants_1.DEFAULT.CORS.ORIGIN);
+        res.setHeader('Access-Control-Allow-Methods', constants_1.DEFAULT.CORS.METHODS);
+        res.setHeader('Access-Control-Allow-Headers', constants_1.DEFAULT.CORS.HEADERS);
+        res.setHeader('Access-Control-Allow-Credentials', `${constants_1.DEFAULT.CORS.CREDENTIALS}`);
+        res.setHeader('Access-Control-Max-Age', constants_1.DEFAULT.CORS.MAX_AGE);
+        return next();
+    });
+};
+exports.noCorsMiddleware = noCorsMiddleware;

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

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

package/dist/src/cors/noCorsMiddleware/noCorsMiddleware.test.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = __importDefault(require("express"));
+const supertest_1 = __importDefault(require("supertest"));
+const noCorsMiddleware_1 = require("./noCorsMiddleware");
+describe('noCorsMiddleware', () => {
+    test('Should set no cors settings for request', async () => {
+        const server = (0, express_1.default)();
+        (0, noCorsMiddleware_1.noCorsMiddleware)(server);
+        const response = await (0, supertest_1.default)(server).get('/');
+        expect(response.headers).toMatchObject({
+            'access-control-allow-headers': '*',
+            'access-control-allow-methods': '*',
+            'access-control-allow-origin': '*',
+            'access-control-max-age': '3600',
+            'access-control-allow-credentials': 'true'
+        });
+    });
+});

package/dist/src/index.d.ts

@@ -0,0 +1,3 @@
+export * from './server/createMockServer/createMockServer';
+export * from './server/startMockServer/startMockServer';
+export * from './utils/types';

package/dist/src/index.js

@@ -0,0 +1,19 @@
+"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("./server/createMockServer/createMockServer"), exports);
+__exportStar(require("./server/startMockServer/startMockServer"), exports);
+__exportStar(require("./utils/types"), exports);

package/dist/src/routes/callRequestInterceptors/callRequestInterceptors.d.ts

@@ -0,0 +1,12 @@
+import type { Request } from 'express';
+import { InterceptorRequest } from '../../utils/types';
+interface CallRequestInterceptorsParams {
+    request: Request;
+    interceptors?: {
+        routeInterceptor?: InterceptorRequest | undefined;
+        requestInterceptor?: InterceptorRequest | undefined;
+        serverInterceptor?: InterceptorRequest | undefined;
+    };
+}
+export declare const callRequestInterceptors: (params: CallRequestInterceptorsParams) => void;
+export {};

package/dist/src/routes/callRequestInterceptors/callRequestInterceptors.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callRequestInterceptors = void 0;
+const callRequestInterceptors = (params) => {
+    const { request, interceptors } = params;
+    if (interceptors?.routeInterceptor)
+        interceptors.routeInterceptor({ request });
+    if (interceptors?.requestInterceptor)
+        interceptors.requestInterceptor({ request });
+    if (interceptors?.serverInterceptor)
+        interceptors.serverInterceptor({ request });
+};
+exports.callRequestInterceptors = callRequestInterceptors;

package/dist/src/routes/callRequestInterceptors/callRequestInterceptors.test.d.ts

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

package/dist/src/routes/callRequestInterceptors/callRequestInterceptors.test.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const callRequestInterceptors_1 = require("./callRequestInterceptors");
+describe('callRequestInterceptors', () => {
+    test('Should call all passed request interceptors in order: route -> request -> server', () => {
+        const request = {};
+        const routeInterceptor = jest.fn();
+        const requestInterceptor = jest.fn();
+        const serverInterceptor = jest.fn();
+        (0, callRequestInterceptors_1.callRequestInterceptors)({ request });
+        expect(routeInterceptor.mock.calls.length).toBe(0);
+        expect(requestInterceptor.mock.calls.length).toBe(0);
+        expect(serverInterceptor.mock.calls.length).toBe(0);
+        (0, callRequestInterceptors_1.callRequestInterceptors)({
+            request,
+            interceptors: {
+                routeInterceptor,
+                requestInterceptor,
+                serverInterceptor
+            }
+        });
+        expect(routeInterceptor.mock.calls.length).toBe(1);
+        expect(requestInterceptor.mock.calls.length).toBe(1);
+        expect(serverInterceptor.mock.calls.length).toBe(1);
+        expect(routeInterceptor.mock.invocationCallOrder[0]).toBeLessThan(requestInterceptor.mock.invocationCallOrder[0]);
+        expect(requestInterceptor.mock.invocationCallOrder[0]).toBeLessThan(serverInterceptor.mock.invocationCallOrder[0]);
+    });
+});

package/dist/src/routes/callResponseInterceptors/callResponseInterceptors.d.ts

@@ -0,0 +1,14 @@
+import type { Request, Response } from 'express';
+import type { InterceptorResponse } from '../../utils/types';
+interface CallResponseInterceptorsParams<T> {
+    data: T;
+    request: Request;
+    response: Response;
+    interceptors?: {
+        routeInterceptor?: InterceptorResponse | undefined;
+        requestInterceptor?: InterceptorResponse | undefined;
+        serverInterceptor?: InterceptorResponse | undefined;
+    };
+}
+export declare const callResponseInterceptors: <T = any>(params: CallResponseInterceptorsParams<T>) => T;
+export {};

package/dist/src/routes/callResponseInterceptors/callResponseInterceptors.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callResponseInterceptors = void 0;
+const helpers_1 = require("../../utils/helpers");
+const callResponseInterceptors = (params) => {
+    const { data, request, response, interceptors } = params;
+    const setDelay = async (delay) => {
+        await (0, helpers_1.sleep)(delay === Infinity ? 100000 : delay);
+    };
+    const setStatusCode = (statusCode) => {
+        response.statusCode = statusCode;
+    };
+    const interceptorResponseParams = {
+        request,
+        response,
+        setDelay,
+        setStatusCode
+    };
+    let updatedData = data;
+    if (interceptors?.routeInterceptor) {
+        updatedData = interceptors.routeInterceptor(updatedData, interceptorResponseParams);
+    }
+    if (interceptors?.requestInterceptor) {
+        updatedData = interceptors.requestInterceptor(updatedData, interceptorResponseParams);
+    }
+    if (interceptors?.serverInterceptor) {
+        updatedData = interceptors.serverInterceptor(updatedData, interceptorResponseParams);
+    }
+    return updatedData;
+};
+exports.callResponseInterceptors = callResponseInterceptors;

package/dist/src/routes/callResponseInterceptors/callResponseInterceptors.test.d.ts

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

package/dist/src/routes/callResponseInterceptors/callResponseInterceptors.test.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const callResponseInterceptors_1 = require("./callResponseInterceptors");
+describe('callResponseInterceptors', () => {
+    test('Should call all passed response interceptors in order: route -> request -> server', () => {
+        const initialData = '';
+        const request = {};
+        const response = {};
+        const routeInterceptor = jest.fn((data) => `${data}routeInterceptor;`);
+        const requestInterceptor = jest.fn((data) => `${data}requestInterceptor;`);
+        const serverInterceptor = jest.fn((data) => `${data}serverInterceptor`);
+        expect((0, callResponseInterceptors_1.callResponseInterceptors)({
+            data: initialData,
+            request,
+            response
+        })).toBe('');
+        expect(routeInterceptor.mock.calls.length).toBe(0);
+        expect(requestInterceptor.mock.calls.length).toBe(0);
+        expect(serverInterceptor.mock.calls.length).toBe(0);
+        expect((0, callResponseInterceptors_1.callResponseInterceptors)({
+            data: initialData,
+            request,
+            response,
+            interceptors: {
+                routeInterceptor,
+                requestInterceptor,
+                serverInterceptor
+            }
+        })).toBe('routeInterceptor;requestInterceptor;serverInterceptor');
+        expect(routeInterceptor.mock.calls.length).toBe(1);
+        expect(requestInterceptor.mock.calls.length).toBe(1);
+        expect(serverInterceptor.mock.calls.length).toBe(1);
+        expect(routeInterceptor.mock.invocationCallOrder[0]).toBeLessThan(requestInterceptor.mock.invocationCallOrder[0]);
+        expect(requestInterceptor.mock.invocationCallOrder[0]).toBeLessThan(serverInterceptor.mock.invocationCallOrder[0]);
+    });
+});

package/dist/src/routes/createRoutes/createRoutes.d.ts

@@ -0,0 +1,3 @@
+import type { IRouter } from 'express';
+import type { MockServerConfig } from '../../utils/types';
+export declare const createRoutes: (router: IRouter, mockServerConfig: Pick<MockServerConfig, 'configs' | 'interceptors'>) => IRouter;

package/dist/src/routes/createRoutes/createRoutes.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRoutes = void 0;
+const isEntityValuesEqual_1 = require("../../configs/isEntitiesEqual/isEntityValuesEqual");
+const prepareRequestConfigs_1 = require("../../configs/prepareRequestConfigs/prepareRequestConfigs");
+const callRequestInterceptors_1 = require("../callRequestInterceptors/callRequestInterceptors");
+const callResponseInterceptors_1 = require("../callResponseInterceptors/callResponseInterceptors");
+const createRoutes = (router, mockServerConfig) => {
+    (0, prepareRequestConfigs_1.prepareRequestConfigs)(mockServerConfig.configs).forEach((requestConfig) => {
+        router.route(requestConfig.path)[requestConfig.method]((request, response) => {
+            (0, callRequestInterceptors_1.callRequestInterceptors)({
+                request,
+                interceptors: {
+                    requestInterceptor: requestConfig.interceptors?.request,
+                    serverInterceptor: mockServerConfig.interceptors?.request
+                }
+            });
+            const matchedRouteConfig = requestConfig.routes.find(({ entities }) => {
+                if (!entities)
+                    return true;
+                return Object.entries(entities).every(([entity, entityValue]) => (0, isEntityValuesEqual_1.isEntityValuesEqual)(entityValue, request[entity]));
+            });
+            if (!matchedRouteConfig) {
+                return response
+                    .status(404)
+                    .json(`No data for ${request.method}:${request.baseUrl}${request.path}`);
+            }
+            const data = (0, callResponseInterceptors_1.callResponseInterceptors)({
+                data: matchedRouteConfig.data,
+                request,
+                response,
+                interceptors: {
+                    routeInterceptor: matchedRouteConfig.interceptors?.response,
+                    requestInterceptor: requestConfig.interceptors?.response,
+                    serverInterceptor: mockServerConfig.interceptors?.response
+                }
+            });
+            return response.status(response.statusCode).json(data);
+        });
+    });
+    return router;
+};
+exports.createRoutes = createRoutes;

package/dist/src/routes/createRoutes/createRoutes.test.d.ts

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