lesgo 0.6.0 → 0.7.0

package/src/services/AuroraDbRDSProxyService.js

@@ -0,0 +1,183 @@
+import mysql from 'mysql2/promise';
+import logger from '../utils/logger';
+import isEmpty from '../utils/isEmpty';
+import LesgoException from '../exceptions/LesgoException';
+import LengthAwarePaginator from './pagination/LengthAwarePaginator';
+import Paginator from './pagination/Paginator';
+
+const FILE = 'Lesgo/services/AuroraDbRDSProxyService';
+
+/**
+ * Service to connect to AWS Aurora Provisioned MySQL Database via RDS Proxy.
+ * Use Services/AuroraDbServerlessService for the Serverless type via Data API.
+ */
+export default class AuroraDbRDSProxyService {
+  constructor(opts = {}) {
+    const { host, user, password, database, persists } = opts;
+
+    this.clientOpts = {
+      host,
+      user,
+      password,
+      database,
+      persists,
+    };
+
+    this.conn = {};
+  }
+
+  /**
+   * Persists the database connection for later use
+   *
+   * @param {*} connectionOpts
+   * @returns
+   */
+  async pConnect(connectionOpts = {}) {
+    await this.connect({ ...connectionOpts, persists: true });
+  }
+
+  async connect(connectionOpts = {}) {
+    const clientOpts = {
+      host: connectionOpts.host ? connectionOpts.host : this.clientOpts.host,
+      user: connectionOpts.user ? connectionOpts.user : this.clientOpts.user,
+      password: connectionOpts.password
+        ? connectionOpts.password
+        : this.clientOpts.password,
+      database: connectionOpts.database
+        ? connectionOpts.database
+        : this.clientOpts.database,
+    };
+
+    const persistentConn = connectionOpts.persists || this.clientOpts.persists;
+
+    logger.debug(`${FILE}::PREPARING DB CONNECTION`, {
+      clientOpts,
+      persistentConn,
+    });
+
+    const conn = await mysql.createConnection(clientOpts);
+    conn.config.namedPlaceholders = true;
+    logger.debug(`${FILE}::DB CONNECTED`);
+
+    if (persistentConn) {
+      this.conn = conn;
+    }
+
+    return conn;
+  }
+
+  /* eslint-disable-next-line class-methods-use-this */
+  async end(conn = {}) {
+    logger.debug(`${FILE}::ENDING DB CONNECTION`);
+    if (!isEmpty(conn)) {
+      await conn.end();
+      logger.debug(`${FILE}::DB DISCONNECTED`);
+    } else {
+      await this.conn.end();
+      logger.debug(`${FILE}::PERSISTED DB DISCONNECTED`);
+    }
+  }
+
+  async query(sql, sqlParams, connectionOpts = {}) {
+    let conn = {};
+    if (!isEmpty(connectionOpts)) {
+      conn = await this.connect(connectionOpts);
+    } else if (isEmpty(this.conn)) {
+      conn = await this.connect();
+    } else {
+      conn = this.conn;
+    }
+
+    try {
+      logger.debug(`${FILE}::QUERYING_DB`, { sql, sqlParams });
+      const [results, fields] = await conn.execute(sql, sqlParams);
+      logger.debug(`${FILE}::DB_RESPONSE`, { results, fields });
+
+      return { results, fields };
+    } catch (err) {
+      throw new LesgoException(
+        'Exception caught executing SQL Statement',
+        `${FILE}::QUERY_EXECUTION_EXCEPTION`,
+        500,
+        { err }
+      );
+    } finally {
+      if (isEmpty(this.conn) || !isEmpty(connectionOpts)) await this.end(conn);
+    }
+  }
+
+  async select(sql, sqlParams, connectionOpts = {}) {
+    const resp = await this.query(sql, sqlParams, connectionOpts);
+    return resp.results;
+  }
+
+  async selectFirst(sql, sqlParams, connectionOpts = {}) {
+    const resp = await this.query(sql, sqlParams, connectionOpts);
+    return resp.results[0];
+  }
+
+  async selectPaginate(
+    sql,
+    sqlParams,
+    perPage = 10,
+    currentPage = 1,
+    total = null,
+    connectionOpts = {}
+  ) {
+    let paginator;
+    if (typeof total === 'number') {
+      paginator = new LengthAwarePaginator(
+        this,
+        sql,
+        sqlParams,
+        {
+          perPage,
+          currentPage,
+          total,
+        },
+        connectionOpts
+      );
+    } else {
+      paginator = new Paginator(
+        this,
+        sql,
+        sqlParams,
+        {
+          perPage,
+          currentPage,
+        },
+        connectionOpts
+      );
+    }
+
+    return (await paginator).toObject();
+  }
+
+  async insert(sql, sqlParams, connectionOpts = {}) {
+    const resp = await this.query(sql, sqlParams, connectionOpts);
+
+    if (resp.results.affectedRows <= 0) {
+      throw new LesgoException(
+        'No records inserted from INSERT query',
+        `${FILE}::NO_RECORDS_INSERTED`,
+        400,
+        { resp, sql, sqlParams }
+      );
+    }
+
+    return resp.results.insertId;
+  }
+
+  async update(sql, sqlParams, connectionOpts = {}) {
+    const resp = await this.query(sql, sqlParams, connectionOpts);
+
+    if (resp.results.changedRows <= 0) {
+      logger.warn(`${FILE}::No records updated from UPDATE query`, {
+        sql,
+        sqlParams,
+      });
+    }
+
+    return Promise.resolve();
+  }
+}

package/src/services/AuroraDbService.js

@@ -1,6 +1,10 @@
 import dataApiClient from 'data-api-client';
 import logger from '../utils/logger';
 import LesgoException from '../exceptions/LesgoException';
+import LengthAwarePaginator from './pagination/LengthAwarePaginator';
+import Paginator from './pagination/Paginator';
+
+const FILE = 'Lesgo/services/AuroraDbService';
 
 export default class AuroraDbService {
   constructor(opts = {}) {
@@ -9,20 +13,26 @@ export default class AuroraDbService {
   }
 
   connect(opts) {
-    const { secretArn, resourceArn, database } = opts;
+    const { secretArn, resourceArn, database, region } = opts;
 
-    this.client = dataApiClient({
+    const clientOpts = {
       secretArn,
       resourceArn,
       database,
-    });
+    };
+
+    if (region) {
+      clientOpts.region = region;
+    }
+
+    this.client = dataApiClient(clientOpts);
   }
 
   async query(sql, sqlParams) {
     try {
-      logger.info('QUERYING AURORA DB', { sql, sqlParams });
+      logger.debug(`${FILE}::QUERYING_DB`, { sql, sqlParams });
       const resp = await this.client.query(sql, sqlParams);
-      logger.info('AURORA DB RESPONSE', { resp });
+      logger.debug(`${FILE}::DB_RESPONSE`, { resp });
 
       return resp;
     } catch (err) {
@@ -45,6 +55,30 @@ export default class AuroraDbService {
     return resp.records[0];
   }
 
+  async selectPaginate(
+    sql,
+    sqlParams,
+    perPage = 10,
+    currentPage = 1,
+    total = null
+  ) {
+    let paginator;
+    if (typeof total === 'number') {
+      paginator = new LengthAwarePaginator(this, sql, sqlParams, {
+        perPage,
+        currentPage,
+        total,
+      });
+    } else {
+      paginator = new Paginator(this, sql, sqlParams, {
+        perPage,
+        currentPage,
+      });
+    }
+
+    return (await paginator).toObject();
+  }
+
   async insert(sql, sqlParams) {
     const resp = await this.query(sql, sqlParams);
 

package/src/services/DynamoDbService.js

@@ -2,6 +2,8 @@ import { DocumentClient } from 'aws-sdk/clients/dynamodb'; // eslint-disable-lin
 import LesgoException from '../exceptions/LesgoException';
 import logger from '../utils/logger';
 
+const FILE = 'Lesgo/services/DynamoDbService';
+
 export default class DynamoDb {
   constructor(opts = {}) {
     this.client = null;
@@ -35,11 +37,11 @@ export default class DynamoDb {
       projectionExpression
     );
 
-    logger.info('PREPARING TO QUERY DYNAMODB', { params });
+    logger.debug(`${FILE}::PREPARING_QUERY`, { params });
 
     try {
       const data = await this.client.query(params).promise();
-      logger.info('RECEIVED RESPONSE FROM DYNAMODB', { data });
+      logger.debug(`${FILE}::RECEIVED_QUERY_RESPONSE`, { data });
       return data.Items;
     } catch (err) {
       throw new LesgoException(
@@ -62,11 +64,11 @@ export default class DynamoDb {
       expressionAttributeValues
     );
 
-    logger.info('PREPARING TO QUERY COUNT DYNAMODB', { params });
+    logger.debug(`${FILE}::PREPARING_QUERY_COUNT`, { params });
 
     try {
       const data = await this.client.query(params).promise();
-      logger.info('RECEIVED RESPONSE FROM DYNAMODB', { data });
+      logger.debug(`${FILE}::RECEIVED_QUERY_COUNT_RESPONSE`, { data });
       return data.Count;
     } catch (err) {
       throw new LesgoException(
@@ -81,11 +83,11 @@ export default class DynamoDb {
   async put(tableName, item) {
     const params = this.preparePutPayload(tableName, item);
 
-    logger.info('PREPARING TO PUT ITEM TO DYNAMODB', { params });
+    logger.debug(`${FILE}::PREPARING_PUT`, { params });
 
     try {
       const data = await this.client.put(params).promise();
-      logger.info('RECEIVED RESPONSE FROM DYNAMODB', { data });
+      logger.debug(`${FILE}::RECEIVED_PUT_RESPONSE`, { data });
       return data;
     } catch (err) {
       throw new LesgoException(
@@ -105,11 +107,11 @@ export default class DynamoDb {
       expressionAttributeValues
     );
 
-    logger.info('PREPARING TO UPDATE ITEM ON DYNAMODB', { params });
+    logger.debug(`${FILE}::PREPARING_UPDATE`, { params });
 
     try {
       const data = await this.client.update(params).promise();
-      logger.info('RECEIVED RESPONSE FROM DYNAMODB', { data });
+      logger.debug(`${FILE}::RECEIVED_UPDATE_RESPONSE`, { data });
       return data;
     } catch (err) {
       throw new LesgoException(

package/src/services/FirebaseAdminService.js

@@ -3,6 +3,8 @@ 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;
@@ -30,13 +32,13 @@ export default class FirebaseAdmin {
     const max = !isEmpty(maxResults) ? maxResults : 25;
 
     try {
-      logger.info('FETCHING FIREBASE USERS', {
+      logger.debug(`${FILE}::FETCHING_USERS`, {
         max,
         maxResults,
         nextPageToken,
       });
       const users = await this.app.auth().listUsers(max, nextPageToken);
-      logger.info('FETCHED FIREBASE USERS', { users });
+      logger.debug(`${FILE}::USERS_FETCHED`, { users });
       return users.users;
     } catch (err) {
       throw new LesgoException(
@@ -58,9 +60,9 @@ export default class FirebaseAdmin {
         displayName: username,
       };
 
-      logger.info('CREATING USER ON FIREBASE', { userData, data });
+      logger.debug(`${FILE}::CREATING_USER`, { userData, data });
       const user = await this.app.auth().createUser(userData);
-      logger.info('USER CREATED ON FIREBASE', { user });
+      logger.debug(`${FILE}::USER_CREATED`, { user });
       return user;
     } catch (err) {
       throw new LesgoException(
@@ -74,9 +76,9 @@ export default class FirebaseAdmin {
 
   async deleteUser(uid) {
     try {
-      logger.info('DELETING FIREBASE USER');
+      logger.debug(`${FILE}::DELETING_USER`);
       const deleted = await this.app.auth().deleteUser(uid);
-      logger.info('DELETED FIREBASE USER', { deleted, uid });
+      logger.debug(`${FILE}::USER_DELETED`, { deleted, uid });
       return deleted;
     } catch (err) {
       throw new LesgoException(
@@ -90,8 +92,9 @@ export default class FirebaseAdmin {
 
   async delete() {
     try {
-      logger.info('DELETING FIREBASE APP');
+      logger.debug(`${FILE}::DELETING_APP`);
       const resp = await this.app.delete();
+      logger.debug(`${FILE}::APP_DELETED`, { resp });
       return resp;
     } catch (err) {
       throw new LesgoException(

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

@@ -0,0 +1,278 @@
+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);
+  });
+});