@creator.co/wapi 1.7.8 → 1.7.10-alpha.1

package/src/BaseEvent/DynamoTransaction.ts

@@ -0,0 +1,175 @@
+import type {
+  Context,
+  DynamoDBBatchResponse,
+  DynamoDBRecord,
+  DynamoDBStreamEvent,
+} from 'aws-lambda'
+
+import Transaction, { TransactionConfig } from './Transaction.js'
+import Response, { ResponseErrorType } from '../API/Response.js'
+import Globals from '../Globals.js'
+import Utils from '../Util/Utils.js'
+
+/**
+ * Interface representing a DynamoDB record with marshalled data.
+ * Extends the DynamoDBRecord interface.
+ * @property {object} Keys - The keys of the record.
+ * @property {object} OldImage - The old image of the record.
+ * @property {object} NewImage - The new image of the record.
+ */
+export interface DynamoDBMarshalledRecord extends DynamoDBRecord {
+  marshalled: {
+    Keys?: object
+    OldImage?: object
+    NewImage?: object
+  }
+}
+
+/**
+ * Defines a type for executing a transaction on DynamoDB.
+ * @param {Transaction<null, ResponseInnerType | ResponseErrorType, DynamoDBBatchResponse | null>} transaction - The transaction to execute.
+ * @param {DynamoDBMarshalledRecord} recordContent - The content of the DynamoDB record.
+ * @returns A promise that resolves to a response or a DynamoDB batch response.
+ */
+export type DynamoTransactionExecution<ResponseInnerType> = (
+  transaction: Transaction<
+    null,
+    ResponseInnerType | ResponseErrorType,
+    DynamoDBBatchResponse | null
+  >,
+  recordContent: DynamoDBMarshalledRecord
+) => Promise<Response<ResponseInnerType | ResponseErrorType> | DynamoDBBatchResponse | null>
+
+/**
+ * Represents a DynamoDB transaction handler that processes events from a DynamoDB stream.
+ * @template ResponseInnerType - The inner type of the response.
+ */
+export default class DynamoTransaction<ResponseInnerType> {
+  /**
+   * A boolean flag indicating whether failures are allowed.
+   */
+  private readonly allowFailure: boolean
+
+  /**
+   * Readonly property that holds the transaction configuration.
+   */
+  private readonly config: TransactionConfig
+
+  /**
+   * The context object that provides information about the current execution context.
+   * @type {Context}
+   */
+  private readonly context: Context
+
+  /**
+   * Represents an event from a DynamoDB stream.
+   * @type {DynamoDBStreamEvent}
+   */
+  private readonly event: DynamoDBStreamEvent
+
+  /**
+   * Constructor for a TransactionHandler object.
+   * @param {DynamoDBStreamEvent} event - The DynamoDB stream event that triggered the transaction.
+   * @param {Context} context - The AWS Lambda context object.
+   * @param {TransactionConfig} [config] - Optional configuration for the transaction.
+   * @param {boolean} [allowFailure] - Flag to indicate whether to allow transaction failure.
+   * @returns None
+   */
+  constructor(
+    event: DynamoDBStreamEvent,
+    context: Context,
+    config?: TransactionConfig,
+    allowFailure?: boolean
+  ) {
+    this.event = event
+    this.context = context
+    this.config = config || {}
+    this.allowFailure = !!allowFailure
+  }
+
+  /**
+   * Processes the event execution and returns a response based on the outcome.
+   * @param {DynamoTransactionExecution<ResponseInnerType>} execution - The execution object to process.
+   * @returns {Promise<Response<ResponseErrorType | null> | null | DynamoDBBatchResponse>} A promise that resolves to a response object or null.
+   * @throws {Error} If the response code is not within the success range and failure is not allowed.
+   */
+  public async processEvent(
+    execution: DynamoTransactionExecution<ResponseInnerType>
+  ): Promise<Response<ResponseErrorType | null> | null | DynamoDBBatchResponse> {
+    const resp = await this.processRawEvent(execution)
+    if (
+      !this.allowFailure &&
+      resp &&
+      resp instanceof Response &&
+      !(resp.getCode() >= 200 && resp.getCode() < 300)
+    )
+      throw new Error(JSON.stringify(resp.getBody() || {}))
+    else if (resp) return resp
+    return null
+  }
+
+  /**
+   * Processes a raw event by executing a transaction on each record in the event.
+   * @param {DynamoTransactionExecution<ResponseInnerType>} execution - The transaction execution function.
+   * @returns {Promise<Response<ResponseErrorType | any> | null | DynamoDBBatchResponse>} A promise that resolves to a response object, null, or a DynamoDB batch response.
+   */
+  private async processRawEvent(
+    execution: DynamoTransactionExecution<ResponseInnerType>
+  ): Promise<Response<ResponseErrorType | any> | null | DynamoDBBatchResponse> {
+    // safe check for empty events?
+    if (this.event.Records && this.event.Records.length > 0) {
+      // Regular cleanup of tmp disk to avoid tmp overflow on reused lambdas
+      if (!this.config?.skipCleanTmp) await Utils.cleanTemporaryFolder()
+      // init transaction for all records
+      return await new Transaction<null, any, DynamoDBBatchResponse | null>(
+        this.event,
+        this.context,
+        {
+          ...this.config,
+          syncReturn: true,
+        }
+      ).execute(async transaction => {
+        // for each available event
+        const failureIDs: Array<string> = []
+        for (const eventRecordIdx in this.event.Records) {
+          const eventRecord = this.event.Records[eventRecordIdx]
+          const record = {
+            ...eventRecord,
+            marshalled: {
+              ...(eventRecord.dynamodb?.Keys
+                ? { Keys: Utils.ddbUnmarshall(eventRecord.dynamodb?.Keys) }
+                : {}),
+              ...(eventRecord.dynamodb?.OldImage
+                ? { OldImage: Utils.ddbUnmarshall(eventRecord.dynamodb?.OldImage) }
+                : {}),
+              ...(eventRecord.dynamodb?.NewImage
+                ? { NewImage: Utils.ddbUnmarshall(eventRecord.dynamodb?.NewImage) }
+                : {}),
+            },
+          }
+          // Call execution with marshalled item
+          const resp = await execution(transaction, record)
+          // check for failure
+          if (
+            !resp ||
+            (resp instanceof Response && !(resp?.getCode() >= 200 && resp?.getCode() < 300))
+          ) {
+            // response with failures or fail hard at first
+            if (this.allowFailure) failureIDs.push(eventRecord.eventID!)
+            else return resp
+          }
+        }
+        // not errored and loop ended - succeeded (might have failures)
+        if (this.allowFailure)
+          return {
+            batchItemFailures: failureIDs.map(id => ({ itemIdentifier: id })),
+          }
+        return Response.SuccessResponse(null)
+      })
+    } else
+      return Response.BadRequestResponse(
+        Globals.ErrorResponseNoRecords,
+        Globals.ErrorCode_NoRecords
+      )
+  }
+}

package/src/BaseEvent/EventProcessor.ts

@@ -67,7 +67,7 @@ export default class EventProcessor<ResponseInnerType> {
    * @returns {Promise<Response<ResponseErrorType> | null | SQSBatchResponse>} - A promise that resolves to the response object, or null if no response is available.
    * @throws {Error} - Throws an error if the response code is not within the range of 200 to 299 and failure is not allowed.
    */
-  async processEvent(
+  public async processEvent(
     execution: EventProcessorExecution<ResponseInnerType>,
     doNotDecodeMessage?: boolean
   ): Promise<Response<ResponseErrorType | null> | null | SQSBatchResponse> {

package/src/BaseEvent/Transaction.ts

@@ -1,4 +1,4 @@
-import type { APIGatewayEvent, Context, SQSEvent } from 'aws-lambda'
+import type { APIGatewayEvent, Context, DynamoDBStreamEvent, SQSEvent } from 'aws-lambda'
 
 import Request from '../API/Request.js'
 import Response, { ResponseErrorType } from '../API/Response.js'
@@ -116,12 +116,16 @@ export default class Transaction<
 
   /**
    * Constructs a new instance of the Transaction class.
-   * @param {APIGatewayEvent | SQSEvent} event - The event object passed to the Lambda function.
+   * @param {APIGatewayEvent | SQSEvent | DynamoDBStreamEvent} event - The event object passed to the Lambda function.
    * @param {Context} context - The context object passed to the Lambda function.
    * @param {TransactionConfig} [config] - Optional configuration object for the transaction.
    * @returns None
    */
-  constructor(event: APIGatewayEvent | SQSEvent, context: Context, config?: TransactionConfig) {
+  constructor(
+    event: APIGatewayEvent | SQSEvent | DynamoDBStreamEvent,
+    context: Context,
+    config?: TransactionConfig
+  ) {
     const transactionId = context.awsRequestId
       ? context.awsRequestId
       : (<APIGatewayEvent>event).requestContext
@@ -244,6 +248,14 @@ export default class Transaction<
     return this.databaseManager.create<S, DBSchema>(config)
   }
 
+  /**
+   * Get the remaining time in milliseconds for the current execution context.
+   * @returns {number} The remaining time in milliseconds, or -1 if the time is not available.
+   */
+  public getRemainingTimeInMillis() {
+    return this.context?.getRemainingTimeInMillis?.() || -1
+  }
+
   /*
    * Executes a series of database transactions in a safe manner.
    * @param {Function} safeExecution - The function that contains the database transactions to be executed.

package/src/Cache/Redis.ts

@@ -35,6 +35,7 @@ export default class Redis {
     if (config.clusterMode) return Redis.redisClusterConnection(config)
     else return Redis.redisClientConnection(config)
   }
+
   /**
    * Establishes a connection to a Redis client based on the provided configuration
    * and holds it for reusability. If connection is detected closed, new connection is

package/src/Database/integrations/dynamo/DynamoDatabase.ts

@@ -10,7 +10,7 @@ export class DynamoDatabase extends Database<any> {
   private static dynamoProvider = DynamoDBClient
   public readonly client: DynamoDBClient
 
-  public constructor(config: DbConfig<'dynamo'>) {
+  constructor(config: DbConfig<'dynamo'>) {
     super(config)
     this.client = this.providerFactory(config)
   }

package/src/Database/integrations/knex/KnexDatabase.ts

@@ -26,7 +26,7 @@ export class KnexDatabase extends Database<KnexTransaction> {
    * @param {DbConfig<'knex'>} config - The configuration object for the Knex database.
    * @returns None
    */
-  public constructor(config: DbConfig<'knex'>) {
+  constructor(config: DbConfig<'knex'>) {
     super(config)
 
     this.client = KnexDatabase.knexProvider(this.constructConfig(config))

package/src/Database/integrations/kysely/KyselyDatabase.ts

@@ -49,7 +49,7 @@ export class KyselyDatabase<DBSchema = never> extends Database<KyselyTransaction
    * @param {DbConfig<'kysely'>} config - The configuration object for the database connection.
    * @returns None
    */
-  public constructor(config: DbConfig<'kysely'>) {
+  constructor(config: DbConfig<'kysely'>) {
     super(config)
     this.pgClient = this.dialectFactory(config)
     this.client = this.providerFactory(this.pgClient)
@@ -66,6 +66,7 @@ export class KyselyDatabase<DBSchema = never> extends Database<KyselyTransaction
   public override async transaction(): Promise<KyselyTransaction<DBSchema>> {
     return KyselyTransactionImpl.newTransaction<DBSchema>(this.client, this, this.readClient)
   }
+
   /**
    * Creates a database dialect based on the provided configuration.
    * @param {DbBaseConfig} config - The configuration object for the database connection.
@@ -83,6 +84,7 @@ export class KyselyDatabase<DBSchema = never> extends Database<KyselyTransaction
       }),
     })
   }
+
   /**
    * Creates a provider for interacting with a database using the specified Postgres dialect.
    * @param {PostgresDialect} dialect - The Postgres dialect to use for the database connection.

package/src/Database/integrations/pgsql/PostgresDatabase.ts

@@ -29,7 +29,7 @@ export class PostgresDatabase extends Database<PostgresTransaction> {
    * @param {DbConfig<'pg'>} config - The configuration object for the Postgres database.
    * @returns None
    */
-  public constructor(config: DbConfig<'pg'>) {
+  constructor(config: DbConfig<'pg'>) {
     super(config)
     this.client = this.providerFactory(config)
     if (config.readReplica) this.readClient = this.providerFactory(config.readReplica)
@@ -42,6 +42,7 @@ export class PostgresDatabase extends Database<PostgresTransaction> {
   public override async transaction(): Promise<PostgresTransaction> {
     return PostgresTransactionImpl.newTransaction(this.client, this, this.readClient)
   }
+
   private providerFactory(config: DbBaseConfig) {
     return new PostgresDatabase.pgProvider({
       host: config.host,

package/src/Logger/Logger.ts

@@ -128,7 +128,7 @@ export default class Logger {
    * @param {...any} args - The arguments to be logged.
    * @returns None
    */
-  debug(...args) {
+  public debug(...args) {
     this.processLog(LOG_LEVELS.DEBUG, args)
   }
 
@@ -137,7 +137,7 @@ export default class Logger {
    * @param {...any} args - The arguments to be logged.
    * @returns None
    */
-  log(...args) {
+  public log(...args) {
     this.processLog(LOG_LEVELS.INFO, args)
   }
 
@@ -146,7 +146,7 @@ export default class Logger {
    * @param {...any} args - The message(s) to log.
    * @returns None
    */
-  info(...args) {
+  public info(...args) {
     this.processLog(LOG_LEVELS.INFO, args)
   }
 
@@ -155,7 +155,7 @@ export default class Logger {
    * @param {...any} args - The arguments to be logged as a warning message.
    * @returns None
    */
-  warning(...args) {
+  public warning(...args) {
     this.processLog(LOG_LEVELS.WARN, args)
   }
 
@@ -164,7 +164,7 @@ export default class Logger {
    * @param {...any} args - The arguments to be logged.
    * @returns None
    */
-  warn(...args) {
+  public warn(...args) {
     this.processLog(LOG_LEVELS.WARN, args)
   }
 
@@ -173,7 +173,7 @@ export default class Logger {
    * @param {...any} args - The arguments to log as an error message.
    * @returns None
    */
-  error(...args) {
+  public error(...args) {
     this.processLog(LOG_LEVELS.ERROR, args)
   }
 
@@ -183,7 +183,7 @@ export default class Logger {
    * @param {...any} args - Additional arguments to include in the log.
    * @returns None
    */
-  exception(exception, ...args) {
+  public exception(exception, ...args) {
     this.iexception(exception, args)
   }
 

package/src/Publisher/Publisher.ts

@@ -58,7 +58,7 @@ export default class Publisher {
    * @param {object} [additionalProps] - Additional properties to include in the publish command.
    * @returns {Promise<PublishCommandOutput>} - A promise that resolves to the response from the publish command.
    */
-  async publishOnTopic(
+  public async publishOnTopic(
     messageObject: any,
     topic: string,
     additionalProps?: object
@@ -86,7 +86,10 @@ export default class Publisher {
    * @param {string} phone - The phone number to publish the message to.
    * @returns {Promise<PublishCommandOutput>} - A promise that resolves to the response from the publish command.
    */
-  async publishSMS(message: string, phone: string): Promise<PublishCommandOutput | undefined> {
+  public async publishSMS(
+    message: string,
+    phone: string
+  ): Promise<PublishCommandOutput | undefined> {
     let resp: undefined | PublishCommandOutput = undefined
     try {
       this.connect()

package/src/Server/RouteResolver.ts

@@ -88,7 +88,7 @@ export default class RouteResolver {
    * @param {RouterConfig} config - The configuration object for the router.
    * @returns None
    */
-  constructor(readonly config: RouterConfig) {
+  constructor(config: RouterConfig) {
     this.routes = {}
     this.buildRoutes(config)
   }

package/src/Server/lib/container/Proxy.ts

@@ -91,7 +91,7 @@ export default class Proxy {
    * Loads the necessary components and initializes the application.
    * @returns None
    */
-  async load() {
+  public async load() {
     await this.startListeners()
     this.installRoutes()
   }
@@ -101,7 +101,7 @@ export default class Proxy {
    * @param {any} [err] - Optional error object to pass to the stopListeners method.
    * @returns {Promise<void>} - A promise that resolves once the listeners have been stopped.
    */
-  async unload(err?: any) {
+  public async unload(err?: any) {
     await this.stopListeners(err)
   }
 

package/src/Util/AsyncSingleton.ts

@@ -17,7 +17,7 @@ export default class AsyncSingleton<T, R> {
    * @param factory The factory function that creates the instance.
    * @param checker The function that checks if the instance is valid.
    */
-  public constructor(
+  constructor(
     factory: (r: R) => Promise<T>,
     checker: (value: T) => Promise<boolean> = async () => true
   ) {

package/src/Util/Utils.ts

@@ -1,5 +1,7 @@
 import child_process from 'child_process'
 
+import { convertToAttr, marshall, unmarshall } from '@aws-sdk/util-dynamodb'
+
 /**
  * Utility class containing various static methods for common operations.
  */
@@ -91,4 +93,40 @@ export default class Utils {
       }
     })
   }
+
+  /**
+   * Marshalls the given item into a DynamoDB format.
+   * If the item is an array, it maps over each element and marshalls it recursively.
+   * If the item is an object, it marshalls the object using the marshall function with options to remove undefined values and convert class instances to maps.
+   * If the item is neither an array nor an object, it converts the item to an attribute.
+   * @param {any} item - The item to be marshalled.
+   * @returns The marshalled item in DynamoDB format.
+   */
+  public static ddbMarshall<T>(item: T, rec?: boolean) {
+    if (Array.isArray(item)) return { L: item.map(_i => this.ddbMarshall(_i, true)) }
+    else if (typeof item === 'object' && isNaN(parseInt(item as any))) {
+      const marshalled = marshall(item, {
+        removeUndefinedValues: true,
+        convertClassInstanceToMap: true,
+      })
+      if (rec) return { M: marshalled }
+      else return marshalled
+    } else
+      return convertToAttr(item, { removeUndefinedValues: true, convertClassInstanceToMap: true })
+  }
+
+  /**
+   * Recursively unmarshalls a DynamoDB item by converting it into a plain JavaScript object.
+   * @param {any} item - The DynamoDB item to unmarshall.
+   * @returns {any} The unmarshalled JavaScript object.
+   */
+  public static ddbUnmarshall(item) {
+    if (!item && item !== false) return null
+    if (Array.isArray(item)) {
+      return item.map(_item => this.ddbUnmarshall(_item))
+    } else if (typeof item === 'object') {
+      return unmarshall(item)
+    }
+    return item
+  }
 }