lesgo 1.0.0 → 2.1.1

package/src/utils/__tests__/cache.spec.js

@@ -1,131 +0,0 @@
-import config from 'Config/cache'; // eslint-disable-line import/no-unresolved
-
-import cache from '../cache';
-import isEmpty from '../isEmpty';
-
-export const cacheKey = 'cacheKey';
-export const cacheKey2 = 'cacheKey2';
-export const cacheTime = 10;
-export const cacheData = {
-  someData: [
-    {
-      someDataKey1: 'someDataValue1',
-    },
-    {
-      someDataKey2: 'someDataValue2',
-    },
-  ],
-};
-export const cacheData2 = 'someValue2';
-
-describe('UtilsGroup: test cache utils', () => {
-  it('test cache utils', async () => {
-    await expect(cache.set(cacheKey, cacheData, cacheTime)).resolves.toBe();
-    await expect(cache.set(cacheKey2, cacheData2, cacheTime)).resolves.toBe();
-
-    await expect(cache.get(cacheKey)).resolves.toMatchObject(cacheData);
-    await expect(cache.getMulti([cacheKey, cacheKey2])).resolves.toMatchObject([
-      cacheData,
-      cacheData2,
-    ]);
-
-    await expect(cache.del(cacheKey)).resolves.toBe();
-    await expect(cache.delMulti([cacheKey, cacheKey2])).resolves.toBe();
-
-    await expect(cache.end()).resolves.toBe();
-    await expect(cache.disconnect()).resolves.toBe();
-  });
-
-  it('test connect using legacy config', async () => {
-    config.connections.memcached = {
-      ...config.connections.memcached,
-      url: 'localhost',
-    };
-
-    await cache.pConnect('memcached');
-    expect(Object.keys(cache.singleton)[0]).toEqual('memcached');
-  });
-
-  it('test pConnect', async () => {
-    await cache.pConnect('memcached');
-    expect(Object.keys(cache.singleton)[0]).toEqual('memcached');
-  });
-
-  it('test pConnect without connectionName to default', async () => {
-    await cache.pConnect();
-    expect(Object.keys(cache.singleton)[0]).toEqual('memcached');
-  });
-
-  it('test disconnecting with pConnect', async () => {
-    await cache.pConnect('memcached');
-
-    await expect(cache.end()).resolves.toBe();
-    expect(isEmpty(Object.keys(cache.singleton))).toEqual(true);
-  });
-
-  it('test cache utils with pConnect', async () => {
-    await cache.pConnect('memcached');
-
-    await expect(cache.set(cacheKey, cacheData, cacheTime)).resolves.toBe();
-    await expect(cache.set(cacheKey2, cacheData2, cacheTime)).resolves.toBe();
-
-    await expect(cache.get(cacheKey)).resolves.toMatchObject(cacheData);
-    await expect(cache.getMulti([cacheKey, cacheKey2])).resolves.toMatchObject([
-      cacheData,
-      cacheData2,
-    ]);
-
-    await expect(cache.del(cacheKey)).resolves.toBe();
-    await expect(cache.delMulti([cacheKey, cacheKey2])).resolves.toBe();
-
-    await expect(cache.end()).resolves.toBe();
-    await expect(cache.disconnect()).resolves.toBe();
-  });
-
-  it('test setting cache with exception', async () => {
-    await expect(
-      cache.set('mockException', cacheData, cacheTime)
-    ).rejects.toMatchObject({
-      code: 'CACHE_SET_EXCEPTION',
-      message: 'mockedException',
-      name: 'LesgoException',
-      statusCode: 500,
-    });
-  });
-
-  it('test getting cache with exception', async () => {
-    await expect(cache.get('mockException')).rejects.toMatchObject({
-      code: 'CACHE_GET_EXCEPTION',
-      message: 'mockedException',
-      name: 'LesgoException',
-      statusCode: 500,
-    });
-  });
-
-  it('test getting multiple cache with exception', async () => {
-    await expect(cache.getMulti(['mockException'])).rejects.toMatchObject({
-      code: 'CACHE_GET_MULTI_EXCEPTION',
-      message: 'mockedException',
-      name: 'LesgoException',
-      statusCode: 500,
-    });
-  });
-
-  it('test deleting cache with exception', async () => {
-    await expect(cache.del('mockException')).rejects.toMatchObject({
-      code: 'CACHE_DEL_EXCEPTION',
-      message: 'mockedException',
-      name: 'LesgoException',
-      statusCode: 500,
-    });
-  });
-
-  it('test deleting multiple cache with exception', async () => {
-    await expect(cache.delMulti(['mockException'])).rejects.toMatchObject({
-      code: 'CACHE_DEL_MULTI_EXCEPTION',
-      message: 'mockedException',
-      name: 'LesgoException',
-      statusCode: 500,
-    });
-  });
-});

package/src/utils/__tests__/crypto.spec.js

@@ -1,122 +0,0 @@
-import { encrypt, decrypt, hash, hashMD5 } from '../crypto';
-import LesgoException from '../../exceptions/LesgoException';
-
-describe('test crypto encrypt', () => {
-  it('should return hashed random string', () => {
-    return expect(encrypt('test')).toBeTruthy();
-  });
-
-  test('should throw an Error when empty sting parameters were passed', () => {
-    expect(() => {
-      encrypt('');
-    }).toThrow(
-      new LesgoException(
-        'Empty parameter supplied on encrypt',
-        'CRYPTO_ENCRYPT_EMPTY_PARAMETER'
-      )
-    );
-  });
-
-  test('should throws an Error when null parameters were passed', () => {
-    expect(() => {
-      encrypt(null);
-    }).toThrow(
-      new LesgoException(
-        'Empty parameter supplied on encrypt',
-        'CRYPTO_ENCRYPT_EMPTY_PARAMETER'
-      )
-    );
-  });
-});
-
-describe('test crypto decrypt', () => {
-  test('should throws an Error when empty sting parameters were passed', () => {
-    expect(() => {
-      decrypt('');
-    }).toThrow(
-      new LesgoException(
-        'Empty parameter supplied on decryp',
-        'CRYPTO_DECRYPT_EMPTY_PARAMETER'
-      )
-    );
-  });
-
-  test('should throws an Error when null parameters were passed', () => {
-    expect(() => {
-      decrypt(null);
-    }).toThrow(
-      new LesgoException(
-        'Empty parameter supplied on decryp',
-        'CRYPTO_DECRYPT_EMPTY_PARAMETER'
-      )
-    );
-  });
-
-  it('should return correct string encrypted', () => {
-    const encryptedText = encrypt('test');
-    return expect(decrypt(encryptedText)).toBe('test');
-  });
-});
-
-describe('test crypto hash', () => {
-  it('should return hashed value', () => {
-    const hashValueOfTest =
-      '9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08';
-
-    expect(hash('test')).toBeTruthy();
-    expect(hash('test')).toBe(hashValueOfTest);
-  });
-
-  test('should throws an Error when empty sting parameters were passed', () => {
-    expect(() => {
-      hash('');
-    }).toThrow(
-      new LesgoException(
-        'Empty parameter supplied on hash',
-        'CRYPTO_HASH_EMPTY_PARAMETER'
-      )
-    );
-  });
-
-  test('should throws an Error when null parameters were passed', () => {
-    expect(() => {
-      hash(null);
-    }).toThrow(
-      new LesgoException(
-        'Empty parameter supplied on hash',
-        'CRYPTO_HASH_EMPTY_PARAMETER'
-      )
-    );
-  });
-});
-
-describe('test crypto hashMD5', () => {
-  it('should return hashed value', () => {
-    const hashValueOfTest = '098f6bcd4621d373cade4e832627b4f6';
-
-    expect(hashMD5('test')).toBeTruthy();
-    expect(hashMD5('test')).toBe(hashValueOfTest);
-  });
-
-  test('should throws an Error when empty sting parameters were passed', () => {
-    expect(() => {
-      hashMD5('');
-    }).toThrow(
-      new LesgoException(
-        'Empty parameter supplied on hashMD5',
-        'CRYPTO_HASHMD5_EMPTY_PARAMETER'
-      )
-    );
-  });
-
-  test('should throws an Error when null parameters were passed', () => {
-    expect(() => {
-      hashMD5(null);
-    }).toThrow(
-      new LesgoException(
-        'Empty parameter supplied on hashMD5',
-        'CRYPTO_HASHMD5_EMPTY_PARAMETER'
-      )
-    );
-  });
-});

package/src/utils/__tests__/db.spec.js

@@ -1,70 +0,0 @@
-import config from 'Config/db'; // eslint-disable-line import/no-unresolved
-
-let db;
-
-beforeEach(() => {
-  jest.isolateModules(() => {
-    db = require('../db').default; // eslint-disable-line global-require
-  });
-});
-
-describe('test db utils instantiate', () => {
-  it('should not throw error on instantiating AuroraDbService', () => {
-    return expect(db).toMatchObject({
-      client: {
-        mocked: {
-          database: config.database,
-          resourceArn: config.resourceArn,
-          secretArn: config.secretArn,
-        },
-      },
-    });
-  });
-
-  it('should update AuroraDb credentials on connect', () => {
-    db.connect({
-      database: config.database,
-      resourceArn: config.resourceArn,
-      secretArn: config.secretCommandArn,
-    });
-
-    return expect(db.client).toMatchObject({
-      mocked: {
-        database: config.database,
-        resourceArn: config.resourceArn,
-        secretArn: config.secretCommandArn,
-      },
-    });
-  });
-
-  it('should update AuroraDb credentials on connect based on dataApi config', () => {
-    config.default = 'dataApi';
-    let thisDb;
-    jest.isolateModules(() => {
-      thisDb = require('../db').default; // eslint-disable-line global-require
-    });
-
-    return expect(thisDb.client).toMatchObject({
-      mocked: {
-        database: config.connections.dataApi.database,
-        resourceArn: config.connections.dataApi.resourceArn,
-        secretArn: config.connections.dataApi.secretArn,
-      },
-    });
-  });
-
-  it('should update AuroraDb credentials on connect based on rdsProxy config', () => {
-    config.default = 'rdsProxy';
-    let thisDb;
-    jest.isolateModules(() => {
-      thisDb = require('../db').default; // eslint-disable-line global-require
-    });
-
-    return expect(thisDb.clientOpts).toMatchObject({
-      database: config.connections.rdsProxy.database,
-      host: config.connections.rdsProxy.host,
-      user: config.connections.rdsProxy.user,
-      password: config.connections.rdsProxy.password,
-    });
-  });
-});

package/src/utils/__tests__/dynamodb.spec.js

@@ -1,27 +0,0 @@
-import dynamodb from '../dynamodb';
-
-describe('test dynamodb utils instantiate', () => {
-  it('should not throw error on instantiating DynamoDb', () => {
-    expect(dynamodb.client).toEqual(
-      expect.objectContaining({
-        mocked: {
-          region: 'ap-southeast-1',
-        },
-      })
-    );
-  });
-
-  it('should update DynamoDb region on connect', () => {
-    dynamodb.connect({
-      region: 'us-west-1',
-    });
-
-    expect(dynamodb.client).toEqual(
-      expect.objectContaining({
-        mocked: {
-          region: 'us-west-1',
-        },
-      })
-    );
-  });
-});

package/src/utils/__tests__/elasticsearch.spec.js

@@ -1,43 +0,0 @@
-import es from '../elasticsearch';
-
-// TODO we'll need to add more expected response
-
-describe('UtilsGroup: test elasticsearch utils', () => {
-  it('test creating index', async () => {
-    await expect(
-      es().createIndices({
-        number_of_shards: 3,
-        number_of_replicas: 2,
-      })
-    ).resolves.toMatchObject({
-      data: {},
-      mocked: {
-        params: {
-          body: {
-            number_of_shards: 3,
-            number_of_replicas: 2,
-          },
-          index: 'lesgo',
-        },
-      },
-    });
-
-    // test singleton instance
-    await expect(
-      es().createIndices({
-        number_of_shards: 4,
-        number_of_replicas: 5,
-      })
-    ).resolves.toMatchObject({
-      data: {},
-      mocked: {
-        params: {
-          body: {
-            number_of_shards: 4,
-            number_of_replicas: 5,
-          },
-        },
-      },
-    });
-  });
-});

package/src/utils/__tests__/generateUid.spec.js

@@ -1,36 +0,0 @@
-import generateUid from '../generateUid';
-
-describe('UtilsGroup: test generateUid utils', () => {
-  it('test generating default unique id', async () => {
-    const uid = await generateUid();
-    expect(uid.length).toEqual(21);
-  });
-
-  it('test generating unique id with prefix', async () => {
-    const uid = await generateUid({ prefix: 'somePrefix' });
-    expect(uid.length).toEqual(32);
-    expect(uid.startsWith('somePrefix-')).toBeTruthy();
-  });
-
-  it('test generating unique id with suffix', async () => {
-    const uid = await generateUid({ suffix: 'someSuffix' });
-    expect(uid.length).toEqual(32);
-    expect(uid.endsWith('-someSuffix')).toBeTruthy();
-  });
-
-  it('test generating unique id with custom length', async () => {
-    const uid = await generateUid({ length: 10 });
-    expect(uid.length).toEqual(10);
-  });
-
-  it('test generating unique id with all parameters', async () => {
-    const uid = await generateUid({
-      length: 15,
-      prefix: 'somePrefix',
-      suffix: 'someSuffix',
-    });
-    expect(uid.length).toEqual(37);
-    expect(uid.startsWith('somePrefix-')).toBeTruthy();
-    expect(uid.endsWith('-someSuffix')).toBeTruthy();
-  });
-});

package/src/utils/__tests__/getJwtSubFromAuthHeader.spec.js

@@ -1,20 +0,0 @@
-import getJwtSubFromAuthHeader from '../getJwtSubFromAuthHeader';
-
-const authorizationHeader =
-  'eyJraWQiOiIzSHc3YmRuUHBIMnJSZWhjT3k5NFRLZm5ybzU0Y1RFUW1lcGtVYWc2bW1vPSIsImFsZyI6IlJTMjU2In0.eyJzdWIiOiJmMmI1MzQ5ZC1mNWUzLTQ0ZjUtOWMwOC1hZTZiMDFlOTU0MzQiLCJhdWQiOiI0aHM0a2ZpNTAwZWtkajJhZTdiOWExazU4byIsImVtYWlsX3ZlcmlmaWVkIjpmYWxzZSwiZXZlbnRfaWQiOiJlNzdiZGZmYy0wYjFjLTQzMzMtYWUxZS1lM2QwNjZkNzAyZGMiLCJ0b2tlbl91c2UiOiJpZCIsImF1dGhfdGltZSI6MTYxNTYxMTc3NywiaXNzIjoiaHR0cHM6XC9cL2NvZ25pdG8taWRwLmFwLXNvdXRoZWFzdC0xLmFtYXpvbmF3cy5jb21cL2FwLXNvdXRoZWFzdC0xXzR3QjFuSmNvSyIsImNvZ25pdG86dXNlcm5hbWUiOiJmMmI1MzQ5ZC1mNWUzLTQ0ZjUtOWMwOC1hZTZiMDFlOTU0MzQiLCJleHAiOjE2MTU2MTUzNzcsImlhdCI6MTYxNTYxMTc3NywiZW1haWwiOiJzdWZpeWFuK3Rlc3RAaW5jdWJlOC5zZyJ9.hbNYnVt6_fhX5KJEfn6Fi9cOZkQAldHGitVBWXSd0_YcWDU_BJ1OVu_VFEKzIvaRLR_zy2eW3dIJ27pn1_6U0sS8MZMsvtz0SKQP4M1hTEnhb5TOSIcOs9Y6ZPy1e1ShIqQmq2j_K1JFzEZH7u3eOmCTmFcs8X5vUk8O1sT2KqBP5UCBVB_4rCVEjbRGdyynqEKcdKkd7Nk6v9onpxRbG3FOg6vlsKSlfZ6RIz3jbjO4ZkCJiYAgrI7bsh2VGwE8pZq80GuQy9pocLkTcZiAFcni50-yvePQX8tkXhPzbp7DibAI6nU87Ol6TW4ZmB-0BZ56Nfeowoe7tT-7hvGkGA';
-
-describe('test Utils/getJwtSubFromAuthHeader util', () => {
-  it('should get sub from Authorization header', () => {
-    expect(getJwtSubFromAuthHeader(authorizationHeader)).toBe(
-      'f2b5349d-f5e3-44f5-9c08-ae6b01e95434'
-    );
-  });
-
-  it('should get sub as null from missing or empty header', () => {
-    expect(getJwtSubFromAuthHeader()).toBe(null);
-  });
-
-  it('should get sub as null from invalid Authorization header', () => {
-    expect(getJwtSubFromAuthHeader('some-invalid-token')).toBe(null);
-  });
-});

package/src/utils/__tests__/isDecimal.spec.js

@@ -1,12 +0,0 @@
-import isDecimal from '../isDecimal';
-
-describe('test Utils/isDecimal util', () => {
-  it('should return false for string', () => {
-    expect(isDecimal('1')).toBeFalsy();
-    expect(isDecimal('one')).toBeFalsy();
-  });
-
-  it('should return true for decimal number', () => {
-    return expect(isDecimal(1.5)).toBeTruthy();
-  });
-});

package/src/utils/__tests__/isEmail.spec.js

@@ -1,28 +0,0 @@
-import isEmail from '../isEmail';
-import LesgoException from '../../exceptions/LesgoException';
-
-describe('test isEmail util', () => {
-  test('isEmail should throws an Error when empty sting parameters were passed', () => {
-    expect(() => {
-      isEmail('');
-    }).toThrow(
-      new LesgoException('Empty parameter supplied', 'IS_EMAIL_EMPTY_PARAMETER')
-    );
-  });
-
-  test('isEmail should throws an Error when null parameters were passed', () => {
-    expect(() => {
-      isEmail(null);
-    }).toThrow(
-      new LesgoException('Empty parameter supplied', 'IS_EMAIL_EMPTY_PARAMETER')
-    );
-  });
-
-  it('isEmail should return false for invalid email ', () => {
-    return expect(isEmail('test@g')).toBeFalsy();
-  });
-
-  it('isEmail should return true for valid email', () => {
-    return expect(isEmail('test@gmail.com')).toBeTruthy();
-  });
-});

package/src/utils/__tests__/isEmpty.spec.js

@@ -1,31 +0,0 @@
-import isEmpty from '../isEmpty';
-
-describe('test isEmpty util', () => {
-  it('isEmpty should return true for undefined object', () => {
-    return expect(isEmpty(undefined)).toBeTruthy();
-  });
-
-  it('isEmpty should return true for null object', () => {
-    return expect(isEmpty(null)).toBeTruthy();
-  });
-
-  it('isEmpty should return true for empty string', () => {
-    return expect(isEmpty('')).toBeTruthy();
-  });
-
-  it('isEmpty should return true for empty object', () => {
-    return expect(isEmpty({})).toBeTruthy();
-  });
-
-  it('isEmpty should return true for empty array', () => {
-    return expect(isEmpty([])).toBeTruthy();
-  });
-
-  it('isEmpty should return false for non-empty array', () => {
-    return expect(isEmpty(['apple', 'banana', 'chiku'])).toBeFalsy();
-  });
-
-  it('isEmpty should return false for non-empty object', () => {
-    return expect(isEmpty({ someKey: 'someValue' })).toBeFalsy();
-  });
-});

package/src/utils/__tests__/logger.spec.js

@@ -1,11 +0,0 @@
-import logger from '../logger';
-
-describe('UtilsGroup: test logger utils', () => {
-  it('test logger', () => {
-    logger.info('some info log');
-
-    expect(logger.transports).toEqual(
-      expect.arrayContaining([expect.objectContaining({ logType: 'console' })])
-    );
-  });
-});

package/src/utils/__tests__/objectStore.spec.js

@@ -1,67 +0,0 @@
-import s3, { getObject } from '../objectStore';
-import LesgoException from '../../exceptions/LesgoException';
-
-describe('UtilsGroup: test objectStore utils', () => {
-  it('test objectStore.getObject', () => {
-    return expect(
-      // eslint-disable-next-line import/no-named-as-default-member
-      s3.getObject('someKey', 'someBucket')
-    ).resolves.toMatchObject({
-      LastModified: '2019-09-04T05:00:57.000Z',
-      ContentLength: 27892,
-      ETag: '38e6c8a510f49edec0ad4244a7665312',
-      ContentType: '.jpg',
-      Metadata: {},
-      Body: {
-        type: 'Buffer',
-        data: [],
-      },
-      mocked: {
-        opts: {},
-        params: {
-          Key: 'someKey',
-          Bucket: 'someBucket',
-        },
-      },
-    });
-  });
-
-  it('test objectStore getObject', () => {
-    return expect(getObject('someKey', 'someBucket')).resolves.toMatchObject({
-      LastModified: '2019-09-04T05:00:57.000Z',
-      ContentLength: 27892,
-      ETag: '38e6c8a510f49edec0ad4244a7665312',
-      ContentType: '.jpg',
-      Metadata: {},
-      Body: {
-        type: 'Buffer',
-        data: [],
-      },
-      mocked: {
-        opts: {},
-        params: {
-          Key: 'someKey',
-          Bucket: 'someBucket',
-        },
-      },
-    });
-  });
-
-  it('test objectStore getObject with empty key', () => {
-    return expect(() => getObject()).toThrow(
-      new LesgoException(
-        'Key is undefined in S3Service.getObject()',
-        'S3SERVICE_GETOBJECT_KEY_UNDEFINED'
-      )
-    );
-  });
-
-  it('test objectStore getObject with empty bucket', () => {
-    return expect(() => getObject('someKey')).toThrow(
-      new LesgoException(
-        'Bucket is undefined in S3Service.getObject()',
-        'S3SERVICE_GETOBJECT_BUCKET_UNDEFINED'
-      )
-    );
-  });
-});

package/src/utils/__tests__/prepSQLInsertParams.spec.js

@@ -1,46 +0,0 @@
-import prepSQLInsertParams from '../prepSQLInsertParams';
-
-const columns = [
-  { key: 'uid', type: 'string', required: true },
-  {
-    key: 'type',
-    type: 'enum',
-    enumValues: ['photo', 'video'],
-    required: true,
-  },
-  { key: 'table_name', type: 'string', required: false },
-  { key: 'row_id', type: 'number', required: false },
-  { key: 'id', type: 'number', required: true },
-];
-
-describe('test prepSQLInsertParams util', () => {
-  test('should return all the fields if provided', () => {
-    const params = {
-      uid: 'sample-123123',
-      type: 'photo',
-      table_name: 'medias',
-      row_id: 123,
-      id: 123,
-    };
-
-    expect(prepSQLInsertParams(params, columns)).toMatchObject({
-      insertColumns: 'uid,type,table_name,row_id,id',
-      insertValues: ':uid,:type,:table_name,:row_id,:id',
-      insertFields: params,
-    });
-  });
-
-  test('should return only the given fields', () => {
-    const params = {
-      uid: 'sample-123123',
-      type: 'photo',
-      id: 123,
-    };
-
-    expect(prepSQLInsertParams(params, columns)).toMatchObject({
-      insertColumns: 'uid,type,id',
-      insertValues: ':uid,:type,:id',
-      insertFields: params,
-    });
-  });
-});

package/src/utils/__tests__/prepSQLUpdateParams.spec.js

@@ -1,36 +0,0 @@
-import prepSQLUpdateParams from '../prepSQLUpdateParams';
-
-const columns = [
-  { key: 'id', type: 'number', required: true },
-  { key: 'table_name', type: 'string', required: false },
-  { key: 'row_id', type: 'number', required: false },
-];
-
-describe('test prepSQLUpdateParams util', () => {
-  test('should return all the fields if provided', () => {
-    const params = {
-      id: 123,
-      table_name: 'users',
-      row_id: 123,
-    };
-
-    expect(prepSQLUpdateParams(params, columns)).toMatchObject({
-      updateColumnValues: 'table_name=:table_name,row_id=:row_id',
-      wherePrimaryKey: 'id=:id',
-      updateFields: params,
-    });
-  });
-
-  test('should return only the provided fields', () => {
-    const params = {
-      id: 123,
-      row_id: 124,
-    };
-
-    expect(prepSQLUpdateParams(params, columns)).toMatchObject({
-      updateColumnValues: 'row_id=:row_id',
-      wherePrimaryKey: 'id=:id',
-      updateFields: params,
-    });
-  });
-});