lesgo 0.7.8 → 2.1.0

package/src/middlewares/verifyJwtMiddleware.js

@@ -1,62 +0,0 @@
-import config from 'Config/jwt'; // eslint-disable-line import/no-unresolved
-import JwtService from '../services/JwtService';
-import LesgoException from '../exceptions/LesgoException';
-
-export const token = headers => {
-  const authorizationHeader = headers.Authorization || headers.authorization;
-
-  if (!authorizationHeader) {
-    throw new LesgoException(
-      'Authorization Header is required!',
-      'JWT_MISSING_AUTHORIZATION_HEADER',
-      403
-    );
-  }
-
-  const parsed = authorizationHeader.split(' ');
-
-  if (!parsed[1]) {
-    throw new LesgoException(
-      'Missing Bearer token!',
-      'JWT_MISSING_BEARER_TOKEN',
-      403
-    );
-  }
-
-  return parsed[1];
-};
-
-export const verifyJwtMiddlewareBeforeHandler = (handler, next, opts) => {
-  const { headers } = handler.event;
-
-  const finalConfig =
-    typeof opts !== 'undefined' && 'jwtConfig' in opts
-      ? opts.jwtConfig
-      : config;
-
-  try {
-    const service = new JwtService(token(headers), finalConfig);
-
-    // eslint-disable-next-line no-param-reassign
-    handler.event.decodedJwt = service.validate().decoded;
-
-    next();
-  } catch (err) {
-    if (err.name === 'JsonWebTokenError') {
-      throw new LesgoException(err.message, 'JWT_ERROR', 403);
-    } else if (err.name === 'TokenExpiredError') {
-      throw new LesgoException(err.message, 'JWT_EXPIRED', 403);
-    } else {
-      throw err;
-    }
-  }
-};
-
-const verifyJwtMiddleware /* istanbul ignore next */ = opts => {
-  return {
-    before: (handler, next) =>
-      verifyJwtMiddlewareBeforeHandler(handler, next, opts),
-  };
-};
-
-export default verifyJwtMiddleware;

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;
-  }
-}