mock-config-server 3.0.0 → 3.1.0

package/dist/bin/bin.d.ts

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

package/dist/bin/bin.js

@@ -0,0 +1,13 @@
+#!/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,55 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.build = void 0;
+var _esbuild = require("esbuild");
+var _helpers = require("./helpers");
+var _run = require("./run");
+const build = async argv => {
+  const configFilePath = (0, _helpers.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(() => {
+          var _instance;
+          (_instance = instance) === null || _instance === void 0 ? void 0 : _instance.destroy();
+        });
+        build.onEnd(result => {
+          if (!result.errors.length) {
+            const mockConfig = (0, _helpers.resolveConfigFile)(result.outputFiles[0].text);
+            instance = (0, _run.run)(mockConfig, argv);
+          }
+        });
+      }
+    };
+    buildOptions.plugins.push(watchPlugin);
+    const ctx = await (0, _esbuild.context)(buildOptions);
+    ctx.watch();
+    return;
+  }
+  const {
+    outputFiles
+  } = await (0, _esbuild.build)(buildOptions);
+  const mockConfig = (0, _helpers.resolveConfigFile)(outputFiles[0].text);
+  (0, _run.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,41 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.cli = void 0;
+var _yargs = _interopRequireDefault(require("yargs"));
+var _helpers = require("yargs/helpers");
+var _build = require("./build");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const cli = () => {
+  const argv = (0, _yargs.default)((0, _helpers.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.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,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _resolveConfigFile = require("./resolveConfigFile");
+Object.keys(_resolveConfigFile).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _resolveConfigFile[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _resolveConfigFile[key];
+    }
+  });
+});
+var _resolveConfigFilePath = require("./resolveConfigFilePath");
+Object.keys(_resolveConfigFilePath).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _resolveConfigFilePath[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _resolveConfigFilePath[key];
+    }
+  });
+});
+var _resolveExportsFromSourceCode = require("./resolveExportsFromSourceCode");
+Object.keys(_resolveExportsFromSourceCode).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _resolveExportsFromSourceCode[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _resolveExportsFromSourceCode[key];
+    }
+  });
+});

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,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.resolveConfigFile = void 0;
+var _helpers = require("../../src/utils/helpers");
+var _resolveExportsFromSourceCode = require("./resolveExportsFromSourceCode");
+const resolveConfigFile = configSourceCode => {
+  if (!configSourceCode) {
+    throw new Error('Cannot handle source code of mock-server.config.(ts|js)');
+  }
+  const mockServerConfigExports = (0, _resolveExportsFromSourceCode.resolveExportsFromSourceCode)(configSourceCode);
+  const mockServerConfig = mockServerConfigExports.default;
+  if (!mockServerConfig) {
+    throw new Error('Cannot handle exports of mock-server.config.(ts|js)');
+  }
+  if (!(0, _helpers.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,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.resolveConfigFilePath = void 0;
+var _fs = _interopRequireDefault(require("fs"));
+var _path = _interopRequireDefault(require("path"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const resolveConfigFilePath = cliConfigFilePath => {
+  const appPath = process.cwd();
+  if (cliConfigFilePath) return _path.default.resolve(appPath, cliConfigFilePath);
+  const configFileNameRegex = /mock-server.config.(?:ts|mts|cts|js|mjs|cjs)/;
+  return _fs.default.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,14 @@
+"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,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.resolveConfigFilePath = void 0;
+var _fs = _interopRequireDefault(require("fs"));
+var _path = _interopRequireDefault(require("path"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const resolveConfigFilePath = cliConfigFilePath => {
+  const appPath = process.cwd();
+  if (cliConfigFilePath) return _path.default.resolve(appPath, cliConfigFilePath);
+  const configFileNameRegex = /mock-server.config.(?:ts|mts|cts|js|mjs|cjs)/;
+  return _fs.default.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,22 @@
+#!/usr/bin/env node
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.run = void 0;
+var _server = require("../src/server");
+var _validateMockServerConfig = require("./validateMockServerConfig/validateMockServerConfig");
+const run = (mockConfig, argv) => {
+  try {
+    const mergedMockServerConfig = {
+      ...mockConfig,
+      ...argv
+    };
+    (0, _validateMockServerConfig.validateMockServerConfig)(mergedMockServerConfig);
+    return (0, _server.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,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _isCheckModeValid = require("./isCheckModeValid");
+Object.keys(_isCheckModeValid).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _isCheckModeValid[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _isCheckModeValid[key];
+    }
+  });
+});
+var _isDescriptorValueValid = require("./isDescriptorValueValid");
+Object.keys(_isDescriptorValueValid).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _isDescriptorValueValid[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _isDescriptorValueValid[key];
+    }
+  });
+});

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,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _isCheckModeValid = require("./isCheckModeValid");
+Object.keys(_isCheckModeValid).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _isCheckModeValid[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _isCheckModeValid[key];
+    }
+  });
+});

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,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isCheckModeValid = void 0;
+var _constants = require("../../../../src/utils/constants");
+const isCheckModeValid = (checkMode, entityName) => {
+  if (entityName === 'body' || entityName === 'variables') return _constants.PLAIN_ENTITY_CHECK_MODES.includes(checkMode);
+  return _constants.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,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _isDescriptorValueValid = require("./isDescriptorValueValid");
+Object.keys(_isDescriptorValueValid).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _isDescriptorValueValid[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _isDescriptorValueValid[key];
+    }
+  });
+});

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,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isDescriptorValueValid = void 0;
+var _constants = require("../../../../src/utils/constants");
+const isDescriptorValueValid = (checkMode, value, entityName) => {
+  if (_constants.CHECK_ACTUAL_VALUE_CHECK_MODES.includes(checkMode)) return typeof value === 'undefined';
+  if (_constants.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,15 @@
+"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,84 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.validateCors = void 0;
+var _helpers = 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.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/validateDatabaseConfig/validateDatabaseConfig.d.ts

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

package/dist/bin/validateMockServerConfig/validateDatabaseConfig/validateDatabaseConfig.js

@@ -0,0 +1,45 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.validateDatabaseConfig = void 0;
+var _helpers = require("../../../src/utils/helpers");
+const validateData = data => {
+  const isDataObject = (0, _helpers.isPlainObject)(data);
+  const isDataJsonFilePath = typeof data === 'string' && data.endsWith('.json');
+  if (!isDataObject && !isDataJsonFilePath) throw new Error('data');
+};
+const validateRoutes = routes => {
+  const isRoutesObject = (0, _helpers.isPlainObject)(routes);
+  if (isRoutesObject) {
+    Object.entries(routes).forEach(([routeKey, routeValue]) => {
+      const isKeyRoutePath = routeKey.startsWith('/');
+      const isValueRoutePath = typeof routeValue === 'string' && routeValue.startsWith('/');
+      if (!isKeyRoutePath || !isValueRoutePath) {
+        throw new Error(`routes.${routeKey}`);
+      }
+    });
+    return;
+  }
+  const isRoutesJsonFilePath = typeof routes === 'string' && routes.endsWith('.json');
+  if (!isRoutesJsonFilePath && typeof routes !== 'undefined') {
+    throw new Error('routes');
+  }
+};
+const validateDatabaseConfig = databaseConfig => {
+  const isDatabaseConfigObject = (0, _helpers.isPlainObject)(databaseConfig);
+  if (isDatabaseConfigObject) {
+    try {
+      validateData(databaseConfig.data);
+      validateRoutes(databaseConfig.routes);
+    } catch (error) {
+      throw new Error(`database.${error.message}`);
+    }
+    return;
+  }
+  if (typeof databaseConfig !== 'undefined') {
+    throw new Error('database');
+  }
+};
+exports.validateDatabaseConfig = validateDatabaseConfig;

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,52 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.validateGraphqlConfig = void 0;
+var _helpers = require("../../../src/utils/helpers");
+var _validateBaseUrl = require("../validateBaseUrl/validateBaseUrl");
+var _validateInterceptors = require("../validateInterceptors/validateInterceptors");
+var _validateRoutes = 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.validateRoutes)(config.routes, operationType);
+        (0, _validateInterceptors.validateInterceptors)(config.interceptors);
+      } catch (error) {
+        throw new Error(`configs[${index}].${error.message}`);
+      }
+    });
+    return;
+  }
+  throw new Error('configs');
+};
+const validateGraphqlConfig = graphqlConfig => {
+  const isGraphqlConfigObject = (0, _helpers.isPlainObject)(graphqlConfig);
+  if (isGraphqlConfigObject) {
+    try {
+      (0, _validateBaseUrl.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;