mock-config-server 4.0.3 → 5.0.0-beta.1

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') {

package/dist/src/utils/helpers/files/isFileDescriptor/isFileDescriptor.js

@@ -8,9 +8,9 @@ Object.defineProperty(exports, "isFileDescriptor", {
         return isFileDescriptor;
     }
 });
-const _nodebuffer = require("node:buffer");
+const _buffer = require("buffer");
 const _zod = require("zod");
 const isFileDescriptor = (value)=>_zod.z.object({
         path: _zod.z.string(),
-        file: _zod.z.instanceof(_nodebuffer.Buffer)
+        file: _zod.z.instanceof(_buffer.Buffer)
     }).strict().safeParse(value).success;

package/dist/src/utils/helpers/files/isFilePathValid/isFilePathValid.js

@@ -8,7 +8,7 @@ Object.defineProperty(exports, "isFilePathValid", {
         return isFilePathValid;
     }
 });
-const _nodefs = /*#__PURE__*/ _interop_require_default(require("node:fs"));
+const _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -16,8 +16,8 @@ function _interop_require_default(obj) {
 }
 const isFilePathValid = (path)=>{
     try {
-        if (!_nodefs.default.existsSync(path)) return false;
-        if (!_nodefs.default.statSync(path).isFile()) return false;
+        if (!_fs.default.existsSync(path)) return false;
+        if (!_fs.default.statSync(path).isFile()) return false;
         return true;
     } catch (error) {
         console.error(error);

package/dist/src/utils/helpers/interceptors/callResponseInterceptors/callResponseInterceptors.d.ts

@@ -2,14 +2,14 @@ import type { Request, Response } from 'express';
 import type { Data, ResponseInterceptor } from '../../../types';
 interface CallResponseInterceptorsParams {
     data: Data;
-    request: Request;
-    response: Response;
     interceptors?: {
         routeInterceptor?: ResponseInterceptor;
         requestInterceptor?: ResponseInterceptor;
-        apiInterceptor?: ResponseInterceptor;
+        componentInterceptor?: ResponseInterceptor;
         serverInterceptor?: ResponseInterceptor;
     };
+    request: Request;
+    response: Response;
 }
 export declare const callResponseInterceptors: (params: CallResponseInterceptorsParams) => Promise<Data>;
 export {};

package/dist/src/utils/helpers/interceptors/callResponseInterceptors/callResponseInterceptors.js

@@ -70,8 +70,8 @@ const callResponseInterceptors = async (params)=>{
     if (interceptors === null || interceptors === void 0 ? void 0 : interceptors.requestInterceptor) {
         updatedData = await interceptors.requestInterceptor(updatedData, responseInterceptorParams);
     }
-    if (interceptors === null || interceptors === void 0 ? void 0 : interceptors.apiInterceptor) {
-        updatedData = await interceptors.apiInterceptor(updatedData, responseInterceptorParams);
+    if (interceptors === null || interceptors === void 0 ? void 0 : interceptors.componentInterceptor) {
+        updatedData = await interceptors.componentInterceptor(updatedData, responseInterceptorParams);
     }
     if (interceptors === null || interceptors === void 0 ? void 0 : interceptors.serverInterceptor) {
         updatedData = await interceptors.serverInterceptor(updatedData, responseInterceptorParams);

package/dist/src/utils/helpers/tests/createTmpDir.js

@@ -8,12 +8,12 @@ Object.defineProperty(exports, "createTmpDir", {
         return createTmpDir;
     }
 });
-const _nodefs = /*#__PURE__*/ _interop_require_default(require("node:fs"));
-const _nodeos = /*#__PURE__*/ _interop_require_default(require("node:os"));
-const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
+const _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
+const _os = /*#__PURE__*/ _interop_require_default(require("os"));
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
 }
-const createTmpDir = ()=>_nodefs.default.mkdtempSync(`${_nodeos.default.tmpdir()}${_nodepath.default.sep}`);
+const createTmpDir = ()=>_fs.default.mkdtempSync(`${_os.default.tmpdir()}${_path.default.sep}`);

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

@@ -1,4 +1,3 @@
 export * from './convertWin32PathToUnix/convertWin32PathToUnix';
-export * from './getUrlParts/getUrlParts';
-export * from './removeLeadingAndTrailingSlashes/removeLeadingAndTrailingSlashes';
+export * from './normalizeUrl/normalizeUrl';
 export * from './urlJoin/urlJoin';

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

@@ -3,8 +3,7 @@ Object.defineProperty(exports, "__esModule", {
     value: true
 });
 _export_star(require("./convertWin32PathToUnix/convertWin32PathToUnix"), exports);
-_export_star(require("./getUrlParts/getUrlParts"), exports);
-_export_star(require("./removeLeadingAndTrailingSlashes/removeLeadingAndTrailingSlashes"), exports);
+_export_star(require("./normalizeUrl/normalizeUrl"), exports);
 _export_star(require("./urlJoin/urlJoin"), exports);
 function _export_star(from, to) {
     Object.keys(from).forEach(function(k) {

package/dist/src/utils/helpers/url/normalizeUrl/normalizeUrl.d.ts

@@ -0,0 +1 @@
+export declare const normalizeUrl: (url: string) => string;

package/dist/src/utils/helpers/url/normalizeUrl/normalizeUrl.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "normalizeUrl", {
+    enumerable: true,
+    get: function() {
+        return normalizeUrl;
+    }
+});
+const normalizeUrl = (url)=>{
+    if (!url || url === '/') return '/';
+    const normalizedUrl = url.replace(/\/+$/g, '');
+    return normalizedUrl || '/';
+};

package/dist/src/utils/helpers/url/urlJoin/urlJoin.js

@@ -8,8 +8,8 @@ Object.defineProperty(exports, "urlJoin", {
         return urlJoin;
     }
 });
-const _nodeos = /*#__PURE__*/ _interop_require_default(require("node:os"));
-const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
+const _os = /*#__PURE__*/ _interop_require_default(require("os"));
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
 const _convertWin32PathToUnix = require("../convertWin32PathToUnix/convertWin32PathToUnix");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
@@ -17,6 +17,6 @@ function _interop_require_default(obj) {
     };
 }
 const urlJoin = (...paths)=>{
-    const pathsToJoin = _nodeos.default.platform() === 'win32' ? paths.map((path)=>(0, _convertWin32PathToUnix.convertWin32PathToUnix)(path)) : paths;
-    return _nodepath.default.posix.join(...pathsToJoin);
+    const pathsToJoin = _os.default.platform() === 'win32' ? paths.map((path)=>(0, _convertWin32PathToUnix.convertWin32PathToUnix)(path)) : paths;
+    return _path.default.posix.join(...pathsToJoin);
 };

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

@@ -1,6 +1,7 @@
-import type { Request } from 'express';
+import type { CookieOptions, Response as ExpressResponse, Request } from 'express';
 import type { MappedEntity, VariablesPlainEntity } from './entities';
 import type { Interceptors } from './interceptors';
+import type { BaseUrl } from './server';
 import type { Data } from './values';
 export type GraphQLEntityName = 'cookies' | 'headers' | 'query' | 'variables';
 export type GraphQLEntity<EntityName extends GraphQLEntityName = GraphQLEntityName> = EntityName extends 'variables' ? VariablesPlainEntity : MappedEntity;
@@ -9,29 +10,38 @@ export type GraphQLOperationName = string | RegExp;
 export type GraphQLEntitiesByEntityName = {
     [EntityName in GraphQLEntityName]?: GraphQLEntity<EntityName>;
 };
-interface GraphQLSettings {
+export interface GraphQLSettings {
     readonly delay?: number;
-    readonly polling?: boolean;
     readonly status?: number;
 }
-export type GraphqlDataResponse = ((request: Request, entities: GraphQLEntitiesByEntityName) => Data | Promise<Data>) | Data;
-export type GraphQLRouteConfig = ({
-    settings: GraphQLSettings & {
-        polling: true;
-    };
-    queue: Array<{
-        time?: number;
-        data: GraphqlDataResponse;
-    }>;
-} | {
-    settings?: GraphQLSettings & {
-        polling?: false;
-    };
+type GraphQLCookieValue = string | undefined;
+type GraphQLHeaderValue = number | string | string[] | undefined;
+export interface GraphQLParams<Query = Record<string, unknown>, Body = Record<string, unknown>, Params = Record<string, unknown>, Response = any> {
+    entities: GraphQLEntitiesByEntityName;
+    request: Request<Params, Response, Body, Query>;
+    response: ExpressResponse;
+    appendHeader: (field: string, value?: string | string[]) => void;
+    attachment: (filename: string) => void;
+    clearCookie: (name: string, options?: CookieOptions) => void;
+    getCookie: (name: string) => GraphQLCookieValue;
+    getRequestHeader: (field: string) => GraphQLHeaderValue;
+    getRequestHeaders: () => Record<string, GraphQLHeaderValue>;
+    getResponseHeader: (field: string) => GraphQLHeaderValue;
+    getResponseHeaders: () => Record<string, GraphQLHeaderValue>;
+    next: () => void;
+    setCookie: (name: string, value: string, options?: CookieOptions) => void;
+    setDelay: (delay: number) => Promise<void>;
+    setHeader: (field: string, value?: string | string[]) => void;
+    setStatusCode: (statusCode: number) => void;
+}
+export type GraphqlDataResponseFunction = (params: GraphQLParams) => Data | Promise<Data>;
+export type GraphqlDataResponse = Data | GraphqlDataResponseFunction;
+export interface GraphQLRouteConfig {
     data: GraphqlDataResponse;
-}) & {
     entities?: GraphQLEntitiesByEntityName;
     interceptors?: Interceptors<'graphql'>;
-};
+    settings?: GraphQLSettings;
+}
 interface BaseGraphQLRequestConfig {
     interceptors?: Interceptors<'graphql'>;
     operationType: GraphQLOperationType;
@@ -44,4 +54,20 @@ interface QueryGraphQLRequestConfig extends BaseGraphQLRequestConfig {
     query: string;
 }
 export type GraphQLRequestConfig = OperationNameGraphQLRequestConfig | QueryGraphQLRequestConfig;
+export interface GraphQLRequestArtifact {
+    baseUrl: BaseUrl;
+    componentRequestInterceptor?: Interceptors<'graphql'>['request'];
+    componentResponseInterceptor?: Interceptors<'graphql'>['response'];
+    config: GraphQLRouteConfig;
+    operationName?: GraphQLOperationName;
+    operationType: GraphQLOperationType;
+    query?: string;
+    requestRequestInterceptor?: Interceptors<'graphql'>['request'];
+    requestResponseInterceptor?: Interceptors<'graphql'>['response'];
+    routeRequestInterceptor?: Interceptors<'graphql'>['request'];
+    routeResponseInterceptor?: Interceptors<'graphql'>['response'];
+    serverRequestInterceptor?: Interceptors<'graphql'>['request'];
+    serverResponseInterceptor?: Interceptors<'graphql'>['response'];
+    weight: number;
+}
 export {};

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

@@ -1,6 +1,7 @@
-import type { Request } from 'express';
+import type { CookieOptions, Response as ExpressResponse, Request } from 'express';
 import type { BodyPlainEntity, MappedEntity } from './entities';
 import type { Interceptors } from './interceptors';
+import type { BaseUrl } from './server';
 import type { Data } from './values';
 export type RestMethod = 'delete' | 'get' | 'options' | 'patch' | 'post' | 'put';
 export type RestEntityName = 'body' | 'cookies' | 'headers' | 'params' | 'query';
@@ -11,40 +12,41 @@ export type RestEntityNamesByMethod = {
 export type RestEntitiesByEntityName<Method extends RestMethod = RestMethod> = {
     [EntityName in RestEntityNamesByMethod[Method]]?: RestEntity<EntityName>;
 };
-interface RestSettings {
+export interface RestSettings {
     readonly delay?: number;
-    readonly polling?: boolean;
     readonly status?: number;
 }
-export type RestDataResponse<Method extends RestMethod = RestMethod> = ((request: Request, entities: RestEntitiesByEntityName<Method>) => Data | Promise<Data>) | Data;
+type RestCookieValue = string | undefined;
+type RestHeaderValue = number | string | string[] | undefined;
+export interface RestParams<Method extends RestMethod = RestMethod, Query = Record<string, unknown>, Body = Record<string, unknown>, Params = Record<string, unknown>, Response = any> {
+    entities: RestEntitiesByEntityName<Method>;
+    request: Request<Params, Response, Body, Query>;
+    response: ExpressResponse;
+    appendHeader: (field: string, value?: string | string[]) => void;
+    attachment: (filename: string) => void;
+    clearCookie: (name: string, options?: CookieOptions) => void;
+    getCookie: (name: string) => RestCookieValue;
+    getRequestHeader: (field: string) => RestHeaderValue;
+    getRequestHeaders: () => Record<string, RestHeaderValue>;
+    getResponseHeader: (field: string) => RestHeaderValue;
+    getResponseHeaders: () => Record<string, RestHeaderValue>;
+    next: () => void;
+    setCookie: (name: string, value: string, options?: CookieOptions) => void;
+    setDelay: (delay: number) => Promise<void>;
+    setHeader: (field: string, value?: string | string[]) => void;
+    setStatusCode: (statusCode: number) => void;
+}
+export type RestDataResponseFunction<Method extends RestMethod = RestMethod> = (params: RestParams<Method>) => Data | Promise<Data>;
+export type RestDataResponse<Method extends RestMethod = RestMethod> = Data | RestDataResponseFunction<Method>;
 export type RestFileResponse = string;
-export type RestRouteConfig<Method extends RestMethod> = ({
-    settings: RestSettings & {
-        polling: true;
-    };
-    queue: Array<{
-        time?: number;
-        data: RestDataResponse<Method>;
-    } | {
-        time?: number;
-        file: RestFileResponse;
-    }>;
-} | {
-    settings?: RestSettings & {
-        polling?: false;
-    };
+export interface RestRouteConfig<Method extends RestMethod> {
     data: RestDataResponse<Method>;
-} | {
-    settings?: RestSettings & {
-        polling?: false;
-    };
-    file: RestFileResponse;
-}) & {
     entities?: RestEntitiesByEntityName<Method>;
     interceptors?: Interceptors<'rest'>;
-};
+    settings?: RestSettings;
+}
 export type RestPathString = `/${string}`;
-interface BaseRestRequestConfig<Method extends RestMethod> {
+export interface BaseRestRequestConfig<Method extends RestMethod> {
     interceptors?: Interceptors<'rest'>;
     method: Method;
     path: RegExp | RestPathString;
@@ -57,4 +59,19 @@ type RestDeleteRequestConfig = BaseRestRequestConfig<'delete'>;
 type RestPatchRequestConfig = BaseRestRequestConfig<'patch'>;
 type RestOptionsRequestConfig = BaseRestRequestConfig<'options'>;
 export type RestRequestConfig = RestDeleteRequestConfig | RestGetRequestConfig | RestOptionsRequestConfig | RestPatchRequestConfig | RestPostRequestConfig | RestPutRequestConfig;
+export interface RestRequestArtifact {
+    baseUrl: BaseUrl;
+    componentRequestInterceptor?: Interceptors<'rest'>['request'];
+    componentResponseInterceptor?: Interceptors<'rest'>['response'];
+    config: RestRouteConfig<RestMethod>;
+    method: RestMethod;
+    path: RegExp | RestPathString;
+    requestRequestInterceptor?: Interceptors<'rest'>['request'];
+    requestResponseInterceptor?: Interceptors<'rest'>['response'];
+    routeRequestInterceptor?: Interceptors<'rest'>['request'];
+    routeResponseInterceptor?: Interceptors<'rest'>['response'];
+    serverRequestInterceptor?: Interceptors<'rest'>['request'];
+    serverResponseInterceptor?: Interceptors<'rest'>['response'];
+    weight: number;
+}
 export {};

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

@@ -35,31 +35,14 @@ export interface DatabaseConfig {
     data: `${string}.json` | Record<string, unknown>;
     routes?: `${string}.json` | Record<`/${string}`, `/${string}`>;
 }
-export interface BaseMockServerConfig {
+export interface BaseServerConfig {
     baseUrl?: BaseUrl;
     cors?: Cors;
     interceptors?: Interceptors;
     port?: Port;
     staticPath?: StaticPath;
 }
-export interface MockServerConfig extends BaseMockServerConfig {
-    database?: DatabaseConfig;
-    graphql?: GraphqlConfig;
-    rest?: RestConfig;
-}
-export interface RestMockServerConfig extends BaseMockServerConfig {
-    configs?: RestRequestConfig[];
-    database?: DatabaseConfig;
-}
-export interface GraphQLMockServerConfig extends BaseMockServerConfig {
-    configs?: GraphQLRequestConfig[];
-    database?: DatabaseConfig;
-}
-export interface DatabaseMockServerConfig extends BaseMockServerConfig {
-    data: `${string}.json` | Record<string, unknown>;
-    routes?: `${string}.json` | Record<`/${string}`, `/${string}`>;
-}
-export type MockServerConfigArgv = Arguments<{
+export type MockServerCliArgv = Arguments<{
     baseUrl?: string;
     port?: number;
     staticPath?: string;
@@ -75,13 +58,13 @@ declare global {
         }
     }
 }
-export interface FlatMockServerComponent {
+export interface MockServerComponent {
     baseUrl?: BaseUrl;
     configs: Array<GraphQLRequestConfig | RestRequestConfig>;
     interceptors?: Interceptors;
     name?: string;
 }
-export interface FlatMockServerSettings {
+export interface MockServerSettings {
     baseUrl?: BaseUrl;
     cors?: Cors;
     database?: DatabaseConfig;
@@ -89,8 +72,8 @@ export interface FlatMockServerSettings {
     port?: Port;
     staticPath?: StaticPath;
 }
-export type FlatMockServerConfig = [
-    option: FlatMockServerComponent | FlatMockServerSettings,
-    ...flatMockServerComponents: FlatMockServerComponent[]
+export type MockServerConfig = [
+    option: MockServerComponent | MockServerSettings,
+    ...mockServerComponents: MockServerComponent[]
 ];
 export {};