mock-config-server 3.0.1 → 3.1.0

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

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

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

@@ -1,52 +1,57 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 exports.validateRestConfig = void 0;
-const helpers_1 = require("../../../src/utils/helpers");
-const validateBaseUrl_1 = require("../validateBaseUrl/validateBaseUrl");
-const validateInterceptors_1 = require("../validateInterceptors/validateInterceptors");
-const validateRoutes_1 = 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_1.validateRoutes)(config.routes, method);
-                (0, validateInterceptors_1.validateInterceptors)(config.interceptors);
-            }
-            catch (error) {
-                throw new Error(`configs[${index}].${error.message}`);
-            }
-        });
-        return;
-    }
-    throw new Error('configs');
+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_1.isPlainObject)(restConfig);
-    if (isRestConfigObject) {
-        try {
-            (0, validateBaseUrl_1.validateBaseUrl)(restConfig.baseUrl);
-            validateConfigs(restConfig.configs);
-        }
-        catch (error) {
-            throw new Error(`rest.${error.message}`);
-        }
-        return;
-    }
-    if (typeof restConfig !== 'undefined') {
-        throw new Error('rest');
+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;
+exports.validateRestConfig = validateRestConfig;

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

@@ -1,101 +1,108 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 exports.validateRoutes = void 0;
-const helpers_1 = require("../../../../src/utils/helpers");
-const helpers_2 = require("../../helpers");
-const validateInterceptors_1 = require("../../validateInterceptors/validateInterceptors");
+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']
+  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_1.convertToEntityDescriptor)(entity);
-    const isBody = entityName === 'body';
-    const isTopLevelDescriptor = (0, helpers_1.isEntityDescriptor)(entity);
-    if (isTopLevelDescriptor && isBody) {
-        if (!(0, helpers_2.isCheckModeValid)(topLevelCheckMode, 'body')) {
-            throw new Error('body.checkMode');
-        }
-        if (!(0, helpers_2.isDescriptorValueValid)(topLevelCheckMode, topLevelValue, 'body')) {
-            const errorMessage = 'body.value';
-            throw new Error(errorMessage);
-        }
+  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_1.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_1.convertToEntityDescriptor)(valueOrDescriptor);
-            if (!(0, helpers_2.isCheckModeValid)(checkMode)) {
-                throw new Error(`${entityName}.${key}.checkMode`);
-            }
-            const isDescriptor = (0, helpers_1.isEntityDescriptor)(valueOrDescriptor);
-            const errorMessage = `${entityName}.${key}${isDescriptor ? '.value' : ''}`;
-            const isValueArray = Array.isArray(value);
-            if (isValueArray && !isBody) {
-                value.forEach((element, index) => {
-                    if (!(0, helpers_2.isDescriptorValueValid)(checkMode, element)) {
-                        throw new Error(`${errorMessage}[${index}]`);
-                    }
-                });
-                return;
-            }
-            if (!(0, helpers_2.isDescriptorValueValid)(checkMode, 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;
-    }
-    throw new Error(entityName);
+      }
+      if (!(0, _helpers2.isDescriptorValueValid)(checkMode, value)) {
+        throw new Error(errorMessage);
+      }
+    });
+    return;
+  }
+  throw new Error(entityName);
 };
 const validateEntities = (entities, method) => {
-    const isEntitiesObject = (0, helpers_1.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 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_1.isPlainObject)(route);
-            if (isRouteObject) {
-                const isRouteHasDataProperty = 'data' in route;
-                if (!isRouteHasDataProperty) {
-                    throw new Error(`routes[${index}]`);
-                }
-                try {
-                    validateEntities(route.entities, method);
-                    (0, validateInterceptors_1.validateInterceptors)(route.interceptors);
-                }
-                catch (error) {
-                    throw new Error(`routes[${index}].${error.message}`);
-                }
-                return;
-            }
-            throw new Error(`routes[${index}]`);
-        });
+  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');
+      }
+      throw new Error(`routes[${index}]`);
+    });
+    return;
+  }
+  throw new Error('routes');
 };
-exports.validateRoutes = validateRoutes;
+exports.validateRoutes = validateRoutes;

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

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

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;