mock-config-server 3.1.1 → 3.3.0

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

@@ -7,10 +7,14 @@ exports.createRestRoutes = void 0;
 var _flat = require("flat");
 var _helpers = require("../../../utils/helpers");
 var _helpers2 = require("./helpers");
-const createRestRoutes = (router, restConfig, serverResponseInterceptors) => {
+const createRestRoutes = ({
+  router,
+  restConfig,
+  serverResponseInterceptor
+}) => {
   (0, _helpers2.prepareRestRequestConfigs)(restConfig.configs).forEach(requestConfig => {
     router.route(requestConfig.path)[requestConfig.method]((0, _helpers.asyncHandler)(async (request, response, next) => {
-      var _requestConfig$interc, _matchedRouteConfig$e, _matchedRouteConfig$i, _requestConfig$interc2, _restConfig$intercept;
+      var _requestConfig$interc, _matchedRouteConfig$s, _matchedRouteConfig$e, _matchedRouteConfig$i, _requestConfig$interc2, _restConfig$intercept;
       const requestInterceptor = (_requestConfig$interc = requestConfig.interceptors) === null || _requestConfig$interc === void 0 ? void 0 : _requestConfig$interc.request;
       if (requestInterceptor) {
         await (0, _helpers.callRequestInterceptor)({
@@ -23,20 +27,26 @@ const createRestRoutes = (router, restConfig, serverResponseInterceptors) => {
       }) => {
         if (!entities) return true;
         const entries = Object.entries(entities);
-        return entries.every(([entityName, valueOrDescriptor]) => {
+        return entries.every(([entityName, entityDescriptorOrValue]) => {
           const {
             checkMode,
             value: descriptorValue
-          } = (0, _helpers.convertToEntityDescriptor)(valueOrDescriptor);
+          } = (0, _helpers.convertToEntityDescriptor)(entityDescriptorOrValue);
 
           // ✅ important: check whole body as plain value strictly if descriptor used for body
-          const isBodyPlain = entityName === 'body' && (0, _helpers.isEntityDescriptor)(valueOrDescriptor);
-          if (isBodyPlain) {
-            // ✅ important: bodyParser sets body to empty object if body not sent or invalid, so count {} as undefined
+          const isEntityBodyByTopLevelDescriptor = entityName === 'body' && (0, _helpers.isEntityDescriptor)(entityDescriptorOrValue);
+          if (isEntityBodyByTopLevelDescriptor) {
+            // ✅ important: bodyParser sets body to empty object if body not sent or invalid, so assume {} as undefined
             return (0, _helpers.resolveEntityValues)(checkMode, Object.keys(request.body).length ? request.body : undefined, descriptorValue);
           }
-          const mappedEntityDescriptors = Object.entries(valueOrDescriptor);
-          return mappedEntityDescriptors.every(([entityKey, mappedEntityDescriptor]) => {
+          const isEntityBodyByTopLevelArray = entityName === 'body' && Array.isArray(entityDescriptorOrValue);
+          if (isEntityBodyByTopLevelArray) {
+            return entityDescriptorOrValue.some(entityDescriptorOrValueElement =>
+            // ✅ important: bodyParser sets body to empty object if body not sent or invalid, so assume {} as undefined
+            (0, _helpers.resolveEntityValues)(checkMode, Object.keys(request.body).length ? request.body : undefined, entityDescriptorOrValueElement));
+          }
+          const recordOrArrayEntries = Object.entries(entityDescriptorOrValue);
+          return recordOrArrayEntries.every(([entityKey, mappedEntityDescriptor]) => {
             const {
               checkMode,
               value: descriptorValue
@@ -50,16 +60,49 @@ const createRestRoutes = (router, restConfig, serverResponseInterceptors) => {
       if (!matchedRouteConfig) {
         return next();
       }
-      const matchedRouteConfigData = typeof matchedRouteConfig.data === 'function' ? await matchedRouteConfig.data(request, (_matchedRouteConfig$e = matchedRouteConfig.entities) !== null && _matchedRouteConfig$e !== void 0 ? _matchedRouteConfig$e : {}) : matchedRouteConfig.data;
+      let matchedRouteConfigData = null;
+      if ((_matchedRouteConfig$s = matchedRouteConfig.settings) !== null && _matchedRouteConfig$s !== void 0 && _matchedRouteConfig$s.polling && 'queue' in matchedRouteConfig) {
+        var _shallowMatchedRouteC;
+        if (!matchedRouteConfig.queue.length) return next();
+        const shallowMatchedRouteConfig = matchedRouteConfig;
+        let index = (_shallowMatchedRouteC = shallowMatchedRouteConfig.__pollingIndex) !== null && _shallowMatchedRouteC !== void 0 ? _shallowMatchedRouteC : 0;
+        const {
+          time,
+          data
+        } = matchedRouteConfig.queue[index];
+        const updateIndex = () => {
+          if (matchedRouteConfig.queue.length - 1 === index) {
+            index = 0;
+          } else {
+            index += 1;
+          }
+          shallowMatchedRouteConfig.__pollingIndex = index;
+        };
+        if (time && !shallowMatchedRouteConfig.__timeoutInProgress) {
+          shallowMatchedRouteConfig.__timeoutInProgress = true;
+          setTimeout(() => {
+            shallowMatchedRouteConfig.__timeoutInProgress = false;
+            updateIndex();
+          }, time);
+        }
+        if (!time && !shallowMatchedRouteConfig.__timeoutInProgress) {
+          updateIndex();
+        }
+        matchedRouteConfigData = data;
+      }
+      if ('data' in matchedRouteConfig) {
+        matchedRouteConfigData = matchedRouteConfig.data;
+      }
+      const resolvedData = typeof matchedRouteConfigData === 'function' ? await matchedRouteConfigData(request, (_matchedRouteConfig$e = matchedRouteConfig.entities) !== null && _matchedRouteConfig$e !== void 0 ? _matchedRouteConfig$e : {}) : matchedRouteConfigData;
       const data = await (0, _helpers.callResponseInterceptors)({
-        data: matchedRouteConfigData,
+        data: resolvedData,
         request,
         response,
         interceptors: {
           routeInterceptor: (_matchedRouteConfig$i = matchedRouteConfig.interceptors) === null || _matchedRouteConfig$i === void 0 ? void 0 : _matchedRouteConfig$i.response,
           requestInterceptor: (_requestConfig$interc2 = requestConfig.interceptors) === null || _requestConfig$interc2 === void 0 ? void 0 : _requestConfig$interc2.response,
           apiInterceptor: (_restConfig$intercept = restConfig.interceptors) === null || _restConfig$intercept === void 0 ? void 0 : _restConfig$intercept.response,
-          serverInterceptor: serverResponseInterceptors
+          serverInterceptor: serverResponseInterceptor
         }
       });
 

package/dist/src/index.d.ts

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

package/dist/src/index.js

@@ -3,25 +3,14 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-var _createMockServer = require("./server/createMockServer/createMockServer");
-Object.keys(_createMockServer).forEach(function (key) {
+var _server = require("./server");
+Object.keys(_server).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _createMockServer[key]) return;
+  if (key in exports && exports[key] === _server[key]) return;
   Object.defineProperty(exports, key, {
     enumerable: true,
     get: function () {
-      return _createMockServer[key];
-    }
-  });
-});
-var _startMockServer = require("./server/startMockServer/startMockServer");
-Object.keys(_startMockServer).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _startMockServer[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _startMockServer[key];
+      return _server[key];
     }
   });
 });

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

@@ -0,0 +1,3 @@
+import type { Express } from 'express';
+import type { DatabaseMockServerConfig } from '../../utils/types';
+export declare const createDatabaseMockServer: (databaseMockServerConfig: Omit<DatabaseMockServerConfig, 'port'>, server?: Express) => Express;

package/dist/src/server/createDatabaseMockServer/createDatabaseMockServer.js

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createDatabaseMockServer = void 0;
+var _bodyParser = _interopRequireDefault(require("body-parser"));
+var _express = _interopRequireDefault(require("express"));
+var _database = require("../../core/database");
+var _middlewares = require("../../core/middlewares");
+var _helpers = require("../../utils/helpers");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const createDatabaseMockServer = (databaseMockServerConfig, server = (0, _express.default)()) => {
+  var _databaseMockServerCo, _databaseMockServerCo2;
+  const {
+    cors,
+    staticPath,
+    data,
+    routes
+  } = databaseMockServerConfig;
+  server.set('view engine', 'ejs');
+  server.set('views', (0, _helpers.urlJoin)(__dirname, '../../static/views'));
+  server.use(_express.default.static((0, _helpers.urlJoin)(__dirname, '../../static/views')));
+  server.use(_bodyParser.default.urlencoded({
+    extended: false
+  }));
+  server.use(_bodyParser.default.json({
+    limit: '10mb'
+  }));
+  server.set('json spaces', 2);
+  server.use(_bodyParser.default.text());
+  (0, _middlewares.cookieParseMiddleware)(server);
+  const serverRequestInterceptor = (_databaseMockServerCo = databaseMockServerConfig.interceptors) === null || _databaseMockServerCo === void 0 ? void 0 : _databaseMockServerCo.request;
+  if (serverRequestInterceptor) {
+    (0, _middlewares.requestInterceptorMiddleware)({
+      server,
+      interceptor: serverRequestInterceptor
+    });
+  }
+  const baseUrl = (_databaseMockServerCo2 = databaseMockServerConfig.baseUrl) !== null && _databaseMockServerCo2 !== void 0 ? _databaseMockServerCo2 : '/';
+  if (cors) {
+    (0, _middlewares.corsMiddleware)(server, cors);
+  } else {
+    (0, _middlewares.noCorsMiddleware)(server);
+  }
+  if (staticPath) {
+    (0, _middlewares.staticMiddleware)(server, baseUrl, staticPath);
+  }
+  const routerWithDatabaseRoutes = (0, _database.createDatabaseRoutes)(_express.default.Router(), {
+    data,
+    routes
+  });
+  server.use(baseUrl, routerWithDatabaseRoutes);
+  (0, _middlewares.notFoundMiddleware)(server, databaseMockServerConfig);
+  (0, _middlewares.errorMiddleware)(server);
+  return server;
+};
+exports.createDatabaseMockServer = createDatabaseMockServer;

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

@@ -0,0 +1,3 @@
+import type { Express } from 'express';
+import type { GraphQLMockServerConfig } from '../../utils/types';
+export declare const createGraphQLMockServer: (graphqlMockServerConfig: Omit<GraphQLMockServerConfig, 'port'>, server?: Express) => Express;

package/dist/src/server/createGraphQLMockServer/createGraphQLMockServer.js

@@ -0,0 +1,67 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createGraphQLMockServer = void 0;
+var _bodyParser = _interopRequireDefault(require("body-parser"));
+var _express = _interopRequireDefault(require("express"));
+var _database = require("../../core/database");
+var _graphql = require("../../core/graphql");
+var _middlewares = require("../../core/middlewares");
+var _helpers = require("../../utils/helpers");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const createGraphQLMockServer = (graphqlMockServerConfig, server = (0, _express.default)()) => {
+  var _graphqlMockServerCon, _graphqlMockServerCon2;
+  const {
+    cors,
+    staticPath,
+    configs,
+    database,
+    interceptors
+  } = graphqlMockServerConfig;
+  server.set('view engine', 'ejs');
+  server.set('views', (0, _helpers.urlJoin)(__dirname, '../../static/views'));
+  server.use(_express.default.static((0, _helpers.urlJoin)(__dirname, '../../static/views')));
+  server.use(_bodyParser.default.urlencoded({
+    extended: false
+  }));
+  server.use(_bodyParser.default.json({
+    limit: '10mb'
+  }));
+  server.set('json spaces', 2);
+  server.use(_bodyParser.default.text());
+  (0, _middlewares.cookieParseMiddleware)(server);
+  const serverRequestInterceptor = (_graphqlMockServerCon = graphqlMockServerConfig.interceptors) === null || _graphqlMockServerCon === void 0 ? void 0 : _graphqlMockServerCon.request;
+  if (serverRequestInterceptor) {
+    (0, _middlewares.requestInterceptorMiddleware)({
+      server,
+      interceptor: serverRequestInterceptor
+    });
+  }
+  const baseUrl = (_graphqlMockServerCon2 = graphqlMockServerConfig.baseUrl) !== null && _graphqlMockServerCon2 !== void 0 ? _graphqlMockServerCon2 : '/';
+  if (cors) {
+    (0, _middlewares.corsMiddleware)(server, cors);
+  } else {
+    (0, _middlewares.noCorsMiddleware)(server);
+  }
+  if (staticPath) {
+    (0, _middlewares.staticMiddleware)(server, baseUrl, staticPath);
+  }
+  const routerWithGraphqlRoutes = (0, _graphql.createGraphQLRoutes)({
+    router: _express.default.Router(),
+    graphqlConfig: {
+      configs
+    },
+    serverResponseInterceptor: interceptors === null || interceptors === void 0 ? void 0 : interceptors.response
+  });
+  server.use(baseUrl, routerWithGraphqlRoutes);
+  if (database) {
+    const routerWithDatabaseRoutes = (0, _database.createDatabaseRoutes)(_express.default.Router(), database);
+    server.use(baseUrl, routerWithDatabaseRoutes);
+  }
+  (0, _middlewares.notFoundMiddleware)(server, graphqlMockServerConfig);
+  (0, _middlewares.errorMiddleware)(server);
+  return server;
+};
+exports.createGraphQLMockServer = createGraphQLMockServer;

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

@@ -1,3 +1,3 @@
 import type { Express } from 'express';
 import type { MockServerConfig } from '../../utils/types';
-export declare const createMockServer: (mockServerConfig: Omit<MockServerConfig, 'port'>) => Express;
+export declare const createMockServer: (mockServerConfig: Omit<MockServerConfig, 'port'>, server?: Express) => Express;

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

@@ -12,7 +12,7 @@ var _middlewares = require("../../core/middlewares");
 var _rest = require("../../core/rest");
 var _helpers = require("../../utils/helpers");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-const createMockServer = mockServerConfig => {
+const createMockServer = (mockServerConfig, server = (0, _express.default)()) => {
   var _mockServerConfig$int, _mockServerConfig$bas;
   const {
     cors,
@@ -22,7 +22,6 @@ const createMockServer = mockServerConfig => {
     database,
     interceptors
   } = mockServerConfig;
-  const server = (0, _express.default)();
   server.set('view engine', 'ejs');
   server.set('views', (0, _helpers.urlJoin)(__dirname, '../../static/views'));
   server.use(_express.default.static((0, _helpers.urlJoin)(__dirname, '../../static/views')));
@@ -37,7 +36,10 @@ const createMockServer = mockServerConfig => {
   (0, _middlewares.cookieParseMiddleware)(server);
   const serverRequestInterceptor = (_mockServerConfig$int = mockServerConfig.interceptors) === null || _mockServerConfig$int === void 0 ? void 0 : _mockServerConfig$int.request;
   if (serverRequestInterceptor) {
-    (0, _middlewares.requestInterceptorMiddleware)(server, serverRequestInterceptor);
+    (0, _middlewares.requestInterceptorMiddleware)({
+      server,
+      interceptor: serverRequestInterceptor
+    });
   }
   const baseUrl = (_mockServerConfig$bas = mockServerConfig.baseUrl) !== null && _mockServerConfig$bas !== void 0 ? _mockServerConfig$bas : '/';
   if (cors) {
@@ -49,23 +51,39 @@ const createMockServer = mockServerConfig => {
     (0, _middlewares.staticMiddleware)(server, baseUrl, staticPath);
   }
   if (rest) {
-    var _rest$interceptors, _rest$baseUrl;
-    const routerWithRestRoutes = (0, _rest.createRestRoutes)(_express.default.Router(), rest, interceptors === null || interceptors === void 0 ? void 0 : interceptors.response);
+    var _rest$baseUrl, _rest$interceptors;
+    const routerWithRestRoutes = (0, _rest.createRestRoutes)({
+      router: _express.default.Router(),
+      restConfig: rest,
+      serverResponseInterceptor: interceptors === null || interceptors === void 0 ? void 0 : interceptors.response
+    });
+    const restBaseUrl = (0, _helpers.urlJoin)(baseUrl, (_rest$baseUrl = rest.baseUrl) !== null && _rest$baseUrl !== void 0 ? _rest$baseUrl : '/');
     const apiRequestInterceptor = (_rest$interceptors = rest.interceptors) === null || _rest$interceptors === void 0 ? void 0 : _rest$interceptors.request;
     if (apiRequestInterceptor) {
-      (0, _middlewares.requestInterceptorMiddleware)(server, apiRequestInterceptor);
+      (0, _middlewares.requestInterceptorMiddleware)({
+        server,
+        path: restBaseUrl,
+        interceptor: apiRequestInterceptor
+      });
     }
-    const restBaseUrl = (0, _helpers.urlJoin)(baseUrl, (_rest$baseUrl = rest.baseUrl) !== null && _rest$baseUrl !== void 0 ? _rest$baseUrl : '/');
     server.use(restBaseUrl, routerWithRestRoutes);
   }
   if (graphql) {
-    var _graphql$interceptors, _graphql$baseUrl;
-    const routerWithGraphQLRoutes = (0, _graphql.createGraphQLRoutes)(_express.default.Router(), graphql, interceptors === null || interceptors === void 0 ? void 0 : interceptors.response);
+    var _graphql$baseUrl, _graphql$interceptors;
+    const routerWithGraphQLRoutes = (0, _graphql.createGraphQLRoutes)({
+      router: _express.default.Router(),
+      graphqlConfig: graphql,
+      serverResponseInterceptor: interceptors === null || interceptors === void 0 ? void 0 : interceptors.response
+    });
+    const graphqlBaseUrl = (0, _helpers.urlJoin)(baseUrl, (_graphql$baseUrl = graphql.baseUrl) !== null && _graphql$baseUrl !== void 0 ? _graphql$baseUrl : '/');
     const apiRequestInterceptor = (_graphql$interceptors = graphql.interceptors) === null || _graphql$interceptors === void 0 ? void 0 : _graphql$interceptors.request;
     if (apiRequestInterceptor) {
-      (0, _middlewares.requestInterceptorMiddleware)(server, apiRequestInterceptor);
+      (0, _middlewares.requestInterceptorMiddleware)({
+        server,
+        path: graphqlBaseUrl,
+        interceptor: apiRequestInterceptor
+      });
     }
-    const graphqlBaseUrl = (0, _helpers.urlJoin)(baseUrl, (_graphql$baseUrl = graphql.baseUrl) !== null && _graphql$baseUrl !== void 0 ? _graphql$baseUrl : '/');
     server.use(graphqlBaseUrl, routerWithGraphQLRoutes);
   }
   if (database) {

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

@@ -0,0 +1,3 @@
+import type { Express } from 'express';
+import type { RestMockServerConfig } from '../../utils/types';
+export declare const createRestMockServer: (restMockServerConfig: Omit<RestMockServerConfig, 'port'>, server?: Express) => Express;

package/dist/src/server/createRestMockServer/createRestMockServer.js

@@ -0,0 +1,67 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createRestMockServer = void 0;
+var _bodyParser = _interopRequireDefault(require("body-parser"));
+var _express = _interopRequireDefault(require("express"));
+var _database = require("../../core/database");
+var _middlewares = require("../../core/middlewares");
+var _rest = require("../../core/rest");
+var _helpers = require("../../utils/helpers");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const createRestMockServer = (restMockServerConfig, server = (0, _express.default)()) => {
+  var _restMockServerConfig, _restMockServerConfig2;
+  const {
+    cors,
+    staticPath,
+    configs,
+    database,
+    interceptors
+  } = restMockServerConfig;
+  server.set('view engine', 'ejs');
+  server.set('views', (0, _helpers.urlJoin)(__dirname, '../../static/views'));
+  server.use(_express.default.static((0, _helpers.urlJoin)(__dirname, '../../static/views')));
+  server.use(_bodyParser.default.urlencoded({
+    extended: false
+  }));
+  server.use(_bodyParser.default.json({
+    limit: '10mb'
+  }));
+  server.set('json spaces', 2);
+  server.use(_bodyParser.default.text());
+  (0, _middlewares.cookieParseMiddleware)(server);
+  const serverRequestInterceptor = (_restMockServerConfig = restMockServerConfig.interceptors) === null || _restMockServerConfig === void 0 ? void 0 : _restMockServerConfig.request;
+  if (serverRequestInterceptor) {
+    (0, _middlewares.requestInterceptorMiddleware)({
+      server,
+      interceptor: serverRequestInterceptor
+    });
+  }
+  const baseUrl = (_restMockServerConfig2 = restMockServerConfig.baseUrl) !== null && _restMockServerConfig2 !== void 0 ? _restMockServerConfig2 : '/';
+  if (cors) {
+    (0, _middlewares.corsMiddleware)(server, cors);
+  } else {
+    (0, _middlewares.noCorsMiddleware)(server);
+  }
+  if (staticPath) {
+    (0, _middlewares.staticMiddleware)(server, baseUrl, staticPath);
+  }
+  const routerWithRestRoutes = (0, _rest.createRestRoutes)({
+    router: _express.default.Router(),
+    restConfig: {
+      configs
+    },
+    serverResponseInterceptor: interceptors === null || interceptors === void 0 ? void 0 : interceptors.response
+  });
+  server.use(baseUrl, routerWithRestRoutes);
+  if (database) {
+    const routerWithDatabaseRoutes = (0, _database.createDatabaseRoutes)(_express.default.Router(), database);
+    server.use(baseUrl, routerWithDatabaseRoutes);
+  }
+  (0, _middlewares.notFoundMiddleware)(server, restMockServerConfig);
+  (0, _middlewares.errorMiddleware)(server);
+  return server;
+};
+exports.createRestMockServer = createRestMockServer;

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

@@ -1,2 +1,8 @@
+export * from './createDatabaseMockServer/createDatabaseMockServer';
+export * from './createGraphQLMockServer/createGraphQLMockServer';
 export * from './createMockServer/createMockServer';
+export * from './createRestMockServer/createRestMockServer';
+export * from './startDatabaseMockServer/startDatabaseMockServer';
+export * from './startGraphQLMockServer/startGraphQLMockServer';
 export * from './startMockServer/startMockServer';
+export * from './startRestMockServer/startRestMockServer';

package/dist/src/server/index.js

@@ -3,6 +3,28 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+var _createDatabaseMockServer = require("./createDatabaseMockServer/createDatabaseMockServer");
+Object.keys(_createDatabaseMockServer).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _createDatabaseMockServer[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _createDatabaseMockServer[key];
+    }
+  });
+});
+var _createGraphQLMockServer = require("./createGraphQLMockServer/createGraphQLMockServer");
+Object.keys(_createGraphQLMockServer).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _createGraphQLMockServer[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _createGraphQLMockServer[key];
+    }
+  });
+});
 var _createMockServer = require("./createMockServer/createMockServer");
 Object.keys(_createMockServer).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
@@ -14,6 +36,39 @@ Object.keys(_createMockServer).forEach(function (key) {
     }
   });
 });
+var _createRestMockServer = require("./createRestMockServer/createRestMockServer");
+Object.keys(_createRestMockServer).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _createRestMockServer[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _createRestMockServer[key];
+    }
+  });
+});
+var _startDatabaseMockServer = require("./startDatabaseMockServer/startDatabaseMockServer");
+Object.keys(_startDatabaseMockServer).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _startDatabaseMockServer[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _startDatabaseMockServer[key];
+    }
+  });
+});
+var _startGraphQLMockServer = require("./startGraphQLMockServer/startGraphQLMockServer");
+Object.keys(_startGraphQLMockServer).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _startGraphQLMockServer[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _startGraphQLMockServer[key];
+    }
+  });
+});
 var _startMockServer = require("./startMockServer/startMockServer");
 Object.keys(_startMockServer).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
@@ -24,4 +79,15 @@ Object.keys(_startMockServer).forEach(function (key) {
       return _startMockServer[key];
     }
   });
+});
+var _startRestMockServer = require("./startRestMockServer/startRestMockServer");
+Object.keys(_startRestMockServer).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _startRestMockServer[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _startRestMockServer[key];
+    }
+  });
 });

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

@@ -0,0 +1,5 @@
+/// <reference types="node" />
+import type { DatabaseMockServerConfig } from '../../utils/types';
+export declare const startDatabaseMockServer: (databaseMockServerConfig: DatabaseMockServerConfig) => 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/startDatabaseMockServer/startDatabaseMockServer.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.startDatabaseMockServer = void 0;
+var _ansiColors = _interopRequireDefault(require("ansi-colors"));
+var _middlewares = require("../../core/middlewares");
+var _constants = require("../../utils/constants");
+var _createDatabaseMockServer = require("../createDatabaseMockServer/createDatabaseMockServer");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const startDatabaseMockServer = databaseMockServerConfig => {
+  var _databaseMockServerCo;
+  const mockServer = (0, _createDatabaseMockServer.createDatabaseMockServer)(databaseMockServerConfig);
+  const port = (_databaseMockServerCo = databaseMockServerConfig.port) !== null && _databaseMockServerCo !== void 0 ? _databaseMockServerCo : _constants.DEFAULT.PORT;
+  const server = mockServer.listen(port, () => {
+    console.log(_ansiColors.default.green(`🎉 Database Mock Server is running at http://localhost:${port}`));
+  });
+
+  // ✅ important: add destroy method for closing keep-alive connections after server shutdown
+  return (0, _middlewares.destroyerMiddleware)(server);
+};
+exports.startDatabaseMockServer = startDatabaseMockServer;

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

@@ -0,0 +1,5 @@
+/// <reference types="node" />
+import type { GraphQLMockServerConfig } from '../../utils/types';
+export declare const startGraphQLMockServer: (graphQLMockServerConfig: GraphQLMockServerConfig) => 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/startGraphQLMockServer/startGraphQLMockServer.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.startGraphQLMockServer = void 0;
+var _ansiColors = _interopRequireDefault(require("ansi-colors"));
+var _middlewares = require("../../core/middlewares");
+var _constants = require("../../utils/constants");
+var _createGraphQLMockServer = require("../createGraphQLMockServer/createGraphQLMockServer");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const startGraphQLMockServer = graphQLMockServerConfig => {
+  var _graphQLMockServerCon;
+  const mockServer = (0, _createGraphQLMockServer.createGraphQLMockServer)(graphQLMockServerConfig);
+  const port = (_graphQLMockServerCon = graphQLMockServerConfig.port) !== null && _graphQLMockServerCon !== void 0 ? _graphQLMockServerCon : _constants.DEFAULT.PORT;
+  const server = mockServer.listen(port, () => {
+    console.log(_ansiColors.default.green(`🎉 GraphQL Mock Server is running at http://localhost:${port}`));
+  });
+
+  // ✅ important: add destroy method for closing keep-alive connections after server shutdown
+  return (0, _middlewares.destroyerMiddleware)(server);
+};
+exports.startGraphQLMockServer = startGraphQLMockServer;

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

@@ -0,0 +1,5 @@
+/// <reference types="node" />
+import type { RestMockServerConfig } from '../../utils/types';
+export declare const startRestMockServer: (restMockServerConfig: RestMockServerConfig) => 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/startRestMockServer/startRestMockServer.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.startRestMockServer = void 0;
+var _ansiColors = _interopRequireDefault(require("ansi-colors"));
+var _middlewares = require("../../core/middlewares");
+var _constants = require("../../utils/constants");
+var _createRestMockServer = require("../createRestMockServer/createRestMockServer");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const startRestMockServer = restMockServerConfig => {
+  var _restMockServerConfig;
+  const mockServer = (0, _createRestMockServer.createRestMockServer)(restMockServerConfig);
+  const port = (_restMockServerConfig = restMockServerConfig.port) !== null && _restMockServerConfig !== void 0 ? _restMockServerConfig : _constants.DEFAULT.PORT;
+  const server = mockServer.listen(port, () => {
+    console.log(_ansiColors.default.green(`🎉 Rest Mock Server is running at http://localhost:${port}`));
+  });
+
+  // ✅ important: add destroy method for closing keep-alive connections after server shutdown
+  return (0, _middlewares.destroyerMiddleware)(server);
+};
+exports.startRestMockServer = startRestMockServer;

package/dist/src/static/views/assets/styles/global.css

@@ -56,7 +56,7 @@ a {
   line-height: 17px;
 }
 
-.margin-container {
+.margin_container {
   display: flex;
   width: 100%;
   justify-content: center;
@@ -80,7 +80,7 @@ a {
   padding-inline: 75px;
 }
 
-.content-head {
+.content_head {
   display: flex;
   flex-direction: column;
   align-items: center;