mock-config-server 3.0.0 → 3.1.0

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

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createRewrittenDatabaseRoutes = void 0;
+var _expressUrlrewrite = _interopRequireDefault(require("express-urlrewrite"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const createRewrittenDatabaseRoutes = (router, rewrittenRoutes) => Object.entries(rewrittenRoutes).forEach(([key, value]) => {
+  router.use((0, _expressUrlrewrite.default)(key, value));
+});
+exports.createRewrittenDatabaseRoutes = createRewrittenDatabaseRoutes;

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

@@ -0,0 +1,4 @@
+import type { IRouter } from 'express';
+import type { ShallowDatabase } from '../../../../../utils/types';
+import type { MemoryStorage } from '../../storages';
+export declare const createShallowDatabaseRoutes: (router: IRouter, database: ShallowDatabase, storage: MemoryStorage<ShallowDatabase>) => IRouter;

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

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createShallowDatabaseRoutes = void 0;
+const createShallowDatabaseRoutes = (router, database, storage) => {
+  Object.keys(database).forEach(key => {
+    const path = `/${key}`;
+    router.route(path).get((_request, response) => {
+      // ✅ 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));
+    });
+    router.route(path).post((request, response) => {
+      storage.write(key, request.body);
+      response.set('Location', request.url);
+      response.status(201).json(request.body);
+    });
+    router.route(path).put((request, response) => {
+      storage.write(key, request.body);
+      response.json(request.body);
+    });
+    router.route(path).patch((request, response) => {
+      const currentResource = storage.read(key);
+      const updatedResource = {
+        ...currentResource,
+        ...request.body
+      };
+      storage.write(key, updatedResource);
+      response.json(updatedResource);
+    });
+  });
+  return router;
+};
+exports.createShallowDatabaseRoutes = createShallowDatabaseRoutes;

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

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

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

@@ -0,0 +1,60 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _array = require("./array");
+Object.keys(_array).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _array[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _array[key];
+    }
+  });
+});
+var _createRewrittenDatabaseRoutes = require("./createRewrittenDatabaseRoutes/createRewrittenDatabaseRoutes");
+Object.keys(_createRewrittenDatabaseRoutes).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _createRewrittenDatabaseRoutes[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _createRewrittenDatabaseRoutes[key];
+    }
+  });
+});
+var _createNestedDatabaseRoutes = require("./createNestedDatabaseRoutes/createNestedDatabaseRoutes");
+Object.keys(_createNestedDatabaseRoutes).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _createNestedDatabaseRoutes[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _createNestedDatabaseRoutes[key];
+    }
+  });
+});
+var _createShallowDatabaseRoutes = require("./createShallowDatabaseRoutes/createShallowDatabaseRoutes");
+Object.keys(_createShallowDatabaseRoutes).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _createShallowDatabaseRoutes[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _createShallowDatabaseRoutes[key];
+    }
+  });
+});
+var _splitDatabaseByNesting = require("./splitDatabaseByNesting/splitDatabaseByNesting");
+Object.keys(_splitDatabaseByNesting).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _splitDatabaseByNesting[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _splitDatabaseByNesting[key];
+    }
+  });
+});

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

@@ -0,0 +1,5 @@
+import type { DatabaseConfig, NestedDatabase, ShallowDatabase } from '../../../../../utils/types';
+export declare const splitDatabaseByNesting: (data: DatabaseConfig['data']) => {
+    shallowDatabase: ShallowDatabase;
+    nestedDatabase: NestedDatabase;
+};

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

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.splitDatabaseByNesting = void 0;
+var _helpers = require("../../../../../utils/helpers");
+const isAllArrayElementsHaveValidTypeId = array => array.every(element => (0, _helpers.isPlainObject)(element) && (typeof element.id === 'number' || typeof element.id === 'string'));
+const isAllArrayElementsHaveUniqueId = array => {
+  const uniqueIdsCount = new Set(array.map(({
+    id
+  }) => id)).size;
+  return array.length === uniqueIdsCount;
+};
+const splitDatabaseByNesting = data => {
+  const shallowDatabase = {};
+  const nestedDatabase = {};
+  Object.entries(data).forEach(([databaseEntityKey, databaseEntityValue]) => {
+    if (Array.isArray(databaseEntityValue) && isAllArrayElementsHaveValidTypeId(databaseEntityValue) && isAllArrayElementsHaveUniqueId(databaseEntityValue)) {
+      nestedDatabase[databaseEntityKey] = databaseEntityValue;
+      return;
+    }
+    shallowDatabase[databaseEntityKey] = databaseEntityValue;
+  });
+  return {
+    shallowDatabase,
+    nestedDatabase
+  };
+};
+exports.splitDatabaseByNesting = splitDatabaseByNesting;

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

@@ -0,0 +1,11 @@
+type Index = string | number;
+type Object = Record<Index, any>;
+export declare class FileStorage<T extends Object = Object> {
+    private readonly fileWriter;
+    private readonly data;
+    constructor(fileName: string);
+    read(key?: Index | Index[]): any;
+    write(key: Index | Index[], value: unknown): void;
+    delete(key: Index | Index[]): void;
+}
+export {};

package/dist/src/core/database/createDatabaseRoutes/storages/File/FileStorage.js

@@ -0,0 +1,64 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FileStorage = void 0;
+var _fs = _interopRequireDefault(require("fs"));
+var _path = _interopRequireDefault(require("path"));
+var _constants = require("../../../../../utils/constants");
+var _helpers = require("../../helpers");
+var _FileWriter = require("./FileWriter");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+class FileStorage {
+  constructor(fileName) {
+    _defineProperty(this, "fileWriter", void 0);
+    _defineProperty(this, "data", void 0);
+    const filePath = _path.default.resolve(_constants.APP_PATH, fileName);
+    this.fileWriter = new _FileWriter.FileWriter(filePath);
+    this.data = JSON.parse(_fs.default.readFileSync(filePath, 'utf-8'));
+  }
+  read(key) {
+    if (!key) return this.data;
+    const keys = Array.isArray(key) ? key : [key];
+    let readable = this.data;
+    for (const currentKey of keys) {
+      readable = readable[currentKey];
+    }
+    return readable;
+  }
+  write(key, value) {
+    const keys = Array.isArray(key) ? key : [key];
+    let writable = this.data;
+    let index = 0;
+    // ✅ important:
+    // stop iterate one element before end of keys for get access to writable object property
+    while (index < keys.length - 1) {
+      writable = writable[keys[index]];
+      index += 1;
+    }
+    writable[keys[index]] = value;
+    this.fileWriter.write(JSON.stringify(this.data));
+  }
+  delete(key) {
+    const keys = Array.isArray(key) ? key : [key];
+    let deletable = this.data;
+    let index = 0;
+    // ✅ important:
+    // stop iterate one element before end of key for get access to deletable object property
+    while (index < keys.length - 1) {
+      deletable = deletable[keys[index]];
+      index += 1;
+    }
+    if (Array.isArray(deletable) && (0, _helpers.isIndex)(keys[index])) {
+      deletable.splice(keys[index], 1);
+    } else {
+      delete deletable[keys[index]];
+    }
+    this.fileWriter.write(JSON.stringify(this.data));
+  }
+}
+exports.FileStorage = FileStorage;

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

@@ -0,0 +1,11 @@
+export declare class FileWriter {
+    private readonly filePath;
+    private nextData;
+    private nextDataPromise;
+    private nextDataResolve;
+    private writeIsLocked;
+    constructor(filePath: string);
+    private lockedWrite;
+    private unlockedWrite;
+    write(data: string): Promise<void>;
+}

package/dist/src/core/database/createDatabaseRoutes/storages/File/FileWriter.js

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FileWriter = void 0;
+var _fs = _interopRequireDefault(require("fs"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+class FileWriter {
+  constructor(filePath) {
+    _defineProperty(this, "filePath", void 0);
+    _defineProperty(this, "nextData", null);
+    _defineProperty(this, "nextDataPromise", null);
+    _defineProperty(this, "nextDataResolve", null);
+    _defineProperty(this, "writeIsLocked", false);
+    this.filePath = filePath;
+  }
+  lockedWrite(data) {
+    var _this$nextDataPromise;
+    this.nextData = data;
+    this.nextDataPromise = (_this$nextDataPromise = this.nextDataPromise) !== null && _this$nextDataPromise !== void 0 ? _this$nextDataPromise : new Promise(resolve => {
+      this.nextDataResolve = resolve;
+    });
+    return new Promise(resolve => {
+      var _this$nextDataPromise2;
+      (_this$nextDataPromise2 = this.nextDataPromise) === null || _this$nextDataPromise2 === void 0 ? void 0 : _this$nextDataPromise2.then(() => {
+        resolve();
+      });
+    });
+  }
+  async unlockedWrite(data, recursionLevel = 0) {
+    this.writeIsLocked = true;
+    await _fs.default.promises.writeFile(this.filePath, data, 'utf-8');
+    this.writeIsLocked = false;
+
+    // ✅ important:
+    // copy content of this.nextData into new variable
+    // for avoid infinite recursion of 'unlockedWrite'
+    const passedData = this.nextData;
+    this.nextData = null;
+    if (passedData) {
+      await this.unlockedWrite(passedData, recursionLevel + 1);
+      if (recursionLevel === 0) {
+        var _this$nextDataResolve;
+        (_this$nextDataResolve = this.nextDataResolve) === null || _this$nextDataResolve === void 0 ? void 0 : _this$nextDataResolve.call(this);
+        this.nextDataPromise = null;
+        this.nextDataResolve = null;
+      }
+    }
+  }
+  write(data) {
+    return this.writeIsLocked ? this.lockedWrite(data) : this.unlockedWrite(data);
+  }
+}
+exports.FileWriter = FileWriter;

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

@@ -0,0 +1,10 @@
+type Index = string | number;
+type Object = Record<Index, any>;
+export declare class MemoryStorage<T extends Object = Object> {
+    private readonly data;
+    constructor(initialData: T);
+    read(key?: Index | Index[]): any;
+    write(key: Index | Index[], value: unknown): void;
+    delete(key: Index | Index[]): void;
+}
+export {};

package/dist/src/core/database/createDatabaseRoutes/storages/Memory/MemoryStorage.js

@@ -0,0 +1,54 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MemoryStorage = void 0;
+var _helpers = require("../../helpers");
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+class MemoryStorage {
+  constructor(initialData) {
+    _defineProperty(this, "data", void 0);
+    this.data = initialData;
+  }
+  read(key) {
+    if (!key) return this.data;
+    const keys = Array.isArray(key) ? key : [key];
+    let readable = this.data;
+    for (const currentKey of keys) {
+      readable = readable[currentKey];
+    }
+    return readable;
+  }
+  write(key, value) {
+    const keys = Array.isArray(key) ? key : [key];
+    let writable = this.data;
+    let index = 0;
+    // ✅ important:
+    // stop iterate one element before end of keys for get access to writable object property
+    while (index < keys.length - 1) {
+      writable = writable[keys[index]];
+      index += 1;
+    }
+    writable[keys[index]] = value;
+  }
+  delete(key) {
+    const keys = Array.isArray(key) ? key : [key];
+    let deletable = this.data;
+    let index = 0;
+    // ✅ important:
+    // stop iterate one element before end of key for get access to deletable object property
+    while (index < keys.length - 1) {
+      deletable = deletable[keys[index]];
+      index += 1;
+    }
+    if (Array.isArray(deletable) && (0, _helpers.isIndex)(keys[index])) {
+      deletable.splice(keys[index], 1);
+      return;
+    }
+    delete deletable[keys[index]];
+  }
+}
+exports.MemoryStorage = MemoryStorage;

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

@@ -0,0 +1,2 @@
+export * from './File/FileStorage';
+export * from './Memory/MemoryStorage';

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

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _FileStorage = require("./File/FileStorage");
+Object.keys(_FileStorage).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _FileStorage[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _FileStorage[key];
+    }
+  });
+});
+var _MemoryStorage = require("./Memory/MemoryStorage");
+Object.keys(_MemoryStorage).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _MemoryStorage[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _MemoryStorage[key];
+    }
+  });
+});

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

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

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

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _createDatabaseRoutes = require("./createDatabaseRoutes/createDatabaseRoutes");
+Object.keys(_createDatabaseRoutes).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _createDatabaseRoutes[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _createDatabaseRoutes[key];
+    }
+  });
+});

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

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

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

@@ -0,0 +1,102 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createGraphQLRoutes = void 0;
+var _flat = require("flat");
+var _helpers = require("../../../utils/helpers");
+var _helpers2 = require("./helpers");
+const createGraphQLRoutes = (router, graphqlConfig, serverResponseInterceptors) => {
+  const preparedGraphQLRequestConfig = (0, _helpers2.prepareGraphQLRequestConfigs)(graphqlConfig.configs);
+  const graphqlMiddleware = async (request, response, next) => {
+    var _matchedRequestConfig, _matchedRouteConfig$e, _matchedRouteConfig$i, _matchedRequestConfig2, _graphqlConfig$interc;
+    const graphQLInput = (0, _helpers.getGraphQLInput)(request);
+    if (!graphQLInput || !graphQLInput.query) {
+      return response.status(400).json({
+        message: 'Query is missing, you must pass a valid GraphQL query'
+      });
+    }
+    const query = (0, _helpers.parseQuery)(graphQLInput.query);
+    if (!query) {
+      return response.status(400).json({
+        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;
+      }
+      return requestConfig.operationName === query.operationName && requestConfig.operationType === query.operationType;
+    });
+    if (!matchedRequestConfig) {
+      return next();
+    }
+    const requestInterceptor = (_matchedRequestConfig = matchedRequestConfig.interceptors) === null || _matchedRequestConfig === void 0 ? void 0 : _matchedRequestConfig.request;
+    if (requestInterceptor) {
+      await (0, _helpers.callRequestInterceptor)({
+        request,
+        interceptor: requestInterceptor
+      });
+    }
+    const matchedRouteConfig = matchedRequestConfig.routes.find(({
+      entities
+    }) => {
+      if (!entities) return true;
+      const entries = Object.entries(entities);
+      return entries.every(([entityName, valueOrDescriptor]) => {
+        const {
+          checkMode,
+          value: descriptorValue
+        } = (0, _helpers.convertToEntityDescriptor)(valueOrDescriptor);
+
+        // ✅ 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 mappedEntityDescriptors = Object.entries(valueOrDescriptor);
+        return mappedEntityDescriptors.every(([entityKey, mappedEntityDescriptor]) => {
+          const {
+            checkMode,
+            value: descriptorValue
+          } = (0, _helpers.convertToEntityDescriptor)(mappedEntityDescriptor);
+          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);
+        });
+      });
+    });
+    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;
+    const data = await (0, _helpers.callResponseInterceptors)({
+      data: matchedRouteConfigData,
+      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
+      }
+    });
+
+    // ✅ 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');
+    return response.status(response.statusCode).json(data);
+  };
+  router.route('/').get((0, _helpers.asyncHandler)(graphqlMiddleware));
+  router.route('/').post((0, _helpers.asyncHandler)(graphqlMiddleware));
+  return router;
+};
+exports.createGraphQLRoutes = createGraphQLRoutes;

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

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

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

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _prepareGraphQLRequestConfigs = require("./prepareGraphQLRequestConfigs/prepareGraphQLRequestConfigs");
+Object.keys(_prepareGraphQLRequestConfigs).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _prepareGraphQLRequestConfigs[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _prepareGraphQLRequestConfigs[key];
+    }
+  });
+});

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

@@ -0,0 +1,2 @@
+import type { GraphQLRequestConfig } from '../../../../../utils/types';
+export declare const prepareGraphQLRequestConfigs: (requestConfigs: GraphQLRequestConfig[]) => GraphQLRequestConfig[];

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

@@ -0,0 +1,41 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.prepareGraphQLRequestConfigs = void 0;
+var _helpers = require("../../../../../utils/helpers");
+const calculateRouteConfigWeight = graphQLRouteConfig => {
+  const {
+    entities
+  } = graphQLRouteConfig;
+  if (!entities) return 0;
+  let routeConfigWeight = 0;
+  const {
+    headers,
+    cookies,
+    query,
+    variables
+  } = entities;
+  if (headers) routeConfigWeight += Object.keys(headers).length;
+  if (cookies) routeConfigWeight += Object.keys(cookies).length;
+  if (query) routeConfigWeight += Object.keys(query).length;
+  if (variables) {
+    if ((0, _helpers.isPlainObject)(variables) && variables.checkMode) {
+      routeConfigWeight += (0, _helpers.isPlainObject)(variables.value) ? Object.keys(variables.value).length : 1;
+      return routeConfigWeight;
+    }
+    routeConfigWeight += Object.keys(variables).length;
+  }
+  return routeConfigWeight;
+};
+const prepareGraphQLRequestConfigs = requestConfigs => {
+  requestConfigs.forEach(requestConfig => {
+    requestConfig.routes.sort((first, second) =>
+    // ✅ important:
+    // Lift more specific configs for correct working of routes
+    calculateRouteConfigWeight(second) - calculateRouteConfigWeight(first));
+  });
+  return requestConfigs;
+};
+exports.prepareGraphQLRequestConfigs = prepareGraphQLRequestConfigs;

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

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

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

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _createGraphQLRoutes = require("./createGraphQLRoutes/createGraphQLRoutes");
+Object.keys(_createGraphQLRoutes).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _createGraphQLRoutes[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _createGraphQLRoutes[key];
+    }
+  });
+});

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

@@ -0,0 +1,2 @@
+import type { Express } from 'express';
+export declare const cookieParseMiddleware: (server: Express) => void;

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

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.cookieParseMiddleware = void 0;
+var _helpers = require("./helpers");
+const cookieParseMiddleware = server => {
+  server.use((request, _response, next) => {
+    if (request.headers.cookie) {
+      request.cookies = (0, _helpers.parseCookie)(request.headers.cookie);
+    } else {
+      request.cookies = {};
+    }
+    return next();
+  });
+};
+exports.cookieParseMiddleware = cookieParseMiddleware;

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

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