@creator.co/wapi 1.2.5 → 1.2.6

package/src/API/Response.ts

@@ -2,121 +2,90 @@ import type { Context } from 'aws-lambda'
 
 import Transaction from '../BaseEvent/Transaction'
 import Globals from '../Globals'
-//
+
 /**
- * ${1:Description placeholder}
- *
- * @class CustomError
- * @typedef {CustomError}
- * @extends {Error}
+ * CustomError class that extends the built-in Error class.
+ * @class
+ * @extends Error
+ * @param {any} body - The body of the error, which can be an object or a string.
+ * @constructor
+ * @property {string} name - The name of the error.
  */
 class CustomError extends Error {
-  /**
-   * Creates an instance of CustomError.
-   *
-   * @constructor
-   * @param {*} body
-   */
   constructor(body: any) {
     super(body.message || 'Unknown error!')
     this.name = body.error || 'UnknownError'
   }
 }
-//
+
 /**
- * ${1:Description placeholder}
- *
- * @export
- * @typedef {ResponseErrorType}
+ * Represents an error response from an API.
+ * @typedef {Object} ResponseErrorType
+ * @property {string} err - The error message.
+ * @property {string} [errCode] - The error code, if available.
  */
 export type ResponseErrorType = {
   err: string
   errCode?: string
 }
-//
+
 /**
- * ${1:Description placeholder}
- *
- * @export
- * @class Response
- * @typedef {Response}
- * @template [BodyType=null]
+ * Represents a response object with various methods for building and manipulating the response.
+ * @template BodyType - The type of the response body.
  */
 export default class Response<BodyType = null> {
   /**
-   * ${1:Description placeholder}
-   *
-   * @private
+   * The private property that stores the status code.
    * @type {number}
+   * @private
    */
-  private _statusCode: number
+  private statusCode: number
   /**
-   * ${1:Description placeholder}
-   *
+   * Private property representing the body of an object.
+   * @type {any}
    * @private
-   * @type {*}
    */
-  private _body: any
+  private body: any
   /**
-   * ${1:Description placeholder}
-   *
-   * @private
+   * Indicates whether the object is currently piping out.
    * @type {boolean}
    */
-  private _isPipingOut: boolean
+  private isPipingOut: boolean
   /**
-   * ${1:Description placeholder}
-   *
-   * @private
-   * @type {object}
+   * Private property that stores the headers as an object.
    */
-  private _headers: object
+  private headers: object
   /**
-   * ${1:Description placeholder}
-   *
-   * @public
-   * @readonly
-   * @type {boolean}
+   * Determines whether streaming is enabled or not.
+   * @returns {boolean} - True if streaming is enabled, false otherwise.
    */
   public readonly shouldStream: boolean
   /**
-   * ${1:Description placeholder}
-   *
-   * @public
-   * @readonly
+   * Indicates whether the request body should be treated as raw data.
    * @type {boolean}
    */
   public readonly rawBody: boolean
   /**
-   * ${1:Description placeholder}
-   *
-   * @public
-   * @readonly
-   * @type {boolean}
+   * A boolean flag indicating whether to throw an error when encountering errors.
+   * If set to true, any errors encountered will result in an exception being thrown.
+   * If set to false, errors will be logged but the program will continue execution.
    */
   public readonly throwOnErrors: boolean
   /**
-   * ${1:Description placeholder}
-   *
-   * @public
-   * @readonly
+   * Indicates whether the transaction ID is disabled.
    * @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]
+   * Constructs a new Response object with the given status code, body, and optional behavior.
+   * @param {number} statusCode - The HTTP status code of the response.
+   * @param {BodyType} body - The body of the response.
+   * @param {Object} [optBehaviour] - Optional behavior configuration for the response.
+   * @param {boolean} [optBehaviour.shouldStream] - Indicates whether the response should be streamed.
+   * @param {boolean} [optBehaviour.rawBody] - Indicates whether the response body should be treated as raw data.
+   * @param {boolean} [optBehaviour.throwOnErrors] - Indicates whether errors should be thrown for non-successful status codes.
+   * @param {boolean} [optBehaviour
    */
   constructor(
     statusCode: number,
@@ -131,140 +100,132 @@ export default class Response<BodyType = null> {
       | undefined
   ) {
     // response
-    this._statusCode = statusCode
-    this._body = body
-    this._headers = {
+    this.statusCode = statusCode
+    this.body = body
+    this.headers = {
       '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
+    this.isPipingOut = false //internal -- flag to indicate streaming out has started and avoid double stream call
     // options
     this.shouldStream = !!optBehaviour?.shouldStream //
     this.rawBody = !!optBehaviour?.rawBody
     this.throwOnErrors = !!optBehaviour?.throwOnErrors
     this.disableTransactionID = !!optBehaviour?.disableTransactionID
   }
+
   /**
-   * ${1:Description placeholder}
-   *
-   * @public
-   * @returns {number}
+   * Get the status code of the response.
+   * @returns {number} The status code.
    */
   public getCode(): number {
-    return this._statusCode
+    return this.statusCode
   }
+
   /**
-   * ${1:Description placeholder}
-   *
-   * @public
-   * @returns {BodyType}
+   * Get the body of the object.
+   * @returns {BodyType} The body of the object.
    */
   public getBody(): BodyType {
-    return this._body
+    return this.body
   }
+
   /**
-   * ${1:Description placeholder}
-   *
-   * @public
-   * @param {string} key
-   * @param {*} value
+   * Appends a key-value pair into the body object.
+   * @param {string} key - The key to append.
+   * @param {any} value - The value to append.
+   * @returns None
    */
   public appendIntoBody(key: string, value: any): void {
-    this._body[key] = value
+    this.body[key] = value
   }
+
   /**
-   * ${1:Description placeholder}
-   *
-   * @public
-   * @param {string} key
-   * @param {*} value
+   * Appends a header to the existing headers object.
+   * @param {string} key - The key of the header.
+   * @param {any} value - The value of the header.
+   * @returns None
    */
   public appendHeader(key: string, value: any): void {
-    this._headers[key] = value
+    this.headers[key] = value
   }
+
   /**
-   * ${1:Description placeholder}
-   *
-   * @public
-   * @async
-   * @param {Context} context
-   * @param {Transaction<any, any, any>} transaction
-   * @param {boolean} _optDoNotCallContext
-   * @returns {Promise<void>}
+   * Builds the response for the given context and transaction.
+   * @param {Context} context - The context object.
+   * @param {Transaction<any, any, any>} transaction - The transaction object.
+   * @param {boolean} optDoNotCallContext - Optional flag to indicate whether to call the context or not.
+   * @returns {Promise<void>} - A promise that resolves when the response is built.
    */
   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)
+    if (this.isPipingOut) return
+    if (this.shouldStream) return this.pipe(context)
 
     //append default fields
-    if (transaction.request.getRequestID() && this._body && !this.disableTransactionID)
+    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)
+    if (this.rawBody) return this.rawContext(context, transaction)
 
     //build response
     const b = {
-      statusCode: this._statusCode,
-      headers: this._headers,
-      ...(this._body ? { body: JSON.stringify(this._body) } : {}),
+      statusCode: this.statusCode,
+      headers: this.headers,
+      ...(this.body ? { body: JSON.stringify(this.body) } : {}),
     }
     //log response and respond to context
     transaction.logger.debug(b)
     //Check for transaction response proxy
     if (transaction.responseProxy) await transaction.responseProxy(this)
     //Batch does not succeed directly just on upper transaction (which will should be a batch)
-    if (!_optDoNotCallContext) context.succeed(b)
+    if (!optDoNotCallContext) context.succeed(b)
   }
+
   /**
-   * ${1:Description placeholder}
-   *
-   * @private
-   * @param {Context} context
+   * Private method that pipes the response to the given context.
+   * @param {Context} context - The context object provided by AWS Lambda.
+   * @returns None
    */
-  private _pipe(context: Context): void {
+  private pipe(context: Context): void {
     //Check if not streaming
-    this._isPipingOut = true
+    this.isPipingOut = true
     //build response
     const b = {
-      statusCode: this._statusCode,
-      body: this._body,
-      headers: this._headers,
+      statusCode: this.statusCode,
+      body: this.body,
+      headers: this.headers,
     }
     //log response and respond to context
     context.succeed(b)
   }
+
   /**
-   * ${1:Description placeholder}
-   *
-   * @private
-   * @param {Context} context
-   * @param {Transaction<null, BodyType>} transaction
+   * Private method that handles the raw context of a transaction.
+   * @param {Context} context - The context object.
+   * @param {Transaction<null, BodyType>} transaction - The transaction object.
+   * @returns None
    */
-  private _rawContext(context: Context, transaction: Transaction<null, BodyType>): void {
+  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)
+    transaction.logger.debug(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)
+      if (!this.throwOnErrors) context.fail(new CustomError(this.body))
+      else throw new CustomError(this.body)
     }
   }
 
-  /* Shortcuts */
   /**
-   * ${1:Description placeholder}
-   *
-   * @public
-   * @static
-   * @param {string} paramName
-   * @returns {Response<ResponseErrorType>}
+   * Generates a response object for a missing path parameter error.
+   * @param {string} paramName - The name of the missing path parameter.
+   * @returns {Response<ResponseErrorType>} - The response object with error details.
    */
   public static MissingParamResponse(paramName: string): Response<ResponseErrorType> {
     console.warn(`Invalid request - Path parameter ${paramName} is missing.`)
@@ -273,13 +234,11 @@ export default class Response<BodyType = null> {
       errCode: Globals.ErrorCode_MissingParam,
     })
   }
+
   /**
-   * ${1:Description placeholder}
-   *
-   * @public
-   * @static
-   * @param {string} paramName
-   * @returns {Response<ResponseErrorType>}
+   * Creates a response object for a missing query parameter error.
+   * @param {string} paramName - The name of the missing query parameter.
+   * @returns {Response<ResponseErrorType>} - The response object with error details.
    */
   public static MissingQueryResponse(paramName: string): Response<ResponseErrorType> {
     console.warn(`Invalid request - Query parameter ${paramName} is missing.`)
@@ -288,15 +247,13 @@ export default class Response<BodyType = null> {
       errCode: Globals.ErrorCode_MissingParam,
     })
   }
+
   /**
-   * ${1:Description placeholder}
-   *
-   * @public
-   * @static
-   * @param {?string} [msg]
-   * @param {?string} [errCode]
-   * @param {?*} [optBody]
-   * @returns {Response<ResponseErrorType>}
+   * Creates a BadRequestResponse object with the given parameters.
+   * @param {string} [msg] - The error message.
+   * @param {string} [errCode] - The error code.
+   * @param {any} [optBody] - Optional additional body data.
+   * @returns {Response<ResponseErrorType>} - The BadRequestResponse object.
    */
   public static BadRequestResponse(
     msg?: string,
@@ -310,15 +267,13 @@ export default class Response<BodyType = null> {
       ...(optBody || {}),
     })
   }
+
   /**
-   * ${1:Description placeholder}
-   *
-   * @public
-   * @static
-   * @param {string} msg
-   * @param {?string} [errCode]
-   * @param {?*} [optBody]
-   * @returns {Response<ResponseErrorType>}
+   * Creates a BadRequestResponse object with rollback option.
+   * @param {string} msg - The error message.
+   * @param {string} [errCode] - The error code.
+   * @param {any} [optBody] - Optional body to include in the response.
+   * @returns {Response<ResponseErrorType>} - The BadRequestResponse object.
    */
   public static BadRequestResponseWithRollback(
     msg: string,
@@ -333,14 +288,12 @@ export default class Response<BodyType = null> {
       ...(optBody || {}),
     })
   }
+
   /**
-   * ${1:Description placeholder}
-   *
-   * @public
-   * @static
-   * @param {string} msg
-   * @param {?string} [errCode]
-   * @returns {Response<ResponseErrorType>}
+   * Creates an unauthorized response with the given error message and error code.
+   * @param {string} msg - The error message.
+   * @param {string} [errCode] - The error code (optional).
+   * @returns {Response<ResponseErrorType>} - The unauthorized response.
    */
   public static UnauthorizedResponse(msg: string, errCode?: string): Response<ResponseErrorType> {
     console.warn(`Denying request - ${msg}`)
@@ -349,49 +302,40 @@ export default class Response<BodyType = null> {
       ...(errCode ? { errCode: errCode } : {}),
     })
   }
+
   /**
-   * ${1:Description placeholder}
-   *
-   * @public
-   * @static
-   * @template BodyType
-   * @param {BodyType} body
-   * @returns {Response<BodyType>}
+   * Creates a success response object with the given body.
+   * @param {BodyType} body - The body of the response.
+   * @returns {Response<BodyType>} - The success response object.
    */
   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>}
+   * Creates a redirect response with the specified URL.
+   * @param {string} url - The URL to redirect to.
+   * @returns {Response<null>} - The redirect response.
    */
   public static RedirectResponse(url: string): Response<null> {
     const resp = new Response<null>(302, null)
     resp.appendHeader('Location', url)
     return resp
   }
+
   /**
-   * ${1:Description placeholder}
-   *
-   * @public
-   * @static
-   * @returns {Response<null>}
+   * Creates a success response with no content.
+   * @returns {Response<null>} A response object with a status code of 204 and no content.
    */
   public static SuccessNoContentResponse(): Response<null> {
     return new Response<null>(204, null)
   }
+
   /**
-   * ${1:Description placeholder}
-   *
-   * @public
-   * @static
-   * @param {*} stream
-   * @param {string} contentType
-   * @returns {Response}
+   * Creates a success response object with a streaming body and specified content type.
+   * @param {any} stream - The stream object to be used as the response body.
+   * @param {string} contentType - The content type of the response.
+   * @returns {Response} - The success response object.
    */
   public static SuccessStreamResponse(stream: any, contentType: string): Response {
     const resp = new Response(200, stream, {
@@ -401,15 +345,12 @@ export default class Response<BodyType = null> {
     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>}
+   * Creates a simple HTTP response with the given body and optional status code.
+   * @param {BodyType} body - The body of the response.
+   * @param {number} [optionalCode] - The optional status code of the response. Defaults to 200.
+   * @returns {Response<BodyType>} - The created response object.
    */
   public static SimpleResponse<BodyType>(
     body: BodyType,

package/src/API/Utils.ts

@@ -1,69 +1,55 @@
 /**
- * ${1:Description placeholder}
- *
- * @export
- * @class Utils
- * @typedef {Utils}
+ * Utility class containing various static methods for common operations.
  */
 export default class Utils {
   /**
-   * ${1:Description placeholder}
-   *
-   * @public
-   * @static
-   * @returns {boolean}
+   * Checks if the application is running in a hybridless container.
+   * @returns {boolean} - True if the application is running in a hybridless container, false otherwise.
    */
   public static isHybridlessContainer(): boolean {
     return process.env.HYBRIDLESS_RUNTIME == 'true'
   }
+
   /**
-   * ${1:Description placeholder}
-   *
-   * @public
-   * @static
-   * @param {string} string
-   * @returns {boolean}
+   * Checks if a given string is valid.
+   * @param {string} string - The string to check.
+   * @returns {boolean} - True if the string is valid, false otherwise.
    */
   public static isValidString(string: string): boolean {
     return string?.length > 0 && !Array.isArray(string)
   }
+
   /**
-   * ${1:Description placeholder}
-   *
-   * @public
-   * @static
-   * @param {string} string
-   * @returns {(number | null)}
+   * Parses a string into an integer and returns null if the string is not a valid number.
+   * @param {string} string - The string to parse into an integer.
+   * @returns {number | null} - The parsed integer or null if the string is not a valid number.
    */
   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)}
+   * Parses a JSON string and returns the resulting object. If the string is empty or
+   * cannot be parsed, null is returned.
+   * @param {string} string - The JSON string to parse.
+   * @returns {any | null} - The parsed object or null if the string is empty or invalid.
    */
-  public static parseObjectNullIfEmpty(string: string): any | null {
+  public static parseObjectNullIfEmpty(string: string | undefined): any | null {
     let o = null
     try {
-      o = JSON.parse(string)
-      if (Object.keys(o).length <= 0) o = null
+      o = string ? JSON.parse(string) : null
+      if (o && Object.keys(o).length <= 0) o = null
     } catch (e) {
       /* empty */
     }
     return o
   }
+
   /**
-   * ${1:Description placeholder}
-   *
-   * @public
-   * @static
-   * @param {string} number
-   * @returns {boolean}
+   * Checks if a given value is a valid number.
+   * @param {string} number - The value to be checked.
+   * @returns {boolean} - True if the value is a valid number, false otherwise.
    */
   public static isValidNumber(number: string): boolean {
     let validNumb = NaN
@@ -74,14 +60,12 @@ export default class Utils {
     }
     return !isNaN(validNumb) && !Array.isArray(number)
   }
+
   /**
-   * ${1:Description placeholder}
-   *
-   * @public
-   * @static
-   * @param {*} obj
-   * @param {string} key
-   * @returns {(any | null)}
+   * Retrieves the value from an object using a case-insensitive key lookup.
+   * @param {any} obj - The object to search for the key.
+   * @param {string} key - The key to search for in the object.
+   * @returns {any | null} The value associated with the key, or null if the key is not found.
    */
   public static caseInsensitiveObjectForKey(obj: any, key: string): any | null {
     if (!obj) return null