mock-config-server 2.0.1 → 2.1.0

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

@@ -1,71 +1,71 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateRoutes = void 0;
-const helpers_1 = require("../../../../src/utils/helpers");
-const validateInterceptors_1 = require("../../validateInterceptors/validateInterceptors");
-const ALLOWED_ENTITIES_BY_OPERATION_TYPE = {
-    query: ['headers', 'query', 'variables'],
-    mutation: ['headers', 'query', 'variables']
-};
-const validateHeadersOrQuery = (headersOrQuery, entity) => {
-    const isHeadersOrQueryObject = (0, helpers_1.isPlainObject)(headersOrQuery);
-    if (isHeadersOrQueryObject) {
-        Object.entries(headersOrQuery).forEach(([headerOrQueryKey, headerOrQueryValue]) => {
-            if (typeof headerOrQueryValue !== 'string') {
-                throw new Error(`${entity}.${headerOrQueryKey}`);
-            }
-        });
-        return;
-    }
-    throw new Error(entity);
-};
-const validateEntities = (entities, operationType) => {
-    const isEntitiesObject = (0, helpers_1.isPlainObject)(entities);
-    if (isEntitiesObject) {
-        Object.keys(entities).forEach((entity) => {
-            const isEntityAllowed = ALLOWED_ENTITIES_BY_OPERATION_TYPE[operationType].includes(entity);
-            if (!isEntityAllowed) {
-                throw new Error(`entities.${entity}`);
-            }
-            if (entity === 'headers' || entity === 'query') {
-                try {
-                    const headersOrQuery = entities[entity];
-                    return validateHeadersOrQuery(headersOrQuery, entity);
-                }
-                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}]`);
-        });
-        return;
-    }
-    throw new Error('routes');
-};
-exports.validateRoutes = validateRoutes;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateRoutes = void 0;
+const helpers_1 = require("../../../../src/utils/helpers");
+const validateInterceptors_1 = require("../../validateInterceptors/validateInterceptors");
+const ALLOWED_ENTITIES_BY_OPERATION_TYPE = {
+    query: ['headers', 'query', 'variables'],
+    mutation: ['headers', 'query', 'variables']
+};
+const validateHeadersOrQuery = (headersOrQuery, entity) => {
+    const isHeadersOrQueryObject = (0, helpers_1.isPlainObject)(headersOrQuery);
+    if (isHeadersOrQueryObject) {
+        Object.entries(headersOrQuery).forEach(([headerOrQueryKey, headerOrQueryValue]) => {
+            if (typeof headerOrQueryValue !== 'string') {
+                throw new Error(`${entity}.${headerOrQueryKey}`);
+            }
+        });
+        return;
+    }
+    throw new Error(entity);
+};
+const validateEntities = (entities, operationType) => {
+    const isEntitiesObject = (0, helpers_1.isPlainObject)(entities);
+    if (isEntitiesObject) {
+        Object.keys(entities).forEach((entity) => {
+            const isEntityAllowed = ALLOWED_ENTITIES_BY_OPERATION_TYPE[operationType].includes(entity);
+            if (!isEntityAllowed) {
+                throw new Error(`entities.${entity}`);
+            }
+            if (entity === 'headers' || entity === 'query') {
+                try {
+                    const headersOrQuery = entities[entity];
+                    validateHeadersOrQuery(headersOrQuery, entity);
+                }
+                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}]`);
+        });
+        return;
+    }
+    throw new Error('routes');
+};
+exports.validateRoutes = validateRoutes;

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

@@ -1 +1 @@
-export declare const validateInterceptors: (interceptors: unknown) => void;
+export declare const validateInterceptors: (interceptors: unknown) => void;

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

@@ -1,21 +1,21 @@
-"use strict";
-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;
-    }
-    if (typeof interceptors !== 'undefined') {
-        throw new Error('interceptors');
-    }
-};
-exports.validateInterceptors = validateInterceptors;
+"use strict";
+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;
+    }
+    if (typeof interceptors !== 'undefined') {
+        throw new Error('interceptors');
+    }
+};
+exports.validateInterceptors = validateInterceptors;

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

@@ -1 +1,2 @@
-export declare const validateMockServerConfig: (mockServerConfig: unknown) => void;
+import type { PlainObject } from '../../src';
+export declare const validateMockServerConfig: (mockServerConfig: PlainObject) => void;

package/dist/bin/validateMockServerConfig/validateMockServerConfig.js

@@ -1,34 +1,30 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateMockServerConfig = void 0;
-const helpers_1 = require("../../src/utils/helpers");
-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 (!(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');
-    }
-    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`);
-    }
-};
-exports.validateMockServerConfig = validateMockServerConfig;
+"use strict";
+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`);
+    }
+};
+exports.validateMockServerConfig = validateMockServerConfig;

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

@@ -1 +1 @@
-export declare const validatePort: (port: unknown) => void;
+export declare const validatePort: (port: unknown) => void;

package/dist/bin/validateMockServerConfig/validatePort/validatePort.js

@@ -1,9 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validatePort = void 0;
-const validatePort = (port) => {
-    if (typeof port !== 'number' && typeof port !== 'undefined') {
-        throw new Error('port');
-    }
-};
-exports.validatePort = validatePort;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validatePort = void 0;
+const validatePort = (port) => {
+    if (typeof port !== 'number' && typeof port !== 'undefined') {
+        throw new Error('port');
+    }
+};
+exports.validatePort = validatePort;

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

@@ -1 +1 @@
-export declare const validateRestConfig: (restConfig: unknown) => void;
+export declare const validateRestConfig: (restConfig: unknown) => void;

package/dist/bin/validateMockServerConfig/validateRestConfig/validateRestConfig.js

@@ -1,52 +1,52 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateRestConfig = 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 { path, method } = config;
-            const isPathStringWithLeadingSlash = typeof path === 'string' && path.startsWith('/');
-            if (!isPathStringWithLeadingSlash && !(path instanceof RegExp)) {
-                throw new Error(`configs[${index}].path`);
-            }
-            // ✅ important:
-            // compare without 'toLowerCase' because Express methods names is case-sensitive
-            const allowedMethods = ['get', 'post', 'delete', 'put', 'patch'];
-            const isMethodAllowed = typeof method === 'string' && allowedMethods.includes(method);
-            if (!isMethodAllowed) {
-                throw new Error(`configs[${index}].method`);
-            }
-            try {
-                (0, validateRoutes_1.validateRoutes)(config.routes, method);
-                (0, validateInterceptors_1.validateInterceptors)(config.interceptors);
-            }
-            catch (error) {
-                throw new Error(`configs[${index}].${error.message}`);
-            }
-        });
-        return;
-    }
-    throw new Error('configs');
-};
-const validateRestConfig = (restConfig) => {
-    const isRestConfigObject = (0, helpers_1.isPlainObject)(restConfig);
-    if (isRestConfigObject) {
-        try {
-            (0, validateBaseUrl_1.validateBaseUrl)(restConfig.baseUrl);
-            validateConfigs(restConfig.configs);
-        }
-        catch (error) {
-            throw new Error(`rest.${error.message}`);
-        }
-        return;
-    }
-    if (typeof restConfig !== 'undefined') {
-        throw new Error('rest');
-    }
-};
-exports.validateRestConfig = validateRestConfig;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateRestConfig = 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 { path, method } = config;
+            const isPathStringWithLeadingSlash = typeof path === 'string' && path.startsWith('/');
+            if (!isPathStringWithLeadingSlash && !(path instanceof RegExp)) {
+                throw new Error(`configs[${index}].path`);
+            }
+            // ✅ important:
+            // compare without 'toLowerCase' because Express methods names is case-sensitive
+            const allowedMethods = ['get', 'post', 'delete', 'put', 'patch', 'options'];
+            const isMethodAllowed = typeof method === 'string' && allowedMethods.includes(method);
+            if (!isMethodAllowed) {
+                throw new Error(`configs[${index}].method`);
+            }
+            try {
+                (0, validateRoutes_1.validateRoutes)(config.routes, method);
+                (0, validateInterceptors_1.validateInterceptors)(config.interceptors);
+            }
+            catch (error) {
+                throw new Error(`configs[${index}].${error.message}`);
+            }
+        });
+        return;
+    }
+    throw new Error('configs');
+};
+const validateRestConfig = (restConfig) => {
+    const isRestConfigObject = (0, helpers_1.isPlainObject)(restConfig);
+    if (isRestConfigObject) {
+        try {
+            (0, validateBaseUrl_1.validateBaseUrl)(restConfig.baseUrl);
+            validateConfigs(restConfig.configs);
+        }
+        catch (error) {
+            throw new Error(`rest.${error.message}`);
+        }
+        return;
+    }
+    if (typeof restConfig !== 'undefined') {
+        throw new Error('rest');
+    }
+};
+exports.validateRestConfig = validateRestConfig;

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

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

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

@@ -1,104 +1,105 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateRoutes = void 0;
-const helpers_1 = require("../../../../src/utils/helpers");
-const validateInterceptors_1 = require("../../validateInterceptors/validateInterceptors");
-const ALLOWED_ENTITIES_BY_METHOD = {
-    get: ['headers', 'query', 'params'],
-    delete: ['headers', 'query', 'params'],
-    post: ['headers', 'query', 'params', 'body'],
-    put: ['headers', 'query', 'params', 'body'],
-    patch: ['headers', 'query', 'params', 'body']
-};
-const validateHeadersOrParams = (headersOrParams, entity) => {
-    const isHeadersOrParamsObject = (0, helpers_1.isPlainObject)(headersOrParams);
-    if (isHeadersOrParamsObject) {
-        Object.entries(headersOrParams).forEach(([headerOrParamKey, headerOrParamValue]) => {
-            if (typeof headerOrParamValue !== 'string') {
-                throw new Error(`${entity}.${headerOrParamKey}`);
-            }
-        });
-        return;
-    }
-    throw new Error(entity);
-};
-const validateQuery = (query, entity) => {
-    const isQueryObject = (0, helpers_1.isPlainObject)(query);
-    if (isQueryObject) {
-        Object.entries(query).forEach(([queryKey, queryValue]) => {
-            const isQueryValueArray = Array.isArray(queryValue);
-            if (isQueryValueArray) {
-                queryValue.forEach((queryValueElement, index) => {
-                    if (typeof queryValueElement !== 'string') {
-                        throw new Error(`${entity}.${queryKey}[${index}]`);
-                    }
-                });
-                return;
-            }
-            if (typeof queryValue !== 'string') {
-                throw new Error(`${entity}.${queryKey}`);
-            }
-        });
-        return;
-    }
-    throw new Error(entity);
-};
-const validateEntities = (entities, method) => {
-    const isEntitiesObject = (0, helpers_1.isPlainObject)(entities);
-    if (isEntitiesObject) {
-        Object.keys(entities).forEach((entity) => {
-            const isEntityAllowed = ALLOWED_ENTITIES_BY_METHOD[method].includes(entity);
-            if (!isEntityAllowed) {
-                throw new Error(`entities.${entity}`);
-            }
-            if (entity === 'headers' || entity === 'params') {
-                try {
-                    const headersOrParams = entities[entity];
-                    return validateHeadersOrParams(headersOrParams, entity);
-                }
-                catch (error) {
-                    throw new Error(`entities.${error.message}`);
-                }
-            }
-            if (entity === 'query') {
-                try {
-                    const query = entities[entity];
-                    return validateQuery(query, entity);
-                }
-                catch (error) {
-                    throw new Error(`entities.${error.message}`);
-                }
-            }
-        });
-        return;
-    }
-    if (typeof entities !== 'undefined') {
-        throw new Error('entities');
-    }
-};
-const validateRoutes = (routes, method) => {
-    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, method);
-                    (0, validateInterceptors_1.validateInterceptors)(route.interceptors);
-                }
-                catch (error) {
-                    throw new Error(`routes[${index}].${error.message}`);
-                }
-                return;
-            }
-            throw new Error(`routes[${index}]`);
-        });
-        return;
-    }
-    throw new Error('routes');
-};
-exports.validateRoutes = validateRoutes;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateRoutes = void 0;
+const helpers_1 = require("../../../../src/utils/helpers");
+const validateInterceptors_1 = require("../../validateInterceptors/validateInterceptors");
+const ALLOWED_ENTITIES_BY_METHOD = {
+    get: ['headers', 'query', 'params'],
+    delete: ['headers', 'query', 'params'],
+    post: ['headers', 'query', 'params', 'body'],
+    put: ['headers', 'query', 'params', 'body'],
+    patch: ['headers', 'query', 'params', 'body'],
+    options: ['headers', 'query', 'params']
+};
+const validateHeadersOrParams = (headersOrParams, entity) => {
+    const isHeadersOrParamsObject = (0, helpers_1.isPlainObject)(headersOrParams);
+    if (isHeadersOrParamsObject) {
+        Object.entries(headersOrParams).forEach(([headerOrParamKey, headerOrParamValue]) => {
+            if (typeof headerOrParamValue !== 'string') {
+                throw new Error(`${entity}.${headerOrParamKey}`);
+            }
+        });
+        return;
+    }
+    throw new Error(entity);
+};
+const validateQuery = (query, entity) => {
+    const isQueryObject = (0, helpers_1.isPlainObject)(query);
+    if (isQueryObject) {
+        Object.entries(query).forEach(([queryKey, queryValue]) => {
+            const isQueryValueArray = Array.isArray(queryValue);
+            if (isQueryValueArray) {
+                queryValue.forEach((queryValueElement, index) => {
+                    if (typeof queryValueElement !== 'string') {
+                        throw new Error(`${entity}.${queryKey}[${index}]`);
+                    }
+                });
+                return;
+            }
+            if (typeof queryValue !== 'string') {
+                throw new Error(`${entity}.${queryKey}`);
+            }
+        });
+        return;
+    }
+    throw new Error(entity);
+};
+const validateEntities = (entities, method) => {
+    const isEntitiesObject = (0, helpers_1.isPlainObject)(entities);
+    if (isEntitiesObject) {
+        Object.keys(entities).forEach((entity) => {
+            const isEntityAllowed = ALLOWED_ENTITIES_BY_METHOD[method].includes(entity);
+            if (!isEntityAllowed) {
+                throw new Error(`entities.${entity}`);
+            }
+            if (entity === 'headers' || entity === 'params') {
+                try {
+                    const headersOrParams = entities[entity];
+                    validateHeadersOrParams(headersOrParams, entity);
+                }
+                catch (error) {
+                    throw new Error(`entities.${error.message}`);
+                }
+            }
+            if (entity === 'query') {
+                try {
+                    const query = entities[entity];
+                    validateQuery(query, entity);
+                }
+                catch (error) {
+                    throw new Error(`entities.${error.message}`);
+                }
+            }
+        });
+        return;
+    }
+    if (typeof entities !== 'undefined') {
+        throw new Error('entities');
+    }
+};
+const validateRoutes = (routes, method) => {
+    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, method);
+                    (0, validateInterceptors_1.validateInterceptors)(route.interceptors);
+                }
+                catch (error) {
+                    throw new Error(`routes[${index}].${error.message}`);
+                }
+                return;
+            }
+            throw new Error(`routes[${index}]`);
+        });
+        return;
+    }
+    throw new Error('routes');
+};
+exports.validateRoutes = validateRoutes;

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

@@ -1 +1 @@
-export declare const validateStaticPath: (staticPath: unknown) => void;
+export declare const validateStaticPath: (staticPath: unknown) => void;