mock-config-server 3.0.0 → 3.1.0

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,52 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.corsMiddleware = void 0;
+var _constants = require("../../../utils/constants");
+var _helpers = require("../../../utils/helpers");
+var _helpers2 = require("./helpers");
+const corsMiddleware = (server, cors) => {
+  server.use((0, _helpers.asyncHandler)(async (request, response, next) => {
+    var _allowedOrigins;
+    if (Array.isArray(cors.origin) && !cors.origin.length) {
+      return next();
+    }
+    let allowedOrigins = [];
+    if (typeof cors.origin === 'function') {
+      const origins = await cors.origin(request);
+      allowedOrigins = (0, _helpers2.getAllowedOrigins)(origins);
+    } else {
+      allowedOrigins = (0, _helpers2.getAllowedOrigins)(cors.origin);
+    }
+    const {
+      origin
+    } = request.headers;
+    if (!((_allowedOrigins = allowedOrigins) !== null && _allowedOrigins !== void 0 && _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) {
+      var _cors$credentials, _cors$exposedHeaders;
+      response.setHeader('Access-Control-Allow-Origin', origin);
+      response.setHeader('Access-Control-Allow-Credentials', `${(_cors$credentials = cors.credentials) !== null && _cors$credentials !== void 0 ? _cors$credentials : _constants.DEFAULT.CORS.CREDENTIALS}`);
+      response.setHeader('Access-Control-Expose-Headers', (_cors$exposedHeaders = cors.exposedHeaders) !== null && _cors$exposedHeaders !== void 0 ? _cors$exposedHeaders : _constants.DEFAULT.CORS.EXPOSED_HEADERS);
+      if (request.method === 'OPTIONS') {
+        var _cors$methods, _cors$allowedHeaders, _cors$maxAge;
+        response.setHeader('Access-Control-Allow-Methods', (_cors$methods = cors.methods) !== null && _cors$methods !== void 0 ? _cors$methods : _constants.DEFAULT.CORS.METHODS);
+        response.setHeader('Access-Control-Allow-Headers', (_cors$allowedHeaders = cors.allowedHeaders) !== null && _cors$allowedHeaders !== void 0 ? _cors$allowedHeaders : _constants.DEFAULT.CORS.ALLOWED_HEADERS);
+        response.setHeader('Access-Control-Max-Age', (_cors$maxAge = cors.maxAge) !== null && _cors$maxAge !== void 0 ? _cors$maxAge : _constants.DEFAULT.CORS.MAX_AGE);
+        response.sendStatus(204);
+        return response.end();
+      }
+    }
+    return next();
+  }));
+};
+exports.corsMiddleware = corsMiddleware;

package/dist/src/core/middlewares/corsMiddleware/helpers/getAllowedOrigins/getAllowedOrigins.d.ts

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

package/dist/src/core/middlewares/corsMiddleware/helpers/getAllowedOrigins/getAllowedOrigins.js

@@ -0,0 +1,16 @@
+"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/core/middlewares/corsMiddleware/helpers/index.d.ts

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

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

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

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

@@ -0,0 +1,7 @@
+/// <reference types="node" />
+import type { Server } from 'http';
+type ServerWithDestroyer = Server & {
+    destroy: Server['close'];
+};
+export declare const destroyerMiddleware: (server: Server) => ServerWithDestroyer;
+export {};

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

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.destroyerMiddleware = void 0;
+const destroyerMiddleware = server => {
+  const serverWithDestroyer = server;
+  const connections = {};
+  serverWithDestroyer.on('connection', connection => {
+    const key = `${connection.remoteAddress}:${connection.remotePort}`;
+    connections[key] = connection;
+    connection.on('close', () => {
+      delete connections[key];
+    });
+  });
+  serverWithDestroyer.destroy = callback => {
+    serverWithDestroyer.close(callback);
+    Object.values(connections).forEach(connection => {
+      connection.destroy();
+    });
+    return serverWithDestroyer;
+  };
+  return serverWithDestroyer;
+};
+exports.destroyerMiddleware = destroyerMiddleware;

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

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

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

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.errorMiddleware = void 0;
+var _ansiColors = _interopRequireDefault(require("ansi-colors"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const errorMiddleware = server => {
+  server.use((error, request, response, next) => {
+    var _error$message;
+    console.error(_ansiColors.default.bgRed(`\nError on ${request.method} ${request.url} request\n`));
+    const message = `Message: ${(_error$message = error.message) !== null && _error$message !== void 0 ? _error$message : 'Internal server error'}\n\n${error.stack}`;
+    response.status(error.status || 500).send(message);
+
+    // ✅ important:
+    // call next function for trigger default express error handling behavior
+    next(error);
+  });
+};
+exports.errorMiddleware = errorMiddleware;

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

@@ -0,0 +1,8 @@
+export * from './staticMiddleware/staticMiddleware';
+export * from './corsMiddleware/corsMiddleware';
+export * from './noCorsMiddleware/noCorsMiddleware';
+export * from './notFoundMiddleware/notFoundMiddleware';
+export * from './requestInterceptorMiddleware/requestInterceptorMiddleware';
+export * from './destroyerMiddleware/destroyerMiddleware';
+export * from './cookieParseMiddleware/cookieParseMiddleware';
+export * from './errorMiddleware/errorMiddleware';

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

@@ -0,0 +1,93 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _staticMiddleware = require("./staticMiddleware/staticMiddleware");
+Object.keys(_staticMiddleware).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _staticMiddleware[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _staticMiddleware[key];
+    }
+  });
+});
+var _corsMiddleware = require("./corsMiddleware/corsMiddleware");
+Object.keys(_corsMiddleware).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _corsMiddleware[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _corsMiddleware[key];
+    }
+  });
+});
+var _noCorsMiddleware = require("./noCorsMiddleware/noCorsMiddleware");
+Object.keys(_noCorsMiddleware).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _noCorsMiddleware[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _noCorsMiddleware[key];
+    }
+  });
+});
+var _notFoundMiddleware = require("./notFoundMiddleware/notFoundMiddleware");
+Object.keys(_notFoundMiddleware).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _notFoundMiddleware[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _notFoundMiddleware[key];
+    }
+  });
+});
+var _requestInterceptorMiddleware = require("./requestInterceptorMiddleware/requestInterceptorMiddleware");
+Object.keys(_requestInterceptorMiddleware).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _requestInterceptorMiddleware[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _requestInterceptorMiddleware[key];
+    }
+  });
+});
+var _destroyerMiddleware = require("./destroyerMiddleware/destroyerMiddleware");
+Object.keys(_destroyerMiddleware).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _destroyerMiddleware[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _destroyerMiddleware[key];
+    }
+  });
+});
+var _cookieParseMiddleware = require("./cookieParseMiddleware/cookieParseMiddleware");
+Object.keys(_cookieParseMiddleware).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _cookieParseMiddleware[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _cookieParseMiddleware[key];
+    }
+  });
+});
+var _errorMiddleware = require("./errorMiddleware/errorMiddleware");
+Object.keys(_errorMiddleware).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _errorMiddleware[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _errorMiddleware[key];
+    }
+  });
+});

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

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

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

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.noCorsMiddleware = void 0;
+var _constants = require("../../../utils/constants");
+const noCorsMiddleware = server => {
+  server.use((request, response, next) => {
+    response.setHeader('Access-Control-Allow-Origin', _constants.DEFAULT.CORS.ORIGIN);
+    response.setHeader('Access-Control-Allow-Credentials', `${_constants.DEFAULT.CORS.CREDENTIALS}`);
+    response.setHeader('Access-Control-Expose-Headers', _constants.DEFAULT.CORS.EXPOSED_HEADERS);
+    const isPreflightRequest = request.method === 'OPTIONS' && request.headers.origin && request.headers['access-control-request-method'] && request.headers['access-control-request-headers'];
+    if (isPreflightRequest) {
+      response.setHeader('Access-Control-Allow-Methods', _constants.DEFAULT.CORS.METHODS);
+      response.setHeader('Access-Control-Allow-Headers', _constants.DEFAULT.CORS.ALLOWED_HEADERS);
+      response.setHeader('Access-Control-Max-Age', _constants.DEFAULT.CORS.MAX_AGE);
+      response.sendStatus(204);
+      return response.end();
+    }
+    return next();
+  });
+};
+exports.noCorsMiddleware = noCorsMiddleware;

package/dist/src/core/middlewares/notFoundMiddleware/helpers/getGraphqlUrlSuggestions/getGraphqlUrlSuggestions.d.ts

@@ -0,0 +1,11 @@
+import type { GraphQLOperationType } from '../../../../../utils/types';
+export type GraphqlRequestSuggestionConfigs = {
+    operationType: GraphQLOperationType;
+    operationName: string;
+}[];
+interface GetGraphqlUrlSuggestionsParams {
+    url: URL;
+    requestConfigs: GraphqlRequestSuggestionConfigs;
+}
+export declare const getGraphqlUrlSuggestions: ({ url, requestConfigs }: GetGraphqlUrlSuggestionsParams) => GraphqlRequestSuggestionConfigs;
+export {};

package/dist/src/core/middlewares/notFoundMiddleware/helpers/getGraphqlUrlSuggestions/getGraphqlUrlSuggestions.js

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

package/dist/src/core/middlewares/notFoundMiddleware/helpers/getLevenshteinDistance/getLevenshteinDistance.d.ts

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

package/dist/src/core/middlewares/notFoundMiddleware/helpers/getLevenshteinDistance/getLevenshteinDistance.js

@@ -0,0 +1,84 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getLevenshteinDistance = void 0;
+/* eslint-disable */
+
+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/core/middlewares/notFoundMiddleware/helpers/getRestUrlSuggestions/getRestUrlSuggestions.d.ts

@@ -0,0 +1,11 @@
+import type { RestMethod, RestPathString } from '../../../../../utils/types';
+export type RestRequestSuggestionConfigs = {
+    method: RestMethod;
+    path: RestPathString;
+}[];
+interface GetRestUrlSuggestionsParams {
+    url: URL;
+    requestConfigs: RestRequestSuggestionConfigs;
+}
+export declare const getRestUrlSuggestions: ({ url, requestConfigs }: GetRestUrlSuggestionsParams) => RestRequestSuggestionConfigs;
+export {};

package/dist/src/core/middlewares/notFoundMiddleware/helpers/getRestUrlSuggestions/getRestUrlSuggestions.js

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getRestUrlSuggestions = void 0;
+var _helpers = require("../../../../../utils/helpers");
+var _getLevenshteinDistance = require("../getLevenshteinDistance/getLevenshteinDistance");
+var _helpers2 = require("./helpers");
+const getRestUrlSuggestions = ({
+  url,
+  requestConfigs
+}) => {
+  const actualUrlParts = (0, _helpers.getUrlParts)(url.pathname);
+  const restUrlSuggestions = requestConfigs.reduce((acc, requestConfig) => {
+    const patternUrlParts = (0, _helpers.getUrlParts)(requestConfig.path);
+    // ✅ important: ignore patterns with different amount of parts
+    if (patternUrlParts.length !== actualUrlParts.length) return acc;
+    const actualUrlMeaningfulString = (0, _helpers2.getActualRestUrlMeaningfulString)(actualUrlParts, patternUrlParts);
+    const patternUrlMeaningfulString = (0, _helpers2.getPatternRestUrlMeaningfulString)(patternUrlParts);
+    const tolerance = Math.floor(patternUrlMeaningfulString.length / 2);
+    const distance = (0, _getLevenshteinDistance.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({
+        ...requestConfig,
+        path: suggestionWithQueryParams
+      });
+    }
+    return acc;
+  }, []);
+  return restUrlSuggestions;
+};
+exports.getRestUrlSuggestions = getRestUrlSuggestions;

package/dist/src/core/middlewares/notFoundMiddleware/helpers/getRestUrlSuggestions/helpers/getActualRestUrlMeaningfulString/getActualRestUrlMeaningfulString.d.ts

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

package/dist/src/core/middlewares/notFoundMiddleware/helpers/getRestUrlSuggestions/helpers/getActualRestUrlMeaningfulString/getActualRestUrlMeaningfulString.js

@@ -0,0 +1,8 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getActualRestUrlMeaningfulString = void 0;
+const getActualRestUrlMeaningfulString = (actualUrlParts, patternUrlParts) => actualUrlParts.filter((_actualUrlPart, index) => !patternUrlParts[index].startsWith(':')).join('');
+exports.getActualRestUrlMeaningfulString = getActualRestUrlMeaningfulString;

package/dist/src/core/middlewares/notFoundMiddleware/helpers/getRestUrlSuggestions/helpers/getPatternRestUrlMeaningfulString/getPatternRestUrlMeaningfulString.d.ts

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

package/dist/src/core/middlewares/notFoundMiddleware/helpers/getRestUrlSuggestions/helpers/getPatternRestUrlMeaningfulString/getPatternRestUrlMeaningfulString.js

@@ -0,0 +1,8 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getPatternRestUrlMeaningfulString = void 0;
+const getPatternRestUrlMeaningfulString = patternUrlParts => patternUrlParts.filter(urlPatternPart => !urlPatternPart.startsWith(':')).join('');
+exports.getPatternRestUrlMeaningfulString = getPatternRestUrlMeaningfulString;

package/dist/src/core/middlewares/notFoundMiddleware/helpers/getRestUrlSuggestions/helpers/index.d.ts

@@ -0,0 +1,2 @@
+export * from './getActualRestUrlMeaningfulString/getActualRestUrlMeaningfulString';
+export * from './getPatternRestUrlMeaningfulString/getPatternRestUrlMeaningfulString';

package/dist/src/core/middlewares/notFoundMiddleware/helpers/getRestUrlSuggestions/helpers/index.js

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

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

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

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

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

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

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