mock-config-server 3.7.0 → 4.0.0

package/dist/src/core/graphql/createGraphQLRoutes/createGraphQLRoutes.js

@@ -30,11 +30,10 @@ const createGraphQLRoutes = ({ router, graphqlConfig, serverResponseInterceptor
         const matchedRequestConfig = preparedGraphQLRequestConfig.find((requestConfig)=>{
             var _graphQLInput_query;
             if (requestConfig.operationType !== query.operationType) return false;
-            if ('query' in requestConfig && requestConfig.query.replace(/\s+/gi, ' ') !== ((_graphQLInput_query = graphQLInput.query) === null || _graphQLInput_query === void 0 ? void 0 : _graphQLInput_query.replace(/\s+/gi, ' '))) return false;
+            if ('query' in requestConfig && requestConfig.query.replace(/\s+/g, '') !== ((_graphQLInput_query = graphQLInput.query) === null || _graphQLInput_query === void 0 ? void 0 : _graphQLInput_query.replace(/\s+/g, ''))) return false;
             if ('operationName' in requestConfig) {
                 if (!query.operationName) return false;
-                if (requestConfig.operationName instanceof RegExp) return new RegExp(requestConfig.operationName).test(query.operationName);
-                return requestConfig.operationName === query.operationName;
+                return requestConfig.operationName instanceof RegExp ? new RegExp(requestConfig.operationName).test(query.operationName) : requestConfig.operationName === query.operationName;
             }
             return true;
         });
@@ -49,24 +48,47 @@ const createGraphQLRoutes = ({ router, graphqlConfig, serverResponseInterceptor
         }
         const matchedRouteConfig = matchedRequestConfig.routes.find(({ entities })=>{
             if (!entities) return true;
-            const entries = Object.entries(entities);
-            return entries.every(([entityName, entityDescriptorOrValue])=>{
-                const { checkMode, value: entityDescriptorValue } = (0, _helpers.convertToEntityDescriptor)(entityDescriptorOrValue);
-                // ✅ important: check whole variables as plain value strictly if descriptor used for variables
+            const entityEntries = Object.entries(entities);
+            return entityEntries.every(([entityName, entityDescriptorOrValue])=>{
+                // ✅ important:
+                // check whole variables as plain value strictly if descriptor used for variables
                 const isEntityVariablesByTopLevelDescriptor = entityName === 'variables' && (0, _helpers.isEntityDescriptor)(entityDescriptorOrValue);
                 if (isEntityVariablesByTopLevelDescriptor) {
-                    return (0, _helpers.resolveEntityValues)(checkMode, graphQLInput.variables, entityDescriptorValue);
+                    const variablesDescriptor = entityDescriptorOrValue;
+                    if (variablesDescriptor.checkMode === 'exists' || variablesDescriptor.checkMode === 'notExists') {
+                        return (0, _helpers.resolveEntityValues)({
+                            actualValue: graphQLInput.variables,
+                            checkMode: variablesDescriptor.checkMode
+                        });
+                    }
+                    var _variablesDescriptor_oneOf;
+                    return (0, _helpers.resolveEntityValues)({
+                        actualValue: graphQLInput.variables,
+                        descriptorValue: variablesDescriptor.value,
+                        checkMode: variablesDescriptor.checkMode,
+                        oneOf: (_variablesDescriptor_oneOf = variablesDescriptor.oneOf) !== null && _variablesDescriptor_oneOf !== void 0 ? _variablesDescriptor_oneOf : false
+                    });
                 }
-                const isEntityVariablesByTopLevelArray = entityName === 'variables' && Array.isArray(entityDescriptorOrValue);
-                if (isEntityVariablesByTopLevelArray) {
-                    return entityDescriptorOrValue.some((entityDescriptorOrValueElement)=>(0, _helpers.resolveEntityValues)(checkMode, graphQLInput.variables, entityDescriptorOrValueElement));
-                }
-                const recordOrArrayEntries = Object.entries(entityDescriptorOrValue);
-                return recordOrArrayEntries.every(([entityKey, entityValue])=>{
-                    const { checkMode, value: descriptorValue } = (0, _helpers.convertToEntityDescriptor)(entityValue);
-                    const flattenEntity = (0, _flat.flatten)(entityName === 'variables' ? graphQLInput.variables : request[entityName]);
+                const actualEntity = (0, _flat.flatten)(entityName === 'variables' ? graphQLInput.variables : request[entityName]);
+                const entityValueEntries = Object.entries(entityDescriptorOrValue);
+                return entityValueEntries.every(([entityPropertyKey, entityPropertyDescriptorOrValue])=>{
+                    const entityPropertyDescriptor = (0, _helpers.convertToEntityDescriptor)(entityPropertyDescriptorOrValue);
                     // ✅ important: transform header keys to lower case because browsers send headers in lowercase
-                    return (0, _helpers.resolveEntityValues)(checkMode, flattenEntity[entityName === 'headers' ? entityKey.toLowerCase() : entityKey], descriptorValue);
+                    const actualPropertyKey = entityName === 'headers' ? entityPropertyKey.toLowerCase() : entityPropertyKey;
+                    const actualPropertyValue = actualEntity[actualPropertyKey];
+                    if (entityPropertyDescriptor.checkMode === 'exists' || entityPropertyDescriptor.checkMode === 'notExists') {
+                        return (0, _helpers.resolveEntityValues)({
+                            actualValue: actualPropertyValue,
+                            checkMode: entityPropertyDescriptor.checkMode
+                        });
+                    }
+                    var _entityPropertyDescriptor_oneOf;
+                    return (0, _helpers.resolveEntityValues)({
+                        actualValue: actualPropertyValue,
+                        descriptorValue: entityPropertyDescriptor.value,
+                        checkMode: entityPropertyDescriptor.checkMode,
+                        oneOf: (_entityPropertyDescriptor_oneOf = entityPropertyDescriptor.oneOf) !== null && _entityPropertyDescriptor_oneOf !== void 0 ? _entityPropertyDescriptor_oneOf : false
+                    });
                 });
             });
         });

package/dist/src/core/graphql/createGraphQLRoutes/helpers/prepareGraphQLRequestConfigs/prepareGraphQLRequestConfigs.js

@@ -18,7 +18,7 @@ const calculateRouteConfigWeight = (graphQLRouteConfig)=>{
     if (cookies) routeConfigWeight += Object.keys(cookies).length;
     if (query) routeConfigWeight += Object.keys(query).length;
     if (variables) {
-        if ((0, _helpers.isPlainObject)(variables) && variables.checkMode) {
+        if (variables.checkMode) {
             // ✅ important:
             // check that actual value check modes does not have `value` for compare
             if (variables.checkMode === 'exists' || variables.checkMode === 'notExists') {
@@ -28,7 +28,7 @@ const calculateRouteConfigWeight = (graphQLRouteConfig)=>{
             routeConfigWeight += (0, _helpers.isPlainObject)(variables.value) ? Object.keys(variables.value).length : 1;
             return routeConfigWeight;
         }
-        routeConfigWeight += (0, _helpers.isPlainObject)(variables) ? Object.keys(variables).length : 1;
+        routeConfigWeight += Object.keys(variables).length;
     }
     return routeConfigWeight;
 };

package/dist/src/core/middlewares/contextMiddleware/contextMiddleware.d.ts

@@ -1,5 +1,5 @@
 import type { Express } from 'express';
-import type { GraphQLEntity, GraphQLOperationName, GraphQLOperationType } from '../../../utils/types';
+import type { GraphQLEntity, GraphQLOperationName, GraphQLOperationType, MockServerConfig } from '../../../utils/types';
 declare global {
     namespace Express {
         interface Request {
@@ -14,4 +14,4 @@ declare global {
         }
     }
 }
-export declare const contextMiddleware: (server: Express) => void;
+export declare const contextMiddleware: (server: Express, { database }: Pick<MockServerConfig, "database">) => void;

package/dist/src/core/middlewares/contextMiddleware/contextMiddleware.js

@@ -8,26 +8,38 @@ Object.defineProperty(exports, "contextMiddleware", {
         return contextMiddleware;
     }
 });
+const _database = require("../../database");
 const _helpers = require("../../../utils/helpers");
-const contextMiddleware = (server)=>{
+const contextMiddleware = (server, { database })=>{
     let requestId = 0;
+    const context = {
+        orm: {}
+    };
+    if (database) {
+        const storage = (0, _database.createStorage)(database.data);
+        const orm = (0, _database.createOrm)(storage);
+        context.orm = orm;
+    }
     server.use((request, _response, next)=>{
         requestId += 1;
         request.id = requestId;
         request.timestamp = Date.now();
-        const graphQLInput = (0, _helpers.getGraphQLInput)(request);
-        var _graphQLInput_query;
-        const graphQLQuery = (0, _helpers.parseQuery)((_graphQLInput_query = graphQLInput.query) !== null && _graphQLInput_query !== void 0 ? _graphQLInput_query : '');
-        if (graphQLInput.query && graphQLQuery) {
-            request.graphQL = {
-                operationType: graphQLQuery.operationType,
-                operationName: graphQLQuery.operationName,
-                query: graphQLInput.query,
-                variables: graphQLInput.variables
-            };
-            return next();
+        if (request.method === 'GET' || request.method === 'POST') {
+            const graphQLInput = (0, _helpers.getGraphQLInput)(request);
+            var _graphQLInput_query;
+            const graphQLQuery = (0, _helpers.parseQuery)((_graphQLInput_query = graphQLInput.query) !== null && _graphQLInput_query !== void 0 ? _graphQLInput_query : '');
+            if (graphQLInput.query && graphQLQuery) {
+                request.graphQL = {
+                    operationType: graphQLQuery.operationType,
+                    operationName: graphQLQuery.operationName,
+                    query: graphQLInput.query,
+                    variables: graphQLInput.variables
+                };
+                return next();
+            }
         }
         request.graphQL = null;
+        request.context = context;
         return next();
     });
 };

package/dist/src/core/middlewares/destroyerMiddleware/destroyerMiddleware.d.ts

@@ -1,5 +1,4 @@
-/// <reference types="node" />
-import type { Server } from 'http';
+import type { Server } from 'node:http';
 type ServerWithDestroyer = Server & {
     destroy: Server['close'];
 };

package/dist/src/core/middlewares/index.d.ts

@@ -4,6 +4,5 @@ export * from './corsMiddleware/corsMiddleware';
 export * from './destroyerMiddleware/destroyerMiddleware';
 export * from './errorMiddleware/errorMiddleware';
 export * from './noCorsMiddleware/noCorsMiddleware';
-export * from './notFoundMiddleware/notFoundMiddleware';
 export * from './requestInterceptorMiddleware/requestInterceptorMiddleware';
 export * from './staticMiddleware/staticMiddleware';

package/dist/src/core/middlewares/index.js

@@ -8,7 +8,6 @@ _export_star(require("./corsMiddleware/corsMiddleware"), exports);
 _export_star(require("./destroyerMiddleware/destroyerMiddleware"), exports);
 _export_star(require("./errorMiddleware/errorMiddleware"), exports);
 _export_star(require("./noCorsMiddleware/noCorsMiddleware"), exports);
-_export_star(require("./notFoundMiddleware/notFoundMiddleware"), exports);
 _export_star(require("./requestInterceptorMiddleware/requestInterceptorMiddleware"), exports);
 _export_star(require("./staticMiddleware/staticMiddleware"), exports);
 function _export_star(from, to) {

package/dist/src/core/middlewares/requestInterceptorMiddleware/requestInterceptorMiddleware.d.ts

@@ -1,9 +1,9 @@
 import type { Express } from 'express';
 import type { RequestInterceptor } from '../../../utils/types';
 interface RequestInterceptorMiddlewareParams {
-    server: Express;
-    path?: string;
     interceptor: RequestInterceptor;
+    path?: string;
+    server: Express;
 }
 export declare const requestInterceptorMiddleware: ({ server, path, interceptor }: RequestInterceptorMiddlewareParams) => void;
 export {};

package/dist/src/core/rest/createRestRoutes/createRestRoutes.d.ts

@@ -1,8 +1,8 @@
 import type { IRouter } from 'express';
 import type { Interceptors, RestConfig } from '../../../utils/types';
 interface CreateRestRoutesParams {
-    router: IRouter;
     restConfig: RestConfig;
+    router: IRouter;
     serverResponseInterceptor?: Interceptors<'rest'>['response'];
 }
 export declare const createRestRoutes: ({ router, restConfig, serverResponseInterceptor }: CreateRestRoutesParams) => IRouter;

package/dist/src/core/rest/createRestRoutes/createRestRoutes.js

@@ -9,7 +9,8 @@ Object.defineProperty(exports, "createRestRoutes", {
     }
 });
 const _flat = require("flat");
-const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _nodefs = /*#__PURE__*/ _interop_require_default(require("node:fs"));
+const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
 const _helpers = require("../../../utils/helpers");
 const _helpers1 = require("./helpers");
 function _interop_require_default(obj) {
@@ -29,29 +30,56 @@ const createRestRoutes = ({ router, restConfig, serverResponseInterceptor })=>{
             }
             const matchedRouteConfig = requestConfig.routes.find(({ entities })=>{
                 if (!entities) return true;
-                const entries = Object.entries(entities);
-                return entries.every(([entityName, entityDescriptorOrValue])=>{
-                    const { checkMode, value: descriptorValue } = (0, _helpers.convertToEntityDescriptor)(entityDescriptorOrValue);
+                const entityEntries = Object.entries(entities);
+                return entityEntries.every(([entityName, entityDescriptorOrValue])=>{
                     // ✅ important:
                     // check whole body as plain value strictly if descriptor used for body
                     const isEntityBodyByTopLevelDescriptor = entityName === 'body' && (0, _helpers.isEntityDescriptor)(entityDescriptorOrValue);
                     if (isEntityBodyByTopLevelDescriptor) {
-                        // ✅ important:
-                        // bodyParser sets body to empty object if body not sent or invalid, so assume {} as undefined
-                        return (0, _helpers.resolveEntityValues)(checkMode, Object.keys(request.body).length ? request.body : undefined, descriptorValue);
+                        const bodyDescriptor = entityDescriptorOrValue;
+                        if (bodyDescriptor.checkMode === 'exists' || bodyDescriptor.checkMode === 'notExists') {
+                            return (0, _helpers.resolveEntityValues)({
+                                actualValue: request.body,
+                                checkMode: bodyDescriptor.checkMode
+                            });
+                        }
+                        var _bodyDescriptor_oneOf;
+                        return (0, _helpers.resolveEntityValues)({
+                            actualValue: request.body,
+                            descriptorValue: bodyDescriptor.value,
+                            checkMode: bodyDescriptor.checkMode,
+                            oneOf: (_bodyDescriptor_oneOf = bodyDescriptor.oneOf) !== null && _bodyDescriptor_oneOf !== void 0 ? _bodyDescriptor_oneOf : false
+                        });
                     }
                     const isEntityBodyByTopLevelArray = entityName === 'body' && Array.isArray(entityDescriptorOrValue);
                     if (isEntityBodyByTopLevelArray) {
-                        return entityDescriptorOrValue.some((entityDescriptorOrValueElement)=>// ✅ important:
-                            // bodyParser sets body to empty object if body not sent or invalid, so assume {} as undefined
-                            (0, _helpers.resolveEntityValues)(checkMode, Object.keys(request.body).length ? request.body : undefined, entityDescriptorOrValueElement));
+                        if (!Array.isArray(request.body)) return false;
+                        return (0, _helpers.resolveEntityValues)({
+                            actualValue: request.body,
+                            descriptorValue: entityDescriptorOrValue,
+                            checkMode: 'equals'
+                        });
                     }
-                    const recordOrArrayEntries = Object.entries(entityDescriptorOrValue);
-                    return recordOrArrayEntries.every(([entityKey, mappedEntityDescriptor])=>{
-                        const { checkMode, value: descriptorValue } = (0, _helpers.convertToEntityDescriptor)(mappedEntityDescriptor);
-                        const flattenEntity = (0, _flat.flatten)(request[entityName]);
+                    const actualEntity = (0, _flat.flatten)(request[entityName]);
+                    const entityValueEntries = Object.entries(entityDescriptorOrValue);
+                    return entityValueEntries.every(([entityPropertyKey, entityPropertyDescriptorOrValue])=>{
+                        const entityPropertyDescriptor = (0, _helpers.convertToEntityDescriptor)(entityPropertyDescriptorOrValue);
                         // ✅ important: transform header keys to lower case because browsers send headers in lowercase
-                        return (0, _helpers.resolveEntityValues)(checkMode, flattenEntity[entityName === 'headers' ? entityKey.toLowerCase() : entityKey], descriptorValue);
+                        const actualPropertyKey = entityName === 'headers' ? entityPropertyKey.toLowerCase() : entityPropertyKey;
+                        const actualPropertyValue = actualEntity[actualPropertyKey];
+                        if (entityPropertyDescriptor.checkMode === 'exists' || entityPropertyDescriptor.checkMode === 'notExists') {
+                            return (0, _helpers.resolveEntityValues)({
+                                actualValue: actualPropertyValue,
+                                checkMode: entityPropertyDescriptor.checkMode
+                            });
+                        }
+                        var _entityPropertyDescriptor_oneOf;
+                        return (0, _helpers.resolveEntityValues)({
+                            actualValue: actualPropertyValue,
+                            descriptorValue: entityPropertyDescriptor.value,
+                            checkMode: entityPropertyDescriptor.checkMode,
+                            oneOf: (_entityPropertyDescriptor_oneOf = entityPropertyDescriptor.oneOf) !== null && _entityPropertyDescriptor_oneOf !== void 0 ? _entityPropertyDescriptor_oneOf : false
+                        });
                     });
                 });
             });
@@ -62,13 +90,13 @@ const createRestRoutes = ({ router, restConfig, serverResponseInterceptor })=>{
                     interceptor: matchedRouteConfig.interceptors.request
                 });
             }
-            let matchedRouteConfigData = null;
+            const matchedRouteConfigDataDescriptor = {};
             if (((_matchedRouteConfig_settings = matchedRouteConfig.settings) === null || _matchedRouteConfig_settings === void 0 ? void 0 : _matchedRouteConfig_settings.polling) && 'queue' in matchedRouteConfig) {
                 if (!matchedRouteConfig.queue.length) return next();
                 const shallowMatchedRouteConfig = matchedRouteConfig;
                 var _shallowMatchedRouteConfig___pollingIndex;
                 let index = (_shallowMatchedRouteConfig___pollingIndex = shallowMatchedRouteConfig.__pollingIndex) !== null && _shallowMatchedRouteConfig___pollingIndex !== void 0 ? _shallowMatchedRouteConfig___pollingIndex : 0;
-                const { time, data } = matchedRouteConfig.queue[index];
+                const { time } = matchedRouteConfig.queue[index];
                 const updateIndex = ()=>{
                     if (matchedRouteConfig.queue.length - 1 === index) {
                         index = 0;
@@ -77,6 +105,7 @@ const createRestRoutes = ({ router, restConfig, serverResponseInterceptor })=>{
                     }
                     shallowMatchedRouteConfig.__pollingIndex = index;
                 };
+                const queueItem = matchedRouteConfig.queue[index];
                 if (time && !shallowMatchedRouteConfig.__timeoutInProgress) {
                     shallowMatchedRouteConfig.__timeoutInProgress = true;
                     setTimeout(()=>{
@@ -87,16 +116,21 @@ const createRestRoutes = ({ router, restConfig, serverResponseInterceptor })=>{
                 if (!time && !shallowMatchedRouteConfig.__timeoutInProgress) {
                     updateIndex();
                 }
-                matchedRouteConfigData = data;
+                if ('data' in queueItem) {
+                    matchedRouteConfigDataDescriptor.data = queueItem.data;
+                }
+                if ('file' in queueItem) {
+                    if (!(0, _helpers.isFilePathValid)(queueItem.file)) return next();
+                    matchedRouteConfigDataDescriptor.file = queueItem.file;
+                }
             }
             if ('data' in matchedRouteConfig) {
-                matchedRouteConfigData = matchedRouteConfig.data;
+                matchedRouteConfigDataDescriptor.data = matchedRouteConfig.data;
             }
             if ('file' in matchedRouteConfig) {
                 if (!(0, _helpers.isFilePathValid)(matchedRouteConfig.file)) return next();
+                matchedRouteConfigDataDescriptor.file = matchedRouteConfig.file;
             }
-            var _matchedRouteConfig_entities;
-            const resolvedData = typeof matchedRouteConfigData === 'function' ? await matchedRouteConfigData(request, (_matchedRouteConfig_entities = matchedRouteConfig.entities) !== null && _matchedRouteConfig_entities !== void 0 ? _matchedRouteConfig_entities : {}) : matchedRouteConfigData;
             if ((_matchedRouteConfig_settings1 = matchedRouteConfig.settings) === null || _matchedRouteConfig_settings1 === void 0 ? void 0 : _matchedRouteConfig_settings1.status) {
                 response.statusCode = matchedRouteConfig.settings.status;
             }
@@ -104,6 +138,18 @@ const createRestRoutes = ({ router, restConfig, serverResponseInterceptor })=>{
             // set 'Cache-Control' header for explicit browsers response revalidate: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Cache-Control
             // this code should place before response interceptors for giving opportunity to rewrite 'Cache-Control' header
             if (request.method === 'GET') response.set('Cache-control', 'no-cache');
+            let resolvedData = null;
+            if (matchedRouteConfigDataDescriptor.data) {
+                var _matchedRouteConfig_entities;
+                resolvedData = typeof matchedRouteConfigDataDescriptor.data === 'function' ? await matchedRouteConfigDataDescriptor.data(request, (_matchedRouteConfig_entities = matchedRouteConfig.entities) !== null && _matchedRouteConfig_entities !== void 0 ? _matchedRouteConfig_entities : {}) : matchedRouteConfigDataDescriptor.data;
+            }
+            if (matchedRouteConfigDataDescriptor.file) {
+                const buffer = _nodefs.default.readFileSync(_nodepath.default.resolve(matchedRouteConfigDataDescriptor.file));
+                resolvedData = {
+                    path: matchedRouteConfigDataDescriptor.file,
+                    file: buffer
+                };
+            }
             const data = await (0, _helpers.callResponseInterceptors)({
                 data: resolvedData,
                 request,
@@ -118,10 +164,20 @@ const createRestRoutes = ({ router, restConfig, serverResponseInterceptor })=>{
             if ((_matchedRouteConfig_settings2 = matchedRouteConfig.settings) === null || _matchedRouteConfig_settings2 === void 0 ? void 0 : _matchedRouteConfig_settings2.delay) {
                 await (0, _helpers.sleep)(matchedRouteConfig.settings.delay);
             }
-            if ('file' in matchedRouteConfig) {
-                return response.sendFile(_path.default.resolve(matchedRouteConfig.file));
+            if ((0, _helpers.isFileDescriptor)(data)) {
+                const isFilePathChanged = matchedRouteConfigDataDescriptor.file !== data.path;
+                if (isFilePathChanged) {
+                    if (!(0, _helpers.isFilePathValid)(data.path)) return next();
+                    data.file = _nodefs.default.readFileSync(_nodepath.default.resolve(data.path));
+                }
+                // ✅ important: replace backslashes because windows can use them in file path
+                const fileName = data.path.replaceAll('\\', '/').split('/').at(-1);
+                const fileExtension = fileName.split('.').at(-1);
+                response.type(fileExtension);
+                response.set('Content-Disposition', `filename=${fileName}`);
+                return response.send(data.file);
             }
-            return response.json(data);
+            response.json(data);
         }));
     });
     return router;

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

@@ -1,3 +1,3 @@
 import type { Express } from 'express';
 import type { DatabaseMockServerConfig } from '../../utils/types';
-export declare const createDatabaseMockServer: (databaseMockServerConfig: Omit<DatabaseMockServerConfig, 'port'>, server?: Express) => Express;
+export declare const createDatabaseMockServer: (databaseMockServerConfig: Omit<DatabaseMockServerConfig, "port">, server?: Express) => Express;

package/dist/src/server/createDatabaseMockServer/createDatabaseMockServer.js

@@ -12,7 +12,6 @@ const _bodyparser = /*#__PURE__*/ _interop_require_default(require("body-parser"
 const _express = /*#__PURE__*/ _interop_require_default(require("express"));
 const _database = require("../../core/database");
 const _middlewares = require("../../core/middlewares");
-const _helpers = require("../../utils/helpers");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -21,9 +20,6 @@ function _interop_require_default(obj) {
 const createDatabaseMockServer = (databaseMockServerConfig, server = (0, _express.default)())=>{
     var _databaseMockServerConfig_interceptors;
     const { cors, staticPath, data, routes } = databaseMockServerConfig;
-    server.set('view engine', 'ejs');
-    server.set('views', (0, _helpers.urlJoin)(__dirname, '../../static/views'));
-    server.use(_express.default.static((0, _helpers.urlJoin)(__dirname, '../../static/views')));
     server.use(_bodyparser.default.urlencoded({
         extended: false
     }));
@@ -32,7 +28,12 @@ const createDatabaseMockServer = (databaseMockServerConfig, server = (0, _expres
     }));
     server.set('json spaces', 2);
     server.use(_bodyparser.default.text());
-    (0, _middlewares.contextMiddleware)(server);
+    (0, _middlewares.contextMiddleware)(server, {
+        database: {
+            data,
+            routes
+        }
+    });
     (0, _middlewares.cookieParseMiddleware)(server);
     const serverRequestInterceptor = (_databaseMockServerConfig_interceptors = databaseMockServerConfig.interceptors) === null || _databaseMockServerConfig_interceptors === void 0 ? void 0 : _databaseMockServerConfig_interceptors.request;
     if (serverRequestInterceptor) {
@@ -56,7 +57,6 @@ const createDatabaseMockServer = (databaseMockServerConfig, server = (0, _expres
         routes
     });
     server.use(baseUrl, routerWithDatabaseRoutes);
-    (0, _middlewares.notFoundMiddleware)(server, databaseMockServerConfig);
     (0, _middlewares.errorMiddleware)(server);
     return server;
 };

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

@@ -0,0 +1,3 @@
+import type { Express } from 'express';
+import type { FlatMockServerConfig } from '../../utils/types';
+export declare const createFlatMockServer: (flatMockServerConfig: FlatMockServerConfig, server?: Express) => Express;

package/dist/src/server/createFlatMockServer/createFlatMockServer.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createFlatMockServer", {
+    enumerable: true,
+    get: function() {
+        return createFlatMockServer;
+    }
+});
+const _bodyparser = /*#__PURE__*/ _interop_require_default(require("body-parser"));
+const _express = /*#__PURE__*/ _interop_require_default(require("express"));
+const _database = require("../../core/database");
+const _graphql = require("../../core/graphql");
+const _middlewares = require("../../core/middlewares");
+const _rest = require("../../core/rest");
+const _validate = require("../../utils/validate");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const createFlatMockServer = (flatMockServerConfig, server = (0, _express.default)())=>{
+    (0, _validate.validateFlatMockServerConfig)(flatMockServerConfig);
+    const [option, ...flatMockServerComponents] = flatMockServerConfig;
+    const flatMockServerSettings = !('configs' in option) ? option : undefined;
+    const { cors, staticPath, interceptors, baseUrl: serverBaseUrl = '/', database } = flatMockServerSettings !== null && flatMockServerSettings !== void 0 ? flatMockServerSettings : {};
+    server.use(_bodyparser.default.urlencoded({
+        extended: false
+    }));
+    server.use(_bodyparser.default.json({
+        limit: '10mb'
+    }));
+    server.set('json spaces', 2);
+    server.use(_bodyparser.default.text());
+    (0, _middlewares.contextMiddleware)(server, {
+        database
+    });
+    (0, _middlewares.cookieParseMiddleware)(server);
+    const serverRequestInterceptor = interceptors === null || interceptors === void 0 ? void 0 : interceptors.request;
+    if (serverRequestInterceptor) {
+        (0, _middlewares.requestInterceptorMiddleware)({
+            server,
+            interceptor: serverRequestInterceptor
+        });
+    }
+    if (cors) {
+        (0, _middlewares.corsMiddleware)(server, cors);
+    } else {
+        (0, _middlewares.noCorsMiddleware)(server);
+    }
+    if (staticPath) {
+        (0, _middlewares.staticMiddleware)(server, serverBaseUrl, staticPath);
+    }
+    if (database) {
+        const routerWithDatabaseRoutes = (0, _database.createDatabaseRoutes)(_express.default.Router(), database);
+        server.use(serverBaseUrl, routerWithDatabaseRoutes);
+    }
+    const { restRequestConfigs, graphQLRequestConfigs } = flatMockServerComponents.reduce((acc, component)=>{
+        const { baseUrl = '' } = component;
+        component.configs.forEach((config)=>{
+            var _component_interceptors, _config_interceptors, _component_interceptors1, _config_interceptors1;
+            const interceptors = {
+                ...(((_component_interceptors = component.interceptors) === null || _component_interceptors === void 0 ? void 0 : _component_interceptors.request) || ((_config_interceptors = config.interceptors) === null || _config_interceptors === void 0 ? void 0 : _config_interceptors.request)) && {
+                    request: (params)=>{
+                        var _component_interceptors, _config_interceptors;
+                        if ((_component_interceptors = component.interceptors) === null || _component_interceptors === void 0 ? void 0 : _component_interceptors.request) {
+                            component.interceptors.request(params);
+                        }
+                        if ((_config_interceptors = config.interceptors) === null || _config_interceptors === void 0 ? void 0 : _config_interceptors.request) {
+                            config.interceptors.request(params);
+                        }
+                    }
+                },
+                ...(((_component_interceptors1 = component.interceptors) === null || _component_interceptors1 === void 0 ? void 0 : _component_interceptors1.response) || ((_config_interceptors1 = config.interceptors) === null || _config_interceptors1 === void 0 ? void 0 : _config_interceptors1.response)) && {
+                    response: (data, params)=>{
+                        var _config_interceptors, _component_interceptors;
+                        if ((_config_interceptors = config.interceptors) === null || _config_interceptors === void 0 ? void 0 : _config_interceptors.response) {
+                            data = config.interceptors.response(data, params);
+                        }
+                        if ((_component_interceptors = component.interceptors) === null || _component_interceptors === void 0 ? void 0 : _component_interceptors.response) {
+                            data = component.interceptors.response(data, params);
+                        }
+                        return data;
+                    }
+                }
+            };
+            const isRest = 'method' in config;
+            if (isRest) acc.restRequestConfigs.push({
+                ...config,
+                interceptors,
+                path: config.path instanceof RegExp ? new RegExp(`${baseUrl}${config.path.source}`, config.path.flags) : `${baseUrl}${config.path}`
+            });
+            const isGraphql = 'operationType' in config;
+            if (isGraphql) acc.graphQLRequestConfigs.push({
+                ...config,
+                interceptors
+            });
+        });
+        return acc;
+    }, {
+        restRequestConfigs: [],
+        graphQLRequestConfigs: []
+    });
+    if (restRequestConfigs.length) {
+        const routerWithRestRoutes = (0, _rest.createRestRoutes)({
+            router: _express.default.Router(),
+            restConfig: {
+                configs: restRequestConfigs
+            },
+            serverResponseInterceptor: interceptors === null || interceptors === void 0 ? void 0 : interceptors.response
+        });
+        server.use(serverBaseUrl, routerWithRestRoutes);
+    }
+    if (graphQLRequestConfigs.length) {
+        const routerWithGraphQLRoutes = (0, _graphql.createGraphQLRoutes)({
+            router: _express.default.Router(),
+            graphqlConfig: {
+                configs: graphQLRequestConfigs
+            },
+            serverResponseInterceptor: interceptors === null || interceptors === void 0 ? void 0 : interceptors.response
+        });
+        server.use(serverBaseUrl, routerWithGraphQLRoutes);
+    }
+    (0, _middlewares.errorMiddleware)(server);
+    return server;
+};

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

@@ -1,3 +1,3 @@
 import type { Express } from 'express';
 import type { GraphQLMockServerConfig } from '../../utils/types';
-export declare const createGraphQLMockServer: (graphqlMockServerConfig: Omit<GraphQLMockServerConfig, 'port'>, server?: Express) => Express;
+export declare const createGraphQLMockServer: (graphqlMockServerConfig: Omit<GraphQLMockServerConfig, "port">, server?: Express) => Express;

package/dist/src/server/createGraphQLMockServer/createGraphQLMockServer.js

@@ -13,7 +13,7 @@ const _express = /*#__PURE__*/ _interop_require_default(require("express"));
 const _database = require("../../core/database");
 const _graphql = require("../../core/graphql");
 const _middlewares = require("../../core/middlewares");
-const _helpers = require("../../utils/helpers");
+const _validate = require("../../utils/validate");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -21,10 +21,8 @@ function _interop_require_default(obj) {
 }
 const createGraphQLMockServer = (graphqlMockServerConfig, server = (0, _express.default)())=>{
     var _graphqlMockServerConfig_interceptors;
+    (0, _validate.validateApiMockServerConfig)(graphqlMockServerConfig, 'graphql');
     const { cors, staticPath, configs, database, interceptors } = graphqlMockServerConfig;
-    server.set('view engine', 'ejs');
-    server.set('views', (0, _helpers.urlJoin)(__dirname, '../../static/views'));
-    server.use(_express.default.static((0, _helpers.urlJoin)(__dirname, '../../static/views')));
     server.use(_bodyparser.default.urlencoded({
         extended: false
     }));
@@ -33,7 +31,7 @@ const createGraphQLMockServer = (graphqlMockServerConfig, server = (0, _express.
     }));
     server.set('json spaces', 2);
     server.use(_bodyparser.default.text());
-    (0, _middlewares.contextMiddleware)(server);
+    (0, _middlewares.contextMiddleware)(server, graphqlMockServerConfig);
     (0, _middlewares.cookieParseMiddleware)(server);
     const serverRequestInterceptor = (_graphqlMockServerConfig_interceptors = graphqlMockServerConfig.interceptors) === null || _graphqlMockServerConfig_interceptors === void 0 ? void 0 : _graphqlMockServerConfig_interceptors.request;
     if (serverRequestInterceptor) {
@@ -64,7 +62,6 @@ const createGraphQLMockServer = (graphqlMockServerConfig, server = (0, _express.
         const routerWithDatabaseRoutes = (0, _database.createDatabaseRoutes)(_express.default.Router(), database);
         server.use(baseUrl, routerWithDatabaseRoutes);
     }
-    (0, _middlewares.notFoundMiddleware)(server, graphqlMockServerConfig);
     (0, _middlewares.errorMiddleware)(server);
     return server;
 };

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

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