@creator.co/wapi 1.2.4 → 1.2.6

package/dist/src/BaseEvent/EventProcessor.d.ts

@@ -2,80 +2,57 @@ import type { Context, SQSBatchResponse, SQSEvent } from 'aws-lambda';
 import Transaction, { TransactionConfig } from './Transaction';
 import Response, { ResponseErrorType } from '../API/Response';
 /**
- * ${1:Description placeholder}
- *
- * @export
- * @typedef {EventProcessorExecution}
- * @template ResponseInnerType
+ * Type definition for an event processor execution function.
+ * @param {Transaction<null, ResponseInnerType | ResponseErrorType, SQSBatchResponse>} transaction - The transaction object.
+ * @param {string | object} recordContent - The content of the record being processed.
+ * @returns {Promise<Response<ResponseInnerType | ResponseErrorType> | SQSBatchResponse>} - A promise that resolves to the response or batch response.
  */
-export type EventProcessorExecution<ResponseInnerType> = (transaction: Transaction<null, ResponseInnerType | ResponseErrorType, SQSBatchResponse>, recordContent: string | object) => Promise<Response<ResponseInnerType | ResponseErrorType> | SQSBatchResponse>;
+export type EventProcessorExecution<ResponseInnerType> = (transaction: Transaction<null, ResponseInnerType | ResponseErrorType, SQSBatchResponse | null>, recordContent: string | object) => Promise<Response<ResponseInnerType | ResponseErrorType> | SQSBatchResponse | null>;
 /**
- * ${1:Description placeholder}
- *
- * @export
- * @class EventProcessor
- * @typedef {EventProcessor}
- * @template ResponseInnerType
+ * EventProcessor class that processes events from an SQS queue.
+ * @template ResponseInnerType - The type of the inner response object.
  */
 export default class EventProcessor<ResponseInnerType> {
     /**
-     * ${1:Description placeholder}
-     *
-     * @private
+     * A boolean flag indicating whether failures are allowed or not.
      * @readonly
-     * @type {boolean}
      */
-    private readonly _allowFailure;
+    private readonly allowFailure;
     /**
-     * ${1:Description placeholder}
-     *
-     * @private
-     * @readonly
-     * @type {TransactionConfig}
+     * The configuration object for the API transaction.
      */
-    private readonly _apiConfig;
+    private readonly config;
     /**
-     * ${1:Description placeholder}
-     *
-     * @private
-     * @readonly
+     * The private readonly context property of the class.
      * @type {Context}
      */
-    private readonly _context;
+    private readonly context;
     /**
-     * ${1:Description placeholder}
-     *
-     * @private
-     * @readonly
-     * @type {SQSEvent}
+     * The SQS event object that triggered the Lambda function.
      */
-    private readonly _event;
+    private readonly event;
     /**
-     * Creates an instance of EventProcessor.
-     *
-     * @constructor
-     * @param {SQSEvent} event
-     * @param {Context} context
-     * @param {?TransactionConfig} [config]
-     * @param {?boolean} [allowFailure]
+     * Constructs a new instance of the class.
+     * @param {SQSEvent} event - The event object representing the incoming SQS message.
+     * @param {Context} context - The context object representing the AWS Lambda execution context.
+     * @param {TransactionConfig} [config] - Optional configuration object for the transaction.
+     * @param {boolean} [allowFailure] - Optional flag indicating whether to allow failure for the transaction.
+     * @returns None
      */
     constructor(event: SQSEvent, context: Context, config?: TransactionConfig, allowFailure?: boolean);
     /**
-     * ${1:Description placeholder}
-     *
-     * @async
-     * @param {EventProcessorExecution<ResponseInnerType>} execution
-     * @param {?boolean} [doNotDecodeMessage]
-     * @returns {(Promise<Response<ResponseErrorType> | null | SQSBatchResponse>)}
+     * Processes an event using the provided execution object and returns a response.
+     * @param {EventProcessorExecution<ResponseInnerType>} execution - The execution object containing the event to process.
+     * @param {boolean} [doNotDecodeMessage] - Optional flag indicating whether to decode the message.
+     * @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.
      */
-    processEvent(execution: EventProcessorExecution<ResponseInnerType>, doNotDecodeMessage?: boolean): Promise<Response<ResponseErrorType> | null | SQSBatchResponse>;
+    processEvent(execution: EventProcessorExecution<ResponseInnerType>, doNotDecodeMessage?: boolean): Promise<Response<ResponseErrorType | null> | null | SQSBatchResponse>;
     /**
-     * ${1:Description placeholder}
-     *
-     * @async
-     * @param {EventProcessorExecution<ResponseInnerType>} execution
-     * @param {boolean} doNotDecodeMessage
-     * @returns {(Promise<Response<ResponseErrorType> | null | SQSBatchResponse>)}
+     * Processes a raw event by executing the provided execution function and handling any errors or failures.
+     * @param {EventProcessorExecution<ResponseInnerType>} execution - The execution function to process the event.
+     * @param {boolean} doNotDecodeMessage - Flag indicating whether to decode the message or not.
+     * @returns {Promise<Response<ResponseErrorType> | null | SQSBatchResponse>} - A promise that resolves to a response object, null, or a SQS batch response.
      */
-    _processRawEvent(execution: EventProcessorExecution<ResponseInnerType>, doNotDecodeMessage: boolean): Promise<Response<ResponseErrorType> | null | SQSBatchResponse>;
+    private processRawEvent;
 }

package/dist/src/BaseEvent/EventProcessor.js

@@ -51,46 +51,40 @@ var Transaction_1 = require("./Transaction");
 var Response_1 = require("../API/Response");
 var Globals_1 = require("../Globals");
 /**
- * ${1:Description placeholder}
- *
- * @export
- * @class EventProcessor
- * @typedef {EventProcessor}
- * @template ResponseInnerType
+ * EventProcessor class that processes events from an SQS queue.
+ * @template ResponseInnerType - The type of the inner response object.
  */
 var EventProcessor = /** @class */ (function () {
     /**
-     * Creates an instance of EventProcessor.
-     *
-     * @constructor
-     * @param {SQSEvent} event
-     * @param {Context} context
-     * @param {?TransactionConfig} [config]
-     * @param {?boolean} [allowFailure]
+     * Constructs a new instance of the class.
+     * @param {SQSEvent} event - The event object representing the incoming SQS message.
+     * @param {Context} context - The context object representing the AWS Lambda execution context.
+     * @param {TransactionConfig} [config] - Optional configuration object for the transaction.
+     * @param {boolean} [allowFailure] - Optional flag indicating whether to allow failure for the transaction.
+     * @returns None
      */
     function EventProcessor(event, context, config, allowFailure) {
-        this._event = event;
-        this._context = context;
-        this._apiConfig = config || {};
-        this._allowFailure = allowFailure;
+        this.event = event;
+        this.context = context;
+        this.config = config || {};
+        this.allowFailure = !!allowFailure;
     }
     /**
-     * ${1:Description placeholder}
-     *
-     * @async
-     * @param {EventProcessorExecution<ResponseInnerType>} execution
-     * @param {?boolean} [doNotDecodeMessage]
-     * @returns {(Promise<Response<ResponseErrorType> | null | SQSBatchResponse>)}
+     * Processes an event using the provided execution object and returns a response.
+     * @param {EventProcessorExecution<ResponseInnerType>} execution - The execution object containing the event to process.
+     * @param {boolean} [doNotDecodeMessage] - Optional flag indicating whether to decode the message.
+     * @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.
      */
     EventProcessor.prototype.processEvent = function (execution, doNotDecodeMessage) {
         return __awaiter(this, void 0, void 0, function () {
             var resp;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, this._processRawEvent(execution, !!doNotDecodeMessage)];
+                    case 0: return [4 /*yield*/, this.processRawEvent(execution, !!doNotDecodeMessage)];
                     case 1:
                         resp = _a.sent();
-                        if (!this._allowFailure &&
+                        if (!this.allowFailure &&
                             resp &&
                             resp instanceof Response_1.default &&
                             !(resp.getCode() >= 200 && resp.getCode() < 300))
@@ -103,26 +97,24 @@ var EventProcessor = /** @class */ (function () {
         });
     };
     /**
-     * ${1:Description placeholder}
-     *
-     * @async
-     * @param {EventProcessorExecution<ResponseInnerType>} execution
-     * @param {boolean} doNotDecodeMessage
-     * @returns {(Promise<Response<ResponseErrorType> | null | SQSBatchResponse>)}
+     * Processes a raw event by executing the provided execution function and handling any errors or failures.
+     * @param {EventProcessorExecution<ResponseInnerType>} execution - The execution function to process the event.
+     * @param {boolean} doNotDecodeMessage - Flag indicating whether to decode the message or not.
+     * @returns {Promise<Response<ResponseErrorType> | null | SQSBatchResponse>} - A promise that resolves to a response object, null, or a SQS batch response.
      */
-    EventProcessor.prototype._processRawEvent = function (execution, doNotDecodeMessage) {
+    EventProcessor.prototype.processRawEvent = function (execution, doNotDecodeMessage) {
         return __awaiter(this, void 0, void 0, function () {
             var _this = this;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        if (!(this._event.Records && this._event.Records.length > 0)) return [3 /*break*/, 2];
-                        return [4 /*yield*/, new Transaction_1.default(this._event, this._context, __assign(__assign({}, this._apiConfig), { syncReturn: true })).execute(function (transaction) { return __awaiter(_this, void 0, void 0, function () {
+                        if (!(this.event.Records && this.event.Records.length > 0)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, new Transaction_1.default(this.event, this.context, __assign(__assign({}, this.config), { syncReturn: true })).execute(function (transaction) { return __awaiter(_this, void 0, void 0, function () {
                                 var decodedRecords, failureIDs, _a, _b, _c, _i, eventRecordIdx, eventRecord, message, resp;
                                 return __generator(this, function (_d) {
                                     switch (_d.label) {
                                         case 0:
-                                            decodedRecords = this._event.Records.map(function (eventRecord) {
+                                            decodedRecords = this.event.Records.map(function (eventRecord) {
                                                 return doNotDecodeMessage ? eventRecord.body : JSON.parse(eventRecord.body);
                                             });
                                             failureIDs = [];
@@ -138,7 +130,7 @@ var EventProcessor = /** @class */ (function () {
                                             if (!(_c in _a)) return [3 /*break*/, 3];
                                             eventRecordIdx = _c;
                                             eventRecord = decodedRecords[eventRecordIdx];
-                                            message = this._event.Records[eventRecordIdx];
+                                            message = this.event.Records[eventRecordIdx];
                                             return [4 /*yield*/, execution(transaction, eventRecord)
                                                 //check for failure
                                             ];
@@ -148,7 +140,7 @@ var EventProcessor = /** @class */ (function () {
                                             if (!resp ||
                                                 (resp instanceof Response_1.default && !((resp === null || resp === void 0 ? void 0 : resp.getCode()) >= 200 && (resp === null || resp === void 0 ? void 0 : resp.getCode()) < 300))) {
                                                 //response with failures or fail hard at first
-                                                if (this._allowFailure)
+                                                if (this.allowFailure)
                                                     failureIDs.push(message.messageId);
                                                 else
                                                     return [2 /*return*/, resp];
@@ -159,7 +151,7 @@ var EventProcessor = /** @class */ (function () {
                                             return [3 /*break*/, 1];
                                         case 4:
                                             //not errored and loop ended - succeeded (might have failures)
-                                            if (this._allowFailure)
+                                            if (this.allowFailure)
                                                 return [2 /*return*/, {
                                                         batchItemFailures: failureIDs.map(function (id) { return ({ itemIdentifier: id }); }),
                                                     }];

package/dist/src/BaseEvent/EventProcessor.js.map

@@ -1 +1 @@
-{"version":3,"file":"EventProcessor.js","sourceRoot":"","sources":["../../../src/BaseEvent/EventProcessor.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"EventProcessor.js","sourceRoot":"","sources":["../../../src/BaseEvent/EventProcessor.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEA,6CAA8D;AAC9D,4CAA6D;AAC7D,sCAAgC;AAahC;;;GAGG;AACH;IAoBE;;;;;;;OAOG;IACH,wBACE,KAAe,EACf,OAAgB,EAChB,MAA0B,EAC1B,YAAsB;QAEtB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAA;QAClB,IAAI,CAAC,OAAO,GAAG,OAAO,CAAA;QACtB,IAAI,CAAC,MAAM,GAAG,MAAM,IAAI,EAAE,CAAA;QAC1B,IAAI,CAAC,YAAY,GAAG,CAAC,CAAC,YAAY,CAAA;IACpC,CAAC;IAED;;;;;;OAMG;IACG,qCAAY,GAAlB,UACE,SAAqD,EACrD,kBAA4B;;;;;4BAEf,qBAAM,IAAI,CAAC,eAAe,CAAC,SAAS,EAAE,CAAC,CAAC,kBAAkB,CAAC,EAAA;;wBAAlE,IAAI,GAAG,SAA2D;wBACxE,IACE,CAAC,IAAI,CAAC,YAAY;4BAClB,IAAI;4BACJ,IAAI,YAAY,kBAAQ;4BACxB,CAAC,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,GAAG,IAAI,IAAI,CAAC,OAAO,EAAE,GAAG,GAAG,CAAC;4BAEhD,MAAM,IAAI,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC,CAAA;6BAClD,IAAI,IAAI;4BAAE,sBAAO,IAAI,EAAA;wBAC1B,sBAAO,IAAI,EAAA;;;;KACZ;IAED;;;;;OAKG;IACW,wCAAe,GAA7B,UACE,SAAqD,EACrD,kBAA2B;;;;;;6BAEvB,CAAA,IAAI,CAAC,KAAK,CAAC,OAAO,IAAI,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,CAAA,EAAnD,wBAAmD;wBAG9C,qBAAM,IAAI,qBAAW,CAAqC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,OAAO,wBACpF,IAAI,CAAC,MAAM,KACd,UAAU,EAAE,IAAI,IAChB,CAAC,OAAO,CAAC,UAAM,WAAW;;;;;4CAEpB,cAAc,GAAwB,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,UAAA,WAAW;gDAC5E,OAAA,kBAAkB,CAAC,CAAC,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,IAAI,CAAC;4CAApE,CAAoE,CACrE,CAAA;4CAGK,UAAU,GAAkB,EAAE,CAAA;iDACP,cAAc;;;;;;;;;;;4CACnC,WAAW,GAAG,cAAc,CAAC,cAAc,CAAC,CAAA;4CAC5C,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,cAAc,CAAC,CAAA;4CAErC,qBAAM,SAAS,CAAC,WAAW,EAAE,WAAW,CAAC;gDACtD,mBAAmB;8CADmC;;4CAAhD,IAAI,GAAG,SAAyC;4CACtD,mBAAmB;4CACnB,IACE,CAAC,IAAI;gDACL,CAAC,IAAI,YAAY,kBAAQ,IAAI,CAAC,CAAC,CAAA,IAAI,aAAJ,IAAI,uBAAJ,IAAI,CAAE,OAAO,EAAE,KAAI,GAAG,IAAI,CAAA,IAAI,aAAJ,IAAI,uBAAJ,IAAI,CAAE,OAAO,EAAE,IAAG,GAAG,CAAC,CAAC,EAChF;gDACA,8CAA8C;gDAC9C,IAAI,IAAI,CAAC,YAAY;oDAAE,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,CAAA;;oDACpD,sBAAO,IAAI,EAAA;6CACjB;;;;;;4CAEH,8DAA8D;4CAC9D,IAAI,IAAI,CAAC,YAAY;gDACnB,sBAAO;wDACL,iBAAiB,EAAE,UAAU,CAAC,GAAG,CAAC,UAAA,EAAE,IAAI,OAAA,CAAC,EAAE,cAAc,EAAE,EAAE,EAAE,CAAC,EAAxB,CAAwB,CAAC;qDAClE,EAAA;4CACH,sBAAO,kBAAQ,CAAC,eAAe,CAAC,IAAI,CAAC,EAAA;;;iCACtC,CAAC,EAAA;;oBAlCF,8BAA8B;oBAC9B,kCAAkC;oBAClC,sBAAO,SAgCL,EAAA;4BAEF,sBAAO,kBAAQ,CAAC,kBAAkB,CAChC,iBAAO,CAAC,sBAAsB,EAC9B,iBAAO,CAAC,mBAAmB,CAC5B,EAAA,CAAC,2BAA2B;;;;KAChC;IACH,qBAAC;AAAD,CAAC,AAnHD,IAmHC"}

package/dist/src/BaseEvent/Process.d.ts

@@ -3,72 +3,49 @@ import { TransactionConfig } from './Transaction';
 import Logger from '../Logger/Logger';
 import Publisher from '../Publisher/Publisher';
 /**
- * ${1:Description placeholder}
- *
- * @export
- * @typedef {ProcessConfig}
+ * A type that represents a modified version of the TransactionConfig type, excluding the 'throwOnErrors' and 'syncReturn' properties.
  */
 export type ProcessConfig = Omit<TransactionConfig, 'throwOnErrors' | 'syncReturn'>;
 /**
- * ${1:Description placeholder}
- *
- * @export
- * @class Process
- * @typedef {Process}
+ * Represents a long-running process that executes a given function at a specified interval.
  */
 export default class Process {
     /**
-     * ${1:Description placeholder}
-     *
-     * @private
+     * Private member variable representing the interval value.
      * @type {number}
+     * @private
      */
-    private _interval;
+    private interval;
     /**
-     * ${1:Description placeholder}
-     *
-     * @public
+     * A logger object used for logging messages, errors, and other information.
      * @readonly
-     * @type {Logger}
      */
     readonly logger: Logger;
     /**
-     * ${1:Description placeholder}
-     *
-     * @public
-     * @readonly
-     * @type {Publisher}
+     * The publisher of the content.
      */
     readonly publisher: Publisher;
     /**
-     * ${1:Description placeholder}
-     *
-     * @public
-     * @type {NodeJS.Timeout}
+     * A reference to the NodeJS.Timeout object representing the interval timer.
      */
-    interval: NodeJS.Timeout;
+    timeout: NodeJS.Timeout;
     /**
-     * Creates an instance of Process.
-     *
-     * @constructor
-     * @param {ProcessConfig} config
-     * @param {number} interval
+     * Constructs a new instance of the LongRunningProcess class.
+     * @param {ProcessConfig} config - The configuration object for the process.
+     * @param {number} interval - The interval at which the process should run.
+     * @returns None
      */
     constructor(config: ProcessConfig, interval: number);
     /**
-     * ${1:Description placeholder}
-     *
-     * @async
-     * @param {*} executionFunc
-     * @returns {*}
+     * Executes the provided execution function at a specified interval.
+     * @param {Function} executionFunc - The function to execute.
+     * @returns None
      */
     execute(executionFunc: any): Promise<void>;
     /**
-     * ${1:Description placeholder}
-     *
-     * @async
-     * @param {*} executionFunc
-     * @returns {unknown}
+     * Executes the given execution function asynchronously and handles any exceptions that occur.
+     * @param {Function} executionFunc - The function to execute.
+     * @returns {boolean} - Returns true if the execution failed, false otherwise.
      */
-    _execute(executionFunc: any): Promise<boolean>;
+    private iexecute;
 }

package/dist/src/BaseEvent/Process.js

@@ -39,32 +39,24 @@ Object.defineProperty(exports, "__esModule", { value: true });
 var Logger_1 = require("../Logger/Logger");
 var Publisher_1 = require("../Publisher/Publisher");
 /**
- * ${1:Description placeholder}
- *
- * @export
- * @class Process
- * @typedef {Process}
+ * Represents a long-running process that executes a given function at a specified interval.
  */
 var Process = /** @class */ (function () {
     /**
-     * Creates an instance of Process.
-     *
-     * @constructor
-     * @param {ProcessConfig} config
-     * @param {number} interval
+     * Constructs a new instance of the LongRunningProcess class.
+     * @param {ProcessConfig} config - The configuration object for the process.
+     * @param {number} interval - The interval at which the process should run.
+     * @returns None
      */
     function Process(config, interval) {
-        this._interval = interval;
+        this.interval = interval;
         this.logger = new Logger_1.default(config.logger, 'long-running-process');
         this.publisher = new Publisher_1.default(config.publisher);
     }
-    //Main interface
     /**
-     * ${1:Description placeholder}
-     *
-     * @async
-     * @param {*} executionFunc
-     * @returns {*}
+     * Executes the provided execution function at a specified interval.
+     * @param {Function} executionFunc - The function to execute.
+     * @returns None
      */
     Process.prototype.execute = function (executionFunc) {
         return __awaiter(this, void 0, void 0, function () {
@@ -74,29 +66,26 @@ var Process = /** @class */ (function () {
                 //Connect DB
                 // if (this.db) await this.db.connect();
                 //Program loop
-                this.interval = setInterval(function () { return __awaiter(_this, void 0, void 0, function () {
+                this.timeout = setInterval(function () { return __awaiter(_this, void 0, void 0, function () {
                     return __generator(this, function (_a) {
                         switch (_a.label) {
-                            case 0: return [4 /*yield*/, this._execute(executionFunc)];
+                            case 0: return [4 /*yield*/, this.iexecute(executionFunc)];
                             case 1:
                                 _a.sent();
                                 return [2 /*return*/];
                         }
                     });
-                }); }, this._interval);
+                }); }, this.interval);
                 return [2 /*return*/];
             });
         });
     };
-    //Executions
     /**
-     * ${1:Description placeholder}
-     *
-     * @async
-     * @param {*} executionFunc
-     * @returns {unknown}
+     * Executes the given execution function asynchronously and handles any exceptions that occur.
+     * @param {Function} executionFunc - The function to execute.
+     * @returns {boolean} - Returns true if the execution failed, false otherwise.
      */
-    Process.prototype._execute = function (executionFunc) {
+    Process.prototype.iexecute = function (executionFunc) {
         return __awaiter(this, void 0, void 0, function () {
             var executionFailed, e_1;
             return __generator(this, function (_a) {

package/dist/src/BaseEvent/Process.js.map

@@ -1 +1 @@
-{"version":3,"file":"Process.js","sourceRoot":"","sources":["../../../src/BaseEvent/Process.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA,2CAAqC;AACrC,oDAA8C;AAW9C;;;;;;GAMG;AACH;IAgCE;;;;;;OAMG;IACH,iBAAY,MAAqB,EAAE,QAAgB;QACjD,IAAI,CAAC,SAAS,GAAG,QAAQ,CAAA;QACzB,IAAI,CAAC,MAAM,GAAG,IAAI,gBAAM,CAAC,MAAM,CAAC,MAAM,EAAE,sBAAsB,CAAC,CAAA;QAC/D,IAAI,CAAC,SAAS,GAAG,IAAI,mBAAS,CAAC,MAAM,CAAC,SAAS,CAAC,CAAA;IAClD,CAAC;IAED,gBAAgB;IAChB;;;;;;OAMG;IACG,yBAAO,GAAb,UAAc,aAAa;;;;gBACzB,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,4BAA4B,CAAC,CAAA;gBAC/C,YAAY;gBACZ,wCAAwC;gBACxC,cAAc;gBACd,IAAI,CAAC,QAAQ,GAAG,WAAW,CAAC;;;oCAC1B,qBAAM,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC,EAAA;;gCAAlC,SAAkC,CAAA;;;;qBACnC,EAAE,IAAI,CAAC,SAAS,CAAC,CAAA;;;;KACnB;IACD,YAAY;IACZ;;;;;;OAMG;IACG,0BAAQ,GAAd,UAAe,aAAa;;;;;;wBACtB,eAAe,GAAG,IAAI,CAAC,wBAAwB;wBAAzB,CAAA;;;;wBAGxB,sBAAsB;wBACtB,iDAAiD;wBACjD,SAAS;wBACT,qBAAM,aAAa,CAAC,IAAI,CAAC;4BACzB,WAAW;4BACX,uCAAuC;4BACvC,EAAE;0BAHuB;;wBAHzB,sBAAsB;wBACtB,iDAAiD;wBACjD,SAAS;wBACT,SAAyB,CAAA;wBACzB,WAAW;wBACX,uCAAuC;wBACvC,EAAE;wBACF,eAAe,GAAG,KAAK,CAAA;;;;wBAEvB,kBAAkB;wBAClB,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,8DAA8D,CAAC,CAAA;wBACjF,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,GAAC,CAAC,CAAA;;4BAI1B,sBAAO,eAAe,EAAA;;;;KACvB;IACH,cAAC;AAAD,CAAC,AA3FD,IA2FC"}
+{"version":3,"file":"Process.js","sourceRoot":"","sources":["../../../src/BaseEvent/Process.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA,2CAAqC;AACrC,oDAA8C;AAO9C;;GAEG;AACH;IAqBE;;;;;OAKG;IACH,iBAAY,MAAqB,EAAE,QAAgB;QACjD,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAA;QACxB,IAAI,CAAC,MAAM,GAAG,IAAI,gBAAM,CAAC,MAAM,CAAC,MAAM,EAAE,sBAAsB,CAAC,CAAA;QAC/D,IAAI,CAAC,SAAS,GAAG,IAAI,mBAAS,CAAC,MAAM,CAAC,SAAS,CAAC,CAAA;IAClD,CAAC;IAED;;;;OAIG;IACU,yBAAO,GAApB,UAAqB,aAAa;;;;gBAChC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,4BAA4B,CAAC,CAAA;gBAC/C,YAAY;gBACZ,wCAAwC;gBACxC,cAAc;gBACd,IAAI,CAAC,OAAO,GAAG,WAAW,CAAC;;;oCACzB,qBAAM,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC,EAAA;;gCAAlC,SAAkC,CAAA;;;;qBACnC,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAA;;;;KAClB;IAED;;;;OAIG;IACW,0BAAQ,GAAtB,UAAuB,aAAa;;;;;;wBAC9B,eAAe,GAAG,IAAI,CAAC,wBAAwB;wBAAzB,CAAA;;;;wBAGxB,sBAAsB;wBACtB,iDAAiD;wBACjD,SAAS;wBACT,qBAAM,aAAa,CAAC,IAAI,CAAC;4BACzB,WAAW;4BACX,uCAAuC;4BACvC,EAAE;0BAHuB;;wBAHzB,sBAAsB;wBACtB,iDAAiD;wBACjD,SAAS;wBACT,SAAyB,CAAA;wBACzB,WAAW;wBACX,uCAAuC;wBACvC,EAAE;wBACF,eAAe,GAAG,KAAK,CAAA;;;;wBAEvB,kBAAkB;wBAClB,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,8DAA8D,CAAC,CAAA;wBACjF,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,GAAC,CAAC,CAAA;;4BAI1B,sBAAO,eAAe,EAAA;;;;KACvB;IACH,cAAC;AAAD,CAAC,AA1ED,IA0EC"}

package/dist/src/BaseEvent/Transaction.d.ts

@@ -1,29 +1,131 @@
 import type { APIGatewayEvent, Context, SQSEvent } from 'aws-lambda';
 import Request from '../API/Request';
 import Response, { ResponseErrorType } from '../API/Response';
+import type { DatabaseTransactionType, DatabaseType, DbConfig } from '../Database/types';
 import Logger, { LoggerConfig } from '../Logger/Logger';
 import Publisher, { PublisherConfig } from '../Publisher/Publisher';
+/**
+ * Defines a type for executing a transaction and returning a promise with the response.
+ * @param {TransactionType} transaction - The transaction to execute.
+ * @returns A promise that resolves to the response of the transaction.
+ */
 export type TransactionExecution<TransactionType, ResponseInnerType, MiscRespType = null> = (transaction: TransactionType) => Promise<Response<ResponseInnerType> | Response<ResponseErrorType> | MiscRespType>;
+/**
+ * Represents the configuration options for a transaction.
+ * @typedef {Object} TransactionConfig
+ * @property {boolean} [throwOnErrors] - Whether to throw an error if there are any errors during the transaction.
+ * @property {boolean} [syncReturn] - Whether to return the result of the transaction synchronously.
+ * @property {LoggerConfig} [logger] - The configuration options for the logger.
+ * @property {PublisherConfig} [publisher] - The configuration options for the publisher.
+ */
 export type TransactionConfig = {
     throwOnErrors?: boolean;
     syncReturn?: boolean;
     logger?: LoggerConfig;
     publisher?: PublisherConfig;
 };
+/**
+ * Represents a transaction object that handles the execution of a request and manages the response.
+ * @template InputType - The type of the input data for the transaction.
+ * @template ResponseInnerType - The type of the inner response data for the transaction.
+ * @template MiscRespType - The type of miscellaneous response data for the transaction.
+ */
 export default class Transaction<InputType = object, ResponseInnerType = null, MiscRespType = null> {
+    /**
+     * The instance of the DatabaseManager class used for managing the database.
+     */
+    private databaseManager;
+    /**
+     * An array of database transactions.
+     * @type {DatabaseTransaction[]}
+     */
+    private transactions;
+    /**
+     * Represents an event object.
+     * @private
+     * @type {any}
+     */
     private event;
+    /**
+     * The context object for the current instance.
+     */
     private context;
+    /**
+     * The response object that can hold different types of responses.
+     * @type {Response<ResponseInnerType | ResponseErrorType> | MiscRespType | null}
+     */
     private response;
+    /**
+     * A private boolean variable indicating whether the return value of a synchronous operation
+     * should be synchronized with the calling thread.
+     */
     private syncReturn;
+    /**
+     * A boolean flag indicating whether retroactive errors are enabled or not.
+     * @private
+     */
     private retrowErrors;
+    /**
+     * A logger object used for logging messages, errors, and other information.
+     * @readonly
+     */
     readonly logger: Logger;
+    /**
+     * The request object for making a request of type InputType.
+     * @readonly
+     */
     readonly request: Request<InputType>;
+    /**
+     * The publisher of the content.
+     */
     readonly publisher: Publisher;
-    responseProxy: (response: Response<ResponseInnerType>) => Promise<void>;
+    /**
+     * A function that acts as a response proxy for a given response object.
+     * @param {Response<ResponseInnerType>} response - The response object to proxy.
+     * @returns A promise that resolves to void.
+     */
+    responseProxy: ((response: Response<ResponseInnerType>) => Promise<void>) | null;
+    /**
+     * Constructs a new instance of the Transaction class.
+     * @param {APIGatewayEvent | SQSEvent} 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);
-    execute(executionFunc: TransactionExecution<Transaction<InputType, ResponseInnerType, MiscRespType>, ResponseInnerType, MiscRespType>): Promise<Response<ResponseInnerType | ResponseErrorType> | MiscRespType>;
+    /**
+     * Executes a transaction using the provided execution function and returns a promise
+     * that resolves to the response or miscellaneous response.
+     * @param {TransactionExecution<Transaction<InputType, ResponseInnerType, MiscRespType>, ResponseInnerType, MiscRespType>} executionFunc - The execution function to be executed.
+     * @returns {Promise<Response<ResponseInnerType | ResponseErrorType> | MiscRespType>} - A promise that resolves to the response or miscellaneous response.
+     */
+    execute(executionFunc: TransactionExecution<Transaction<InputType, ResponseInnerType, MiscRespType>, ResponseInnerType, MiscRespType>): Promise<Response<ResponseInnerType | ResponseErrorType> | MiscRespType | null>;
+    /**
+     * Executes a transaction using the provided execution function and handles the response.
+     * @param {TransactionExecution<Transaction<InputType, ResponseInnerType, MiscRespType>, ResponseInnerType, MiscRespType>} executionFunc - The function to execute the transaction.
+     * @returns {Promise<boolean>} - A promise that resolves to a boolean indicating whether the execution failed or not.
+     */
     private iexecute;
+    /**
+     * Retrieves a database transaction for the specified database configuration.
+     * @async
+     * @param {DbConfig<S>} config - The configuration object for the database.
+     * @returns {Promise<DatabaseTransactionType<S>>} A promise that resolves to the database transaction.
+     */
+    getDbTransaction<S extends DatabaseType>(config: DbConfig<S>): Promise<DatabaseTransactionType<S>>;
     private executeDBTransactions;
+    /**
+     * Executes a logger flush operation with error handling and logging.
+     * @param {Function} safeExecution - The function to execute safely.
+     * @returns None
+     * @throws {Error} - If `retrowErrors` is true and an error occurs during execution.
+     */
     private executeLoggerFlush;
+    /**
+     * Returns an error response with the specified error message and error code.
+     * @param {string} error - The error message.
+     * @param {string} code - The error code.
+     * @returns {Response<ResponseErrorType>} - The error response.
+     */
     private getErrorResponse;
 }