lesgo 0.7.8 → 2.1.0

package/dist/services/ElastiCacheRedisService/setRedisCache.js

@@ -0,0 +1,77 @@
+var __awaiter =
+  (this && this.__awaiter) ||
+  function (thisArg, _arguments, P, generator) {
+    function adopt(value) {
+      return value instanceof P
+        ? value
+        : new P(function (resolve) {
+            resolve(value);
+          });
+    }
+    return new (P || (P = Promise))(function (resolve, reject) {
+      function fulfilled(value) {
+        try {
+          step(generator.next(value));
+        } catch (e) {
+          reject(e);
+        }
+      }
+      function rejected(value) {
+        try {
+          step(generator['throw'](value));
+        } catch (e) {
+          reject(e);
+        }
+      }
+      function step(result) {
+        result.done
+          ? resolve(result.value)
+          : adopt(result.value).then(fulfilled, rejected);
+      }
+      step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+  };
+import { logger, validateFields } from '../../utils';
+import { LesgoException } from '../../exceptions';
+import getElastiCacheRedisClient from './getElastiCacheRedisClient';
+const FILE = 'lesgo.services.ElastiCacheRedis.setRedisCache';
+const setRedisCache = (key, value, opts, clientOpts) =>
+  __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    const input = validateFields({ key, value }, [
+      { key: 'key', type: 'string', required: true },
+      { key: 'value', type: 'any', required: true },
+    ]);
+    opts = Object.assign(Object.assign({}, opts), {
+      EX:
+        (_a = opts === null || opts === void 0 ? void 0 : opts.EX) !== null &&
+        _a !== void 0
+          ? _a
+          : 300,
+    });
+    const client = yield getElastiCacheRedisClient(clientOpts);
+    input.value =
+      typeof input.value === 'object'
+        ? JSON.stringify(input.value)
+        : input.value;
+    try {
+      // @ts-ignore
+      const resp = yield client.set(input.key, input.value, 'EX', opts.EX);
+      logger.debug(`${FILE}::RECEIVED_RESPONSE`, { resp, input, value });
+      return resp;
+    } catch (err) {
+      throw new LesgoException(
+        'Failed to set redis cache',
+        `${FILE}::SET_ERROR`,
+        500,
+        {
+          err,
+          input,
+          value,
+          opts,
+          clientOpts,
+        }
+      );
+    }
+  });
+export default setRedisCache;

package/dist/services/JWTService/decodeJwt.d.ts

@@ -0,0 +1,7 @@
+import { JwtHeader, JwtPayload } from 'jsonwebtoken';
+declare const decodeJwt: (token: string) => {
+    header: JwtHeader;
+    payload: JwtPayload;
+    signature: string;
+};
+export default decodeJwt;

package/dist/services/JWTService/decodeJwt.js

@@ -0,0 +1,9 @@
+const decodeJwt = token => {
+  const parts = token.split('.');
+  return {
+    header: JSON.parse(Buffer.from(parts[0], 'base64').toString('utf8')),
+    payload: JSON.parse(Buffer.from(parts[1], 'base64').toString('utf8')),
+    signature: parts[2],
+  };
+};
+export default decodeJwt;

package/dist/services/JWTService/getJwtSecret.d.ts

@@ -0,0 +1,13 @@
+export interface GetJwtSecretInput {
+    secret?: string;
+    keyid?: string;
+}
+export interface JwtSecret {
+    keyid: string;
+    secret: string;
+}
+declare const getJwtSecret: (input: GetJwtSecretInput) => {
+    keyid: string;
+    secret: string;
+};
+export default getJwtSecret;

package/dist/services/JWTService/getJwtSecret.js

@@ -0,0 +1,54 @@
+import { LesgoException } from '../../exceptions';
+import jwtConfig from '../../config/jwt';
+const FILE = 'lesgo.services.JWTService.getJwtSecret';
+const getJwtSecret = input => {
+  var _a, _b;
+  const jwtSecret = {
+    keyid: input.keyid || '',
+    secret: input.secret || '',
+  };
+  if (!input.secret) {
+    jwtSecret.keyid =
+      ((_a = jwtConfig.secrets[0]) === null || _a === void 0
+        ? void 0
+        : _a.keyid) || '';
+    jwtSecret.secret =
+      ((_b = jwtConfig.secrets[0]) === null || _b === void 0
+        ? void 0
+        : _b.secret) || '';
+  }
+  if (input.secret) {
+    const foundSecret = jwtConfig.secrets.find(
+      s => (s === null || s === void 0 ? void 0 : s.secret) === input.secret
+    );
+    if (!foundSecret) {
+      throw new LesgoException(
+        `No matching JWT Secret found.`,
+        `${FILE}::SECRET_NOT_FOUND`
+      );
+    }
+    jwtSecret.keyid = foundSecret.keyid;
+    jwtSecret.secret = foundSecret.secret;
+  }
+  if (input.keyid) {
+    const foundSecret = jwtConfig.secrets.find(
+      s => (s === null || s === void 0 ? void 0 : s.keyid) === input.keyid
+    );
+    if (!foundSecret) {
+      throw new LesgoException(
+        `kid ${input.keyid} not found.`,
+        `${FILE}::KID_NOT_FOUND`
+      );
+    }
+    jwtSecret.keyid = foundSecret.keyid;
+    jwtSecret.secret = foundSecret.secret;
+  }
+  if (!jwtSecret.secret) {
+    throw new LesgoException(
+      'Missing Secret to sign JWT',
+      `${FILE}::SECRET_NOT_FOUND`
+    );
+  }
+  return jwtSecret;
+};
+export default getJwtSecret;

package/dist/services/JWTService/index.d.ts

@@ -0,0 +1,2 @@
+export { default as sign } from './sign';
+export { default as verify } from './verify';

package/dist/services/JWTService/index.js

@@ -0,0 +1,2 @@
+export { default as sign } from './sign';
+export { default as verify } from './verify';

package/dist/services/JWTService/sign.d.ts

@@ -0,0 +1,3 @@
+import { SignOptions } from 'jsonwebtoken';
+declare const sign: (payload: any, secret?: string, opts?: SignOptions) => string;
+export default sign;

package/dist/services/JWTService/sign.js

@@ -0,0 +1,31 @@
+import { sign as signJwt } from 'jsonwebtoken';
+import { jwt as jwtConfig } from '../../config';
+import { generateUid } from '../../utils';
+import getJwtSecret from './getJwtSecret';
+const sign = (payload, secret, opts) => {
+  const jwtSecret = getJwtSecret({
+    secret,
+    keyid: opts === null || opts === void 0 ? void 0 : opts.keyid,
+  });
+  const options = Object.assign(Object.assign({}, opts), {
+    algorithm:
+      (opts === null || opts === void 0 ? void 0 : opts.algorithm) ||
+      jwtConfig.algorithm,
+    expiresIn:
+      (opts === null || opts === void 0 ? void 0 : opts.expiresIn) ||
+      jwtConfig.expiresIn,
+    issuer:
+      (opts === null || opts === void 0 ? void 0 : opts.issuer) ||
+      jwtConfig.issuer,
+    audience:
+      (opts === null || opts === void 0 ? void 0 : opts.audience) ||
+      jwtConfig.audience,
+    jwtid:
+      (opts === null || opts === void 0 ? void 0 : opts.jwtid) ||
+      generateUid({ length: 16 }),
+    keyid: jwtSecret.keyid,
+  });
+  const token = signJwt(payload, jwtSecret.secret, options);
+  return token;
+};
+export default sign;

package/dist/services/JWTService/verify.d.ts

@@ -0,0 +1,7 @@
+import { VerifyOptions } from 'jsonwebtoken';
+export interface VerifyInputOptions extends VerifyOptions {
+    validateClaims?: boolean;
+    keyid?: string;
+}
+declare const verify: (token: string, secret?: string, opts?: VerifyInputOptions) => string | import("jsonwebtoken").JwtPayload | import("jsonwebtoken").Jwt;
+export default verify;

package/dist/services/JWTService/verify.js

@@ -0,0 +1,61 @@
+import { verify as verifyToken } from 'jsonwebtoken';
+import jwtConfig from '../../config/jwt';
+import { LesgoException } from '../../exceptions';
+import { isEmpty, logger } from '../../utils';
+import getJwtSecret from './getJwtSecret';
+import decodeJwt from './decodeJwt';
+const FILE = 'lesgo.services.JWTService.verify';
+const verify = (token, secret, opts) => {
+  const { header, payload, signature } = decodeJwt(token);
+  logger.debug(`${FILE}::DECODED_JWT`, { header, payload, signature });
+  const jwtSecret = getJwtSecret({
+    secret,
+    keyid:
+      payload.kid ||
+      header.kid ||
+      (opts === null || opts === void 0 ? void 0 : opts.keyid),
+  });
+  const validateClaims = !isEmpty(
+    opts === null || opts === void 0 ? void 0 : opts.validateClaims
+  )
+    ? opts === null || opts === void 0
+      ? void 0
+      : opts.validateClaims
+    : jwtConfig.validateClaims;
+  if (validateClaims) {
+    opts = Object.assign(
+      {
+        issuer:
+          (opts === null || opts === void 0 ? void 0 : opts.issuer) ||
+          jwtConfig.issuer,
+        audience:
+          (opts === null || opts === void 0 ? void 0 : opts.audience) ||
+          jwtConfig.audience,
+      },
+      opts
+    );
+  }
+  opts = Object.assign({ complete: true }, opts);
+  try {
+    logger.debug(`${FILE}::VERIFYING_TOKEN`, {
+      token,
+      opts,
+      isValidateClaims: validateClaims,
+    });
+    const decoded = verifyToken(token, jwtSecret.secret, opts);
+    logger.debug(`${FILE}::VERIFIED_TOKEN`, decoded);
+    return decoded;
+  } catch (error) {
+    throw new LesgoException(
+      'Failed to verify token',
+      `${FILE}::VERIFY_ERROR`,
+      500,
+      {
+        error,
+        token,
+        opts,
+      }
+    );
+  }
+};
+export default verify;

package/dist/services/LoggerService.d.ts

@@ -0,0 +1,46 @@
+type LogLevel = 'error' | 'warn' | 'notice' | 'info' | 'debug';
+interface LoggerServiceOptions {
+    logger?: string;
+    defaultMeta?: object;
+    transports?: Array<Transport>;
+}
+interface Transport {
+    logType: string;
+    level: string;
+    config?: TransportConfig;
+}
+interface TransportConfig {
+    getCreatedAt?: boolean;
+    meta?: object;
+    tags?: TransportConfigTags;
+}
+interface TransportConfigTags {
+    [key: string]: string;
+}
+export default class LoggerService {
+    logger: string;
+    meta: object;
+    transports: Array<Transport>;
+    logLevels: {
+        [key: string]: number;
+    };
+    constructor(opts?: LoggerServiceOptions);
+    log(level: LogLevel, message: string, extra?: {}): void;
+    error(message: string, extra?: {}): void;
+    warn(message: string, extra?: {}): void;
+    info(message: string, extra?: {}): void;
+    debug(message: string, extra?: {}): void;
+    notice(message: string, extra?: {}): void;
+    addMeta(meta?: {}): void;
+    consoleLogger(level: LogLevel, message: string): void | null;
+    checkIsLogRequired(transportName: string, level: LogLevel): boolean;
+    structureLogMessage(level: LogLevel, message: any, extra: object): {
+        level: LogLevel;
+        message: any;
+        logger: string;
+        extra: {};
+    };
+    refineMessagePerTransport(transportName: string, message: any): any;
+    getTransportByName(transportName: string): Transport | undefined;
+}
+export {};

package/{src → dist}/services/LoggerService.js

@@ -1,9 +1,5 @@
 import LesgoException from '../exceptions/LesgoException';
-
-const getCurrentDateTime = () => {
-  return new Date().toUTCString();
-};
-
+import { getCurrentDatetime } from '../utils';
 export default class LoggerService {
   constructor(opts = {}) {
     const defaultOptions = {
@@ -11,131 +7,111 @@ export default class LoggerService {
       meta: {},
       transports: [],
     };
-
-    const options = {
-      ...defaultOptions,
+    const options = Object.assign(Object.assign({}, defaultOptions), {
       logger: opts.logger || defaultOptions.logger,
-      meta: {
-        ...defaultOptions.meta,
-        ...(opts.defaultMeta || {}),
-      },
+      meta: Object.assign(
+        Object.assign({}, defaultOptions.meta),
+        opts.defaultMeta || {}
+      ),
       transports: opts.transports || [],
-    };
-
+    });
     this.logger = options.logger;
     this.meta = options.meta;
     this.transports = options.transports;
-    this.getCreatedAt = options.getCreatedAt;
-
     this.logLevels = {
       error: 0,
       warn: 1,
-      info: 2,
-      debug: 3,
+      notice: 2,
+      info: 3,
+      debug: 4,
     };
   }
-
   log(level, message, extra = {}) {
     if (level === undefined || !Object.keys(this.logLevels).includes(level)) {
       throw new LesgoException('Invalid level provided in log()');
     }
-
     const structuredMessage = this.structureLogMessage(level, message, extra);
-
     this.transports.map(transport => {
+      // @ts-ignore
       return this[`${transport.logType}Logger`](level, structuredMessage);
     });
   }
-
   error(message, extra = {}) {
     this.log('error', message, extra);
   }
-
   warn(message, extra = {}) {
     this.log('warn', message, extra);
   }
-
   info(message, extra = {}) {
     this.log('info', message, extra);
   }
-
   debug(message, extra = {}) {
     this.log('debug', message, extra);
   }
-
+  notice(message, extra = {}) {
+    this.log('notice', message, extra);
+  }
   addMeta(meta = {}) {
-    this.meta = {
-      ...this.meta,
-      ...meta,
-    };
+    this.meta = Object.assign(Object.assign({}, this.meta), meta);
   }
-
   consoleLogger(level, message) {
     if (!this.checkIsLogRequired('console', level)) return null;
     const refinedMessage = this.refineMessagePerTransport('console', message);
-    return console[level](JSON.stringify(refinedMessage)); // eslint-disable-line no-console
+    const consoleFunc = level === 'notice' ? 'log' : level;
+    return console[consoleFunc](JSON.stringify(refinedMessage));
   }
-
   checkIsLogRequired(transportName, level) {
-    const transportLevel = this.getTransportByName(transportName).level;
-
+    const transport = this.getTransportByName(transportName);
+    if (transport === undefined) {
+      return false;
+    }
+    const transportLevel = transport.level;
     if (this.logLevels[transportLevel] < this.logLevels[level]) {
       return false;
     }
-
     return true;
   }
-
   structureLogMessage(level, message, extra) {
     const structuredMessage = {
       level,
       message,
       logger: this.logger,
-      extra: {
-        ...this.meta,
-        ...extra,
-      },
+      extra: Object.assign(Object.assign({}, this.meta), extra),
     };
-
     return structuredMessage;
   }
-
   refineMessagePerTransport(transportName, message) {
     const transport = this.getTransportByName(transportName);
-    const refinedMessage = { ...message };
-
+    const refinedMessage = message;
+    if (transport === undefined) {
+      return refinedMessage;
+    }
     if (transport.config !== undefined) {
       if (transport.config.meta !== undefined) {
-        refinedMessage.extra = {
-          ...refinedMessage.extra,
-          ...transport.config.meta,
-        };
+        refinedMessage.extra = Object.assign(
+          Object.assign({}, refinedMessage.extra),
+          transport.config.meta
+        );
       }
-
       if (transport.config.tags !== undefined) {
         refinedMessage.tags = transport.config.tags;
       }
-
       if (
         refinedMessage.tags !== undefined &&
         refinedMessage.extra.tags !== undefined
       ) {
-        refinedMessage.tags = {
-          ...refinedMessage.tags,
-          ...refinedMessage.extra.tags,
-        };
-
+        refinedMessage.tags = Object.assign(
+          Object.assign({}, refinedMessage.tags),
+          refinedMessage.extra.tags
+        );
         delete refinedMessage.extra.tags;
       }
-
       if (transport.config.getCreatedAt) {
-        refinedMessage.created = getCurrentDateTime();
+        refinedMessage.created = getCurrentDatetime();
       }
     }
-
     return refinedMessage;
   }
-
   getTransportByName(transportName) {
     return this.transports.find(
       transport => transport.logType === transportName

package/dist/services/RDSAuroraMySQLProxyService/disconnectMySQLProxyClient.d.ts

@@ -0,0 +1,2 @@
+declare const disconnectMySQLProxyClient: () => Promise<void>;
+export default disconnectMySQLProxyClient;

package/dist/services/RDSAuroraMySQLProxyService/disconnectMySQLProxyClient.js

@@ -0,0 +1,60 @@
+var __awaiter =
+  (this && this.__awaiter) ||
+  function (thisArg, _arguments, P, generator) {
+    function adopt(value) {
+      return value instanceof P
+        ? value
+        : new P(function (resolve) {
+            resolve(value);
+          });
+    }
+    return new (P || (P = Promise))(function (resolve, reject) {
+      function fulfilled(value) {
+        try {
+          step(generator.next(value));
+        } catch (e) {
+          reject(e);
+        }
+      }
+      function rejected(value) {
+        try {
+          step(generator['throw'](value));
+        } catch (e) {
+          reject(e);
+        }
+      }
+      function step(result) {
+        result.done
+          ? resolve(result.value)
+          : adopt(result.value).then(fulfilled, rejected);
+      }
+      step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+  };
+import { logger } from '../../utils';
+import { singleton } from '../RDSAuroraMySQLProxyService/getMySQLProxyClient';
+const FILE =
+  'lesgo.services.RDSAuroraMySQLProxyService.disconnectMySQLProxyClient';
+const disconnectMySQLProxyClient = () =>
+  __awaiter(void 0, void 0, void 0, function* () {
+    const singletonConns = Object.keys(singleton);
+    if (singletonConns.length === 0) {
+      logger.debug(`${FILE}::NO_CONNECTIONS_TO_DISCONNECT`);
+      return;
+    }
+    logger.debug(`${FILE}::PREPARING_TO_DISCONNECT`, {
+      singletonConns,
+    });
+    singletonConns.forEach(singletonConn =>
+      __awaiter(void 0, void 0, void 0, function* () {
+        try {
+          yield singleton[singletonConn].end();
+          delete singleton[singletonConn];
+          logger.debug(`${FILE}::COMPLETED`, { singletonConn });
+        } catch (err) {
+          logger.error(`${FILE}::ERROR`, { singletonConn, err });
+        }
+      })
+    );
+  });
+export default disconnectMySQLProxyClient;

package/dist/services/RDSAuroraMySQLProxyService/getMySQLProxyClient.d.ts

@@ -0,0 +1,8 @@
+import { Connection, ConnectionOptions } from 'mysql2/promise';
+import { RDSAuroraMySQLProxyClientOptions } from '../../types/aws';
+export interface Singleton {
+    [key: string]: Connection;
+}
+export declare const singleton: Singleton;
+declare const getMySQLProxyClient: (connOptions?: ConnectionOptions, clientOpts?: RDSAuroraMySQLProxyClientOptions) => Promise<Connection>;
+export default getMySQLProxyClient;

package/dist/services/RDSAuroraMySQLProxyService/getMySQLProxyClient.js

@@ -0,0 +1,87 @@
+var __awaiter =
+  (this && this.__awaiter) ||
+  function (thisArg, _arguments, P, generator) {
+    function adopt(value) {
+      return value instanceof P
+        ? value
+        : new P(function (resolve) {
+            resolve(value);
+          });
+    }
+    return new (P || (P = Promise))(function (resolve, reject) {
+      function fulfilled(value) {
+        try {
+          step(generator.next(value));
+        } catch (e) {
+          reject(e);
+        }
+      }
+      function rejected(value) {
+        try {
+          step(generator['throw'](value));
+        } catch (e) {
+          reject(e);
+        }
+      }
+      function step(result) {
+        result.done
+          ? resolve(result.value)
+          : adopt(result.value).then(fulfilled, rejected);
+      }
+      step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+  };
+import { createConnection } from 'mysql2/promise';
+import { logger, isEmpty, validateFields } from '../../utils';
+import { rds as rdsConfig } from '../../config';
+import { getSecretValue } from '../../utils/secretsmanager';
+const FILE = 'lesgo.services.RDSAuroraMySQLProxyService.getMySQLProxyClient';
+export const singleton = {};
+const getMySQLProxyClient = (connOptions, clientOpts) =>
+  __awaiter(void 0, void 0, void 0, function* () {
+    const options = validateFields(clientOpts || {}, [
+      { key: 'region', type: 'string', required: false },
+      { key: 'singletonConn', type: 'string', required: false },
+      { key: 'dbCredentialsSecretId', type: 'string', required: false },
+      { key: 'databaseName', type: 'string', required: false },
+    ]);
+    const region = options.region || rdsConfig.aurora.mysql.region;
+    const singletonConn = options.singletonConn || 'default';
+    const dbCredentialsSecretId =
+      options.dbCredentialsSecretId ||
+      rdsConfig.aurora.mysql.proxy.dbCredentialsSecretId;
+    const databaseName =
+      options.databaseName || rdsConfig.aurora.mysql.databaseName;
+    if (!isEmpty(singleton[singletonConn])) {
+      logger.debug(`${FILE}::REUSE_RDS_CONNECTION`, {
+        client: singleton[singletonConn],
+        region,
+      });
+      return singleton[singletonConn];
+    }
+    const dbCredentials = yield getSecretValue(
+      dbCredentialsSecretId,
+      undefined,
+      {
+        region,
+        singletonConn,
+      }
+    );
+    const validatedDbCredentials = validateFields(dbCredentials, [
+      { key: 'host', type: 'string', required: true },
+      { key: 'username', type: 'string', required: true },
+      { key: 'password', type: 'string', required: true },
+    ]);
+    const conn = yield createConnection(
+      Object.assign(Object.assign({}, connOptions), {
+        host: validatedDbCredentials.host,
+        user: validatedDbCredentials.username,
+        password: validatedDbCredentials.password,
+        database: databaseName,
+      })
+    );
+    singleton[singletonConn] = conn;
+    logger.debug(`${FILE}::NEW_RDS_CONNECTION`);
+    return conn;
+  });
+export default getMySQLProxyClient;

package/dist/services/RDSAuroraMySQLProxyService/index.d.ts

@@ -0,0 +1,3 @@
+export { default as disconnectMySQLProxyClient } from './disconnectMySQLProxyClient';
+export { default as getMySQLProxyClient } from './getMySQLProxyClient';
+export { default as query } from './query';

package/dist/services/RDSAuroraMySQLProxyService/index.js

@@ -0,0 +1,3 @@
+export { default as disconnectMySQLProxyClient } from './disconnectMySQLProxyClient';
+export { default as getMySQLProxyClient } from './getMySQLProxyClient';
+export { default as query } from './query';

package/dist/services/RDSAuroraMySQLProxyService/query.d.ts

@@ -0,0 +1,4 @@
+import { ConnectionOptions } from 'mysql2/promise';
+import { RDSAuroraMySQLProxyClientOptions } from '../../types/aws';
+declare const query: (sql: string, preparedValues?: any[], connOptions?: ConnectionOptions, clientOpts?: RDSAuroraMySQLProxyClientOptions) => Promise<[import("mysql2/promise").QueryResult, import("mysql2/typings/mysql/lib/protocol/packets/FieldPacket").FieldPacket[]]>;
+export default query;