mock-config-server 3.2.0 → 3.3.1

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

@@ -0,0 +1,112 @@
+import type { Express } from 'express';
+import express from 'express';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import request from 'supertest';
+
+import { createDatabaseRoutes } from '@/core/database';
+import type { DatabaseConfig, MockServerConfig } from '@/utils/types';
+
+import { findIndexById } from './helpers';
+
+describe('createDatabaseRoutes', () => {
+  const createServer = (
+    mockServerConfig: Pick<MockServerConfig, 'baseUrl'> & { database: DatabaseConfig }
+  ) => {
+    const server = express();
+    const routerBase = express.Router();
+    const routesWithDatabaseRoutes = createDatabaseRoutes(routerBase, mockServerConfig.database);
+
+    server.use(mockServerConfig.baseUrl ?? '/', routesWithDatabaseRoutes);
+    return server;
+  };
+
+  describe('createDatabaseRoutes: routes and data successfully works when passing them by object', () => {
+    const data = { profile: { name: 'John' }, users: [{ id: 1 }, { id: 2 }] };
+    const routes = { '/api/profile': '/profile' } as const;
+    const server = createServer({ database: { data, routes } });
+
+    test('Should overwrite routes according to routes object (but default url should work too)', async () => {
+      const overwrittenUrlResponse = await request(server).get('/api/profile');
+      expect(overwrittenUrlResponse.body).toStrictEqual(data.profile);
+
+      const defaultUrlResponse = await request(server).get('/profile');
+      expect(defaultUrlResponse.body).toStrictEqual(data.profile);
+    });
+
+    test('Should successfully handle requests to shallow and nested database parts', async () => {
+      const shallowDatabaseResponse = await request(server).get('/profile');
+      expect(shallowDatabaseResponse.body).toStrictEqual(data.profile);
+
+      const nestedDatabaseCollectionResponse = await request(server).get('/users');
+      expect(nestedDatabaseCollectionResponse.body).toStrictEqual(data.users);
+
+      const nestedDatabaseItemResponse = await request(server).get('/users/1');
+      expect(nestedDatabaseItemResponse.body).toStrictEqual(
+        data.users[findIndexById(data.users, 1)]
+      );
+    });
+  });
+
+  describe('createDatabaseRoutes: routes and data successfully works when passing them by file', () => {
+    const data = { profile: { name: 'John' }, users: [{ id: 1 }, { id: 2 }] };
+    const routes = { '/api/profile': '/profile' } as const;
+
+    let tmpDirPath: string;
+    let server: Express;
+
+    beforeAll(() => {
+      tmpDirPath = fs.mkdtempSync(os.tmpdir());
+
+      const pathToData = path.join(tmpDirPath, './data.json') as `${string}.json`;
+      fs.writeFileSync(pathToData, JSON.stringify(data));
+
+      const pathToRoutes = path.join(tmpDirPath, './routes.json') as `${string}.json`;
+      fs.writeFileSync(pathToRoutes, JSON.stringify(routes));
+
+      server = createServer({ database: { data: pathToData, routes: pathToRoutes } });
+    });
+
+    afterAll(() => {
+      fs.rmSync(tmpDirPath, { recursive: true, force: true });
+    });
+
+    test('Should overwrite routes according to routes object (but default url should work too)', async () => {
+      const overwrittenUrlResponse = await request(server).get('/api/profile');
+      expect(overwrittenUrlResponse.body).toStrictEqual(data.profile);
+
+      const defaultUrlResponse = await request(server).get('/profile');
+      expect(defaultUrlResponse.body).toStrictEqual(data.profile);
+    });
+
+    test('Should successfully handle requests to shallow and nested database parts', async () => {
+      const shallowDatabaseResponse = await request(server).get('/profile');
+      expect(shallowDatabaseResponse.body).toStrictEqual(data.profile);
+
+      const nestedDatabaseCollectionResponse = await request(server).get('/users');
+      expect(nestedDatabaseCollectionResponse.body).toStrictEqual(data.users);
+
+      const nestedDatabaseItemResponse = await request(server).get('/users/1');
+      expect(nestedDatabaseItemResponse.body).toStrictEqual(
+        data.users[findIndexById(data.users, 1)]
+      );
+    });
+  });
+
+  describe('createDatabaseRoutes: routes /__routes and /__db', () => {
+    const data = { profile: { name: 'John' }, users: [{ id: 1 }, { id: 2 }] };
+    const routes = { '/api/profile': '/profile' } as const;
+    const server = createServer({ database: { data, routes } });
+
+    test('Should create /__db route that return data from databaseConfig', async () => {
+      const response = await request(server).get('/__db');
+      expect(response.body).toStrictEqual(data);
+    });
+
+    test('Should create /__routes route that return routes from databaseConfig', async () => {
+      const response = await request(server).get('/__routes');
+      expect(response.body).toStrictEqual(routes);
+    });
+  });
+});

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

@@ -0,0 +1,13 @@
+import { createNewId } from './createNewId';
+
+describe('createNewId', () => {
+  test('Should increment max numeric id in array on 1', () => {
+    const array = [{ id: 1 }, { id: 'string' }, { id: 1000 }];
+    expect(createNewId(array)).toBe(1001);
+  });
+
+  test('Should return 0 if no numeric ids in array', () => {
+    const array = [{ id: 'string' }];
+    expect(createNewId(array)).toBe(0);
+  });
+});

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

@@ -0,0 +1,17 @@
+import { findIndexById } from './findIndexById';
+
+describe('findIndexById', () => {
+  const array = [{ id: 1 }, { id: 2 }];
+
+  test('Should return index of item by id', () => {
+    expect(findIndexById(array, 2)).toBe(1);
+  });
+
+  test('Should return -1 if item with id does not exists', () => {
+    expect(findIndexById(array, 3)).toBe(-1);
+  });
+
+  test('Should compare ids independently of type: string or number', () => {
+    expect(findIndexById(array, '2')).toBe(1);
+  });
+});

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

@@ -0,0 +1,30 @@
+import { isIndex } from './isIndex';
+
+describe('isIndex', () => {
+  test('Should return true for positive integer value', () => {
+    expect(isIndex(5)).toBe(true);
+  });
+
+  test('Should return true for 0', () => {
+    expect(isIndex(0)).toBe(true);
+  });
+
+  test('Should return false for negative integer value', () => {
+    expect(isIndex(-5)).toBe(false);
+  });
+
+  test('Should return false for floating point value', () => {
+    expect(isIndex(1.5)).toBe(false);
+  });
+
+  test('Should return false for non-numeric value', () => {
+    expect(isIndex(true)).toBe(false);
+    expect(isIndex('hello')).toBe(false);
+    expect(isIndex(null)).toBe(false);
+    expect(isIndex(undefined)).toBe(false);
+    expect(isIndex({})).toBe(false);
+    expect(isIndex([])).toBe(false);
+    expect(isIndex(() => {})).toBe(false);
+    expect(isIndex(Symbol('symbol'))).toBe(false);
+  });
+});

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

@@ -6,16 +6,59 @@ Object.defineProperty(exports, "__esModule", {
 exports.createNestedDatabaseRoutes = void 0;
 var _array = require("../array");
 var _filter = require("../filter/filter");
+var _pagination = require("../pagination/pagination");
+var _sort2 = require("../sort/sort");
 const createNestedDatabaseRoutes = (router, database, storage) => {
   Object.keys(database).forEach(key => {
     const collectionPath = `/${key}`;
     const itemPath = `/${key}/:id`;
     router.route(collectionPath).get((request, response) => {
+      var _request$query;
       let data = storage.read(key);
       if (request.query && Object.keys(request.query).length) {
-        data = (0, _filter.filter)(data, request.query);
+        const {
+          _page,
+          _limit,
+          _begin,
+          _end,
+          _sort,
+          _order,
+          ...filters
+        } = request.query;
+        data = (0, _filter.filter)(data, filters);
+      }
+      if ((_request$query = request.query) !== null && _request$query !== void 0 && _request$query._page) {
+        data = (0, _pagination.pagination)(data, request.query);
+        if (data._link) {
+          const links = {};
+          const fullUrl = `${request.protocol}://${request.get('host')}${request.originalUrl}`;
+          if (data._link.first) {
+            links.first = fullUrl.replace(`page=${data._link.current}`, `page=${data._link.first}`);
+          }
+          if (data._link.prev) {
+            links.prev = fullUrl.replace(`page=${data._link.current}`, `page=${data._link.prev}`);
+          }
+          if (data._link.next) {
+            links.next = fullUrl.replace(`page=${data._link.current}`, `page=${data._link.next}`);
+          }
+          if (data._link.last) {
+            links.last = fullUrl.replace(`page=${data._link.current}`, `page=${data._link.last}`);
+          }
+          data._link = {
+            ...data._link,
+            ...links
+          };
+          response.links(links);
+        }
+      }
+      if (request.query && request.query._sort) {
+        data = (0, _sort2.sort)(data, request.query);
+      }
+      if (request.query._begin || request.query._end) {
+        var _request$query$_begin;
+        data = data.slice((_request$query$_begin = request.query._begin) !== null && _request$query$_begin !== void 0 ? _request$query$_begin : 0, request.query._end);
+        response.set('X-Total-Count', data.length);
       }
-
       // ✅ important:
       // set 'Cache-Control' header for explicit browsers response revalidate
       // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Cache-Control

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

@@ -0,0 +1,399 @@
+import type { Express } from 'express';
+import express from 'express';
+import request from 'supertest';
+
+import type { NestedDatabase } from '@/utils/types';
+
+import { MemoryStorage } from '../../storages';
+
+import { createNestedDatabaseRoutes } from './createNestedDatabaseRoutes';
+
+describe('CreateNestedDatabaseRoutes', () => {
+  const createNestedDatabase = () => ({
+    users: [
+      { id: 1, name: 'John Doe', age: 25, address: { city: 'Novosibirsk' } },
+      { id: 2, name: 'Jane Smith', age: 30, address: { city: 'Tomsk' } }
+    ]
+  });
+
+  const createServer = (nestedDatabase: NestedDatabase) => {
+    const server = express();
+    const routerBase = express.Router();
+    const storage = new MemoryStorage(nestedDatabase);
+
+    const routerWithNestedDatabaseRoutes = createNestedDatabaseRoutes(
+      routerBase,
+      nestedDatabase,
+      storage
+    );
+
+    server.use(express.json());
+    server.use(express.text());
+    server.use('/', routerWithNestedDatabaseRoutes);
+
+    return server;
+  };
+
+  describe('createNestedDatabaseRoutes: GET method for collection', () => {
+    const nestedDatabase = createNestedDatabase();
+    const server = createServer(nestedDatabase);
+
+    test('Should return correct data for valid key', async () => {
+      const response = await request(server).get('/users');
+
+      expect(response.body).toStrictEqual(nestedDatabase.users);
+    });
+
+    test('Should return correct Cache-Control header for valid key', async () => {
+      const response = await request(server).get('/users');
+
+      expect(response.headers['cache-control']).toBe('max-age=0, must-revalidate');
+    });
+  });
+
+  describe('createNestedDatabaseRoutes: POST method for collection', () => {
+    let nestedDatabase: ReturnType<typeof createNestedDatabase>;
+    let server: Express;
+    beforeEach(() => {
+      nestedDatabase = createNestedDatabase();
+      server = createServer(nestedDatabase);
+    });
+
+    test('Should return correct data (ignored id) for valid key and successfully update database', async () => {
+      const jim = { id: 4, name: 'jim', age: 35 };
+      const postResponse = await request(server).post('/users').send(jim);
+
+      expect(postResponse.statusCode).toBe(201);
+      expect(postResponse.body).toStrictEqual({ ...jim, id: 3 });
+
+      const getResponse = await request(server).get('/users');
+      expect(getResponse.body).toContainEqual({ ...jim, id: 3 });
+    });
+
+    test('Should return correct Location header for valid key', async () => {
+      const jim = { id: 4, name: 'jim', age: 35 };
+      const postResponse = await request(server).post('/users').send(jim);
+
+      expect(postResponse.headers.location).toBe('/users/3');
+    });
+  });
+
+  describe('createNestedDatabaseRoutes: GET method for item', () => {
+    const nestedDatabase = createNestedDatabase();
+    const server = createServer(nestedDatabase);
+
+    test('Should return correct data for valid key and id', async () => {
+      const response = await request(server).get('/users/1');
+
+      expect(response.body).toStrictEqual(nestedDatabase.users.find((item) => item.id === 1));
+    });
+
+    test('Should correct Cache-Control header for valid key and id', async () => {
+      const response = await request(server).get('/users/1');
+
+      expect(response.headers['cache-control']).toBe('max-age=0, must-revalidate');
+    });
+
+    test('Should return 404 for non-existent id', async () => {
+      const response = await request(server).get('/users/3');
+
+      expect(response.status).toBe(404);
+    });
+  });
+
+  describe('createNestedDatabaseRoutes: PUT method for item', () => {
+    let nestedDatabase: ReturnType<typeof createNestedDatabase>;
+    let server: Express;
+    beforeEach(() => {
+      nestedDatabase = createNestedDatabase();
+      server = createServer(nestedDatabase);
+    });
+
+    test('Should correctly replace resource (ignoring id) for valid key and id', async () => {
+      const response = await request(server).put('/users/1').send({ id: 3, name: 'John Smith' });
+
+      expect(response.body).toStrictEqual({ id: 1, name: 'John Smith' });
+    });
+
+    test('Should return 404 for non-existent id', async () => {
+      const response = await request(server).put('/users/3');
+
+      expect(response.status).toBe(404);
+    });
+  });
+
+  describe('createNestedDatabaseRoutes: PATCH method for item', () => {
+    let nestedDatabase: ReturnType<typeof createNestedDatabase>;
+    let server: Express;
+    beforeEach(() => {
+      nestedDatabase = createNestedDatabase();
+      server = createServer(nestedDatabase);
+    });
+
+    test('Should correctly update resource (ignoring id) for valid key and id', async () => {
+      const response = await request(server).patch('/users/1').send({ id: 3, name: 'John Smith' });
+
+      expect(response.body).toStrictEqual({
+        id: 1,
+        name: 'John Smith',
+        age: 25,
+        address: { city: 'Novosibirsk' }
+      });
+    });
+
+    test('Should return 404 for non-existent id', async () => {
+      const response = await request(server).patch('/users/3');
+
+      expect(response.status).toBe(404);
+    });
+  });
+
+  describe('createNestedDatabase: DELETE method for item', () => {
+    let nestedDatabase: ReturnType<typeof createNestedDatabase>;
+    let server: Express;
+    beforeEach(() => {
+      nestedDatabase = createNestedDatabase();
+      server = createServer(nestedDatabase);
+    });
+
+    test('Should correctly delete item from collection for valid key and id', async () => {
+      const deleteResponse = await request(server).delete('/users/1');
+      expect(deleteResponse.status).toBe(204);
+
+      const getResponse = await request(server).get('/users/1');
+      expect(getResponse.status).toBe(404);
+    });
+
+    test('Should return 404 for non-existent id', async () => {
+      const response = await request(server).delete('/users/3');
+
+      expect(response.status).toBe(404);
+    });
+  });
+
+  describe('createNestedDatabaseRoutes: filter function', () => {
+    const nestedDatabase = createNestedDatabase();
+    const server = createServer(nestedDatabase);
+
+    test('Should return filtered array by query', async () => {
+      const response = await request(server).get('/users?name=John Doe');
+
+      expect(response.body).toStrictEqual([
+        {
+          id: 1,
+          name: 'John Doe',
+          age: 25,
+          address: { city: 'Novosibirsk' }
+        }
+      ]);
+    });
+
+    test('Should return filtered array by identical queries names', async () => {
+      const response = await request(server).get('/users?id=1&id=2');
+
+      expect(response.body).toStrictEqual(nestedDatabase.users);
+    });
+
+    test('Should return filtered array by nested query', async () => {
+      const response = await request(server).get('/users?address.city=Novosibirsk');
+
+      expect(response.body).toStrictEqual([
+        {
+          id: 1,
+          name: 'John Doe',
+          age: 25,
+          address: { city: 'Novosibirsk' }
+        }
+      ]);
+    });
+  });
+
+  describe('createNestedDatabaseRoutes: pagination function', () => {
+    const nestedDatabase = createNestedDatabase();
+    const server = createServer(nestedDatabase);
+
+    test('Should return paginationed data by query', async () => {
+      const response = await request(server).get('/users?_page=1');
+
+      expect(response.body.results).toStrictEqual([
+        { id: 1, name: 'John Doe', age: 25, address: { city: 'Novosibirsk' } },
+        { id: 2, name: 'Jane Smith', age: 30, address: { city: 'Tomsk' } }
+      ]);
+      expect(response.body._link).toEqual(
+        expect.objectContaining({
+          count: 2,
+          pages: 1,
+          current: 1,
+          next: null,
+          prev: null
+        })
+      );
+      expect(response.body._link.first).toContain('/users?_page=1');
+      expect(response.body._link.last).toContain('/users?_page=1');
+    });
+
+    test('Should return paginationed data by query with limit', async () => {
+      const response = await request(server).get('/users?_page=1&_limit=1');
+
+      expect(response.body.results).toStrictEqual([
+        { id: 1, name: 'John Doe', age: 25, address: { city: 'Novosibirsk' } }
+      ]);
+      expect(response.body._link).toEqual(
+        expect.objectContaining({
+          count: 2,
+          pages: 2,
+          current: 1,
+          prev: null
+        })
+      );
+      expect(response.body._link.first).toContain('/users?_page=1&_limit=1');
+      expect(response.body._link.last).toContain('/users?_page=2&_limit=1');
+      expect(response.body._link.next).toContain('/users?_page=2&_limit=1');
+    });
+
+    test('Should return valid _link for paginationed data', async () => {
+      const linkHeaderRegexp = /<([^>]+)>;\s*rel="([^"]+)"/g;
+      const firstResponse = await request(server).get('/users?_page=1&_limit=1');
+
+      const firstResponseLinks = firstResponse.headers.link.match(linkHeaderRegexp);
+      expect(firstResponse.headers.link).toMatch(linkHeaderRegexp);
+
+      if (!firstResponseLinks) throw new Error('Link header not found');
+
+      expect(firstResponseLinks.length).toEqual(3);
+
+      const [firstNextLink, firstPrevLink, firstLastLink] = firstResponseLinks;
+      expect(firstNextLink).toContain('/users?_page=1&_limit=1>; rel="first"');
+      expect(firstPrevLink).toContain('/users?_page=2&_limit=1>; rel="next"');
+      expect(firstLastLink).toContain('/users?_page=2&_limit=1>; rel="last"');
+
+      expect(firstResponse.body.results).toStrictEqual([
+        { id: 1, name: 'John Doe', age: 25, address: { city: 'Novosibirsk' } }
+      ]);
+      expect(firstResponse.body._link).toEqual(
+        expect.objectContaining({
+          count: 2,
+          pages: 2,
+          current: 1,
+          prev: null
+        })
+      );
+      expect(firstResponse.body._link.first).toContain('/users?_page=1&_limit=1');
+      expect(firstResponse.body._link.last).toContain('/users?_page=2&_limit=1');
+      expect(firstResponse.body._link.next).toContain('/users?_page=2&_limit=1');
+
+      const secondResponse = await request(server).get('/users?_page=2&_limit=1');
+
+      const secondResponseLinks = firstResponse.headers.link.match(linkHeaderRegexp);
+      expect(secondResponse.headers.link).toMatch(linkHeaderRegexp);
+
+      if (!secondResponseLinks) throw new Error('Link header not found');
+
+      expect(secondResponseLinks.length).toEqual(3);
+
+      const [secondNextLink, secondPrevLink, secondLastLink] = secondResponseLinks;
+      expect(secondNextLink).toContain('/users?_page=1&_limit=1>; rel="first"');
+      expect(secondPrevLink).toContain('/users?_page=2&_limit=1>; rel="next"');
+      expect(secondLastLink).toContain('/users?_page=2&_limit=1>; rel="last"');
+
+      expect(secondResponse.body.results).toStrictEqual([
+        { id: 2, name: 'Jane Smith', age: 30, address: { city: 'Tomsk' } }
+      ]);
+      expect(secondResponse.body._link).toEqual(
+        expect.objectContaining({
+          count: 2,
+          pages: 2,
+          current: 2,
+          next: null
+        })
+      );
+      expect(secondResponse.body._link.first).toContain('/users?_page=1&_limit=1');
+      expect(secondResponse.body._link.last).toContain('/users?_page=2&_limit=1');
+      expect(secondResponse.body._link.prev).toContain('/users?_page=1&_limit=1');
+    });
+
+    test('Should return valid data by invalid pagination data', async () => {
+      const response = await request(server).get('/users?_page=2');
+
+      expect(response.body).toStrictEqual([
+        { id: 1, name: 'John Doe', age: 25, address: { city: 'Novosibirsk' } },
+        { id: 2, name: 'Jane Smith', age: 30, address: { city: 'Tomsk' } }
+      ]);
+    });
+  });
+
+  describe('createNestedDatabaseRoutes: slice function', () => {
+    const nestedDatabase = createNestedDatabase();
+    const server = createServer(nestedDatabase);
+
+    test('Should return sliced array by _begin query', async () => {
+      const response = await request(server).get('/users?_begin=1');
+
+      expect(response.body).toStrictEqual(nestedDatabase.users.slice(1));
+    });
+
+    test('Should return sliced array by _end query', async () => {
+      const response = await request(server).get('/users?_end=1');
+
+      expect(response.body).toStrictEqual(nestedDatabase.users.slice(0, 1));
+    });
+
+    test('Should return sliced array by _begin and _end query', async () => {
+      const response = await request(server).get('/users?_begin=0&_end=2');
+
+      expect(response.body).toStrictEqual(nestedDatabase.users.slice(0, 2));
+    });
+  });
+
+  describe('createNestedDatabaseRoutes: sort function', () => {
+    const nestedDatabase = createNestedDatabase();
+    const server = createServer({
+      users: [
+        ...nestedDatabase.users,
+        { id: 3, name: 'Will Smith', age: 27, address: { city: 'Moscow' } }
+      ]
+    });
+
+    test('Should return sorted data by query', async () => {
+      const response = await request(server).get('/users?_sort=age');
+
+      expect(response.body).toStrictEqual([
+        { id: 1, name: 'John Doe', age: 25, address: { city: 'Novosibirsk' } },
+        { id: 3, name: 'Will Smith', age: 27, address: { city: 'Moscow' } },
+        { id: 2, name: 'Jane Smith', age: 30, address: { city: 'Tomsk' } }
+      ]);
+    });
+
+    test('Should return sorted data by query with order', async () => {
+      const response = await request(server).get('/users?_sort=age&_order=desc');
+
+      expect(response.body).toStrictEqual([
+        { id: 2, name: 'Jane Smith', age: 30, address: { city: 'Tomsk' } },
+        { id: 3, name: 'Will Smith', age: 27, address: { city: 'Moscow' } },
+        { id: 1, name: 'John Doe', age: 25, address: { city: 'Novosibirsk' } }
+      ]);
+    });
+
+    test('Should return sorted data by multiple query', async () => {
+      const response = await request(server).get(
+        '/users?_sort=name&_order=asc&_sort=id&_order=desc'
+      );
+
+      expect(response.body).toStrictEqual([
+        { id: 3, name: 'Will Smith', age: 27, address: { city: 'Moscow' } },
+        { id: 2, name: 'Jane Smith', age: 30, address: { city: 'Tomsk' } },
+        { id: 1, name: 'John Doe', age: 25, address: { city: 'Novosibirsk' } }
+      ]);
+    });
+
+    test('Should return filtered array by nested query', async () => {
+      const response = await request(server).get('/users?_sort=address.city&_order=desc');
+
+      expect(response.body).toStrictEqual([
+        { id: 2, name: 'Jane Smith', age: 30, address: { city: 'Tomsk' } },
+        { id: 1, name: 'John Doe', age: 25, address: { city: 'Novosibirsk' } },
+        { id: 3, name: 'Will Smith', age: 27, address: { city: 'Moscow' } }
+      ]);
+    });
+  });
+});