@creator.co/wapi 1.2.1-beta6 → 1.2.3

package/src/API/Response.ts

@@ -1,31 +1,123 @@
-import type { Context } from "aws-lambda"
+import type { Context } from 'aws-lambda'
 
-import Transaction from "../BaseEvent/Transaction"
-import Globals from "../Globals"
+import Transaction from '../BaseEvent/Transaction'
+import Globals from '../Globals'
 //
+/**
+ * ${1:Description placeholder}
+ *
+ * @class CustomError
+ * @typedef {CustomError}
+ * @extends {Error}
+ */
 class CustomError extends Error {
+  /**
+   * Creates an instance of CustomError.
+   *
+   * @constructor
+   * @param {*} body
+   */
   constructor(body: any) {
-    const msg = body && body.message ? body.message : "Unknown error!"
-    super(msg)
-    this.name = body && body.error ? body.error : "UnknownError"
+    super(body.message || 'Unknown error!')
+    this.name = body.error || 'UnknownError'
   }
 }
 //
+/**
+ * ${1:Description placeholder}
+ *
+ * @export
+ * @typedef {ResponseErrorType}
+ */
 export type ResponseErrorType = {
   err: string
   errCode?: string
 }
 //
+/**
+ * ${1:Description placeholder}
+ *
+ * @export
+ * @class Response
+ * @typedef {Response}
+ * @template [BodyType=null]
+ */
 export default class Response<BodyType = null> {
+  /**
+   * ${1:Description placeholder}
+   *
+   * @private
+   * @type {number}
+   */
   private _statusCode: number
+  /**
+   * ${1:Description placeholder}
+   *
+   * @private
+   * @type {*}
+   */
   private _body: any
+  /**
+   * ${1:Description placeholder}
+   *
+   * @private
+   * @type {boolean}
+   */
   private _isPipingOut: boolean
+  /**
+   * ${1:Description placeholder}
+   *
+   * @private
+   * @type {object}
+   */
   private _headers: object
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @readonly
+   * @type {boolean}
+   */
   public readonly shouldStream: boolean
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @readonly
+   * @type {boolean}
+   */
   public readonly rawBody: boolean
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @readonly
+   * @type {boolean}
+   */
   public readonly throwOnErrors: boolean
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @readonly
+   * @type {boolean}
+   */
   public readonly disableTransactionID: boolean
   //
+  /**
+   * Creates an instance of Response.
+   *
+   * @constructor
+   * @param {number} statusCode
+   * @param {BodyType} body
+   * @param {?(| {
+   *           shouldStream?: boolean
+   *           rawBody?: boolean
+   *           throwOnErrors?: boolean
+   *           disableTransactionID?: boolean
+   *         }
+   *       | undefined)\} [optBehaviour]
+   */
   constructor(
     statusCode: number,
     body: BodyType,
@@ -36,15 +128,15 @@ export default class Response<BodyType = null> {
           throwOnErrors?: boolean
           disableTransactionID?: boolean
         }
-      | undefined,
+      | undefined
   ) {
     // response
     this._statusCode = statusCode
     this._body = body
     this._headers = {
-      "Access-Control-Allow-Origin": "*",
-      "Access-Control-Allow-Credentials": true,
-      "Content-Type": "application/json",
+      'Access-Control-Allow-Origin': '*',
+      'Access-Control-Allow-Credentials': true,
+      'Content-Type': 'application/json',
     }
     // behaviour
     this._isPipingOut = false //internal -- flag to indicate streaming out has started and avoid double stream call
@@ -54,34 +146,66 @@ export default class Response<BodyType = null> {
     this.throwOnErrors = !!optBehaviour?.throwOnErrors
     this.disableTransactionID = !!optBehaviour?.disableTransactionID
   }
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @returns {number}
+   */
   public getCode(): number {
     return this._statusCode
   }
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @returns {BodyType}
+   */
   public getBody(): BodyType {
     return this._body
   }
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @param {string} key
+   * @param {*} value
+   */
   public appendIntoBody(key: string, value: any): void {
     this._body[key] = value
   }
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @param {string} key
+   * @param {*} value
+   */
   public appendHeader(key: string, value: any): void {
     this._headers[key] = value
   }
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @async
+   * @param {Context} context
+   * @param {Transaction<any, any, any>} transaction
+   * @param {boolean} _optDoNotCallContext
+   * @returns {Promise<void>}
+   */
   public async build(
     context: Context,
     transaction: Transaction<any, any, any>,
-    _optDoNotCallContext: boolean,
+    _optDoNotCallContext: boolean
   ): Promise<void> {
     //Stream support
     if (this._isPipingOut) return
     if (this.shouldStream) return this._pipe(context)
 
     //append default fields
-    if (
-      transaction.request.getRequestID() &&
-      this._body &&
-      !this.disableTransactionID
-    )
-      this.appendIntoBody("transactionID", transaction.request.getRequestID()) //append transaction ID
+    if (transaction.request.getRequestID() && this._body && !this.disableTransactionID)
+      this.appendIntoBody('transactionID', transaction.request.getRequestID()) //append transaction ID
     //Raw response support
     if (this.rawBody) return this._rawContext(context, transaction)
 
@@ -98,9 +222,14 @@ export default class Response<BodyType = null> {
     //Batch does not succeed directly just on upper transaction (which will should be a batch)
     if (!_optDoNotCallContext) context.succeed(b)
   }
+  /**
+   * ${1:Description placeholder}
+   *
+   * @private
+   * @param {Context} context
+   */
   private _pipe(context: Context): void {
     //Check if not streaming
-    if (this._isPipingOut) return
     this._isPipingOut = true
     //build response
     const b = {
@@ -111,14 +240,17 @@ export default class Response<BodyType = null> {
     //log response and respond to context
     context.succeed(b)
   }
-  private _rawContext(
-    context: Context,
-    transaction: Transaction<null, BodyType>,
-  ): void {
+  /**
+   * ${1:Description placeholder}
+   *
+   * @private
+   * @param {Context} context
+   * @param {Transaction<null, BodyType>} transaction
+   */
+  private _rawContext(context: Context, transaction: Transaction<null, BodyType>): void {
     //log response and respond to context
     transaction.logger.debug(this._body)
-    if (this.getCode() <= 200 && this.getCode() <= 299)
-      context.succeed(this._body)
+    if (this.getCode() <= 200 && this.getCode() <= 299) context.succeed(this._body)
     else {
       if (!this.throwOnErrors) context.fail(new CustomError(this._body))
       else throw new CustomError(this._body)
@@ -126,28 +258,50 @@ export default class Response<BodyType = null> {
   }
 
   /* Shortcuts */
-  public static MissingParamResponse(
-    paramName: string,
-  ): Response<ResponseErrorType> {
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @static
+   * @param {string} paramName
+   * @returns {Response<ResponseErrorType>}
+   */
+  public static MissingParamResponse(paramName: string): Response<ResponseErrorType> {
     console.warn(`Invalid request - Path parameter ${paramName} is missing.`)
     return new Response<ResponseErrorType>(400, {
       err: `Invalid request. Path parameter ${paramName} is missing.`,
       errCode: Globals.ErrorCode_MissingParam,
     })
   }
-  public static MissingQueryResponse(
-    paramName: string,
-  ): Response<ResponseErrorType> {
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @static
+   * @param {string} paramName
+   * @returns {Response<ResponseErrorType>}
+   */
+  public static MissingQueryResponse(paramName: string): Response<ResponseErrorType> {
     console.warn(`Invalid request - Query parameter ${paramName} is missing.`)
     return new Response<ResponseErrorType>(400, {
       err: `Invalid request. Query parameter ${paramName} is missing.`,
       errCode: Globals.ErrorCode_MissingParam,
     })
   }
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @static
+   * @param {?string} [msg]
+   * @param {?string} [errCode]
+   * @param {?*} [optBody]
+   * @returns {Response<ResponseErrorType>}
+   */
   public static BadRequestResponse(
     msg?: string,
     errCode?: string,
-    optBody?: any,
+    optBody?: any
   ): Response<ResponseErrorType> {
     console.warn(`Bad request - ${msg}`)
     return new Response<ResponseErrorType>(400, {
@@ -156,10 +310,20 @@ export default class Response<BodyType = null> {
       ...(optBody || {}),
     })
   }
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @static
+   * @param {string} msg
+   * @param {?string} [errCode]
+   * @param {?*} [optBody]
+   * @returns {Response<ResponseErrorType>}
+   */
   public static BadRequestResponseWithRollback(
     msg: string,
-    errCode: string,
-    optBody?: any,
+    errCode?: string,
+    optBody?: any
   ): Response<ResponseErrorType> {
     console.warn(`Bad request - ${msg}`)
     return new Response<ResponseErrorType>(400, {
@@ -169,41 +333,87 @@ export default class Response<BodyType = null> {
       ...(optBody || {}),
     })
   }
-  public static UnauthorizedResponse(
-    msg: string,
-    errCode: string,
-  ): Response<ResponseErrorType> {
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @static
+   * @param {string} msg
+   * @param {?string} [errCode]
+   * @returns {Response<ResponseErrorType>}
+   */
+  public static UnauthorizedResponse(msg: string, errCode?: string): Response<ResponseErrorType> {
     console.warn(`Denying request - ${msg}`)
     return new Response<ResponseErrorType>(401, {
       err: msg,
       ...(errCode ? { errCode: errCode } : {}),
     })
   }
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @static
+   * @template BodyType
+   * @param {BodyType} body
+   * @returns {Response<BodyType>}
+   */
   public static SuccessResponse<BodyType>(body: BodyType): Response<BodyType> {
     return new Response<BodyType>(200, (body ? body : {}) as BodyType)
   }
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @static
+   * @param {string} url
+   * @returns {Response<null>}
+   */
   public static RedirectResponse(url: string): Response<null> {
     const resp = new Response<null>(302, null)
-    resp.appendHeader("Location", url)
+    resp.appendHeader('Location', url)
     return resp
   }
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @static
+   * @returns {Response<null>}
+   */
   public static SuccessNoContentResponse(): Response<null> {
     return new Response<null>(204, null)
   }
-  public static SuccessStreamResponse(
-    stream: any,
-    contentType: string,
-  ): Response {
-    const resp = new Response(200, stream ? stream : {}, {
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @static
+   * @param {*} stream
+   * @param {string} contentType
+   * @returns {Response}
+   */
+  public static SuccessStreamResponse(stream: any, contentType: string): Response {
+    const resp = new Response(200, stream, {
       shouldStream: true,
     })
-    resp.appendHeader("Connection", "keep-alive")
-    if (contentType) resp.appendHeader("Content-type", contentType)
+    resp.appendHeader('Connection', 'keep-alive')
+    if (contentType) resp.appendHeader('Content-Type', contentType)
     return resp
   }
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @static
+   * @template BodyType
+   * @param {BodyType} body
+   * @param {?number} [optionalCode]
+   * @returns {Response<BodyType>}
+   */
   public static SimpleResponse<BodyType>(
     body: BodyType,
-    optionalCode?: number,
+    optionalCode?: number
   ): Response<BodyType> {
     const resp = new Response<BodyType>(optionalCode || 200, body)
     return resp

package/src/API/Utils.ts

@@ -1,14 +1,52 @@
+/**
+ * ${1:Description placeholder}
+ *
+ * @export
+ * @class Utils
+ * @typedef {Utils}
+ */
 export default class Utils {
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @static
+   * @returns {boolean}
+   */
   public static isHybridlessContainer(): boolean {
-    return !!process.env.HYBRIDLESS_RUNTIME
+    return process.env.HYBRIDLESS_RUNTIME == 'true'
   }
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @static
+   * @param {string} string
+   * @returns {boolean}
+   */
   public static isValidString(string: string): boolean {
     return string?.length > 0 && !Array.isArray(string)
   }
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @static
+   * @param {string} string
+   * @returns {(number | null)}
+   */
   public static parseIntNullIfNaN(string: string): number | null {
     const n = parseInt(string)
     return isNaN(n) ? null : n
   }
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @static
+   * @param {string} string
+   * @returns {(any | null)}
+   */
   public static parseObjectNullIfEmpty(string: string): any | null {
     let o = null
     try {
@@ -19,21 +57,36 @@ export default class Utils {
     }
     return o
   }
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @static
+   * @param {string} number
+   * @returns {boolean}
+   */
   public static isValidNumber(number: string): boolean {
     let validNumb = NaN
     try {
-      validNumb = parseInt(number + "")
+      validNumb = parseInt(number + '')
     } catch (e) {
-      console.error("Error while validating number", e)
+      console.error('Error while validating number', e)
     }
     return !isNaN(validNumb) && !Array.isArray(number)
   }
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @static
+   * @param {*} obj
+   * @param {string} key
+   * @returns {(any | null)}
+   */
   public static caseInsensitiveObjectForKey(obj: any, key: string): any | null {
     if (!obj) return null
-    const insensitiveKey = Object.keys(obj).find(
-      (k) => k.toLowerCase() === key.toLowerCase(),
-    )
-    if (insensitiveKey && insensitiveKey != "") return obj[insensitiveKey]
+    const insensitiveKey = Object.keys(obj).find(k => k.toLowerCase() === key.toLowerCase())
+    if (insensitiveKey && insensitiveKey != '') return obj[insensitiveKey]
     return null
   }
 }