mock-config-server 1.0.1

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

@@ -0,0 +1,276 @@
+"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 createRoutes_1 = require("./createRoutes");
+describe('createRoutes', () => {
+    const createServer = (mockServerConfig) => {
+        const server = (0, express_1.default)();
+        const routerBase = express_1.default.Router();
+        const routerWithRoutes = (0, createRoutes_1.createRoutes)(routerBase, mockServerConfig);
+        server.use(express_1.default.json());
+        server.use(mockServerConfig.baseUrl ?? '/', routerWithRoutes);
+        return server;
+    };
+    test('Should match config by entities "includes" behavior', async () => {
+        const server = createServer({
+            configs: [
+                {
+                    path: '/users',
+                    method: 'get',
+                    routes: [
+                        {
+                            entities: {
+                                headers: { key1: 'value1', key2: 'value2' },
+                                query: { key1: 'value1' }
+                            },
+                            data: { name: 'John', surname: 'Doe' }
+                        }
+                    ]
+                }
+            ]
+        });
+        const response = await (0, supertest_1.default)(server)
+            .get('/users')
+            .set({ key1: 'value1', key2: 'value2' })
+            .query({ key1: 'value1', key2: 'value2' });
+        expect(response.statusCode).toBe(200);
+        expect(response.body).toStrictEqual({ name: 'John', surname: 'Doe' });
+    });
+    test('Should give priority to more specific route config', async () => {
+        const server = createServer({
+            configs: [
+                {
+                    path: '/users',
+                    method: 'get',
+                    routes: [
+                        {
+                            entities: {
+                                headers: { key1: 'value1', key2: 'value2' },
+                                query: { key1: 'value1' }
+                            },
+                            data: { name: 'John', surname: 'Doe' }
+                        },
+                        {
+                            entities: {
+                                headers: { key1: 'value1', key2: 'value2' },
+                                query: { key1: 'value1', key2: 'value2' }
+                            },
+                            data: { name: 'John', surname: 'Smith' }
+                        }
+                    ]
+                }
+            ]
+        });
+        const response = await (0, supertest_1.default)(server)
+            .get('/users')
+            .set({ key1: 'value1', key2: 'value2', key3: 'value3' })
+            .query({ key1: 'value1', key2: 'value2', key3: 'value3' });
+        expect(response.statusCode).toBe(200);
+        expect(response.body).toStrictEqual({ name: 'John', surname: 'Smith' });
+    });
+    test('Should return 404 and description text for no matched request entities', async () => {
+        const server = createServer({
+            configs: [
+                {
+                    path: '/users',
+                    method: 'get',
+                    routes: [
+                        {
+                            entities: {
+                                headers: { key1: 'value1' }
+                            },
+                            data: { name: 'John', surname: 'Doe' }
+                        }
+                    ]
+                }
+            ]
+        });
+        const response = await (0, supertest_1.default)(server).get('/users').set({ key2: 'value2' });
+        expect(response.statusCode).toBe(404);
+        expect(response.body).toBe('No data for GET:/users');
+    });
+    test('Should compare non plain object body by full equal behavior', async () => {
+        const server = createServer({
+            configs: [
+                {
+                    path: '/users',
+                    method: 'post',
+                    routes: [
+                        {
+                            entities: {
+                                body: [
+                                    {
+                                        key1: 'value1',
+                                        key2: { nestedKey1: 'nestedValue1' }
+                                    }
+                                ]
+                            },
+                            data: { name: 'John', surname: 'Doe' }
+                        }
+                    ]
+                }
+            ]
+        });
+        const successResponse = await (0, supertest_1.default)(server)
+            .post('/users')
+            .set('Content-Type', 'application/json')
+            .send([{ key1: 'value1', key2: { nestedKey1: 'nestedValue1' } }]);
+        expect(successResponse.statusCode).toBe(200);
+        expect(successResponse.body).toStrictEqual({ name: 'John', surname: 'Doe' });
+        const failedResponse = await (0, supertest_1.default)(server)
+            .post('/users')
+            .set('Content-Type', 'application/json')
+            .send([{ key1: 'value1', key2: { nestedKey1: 'nestedValue1', nestedKey2: 'nestedValue2' } }]);
+        expect(failedResponse.statusCode).toBe(404);
+        expect(failedResponse.body).toBe('No data for POST:/users');
+    });
+    test('Should compare plain object body by "includes" behavior', async () => {
+        const server = createServer({
+            configs: [
+                {
+                    path: '/users',
+                    method: 'post',
+                    routes: [
+                        {
+                            entities: {
+                                body: {
+                                    key1: 'value1',
+                                    key2: { nestedKey1: 'nestedValue1' }
+                                }
+                            },
+                            data: { name: 'John', surname: 'Doe' }
+                        }
+                    ]
+                }
+            ]
+        });
+        const response = await (0, supertest_1.default)(server)
+            .post('/users')
+            .set('Content-Type', 'application/json')
+            .send({ key1: 'value1', key2: { nestedKey1: 'nestedValue1', nestedKey2: 'nestedValue2' } });
+        expect(response.statusCode).toBe(200);
+        expect(response.body).toStrictEqual({ name: 'John', surname: 'Doe' });
+    });
+    test('Should call request interceptors in order: request -> server', async () => {
+        const requestInterceptor = jest.fn();
+        const serverInterceptor = jest.fn();
+        const server = createServer({
+            configs: [
+                {
+                    path: '/users',
+                    method: 'post',
+                    routes: [
+                        {
+                            entities: {
+                                body: {
+                                    key1: 'value1',
+                                    key2: 'value2'
+                                }
+                            },
+                            data: { name: 'John', surname: 'Doe' }
+                        }
+                    ],
+                    interceptors: { request: requestInterceptor }
+                },
+                {
+                    path: '/settings',
+                    method: 'post',
+                    routes: [
+                        {
+                            entities: {
+                                body: {
+                                    key1: 'value1',
+                                    key2: 'value2'
+                                }
+                            },
+                            data: { name: 'John', surname: 'Smith' }
+                        }
+                    ]
+                }
+            ],
+            interceptors: { request: serverInterceptor }
+        });
+        await (0, supertest_1.default)(server)
+            .post('/users')
+            .set('Content-Type', 'application/json')
+            .send({ key1: 'value1', key2: 'value2' });
+        expect(requestInterceptor.mock.calls.length).toBe(1);
+        expect(serverInterceptor.mock.calls.length).toBe(1);
+        expect(requestInterceptor.mock.invocationCallOrder[0]).toBeLessThan(serverInterceptor.mock.invocationCallOrder[0]);
+        await (0, supertest_1.default)(server)
+            .post('/settings')
+            .set('Content-Type', 'application/json')
+            .send({ key1: 'value1', key2: 'value2' });
+        expect(requestInterceptor.mock.calls.length).toBe(1);
+        expect(serverInterceptor.mock.calls.length).toBe(2);
+    });
+    test('Should call response interceptors in order: route -> request -> server', async () => {
+        const routeInterceptor = jest.fn();
+        const requestInterceptor = jest.fn();
+        const serverInterceptor = jest.fn();
+        const server = createServer({
+            configs: [
+                {
+                    path: '/users',
+                    method: 'post',
+                    routes: [
+                        {
+                            entities: {
+                                body: {
+                                    key1: 'value1',
+                                    key2: 'value2'
+                                }
+                            },
+                            data: { name: 'John', surname: 'Doe' },
+                            interceptors: { response: routeInterceptor }
+                        }
+                    ],
+                    interceptors: { response: requestInterceptor }
+                },
+                {
+                    path: '/settings',
+                    method: 'post',
+                    routes: [
+                        {
+                            entities: {
+                                body: {
+                                    key1: 'value1',
+                                    key2: 'value2'
+                                }
+                            },
+                            data: { name: 'John', surname: 'Smith' }
+                        }
+                    ]
+                }
+            ],
+            interceptors: { response: serverInterceptor }
+        });
+        await (0, supertest_1.default)(server)
+            .post('/users')
+            .set('Content-Type', 'application/json')
+            .send({ key1: 'value1', key2: 'value2' });
+        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]);
+        await (0, supertest_1.default)(server)
+            .post('/settings')
+            .set('Content-Type', 'application/json')
+            .send({ key1: 'value1', key2: 'value2' });
+        expect(routeInterceptor.mock.calls.length).toBe(1);
+        expect(requestInterceptor.mock.calls.length).toBe(1);
+        expect(serverInterceptor.mock.calls.length).toBe(2);
+        await (0, supertest_1.default)(server)
+            .post('/messages')
+            .set('Content-Type', 'application/json')
+            .send({ key1: 'value1', key2: 'value2' });
+        expect(routeInterceptor.mock.calls.length).toBe(1);
+        expect(requestInterceptor.mock.calls.length).toBe(1);
+        expect(serverInterceptor.mock.calls.length).toBe(2);
+    });
+});

package/dist/src/server/createMockServer/createMockServer.d.ts

@@ -0,0 +1,3 @@
+import type { Express } from 'express';
+import type { MockServerConfig } from '../../utils/types';
+export declare const createMockServer: ({ cors, staticPath, ...mockServerConfig }: Omit<MockServerConfig, 'port'>) => Express;

package/dist/src/server/createMockServer/createMockServer.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMockServer = void 0;
+const body_parser_1 = __importDefault(require("body-parser"));
+const express_1 = __importDefault(require("express"));
+const corsMiddleware_1 = require("../../cors/corsMiddleware/corsMiddleware");
+const noCorsMiddleware_1 = require("../../cors/noCorsMiddleware/noCorsMiddleware");
+const createRoutes_1 = require("../../routes/createRoutes/createRoutes");
+const staticMiddleware_1 = require("../../static/staticMiddleware/staticMiddleware");
+const createMockServer = ({ cors, staticPath, ...mockServerConfig }) => {
+    const server = (0, express_1.default)();
+    server.use(body_parser_1.default.urlencoded({ extended: false }));
+    server.use(body_parser_1.default.json({ limit: '10mb' }));
+    const baseUrl = mockServerConfig.baseUrl ?? '/';
+    if (cors) {
+        (0, corsMiddleware_1.corsMiddleware)(server, cors);
+    }
+    else {
+        (0, noCorsMiddleware_1.noCorsMiddleware)(server);
+    }
+    if (staticPath) {
+        (0, staticMiddleware_1.staticMiddleware)(server, baseUrl, staticPath);
+    }
+    const routerBase = express_1.default.Router();
+    const routerWithRoutes = (0, createRoutes_1.createRoutes)(routerBase, {
+        configs: mockServerConfig.configs,
+        interceptors: mockServerConfig.interceptors
+    });
+    server.use(baseUrl, routerWithRoutes);
+    return server;
+};
+exports.createMockServer = createMockServer;

package/dist/src/server/startMockServer/startMockServer.d.ts

@@ -0,0 +1,2 @@
+import type { MockServerConfig } from '../../utils/types';
+export declare const startMockServer: (mockServerConfig: MockServerConfig) => void;

package/dist/src/server/startMockServer/startMockServer.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startMockServer = void 0;
+const constants_1 = require("../../utils/constants");
+const createMockServer_1 = require("../createMockServer/createMockServer");
+const startMockServer = (mockServerConfig) => {
+    const mockServer = (0, createMockServer_1.createMockServer)(mockServerConfig);
+    const port = mockServerConfig.port ?? constants_1.DEFAULT.PORT;
+    mockServer.listen(port, () => {
+        console.log(`🎉 Mock Server is running at http://localhost:${port}`);
+    });
+};
+exports.startMockServer = startMockServer;

package/dist/src/static/staticMiddleware/staticMiddleware.d.ts

@@ -0,0 +1,3 @@
+import type { Express } from 'express';
+import type { BaseUrl, StaticPath } from '../../utils/types';
+export declare const staticMiddleware: (server: Express, baseUrl: BaseUrl, staticPath: StaticPath) => void;

package/dist/src/static/staticMiddleware/staticMiddleware.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.staticMiddleware = void 0;
+const express_1 = __importDefault(require("express"));
+const path_1 = __importDefault(require("path"));
+const constants_1 = require("../../utils/constants");
+const staticMiddleware = (server, baseUrl, staticPath) => {
+    const isStaticPathArray = Array.isArray(staticPath);
+    if (isStaticPathArray) {
+        staticPath.forEach((staticPath) => {
+            const isPathObject = typeof staticPath === 'object';
+            if (isPathObject) {
+                return server.use(path_1.default.join(baseUrl, staticPath.prefix), express_1.default.static(path_1.default.join(constants_1.APP_PATH, staticPath.path)));
+            }
+            server.use(baseUrl, express_1.default.static(path_1.default.join(constants_1.APP_PATH, staticPath)));
+        });
+        return;
+    }
+    const isStaticPathObject = typeof staticPath === 'object';
+    if (isStaticPathObject) {
+        server.use(path_1.default.join(baseUrl, staticPath.prefix), express_1.default.static(path_1.default.join(constants_1.APP_PATH, staticPath.path)));
+        return;
+    }
+    server.use(baseUrl, express_1.default.static(path_1.default.join(constants_1.APP_PATH, staticPath)));
+};
+exports.staticMiddleware = staticMiddleware;

package/dist/src/utils/constants/appPath.d.ts

@@ -0,0 +1 @@
+export declare const APP_PATH: string;

package/dist/src/utils/constants/appPath.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APP_PATH = void 0;
+exports.APP_PATH = process.cwd();

package/dist/src/utils/constants/default.d.ts

@@ -0,0 +1,10 @@
+export declare const DEFAULT: {
+    PORT: number;
+    CORS: {
+        ORIGIN: string;
+        METHODS: string;
+        HEADERS: string;
+        CREDENTIALS: boolean;
+        MAX_AGE: number;
+    };
+};

package/dist/src/utils/constants/default.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT = void 0;
+exports.DEFAULT = {
+    PORT: 31299,
+    CORS: {
+        ORIGIN: '*',
+        METHODS: '*',
+        HEADERS: '*',
+        CREDENTIALS: true,
+        MAX_AGE: 3600
+    }
+};

package/dist/src/utils/constants/index.d.ts

@@ -0,0 +1,2 @@
+export * from './appPath';
+export * from './default';

package/dist/src/utils/constants/index.js

@@ -0,0 +1,18 @@
+"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("./appPath"), exports);
+__exportStar(require("./default"), exports);

package/dist/src/utils/helpers/index.d.ts

@@ -0,0 +1,2 @@
+export * from './isPlainObject';
+export * from './sleep';

package/dist/src/utils/helpers/index.js

@@ -0,0 +1,18 @@
+"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("./isPlainObject"), exports);
+__exportStar(require("./sleep"), exports);

package/dist/src/utils/helpers/isPlainObject.d.ts

@@ -0,0 +1 @@
+export declare const isPlainObject: (value: any) => boolean;

package/dist/src/utils/helpers/isPlainObject.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPlainObject = void 0;
+const isPlainObject = (value) => typeof value === 'object' && !Array.isArray(value) && value !== null;
+exports.isPlainObject = isPlainObject;

package/dist/src/utils/helpers/sleep.d.ts

@@ -0,0 +1 @@
+export declare const sleep: (seconds: number) => Promise<unknown>;

package/dist/src/utils/helpers/sleep.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sleep = void 0;
+const sleep = (seconds) => new Promise((resolve) => {
+    setTimeout(resolve, seconds * 1000);
+});
+exports.sleep = sleep;

package/dist/src/utils/types/configs.d.ts

@@ -0,0 +1,34 @@
+export type PlainObject = Record<string, string | number>;
+export type PlainFunction = (...args: any[]) => any;
+export type Entities = 'headers' | 'query' | 'params' | 'body';
+export type BodyValue = any;
+export type EntitiesValues = {
+    [Key in Entities]: Key extends 'body' ? BodyValue : PlainObject;
+};
+export interface HttpMethodsEntities {
+    get: Extract<Entities, 'headers' | 'query' | 'params'>;
+    delete: Extract<Entities, 'headers' | 'query' | 'params'>;
+    post: Entities;
+    put: Entities;
+    patch: Entities;
+}
+export interface RouteConfig<Method extends RestMethod> {
+    entities?: {
+        [Key in HttpMethodsEntities[Method]]?: EntitiesValues[Key];
+    };
+    data: any;
+    interceptors?: Pick<import('./interceptors').Interceptors, 'response'>;
+}
+export type RestMethod = 'get' | 'post' | 'delete' | 'put' | 'patch';
+export interface RestRequestConfig<Method extends RestMethod> {
+    path: string | RegExp;
+    method: Method;
+    routes: RouteConfig<Method>[];
+    interceptors?: import('./interceptors').Interceptors;
+}
+export type RestGetRequestConfig = RestRequestConfig<'get'>;
+export type RestPostRequestConfig = RestRequestConfig<'post'>;
+export type RestPutRequestConfig = RestRequestConfig<'put'>;
+export type RestDeleteRequestConfig = RestRequestConfig<'delete'>;
+export type RestPatchRequestConfig = RestRequestConfig<'patch'>;
+export type RequestConfig = RestGetRequestConfig | RestPostRequestConfig | RestPutRequestConfig | RestDeleteRequestConfig | RestPatchRequestConfig;

package/dist/src/utils/types/configs.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/utils/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from './configs';
+export * from './interceptors';
+export * from './server';

package/dist/src/utils/types/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("./configs"), exports);
+__exportStar(require("./interceptors"), exports);
+__exportStar(require("./server"), exports);

package/dist/src/utils/types/interceptors.d.ts

@@ -0,0 +1,15 @@
+export interface InterceptorRequestParams {
+    request: import('express').Request;
+}
+export type InterceptorRequest = (params: InterceptorRequestParams) => void;
+export interface InterceptorResponseParams {
+    request: import('express').Request;
+    response: import('express').Response;
+    setDelay: (delay: number) => Promise<void>;
+    setStatusCode: (statusCode: number) => void;
+}
+export type InterceptorResponse = <Data>(data: Data, params: InterceptorResponseParams) => any;
+export interface Interceptors {
+    response?: InterceptorResponse;
+    request?: InterceptorRequest;
+}

package/dist/src/utils/types/interceptors.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/utils/types/server.d.ts

@@ -0,0 +1,24 @@
+export type StaticPathObject = {
+    prefix: string;
+    path: string;
+};
+export type StaticPath = string | StaticPathObject | (StaticPathObject | string)[];
+export type CorsHeader = string;
+export type CorsOrigin = string | RegExp | (RegExp | string)[];
+export type Cors = {
+    origin: CorsOrigin | (() => Promise<CorsOrigin> | CorsOrigin);
+    methods?: Uppercase<import('./configs').RestMethod>[];
+    headers?: CorsHeader[];
+    credentials?: boolean;
+    maxAge?: number;
+};
+export type Port = number;
+export type BaseUrl = string;
+export interface MockServerConfig {
+    configs: import('./configs').RequestConfig[];
+    baseUrl?: BaseUrl;
+    port?: Port;
+    staticPath?: StaticPath;
+    interceptors?: import('./interceptors').Interceptors;
+    cors?: Cors;
+}

package/dist/src/utils/types/server.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });