mock-config-server 3.2.0 → 3.3.1

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

@@ -0,0 +1,118 @@
+import type { Express } from 'express';
+import express from 'express';
+import request from 'supertest';
+
+import type { ShallowDatabase } from '@/utils/types';
+
+import { MemoryStorage } from '../../storages';
+
+import { createShallowDatabaseRoutes } from './createShallowDatabaseRoutes';
+
+describe('createShallowDatabaseRoutes', () => {
+  const createShallowDatabase = () => ({
+    john: { name: 'John Doe', age: 25 },
+    jane: { name: 'Jane Smith', age: 30 }
+  });
+
+  const createServer = (shallowDatabase: ShallowDatabase) => {
+    const server = express();
+    const routerBase = express.Router();
+    const storage = new MemoryStorage(shallowDatabase);
+
+    const routerWithRoutesForShallowDatabase = createShallowDatabaseRoutes(
+      routerBase,
+      shallowDatabase,
+      storage
+    );
+
+    server.use(express.json());
+    server.use(express.text());
+    server.use('/', routerWithRoutesForShallowDatabase);
+
+    return server;
+  };
+
+  describe('createShallowDatabaseRoutes: GET method', () => {
+    const shallowDatabase = createShallowDatabase();
+    const server = createServer(shallowDatabase);
+
+    test('Should return correct data for valid key', async () => {
+      const response = await request(server).get('/john');
+
+      expect(response.statusCode).toBe(200);
+      expect(response.body).toStrictEqual(shallowDatabase.john);
+    });
+
+    test('Should return correct Cache-Control header for valid key', async () => {
+      const response = await request(server).get('/john');
+
+      expect(response.headers['cache-control']).toBe('max-age=0, must-revalidate');
+    });
+  });
+
+  describe('createShallowDatabaseRoutes: POST method', () => {
+    let shallowDatabase: ReturnType<typeof createShallowDatabase>;
+    let server: Express;
+    beforeEach(() => {
+      shallowDatabase = createShallowDatabase();
+      server = createServer(shallowDatabase);
+    });
+
+    test('Should return correct data for valid key and successfully update database', async () => {
+      const newJohnInfo = { age: 26, standName: 'The World' };
+
+      const postResponse = await request(server).post('/john').send(newJohnInfo);
+      expect(postResponse.statusCode).toBe(201);
+      expect(postResponse.body).toStrictEqual(newJohnInfo);
+
+      const getResponse = await request(server).get('/john');
+      expect(getResponse.body).toStrictEqual(newJohnInfo);
+    });
+
+    test('Should return correct Location header for valid key', async () => {
+      const response = await request(server).post('/john').send(undefined);
+
+      expect(response.headers.location).toBe('/john');
+    });
+  });
+
+  describe('createShallowDatabaseRoutes: PUT method', () => {
+    let shallowDatabase: ReturnType<typeof createShallowDatabase>;
+    let server: Express;
+    beforeEach(() => {
+      shallowDatabase = createShallowDatabase();
+      server = createServer(shallowDatabase);
+    });
+
+    test('Should return correct data for valid key and successfully update database', async () => {
+      const newJohnInfo = { age: 26, standName: 'The World' };
+
+      const putResponse = await request(server).put('/john').send(newJohnInfo);
+      expect(putResponse.statusCode).toBe(200);
+      expect(putResponse.body).toStrictEqual(newJohnInfo);
+
+      const getResponse = await request(server).get('/john');
+      expect(getResponse.body).toStrictEqual(newJohnInfo);
+    });
+  });
+
+  describe('createShallowDatabaseRoutes: PATCH method', () => {
+    let shallowDatabase: ReturnType<typeof createShallowDatabase>;
+    let server: Express;
+    beforeEach(() => {
+      shallowDatabase = createShallowDatabase();
+      server = createServer(shallowDatabase);
+    });
+
+    test('Should return correct data for valid key and successfully update database', async () => {
+      const newJohnInfo = { age: 26, standName: 'The World' };
+
+      const patchResponse = await request(server).patch('/john').send(newJohnInfo);
+      expect(patchResponse.statusCode).toBe(200);
+      expect(patchResponse.body).toStrictEqual({ ...shallowDatabase.john, ...newJohnInfo });
+
+      const getResponse = await request(server).get('/john');
+      expect(getResponse.body).toStrictEqual({ ...shallowDatabase.john, ...newJohnInfo });
+    });
+  });
+});

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[];

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/pagination/pagination.d.ts

@@ -0,0 +1,13 @@
+import type { ParsedUrlQuery } from 'node:querystring';
+export declare const pagination: (array: any[], queries: ParsedUrlQuery) => any[] | {
+    _link: {
+        count: number;
+        pages: number;
+        first: number;
+        current: number;
+        next: number | null;
+        prev: number | null;
+        last: number | null;
+    };
+    results: any[];
+};

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

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.pagination = void 0;
+const DEFAULT_LIMIT = 10;
+const pagination = (array, queries) => {
+  const {
+    _page
+  } = queries;
+  if (!_page || +_page <= 0) return array;
+  const page = +_page;
+  const limit = queries._limit && +queries._limit > 0 ? +queries._limit : DEFAULT_LIMIT;
+  const pages = Math.ceil(array.length / limit);
+  if (page > pages) return array;
+  const start = page * limit - limit;
+  const end = page * limit;
+  const results = array.slice(start, end);
+  const next = page + 1 <= pages ? page + 1 : null;
+  const prev = page - 1 !== 0 ? page - 1 : null;
+  const last = pages > 0 ? pages : null;
+  return {
+    _link: {
+      count: array.length,
+      pages,
+      first: 1,
+      current: page,
+      next,
+      prev,
+      last
+    },
+    results
+  };
+};
+exports.pagination = pagination;

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/sort/sort.d.ts

@@ -0,0 +1,2 @@
+import type { ParsedUrlQuery } from 'node:querystring';
+export declare const sort: (array: any[], queries: ParsedUrlQuery) => any[];

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

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.sort = void 0;
+var _flat = _interopRequireDefault(require("flat"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const DEFAULT_ORDER = 'asc';
+const getOrder = order => {
+  if (order === 'asc' || order === 'desc') return order;
+  return DEFAULT_ORDER;
+};
+const sortArray = (array, key, order) => array.sort((a, b) => {
+  const flattenedA = (0, _flat.default)(a);
+  const flattenedB = (0, _flat.default)(b);
+  if (!flattenedA[key] || !flattenedB[key]) return 0;
+  if (typeof flattenedA[key] === 'string' && typeof flattenedB[key] === 'string') {
+    return order === 'asc' ? flattenedA[key].localeCompare(flattenedB[key]) : flattenedB[key].localeCompare(flattenedA[key]);
+  }
+  return order === 'asc' ? Number(flattenedA[key]) - Number(flattenedB[key]) : Number(flattenedB[key]) - Number(flattenedA[key]);
+});
+const sort = (array, queries) => {
+  const {
+    _sort,
+    _order = DEFAULT_ORDER
+  } = queries;
+  if (!_sort) return array;
+  const result = [...array];
+  if (Array.isArray(_sort)) {
+    const orders = Array.isArray(_order) ? _order : [_order];
+    _sort.forEach((key, index) => {
+      const order = getOrder(orders[index]);
+      sortArray(result, key, order);
+    });
+    return result;
+  }
+  const order = getOrder(Array.isArray(_order) ? _order[0] : _order);
+  sortArray(result, _sort, order);
+  return result;
+};
+exports.sort = sort;

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);
+    });
+  });
+});

package/dist/src/core/graphql/createGraphQLRoutes/createGraphQLRoutes.d.ts

@@ -1,3 +1,9 @@
 import type { IRouter } from 'express';
 import type { GraphqlConfig, Interceptors } from '../../../utils/types';
-export declare const createGraphQLRoutes: (router: IRouter, graphqlConfig: GraphqlConfig, serverResponseInterceptors?: Interceptors['response']) => IRouter;
+interface CreateGraphQLRoutesParams {
+    router: IRouter;
+    graphqlConfig: GraphqlConfig;
+    serverResponseInterceptor?: Interceptors['response'];
+}
+export declare const createGraphQLRoutes: ({ router, graphqlConfig, serverResponseInterceptor }: CreateGraphQLRoutesParams) => IRouter;
+export {};