mock-config-server 4.0.2 → 5.0.0-beta.0

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

@@ -0,0 +1,190 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createRestRoute", {
+    enumerable: true,
+    get: function() {
+        return createRestRoute;
+    }
+});
+const _flat = require("flat");
+const _helpers = require("../../../utils/helpers");
+const _helpers1 = require("./helpers");
+const extractPathParams = (artifact, path)=>{
+    var _fullPath_match;
+    if (artifact.path instanceof RegExp) return {};
+    const fullPath = (0, _helpers.urlJoin)(artifact.baseUrl, artifact.path);
+    var _fullPath_match_map;
+    const keys = (_fullPath_match_map = (_fullPath_match = fullPath.match(/:[^/]+/g)) === null || _fullPath_match === void 0 ? void 0 : _fullPath_match.map((key)=>key.slice(1))) !== null && _fullPath_match_map !== void 0 ? _fullPath_match_map : [];
+    if (!keys.length) return {};
+    const match = path.match((0, _helpers1.generatePathRegex)(fullPath));
+    if (!match) return {};
+    return keys.reduce((acc, key, index)=>{
+        acc[key] = decodeURIComponent(match[index + 1]);
+        return acc;
+    }, {});
+};
+const createRestRoute = ({ server, restRequestArtifacts })=>server.use((0, _helpers.asyncHandler)(async (request, response, next)=>{
+        var _matchedRouteConfig_config_settings, _matchedRouteConfig_config_settings1;
+        const requestMethod = request.method.toLowerCase();
+        const previousParams = {
+            ...request.params
+        };
+        const matchedRequestArtifacts = (0, _helpers1.matchRestRequestArtifacts)({
+            artifacts: restRequestArtifacts,
+            meta: {
+                method: requestMethod,
+                path: (0, _helpers.normalizeUrl)(request.path)
+            }
+        });
+        if (!matchedRequestArtifacts.length) return next();
+        const matchedRouteConfig = matchedRequestArtifacts.find((artifact)=>{
+            request.params = extractPathParams(artifact, request.path);
+            const { config } = artifact;
+            if (!config.entities) return true;
+            const entityEntries = Object.entries(config.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) {
+                    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) {
+                    if (!Array.isArray(request.body)) return false;
+                    return (0, _helpers.resolveEntityValues)({
+                        actualValue: request.body,
+                        descriptorValue: entityDescriptorOrValue,
+                        checkMode: 'equals'
+                    });
+                }
+                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
+                    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
+                    });
+                });
+            });
+        });
+        if (!matchedRouteConfig) {
+            request.params = previousParams;
+            return next();
+        }
+        if (matchedRouteConfig.componentRequestInterceptor) {
+            await (0, _helpers.callRequestInterceptor)({
+                request,
+                interceptor: matchedRouteConfig.componentRequestInterceptor
+            });
+        }
+        if (matchedRouteConfig.requestRequestInterceptor) {
+            await (0, _helpers.callRequestInterceptor)({
+                request,
+                interceptor: matchedRouteConfig.requestRequestInterceptor
+            });
+        }
+        if (matchedRouteConfig.routeRequestInterceptor) {
+            await (0, _helpers.callRequestInterceptor)({
+                request,
+                interceptor: matchedRouteConfig.routeRequestInterceptor
+            });
+        }
+        if ((_matchedRouteConfig_config_settings = matchedRouteConfig.config.settings) === null || _matchedRouteConfig_config_settings === void 0 ? void 0 : _matchedRouteConfig_config_settings.status) {
+            response.statusCode = matchedRouteConfig.config.settings.status;
+        }
+        // ✅ important:
+        // 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-store');
+        var _matchedRouteConfig_config_entities;
+        const params = {
+            request,
+            response,
+            next,
+            entities: (_matchedRouteConfig_config_entities = matchedRouteConfig.config.entities) !== null && _matchedRouteConfig_config_entities !== void 0 ? _matchedRouteConfig_config_entities : {},
+            appendHeader: (field, value)=>{
+                response.append(field, value);
+            },
+            attachment: (filename)=>{
+                response.attachment(filename);
+            },
+            clearCookie: (name, options)=>{
+                response.clearCookie(name, options);
+            },
+            getCookie: (name)=>request.cookies[name],
+            getRequestHeader: (field)=>request.headers[field],
+            getRequestHeaders: ()=>request.headers,
+            getResponseHeader: (field)=>response.getHeader(field),
+            getResponseHeaders: ()=>response.getHeaders(),
+            setCookie: (name, value, options)=>{
+                if (options) {
+                    response.cookie(name, value, options);
+                    return;
+                }
+                response.cookie(name, value);
+            },
+            setDelay: async (delay)=>{
+                await (0, _helpers.sleep)(delay === Infinity ? 99999999 : delay);
+            },
+            setHeader: (field, value)=>{
+                response.set(field, value);
+            },
+            setStatusCode: (statusCode)=>{
+                response.statusCode = statusCode;
+            }
+        };
+        const resolvedData = typeof matchedRouteConfig.config.data === 'function' ? await matchedRouteConfig.config.data(params) : matchedRouteConfig.config.data;
+        if (response.headersSent) {
+            return;
+        }
+        const data = await (0, _helpers.callResponseInterceptors)({
+            data: resolvedData,
+            request,
+            response,
+            interceptors: {
+                routeInterceptor: matchedRouteConfig.routeResponseInterceptor,
+                requestInterceptor: matchedRouteConfig.requestResponseInterceptor,
+                componentInterceptor: matchedRouteConfig.componentResponseInterceptor,
+                serverInterceptor: matchedRouteConfig.serverResponseInterceptor
+            }
+        });
+        if ((_matchedRouteConfig_config_settings1 = matchedRouteConfig.config.settings) === null || _matchedRouteConfig_config_settings1 === void 0 ? void 0 : _matchedRouteConfig_config_settings1.delay) {
+            await (0, _helpers.sleep)(matchedRouteConfig.config.settings.delay);
+        }
+        if (response.headersSent) {
+            return;
+        }
+        if (response.getHeader('content-type')) {
+            return response.send(data);
+        }
+        return response.json(data);
+    }));

package/dist/src/core/rest/createRestRoute/helpers/calculateRestRouteConfigWeight/calculateRestRouteConfigWeight.d.ts

@@ -0,0 +1,2 @@
+import type { RestMethod, RestRouteConfig } from '../../../../../utils/types';
+export declare const calculateRestRouteConfigWeight: (restRouteConfig: RestRouteConfig<RestMethod>) => number;

package/dist/src/core/rest/createRestRoute/helpers/calculateRestRouteConfigWeight/calculateRestRouteConfigWeight.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "calculateRestRouteConfigWeight", {
+    enumerable: true,
+    get: function() {
+        return calculateRestRouteConfigWeight;
+    }
+});
+const _helpers = require("../../../../../utils/helpers");
+const calculateRestRouteConfigWeight = (restRouteConfig)=>{
+    const { entities } = restRouteConfig;
+    if (!entities) return 0;
+    let routeConfigWeight = 0;
+    const { headers, cookies, query, params, body } = entities;
+    if (headers) routeConfigWeight += Object.keys(headers).length;
+    if (cookies) routeConfigWeight += Object.keys(cookies).length;
+    if (query) routeConfigWeight += Object.keys(query).length;
+    if (params) routeConfigWeight += Object.keys(params).length;
+    if (body) {
+        if ((0, _helpers.isPlainObject)(body) && body.checkMode) {
+            // ✅ important:
+            // check that actual value check modes does not have `value` for compare
+            if (body.checkMode === 'exists' || body.checkMode === 'notExists') {
+                routeConfigWeight += 1;
+                return routeConfigWeight;
+            }
+            routeConfigWeight += (0, _helpers.isPlainObject)(body.value) ? Object.keys(body.value).length : 1;
+            return routeConfigWeight;
+        }
+        routeConfigWeight += (0, _helpers.isPlainObject)(body) ? Object.keys(body).length : 1;
+    }
+    return routeConfigWeight;
+};

package/dist/src/core/rest/createRestRoute/helpers/index.d.ts

@@ -0,0 +1,3 @@
+export * from './calculateRestRouteConfigWeight/calculateRestRouteConfigWeight';
+export * from './matchRestRequestArtifacts/matchRestRequestArtifacts';
+export * from './prepareRestRequestArtifacts/prepareRestRequestArtifacts';

package/dist/src/core/rest/createRestRoute/helpers/index.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./calculateRestRouteConfigWeight/calculateRestRouteConfigWeight"), exports);
+_export_star(require("./matchRestRequestArtifacts/matchRestRequestArtifacts"), exports);
+_export_star(require("./prepareRestRequestArtifacts/prepareRestRequestArtifacts"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}

package/dist/src/core/rest/createRestRoute/helpers/matchRestRequestArtifacts/matchRestRequestArtifacts.d.ts

@@ -0,0 +1,11 @@
+import type { RestRequestArtifact } from '../../../../../utils/types';
+export declare const generatePathRegex: (path: string) => RegExp;
+interface MatchRestRequestArtifactsParams {
+    artifacts: RestRequestArtifact[];
+    meta: {
+        method: string;
+        path: string;
+    };
+}
+export declare const matchRestRequestArtifacts: ({ artifacts, meta }: MatchRestRequestArtifactsParams) => RestRequestArtifact[];
+export {};

package/dist/src/core/rest/createRestRoute/helpers/matchRestRequestArtifacts/matchRestRequestArtifacts.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get generatePathRegex () {
+        return generatePathRegex;
+    },
+    get matchRestRequestArtifacts () {
+        return matchRestRequestArtifacts;
+    }
+});
+const _helpers = require("../../../../../utils/helpers");
+const generatePathRegex = (path)=>new RegExp(`^${path.split('/').map((part)=>part.startsWith(':') ? '([^/]+)' : part.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('/')}$`);
+const matchRestRequestArtifacts = ({ artifacts, meta })=>artifacts.filter((artifact)=>{
+        if (!meta.path.startsWith(artifact.baseUrl)) return false;
+        if (artifact.method !== meta.method) return false;
+        if (artifact.path instanceof RegExp) {
+            if (artifact.baseUrl === '/') return new RegExp(artifact.path).test(meta.path);
+            const tail = meta.path === artifact.baseUrl ? '' : meta.path.slice(artifact.baseUrl.length);
+            if (!tail) return false;
+            return new RegExp(artifact.path).test(tail);
+        }
+        return generatePathRegex((0, _helpers.urlJoin)(artifact.baseUrl, artifact.path)).test(meta.path);
+    });

package/dist/src/core/rest/createRestRoute/helpers/prepareRestRequestArtifacts/prepareRestRequestArtifacts.d.ts

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

package/dist/src/core/rest/createRestRoute/helpers/prepareRestRequestArtifacts/prepareRestRequestArtifacts.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "prepareRestRequestArtifacts", {
+    enumerable: true,
+    get: function() {
+        return prepareRestRequestArtifacts;
+    }
+});
+const prepareRestRequestArtifacts = (requestArtifacts)=>{
+    const sortedByPathRequestArtifacts = requestArtifacts.toSorted((first, second)=>second.weight - first.weight).toSorted(({ path: firstPath }, { path: secondPath })=>{
+        // ✅ important:
+        // do not compare RegExp paths and non-parameterized paths
+        if (firstPath instanceof RegExp || secondPath instanceof RegExp) return 0;
+        if (!firstPath.includes('/:') && !secondPath.includes('/:')) return 0;
+        const firstPathParts = firstPath.split('/');
+        const secondPathParts = secondPath.split('/');
+        const minimalPathPartsLength = Math.min(firstPathParts.length, secondPathParts.length);
+        // ✅ important:
+        // need to find the leftmost parameter/non-parameter pair and give priority to non-parameter one
+        for(let i = 0; i < minimalPathPartsLength; i += 1){
+            const firstPathPart = firstPathParts[i];
+            const secondPathPart = secondPathParts[i];
+            const isFirstPathPartParameter = firstPathPart.startsWith(':');
+            const isSecondPathPartParameter = secondPathPart.startsWith(':');
+            if (!isFirstPathPartParameter && !isSecondPathPartParameter) {
+                if (firstPathPart === secondPathPart) continue;
+                return 0;
+            }
+            if (isFirstPathPartParameter && isSecondPathPartParameter) continue;
+            return +isFirstPathPartParameter - +isSecondPathPartParameter;
+        }
+        return 0;
+    });
+    return sortedByPathRequestArtifacts;
+};

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

@@ -1 +1,2 @@
-export * from './createRestRoutes/createRestRoutes';
+export * from './createRestRoute/createRestRoute';
+export * from './createRestRoute/helpers';

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

@@ -2,7 +2,8 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-_export_star(require("./createRestRoutes/createRestRoutes"), exports);
+_export_star(require("./createRestRoute/createRestRoute"), exports);
+_export_star(require("./createRestRoute/helpers"), exports);
 function _export_star(from, to) {
     Object.keys(from).forEach(function(k) {
         if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {

package/dist/src/index.d.ts

@@ -1,2 +1,3 @@
+export * from './core/functions';
 export * from './server';
 export * from './utils/types';

package/dist/src/index.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
+_export_star(require("./core/functions"), exports);
 _export_star(require("./server"), exports);
 _export_star(require("./utils/types"), exports);
 function _export_star(from, to) {

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: MockServerConfig, server?: Express) => Express;

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

@@ -22,9 +22,10 @@ function _interop_require_default(obj) {
     };
 }
 const createMockServer = (mockServerConfig, server = (0, _express.default)())=>{
-    var _mockServerConfig_interceptors;
     (0, _validate.validateMockServerConfig)(mockServerConfig);
-    const { cors, staticPath, rest, graphql, database, interceptors } = mockServerConfig;
+    const [option, ...mockServerComponents] = mockServerConfig;
+    const mockServerSettings = !('configs' in option) ? option : undefined;
+    const { cors, staticPath, interceptors, baseUrl: serverBaseUrl = '/', database } = mockServerSettings !== null && mockServerSettings !== void 0 ? mockServerSettings : {};
     server.use(_bodyparser.default.urlencoded({
         extended: false
     }));
@@ -33,66 +34,96 @@ const createMockServer = (mockServerConfig, server = (0, _express.default)())=>{
     }));
     server.set('json spaces', 2);
     server.use(_bodyparser.default.text());
-    (0, _middlewares.contextMiddleware)(server, mockServerConfig);
+    (0, _middlewares.contextMiddleware)(server, {
+        database
+    });
     (0, _middlewares.cookieParseMiddleware)(server);
-    const serverRequestInterceptor = (_mockServerConfig_interceptors = mockServerConfig.interceptors) === null || _mockServerConfig_interceptors === void 0 ? void 0 : _mockServerConfig_interceptors.request;
+    const serverRequestInterceptor = interceptors === null || interceptors === void 0 ? void 0 : interceptors.request;
     if (serverRequestInterceptor) {
         (0, _middlewares.requestInterceptorMiddleware)({
             server,
             interceptor: serverRequestInterceptor
         });
     }
-    var _mockServerConfig_baseUrl;
-    const baseUrl = (_mockServerConfig_baseUrl = mockServerConfig.baseUrl) !== null && _mockServerConfig_baseUrl !== void 0 ? _mockServerConfig_baseUrl : '/';
     if (cors) {
         (0, _middlewares.corsMiddleware)(server, cors);
     } else {
         (0, _middlewares.noCorsMiddleware)(server);
     }
     if (staticPath) {
-        (0, _middlewares.staticMiddleware)(server, baseUrl, staticPath);
+        (0, _middlewares.staticMiddleware)(server, serverBaseUrl, staticPath);
     }
-    if (rest) {
-        var _rest_interceptors;
-        const routerWithRestRoutes = (0, _rest.createRestRoutes)({
-            router: _express.default.Router(),
-            restConfig: rest,
-            serverResponseInterceptor: interceptors === null || interceptors === void 0 ? void 0 : interceptors.response
-        });
-        var _rest_baseUrl;
-        const restBaseUrl = (0, _helpers.urlJoin)(baseUrl, (_rest_baseUrl = rest.baseUrl) !== null && _rest_baseUrl !== void 0 ? _rest_baseUrl : '/');
-        const apiRequestInterceptor = (_rest_interceptors = rest.interceptors) === null || _rest_interceptors === void 0 ? void 0 : _rest_interceptors.request;
-        if (apiRequestInterceptor) {
-            (0, _middlewares.requestInterceptorMiddleware)({
-                server,
-                path: restBaseUrl,
-                interceptor: apiRequestInterceptor
-            });
-        }
-        server.use(restBaseUrl, routerWithRestRoutes);
+    if (database) {
+        const routerWithDatabaseRoutes = (0, _database.createDatabaseRoutes)(_express.default.Router(), database);
+        server.use(serverBaseUrl, routerWithDatabaseRoutes);
     }
-    if (graphql) {
-        var _graphql_interceptors;
-        const routerWithGraphQLRoutes = (0, _graphql.createGraphQLRoutes)({
-            router: _express.default.Router(),
-            graphqlConfig: graphql,
-            serverResponseInterceptor: interceptors === null || interceptors === void 0 ? void 0 : interceptors.response
+    const components = mockServerSettings ? mockServerComponents : mockServerConfig;
+    const { restRequestsArtifacts, graphQLRequestsArtifacts } = components.reduce((acc, component)=>{
+        component.configs.forEach((config)=>{
+            const isRest = 'method' in config;
+            if (isRest) {
+                config.routes.forEach((route)=>{
+                    var _config_interceptors, _config_interceptors1, _component_interceptors, _component_interceptors1, _route_interceptors, _route_interceptors1;
+                    var _component_baseUrl;
+                    acc.restRequestsArtifacts.push({
+                        baseUrl: (0, _helpers.urlJoin)(serverBaseUrl !== null && serverBaseUrl !== void 0 ? serverBaseUrl : '/', (_component_baseUrl = component.baseUrl) !== null && _component_baseUrl !== void 0 ? _component_baseUrl : ''),
+                        method: config.method,
+                        path: config.path,
+                        config: route,
+                        weight: (0, _rest.calculateRestRouteConfigWeight)(route),
+                        serverResponseInterceptor: interceptors === null || interceptors === void 0 ? void 0 : interceptors.response,
+                        serverRequestInterceptor: interceptors === null || interceptors === void 0 ? void 0 : interceptors.request,
+                        requestResponseInterceptor: (_config_interceptors = config.interceptors) === null || _config_interceptors === void 0 ? void 0 : _config_interceptors.response,
+                        requestRequestInterceptor: (_config_interceptors1 = config.interceptors) === null || _config_interceptors1 === void 0 ? void 0 : _config_interceptors1.request,
+                        componentResponseInterceptor: (_component_interceptors = component.interceptors) === null || _component_interceptors === void 0 ? void 0 : _component_interceptors.response,
+                        componentRequestInterceptor: (_component_interceptors1 = component.interceptors) === null || _component_interceptors1 === void 0 ? void 0 : _component_interceptors1.request,
+                        routeResponseInterceptor: (_route_interceptors = route.interceptors) === null || _route_interceptors === void 0 ? void 0 : _route_interceptors.response,
+                        routeRequestInterceptor: (_route_interceptors1 = route.interceptors) === null || _route_interceptors1 === void 0 ? void 0 : _route_interceptors1.request
+                    });
+                });
+            }
+            const isGraphql = 'operationType' in config;
+            if (isGraphql) {
+                config.routes.forEach((route)=>{
+                    var _config_interceptors, _config_interceptors1, _component_interceptors, _component_interceptors1, _route_interceptors, _route_interceptors1;
+                    var _component_baseUrl;
+                    acc.graphQLRequestsArtifacts.push({
+                        baseUrl: (0, _helpers.urlJoin)(serverBaseUrl !== null && serverBaseUrl !== void 0 ? serverBaseUrl : '/', (_component_baseUrl = component.baseUrl) !== null && _component_baseUrl !== void 0 ? _component_baseUrl : ''),
+                        operationType: config.operationType,
+                        operationName: 'operationName' in config ? config.operationName : undefined,
+                        query: 'query' in config ? config.query : undefined,
+                        config: route,
+                        weight: (0, _graphql.calculateGraphQLRouteConfigWeight)(route),
+                        serverResponseInterceptor: interceptors === null || interceptors === void 0 ? void 0 : interceptors.response,
+                        serverRequestInterceptor: interceptors === null || interceptors === void 0 ? void 0 : interceptors.request,
+                        requestResponseInterceptor: (_config_interceptors = config.interceptors) === null || _config_interceptors === void 0 ? void 0 : _config_interceptors.response,
+                        requestRequestInterceptor: (_config_interceptors1 = config.interceptors) === null || _config_interceptors1 === void 0 ? void 0 : _config_interceptors1.request,
+                        componentResponseInterceptor: (_component_interceptors = component.interceptors) === null || _component_interceptors === void 0 ? void 0 : _component_interceptors.response,
+                        componentRequestInterceptor: (_component_interceptors1 = component.interceptors) === null || _component_interceptors1 === void 0 ? void 0 : _component_interceptors1.request,
+                        routeResponseInterceptor: (_route_interceptors = route.interceptors) === null || _route_interceptors === void 0 ? void 0 : _route_interceptors.response,
+                        routeRequestInterceptor: (_route_interceptors1 = route.interceptors) === null || _route_interceptors1 === void 0 ? void 0 : _route_interceptors1.request
+                    });
+                });
+            }
+        });
+        return acc;
+    }, {
+        restRequestsArtifacts: [],
+        graphQLRequestsArtifacts: []
+    });
+    const preparedRestRequestArtifacts = (0, _rest.prepareRestRequestArtifacts)(restRequestsArtifacts);
+    const preparedGraphQLRequestArtifacts = (0, _graphql.prepareGraphQLRequestArtifacts)(graphQLRequestsArtifacts);
+    if (preparedRestRequestArtifacts.length) {
+        (0, _rest.createRestRoute)({
+            server,
+            restRequestArtifacts: preparedRestRequestArtifacts
         });
-        var _graphql_baseUrl;
-        const graphqlBaseUrl = (0, _helpers.urlJoin)(baseUrl, (_graphql_baseUrl = graphql.baseUrl) !== null && _graphql_baseUrl !== void 0 ? _graphql_baseUrl : '/');
-        const apiRequestInterceptor = (_graphql_interceptors = graphql.interceptors) === null || _graphql_interceptors === void 0 ? void 0 : _graphql_interceptors.request;
-        if (apiRequestInterceptor) {
-            (0, _middlewares.requestInterceptorMiddleware)({
-                server,
-                path: graphqlBaseUrl,
-                interceptor: apiRequestInterceptor
-            });
-        }
-        server.use(graphqlBaseUrl, routerWithGraphQLRoutes);
     }
-    if (database) {
-        const routerWithDatabaseRoutes = (0, _database.createDatabaseRoutes)(_express.default.Router(), database);
-        server.use(baseUrl, routerWithDatabaseRoutes);
+    if (preparedGraphQLRequestArtifacts.length) {
+        (0, _graphql.createGraphQLRoute)({
+            server,
+            graphQLRequestArtifacts: preparedGraphQLRequestArtifacts
+        });
     }
     (0, _middlewares.errorMiddleware)(server);
     return server;

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

@@ -1,10 +1,2 @@
-export * from './createDatabaseMockServer/createDatabaseMockServer';
-export * from './createFlatMockServer/createFlatMockServer';
-export * from './createGraphQLMockServer/createGraphQLMockServer';
 export * from './createMockServer/createMockServer';
-export * from './createRestMockServer/createRestMockServer';
-export * from './startDatabaseMockServer/startDatabaseMockServer';
-export * from './startFlatMockServer/startFlatMockServer';
-export * from './startGraphQLMockServer/startGraphQLMockServer';
 export * from './startMockServer/startMockServer';
-export * from './startRestMockServer/startRestMockServer';

package/dist/src/server/index.js

@@ -2,16 +2,8 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-_export_star(require("./createDatabaseMockServer/createDatabaseMockServer"), exports);
-_export_star(require("./createFlatMockServer/createFlatMockServer"), exports);
-_export_star(require("./createGraphQLMockServer/createGraphQLMockServer"), exports);
 _export_star(require("./createMockServer/createMockServer"), exports);
-_export_star(require("./createRestMockServer/createRestMockServer"), exports);
-_export_star(require("./startDatabaseMockServer/startDatabaseMockServer"), exports);
-_export_star(require("./startFlatMockServer/startFlatMockServer"), exports);
-_export_star(require("./startGraphQLMockServer/startGraphQLMockServer"), exports);
 _export_star(require("./startMockServer/startMockServer"), exports);
-_export_star(require("./startRestMockServer/startRestMockServer"), exports);
 function _export_star(from, to) {
     Object.keys(from).forEach(function(k) {
         if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {

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

@@ -1,4 +1,4 @@
 import type { MockServerConfig } from '../../utils/types';
-export declare const startMockServer: (mockServerConfig: MockServerConfig) => import("http").Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse> & {
-    destroy: import("http").Server["close"];
+export declare const startMockServer: (mockServerConfig: MockServerConfig) => import("node:http").Server<typeof import("node:http").IncomingMessage, typeof import("node:http").ServerResponse> & {
+    destroy: import("node:http").Server["close"];
 };

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

@@ -19,10 +19,11 @@ function _interop_require_default(obj) {
 }
 const startMockServer = (mockServerConfig)=>{
     const mockServer = (0, _createMockServer.createMockServer)(mockServerConfig);
-    var _mockServerConfig_port;
-    const port = (_mockServerConfig_port = mockServerConfig.port) !== null && _mockServerConfig_port !== void 0 ? _mockServerConfig_port : _constants.DEFAULT.PORT;
+    const [option] = mockServerConfig;
+    const mockServerSettings = !('configs' in option) ? option : {};
+    const { port = _constants.DEFAULT.PORT } = mockServerSettings;
     const server = mockServer.listen(port, ()=>{
-        console.info(_ansicolors.default.green(`🎉 Mock Server is running at http://localhost:${port}`));
+        console.log(_ansicolors.default.green(`🎉 Mock Server is running at http://localhost:${port}`));
     });
     // ✅ important: add destroy method for closing keep-alive connections after server shutdown
     return (0, _middlewares.destroyerMiddleware)(server);

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

@@ -5,26 +5,26 @@ Object.defineProperty(exports, "__esModule", {
 function _export(target, all) {
     for(var name in all)Object.defineProperty(target, name, {
         enumerable: true,
-        get: all[name]
+        get: Object.getOwnPropertyDescriptor(all, name).get
     });
 }
 _export(exports, {
-    CALCULATE_BY_DESCRIPTOR_VALUE_CHECK_MODES: function() {
+    get CALCULATE_BY_DESCRIPTOR_VALUE_CHECK_MODES () {
         return CALCULATE_BY_DESCRIPTOR_VALUE_CHECK_MODES;
     },
-    CHECK_ACTUAL_VALUE_CHECK_MODES: function() {
+    get CHECK_ACTUAL_VALUE_CHECK_MODES () {
         return CHECK_ACTUAL_VALUE_CHECK_MODES;
     },
-    COMPARE_WITH_DESCRIPTOR_ANY_VALUE_CHECK_MODES: function() {
+    get COMPARE_WITH_DESCRIPTOR_ANY_VALUE_CHECK_MODES () {
         return COMPARE_WITH_DESCRIPTOR_ANY_VALUE_CHECK_MODES;
     },
-    COMPARE_WITH_DESCRIPTOR_STRING_VALUE_CHECK_MODES: function() {
+    get COMPARE_WITH_DESCRIPTOR_STRING_VALUE_CHECK_MODES () {
         return COMPARE_WITH_DESCRIPTOR_STRING_VALUE_CHECK_MODES;
     },
-    COMPARE_WITH_DESCRIPTOR_VALUE_CHECK_MODES: function() {
+    get COMPARE_WITH_DESCRIPTOR_VALUE_CHECK_MODES () {
         return COMPARE_WITH_DESCRIPTOR_VALUE_CHECK_MODES;
     },
-    NEGATIVE_CHECK_MODES: function() {
+    get NEGATIVE_CHECK_MODES () {
         return NEGATIVE_CHECK_MODES;
     }
 });

package/dist/src/utils/helpers/config/resolveEntityValues/resolveEntityValues.js

@@ -13,7 +13,7 @@ const _constants = require("../../../constants");
 const _isPlainObject = require("../../isPlainObject/isPlainObject");
 const _isPrimitive = require("../../isPrimitive/isPrimitive");
 const checkFunction = (checkMode, actualValue, descriptorValue)=>{
-    const isActualValueUndefined = typeof actualValue === 'undefined';
+    const isActualValueUndefined = actualValue === undefined;
     if (checkMode === 'exists') return !isActualValueUndefined;
     if (checkMode === 'notExists') return isActualValueUndefined;
     if (checkMode === 'function') {