mock-config-server 3.0.0 → 3.0.1

package/dist/bin/bin.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin/bin.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const pleaseUpgradeNode = require('please-upgrade-node');
+const packageJson = require('../../package.json');
+pleaseUpgradeNode(packageJson);
+const { cli } = require('./cli');
+cli();

package/dist/bin/build.d.ts

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

package/dist/bin/build.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.build = void 0;
+const esbuild_1 = require("esbuild");
+const helpers_1 = require("./helpers");
+const run_1 = require("./run");
+const build = async (argv) => {
+    const configFilePath = (0, helpers_1.resolveConfigFilePath)(argv.config);
+    if (!configFilePath) {
+        throw new Error('Cannot find config file mock-server.config.(ts|mts|cts|js|mjs|cjs)');
+    }
+    const buildOptions = {
+        entryPoints: [configFilePath],
+        bundle: true,
+        platform: 'node',
+        target: 'esnext',
+        minifySyntax: true,
+        minify: true,
+        write: false,
+        metafile: false,
+        logLevel: 'info',
+        plugins: []
+    };
+    if (argv.watch) {
+        const watchPlugin = {
+            name: 'watch',
+            setup: (build) => {
+                let instance;
+                build.onStart(() => {
+                    instance?.destroy();
+                });
+                build.onEnd((result) => {
+                    if (!result.errors.length) {
+                        const mockConfig = (0, helpers_1.resolveConfigFile)(result.outputFiles[0].text);
+                        instance = (0, run_1.run)(mockConfig, argv);
+                    }
+                });
+            }
+        };
+        buildOptions.plugins.push(watchPlugin);
+        const ctx = await (0, esbuild_1.context)(buildOptions);
+        ctx.watch();
+        return;
+    }
+    const { outputFiles } = await (0, esbuild_1.build)(buildOptions);
+    const mockConfig = (0, helpers_1.resolveConfigFile)(outputFiles[0].text);
+    (0, run_1.run)(mockConfig, argv);
+};
+exports.build = build;

package/dist/bin/cli.d.ts

@@ -0,0 +1 @@
+export declare const cli: () => void;

package/dist/bin/cli.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cli = void 0;
+const yargs_1 = __importDefault(require("yargs"));
+const helpers_1 = require("yargs/helpers");
+const build_1 = require("./build");
+const cli = () => {
+    const argv = (0, yargs_1.default)((0, helpers_1.hideBin)(process.argv))
+        .usage('mcs [options]')
+        .epilogue('More info: https://github.com/siberiacancode/mock-config-server#readme')
+        .options({
+        baseUrl: {
+            alias: 'b',
+            description: 'Set base url for mock server',
+            type: 'string'
+        },
+        port: {
+            alias: 'p',
+            description: 'Set port for server',
+            type: 'number'
+        },
+        staticPath: {
+            alias: 's',
+            description: 'Set static path for mock server',
+            type: 'string'
+        },
+        config: {
+            alias: 'c',
+            description: 'Set path to config file',
+            type: 'string'
+        },
+        watch: {
+            alias: 'w',
+            description: 'Enables server restart after config file changes',
+            type: 'boolean'
+        }
+    })
+        .version()
+        .alias('version', 'v')
+        .help()
+        .alias('help', 'h')
+        .parse();
+    (0, build_1.build)(argv);
+};
+exports.cli = cli;

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

@@ -0,0 +1,3 @@
+export * from './resolveConfigFile';
+export * from './resolveConfigFilePath';
+export * from './resolveExportsFromSourceCode';

package/dist/bin/helpers/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./resolveConfigFile"), exports);
+__exportStar(require("./resolveConfigFilePath"), exports);
+__exportStar(require("./resolveExportsFromSourceCode"), exports);

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

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

package/dist/bin/helpers/resolveConfigFile.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveConfigFile = void 0;
+const helpers_1 = require("../../src/utils/helpers");
+const resolveExportsFromSourceCode_1 = require("./resolveExportsFromSourceCode");
+const resolveConfigFile = (configSourceCode) => {
+    if (!configSourceCode) {
+        throw new Error('Cannot handle source code of mock-server.config.(ts|js)');
+    }
+    const mockServerConfigExports = (0, resolveExportsFromSourceCode_1.resolveExportsFromSourceCode)(configSourceCode);
+    const mockServerConfig = mockServerConfigExports.default;
+    if (!mockServerConfig) {
+        throw new Error('Cannot handle exports of mock-server.config.(ts|js)');
+    }
+    if (!(0, helpers_1.isPlainObject)(mockServerConfig)) {
+        throw new Error('configuration should be plain object; see our doc (https://www.npmjs.com/package/mock-config-server) for more information');
+    }
+    return mockServerConfig;
+};
+exports.resolveConfigFile = resolveConfigFile;

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

@@ -0,0 +1 @@
+export declare const resolveConfigFilePath: (cliConfigFilePath?: string) => string | undefined;

package/dist/bin/helpers/resolveConfigFilePath.js

@@ -0,0 +1,39 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveConfigFilePath = void 0;
+const fs = __importStar(require("fs"));
+const path_1 = __importDefault(require("path"));
+const resolveConfigFilePath = (cliConfigFilePath) => {
+    const appPath = process.cwd();
+    if (cliConfigFilePath)
+        return path_1.default.resolve(appPath, cliConfigFilePath);
+    const configFileNameRegex = /mock-server.config.(?:ts|mts|cts|js|mjs|cjs)/;
+    return fs.readdirSync(appPath).find((fileName) => configFileNameRegex.test(fileName));
+};
+exports.resolveConfigFilePath = resolveConfigFilePath;

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

@@ -0,0 +1 @@
+export declare const resolveExportsFromSourceCode: (sourceCode: string) => any;

package/dist/bin/helpers/resolveExportsFromSourceCode.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveExportsFromSourceCode = void 0;
+const resolveExportsFromSourceCode = (sourceCode) => {
+    // @ts-ignore
+    const moduleInstance = new module.constructor();
+    // eslint-disable-next-line no-underscore-dangle
+    moduleInstance._compile(sourceCode, '');
+    return moduleInstance.exports;
+};
+exports.resolveExportsFromSourceCode = resolveExportsFromSourceCode;

package/dist/bin/resolveConfigFilePath/resolveConfigFilePath.d.ts

@@ -0,0 +1 @@
+export declare const resolveConfigFilePath: (cliConfigFilePath?: string) => string | undefined;

package/dist/bin/resolveConfigFilePath/resolveConfigFilePath.js

@@ -0,0 +1,39 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveConfigFilePath = void 0;
+const fs = __importStar(require("fs"));
+const path_1 = __importDefault(require("path"));
+const resolveConfigFilePath = (cliConfigFilePath) => {
+    const appPath = process.cwd();
+    if (cliConfigFilePath)
+        return path_1.default.resolve(appPath, cliConfigFilePath);
+    const configFileNameRegex = /mock-server.config.(?:ts|mts|cts|js|mjs|cjs)/;
+    return fs.readdirSync(appPath).find((fileName) => configFileNameRegex.test(fileName));
+};
+exports.resolveConfigFilePath = resolveConfigFilePath;

package/dist/bin/run.d.ts

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+/// <reference types="node" />
+import type { MockServerConfig, MockServerConfigArgv } from '../src';
+export declare const run: (mockConfig: MockServerConfig, argv: MockServerConfigArgv) => (import("http").Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse> & {
+    destroy: (callback?: ((err?: Error | undefined) => void) | undefined) => import("http").Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse>;
+}) | undefined;

package/dist/bin/run.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = void 0;
+const server_1 = require("../src/server");
+const validateMockServerConfig_1 = require("./validateMockServerConfig/validateMockServerConfig");
+const run = (mockConfig, argv) => {
+    try {
+        const mergedMockServerConfig = { ...mockConfig, ...argv };
+        (0, validateMockServerConfig_1.validateMockServerConfig)(mergedMockServerConfig);
+        return (0, server_1.startMockServer)(mergedMockServerConfig);
+    }
+    catch (error) {
+        console.error(error.message);
+    }
+};
+exports.run = run;

package/dist/bin/validateMockServerConfig/helpers/index.d.ts

@@ -0,0 +1,2 @@
+export * from './isCheckModeValid';
+export * from './isDescriptorValueValid';

package/dist/bin/validateMockServerConfig/helpers/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./isCheckModeValid"), exports);
+__exportStar(require("./isDescriptorValueValid"), exports);

package/dist/bin/validateMockServerConfig/helpers/isCheckModeValid/index.d.ts

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

package/dist/bin/validateMockServerConfig/helpers/isCheckModeValid/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./isCheckModeValid"), exports);

package/dist/bin/validateMockServerConfig/helpers/isCheckModeValid/isCheckModeValid.d.ts

@@ -0,0 +1 @@
+export declare const isCheckModeValid: (checkMode: unknown, entityName?: unknown) => boolean;

package/dist/bin/validateMockServerConfig/helpers/isCheckModeValid/isCheckModeValid.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isCheckModeValid = void 0;
+const constants_1 = require("../../../../src/utils/constants");
+const isCheckModeValid = (checkMode, entityName) => {
+    if (entityName === 'body' || entityName === 'variables')
+        return constants_1.PLAIN_ENTITY_CHECK_MODES.includes(checkMode);
+    return constants_1.CHECK_MODES.includes(checkMode);
+};
+exports.isCheckModeValid = isCheckModeValid;

package/dist/bin/validateMockServerConfig/helpers/isDescriptorValueValid/index.d.ts

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

package/dist/bin/validateMockServerConfig/helpers/isDescriptorValueValid/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./isDescriptorValueValid"), exports);

package/dist/bin/validateMockServerConfig/helpers/isDescriptorValueValid/isDescriptorValueValid.d.ts

@@ -0,0 +1 @@
+export declare const isDescriptorValueValid: (checkMode: unknown, value: unknown, entityName?: unknown) => boolean;

package/dist/bin/validateMockServerConfig/helpers/isDescriptorValueValid/isDescriptorValueValid.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDescriptorValueValid = void 0;
+const constants_1 = require("../../../../src/utils/constants");
+const isDescriptorValueValid = (checkMode, value, entityName) => {
+    if (constants_1.CHECK_ACTUAL_VALUE_CHECK_MODES.includes(checkMode))
+        return typeof value === 'undefined';
+    if (constants_1.COMPARE_WITH_DESCRIPTOR_VALUE_CHECK_MODES.includes(checkMode)) {
+        if (entityName === 'body' || entityName === 'variables') {
+            return (typeof value === 'object' &&
+                value !== null &&
+                typeof value !== 'function' &&
+                !(value instanceof RegExp));
+        }
+        return typeof value === 'boolean' || typeof value === 'number' || typeof value === 'string';
+    }
+    if (checkMode === 'function')
+        return typeof value === 'function';
+    if (checkMode === 'regExp')
+        return value instanceof RegExp;
+    throw new Error('Invalid checkMode');
+};
+exports.isDescriptorValueValid = isDescriptorValueValid;

package/dist/bin/validateMockServerConfig/validateBaseUrl/validateBaseUrl.d.ts

@@ -0,0 +1 @@
+export declare const validateBaseUrl: (baseUrl: unknown) => void;

package/dist/bin/validateMockServerConfig/validateBaseUrl/validateBaseUrl.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateBaseUrl = void 0;
+const validateBaseUrl = (baseUrl) => {
+    if (typeof baseUrl !== 'string' && typeof baseUrl !== 'undefined') {
+        throw new Error('baseUrl');
+    }
+    if (typeof baseUrl === 'string' && !baseUrl.startsWith('/')) {
+        throw new Error('baseUrl');
+    }
+};
+exports.validateBaseUrl = validateBaseUrl;

package/dist/bin/validateMockServerConfig/validateCors/validateCors.d.ts

@@ -0,0 +1 @@
+export declare const validateCors: (cors: unknown) => void;

package/dist/bin/validateMockServerConfig/validateCors/validateCors.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateCors = void 0;
+const helpers_1 = require("../../../src/utils/helpers");
+const validateOrigin = (origin) => {
+    const isOriginArray = Array.isArray(origin);
+    if (isOriginArray) {
+        origin.forEach((originElement, index) => {
+            const isOriginElementStringOrRegExp = typeof originElement === 'string' || originElement instanceof RegExp;
+            if (!isOriginElementStringOrRegExp) {
+                throw new Error(`origin[${index}]`);
+            }
+        });
+        return;
+    }
+    const isOriginStringOrRegexp = typeof origin === 'string' || origin instanceof RegExp;
+    const isOriginFunction = typeof origin === 'function';
+    if (!isOriginStringOrRegexp && !isOriginFunction) {
+        throw new Error('origin');
+    }
+};
+const validateMethods = (methods) => {
+    const isMethodsArray = Array.isArray(methods);
+    if (isMethodsArray) {
+        const allowedMethods = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'OPTIONS'];
+        methods.forEach((method, index) => {
+            // ✅ important:
+            // compare without 'toUpperCase' because 'Access-Control-Allow-Methods' value is case-sensitive
+            if (!allowedMethods.includes(method)) {
+                throw new Error(`methods[${index}]`);
+            }
+        });
+        return;
+    }
+    if (typeof methods !== 'undefined') {
+        throw new Error('methods');
+    }
+};
+const validateHeaders = (headers) => {
+    const isHeadersArray = Array.isArray(headers);
+    if (isHeadersArray) {
+        headers.forEach((header, index) => {
+            if (typeof header !== 'string') {
+                throw new Error(`headers[${index}]`);
+            }
+        });
+        return;
+    }
+    if (typeof headers !== 'undefined') {
+        throw new Error('headers');
+    }
+};
+const validateCredentials = (credentials) => {
+    if (typeof credentials !== 'boolean' && typeof credentials !== 'undefined') {
+        throw new Error('credentials');
+    }
+};
+const validateMaxAge = (maxAge) => {
+    if (typeof maxAge !== 'number' && typeof maxAge !== 'undefined') {
+        throw new Error('maxAge');
+    }
+};
+const validateCors = (cors) => {
+    const isCorsObject = (0, helpers_1.isPlainObject)(cors);
+    if (isCorsObject) {
+        try {
+            validateOrigin(cors.origin);
+            validateMethods(cors.methods);
+            validateHeaders(cors.headers);
+            validateCredentials(cors.credentials);
+            validateMaxAge(cors.maxAge);
+        }
+        catch (error) {
+            throw new Error(`cors.${error.message}`);
+        }
+        return;
+    }
+    if (typeof cors !== 'undefined') {
+        throw new Error('cors');
+    }
+};
+exports.validateCors = validateCors;

package/dist/bin/validateMockServerConfig/validateGraphqlConfig/validateGraphqlConfig.d.ts

@@ -0,0 +1 @@
+export declare const validateGraphqlConfig: (graphqlConfig: unknown) => void;

package/dist/bin/validateMockServerConfig/validateGraphqlConfig/validateGraphqlConfig.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateGraphqlConfig = void 0;
+const helpers_1 = require("../../../src/utils/helpers");
+const validateBaseUrl_1 = require("../validateBaseUrl/validateBaseUrl");
+const validateInterceptors_1 = require("../validateInterceptors/validateInterceptors");
+const validateRoutes_1 = require("./validateRoutes/validateRoutes");
+const validateConfigs = (configs) => {
+    const isConfigsArray = Array.isArray(configs);
+    if (isConfigsArray) {
+        configs.forEach((config, index) => {
+            const { operationType, operationName } = config;
+            if (operationType !== 'query' && operationType !== 'mutation') {
+                throw new Error(`configs[${index}].operationType`);
+            }
+            const isOperationNameStringOrRegExp = typeof operationName === 'string' || operationName instanceof RegExp;
+            if (!isOperationNameStringOrRegExp) {
+                throw new Error(`configs[${index}].operationName`);
+            }
+            try {
+                (0, validateRoutes_1.validateRoutes)(config.routes, operationType);
+                (0, validateInterceptors_1.validateInterceptors)(config.interceptors);
+            }
+            catch (error) {
+                throw new Error(`configs[${index}].${error.message}`);
+            }
+        });
+        return;
+    }
+    throw new Error('configs');
+};
+const validateGraphqlConfig = (graphqlConfig) => {
+    const isGraphqlConfigObject = (0, helpers_1.isPlainObject)(graphqlConfig);
+    if (isGraphqlConfigObject) {
+        try {
+            (0, validateBaseUrl_1.validateBaseUrl)(graphqlConfig.baseUrl);
+            validateConfigs(graphqlConfig.configs);
+        }
+        catch (error) {
+            throw new Error(`graphql.${error.message}`);
+        }
+        return;
+    }
+    if (typeof graphqlConfig !== 'undefined') {
+        throw new Error('graphql');
+    }
+};
+exports.validateGraphqlConfig = validateGraphqlConfig;

package/dist/bin/validateMockServerConfig/validateGraphqlConfig/validateRoutes/validateRoutes.d.ts

@@ -0,0 +1,2 @@
+import type { GraphQLOperationType } from '../../../../src/utils/types';
+export declare const validateRoutes: (routes: unknown, operationType: GraphQLOperationType) => void;