@adaptivestone/framework 5.0.0-alpha.2 → 5.0.0-alpha.21

package/services/http/middleware/RateLimiter.test.js

@@ -1,233 +0,0 @@
-import { setTimeout } from 'node:timers/promises';
-import crypto from 'node:crypto';
-import { beforeAll, afterAll, describe, it, expect } from 'vitest';
-
-import RateLimiter from './RateLimiter.js';
-
-let mongoRateLimiter;
-
-describe('rate limiter methods', () => {
-  beforeAll(async () => {
-    await setTimeout(20);
-
-    mongoRateLimiter = new RateLimiter(global.server.app, {
-      driver: 'mongo',
-      limiterOptions: {
-        keyPrefix: `mongo_${Date.now()}_${crypto.randomUUID()}}`,
-      },
-    });
-  });
-
-  afterAll(async () => {
-    // we need to wait because redis mongo ask mongo to create indexes
-    await setTimeout(200);
-  });
-  it('have description fields', async () => {
-    expect.assertions(1);
-    const middleware = new RateLimiter(global.server.app, {
-      driver: 'redis',
-    });
-    expect(middleware.constructor.description).toBeDefined();
-  });
-
-  it('can create redis rateLimiter', async () => {
-    expect.assertions(1);
-
-    const redisRateLimiter = new RateLimiter(global.server.app, {
-      driver: 'redis',
-    });
-
-    expect(redisRateLimiter.limiter).toBeDefined();
-  });
-
-  it('can not create rateLimiter with unknown driver', async () => {
-    expect.assertions(1);
-
-    const rateLimiter = new RateLimiter(global.server.app, {
-      driver: 'unknown',
-    });
-
-    expect(rateLimiter.limiter).toBeNull();
-  });
-
-  it('generateConsumeKey works correctly', async () => {
-    expect.assertions(1);
-
-    const redisRateLimiter = new RateLimiter(global.server.app, {
-      driver: 'redis',
-    });
-
-    const res = await redisRateLimiter.gerenateConsumeKey({
-      ip: '192.168.0.0',
-      appInfo: {
-        user: {
-          id: 'someId',
-        },
-      },
-    });
-
-    expect(res).toBe('192.168.0.0__someId');
-  });
-
-  it('generateConsumeKey with request works correctly', async () => {
-    expect.assertions(1);
-
-    const redisRateLimiter = new RateLimiter(global.server.app, {
-      driver: 'redis',
-      consumeKeyComponents: {
-        request: ['email'],
-      },
-    });
-
-    const res = await redisRateLimiter.gerenateConsumeKey({
-      ip: '192.168.0.0',
-      body: {
-        email: 'foo@example.com',
-      },
-    });
-
-    expect(res).toBe('192.168.0.0__foo@example.com');
-  });
-
-  it('middleware without driver should fail', async () => {
-    expect.assertions(2);
-    const rateLimiter = new RateLimiter(global.server.app, {
-      driver: 'unknown',
-    });
-    const req = {
-      appInfo: {},
-    };
-    let status;
-    let isSend;
-    await rateLimiter.middleware(
-      req,
-      {
-        status(statusCode) {
-          status = statusCode;
-          return this;
-        },
-        json() {
-          isSend = true;
-        },
-      },
-      () => {},
-    );
-    expect(status).toBe(500);
-    expect(isSend).toBeTruthy();
-  });
-
-  const makeOneRequest = async ({ rateLimiter, driver, request }) => {
-    let realRateLimiter = rateLimiter;
-    if (!realRateLimiter) {
-      realRateLimiter = new RateLimiter(global.server.app, {
-        driver,
-      });
-    }
-    const req = {
-      appInfo: {},
-      ...request,
-    };
-    let status;
-    let isSend = false;
-    let isNextCalled = false;
-    await realRateLimiter.middleware(
-      req,
-      {
-        status(statusCode) {
-          status = statusCode;
-          return this;
-        },
-        json() {
-          isSend = true;
-        },
-      },
-      () => {
-        isNextCalled = true;
-      },
-    );
-    return { status, isSend, isNextCalled };
-  };
-
-  it('middleware should works with a mongo drivers', async () => {
-    expect.assertions(1);
-    const { isNextCalled } = await makeOneRequest({
-      rateLimiter: mongoRateLimiter,
-      request: { ip: '10.10.0.1' },
-    });
-    expect(isNextCalled).toBeTruthy();
-  });
-
-  it('middleware should works with a memory drivers', async () => {
-    expect.assertions(1);
-    const { isNextCalled } = await makeOneRequest({
-      driver: 'memory',
-      request: { ip: '10.10.0.1' },
-    });
-    expect(isNextCalled).toBeTruthy();
-  });
-
-  it('middleware should works with a redis drivers', async () => {
-    expect.assertions(1);
-    const { isNextCalled } = await makeOneRequest({
-      driver: 'redis',
-      request: { ip: '10.10.0.1' },
-    });
-    expect(isNextCalled).toBeTruthy();
-  });
-
-  it('middleware should rate limits for us. mongo driver', async () => {
-    expect.assertions(2);
-
-    const middlewares = Array.from({ length: 20 }, () =>
-      makeOneRequest({ rateLimiter: mongoRateLimiter }),
-    );
-
-    const data = await Promise.all(middlewares);
-
-    const status = data.find((obj) => obj.status === 429);
-    const isSend = data.find((obj) => obj.isSend);
-
-    expect(status.status).toBe(429);
-    expect(isSend.isSend).toBeTruthy();
-  });
-
-  it('middleware should rate limits for us. memory driver', async () => {
-    expect.assertions(2);
-
-    const rateLimiter = new RateLimiter(global.server.app, {
-      driver: 'memory',
-    });
-
-    const middlewares = Array.from({ length: 20 }, () =>
-      makeOneRequest({ rateLimiter }),
-    );
-
-    const data = await Promise.all(middlewares);
-
-    const status = data.find((obj) => obj.status === 429);
-    const isSend = data.find((obj) => obj.isSend);
-
-    expect(status.status).toBe(429);
-    expect(isSend.isSend).toBeTruthy();
-  });
-
-  it('middleware should rate limits for us. redis driver', async () => {
-    expect.assertions(2);
-
-    const rateLimiter = new RateLimiter(global.server.app, {
-      driver: 'redis',
-    });
-
-    const middlewares = Array.from({ length: 20 }, () =>
-      makeOneRequest({ rateLimiter }),
-    );
-
-    const data = await Promise.all(middlewares);
-
-    const status = data.find((obj) => obj.status === 429);
-    const isSend = data.find((obj) => obj.isSend);
-
-    expect(status.status).toBe(429);
-    expect(isSend.isSend).toBeTruthy();
-  });
-});

package/services/http/middleware/RequestParser.test.js

@@ -1,112 +0,0 @@
-import { createServer } from 'node:http';
-import { describe, it, expect } from 'vitest';
-import { PersistentFile } from 'formidable';
-
-import RequestParser from './RequestParser.js';
-
-describe('reqest parser limiter methods', () => {
-  it('have description fields', async () => {
-    expect.assertions(1);
-    const middleware = new RequestParser(global.server.app);
-    expect(middleware.constructor.description).toBeDefined();
-  });
-  it('middleware that works', async () => {
-    expect.assertions(4);
-
-    await new Promise((done) => {
-      // from https://github.com/node-formidable/formidable/blob/master/test-node/standalone/promise.test.js
-
-      const server = createServer(async (req, res) => {
-        req.appInfo = {};
-        const middleware = new RequestParser(global.server.app);
-        middleware.middleware(req, {}, (err) => {
-          expect(err).toBeUndefined();
-          expect(req.body.title).toBeDefined();
-          expect(req.body.multipleFiles).toBeDefined();
-          expect(
-            req.body.multipleFiles[0] instanceof PersistentFile,
-          ).toBeTruthy();
-
-          res.writeHead(200);
-          res.end('ok');
-        });
-      });
-      server.listen(null, async () => {
-        const chosenPort = server.address().port;
-        const body = `----13068458571765726332503797717\r
-Content-Disposition: form-data; name="title"\r
-\r
-a\r
-----13068458571765726332503797717\r
-Content-Disposition: form-data; name="multipleFiles"; filename="x.txt"\r
-Content-Type: application/x-javascript\r
-\r
-\r
-\r
-a\r
-b\r
-c\r
-d\r
-\r
-----13068458571765726332503797717--\r
-`;
-        await fetch(String(new URL(`http:localhost:${chosenPort}/`)), {
-          method: 'POST',
-
-          headers: {
-            'Content-Length': body.length,
-            Host: `localhost:${chosenPort}`,
-            'Content-Type':
-              'multipart/form-data; boundary=--13068458571765726332503797717',
-          },
-          body,
-        }).catch((err) => {
-          console.error(err);
-          done(err);
-        });
-        server.close(() => {
-          done();
-        });
-      });
-    });
-  });
-  it('middleware with a problem', async () => {
-    expect.assertions(1);
-
-    await new Promise((done) => {
-      // from https://github.com/node-formidable/formidable/blob/master/test-node/standalone/promise.test.js
-
-      const server = createServer(async (req, res) => {
-        req.appInfo = {};
-        const middleware = new RequestParser(global.server.app);
-        middleware.middleware(req, {}, (err) => {
-          expect(err).toBeDefined();
-
-          res.writeHead(200);
-          res.end('ok');
-        });
-      });
-      server.listen(null, async () => {
-        const chosenPort = server.address().port;
-        const body = 'someBadBody';
-
-        await fetch(String(new URL(`http:localhost:${chosenPort}/`)), {
-          method: 'POST',
-
-          headers: {
-            'Content-Length': body.length,
-            Host: `localhost:${chosenPort}`,
-            'Content-Type': 'badContentType',
-          },
-          body,
-        }).catch((err) => {
-          console.error(err);
-          done(err);
-        });
-        server.close(() => {
-          done();
-        });
-      });
-    });
-  });
-});

package/services/http/middleware/Role.test.js

@@ -1,93 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import Role from './Role.js';
-
-describe('role middleware methods', () => {
-  it('have description fields', async () => {
-    expect.assertions(1);
-    const middleware = new Role(global.server.app);
-    expect(middleware.constructor.description).toBeDefined();
-  });
-
-  it('middleware pass when user presented with a right role', async () => {
-    expect.assertions(1);
-    let isCalled = false;
-    const nextFunction = () => {
-      isCalled = true;
-    };
-    const req = {
-      appInfo: {
-        user: {
-          roles: ['role1', 'role2'],
-        },
-      },
-    };
-    const middleware = new Role(global.server.app, {
-      roles: ['admin', 'role1'],
-    });
-
-    await middleware.middleware(req, {}, nextFunction);
-    expect(isCalled).toBeTruthy();
-  });
-
-  it('middleware NOT pass when user NOT presented', async () => {
-    expect.assertions(3);
-    let isCalled = false;
-    let status;
-    let isSend;
-    const nextFunction = () => {
-      isCalled = true;
-    };
-    const req = {
-      appInfo: {}, // no user
-    };
-    const middleware = new Role(global.server.app);
-    await middleware.middleware(
-      req,
-      {
-        status(statusCode) {
-          status = statusCode;
-          return this;
-        },
-        json() {
-          isSend = true;
-        },
-      },
-      nextFunction,
-    );
-    expect(isCalled).toBeFalsy();
-    expect(status).toBe(401);
-    expect(isSend).toBeTruthy();
-  });
-
-  it('middleware NOT pass when user  have a wrong role', async () => {
-    expect.assertions(3);
-    let isCalled = false;
-    let status;
-    let isSend;
-    const nextFunction = () => {
-      isCalled = true;
-    };
-    const req = {
-      appInfo: {
-        user: { roles: ['role1', 'role2'] },
-      },
-    };
-    const middleware = new Role(global.server.app, { roles: ['admin'] });
-    await middleware.middleware(
-      req,
-      {
-        status(statusCode) {
-          status = statusCode;
-          return this;
-        },
-        json() {
-          isSend = true;
-        },
-      },
-      nextFunction,
-    );
-    expect(isCalled).toBeFalsy();
-    expect(status).toBe(403);
-    expect(isSend).toBeTruthy();
-  });
-});

package/services/http/middleware/StaticFiles.js

@@ -1,59 +0,0 @@
-import fsPromises from 'node:fs/promises';
-import fs from 'node:fs';
-import path from 'node:path';
-import mime from 'mime';
-import AbstractMiddleware from './AbstractMiddleware.js';
-/**
- * Middleware for static files
- */
-class StaticFiles extends AbstractMiddleware {
-  constructor(app, params) {
-    super(app);
-    this.params = params;
-    if (!params || !params.folders || !params.folders.length) {
-      throw new Error('StaticFiles inited without folders config');
-    }
-  }
-
-  static get description() {
-    return 'Static file server middleware. Host you static files from public foolder. Mostly for dev.';
-  }
-
-  async middleware(req, res, next) {
-    if (req.method !== 'GET') {
-      // only get supported
-      return next();
-    }
-    const { folders } = this.params;
-
-    const promises = [];
-
-    for (const f of folders) {
-      const filePath = path.join(f, req.url);
-      promises.push(
-        fsPromises
-          .stat(filePath)
-          .catch(() => {
-            // nothing there, file just not exists
-          })
-          .then((stats) => ({ stats, file: filePath })),
-      );
-    }
-
-    const fileStats = await Promise.all(promises);
-
-    for (const fileStat of fileStats) {
-      if (fileStat.stats && fileStat.stats.isFile()) {
-        const contentType = mime.getType(fileStat.file);
-        const fileStream = fs.createReadStream(fileStat.file);
-        res.set('Content-Type', contentType);
-        fileStream.pipe(res);
-        return null;
-      }
-    }
-
-    return next();
-  }
-}
-
-export default StaticFiles;

package/services/validate/ValidateService.test.js

@@ -1,107 +0,0 @@
-import { describe, it, expect } from 'vitest';
-
-import yup from 'yup';
-import ValidateService from './ValidateService.js';
-import YupValidator from './drivers/YupValidator.js';
-import CustomValidator from './drivers/CustomValidator.js';
-
-describe('validate service', () => {
-  describe('validateSchema funtion', () => {
-    const data = {
-      name: '1213123123',
-    };
-    const req = {};
-
-    it('returns an empty object if no validator is provided', async () => {
-      expect.assertions(1);
-      const result = await new ValidateService(
-        global.server.app,
-        new YupValidator(
-          global.server.app,
-          yup.object().shape({ name: '123' }),
-        ),
-      ).validateSchema(req, undefined, data);
-      expect(result).toStrictEqual({});
-    });
-
-    it('calls validateFields and castFields if validator is provided', async () => {
-      expect.assertions(1);
-      const validator = new YupValidator(
-        global.server.app,
-        yup.object().shape({ name: yup.string() }),
-      );
-      const result = await new ValidateService(
-        global.server.app,
-        {},
-      ).validateSchema(req, validator, data);
-      expect(result).toStrictEqual({
-        name: '1213123123',
-      });
-    });
-  });
-
-  describe('isValidatorExists funtion', () => {
-    it('returns false for non-object input', () => {
-      expect.assertions(1);
-      const validator = 'not an object';
-      const result = ValidateService.isValidatorExists(validator);
-      expect(result).toBeFalsy();
-    });
-
-    it('returns true if validator is an instance of one of the drivers', () => {
-      expect.assertions(1);
-      const validator = new ValidateService.drivers.YupValidator();
-      const result = ValidateService.isValidatorExists(validator);
-      expect(result).toBeTruthy();
-    });
-
-    it('returns false if validator is not an instance of any of the drivers', () => {
-      expect.assertions(1);
-      const validator = {};
-      const result = ValidateService.isValidatorExists(validator);
-      expect(result).toBeFalsy();
-    });
-  });
-
-  describe('getDriverByValidatorBody', () => {
-    it('should return the body if it is already a validator', () => {
-      expect.assertions(1);
-      const body = new YupValidator(
-        global.server.app,
-        yup.object().shape({ name: yup.string() }),
-      );
-
-      const validator = ValidateService.getDriverByValidatorBody(
-        global.server.app,
-        body,
-      );
-
-      expect(validator).toStrictEqual(body);
-    });
-
-    it('should return a YupValidator instance if the body is a Yup schema', () => {
-      expect.assertions(1);
-      const body = yup.object().shape({
-        name: '1234',
-      });
-
-      const validator = ValidateService.getDriverByValidatorBody(
-        global.server.app,
-        body,
-      );
-
-      expect(validator).toBeInstanceOf(YupValidator);
-    });
-
-    it('should return CustomValidator if the body is neither a validator nor a Yup schema', () => {
-      expect.assertions(1);
-      const body = 'string';
-      const validator = ValidateService.getDriverByValidatorBody(
-        global.server.app,
-        body,
-      );
-
-      expect(validator).toBeInstanceOf(CustomValidator);
-    });
-  });
-});