mock-config-server 2.2.0 → 2.3.0

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

@@ -3,20 +3,20 @@ 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);
-        const isPreflightRequest = req.method === 'OPTIONS' &&
-            req.headers.origin &&
-            req.headers['access-control-request-method'] &&
-            req.headers['access-control-request-headers'];
+    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) {
-            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();
+            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();
     });

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(async (request, _response, next) => {
+        await (0, helpers_1.callRequestInterceptor)({ request, interceptor });
+        return next();
+    });
+};
+exports.requestInterceptorMiddleware = requestInterceptorMiddleware;

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

@@ -1,3 +1,3 @@
 import type { IRouter } from 'express';
-import type { Interceptors, RestRequestConfig } from '../../../utils/types';
-export declare const createRestRoutes: (router: IRouter, configs: RestRequestConfig[], interceptors?: Interceptors) => IRouter;
+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

@@ -3,16 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createRestRoutes = void 0;
 const helpers_1 = require("../../../utils/helpers");
 const helpers_2 = require("./helpers");
-const createRestRoutes = (router, configs, interceptors) => {
-    (0, helpers_2.prepareRestRequestConfigs)(configs).forEach((requestConfig) => {
+const createRestRoutes = (router, restConfig, serverResponseInterceptors) => {
+    (0, helpers_2.prepareRestRequestConfigs)(restConfig.configs).forEach((requestConfig) => {
         router.route(requestConfig.path)[requestConfig.method](async (request, response, next) => {
-            (0, helpers_1.callRequestInterceptors)({
-                request,
-                interceptors: {
-                    requestInterceptor: requestConfig.interceptors?.request,
-                    serverInterceptor: interceptors?.request
-                }
-            });
+            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;
@@ -24,14 +21,15 @@ const createRestRoutes = (router, configs, interceptors) => {
             const matchedRouteConfigData = typeof matchedRouteConfig.data === 'function'
                 ? await matchedRouteConfig.data(request, matchedRouteConfig.entities ?? {})
                 : matchedRouteConfig.data;
-            const data = (0, helpers_1.callResponseInterceptors)({
+            const data = await (0, helpers_1.callResponseInterceptors)({
                 data: matchedRouteConfigData,
                 request,
                 response,
                 interceptors: {
                     routeInterceptor: matchedRouteConfig.interceptors?.response,
                     requestInterceptor: requestConfig.interceptors?.response,
-                    serverInterceptor: interceptors?.response
+                    apiInterceptor: restConfig.interceptors?.response,
+                    serverInterceptor: serverResponseInterceptors
                 }
             });
             // ✅ important:

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

@@ -7,9 +7,11 @@ const calculateRouteConfigWeight = (restRouteConfig) => {
     if (!entities)
         return 0;
     let routeConfigWeight = 0;
-    const { headers, query, params, body } = entities;
+    const { headers, cookies, query, params, body } = entities;
     if (headers)
         routeConfigWeight += Object.keys(headers).length;
+    if (cookies)
+        routeConfigWeight += Object.keys(cookies).length;
     if (query)
         routeConfigWeight += Object.keys(query).length;
     if (params)

package/dist/src/server/createMockServer/createMockServer.js

@@ -17,6 +17,11 @@ const createMockServer = (mockServerConfig) => {
     server.set('view engine', 'ejs');
     server.use(body_parser_1.default.urlencoded({ extended: false }));
     server.use(body_parser_1.default.json({ limit: '10mb' }));
+    (0, middlewares_1.cookieParseMiddleware)(server);
+    const serverRequestInterceptor = mockServerConfig.interceptors?.request;
+    if (serverRequestInterceptor) {
+        (0, middlewares_1.requestInterceptorMiddleware)(server, serverRequestInterceptor);
+    }
     const baseUrl = mockServerConfig.baseUrl ?? '/';
     if (cors) {
         (0, middlewares_1.corsMiddleware)(server, cors);
@@ -28,12 +33,20 @@ const createMockServer = (mockServerConfig) => {
         (0, middlewares_1.staticMiddleware)(server, baseUrl, staticPath);
     }
     if (rest) {
-        const routerWithRestRoutes = (0, rest_1.createRestRoutes)(express_1.default.Router(), rest.configs, interceptors);
+        const routerWithRestRoutes = (0, rest_1.createRestRoutes)(express_1.default.Router(), rest, interceptors?.response);
+        const apiRequestInterceptor = rest.interceptors?.request;
+        if (apiRequestInterceptor) {
+            (0, middlewares_1.requestInterceptorMiddleware)(server, apiRequestInterceptor);
+        }
         const restBaseUrl = (0, helpers_1.urlJoin)(baseUrl, rest.baseUrl ?? '/');
         server.use(restBaseUrl, routerWithRestRoutes);
     }
     if (graphql) {
-        const routerWithGraphQLRoutes = (0, graphql_1.createGraphQLRoutes)(express_1.default.Router(), graphql.configs, interceptors);
+        const routerWithGraphQLRoutes = (0, graphql_1.createGraphQLRoutes)(express_1.default.Router(), graphql, interceptors?.response);
+        const apiRequestInterceptor = graphql.interceptors?.request;
+        if (apiRequestInterceptor) {
+            (0, middlewares_1.requestInterceptorMiddleware)(server, apiRequestInterceptor);
+        }
         const graphqlBaseUrl = (0, helpers_1.urlJoin)(baseUrl, graphql.baseUrl ?? '/');
         server.use(graphqlBaseUrl, routerWithGraphQLRoutes);
     }

package/dist/src/server/index.d.ts

@@ -1,2 +1,2 @@
-export * from './startMockServer/startMockServer';
 export * from './createMockServer/createMockServer';
+export * from './startMockServer/startMockServer';

package/dist/src/server/index.js

@@ -14,5 +14,5 @@ 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("./startMockServer/startMockServer"), exports);
 __exportStar(require("./createMockServer/createMockServer"), exports);
+__exportStar(require("./startMockServer/startMockServer"), exports);

package/dist/src/server/startMockServer/startMockServer.d.ts

@@ -1,2 +1,5 @@
+/// <reference types="node" />
 import type { MockServerConfig } from '../../utils/types';
-export declare const startMockServer: (mockServerConfig: MockServerConfig) => void;
+export declare const startMockServer: (mockServerConfig: MockServerConfig) => import("http").Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse> & {
+    destroy: (callback?: ((err?: Error | undefined) => void) | undefined) => import("http").Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse>;
+};

package/dist/src/server/startMockServer/startMockServer.js

@@ -5,13 +5,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.startMockServer = void 0;
 const ansi_colors_1 = __importDefault(require("ansi-colors"));
+const middlewares_1 = require("../../core/middlewares");
 const constants_1 = require("../../utils/constants");
 const createMockServer_1 = require("../createMockServer/createMockServer");
 const startMockServer = (mockServerConfig) => {
     const mockServer = (0, createMockServer_1.createMockServer)(mockServerConfig);
     const port = mockServerConfig.port ?? constants_1.DEFAULT.PORT;
-    mockServer.listen(port, () => {
+    const server = mockServer.listen(port, () => {
         console.log(ansi_colors_1.default.green(`🎉 Mock Server is running at http://localhost:${port}`));
     });
+    // ✅ important: add destroy method for closing keep-alive connections after server shutdown
+    return (0, middlewares_1.destroyerMiddleware)(server);
 };
 exports.startMockServer = startMockServer;

package/dist/src/utils/helpers/interceptors/callRequestInterceptor/callRequestInterceptor.d.ts

@@ -0,0 +1,8 @@
+import type { Request } from 'express';
+import type { RequestInterceptor } from '../../../types';
+interface CallRequestInterceptorParams {
+    request: Request;
+    interceptor: RequestInterceptor;
+}
+export declare const callRequestInterceptor: (params: CallRequestInterceptorParams) => Promise<void>;
+export {};

package/dist/src/utils/helpers/interceptors/callRequestInterceptor/callRequestInterceptor.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callRequestInterceptor = void 0;
+const setDelay_1 = require("../helpers/setDelay");
+const callRequestInterceptor = async (params) => {
+    const { request, interceptor } = params;
+    const getHeader = (field) => request.headers[field];
+    const getHeaders = () => request.headers;
+    const getCookie = (name) => request.cookies[name];
+    const requestInterceptorParams = {
+        request,
+        setDelay: setDelay_1.setDelay,
+        getHeader,
+        getHeaders,
+        getCookie
+    };
+    await interceptor(requestInterceptorParams);
+};
+exports.callRequestInterceptor = callRequestInterceptor;

package/dist/src/utils/helpers/interceptors/callResponseInterceptors/callResponseInterceptors.d.ts

@@ -1,14 +1,15 @@
 import type { Request, Response } from 'express';
-import type { Data, InterceptorResponse } from '../../../types';
+import type { Data, ResponseInterceptor } from '../../../types';
 interface CallResponseInterceptorsParams {
     data: Data;
     request: Request;
     response: Response;
     interceptors?: {
-        routeInterceptor?: InterceptorResponse | undefined;
-        requestInterceptor?: InterceptorResponse | undefined;
-        serverInterceptor?: InterceptorResponse | undefined;
+        routeInterceptor?: ResponseInterceptor;
+        requestInterceptor?: ResponseInterceptor;
+        apiInterceptor?: ResponseInterceptor;
+        serverInterceptor?: ResponseInterceptor;
     };
 }
-export declare const callResponseInterceptors: (params: CallResponseInterceptorsParams) => Data;
+export declare const callResponseInterceptors: (params: CallResponseInterceptorsParams) => Promise<Data>;
 export {};

package/dist/src/utils/helpers/interceptors/callResponseInterceptors/callResponseInterceptors.js

@@ -1,54 +1,51 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.callResponseInterceptors = void 0;
-const sleep_1 = require("../../sleep");
-const callResponseInterceptors = (params) => {
+const setDelay_1 = require("../helpers/setDelay");
+const callResponseInterceptors = async (params) => {
     const { data, request, response, interceptors } = params;
-    const setDelay = async (delay) => {
-        await (0, sleep_1.sleep)(delay === Infinity ? 100000 : delay);
-    };
+    const getHeader = (field) => response.getHeader(field);
+    const getHeaders = () => response.getHeaders();
+    const getCookie = (name) => request.cookies[name];
     const setStatusCode = (statusCode) => {
         response.statusCode = statusCode;
     };
-    const setHeader = (field, value) => {
-        response.header(field, value);
-    };
-    const appendHeader = (field, value) => {
-        response.append(field, value);
-    };
+    const setHeader = (field, value) => response.set(field, value);
+    const appendHeader = (field, value) => response.append(field, value);
     const setCookie = (name, value, options) => {
         if (options) {
             response.cookie(name, value, options);
-            return;
         }
         response.cookie(name, value);
     };
-    const clearCookie = (name, options) => {
-        response.clearCookie(name, options);
-    };
-    const attachment = (filename) => {
-        response.attachment(filename);
-    };
-    const interceptorResponseParams = {
+    const clearCookie = (name, options) => response.clearCookie(name, options);
+    const attachment = (filename) => response.attachment(filename);
+    const ResponseInterceptorParams = {
         request,
         response,
-        setDelay,
+        setDelay: setDelay_1.setDelay,
         setStatusCode,
         setHeader,
         appendHeader,
+        getHeader,
+        getHeaders,
         setCookie,
+        getCookie,
         clearCookie,
         attachment
     };
     let updatedData = data;
     if (interceptors?.routeInterceptor) {
-        updatedData = interceptors.routeInterceptor(updatedData, interceptorResponseParams);
+        updatedData = await interceptors.routeInterceptor(updatedData, ResponseInterceptorParams);
     }
     if (interceptors?.requestInterceptor) {
-        updatedData = interceptors.requestInterceptor(updatedData, interceptorResponseParams);
+        updatedData = await interceptors.requestInterceptor(updatedData, ResponseInterceptorParams);
+    }
+    if (interceptors?.apiInterceptor) {
+        updatedData = await interceptors.apiInterceptor(updatedData, ResponseInterceptorParams);
     }
     if (interceptors?.serverInterceptor) {
-        updatedData = interceptors.serverInterceptor(updatedData, interceptorResponseParams);
+        updatedData = await interceptors.serverInterceptor(updatedData, ResponseInterceptorParams);
     }
     return updatedData;
 };

package/dist/src/utils/helpers/interceptors/helpers/setDelay.d.ts

@@ -0,0 +1 @@
+export declare const setDelay: (delay: number) => Promise<void>;

package/dist/src/utils/helpers/interceptors/helpers/setDelay.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setDelay = void 0;
+const sleep_1 = require("../../sleep");
+const setDelay = async (delay) => {
+    await (0, sleep_1.sleep)(delay === Infinity ? 99999999 : delay);
+};
+exports.setDelay = setDelay;

package/dist/src/utils/helpers/interceptors/index.d.ts

@@ -1,2 +1,2 @@
-export * from './callRequestInterceptors/callRequestInterceptors';
+export * from './callRequestInterceptor/callRequestInterceptor';
 export * from './callResponseInterceptors/callResponseInterceptors';

package/dist/src/utils/helpers/interceptors/index.js

@@ -14,5 +14,5 @@ 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("./callRequestInterceptors/callRequestInterceptors"), exports);
+__exportStar(require("./callRequestInterceptor/callRequestInterceptor"), exports);
 __exportStar(require("./callResponseInterceptors/callResponseInterceptors"), exports);

package/dist/src/utils/helpers/sleep.d.ts

@@ -1 +1 @@
-export declare const sleep: (seconds: number) => Promise<unknown>;
+export declare const sleep: (milliseconds: number) => Promise<unknown>;

package/dist/src/utils/helpers/sleep.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.sleep = void 0;
-const sleep = (seconds) => new Promise((resolve) => {
-    setTimeout(resolve, seconds * 1000);
+const sleep = (milliseconds) => new Promise((resolve) => {
+    setTimeout(resolve, milliseconds);
 });
 exports.sleep = sleep;

package/dist/src/utils/types/graphql.d.ts

@@ -6,7 +6,7 @@ export interface GraphQLInput {
     query?: string;
     variables: GraphQLVariables;
 }
-export type GraphQLEntities = 'headers' | 'query' | 'variables';
+export type GraphQLEntities = 'headers' | 'cookies' | 'query' | 'variables';
 export type GraphQLEntitiesValues = {
     [Key in GraphQLEntities]: Key extends 'variables' ? VariablesValue : PlainObject;
 };

package/dist/src/utils/types/interceptors.d.ts

@@ -1,21 +1,30 @@
 import type { CookieOptions, Request, Response } from 'express';
-export interface InterceptorRequestParams {
+export type RequestInterceptorCookieValue = string | undefined;
+export type RequestInterceptorHeaderValue = string | number | string[] | undefined;
+export interface RequestInterceptorParams {
     request: Request;
+    setDelay: (delay: number) => Promise<void>;
+    getCookie: (name: string) => RequestInterceptorCookieValue;
+    getHeader: (field: string) => RequestInterceptorHeaderValue;
+    getHeaders: () => Record<string, RequestInterceptorHeaderValue>;
 }
-export type InterceptorRequest = (params: InterceptorRequestParams) => void;
-export interface InterceptorResponseParams {
+export type RequestInterceptor = (params: RequestInterceptorParams) => void;
+export interface ResponseInterceptorParams {
     request: Request;
     response: Response;
     setDelay: (delay: number) => Promise<void>;
     setStatusCode: (statusCode: number) => void;
     setHeader: (field: string, value?: string | string[]) => void;
     appendHeader: (field: string, value?: string[] | string) => void;
+    getHeader: (field: string) => RequestInterceptorHeaderValue;
+    getHeaders: () => Record<string, RequestInterceptorHeaderValue>;
     setCookie: (name: string, value: string, options?: CookieOptions) => void;
+    getCookie: (name: string) => RequestInterceptorCookieValue;
     clearCookie: (name: string, options?: CookieOptions) => void;
     attachment: (filename: string) => void;
 }
-export type InterceptorResponse<DataType extends any = any> = (data: DataType, params: InterceptorResponseParams) => any;
+export type ResponseInterceptor<Data extends any = any> = (data: Data, params: ResponseInterceptorParams) => any;
 export interface Interceptors {
-    request?: InterceptorRequest;
-    response?: InterceptorResponse;
+    request?: RequestInterceptor;
+    response?: ResponseInterceptor;
 }

package/dist/src/utils/types/rest.d.ts

@@ -1,18 +1,18 @@
 import type { Request } from 'express';
 import type { Interceptors } from './interceptors';
-import type { BodyValue, Data, HeadersValue, ParamsValue, QueryValue } from './values';
-export type RestEntities = 'headers' | 'query' | 'params' | 'body';
-export type RestEntitiesValue = BodyValue | QueryValue | HeadersValue | ParamsValue;
+import type { BodyValue, CookiesValue, Data, HeadersValue, ParamsValue, QueryValue } from './values';
+export type RestEntities = 'headers' | 'cookies' | 'query' | 'params' | 'body';
+export type RestEntitiesValue = BodyValue | QueryValue | HeadersValue | CookiesValue | ParamsValue;
 export type RestEntitiesValues = {
-    [Key in RestEntities]: Key extends 'body' ? BodyValue : Key extends 'query' ? QueryValue : Key extends 'headers' ? HeadersValue : Key extends 'params' ? ParamsValue : never;
+    [Key in RestEntities]: Key extends 'body' ? BodyValue : Key extends 'query' ? QueryValue : Key extends 'headers' ? HeadersValue : Key extends 'cookies' ? CookiesValue : Key extends 'params' ? ParamsValue : never;
 };
 export interface RestMethodsEntities {
-    get: Extract<RestEntities, 'headers' | 'query' | 'params'>;
-    delete: Extract<RestEntities, 'headers' | 'query' | 'params'>;
+    get: Exclude<RestEntities, 'body'>;
+    delete: Exclude<RestEntities, 'body'>;
     post: RestEntities;
     put: RestEntities;
     patch: RestEntities;
-    options: Extract<RestEntities, 'headers' | 'query' | 'params'>;
+    options: Exclude<RestEntities, 'body'>;
 }
 export type RestRouteConfigEntities<Method extends RestMethod> = {
     [Key in RestMethodsEntities[Method]]?: RestEntitiesValues[Key];

package/dist/src/utils/types/server.d.ts

@@ -19,19 +19,29 @@ export type Cors = {
 };
 export type Port = number;
 export type BaseUrl = `/${string}`;
+export interface RestConfig {
+    baseUrl?: BaseUrl;
+    configs: RestRequestConfig[];
+    interceptors?: Interceptors;
+}
+export interface GraphqlConfig {
+    baseUrl?: BaseUrl;
+    configs: GraphQLRequestConfig[];
+    interceptors?: Interceptors;
+}
 export interface MockServerConfig {
     baseUrl?: BaseUrl;
-    rest?: {
-        baseUrl?: BaseUrl;
-        configs: RestRequestConfig[];
-    };
-    graphql?: {
-        baseUrl?: BaseUrl;
-        configs: GraphQLRequestConfig[];
-    };
+    rest?: RestConfig;
+    graphql?: GraphqlConfig;
     port?: Port;
     staticPath?: StaticPath;
     interceptors?: Interceptors;
     cors?: Cors;
 }
-export type MockServerConfigArgv = Partial<Pick<MockServerConfig, 'baseUrl' | 'port' | 'staticPath'>>;
+export interface MockServerConfigArgv {
+    baseUrl?: string;
+    port?: number;
+    staticPath?: string;
+    config?: string;
+    watch?: boolean;
+}

package/dist/src/utils/types/values.d.ts

@@ -5,5 +5,6 @@ export type BodyValue = any;
 export type VariablesValue = any;
 export type QueryValue = ParsedQs;
 export type HeadersValue = Record<string, string>;
+export type CookiesValue = Record<string, string>;
 export type ParamsValue = Record<string, string>;
 export type Data = boolean | number | string | any[] | Record<any, any> | null | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mock-config-server",
-  "version": "2.2.0",
+  "version": "2.3.0",
   "description": "Tool that easily and quickly imitates server operation, create full fake api in few steps",
   "author": {
     "name": "SIBERIA CAN CODE 🧊",

package/dist/bin/start.d.ts

@@ -1,3 +0,0 @@
-#!/usr/bin/env node
-import type { MockServerConfigArgv } from '../src';
-export declare const start: (argv: MockServerConfigArgv) => Promise<void>;

package/dist/bin/start.js

@@ -1,73 +0,0 @@
-#!/usr/bin/env node
-"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.start = void 0;
-const fs = __importStar(require("fs"));
-const esbuild_1 = require("esbuild");
-const server_1 = require("../src/server");
-const helpers_1 = require("../src/utils/helpers");
-const resolveExportsFromSourceCode_1 = require("./resolveExportsFromSourceCode/resolveExportsFromSourceCode");
-const validateMockServerConfig_1 = require("./validateMockServerConfig/validateMockServerConfig");
-const start = async (argv) => {
-    try {
-        const appPath = process.cwd();
-        const mockServerConfigFileRegex = /mock-server.config.(?:ts|js)/;
-        const mockServerConfigFile = fs
-            .readdirSync(appPath)
-            .find((file) => mockServerConfigFileRegex.test(file));
-        if (!mockServerConfigFile) {
-            throw new Error('Cannot find config file mock-server.config.(ts|js)');
-        }
-        const { outputFiles } = await (0, esbuild_1.build)({
-            entryPoints: [mockServerConfigFile],
-            bundle: true,
-            platform: 'node',
-            target: 'esnext',
-            minifySyntax: true,
-            minify: true,
-            write: false,
-            metafile: false
-        });
-        const mockServerConfigSourceCode = outputFiles[0]?.text;
-        if (!mockServerConfigSourceCode) {
-            throw new Error('Cannot handle source code of mock-server.config.(ts|js)');
-        }
-        const mockServerConfigExports = (0, resolveExportsFromSourceCode_1.resolveExportsFromSourceCode)(mockServerConfigSourceCode);
-        if (!mockServerConfigExports?.default) {
-            throw new Error('Cannot handle exports of mock-server.config.(ts|js)');
-        }
-        if (!(0, helpers_1.isPlainObject)(mockServerConfigExports.default)) {
-            throw new Error('configuration should be plain object; see our doc (https://www.npmjs.com/package/mock-config-server) for more information');
-        }
-        const mergedMockServerConfig = { ...mockServerConfigExports.default, ...argv };
-        (0, validateMockServerConfig_1.validateMockServerConfig)(mergedMockServerConfig);
-        (0, server_1.startMockServer)(mergedMockServerConfig);
-    }
-    catch (error) {
-        console.error(error.message);
-    }
-};
-exports.start = start;

package/dist/src/utils/helpers/interceptors/callRequestInterceptors/callRequestInterceptors.d.ts

@@ -1,12 +0,0 @@
-import type { Request } from 'express';
-import type { InterceptorRequest } from '../../../types';
-interface CallRequestInterceptorsParams {
-    request: Request;
-    interceptors?: {
-        routeInterceptor?: InterceptorRequest | undefined;
-        requestInterceptor?: InterceptorRequest | undefined;
-        serverInterceptor?: InterceptorRequest | undefined;
-    };
-}
-export declare const callRequestInterceptors: (params: CallRequestInterceptorsParams) => void;
-export {};

package/dist/src/utils/helpers/interceptors/callRequestInterceptors/callRequestInterceptors.js

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.callRequestInterceptors = void 0;
-const callRequestInterceptors = (params) => {
-    const { request, interceptors } = params;
-    if (interceptors?.routeInterceptor)
-        interceptors.routeInterceptor({ request });
-    if (interceptors?.requestInterceptor)
-        interceptors.requestInterceptor({ request });
-    if (interceptors?.serverInterceptor)
-        interceptors.serverInterceptor({ request });
-};
-exports.callRequestInterceptors = callRequestInterceptors;