mock-config-server 3.2.0 → 3.3.0

package/README.md

@@ -73,7 +73,7 @@ $ npx mock-config-server
   - `baseUrl?` {string} part of the url that will be substituted at the beginning of graphql request url (default: `'/'`)
   - `configs` {Array<GraphQLRequestConfig>} configs for mock requests, [read](#configs)
   - `interceptors?` {Interceptors} functions to change request or response parameters, [read](#interceptors)
-- `database?` Database config for mock requests [read](#Database)
+- `database?` Database config for mock requests [read](#database)
   - `data` {Object | string} initial data for database
   - `routes?` {Object | string} map of custom routes for database
 - `staticPath?` {StaticPath} entity for working with static files, [read](#static-path)
@@ -99,13 +99,16 @@ Configs are the fundamental part of the mock server. These configs are easy to f
 ##### GraphQL request config
 
 - `operationType` {query | mutation} graphql operation type
-- `operationName` {string} graphql operation name
+- `operationName?` {string | RegExp} graphql operation name
+- `query?`: {string} graphql query as string
 - `routes` {GraphQLRouteConfig[]} request routes
   - `data` {any} mock data of request
   - `entities?` Object<headers | cookies | query | variables> object that helps in data retrieval
   - `interceptors?` {Interceptors} functions to change request or response parameters, [read](#interceptors)
 - `interceptors?` {Interceptors} functions to change request or response parameters, [read](#interceptors)
 
+> Every graphql config should contain `operationName` or `query` or both of them
+
 ##### Rest example
 
 ```javascript
@@ -270,6 +273,35 @@ const mockServerConfig = {
 module.exports = mockServerConfig;
 ```
 
+Also you can use array as value for REST body and GraphQL variables entities: in this case mock-config-server will iterate
+over array until `checkMode=equals` finds a match or return 404
+
+```javascript
+/** @type {import('mock-config-server').MockServerConfig} */
+const mockServerConfig = {
+  rest: {
+    baseUrl: '/api',
+    configs: [
+      {
+        path: '/user',
+        method: 'post',
+        routes: [
+          {
+            entities: {
+              // if body equals to { key1: 'value1' } or ['value1'] then mock-config-server return data
+              body: [{ key1: 'value1' }, ['value1']]
+            },
+            data: 'Some user data'
+          }
+        ]
+      }
+    ]
+  }
+};
+
+module.exports = mockServerConfig;
+```
+
 `function checkMode` is the most powerful way to describe your `entities` logic, but in most cases you will be fine using other `checkModes`.
 
 `Function value` has the following signature `(actualValue, checkFunction) => boolean`.
@@ -381,6 +413,66 @@ const mockServerConfig = {
 module.exports = mockServerConfig;
 ```
 
+#### Polling
+
+Routes support polling for data. To add polling for data, you must specify the `polling setting` and change `data` property to `queue`.
+
+> After receiving the last value from polling, the queue is reset and the next request will return the first value from the queue.
+
+```javascript
+/** @type {import('mock-config-server').MockServerConfig} */
+const mockServerConfig = {
+  rest: {
+    baseUrl: '/api',
+    configs: [
+      {
+        path: '/user',
+        method: 'get',
+        routes: [
+          {
+            settings: { polling: true },
+            queue: [
+              { data: { emoji: '🦁', name: 'Nursultan' } },
+              { data: { emoji: '☄', name: 'Dmitriy' } }
+            ]
+          }
+        ]
+      }
+    ]
+  }
+};
+
+export default mockServerConfig;
+```
+
+Using the additional `time` properties in milliseconds, you can specify how much time certain data should be returned
+
+```javascript
+/** @type {import('mock-config-server').MockServerConfig} */
+const mockServerConfig = {
+  rest: {
+    baseUrl: '/api',
+    configs: [
+      {
+        path: '/user',
+        method: 'get',
+        routes: [
+          {
+            settings: { polling: true },
+            queue: [
+              { time: 5000, data: { emoji: '🦁', name: 'Nursultan' } },
+              { data: { emoji: '☄', name: 'Dmitriy' } }
+            ]
+          }
+        ]
+      }
+    ]
+  }
+};
+
+export default mockServerConfig;
+```
+
 #### Static Path
 
 Entity for connecting statics to the server, like HTML, JSON, PNG, etc.
@@ -547,6 +639,64 @@ GET /users?id=1&id=2
 GET /users?author.name=siberiacancode
 ```
 
+### Pagination
+
+> Use \_page and optionally \_limit to paginate returned data.
+
+```
+GET /users?_page=1
+GET /users?_page=1&_limit=5
+```
+
+> **\_limit** is 10 by default
+
+The returned data has the format:
+
+```
+{
+  _link: Link,
+  results: Data[]
+}
+```
+
+In the **Link** header you'll get **count**, **pages**, **next** and **prev** links.
+
+#### Link
+
+- `count` {number} total count of elements
+- `pages` {number} count of pages
+- `next` {string | null} query string for next link
+- `prev` {string | null} query string for prev link
+
+### Sort
+
+> Use \_sort and \_order, use . to access deep properties
+
+```
+GET /users?_sort=name
+GET /users/1/transfers?_sort=id&_order=asc
+GET /users?_sort=address.city&_order=desc
+```
+
+> **\_order** is 'asc' by default
+
+For multiple fields:
+
+```
+GET /users?_sort=id&_order=desc&_sort=name&_order=asc
+```
+
+### Slice
+
+> X-Total-Count header is included in the response
+
+```
+GET /users?_begin=20
+GET /users?_begin=20&_end=30
+```
+
+Works exactly as [slice](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice), \_begin and \_end are optional
+
 ### File example
 
 ```javascript
@@ -601,7 +751,7 @@ Examples:
             <br />
             <sub style="font-size:13px"><b>👹 MiaInturi</b></sub>
         </a>
-    </td> 
+    </td>
       <td align="center" style="word-wrap: break-word; width: 100.0; height: 100.0">
         <a href="https://github.com/RiceWithMeat">
             <img src="https://avatars.githubusercontent.com/u/47690223?v=4"

package/dist/bin/validateMockServerConfig/helpers/isDescriptorValueValid/isDescriptorValueValid.d.ts

@@ -1 +1,2 @@
-export declare const isDescriptorValueValid: (checkMode: unknown, value: unknown, entityName?: unknown) => boolean;
+import type { CheckMode } from '../../../../src/utils/types';
+export declare const isDescriptorValueValid: (checkMode: CheckMode, value: unknown) => boolean | undefined;

package/dist/bin/validateMockServerConfig/helpers/isDescriptorValueValid/isDescriptorValueValid.js

@@ -5,16 +5,39 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.isDescriptorValueValid = void 0;
 var _constants = require("../../../../src/utils/constants");
-const isDescriptorValueValid = (checkMode, value, entityName) => {
-  if (_constants.CHECK_ACTUAL_VALUE_CHECK_MODES.includes(checkMode)) return typeof value === 'undefined';
-  if (_constants.COMPARE_WITH_DESCRIPTOR_VALUE_CHECK_MODES.includes(checkMode)) {
-    if (entityName === 'body' || entityName === 'variables') {
-      return typeof value === 'object' && value !== null && typeof value !== 'function' && !(value instanceof RegExp);
+var _helpers = require("../../../../src/utils/helpers");
+// ✅ important:
+// should validate all properties over nesting
+const isObjectOrArrayValid = value => {
+  if (typeof value === 'boolean' || typeof value === 'number' || typeof value === 'string' || value === null) {
+    return true;
+  }
+  if (Array.isArray(value)) {
+    return value.every(isObjectOrArrayValid);
+  }
+  if ((0, _helpers.isPlainObject)(value)) {
+    for (const key in value) {
+      if (!isObjectOrArrayValid(value[key])) {
+        return false;
+      }
     }
+    return true;
+  }
+  return false;
+};
+const isDescriptorValueValid = (checkMode, value) => {
+  if (_constants.CHECK_ACTUAL_VALUE_CHECK_MODES.includes(checkMode)) {
+    return typeof value === 'undefined';
+  }
+  if (_constants.COMPARE_WITH_DESCRIPTOR_ANY_VALUE_CHECK_MODES.includes(checkMode)) {
+    const isValueObjectOrArray = (0, _helpers.isPlainObject)(value) || Array.isArray(value);
+    if (isValueObjectOrArray) return isObjectOrArrayValid(value);
+    return typeof value === 'boolean' || typeof value === 'number' || typeof value === 'string' || value === null;
+  }
+  if (_constants.COMPARE_WITH_DESCRIPTOR_STRING_VALUE_CHECK_MODES.includes(checkMode)) {
     return typeof value === 'boolean' || typeof value === 'number' || typeof value === 'string';
   }
-  if (checkMode === 'function') return typeof value === 'function';
+  if (checkMode === 'function') return typeof value === 'function' && value.length <= 2;
   if (checkMode === 'regExp') return value instanceof RegExp;
-  throw new Error('Invalid checkMode');
 };
 exports.isDescriptorValueValid = isDescriptorValueValid;

package/dist/bin/validateMockServerConfig/validateGraphqlConfig/validateGraphqlConfig.js

@@ -14,15 +14,21 @@ const validateConfigs = configs => {
     configs.forEach((config, index) => {
       const {
         operationType,
-        operationName
+        operationName,
+        query
       } = config;
+      if (typeof operationName === 'undefined' && typeof query === 'undefined') {
+        throw new Error(`configs[${index}]`);
+      }
       if (operationType !== 'query' && operationType !== 'mutation') {
         throw new Error(`configs[${index}].operationType`);
       }
-      const isOperationNameStringOrRegExp = typeof operationName === 'string' || operationName instanceof RegExp;
-      if (!isOperationNameStringOrRegExp) {
+      if (typeof operationName !== 'undefined' && typeof operationName !== 'string' && !(operationName instanceof RegExp)) {
         throw new Error(`configs[${index}].operationName`);
       }
+      if (typeof query !== 'undefined' && typeof query !== 'string') {
+        throw new Error(`configs[${index}].query`);
+      }
       try {
         (0, _validateRoutes.validateRoutes)(config.routes, operationType);
         (0, _validateInterceptors.validateInterceptors)(config.interceptors);

package/dist/bin/validateMockServerConfig/validateGraphqlConfig/validateRoutes/validateRoutes.js

@@ -7,30 +7,44 @@ exports.validateRoutes = void 0;
 var _helpers = require("../../../../src/utils/helpers");
 var _helpers2 = require("../../helpers");
 var _validateInterceptors = require("../../validateInterceptors/validateInterceptors");
+var _validateQueue = require("../../validateQueue/validateQueue");
+var _validateSettings = require("../../validateSettings/validateSettings");
 const ALLOWED_ENTITIES_BY_OPERATION_TYPE = {
   query: ['headers', 'cookies', 'query', 'variables'],
   mutation: ['headers', 'cookies', 'query', 'variables']
 };
 const validateEntity = (entity, entityName) => {
-  const {
-    checkMode: topLevelCheckMode,
-    value: topLevelValue
-  } = (0, _helpers.convertToEntityDescriptor)(entity);
   const isVariables = entityName === 'variables';
-  const isTopLevelDescriptor = (0, _helpers.isEntityDescriptor)(entity);
-  if (isTopLevelDescriptor && isVariables) {
-    if (!(0, _helpers2.isCheckModeValid)(topLevelCheckMode, 'variables')) {
+  const isEntityTopLevelDescriptor = (0, _helpers.isEntityDescriptor)(entity);
+  if (isEntityTopLevelDescriptor) {
+    if (!isVariables) {
+      throw new Error(entityName);
+    }
+    if (!(0, _helpers2.isCheckModeValid)(entity.checkMode, 'variables')) {
       throw new Error('variables.checkMode');
     }
-    if (!(0, _helpers2.isDescriptorValueValid)(topLevelCheckMode, topLevelValue, 'variables')) {
-      const errorMessage = 'variables.value';
-      throw new Error(errorMessage);
+    const isDescriptorValueObjectOrArray = (0, _helpers.isPlainObject)(entity.value) || Array.isArray(entity.value);
+    if (!isDescriptorValueObjectOrArray || !(0, _helpers2.isDescriptorValueValid)(entity.checkMode, entity.value)) {
+      throw new Error('variables.value');
+    }
+    return;
+  }
+  const isEntityArray = Array.isArray(entity);
+  if (isEntityArray) {
+    if (!isVariables) {
+      throw new Error(entityName);
     }
+    entity.forEach((entityElement, index) => {
+      const isEntityElementObjectOrArray = (0, _helpers.isPlainObject)(entityElement) || Array.isArray(entityElement);
+      if (!isEntityElementObjectOrArray || !(0, _helpers2.isDescriptorValueValid)('equals', entityElement)) {
+        throw new Error(`${entityName}[${index}]`);
+      }
+    });
+    return;
   }
-  const isEntityObject = (0, _helpers.isPlainObject)(entity) && !(entity instanceof RegExp);
-  const isEntityArray = Array.isArray(entity) && isVariables;
-  if (isEntityObject || isEntityArray) {
-    Object.entries(topLevelValue).forEach(([key, valueOrDescriptor]) => {
+  const isEntityObject = (0, _helpers.isPlainObject)(entity);
+  if (isEntityObject) {
+    Object.entries(entity).forEach(([key, valueOrDescriptor]) => {
       const {
         checkMode,
         value
@@ -41,15 +55,25 @@ const validateEntity = (entity, entityName) => {
       const isDescriptor = (0, _helpers.isEntityDescriptor)(valueOrDescriptor);
       const errorMessage = `${entityName}.${key}${isDescriptor ? '.value' : ''}`;
       const isValueArray = Array.isArray(value);
-      if (isValueArray && !isVariables) {
+      if (isValueArray) {
         value.forEach((element, index) => {
-          if (!(0, _helpers2.isDescriptorValueValid)(checkMode, element)) {
+          if (isVariables) {
+            if ((0, _helpers2.isDescriptorValueValid)(checkMode, element)) return;
+            throw new Error(`${errorMessage}[${index}]`);
+          }
+          const isElementObjectOrArray = (0, _helpers.isPlainObject)(element) || Array.isArray(element);
+          if (isElementObjectOrArray || !(0, _helpers2.isDescriptorValueValid)(checkMode, element)) {
             throw new Error(`${errorMessage}[${index}]`);
           }
         });
         return;
       }
-      if (!(0, _helpers2.isDescriptorValueValid)(checkMode, value)) {
+      if (isVariables) {
+        if ((0, _helpers2.isDescriptorValueValid)(checkMode, value)) return;
+        throw new Error(errorMessage);
+      }
+      const isValueObject = (0, _helpers.isPlainObject)(value);
+      if (isValueObject || !(0, _helpers2.isDescriptorValueValid)(checkMode, value)) {
         throw new Error(errorMessage);
       }
     });
@@ -84,10 +108,35 @@ const validateRoutes = (routes, operationType) => {
       const isRouteObject = (0, _helpers.isPlainObject)(route);
       if (isRouteObject) {
         const isRouteHasDataProperty = ('data' in route);
-        if (!isRouteHasDataProperty) {
+        const isRouteHasQueueProperty = ('queue' in route);
+        if (!isRouteHasDataProperty && !isRouteHasQueueProperty) {
+          throw new Error(`routes[${index}]`);
+        }
+        if (isRouteHasDataProperty && isRouteHasQueueProperty) {
           throw new Error(`routes[${index}]`);
         }
+        const {
+          settings
+        } = route;
+        const isRouteSettingsObject = (0, _helpers.isPlainObject)(settings);
+        if (isRouteHasQueueProperty) {
+          try {
+            (0, _validateQueue.validateQueue)(route.queue);
+            if (!isRouteSettingsObject) {
+              throw new Error('settings');
+            }
+            if (!(isRouteSettingsObject && settings !== null && settings !== void 0 && settings.polling)) {
+              throw new Error('settings.polling');
+            }
+          } catch (error) {
+            throw new Error(`routes[${index}].${error.message}`);
+          }
+        }
+        if (isRouteHasDataProperty && isRouteSettingsObject && settings !== null && settings !== void 0 && settings.polling) {
+          throw new Error(`routes[${index}].settings.polling`);
+        }
         try {
+          (0, _validateSettings.validateSettings)(route.settings);
           validateEntities(route.entities, operationType);
           (0, _validateInterceptors.validateInterceptors)(route.interceptors);
         } catch (error) {

package/dist/bin/validateMockServerConfig/validateQueue/validateQueue.d.ts

@@ -0,0 +1 @@
+export declare const validateQueue: (queue: unknown) => void;

package/dist/bin/validateMockServerConfig/validateQueue/validateQueue.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.validateQueue = void 0;
+var _helpers = require("../../../src/utils/helpers");
+const validateQueue = queue => {
+  const isQueueArray = Array.isArray(queue);
+  if (!isQueueArray) {
+    throw new Error('queue');
+  }
+  queue.forEach((queueElement, index) => {
+    const isQueueElementObject = (0, _helpers.isPlainObject)(queueElement);
+    if (isQueueElementObject) {
+      const isQueueElementDataProperty = ('data' in queueElement);
+      if (!isQueueElementDataProperty) {
+        throw new Error(`queue[${index}].data`);
+      }
+      const isQueueElementTimeProperty = ('time' in queueElement);
+      if (isQueueElementTimeProperty && typeof queueElement.time !== 'number') {
+        throw new Error(`queue[${index}].time`);
+      }
+      return;
+    }
+    throw new Error(`queue[${index}]`);
+  });
+};
+exports.validateQueue = validateQueue;

package/dist/bin/validateMockServerConfig/validateRestConfig/validateRoutes/validateRoutes.js

@@ -7,6 +7,8 @@ exports.validateRoutes = void 0;
 var _helpers = require("../../../../src/utils/helpers");
 var _helpers2 = require("../../helpers");
 var _validateInterceptors = require("../../validateInterceptors/validateInterceptors");
+var _validateQueue = require("../../validateQueue/validateQueue");
+var _validateSettings = require("../../validateSettings/validateSettings");
 const ALLOWED_ENTITIES_BY_METHOD = {
   get: ['headers', 'cookies', 'query', 'params'],
   delete: ['headers', 'cookies', 'query', 'params'],
@@ -16,25 +18,37 @@ const ALLOWED_ENTITIES_BY_METHOD = {
   options: ['headers', 'cookies', 'query', 'params']
 };
 const validateEntity = (entity, entityName) => {
-  const {
-    checkMode: topLevelCheckMode,
-    value: topLevelValue
-  } = (0, _helpers.convertToEntityDescriptor)(entity);
   const isBody = entityName === 'body';
-  const isTopLevelDescriptor = (0, _helpers.isEntityDescriptor)(entity);
-  if (isTopLevelDescriptor && isBody) {
-    if (!(0, _helpers2.isCheckModeValid)(topLevelCheckMode, 'body')) {
+  const isEntityTopLevelDescriptor = (0, _helpers.isEntityDescriptor)(entity);
+  if (isEntityTopLevelDescriptor) {
+    if (!isBody) {
+      throw new Error(entityName);
+    }
+    if (!(0, _helpers2.isCheckModeValid)(entity.checkMode, 'body')) {
       throw new Error('body.checkMode');
     }
-    if (!(0, _helpers2.isDescriptorValueValid)(topLevelCheckMode, topLevelValue, 'body')) {
-      const errorMessage = 'body.value';
-      throw new Error(errorMessage);
+    const isDescriptorValueObjectOrArray = (0, _helpers.isPlainObject)(entity.value) || Array.isArray(entity.value);
+    if (!isDescriptorValueObjectOrArray || !(0, _helpers2.isDescriptorValueValid)(entity.checkMode, entity.value)) {
+      throw new Error('body.value');
+    }
+    return;
+  }
+  const isEntityArray = Array.isArray(entity);
+  if (isEntityArray) {
+    if (!isBody) {
+      throw new Error(entityName);
     }
+    entity.forEach((entityElement, index) => {
+      const isEntityElementObjectOrArray = (0, _helpers.isPlainObject)(entityElement) || Array.isArray(entityElement);
+      if (!isEntityElementObjectOrArray || !(0, _helpers2.isDescriptorValueValid)('equals', entityElement)) {
+        throw new Error(`${entityName}[${index}]`);
+      }
+    });
+    return;
   }
-  const isEntityObject = (0, _helpers.isPlainObject)(entity) && !(entity instanceof RegExp);
-  const isEntityArray = Array.isArray(entity) && isBody;
-  if (isEntityObject || isEntityArray) {
-    Object.entries(topLevelValue).forEach(([key, valueOrDescriptor]) => {
+  const isEntityObject = (0, _helpers.isPlainObject)(entity);
+  if (isEntityObject) {
+    Object.entries(entity).forEach(([key, valueOrDescriptor]) => {
       const {
         checkMode,
         value
@@ -45,15 +59,25 @@ const validateEntity = (entity, entityName) => {
       const isDescriptor = (0, _helpers.isEntityDescriptor)(valueOrDescriptor);
       const errorMessage = `${entityName}.${key}${isDescriptor ? '.value' : ''}`;
       const isValueArray = Array.isArray(value);
-      if (isValueArray && !isBody) {
+      if (isValueArray) {
         value.forEach((element, index) => {
-          if (!(0, _helpers2.isDescriptorValueValid)(checkMode, element)) {
+          if (isBody) {
+            if ((0, _helpers2.isDescriptorValueValid)(checkMode, element)) return;
+            throw new Error(`${errorMessage}[${index}]`);
+          }
+          const isElementObjectOrArray = (0, _helpers.isPlainObject)(element) || Array.isArray(element);
+          if (isElementObjectOrArray || !(0, _helpers2.isDescriptorValueValid)(checkMode, element)) {
             throw new Error(`${errorMessage}[${index}]`);
           }
         });
         return;
       }
-      if (!(0, _helpers2.isDescriptorValueValid)(checkMode, value)) {
+      if (isBody) {
+        if ((0, _helpers2.isDescriptorValueValid)(checkMode, value)) return;
+        throw new Error(errorMessage);
+      }
+      const isValueObject = (0, _helpers.isPlainObject)(value);
+      if (isValueObject || !(0, _helpers2.isDescriptorValueValid)(checkMode, value)) {
         throw new Error(errorMessage);
       }
     });
@@ -88,10 +112,35 @@ const validateRoutes = (routes, method) => {
       const isRouteObject = (0, _helpers.isPlainObject)(route);
       if (isRouteObject) {
         const isRouteHasDataProperty = ('data' in route);
-        if (!isRouteHasDataProperty) {
+        const isRouteHasQueueProperty = ('queue' in route);
+        if (!isRouteHasDataProperty && !isRouteHasQueueProperty) {
+          throw new Error(`routes[${index}]`);
+        }
+        if (isRouteHasDataProperty && isRouteHasQueueProperty) {
           throw new Error(`routes[${index}]`);
         }
+        const {
+          settings
+        } = route;
+        const isRouteSettingsObject = (0, _helpers.isPlainObject)(settings);
+        if (isRouteHasQueueProperty) {
+          try {
+            (0, _validateQueue.validateQueue)(route.queue);
+            if (!isRouteSettingsObject) {
+              throw new Error('settings');
+            }
+            if (!(isRouteSettingsObject && settings !== null && settings !== void 0 && settings.polling)) {
+              throw new Error('settings.polling');
+            }
+          } catch (error) {
+            throw new Error(`routes[${index}].${error.message}`);
+          }
+        }
+        if (isRouteHasDataProperty && isRouteSettingsObject && settings !== null && settings !== void 0 && settings.polling) {
+          throw new Error(`routes[${index}].settings.polling`);
+        }
         try {
+          (0, _validateSettings.validateSettings)(route.settings);
           validateEntities(route.entities, method);
           (0, _validateInterceptors.validateInterceptors)(route.interceptors);
         } catch (error) {

package/dist/bin/validateMockServerConfig/validateSettings/validateSettings.d.ts

@@ -0,0 +1 @@
+export declare const validateSettings: (settings: unknown) => void;

package/dist/bin/validateMockServerConfig/validateSettings/validateSettings.js

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.validateSettings = void 0;
+var _helpers = require("../../../src/utils/helpers");
+const ALLOWED_SETTINGS = ['polling'];
+const validateSetting = (setting, settingName) => {
+  if (settingName === 'polling' && typeof setting !== 'boolean') {
+    throw new Error('polling');
+  }
+};
+const validateSettings = settings => {
+  const isSettingsObject = (0, _helpers.isPlainObject)(settings);
+  if (isSettingsObject) {
+    Object.keys(settings).forEach(settingName => {
+      const isSettingAllowed = ALLOWED_SETTINGS.includes(settingName);
+      if (!isSettingAllowed) {
+        throw new Error(`settings.${settingName}`);
+      }
+      try {
+        validateSetting(settings[settingName], settingName);
+      } catch (error) {
+        throw new Error(`settings.${error.message}`);
+      }
+    });
+    return;
+  }
+  if (typeof settings !== 'undefined') {
+    throw new Error('settings');
+  }
+};
+exports.validateSettings = validateSettings;

package/dist/src/core/database/createDatabaseRoutes/helpers/createNestedDatabaseRoutes/createNestedDatabaseRoutes.js

@@ -6,16 +6,59 @@ Object.defineProperty(exports, "__esModule", {
 exports.createNestedDatabaseRoutes = void 0;
 var _array = require("../array");
 var _filter = require("../filter/filter");
+var _pagination = require("../pagination/pagination");
+var _sort2 = require("../sort/sort");
 const createNestedDatabaseRoutes = (router, database, storage) => {
   Object.keys(database).forEach(key => {
     const collectionPath = `/${key}`;
     const itemPath = `/${key}/:id`;
     router.route(collectionPath).get((request, response) => {
+      var _request$query;
       let data = storage.read(key);
       if (request.query && Object.keys(request.query).length) {
-        data = (0, _filter.filter)(data, request.query);
+        const {
+          _page,
+          _limit,
+          _begin,
+          _end,
+          _sort,
+          _order,
+          ...filters
+        } = request.query;
+        data = (0, _filter.filter)(data, filters);
+      }
+      if ((_request$query = request.query) !== null && _request$query !== void 0 && _request$query._page) {
+        data = (0, _pagination.pagination)(data, request.query);
+        if (data._link) {
+          const links = {};
+          const fullUrl = `${request.protocol}://${request.get('host')}${request.originalUrl}`;
+          if (data._link.first) {
+            links.first = fullUrl.replace(`page=${data._link.current}`, `page=${data._link.first}`);
+          }
+          if (data._link.prev) {
+            links.prev = fullUrl.replace(`page=${data._link.current}`, `page=${data._link.prev}`);
+          }
+          if (data._link.next) {
+            links.next = fullUrl.replace(`page=${data._link.current}`, `page=${data._link.next}`);
+          }
+          if (data._link.last) {
+            links.last = fullUrl.replace(`page=${data._link.current}`, `page=${data._link.last}`);
+          }
+          data._link = {
+            ...data._link,
+            ...links
+          };
+          response.links(links);
+        }
+      }
+      if (request.query && request.query._sort) {
+        data = (0, _sort2.sort)(data, request.query);
+      }
+      if (request.query._begin || request.query._end) {
+        var _request$query$_begin;
+        data = data.slice((_request$query$_begin = request.query._begin) !== null && _request$query$_begin !== void 0 ? _request$query$_begin : 0, request.query._end);
+        response.set('X-Total-Count', data.length);
       }
-
       // ✅ important:
       // set 'Cache-Control' header for explicit browsers response revalidate
       // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Cache-Control

package/dist/src/core/database/createDatabaseRoutes/helpers/filter/filter.d.ts

@@ -1 +1,2 @@
-export declare const filter: (array: any[], filters: Record<string, string | string[]>) => any[];
+import type { ParsedUrlQuery } from 'node:querystring';
+export declare const filter: (array: any[], filters: ParsedUrlQuery) => any[];