@creator.co/wapi 1.2.1-beta6 → 1.2.3

package/src/BaseEvent/EventProcessor.ts

@@ -1,34 +1,94 @@
-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
-export type EventProcessorExecution = (
-  transaction: Transaction<null, ResponseErrorType, SQSBatchResponse>,
-  recordContent: string | object,
-) => Promise<Response | SQSBatchResponse>
+/**
+ * ${1:Description placeholder}
+ *
+ * @export
+ * @typedef {EventProcessorExecution}
+ * @template ResponseInnerType
+ */
+export type EventProcessorExecution<ResponseInnerType> = (
+  transaction: Transaction<null, ResponseInnerType | ResponseErrorType, SQSBatchResponse>,
+  recordContent: string | object
+) => Promise<Response<ResponseInnerType | ResponseErrorType> | SQSBatchResponse>
 
-export default class EventProcessor {
+/**
+ * ${1:Description placeholder}
+ *
+ * @export
+ * @class EventProcessor
+ * @typedef {EventProcessor}
+ * @template ResponseInnerType
+ */
+export default class EventProcessor<ResponseInnerType> {
+  /**
+   * ${1:Description placeholder}
+   *
+   * @private
+   * @readonly
+   * @type {boolean}
+   */
   private readonly _allowFailure: boolean
+  /**
+   * ${1:Description placeholder}
+   *
+   * @private
+   * @readonly
+   * @type {TransactionConfig}
+   */
   private readonly _apiConfig: TransactionConfig
+  /**
+   * ${1:Description placeholder}
+   *
+   * @private
+   * @readonly
+   * @type {Context}
+   */
   private readonly _context: Context
+  /**
+   * ${1:Description placeholder}
+   *
+   * @private
+   * @readonly
+   * @type {SQSEvent}
+   */
   private readonly _event: SQSEvent
+  /**
+   * Creates an instance of EventProcessor.
+   *
+   * @constructor
+   * @param {SQSEvent} event
+   * @param {Context} context
+   * @param {?TransactionConfig} [config]
+   * @param {?boolean} [allowFailure]
+   */
   constructor(
     event: SQSEvent,
     context: Context,
-    config: TransactionConfig,
-    allowFailure?: boolean,
+    config?: TransactionConfig,
+    allowFailure?: boolean
   ) {
     this._event = event
     this._context = context
-    this._apiConfig = config
+    this._apiConfig = config || {}
     this._allowFailure = allowFailure
   }
+  /**
+   * ${1:Description placeholder}
+   *
+   * @async
+   * @param {EventProcessorExecution<ResponseInnerType>} execution
+   * @param {?boolean} [doNotDecodeMessage]
+   * @returns {(Promise<Response<ResponseErrorType> | null | SQSBatchResponse>)}
+   */
   async processEvent(
-    execution: EventProcessorExecution,
-    doNotDecodeMessage?: boolean,
+    execution: EventProcessorExecution<ResponseInnerType>,
+    doNotDecodeMessage?: boolean
   ): Promise<Response<ResponseErrorType> | null | SQSBatchResponse> {
     const resp = await this._processRawEvent(execution, !!doNotDecodeMessage)
     if (
@@ -37,13 +97,21 @@ export default class EventProcessor {
       resp instanceof Response &&
       !(resp.getCode() >= 200 && resp.getCode() < 300)
     )
-      throw new Error(JSON.stringify(resp.getBody()))
+      throw new Error(JSON.stringify(resp.getBody() || {}))
     else if (resp) return resp
     return null
   }
+  /**
+   * ${1:Description placeholder}
+   *
+   * @async
+   * @param {EventProcessorExecution<ResponseInnerType>} execution
+   * @param {boolean} doNotDecodeMessage
+   * @returns {(Promise<Response<ResponseErrorType> | null | SQSBatchResponse>)}
+   */
   async _processRawEvent(
-    execution: EventProcessorExecution,
-    doNotDecodeMessage: boolean,
+    execution: EventProcessorExecution<ResponseInnerType>,
+    doNotDecodeMessage: boolean
   ): Promise<Response<ResponseErrorType> | null | SQSBatchResponse> {
     if (this._event.Records && this._event.Records.length > 0) {
       //safe check for empty events?
@@ -54,14 +122,11 @@ export default class EventProcessor {
         {
           ...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
@@ -73,8 +138,8 @@ export default class EventProcessor {
           const resp = await execution(transaction, eventRecord)
           //check for failure
           if (
-            resp instanceof Response &&
-            !(resp.getCode() >= 200 && resp.getCode() < 300)
+            !resp ||
+            (resp instanceof Response && !(resp?.getCode() >= 200 && resp?.getCode() < 300))
           ) {
             //response with failures or fail hard at first
             if (this._allowFailure) failureIDs.push(message.messageId)
@@ -84,14 +149,14 @@ export default class EventProcessor {
         //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,35 +1,93 @@
-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
-export type ProcessConfig = Omit<
-  TransactionConfig,
-  "throwOnErrors" | "syncReturn"
->
+/**
+ * ${1:Description placeholder}
+ *
+ * @export
+ * @typedef {ProcessConfig}
+ */
+export type ProcessConfig = Omit<TransactionConfig, 'throwOnErrors' | 'syncReturn'>
 
+/**
+ * ${1:Description placeholder}
+ *
+ * @export
+ * @class Process
+ * @typedef {Process}
+ */
 export default class Process {
+  /**
+   * ${1:Description placeholder}
+   *
+   * @private
+   * @type {number}
+   */
   private _interval: number
   //
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @readonly
+   * @type {Logger}
+   */
   public readonly logger: Logger
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @readonly
+   * @type {Publisher}
+   */
   public readonly publisher: Publisher
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @type {NodeJS.Timeout}
+   */
+  public interval: NodeJS.Timeout
+  /**
+   * Creates an instance of Process.
+   *
+   * @constructor
+   * @param {ProcessConfig} config
+   * @param {number} interval
+   */
   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)
   }
 
   //Main interface
+  /**
+   * ${1:Description placeholder}
+   *
+   * @async
+   * @param {*} executionFunc
+   * @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
-    setInterval(async () => {
+    this.interval = setInterval(async () => {
       await this._execute(executionFunc)
     }, this._interval)
   }
   //Executions
+  /**
+   * ${1:Description placeholder}
+   *
+   * @async
+   * @param {*} executionFunc
+   * @returns {unknown}
+   */
   async _execute(executionFunc) {
     let executionFailed = true //failled til we say no!
     //safe execution handler
@@ -44,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,46 +80,42 @@ 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?
-      if (executionFailed) {
-        this.response = this.getErrorResponse(
-          Globals.ErrorResponseUnhandledError,
-          Globals.ErrorCode_APIError,
-        )
-        await this.response.build(this.context, this, this.syncReturn)
-      }
+      this.response = this.getErrorResponse(
+        Globals.ErrorResponseUnhandledError,
+        Globals.ErrorCode_APIError
+      )
+      await this.response.build(this.context, this, this.syncReturn)
     }
     return executionFailed
   }
@@ -155,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
@@ -164,21 +147,17 @@ export default class Transaction<
   private async executeLoggerFlush(safeExecution) {
     try {
       await safeExecution()
-      await this.logger.flushLogs()
     } 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)
   }
 }

package/src/Config/Configuration.ts

@@ -1,11 +1,23 @@
-import * as MemCache from "node-cache"
-import * as DurationParser from "parse-duration"
+import * as MemCache from 'node-cache'
+import * as DurationParser from 'parse-duration'
 
-import EnvironmentVar, { EnvironmentType } from "./EnvironmentVar"
+import EnvironmentVar, { EnvironmentType } from './EnvironmentVar'
 
 // Hold cached values at nodeVM level
-const cacheStore = new MemCache()
+// eslint-disable-next-line no-var
+/**
+ * ${1:Description placeholder}
+ *
+ * @type {*}
+ */
+let cacheStore = new MemCache()
 
+/**
+ * ${1:Description placeholder}
+ *
+ * @export
+ * @typedef {ConfigurationSchema}
+ */
 export type ConfigurationSchema = {
   [name: string]: {
     isLocal?: boolean
@@ -16,6 +28,12 @@ export type ConfigurationSchema = {
 }
 
 // runtime type infer to ConfigurationSchema keys, which type is remote
+/**
+ * ${1:Description placeholder}
+ *
+ * @typedef {ExtractRemote}
+ * @template Type
+ */
 type ExtractRemote<Type> = {
   [Property in keyof Type]-?: Type[Property] extends {
     isRemote: true
@@ -24,6 +42,12 @@ type ExtractRemote<Type> = {
     : null
 }
 // runtime type infer to ConfigurationSchema keys, which type is local
+/**
+ * ${1:Description placeholder}
+ *
+ * @typedef {ExtractLocal}
+ * @template Type
+ */
 type ExtractLocal<Type> = {
   [Property in keyof Type]-?: Type[Property] extends {
     isLocal: true
@@ -33,25 +57,75 @@ type ExtractLocal<Type> = {
 }
 
 // Helpers to filter null keys
+/**
+ * ${1:Description placeholder}
+ *
+ * @typedef {OmitKeysByValueType}
+ * @template T
+ * @template U
+ */
 type OmitKeysByValueType<T, U> = {
   [P in keyof T]: T[P] extends U ? never : P
 }[keyof T]
 
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-type OmitByValueType<T, V> = T extends infer _
+/**
+ * ${1:Description placeholder}
+ *
+ * @typedef {OmitByValueType}
+ * @template T
+ * @template V
+ */
+// eslint-disable-next-line @typescript-eslint/no-unused-vars, prettier/prettier
+type OmitByValueType<T, V> = T extends infer _ 
   ? {
       [key in OmitKeysByValueType<T, V>]: T[key]
     }
   : never
 
+/**
+ * ${1:Description placeholder}
+ *
+ * @export
+ * @class Configuration
+ * @typedef {Configuration}
+ * @template {ConfigurationSchema} T
+ */
 export default class Configuration<T extends ConfigurationSchema> {
+  /**
+   * ${1:Description placeholder}
+   *
+   * @private
+   * @readonly
+   * @type {T}
+   */
   private readonly schema: T
+  /**
+   * ${1:Description placeholder}
+   *
+   * @private
+   * @readonly
+   * @type {string}
+   */
   private readonly remotePrefix: string
+  /**
+   * Creates an instance of Configuration.
+   *
+   * @constructor
+   * @param {T} schema
+   * @param {string} remotePrefix
+   */
   constructor(schema: T, remotePrefix: string) {
     this.schema = schema
     this.remotePrefix = remotePrefix
   }
 
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @param {keyof OmitByValueType<ExtractLocal<T>, null>} propName
+   * @returns {*}
+   */
   public get(propName: keyof OmitByValueType<ExtractLocal<T>, null>): any {
     const propString = propName as string
     const propSchema = this.schema[propString]
@@ -61,15 +135,21 @@ export default class Configuration<T extends ConfigurationSchema> {
       new EnvironmentVar<string>(
         propString,
         EnvironmentType.Local,
-        propSchema.required,
-        this.remotePrefix,
+        !propSchema.required,
+        this.remotePrefix
       ).syncResolve()
     this.cacheValue(propString, v, propSchema.cachingPolicy)
     return v
   }
-  public async asyncGet(
-    propName: keyof OmitByValueType<ExtractRemote<T>, null>,
-  ): Promise<any> {
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @async
+   * @param {keyof OmitByValueType<ExtractRemote<T>, null>} propName
+   * @returns {Promise<any>}
+   */
+  public async asyncGet(propName: keyof OmitByValueType<ExtractRemote<T>, null>): Promise<any> {
     const propString = propName as string
     const propSchema = this.schema[propString]
     let v = this.getCachedValue(propString)
@@ -78,21 +158,41 @@ export default class Configuration<T extends ConfigurationSchema> {
       (await new EnvironmentVar<string>(
         propString,
         EnvironmentType.PlainRemote,
-        propSchema.required,
-        this.remotePrefix,
+        !propSchema.required,
+        this.remotePrefix
       ).resolve())
     this.cacheValue(propString, v, propSchema.cachingPolicy)
     return v
   }
   // caching layer
+  /**
+   * ${1:Description placeholder}
+   *
+   * @private
+   * @param {string} valueKey
+   * @returns {*}
+   */
   private getCachedValue(valueKey: string): any {
     return cacheStore.get(valueKey)
   }
-  private cacheValue(
-    valueKey: string,
-    value: any,
-    policy: string = "1d",
-  ): void {
-    cacheStore.set(valueKey, value, DurationParser(policy, "s"))
+  /**
+   * ${1:Description placeholder}
+   *
+   * @private
+   * @param {string} valueKey
+   * @param {*} value
+   * @param {string} [policy="1d"]
+   */
+  private cacheValue(valueKey: string, value: any, policy: string = '1d'): void {
+    cacheStore.set(valueKey, value, DurationParser(policy, 's'))
+  }
+  // unit-test support
+  /**
+   * ${1:Description placeholder}
+   *
+   * @private
+   */
+  private resetCache() {
+    cacheStore = new MemCache()
   }
 }