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

package/dist/bin/build.d.ts

@@ -1,4 +1,4 @@
-import type { MockServerConfigArgv } from '../src/utils/types';
-export declare const build: (argv: MockServerConfigArgv) => Promise<(import("http").Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse> & {
-    destroy: import("http").Server["close"];
+import type { MockServerCliArgv } from '../src/utils/types';
+export declare const build: (argv: MockServerCliArgv) => Promise<(import("node:http").Server<typeof import("node:http").IncomingMessage, typeof import("node:http").ServerResponse> & {
+    destroy: import("node:http").Server["close"];
 }) | undefined>;

package/dist/bin/build.js

@@ -11,7 +11,6 @@ Object.defineProperty(exports, "build", {
 const _esbuild = require("esbuild");
 const _helpers = require("./helpers");
 const _run = require("./run");
-const _runFlatConfig = require("./runFlatConfig");
 const build = async (argv)=>{
     const configFilePath = (0, _helpers.resolveConfigFilePath)(argv.config);
     if (!configFilePath) {
@@ -42,11 +41,6 @@ const build = async (argv)=>{
                 build.onEnd((result)=>{
                     if (!result.errors.length) {
                         const mockConfig = (0, _helpers.resolveConfigFile)(result.outputFiles[0].text);
-                        const isFlatConfig = Array.isArray(mockConfig);
-                        if (isFlatConfig) {
-                            instance = (0, _runFlatConfig.runFlatConfig)(mockConfig, argv);
-                            return;
-                        }
                         instance = (0, _run.run)(mockConfig, argv);
                     }
                 });
@@ -59,9 +53,5 @@ const build = async (argv)=>{
     }
     const { outputFiles } = await (0, _esbuild.build)(buildOptions);
     const mockConfig = (0, _helpers.resolveConfigFile)(outputFiles[0].text);
-    const isFlatConfig = Array.isArray(mockConfig);
-    if (isFlatConfig) {
-        return (0, _runFlatConfig.runFlatConfig)(mockConfig, argv);
-    }
-    (0, _run.run)(mockConfig, argv);
+    return (0, _run.run)(mockConfig, argv);
 };

package/dist/bin/helpers/createTemplate.js

@@ -8,8 +8,8 @@ Object.defineProperty(exports, "createTemplate", {
         return createTemplate;
     }
 });
-const _nodefs = /*#__PURE__*/ _interop_require_default(require("node:fs"));
-const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
+const _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
 const _constants = require("../../src/utils/constants");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
@@ -18,16 +18,16 @@ function _interop_require_default(obj) {
 }
 const createTemplate = (options)=>{
     const language = options.withTypescript ? 'ts' : 'js';
-    const templatePath = _nodepath.default.join(__dirname, '..', `templates/${language}/${options.apiType}`);
-    _nodefs.default.cpSync(`${templatePath}/mock-requests`, `${_constants.APP_PATH}/mock-requests`, {
+    const templatePath = _path.default.join(__dirname, '..', `templates/${language}/${options.apiType}`);
+    _fs.default.cpSync(`${templatePath}/mock-requests`, `${_constants.APP_PATH}/mock-requests`, {
         recursive: true,
         force: true
     });
-    let mockServerConfig = _nodefs.default.readFileSync(`${templatePath}/mock-server.config.${language}`, 'utf8');
+    let mockServerConfig = _fs.default.readFileSync(`${templatePath}/mock-server.config.${language}`, 'utf8');
     if (options.staticPath !== '/') {
         mockServerConfig = mockServerConfig.replace(`port: ${_constants.DEFAULT.PORT}`, `port: ${_constants.DEFAULT.PORT},\n\u0020\u0020\u0020\u0020staticPath: '${options.staticPath}'`);
     }
     mockServerConfig = mockServerConfig.replace(`port: ${_constants.DEFAULT.PORT}`, `port: ${options.port.toString()}`);
     mockServerConfig = mockServerConfig.replace("baseUrl: '/'", `baseUrl: '${options.baseUrl}'`);
-    _nodefs.default.writeFileSync(`${_constants.APP_PATH}/mock-server.config.${language}`, mockServerConfig);
+    _fs.default.writeFileSync(`${_constants.APP_PATH}/mock-server.config.${language}`, mockServerConfig);
 };

package/dist/bin/helpers/resolveConfigFile.d.ts

@@ -1,2 +1,2 @@
-import type { FlatMockServerConfig, MockServerConfig } from '../../src/utils/types';
-export declare const resolveConfigFile: (configSourceCode: string) => FlatMockServerConfig | MockServerConfig;
+import type { MockServerConfig } from '../../src/utils/types';
+export declare const resolveConfigFile: (configSourceCode: string) => MockServerConfig;

package/dist/bin/helpers/resolveConfigFile.js

@@ -8,7 +8,6 @@ Object.defineProperty(exports, "resolveConfigFile", {
         return resolveConfigFile;
     }
 });
-const _helpers = require("../../src/utils/helpers");
 const _resolveExportsFromSourceCode = require("./resolveExportsFromSourceCode");
 const resolveConfigFile = (configSourceCode)=>{
     if (!configSourceCode) {
@@ -19,8 +18,8 @@ const resolveConfigFile = (configSourceCode)=>{
     if (!mockServerConfig) {
         throw new Error('Cannot handle exports of mock-server.config.(ts|js)');
     }
-    if (!(0, _helpers.isPlainObject)(mockServerConfig) && !Array.isArray(mockServerConfig)) {
-        throw new Error('configuration should be plain object or array; see our doc (https://www.npmjs.com/package/mock-config-server) for more information');
+    if (!Array.isArray(mockServerConfig)) {
+        throw new TypeError('configuration should be array config; see our doc (https://www.npmjs.com/package/mock-config-server) for more information');
     }
     return mockServerConfig;
 };

package/dist/bin/helpers/resolveConfigFilePath.js

@@ -8,8 +8,8 @@ Object.defineProperty(exports, "resolveConfigFilePath", {
         return resolveConfigFilePath;
     }
 });
-const _nodefs = /*#__PURE__*/ _interop_require_default(require("node:fs"));
-const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
+const _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -17,7 +17,7 @@ function _interop_require_default(obj) {
 }
 const resolveConfigFilePath = (cliConfigFilePath)=>{
     const appPath = process.cwd();
-    if (cliConfigFilePath) return _nodepath.default.resolve(appPath, cliConfigFilePath);
+    if (cliConfigFilePath) return _path.default.resolve(appPath, cliConfigFilePath);
     const configFileNameRegex = /mock-server.config.(?:ts|mts|cts|js|mjs|cjs)/;
-    return _nodefs.default.readdirSync(appPath).find((fileName)=>configFileNameRegex.test(fileName));
+    return _fs.default.readdirSync(appPath).find((fileName)=>configFileNameRegex.test(fileName));
 };

package/dist/bin/init.d.ts

@@ -1,2 +1,2 @@
-import type { MockServerConfigArgv } from '../src/utils/types';
-export declare const init: (argv: MockServerConfigArgv) => Promise<void>;
+import type { MockServerCliArgv } from '../src/utils/types';
+export declare const init: (argv: MockServerCliArgv) => Promise<void>;

package/dist/bin/init.js

@@ -31,22 +31,22 @@ const init = async (argv)=>{
             {
                 type: 'select',
                 name: 'apiType',
-                message: 'Choose api type',
+                message: 'Choose API type',
                 initial: 0,
                 choices: [
                     {
-                        title: 'Rest',
-                        description: 'Rest api sample',
+                        title: 'REST',
+                        description: 'REST API sample',
                         value: 'rest'
                     },
                     {
                         title: 'GraphQL',
-                        description: 'GraphQL api sample',
+                        description: 'GraphQL API sample',
                         value: 'graphql'
                     },
                     {
                         title: 'Both',
-                        description: 'Rest api and GraphQL api sample',
+                        description: 'REST API and GraphQL API sample',
                         value: 'full'
                     }
                 ]
@@ -54,14 +54,14 @@ const init = async (argv)=>{
             {
                 name: 'baseUrl',
                 type: argv.baseUrl ? null : 'text',
-                message: 'Base url (must start with a forward slash):',
+                message: 'Base URL (must start with a forward slash):',
                 initial: '/',
                 validate: (baseUrl)=>{
                     try {
                         _validate.baseUrlSchema.parse(baseUrl);
                         return true;
                     } catch  {
-                        return 'Invalid base url value';
+                        return 'Invalid base URL value';
                     }
                 }
             },

package/dist/bin/run.d.ts

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import type { MockServerConfig, MockServerConfigArgv } from '../src';
-export declare const run: (mockConfig: MockServerConfig, { baseUrl, port, staticPath }: MockServerConfigArgv) => (import("http").Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse> & {
-    destroy: import("http").Server["close"];
+import type { MockServerCliArgv, MockServerConfig } from '../src';
+export declare const run: (mockServerConfig: MockServerConfig, { baseUrl, port, staticPath }: MockServerCliArgv) => (import("node:http").Server<typeof import("node:http").IncomingMessage, typeof import("node:http").ServerResponse> & {
+    destroy: import("node:http").Server["close"];
 }) | undefined;

package/dist/bin/run.js

@@ -10,32 +10,25 @@ Object.defineProperty(exports, "run", {
     }
 });
 const _server = require("../src/server");
-const _helpers = require("../src/utils/helpers");
-const run = (mockConfig, { baseUrl, port, staticPath })=>{
-    console.warn(`**DEPRECATION WARNING**\nThe old mock config format is deprecated and will be removed in the next major version. Please use new format of config (flat config); see our doc (https://github.com/siberiacancode/mock-config-server) for more information`);
+const run = (mockServerConfig, { baseUrl, port, staticPath })=>{
     try {
-        const mergedMockServerConfig = {
-            ...mockConfig,
-            ...baseUrl && {
-                baseUrl
+        const [option, ...mockServerComponents] = mockServerConfig;
+        const mockServerSettings = !('configs' in option) ? option : undefined;
+        const mergedMockServerConfig = [
+            {
+                ...mockServerSettings,
+                ...baseUrl && {
+                    baseUrl
+                },
+                ...port && {
+                    port
+                },
+                ...staticPath && {
+                    staticPath
+                }
             },
-            ...port && {
-                port
-            },
-            ...staticPath && {
-                staticPath
-            }
-        };
-        if (!mergedMockServerConfig.rest && !mergedMockServerConfig.graphql && 'configs' in mergedMockServerConfig) {
-            const mergedApiMockServerConfig = mergedMockServerConfig;
-            if (Array.isArray(mergedApiMockServerConfig.configs) && (0, _helpers.isPlainObject)(mergedApiMockServerConfig.configs[0]) && 'path' in mergedApiMockServerConfig.configs[0]) {
-                return (0, _server.startRestMockServer)(mergedApiMockServerConfig);
-            }
-            if (Array.isArray(mergedApiMockServerConfig.configs) && (0, _helpers.isPlainObject)(mergedApiMockServerConfig.configs[0]) && ('query' in mergedApiMockServerConfig.configs[0] || 'operationName' in mergedApiMockServerConfig.configs[0])) {
-                return (0, _server.startGraphQLMockServer)(mergedApiMockServerConfig);
-            }
-            return (0, _server.startRestMockServer)(mergedApiMockServerConfig);
-        }
+            ...mockServerSettings ? mockServerComponents : mockServerConfig
+        ];
         return (0, _server.startMockServer)(mergedMockServerConfig);
     } catch (error) {
         console.error(error.message);

package/dist/bin/templates/ts/full/mock-server.config.ts

@@ -1,9 +1,9 @@
-import type { FlatMockServerConfig } from 'mock-config-server';
+import type { MockServerConfig } from 'mock-config-server';
 
 import { createUserMutation, getUserQuery, getUsersQuery } from './mock-requests/graphql';
 import { getUserRequest, getUsersRequest, postUserRequest } from './mock-requests/rest';
 
-const mockServerConfig: FlatMockServerConfig = [
+const mockServerConfig: MockServerConfig = [
   {
     port: 31299,
     baseUrl: '/'

package/dist/bin/templates/ts/graphql/mock-server.config.ts

@@ -1,8 +1,8 @@
-import type { FlatMockServerConfig } from 'mock-config-server';
+import type { MockServerConfig } from 'mock-config-server';
 
 import { createUserMutation, getUserQuery, getUsersQuery } from './mock-requests';
 
-const mockServerConfig: FlatMockServerConfig = [
+const mockServerConfig: MockServerConfig = [
   {
     port: 31299,
     baseUrl: '/graphql'

package/dist/bin/templates/ts/rest/mock-server.config.ts

@@ -1,8 +1,8 @@
-import type { FlatMockServerConfig } from 'mock-config-server';
+import type { MockServerConfig } from 'mock-config-server';
 
 import { getUserRequest, getUsersRequest, postUserRequest } from './mock-requests';
 
-const mockServerConfig: FlatMockServerConfig = [
+const mockServerConfig: MockServerConfig = [
   {
     port: 31299,
     baseUrl: '/'

package/dist/src/core/database/createDatabaseRoutes/helpers/search/search.js

@@ -5,14 +5,14 @@ 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, {
-    search: function() {
+    get search () {
         return search;
     },
-    searchInNestedObjects: function() {
+    get searchInNestedObjects () {
         return searchInNestedObjects;
     }
 });

package/dist/src/core/database/createDatabaseRoutes/storages/File/FileStorage.js

@@ -8,8 +8,8 @@ Object.defineProperty(exports, "FileStorage", {
         return FileStorage;
     }
 });
-const _nodefs = /*#__PURE__*/ _interop_require_default(require("node:fs"));
-const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
+const _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
 const _constants = require("../../../../../utils/constants");
 const _helpers = require("../../helpers");
 const _FileWriter = require("./FileWriter");
@@ -22,9 +22,9 @@ class FileStorage {
     fileWriter;
     data;
     constructor(fileName){
-        const filePath = _nodepath.default.resolve(_constants.APP_PATH, fileName);
+        const filePath = _path.default.resolve(_constants.APP_PATH, fileName);
         this.fileWriter = new _FileWriter.FileWriter(filePath);
-        this.data = JSON.parse(_nodefs.default.readFileSync(filePath, 'utf-8'));
+        this.data = JSON.parse(_fs.default.readFileSync(filePath, 'utf-8'));
     }
     read(key) {
         if (!key) return this.data;

package/dist/src/core/database/createDatabaseRoutes/storages/File/FileWriter.js

@@ -8,7 +8,7 @@ Object.defineProperty(exports, "FileWriter", {
         return FileWriter;
     }
 });
-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
@@ -38,7 +38,7 @@ class FileWriter {
     }
     async unlockedWrite(data, recursionLevel = 0) {
         this.writeIsLocked = true;
-        await _nodefs.default.promises.writeFile(this.filePath, data, 'utf-8');
+        await _fs.default.promises.writeFile(this.filePath, data, 'utf-8');
         this.writeIsLocked = false;
         // ✅ important:
         // copy content of this.nextData into new variable

package/dist/src/core/functions/graphql/graphql.d.ts

@@ -0,0 +1,54 @@
+import type { Data, GraphQLEntitiesByEntityName, GraphQLOperationName, GraphQLOperationType, GraphQLParams, GraphQLRequestConfig, GraphQLSettings } from '../../../utils/types';
+interface GraphQLRequestInput {
+    body?: unknown;
+    params?: unknown;
+    query?: unknown;
+    response?: Data;
+}
+type ReservedGraphQLConfigKeys = {
+    [K in 'handler' | 'match' | 'queue' | 'response']?: never;
+};
+type GraphQLInlineResponse<Response> = Response extends Record<string, unknown> ? Response & ReservedGraphQLConfigKeys : Response;
+type GraphQLFunction<Options extends GraphQLRequestInput> = (params: GraphQLParams<Options['query'], Options['body'], Options['params'], Options['response']>) => Options['response'] | Promise<Options['response']>;
+interface GraphQLResponseObject<Response> {
+    match?: GraphQLEntitiesByEntityName;
+    response: Response;
+}
+interface GraphQLHandlerObject<Options extends GraphQLRequestInput> {
+    handler: GraphQLFunction<Options>;
+    match?: GraphQLEntitiesByEntityName;
+}
+interface GraphQLQueueObject<Options extends GraphQLRequestInput> {
+    match?: GraphQLEntitiesByEntityName;
+    queue: Array<{
+        handler: GraphQLFunction<Options>;
+        time?: number;
+    } | {
+        response: Options['response'];
+        time?: number;
+    }>;
+}
+export declare const graphql: {
+    query: {
+        <Options extends GraphQLRequestInput = Partial<GraphQLRequestInput>>(identifier: GraphQLOperationName, config: GraphQLResponseObject<Options["response"]>, settings?: GraphQLSettings, operationType?: undefined): GraphQLRequestConfig;
+        <Options extends GraphQLRequestInput = Partial<GraphQLRequestInput>>(identifier: GraphQLOperationName, config: GraphQLHandlerObject<Options>, settings?: GraphQLSettings, operationType?: undefined): GraphQLRequestConfig;
+        <Options extends GraphQLRequestInput = Partial<GraphQLRequestInput>>(identifier: GraphQLOperationName, config: GraphQLFunction<Options>, settings?: GraphQLSettings, operationType?: undefined): GraphQLRequestConfig;
+        <Options extends GraphQLRequestInput = Partial<GraphQLRequestInput>>(identifier: GraphQLOperationName, config: GraphQLQueueObject<Options>, settings?: GraphQLSettings, operationType?: undefined): GraphQLRequestConfig;
+        <Options extends GraphQLRequestInput = Partial<GraphQLRequestInput>>(identifier: GraphQLOperationName, config: GraphQLInlineResponse<Options["response"]>, settings?: GraphQLSettings, operationType?: undefined): GraphQLRequestConfig;
+    };
+    mutation: {
+        <Options extends GraphQLRequestInput = Partial<GraphQLRequestInput>>(identifier: GraphQLOperationName, config: GraphQLResponseObject<Options["response"]>, settings?: GraphQLSettings, operationType?: undefined): GraphQLRequestConfig;
+        <Options extends GraphQLRequestInput = Partial<GraphQLRequestInput>>(identifier: GraphQLOperationName, config: GraphQLHandlerObject<Options>, settings?: GraphQLSettings, operationType?: undefined): GraphQLRequestConfig;
+        <Options extends GraphQLRequestInput = Partial<GraphQLRequestInput>>(identifier: GraphQLOperationName, config: GraphQLFunction<Options>, settings?: GraphQLSettings, operationType?: undefined): GraphQLRequestConfig;
+        <Options extends GraphQLRequestInput = Partial<GraphQLRequestInput>>(identifier: GraphQLOperationName, config: GraphQLQueueObject<Options>, settings?: GraphQLSettings, operationType?: undefined): GraphQLRequestConfig;
+        <Options extends GraphQLRequestInput = Partial<GraphQLRequestInput>>(identifier: GraphQLOperationName, config: GraphQLInlineResponse<Options["response"]>, settings?: GraphQLSettings, operationType?: undefined): GraphQLRequestConfig;
+    };
+    raw: {
+        <Options extends GraphQLRequestInput = Partial<GraphQLRequestInput>>(identifier: string, config: GraphQLResponseObject<Options["response"]>, settings?: GraphQLSettings, operationType?: GraphQLOperationType | undefined): GraphQLRequestConfig;
+        <Options extends GraphQLRequestInput = Partial<GraphQLRequestInput>>(identifier: string, config: GraphQLHandlerObject<Options>, settings?: GraphQLSettings, operationType?: GraphQLOperationType | undefined): GraphQLRequestConfig;
+        <Options extends GraphQLRequestInput = Partial<GraphQLRequestInput>>(identifier: string, config: GraphQLFunction<Options>, settings?: GraphQLSettings, operationType?: GraphQLOperationType | undefined): GraphQLRequestConfig;
+        <Options extends GraphQLRequestInput = Partial<GraphQLRequestInput>>(identifier: string, config: GraphQLQueueObject<Options>, settings?: GraphQLSettings, operationType?: GraphQLOperationType | undefined): GraphQLRequestConfig;
+        <Options extends GraphQLRequestInput = Partial<GraphQLRequestInput>>(identifier: string, config: GraphQLInlineResponse<Options["response"]>, settings?: GraphQLSettings, operationType?: GraphQLOperationType | undefined): GraphQLRequestConfig;
+    };
+};
+export {};

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

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "graphql", {
+    enumerable: true,
+    get: function() {
+        return graphql;
+    }
+});
+const _helpers = require("./helpers");
+const resolveConfigType = (config)=>{
+    if (typeof config === 'function') return {
+        type: 'inlineHandler',
+        config
+    };
+    if (typeof config !== 'object' || config === null) return {
+        type: 'inlineResponse',
+        config
+    };
+    if ('queue' in config) return {
+        type: 'queue',
+        config
+    };
+    if ('response' in config) return {
+        type: 'data',
+        config
+    };
+    if ('handler' in config) return {
+        type: 'handlerObj',
+        config
+    };
+    return {
+        type: 'inlineResponse',
+        config
+    };
+};
+const createConfigResolver = (config, settings = {})=>{
+    const resolvedConfig = resolveConfigType(config);
+    switch(resolvedConfig.type){
+        case 'inlineResponse':
+            return {
+                data: resolvedConfig.config,
+                entities: {},
+                settings
+            };
+        case 'data':
+            {
+                var _resolvedConfig_config_match;
+                return {
+                    data: resolvedConfig.config.response,
+                    entities: (_resolvedConfig_config_match = resolvedConfig.config.match) !== null && _resolvedConfig_config_match !== void 0 ? _resolvedConfig_config_match : {},
+                    settings
+                };
+            }
+        case 'queue':
+            {
+                const normalizedQueue = resolvedConfig.config.queue.map((item)=>{
+                    if ('handler' in item) {
+                        return {
+                            data: item.handler,
+                            time: item.time
+                        };
+                    }
+                    if ('response' in item) {
+                        return {
+                            data: item.response,
+                            time: item.time
+                        };
+                    }
+                    throw new Error(`Unexpected queue item kind: ${JSON.stringify(item, null, 2)}`);
+                });
+                var _resolvedConfig_config_match1;
+                return {
+                    data: (0, _helpers.createQueueHandler)(normalizedQueue),
+                    entities: (_resolvedConfig_config_match1 = resolvedConfig.config.match) !== null && _resolvedConfig_config_match1 !== void 0 ? _resolvedConfig_config_match1 : {},
+                    settings
+                };
+            }
+        case 'inlineHandler':
+            return {
+                data: resolvedConfig.config,
+                entities: {},
+                settings
+            };
+        case 'handlerObj':
+            {
+                var _resolvedConfig_config_match2;
+                return {
+                    data: resolvedConfig.config.handler,
+                    entities: (_resolvedConfig_config_match2 = resolvedConfig.config.match) !== null && _resolvedConfig_config_match2 !== void 0 ? _resolvedConfig_config_match2 : {},
+                    settings
+                };
+            }
+        default:
+            {
+                throw new Error(`Unexpected route config kind: ${JSON.stringify(config, null, 2)}`);
+            }
+    }
+};
+const createGraphQLFactory = (mode)=>{
+    function createRequestConfig(identifier, config, settings, operationType) {
+        if (mode === 'raw') {
+            return {
+                query: identifier,
+                operationType: operationType !== null && operationType !== void 0 ? operationType : 'query',
+                routes: [
+                    createConfigResolver(config, settings)
+                ]
+            };
+        }
+        return {
+            operationName: identifier,
+            operationType: mode,
+            routes: [
+                createConfigResolver(config, settings)
+            ]
+        };
+    }
+    return createRequestConfig;
+};
+const graphql = {
+    query: createGraphQLFactory('query'),
+    mutation: createGraphQLFactory('mutation'),
+    raw: createGraphQLFactory('raw')
+};

package/dist/src/core/functions/graphql/helpers/createQueueHandler/createQueueHandler.d.ts

@@ -0,0 +1,5 @@
+import type { GraphqlDataResponse, GraphqlDataResponseFunction } from '../../../../../utils/types';
+export declare const createQueueHandler: (normalizedQueue: {
+    data: GraphqlDataResponse;
+    time?: number;
+}[]) => GraphqlDataResponseFunction;

package/dist/src/core/functions/graphql/helpers/createQueueHandler/createQueueHandler.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createQueueHandler", {
+    enumerable: true,
+    get: function() {
+        return createQueueHandler;
+    }
+});
+const createQueueHandler = (normalizedQueue)=>{
+    let queueIndex = 0;
+    let timeoutInProgress = false;
+    const updateQueueIndex = ()=>{
+        queueIndex = normalizedQueue.length - 1 === queueIndex ? 0 : queueIndex + 1;
+    };
+    return async (params)=>{
+        if (!normalizedQueue.length) {
+            return params.next();
+        }
+        const queueItem = normalizedQueue[queueIndex];
+        const { time } = queueItem;
+        if (time && !timeoutInProgress) {
+            timeoutInProgress = true;
+            setTimeout(()=>{
+                timeoutInProgress = false;
+                updateQueueIndex();
+            }, time);
+        }
+        if (!time) {
+            updateQueueIndex();
+        }
+        return typeof queueItem.data === 'function' ? queueItem.data(params) : queueItem.data;
+    };
+};

package/dist/src/core/functions/graphql/helpers/index.d.ts

@@ -0,0 +1 @@
+export * from './createQueueHandler/createQueueHandler';

package/dist/src/core/{rest/createRestRoutes → functions/graphql}/helpers/index.js

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

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

@@ -0,0 +1,3 @@
+export * from './graphql/graphql';
+export * from './mock';
+export * from './rest/rest';

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./graphql/graphql"), exports);
+_export_star(require("./mock"), exports);
+_export_star(require("./rest/rest"), 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/functions/mock.d.ts

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

package/dist/src/core/functions/mock.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "mock", {
+    enumerable: true,
+    get: function() {
+        return mock;
+    }
+});
+const mock = (...config)=>config;

package/dist/src/core/functions/rest/helpers/createFileHandler/createFileHandler.d.ts

@@ -0,0 +1,2 @@
+import type { RestDataResponseFunction, RestFileResponse, RestMethod } from '../../../../../utils/types';
+export declare const createFileHandler: <Method extends RestMethod>(filePath: RestFileResponse) => RestDataResponseFunction<Method>;