@creator.co/wapi 1.2.2 → 1.2.4

package/src/API/Request.ts

@@ -1,7 +1,7 @@
-import type { Context, APIGatewayEvent } from "aws-lambda"
+import type { Context, APIGatewayEvent } from 'aws-lambda'
 
-import Utils from "./Utils"
-import Logger from "../Logger/Logger"
+import Utils from './Utils'
+import Logger from '../Logger/Logger'
 /**
  * ${1:Description placeholder}
  *
@@ -36,8 +36,8 @@ export default class Request<InputType> {
   constructor(requestEvent: APIGatewayEvent, context: Context, logger: Logger) {
     this.requestEvent = requestEvent
     this.context = context
-    logger.debug("Request info:", JSON.stringify(requestEvent))
-    logger.debug("Request context:", JSON.stringify(context))
+    logger.debug('Request info:', JSON.stringify(requestEvent))
+    logger.debug('Request context:', JSON.stringify(context))
   }
   /**
    * ${1:Description placeholder}
@@ -58,10 +58,7 @@ export default class Request<InputType> {
    * @returns {(string | null)}
    */
   public getQueryParam(paramName: string): string | null {
-    return Utils.caseInsensitiveObjectForKey(
-      this.requestEvent.queryStringParameters,
-      paramName,
-    )
+    return Utils.caseInsensitiveObjectForKey(this.requestEvent.queryStringParameters, paramName)
   }
   /**
    * ${1:Description placeholder}
@@ -71,10 +68,7 @@ export default class Request<InputType> {
    * @returns {(string | null)}
    */
   public getHeader(headerName: string): string | null {
-    return Utils.caseInsensitiveObjectForKey(
-      this.requestEvent.headers,
-      headerName,
-    )
+    return Utils.caseInsensitiveObjectForKey(this.requestEvent.headers, headerName)
   }
   //context params
   /**
@@ -85,10 +79,7 @@ export default class Request<InputType> {
    * @returns {(any | null)}
    */
   public getContextParam(cxtParam: string): any | null {
-    return Utils.caseInsensitiveObjectForKey(
-      this.requestEvent.requestContext,
-      cxtParam,
-    )
+    return Utils.caseInsensitiveObjectForKey(this.requestEvent.requestContext, cxtParam)
   }
   /**
    * ${1:Description placeholder}
@@ -109,10 +100,7 @@ export default class Request<InputType> {
    * @returns {(string | null)}
    */
   public getPathParam(paramName: string): string | null {
-    return Utils.caseInsensitiveObjectForKey(
-      this.requestEvent.pathParameters,
-      paramName,
-    )
+    return Utils.caseInsensitiveObjectForKey(this.requestEvent.pathParameters, paramName)
   }
   /**
    * ${1:Description placeholder}
@@ -124,10 +112,9 @@ export default class Request<InputType> {
     let b: any = null
     try {
       b = this.requestEvent.body
-      if (typeof b === "string" || b instanceof String)
-        b = JSON.parse(b as string)
+      if (typeof b === 'string' || b instanceof String) b = JSON.parse(b as string)
     } catch (e) {
-      console.error("Error while getting request body!", e)
+      console.error('Error while getting request body!', e)
     }
     return b
   }
@@ -165,7 +152,7 @@ export default class Request<InputType> {
    * @returns {(string | null)}
    */
   public getAuthorizationHeader(): string | null {
-    return this.getHeader("Authorization")
+    return this.getHeader('Authorization')
   }
   /**
    * ${1:Description placeholder}
@@ -175,9 +162,7 @@ export default class Request<InputType> {
    */
   public getRequestID(): string {
     if (this.context.awsRequestId) return this.context.awsRequestId
-    return this.requestEvent.requestContext
-      ? this.requestEvent.requestContext.requestId
-      : "unknown"
+    return this.requestEvent.requestContext ? this.requestEvent.requestContext.requestId : 'unknown'
   }
   /**
    * ${1:Description placeholder}
@@ -186,9 +171,9 @@ export default class Request<InputType> {
    * @returns {string}
    */
   public getOriginIP(): string {
-    const origin = this.getContextParam("identity")?.sourceIp
-    const hOrigin = this.getHeader("X-Forwarded-For")
-    return origin ? origin : hOrigin ? hOrigin : "unknown"
+    const origin = this.getContextParam('identity')?.sourceIp
+    const hOrigin = this.getHeader('X-Forwarded-For')
+    return origin ? origin : hOrigin ? hOrigin : 'unknown'
   }
   /**
    * ${1:Description placeholder}
@@ -199,9 +184,6 @@ export default class Request<InputType> {
    */
   public setFixedPathParams(keys: any[], result: any[]): void {
     this.requestEvent.pathParameters = {}
-    keys.forEach(
-      (key, index) =>
-        (this.requestEvent.pathParameters[key.name] = result[index + 1]),
-    )
+    keys.forEach((key, index) => (this.requestEvent.pathParameters[key.name] = result[index + 1]))
   }
 }

package/src/API/Response.ts

@@ -1,7 +1,7 @@
-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}
@@ -18,8 +18,8 @@ class CustomError extends Error {
    * @param {*} body
    */
   constructor(body: any) {
-    super(body.message || "Unknown error!")
-    this.name = body.error || "UnknownError"
+    super(body.message || 'Unknown error!')
+    this.name = body.error || 'UnknownError'
   }
 }
 //
@@ -128,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
@@ -197,19 +197,15 @@ export default class Response<BodyType = null> {
   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)
 
@@ -251,14 +247,10 @@ export default class Response<BodyType = null> {
    * @param {Context} context
    * @param {Transaction<null, BodyType>} transaction
    */
-  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)
+    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)
@@ -274,9 +266,7 @@ export default class Response<BodyType = null> {
    * @param {string} paramName
    * @returns {Response<ResponseErrorType>}
    */
-  public static MissingParamResponse(
-    paramName: string,
-  ): 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.`,
@@ -291,9 +281,7 @@ export default class Response<BodyType = null> {
    * @param {string} paramName
    * @returns {Response<ResponseErrorType>}
    */
-  public static MissingQueryResponse(
-    paramName: string,
-  ): 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.`,
@@ -313,7 +301,7 @@ export default class Response<BodyType = null> {
   public static BadRequestResponse(
     msg?: string,
     errCode?: string,
-    optBody?: any,
+    optBody?: any
   ): Response<ResponseErrorType> {
     console.warn(`Bad request - ${msg}`)
     return new Response<ResponseErrorType>(400, {
@@ -335,7 +323,7 @@ export default class Response<BodyType = null> {
   public static BadRequestResponseWithRollback(
     msg: string,
     errCode?: string,
-    optBody?: any,
+    optBody?: any
   ): Response<ResponseErrorType> {
     console.warn(`Bad request - ${msg}`)
     return new Response<ResponseErrorType>(400, {
@@ -354,10 +342,7 @@ export default class Response<BodyType = null> {
    * @param {?string} [errCode]
    * @returns {Response<ResponseErrorType>}
    */
-  public static UnauthorizedResponse(
-    msg: string,
-    errCode?: string,
-  ): Response<ResponseErrorType> {
+  public static UnauthorizedResponse(msg: string, errCode?: string): Response<ResponseErrorType> {
     console.warn(`Denying request - ${msg}`)
     return new Response<ResponseErrorType>(401, {
       err: msg,
@@ -386,7 +371,7 @@ export default class Response<BodyType = 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
   }
   /**
@@ -408,15 +393,12 @@ export default class Response<BodyType = null> {
    * @param {string} contentType
    * @returns {Response}
    */
-  public static SuccessStreamResponse(
-    stream: any,
-    contentType: string,
-  ): 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
   }
   /**
@@ -431,7 +413,7 @@ export default class Response<BodyType = null> {
    */
   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

@@ -14,7 +14,7 @@ export default class Utils {
    * @returns {boolean}
    */
   public static isHybridlessContainer(): boolean {
-    return process.env.HYBRIDLESS_RUNTIME == "true"
+    return process.env.HYBRIDLESS_RUNTIME == 'true'
   }
   /**
    * ${1:Description placeholder}
@@ -68,9 +68,9 @@ export default class Utils {
   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)
   }
@@ -85,10 +85,8 @@ export default class Utils {
    */
   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
   }
 }

package/src/BaseEvent/EventProcessor.ts

@@ -1,8 +1,8 @@
-import type { Context, SQSBatchResponse, SQSEvent } from "aws-lambda"
+import type { Context, SQSBatchResponse, SQSEvent } from 'aws-lambda'
 
-import Transaction, { TransactionConfig } from "./Transaction"
-import Response, { ResponseErrorType } from "../API/Response"
-import Globals from "../Globals"
+import Transaction, { TransactionConfig } from './Transaction'
+import Response, { ResponseErrorType } from '../API/Response'
+import Globals from '../Globals'
 
 // Handler
 /**
@@ -13,12 +13,8 @@ import Globals from "../Globals"
  * @template ResponseInnerType
  */
 export type EventProcessorExecution<ResponseInnerType> = (
-  transaction: Transaction<
-    null,
-    ResponseInnerType | ResponseErrorType,
-    SQSBatchResponse
-  >,
-  recordContent: string | object,
+  transaction: Transaction<null, ResponseInnerType | ResponseErrorType, SQSBatchResponse>,
+  recordContent: string | object
 ) => Promise<Response<ResponseInnerType | ResponseErrorType> | SQSBatchResponse>
 
 /**
@@ -75,7 +71,7 @@ export default class EventProcessor<ResponseInnerType> {
     event: SQSEvent,
     context: Context,
     config?: TransactionConfig,
-    allowFailure?: boolean,
+    allowFailure?: boolean
   ) {
     this._event = event
     this._context = context
@@ -92,7 +88,7 @@ export default class EventProcessor<ResponseInnerType> {
    */
   async processEvent(
     execution: EventProcessorExecution<ResponseInnerType>,
-    doNotDecodeMessage?: boolean,
+    doNotDecodeMessage?: boolean
   ): Promise<Response<ResponseErrorType> | null | SQSBatchResponse> {
     const resp = await this._processRawEvent(execution, !!doNotDecodeMessage)
     if (
@@ -115,7 +111,7 @@ export default class EventProcessor<ResponseInnerType> {
    */
   async _processRawEvent(
     execution: EventProcessorExecution<ResponseInnerType>,
-    doNotDecodeMessage: boolean,
+    doNotDecodeMessage: boolean
   ): Promise<Response<ResponseErrorType> | null | SQSBatchResponse> {
     if (this._event.Records && this._event.Records.length > 0) {
       //safe check for empty events?
@@ -126,14 +122,11 @@ export default class EventProcessor<ResponseInnerType> {
         {
           ...this._apiConfig,
           syncReturn: true,
-        },
-      ).execute(async (transaction) => {
+        }
+      ).execute(async transaction => {
         //Map records with decoded message when required
-        const decodedRecords: string[] | object[] = this._event.Records.map(
-          (eventRecord) =>
-            doNotDecodeMessage
-              ? eventRecord.body
-              : JSON.parse(eventRecord.body),
+        const decodedRecords: string[] | object[] = this._event.Records.map(eventRecord =>
+          doNotDecodeMessage ? eventRecord.body : JSON.parse(eventRecord.body)
         )
 
         //for each available event
@@ -146,8 +139,7 @@ export default class EventProcessor<ResponseInnerType> {
           //check for failure
           if (
             !resp ||
-            (resp instanceof Response &&
-              !(resp?.getCode() >= 200 && resp?.getCode() < 300))
+            (resp instanceof Response && !(resp?.getCode() >= 200 && resp?.getCode() < 300))
           ) {
             //response with failures or fail hard at first
             if (this._allowFailure) failureIDs.push(message.messageId)
@@ -157,14 +149,14 @@ export default class EventProcessor<ResponseInnerType> {
         //not errored and loop ended - succeeded (might have failures)
         if (this._allowFailure)
           return {
-            batchItemFailures: failureIDs.map((id) => ({ itemIdentifier: id })),
+            batchItemFailures: failureIDs.map(id => ({ itemIdentifier: id })),
           }
         return Response.SuccessResponse(null)
       })
     } else
       return Response.BadRequestResponse(
         Globals.ErrorResponseNoRecords,
-        Globals.ErrorCode_NoRecords,
+        Globals.ErrorCode_NoRecords
       ) //no event to be processed?
   }
 }

package/src/BaseEvent/Process.ts

@@ -1,6 +1,6 @@
-import { TransactionConfig } from "./Transaction"
-import Logger from "../Logger/Logger"
-import Publisher from "../Publisher/Publisher"
+import { TransactionConfig } from './Transaction'
+import Logger from '../Logger/Logger'
+import Publisher from '../Publisher/Publisher'
 
 // Config
 /**
@@ -9,10 +9,7 @@ import Publisher from "../Publisher/Publisher"
  * @export
  * @typedef {ProcessConfig}
  */
-export type ProcessConfig = Omit<
-  TransactionConfig,
-  "throwOnErrors" | "syncReturn"
->
+export type ProcessConfig = Omit<TransactionConfig, 'throwOnErrors' | 'syncReturn'>
 
 /**
  * ${1:Description placeholder}
@@ -62,7 +59,7 @@ export default class Process {
    */
   constructor(config: ProcessConfig, interval: number) {
     this._interval = interval
-    this.logger = new Logger(config.logger, "long-running-process")
+    this.logger = new Logger(config.logger, 'long-running-process')
     this.publisher = new Publisher(config.publisher)
   }
 
@@ -75,7 +72,7 @@ export default class Process {
    * @returns {*}
    */
   async execute(executionFunc) {
-    this.logger.debug("Starting main process code")
+    this.logger.debug('Starting main process code')
     //Connect DB
     // if (this.db) await this.db.connect();
     //Program loop
@@ -105,9 +102,7 @@ export default class Process {
       executionFailed = false
     } catch (e) {
       /*EXECUTION FAIL*/
-      this.logger.error(
-        "Exception when executing main process code. Rolling back DB!",
-      )
+      this.logger.error('Exception when executing main process code. Rolling back DB!')
       this.logger.exception(e)
       //Rollback DB
       // if (this.db) await this.db.rollback();

package/src/BaseEvent/Transaction.ts

@@ -1,21 +1,15 @@
-import type { APIGatewayEvent, Context, SQSEvent } from "aws-lambda"
+import type { APIGatewayEvent, Context, SQSEvent } from 'aws-lambda'
 
-import Request from "../API/Request"
-import Response, { ResponseErrorType } from "../API/Response"
-import Globals from "../Globals"
-import Logger, { LoggerConfig } from "../Logger/Logger"
-import Publisher, { PublisherConfig } from "../Publisher/Publisher"
+import Request from '../API/Request'
+import Response, { ResponseErrorType } from '../API/Response'
+import Globals from '../Globals'
+import Logger, { LoggerConfig } from '../Logger/Logger'
+import Publisher, { PublisherConfig } from '../Publisher/Publisher'
 
 // Request
-export type TransactionExecution<
-  TransactionType,
-  ResponseInnerType,
-  MiscRespType = null,
-> = (
-  transaction: TransactionType,
-) => Promise<
-  Response<ResponseInnerType> | Response<ResponseErrorType> | MiscRespType
->
+export type TransactionExecution<TransactionType, ResponseInnerType, MiscRespType = null> = (
+  transaction: TransactionType
+) => Promise<Response<ResponseInnerType> | Response<ResponseErrorType> | MiscRespType>
 // Config
 export type TransactionConfig = {
   throwOnErrors?: boolean
@@ -32,10 +26,7 @@ export default class Transaction<
 > {
   private event: any
   private context: Context
-  private response:
-    | Response<ResponseInnerType | ResponseErrorType>
-    | MiscRespType
-    | null
+  private response: Response<ResponseInnerType | ResponseErrorType> | MiscRespType | null
   private syncReturn: boolean
   private retrowErrors: boolean
   //
@@ -44,16 +35,12 @@ export default class Transaction<
   public readonly publisher: Publisher
   public responseProxy: (response: Response<ResponseInnerType>) => Promise<void>
   //
-  constructor(
-    event: APIGatewayEvent | SQSEvent,
-    context: Context,
-    config?: TransactionConfig,
-  ) {
+  constructor(event: APIGatewayEvent | SQSEvent, context: Context, config?: TransactionConfig) {
     const transactionId = context.awsRequestId
       ? context.awsRequestId
       : (<APIGatewayEvent>event).requestContext
       ? (<APIGatewayEvent>event).requestContext.requestId
-      : "unknown"
+      : 'unknown'
     // transaction ctx
     this.event = event
     this.context = context
@@ -75,7 +62,7 @@ export default class Transaction<
       Transaction<InputType, ResponseInnerType, MiscRespType>,
       ResponseInnerType,
       MiscRespType
-    >,
+    >
   ): Promise<Response<ResponseInnerType | ResponseErrorType> | MiscRespType> {
     await this.executeLoggerFlush(async () => {
       await this.executeDBTransactions(async () => {
@@ -93,42 +80,40 @@ export default class Transaction<
       Transaction<InputType, ResponseInnerType, MiscRespType>,
       ResponseInnerType,
       MiscRespType
-    >,
+    >
   ): Promise<boolean> {
     let executionFailed = true //failed til we say no!
     //safe execution handler
     try {
       //Execute
-      this.logger.debug("Starting main request code")
+      this.logger.debug('Starting main request code')
       this.response = await executionFunc(this)
       //Answer client
       if (this.response && this.response instanceof Response) {
         await this.response.build(this.context, this, this.syncReturn)
-        executionFailed = !!(
-          this.response.getBody() && this.response.getBody()["rollback"]
-        )
+        executionFailed = !!(this.response.getBody() && this.response.getBody()['rollback'])
       } else if (this.syncReturn && this.response) {
-        this.logger.log("Sync return with different response object")
+        this.logger.log('Sync return with different response object')
         this.logger.debug(this.response)
         executionFailed = false
       } else {
         this.response = this.getErrorResponse(
           Globals.ErrorResponseInvalidServerResponse,
-          Globals.ErrorCode_APIError,
+          Globals.ErrorCode_APIError
         )
         await this.response.build(this.context, this, this.syncReturn)
-        this.logger.error("Invalid response object from main request code.")
+        this.logger.error('Invalid response object from main request code.')
       }
     } catch (e) {
       /*EXECUTION FAIL*/
-      this.logger.error("Exception when executing main request code.")
+      this.logger.error('Exception when executing main request code.')
       this.logger.exception(e)
       //retrow?
       if (this.retrowErrors) throw e
       //envelope exception?
       this.response = this.getErrorResponse(
         Globals.ErrorResponseUnhandledError,
-        Globals.ErrorCode_APIError,
+        Globals.ErrorCode_APIError
       )
       await this.response.build(this.context, this, this.syncReturn)
     }
@@ -153,7 +138,7 @@ export default class Transaction<
       // //Cleanup DB after execution
       // if (this.db) await this.db.cleanup();
     } catch (e) {
-      this.logger.error("Exception when executing DB transactions.")
+      this.logger.error('Exception when executing DB transactions.')
       this.logger.log(e.stack)
       //retrow?
       if (this.retrowErrors) throw e
@@ -163,19 +148,16 @@ export default class Transaction<
     try {
       await safeExecution()
     } catch (e) {
-      this.logger.error("Exception when flushing logs.")
+      this.logger.error('Exception when flushing logs.')
       this.logger.exception(e)
       //retrow?
       if (this.retrowErrors) throw e
     } finally {
-      this.logger.debug("Transaction ended")
+      this.logger.debug('Transaction ended')
     }
   }
   /* Response support */
-  private getErrorResponse(
-    error: string,
-    code: string,
-  ): Response<ResponseErrorType> {
+  private getErrorResponse(error: string, code: string): Response<ResponseErrorType> {
     return Response.BadRequestResponseWithRollback(error, code)
   }
 }