mock-config-server 4.0.3 → 5.0.0-beta.1

package/dist/src/core/functions/rest/helpers/createFileHandler/createFileHandler.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createFileHandler", {
+    enumerable: true,
+    get: function() {
+        return createFileHandler;
+    }
+});
+const _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _helpers = require("../../../../../utils/helpers");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const createFileHandler = (filePath)=>({ response, setHeader, next })=>{
+        if (!(0, _helpers.isFilePathValid)(filePath)) {
+            return next();
+        }
+        const buffer = _fs.default.readFileSync(_path.default.resolve(filePath));
+        const fileName = filePath.replaceAll('\\', '/').split('/').at(-1);
+        const fileExtension = fileName.split('.').at(-1);
+        response.type(fileExtension);
+        setHeader('Content-Disposition', `attachment; filename="${fileName}"`);
+        return buffer;
+    };

package/dist/src/core/functions/rest/helpers/createQueueHandler/createQueueHandler.d.ts

@@ -0,0 +1,5 @@
+import type { RestDataResponse, RestDataResponseFunction, RestMethod } from '../../../../../utils/types';
+export declare const createQueueHandler: <Method extends RestMethod>(queue: {
+    data: RestDataResponse<Method>;
+    time?: number;
+}[]) => RestDataResponseFunction<Method>;

package/dist/src/core/functions/rest/helpers/createQueueHandler/createQueueHandler.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createQueueHandler", {
+    enumerable: true,
+    get: function() {
+        return createQueueHandler;
+    }
+});
+const createQueueHandler = (queue)=>{
+    let queueIndex = 0;
+    let timeoutInProgress = false;
+    const updateQueueIndex = ()=>{
+        queueIndex = queue.length - 1 === queueIndex ? 0 : queueIndex + 1;
+    };
+    return async (params)=>{
+        if (!queue.length) {
+            return params.next();
+        }
+        const queueItem = queue[queueIndex];
+        const { time } = queueItem;
+        if (time && !timeoutInProgress) {
+            timeoutInProgress = true;
+            setTimeout(()=>{
+                timeoutInProgress = false;
+                updateQueueIndex();
+            }, time);
+        }
+        if (!time) {
+            updateQueueIndex();
+        }
+        return typeof queueItem.data === 'function' ? queueItem.data(params) : queueItem.data;
+    };
+};

package/dist/src/core/functions/rest/helpers/formatSsePayload/formatSsePayload.d.ts

@@ -0,0 +1,5 @@
+export declare const formatSsePayload: (data: string, meta?: {
+    event?: string;
+    id?: string;
+    retry?: number;
+}) => string;

package/dist/src/core/functions/rest/helpers/formatSsePayload/formatSsePayload.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "formatSsePayload", {
+    enumerable: true,
+    get: function() {
+        return formatSsePayload;
+    }
+});
+const _zod = /*#__PURE__*/ _interop_require_default(require("zod"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const sseMetaSchema = _zod.default.object({
+    event: _zod.default.string().optional(),
+    id: _zod.default.string().optional(),
+    retry: _zod.default.number().int().nonnegative().optional()
+}).optional();
+// ✅ important:
+// SSE is a line-based protocol. `id` and `event` must be single-line values.
+// Strip CR/LF so metadata cannot break frame structure.
+const normalizeSseMetaValue = (value)=>value.replaceAll('\r', '').replaceAll('\n', '');
+const formatSsePayload = (data, meta)=>{
+    const parseMetaResult = sseMetaSchema.safeParse(meta);
+    if (!parseMetaResult.success) {
+        var _parseMetaResult_error_issues_;
+        throw new Error(`Invalid SSE meta: ${(_parseMetaResult_error_issues_ = parseMetaResult.error.issues[0]) === null || _parseMetaResult_error_issues_ === void 0 ? void 0 : _parseMetaResult_error_issues_.message}`);
+    }
+    const parsedMeta = parseMetaResult.data;
+    const lines = [];
+    if (parsedMeta === null || parsedMeta === void 0 ? void 0 : parsedMeta.id) {
+        lines.push(`id: ${normalizeSseMetaValue(parsedMeta.id)}`);
+    }
+    if (parsedMeta === null || parsedMeta === void 0 ? void 0 : parsedMeta.event) {
+        lines.push(`event: ${normalizeSseMetaValue(parsedMeta.event)}`);
+    }
+    if ((parsedMeta === null || parsedMeta === void 0 ? void 0 : parsedMeta.retry) != null) {
+        lines.push(`retry: ${parsedMeta.retry}`);
+    }
+    // ✅ important:
+    // Multiline payloads are encoded as multiple `data:` lines.
+    // SSE clients concatenate consecutive `data:` lines with '\n' into one message.
+    data.split(/\r\n|\r|\n/).forEach((line)=>{
+        lines.push(`data: ${line}`);
+    });
+    return `${lines.join('\n')}\n\n`;
+};

package/dist/src/core/functions/rest/helpers/index.d.ts

@@ -0,0 +1,3 @@
+export * from './createFileHandler/createFileHandler';
+export * from './createQueueHandler/createQueueHandler';
+export * from './formatSsePayload/formatSsePayload';

package/dist/src/core/functions/rest/helpers/index.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./createFileHandler/createFileHandler"), exports);
+_export_star(require("./createQueueHandler/createQueueHandler"), exports);
+_export_star(require("./formatSsePayload/formatSsePayload"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}

package/dist/src/core/functions/rest/index.d.ts

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

package/dist/src/core/{graphql/createGraphQLRoutes/helpers → functions/rest}/index.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-_export_star(require("./prepareGraphQLRequestConfigs/prepareGraphQLRequestConfigs"), exports);
+_export_star(require("./rest"), exports);
 function _export_star(from, to) {
     Object.keys(from).forEach(function(k) {
         if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {

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

@@ -0,0 +1,114 @@
+import type { BaseRestRequestConfig, Data, RestEntitiesByEntityName, RestFileResponse, RestMethod, RestParams, RestRequestConfig, RestSettings } from '../../../utils/types';
+interface RestRequestInput {
+    body?: unknown;
+    params?: unknown;
+    query?: unknown;
+    response?: Data;
+}
+type ReservedRestConfigKeys = {
+    [K in 'file' | 'handler' | 'match' | 'queue' | 'response']?: never;
+};
+type RestInlineResponse<Response> = Response extends Record<string, unknown> ? Response & ReservedRestConfigKeys : Response;
+type RestFunction<Method extends RestMethod, Options extends RestRequestInput, AdditionalParams = {}> = (params: RestParams<Method, Options['query'], Options['body'], Options['params'], Options['response']> & AdditionalParams) => Options['response'] | Promise<Options['response']>;
+interface RestResponseObject<Method extends RestMethod, Response> {
+    match?: RestEntitiesByEntityName<Method>;
+    response: Response;
+}
+interface RestHandlerObject<Method extends RestMethod, Options extends RestRequestInput> {
+    handler: RestFunction<Method, Options>;
+    match?: RestEntitiesByEntityName<Method>;
+}
+interface RestFileObject<Method extends RestMethod> {
+    file: RestFileResponse;
+    match?: RestEntitiesByEntityName<Method>;
+}
+interface RestQueueObject<Method extends RestMethod, Options extends RestRequestInput> {
+    match?: RestEntitiesByEntityName<Method>;
+    queue: Array<{
+        file: RestFileResponse;
+        time?: number;
+    } | {
+        handler: RestFunction<Method, Options>;
+        time?: number;
+    } | {
+        response: Options['response'];
+        time?: number;
+    }>;
+}
+interface RestSseClient<Response extends string> {
+    close: () => void;
+    send: (data: Response, meta?: {
+        event?: string;
+        id?: string;
+        retry?: number;
+    }) => void;
+}
+interface SseRestHandlerObject<Method extends 'get' | 'post', Options extends RestRequestInput, Response extends string> {
+    handler: RestFunction<Method, Options, {
+        client: RestSseClient<Response>;
+    }>;
+    match?: RestEntitiesByEntityName<Method>;
+}
+export declare const rest: {
+    delete: {
+        <Options extends RestRequestInput = Partial<RestRequestInput>>(path: RestRequestConfig["path"], config: RestResponseObject<"delete", Options["response"]>, settings?: RestSettings): BaseRestRequestConfig<"delete">;
+        (path: RestRequestConfig["path"], config: RestFileObject<"delete">, settings?: RestSettings): BaseRestRequestConfig<"delete">;
+        <Options extends RestRequestInput = Partial<RestRequestInput>>(path: RestRequestConfig["path"], config: RestHandlerObject<"delete", Options>, settings?: RestSettings): BaseRestRequestConfig<"delete">;
+        <Options extends RestRequestInput = Partial<RestRequestInput>>(path: RestRequestConfig["path"], config: RestFunction<"delete", Options, {}>, settings?: RestSettings): BaseRestRequestConfig<"delete">;
+        <Options extends RestRequestInput = Partial<RestRequestInput>>(path: RestRequestConfig["path"], config: RestQueueObject<"delete", Options>, settings?: RestSettings): BaseRestRequestConfig<"delete">;
+        <Options extends RestRequestInput = Partial<RestRequestInput>>(path: RestRequestConfig["path"], config: RestInlineResponse<Options["response"]>, settings?: RestSettings): BaseRestRequestConfig<"delete">;
+    };
+    get: {
+        <Options extends RestRequestInput = Partial<RestRequestInput>>(path: RestRequestConfig["path"], config: RestResponseObject<"get", Options["response"]>, settings?: RestSettings): BaseRestRequestConfig<"get">;
+        (path: RestRequestConfig["path"], config: RestFileObject<"get">, settings?: RestSettings): BaseRestRequestConfig<"get">;
+        <Options extends RestRequestInput = Partial<RestRequestInput>>(path: RestRequestConfig["path"], config: RestHandlerObject<"get", Options>, settings?: RestSettings): BaseRestRequestConfig<"get">;
+        <Options extends RestRequestInput = Partial<RestRequestInput>>(path: RestRequestConfig["path"], config: RestFunction<"get", Options, {}>, settings?: RestSettings): BaseRestRequestConfig<"get">;
+        <Options extends RestRequestInput = Partial<RestRequestInput>>(path: RestRequestConfig["path"], config: RestQueueObject<"get", Options>, settings?: RestSettings): BaseRestRequestConfig<"get">;
+        <Options extends RestRequestInput = Partial<RestRequestInput>>(path: RestRequestConfig["path"], config: RestInlineResponse<Options["response"]>, settings?: RestSettings): BaseRestRequestConfig<"get">;
+    };
+    options: {
+        <Options extends RestRequestInput = Partial<RestRequestInput>>(path: RestRequestConfig["path"], config: RestResponseObject<"options", Options["response"]>, settings?: RestSettings): BaseRestRequestConfig<"options">;
+        (path: RestRequestConfig["path"], config: RestFileObject<"options">, settings?: RestSettings): BaseRestRequestConfig<"options">;
+        <Options extends RestRequestInput = Partial<RestRequestInput>>(path: RestRequestConfig["path"], config: RestHandlerObject<"options", Options>, settings?: RestSettings): BaseRestRequestConfig<"options">;
+        <Options extends RestRequestInput = Partial<RestRequestInput>>(path: RestRequestConfig["path"], config: RestFunction<"options", Options, {}>, settings?: RestSettings): BaseRestRequestConfig<"options">;
+        <Options extends RestRequestInput = Partial<RestRequestInput>>(path: RestRequestConfig["path"], config: RestQueueObject<"options", Options>, settings?: RestSettings): BaseRestRequestConfig<"options">;
+        <Options extends RestRequestInput = Partial<RestRequestInput>>(path: RestRequestConfig["path"], config: RestInlineResponse<Options["response"]>, settings?: RestSettings): BaseRestRequestConfig<"options">;
+    };
+    patch: {
+        <Options extends RestRequestInput = Partial<RestRequestInput>>(path: RestRequestConfig["path"], config: RestResponseObject<"patch", Options["response"]>, settings?: RestSettings): BaseRestRequestConfig<"patch">;
+        (path: RestRequestConfig["path"], config: RestFileObject<"patch">, settings?: RestSettings): BaseRestRequestConfig<"patch">;
+        <Options extends RestRequestInput = Partial<RestRequestInput>>(path: RestRequestConfig["path"], config: RestHandlerObject<"patch", Options>, settings?: RestSettings): BaseRestRequestConfig<"patch">;
+        <Options extends RestRequestInput = Partial<RestRequestInput>>(path: RestRequestConfig["path"], config: RestFunction<"patch", Options, {}>, settings?: RestSettings): BaseRestRequestConfig<"patch">;
+        <Options extends RestRequestInput = Partial<RestRequestInput>>(path: RestRequestConfig["path"], config: RestQueueObject<"patch", Options>, settings?: RestSettings): BaseRestRequestConfig<"patch">;
+        <Options extends RestRequestInput = Partial<RestRequestInput>>(path: RestRequestConfig["path"], config: RestInlineResponse<Options["response"]>, settings?: RestSettings): BaseRestRequestConfig<"patch">;
+    };
+    post: {
+        <Options extends RestRequestInput = Partial<RestRequestInput>>(path: RestRequestConfig["path"], config: RestResponseObject<"post", Options["response"]>, settings?: RestSettings): BaseRestRequestConfig<"post">;
+        (path: RestRequestConfig["path"], config: RestFileObject<"post">, settings?: RestSettings): BaseRestRequestConfig<"post">;
+        <Options extends RestRequestInput = Partial<RestRequestInput>>(path: RestRequestConfig["path"], config: RestHandlerObject<"post", Options>, settings?: RestSettings): BaseRestRequestConfig<"post">;
+        <Options extends RestRequestInput = Partial<RestRequestInput>>(path: RestRequestConfig["path"], config: RestFunction<"post", Options, {}>, settings?: RestSettings): BaseRestRequestConfig<"post">;
+        <Options extends RestRequestInput = Partial<RestRequestInput>>(path: RestRequestConfig["path"], config: RestQueueObject<"post", Options>, settings?: RestSettings): BaseRestRequestConfig<"post">;
+        <Options extends RestRequestInput = Partial<RestRequestInput>>(path: RestRequestConfig["path"], config: RestInlineResponse<Options["response"]>, settings?: RestSettings): BaseRestRequestConfig<"post">;
+    };
+    put: {
+        <Options extends RestRequestInput = Partial<RestRequestInput>>(path: RestRequestConfig["path"], config: RestResponseObject<"put", Options["response"]>, settings?: RestSettings): BaseRestRequestConfig<"put">;
+        (path: RestRequestConfig["path"], config: RestFileObject<"put">, settings?: RestSettings): BaseRestRequestConfig<"put">;
+        <Options extends RestRequestInput = Partial<RestRequestInput>>(path: RestRequestConfig["path"], config: RestHandlerObject<"put", Options>, settings?: RestSettings): BaseRestRequestConfig<"put">;
+        <Options extends RestRequestInput = Partial<RestRequestInput>>(path: RestRequestConfig["path"], config: RestFunction<"put", Options, {}>, settings?: RestSettings): BaseRestRequestConfig<"put">;
+        <Options extends RestRequestInput = Partial<RestRequestInput>>(path: RestRequestConfig["path"], config: RestQueueObject<"put", Options>, settings?: RestSettings): BaseRestRequestConfig<"put">;
+        <Options extends RestRequestInput = Partial<RestRequestInput>>(path: RestRequestConfig["path"], config: RestInlineResponse<Options["response"]>, settings?: RestSettings): BaseRestRequestConfig<"put">;
+    };
+    sse: {
+        <Options extends RestRequestInput = Partial<RestRequestInput>, Response extends string = string>(path: RestRequestConfig["path"], config: SseRestHandlerObject<"get", Options, Response>, settings?: RestSettings): BaseRestRequestConfig<"get">;
+        <Options extends RestRequestInput = Partial<RestRequestInput>, Response extends string = string>(path: RestRequestConfig["path"], config: RestFunction<"get", Options, {
+            client: RestSseClient<Response>;
+        }>, settings?: RestSettings): BaseRestRequestConfig<"get">;
+    };
+    stream: {
+        <Options extends RestRequestInput = Partial<RestRequestInput>, Response extends string = string>(path: RestRequestConfig["path"], config: SseRestHandlerObject<"post", Options, Response>, settings?: RestSettings): BaseRestRequestConfig<"post">;
+        <Options extends RestRequestInput = Partial<RestRequestInput>, Response extends string = string>(path: RestRequestConfig["path"], config: RestFunction<"post", Options, {
+            client: RestSseClient<Response>;
+        }>, settings?: RestSettings): BaseRestRequestConfig<"post">;
+    };
+};
+export {};

package/dist/src/core/functions/rest/rest.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "rest", {
+    enumerable: true,
+    get: function() {
+        return rest;
+    }
+});
+const _helpers = require("./helpers");
+const resolveConfigType = (config)=>{
+    if (typeof config === 'function') return {
+        type: 'inlineHandler',
+        config
+    };
+    if (typeof config !== 'object' || config === null) return {
+        type: 'inlineResponse',
+        config
+    };
+    if ('queue' in config) return {
+        type: 'queue',
+        config
+    };
+    if ('file' in config) return {
+        type: 'file',
+        config
+    };
+    if ('response' in config) return {
+        type: 'data',
+        config
+    };
+    if ('handler' in config) return {
+        type: 'handler',
+        config
+    };
+    return {
+        type: 'inlineResponse',
+        config
+    };
+};
+const createConfigResolver = (config, settings = {})=>{
+    const resolvedConfig = resolveConfigType(config);
+    switch(resolvedConfig.type){
+        case 'inlineResponse':
+            return {
+                data: resolvedConfig.config,
+                settings
+            };
+        case 'data':
+            {
+                return {
+                    data: resolvedConfig.config.response,
+                    entities: resolvedConfig.config.match,
+                    settings
+                };
+            }
+        case 'file':
+            {
+                return {
+                    data: (0, _helpers.createFileHandler)(resolvedConfig.config.file),
+                    entities: resolvedConfig.config.match,
+                    settings
+                };
+            }
+        case 'queue':
+            {
+                const normalizedQueue = resolvedConfig.config.queue.map((item)=>{
+                    if ('handler' in item) {
+                        return {
+                            data: item.handler,
+                            time: item.time
+                        };
+                    }
+                    if ('response' in item) {
+                        return {
+                            data: item.response,
+                            time: item.time
+                        };
+                    }
+                    if ('file' in item) {
+                        return {
+                            data: (0, _helpers.createFileHandler)(item.file),
+                            time: item.time
+                        };
+                    }
+                    throw new Error(`Unexpected queue item kind: ${JSON.stringify(item, null, 2)}`);
+                });
+                return {
+                    data: (0, _helpers.createQueueHandler)(normalizedQueue),
+                    entities: resolvedConfig.config.match,
+                    settings
+                };
+            }
+        case 'inlineHandler':
+            return {
+                data: resolvedConfig.config,
+                settings
+            };
+        case 'handler':
+            {
+                return {
+                    data: resolvedConfig.config.handler,
+                    entities: resolvedConfig.config.match,
+                    settings
+                };
+            }
+        default:
+            {
+                throw new Error(`Unexpected route config kind: ${JSON.stringify(config, null, 2)}`);
+            }
+    }
+};
+const createRestFactory = (method)=>{
+    function createRequestConfig(path, config, settings) {
+        return {
+            method,
+            path,
+            routes: [
+                createConfigResolver(config, settings)
+            ]
+        };
+    }
+    return createRequestConfig;
+};
+const createSseRestFactory = (method)=>{
+    function createSseRequestConfig(path, config, settings) {
+        const normalizedConfig = typeof config === 'function' ? {
+            handler: config
+        } : config;
+        const wrapperHandler = (params)=>{
+            params.setHeader('connection', 'keep-alive');
+            params.setHeader('content-type', 'text/event-stream');
+            params.setHeader('cache-control', 'no-cache');
+            const client = {
+                send (message, meta) {
+                    const payload = (0, _helpers.formatSsePayload)(message, meta);
+                    params.response.write(payload);
+                },
+                close () {
+                    params.response.end();
+                }
+            };
+            return normalizedConfig.handler({
+                ...params,
+                client
+            });
+        };
+        return {
+            method,
+            path,
+            routes: [
+                createConfigResolver({
+                    handler: wrapperHandler,
+                    match: normalizedConfig.match
+                }, settings)
+            ]
+        };
+    }
+    return createSseRequestConfig;
+};
+const rest = {
+    delete: createRestFactory('delete'),
+    get: createRestFactory('get'),
+    options: createRestFactory('options'),
+    patch: createRestFactory('patch'),
+    post: createRestFactory('post'),
+    put: createRestFactory('put'),
+    sse: createSseRestFactory('get'),
+    stream: createSseRestFactory('post')
+};

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

@@ -0,0 +1,8 @@
+import type { Express } from 'express';
+import type { GraphQLRequestArtifact } from '../../../utils/types';
+interface CreateGraphQLRouteParams {
+    graphQLRequestArtifacts: GraphQLRequestArtifact[];
+    server: Express;
+}
+export declare const createGraphQLRoute: ({ server, graphQLRequestArtifacts }: CreateGraphQLRouteParams) => Express;
+export {};

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

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createGraphQLRoute", {
+    enumerable: true,
+    get: function() {
+        return createGraphQLRoute;
+    }
+});
+const _flat = require("flat");
+const _helpers = require("../../../utils/helpers");
+const _helpers1 = require("./helpers");
+const createGraphQLRoute = ({ server, graphQLRequestArtifacts })=>server.use((0, _helpers.asyncHandler)(async (request, response, next)=>{
+        var _matchedRouteConfig_config_settings, _matchedRouteConfig_config_settings1;
+        if (request.method !== 'GET' && request.method !== 'POST') return next();
+        const graphQLInput = (0, _helpers.getGraphQLInput)(request);
+        if (!graphQLInput.query) return next();
+        const query = (0, _helpers.parseQuery)(graphQLInput.query);
+        if (!query) return next();
+        const matchedRequestArtifacts = (0, _helpers1.matchGraphQLRequestArtifacts)({
+            artifacts: graphQLRequestArtifacts,
+            meta: {
+                path: (0, _helpers.normalizeUrl)(request.path),
+                query: graphQLInput.query,
+                operationType: query.operationType,
+                operationName: query.operationName
+            }
+        });
+        if (!matchedRequestArtifacts.length) return next();
+        const matchedRouteConfig = matchedRequestArtifacts.find(({ config })=>{
+            if (!config.entities) return true;
+            const entityEntries = Object.entries(config.entities);
+            return entityEntries.every(([entityName, entityDescriptorOrValue])=>{
+                const isEntityVariablesByTopLevelDescriptor = entityName === 'variables' && (0, _helpers.isEntityDescriptor)(entityDescriptorOrValue);
+                if (isEntityVariablesByTopLevelDescriptor) {
+                    const variablesDescriptor = entityDescriptorOrValue;
+                    if (variablesDescriptor.checkMode === 'exists' || variablesDescriptor.checkMode === 'notExists') {
+                        return (0, _helpers.resolveEntityValues)({
+                            actualValue: graphQLInput.variables,
+                            checkMode: variablesDescriptor.checkMode
+                        });
+                    }
+                    var _variablesDescriptor_oneOf;
+                    return (0, _helpers.resolveEntityValues)({
+                        actualValue: graphQLInput.variables,
+                        descriptorValue: variablesDescriptor.value,
+                        checkMode: variablesDescriptor.checkMode,
+                        oneOf: (_variablesDescriptor_oneOf = variablesDescriptor.oneOf) !== null && _variablesDescriptor_oneOf !== void 0 ? _variablesDescriptor_oneOf : false
+                    });
+                }
+                const actualEntity = (0, _flat.flatten)(entityName === 'variables' ? graphQLInput.variables : request[entityName]);
+                const entityValueEntries = Object.entries(entityDescriptorOrValue);
+                return entityValueEntries.every(([entityPropertyKey, entityPropertyDescriptorOrValue])=>{
+                    const entityPropertyDescriptor = (0, _helpers.convertToEntityDescriptor)(entityPropertyDescriptorOrValue);
+                    const actualPropertyKey = entityName === 'headers' ? entityPropertyKey.toLowerCase() : entityPropertyKey;
+                    const actualPropertyValue = actualEntity[actualPropertyKey];
+                    if (entityPropertyDescriptor.checkMode === 'exists' || entityPropertyDescriptor.checkMode === 'notExists') {
+                        return (0, _helpers.resolveEntityValues)({
+                            actualValue: actualPropertyValue,
+                            checkMode: entityPropertyDescriptor.checkMode
+                        });
+                    }
+                    var _entityPropertyDescriptor_oneOf;
+                    return (0, _helpers.resolveEntityValues)({
+                        actualValue: actualPropertyValue,
+                        descriptorValue: entityPropertyDescriptor.value,
+                        checkMode: entityPropertyDescriptor.checkMode,
+                        oneOf: (_entityPropertyDescriptor_oneOf = entityPropertyDescriptor.oneOf) !== null && _entityPropertyDescriptor_oneOf !== void 0 ? _entityPropertyDescriptor_oneOf : false
+                    });
+                });
+            });
+        });
+        if (!matchedRouteConfig) return next();
+        if (matchedRouteConfig.componentRequestInterceptor) {
+            await (0, _helpers.callRequestInterceptor)({
+                request,
+                interceptor: matchedRouteConfig.componentRequestInterceptor
+            });
+        }
+        if (matchedRouteConfig.requestRequestInterceptor) {
+            await (0, _helpers.callRequestInterceptor)({
+                request,
+                interceptor: matchedRouteConfig.requestRequestInterceptor
+            });
+        }
+        if (matchedRouteConfig.routeRequestInterceptor) {
+            await (0, _helpers.callRequestInterceptor)({
+                request,
+                interceptor: matchedRouteConfig.routeRequestInterceptor
+            });
+        }
+        var _matchedRouteConfig_config_entities;
+        const params = {
+            request,
+            response,
+            next,
+            entities: (_matchedRouteConfig_config_entities = matchedRouteConfig.config.entities) !== null && _matchedRouteConfig_config_entities !== void 0 ? _matchedRouteConfig_config_entities : {},
+            appendHeader: (field, value)=>{
+                response.append(field, value);
+            },
+            attachment: (filename)=>{
+                response.attachment(filename);
+            },
+            clearCookie: (name, options)=>{
+                response.clearCookie(name, options);
+            },
+            getCookie: (name)=>request.cookies[name],
+            getRequestHeader: (field)=>request.headers[field],
+            getRequestHeaders: ()=>request.headers,
+            getResponseHeader: (field)=>response.getHeader(field),
+            getResponseHeaders: ()=>response.getHeaders(),
+            setCookie: (name, value, options)=>{
+                if (options) {
+                    response.cookie(name, value, options);
+                    return;
+                }
+                response.cookie(name, value);
+            },
+            setDelay: async (delay)=>{
+                await (0, _helpers.sleep)(delay === Infinity ? 99999999 : delay);
+            },
+            setHeader: (field, value)=>{
+                response.set(field, value);
+            },
+            setStatusCode: (statusCode)=>{
+                response.statusCode = statusCode;
+            }
+        };
+        const resolvedData = typeof matchedRouteConfig.config.data === 'function' ? await matchedRouteConfig.config.data(params) : matchedRouteConfig.config.data;
+        if (response.headersSent) {
+            return;
+        }
+        if ((_matchedRouteConfig_config_settings = matchedRouteConfig.config.settings) === null || _matchedRouteConfig_config_settings === void 0 ? void 0 : _matchedRouteConfig_config_settings.status) {
+            response.statusCode = matchedRouteConfig.config.settings.status;
+        }
+        if (matchedRouteConfig.operationType === 'query') {
+            response.set('Cache-control', 'no-cache');
+        }
+        const data = await (0, _helpers.callResponseInterceptors)({
+            data: resolvedData,
+            request,
+            response,
+            interceptors: {
+                routeInterceptor: matchedRouteConfig.routeResponseInterceptor,
+                componentInterceptor: matchedRouteConfig.componentResponseInterceptor,
+                requestInterceptor: matchedRouteConfig.requestResponseInterceptor,
+                serverInterceptor: matchedRouteConfig.serverResponseInterceptor
+            }
+        });
+        if ((_matchedRouteConfig_config_settings1 = matchedRouteConfig.config.settings) === null || _matchedRouteConfig_config_settings1 === void 0 ? void 0 : _matchedRouteConfig_config_settings1.delay) {
+            await (0, _helpers.sleep)(matchedRouteConfig.config.settings.delay);
+        }
+        if (response.headersSent) {
+            return;
+        }
+        return response.json(data);
+    }));

package/dist/src/core/graphql/createGraphQLRoute/helpers/calculateGraphQLRouteConfigWeight/calculateGraphQLRouteConfigWeight.d.ts

@@ -0,0 +1,2 @@
+import type { GraphQLRouteConfig } from '../../../../../utils/types';
+export declare const calculateGraphQLRouteConfigWeight: (graphQLRouteConfig: GraphQLRouteConfig) => number;

package/dist/src/core/graphql/{createGraphQLRoutes/helpers/prepareGraphQLRequestConfigs/prepareGraphQLRequestConfigs.js → createGraphQLRoute/helpers/calculateGraphQLRouteConfigWeight/calculateGraphQLRouteConfigWeight.js}

@@ -2,14 +2,14 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-Object.defineProperty(exports, "prepareGraphQLRequestConfigs", {
+Object.defineProperty(exports, "calculateGraphQLRouteConfigWeight", {
     enumerable: true,
     get: function() {
-        return prepareGraphQLRequestConfigs;
+        return calculateGraphQLRouteConfigWeight;
     }
 });
 const _helpers = require("../../../../../utils/helpers");
-const calculateRouteConfigWeight = (graphQLRouteConfig)=>{
+const calculateGraphQLRouteConfigWeight = (graphQLRouteConfig)=>{
     const { entities } = graphQLRouteConfig;
     if (!entities) return 0;
     let routeConfigWeight = 0;
@@ -32,11 +32,3 @@ const calculateRouteConfigWeight = (graphQLRouteConfig)=>{
     }
     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;
-};