mock-config-server 3.3.0 → 3.3.1

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

@@ -0,0 +1,3 @@
+/// <reference types="node" />
+import type { ParsedUrlQuery } from 'node:querystring';
+export declare const operators: (array: any[], query: ParsedUrlQuery) => void;

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

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.operators = void 0;
+// import { flatten } from 'flat';
+
+const OPERATORS = {
+  neq: (a, b) => a !== b,
+  gt: (a, b) => a > b,
+  gte: (a, b) => a >= b,
+  lt: (a, b) => a < b,
+  lte: (a, b) => a <= b,
+  in: (a, b) => b.includes(a),
+  nin: (a, b) => !b.includes(a),
+  cn: (a, b) => a.includes(b),
+  ncn: (a, b) => !a.includes(b),
+  sw: (a, b) => a.startsWith(b),
+  nsw: (a, b) => !a.startsWith(b),
+  ew: (a, b) => a.endsWith(b),
+  new: (a, b) => !a.endsWith(b),
+  rgx: (a, b) => new RegExp(b).test(a)
+};
+console.log('@', OPERATORS);
+const operators = (array, query) => {
+  const operators1 = Object.entries(query).map(([key, value]) => console.log('@', [key, value]));
+  console.log('@', array, operators1);
+};
+exports.operators = operators;

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

@@ -0,0 +1,3 @@
+import type { ParsedUrlQuery } from 'node:querystring';
+export declare const searchInNestedObjects: (obj: any, searchText: string) => boolean;
+export declare const search: (array: any[], searchText: ParsedUrlQuery) => any[];

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

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.searchInNestedObjects = exports.search = void 0;
+const searchInNestedObjects = (obj, searchText) => {
+  for (const key in obj) {
+    if (typeof obj[key] === 'object' && obj[key] !== null) {
+      if (searchInNestedObjects(obj[key], searchText)) {
+        return true;
+      }
+    } else if (typeof obj[key] === 'string' && obj[key].includes(searchText)) {
+      return true;
+    } else if (typeof obj[key] === 'number' && obj[key].toString().includes(searchText)) {
+      return true;
+    }
+  }
+  return false;
+};
+exports.searchInNestedObjects = searchInNestedObjects;
+const search = (array, searchText) => array.filter(element => {
+  if (typeof searchText === 'string') {
+    return searchInNestedObjects(element, searchText);
+  }
+  if (Array.isArray(searchText)) {
+    return searchText.some(text => searchInNestedObjects(element, text));
+  }
+  throw new Error('search technical error');
+});
+exports.search = search;

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

@@ -0,0 +1,25 @@
+import { splitDatabaseByNesting } from './splitDatabaseByNesting';
+
+describe('splitDatabaseByNesting', () => {
+  test('Should put in nested database only arrays of objects with unique id (string | number)', () => {
+    const databaseConfig = {
+      data: {
+        key: 'value',
+        arrayWithInvalidTypeIds: [{ id: 1 }, null],
+        arrayWithNotUniqueIds: [{ id: 1 }, { id: 1 }],
+        validArray: [{ id: 1 }, { id: 'string' }]
+      }
+    };
+
+    const { shallowDatabase, nestedDatabase } = splitDatabaseByNesting(databaseConfig.data);
+
+    expect(shallowDatabase).toStrictEqual({
+      key: databaseConfig.data.key,
+      arrayWithInvalidTypeIds: databaseConfig.data.arrayWithInvalidTypeIds,
+      arrayWithNotUniqueIds: databaseConfig.data.arrayWithNotUniqueIds
+    });
+    expect(nestedDatabase).toStrictEqual({
+      validArray: databaseConfig.data.validArray
+    });
+  });
+});

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

@@ -0,0 +1,156 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+
+import { FileStorage } from './FileStorage';
+import { FileWriter } from './FileWriter';
+
+jest.mock('./FileWriter');
+
+describe('FileStorage', () => {
+  const createInitialData = () => ({
+    john: { name: 'John Doe', age: 25 },
+    jane: { name: 'Jane Smith', age: 30 },
+    users: [{ id: 1 }, { id: 2 }]
+  });
+
+  describe('FileStorage: read', () => {
+    let tmpDirPath: string;
+    let initialData: ReturnType<typeof createInitialData>;
+    let fileStorage: FileStorage;
+
+    beforeAll(() => {
+      tmpDirPath = fs.mkdtempSync(os.tmpdir());
+      initialData = createInitialData();
+
+      const pathToFileStorage = path.join(tmpDirPath, './database.json');
+      fs.writeFileSync(pathToFileStorage, JSON.stringify(initialData));
+      fileStorage = new FileStorage(pathToFileStorage);
+    });
+
+    afterAll(() => {
+      fs.rmSync(tmpDirPath, { recursive: true, force: true });
+      jest.clearAllMocks();
+    });
+
+    test('Should return correct full data for read without keys', () => {
+      expect(fileStorage.read()).toStrictEqual(initialData);
+    });
+
+    test('Should return correct data for read with valid single key', () => {
+      expect(fileStorage.read('john')).toStrictEqual(initialData.john);
+    });
+
+    test('Should return correct data for read with valid array key', () => {
+      expect(fileStorage.read(['john', 'name'])).toStrictEqual(initialData.john.name);
+    });
+  });
+
+  describe('FileStorage: write', () => {
+    let tmpDirPath: string;
+    let initialData: ReturnType<typeof createInitialData>;
+    let fileStorage: FileStorage;
+
+    beforeEach(() => {
+      tmpDirPath = fs.mkdtempSync(os.tmpdir());
+      initialData = createInitialData();
+
+      const pathToFileStorage = path.join(tmpDirPath, './database.json');
+      fs.writeFileSync(pathToFileStorage, JSON.stringify(initialData));
+      fileStorage = new FileStorage(pathToFileStorage);
+    });
+
+    afterEach(() => {
+      fs.rmSync(tmpDirPath, { recursive: true, force: true });
+      jest.clearAllMocks();
+    });
+
+    test('Should update value with valid single key', () => {
+      const johnWithNewAge = { ...initialData.john, age: initialData.john.age + 1 };
+
+      fileStorage.write('john', johnWithNewAge);
+
+      expect(fileStorage.read('john')).toStrictEqual(johnWithNewAge);
+    });
+
+    test('Should update value with valid array key', () => {
+      const newAge = initialData.john.age + 1;
+
+      fileStorage.write(['john', 'age'], newAge);
+
+      expect(fileStorage.read(['john', 'age'])).toBe(newAge);
+    });
+
+    test('Should update value with valid key which contain non-existent last part', () => {
+      const stand = 'The World';
+
+      fileStorage.write(['john', 'stand'], stand);
+
+      expect(fileStorage.read(['john', 'stand'])).toBe(stand);
+    });
+
+    test('Should write in file updated data', () => {
+      const fileWriterWriteMethodMock = jest.spyOn(FileWriter.prototype, 'write');
+
+      fileStorage.write(['john', 'stand'], 'The World');
+
+      expect(fileWriterWriteMethodMock).toHaveBeenCalledTimes(1);
+      expect(fileWriterWriteMethodMock).toHaveBeenCalledWith(JSON.stringify(fileStorage.read()));
+    });
+  });
+
+  describe('FileStorage: delete', () => {
+    let tmpDirPath: string;
+    let initialData: ReturnType<typeof createInitialData>;
+    let fileStorage: FileStorage;
+
+    beforeEach(() => {
+      tmpDirPath = fs.mkdtempSync(os.tmpdir());
+      initialData = createInitialData();
+
+      const pathToFileStorage = path.join(tmpDirPath, './database.json');
+      fs.writeFileSync(pathToFileStorage, JSON.stringify(initialData));
+      fileStorage = new FileStorage(pathToFileStorage);
+    });
+
+    afterEach(() => {
+      fs.rmSync(tmpDirPath, { recursive: true, force: true });
+      jest.clearAllMocks();
+    });
+
+    test('Should correctly delete object property with valid single key', () => {
+      expect(fileStorage.read('john')).toStrictEqual(initialData.john);
+
+      fileStorage.delete('john');
+
+      expect(fileStorage.read('john')).toBe(undefined);
+    });
+
+    test('Should correctly delete object property with valid array key', () => {
+      expect(fileStorage.read('john')).toStrictEqual(initialData.john);
+
+      fileStorage.delete(['john', 'age']);
+
+      expect(fileStorage.read('john')).toStrictEqual({ name: initialData.john.name });
+    });
+
+    test('Should splice array if delete element from array', () => {
+      expect(fileStorage.read('users')).toStrictEqual(initialData.users);
+
+      fileStorage.delete(['users', 0]);
+
+      const updatedUsers = fileStorage.read('users');
+      expect(updatedUsers).toStrictEqual([{ id: 2 }]);
+      expect(updatedUsers.length).toBe(1);
+    });
+
+    test('Should write in file updated data', () => {
+      const fileWriterWriteMethodMock = jest.spyOn(FileWriter.prototype, 'write');
+
+      fileStorage.delete(['users', 0]);
+
+      expect(fileWriterWriteMethodMock).toHaveBeenCalledTimes(1);
+      expect(fileWriterWriteMethodMock).toHaveBeenCalledWith(JSON.stringify(fileStorage.read()));
+    });
+  });
+});

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

@@ -0,0 +1,48 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+
+import { FileWriter } from './FileWriter';
+
+describe('FileWriter', () => {
+  let tmpDirPath: string;
+
+  beforeEach(() => {
+    tmpDirPath = fs.mkdtempSync(os.tmpdir());
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDirPath, { recursive: true, force: true });
+    jest.clearAllMocks();
+  });
+
+  test('Write asynchronously in file only last data (before Promise become fulfilled)', async () => {
+    const fileName = './database.json';
+    const filePath = path.join(tmpDirPath, fileName);
+    const fileWriter = new FileWriter(filePath);
+
+    const writePromises: Promise<void>[] = [];
+    const writeOperationCount = 100;
+    for (let i = 0; i <= writeOperationCount; i += 1) {
+      writePromises.push(fileWriter.write(JSON.stringify({ index: i })));
+    }
+    await Promise.all(writePromises);
+
+    const fileData = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+    expect(fileData).toStrictEqual({ index: writeOperationCount });
+  });
+
+  test('Write in file only if writing is unlocked (first write and last write)', async () => {
+    const fileWriter = new FileWriter(path.join(tmpDirPath, './database.json'));
+    const fsPromisesWriteFileMock = jest.spyOn(fs.promises, 'writeFile');
+
+    const writePromises: Promise<void>[] = [];
+    const writeOperationCount = 100;
+    for (let i = 0; i <= writeOperationCount; i += 1) {
+      writePromises.push(fileWriter.write(JSON.stringify({ index: i })));
+    }
+    await Promise.all(writePromises);
+
+    expect(fsPromisesWriteFileMock).toHaveBeenCalledTimes(2);
+  });
+});

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

@@ -0,0 +1,96 @@
+import { MemoryStorage } from './MemoryStorage';
+
+describe('MemoryStorage', () => {
+  const createInitialData = () => ({
+    john: { name: 'John Doe', age: 25 },
+    jane: { name: 'Jane Smith', age: 30 },
+    users: [{ id: 1 }, { id: 2 }]
+  });
+
+  describe('MemoryStorage: read', () => {
+    const initialData = createInitialData();
+    const memoryStorage = new MemoryStorage(initialData);
+
+    test('Should return correct full data for read without keys', () => {
+      expect(memoryStorage.read()).toStrictEqual(initialData);
+    });
+
+    test('Should return correct data for read with valid single key', () => {
+      expect(memoryStorage.read('john')).toStrictEqual(initialData.john);
+    });
+
+    test('Should return correct data for read with valid array key', () => {
+      expect(memoryStorage.read(['john', 'name'])).toStrictEqual(initialData.john.name);
+    });
+  });
+
+  describe('MemoryStorage: write', () => {
+    let initialData: ReturnType<typeof createInitialData>;
+    let memoryStorage: MemoryStorage<typeof initialData>;
+
+    beforeEach(() => {
+      initialData = createInitialData();
+      memoryStorage = new MemoryStorage(initialData);
+    });
+
+    test('Should update value with valid single key', () => {
+      const johnWithNewAge = { ...initialData.john, age: initialData.john.age + 1 };
+
+      memoryStorage.write('john', johnWithNewAge);
+
+      expect(memoryStorage.read('john')).toStrictEqual(johnWithNewAge);
+    });
+
+    test('Should update value with valid array key', () => {
+      const newAge = initialData.john.age + 1;
+
+      memoryStorage.write(['john', 'age'], newAge);
+
+      expect(memoryStorage.read(['john', 'age'])).toBe(newAge);
+    });
+
+    test('Should update value with valid key which contain non-existent last part', () => {
+      const stand = initialData.john.age + 1;
+
+      memoryStorage.write(['john', 'stand'], stand);
+
+      expect(memoryStorage.read(['john', 'stand'])).toBe(stand);
+    });
+  });
+
+  describe('MemoryStorage: delete', () => {
+    let initialData: ReturnType<typeof createInitialData>;
+    let memoryStorage: MemoryStorage<typeof initialData>;
+
+    beforeEach(() => {
+      initialData = createInitialData();
+      memoryStorage = new MemoryStorage(initialData);
+    });
+
+    test('Should correctly delete object property with valid single key', () => {
+      expect(memoryStorage.read('john')).toStrictEqual(initialData.john);
+
+      memoryStorage.delete('john');
+
+      expect(memoryStorage.read('john')).toBe(undefined);
+    });
+
+    test('Should correctly delete object property with valid array key', () => {
+      expect(memoryStorage.read('john')).toStrictEqual(initialData.john);
+
+      memoryStorage.delete(['john', 'age']);
+
+      expect(memoryStorage.read('john')).toStrictEqual({ name: initialData.john.name });
+    });
+
+    test('Should splice array if delete element from array', () => {
+      expect(memoryStorage.read('users')).toStrictEqual(initialData.users);
+
+      memoryStorage.delete(['users', 0]);
+
+      const updatedUsers = memoryStorage.read('users');
+      expect(updatedUsers).toStrictEqual([{ id: 2 }]);
+      expect(updatedUsers.length).toBe(1);
+    });
+  });
+});