mock-config-server 3.0.0 → 3.0.1

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

@@ -0,0 +1,97 @@
+"use strict";
+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");
+const ALLOWED_ENTITIES_BY_OPERATION_TYPE = {
+    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 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);
+            }
+        });
+        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 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

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

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

@@ -0,0 +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;

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

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

package/dist/bin/validateMockServerConfig/validateMockServerConfig.js

@@ -0,0 +1,30 @@
+"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

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

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

@@ -0,0 +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;

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

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

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

@@ -0,0 +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', '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

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

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

@@ -0,0 +1,101 @@
+"use strict";
+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");
+const ALLOWED_ENTITIES_BY_METHOD = {
+    get: ['headers', 'cookies', 'query', 'params'],
+    delete: ['headers', 'cookies', 'query', 'params'],
+    post: ['headers', 'cookies', 'query', 'params', 'body'],
+    put: ['headers', 'cookies', 'query', 'params', 'body'],
+    patch: ['headers', 'cookies', 'query', 'params', 'body'],
+    options: ['headers', 'cookies', 'query', 'params']
+};
+const validateEntity = (entity, entityName) => {
+    const { checkMode: topLevelCheckMode, value: topLevelValue } = (0, helpers_1.convertToEntityDescriptor)(entity);
+    const isBody = entityName === 'body';
+    const isTopLevelDescriptor = (0, helpers_1.isEntityDescriptor)(entity);
+    if (isTopLevelDescriptor && isBody) {
+        if (!(0, helpers_2.isCheckModeValid)(topLevelCheckMode, 'body')) {
+            throw new Error('body.checkMode');
+        }
+        if (!(0, helpers_2.isDescriptorValueValid)(topLevelCheckMode, topLevelValue, 'body')) {
+            const errorMessage = 'body.value';
+            throw new Error(errorMessage);
+        }
+    }
+    const isEntityObject = (0, helpers_1.isPlainObject)(entity) && !(entity instanceof RegExp);
+    const isEntityArray = Array.isArray(entity) && isBody;
+    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 && !isBody) {
+                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);
+            }
+        });
+        return;
+    }
+    throw new Error(entityName);
+};
+const validateEntities = (entities, method) => {
+    const isEntitiesObject = (0, helpers_1.isPlainObject)(entities);
+    if (isEntitiesObject) {
+        Object.keys(entities).forEach((entityName) => {
+            const isEntityAllowed = ALLOWED_ENTITIES_BY_METHOD[method].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, 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

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

package/dist/bin/validateMockServerConfig/validateStaticPath/validateStaticPath.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateStaticPath = void 0;
+const helpers_1 = require("../../../src/utils/helpers");
+const validateStaticPath = (staticPath) => {
+    const isStaticPathArray = Array.isArray(staticPath);
+    if (isStaticPathArray) {
+        staticPath.forEach((staticPathElement, index) => {
+            const isStaticPathElementObject = (0, helpers_1.isPlainObject)(staticPathElement);
+            if (isStaticPathElementObject) {
+                const { prefix, path } = staticPathElement;
+                if (typeof prefix !== 'string' || !prefix.startsWith('/')) {
+                    throw new Error(`staticPath[${index}].prefix`);
+                }
+                if (typeof path !== 'string' || !path.startsWith('/')) {
+                    throw new Error(`staticPath[${index}].path`);
+                }
+                return;
+            }
+            if (typeof staticPathElement !== 'string' || !staticPathElement.startsWith('/')) {
+                throw new Error(`staticPath[${index}]`);
+            }
+        });
+        return;
+    }
+    const isStaticPathObject = (0, helpers_1.isPlainObject)(staticPath);
+    if (isStaticPathObject) {
+        const { prefix, path } = staticPath;
+        if (typeof prefix !== 'string' || !prefix.startsWith('/')) {
+            throw new Error('staticPath.prefix');
+        }
+        if (typeof path !== 'string' || !path.startsWith('/')) {
+            throw new Error('staticPath.path');
+        }
+        return;
+    }
+    if (typeof staticPath !== 'string' && typeof staticPath !== 'undefined') {
+        throw new Error('staticPath');
+    }
+    if (typeof staticPath === 'string' && !staticPath.startsWith('/')) {
+        throw new Error('staticPath');
+    }
+};
+exports.validateStaticPath = validateStaticPath;

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./src"), exports);

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,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGraphQLRoutes = void 0;
+const flat_1 = require("flat");
+const helpers_1 = require("../../../utils/helpers");
+const helpers_2 = require("./helpers");
+const createGraphQLRoutes = (router, graphqlConfig, serverResponseInterceptors) => {
+    const preparedGraphQLRequestConfig = (0, helpers_2.prepareGraphQLRequestConfigs)(graphqlConfig.configs);
+    const graphqlMiddleware = async (request, response, next) => {
+        const graphQLInput = (0, helpers_1.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_1.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.interceptors?.request;
+        if (requestInterceptor) {
+            await (0, helpers_1.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_1.convertToEntityDescriptor)(valueOrDescriptor);
+                // ✅ important: check whole variables as plain value strictly if descriptor used for variables
+                const isVariablesPlain = entityName === 'variables' && (0, helpers_1.isEntityDescriptor)(valueOrDescriptor);
+                if (isVariablesPlain) {
+                    // ✅ important: getGraphQLInput returns empty object if variables not sent or invalid, so count {} as undefined
+                    return (0, helpers_1.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_1.convertToEntityDescriptor)(mappedEntityDescriptor);
+                    const flattenEntity = (0, flat_1.flatten)(entityName === 'variables' ? graphQLInput.variables : request[entityName]);
+                    return (0, helpers_1.resolveEntityValues)(checkMode, flattenEntity[entityKey], descriptorValue);
+                });
+            });
+        });
+        if (!matchedRouteConfig) {
+            return next();
+        }
+        const matchedRouteConfigData = typeof matchedRouteConfig.data === 'function'
+            ? await matchedRouteConfig.data(request, matchedRouteConfig.entities ?? {})
+            : matchedRouteConfig.data;
+        const data = await (0, helpers_1.callResponseInterceptors)({
+            data: matchedRouteConfigData,
+            request,
+            response,
+            interceptors: {
+                routeInterceptor: matchedRouteConfig.interceptors?.response,
+                requestInterceptor: matchedRequestConfig.interceptors?.response,
+                apiInterceptor: graphqlConfig.interceptors?.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_1.asyncHandler)(graphqlMiddleware));
+    router.route('/').post((0, helpers_1.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,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./prepareGraphQLRequestConfigs/prepareGraphQLRequestConfigs"), exports);

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,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareGraphQLRequestConfigs = void 0;
+const helpers_1 = 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_1.isPlainObject)(variables) && variables.checkMode) {
+            routeConfigWeight += (0, helpers_1.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,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./createGraphQLRoutes/createGraphQLRoutes"), exports);

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,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cookieParseMiddleware = void 0;
+const helpers_1 = require("./helpers");
+const cookieParseMiddleware = (server) => {
+    server.use((request, _response, next) => {
+        if (request.headers.cookie) {
+            request.cookies = (0, helpers_1.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';

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

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./parseCookie/parseCookie"), exports);

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

@@ -0,0 +1,3 @@
+type Cookies = Record<string, string>;
+export declare const parseCookie: (cookieHeader: string) => Cookies;
+export {};

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCookie = void 0;
+const parseCookie = (cookieHeader) => {
+    if (!cookieHeader)
+        return {};
+    const cookies = {};
+    const cookiePairs = cookieHeader.split(';');
+    cookiePairs.forEach((cookie) => {
+        const [name, value] = cookie.trim().split('=');
+        if (!name)
+            return;
+        cookies[name.trim()] = value?.trim() ?? '';
+    });
+    return cookies;
+};
+exports.parseCookie = parseCookie;