mutualbankutils 1.0.0

package/dist/domain/BaseDomain.d.ts

@@ -0,0 +1,8 @@
+export declare abstract class BaseDomain<T> {
+    private readonly props;
+    constructor(props: T);
+    get(): T;
+    get<K extends keyof T>(key: K): T[K];
+    set<K extends keyof T>(key: K, value: T[K]): void;
+    toJSON(): T;
+}

package/dist/domain/BaseDomain.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseDomain = void 0;
+class BaseDomain {
+    constructor(props) {
+        this.props = props;
+    }
+    get(key) {
+        if (key !== undefined)
+            return this.props[key];
+        return this.props;
+    }
+    set(key, value) {
+        this.props[key] = value;
+    }
+    toJSON() {
+        return Object.freeze({ ...this.props });
+    }
+}
+exports.BaseDomain = BaseDomain;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQmFzZURvbWFpbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NoYXJlZC9kb21haW4vQmFzZURvbWFpbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSxNQUFzQixVQUFVO0lBRzlCLFlBQVksS0FBUTtRQUNsQixJQUFJLENBQUMsS0FBSyxHQUFHLEtBQUssQ0FBQztJQUNyQixDQUFDO0lBTUQsR0FBRyxDQUFvQixHQUFPO1FBQzVCLElBQUksR0FBRyxLQUFLLFNBQVM7WUFBRSxPQUFPLElBQUksQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLENBQUM7UUFDOUMsT0FBTyxJQUFJLENBQUMsS0FBSyxDQUFDO0lBQ3BCLENBQUM7SUFFRCxHQUFHLENBQW9CLEdBQU0sRUFBRSxLQUFXO1FBQ3ZDLElBQUksQ0FBQyxLQUFhLENBQUMsR0FBRyxDQUFDLEdBQUcsS0FBSyxDQUFDO0lBQ25DLENBQUM7SUFFRCxNQUFNO1FBQ0osT0FBTyxNQUFNLENBQUMsTUFBTSxDQUFDLEVBQUUsR0FBRyxJQUFJLENBQUMsS0FBSyxFQUFFLENBQUMsQ0FBQztJQUMxQyxDQUFDO0NBQ0Y7QUF2QkQsZ0NBdUJDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGFic3RyYWN0IGNsYXNzIEJhc2VEb21haW48VD4ge1xyXG4gIHByaXZhdGUgcmVhZG9ubHkgcHJvcHM6IFQ7XHJcblxyXG4gIGNvbnN0cnVjdG9yKHByb3BzOiBUKSB7XHJcbiAgICB0aGlzLnByb3BzID0gcHJvcHM7XHJcbiAgfVxyXG5cclxuICBnZXQoKTogVDtcclxuXHJcbiAgZ2V0PEsgZXh0ZW5kcyBrZXlvZiBUPihrZXk6IEspOiBUW0tdO1xyXG5cclxuICBnZXQ8SyBleHRlbmRzIGtleW9mIFQ+KGtleT86IEspOiBUIHwgVFtLXSB7XHJcbiAgICBpZiAoa2V5ICE9PSB1bmRlZmluZWQpIHJldHVybiB0aGlzLnByb3BzW2tleV07XHJcbiAgICByZXR1cm4gdGhpcy5wcm9wcztcclxuICB9XHJcblxyXG4gIHNldDxLIGV4dGVuZHMga2V5b2YgVD4oa2V5OiBLLCB2YWx1ZTogVFtLXSk6IHZvaWQge1xyXG4gICAgKHRoaXMucHJvcHMgYXMgYW55KVtrZXldID0gdmFsdWU7XHJcbiAgfVxyXG5cclxuICB0b0pTT04oKTogVCB7XHJcbiAgICByZXR1cm4gT2JqZWN0LmZyZWV6ZSh7IC4uLnRoaXMucHJvcHMgfSk7XHJcbiAgfVxyXG59Il19

package/dist/domain/RoutingAttempts.d.ts

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+import { BaseDomain } from './BaseDomain';
+export declare enum RoutingAttemptStatus {
+    PENDING = "pending",
+    SUCCESS = "success",
+    FAILED = "failed"
+}
+export declare const routingAttemptsSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    transactionId: z.ZodString;
+    providerCode: z.ZodString;
+    requestPayload: z.ZodOptional<z.ZodAny>;
+    responsePayload: z.ZodOptional<z.ZodAny>;
+    status: z.ZodEnum<typeof RoutingAttemptStatus>;
+    createdAt: z.ZodDefault<z.ZodOptional<z.ZodDate>>;
+    updatedAt: z.ZodDefault<z.ZodOptional<z.ZodDate>>;
+}, z.core.$strip>;
+export type RoutingAttemptsProps = z.infer<typeof routingAttemptsSchema>;
+export declare class RoutingAttempts extends BaseDomain<RoutingAttemptsProps> {
+    constructor(props: RoutingAttemptsProps);
+    static create(props: RoutingAttemptsProps): RoutingAttempts;
+    static restore(props: RoutingAttemptsProps): RoutingAttempts;
+    success(): void;
+    failed(): void;
+    setRequestPayload(payload: any): void;
+    setResponsePayload(payload: any): void;
+}

package/dist/domain/RoutingAttempts.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoutingAttempts = exports.routingAttemptsSchema = exports.RoutingAttemptStatus = void 0;
+const zod_1 = require("zod");
+const BaseDomain_1 = require("./BaseDomain");
+const crypto_1 = require("crypto");
+var RoutingAttemptStatus;
+(function (RoutingAttemptStatus) {
+    RoutingAttemptStatus["PENDING"] = "pending";
+    RoutingAttemptStatus["SUCCESS"] = "success";
+    RoutingAttemptStatus["FAILED"] = "failed";
+})(RoutingAttemptStatus || (exports.RoutingAttemptStatus = RoutingAttemptStatus = {}));
+exports.routingAttemptsSchema = zod_1.z.object({
+    id: zod_1.z.string().optional(),
+    transactionId: zod_1.z.string(),
+    providerCode: zod_1.z.string(),
+    requestPayload: zod_1.z.any().optional(),
+    responsePayload: zod_1.z.any().optional(),
+    status: zod_1.z.nativeEnum(RoutingAttemptStatus),
+    createdAt: zod_1.z.date().optional().default(new Date()),
+    updatedAt: zod_1.z.date().optional().default(new Date()),
+});
+class RoutingAttempts extends BaseDomain_1.BaseDomain {
+    constructor(props) {
+        super(props);
+    }
+    static create(props) {
+        const id = (0, crypto_1.randomUUID)();
+        return new RoutingAttempts({
+            id,
+            ...props,
+            createdAt: new Date(),
+            updatedAt: new Date(),
+        });
+    }
+    static restore(props) {
+        return new RoutingAttempts(props);
+    }
+    success() {
+        this.set("status", RoutingAttemptStatus.SUCCESS);
+    }
+    failed() {
+        this.set("status", RoutingAttemptStatus.FAILED);
+    }
+    setRequestPayload(payload) {
+        this.set("requestPayload", JSON.stringify(payload));
+    }
+    setResponsePayload(payload) {
+        this.set("responsePayload", JSON.stringify(payload));
+    }
+}
+exports.RoutingAttempts = RoutingAttempts;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/domain/Transaction.d.ts

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+import { BaseDomain } from './BaseDomain';
+export declare enum TransactionStatus {
+    CREATED = "created",
+    PENDING = "pending",
+    PROCESSING = "processing",
+    COMPLETED = "completed",
+    FAILED = "failed",
+    CANCELLED = "cancelled",
+    REFUNDED = "refunded"
+}
+export declare const transactionSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    amount: z.ZodNumber;
+    providerCode: z.ZodString;
+    externalId: z.ZodString;
+    status: z.ZodEnum<typeof TransactionStatus>;
+}, z.core.$strip>;
+export type TransactionProps = z.infer<typeof transactionSchema>;
+export declare class Transaction extends BaseDomain<TransactionProps> {
+    constructor(props: TransactionProps);
+    static create(props: TransactionProps): Transaction;
+    static restore(props: TransactionProps): Transaction;
+    failed(): void;
+    completed(): void;
+    cancelled(): void;
+    refunded(): void;
+}

package/dist/domain/Transaction.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Transaction = exports.transactionSchema = exports.TransactionStatus = void 0;
+const zod_1 = require("zod");
+const BaseDomain_1 = require("./BaseDomain");
+const crypto_1 = require("crypto");
+var TransactionStatus;
+(function (TransactionStatus) {
+    TransactionStatus["CREATED"] = "created";
+    TransactionStatus["PENDING"] = "pending";
+    TransactionStatus["PROCESSING"] = "processing";
+    TransactionStatus["COMPLETED"] = "completed";
+    TransactionStatus["FAILED"] = "failed";
+    TransactionStatus["CANCELLED"] = "cancelled";
+    TransactionStatus["REFUNDED"] = "refunded";
+})(TransactionStatus || (exports.TransactionStatus = TransactionStatus = {}));
+exports.transactionSchema = zod_1.z.object({
+    id: zod_1.z.string().optional(),
+    amount: zod_1.z.number(),
+    providerCode: zod_1.z.string(),
+    externalId: zod_1.z.string(),
+    status: zod_1.z.nativeEnum(TransactionStatus),
+});
+class Transaction extends BaseDomain_1.BaseDomain {
+    constructor(props) {
+        super(props);
+    }
+    static create(props) {
+        const id = (0, crypto_1.randomUUID)();
+        return new Transaction({
+            id,
+            ...props,
+            status: TransactionStatus.CREATED,
+        });
+    }
+    static restore(props) {
+        return new Transaction(props);
+    }
+    failed() {
+        this.set("status", TransactionStatus.FAILED);
+    }
+    completed() {
+        this.set("status", TransactionStatus.COMPLETED);
+    }
+    cancelled() {
+        this.set("status", TransactionStatus.CANCELLED);
+    }
+    refunded() {
+        this.set("status", TransactionStatus.REFUNDED);
+    }
+}
+exports.Transaction = Transaction;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/factory/QueueFactory.d.ts

@@ -0,0 +1,6 @@
+import { IQueueAdapter } from "../interfaces/IQueueAdapter";
+import { QueueConfig } from "../interfaces/IQueueConfig";
+export declare class QueueFactory {
+    static create(config: QueueConfig): IQueueAdapter;
+    static createFromEnv(): IQueueAdapter;
+}

package/dist/factory/QueueFactory.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueueFactory = void 0;
+const RabbitMQAdapter_1 = require("../queue/adapters/RabbitMQAdapter");
+const SQSAdapter_1 = require("../queue/adapters/SQSAdapter");
+class QueueFactory {
+    static create(config) {
+        switch (config.type) {
+            case "rabbitmq":
+                return new RabbitMQAdapter_1.RabbitMQAdapter(config);
+            case "sqs":
+                return new SQSAdapter_1.SQSAdapter(config);
+            default:
+                throw new Error(`Unknown queue type: ${config.type}`);
+        }
+    }
+    static createFromEnv() {
+        const type = process.env.QUEUE_TYPE || "rabbitmq";
+        if (type === "sqs") {
+            return new SQSAdapter_1.SQSAdapter({
+                type: "sqs",
+                endpoint: process.env.SQS_ENDPOINT,
+                region: process.env.SQS_REGION || "us-east-1",
+                accessKeyId: process.env.SQS_ACCESS_KEY || process.env.AWS_ACCESS_KEY_ID || "",
+                secretAccessKey: process.env.SQS_SECRET_KEY || process.env.AWS_SECRET_ACCESS_KEY || "",
+            });
+        }
+        return new RabbitMQAdapter_1.RabbitMQAdapter({
+            type: "rabbitmq",
+            host: process.env.RABBITMQ_HOST || "localhost",
+            port: parseInt(process.env.RABBITMQ_PORT || "5672", 10),
+            username: process.env.RABBITMQ_USER || "guest",
+            password: process.env.RABBITMQ_PASSWORD || "guest",
+            vhost: process.env.RABBITMQ_VHOST || "/",
+        });
+    }
+}
+exports.QueueFactory = QueueFactory;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUXVldWVGYWN0b3J5LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc2hhcmVkL2ZhY3RvcnkvUXVldWVGYWN0b3J5LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUVBLHVFQUFvRTtBQUNwRSw2REFBMEQ7QUFFMUQsTUFBYSxZQUFZO0lBRXZCLE1BQU0sQ0FBQyxNQUFNLENBQUMsTUFBbUI7UUFDL0IsUUFBUSxNQUFNLENBQUMsSUFBSSxFQUFFLENBQUM7WUFDcEIsS0FBSyxVQUFVO2dCQUNiLE9BQU8sSUFBSSxpQ0FBZSxDQUFDLE1BQU0sQ0FBQyxDQUFDO1lBQ3JDLEtBQUssS0FBSztnQkFDUixPQUFPLElBQUksdUJBQVUsQ0FBQyxNQUFNLENBQUMsQ0FBQztZQUNoQztnQkFDRSxNQUFNLElBQUksS0FBSyxDQUFDLHVCQUF3QixNQUFzQixDQUFDLElBQUksRUFBRSxDQUFDLENBQUM7UUFDM0UsQ0FBQztJQUNILENBQUM7SUFFRCxNQUFNLENBQUMsYUFBYTtRQUNsQixNQUFNLElBQUksR0FBRyxPQUFPLENBQUMsR0FBRyxDQUFDLFVBQVUsSUFBSSxVQUFVLENBQUM7UUFFbEQsSUFBSSxJQUFJLEtBQUssS0FBSyxFQUFFLENBQUM7WUFDbkIsT0FBTyxJQUFJLHVCQUFVLENBQUM7Z0JBQ3BCLElBQUksRUFBRSxLQUFLO2dCQUNYLFFBQVEsRUFBRSxPQUFPLENBQUMsR0FBRyxDQUFDLFlBQVk7Z0JBQ2xDLE1BQU0sRUFBRSxPQUFPLENBQUMsR0FBRyxDQUFDLFVBQVUsSUFBSSxXQUFXO2dCQUM3QyxXQUFXLEVBQUUsT0FBTyxDQUFDLEdBQUcsQ0FBQyxjQUFjLElBQUksT0FBTyxDQUFDLEdBQUcsQ0FBQyxpQkFBaUIsSUFBSSxFQUFFO2dCQUM5RSxlQUFlLEVBQUUsT0FBTyxDQUFDLEdBQUcsQ0FBQyxjQUFjLElBQUksT0FBTyxDQUFDLEdBQUcsQ0FBQyxxQkFBcUIsSUFBSSxFQUFFO2FBQ3ZGLENBQUMsQ0FBQztRQUNMLENBQUM7UUFFRCxPQUFPLElBQUksaUNBQWUsQ0FBQztZQUN6QixJQUFJLEVBQUUsVUFBVTtZQUNoQixJQUFJLEVBQUUsT0FBTyxDQUFDLEdBQUcsQ0FBQyxhQUFhLElBQUksV0FBVztZQUM5QyxJQUFJLEVBQUUsUUFBUSxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUMsYUFBYSxJQUFJLE1BQU0sRUFBRSxFQUFFLENBQUM7WUFDdkQsUUFBUSxFQUFFLE9BQU8sQ0FBQyxHQUFHLENBQUMsYUFBYSxJQUFJLE9BQU87WUFDOUMsUUFBUSxFQUFFLE9BQU8sQ0FBQyxHQUFHLENBQUMsaUJBQWlCLElBQUksT0FBTztZQUNsRCxLQUFLLEVBQUUsT0FBTyxDQUFDLEdBQUcsQ0FBQyxjQUFjLElBQUksR0FBRztTQUN6QyxDQUFDLENBQUM7SUFDTCxDQUFDO0NBQ0Y7QUFuQ0Qsb0NBbUNDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSVF1ZXVlQWRhcHRlciB9IGZyb20gXCIuLi9pbnRlcmZhY2VzL0lRdWV1ZUFkYXB0ZXJcIjtcclxuaW1wb3J0IHsgUXVldWVDb25maWcgfSBmcm9tIFwiLi4vaW50ZXJmYWNlcy9JUXVldWVDb25maWdcIjtcclxuaW1wb3J0IHsgUmFiYml0TVFBZGFwdGVyIH0gZnJvbSBcIi4uL3F1ZXVlL2FkYXB0ZXJzL1JhYmJpdE1RQWRhcHRlclwiO1xyXG5pbXBvcnQgeyBTUVNBZGFwdGVyIH0gZnJvbSBcIi4uL3F1ZXVlL2FkYXB0ZXJzL1NRU0FkYXB0ZXJcIjtcclxuXHJcbmV4cG9ydCBjbGFzcyBRdWV1ZUZhY3Rvcnkge1xyXG5cclxuICBzdGF0aWMgY3JlYXRlKGNvbmZpZzogUXVldWVDb25maWcpOiBJUXVldWVBZGFwdGVyIHtcclxuICAgIHN3aXRjaCAoY29uZmlnLnR5cGUpIHtcclxuICAgICAgY2FzZSBcInJhYmJpdG1xXCI6XHJcbiAgICAgICAgcmV0dXJuIG5ldyBSYWJiaXRNUUFkYXB0ZXIoY29uZmlnKTtcclxuICAgICAgY2FzZSBcInNxc1wiOlxyXG4gICAgICAgIHJldHVybiBuZXcgU1FTQWRhcHRlcihjb25maWcpO1xyXG4gICAgICBkZWZhdWx0OlxyXG4gICAgICAgIHRocm93IG5ldyBFcnJvcihgVW5rbm93biBxdWV1ZSB0eXBlOiAkeyhjb25maWcgYXMgUXVldWVDb25maWcpLnR5cGV9YCk7XHJcbiAgICB9XHJcbiAgfVxyXG5cclxuICBzdGF0aWMgY3JlYXRlRnJvbUVudigpOiBJUXVldWVBZGFwdGVyIHtcclxuICAgIGNvbnN0IHR5cGUgPSBwcm9jZXNzLmVudi5RVUVVRV9UWVBFIHx8IFwicmFiYml0bXFcIjtcclxuXHJcbiAgICBpZiAodHlwZSA9PT0gXCJzcXNcIikge1xyXG4gICAgICByZXR1cm4gbmV3IFNRU0FkYXB0ZXIoe1xyXG4gICAgICAgIHR5cGU6IFwic3FzXCIsXHJcbiAgICAgICAgZW5kcG9pbnQ6IHByb2Nlc3MuZW52LlNRU19FTkRQT0lOVCxcclxuICAgICAgICByZWdpb246IHByb2Nlc3MuZW52LlNRU19SRUdJT04gfHwgXCJ1cy1lYXN0LTFcIixcclxuICAgICAgICBhY2Nlc3NLZXlJZDogcHJvY2Vzcy5lbnYuU1FTX0FDQ0VTU19LRVkgfHwgcHJvY2Vzcy5lbnYuQVdTX0FDQ0VTU19LRVlfSUQgfHwgXCJcIixcclxuICAgICAgICBzZWNyZXRBY2Nlc3NLZXk6IHByb2Nlc3MuZW52LlNRU19TRUNSRVRfS0VZIHx8IHByb2Nlc3MuZW52LkFXU19TRUNSRVRfQUNDRVNTX0tFWSB8fCBcIlwiLFxyXG4gICAgICB9KTtcclxuICAgIH1cclxuXHJcbiAgICByZXR1cm4gbmV3IFJhYmJpdE1RQWRhcHRlcih7XHJcbiAgICAgIHR5cGU6IFwicmFiYml0bXFcIixcclxuICAgICAgaG9zdDogcHJvY2Vzcy5lbnYuUkFCQklUTVFfSE9TVCB8fCBcImxvY2FsaG9zdFwiLFxyXG4gICAgICBwb3J0OiBwYXJzZUludChwcm9jZXNzLmVudi5SQUJCSVRNUV9QT1JUIHx8IFwiNTY3MlwiLCAxMCksXHJcbiAgICAgIHVzZXJuYW1lOiBwcm9jZXNzLmVudi5SQUJCSVRNUV9VU0VSIHx8IFwiZ3Vlc3RcIixcclxuICAgICAgcGFzc3dvcmQ6IHByb2Nlc3MuZW52LlJBQkJJVE1RX1BBU1NXT1JEIHx8IFwiZ3Vlc3RcIixcclxuICAgICAgdmhvc3Q6IHByb2Nlc3MuZW52LlJBQkJJVE1RX1ZIT1NUIHx8IFwiL1wiLFxyXG4gICAgfSk7XHJcbiAgfVxyXG59XHJcblxyXG4iXX0=

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+export * from "./interfaces/IQueueAdapter";
+export * from "./interfaces/IQueueConfig";
+export * from "./queue/adapters/RabbitMQAdapter";
+export * from "./queue/adapters/SQSAdapter";
+export * from "./factory/QueueFactory";
+export * from "./domain/BaseDomain";
+export * from "./domain/Transaction";
+export * from "./domain/RoutingAttempts";
+export * from "./utils/BaseError";
+export * from "./utils/NotFound";
+export * from "./utils/NotFoundKey";
+export * from "./utils/NotSupport";
+export * from "./utils/NotSupported";
+export * from "./utils/UnauthorizedAccess";

package/dist/index.js

@@ -0,0 +1,36 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Interfaces
+__exportStar(require("./interfaces/IQueueAdapter"), exports);
+__exportStar(require("./interfaces/IQueueConfig"), exports);
+// Adapters
+__exportStar(require("./queue/adapters/RabbitMQAdapter"), exports);
+__exportStar(require("./queue/adapters/SQSAdapter"), exports);
+// Factory
+__exportStar(require("./factory/QueueFactory"), exports);
+// Domain
+__exportStar(require("./domain/BaseDomain"), exports);
+__exportStar(require("./domain/Transaction"), exports);
+__exportStar(require("./domain/RoutingAttempts"), exports);
+// Utils/Errors
+__exportStar(require("./utils/BaseError"), exports);
+__exportStar(require("./utils/NotFound"), exports);
+__exportStar(require("./utils/NotFoundKey"), exports);
+__exportStar(require("./utils/NotSupport"), exports);
+__exportStar(require("./utils/NotSupported"), exports);
+__exportStar(require("./utils/UnauthorizedAccess"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zaGFyZWQvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLGFBQWE7QUFDYiw2REFBMkM7QUFDM0MsNERBQTBDO0FBRTFDLFdBQVc7QUFDWCxtRUFBaUQ7QUFDakQsOERBQTRDO0FBRTVDLFVBQVU7QUFDVix5REFBdUM7QUFFdkMsU0FBUztBQUNULHNEQUFvQztBQUNwQyx1REFBcUM7QUFDckMsMkRBQXlDO0FBRXpDLGVBQWU7QUFDZixvREFBa0M7QUFDbEMsbURBQWlDO0FBQ2pDLHNEQUFvQztBQUNwQyxxREFBbUM7QUFDbkMsdURBQXFDO0FBQ3JDLDZEQUEyQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIEludGVyZmFjZXNcclxuZXhwb3J0ICogZnJvbSBcIi4vaW50ZXJmYWNlcy9JUXVldWVBZGFwdGVyXCI7XHJcbmV4cG9ydCAqIGZyb20gXCIuL2ludGVyZmFjZXMvSVF1ZXVlQ29uZmlnXCI7XHJcblxyXG4vLyBBZGFwdGVyc1xyXG5leHBvcnQgKiBmcm9tIFwiLi9xdWV1ZS9hZGFwdGVycy9SYWJiaXRNUUFkYXB0ZXJcIjtcclxuZXhwb3J0ICogZnJvbSBcIi4vcXVldWUvYWRhcHRlcnMvU1FTQWRhcHRlclwiO1xyXG5cclxuLy8gRmFjdG9yeVxyXG5leHBvcnQgKiBmcm9tIFwiLi9mYWN0b3J5L1F1ZXVlRmFjdG9yeVwiO1xyXG5cclxuLy8gRG9tYWluXHJcbmV4cG9ydCAqIGZyb20gXCIuL2RvbWFpbi9CYXNlRG9tYWluXCI7XHJcbmV4cG9ydCAqIGZyb20gXCIuL2RvbWFpbi9UcmFuc2FjdGlvblwiO1xyXG5leHBvcnQgKiBmcm9tIFwiLi9kb21haW4vUm91dGluZ0F0dGVtcHRzXCI7XHJcblxyXG4vLyBVdGlscy9FcnJvcnNcclxuZXhwb3J0ICogZnJvbSBcIi4vdXRpbHMvQmFzZUVycm9yXCI7XHJcbmV4cG9ydCAqIGZyb20gXCIuL3V0aWxzL05vdEZvdW5kXCI7XHJcbmV4cG9ydCAqIGZyb20gXCIuL3V0aWxzL05vdEZvdW5kS2V5XCI7XHJcbmV4cG9ydCAqIGZyb20gXCIuL3V0aWxzL05vdFN1cHBvcnRcIjtcclxuZXhwb3J0ICogZnJvbSBcIi4vdXRpbHMvTm90U3VwcG9ydGVkXCI7XHJcbmV4cG9ydCAqIGZyb20gXCIuL3V0aWxzL1VuYXV0aG9yaXplZEFjY2Vzc1wiO1xyXG5cclxuIl19

package/dist/interfaces/IQueueAdapter.d.ts

@@ -0,0 +1,29 @@
+export interface QueueMessage<T = unknown> {
+    id: string;
+    body: T;
+    raw: unknown;
+    receivedAt: Date;
+}
+export interface PublishOptions {
+    delaySeconds?: number;
+    messageGroupId?: string;
+    deduplicationId?: string;
+}
+export interface ConsumeOptions {
+    prefetch?: number;
+    visibilityTimeout?: number;
+    waitTimeSeconds?: number;
+}
+export interface IQueueAdapter {
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    createQueue(queue: string): Promise<void>;
+    deleteQueue(queue: string): Promise<void>;
+    publish<T = unknown>(queue: string, message: T, options?: PublishOptions): Promise<string>;
+    publishBatch<T = unknown>(queue: string, messages: T[], options?: PublishOptions): Promise<string[]>;
+    consume<T = unknown>(queue: string, handler: (message: QueueMessage<T>) => Promise<void>, options?: ConsumeOptions): Promise<void>;
+    ack(message: QueueMessage): Promise<void>;
+    nack(message: QueueMessage, requeue?: boolean): Promise<void>;
+    getQueueLength(queue: string): Promise<number>;
+}

package/dist/interfaces/IQueueAdapter.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiSVF1ZXVlQWRhcHRlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NoYXJlZC9pbnRlcmZhY2VzL0lRdWV1ZUFkYXB0ZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBpbnRlcmZhY2UgUXVldWVNZXNzYWdlPFQgPSB1bmtub3duPiB7XHJcbiAgaWQ6IHN0cmluZztcclxuICBib2R5OiBUO1xyXG4gIHJhdzogdW5rbm93bjtcclxuICByZWNlaXZlZEF0OiBEYXRlO1xyXG59XHJcblxyXG5leHBvcnQgaW50ZXJmYWNlIFB1Ymxpc2hPcHRpb25zIHtcclxuICBkZWxheVNlY29uZHM/OiBudW1iZXI7XHJcbiAgbWVzc2FnZUdyb3VwSWQ/OiBzdHJpbmc7XHJcbiAgZGVkdXBsaWNhdGlvbklkPzogc3RyaW5nO1xyXG59XHJcblxyXG5leHBvcnQgaW50ZXJmYWNlIENvbnN1bWVPcHRpb25zIHtcclxuICBwcmVmZXRjaD86IG51bWJlcjtcclxuICB2aXNpYmlsaXR5VGltZW91dD86IG51bWJlcjtcclxuICB3YWl0VGltZVNlY29uZHM/OiBudW1iZXI7XHJcbn1cclxuXHJcbmV4cG9ydCBpbnRlcmZhY2UgSVF1ZXVlQWRhcHRlciB7XHJcbiAgY29ubmVjdCgpOiBQcm9taXNlPHZvaWQ+O1xyXG4gIGRpc2Nvbm5lY3QoKTogUHJvbWlzZTx2b2lkPjtcclxuICBpc0Nvbm5lY3RlZCgpOiBib29sZWFuO1xyXG5cclxuICBjcmVhdGVRdWV1ZShxdWV1ZTogc3RyaW5nKTogUHJvbWlzZTx2b2lkPjtcclxuICBkZWxldGVRdWV1ZShxdWV1ZTogc3RyaW5nKTogUHJvbWlzZTx2b2lkPjtcclxuXHJcbiAgcHVibGlzaDxUID0gdW5rbm93bj4ocXVldWU6IHN0cmluZywgbWVzc2FnZTogVCwgb3B0aW9ucz86IFB1Ymxpc2hPcHRpb25zKTogUHJvbWlzZTxzdHJpbmc+O1xyXG4gIHB1Ymxpc2hCYXRjaDxUID0gdW5rbm93bj4ocXVldWU6IHN0cmluZywgbWVzc2FnZXM6IFRbXSwgb3B0aW9ucz86IFB1Ymxpc2hPcHRpb25zKTogUHJvbWlzZTxzdHJpbmdbXT47XHJcblxyXG4gIGNvbnN1bWU8VCA9IHVua25vd24+KFxyXG4gICAgcXVldWU6IHN0cmluZyxcclxuICAgIGhhbmRsZXI6IChtZXNzYWdlOiBRdWV1ZU1lc3NhZ2U8VD4pID0+IFByb21pc2U8dm9pZD4sXHJcbiAgICBvcHRpb25zPzogQ29uc3VtZU9wdGlvbnNcclxuICApOiBQcm9taXNlPHZvaWQ+O1xyXG5cclxuICBhY2sobWVzc2FnZTogUXVldWVNZXNzYWdlKTogUHJvbWlzZTx2b2lkPjtcclxuICBuYWNrKG1lc3NhZ2U6IFF1ZXVlTWVzc2FnZSwgcmVxdWV1ZT86IGJvb2xlYW4pOiBQcm9taXNlPHZvaWQ+O1xyXG5cclxuICBnZXRRdWV1ZUxlbmd0aChxdWV1ZTogc3RyaW5nKTogUHJvbWlzZTxudW1iZXI+O1xyXG59XHJcblxyXG4iXX0=

package/dist/interfaces/IQueueConfig.d.ts

@@ -0,0 +1,17 @@
+export interface RabbitMQConfig {
+    type: "rabbitmq";
+    host: string;
+    port: number;
+    username: string;
+    password: string;
+    vhost?: string;
+    heartbeat?: number;
+}
+export interface SQSConfig {
+    type: "sqs";
+    endpoint?: string;
+    region: string;
+    accessKeyId: string;
+    secretAccessKey: string;
+}
+export type QueueConfig = RabbitMQConfig | SQSConfig;

package/dist/interfaces/IQueueConfig.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiSVF1ZXVlQ29uZmlnLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc2hhcmVkL2ludGVyZmFjZXMvSVF1ZXVlQ29uZmlnLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgaW50ZXJmYWNlIFJhYmJpdE1RQ29uZmlnIHtcclxuICB0eXBlOiBcInJhYmJpdG1xXCI7XHJcbiAgaG9zdDogc3RyaW5nO1xyXG4gIHBvcnQ6IG51bWJlcjtcclxuICB1c2VybmFtZTogc3RyaW5nO1xyXG4gIHBhc3N3b3JkOiBzdHJpbmc7XHJcbiAgdmhvc3Q/OiBzdHJpbmc7XHJcbiAgaGVhcnRiZWF0PzogbnVtYmVyO1xyXG59XHJcblxyXG5leHBvcnQgaW50ZXJmYWNlIFNRU0NvbmZpZyB7XHJcbiAgdHlwZTogXCJzcXNcIjtcclxuICBlbmRwb2ludD86IHN0cmluZztcclxuICByZWdpb246IHN0cmluZztcclxuICBhY2Nlc3NLZXlJZDogc3RyaW5nO1xyXG4gIHNlY3JldEFjY2Vzc0tleTogc3RyaW5nO1xyXG59XHJcblxyXG5leHBvcnQgdHlwZSBRdWV1ZUNvbmZpZyA9IFJhYmJpdE1RQ29uZmlnIHwgU1FTQ29uZmlnO1xyXG5cclxuIl19

package/dist/queue/adapters/RabbitMQAdapter.d.ts

@@ -0,0 +1,21 @@
+import { IQueueAdapter, QueueMessage, PublishOptions, ConsumeOptions } from "../../interfaces/IQueueAdapter";
+import { RabbitMQConfig } from "../../interfaces/IQueueConfig";
+export declare class RabbitMQAdapter implements IQueueAdapter {
+    private connection;
+    private channel;
+    private config;
+    constructor(config: RabbitMQConfig);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    createQueue(queue: string): Promise<void>;
+    deleteQueue(queue: string): Promise<void>;
+    publish<T = unknown>(queue: string, message: T, options?: PublishOptions): Promise<string>;
+    publishBatch<T = unknown>(queue: string, messages: T[], options?: PublishOptions): Promise<string[]>;
+    consume<T = unknown>(queue: string, handler: (message: QueueMessage<T>) => Promise<void>, options?: ConsumeOptions): Promise<void>;
+    ack(message: QueueMessage): Promise<void>;
+    nack(message: QueueMessage, requeue?: boolean): Promise<void>;
+    getQueueLength(queue: string): Promise<number>;
+    private ensureChannel;
+    private generateMessageId;
+}

package/dist/queue/adapters/RabbitMQAdapter.js

@@ -0,0 +1,115 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RabbitMQAdapter = void 0;
+const amqplib_1 = __importDefault(require("amqplib"));
+class RabbitMQAdapter {
+    constructor(config) {
+        this.connection = null;
+        this.channel = null;
+        this.config = config;
+    }
+    async connect() {
+        const { host, port, username, password, vhost = "/", heartbeat = 60 } = this.config;
+        const url = `amqp://${username}:${password}@${host}:${port}${vhost}?heartbeat=${heartbeat}`;
+        this.connection = await amqplib_1.default.connect(url);
+        this.channel = await this.connection.createChannel();
+        this.connection.on("error", (err) => {
+            console.error("[RabbitMQ] Connection error:", err.message);
+        });
+        this.connection.on("close", () => {
+            console.warn("[RabbitMQ] Connection closed");
+            this.connection = null;
+            this.channel = null;
+        });
+    }
+    async disconnect() {
+        if (this.channel) {
+            await this.channel.close();
+            this.channel = null;
+        }
+        if (this.connection) {
+            await this.connection.close();
+            this.connection = null;
+        }
+    }
+    isConnected() {
+        return this.connection !== null && this.channel !== null;
+    }
+    async createQueue(queue) {
+        this.ensureChannel();
+        await this.channel.assertQueue(queue, { durable: true });
+    }
+    async deleteQueue(queue) {
+        this.ensureChannel();
+        await this.channel.deleteQueue(queue);
+    }
+    async publish(queue, message, options) {
+        this.ensureChannel();
+        const messageId = this.generateMessageId();
+        const content = Buffer.from(JSON.stringify(message));
+        await this.channel.assertQueue(queue, { durable: true });
+        this.channel.sendToQueue(queue, content, {
+            persistent: true,
+            messageId,
+            timestamp: Date.now(),
+        });
+        return messageId;
+    }
+    async publishBatch(queue, messages, options) {
+        const ids = [];
+        for (const message of messages) {
+            const id = await this.publish(queue, message, options);
+            ids.push(id);
+        }
+        return ids;
+    }
+    async consume(queue, handler, options) {
+        this.ensureChannel();
+        if (options?.prefetch) {
+            await this.channel.prefetch(options.prefetch);
+        }
+        await this.channel.assertQueue(queue, { durable: true });
+        await this.channel.consume(queue, async (msg) => {
+            if (!msg)
+                return;
+            const queueMessage = {
+                id: msg.properties.messageId || this.generateMessageId(),
+                body: JSON.parse(msg.content.toString()),
+                raw: msg,
+                receivedAt: new Date(),
+            };
+            try {
+                await handler(queueMessage);
+            }
+            catch (error) {
+                console.error("[RabbitMQ] Error processing message:", error);
+            }
+        });
+    }
+    async ack(message) {
+        this.ensureChannel();
+        this.channel.ack(message.raw);
+    }
+    async nack(message, requeue = true) {
+        this.ensureChannel();
+        this.channel.nack(message.raw, false, requeue);
+    }
+    async getQueueLength(queue) {
+        this.ensureChannel();
+        const { messageCount } = await this.channel.assertQueue(queue, { durable: true });
+        return messageCount;
+    }
+    ensureChannel() {
+        if (!this.channel) {
+            throw new Error("[RabbitMQ] Not connected. Call connect() first.");
+        }
+    }
+    generateMessageId() {
+        return `${Date.now()}-${Math.random().toString(36).substring(2, 15)}`;
+    }
+}
+exports.RabbitMQAdapter = RabbitMQAdapter;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"RabbitMQAdapter.js","sourceRoot":"","sources":["../../../shared/queue/adapters/RabbitMQAdapter.ts"],"names":[],"mappings":"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","sourcesContent":["import amqp from \"amqplib\";\r\nimport { IQueueAdapter, QueueMessage, PublishOptions, ConsumeOptions } from \"../../interfaces/IQueueAdapter\";\r\nimport { RabbitMQConfig } from \"../../interfaces/IQueueConfig\";\r\n\r\ntype AmqpConnection = Awaited<ReturnType<typeof amqp.connect>>;\r\ntype AmqpChannel = Awaited<ReturnType<AmqpConnection[\"createChannel\"]>>;\r\n\r\nexport class RabbitMQAdapter implements IQueueAdapter {\r\n  private connection: AmqpConnection | null = null;\r\n  private channel: AmqpChannel | null = null;\r\n  private config: RabbitMQConfig;\r\n\r\n  constructor(config: RabbitMQConfig) {\r\n    this.config = config;\r\n  }\r\n\r\n  async connect(): Promise<void> {\r\n    const { host, port, username, password, vhost = \"/\", heartbeat = 60 } = this.config;\r\n    const url = `amqp://${username}:${password}@${host}:${port}${vhost}?heartbeat=${heartbeat}`;\r\n\r\n    this.connection = await amqp.connect(url);\r\n    this.channel = await this.connection.createChannel();\r\n\r\n    this.connection.on(\"error\", (err) => {\r\n      console.error(\"[RabbitMQ] Connection error:\", err.message);\r\n    });\r\n\r\n    this.connection.on(\"close\", () => {\r\n      console.warn(\"[RabbitMQ] Connection closed\");\r\n      this.connection = null;\r\n      this.channel = null;\r\n    });\r\n  }\r\n\r\n  async disconnect(): Promise<void> {\r\n    if (this.channel) {\r\n      await this.channel.close();\r\n      this.channel = null;\r\n    }\r\n    if (this.connection) {\r\n      await this.connection.close();\r\n      this.connection = null;\r\n    }\r\n  }\r\n\r\n  isConnected(): boolean {\r\n    return this.connection !== null && this.channel !== null;\r\n  }\r\n\r\n  async createQueue(queue: string): Promise<void> {\r\n    this.ensureChannel();\r\n    await this.channel!.assertQueue(queue, { durable: true });\r\n  }\r\n\r\n  async deleteQueue(queue: string): Promise<void> {\r\n    this.ensureChannel();\r\n    await this.channel!.deleteQueue(queue);\r\n  }\r\n\r\n  async publish<T = unknown>(queue: string, message: T, options?: PublishOptions): Promise<string> {\r\n    this.ensureChannel();\r\n\r\n    const messageId = this.generateMessageId();\r\n    const content = Buffer.from(JSON.stringify(message));\r\n\r\n    await this.channel!.assertQueue(queue, { durable: true });\r\n\r\n    this.channel!.sendToQueue(queue, content, {\r\n      persistent: true,\r\n      messageId,\r\n      timestamp: Date.now(),\r\n    });\r\n\r\n    return messageId;\r\n  }\r\n\r\n  async publishBatch<T = unknown>(queue: string, messages: T[], options?: PublishOptions): Promise<string[]> {\r\n    const ids: string[] = [];\r\n    for (const message of messages) {\r\n      const id = await this.publish(queue, message, options);\r\n      ids.push(id);\r\n    }\r\n    return ids;\r\n  }\r\n\r\n  async consume<T = unknown>(\r\n    queue: string,\r\n    handler: (message: QueueMessage<T>) => Promise<void>,\r\n    options?: ConsumeOptions\r\n  ): Promise<void> {\r\n    this.ensureChannel();\r\n\r\n    if (options?.prefetch) {\r\n      await this.channel!.prefetch(options.prefetch);\r\n    }\r\n\r\n    await this.channel!.assertQueue(queue, { durable: true });\r\n\r\n    await this.channel!.consume(queue, async (msg) => {\r\n      if (!msg) return;\r\n\r\n      const queueMessage: QueueMessage<T> = {\r\n        id: msg.properties.messageId || this.generateMessageId(),\r\n        body: JSON.parse(msg.content.toString()) as T,\r\n        raw: msg,\r\n        receivedAt: new Date(),\r\n      };\r\n\r\n      try {\r\n        await handler(queueMessage);\r\n      } catch (error) {\r\n        console.error(\"[RabbitMQ] Error processing message:\", error);\r\n      }\r\n    });\r\n  }\r\n\r\n  async ack(message: QueueMessage): Promise<void> {\r\n    this.ensureChannel();\r\n    this.channel!.ack(message.raw as amqp.Message);\r\n  }\r\n\r\n  async nack(message: QueueMessage, requeue = true): Promise<void> {\r\n    this.ensureChannel();\r\n    this.channel!.nack(message.raw as amqp.Message, false, requeue);\r\n  }\r\n\r\n  async getQueueLength(queue: string): Promise<number> {\r\n    this.ensureChannel();\r\n    const { messageCount } = await this.channel!.assertQueue(queue, { durable: true });\r\n    return messageCount;\r\n  }\r\n\r\n  private ensureChannel(): void {\r\n    if (!this.channel) {\r\n      throw new Error(\"[RabbitMQ] Not connected. Call connect() first.\");\r\n    }\r\n  }\r\n\r\n  private generateMessageId(): string {\r\n    return `${Date.now()}-${Math.random().toString(36).substring(2, 15)}`;\r\n  }\r\n}\r\n\r\n"]}

package/dist/queue/adapters/SQSAdapter.d.ts

@@ -0,0 +1,25 @@
+import { IQueueAdapter, QueueMessage, PublishOptions, ConsumeOptions } from "../../interfaces/IQueueAdapter";
+import { SQSConfig } from "../../interfaces/IQueueConfig";
+export declare class SQSAdapter implements IQueueAdapter {
+    private client;
+    private config;
+    private queueUrls;
+    private consuming;
+    constructor(config: SQSConfig);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    createQueue(queue: string): Promise<void>;
+    deleteQueue(queue: string): Promise<void>;
+    publish<T = unknown>(queue: string, message: T, options?: PublishOptions): Promise<string>;
+    publishBatch<T = unknown>(queue: string, messages: T[], options?: PublishOptions): Promise<string[]>;
+    consume<T = unknown>(queue: string, handler: (message: QueueMessage<T>) => Promise<void>, options?: ConsumeOptions): Promise<void>;
+    ack(message: QueueMessage): Promise<void>;
+    nack(message: QueueMessage, _requeue?: boolean): Promise<void>;
+    getQueueLength(queue: string): Promise<number>;
+    stopConsuming(queue: string): void;
+    private getQueueUrl;
+    private ensureClient;
+    private generateMessageId;
+    private sleep;
+}

package/dist/queue/adapters/SQSAdapter.js

@@ -0,0 +1,187 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SQSAdapter = void 0;
+const client_sqs_1 = require("@aws-sdk/client-sqs");
+class SQSAdapter {
+    constructor(config) {
+        this.client = null;
+        this.queueUrls = new Map();
+        this.consuming = new Map();
+        this.config = config;
+    }
+    async connect() {
+        this.client = new client_sqs_1.SQSClient({
+            region: this.config.region,
+            endpoint: this.config.endpoint,
+            credentials: {
+                accessKeyId: this.config.accessKeyId,
+                secretAccessKey: this.config.secretAccessKey,
+            },
+        });
+    }
+    async disconnect() {
+        this.consuming.clear();
+        this.queueUrls.clear();
+        if (this.client) {
+            this.client.destroy();
+            this.client = null;
+        }
+    }
+    isConnected() {
+        return this.client !== null;
+    }
+    async createQueue(queue) {
+        this.ensureClient();
+        const command = new client_sqs_1.CreateQueueCommand({
+            QueueName: queue,
+            Attributes: {
+                VisibilityTimeout: "30",
+                MessageRetentionPeriod: "345600",
+            },
+        });
+        const response = await this.client.send(command);
+        if (response.QueueUrl) {
+            this.queueUrls.set(queue, response.QueueUrl);
+        }
+    }
+    async deleteQueue(queue) {
+        this.ensureClient();
+        const queueUrl = await this.getQueueUrl(queue);
+        const command = new client_sqs_1.DeleteQueueCommand({ QueueUrl: queueUrl });
+        await this.client.send(command);
+        this.queueUrls.delete(queue);
+    }
+    async publish(queue, message, options) {
+        this.ensureClient();
+        const queueUrl = await this.getQueueUrl(queue);
+        const messageId = this.generateMessageId();
+        const command = new client_sqs_1.SendMessageCommand({
+            QueueUrl: queueUrl,
+            MessageBody: JSON.stringify(message),
+            DelaySeconds: options?.delaySeconds,
+            MessageGroupId: options?.messageGroupId,
+            MessageDeduplicationId: options?.deduplicationId || messageId,
+        });
+        const response = await this.client.send(command);
+        return response.MessageId || messageId;
+    }
+    async publishBatch(queue, messages, options) {
+        this.ensureClient();
+        const queueUrl = await this.getQueueUrl(queue);
+        const entries = messages.map((message, index) => ({
+            Id: `${index}`,
+            MessageBody: JSON.stringify(message),
+            DelaySeconds: options?.delaySeconds,
+            MessageGroupId: options?.messageGroupId,
+            MessageDeduplicationId: options?.deduplicationId || this.generateMessageId(),
+        }));
+        const command = new client_sqs_1.SendMessageBatchCommand({
+            QueueUrl: queueUrl,
+            Entries: entries,
+        });
+        const response = await this.client.send(command);
+        return response.Successful?.map((s) => s.MessageId || s.Id || "") || [];
+    }
+    async consume(queue, handler, options) {
+        this.ensureClient();
+        const queueUrl = await this.getQueueUrl(queue);
+        this.consuming.set(queue, true);
+        const poll = async () => {
+            while (this.consuming.get(queue)) {
+                try {
+                    const command = new client_sqs_1.ReceiveMessageCommand({
+                        QueueUrl: queueUrl,
+                        MaxNumberOfMessages: options?.prefetch || 10,
+                        WaitTimeSeconds: options?.waitTimeSeconds || 20,
+                        VisibilityTimeout: options?.visibilityTimeout || 30,
+                        AttributeNames: ["All"],
+                        MessageAttributeNames: ["All"],
+                    });
+                    const response = await this.client.send(command);
+                    if (response.Messages && response.Messages.length > 0) {
+                        for (const msg of response.Messages) {
+                            const queueMessage = {
+                                id: msg.MessageId || this.generateMessageId(),
+                                body: JSON.parse(msg.Body || "{}"),
+                                raw: { message: msg, queueUrl },
+                                receivedAt: new Date(),
+                            };
+                            try {
+                                await handler(queueMessage);
+                            }
+                            catch (error) {
+                                console.error("[SQS] Error processing message:", error);
+                            }
+                        }
+                    }
+                }
+                catch (error) {
+                    console.error("[SQS] Polling error:", error);
+                    await this.sleep(5000);
+                }
+            }
+        };
+        poll();
+    }
+    async ack(message) {
+        this.ensureClient();
+        const { message: msg, queueUrl } = message.raw;
+        if (!msg.ReceiptHandle) {
+            throw new Error("[SQS] Message has no ReceiptHandle");
+        }
+        const command = new client_sqs_1.DeleteMessageCommand({
+            QueueUrl: queueUrl,
+            ReceiptHandle: msg.ReceiptHandle,
+        });
+        await this.client.send(command);
+    }
+    async nack(message, _requeue = true) {
+        // SQS automaticamente retorna a mensagem para a fila após o visibility timeout
+        // Não é necessário fazer nada aqui
+        console.warn("[SQS] nack called - message will be redelivered after visibility timeout");
+    }
+    async getQueueLength(queue) {
+        this.ensureClient();
+        const queueUrl = await this.getQueueUrl(queue);
+        const command = new client_sqs_1.GetQueueAttributesCommand({
+            QueueUrl: queueUrl,
+            AttributeNames: ["ApproximateNumberOfMessages"],
+        });
+        const response = await this.client.send(command);
+        return parseInt(response.Attributes?.ApproximateNumberOfMessages || "0", 10);
+    }
+    stopConsuming(queue) {
+        this.consuming.set(queue, false);
+    }
+    async getQueueUrl(queue) {
+        if (this.queueUrls.has(queue)) {
+            return this.queueUrls.get(queue);
+        }
+        try {
+            const command = new client_sqs_1.GetQueueUrlCommand({ QueueName: queue });
+            const response = await this.client.send(command);
+            if (response.QueueUrl) {
+                this.queueUrls.set(queue, response.QueueUrl);
+                return response.QueueUrl;
+            }
+        }
+        catch {
+            await this.createQueue(queue);
+            return this.queueUrls.get(queue);
+        }
+        throw new Error(`[SQS] Could not get URL for queue: ${queue}`);
+    }
+    ensureClient() {
+        if (!this.client) {
+            throw new Error("[SQS] Not connected. Call connect() first.");
+        }
+    }
+    generateMessageId() {
+        return `${Date.now()}-${Math.random().toString(36).substring(2, 15)}`;
+    }
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+}
+exports.SQSAdapter = SQSAdapter;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SQSAdapter.js","sourceRoot":"","sources":["../../../shared/queue/adapters/SQSAdapter.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  SQSClient,\r\n  SendMessageCommand,\r\n  SendMessageBatchCommand,\r\n  ReceiveMessageCommand,\r\n  DeleteMessageCommand,\r\n  CreateQueueCommand,\r\n  DeleteQueueCommand,\r\n  GetQueueAttributesCommand,\r\n  GetQueueUrlCommand,\r\n  Message,\r\n} from \"@aws-sdk/client-sqs\";\r\nimport { IQueueAdapter, QueueMessage, PublishOptions, ConsumeOptions } from \"../../interfaces/IQueueAdapter\";\r\nimport { SQSConfig } from \"../../interfaces/IQueueConfig\";\r\n\r\nexport class SQSAdapter implements IQueueAdapter {\r\n  private client: SQSClient | null = null;\r\n  private config: SQSConfig;\r\n  private queueUrls: Map<string, string> = new Map();\r\n  private consuming: Map<string, boolean> = new Map();\r\n\r\n  constructor(config: SQSConfig) {\r\n    this.config = config;\r\n  }\r\n\r\n  async connect(): Promise<void> {\r\n    this.client = new SQSClient({\r\n      region: this.config.region,\r\n      endpoint: this.config.endpoint,\r\n      credentials: {\r\n        accessKeyId: this.config.accessKeyId,\r\n        secretAccessKey: this.config.secretAccessKey,\r\n      },\r\n    });\r\n  }\r\n\r\n  async disconnect(): Promise<void> {\r\n    this.consuming.clear();\r\n    this.queueUrls.clear();\r\n    if (this.client) {\r\n      this.client.destroy();\r\n      this.client = null;\r\n    }\r\n  }\r\n\r\n  isConnected(): boolean {\r\n    return this.client !== null;\r\n  }\r\n\r\n  async createQueue(queue: string): Promise<void> {\r\n    this.ensureClient();\r\n\r\n    const command = new CreateQueueCommand({\r\n      QueueName: queue,\r\n      Attributes: {\r\n        VisibilityTimeout: \"30\",\r\n        MessageRetentionPeriod: \"345600\",\r\n      },\r\n    });\r\n\r\n    const response = await this.client!.send(command);\r\n    if (response.QueueUrl) {\r\n      this.queueUrls.set(queue, response.QueueUrl);\r\n    }\r\n  }\r\n\r\n  async deleteQueue(queue: string): Promise<void> {\r\n    this.ensureClient();\r\n    const queueUrl = await this.getQueueUrl(queue);\r\n\r\n    const command = new DeleteQueueCommand({ QueueUrl: queueUrl });\r\n    await this.client!.send(command);\r\n    this.queueUrls.delete(queue);\r\n  }\r\n\r\n  async publish<T = unknown>(queue: string, message: T, options?: PublishOptions): Promise<string> {\r\n    this.ensureClient();\r\n    const queueUrl = await this.getQueueUrl(queue);\r\n\r\n    const messageId = this.generateMessageId();\r\n\r\n    const command = new SendMessageCommand({\r\n      QueueUrl: queueUrl,\r\n      MessageBody: JSON.stringify(message),\r\n      DelaySeconds: options?.delaySeconds,\r\n      MessageGroupId: options?.messageGroupId,\r\n      MessageDeduplicationId: options?.deduplicationId || messageId,\r\n    });\r\n\r\n    const response = await this.client!.send(command);\r\n    return response.MessageId || messageId;\r\n  }\r\n\r\n  async publishBatch<T = unknown>(queue: string, messages: T[], options?: PublishOptions): Promise<string[]> {\r\n    this.ensureClient();\r\n    const queueUrl = await this.getQueueUrl(queue);\r\n\r\n    const entries = messages.map((message, index) => ({\r\n      Id: `${index}`,\r\n      MessageBody: JSON.stringify(message),\r\n      DelaySeconds: options?.delaySeconds,\r\n      MessageGroupId: options?.messageGroupId,\r\n      MessageDeduplicationId: options?.deduplicationId || this.generateMessageId(),\r\n    }));\r\n\r\n    const command = new SendMessageBatchCommand({\r\n      QueueUrl: queueUrl,\r\n      Entries: entries,\r\n    });\r\n\r\n    const response = await this.client!.send(command);\r\n    return response.Successful?.map((s) => s.MessageId || s.Id || \"\") || [];\r\n  }\r\n\r\n  async consume<T = unknown>(\r\n    queue: string,\r\n    handler: (message: QueueMessage<T>) => Promise<void>,\r\n    options?: ConsumeOptions\r\n  ): Promise<void> {\r\n    this.ensureClient();\r\n    const queueUrl = await this.getQueueUrl(queue);\r\n\r\n    this.consuming.set(queue, true);\r\n\r\n    const poll = async () => {\r\n      while (this.consuming.get(queue)) {\r\n        try {\r\n          const command = new ReceiveMessageCommand({\r\n            QueueUrl: queueUrl,\r\n            MaxNumberOfMessages: options?.prefetch || 10,\r\n            WaitTimeSeconds: options?.waitTimeSeconds || 20,\r\n            VisibilityTimeout: options?.visibilityTimeout || 30,\r\n            AttributeNames: [\"All\"],\r\n            MessageAttributeNames: [\"All\"],\r\n          });\r\n\r\n          const response = await this.client!.send(command);\r\n\r\n          if (response.Messages && response.Messages.length > 0) {\r\n            for (const msg of response.Messages) {\r\n              const queueMessage: QueueMessage<T> = {\r\n                id: msg.MessageId || this.generateMessageId(),\r\n                body: JSON.parse(msg.Body || \"{}\") as T,\r\n                raw: { message: msg, queueUrl },\r\n                receivedAt: new Date(),\r\n              };\r\n\r\n              try {\r\n                await handler(queueMessage);\r\n              } catch (error) {\r\n                console.error(\"[SQS] Error processing message:\", error);\r\n              }\r\n            }\r\n          }\r\n        } catch (error) {\r\n          console.error(\"[SQS] Polling error:\", error);\r\n          await this.sleep(5000);\r\n        }\r\n      }\r\n    };\r\n\r\n    poll();\r\n  }\r\n\r\n  async ack(message: QueueMessage): Promise<void> {\r\n    this.ensureClient();\r\n    const { message: msg, queueUrl } = message.raw as { message: Message; queueUrl: string };\r\n\r\n    if (!msg.ReceiptHandle) {\r\n      throw new Error(\"[SQS] Message has no ReceiptHandle\");\r\n    }\r\n\r\n    const command = new DeleteMessageCommand({\r\n      QueueUrl: queueUrl,\r\n      ReceiptHandle: msg.ReceiptHandle,\r\n    });\r\n\r\n    await this.client!.send(command);\r\n  }\r\n\r\n  async nack(message: QueueMessage, _requeue = true): Promise<void> {\r\n    // SQS automaticamente retorna a mensagem para a fila após o visibility timeout\r\n    // Não é necessário fazer nada aqui\r\n    console.warn(\"[SQS] nack called - message will be redelivered after visibility timeout\");\r\n  }\r\n\r\n  async getQueueLength(queue: string): Promise<number> {\r\n    this.ensureClient();\r\n    const queueUrl = await this.getQueueUrl(queue);\r\n\r\n    const command = new GetQueueAttributesCommand({\r\n      QueueUrl: queueUrl,\r\n      AttributeNames: [\"ApproximateNumberOfMessages\"],\r\n    });\r\n\r\n    const response = await this.client!.send(command);\r\n    return parseInt(response.Attributes?.ApproximateNumberOfMessages || \"0\", 10);\r\n  }\r\n\r\n  stopConsuming(queue: string): void {\r\n    this.consuming.set(queue, false);\r\n  }\r\n\r\n  private async getQueueUrl(queue: string): Promise<string> {\r\n    if (this.queueUrls.has(queue)) {\r\n      return this.queueUrls.get(queue)!;\r\n    }\r\n\r\n    try {\r\n      const command = new GetQueueUrlCommand({ QueueName: queue });\r\n      const response = await this.client!.send(command);\r\n\r\n      if (response.QueueUrl) {\r\n        this.queueUrls.set(queue, response.QueueUrl);\r\n        return response.QueueUrl;\r\n      }\r\n    } catch {\r\n      await this.createQueue(queue);\r\n      return this.queueUrls.get(queue)!;\r\n    }\r\n\r\n    throw new Error(`[SQS] Could not get URL for queue: ${queue}`);\r\n  }\r\n\r\n  private ensureClient(): void {\r\n    if (!this.client) {\r\n      throw new Error(\"[SQS] Not connected. Call connect() first.\");\r\n    }\r\n  }\r\n\r\n  private generateMessageId(): string {\r\n    return `${Date.now()}-${Math.random().toString(36).substring(2, 15)}`;\r\n  }\r\n\r\n  private sleep(ms: number): Promise<void> {\r\n    return new Promise((resolve) => setTimeout(resolve, ms));\r\n  }\r\n}\r\n\r\n"]}

package/dist/utils/BaseError.d.ts

@@ -0,0 +1,4 @@
+export declare class BaseError extends Error {
+    statusCode: number;
+    constructor(message: string, statusCode?: number);
+}

package/dist/utils/BaseError.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseError = void 0;
+class BaseError extends Error {
+    constructor(message, statusCode = 500) {
+        super(message);
+        this.statusCode = statusCode;
+        this.name = this.constructor.name;
+        Error.captureStackTrace(this, this.constructor);
+    }
+}
+exports.BaseError = BaseError;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQmFzZUVycm9yLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc2hhcmVkL3V0aWxzL0Jhc2VFcnJvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSxNQUFhLFNBQVUsU0FBUSxLQUFLO0lBR2xDLFlBQVksT0FBZSxFQUFFLGFBQXFCLEdBQUc7UUFDbkQsS0FBSyxDQUFDLE9BQU8sQ0FBQyxDQUFDO1FBQ2YsSUFBSSxDQUFDLFVBQVUsR0FBRyxVQUFVLENBQUM7UUFDN0IsSUFBSSxDQUFDLElBQUksR0FBRyxJQUFJLENBQUMsV0FBVyxDQUFDLElBQUksQ0FBQztRQUNsQyxLQUFLLENBQUMsaUJBQWlCLENBQUMsSUFBSSxFQUFFLElBQUksQ0FBQyxXQUFXLENBQUMsQ0FBQztJQUNsRCxDQUFDO0NBQ0Y7QUFURCw4QkFTQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBjbGFzcyBCYXNlRXJyb3IgZXh0ZW5kcyBFcnJvciB7XHJcbiAgc3RhdHVzQ29kZTogbnVtYmVyO1xyXG5cclxuICBjb25zdHJ1Y3RvcihtZXNzYWdlOiBzdHJpbmcsIHN0YXR1c0NvZGU6IG51bWJlciA9IDUwMCkge1xyXG4gICAgc3VwZXIobWVzc2FnZSk7XHJcbiAgICB0aGlzLnN0YXR1c0NvZGUgPSBzdGF0dXNDb2RlO1xyXG4gICAgdGhpcy5uYW1lID0gdGhpcy5jb25zdHJ1Y3Rvci5uYW1lO1xyXG4gICAgRXJyb3IuY2FwdHVyZVN0YWNrVHJhY2UodGhpcywgdGhpcy5jb25zdHJ1Y3Rvcik7XHJcbiAgfVxyXG59XHJcbiJdfQ==

package/dist/utils/NotFound.d.ts

@@ -0,0 +1,4 @@
+import { BaseError } from "./BaseError";
+export declare class NotFound extends BaseError {
+    constructor(message: string, statusCode?: number);
+}

package/dist/utils/NotFound.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotFound = void 0;
+const BaseError_1 = require("./BaseError");
+class NotFound extends BaseError_1.BaseError {
+    constructor(message, statusCode = 404) {
+        super(`Not found: ${message}`, statusCode);
+        this.name = this.constructor.name;
+        Error.captureStackTrace(this, this.constructor);
+    }
+}
+exports.NotFound = NotFound;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiTm90Rm91bmQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zaGFyZWQvdXRpbHMvTm90Rm91bmQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsMkNBQXdDO0FBRXhDLE1BQWEsUUFBUyxTQUFRLHFCQUFTO0lBQ3JDLFlBQVksT0FBZSxFQUFFLGFBQXFCLEdBQUc7UUFDbkQsS0FBSyxDQUFDLGNBQWMsT0FBTyxFQUFFLEVBQUUsVUFBVSxDQUFDLENBQUM7UUFDM0MsSUFBSSxDQUFDLElBQUksR0FBRyxJQUFJLENBQUMsV0FBVyxDQUFDLElBQUksQ0FBQztRQUNsQyxLQUFLLENBQUMsaUJBQWlCLENBQUMsSUFBSSxFQUFFLElBQUksQ0FBQyxXQUFXLENBQUMsQ0FBQztJQUNsRCxDQUFDO0NBQ0Y7QUFORCw0QkFNQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEJhc2VFcnJvciB9IGZyb20gXCIuL0Jhc2VFcnJvclwiO1xyXG5cclxuZXhwb3J0IGNsYXNzIE5vdEZvdW5kIGV4dGVuZHMgQmFzZUVycm9yIHtcclxuICBjb25zdHJ1Y3RvcihtZXNzYWdlOiBzdHJpbmcsIHN0YXR1c0NvZGU6IG51bWJlciA9IDQwNCkge1xyXG4gICAgc3VwZXIoYE5vdCBmb3VuZDogJHttZXNzYWdlfWAsIHN0YXR1c0NvZGUpO1xyXG4gICAgdGhpcy5uYW1lID0gdGhpcy5jb25zdHJ1Y3Rvci5uYW1lO1xyXG4gICAgRXJyb3IuY2FwdHVyZVN0YWNrVHJhY2UodGhpcywgdGhpcy5jb25zdHJ1Y3Rvcik7XHJcbiAgfVxyXG59Il19

package/dist/utils/NotFoundKey.d.ts

@@ -0,0 +1,4 @@
+import { BaseError } from "./BaseError";
+export declare class NotFoundKey extends BaseError {
+    constructor(provider: string, statusCode?: number);
+}

package/dist/utils/NotFoundKey.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotFoundKey = void 0;
+const BaseError_1 = require("./BaseError");
+class NotFoundKey extends BaseError_1.BaseError {
+    constructor(provider, statusCode = 400) {
+        super(`Key not found for provider: ${provider}`, statusCode);
+        this.name = this.constructor.name;
+        Error.captureStackTrace(this, this.constructor);
+    }
+}
+exports.NotFoundKey = NotFoundKey;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiTm90Rm91bmRLZXkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zaGFyZWQvdXRpbHMvTm90Rm91bmRLZXkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsMkNBQXdDO0FBRXhDLE1BQWEsV0FBWSxTQUFRLHFCQUFTO0lBQ3hDLFlBQVksUUFBZ0IsRUFBRSxhQUFxQixHQUFHO1FBQ3BELEtBQUssQ0FBQywrQkFBK0IsUUFBUSxFQUFFLEVBQUUsVUFBVSxDQUFDLENBQUM7UUFDN0QsSUFBSSxDQUFDLElBQUksR0FBRyxJQUFJLENBQUMsV0FBVyxDQUFDLElBQUksQ0FBQztRQUNsQyxLQUFLLENBQUMsaUJBQWlCLENBQUMsSUFBSSxFQUFFLElBQUksQ0FBQyxXQUFXLENBQUMsQ0FBQztJQUNsRCxDQUFDO0NBQ0Y7QUFORCxrQ0FNQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEJhc2VFcnJvciB9IGZyb20gXCIuL0Jhc2VFcnJvclwiO1xyXG5cclxuZXhwb3J0IGNsYXNzIE5vdEZvdW5kS2V5IGV4dGVuZHMgQmFzZUVycm9yIHtcclxuICBjb25zdHJ1Y3Rvcihwcm92aWRlcjogc3RyaW5nLCBzdGF0dXNDb2RlOiBudW1iZXIgPSA0MDApIHtcclxuICAgIHN1cGVyKGBLZXkgbm90IGZvdW5kIGZvciBwcm92aWRlcjogJHtwcm92aWRlcn1gLCBzdGF0dXNDb2RlKTtcclxuICAgIHRoaXMubmFtZSA9IHRoaXMuY29uc3RydWN0b3IubmFtZTtcclxuICAgIEVycm9yLmNhcHR1cmVTdGFja1RyYWNlKHRoaXMsIHRoaXMuY29uc3RydWN0b3IpO1xyXG4gIH1cclxufSJdfQ==

package/dist/utils/NotSupport.d.ts

@@ -0,0 +1,4 @@
+import { BaseError } from "./BaseError";
+export declare class NotSupport extends BaseError {
+    constructor(message: string, statusCode?: number);
+}

package/dist/utils/NotSupport.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotSupport = void 0;
+const BaseError_1 = require("./BaseError");
+class NotSupport extends BaseError_1.BaseError {
+    constructor(message, statusCode = 400) {
+        super(message, statusCode);
+        this.name = this.constructor.name;
+        Error.captureStackTrace(this, this.constructor);
+    }
+}
+exports.NotSupport = NotSupport;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiTm90U3VwcG9ydC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NoYXJlZC91dGlscy9Ob3RTdXBwb3J0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLDJDQUF3QztBQUV4QyxNQUFhLFVBQVcsU0FBUSxxQkFBUztJQUN2QyxZQUFZLE9BQWUsRUFBRSxhQUFxQixHQUFHO1FBQ25ELEtBQUssQ0FBQyxPQUFPLEVBQUUsVUFBVSxDQUFDLENBQUM7UUFDM0IsSUFBSSxDQUFDLElBQUksR0FBRyxJQUFJLENBQUMsV0FBVyxDQUFDLElBQUksQ0FBQztRQUNsQyxLQUFLLENBQUMsaUJBQWlCLENBQUMsSUFBSSxFQUFFLElBQUksQ0FBQyxXQUFXLENBQUMsQ0FBQztJQUNsRCxDQUFDO0NBQ0Y7QUFORCxnQ0FNQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEJhc2VFcnJvciB9IGZyb20gXCIuL0Jhc2VFcnJvclwiO1xyXG5cclxuZXhwb3J0IGNsYXNzIE5vdFN1cHBvcnQgZXh0ZW5kcyBCYXNlRXJyb3Ige1xyXG4gIGNvbnN0cnVjdG9yKG1lc3NhZ2U6IHN0cmluZywgc3RhdHVzQ29kZTogbnVtYmVyID0gNDAwKSB7XHJcbiAgICBzdXBlcihtZXNzYWdlLCBzdGF0dXNDb2RlKTtcclxuICAgIHRoaXMubmFtZSA9IHRoaXMuY29uc3RydWN0b3IubmFtZTtcclxuICAgIEVycm9yLmNhcHR1cmVTdGFja1RyYWNlKHRoaXMsIHRoaXMuY29uc3RydWN0b3IpO1xyXG4gIH1cclxufVxyXG5cclxuIl19

package/dist/utils/NotSupported.d.ts

@@ -0,0 +1,4 @@
+import { BaseError } from "./BaseError";
+export declare class NotSupported extends BaseError {
+    constructor(message: string, statusCode?: number);
+}

package/dist/utils/NotSupported.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotSupported = void 0;
+const BaseError_1 = require("./BaseError");
+class NotSupported extends BaseError_1.BaseError {
+    constructor(message, statusCode = 400) {
+        super(message, statusCode);
+        this.name = this.constructor.name;
+        Error.captureStackTrace(this, this.constructor);
+    }
+}
+exports.NotSupported = NotSupported;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiTm90U3VwcG9ydGVkLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc2hhcmVkL3V0aWxzL05vdFN1cHBvcnRlZC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSwyQ0FBd0M7QUFFeEMsTUFBYSxZQUFhLFNBQVEscUJBQVM7SUFDekMsWUFBWSxPQUFlLEVBQUUsYUFBcUIsR0FBRztRQUNuRCxLQUFLLENBQUMsT0FBTyxFQUFFLFVBQVUsQ0FBQyxDQUFDO1FBQzNCLElBQUksQ0FBQyxJQUFJLEdBQUcsSUFBSSxDQUFDLFdBQVcsQ0FBQyxJQUFJLENBQUM7UUFDbEMsS0FBSyxDQUFDLGlCQUFpQixDQUFDLElBQUksRUFBRSxJQUFJLENBQUMsV0FBVyxDQUFDLENBQUM7SUFDbEQsQ0FBQztDQUNGO0FBTkQsb0NBTUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBCYXNlRXJyb3IgfSBmcm9tIFwiLi9CYXNlRXJyb3JcIjtcclxuXHJcbmV4cG9ydCBjbGFzcyBOb3RTdXBwb3J0ZWQgZXh0ZW5kcyBCYXNlRXJyb3Ige1xyXG4gIGNvbnN0cnVjdG9yKG1lc3NhZ2U6IHN0cmluZywgc3RhdHVzQ29kZTogbnVtYmVyID0gNDAwKSB7XHJcbiAgICBzdXBlcihtZXNzYWdlLCBzdGF0dXNDb2RlKTtcclxuICAgIHRoaXMubmFtZSA9IHRoaXMuY29uc3RydWN0b3IubmFtZTtcclxuICAgIEVycm9yLmNhcHR1cmVTdGFja1RyYWNlKHRoaXMsIHRoaXMuY29uc3RydWN0b3IpO1xyXG4gIH1cclxufVxyXG5cclxuIl19

package/dist/utils/UnauthorizedAccess.d.ts

@@ -0,0 +1,4 @@
+import { BaseError } from "./BaseError";
+export declare class UnauthorizedAccess extends BaseError {
+    constructor(provider: string, statusCode?: number);
+}

package/dist/utils/UnauthorizedAccess.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnauthorizedAccess = void 0;
+const BaseError_1 = require("./BaseError");
+class UnauthorizedAccess extends BaseError_1.BaseError {
+    constructor(provider, statusCode = 401) {
+        super(`Unauthorized to access the provider: ${provider}`, statusCode);
+        this.name = this.constructor.name;
+        Error.captureStackTrace(this, this.constructor);
+    }
+}
+exports.UnauthorizedAccess = UnauthorizedAccess;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiVW5hdXRob3JpemVkQWNjZXNzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc2hhcmVkL3V0aWxzL1VuYXV0aG9yaXplZEFjY2Vzcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSwyQ0FBd0M7QUFFeEMsTUFBYSxrQkFBbUIsU0FBUSxxQkFBUztJQUMvQyxZQUFZLFFBQWdCLEVBQUUsYUFBcUIsR0FBRztRQUNwRCxLQUFLLENBQUMsd0NBQXdDLFFBQVEsRUFBRSxFQUFFLFVBQVUsQ0FBQyxDQUFDO1FBQ3RFLElBQUksQ0FBQyxJQUFJLEdBQUcsSUFBSSxDQUFDLFdBQVcsQ0FBQyxJQUFJLENBQUM7UUFDbEMsS0FBSyxDQUFDLGlCQUFpQixDQUFDLElBQUksRUFBRSxJQUFJLENBQUMsV0FBVyxDQUFDLENBQUM7SUFDbEQsQ0FBQztDQUNGO0FBTkQsZ0RBTUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBCYXNlRXJyb3IgfSBmcm9tIFwiLi9CYXNlRXJyb3JcIjtcclxuXHJcbmV4cG9ydCBjbGFzcyBVbmF1dGhvcml6ZWRBY2Nlc3MgZXh0ZW5kcyBCYXNlRXJyb3Ige1xyXG4gIGNvbnN0cnVjdG9yKHByb3ZpZGVyOiBzdHJpbmcsIHN0YXR1c0NvZGU6IG51bWJlciA9IDQwMSkge1xyXG4gICAgc3VwZXIoYFVuYXV0aG9yaXplZCB0byBhY2Nlc3MgdGhlIHByb3ZpZGVyOiAke3Byb3ZpZGVyfWAsIHN0YXR1c0NvZGUpO1xyXG4gICAgdGhpcy5uYW1lID0gdGhpcy5jb25zdHJ1Y3Rvci5uYW1lO1xyXG4gICAgRXJyb3IuY2FwdHVyZVN0YWNrVHJhY2UodGhpcywgdGhpcy5jb25zdHJ1Y3Rvcik7XHJcbiAgfVxyXG59Il19

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "mutualbankutils",
+  "version": "1.0.0",
+  "description": "MutualbankUtils - Queue adapters and shared utilities",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "queue",
+    "rabbitmq",
+    "sqs",
+    "adapter"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "@aws-sdk/client-sqs": "^3.956.0",
+    "amqplib": "^0.10.9"
+  },
+  "devDependencies": {
+    "@types/amqplib": "^0.10.8",
+    "typescript": "^5.0.0"
+  }
+}
+