mock-config-server 3.0.0 → 3.0.1

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,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.corsMiddleware = void 0;
+const constants_1 = require("../../../utils/constants");
+const helpers_1 = require("../../../utils/helpers");
+const helpers_2 = require("./helpers");
+const corsMiddleware = (server, cors) => {
+    server.use((0, helpers_1.asyncHandler)(async (request, response, next) => {
+        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, helpers_2.getAllowedOrigins)(origins);
+        }
+        else {
+            allowedOrigins = (0, helpers_2.getAllowedOrigins)(cors.origin);
+        }
+        const { origin } = request.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) {
+            response.setHeader('Access-Control-Allow-Origin', origin);
+            response.setHeader('Access-Control-Allow-Credentials', `${cors.credentials ?? constants_1.DEFAULT.CORS.CREDENTIALS}`);
+            response.setHeader('Access-Control-Expose-Headers', cors.exposedHeaders ?? constants_1.DEFAULT.CORS.EXPOSED_HEADERS);
+            if (request.method === 'OPTIONS') {
+                response.setHeader('Access-Control-Allow-Methods', cors.methods ?? constants_1.DEFAULT.CORS.METHODS);
+                response.setHeader('Access-Control-Allow-Headers', cors.allowedHeaders ?? constants_1.DEFAULT.CORS.ALLOWED_HEADERS);
+                response.setHeader('Access-Control-Max-Age', cors.maxAge ?? constants_1.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,13 @@
+"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,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("./getAllowedOrigins/getAllowedOrigins"), exports);

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,23 @@
+"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,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.errorMiddleware = void 0;
+const ansi_colors_1 = __importDefault(require("ansi-colors"));
+const errorMiddleware = (server) => {
+    server.use(((error, request, response, next) => {
+        console.error(ansi_colors_1.default.bgRed(`\nError on ${request.method} ${request.url} request\n`));
+        const message = `Message: ${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,24 @@
+"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("./staticMiddleware/staticMiddleware"), exports);
+__exportStar(require("./corsMiddleware/corsMiddleware"), exports);
+__exportStar(require("./noCorsMiddleware/noCorsMiddleware"), exports);
+__exportStar(require("./notFoundMiddleware/notFoundMiddleware"), exports);
+__exportStar(require("./requestInterceptorMiddleware/requestInterceptorMiddleware"), exports);
+__exportStar(require("./destroyerMiddleware/destroyerMiddleware"), exports);
+__exportStar(require("./cookieParseMiddleware/cookieParseMiddleware"), exports);
+__exportStar(require("./errorMiddleware/errorMiddleware"), exports);

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;
+const constants_1 = require("../../../utils/constants");
+const noCorsMiddleware = (server) => {
+    server.use((request, response, next) => {
+        response.setHeader('Access-Control-Allow-Origin', constants_1.DEFAULT.CORS.ORIGIN);
+        response.setHeader('Access-Control-Allow-Credentials', `${constants_1.DEFAULT.CORS.CREDENTIALS}`);
+        response.setHeader('Access-Control-Expose-Headers', constants_1.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_1.DEFAULT.CORS.METHODS);
+            response.setHeader('Access-Control-Allow-Headers', constants_1.DEFAULT.CORS.ALLOWED_HEADERS);
+            response.setHeader('Access-Control-Max-Age', constants_1.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,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGraphqlUrlSuggestions = void 0;
+const getLevenshteinDistance_1 = require("../getLevenshteinDistance/getLevenshteinDistance");
+const getGraphqlUrlSuggestions = ({ url, requestConfigs }) => {
+    // ✅ important: operationName is always second word in 'query' query param
+    const actualOperationName = url.searchParams.get('query')?.split(' ')[1];
+    const actualUrlMeaningful = `${url.pathname}/${actualOperationName}`;
+    const graphqlUrlSuggestions = requestConfigs.reduce((acc, requestConfig) => {
+        const { operationName } = requestConfig;
+        const distance = (0, getLevenshteinDistance_1.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,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/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,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, requestConfigs }) => {
+    const actualUrlParts = (0, helpers_1.getUrlParts)(url.pathname);
+    const restUrlSuggestions = requestConfigs.reduce((acc, requestConfig) => {
+        const patternUrlParts = (0, helpers_1.getUrlParts)(requestConfig.path);
+        // ✅ 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({ ...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,7 @@
+"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,5 @@
+"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,18 @@
+"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("./getActualRestUrlMeaningfulString/getActualRestUrlMeaningfulString"), exports);
+__exportStar(require("./getPatternRestUrlMeaningfulString/getPatternRestUrlMeaningfulString"), exports);

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,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("./getGraphqlUrlSuggestions/getGraphqlUrlSuggestions"), exports);
+__exportStar(require("./getLevenshteinDistance/getLevenshteinDistance"), exports);
+__exportStar(require("./getRestUrlSuggestions/getRestUrlSuggestions"), exports);

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;

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

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.notFoundMiddleware = void 0;
+const helpers_1 = require("../../../utils/helpers");
+const helpers_2 = require("./helpers");
+const notFoundMiddleware = (server, mockServerConfig) => {
+    const { baseUrl: serverBaseUrl, rest, graphql } = mockServerConfig;
+    const restRequestConfigs = rest?.configs
+        .filter(({ path }) => !(path instanceof RegExp))
+        .map((request) => ({
+        method: request.method,
+        path: `${serverBaseUrl ?? ''}${rest?.baseUrl ?? ''}${request.path}`
+    })) ?? [];
+    const graphqlRequestConfigs = graphql?.configs
+        .filter(({ operationName }) => !(operationName instanceof RegExp))
+        .map((request) => ({
+        operationType: request.operationType,
+        operationName: `${serverBaseUrl ?? ''}${graphql?.baseUrl ?? ''} ${request.operationName}`
+    })) ?? [];
+    server.use((request, response) => {
+        const url = new URL(`${request.protocol}://${request.get('host')}${request.originalUrl}`);
+        let restRequestSuggestions = [];
+        if (rest) {
+            restRequestSuggestions = (0, helpers_2.getRestUrlSuggestions)({
+                url,
+                requestConfigs: restRequestConfigs
+            });
+        }
+        let graphqlRequestSuggestions = [];
+        if (graphql && (0, helpers_1.parseGraphQLRequest)(request)) {
+            graphqlRequestSuggestions = (0, helpers_2.getGraphqlUrlSuggestions)({
+                url,
+                requestConfigs: graphqlRequestConfigs
+            });
+        }
+        const isRequestSupportHtml = request.headers.accept?.includes('text/html') || request.headers.accept?.includes('*/*');
+        if (isRequestSupportHtml) {
+            response.status(404).render('pages/404', {
+                restRequestSuggestions,
+                graphqlRequestSuggestions
+            });
+            return;
+        }
+        response.status(404).json({
+            message: 'Request or page not found. Similar requests in data',
+            data: {
+                restRequestSuggestions,
+                graphqlRequestSuggestions
+            }
+        });
+    });
+};
+exports.notFoundMiddleware = notFoundMiddleware;

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

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

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

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requestInterceptorMiddleware = void 0;
+const helpers_1 = require("../../../utils/helpers");
+const requestInterceptorMiddleware = (server, interceptor) => {
+    server.use((0, helpers_1.asyncHandler)(async (request, _response, next) => {
+        await (0, helpers_1.callRequestInterceptor)({ request, interceptor });
+        return next();
+    }));
+};
+exports.requestInterceptorMiddleware = requestInterceptorMiddleware;

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

@@ -0,0 +1,3 @@
+import type { Express } from 'express';
+import type { BaseUrl, StaticPath } from '../../../utils/types';
+export declare const staticMiddleware: (server: Express, baseUrl: BaseUrl, staticPath: StaticPath) => void;

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

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.staticMiddleware = void 0;
+const express_1 = __importDefault(require("express"));
+const constants_1 = require("../../../utils/constants");
+const helpers_1 = require("../../../utils/helpers");
+const staticMiddleware = (server, baseUrl, staticPath) => {
+    const isStaticPathArray = Array.isArray(staticPath);
+    if (isStaticPathArray) {
+        staticPath.forEach((staticPath) => {
+            const isPathObject = typeof staticPath === 'object';
+            if (isPathObject) {
+                server.use((0, helpers_1.urlJoin)(baseUrl, staticPath.prefix), express_1.default.static((0, helpers_1.urlJoin)(constants_1.APP_PATH, staticPath.path)));
+                return;
+            }
+            server.use(baseUrl, express_1.default.static((0, helpers_1.urlJoin)(constants_1.APP_PATH, staticPath)));
+        });
+        return;
+    }
+    const isStaticPathObject = typeof staticPath === 'object';
+    if (isStaticPathObject) {
+        server.use((0, helpers_1.urlJoin)(baseUrl, staticPath.prefix), express_1.default.static((0, helpers_1.urlJoin)(constants_1.APP_PATH, staticPath.path)));
+        return;
+    }
+    server.use(baseUrl, express_1.default.static((0, helpers_1.urlJoin)(constants_1.APP_PATH, staticPath)));
+};
+exports.staticMiddleware = staticMiddleware;

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

@@ -0,0 +1,3 @@
+import type { IRouter } from 'express';
+import type { Interceptors, RestConfig } from '../../../utils/types';
+export declare const createRestRoutes: (router: IRouter, restConfig: RestConfig, serverResponseInterceptors?: Interceptors['response']) => IRouter;

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

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRestRoutes = void 0;
+const flat_1 = require("flat");
+const helpers_1 = require("../../../utils/helpers");
+const helpers_2 = require("./helpers");
+const createRestRoutes = (router, restConfig, serverResponseInterceptors) => {
+    (0, helpers_2.prepareRestRequestConfigs)(restConfig.configs).forEach((requestConfig) => {
+        router.route(requestConfig.path)[requestConfig.method]((0, helpers_1.asyncHandler)(async (request, response, next) => {
+            const requestInterceptor = requestConfig.interceptors?.request;
+            if (requestInterceptor) {
+                await (0, helpers_1.callRequestInterceptor)({ request, interceptor: requestInterceptor });
+            }
+            const matchedRouteConfig = requestConfig.routes.find(({ entities }) => {
+                if (!entities)
+                    return true;
+                const entries = Object.entries(entities);
+                return entries.every(([entityName, valueOrDescriptor]) => {
+                    const { checkMode, value: descriptorValue } = (0, helpers_1.convertToEntityDescriptor)(valueOrDescriptor);
+                    // ✅ important: check whole body as plain value strictly if descriptor used for body
+                    const isBodyPlain = entityName === 'body' && (0, helpers_1.isEntityDescriptor)(valueOrDescriptor);
+                    if (isBodyPlain) {
+                        // ✅ important: bodyParser sets body to empty object if body not sent or invalid, so count {} as undefined
+                        return (0, helpers_1.resolveEntityValues)(checkMode, Object.keys(request.body).length ? request.body : undefined, descriptorValue);
+                    }
+                    const mappedEntityDescriptors = Object.entries(valueOrDescriptor);
+                    return mappedEntityDescriptors.every(([entityKey, mappedEntityDescriptor]) => {
+                        const { checkMode, value: descriptorValue } = (0, helpers_1.convertToEntityDescriptor)(mappedEntityDescriptor);
+                        const flattenEntity = (0, flat_1.flatten)(request[entityName]);
+                        return (0, helpers_1.resolveEntityValues)(checkMode, flattenEntity[entityKey], descriptorValue);
+                    });
+                });
+            });
+            if (!matchedRouteConfig) {
+                return next();
+            }
+            const matchedRouteConfigData = typeof matchedRouteConfig.data === 'function'
+                ? await matchedRouteConfig.data(request, matchedRouteConfig.entities ?? {})
+                : matchedRouteConfig.data;
+            const data = await (0, helpers_1.callResponseInterceptors)({
+                data: matchedRouteConfigData,
+                request,
+                response,
+                interceptors: {
+                    routeInterceptor: matchedRouteConfig.interceptors?.response,
+                    requestInterceptor: requestConfig.interceptors?.response,
+                    apiInterceptor: restConfig.interceptors?.response,
+                    serverInterceptor: serverResponseInterceptors
+                }
+            });
+            // ✅ important:
+            // set 'Cache-Control' header for explicit browsers response revalidate
+            // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Cache-Control
+            response.set('Cache-control', 'max-age=0, must-revalidate');
+            return response.status(response.statusCode).json(data);
+        }));
+    });
+    return router;
+};
+exports.createRestRoutes = createRestRoutes;

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

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