mock-config-server 4.0.2 → 5.0.0-beta.0

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

@@ -0,0 +1,102 @@
+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;
+}
+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: RestFunction<"get", Options, {
+        client: RestSseClient<Response>;
+    }>, settings?: RestSettings) => BaseRestRequestConfig<"get">;
+    stream: <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,165 @@
+"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 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 config({
+                ...params,
+                client
+            });
+        };
+        return {
+            method,
+            path,
+            routes: [
+                createConfigResolver(wrapperHandler, 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;
-};

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

@@ -0,0 +1,3 @@
+export * from './calculateGraphQLRouteConfigWeight/calculateGraphQLRouteConfigWeight';
+export * from './matchGraphQLRequestArtifacts/matchGraphQLRequestArtifacts';
+export * from './prepareGraphQLRequestArtifacts/prepareGraphQLRequestArtifacts';

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./calculateGraphQLRouteConfigWeight/calculateGraphQLRouteConfigWeight"), exports);
+_export_star(require("./matchGraphQLRequestArtifacts/matchGraphQLRequestArtifacts"), exports);
+_export_star(require("./prepareGraphQLRequestArtifacts/prepareGraphQLRequestArtifacts"), 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/graphql/createGraphQLRoute/helpers/matchGraphQLRequestArtifacts/matchGraphQLRequestArtifacts.d.ts

@@ -0,0 +1,12 @@
+import type { GraphQLRequestArtifact } from '../../../../../utils/types';
+interface MatchGraphQLRequestArtifactsParams {
+    artifacts: GraphQLRequestArtifact[];
+    meta: {
+        path: string;
+        operationType: string;
+        query?: string;
+        operationName?: string;
+    };
+}
+export declare const matchGraphQLRequestArtifacts: ({ artifacts, meta }: MatchGraphQLRequestArtifactsParams) => GraphQLRequestArtifact[];
+export {};

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

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "matchGraphQLRequestArtifacts", {
+    enumerable: true,
+    get: function() {
+        return matchGraphQLRequestArtifacts;
+    }
+});
+const _graphql = require("graphql");
+const _helpers = require("../../../../../utils/helpers");
+const matchGraphQLRequestArtifacts = ({ artifacts, meta })=>artifacts.filter((artifact)=>{
+        if ((0, _helpers.normalizeUrl)(meta.path) !== (0, _helpers.normalizeUrl)(artifact.baseUrl)) {
+            return false;
+        }
+        if (artifact.operationType !== meta.operationType) return false;
+        if (artifact.query) {
+            if (!meta.query) return false;
+            return (0, _graphql.stripIgnoredCharacters)((0, _graphql.print)((0, _graphql.parse)(artifact.query))) === (0, _graphql.stripIgnoredCharacters)((0, _graphql.print)((0, _graphql.parse)(meta.query)));
+        }
+        if (artifact.operationName) {
+            if (!meta.operationName) return false;
+            return artifact.operationName instanceof RegExp ? new RegExp(artifact.operationName).test(meta.operationName) : artifact.operationName === meta.operationName;
+        }
+        console.warn(`[mock-config] GraphQL artifact with no query or operationName was skipped: ${JSON.stringify(artifact)}`);
+        return false;
+    });

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

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

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

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "prepareGraphQLRequestArtifacts", {
+    enumerable: true,
+    get: function() {
+        return prepareGraphQLRequestArtifacts;
+    }
+});
+const prepareGraphQLRequestArtifacts = (requestArtifacts)=>requestArtifacts.toSorted((first, second)=>second.weight - first.weight);

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

@@ -1 +1,2 @@
-export * from './createGraphQLRoutes/createGraphQLRoutes';
+export * from './createGraphQLRoute/createGraphQLRoute';
+export * from './createGraphQLRoute/helpers';

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

@@ -2,7 +2,8 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-_export_star(require("./createGraphQLRoutes/createGraphQLRoutes"), exports);
+_export_star(require("./createGraphQLRoute/createGraphQLRoute"), exports);
+_export_star(require("./createGraphQLRoute/helpers"), 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/middlewares/contextMiddleware/contextMiddleware.d.ts

@@ -1,17 +1,19 @@
 import type { Express } from 'express';
-import type { GraphQLEntity, GraphQLOperationName, GraphQLOperationType, MockServerConfig } from '../../../utils/types';
+import type { DatabaseConfig, GraphQLEntity, GraphQLOperationName, GraphQLOperationType } from '../../../utils/types';
 declare global {
     namespace Express {
         interface Request {
-            id: number;
-            timestamp: number;
             graphQL: {
                 operationType: GraphQLOperationType;
                 operationName?: GraphQLOperationName;
                 query: string;
                 variables?: GraphQLEntity<'variables'>;
             } | null;
+            id: number;
+            timestamp: number;
         }
     }
 }
-export declare const contextMiddleware: (server: Express, { database }: Pick<MockServerConfig, "database">) => void;
+export declare const contextMiddleware: (server: Express, { database }: {
+    database?: DatabaseConfig;
+}) => void;

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

@@ -24,6 +24,7 @@ const contextMiddleware = (server, { database })=>{
         requestId += 1;
         request.id = requestId;
         request.timestamp = Date.now();
+        request.graphQL = null;
         if (request.method === 'GET' || request.method === 'POST') {
             const graphQLInput = (0, _helpers.getGraphQLInput)(request);
             var _graphQLInput_query;
@@ -35,10 +36,8 @@ const contextMiddleware = (server, { database })=>{
                     query: graphQLInput.query,
                     variables: graphQLInput.variables
                 };
-                return next();
             }
         }
-        request.graphQL = null;
         request.context = context;
         return next();
     });

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

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