mock-config-server 3.0.0 → 3.1.0

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

@@ -0,0 +1,104 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.validateRoutes = void 0;
+var _helpers = require("../../../../src/utils/helpers");
+var _helpers2 = require("../../helpers");
+var _validateInterceptors = require("../../validateInterceptors/validateInterceptors");
+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')) {
+      throw new Error('variables.checkMode');
+    }
+    if (!(0, _helpers2.isDescriptorValueValid)(topLevelCheckMode, topLevelValue, 'variables')) {
+      const errorMessage = 'variables.value';
+      throw new Error(errorMessage);
+    }
+  }
+  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 {
+        checkMode,
+        value
+      } = (0, _helpers.convertToEntityDescriptor)(valueOrDescriptor);
+      if (!(0, _helpers2.isCheckModeValid)(checkMode)) {
+        throw new Error(`${entityName}.${key}.checkMode`);
+      }
+      const isDescriptor = (0, _helpers.isEntityDescriptor)(valueOrDescriptor);
+      const errorMessage = `${entityName}.${key}${isDescriptor ? '.value' : ''}`;
+      const isValueArray = Array.isArray(value);
+      if (isValueArray && !isVariables) {
+        value.forEach((element, index) => {
+          if (!(0, _helpers2.isDescriptorValueValid)(checkMode, element)) {
+            throw new Error(`${errorMessage}[${index}]`);
+          }
+        });
+        return;
+      }
+      if (!(0, _helpers2.isDescriptorValueValid)(checkMode, value)) {
+        throw new Error(errorMessage);
+      }
+    });
+    return;
+  }
+  throw new Error(entityName);
+};
+const validateEntities = (entities, operationType) => {
+  const isEntitiesObject = (0, _helpers.isPlainObject)(entities);
+  if (isEntitiesObject) {
+    Object.keys(entities).forEach(entityName => {
+      const isEntityAllowed = ALLOWED_ENTITIES_BY_OPERATION_TYPE[operationType].includes(entityName);
+      if (!isEntityAllowed) {
+        throw new Error(`entities.${entityName}`);
+      }
+      try {
+        validateEntity(entities[entityName], entityName);
+      } catch (error) {
+        throw new Error(`entities.${error.message}`);
+      }
+    });
+    return;
+  }
+  if (typeof entities !== 'undefined') {
+    throw new Error('entities');
+  }
+};
+const validateRoutes = (routes, operationType) => {
+  const isRoutesArray = Array.isArray(routes);
+  if (isRoutesArray) {
+    routes.forEach((route, index) => {
+      const isRouteObject = (0, _helpers.isPlainObject)(route);
+      if (isRouteObject) {
+        const isRouteHasDataProperty = ('data' in route);
+        if (!isRouteHasDataProperty) {
+          throw new Error(`routes[${index}]`);
+        }
+        try {
+          validateEntities(route.entities, operationType);
+          (0, _validateInterceptors.validateInterceptors)(route.interceptors);
+        } catch (error) {
+          throw new Error(`routes[${index}].${error.message}`);
+        }
+        return;
+      }
+      throw new Error(`routes[${index}]`);
+    });
+    return;
+  }
+  throw new Error('routes');
+};
+exports.validateRoutes = validateRoutes;

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

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

package/dist/bin/validateMockServerConfig/validateInterceptors/validateInterceptors.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.validateInterceptors = void 0;
+var _helpers = require("../../../src/utils/helpers");
+const validateInterceptors = interceptors => {
+  const isInterceptorsObject = (0, _helpers.isPlainObject)(interceptors);
+  if (isInterceptorsObject) {
+    const {
+      request,
+      response
+    } = interceptors;
+    if (typeof request !== 'function' && typeof request !== 'undefined') {
+      throw new Error('interceptors.request');
+    }
+    if (typeof response !== 'function' && typeof response !== 'undefined') {
+      throw new Error('interceptors.response');
+    }
+    return;
+  }
+  if (typeof interceptors !== 'undefined') {
+    throw new Error('interceptors');
+  }
+};
+exports.validateInterceptors = validateInterceptors;

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

@@ -0,0 +1,2 @@
+import type { PlainObject } from '../../src';
+export declare const validateMockServerConfig: (mockServerConfig: PlainObject) => void;

package/dist/bin/validateMockServerConfig/validateMockServerConfig.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.validateMockServerConfig = void 0;
+var _validateBaseUrl = require("./validateBaseUrl/validateBaseUrl");
+var _validateCors = require("./validateCors/validateCors");
+var _validateDatabaseConfig = require("./validateDatabaseConfig/validateDatabaseConfig");
+var _validateGraphqlConfig = require("./validateGraphqlConfig/validateGraphqlConfig");
+var _validateInterceptors = require("./validateInterceptors/validateInterceptors");
+var _validatePort = require("./validatePort/validatePort");
+var _validateRestConfig = require("./validateRestConfig/validateRestConfig");
+var _validateStaticPath = require("./validateStaticPath/validateStaticPath");
+const validateMockServerConfig = mockServerConfig => {
+  if (!mockServerConfig.rest && !mockServerConfig.graphql && !mockServerConfig.database) {
+    throw new Error('configuration should contain at least one of these configs: rest | graphql | database; see our doc (https://www.npmjs.com/package/mock-config-server) for more information');
+  }
+  try {
+    if (mockServerConfig.rest) (0, _validateRestConfig.validateRestConfig)(mockServerConfig.rest);
+    if (mockServerConfig.graphql) (0, _validateGraphqlConfig.validateGraphqlConfig)(mockServerConfig.graphql);
+    if (mockServerConfig.database) (0, _validateDatabaseConfig.validateDatabaseConfig)(mockServerConfig.database);
+    (0, _validateBaseUrl.validateBaseUrl)(mockServerConfig.baseUrl);
+    (0, _validatePort.validatePort)(mockServerConfig.port);
+    (0, _validateStaticPath.validateStaticPath)(mockServerConfig.staticPath);
+    (0, _validateInterceptors.validateInterceptors)(mockServerConfig.interceptors);
+    (0, _validateCors.validateCors)(mockServerConfig.cors);
+  } catch (error) {
+    throw new Error(`Validation Error: configuration.${error.message} does not match the API schema. Click here to see correct type: https://github.com/siberiacancode/mock-config-server`);
+  }
+};
+exports.validateMockServerConfig = validateMockServerConfig;

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

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

package/dist/bin/validateMockServerConfig/validatePort/validatePort.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.validatePort = void 0;
+const validatePort = port => {
+  if (typeof port !== 'number' && typeof port !== 'undefined') {
+    throw new Error('port');
+  }
+};
+exports.validatePort = validatePort;

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

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

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

@@ -0,0 +1,57 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.validateRestConfig = void 0;
+var _helpers = require("../../../src/utils/helpers");
+var _validateBaseUrl = require("../validateBaseUrl/validateBaseUrl");
+var _validateInterceptors = require("../validateInterceptors/validateInterceptors");
+var _validateRoutes = require("./validateRoutes/validateRoutes");
+const validateConfigs = configs => {
+  const isConfigsArray = Array.isArray(configs);
+  if (isConfigsArray) {
+    configs.forEach((config, index) => {
+      const {
+        path,
+        method
+      } = config;
+      const isPathStringWithLeadingSlash = typeof path === 'string' && path.startsWith('/');
+      if (!isPathStringWithLeadingSlash && !(path instanceof RegExp)) {
+        throw new Error(`configs[${index}].path`);
+      }
+
+      // ✅ important:
+      // compare without 'toLowerCase' because Express methods names is case-sensitive
+      const allowedMethods = ['get', 'post', 'delete', 'put', 'patch', 'options'];
+      const isMethodAllowed = typeof method === 'string' && allowedMethods.includes(method);
+      if (!isMethodAllowed) {
+        throw new Error(`configs[${index}].method`);
+      }
+      try {
+        (0, _validateRoutes.validateRoutes)(config.routes, method);
+        (0, _validateInterceptors.validateInterceptors)(config.interceptors);
+      } catch (error) {
+        throw new Error(`configs[${index}].${error.message}`);
+      }
+    });
+    return;
+  }
+  throw new Error('configs');
+};
+const validateRestConfig = restConfig => {
+  const isRestConfigObject = (0, _helpers.isPlainObject)(restConfig);
+  if (isRestConfigObject) {
+    try {
+      (0, _validateBaseUrl.validateBaseUrl)(restConfig.baseUrl);
+      validateConfigs(restConfig.configs);
+    } catch (error) {
+      throw new Error(`rest.${error.message}`);
+    }
+    return;
+  }
+  if (typeof restConfig !== 'undefined') {
+    throw new Error('rest');
+  }
+};
+exports.validateRestConfig = validateRestConfig;

package/dist/bin/validateMockServerConfig/validateRestConfig/validateRoutes/validateRoutes.d.ts

@@ -0,0 +1,2 @@
+import type { RestMethod } from '../../../../src/utils/types';
+export declare const validateRoutes: (routes: unknown, method: RestMethod) => void;

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

@@ -0,0 +1,108 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.validateRoutes = void 0;
+var _helpers = require("../../../../src/utils/helpers");
+var _helpers2 = require("../../helpers");
+var _validateInterceptors = require("../../validateInterceptors/validateInterceptors");
+const ALLOWED_ENTITIES_BY_METHOD = {
+  get: ['headers', 'cookies', 'query', 'params'],
+  delete: ['headers', 'cookies', 'query', 'params'],
+  post: ['headers', 'cookies', 'query', 'params', 'body'],
+  put: ['headers', 'cookies', 'query', 'params', 'body'],
+  patch: ['headers', 'cookies', 'query', 'params', 'body'],
+  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')) {
+      throw new Error('body.checkMode');
+    }
+    if (!(0, _helpers2.isDescriptorValueValid)(topLevelCheckMode, topLevelValue, 'body')) {
+      const errorMessage = 'body.value';
+      throw new Error(errorMessage);
+    }
+  }
+  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 {
+        checkMode,
+        value
+      } = (0, _helpers.convertToEntityDescriptor)(valueOrDescriptor);
+      if (!(0, _helpers2.isCheckModeValid)(checkMode)) {
+        throw new Error(`${entityName}.${key}.checkMode`);
+      }
+      const isDescriptor = (0, _helpers.isEntityDescriptor)(valueOrDescriptor);
+      const errorMessage = `${entityName}.${key}${isDescriptor ? '.value' : ''}`;
+      const isValueArray = Array.isArray(value);
+      if (isValueArray && !isBody) {
+        value.forEach((element, index) => {
+          if (!(0, _helpers2.isDescriptorValueValid)(checkMode, element)) {
+            throw new Error(`${errorMessage}[${index}]`);
+          }
+        });
+        return;
+      }
+      if (!(0, _helpers2.isDescriptorValueValid)(checkMode, value)) {
+        throw new Error(errorMessage);
+      }
+    });
+    return;
+  }
+  throw new Error(entityName);
+};
+const validateEntities = (entities, method) => {
+  const isEntitiesObject = (0, _helpers.isPlainObject)(entities);
+  if (isEntitiesObject) {
+    Object.keys(entities).forEach(entityName => {
+      const isEntityAllowed = ALLOWED_ENTITIES_BY_METHOD[method].includes(entityName);
+      if (!isEntityAllowed) {
+        throw new Error(`entities.${entityName}`);
+      }
+      try {
+        validateEntity(entities[entityName], entityName);
+      } catch (error) {
+        throw new Error(`entities.${error.message}`);
+      }
+    });
+    return;
+  }
+  if (typeof entities !== 'undefined') {
+    throw new Error('entities');
+  }
+};
+const validateRoutes = (routes, method) => {
+  const isRoutesArray = Array.isArray(routes);
+  if (isRoutesArray) {
+    routes.forEach((route, index) => {
+      const isRouteObject = (0, _helpers.isPlainObject)(route);
+      if (isRouteObject) {
+        const isRouteHasDataProperty = ('data' in route);
+        if (!isRouteHasDataProperty) {
+          throw new Error(`routes[${index}]`);
+        }
+        try {
+          validateEntities(route.entities, method);
+          (0, _validateInterceptors.validateInterceptors)(route.interceptors);
+        } catch (error) {
+          throw new Error(`routes[${index}].${error.message}`);
+        }
+        return;
+      }
+      throw new Error(`routes[${index}]`);
+    });
+    return;
+  }
+  throw new Error('routes');
+};
+exports.validateRoutes = validateRoutes;

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

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

package/dist/bin/validateMockServerConfig/validateStaticPath/validateStaticPath.js

@@ -0,0 +1,53 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.validateStaticPath = void 0;
+var _helpers = require("../../../src/utils/helpers");
+const validateStaticPath = staticPath => {
+  const isStaticPathArray = Array.isArray(staticPath);
+  if (isStaticPathArray) {
+    staticPath.forEach((staticPathElement, index) => {
+      const isStaticPathElementObject = (0, _helpers.isPlainObject)(staticPathElement);
+      if (isStaticPathElementObject) {
+        const {
+          prefix,
+          path
+        } = staticPathElement;
+        if (typeof prefix !== 'string' || !prefix.startsWith('/')) {
+          throw new Error(`staticPath[${index}].prefix`);
+        }
+        if (typeof path !== 'string' || !path.startsWith('/')) {
+          throw new Error(`staticPath[${index}].path`);
+        }
+        return;
+      }
+      if (typeof staticPathElement !== 'string' || !staticPathElement.startsWith('/')) {
+        throw new Error(`staticPath[${index}]`);
+      }
+    });
+    return;
+  }
+  const isStaticPathObject = (0, _helpers.isPlainObject)(staticPath);
+  if (isStaticPathObject) {
+    const {
+      prefix,
+      path
+    } = staticPath;
+    if (typeof prefix !== 'string' || !prefix.startsWith('/')) {
+      throw new Error('staticPath.prefix');
+    }
+    if (typeof path !== 'string' || !path.startsWith('/')) {
+      throw new Error('staticPath.path');
+    }
+    return;
+  }
+  if (typeof staticPath !== 'string' && typeof staticPath !== 'undefined') {
+    throw new Error('staticPath');
+  }
+  if (typeof staticPath === 'string' && !staticPath.startsWith('/')) {
+    throw new Error('staticPath');
+  }
+};
+exports.validateStaticPath = validateStaticPath;

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from './src';

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

@@ -0,0 +1,3 @@
+import type { IRouter } from 'express';
+import type { DatabaseConfig } from '../../../utils/types';
+export declare const createDatabaseRoutes: (router: IRouter, { data, routes }: DatabaseConfig) => IRouter;

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

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createDatabaseRoutes = void 0;
+var _helpers = require("./helpers");
+var _storages = require("./storages");
+const isVariableJsonFile = variable => typeof variable === 'string' && variable.endsWith('.json');
+const createDatabaseRoutes = (router, {
+  data,
+  routes
+}) => {
+  if (routes) {
+    const storage = isVariableJsonFile(routes) ? new _storages.FileStorage(routes) : new _storages.MemoryStorage(routes);
+    (0, _helpers.createRewrittenDatabaseRoutes)(router, storage.read());
+    router.route('/__routes').get((_request, response) => {
+      response.json(storage.read());
+    });
+  }
+  const storage = isVariableJsonFile(data) ? new _storages.FileStorage(data) : new _storages.MemoryStorage(data);
+  const {
+    shallowDatabase,
+    nestedDatabase
+  } = (0, _helpers.splitDatabaseByNesting)(storage.read());
+  (0, _helpers.createShallowDatabaseRoutes)(router, shallowDatabase, storage);
+  (0, _helpers.createNestedDatabaseRoutes)(router, nestedDatabase, storage);
+  router.route('/__db').get((_request, response) => {
+    response.json(storage.read());
+  });
+  return router;
+};
+exports.createDatabaseRoutes = createDatabaseRoutes;

package/dist/src/core/database/createDatabaseRoutes/helpers/array/createNewId/createNewId.d.ts

@@ -0,0 +1,4 @@
+import type { NestedDatabaseId } from '../../../../../../utils/types';
+export declare const createNewId: (array: {
+    id: NestedDatabaseId;
+}[]) => number;

package/dist/src/core/database/createDatabaseRoutes/helpers/array/createNewId/createNewId.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createNewId = void 0;
+const createNewId = array => {
+  let maxId = -1;
+  for (let i = 0; i < array.length; i += 1) {
+    if (typeof array[i].id === 'number' && array[i].id > maxId) {
+      maxId = array[i].id;
+    }
+  }
+  return maxId + 1;
+};
+exports.createNewId = createNewId;

package/dist/src/core/database/createDatabaseRoutes/helpers/array/findIndexById/findIndexById.d.ts

@@ -0,0 +1,4 @@
+import type { NestedDatabaseId } from '../../../../../../utils/types';
+export declare const findIndexById: (array: {
+    id: NestedDatabaseId;
+}[], id: NestedDatabaseId) => number;

package/dist/src/core/database/createDatabaseRoutes/helpers/array/findIndexById/findIndexById.js

@@ -0,0 +1,8 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.findIndexById = void 0;
+const findIndexById = (array, id) => array.findIndex(item => item.id.toString() === id.toString());
+exports.findIndexById = findIndexById;

package/dist/src/core/database/createDatabaseRoutes/helpers/array/index.d.ts

@@ -0,0 +1,3 @@
+export * from './createNewId/createNewId';
+export * from './findIndexById/findIndexById';
+export * from './isIndex/isIndex';

package/dist/src/core/database/createDatabaseRoutes/helpers/array/index.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _createNewId = require("./createNewId/createNewId");
+Object.keys(_createNewId).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _createNewId[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _createNewId[key];
+    }
+  });
+});
+var _findIndexById = require("./findIndexById/findIndexById");
+Object.keys(_findIndexById).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _findIndexById[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _findIndexById[key];
+    }
+  });
+});
+var _isIndex = require("./isIndex/isIndex");
+Object.keys(_isIndex).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _isIndex[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _isIndex[key];
+    }
+  });
+});

package/dist/src/core/database/createDatabaseRoutes/helpers/array/isIndex/isIndex.d.ts

@@ -0,0 +1 @@
+export declare const isIndex: (value: any) => value is number;

package/dist/src/core/database/createDatabaseRoutes/helpers/array/isIndex/isIndex.js

@@ -0,0 +1,8 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isIndex = void 0;
+const isIndex = value => Number.isInteger(value) && value >= 0;
+exports.isIndex = isIndex;

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

@@ -0,0 +1,4 @@
+import type { IRouter } from 'express';
+import type { NestedDatabase } from '../../../../../utils/types';
+import type { MemoryStorage } from '../../storages';
+export declare const createNestedDatabaseRoutes: (router: IRouter, database: NestedDatabase, storage: MemoryStorage<NestedDatabase>) => IRouter;

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

@@ -0,0 +1,88 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createNestedDatabaseRoutes = void 0;
+var _array = require("../array");
+const createNestedDatabaseRoutes = (router, database, storage) => {
+  Object.keys(database).forEach(key => {
+    const collectionPath = `/${key}`;
+    const itemPath = `/${key}/:id`;
+    router.route(collectionPath).get((_request, response) => {
+      // ✅ important:
+      // set 'Cache-Control' header for explicit browsers response revalidate
+      // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Cache-Control
+      response.set('Cache-control', 'max-age=0, must-revalidate');
+      response.json(storage.read(key));
+    });
+    router.route(collectionPath).post((request, response) => {
+      const collection = storage.read(key);
+      const newResourceId = (0, _array.createNewId)(collection);
+      const newResource = {
+        ...request.body,
+        id: newResourceId
+      };
+      storage.write([key, collection.length], newResource);
+      response.set('Location', `${request.url}/${newResourceId}`);
+      response.status(201).json(newResource);
+    });
+    router.route(itemPath).get((request, response) => {
+      const currentResourceCollection = storage.read(key);
+      const currentResourceIndex = (0, _array.findIndexById)(currentResourceCollection, request.params.id);
+      if (currentResourceIndex === -1) {
+        response.status(404).end();
+        return;
+      }
+
+      // ✅ important:
+      // set 'Cache-Control' header for explicit browsers response revalidate
+      // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Cache-Control
+      response.set('Cache-control', 'max-age=0, must-revalidate');
+      response.json(storage.read([key, currentResourceIndex]));
+    });
+    router.route(itemPath).put((request, response) => {
+      const currentResourceCollection = storage.read(key);
+      const currentResourceIndex = (0, _array.findIndexById)(currentResourceCollection, request.params.id);
+      if (currentResourceIndex === -1) {
+        response.status(404).end();
+        return;
+      }
+      const currentResource = storage.read([key, currentResourceIndex]);
+      const updatedResource = {
+        ...request.body,
+        id: currentResource.id
+      };
+      storage.write([key, currentResourceIndex], updatedResource);
+      response.json(updatedResource);
+    });
+    router.route(itemPath).patch((request, response) => {
+      const currentResourceCollection = storage.read(key);
+      const currentResourceIndex = (0, _array.findIndexById)(currentResourceCollection, request.params.id);
+      if (currentResourceIndex === -1) {
+        response.status(404).end();
+        return;
+      }
+      const currentResource = storage.read([key, currentResourceIndex]);
+      const updatedResource = {
+        ...currentResource,
+        ...request.body,
+        id: currentResource.id
+      };
+      storage.write([key, currentResourceIndex], updatedResource);
+      response.json(updatedResource);
+    });
+    router.route(itemPath).delete((request, response) => {
+      const currentResourceCollection = storage.read(key);
+      const currentResourceIndex = (0, _array.findIndexById)(currentResourceCollection, request.params.id);
+      if (currentResourceIndex === -1) {
+        response.status(404).end();
+        return;
+      }
+      storage.delete([key, currentResourceIndex]);
+      response.status(204).end();
+    });
+  });
+  return router;
+};
+exports.createNestedDatabaseRoutes = createNestedDatabaseRoutes;

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

@@ -0,0 +1,2 @@
+import type { IRouter } from 'express';
+export declare const createRewrittenDatabaseRoutes: (router: IRouter, rewrittenRoutes: Record<string, string>) => void;