lesgo 1.0.0 → 2.1.0

package/src/services/AuroraDbRDSProxyService.js

@@ -1,182 +0,0 @@
-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 } = opts;
-
-    this.clientOpts = {
-      host,
-      user,
-      password,
-      database,
-    };
-
-    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;
-
-    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,111 +0,0 @@
-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 = {}) {
-    this.client = null;
-    this.connect(opts);
-  }
-
-  connect(opts) {
-    const { secretArn, resourceArn, database, region } = opts;
-
-    const clientOpts = {
-      secretArn,
-      resourceArn,
-      database,
-    };
-
-    if (region) {
-      clientOpts.region = region;
-    }
-
-    this.client = dataApiClient(clientOpts);
-  }
-
-  async query(sql, sqlParams) {
-    try {
-      logger.debug(`${FILE}::QUERYING_DB`, { sql, sqlParams });
-      const resp = await this.client.query(sql, sqlParams);
-      logger.debug(`${FILE}::DB_RESPONSE`, { resp });
-
-      return resp;
-    } catch (err) {
-      throw new LesgoException(
-        'Exception caught executing SQL Statement',
-        'AURORADBSERVICE_QUERY_EXCEPTION',
-        500,
-        { err }
-      );
-    }
-  }
-
-  async select(sql, sqlParams) {
-    const resp = await this.query(sql, sqlParams);
-    return resp.records;
-  }
-
-  async selectFirst(sql, sqlParams) {
-    const resp = await this.query(sql, sqlParams);
-    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);
-
-    if (resp.numberOfRecordsUpdated <= 0) {
-      throw new LesgoException(
-        'No records inserted from INSERT query',
-        'AURORADBSERVICE_NO_RECORDS_INSERTED',
-        400,
-        { resp, sql, sqlParams }
-      );
-    }
-
-    return resp.insertId;
-  }
-
-  async update(sql, sqlParams) {
-    const resp = await this.query(sql, sqlParams);
-
-    if (resp.numberOfRecordsUpdated <= 0) {
-      throw new LesgoException(
-        'No records updated from UPDATE query',
-        'AURORADBSERVICE_NO_RECORDS_UPDATED',
-        400,
-        { resp, sql, sqlParams }
-      );
-    }
-
-    return Promise.resolve();
-  }
-}

package/src/services/DynamoDbService.js

@@ -1,177 +0,0 @@
-import { DocumentClient } from 'aws-sdk/clients/dynamodb'; // eslint-disable-line import/no-extraneous-dependencies
-import LesgoException from '../exceptions/LesgoException';
-import logger from '../utils/logger';
-
-const FILE = 'Lesgo/services/DynamoDbService';
-
-export default class DynamoDb {
-  constructor(opts = {}) {
-    this.client = null;
-    this.connect(opts);
-  }
-
-  connect(opts) {
-    const { region } = opts;
-
-    if (!region)
-      throw new LesgoException(
-        'Missing required parameter region',
-        'DYNAMODB_MISSING_PARAMETER',
-        500,
-        { opts }
-      );
-
-    this.client = new DocumentClient({ region });
-  }
-
-  async query(
-    tableName,
-    keyConditionExpression,
-    expressionAttributeValues,
-    projectionExpression
-  ) {
-    const params = this.prepareQueryPayload(
-      tableName,
-      keyConditionExpression,
-      expressionAttributeValues,
-      projectionExpression
-    );
-
-    logger.debug(`${FILE}::PREPARING_QUERY`, { params });
-
-    try {
-      const data = await this.client.query(params).promise();
-      logger.debug(`${FILE}::RECEIVED_QUERY_RESPONSE`, { data });
-      return data.Items;
-    } catch (err) {
-      throw new LesgoException(
-        'EXCEPTION ENCOUNTERED FOR DYNAMODB QUERY OPERATION',
-        'DYNAMODB_QUERY_EXCEPTION',
-        500,
-        { err, params }
-      );
-    }
-  }
-
-  async queryCount(
-    tableName,
-    keyConditionExpression,
-    expressionAttributeValues
-  ) {
-    const params = this.prepareQueryCountPayload(
-      tableName,
-      keyConditionExpression,
-      expressionAttributeValues
-    );
-
-    logger.debug(`${FILE}::PREPARING_QUERY_COUNT`, { params });
-
-    try {
-      const data = await this.client.query(params).promise();
-      logger.debug(`${FILE}::RECEIVED_QUERY_COUNT_RESPONSE`, { data });
-      return data.Count;
-    } catch (err) {
-      throw new LesgoException(
-        'EXCEPTION ENCOUNTERED FOR DYNAMODB QUERY COUNT OPERATION',
-        'DYNAMODB_QUERY_COUNT_EXCEPTION',
-        500,
-        { err, params }
-      );
-    }
-  }
-
-  async put(tableName, item) {
-    const params = this.preparePutPayload(tableName, item);
-
-    logger.debug(`${FILE}::PREPARING_PUT`, { params });
-
-    try {
-      const data = await this.client.put(params).promise();
-      logger.debug(`${FILE}::RECEIVED_PUT_RESPONSE`, { data });
-      return data;
-    } catch (err) {
-      throw new LesgoException(
-        'EXCEPTION ENCOUNTERED FOR DYNAMODB PUT OPERATION',
-        'DYNAMODB_PUT_EXCEPTION',
-        500,
-        { err, params }
-      );
-    }
-  }
-
-  async update(tableName, key, updateExpression, expressionAttributeValues) {
-    const params = this.prepareUpdatePayload(
-      tableName,
-      key,
-      updateExpression,
-      expressionAttributeValues
-    );
-
-    logger.debug(`${FILE}::PREPARING_UPDATE`, { params });
-
-    try {
-      const data = await this.client.update(params).promise();
-      logger.debug(`${FILE}::RECEIVED_UPDATE_RESPONSE`, { data });
-      return data;
-    } catch (err) {
-      throw new LesgoException(
-        'EXCEPTION ENCOUNTERED FOR DYNAMODB UPDATE OPERATION',
-        'DYNAMODB_UPDATE_EXCEPTION',
-        500,
-        { err, params }
-      );
-    }
-  }
-
-  // eslint-disable-next-line class-methods-use-this
-  prepareQueryPayload(
-    tableName,
-    keyConditionExpression,
-    expressionAttributeValues,
-    projectionExpression
-  ) {
-    return {
-      TableName: tableName,
-      KeyConditionExpression: keyConditionExpression,
-      ProjectionExpression: projectionExpression,
-      ExpressionAttributeValues: expressionAttributeValues,
-    };
-  }
-
-  // eslint-disable-next-line class-methods-use-this
-  prepareQueryCountPayload(
-    tableName,
-    keyConditionExpression,
-    expressionAttributeValues
-  ) {
-    return {
-      TableName: tableName,
-      KeyConditionExpression: keyConditionExpression,
-      ExpressionAttributeValues: expressionAttributeValues,
-      Select: 'COUNT',
-    };
-  }
-
-  // eslint-disable-next-line class-methods-use-this
-  preparePutPayload(tableName, item) {
-    return {
-      TableName: tableName,
-      Item: item,
-    };
-  }
-
-  // eslint-disable-next-line class-methods-use-this
-  prepareUpdatePayload(
-    tableName,
-    key,
-    updateExpression,
-    expressionAttributeValues
-  ) {
-    return {
-      TableName: tableName,
-      Key: key,
-      UpdateExpression: updateExpression,
-      ExpressionAttributeValues: expressionAttributeValues,
-    };
-  }
-}

package/src/services/ElastiCacheService.js

@@ -1,17 +0,0 @@
-import MemcachePlus from 'memcache-plus';
-
-export default class ElastiCacheService {
-  constructor(options) {
-    // @TODO:
-    // - determine the driver used 'memcached' or 'redis'
-    // - add switch-case that will set the driver
-
-    this.setDriver(new MemcachePlus(options));
-  }
-
-  setDriver(driver) {
-    this.driver = driver;
-
-    return this;
-  }
-}

package/src/services/ElasticsearchService.js

@@ -1,181 +0,0 @@
-import {
-  Client as ElasticsearchClient,
-  Connection as DefaultConnection,
-} from '@elastic/elasticsearch';
-import AwsConnection from './aws/AwsElasticsearchConnection';
-
-class ElasticsearchService {
-  constructor({ index, type, connection, options }) {
-    this.index = index;
-    this.type = type;
-    this.options = options;
-
-    this.setConnection(connection);
-  }
-
-  setConnection(conn) {
-    let Connection = null;
-
-    switch (conn) {
-      case 'aws':
-        Connection = AwsConnection;
-        break;
-
-      default:
-        Connection = DefaultConnection;
-        break;
-    }
-
-    this.client = new ElasticsearchClient({
-      ...this.options,
-      Connection,
-    });
-
-    return this;
-  }
-
-  getClient() {
-    return this.client;
-  }
-
-  async search(body) {
-    const param = {
-      index: this.index,
-      type: this.type,
-      body,
-    };
-
-    const response = await this.client.search(param);
-
-    this.result = response;
-
-    return response;
-  }
-
-  /**
-   * @param {*} settings
-   * @param {*} index
-   *
-   *  const settings = {
-   *    index: {
-   *       number_of_shards: 3,
-   *       number_of_replicas: 2,
-   *     },
-   *   };
-   */
-  createIndices(settings, index = null) {
-    const params = {
-      index: index || this.index,
-      body: settings,
-    };
-
-    return this.client.indices.create(params);
-  }
-
-  deleteIndices(index, options = {}) {
-    const params = {
-      index,
-      ...options,
-    };
-
-    return this.client.indices.delete(params);
-  }
-
-  async existIndices(index, options = {}) {
-    const params = { index, ...options };
-
-    const response = await this.client.indices.exists(params);
-    return response.body;
-  }
-
-  putMapping(index, type, body) {
-    const params = { index, type, body: { properties: body } };
-
-    return this.client.indices.putMapping(params);
-  }
-
-  get(id) {
-    const params = {
-      index: this.index,
-      type: this.type,
-      id,
-    };
-
-    return this.client.get(params);
-  }
-
-  /**
-   * Multi search API
-   *
-   * Executes several searches with a single API request.
-   *
-   * @see https://www.elastic.co/guide/en/elasticsearch/reference/7.16/search-multi-search.html
-   */
-  msearch(body) {
-    return this.client.msearch({ body });
-  }
-
-  indexOrCreateById(body, refresh = false) {
-    const params = {
-      index: this.index,
-      type: this.type,
-      id: body.id,
-      body,
-      refresh,
-    };
-
-    return this.client.index(params);
-  }
-
-  bulkIndex(bodies) {
-    return this.client.bulk({ body: this.constructBulkIndex(bodies) });
-  }
-
-  create(id, body) {
-    const params = {
-      index: this.index,
-      type: this.type,
-      id,
-      body,
-    };
-
-    return this.client.index(params);
-  }
-
-  updateById(id) {
-    const params = {
-      index: this.index,
-      type: this.type,
-      id,
-    };
-
-    return this.client.get(params);
-  }
-
-  /**
-   * Bulk operation very confusing if read from documentation
-   * use this example from blogs instead
-   *
-   * @ref https://taohiko.wordpress.com/2014/10/15/example-javascript-to-use-bulk-command-of-elasticsearch/
-   */
-  constructBulkIndex(bodies) {
-    const bulk = [];
-
-    bodies.forEach(body => {
-      // array 0 - add index operation
-      bulk.push({
-        index: {
-          _index: this.index,
-          _type: this.type,
-          _id: body.profile_id,
-        },
-      });
-      // array 1 - profile attributes
-      bulk.push(body);
-    });
-
-    return bulk;
-  }
-}
-
-export default ElasticsearchService;