mock-config-server 3.2.0 → 3.3.1

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

@@ -0,0 +1,285 @@
+import express from 'express';
+import request from 'supertest';
+
+import { createGraphQLRoutes } from '@/core/graphql';
+import { createRestRoutes } from '@/core/rest';
+import { urlJoin } from '@/utils/helpers';
+import type { BaseUrl, MockServerConfig } from '@/utils/types';
+
+import type { GraphqlRequestSuggestionConfigs } from './helpers/getGraphqlUrlSuggestions/getGraphqlUrlSuggestions';
+import type { RestRequestSuggestionConfigs } from './helpers/getRestUrlSuggestions/getRestUrlSuggestions';
+import { notFoundMiddleware } from './notFoundMiddleware';
+
+const createServer = (
+  mockServerConfig: Pick<MockServerConfig, 'rest' | 'graphql' | 'interceptors' | 'baseUrl'>
+) => {
+  const { baseUrl, rest, interceptors, graphql } = mockServerConfig;
+
+  const server = express();
+
+  const serverBaseUrl = baseUrl ?? '/';
+
+  const restBaseUrl = urlJoin(serverBaseUrl, rest?.baseUrl ?? '/');
+  const routerWithRestRoutes = createRestRoutes({
+    router: express.Router(),
+    restConfig: { configs: rest?.configs ?? [] },
+    serverResponseInterceptor: interceptors?.response
+  });
+  server.use(restBaseUrl, routerWithRestRoutes);
+
+  const graphqlBaseUrl = urlJoin(serverBaseUrl, graphql?.baseUrl ?? '/');
+  const routerWithGraphqlRoutes = createGraphQLRoutes({
+    router: express.Router(),
+    graphqlConfig: { configs: graphql?.configs ?? [] },
+    serverResponseInterceptor: interceptors?.response
+  });
+  server.use(graphqlBaseUrl, routerWithGraphqlRoutes);
+
+  server.set('view engine', 'ejs');
+  server.set('views', urlJoin(__dirname, '../../../static/views'));
+  server.use(express.static(urlJoin(__dirname, '../../../static/views')));
+  server.use(express.json());
+
+  notFoundMiddleware(server, mockServerConfig);
+
+  return server;
+};
+
+describe('notFoundMiddleware: HTML response', () => {
+  const server = createServer({
+    rest: {
+      configs: [
+        {
+          path: '/posts',
+          method: 'get',
+          routes: [{ data: {} }]
+        }
+      ]
+    },
+    graphql: {
+      configs: [
+        {
+          operationName: 'GetPosts',
+          operationType: 'query',
+          routes: [{ data: {} }]
+        }
+      ]
+    }
+  });
+
+  test('Should send correct HTML REST response', async () => {
+    const response = await request(server).get('/pstss').set('accept', 'text/html');
+
+    expect(response.statusCode).toBe(404);
+    expect(response.get('Content-Type')).toContain('text/html');
+    expect(response.text).toContain('GET /posts');
+  });
+
+  test('Should send correct HTML GraphQL response', async () => {
+    const response = await request(server)
+      .get('/?query=query getPost { posts }')
+      .set('accept', 'text/html');
+
+    expect(response.statusCode).toBe(404);
+    expect(response.get('Content-Type')).toContain('text/html');
+    expect(response.text).toContain('query  GetPosts');
+  });
+});
+
+interface ResponseBody {
+  restRequestSuggestions?: RestRequestSuggestionConfigs;
+  graphqlRequestSuggestions?: GraphqlRequestSuggestionConfigs;
+}
+
+const responseBody = ({
+  restRequestSuggestions = [],
+  graphqlRequestSuggestions = []
+}: ResponseBody) => ({
+  message: 'Request or page not found. Similar requests in data',
+  data: {
+    restRequestSuggestions,
+    graphqlRequestSuggestions
+  }
+});
+
+describe('notFoundMiddleware: REST', () => {
+  const serverBaseUrl: BaseUrl = '/base';
+  const restBaseUrl: BaseUrl = '/rest';
+  const rest: MockServerConfig['rest'] = {
+    configs: [
+      {
+        path: '/posts',
+        method: 'get',
+        routes: [{ data: {} }]
+      },
+      {
+        path: '/posts/:postId',
+        method: 'get',
+        routes: [{ data: {}, entities: { params: { postId: '1' } } }]
+      },
+
+      {
+        path: '/developers',
+        method: 'post',
+        routes: [{ data: {} }]
+      },
+      {
+        path: '/developers/:developerId',
+        method: 'post',
+        routes: [{ data: {}, entities: { params: { developerId: '1' } } }]
+      }
+    ]
+  };
+
+  test('Should send correct REST suggestions', async () => {
+    const server = createServer({
+      rest
+    });
+
+    const response = await request(server).get('/pstss');
+
+    expect(response.statusCode).toBe(404);
+    expect(response.body).toStrictEqual(
+      responseBody({ restRequestSuggestions: [{ path: '/posts', method: 'get' }] })
+    );
+  });
+
+  test('Should send correct REST suggestions with serverBaseUrl', async () => {
+    const server = createServer({
+      baseUrl: serverBaseUrl,
+      rest
+    });
+
+    const response = await request(server).get('/bas/dveloprs');
+
+    expect(response.statusCode).toBe(404);
+    expect(response.body).toStrictEqual(
+      responseBody({ restRequestSuggestions: [{ path: '/base/developers', method: 'post' }] })
+    );
+  });
+
+  test('Should send correct REST suggestions with restBaseUrl', async () => {
+    const server = createServer({
+      rest: {
+        ...rest,
+        baseUrl: restBaseUrl
+      }
+    });
+
+    const response = await request(server).get('/res/pstss');
+
+    expect(response.statusCode).toBe(404);
+    expect(response.body).toStrictEqual(
+      responseBody({ restRequestSuggestions: [{ path: '/rest/posts', method: 'get' }] })
+    );
+  });
+
+  test('Should send correct REST suggestions with serverBaseUrl and restBaseUrl', async () => {
+    const server = createServer({
+      baseUrl: serverBaseUrl,
+      rest: {
+        ...rest,
+        baseUrl: restBaseUrl
+      }
+    });
+
+    const response = await request(server).get('/bas/res/post');
+
+    expect(response.statusCode).toBe(404);
+    expect(response.body).toStrictEqual(
+      responseBody({ restRequestSuggestions: [{ path: '/base/rest/posts', method: 'get' }] })
+    );
+  });
+});
+
+describe('notFoundMiddleware: GraphQL', () => {
+  const serverBaseUrl: MockServerConfig['baseUrl'] = '/base';
+  const graphqlBaseUrl: BaseUrl = '/graphql';
+
+  const graphql: MockServerConfig['graphql'] = {
+    configs: [
+      {
+        operationName: 'GetPosts',
+        operationType: 'query',
+        routes: [{ data: {} }]
+      },
+      {
+        operationName: 'GetDevelopers',
+        operationType: 'mutation',
+        routes: [{ data: {} }]
+      }
+    ]
+  };
+
+  test('Should send correct GraphQL suggestions', async () => {
+    const server = createServer({
+      graphql
+    });
+
+    const response = await request(server).get('/?query=query getPost { posts }');
+
+    expect(response.statusCode).toBe(404);
+    expect(response.body).toStrictEqual(
+      responseBody({
+        graphqlRequestSuggestions: [{ operationName: ' GetPosts', operationType: 'query' }]
+      })
+    );
+  });
+
+  test('Should send correct GraphQL suggestions with serverBaseUrl', async () => {
+    const server = createServer({
+      baseUrl: serverBaseUrl,
+      graphql
+    });
+
+    const response = await request(server).get('/bse?query=query developers { posts }');
+
+    expect(response.statusCode).toBe(404);
+    expect(response.body).toStrictEqual(
+      responseBody({
+        graphqlRequestSuggestions: [
+          { operationName: '/base GetDevelopers', operationType: 'mutation' }
+        ]
+      })
+    );
+  });
+
+  test('Should send correct GraphQL suggestions with graphqlBaseUrl', async () => {
+    const server = createServer({
+      graphql: {
+        ...graphql,
+        baseUrl: graphqlBaseUrl
+      }
+    });
+
+    const response = await request(server).get('/graph?query=query posts { posts }');
+
+    expect(response.statusCode).toBe(404);
+    expect(response.body).toStrictEqual(
+      responseBody({
+        graphqlRequestSuggestions: [{ operationName: '/graphql GetPosts', operationType: 'query' }]
+      })
+    );
+  });
+
+  test('Should send correct GraphQL suggestions with serverBaseUrl and graphqlBaseUrl', async () => {
+    const server = createServer({
+      baseUrl: serverBaseUrl,
+      graphql: {
+        ...graphql,
+        baseUrl: graphqlBaseUrl
+      }
+    });
+
+    const response = await request(server).get('/bas/graphq?query=query posts { posts }');
+
+    expect(response.statusCode).toBe(404);
+    expect(response.body).toStrictEqual(
+      responseBody({
+        graphqlRequestSuggestions: [
+          { operationName: '/base/graphql GetPosts', operationType: 'query' }
+        ]
+      })
+    );
+  });
+});

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

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

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

@@ -5,8 +5,12 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.requestInterceptorMiddleware = void 0;
 var _helpers = require("../../../utils/helpers");
-const requestInterceptorMiddleware = (server, interceptor) => {
-  server.use((0, _helpers.asyncHandler)(async (request, _response, next) => {
+const requestInterceptorMiddleware = ({
+  server,
+  path = '*',
+  interceptor
+}) => {
+  server.use(path, (0, _helpers.asyncHandler)(async (request, _response, next) => {
     await (0, _helpers.callRequestInterceptor)({
       request,
       interceptor

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

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

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