lesgo 1.0.0 → 2.1.1

package/src/services/FirebaseAdminService.js

@@ -1,108 +0,0 @@
-import * as firebaseAdmin from 'firebase-admin';
-import logger from '../utils/logger';
-import isEmpty from '../utils/isEmpty';
-import LesgoException from '../exceptions/LesgoException';
-
-const FILE = 'Lesgo/services/FirebaseAdminService';
-
-export default class FirebaseAdmin {
-  constructor(opts = {}) {
-    this.app = null;
-    this.connect(opts);
-  }
-
-  connect(opts) {
-    const { serviceAccount, projectName } = opts;
-
-    if (!serviceAccount || !projectName)
-      throw new LesgoException(
-        'Missing required parameters serviceAccount and or projectName',
-        'FIREBASEADMIN_MISSING_PARAMETERS',
-        500,
-        { opts }
-      );
-
-    this.app = firebaseAdmin.initializeApp({
-      credential: firebaseAdmin.credential.cert(serviceAccount),
-      databaseURL: `https://${projectName}.firebaseio.com`,
-    });
-  }
-
-  async getAllUsers(maxResults, nextPageToken) {
-    const max = !isEmpty(maxResults) ? maxResults : 25;
-
-    try {
-      logger.debug(`${FILE}::FETCHING_USERS`, {
-        max,
-        maxResults,
-        nextPageToken,
-      });
-      const users = await this.app.auth().listUsers(max, nextPageToken);
-      logger.debug(`${FILE}::USERS_FETCHED`, { users });
-      return users.users;
-    } catch (err) {
-      throw new LesgoException(
-        'Failed to fetch all users from firebase',
-        'FIREBASE_FETCH_USERS',
-        500,
-        { err, max, maxResults, nextPageToken }
-      );
-    }
-  }
-
-  async createUser(data) {
-    try {
-      const { uid, email, password, username } = data;
-      const userData = {
-        uid,
-        email,
-        password,
-        displayName: username,
-      };
-
-      logger.debug(`${FILE}::CREATING_USER`, { userData, data });
-      const user = await this.app.auth().createUser(userData);
-      logger.debug(`${FILE}::USER_CREATED`, { user });
-      return user;
-    } catch (err) {
-      throw new LesgoException(
-        'Failed to create user on firebase',
-        'FIREBASE_CREATE_USER',
-        400,
-        { err, data }
-      );
-    }
-  }
-
-  async deleteUser(uid) {
-    try {
-      logger.debug(`${FILE}::DELETING_USER`);
-      const deleted = await this.app.auth().deleteUser(uid);
-      logger.debug(`${FILE}::USER_DELETED`, { deleted, uid });
-      return deleted;
-    } catch (err) {
-      throw new LesgoException(
-        'Failed to delete user from firebase',
-        'FIREBASE_DELETE_USER',
-        400,
-        { err, uid }
-      );
-    }
-  }
-
-  async delete() {
-    try {
-      logger.debug(`${FILE}::DELETING_APP`);
-      const resp = await this.app.delete();
-      logger.debug(`${FILE}::APP_DELETED`, { resp });
-      return resp;
-    } catch (err) {
-      throw new LesgoException(
-        'Failed to delete firebase app',
-        'FIREBASE_DELETE_APP',
-        500,
-        { err }
-      );
-    }
-  }
-}

package/src/services/JwtService.js

@@ -1,52 +0,0 @@
-import jwtpkg from 'jsonwebtoken';
-import LesgoException from '../exceptions/LesgoException';
-
-export default class JwtService {
-  constructor(token, config) {
-    this.jwtpkg = jwtpkg;
-    this.decoded = this.jwtpkg.verify(token, config.secret);
-    this.settings = {
-      validate: {
-        iss: config.iss.validate,
-        customClaims: config.customClaims.validate,
-      },
-      config: {
-        iss: config.iss.data,
-        customClaims: config.customClaims.data,
-      },
-    };
-  }
-
-  validate() {
-    if (
-      this.settings.validate.iss &&
-      this.settings.config.iss.indexOf(this.decoded.iss) === -1
-    ) {
-      throw new LesgoException(
-        `Token's [iss] is not valid!`,
-        'JWT_ISS_NOT_VALID',
-        403
-      );
-    }
-
-    /**
-     * Your conditions here, if you would like to validate
-     * custom claims: https://auth0.com/docs/tokens/jwt-claims
-     */
-    this.settings.config.customClaims.forEach(customClaim => {
-      if (this.settings.validate.customClaims && !this.decoded[customClaim]) {
-        throw new LesgoException(
-          `Token's custom claim [${customClaim}] not found!`,
-          'JWT_CUSTOM_CLAIM_NOT_FOUND',
-          403
-        );
-      }
-    });
-
-    return this;
-  }
-
-  jwt() {
-    return this.jwtpkg;
-  }
-}

package/src/services/S3Service.js

@@ -1,59 +0,0 @@
-// eslint-disable-next-line import/no-extraneous-dependencies
-import { S3 } from 'aws-sdk';
-
-import LesgoException from '../exceptions/LesgoException';
-
-export default class S3Service {
-  constructor(
-    opts = {
-      accessKeyId: null,
-      secretAccessKey: null,
-      region: null,
-    }
-  ) {
-    let options = {};
-
-    if (opts.accessKeyId !== null && opts.accessKeyId !== undefined) {
-      options = { ...options, accessKeyId: opts.accessKeyId };
-    }
-    if (opts.secretAccessKey !== null && opts.secretAccessKey !== undefined) {
-      options = { ...options, secretAccessKey: opts.secretAccessKey };
-    }
-    if (opts.region !== null && opts.region !== undefined) {
-      options = { ...options, region: opts.region };
-    }
-
-    this.s3Instance = new S3({
-      ...{ ...options },
-    });
-  }
-
-  /**
-   * Get S3 bucket object
-   *
-   * @param {object} payload
-   * @param {string} queueName
-   */
-  getObject(key, bucket) {
-    if (key === undefined || key === null) {
-      throw new LesgoException(
-        'Key is undefined in S3Service.getObject()',
-        'S3SERVICE_GETOBJECT_KEY_UNDEFINED'
-      );
-    }
-
-    if (bucket === undefined || bucket === null) {
-      throw new LesgoException(
-        'Bucket is undefined in S3Service.getObject()',
-        'S3SERVICE_GETOBJECT_BUCKET_UNDEFINED'
-      );
-    }
-
-    return this.s3Instance
-      .getObject({
-        Bucket: bucket,
-        Key: key,
-      })
-      .promise();
-  }
-}

package/src/services/SQSService.js

@@ -1,65 +0,0 @@
-// eslint-disable-next-line import/no-extraneous-dependencies
-import { SQS } from 'aws-sdk';
-import LesgoException from '../exceptions/LesgoException';
-
-export default class SQSService {
-  constructor(
-    opts = {
-      accessKeyId: null,
-      secretAccessKey: null,
-      region: null,
-    },
-    queues = {}
-  ) {
-    let options = {};
-
-    if (opts.accessKeyId !== null && opts.accessKeyId !== undefined) {
-      options = { ...options, accessKeyId: opts.accessKeyId };
-    }
-
-    if (opts.secretAccessKey !== null && opts.secretAccessKey !== undefined) {
-      options = { ...options, secretAccessKey: opts.secretAccessKey };
-    }
-
-    if (opts.region !== null && opts.region !== undefined) {
-      options = { ...options, region: opts.region };
-    }
-
-    this.sqsClient = new SQS({
-      ...{ ...options },
-    });
-
-    this.queues = queues;
-  }
-
-  /**
-   * Sends a payload to the queue
-   *
-   * @param {object} payload
-   * @param {string} queueName
-   */
-  dispatch(payload, queueName) {
-    if (payload === undefined) {
-      throw new LesgoException(
-        'payload is undefined in dispatch()',
-        'SQSSERVICE_DISPATCH_PAYLOAD_UNDEFINED'
-      );
-    }
-
-    if (queueName === undefined) {
-      throw new LesgoException(
-        'queueName is undefined in dispatch()',
-        'SQSSERVICE_DISPATCH_QUEUENAME_UNDEFINED'
-      );
-    }
-
-    const queue = this.queues[queueName];
-
-    return this.sqsClient
-      .sendMessage({
-        MessageBody: JSON.stringify(payload),
-        QueueUrl: `${queue.url}`,
-      })
-      .promise();
-  }
-}

package/src/services/__tests__/AuroraDbRDSProxyService.spec.js

@@ -1,278 +0,0 @@
-import mysql from 'mysql2/promise';
-import AuroraDbRDSProxyService from '../AuroraDbRDSProxyService';
-import LesgoException from '../../exceptions/LesgoException';
-
-const auroraConfig = {
-  host: 'some-fake-host',
-  user: 'fakeUsername',
-  password: 'fakePassword',
-  database: 'fakeDbName',
-};
-
-const customConfig = {
-  host: 'some-fake-host-2',
-  user: 'fakeUsername2',
-  password: 'fakePassword2',
-  database: 'fakeDbName2',
-};
-
-describe('test AuroraDbRDSProxyService instantiate', () => {
-  it('should not throw exception when instantiating', () => {
-    const db = new AuroraDbRDSProxyService(auroraConfig);
-    expect(db.clientOpts).toMatchObject(auroraConfig);
-  });
-
-  it('should allow for empty config', () => {
-    const db = new AuroraDbRDSProxyService();
-    expect(db.clientOpts).toMatchObject({});
-  });
-});
-
-describe('test AuroraDbRDSProxyService connect', () => {
-  it('should be able to connect without custom config', async () => {
-    const db = new AuroraDbRDSProxyService(auroraConfig);
-    const conn = await db.connect();
-
-    expect(conn.mocked).toMatchObject(auroraConfig);
-  });
-
-  it('should be able to connect with custom config', async () => {
-    const db = new AuroraDbRDSProxyService(auroraConfig);
-    const conn = await db.connect(customConfig);
-
-    expect(conn.mocked).toMatchObject(customConfig);
-  });
-});
-
-describe('test AuroraDbRDSProxyService query', () => {
-  it('should return results object when calling query function', async () => {
-    const db = new AuroraDbRDSProxyService(auroraConfig);
-    const resp = await db.query('SELECT_QUERY', {});
-
-    expect(resp).toMatchObject({
-      results: [
-        {
-          id: 1,
-          uid: 'some-uid-1',
-        },
-        {
-          id: 2,
-          uid: 'some-uid-2',
-        },
-      ],
-    });
-
-    expect(mysql.createConnection).toHaveBeenCalled();
-  });
-
-  it('should return results object when calling querying with connection options passed', async () => {
-    const db = new AuroraDbRDSProxyService(auroraConfig);
-    const resp = await db.query('SELECT_QUERY', {}, auroraConfig);
-
-    expect(resp).toMatchObject({
-      results: [
-        {
-          id: 1,
-          uid: 'some-uid-1',
-        },
-        {
-          id: 2,
-          uid: 'some-uid-2',
-        },
-      ],
-    });
-
-    expect(mysql.createConnection).toHaveBeenCalled();
-  });
-
-  it('should return results object when calling querying with no connection options passed and persistent conn', async () => {
-    const db = new AuroraDbRDSProxyService(auroraConfig);
-    await db.pConnect();
-    const resp = await db.query('SELECT_QUERY', {});
-
-    expect(resp).toMatchObject({
-      results: [
-        {
-          id: 1,
-          uid: 'some-uid-1',
-        },
-        {
-          id: 2,
-          uid: 'some-uid-2',
-        },
-      ],
-    });
-
-    expect(mysql.createConnection).toHaveBeenCalled();
-  });
-});
-
-describe('test AuroraDbRDSProxyService select', () => {
-  it('should return array results when calling select function', async () => {
-    const db = new AuroraDbRDSProxyService(auroraConfig);
-    return expect(db.select('SELECT_QUERY', {})).resolves.toMatchObject([
-      {
-        id: 1,
-        uid: 'some-uid-1',
-      },
-      {
-        id: 2,
-        uid: 'some-uid-2',
-      },
-    ]);
-  });
-
-  it('should throw an exception when writing with invalid query', async () => {
-    const error = new LesgoException(
-      'Exception caught executing SQL Statement',
-      'AURORADBSERVICE_QUERY_EXCEPTION',
-      500,
-      {
-        err: {
-          code: 'BadRequestException',
-        },
-      }
-    );
-
-    const db = new AuroraDbRDSProxyService(auroraConfig);
-    return expect(db.select('INVALID_QUERY', {})).rejects.toMatchObject(error);
-  });
-
-  it('should throw an exception when calling select with invalid query parameters', async () => {
-    const error = new LesgoException(
-      'Exception caught executing SQL Statement',
-      'AURORADBSERVICE_QUERY_EXCEPTION',
-      500,
-      {
-        err: {
-          code: 'BadRequestException',
-        },
-      }
-    );
-
-    const db = new AuroraDbRDSProxyService(auroraConfig);
-    return expect(
-      db.select('RANDOM_QUERY', 'INVALID_QUERY_PARAMETERS')
-    ).rejects.toMatchObject(error);
-  });
-});
-
-describe('test AuroraDbRDSProxyService selectPaginate', () => {
-  it('should return paginated results when calling selectPaginate function', async () => {
-    const db = new AuroraDbRDSProxyService(auroraConfig);
-    return expect(db.selectPaginate('SELECT_QUERY', {})).resolves.toMatchObject(
-      {
-        count: 2,
-        previous_page: false,
-        current_page: 1,
-        next_page: false,
-        per_page: 10,
-        items: [
-          {
-            id: 1,
-            uid: 'some-uid-1',
-          },
-          {
-            id: 2,
-            uid: 'some-uid-2',
-          },
-        ],
-      }
-    );
-  });
-
-  it('should return paginated results when calling selectPaginate with defined total', async () => {
-    const db = new AuroraDbRDSProxyService(auroraConfig);
-    return expect(
-      db.selectPaginate('SELECT_QUERY', {}, 1, 2, 1)
-    ).resolves.toMatchObject({
-      count: 1,
-      previous_page: 1,
-      current_page: 2,
-      next_page: 3,
-      per_page: 1,
-      items: [
-        {
-          id: 1,
-          uid: 'some-uid-1',
-        },
-      ],
-    });
-  });
-});
-
-describe('test AuroraDbRDSProxyService selectFirst', () => {
-  it('should only return the first record when calling selectFirst', async () => {
-    const db = new AuroraDbRDSProxyService(auroraConfig);
-    return expect(db.selectFirst('SELECT_QUERY', {})).resolves.toMatchObject({
-      id: 1,
-      uid: 'some-uid-1',
-    });
-  });
-});
-
-describe('test AuroraDbRDSProxyService insert', () => {
-  it('should return recordId when inserting record', async () => {
-    const db = new AuroraDbRDSProxyService(auroraConfig);
-    return expect(db.insert('INSERT_QUERY', {})).resolves.toEqual(20);
-  });
-
-  it('should throw exception when calling insert with invalid query', async () => {
-    const error = new LesgoException(
-      'No records inserted from INSERT query',
-      'AURORADBSERVICE_NO_RECORDS_INSERTED',
-      400
-    );
-
-    const db = new AuroraDbRDSProxyService(auroraConfig);
-    return expect(db.insert('INVALID_INSERT_QUERY', {})).rejects.toMatchObject(
-      error
-    );
-  });
-});
-
-describe('test AuroraDbRDSProxyService update', () => {
-  it('should return success when making update query', async () => {
-    const db = new AuroraDbRDSProxyService(auroraConfig);
-    return expect(db.update('UPDATE_QUERY', {})).resolves.not.toThrow();
-  });
-
-  it('should throw not exception when caliing update with invalid query', async () => {
-    const db = new AuroraDbRDSProxyService(auroraConfig);
-    return expect(db.update('INVALID_UPDATE_QUERY', {})).resolves.not.toThrow();
-  });
-});
-
-describe('test AuroraDbRDSProxyService pConnect', () => {
-  it('should be able to connect without custom config', async () => {
-    const db = new AuroraDbRDSProxyService(auroraConfig);
-    await db.pConnect();
-
-    expect(db.conn.mocked).toMatchObject(auroraConfig);
-  });
-
-  it('should be able to connect with custom config', async () => {
-    const db = new AuroraDbRDSProxyService(auroraConfig);
-    await db.pConnect(customConfig);
-
-    expect(db.conn.mocked).toMatchObject(customConfig);
-  });
-});
-
-describe('test AuroraDbRDSProxyService end', () => {
-  it('should end the connection when passed', async () => {
-    const db = new AuroraDbRDSProxyService(auroraConfig);
-    const conn = await db.connect();
-    await db.end(conn);
-
-    expect(conn.end).toHaveBeenCalledTimes(1);
-  });
-
-  it('should end the persisted connection when none is passed', async () => {
-    const db = new AuroraDbRDSProxyService(auroraConfig);
-    await db.pConnect();
-    await db.end();
-
-    expect(db.conn.end).toHaveBeenCalledTimes(1);
-  });
-});