mock-config-server 3.0.1 → 3.1.1

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;

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

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createRewrittenDatabaseRoutes = void 0;
+var _expressUrlrewrite = _interopRequireDefault(require("express-urlrewrite"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const createRewrittenDatabaseRoutes = (router, rewrittenRoutes) => Object.entries(rewrittenRoutes).forEach(([key, value]) => {
+  router.use((0, _expressUrlrewrite.default)(key, value));
+});
+exports.createRewrittenDatabaseRoutes = createRewrittenDatabaseRoutes;

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

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

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

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createShallowDatabaseRoutes = void 0;
+const createShallowDatabaseRoutes = (router, database, storage) => {
+  Object.keys(database).forEach(key => {
+    const path = `/${key}`;
+    router.route(path).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(path).post((request, response) => {
+      storage.write(key, request.body);
+      response.set('Location', request.url);
+      response.status(201).json(request.body);
+    });
+    router.route(path).put((request, response) => {
+      storage.write(key, request.body);
+      response.json(request.body);
+    });
+    router.route(path).patch((request, response) => {
+      const currentResource = storage.read(key);
+      const updatedResource = {
+        ...currentResource,
+        ...request.body
+      };
+      storage.write(key, updatedResource);
+      response.json(updatedResource);
+    });
+  });
+  return router;
+};
+exports.createShallowDatabaseRoutes = createShallowDatabaseRoutes;

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

@@ -0,0 +1,5 @@
+export * from './array';
+export * from './createRewrittenDatabaseRoutes/createRewrittenDatabaseRoutes';
+export * from './createNestedDatabaseRoutes/createNestedDatabaseRoutes';
+export * from './createShallowDatabaseRoutes/createShallowDatabaseRoutes';
+export * from './splitDatabaseByNesting/splitDatabaseByNesting';

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

@@ -0,0 +1,60 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _array = require("./array");
+Object.keys(_array).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _array[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _array[key];
+    }
+  });
+});
+var _createRewrittenDatabaseRoutes = require("./createRewrittenDatabaseRoutes/createRewrittenDatabaseRoutes");
+Object.keys(_createRewrittenDatabaseRoutes).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _createRewrittenDatabaseRoutes[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _createRewrittenDatabaseRoutes[key];
+    }
+  });
+});
+var _createNestedDatabaseRoutes = require("./createNestedDatabaseRoutes/createNestedDatabaseRoutes");
+Object.keys(_createNestedDatabaseRoutes).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _createNestedDatabaseRoutes[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _createNestedDatabaseRoutes[key];
+    }
+  });
+});
+var _createShallowDatabaseRoutes = require("./createShallowDatabaseRoutes/createShallowDatabaseRoutes");
+Object.keys(_createShallowDatabaseRoutes).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _createShallowDatabaseRoutes[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _createShallowDatabaseRoutes[key];
+    }
+  });
+});
+var _splitDatabaseByNesting = require("./splitDatabaseByNesting/splitDatabaseByNesting");
+Object.keys(_splitDatabaseByNesting).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _splitDatabaseByNesting[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _splitDatabaseByNesting[key];
+    }
+  });
+});

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

@@ -0,0 +1,5 @@
+import type { DatabaseConfig, NestedDatabase, ShallowDatabase } from '../../../../../utils/types';
+export declare const splitDatabaseByNesting: (data: DatabaseConfig['data']) => {
+    shallowDatabase: ShallowDatabase;
+    nestedDatabase: NestedDatabase;
+};

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

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.splitDatabaseByNesting = void 0;
+var _helpers = require("../../../../../utils/helpers");
+const isAllArrayElementsHaveValidTypeId = array => array.every(element => (0, _helpers.isPlainObject)(element) && (typeof element.id === 'number' || typeof element.id === 'string'));
+const isAllArrayElementsHaveUniqueId = array => {
+  const uniqueIdsCount = new Set(array.map(({
+    id
+  }) => id)).size;
+  return array.length === uniqueIdsCount;
+};
+const splitDatabaseByNesting = data => {
+  const shallowDatabase = {};
+  const nestedDatabase = {};
+  Object.entries(data).forEach(([databaseEntityKey, databaseEntityValue]) => {
+    if (Array.isArray(databaseEntityValue) && isAllArrayElementsHaveValidTypeId(databaseEntityValue) && isAllArrayElementsHaveUniqueId(databaseEntityValue)) {
+      nestedDatabase[databaseEntityKey] = databaseEntityValue;
+      return;
+    }
+    shallowDatabase[databaseEntityKey] = databaseEntityValue;
+  });
+  return {
+    shallowDatabase,
+    nestedDatabase
+  };
+};
+exports.splitDatabaseByNesting = splitDatabaseByNesting;

package/dist/src/core/database/createDatabaseRoutes/storages/File/FileStorage.d.ts

@@ -0,0 +1,11 @@
+type Index = string | number;
+type Object = Record<Index, any>;
+export declare class FileStorage<T extends Object = Object> {
+    private readonly fileWriter;
+    private readonly data;
+    constructor(fileName: string);
+    read(key?: Index | Index[]): any;
+    write(key: Index | Index[], value: unknown): void;
+    delete(key: Index | Index[]): void;
+}
+export {};

package/dist/src/core/database/createDatabaseRoutes/storages/File/FileStorage.js

@@ -0,0 +1,64 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FileStorage = void 0;
+var _fs = _interopRequireDefault(require("fs"));
+var _path = _interopRequireDefault(require("path"));
+var _constants = require("../../../../../utils/constants");
+var _helpers = require("../../helpers");
+var _FileWriter = require("./FileWriter");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+class FileStorage {
+  constructor(fileName) {
+    _defineProperty(this, "fileWriter", void 0);
+    _defineProperty(this, "data", void 0);
+    const filePath = _path.default.resolve(_constants.APP_PATH, fileName);
+    this.fileWriter = new _FileWriter.FileWriter(filePath);
+    this.data = JSON.parse(_fs.default.readFileSync(filePath, 'utf-8'));
+  }
+  read(key) {
+    if (!key) return this.data;
+    const keys = Array.isArray(key) ? key : [key];
+    let readable = this.data;
+    for (const currentKey of keys) {
+      readable = readable[currentKey];
+    }
+    return readable;
+  }
+  write(key, value) {
+    const keys = Array.isArray(key) ? key : [key];
+    let writable = this.data;
+    let index = 0;
+    // ✅ important:
+    // stop iterate one element before end of keys for get access to writable object property
+    while (index < keys.length - 1) {
+      writable = writable[keys[index]];
+      index += 1;
+    }
+    writable[keys[index]] = value;
+    this.fileWriter.write(JSON.stringify(this.data));
+  }
+  delete(key) {
+    const keys = Array.isArray(key) ? key : [key];
+    let deletable = this.data;
+    let index = 0;
+    // ✅ important:
+    // stop iterate one element before end of key for get access to deletable object property
+    while (index < keys.length - 1) {
+      deletable = deletable[keys[index]];
+      index += 1;
+    }
+    if (Array.isArray(deletable) && (0, _helpers.isIndex)(keys[index])) {
+      deletable.splice(keys[index], 1);
+    } else {
+      delete deletable[keys[index]];
+    }
+    this.fileWriter.write(JSON.stringify(this.data));
+  }
+}
+exports.FileStorage = FileStorage;

package/dist/src/core/database/createDatabaseRoutes/storages/File/FileWriter.d.ts

@@ -0,0 +1,11 @@
+export declare class FileWriter {
+    private readonly filePath;
+    private nextData;
+    private nextDataPromise;
+    private nextDataResolve;
+    private writeIsLocked;
+    constructor(filePath: string);
+    private lockedWrite;
+    private unlockedWrite;
+    write(data: string): Promise<void>;
+}

package/dist/src/core/database/createDatabaseRoutes/storages/File/FileWriter.js

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FileWriter = void 0;
+var _fs = _interopRequireDefault(require("fs"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+class FileWriter {
+  constructor(filePath) {
+    _defineProperty(this, "filePath", void 0);
+    _defineProperty(this, "nextData", null);
+    _defineProperty(this, "nextDataPromise", null);
+    _defineProperty(this, "nextDataResolve", null);
+    _defineProperty(this, "writeIsLocked", false);
+    this.filePath = filePath;
+  }
+  lockedWrite(data) {
+    var _this$nextDataPromise;
+    this.nextData = data;
+    this.nextDataPromise = (_this$nextDataPromise = this.nextDataPromise) !== null && _this$nextDataPromise !== void 0 ? _this$nextDataPromise : new Promise(resolve => {
+      this.nextDataResolve = resolve;
+    });
+    return new Promise(resolve => {
+      var _this$nextDataPromise2;
+      (_this$nextDataPromise2 = this.nextDataPromise) === null || _this$nextDataPromise2 === void 0 ? void 0 : _this$nextDataPromise2.then(() => {
+        resolve();
+      });
+    });
+  }
+  async unlockedWrite(data, recursionLevel = 0) {
+    this.writeIsLocked = true;
+    await _fs.default.promises.writeFile(this.filePath, data, 'utf-8');
+    this.writeIsLocked = false;
+
+    // ✅ important:
+    // copy content of this.nextData into new variable
+    // for avoid infinite recursion of 'unlockedWrite'
+    const passedData = this.nextData;
+    this.nextData = null;
+    if (passedData) {
+      await this.unlockedWrite(passedData, recursionLevel + 1);
+      if (recursionLevel === 0) {
+        var _this$nextDataResolve;
+        (_this$nextDataResolve = this.nextDataResolve) === null || _this$nextDataResolve === void 0 ? void 0 : _this$nextDataResolve.call(this);
+        this.nextDataPromise = null;
+        this.nextDataResolve = null;
+      }
+    }
+  }
+  write(data) {
+    return this.writeIsLocked ? this.lockedWrite(data) : this.unlockedWrite(data);
+  }
+}
+exports.FileWriter = FileWriter;

package/dist/src/core/database/createDatabaseRoutes/storages/Memory/MemoryStorage.d.ts

@@ -0,0 +1,10 @@
+type Index = string | number;
+type Object = Record<Index, any>;
+export declare class MemoryStorage<T extends Object = Object> {
+    private readonly data;
+    constructor(initialData: T);
+    read(key?: Index | Index[]): any;
+    write(key: Index | Index[], value: unknown): void;
+    delete(key: Index | Index[]): void;
+}
+export {};

package/dist/src/core/database/createDatabaseRoutes/storages/Memory/MemoryStorage.js

@@ -0,0 +1,54 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MemoryStorage = void 0;
+var _helpers = require("../../helpers");
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+class MemoryStorage {
+  constructor(initialData) {
+    _defineProperty(this, "data", void 0);
+    this.data = initialData;
+  }
+  read(key) {
+    if (!key) return this.data;
+    const keys = Array.isArray(key) ? key : [key];
+    let readable = this.data;
+    for (const currentKey of keys) {
+      readable = readable[currentKey];
+    }
+    return readable;
+  }
+  write(key, value) {
+    const keys = Array.isArray(key) ? key : [key];
+    let writable = this.data;
+    let index = 0;
+    // ✅ important:
+    // stop iterate one element before end of keys for get access to writable object property
+    while (index < keys.length - 1) {
+      writable = writable[keys[index]];
+      index += 1;
+    }
+    writable[keys[index]] = value;
+  }
+  delete(key) {
+    const keys = Array.isArray(key) ? key : [key];
+    let deletable = this.data;
+    let index = 0;
+    // ✅ important:
+    // stop iterate one element before end of key for get access to deletable object property
+    while (index < keys.length - 1) {
+      deletable = deletable[keys[index]];
+      index += 1;
+    }
+    if (Array.isArray(deletable) && (0, _helpers.isIndex)(keys[index])) {
+      deletable.splice(keys[index], 1);
+      return;
+    }
+    delete deletable[keys[index]];
+  }
+}
+exports.MemoryStorage = MemoryStorage;

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

@@ -0,0 +1,2 @@
+export * from './File/FileStorage';
+export * from './Memory/MemoryStorage';

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

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _FileStorage = require("./File/FileStorage");
+Object.keys(_FileStorage).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _FileStorage[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _FileStorage[key];
+    }
+  });
+});
+var _MemoryStorage = require("./Memory/MemoryStorage");
+Object.keys(_MemoryStorage).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _MemoryStorage[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _MemoryStorage[key];
+    }
+  });
+});

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

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

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

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