mock-config-server 3.0.1 → 3.1.1

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

@@ -1,12 +1,15 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+
+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');
-    }
+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;
+exports.validateBaseUrl = validateBaseUrl;

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

@@ -1,82 +1,84 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+
+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');
-    }
+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 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 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 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 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');
+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;
+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.js

@@ -1,48 +1,52 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+
+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');
+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_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');
+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;
+exports.validateGraphqlConfig = validateGraphqlConfig;

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

@@ -1,97 +1,104 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 exports.validateRoutes = void 0;
-const helpers_1 = require("../../../../src/utils/helpers");
-const helpers_2 = require("../../helpers");
-const validateInterceptors_1 = require("../../validateInterceptors/validateInterceptors");
+var _helpers = require("../../../../src/utils/helpers");
+var _helpers2 = require("../../helpers");
+var _validateInterceptors = require("../../validateInterceptors/validateInterceptors");
 const ALLOWED_ENTITIES_BY_OPERATION_TYPE = {
-    query: ['headers', 'cookies', 'query', 'variables'],
-    mutation: ['headers', 'cookies', 'query', 'variables']
+  query: ['headers', 'cookies', 'query', 'variables'],
+  mutation: ['headers', 'cookies', 'query', 'variables']
 };
 const validateEntity = (entity, entityName) => {
-    const { checkMode: topLevelCheckMode, value: topLevelValue } = (0, helpers_1.convertToEntityDescriptor)(entity);
-    const isVariables = entityName === 'variables';
-    const isTopLevelDescriptor = (0, helpers_1.isEntityDescriptor)(entity);
-    if (isTopLevelDescriptor && isVariables) {
-        if (!(0, helpers_2.isCheckModeValid)(topLevelCheckMode, 'variables')) {
-            throw new Error('variables.checkMode');
-        }
-        if (!(0, helpers_2.isDescriptorValueValid)(topLevelCheckMode, topLevelValue, 'variables')) {
-            const errorMessage = 'variables.value';
-            throw new Error(errorMessage);
-        }
+  const {
+    checkMode: topLevelCheckMode,
+    value: topLevelValue
+  } = (0, _helpers.convertToEntityDescriptor)(entity);
+  const isVariables = entityName === 'variables';
+  const isTopLevelDescriptor = (0, _helpers.isEntityDescriptor)(entity);
+  if (isTopLevelDescriptor && isVariables) {
+    if (!(0, _helpers2.isCheckModeValid)(topLevelCheckMode, 'variables')) {
+      throw new Error('variables.checkMode');
+    }
+    if (!(0, _helpers2.isDescriptorValueValid)(topLevelCheckMode, topLevelValue, 'variables')) {
+      const errorMessage = 'variables.value';
+      throw new Error(errorMessage);
     }
-    const isEntityObject = (0, helpers_1.isPlainObject)(entity) && !(entity instanceof RegExp);
-    const isEntityArray = Array.isArray(entity) && isVariables;
-    if (isEntityObject || isEntityArray) {
-        Object.entries(topLevelValue).forEach(([key, valueOrDescriptor]) => {
-            const { checkMode, value } = (0, helpers_1.convertToEntityDescriptor)(valueOrDescriptor);
-            if (!(0, helpers_2.isCheckModeValid)(checkMode)) {
-                throw new Error(`${entityName}.${key}.checkMode`);
-            }
-            const isDescriptor = (0, helpers_1.isEntityDescriptor)(valueOrDescriptor);
-            const errorMessage = `${entityName}.${key}${isDescriptor ? '.value' : ''}`;
-            const isValueArray = Array.isArray(value);
-            if (isValueArray && !isVariables) {
-                value.forEach((element, index) => {
-                    if (!(0, helpers_2.isDescriptorValueValid)(checkMode, element)) {
-                        throw new Error(`${errorMessage}[${index}]`);
-                    }
-                });
-                return;
-            }
-            if (!(0, helpers_2.isDescriptorValueValid)(checkMode, value)) {
-                throw new Error(errorMessage);
-            }
+  }
+  const isEntityObject = (0, _helpers.isPlainObject)(entity) && !(entity instanceof RegExp);
+  const isEntityArray = Array.isArray(entity) && isVariables;
+  if (isEntityObject || isEntityArray) {
+    Object.entries(topLevelValue).forEach(([key, valueOrDescriptor]) => {
+      const {
+        checkMode,
+        value
+      } = (0, _helpers.convertToEntityDescriptor)(valueOrDescriptor);
+      if (!(0, _helpers2.isCheckModeValid)(checkMode)) {
+        throw new Error(`${entityName}.${key}.checkMode`);
+      }
+      const isDescriptor = (0, _helpers.isEntityDescriptor)(valueOrDescriptor);
+      const errorMessage = `${entityName}.${key}${isDescriptor ? '.value' : ''}`;
+      const isValueArray = Array.isArray(value);
+      if (isValueArray && !isVariables) {
+        value.forEach((element, index) => {
+          if (!(0, _helpers2.isDescriptorValueValid)(checkMode, element)) {
+            throw new Error(`${errorMessage}[${index}]`);
+          }
         });
         return;
-    }
-    throw new Error(entityName);
+      }
+      if (!(0, _helpers2.isDescriptorValueValid)(checkMode, value)) {
+        throw new Error(errorMessage);
+      }
+    });
+    return;
+  }
+  throw new Error(entityName);
 };
 const validateEntities = (entities, operationType) => {
-    const isEntitiesObject = (0, helpers_1.isPlainObject)(entities);
-    if (isEntitiesObject) {
-        Object.keys(entities).forEach((entityName) => {
-            const isEntityAllowed = ALLOWED_ENTITIES_BY_OPERATION_TYPE[operationType].includes(entityName);
-            if (!isEntityAllowed) {
-                throw new Error(`entities.${entityName}`);
-            }
-            try {
-                validateEntity(entities[entityName], entityName);
-            }
-            catch (error) {
-                throw new Error(`entities.${error.message}`);
-            }
-        });
-        return;
-    }
-    if (typeof entities !== 'undefined') {
-        throw new Error('entities');
-    }
+  const isEntitiesObject = (0, _helpers.isPlainObject)(entities);
+  if (isEntitiesObject) {
+    Object.keys(entities).forEach(entityName => {
+      const isEntityAllowed = ALLOWED_ENTITIES_BY_OPERATION_TYPE[operationType].includes(entityName);
+      if (!isEntityAllowed) {
+        throw new Error(`entities.${entityName}`);
+      }
+      try {
+        validateEntity(entities[entityName], entityName);
+      } catch (error) {
+        throw new Error(`entities.${error.message}`);
+      }
+    });
+    return;
+  }
+  if (typeof entities !== 'undefined') {
+    throw new Error('entities');
+  }
 };
 const validateRoutes = (routes, operationType) => {
-    const isRoutesArray = Array.isArray(routes);
-    if (isRoutesArray) {
-        routes.forEach((route, index) => {
-            const isRouteObject = (0, helpers_1.isPlainObject)(route);
-            if (isRouteObject) {
-                const isRouteHasDataProperty = 'data' in route;
-                if (!isRouteHasDataProperty) {
-                    throw new Error(`routes[${index}]`);
-                }
-                try {
-                    validateEntities(route.entities, operationType);
-                    (0, validateInterceptors_1.validateInterceptors)(route.interceptors);
-                }
-                catch (error) {
-                    throw new Error(`routes[${index}].${error.message}`);
-                }
-                return;
-            }
-            throw new Error(`routes[${index}]`);
-        });
+  const isRoutesArray = Array.isArray(routes);
+  if (isRoutesArray) {
+    routes.forEach((route, index) => {
+      const isRouteObject = (0, _helpers.isPlainObject)(route);
+      if (isRouteObject) {
+        const isRouteHasDataProperty = ('data' in route);
+        if (!isRouteHasDataProperty) {
+          throw new Error(`routes[${index}]`);
+        }
+        try {
+          validateEntities(route.entities, operationType);
+          (0, _validateInterceptors.validateInterceptors)(route.interceptors);
+        } catch (error) {
+          throw new Error(`routes[${index}].${error.message}`);
+        }
         return;
-    }
-    throw new Error('routes');
+      }
+      throw new Error(`routes[${index}]`);
+    });
+    return;
+  }
+  throw new Error('routes');
 };
-exports.validateRoutes = validateRoutes;
+exports.validateRoutes = validateRoutes;

package/dist/bin/validateMockServerConfig/validateInterceptors/validateInterceptors.js

@@ -1,21 +1,27 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 exports.validateInterceptors = void 0;
-const helpers_1 = require("../../../src/utils/helpers");
-const validateInterceptors = (interceptors) => {
-    const isInterceptorsObject = (0, helpers_1.isPlainObject)(interceptors);
-    if (isInterceptorsObject) {
-        const { request, response } = interceptors;
-        if (typeof request !== 'function' && typeof request !== 'undefined') {
-            throw new Error('interceptors.request');
-        }
-        if (typeof response !== 'function' && typeof response !== 'undefined') {
-            throw new Error('interceptors.response');
-        }
-        return;
+var _helpers = require("../../../src/utils/helpers");
+const validateInterceptors = interceptors => {
+  const isInterceptorsObject = (0, _helpers.isPlainObject)(interceptors);
+  if (isInterceptorsObject) {
+    const {
+      request,
+      response
+    } = interceptors;
+    if (typeof request !== 'function' && typeof request !== 'undefined') {
+      throw new Error('interceptors.request');
     }
-    if (typeof interceptors !== 'undefined') {
-        throw new Error('interceptors');
+    if (typeof response !== 'function' && typeof response !== 'undefined') {
+      throw new Error('interceptors.response');
     }
+    return;
+  }
+  if (typeof interceptors !== 'undefined') {
+    throw new Error('interceptors');
+  }
 };
-exports.validateInterceptors = validateInterceptors;
+exports.validateInterceptors = validateInterceptors;

package/dist/bin/validateMockServerConfig/validateMockServerConfig.js

@@ -1,30 +1,32 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 exports.validateMockServerConfig = void 0;
-const validateBaseUrl_1 = require("./validateBaseUrl/validateBaseUrl");
-const validateCors_1 = require("./validateCors/validateCors");
-const validateGraphqlConfig_1 = require("./validateGraphqlConfig/validateGraphqlConfig");
-const validateInterceptors_1 = require("./validateInterceptors/validateInterceptors");
-const validatePort_1 = require("./validatePort/validatePort");
-const validateRestConfig_1 = require("./validateRestConfig/validateRestConfig");
-const validateStaticPath_1 = require("./validateStaticPath/validateStaticPath");
-const validateMockServerConfig = (mockServerConfig) => {
-    if (!mockServerConfig.rest && !mockServerConfig.graphql) {
-        throw new Error('configuration should contain at least one of these configs: rest | graphql; see our doc (https://www.npmjs.com/package/mock-config-server) for more information');
-    }
-    try {
-        if (mockServerConfig.rest)
-            (0, validateRestConfig_1.validateRestConfig)(mockServerConfig.rest);
-        if (mockServerConfig.graphql)
-            (0, validateGraphqlConfig_1.validateGraphqlConfig)(mockServerConfig.graphql);
-        (0, validateBaseUrl_1.validateBaseUrl)(mockServerConfig.baseUrl);
-        (0, validatePort_1.validatePort)(mockServerConfig.port);
-        (0, validateStaticPath_1.validateStaticPath)(mockServerConfig.staticPath);
-        (0, validateInterceptors_1.validateInterceptors)(mockServerConfig.interceptors);
-        (0, validateCors_1.validateCors)(mockServerConfig.cors);
-    }
-    catch (error) {
-        throw new Error(`Validation Error: configuration.${error.message} does not match the API schema. Click here to see correct type: https://github.com/siberiacancode/mock-config-server`);
-    }
+var _validateBaseUrl = require("./validateBaseUrl/validateBaseUrl");
+var _validateCors = require("./validateCors/validateCors");
+var _validateDatabaseConfig = require("./validateDatabaseConfig/validateDatabaseConfig");
+var _validateGraphqlConfig = require("./validateGraphqlConfig/validateGraphqlConfig");
+var _validateInterceptors = require("./validateInterceptors/validateInterceptors");
+var _validatePort = require("./validatePort/validatePort");
+var _validateRestConfig = require("./validateRestConfig/validateRestConfig");
+var _validateStaticPath = require("./validateStaticPath/validateStaticPath");
+const validateMockServerConfig = mockServerConfig => {
+  if (!mockServerConfig.rest && !mockServerConfig.graphql && !mockServerConfig.database) {
+    throw new Error('configuration should contain at least one of these configs: rest | graphql | database; see our doc (https://www.npmjs.com/package/mock-config-server) for more information');
+  }
+  try {
+    if (mockServerConfig.rest) (0, _validateRestConfig.validateRestConfig)(mockServerConfig.rest);
+    if (mockServerConfig.graphql) (0, _validateGraphqlConfig.validateGraphqlConfig)(mockServerConfig.graphql);
+    if (mockServerConfig.database) (0, _validateDatabaseConfig.validateDatabaseConfig)(mockServerConfig.database);
+    (0, _validateBaseUrl.validateBaseUrl)(mockServerConfig.baseUrl);
+    (0, _validatePort.validatePort)(mockServerConfig.port);
+    (0, _validateStaticPath.validateStaticPath)(mockServerConfig.staticPath);
+    (0, _validateInterceptors.validateInterceptors)(mockServerConfig.interceptors);
+    (0, _validateCors.validateCors)(mockServerConfig.cors);
+  } catch (error) {
+    throw new Error(`Validation Error: configuration.${error.message} does not match the API schema. Click here to see correct type: https://github.com/siberiacancode/mock-config-server`);
+  }
 };
-exports.validateMockServerConfig = validateMockServerConfig;
+exports.validateMockServerConfig = validateMockServerConfig;