mock-config-server 2.1.0 → 2.3.0

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

@@ -4,19 +4,19 @@ exports.corsMiddleware = void 0;
 const constants_1 = require("../../../utils/constants");
 const helpers_1 = require("./helpers");
 const corsMiddleware = (server, cors) => {
-    server.use(async (req, res, next) => {
+    server.use(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(req);
+            const origins = await cors.origin(request);
             allowedOrigins = (0, helpers_1.getAllowedOrigins)(origins);
         }
         else {
             allowedOrigins = (0, helpers_1.getAllowedOrigins)(cors.origin);
         }
-        const { origin } = req.headers;
+        const { origin } = request.headers;
         if (!allowedOrigins?.length || !origin) {
             return next();
         }
@@ -27,15 +27,15 @@ const corsMiddleware = (server, cors) => {
             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();
+            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();

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/index.d.ts

@@ -2,3 +2,6 @@ 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';

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

@@ -18,3 +18,6 @@ __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);

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.1.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 🧊",
@@ -20,7 +20,7 @@
       "url": "https://github.com/RiceWithMeat"
     }
   ],
-  "license": "ISC",
+  "license": "MIT",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "bin": {
@@ -36,6 +36,8 @@
   "scripts": {
     "prepare": "husky install",
     "build": "shx rm -rf dist && tsc -p tsconfig.production.json && tsc-alias -p tsconfig.production.json && shx cp -R src/static dist/src/static",
+    "start": "yarn build && node ./dist/bin/bin.js",
+    "dev": "nodemon --watch src --watch bin --watch mock-server.config.* -e js,ts,ejs --exec \"yarn start\"",
     "test": "jest",
     "type": "tsc --noEmit",
     "lint": "eslint . --ext ts --no-error-on-unmatched-pattern",

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>;