mock-config-server 3.1.1 → 3.3.0

package/dist/bin/validateMockServerConfig/validateSettings/validateSettings.js

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.validateSettings = void 0;
+var _helpers = require("../../../src/utils/helpers");
+const ALLOWED_SETTINGS = ['polling'];
+const validateSetting = (setting, settingName) => {
+  if (settingName === 'polling' && typeof setting !== 'boolean') {
+    throw new Error('polling');
+  }
+};
+const validateSettings = settings => {
+  const isSettingsObject = (0, _helpers.isPlainObject)(settings);
+  if (isSettingsObject) {
+    Object.keys(settings).forEach(settingName => {
+      const isSettingAllowed = ALLOWED_SETTINGS.includes(settingName);
+      if (!isSettingAllowed) {
+        throw new Error(`settings.${settingName}`);
+      }
+      try {
+        validateSetting(settings[settingName], settingName);
+      } catch (error) {
+        throw new Error(`settings.${error.message}`);
+      }
+    });
+    return;
+  }
+  if (typeof settings !== 'undefined') {
+    throw new Error('settings');
+  }
+};
+exports.validateSettings = validateSettings;

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

@@ -5,16 +5,65 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.createNestedDatabaseRoutes = void 0;
 var _array = require("../array");
+var _filter = require("../filter/filter");
+var _pagination = require("../pagination/pagination");
+var _sort2 = require("../sort/sort");
 const createNestedDatabaseRoutes = (router, database, storage) => {
   Object.keys(database).forEach(key => {
     const collectionPath = `/${key}`;
     const itemPath = `/${key}/:id`;
-    router.route(collectionPath).get((_request, response) => {
+    router.route(collectionPath).get((request, response) => {
+      var _request$query;
+      let data = storage.read(key);
+      if (request.query && Object.keys(request.query).length) {
+        const {
+          _page,
+          _limit,
+          _begin,
+          _end,
+          _sort,
+          _order,
+          ...filters
+        } = request.query;
+        data = (0, _filter.filter)(data, filters);
+      }
+      if ((_request$query = request.query) !== null && _request$query !== void 0 && _request$query._page) {
+        data = (0, _pagination.pagination)(data, request.query);
+        if (data._link) {
+          const links = {};
+          const fullUrl = `${request.protocol}://${request.get('host')}${request.originalUrl}`;
+          if (data._link.first) {
+            links.first = fullUrl.replace(`page=${data._link.current}`, `page=${data._link.first}`);
+          }
+          if (data._link.prev) {
+            links.prev = fullUrl.replace(`page=${data._link.current}`, `page=${data._link.prev}`);
+          }
+          if (data._link.next) {
+            links.next = fullUrl.replace(`page=${data._link.current}`, `page=${data._link.next}`);
+          }
+          if (data._link.last) {
+            links.last = fullUrl.replace(`page=${data._link.current}`, `page=${data._link.last}`);
+          }
+          data._link = {
+            ...data._link,
+            ...links
+          };
+          response.links(links);
+        }
+      }
+      if (request.query && request.query._sort) {
+        data = (0, _sort2.sort)(data, request.query);
+      }
+      if (request.query._begin || request.query._end) {
+        var _request$query$_begin;
+        data = data.slice((_request$query$_begin = request.query._begin) !== null && _request$query$_begin !== void 0 ? _request$query$_begin : 0, request.query._end);
+        response.set('X-Total-Count', data.length);
+      }
       // ✅ important:
       // set 'Cache-Control' header for explicit browsers response revalidate
       // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Cache-Control
       response.set('Cache-control', 'max-age=0, must-revalidate');
-      response.json(storage.read(key));
+      response.json(data);
     });
     router.route(collectionPath).post((request, response) => {
       const collection = storage.read(key);

package/dist/src/core/database/createDatabaseRoutes/helpers/filter/filter.d.ts

@@ -0,0 +1,2 @@
+import type { ParsedUrlQuery } from 'node:querystring';
+export declare const filter: (array: any[], filters: ParsedUrlQuery) => any[];

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

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.filter = void 0;
+var _flat = require("flat");
+const filter = (array, filters) => array.filter(element => {
+  const flattenedElement = (0, _flat.flatten)(element);
+  return Object.entries(filters).every(([key, value]) => {
+    if (Array.isArray(value)) {
+      return value.includes(`${flattenedElement[key]}`);
+    }
+    return `${flattenedElement[key]}` === value;
+  });
+});
+exports.filter = filter;

package/dist/src/core/database/createDatabaseRoutes/helpers/index.d.ts

@@ -1,5 +1,5 @@
 export * from './array';
-export * from './createRewrittenDatabaseRoutes/createRewrittenDatabaseRoutes';
 export * from './createNestedDatabaseRoutes/createNestedDatabaseRoutes';
+export * from './createRewrittenDatabaseRoutes/createRewrittenDatabaseRoutes';
 export * from './createShallowDatabaseRoutes/createShallowDatabaseRoutes';
 export * from './splitDatabaseByNesting/splitDatabaseByNesting';

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

@@ -14,25 +14,25 @@ Object.keys(_array).forEach(function (key) {
     }
   });
 });
-var _createRewrittenDatabaseRoutes = require("./createRewrittenDatabaseRoutes/createRewrittenDatabaseRoutes");
-Object.keys(_createRewrittenDatabaseRoutes).forEach(function (key) {
+var _createNestedDatabaseRoutes = require("./createNestedDatabaseRoutes/createNestedDatabaseRoutes");
+Object.keys(_createNestedDatabaseRoutes).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _createRewrittenDatabaseRoutes[key]) return;
+  if (key in exports && exports[key] === _createNestedDatabaseRoutes[key]) return;
   Object.defineProperty(exports, key, {
     enumerable: true,
     get: function () {
-      return _createRewrittenDatabaseRoutes[key];
+      return _createNestedDatabaseRoutes[key];
     }
   });
 });
-var _createNestedDatabaseRoutes = require("./createNestedDatabaseRoutes/createNestedDatabaseRoutes");
-Object.keys(_createNestedDatabaseRoutes).forEach(function (key) {
+var _createRewrittenDatabaseRoutes = require("./createRewrittenDatabaseRoutes/createRewrittenDatabaseRoutes");
+Object.keys(_createRewrittenDatabaseRoutes).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _createNestedDatabaseRoutes[key]) return;
+  if (key in exports && exports[key] === _createRewrittenDatabaseRoutes[key]) return;
   Object.defineProperty(exports, key, {
     enumerable: true,
     get: function () {
-      return _createNestedDatabaseRoutes[key];
+      return _createRewrittenDatabaseRoutes[key];
     }
   });
 });

package/dist/src/core/database/createDatabaseRoutes/helpers/pagination/pagination.d.ts

@@ -0,0 +1,13 @@
+import type { ParsedUrlQuery } from 'node:querystring';
+export declare const pagination: (array: any[], queries: ParsedUrlQuery) => any[] | {
+    _link: {
+        count: number;
+        pages: number;
+        first: number;
+        current: number;
+        next: number | null;
+        prev: number | null;
+        last: number | null;
+    };
+    results: any[];
+};

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

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.pagination = void 0;
+const DEFAULT_LIMIT = 10;
+const pagination = (array, queries) => {
+  const {
+    _page
+  } = queries;
+  if (!_page || +_page <= 0) return array;
+  const page = +_page;
+  const limit = queries._limit && +queries._limit > 0 ? +queries._limit : DEFAULT_LIMIT;
+  const pages = Math.ceil(array.length / limit);
+  if (page > pages) return array;
+  const start = page * limit - limit;
+  const end = page * limit;
+  const results = array.slice(start, end);
+  const next = page + 1 <= pages ? page + 1 : null;
+  const prev = page - 1 !== 0 ? page - 1 : null;
+  const last = pages > 0 ? pages : null;
+  return {
+    _link: {
+      count: array.length,
+      pages,
+      first: 1,
+      current: page,
+      next,
+      prev,
+      last
+    },
+    results
+  };
+};
+exports.pagination = pagination;

package/dist/src/core/database/createDatabaseRoutes/helpers/sort/sort.d.ts

@@ -0,0 +1,2 @@
+import type { ParsedUrlQuery } from 'node:querystring';
+export declare const sort: (array: any[], queries: ParsedUrlQuery) => any[];

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

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.sort = void 0;
+var _flat = _interopRequireDefault(require("flat"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const DEFAULT_ORDER = 'asc';
+const getOrder = order => {
+  if (order === 'asc' || order === 'desc') return order;
+  return DEFAULT_ORDER;
+};
+const sortArray = (array, key, order) => array.sort((a, b) => {
+  const flattenedA = (0, _flat.default)(a);
+  const flattenedB = (0, _flat.default)(b);
+  if (!flattenedA[key] || !flattenedB[key]) return 0;
+  if (typeof flattenedA[key] === 'string' && typeof flattenedB[key] === 'string') {
+    return order === 'asc' ? flattenedA[key].localeCompare(flattenedB[key]) : flattenedB[key].localeCompare(flattenedA[key]);
+  }
+  return order === 'asc' ? Number(flattenedA[key]) - Number(flattenedB[key]) : Number(flattenedB[key]) - Number(flattenedA[key]);
+});
+const sort = (array, queries) => {
+  const {
+    _sort,
+    _order = DEFAULT_ORDER
+  } = queries;
+  if (!_sort) return array;
+  const result = [...array];
+  if (Array.isArray(_sort)) {
+    const orders = Array.isArray(_order) ? _order : [_order];
+    _sort.forEach((key, index) => {
+      const order = getOrder(orders[index]);
+      sortArray(result, key, order);
+    });
+    return result;
+  }
+  const order = getOrder(Array.isArray(_order) ? _order[0] : _order);
+  sortArray(result, _sort, order);
+  return result;
+};
+exports.sort = sort;

package/dist/src/core/database/createDatabaseRoutes/storages/File/FileStorage.d.ts

@@ -1,6 +1,5 @@
 type Index = string | number;
-type Object = Record<Index, any>;
-export declare class FileStorage<T extends Object = Object> {
+export declare class FileStorage<T extends Record<Index, any> = Record<Index, any>> {
     private readonly fileWriter;
     private readonly data;
     constructor(fileName: string);

package/dist/src/core/database/createDatabaseRoutes/storages/Memory/MemoryStorage.d.ts

@@ -1,6 +1,5 @@
 type Index = string | number;
-type Object = Record<Index, any>;
-export declare class MemoryStorage<T extends Object = Object> {
+export declare class MemoryStorage<T extends Record<Index, any> = Record<Index, any>> {
     private readonly data;
     constructor(initialData: T);
     read(key?: Index | Index[]): any;

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

@@ -1,3 +1,9 @@
 import type { IRouter } from 'express';
 import type { GraphqlConfig, Interceptors } from '../../../utils/types';
-export declare const createGraphQLRoutes: (router: IRouter, graphqlConfig: GraphqlConfig, serverResponseInterceptors?: Interceptors['response']) => IRouter;
+interface CreateGraphQLRoutesParams {
+    router: IRouter;
+    graphqlConfig: GraphqlConfig;
+    serverResponseInterceptor?: Interceptors['response'];
+}
+export declare const createGraphQLRoutes: ({ router, graphqlConfig, serverResponseInterceptor }: CreateGraphQLRoutesParams) => IRouter;
+export {};

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

@@ -7,12 +7,16 @@ exports.createGraphQLRoutes = void 0;
 var _flat = require("flat");
 var _helpers = require("../../../utils/helpers");
 var _helpers2 = require("./helpers");
-const createGraphQLRoutes = (router, graphqlConfig, serverResponseInterceptors) => {
+const createGraphQLRoutes = ({
+  router,
+  graphqlConfig,
+  serverResponseInterceptor
+}) => {
   const preparedGraphQLRequestConfig = (0, _helpers2.prepareGraphQLRequestConfigs)(graphqlConfig.configs);
   const graphqlMiddleware = async (request, response, next) => {
-    var _matchedRequestConfig, _matchedRouteConfig$e, _matchedRouteConfig$i, _matchedRequestConfig2, _graphqlConfig$interc;
+    var _matchedRequestConfig, _matchedRouteConfig$s, _matchedRouteConfig$e, _matchedRouteConfig$i, _matchedRequestConfig2, _graphqlConfig$interc;
     const graphQLInput = (0, _helpers.getGraphQLInput)(request);
-    if (!graphQLInput || !graphQLInput.query) {
+    if (!graphQLInput.query) {
       return response.status(400).json({
         message: 'Query is missing, you must pass a valid GraphQL query'
       });
@@ -23,16 +27,16 @@ const createGraphQLRoutes = (router, graphqlConfig, serverResponseInterceptors)
         message: 'Query is invalid, you must use a valid GraphQL query'
       });
     }
-    if (!query.operationName || !query.operationType) {
-      return response.status(400).json({
-        message: `You should to specify operationName and operationType for ${request.method}:${request.baseUrl}${request.path}`
-      });
-    }
     const matchedRequestConfig = preparedGraphQLRequestConfig.find(requestConfig => {
-      if (requestConfig.operationName instanceof RegExp) {
-        return new RegExp(requestConfig.operationName).test(query.operationName) && requestConfig.operationType === query.operationType;
+      var _graphQLInput$query;
+      if (requestConfig.operationType !== query.operationType) return false;
+      if ('query' in requestConfig && requestConfig.query.replace(/\s+/gi, ' ') !== ((_graphQLInput$query = graphQLInput.query) === null || _graphQLInput$query === void 0 ? void 0 : _graphQLInput$query.replace(/\s+/gi, ' '))) return false;
+      if ('operationName' in requestConfig) {
+        if (!query.operationName) return false;
+        if (requestConfig.operationName instanceof RegExp) return new RegExp(requestConfig.operationName).test(query.operationName);
+        return requestConfig.operationName === query.operationName;
       }
-      return requestConfig.operationName === query.operationName && requestConfig.operationType === query.operationType;
+      return true;
     });
     if (!matchedRequestConfig) {
       return next();
@@ -49,25 +53,29 @@ const createGraphQLRoutes = (router, graphqlConfig, serverResponseInterceptors)
     }) => {
       if (!entities) return true;
       const entries = Object.entries(entities);
-      return entries.every(([entityName, valueOrDescriptor]) => {
+      return entries.every(([entityName, entityDescriptorOrValue]) => {
         const {
           checkMode,
-          value: descriptorValue
-        } = (0, _helpers.convertToEntityDescriptor)(valueOrDescriptor);
+          value: entityDescriptorValue
+        } = (0, _helpers.convertToEntityDescriptor)(entityDescriptorOrValue);
 
         // ✅ important: check whole variables as plain value strictly if descriptor used for variables
-        const isVariablesPlain = entityName === 'variables' && (0, _helpers.isEntityDescriptor)(valueOrDescriptor);
-        if (isVariablesPlain) {
-          // ✅ important: getGraphQLInput returns empty object if variables not sent or invalid, so count {} as undefined
-          return (0, _helpers.resolveEntityValues)(checkMode, Object.keys(graphQLInput.variables).length ? graphQLInput.variables : undefined, descriptorValue);
+        const isEntityVariablesByTopLevelDescriptor = entityName === 'variables' && (0, _helpers.isEntityDescriptor)(entityDescriptorOrValue);
+        if (isEntityVariablesByTopLevelDescriptor) {
+          return (0, _helpers.resolveEntityValues)(checkMode, graphQLInput.variables, entityDescriptorValue);
         }
-        const mappedEntityDescriptors = Object.entries(valueOrDescriptor);
-        return mappedEntityDescriptors.every(([entityKey, mappedEntityDescriptor]) => {
+        const isEntityVariablesByTopLevelArray = entityName === 'variables' && Array.isArray(entityDescriptorOrValue);
+        if (isEntityVariablesByTopLevelArray) {
+          return entityDescriptorOrValue.some(entityDescriptorOrValueElement => (0, _helpers.resolveEntityValues)(checkMode, graphQLInput.variables, entityDescriptorOrValueElement));
+        }
+        const recordOrArrayEntries = Object.entries(entityDescriptorOrValue);
+        return recordOrArrayEntries.every(([entityKey, entityValue]) => {
           const {
             checkMode,
             value: descriptorValue
-          } = (0, _helpers.convertToEntityDescriptor)(mappedEntityDescriptor);
+          } = (0, _helpers.convertToEntityDescriptor)(entityValue);
           const flattenEntity = (0, _flat.flatten)(entityName === 'variables' ? graphQLInput.variables : request[entityName]);
+
           // ✅ important: transform header keys to lower case because browsers send headers in lowercase
           return (0, _helpers.resolveEntityValues)(checkMode, flattenEntity[entityName === 'headers' ? entityKey.toLowerCase() : entityKey], descriptorValue);
         });
@@ -76,16 +84,49 @@ const createGraphQLRoutes = (router, graphqlConfig, serverResponseInterceptors)
     if (!matchedRouteConfig) {
       return next();
     }
-    const matchedRouteConfigData = typeof matchedRouteConfig.data === 'function' ? await matchedRouteConfig.data(request, (_matchedRouteConfig$e = matchedRouteConfig.entities) !== null && _matchedRouteConfig$e !== void 0 ? _matchedRouteConfig$e : {}) : matchedRouteConfig.data;
+    let matchedRouteConfigData = null;
+    if ((_matchedRouteConfig$s = matchedRouteConfig.settings) !== null && _matchedRouteConfig$s !== void 0 && _matchedRouteConfig$s.polling && 'queue' in matchedRouteConfig) {
+      var _shallowMatchedRouteC;
+      if (!matchedRouteConfig.queue.length) return next();
+      const shallowMatchedRouteConfig = matchedRouteConfig;
+      let index = (_shallowMatchedRouteC = shallowMatchedRouteConfig.__pollingIndex) !== null && _shallowMatchedRouteC !== void 0 ? _shallowMatchedRouteC : 0;
+      const {
+        time,
+        data
+      } = matchedRouteConfig.queue[index];
+      const updateIndex = () => {
+        if (matchedRouteConfig.queue.length - 1 === index) {
+          index = 0;
+        } else {
+          index += 1;
+        }
+        shallowMatchedRouteConfig.__pollingIndex = index;
+      };
+      if (time && !shallowMatchedRouteConfig.__timeoutInProgress) {
+        shallowMatchedRouteConfig.__timeoutInProgress = true;
+        setTimeout(() => {
+          shallowMatchedRouteConfig.__timeoutInProgress = false;
+          updateIndex();
+        }, time);
+      }
+      if (!time && !shallowMatchedRouteConfig.__timeoutInProgress) {
+        updateIndex();
+      }
+      matchedRouteConfigData = data;
+    }
+    if ('data' in matchedRouteConfig) {
+      matchedRouteConfigData = matchedRouteConfig.data;
+    }
+    const resolvedData = typeof matchedRouteConfigData === 'function' ? await matchedRouteConfigData(request, (_matchedRouteConfig$e = matchedRouteConfig.entities) !== null && _matchedRouteConfig$e !== void 0 ? _matchedRouteConfig$e : {}) : matchedRouteConfigData;
     const data = await (0, _helpers.callResponseInterceptors)({
-      data: matchedRouteConfigData,
+      data: resolvedData,
       request,
       response,
       interceptors: {
         routeInterceptor: (_matchedRouteConfig$i = matchedRouteConfig.interceptors) === null || _matchedRouteConfig$i === void 0 ? void 0 : _matchedRouteConfig$i.response,
         requestInterceptor: (_matchedRequestConfig2 = matchedRequestConfig.interceptors) === null || _matchedRequestConfig2 === void 0 ? void 0 : _matchedRequestConfig2.response,
         apiInterceptor: (_graphqlConfig$interc = graphqlConfig.interceptors) === null || _graphqlConfig$interc === void 0 ? void 0 : _graphqlConfig$interc.response,
-        serverInterceptor: serverResponseInterceptors
+        serverInterceptor: serverResponseInterceptor
       }
     });
 

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

@@ -1,8 +1,8 @@
-export * from './staticMiddleware/staticMiddleware';
+export * from './cookieParseMiddleware/cookieParseMiddleware';
 export * from './corsMiddleware/corsMiddleware';
+export * from './destroyerMiddleware/destroyerMiddleware';
+export * from './errorMiddleware/errorMiddleware';
 export * from './noCorsMiddleware/noCorsMiddleware';
 export * from './notFoundMiddleware/notFoundMiddleware';
 export * from './requestInterceptorMiddleware/requestInterceptorMiddleware';
-export * from './destroyerMiddleware/destroyerMiddleware';
-export * from './cookieParseMiddleware/cookieParseMiddleware';
-export * from './errorMiddleware/errorMiddleware';
+export * from './staticMiddleware/staticMiddleware';

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

@@ -3,14 +3,14 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-var _staticMiddleware = require("./staticMiddleware/staticMiddleware");
-Object.keys(_staticMiddleware).forEach(function (key) {
+var _cookieParseMiddleware = require("./cookieParseMiddleware/cookieParseMiddleware");
+Object.keys(_cookieParseMiddleware).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _staticMiddleware[key]) return;
+  if (key in exports && exports[key] === _cookieParseMiddleware[key]) return;
   Object.defineProperty(exports, key, {
     enumerable: true,
     get: function () {
-      return _staticMiddleware[key];
+      return _cookieParseMiddleware[key];
     }
   });
 });
@@ -25,69 +25,69 @@ Object.keys(_corsMiddleware).forEach(function (key) {
     }
   });
 });
-var _noCorsMiddleware = require("./noCorsMiddleware/noCorsMiddleware");
-Object.keys(_noCorsMiddleware).forEach(function (key) {
+var _destroyerMiddleware = require("./destroyerMiddleware/destroyerMiddleware");
+Object.keys(_destroyerMiddleware).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _noCorsMiddleware[key]) return;
+  if (key in exports && exports[key] === _destroyerMiddleware[key]) return;
   Object.defineProperty(exports, key, {
     enumerable: true,
     get: function () {
-      return _noCorsMiddleware[key];
+      return _destroyerMiddleware[key];
     }
   });
 });
-var _notFoundMiddleware = require("./notFoundMiddleware/notFoundMiddleware");
-Object.keys(_notFoundMiddleware).forEach(function (key) {
+var _errorMiddleware = require("./errorMiddleware/errorMiddleware");
+Object.keys(_errorMiddleware).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _notFoundMiddleware[key]) return;
+  if (key in exports && exports[key] === _errorMiddleware[key]) return;
   Object.defineProperty(exports, key, {
     enumerable: true,
     get: function () {
-      return _notFoundMiddleware[key];
+      return _errorMiddleware[key];
     }
   });
 });
-var _requestInterceptorMiddleware = require("./requestInterceptorMiddleware/requestInterceptorMiddleware");
-Object.keys(_requestInterceptorMiddleware).forEach(function (key) {
+var _noCorsMiddleware = require("./noCorsMiddleware/noCorsMiddleware");
+Object.keys(_noCorsMiddleware).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _requestInterceptorMiddleware[key]) return;
+  if (key in exports && exports[key] === _noCorsMiddleware[key]) return;
   Object.defineProperty(exports, key, {
     enumerable: true,
     get: function () {
-      return _requestInterceptorMiddleware[key];
+      return _noCorsMiddleware[key];
     }
   });
 });
-var _destroyerMiddleware = require("./destroyerMiddleware/destroyerMiddleware");
-Object.keys(_destroyerMiddleware).forEach(function (key) {
+var _notFoundMiddleware = require("./notFoundMiddleware/notFoundMiddleware");
+Object.keys(_notFoundMiddleware).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _destroyerMiddleware[key]) return;
+  if (key in exports && exports[key] === _notFoundMiddleware[key]) return;
   Object.defineProperty(exports, key, {
     enumerable: true,
     get: function () {
-      return _destroyerMiddleware[key];
+      return _notFoundMiddleware[key];
     }
   });
 });
-var _cookieParseMiddleware = require("./cookieParseMiddleware/cookieParseMiddleware");
-Object.keys(_cookieParseMiddleware).forEach(function (key) {
+var _requestInterceptorMiddleware = require("./requestInterceptorMiddleware/requestInterceptorMiddleware");
+Object.keys(_requestInterceptorMiddleware).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _cookieParseMiddleware[key]) return;
+  if (key in exports && exports[key] === _requestInterceptorMiddleware[key]) return;
   Object.defineProperty(exports, key, {
     enumerable: true,
     get: function () {
-      return _cookieParseMiddleware[key];
+      return _requestInterceptorMiddleware[key];
     }
   });
 });
-var _errorMiddleware = require("./errorMiddleware/errorMiddleware");
-Object.keys(_errorMiddleware).forEach(function (key) {
+var _staticMiddleware = require("./staticMiddleware/staticMiddleware");
+Object.keys(_staticMiddleware).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _errorMiddleware[key]) return;
+  if (key in exports && exports[key] === _staticMiddleware[key]) return;
   Object.defineProperty(exports, key, {
     enumerable: true,
     get: function () {
-      return _errorMiddleware[key];
+      return _staticMiddleware[key];
     }
   });
 });

package/dist/src/core/middlewares/notFoundMiddleware/helpers/getLevenshteinDistance/getLevenshteinDistance.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.getLevenshteinDistance = void 0;
+/* eslint-disable eslint-comments/disable-enable-pair, eslint-comments/no-unlimited-disable */
 /* eslint-disable */
 
 const min = (d0, d1, d2, bx, ay) => d0 < d1 || d2 < d1 ? d0 > d2 ? d2 + 1 : d0 + 1 : bx === ay ? d1 : d1 + 1;

package/dist/src/core/middlewares/notFoundMiddleware/notFoundMiddleware.js

@@ -22,9 +22,7 @@ const notFoundMiddleware = (server, mockServerConfig) => {
       path: `${serverBaseUrl !== null && serverBaseUrl !== void 0 ? serverBaseUrl : ''}${(_rest$baseUrl = rest === null || rest === void 0 ? void 0 : rest.baseUrl) !== null && _rest$baseUrl !== void 0 ? _rest$baseUrl : ''}${request.path}`
     };
   })) !== null && _rest$configs$filter$ !== void 0 ? _rest$configs$filter$ : [];
-  const graphqlRequestConfigs = (_graphql$configs$filt = graphql === null || graphql === void 0 ? void 0 : graphql.configs.filter(({
-    operationName
-  }) => !(operationName instanceof RegExp)).map(request => {
+  const graphqlRequestConfigs = (_graphql$configs$filt = graphql === null || graphql === void 0 ? void 0 : graphql.configs.filter(request => 'operationName' in request && !(request.operationName instanceof RegExp)).map(request => {
     var _graphql$baseUrl;
     return {
       operationType: request.operationType,

package/dist/src/core/middlewares/requestInterceptorMiddleware/requestInterceptorMiddleware.d.ts

@@ -1,3 +1,9 @@
 import type { Express } from 'express';
 import type { RequestInterceptor } from '../../../utils/types';
-export declare const requestInterceptorMiddleware: (server: Express, interceptor: RequestInterceptor) => void;
+interface RequestInterceptorMiddlewareParams {
+    server: Express;
+    path?: string;
+    interceptor: RequestInterceptor;
+}
+export declare const requestInterceptorMiddleware: ({ server, path, interceptor }: RequestInterceptorMiddlewareParams) => void;
+export {};

package/dist/src/core/middlewares/requestInterceptorMiddleware/requestInterceptorMiddleware.js

@@ -5,8 +5,12 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.requestInterceptorMiddleware = void 0;
 var _helpers = require("../../../utils/helpers");
-const requestInterceptorMiddleware = (server, interceptor) => {
-  server.use((0, _helpers.asyncHandler)(async (request, _response, next) => {
+const requestInterceptorMiddleware = ({
+  server,
+  path = '*',
+  interceptor
+}) => {
+  server.use(path, (0, _helpers.asyncHandler)(async (request, _response, next) => {
     await (0, _helpers.callRequestInterceptor)({
       request,
       interceptor

package/dist/src/core/rest/createRestRoutes/createRestRoutes.d.ts

@@ -1,3 +1,9 @@
 import type { IRouter } from 'express';
 import type { Interceptors, RestConfig } from '../../../utils/types';
-export declare const createRestRoutes: (router: IRouter, restConfig: RestConfig, serverResponseInterceptors?: Interceptors['response']) => IRouter;
+interface CreateRestRoutesParams {
+    router: IRouter;
+    restConfig: RestConfig;
+    serverResponseInterceptor?: Interceptors['response'];
+}
+export declare const createRestRoutes: ({ router, restConfig, serverResponseInterceptor }: CreateRestRoutesParams) => IRouter;
+export {};