mock-config-server 1.0.4 → 2.0.1

package/dist/src/cors/corsMiddleware/corsMiddleware.d.ts

@@ -1,3 +1,3 @@
-import type { Express } from 'express';
-import type { Cors } from '../../utils/types';
-export declare const corsMiddleware: (server: Express, cors: Cors) => Promise<void>;
+import type { Express } from 'express';
+import type { Cors } from '../../utils/types';
+export declare const corsMiddleware: (server: Express, cors: Cors) => void;

package/dist/src/cors/corsMiddleware/corsMiddleware.js

@@ -1,32 +1,44 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.corsMiddleware = void 0;
-const constants_1 = require("../../utils/constants");
-const getAllowedOrigins_1 = require("../getOrigins/getAllowedOrigins");
-const corsMiddleware = async (server, cors) => {
-    server.use(async (req, res, next) => {
-        if (Array.isArray(cors.origin) && !cors.origin.length) {
-            return next();
-        }
-        const allowedOrigins = await (0, getAllowedOrigins_1.getAllowedOrigins)(cors.origin);
-        const { origin } = req.headers;
-        if (!allowedOrigins?.length || !origin) {
-            return next();
-        }
-        const isAllowedOrigin = allowedOrigins.some((allowedOrigin) => {
-            if (typeof allowedOrigin === 'string') {
-                return allowedOrigin.includes(origin);
-            }
-            return allowedOrigin.test(origin);
-        });
-        if (isAllowedOrigin) {
-            res.setHeader('Access-Control-Allow-Origin', origin);
-            res.setHeader('Access-Control-Allow-Methods', cors.methods ?? constants_1.DEFAULT.CORS.METHODS);
-            res.setHeader('Access-Control-Allow-Headers', cors.headers ?? constants_1.DEFAULT.CORS.HEADERS);
-            res.setHeader('Access-Control-Allow-Credentials', `${cors.credentials ?? constants_1.DEFAULT.CORS.CREDENTIALS}`);
-            res.setHeader('Access-Control-Max-Age', cors.maxAge ?? constants_1.DEFAULT.CORS.MAX_AGE);
-        }
-        next();
-    });
-};
-exports.corsMiddleware = corsMiddleware;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.corsMiddleware = void 0;
+const constants_1 = require("../../utils/constants");
+const getAllowedOrigins_1 = require("../getOrigins/getAllowedOrigins");
+const corsMiddleware = (server, cors) => {
+    server.use(async (req, res, next) => {
+        if (Array.isArray(cors.origin) && !cors.origin.length) {
+            return next();
+        }
+        let allowedOrigins = [];
+        if (typeof cors.origin === 'function') {
+            const origins = await cors.origin(req);
+            allowedOrigins = (0, getAllowedOrigins_1.getAllowedOrigins)(origins);
+        }
+        else {
+            allowedOrigins = (0, getAllowedOrigins_1.getAllowedOrigins)(cors.origin);
+        }
+        const { origin } = req.headers;
+        if (!allowedOrigins?.length || !origin) {
+            return next();
+        }
+        const isRequestOriginAllowed = allowedOrigins.some((allowedOrigin) => {
+            if (allowedOrigin instanceof RegExp) {
+                return new RegExp(allowedOrigin).test(origin);
+            }
+            return allowedOrigin === origin;
+        });
+        if (isRequestOriginAllowed) {
+            res.setHeader('Access-Control-Allow-Origin', origin);
+            res.setHeader('Access-Control-Allow-Credentials', `${cors.credentials ?? constants_1.DEFAULT.CORS.CREDENTIALS}`);
+            res.setHeader('Access-Control-Expose-Headers', cors.exposedHeaders ?? constants_1.DEFAULT.CORS.EXPOSED_HEADERS);
+            if (req.method === 'OPTIONS') {
+                res.setHeader('Access-Control-Allow-Methods', cors.methods ?? constants_1.DEFAULT.CORS.METHODS);
+                res.setHeader('Access-Control-Allow-Headers', cors.allowedHeaders ?? constants_1.DEFAULT.CORS.ALLOWED_HEADERS);
+                res.setHeader('Access-Control-Max-Age', cors.maxAge ?? constants_1.DEFAULT.CORS.MAX_AGE);
+                res.sendStatus(204);
+                return res.end();
+            }
+        }
+        return next();
+    });
+};
+exports.corsMiddleware = corsMiddleware;

package/dist/src/cors/getOrigins/getAllowedOrigins.d.ts

@@ -1,2 +1,2 @@
-import type { Cors } from '../../utils/types';
-export declare const getAllowedOrigins: (origin: Cors['origin']) => Promise<(string | RegExp)[]>;
+import type { CorsOrigin } from '../../utils/types';
+export declare const getAllowedOrigins: (origin: CorsOrigin) => (string | RegExp)[];

package/dist/src/cors/getOrigins/getAllowedOrigins.js

@@ -1,16 +1,13 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAllowedOrigins = void 0;
-const getAllowedOrigins = async (origin) => {
-    if (Array.isArray(origin)) {
-        return origin;
-    }
-    if (typeof origin === 'string' || origin instanceof RegExp) {
-        return [origin];
-    }
-    if (typeof origin === 'function') {
-        return (0, exports.getAllowedOrigins)(await origin());
-    }
-    throw new Error('Invalid cors origin format');
-};
-exports.getAllowedOrigins = getAllowedOrigins;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAllowedOrigins = void 0;
+const getAllowedOrigins = (origin) => {
+    if (Array.isArray(origin)) {
+        return origin;
+    }
+    if (typeof origin === 'string' || origin instanceof RegExp) {
+        return [origin];
+    }
+    throw new Error('Invalid cors origin format');
+};
+exports.getAllowedOrigins = getAllowedOrigins;

package/dist/src/cors/noCorsMiddleware/noCorsMiddleware.d.ts

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

package/dist/src/cors/noCorsMiddleware/noCorsMiddleware.js

@@ -1,15 +1,20 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.noCorsMiddleware = void 0;
-const constants_1 = require("../../utils/constants");
-const noCorsMiddleware = async (server) => {
-    server.use(async (_req, res, next) => {
-        res.setHeader('Access-Control-Allow-Origin', constants_1.DEFAULT.CORS.ORIGIN);
-        res.setHeader('Access-Control-Allow-Methods', constants_1.DEFAULT.CORS.METHODS);
-        res.setHeader('Access-Control-Allow-Headers', constants_1.DEFAULT.CORS.HEADERS);
-        res.setHeader('Access-Control-Allow-Credentials', `${constants_1.DEFAULT.CORS.CREDENTIALS}`);
-        res.setHeader('Access-Control-Max-Age', constants_1.DEFAULT.CORS.MAX_AGE);
-        return next();
-    });
-};
-exports.noCorsMiddleware = noCorsMiddleware;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noCorsMiddleware = void 0;
+const constants_1 = require("../../utils/constants");
+const noCorsMiddleware = (server) => {
+    server.use((req, res, next) => {
+        res.setHeader('Access-Control-Allow-Origin', constants_1.DEFAULT.CORS.ORIGIN);
+        res.setHeader('Access-Control-Allow-Credentials', `${constants_1.DEFAULT.CORS.CREDENTIALS}`);
+        res.setHeader('Access-Control-Expose-Headers', constants_1.DEFAULT.CORS.EXPOSED_HEADERS);
+        if (req.method === 'OPTIONS') {
+            res.setHeader('Access-Control-Allow-Methods', constants_1.DEFAULT.CORS.METHODS);
+            res.setHeader('Access-Control-Allow-Headers', constants_1.DEFAULT.CORS.ALLOWED_HEADERS);
+            res.setHeader('Access-Control-Max-Age', constants_1.DEFAULT.CORS.MAX_AGE);
+            res.sendStatus(204);
+            return res.end();
+        }
+        return next();
+    });
+};
+exports.noCorsMiddleware = noCorsMiddleware;

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

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

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

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGraphQLRoutes = void 0;
+const isEntityValuesEqual_1 = require("../../configs/isEntitiesEqual/isEntityValuesEqual");
+const callRequestInterceptors_1 = require("../../routes/callRequestInterceptors/callRequestInterceptors");
+const callResponseInterceptors_1 = require("../../routes/callResponseInterceptors/callResponseInterceptors");
+const getGraphQLInput_1 = require("../getGraphQLInput/getGraphQLInput");
+const parseQuery_1 = require("../parseQuery/parseQuery");
+const prepareGraphQLRequestConfigs_1 = require("../prepareGraphQLRequestConfigs/prepareGraphQLRequestConfigs");
+const createGraphQLRoutes = (router, configs, interceptors) => {
+    const preparedGraphQLRequestConfig = (0, prepareGraphQLRequestConfigs_1.prepareGraphQLRequestConfigs)(configs);
+    const graphqlMiddleware = (request, response, next) => {
+        const graphQLInput = (0, getGraphQLInput_1.getGraphQLInput)(request);
+        if (!graphQLInput || !graphQLInput.query) {
+            return response.status(400).json('Query is missing, you must pass a valid GraphQL query');
+        }
+        const query = (0, parseQuery_1.parseQuery)(graphQLInput.query);
+        if (!query) {
+            return response.status(400).json('Query is invalid, you must use a valid GraphQL query');
+        }
+        if (!query.operationName || !query.operationType) {
+            return response
+                .status(400)
+                .json(`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();
+        }
+        (0, callRequestInterceptors_1.callRequestInterceptors)({
+            request,
+            interceptors: {
+                requestInterceptor: matchedRequestConfig.interceptors?.request,
+                serverInterceptor: interceptors?.request
+            }
+        });
+        const matchedRouteConfig = matchedRequestConfig.routes.find(({ entities }) => {
+            if (!entities)
+                return true;
+            return Object.entries(entities).every(([entity, entityValue]) => {
+                if (entity === 'variables') {
+                    return (0, isEntityValuesEqual_1.isEntityValuesEqual)(entityValue, graphQLInput.variables);
+                }
+                return (0, isEntityValuesEqual_1.isEntityValuesEqual)(entityValue, request[entity]);
+            });
+        });
+        if (!matchedRouteConfig) {
+            return next();
+        }
+        const data = (0, callResponseInterceptors_1.callResponseInterceptors)({
+            data: matchedRouteConfig.data,
+            request,
+            response,
+            interceptors: {
+                routeInterceptor: matchedRouteConfig.interceptors?.response,
+                requestInterceptor: matchedRequestConfig.interceptors?.response,
+                serverInterceptor: interceptors?.response
+            }
+        });
+        return response.status(response.statusCode).json(data);
+    };
+    router.route('/').get(graphqlMiddleware);
+    router.route('/').post(graphqlMiddleware);
+    return router;
+};
+exports.createGraphQLRoutes = createGraphQLRoutes;

package/dist/src/graphql/getGraphQLInput/getGraphQLInput.d.ts

@@ -0,0 +1,3 @@
+import type { Request } from 'express';
+import type { GraphQLInput } from '../../utils/types/graphql';
+export declare const getGraphQLInput: (request: Request) => GraphQLInput;

package/dist/src/graphql/getGraphQLInput/getGraphQLInput.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGraphQLInput = void 0;
+const getGraphQLInput = (request) => {
+    if (request.method === 'GET') {
+        const { query, variables } = request.query;
+        return {
+            query: query?.toString(),
+            variables: JSON.parse(variables ?? '{}')
+        };
+    }
+    if (request.method === 'POST') {
+        const { query, variables } = request.body;
+        return {
+            query,
+            variables: variables ?? {}
+        };
+    }
+    throw new Error('Not allowed request method for graphql request');
+};
+exports.getGraphQLInput = getGraphQLInput;

package/dist/src/graphql/parseGraphQLRequest/parseGraphQLRequest.d.ts

@@ -0,0 +1,3 @@
+import { Request } from 'express';
+import { parseQuery } from '../parseQuery/parseQuery';
+export declare const parseGraphQLRequest: (request: Request) => ReturnType<typeof parseQuery>;

package/dist/src/graphql/parseGraphQLRequest/parseGraphQLRequest.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseGraphQLRequest = void 0;
+const getGraphQLInput_1 = require("../getGraphQLInput/getGraphQLInput");
+const parseQuery_1 = require("../parseQuery/parseQuery");
+const parseGraphQLRequest = (request) => {
+    const graphQLInput = (0, getGraphQLInput_1.getGraphQLInput)(request);
+    if (!graphQLInput.query)
+        return null;
+    return (0, parseQuery_1.parseQuery)(graphQLInput.query);
+};
+exports.parseGraphQLRequest = parseGraphQLRequest;

package/dist/src/graphql/parseQuery/parseQuery.d.ts

@@ -0,0 +1,7 @@
+import type { OperationTypeNode } from 'graphql';
+interface ParseDocumentNodeResult {
+    operationType: OperationTypeNode;
+    operationName: string;
+}
+export declare const parseQuery: (query: string) => ParseDocumentNodeResult | null;
+export {};

package/dist/src/graphql/parseQuery/parseQuery.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseQuery = void 0;
+const graphql_1 = require("graphql");
+const parseDocumentNode = (node) => {
+    const operationDefinition = node.definitions.find((definition) => definition.kind === 'OperationDefinition');
+    return {
+        operationType: operationDefinition.operation,
+        operationName: operationDefinition.name?.value ?? ''
+    };
+};
+const parseQuery = (query) => {
+    try {
+        const document = (0, graphql_1.parse)(query);
+        return parseDocumentNode(document);
+    }
+    catch {
+        return null;
+    }
+};
+exports.parseQuery = parseQuery;

package/dist/src/graphql/prepareGraphQLRequestConfigs/prepareGraphQLRequestConfigs.d.ts

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

package/dist/src/graphql/prepareGraphQLRequestConfigs/prepareGraphQLRequestConfigs.js

@@ -0,0 +1,28 @@
+"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, query, variables } = entities;
+    if (headers)
+        routeConfigWeight += Object.keys(headers).length;
+    if (query)
+        routeConfigWeight += Object.keys(query).length;
+    if (variables)
+        routeConfigWeight += (0, helpers_1.isPlainObject)(variables) ? Object.keys(variables).length : 1;
+    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/index.d.ts

@@ -1,3 +1,3 @@
-export * from './server/createMockServer/createMockServer';
-export * from './server/startMockServer/startMockServer';
-export * from './utils/types';
+export * from './server/createMockServer/createMockServer';
+export * from './server/startMockServer/startMockServer';
+export * from './utils/types';

package/dist/src/index.js

@@ -1,19 +1,19 @@
-"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("./server/createMockServer/createMockServer"), exports);
-__exportStar(require("./server/startMockServer/startMockServer"), exports);
-__exportStar(require("./utils/types"), exports);
+"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("./server/createMockServer/createMockServer"), exports);
+__exportStar(require("./server/startMockServer/startMockServer"), exports);
+__exportStar(require("./utils/types"), exports);

package/dist/src/notFound/notFoundMiddleware.d.ts

@@ -0,0 +1,8 @@
+import type { Express } from 'express';
+import type { MockServerConfig } from '../utils/types';
+interface NotFoundMiddlewareParams {
+    server: Express;
+    mockServerConfig: Pick<MockServerConfig, 'baseUrl' | 'rest' | 'graphql'>;
+}
+export declare const notFoundMiddleware: ({ server, mockServerConfig }: NotFoundMiddlewareParams) => void;
+export {};

package/dist/src/notFound/notFoundMiddleware.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.notFoundMiddleware = void 0;
+const parseGraphQLRequest_1 = require("../graphql/parseGraphQLRequest/parseGraphQLRequest");
+const urlSuggestions_1 = require("./urlSuggestions");
+const notFoundMiddleware = ({ server, mockServerConfig }) => {
+    const { baseUrl: serverBaseUrl, rest, graphql } = mockServerConfig;
+    const operationNames = graphql?.configs.map(({ operationName }) => operationName) ?? [];
+    const graphqlPatternUrlMeaningfulStrings = Array.from(operationNames.reduce((acc, operationName) => {
+        if (typeof operationName === 'string')
+            acc.add(`${serverBaseUrl}${graphql?.baseUrl}/${operationName}`);
+        return acc;
+    }, new Set()));
+    const restPaths = rest?.configs.map(({ path }) => path) ?? [];
+    const patternUrls = Array.from(restPaths.reduce((acc, patternPath) => {
+        if (typeof patternPath === 'string')
+            acc.add(`${serverBaseUrl}${rest?.baseUrl}${patternPath}`);
+        return acc;
+    }, new Set()));
+    server.use((request, response) => {
+        const url = new URL(`${request.protocol}://${request.get('host')}${request.originalUrl}`);
+        let graphqlUrlSuggestions = [];
+        if (graphql) {
+            const graphqlQuery = (0, parseGraphQLRequest_1.parseGraphQLRequest)(request);
+            if (graphqlQuery) {
+                graphqlUrlSuggestions = (0, urlSuggestions_1.getGraphqlUrlSuggestions)({
+                    url,
+                    graphqlPatternUrlMeaningfulStrings
+                });
+            }
+        }
+        let restUrlSuggestions = [];
+        if (rest) {
+            restUrlSuggestions = (0, urlSuggestions_1.getRestUrlSuggestions)({
+                url,
+                patternUrls
+            });
+        }
+        response.status(404).render('notFound', {
+            requestMethod: request.method,
+            url: `${url.pathname}${url.search}`,
+            restUrlSuggestions,
+            graphqlUrlSuggestions
+        });
+    });
+};
+exports.notFoundMiddleware = notFoundMiddleware;

package/dist/src/notFound/urlSuggestions/getGraphqlUrlSuggestions/getGraphqlUrlSuggestions.d.ts

@@ -0,0 +1,6 @@
+interface GetGraphqlUrlSuggestionsParams {
+    url: URL;
+    graphqlPatternUrlMeaningfulStrings: string[];
+}
+export declare const getGraphqlUrlSuggestions: ({ url, graphqlPatternUrlMeaningfulStrings }: GetGraphqlUrlSuggestionsParams) => string[];
+export {};

package/dist/src/notFound/urlSuggestions/getGraphqlUrlSuggestions/getGraphqlUrlSuggestions.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGraphqlUrlSuggestions = void 0;
+const getLevenshteinDistance_1 = require("../getLevenshteinDistance/getLevenshteinDistance");
+const getGraphqlUrlSuggestions = ({ url, graphqlPatternUrlMeaningfulStrings }) => {
+    // ✅ important: operationName is always second word in 'query' query param
+    const operationName = url.searchParams.get('query')?.split(' ')[1];
+    const actualUrlMeaningfulString = `${url.pathname}/${operationName}`;
+    const graphqlUrlSuggestions = graphqlPatternUrlMeaningfulStrings.reduce((acc, patternUrlMeaningfulString) => {
+        const distance = (0, getLevenshteinDistance_1.getLevenshteinDistance)(actualUrlMeaningfulString, patternUrlMeaningfulString);
+        const tolerance = Math.floor(patternUrlMeaningfulString.length / 2);
+        if (distance <= tolerance)
+            acc.push(patternUrlMeaningfulString);
+        return acc;
+    }, []);
+    return graphqlUrlSuggestions;
+};
+exports.getGraphqlUrlSuggestions = getGraphqlUrlSuggestions;

package/dist/src/notFound/urlSuggestions/getGraphqlUrlSuggestions/index.d.ts

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

package/dist/src/notFound/urlSuggestions/getGraphqlUrlSuggestions/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("./getGraphqlUrlSuggestions"), exports);

package/dist/src/notFound/urlSuggestions/getLevenshteinDistance/getLevenshteinDistance.d.ts

@@ -0,0 +1 @@
+export declare const getLevenshteinDistance: (a: string, b: string) => number;

package/dist/src/notFound/urlSuggestions/getLevenshteinDistance/getLevenshteinDistance.js

@@ -0,0 +1,80 @@
+"use strict";
+/* eslint-disable */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLevenshteinDistance = void 0;
+const min = (d0, d1, d2, bx, ay) => d0 < d1 || d2 < d1 ? (d0 > d2 ? d2 + 1 : d0 + 1) : bx === ay ? d1 : d1 + 1;
+const getLevenshteinDistance = (a, b) => {
+    if (a === b) {
+        return 0;
+    }
+    if (a.length > b.length) {
+        const tmp = a;
+        a = b;
+        b = tmp;
+    }
+    let la = a.length;
+    let lb = b.length;
+    while (la > 0 && a.charCodeAt(la - 1) === b.charCodeAt(lb - 1)) {
+        la--;
+        lb--;
+    }
+    let offset = 0;
+    while (offset < la && a.charCodeAt(offset) === b.charCodeAt(offset)) {
+        offset++;
+    }
+    la -= offset;
+    lb -= offset;
+    if (la === 0 || lb < 3) {
+        return lb;
+    }
+    let x = 0;
+    let y;
+    let d0;
+    let d1;
+    let d2;
+    let d3;
+    let dd = 0;
+    let dy;
+    let ay;
+    let bx0;
+    let bx1;
+    let bx2;
+    let bx3;
+    const vector = [];
+    for (y = 0; y < la; y++) {
+        vector.push(y + 1);
+        vector.push(a.charCodeAt(offset + y));
+    }
+    const len = vector.length - 1;
+    for (; x < lb - 3;) {
+        bx0 = b.charCodeAt(offset + (d0 = x));
+        bx1 = b.charCodeAt(offset + (d1 = x + 1));
+        bx2 = b.charCodeAt(offset + (d2 = x + 2));
+        bx3 = b.charCodeAt(offset + (d3 = x + 3));
+        dd = x += 4;
+        for (y = 0; y < len; y += 2) {
+            dy = vector[y];
+            ay = vector[y + 1];
+            d0 = min(dy, d0, d1, bx0, ay);
+            d1 = min(d0, d1, d2, bx1, ay);
+            d2 = min(d1, d2, d3, bx2, ay);
+            dd = min(d2, d3, dd, bx3, ay);
+            vector[y] = dd;
+            d3 = d2;
+            d2 = d1;
+            d1 = d0;
+            d0 = dy;
+        }
+    }
+    for (; x < lb;) {
+        bx0 = b.charCodeAt(offset + (d0 = x));
+        dd = ++x;
+        for (y = 0; y < len; y += 2) {
+            dy = vector[y];
+            vector[y] = dd = min(dy, d0, dd, bx0, vector[y + 1]);
+            d0 = dy;
+        }
+    }
+    return dd;
+};
+exports.getLevenshteinDistance = getLevenshteinDistance;

package/dist/src/notFound/urlSuggestions/getRestUrlSuggestions/getRestUrlSuggestions.d.ts

@@ -0,0 +1,6 @@
+interface GetRestUrlSuggestionsParams {
+    url: URL;
+    patternUrls: string[];
+}
+export declare const getRestUrlSuggestions: ({ url, patternUrls }: GetRestUrlSuggestionsParams) => string[];
+export {};

package/dist/src/notFound/urlSuggestions/getRestUrlSuggestions/getRestUrlSuggestions.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRestUrlSuggestions = void 0;
+const helpers_1 = require("../../../utils/helpers");
+const getLevenshteinDistance_1 = require("../getLevenshteinDistance/getLevenshteinDistance");
+const helpers_2 = require("./helpers");
+const getRestUrlSuggestions = ({ url, patternUrls }) => {
+    const actualUrlParts = (0, helpers_1.getUrlParts)(url.pathname);
+    const restUrlSuggestions = patternUrls.reduce((acc, patternUrl) => {
+        const patternUrlParts = (0, helpers_1.getUrlParts)(patternUrl);
+        // ✅ important: ignore patterns with different amount of parts
+        if (patternUrlParts.length !== actualUrlParts.length)
+            return acc;
+        const actualUrlMeaningfulString = (0, helpers_2.getActualRestUrlMeaningfulString)(actualUrlParts, patternUrlParts);
+        const patternUrlMeaningfulString = (0, helpers_2.getPatternRestUrlMeaningfulString)(patternUrlParts);
+        const tolerance = Math.floor(patternUrlMeaningfulString.length / 2);
+        const distance = (0, getLevenshteinDistance_1.getLevenshteinDistance)(actualUrlMeaningfulString, patternUrlMeaningfulString);
+        if (distance <= tolerance) {
+            // replace param names in pattern with param values from actual url
+            const urlSuggestion = patternUrlParts
+                .map((_patternUrlPart, index) => {
+                if (patternUrlParts[index].startsWith(':'))
+                    return actualUrlParts[index];
+                return patternUrlParts[index];
+            })
+                .join('/');
+            const suggestionWithQueryParams = `/${urlSuggestion}${url.search}`;
+            acc.push(suggestionWithQueryParams);
+        }
+        return acc;
+    }, []);
+    return restUrlSuggestions;
+};
+exports.getRestUrlSuggestions = getRestUrlSuggestions;

package/dist/src/notFound/urlSuggestions/getRestUrlSuggestions/helpers/getActualRestUrlMeaningfulString/getActualRestUrlMeaningfulString.d.ts

@@ -0,0 +1 @@
+export declare const getActualRestUrlMeaningfulString: (actualUrlParts: string[], patternUrlParts: string[]) => string;