@ikonintegration/ikapi 5.0.2 → 5.0.4

package/dist/src/BaseEvent/Launchable/ContainerExec.d.ts

@@ -1,42 +0,0 @@
-import { LaunchableHandlerType } from './types.js';
-/**
- * Represents a ContainerExecution class that handles the execution of a launchable handler.
- * @template Input - The type of input expected by the launchable handler.
- */
-export default class ContainerExecution<Input> {
-    /**
-     * A private readonly property that holds a handler of LaunchableHandlerType with a given Input type.
-     */
-    private readonly handler;
-    /**
-     * Constructor for creating an instance of a class with a LaunchableHandlerType input.
-     * @param {LaunchableHandlerType<Input>} handler - The handler for the launchable type.
-     * @returns None
-     */
-    constructor(handler: LaunchableHandlerType<Input>);
-    /**
-     * Executes the function asynchronously, invoking the specified inputs and handling the response accordingly.
-     * If the response code is 200, the process exits with code 0; otherwise, it exits with code 1.
-     * @returns None
-     */
-    execute(): Promise<void>;
-    /**
-     * Retrieves inputs from the process arguments and parses them as JSON.
-     * @returns {any} The parsed input object from process arguments.
-     */
-    private getInputs;
-    /**
-     * Builds a context object for AWS Lambda function.
-     * @param {CallableFunction} callback - The callback function to be executed.
-     * @returns {Context} A context object with AWS Lambda properties.
-     */
-    private buildContext;
-    /**
-     * Asynchronously invokes a function with the given input and returns a promise that resolves
-     * with an object containing an error message or data response.
-     * @param {any} input - The input to be passed to the function.
-     * @returns {Promise<{ err?: string; data?: any }>} A promise that resolves with an object
-     * containing an error message or data response (serialized).
-     */
-    private invoke;
-}

package/dist/src/BaseEvent/Launchable/ContainerExec.js

@@ -1,102 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-/**
- * Represents a ContainerExecution class that handles the execution of a launchable handler.
- * @template Input - The type of input expected by the launchable handler.
- */
-export default class ContainerExecution {
-    /**
-     * Constructor for creating an instance of a class with a LaunchableHandlerType input.
-     * @param {LaunchableHandlerType<Input>} handler - The handler for the launchable type.
-     * @returns None
-     */
-    constructor(handler) {
-        this.handler = handler;
-    }
-    /**
-     * Executes the function asynchronously, invoking the specified inputs and handling the response accordingly.
-     * If the response code is 200, the process exits with code 0; otherwise, it exits with code 1.
-     * @returns None
-     */
-    execute() {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                // Invoke
-                const resp = yield this.invoke(this.getInputs());
-                // Return
-                console.debug(resp);
-                if (!resp.err && resp.data && resp.data.statusCode == 200)
-                    process.exit(0);
-                else
-                    process.exit(1);
-            }
-            catch (e) {
-                console.error(e);
-                process.exit(1);
-            }
-        });
-    }
-    /**
-     * Retrieves inputs from the process arguments and parses them as JSON.
-     * @returns {any} The parsed input object from process arguments.
-     */
-    getInputs() {
-        let input = {};
-        console.debug(process.argv);
-        try {
-            input = JSON.parse(process.argv[2]);
-        }
-        catch (e) {
-            console.log('[IKApi Launchable Runtime] - Error while decoding process arguments! (can be desconsider if no inputs were provided)', e.message);
-        }
-        return input;
-    }
-    /**
-     * Builds a context object for AWS Lambda function.
-     * @param {CallableFunction} callback - The callback function to be executed.
-     * @returns {Context} A context object with AWS Lambda properties.
-     */
-    buildContext(callback) {
-        return {
-            awsRequestId: `${Date.now()}-${Date.now()}`,
-            callbackWaitsForEmptyEventLoop: true,
-            getRemainingTimeInMillis: () => 0,
-            done: (err, data) => callback(err, data),
-            fail: err => callback(err),
-            succeed: res => callback(null, res),
-        };
-    }
-    /**
-     * Asynchronously invokes a function with the given input and returns a promise that resolves
-     * with an object containing an error message or data response.
-     * @param {any} input - The input to be passed to the function.
-     * @returns {Promise<{ err?: string; data?: any }>} A promise that resolves with an object
-     * containing an error message or data response (serialized).
-     */
-    invoke(input) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // eslint-disable-next-line no-async-promise-executor
-            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
-                try {
-                    const context = this.buildContext((err, data) => {
-                        resolve({ err, data });
-                    });
-                    const resp = yield this.handler(input, context);
-                    if (resp)
-                        resolve({ data: resp });
-                }
-                catch (e) {
-                    reject(e);
-                }
-            }));
-        });
-    }
-}
-//# sourceMappingURL=ContainerExec.js.map

package/dist/src/BaseEvent/Launchable/ContainerExec.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ContainerExec.js","sourceRoot":"","sources":["../../../../src/BaseEvent/Launchable/ContainerExec.ts"],"names":[],"mappings":";;;;;;;;;AAKA;;;GAGG;AACH,MAAM,CAAC,OAAO,OAAO,kBAAkB;IAMrC;;;;OAIG;IACH,YAAY,OAAqC;QAC/C,IAAI,CAAC,OAAO,GAAG,OAAO,CAAA;IACxB,CAAC;IAED;;;;OAIG;IACU,OAAO;;YAClB,IAAI,CAAC;gBACH,SAAS;gBACT,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC,CAAA;gBAChD,SAAS;gBACT,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAA;gBACnB,IAAI,CAAC,IAAI,CAAC,GAAG,IAAI,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,IAAI,CAAC,UAAU,IAAI,GAAG;oBAAE,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAA;;oBACrE,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAA;YACtB,CAAC;YAAC,OAAO,CAAC,EAAE,CAAC;gBACX,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAA;gBAChB,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAA;YACjB,CAAC;QACH,CAAC;KAAA;IAED;;;OAGG;IACK,SAAS;QACf,IAAI,KAAK,GAAQ,EAAE,CAAA;QACnB,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAA;QAC3B,IAAI,CAAC;YACH,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAA;QACrC,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACX,OAAO,CAAC,GAAG,CACT,sHAAsH,EACtH,CAAC,CAAC,OAAO,CACV,CAAA;QACH,CAAC;QACD,OAAO,KAAK,CAAA;IACd,CAAC;IAED;;;;OAIG;IACK,YAAY,CAAC,QAA0B;QAC7C,OAAO;YACL,YAAY,EAAE,GAAG,IAAI,CAAC,GAAG,EAAE,IAAI,IAAI,CAAC,GAAG,EAAE,EAAE;YAC3C,8BAA8B,EAAE,IAAI;YACpC,wBAAwB,EAAE,GAAG,EAAE,CAAC,CAAC;YACjC,IAAI,EAAE,CAAC,GAAG,EAAE,IAAI,EAAE,EAAE,CAAC,QAAQ,CAAC,GAAG,EAAE,IAAI,CAAC;YACxC,IAAI,EAAE,GAAG,CAAC,EAAE,CAAC,QAAQ,CAAC,GAAG,CAAC;YAC1B,OAAO,EAAE,GAAG,CAAC,EAAE,CAAC,QAAQ,CAAC,IAAI,EAAE,GAAG,CAAC;SAClB,CAAA;IACrB,CAAC;IAED;;;;;;OAMG;IACW,MAAM,CAAC,KAAU;;YAC7B,qDAAqD;YACrD,OAAO,IAAI,OAAO,CAA+B,CAAO,OAAO,EAAE,MAAM,EAAE,EAAE;gBACzE,IAAI,CAAC;oBACH,MAAM,OAAO,GAAG,IAAI,CAAC,YAAY,CAAC,CAAC,GAAG,EAAE,IAAI,EAAE,EAAE;wBAC9C,OAAO,CAAC,EAAE,GAAG,EAAE,IAAI,EAAE,CAAC,CAAA;oBACxB,CAAC,CAAC,CAAA;oBACF,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,OAAO,CAAC,CAAA;oBAC/C,IAAI,IAAI;wBAAE,OAAO,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAA;gBACnC,CAAC;gBAAC,OAAO,CAAC,EAAE,CAAC;oBACX,MAAM,CAAC,CAAC,CAAC,CAAA;gBACX,CAAC;YACH,CAAC,CAAA,CAAC,CAAA;QACJ,CAAC;KAAA;CACF"}

package/dist/src/BaseEvent/Launchable/index.d.ts

@@ -1,34 +0,0 @@
-import { LaunchableHandlerType } from './types.js';
-/**
- * Represents a Launchable class that can be used to handle launchable items.
- * @template Input - The type of input expected by the LaunchableHandlerType.
- */
-export default class Launchable<Input = any> {
-    /**
-     * A private readonly property that holds a handler for launching with a specific input type.
-     * @type {LaunchableHandlerType<Input>}
-     */
-    private readonly handler;
-    /**
-     * Constructor for creating an instance of a class with a LaunchableHandlerType input.
-     * @param {LaunchableHandlerType<Input>} handler - The handler for the launchable type.
-     * @returns None
-     */
-    constructor(handler: LaunchableHandlerType<Input>);
-    /**
-     * Returns the export function based on whether the object is a container or not.
-     * If it is a container, it returns the container export function, otherwise it returns the handler function.
-     * @returns {CallableFunction} The export function to be used.
-     */
-    getExport(): CallableFunction;
-    /**
-     * Checks if the current element is a container by calling the isHybridlessContainer method from the Utils class.
-     * @returns {boolean} - true if the element is a container, false otherwise.
-     */
-    private isContainer;
-    /**
-     * Returns a callable function that executes a ContainerExecution instance and returns a promise.
-     * @returns {CallableFunction} A function that when called, executes a ContainerExecution instance.
-     */
-    private getContainerExport;
-}

package/dist/src/BaseEvent/Launchable/index.js

@@ -1,43 +0,0 @@
-import ContainerExecution from './ContainerExec.js';
-import Utils from '../../Util/Utils.js';
-/**
- * Represents a Launchable class that can be used to handle launchable items.
- * @template Input - The type of input expected by the LaunchableHandlerType.
- */
-export default class Launchable {
-    /**
-     * Constructor for creating an instance of a class with a LaunchableHandlerType input.
-     * @param {LaunchableHandlerType<Input>} handler - The handler for the launchable type.
-     * @returns None
-     */
-    constructor(handler) {
-        this.handler = handler;
-    }
-    /**
-     * Returns the export function based on whether the object is a container or not.
-     * If it is a container, it returns the container export function, otherwise it returns the handler function.
-     * @returns {CallableFunction} The export function to be used.
-     */
-    getExport() {
-        return this.isContainer() ? this.getContainerExport() : this.handler;
-    }
-    /**
-     * Checks if the current element is a container by calling the isHybridlessContainer method from the Utils class.
-     * @returns {boolean} - true if the element is a container, false otherwise.
-     */
-    isContainer() {
-        return Utils.isHybridlessContainer();
-    }
-    /**
-     * Returns a callable function that executes a ContainerExecution instance and returns a promise.
-     * @returns {CallableFunction} A function that when called, executes a ContainerExecution instance.
-     */
-    getContainerExport() {
-        // emulate lambda invocation
-        const ce = new ContainerExecution(this.handler);
-        ce.execute().then(() => { });
-        // return empty function, we are all done
-        return () => { };
-    }
-}
-//# sourceMappingURL=index.js.map

package/dist/src/BaseEvent/Launchable/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/BaseEvent/Launchable/index.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,MAAM,oBAAoB,CAAA;AAEnD,OAAO,KAAK,MAAM,qBAAqB,CAAA;AAEvC;;;GAGG;AACH,MAAM,CAAC,OAAO,OAAO,UAAU;IAO7B;;;;OAIG;IACH,YAAY,OAAqC;QAC/C,IAAI,CAAC,OAAO,GAAG,OAAO,CAAA;IACxB,CAAC;IAED;;;;OAIG;IACI,SAAS;QACd,OAAO,IAAI,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,kBAAkB,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAA;IACtE,CAAC;IAED;;;OAGG;IACK,WAAW;QACjB,OAAO,KAAK,CAAC,qBAAqB,EAAE,CAAA;IACtC,CAAC;IAED;;;OAGG;IACK,kBAAkB;QACxB,4BAA4B;QAC5B,MAAM,EAAE,GAAG,IAAI,kBAAkB,CAAC,IAAI,CAAC,OAAO,CAAC,CAAA;QAC/C,EAAE,CAAC,OAAO,EAAE,CAAC,IAAI,CAAC,GAAG,EAAE,GAAE,CAAC,CAAC,CAAA;QAC3B,yCAAyC;QACzC,OAAO,GAAG,EAAE,GAAE,CAAC,CAAA;IACjB,CAAC;CACF"}

package/dist/src/BaseEvent/Launchable/types.d.ts

@@ -1,10 +0,0 @@
-import { Context } from 'aws-lambda';
-import Response from '../../API/Response.js';
-/**
- * Defines a type for a launchable handler that takes an input event and context,
- * and returns a promise of a response.
- * @param {Input} event - The input event for the handler.
- * @param {Context} context - The context for the handler.
- * @returns {Promise<Response<any>>} A promise that resolves to a response.
- */
-export type LaunchableHandlerType<Input> = (event: Input, context: Context) => Promise<Response<any> | null>;

package/dist/src/BaseEvent/Launchable/types.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=types.js.map

package/dist/src/BaseEvent/Launchable/types.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../src/BaseEvent/Launchable/types.ts"],"names":[],"mappings":""}

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

@@ -1,50 +0,0 @@
-import { TransactionConfig } from './Transaction.js';
-import Logger from '../Logger/Logger.js';
-import Publisher from '../Publisher/Publisher.js';
-/**
- * A type that represents a modified version of the TransactionConfig type, excluding the 'throwOnErrors' and 'syncReturn' properties.
- */
-export type ProcessConfig = Omit<TransactionConfig, 'throwOnErrors' | 'syncReturn'>;
-/**
- * Represents a long-running process that executes a given function at a specified interval.
- */
-export default class Process {
-    /**
-     * Private member variable representing the interval value.
-     * @type {number}
-     * @private
-     */
-    private interval;
-    /**
-     * A logger object used for logging messages, errors, and other information.
-     * @readonly
-     */
-    readonly logger: Logger;
-    /**
-     * The publisher of the content.
-     */
-    readonly publisher: Publisher;
-    /**
-     * A reference to the NodeJS.Timeout object representing the interval timer.
-     */
-    timeout: NodeJS.Timeout;
-    /**
-     * 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);
-    /**
-     * Executes the provided execution function at a specified interval.
-     * @param {Function} executionFunc - The function to execute.
-     * @returns None
-     */
-    execute(executionFunc: any): Promise<void>;
-    /**
-     * 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.
-     */
-    private iexecute;
-}

package/dist/src/BaseEvent/Process.js

@@ -1,64 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import Logger from '../Logger/Logger.js';
-import Publisher from '../Publisher/Publisher.js';
-/**
- * Represents a long-running process that executes a given function at a specified interval.
- */
-export default class Process {
-    /**
-     * 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, interval) {
-        this.interval = interval;
-        this.logger = new Logger(config.logger, 'long-running-process');
-        this.publisher = new Publisher(config.publisher);
-    }
-    /**
-     * Executes the provided execution function at a specified interval.
-     * @param {Function} executionFunc - The function to execute.
-     * @returns None
-     */
-    execute(executionFunc) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.logger.debug('Starting main process code');
-            //Program loop
-            this.timeout = setInterval(() => __awaiter(this, void 0, void 0, function* () {
-                yield this.iexecute(executionFunc);
-            }), this.interval);
-        });
-    }
-    /**
-     * 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.
-     */
-    iexecute(executionFunc) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let executionFailed = true; //failed til we say no!
-            // safe execution handler
-            try {
-                // Execute
-                yield executionFunc(this);
-                executionFailed = false;
-            }
-            catch (e) {
-                /* EXECUTION FAIL */
-                this.logger.error('Exception when executing main process code. Rolling back DB!');
-                this.logger.exception(e);
-            }
-            return executionFailed;
-        });
-    }
-}
-//# sourceMappingURL=Process.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"Process.js","sourceRoot":"","sources":["../../../src/BaseEvent/Process.ts"],"names":[],"mappings":";;;;;;;;;AACA,OAAO,MAAM,MAAM,qBAAqB,CAAA;AACxC,OAAO,SAAS,MAAM,2BAA2B,CAAA;AAOjD;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,OAAO;IAqB1B;;;;;OAKG;IACH,YAAY,MAAqB,EAAE,QAAgB;QACjD,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAA;QACxB,IAAI,CAAC,MAAM,GAAG,IAAI,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,sBAAsB,CAAC,CAAA;QAC/D,IAAI,CAAC,SAAS,GAAG,IAAI,SAAS,CAAC,MAAM,CAAC,SAAS,CAAC,CAAA;IAClD,CAAC;IAED;;;;OAIG;IACU,OAAO,CAAC,aAAa;;YAChC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,4BAA4B,CAAC,CAAA;YAC/C,cAAc;YACd,IAAI,CAAC,OAAO,GAAG,WAAW,CAAC,GAAS,EAAE;gBACpC,MAAM,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAA;YACpC,CAAC,CAAA,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAA;QACnB,CAAC;KAAA;IAED;;;;OAIG;IACW,QAAQ,CAAC,aAAa;;YAClC,IAAI,eAAe,GAAG,IAAI,CAAA,CAAC,uBAAuB;YAClD,yBAAyB;YACzB,IAAI,CAAC;gBACH,UAAU;gBACV,MAAM,aAAa,CAAC,IAAI,CAAC,CAAA;gBACzB,eAAe,GAAG,KAAK,CAAA;YACzB,CAAC;YAAC,OAAO,CAAC,EAAE,CAAC;gBACX,oBAAoB;gBACpB,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,8DAA8D,CAAC,CAAA;gBACjF,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,CAAA;YAC1B,CAAC;YACD,OAAO,eAAe,CAAA;QACxB,CAAC;KAAA;CACF"}

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

@@ -1,23 +0,0 @@
-import type { Context } from 'aws-lambda';
-import Transaction, { TransactionConfig } from './Transaction.js';
-import Response, { ResponseErrorType } from '../API/Response.js';
-/**
- * Represents a step transaction that extends the Transaction class.
- */
-export default class StepTransaction extends Transaction {
-    /**
-     * Constructor for creating a new Transaction object.
-     * @param {any} event - The event object.
-     * @param {Context} context - The context object.
-     * @param {TransactionConfig} [config] - Optional configuration for the transaction.
-     * @returns None
-     */
-    constructor(event: any, context: Context, config?: TransactionConfig);
-    /**
-     * Generates an error response with the provided error message and error code.
-     * @param {string} error - The error message to include in the response.
-     * @param {string} code - The error code associated with the error.
-     * @returns {Response<ResponseErrorType>} - The error response object.
-     */
-    protected getErrorResponse(error: string, code: string): Response<ResponseErrorType>;
-}

package/dist/src/BaseEvent/StepTransaction.js

@@ -1,27 +0,0 @@
-import Transaction from './Transaction.js';
-import Response from '../API/Response.js';
-/**
- * Represents a step transaction that extends the Transaction class.
- */
-export default class StepTransaction extends Transaction {
-    /**
-     * Constructor for creating a new Transaction object.
-     * @param {any} event - The event object.
-     * @param {Context} context - The context object.
-     * @param {TransactionConfig} [config] - Optional configuration for the transaction.
-     * @returns None
-     */
-    constructor(event, context, config) {
-        super(event, context, Object.assign({ syncReturn: true, throwOnErrors: true }, (config || {})));
-    }
-    /**
-     * Generates an error response with the provided error message and error code.
-     * @param {string} error - The error message to include in the response.
-     * @param {string} code - The error code associated with the error.
-     * @returns {Response<ResponseErrorType>} - The error response object.
-     */
-    getErrorResponse(error, code) {
-        return Response.StepFunctionResponse({ err: error, errCode: code }, 400);
-    }
-}
-//# sourceMappingURL=StepTransaction.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"StepTransaction.js","sourceRoot":"","sources":["../../../src/BaseEvent/StepTransaction.ts"],"names":[],"mappings":"AAEA,OAAO,WAAkC,MAAM,kBAAkB,CAAA;AACjE,OAAO,QAA+B,MAAM,oBAAoB,CAAA;AAEhE;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,eAAgB,SAAQ,WAAW;IACtD;;;;;;OAMG;IACH,YAAY,KAAU,EAAE,OAAgB,EAAE,MAA0B;QAClE,KAAK,CAAC,KAAK,EAAE,OAAO,kBAClB,UAAU,EAAE,IAAI,EAChB,aAAa,EAAE,IAAI,IAEhB,CAAC,MAAM,IAAI,EAAE,CAAC,EACjB,CAAA;IACJ,CAAC;IAED;;;;;OAKG;IACO,gBAAgB,CAAC,KAAa,EAAE,IAAY;QACpD,OAAO,QAAQ,CAAC,oBAAoB,CAAC,EAAE,GAAG,EAAE,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,EAAE,GAAG,CAAC,CAAA;IAC1E,CAAC;CACF"}

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

@@ -1,149 +0,0 @@
-import type { APIGatewayEvent, Context, DynamoDBStreamEvent, SQSEvent } from 'aws-lambda';
-import Request from '../API/Request.js';
-import Response, { ResponseErrorType } from '../API/Response.js';
-import type { DatabaseImplType, DatabaseTransactionType, DatabaseType, DbConfig } from '../Database/types.js';
-import Logger, { LoggerConfig } from '../Logger/Logger.js';
-import Publisher, { PublisherConfig } from '../Publisher/Publisher.js';
-/**
- * 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 = never> = (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 {boolean} [skipCleanTmp] - Whether to skip cleaning the temporary folder, in EventProcessor.
- * @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;
-    skipCleanTmp?: boolean;
-    logger?: LoggerConfig;
-    publisher?: PublisherConfig;
-};
-/**
- * Represents a simple string dictionary with string values
- */
-export type StringMap = {
-    [key: string]: string | null;
-};
-/**
- * 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 = never, ResponseInnerType = null, MiscRespType = never, PathParamsType = StringMap, QueryParamsType = StringMap> {
-    /**
-     * 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, PathParamsType, QueryParamsType>;
-    /**
-     * The publisher of the content.
-     */
-    readonly publisher: Publisher;
-    /**
-     * 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 | 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 | DynamoDBStreamEvent, context: Context, config?: TransactionConfig);
-    /**
-     * 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, PathParamsType, QueryParamsType>, 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 based on the provided database configuration.
-     * @param {DbConfig<S>} config - The configuration object for the database.
-     * @returns {Promise<DatabaseTransactionType<S, DBSchema>>} A promise that resolves to the database transaction.
-     */
-    getDbTransaction<S extends DatabaseType, DBSchema>(config: DbConfig<S>): Promise<DatabaseTransactionType<S, DBSchema>>;
-    /**
-     * Retrieves a database instance based on the provided configuration.
-     * @param {DbConfig<S>} config - The configuration object specifying the type of database.
-     * @returns {DatabaseImplType<S, DBSchema>} A database instance based on the provided configuration.
-     */
-    getDatabase<S extends DatabaseType, DBSchema>(config: DbConfig<S>): DatabaseImplType<S, DBSchema>;
-    /**
-     * 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.
-     */
-    getRemainingTimeInMillis(): number;
-    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;
-    /**
-     * Generates an error response with the provided error message and code.
-     * @param {string} error - The error message to include in the response.
-     * @param {string} code - The error code associated with the response.
-     * @returns {Response<ResponseErrorType>} - The error response object.
-     */
-    protected getErrorResponse(error: string, code: string): Response<ResponseErrorType>;
-}