@creator.co/wapi 1.2.1-beta6 → 1.2.3

package/src/Config/EnvironmentVar.ts

@@ -1,30 +1,83 @@
-import {
-  SecretsManagerClient,
-  GetSecretValueCommand,
-} from "@aws-sdk/client-secrets-manager"
-import { SSMClient, GetParameterCommand } from "@aws-sdk/client-ssm"
+import { SecretsManagerClient, GetSecretValueCommand } from '@aws-sdk/client-secrets-manager'
+import { SSMClient, GetParameterCommand } from '@aws-sdk/client-ssm'
 
 // Explicity setting VM level variables in order to persist
 // client across different important and instances.
 // eslint-disable-next-line no-var
-var ssmClient = null,
+/**
+ * ${1:Description placeholder}
+ *
+ * @type {*}
+ */
+let ssmClient = null,
   secretsClient = null
 
+/**
+ * ${1:Description placeholder}
+ *
+ * @export
+ * @enum {number}
+ */
 export enum EnvironmentType {
   PlainRemote,
   SecureRemote,
   Local,
 }
+/**
+ * ${1:Description placeholder}
+ *
+ * @export
+ * @class EnvironmentVar
+ * @typedef {EnvironmentVar}
+ * @template T
+ */
 export default class EnvironmentVar<T> {
+  /**
+   * ${1:Description placeholder}
+   *
+   * @private
+   * @readonly
+   * @type {string}
+   */
   private readonly paramName: string
+  /**
+   * ${1:Description placeholder}
+   *
+   * @private
+   * @readonly
+   * @type {EnvironmentType}
+   */
   private readonly type: EnvironmentType
+  /**
+   * ${1:Description placeholder}
+   *
+   * @private
+   * @readonly
+   * @type {boolean}
+   */
   private readonly optional: boolean
+  /**
+   * ${1:Description placeholder}
+   *
+   * @private
+   * @readonly
+   * @type {string}
+   */
   private readonly paramPrefix: string
+  /**
+   * Creates an instance of EnvironmentVar.
+   *
+   * @constructor
+   * @param {string} paramName
+   * @param {EnvironmentType} type
+   * @param {?boolean} [optional]
+   * @param {string} [paramPrefix=`/creatorco-api-\${process.env.STAGE\}/env/`]
+   */
   constructor(
     paramName: string,
     type: EnvironmentType,
     optional?: boolean,
-    paramPrefix = `/creatorco-api-${process.env.STAGE}/env/` /* only allowed process.env */,
+    paramPrefix = `/creatorco-api-${process.env.STAGE}/env/` /* only allowed process.env */
   ) {
     this.paramName = paramName
     this.type = type
@@ -32,39 +85,61 @@ export default class EnvironmentVar<T> {
     this.paramPrefix = paramPrefix
   }
 
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @returns {T}
+   */
   public syncResolve(): T {
     if (this.type == EnvironmentType.Local) return this.getLocalValue()
     else {
       throw new Error(
-        "EnvironmentVar syncResolve method can only be called for environments of type 'Local'",
+        "EnvironmentVar syncResolve method can only be called for environments of type 'Local'"
       )
     }
   }
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @async
+   * @returns {unknown}
+   */
   public async resolve() {
     if (this.type == EnvironmentType.Local) return this.getLocalValue()
-    else if (this.type == EnvironmentType.SecureRemote)
-      return this.getSecureValue()
+    else if (this.type == EnvironmentType.SecureRemote) return this.getSecureValue()
     else return this.getPlainValue()
   }
 
+  /**
+   * ${1:Description placeholder}
+   *
+   * @private
+   * @returns {T}
+   */
   private getLocalValue(): T {
     const value = process.env[this.paramName]
     if (!value && !this.optional) {
       throw new Error(
-        `Local environment ${this.paramName} is not defined, please reconfigure the application and redeploy!`,
+        `Local environment ${this.paramName} is not defined, please reconfigure the application and redeploy!`
       )
     }
     return value as T
   }
+  /**
+   * ${1:Description placeholder}
+   *
+   * @private
+   * @async
+   * @returns {Promise<T>}
+   */
   private async getPlainValue(): Promise<T> {
     if (!ssmClient) ssmClient = new SSMClient()
     const pName = `${this.paramPrefix}${this.paramName}`
     try {
-      const data = await ssmClient.send(
-        new GetParameterCommand({ Name: pName }),
-      )
-      if (data.Parameter && data.Parameter.Value)
-        return data.Parameter.Value as T
+      const data = await ssmClient.send(new GetParameterCommand({ Name: pName }))
+      if (data.Parameter && data.Parameter.Value) return data.Parameter.Value as T
     } catch (error) {
       console.error(error)
     }
@@ -72,15 +147,19 @@ export default class EnvironmentVar<T> {
       throw new Error(`Unable to retrieve plain remote env value: ${pName}`)
     }
   }
+  /**
+   * ${1:Description placeholder}
+   *
+   * @private
+   * @async
+   * @returns {Promise<T>}
+   */
   private async getSecureValue(): Promise<T> {
     if (!secretsClient) secretsClient = new SecretsManagerClient()
     const pName = `${this.paramPrefix}${this.paramName}`
     try {
-      const data = await secretsClient.send(
-        new GetSecretValueCommand({ SecretId: pName }),
-      )
-      if (data.Parameter && data.Parameter.Value)
-        return data.Parameter.Value as T
+      const data = await secretsClient.send(new GetSecretValueCommand({ SecretId: pName }))
+      if (data.Parameter && data.Parameter.Value) return data.Parameter.Value as T
     } catch (error) {
       console.error(error)
     }

package/src/Crypto/Crypto.ts

@@ -1,35 +1,94 @@
-import { KMSClient, EncryptCommand, DecryptCommand } from "@aws-sdk/client-kms"
+import { KMSClient, EncryptCommand, DecryptCommand } from '@aws-sdk/client-kms'
 
+/**
+ * ${1:Description placeholder}
+ *
+ * @export
+ * @class Crypto
+ * @typedef {Crypto}
+ */
 export default class Crypto {
+  /**
+   * ${1:Description placeholder}
+   *
+   * @private
+   * @readonly
+   * @type {KMSClient}
+   */
   private readonly client: KMSClient
+  /**
+   * ${1:Description placeholder}
+   *
+   * @private
+   * @readonly
+   * @type {string}
+   */
   private readonly region: string
+  /**
+   * ${1:Description placeholder}
+   *
+   * @private
+   * @readonly
+   * @type {string}
+   */
   private readonly keyId: string
+  /**
+   * Creates an instance of Crypto.
+   *
+   * @constructor
+   * @param {string} region
+   * @param {string} keyId
+   */
   constructor(region: string, keyId: string) {
     this.region = region
     this.keyId = keyId
     this.client = new KMSClient({ region: this.region })
   }
   //
+  /**
+   * ${1:Description placeholder}
+   *
+   * @async
+   * @param {(string | any)} data
+   * @returns {Promise<string>}
+   */
   async encryptData(data: string | any): Promise<string> {
-    const resp = await this.client.send(
-      new EncryptCommand({
-        KeyId: this.keyId,
-        EncryptionAlgorithm: "RSAES_OAEP_SHA_256",
-        Plaintext: new TextEncoder().encode(
-          typeof data === "string" ? data : JSON.stringify(data),
-        ),
-      }),
-    )
-    return Buffer.from(resp.CiphertextBlob as any, "utf8").toString("hex")
+    try {
+      const resp = await this.client.send(
+        new EncryptCommand({
+          KeyId: this.keyId,
+          EncryptionAlgorithm: 'RSAES_OAEP_SHA_256',
+          Plaintext: new TextEncoder().encode(
+            typeof data === 'string' ? data : JSON.stringify(data)
+          ),
+        })
+      )
+      return Buffer.from(resp.CiphertextBlob as any, 'utf8').toString('hex')
+    } catch (e) {
+      console.error('Encryption failure', e)
+      return null
+    }
   }
+  /**
+   * ${1:Description placeholder}
+   *
+   * @async
+   * @param {string} data
+   * @returns {Promise<string>}
+   */
   async decryptData(data: string): Promise<string> {
-    const resp = await this.client.send(
-      new DecryptCommand({
-        KeyId: this.keyId,
-        CiphertextBlob: Buffer.from(data, "hex"),
-        EncryptionAlgorithm: "RSAES_OAEP_SHA_256",
-      }),
-    )
-    return new TextDecoder().decode(resp.Plaintext)
+    try {
+      const resp = await this.client.send(
+        new DecryptCommand({
+          KeyId: this.keyId,
+          CiphertextBlob: Buffer.from(data, 'hex'),
+          EncryptionAlgorithm: 'RSAES_OAEP_SHA_256',
+        })
+      )
+      return new TextDecoder().decode(resp.Plaintext)
+    } catch (e) {
+      console.error('Decryption failure', e)
+      return null
+    }
   }
 }

package/src/Crypto/JWT.ts

@@ -1,5 +1,10 @@
-import * as jwt from "jsonwebtoken"
+import * as jwt from 'jsonwebtoken'
 
+/**
+ * ${1:Description placeholder}
+ *
+ * @typedef {JWTValidationResponse}
+ */
 type JWTValidationResponse =
   | { isValid: true; decodedToken: jwt.JwtPayload }
   | {
@@ -7,41 +12,76 @@ type JWTValidationResponse =
       isExpired?: boolean
     }
 
+/**
+ * ${1:Description placeholder}
+ *
+ * @export
+ * @class JWT
+ * @typedef {JWT}
+ */
 export default class JWT {
+  /**
+   * ${1:Description placeholder}
+   *
+   * @private
+   * @readonly
+   * @type {string}
+   */
   private readonly tokenSecret: string
+  /**
+   * ${1:Description placeholder}
+   *
+   * @private
+   * @readonly
+   * @type {string}
+   */
   private readonly defaultExpiration: string
+  /**
+   * Creates an instance of JWT.
+   *
+   * @constructor
+   * @param {string} tokenSecret
+   * @param {?string} [defaultExpiration]
+   */
   constructor(tokenSecret: string, defaultExpiration?: string) {
     this.tokenSecret = tokenSecret
     this.defaultExpiration = defaultExpiration
   }
   //
-  createToken(
-    data: object,
-    expiration?: string,
-    overrideToken?: string,
-    opts?: any,
-  ): string {
+  /**
+   * ${1:Description placeholder}
+   *
+   * @param {object} data
+   * @param {?string} [expiration]
+   * @param {?string} [overrideToken]
+   * @param {?*} [opts]
+   * @returns {string}
+   */
+  createToken(data: object, expiration?: string, overrideToken?: string, opts?: any): string {
     const exp = expiration || this.defaultExpiration
     return jwt.sign(
       data,
       overrideToken || this.tokenSecret,
-      exp ? { expiresIn: exp, ...(opts || {}) } : opts || {},
+      exp ? { expiresIn: exp, ...(opts || {}) } : opts || {}
     )
   }
+  /**
+   * ${1:Description placeholder}
+   *
+   * @param {string} token
+   * @returns {JWTValidationResponse}
+   */
   validateToken(token: string): JWTValidationResponse {
     try {
       // Check if is valid
       const isValid = jwt.verify(token, this.tokenSecret)
-      if (!isValid) throw new Error("Issue with token validation!")
-      else {
+      if (isValid) {
         const payload = jwt.decode(token, { json: true })
         if (payload) return { isValid: true, decodedToken: payload }
-        else throw new Error("Issue while decoding token!")
       }
     } catch (err) {
       console.error(err)
-      if (err instanceof jwt.TokenExpiredError)
-        return { isValid: false, isExpired: true }
+      if (err instanceof jwt.TokenExpiredError) return { isValid: false, isExpired: true }
     }
     return { isValid: false }
   }

package/src/Globals.ts

@@ -1,39 +1,171 @@
-import * as dotenv from "dotenv"
+import * as dotenv from 'dotenv'
 
-import Utils from "./API/Utils"
+import Utils from './API/Utils'
 
 // important for dev env to load .env file
 dotenv.config()
+/**
+ * Description placeholder
+ *
+ * @export
+ * @class Globals
+ * @typedef {Globals}
+ */
 export default class Globals {
-  //Error messages
-  public static ErrorResponseValidationFail = "Input validation failed: " //400
-  public static ErrorResponseInvalidServerResponse =
-    "No valid response, this is a system error." //400
-  public static ErrorResponseUnhandledError =
-    "Unhandled error when processing request." //400
-  public static ErrorResponseNoRecords = "No events to be processed." //400
-  //Error Codes
-  public static ErrorCode_MissingParam = "MISSING_PARAM"
-  public static ErrorCode_InvalidInput = "INVALID_INPUT"
-  public static ErrorCode_APIError = "API_ERROR"
-  public static ErrorCode_NoRecords = "EMPTY_EVENT"
+  /**
+   * Description placeholder
+   *
+   * @public
+   * @static
+   * @type {string}
+   */
+  public static ErrorResponseValidationFail = 'Input validation failed: ' //400
+  /**
+   * Description placeholder
+   *
+   * @public
+   * @static
+   * @type {string}
+   */
+  public static ErrorResponseInvalidServerResponse = 'No valid response, this is a system error.' //400
+  /**
+   * Description placeholder
+   *
+   * @public
+   * @static
+   * @type {string}
+   */
+  public static ErrorResponseUnhandledError = 'Unhandled error when processing request.' //400
+  /**
+   * Description placeholder
+   *
+   * @public
+   * @static
+   * @type {string}
+   */
+  public static ErrorResponseNoRecords = 'No events to be processed.' //400
+  /**
+   * Description placeholder
+   *
+   * @public
+   * @static
+   * @type {string}
+   */
+  public static ErrorCode_MissingParam = 'MISSING_PARAM'
+  /**
+   * Description placeholder
+   *
+   * @public
+   * @static
+   * @type {string}
+   */
+  public static ErrorCode_InvalidInput = 'INVALID_INPUT'
+  /**
+   * Description placeholder
+   *
+   * @public
+   * @static
+   * @type {string}
+   */
+  public static ErrorCode_APIError = 'API_ERROR'
+  /**
+   * Description placeholder
+   *
+   * @public
+   * @static
+   * @type {string}
+   */
+  public static ErrorCode_NoRecords = 'EMPTY_EVENT'
 
-  public static Listener_HTTP_DefaultPort =
-    Utils.parseIntNullIfNaN(process.env.PORT) || 80
+  /**
+   * Description placeholder
+   *
+   * @public
+   * @static
+   * @type {*}
+   */
+  public static Listener_HTTP_DefaultPort = Utils.parseIntNullIfNaN(process.env.PORT) || 9000
 
-  public static Listener_HTTP_DefaultHost = "localhost"
-  public static Listener_HTTP_ProxyRoute = "*"
-  public static Listener_HTTP_DefaultTimeout =
-    Utils.parseIntNullIfNaN(process.env.TIMEOUT) || 30000
-  public static Listener_HTTP_DefaultHealthCheckRoute =
-    process.env.HEALTH_ROUTE || "/health"
+  /**
+   * Description placeholder
+   *
+   * @public
+   * @static
+   * @type {string}
+   */
+  public static Listener_HTTP_DefaultHost = 'localhost'
+  /**
+   * Description placeholder
+   *
+   * @public
+   * @static
+   * @type {string}
+   */
+  public static Listener_HTTP_ProxyRoute = '*'
+  /**
+   * Description placeholder
+   *
+   * @public
+   * @static
+   * @type {*}
+   */
+  public static Listener_HTTP_DefaultTimeout = Utils.parseIntNullIfNaN(process.env.TIMEOUT) || 30000
+  /**
+   * Description placeholder
+   *
+   * @public
+   * @static
+   * @type {*}
+   */
+  public static Listener_HTTP_DefaultHealthCheckRoute = process.env.HEALTH_ROUTE || '/health'
   //Resps
-  public static Resp_MSG_EXCEPTION =
-    "[Proxy]: Exception during request execution!"
-  public static Resp_CODE_EXCEPTION = "EXEC_EXCEPTION"
+  /**
+   * Description placeholder
+   *
+   * @public
+   * @static
+   * @type {string}
+   */
+  public static Resp_MSG_EXCEPTION = '[Proxy]: Exception during request execution!'
+  /**
+   * Description placeholder
+   *
+   * @public
+   * @static
+   * @type {string}
+   */
+  public static Resp_CODE_EXCEPTION = 'EXEC_EXCEPTION'
+  /**
+   * Description placeholder
+   *
+   * @public
+   * @static
+   * @type {number}
+   */
   public static Resp_STATUSCODE_EXCEPTION = 502
 
-  public static Resp_MSG_INVALIDRESP = "[Proxy]: Invalid response from server!"
-  public static Resp_CODE_INVALIDRESP = "EMPTY_RESPONSE"
+  /**
+   * Description placeholder
+   *
+   * @public
+   * @static
+   * @type {string}
+   */
+  public static Resp_MSG_INVALIDRESP = '[Proxy]: Invalid response from server!'
+  /**
+   * Description placeholder
+   *
+   * @public
+   * @static
+   * @type {string}
+   */
+  public static Resp_CODE_INVALIDRESP = 'EMPTY_RESPONSE'
+  /**
+   * Description placeholder
+   *
+   * @public
+   * @static
+   * @type {number}
+   */
   public static Resp_STATUSCODE_INVALIDRESP = 400
 }