@creator.co/wapi 1.2.1-beta6 → 1.2.2

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,6 +57,14 @@ 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 {
@@ -28,6 +74,15 @@ export default class Utils {
     }
     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(

package/src/BaseEvent/EventProcessor.ts

@@ -5,29 +5,93 @@ import Response, { ResponseErrorType } from "../API/Response"
 import Globals from "../Globals"
 
 // Handler
-export type EventProcessorExecution = (
-  transaction: Transaction<null, ResponseErrorType, SQSBatchResponse>,
+/**
+ * ${1:Description placeholder}
+ *
+ * @export
+ * @typedef {EventProcessorExecution}
+ * @template ResponseInnerType
+ */
+export type EventProcessorExecution<ResponseInnerType> = (
+  transaction: Transaction<
+    null,
+    ResponseInnerType | ResponseErrorType,
+    SQSBatchResponse
+  >,
   recordContent: string | object,
-) => Promise<Response | SQSBatchResponse>
+) => 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,
+    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,
+    execution: EventProcessorExecution<ResponseInnerType>,
     doNotDecodeMessage?: boolean,
   ): Promise<Response<ResponseErrorType> | null | SQSBatchResponse> {
     const resp = await this._processRawEvent(execution, !!doNotDecodeMessage)
@@ -37,12 +101,20 @@ 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,
+    execution: EventProcessorExecution<ResponseInnerType>,
     doNotDecodeMessage: boolean,
   ): Promise<Response<ResponseErrorType> | null | SQSBatchResponse> {
     if (this._event.Records && this._event.Records.length > 0) {
@@ -73,8 +145,9 @@ 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)

package/src/BaseEvent/Process.ts

@@ -3,16 +3,63 @@ import Logger from "../Logger/Logger"
 import Publisher from "../Publisher/Publisher"
 
 // Config
+/**
+ * ${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")
@@ -20,16 +67,30 @@ export default class Process {
   }
 
   //Main interface
+  /**
+   * ${1:Description placeholder}
+   *
+   * @async
+   * @param {*} executionFunc
+   * @returns {*}
+   */
   async execute(executionFunc) {
     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

package/src/BaseEvent/Transaction.ts

@@ -126,13 +126,11 @@ export default class Transaction<
       //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
   }
@@ -164,7 +162,6 @@ 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.exception(e)

package/src/Config/Configuration.ts

@@ -4,8 +4,20 @@ import * as DurationParser from "parse-duration"
 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,12 +135,20 @@ export default class Configuration<T extends ConfigurationSchema> {
       new EnvironmentVar<string>(
         propString,
         EnvironmentType.Local,
-        propSchema.required,
+        !propSchema.required,
         this.remotePrefix,
       ).syncResolve()
     this.cacheValue(propString, v, propSchema.cachingPolicy)
     return v
   }
+  /**
+   * ${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> {
@@ -78,16 +160,31 @@ export default class Configuration<T extends ConfigurationSchema> {
       (await new EnvironmentVar<string>(
         propString,
         EnvironmentType.PlainRemote,
-        propSchema.required,
+        !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)
   }
+  /**
+   * ${1:Description placeholder}
+   *
+   * @private
+   * @param {string} valueKey
+   * @param {*} value
+   * @param {string} [policy="1d"]
+   */
   private cacheValue(
     valueKey: string,
     value: any,
@@ -95,4 +192,13 @@ export default class Configuration<T extends ConfigurationSchema> {
   ): void {
     cacheStore.set(valueKey, value, DurationParser(policy, "s"))
   }
+  // unit-test support
+  /**
+   * ${1:Description placeholder}
+   *
+   * @private
+   */
+  private resetCache() {
+    cacheStore = new MemCache()
+  }
 }

package/src/Config/EnvironmentVar.ts

@@ -7,19 +7,75 @@ 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,
@@ -32,6 +88,12 @@ 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 {
@@ -40,6 +102,13 @@ export default class EnvironmentVar<T> {
       )
     }
   }
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @async
+   * @returns {unknown}
+   */
   public async resolve() {
     if (this.type == EnvironmentType.Local) return this.getLocalValue()
     else if (this.type == EnvironmentType.SecureRemote)
@@ -47,6 +116,12 @@ export default class EnvironmentVar<T> {
     else return this.getPlainValue()
   }
 
+  /**
+   * ${1:Description placeholder}
+   *
+   * @private
+   * @returns {T}
+   */
   private getLocalValue(): T {
     const value = process.env[this.paramName]
     if (!value && !this.optional) {
@@ -56,6 +131,13 @@ export default class EnvironmentVar<T> {
     }
     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}`
@@ -72,6 +154,13 @@ 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}`