@rentbase/common 1.0.25 → 1.0.26

package/build/events/consumer.js

@@ -14,7 +14,21 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.connectConsumer = void 0;
 const amqplib_1 = __importDefault(require("amqplib"));
+const inbox_1 = require("./inbox");
 const DEFAULT_EXCHANGE = process.env.RABBITMQ_EXCHANGE || "rentbase.events";
+const getNumberEnv = (key, fallback) => {
+    const raw = process.env[key];
+    if (!raw)
+        return fallback;
+    const n = Number(raw);
+    return Number.isFinite(n) ? n : fallback;
+};
+const getBoolEnv = (key, fallback) => {
+    const raw = process.env[key];
+    if (!raw)
+        return fallback;
+    return raw === "true" || raw === "1";
+};
 const connectConsumer = (queue, rabbitUrl, onMessage) => __awaiter(void 0, void 0, void 0, function* () {
     if (!rabbitUrl) {
         throw new Error("RabbitMQ URL is required for connectConsumer()");
@@ -22,28 +36,122 @@ const connectConsumer = (queue, rabbitUrl, onMessage) => __awaiter(void 0, void
     const routingKey = String(queue);
     const serviceName = process.env.SERVICE_NAME;
     const queueName = serviceName ? `${serviceName}.${routingKey}` : routingKey;
+    // Optional: bounded retries + dead-letter “parking lot”.
+    // - If RABBITMQ_MAX_RETRIES >= 0, failures will be republished with an incremented `x-retry-count`.
+    // - Once max retries is reached, the message is published to DLX and ACKed (so it won't loop forever).
+    // - This does NOT require changing existing queue arguments (safe rollout).
+    const maxRetries = getNumberEnv("RABBITMQ_MAX_RETRIES", -1);
+    const enableDlq = getBoolEnv("RABBITMQ_ENABLE_DLQ", maxRetries >= 0);
+    const dlxExchange = process.env.RABBITMQ_DLX || `${DEFAULT_EXCHANGE}.dlx`;
+    const dlqName = `${queueName}.dlq`;
+    // Default behavior matches the old implementation: transient errors requeue.
+    // If you enable DLQ + bounded retries, requeue is handled by republish.
+    const requeueOnError = getBoolEnv("RABBITMQ_REQUEUE_ON_ERROR", true);
     const connection = yield amqplib_1.default.connect(rabbitUrl);
     const channel = yield connection.createChannel();
     // Topic exchange enables pub/sub (each service has its own queue).
     yield channel.assertExchange(DEFAULT_EXCHANGE, "topic", { durable: true });
+    if (enableDlq) {
+        yield channel.assertExchange(dlxExchange, "topic", { durable: true });
+        yield channel.assertQueue(dlqName, { durable: true });
+        yield channel.bindQueue(dlqName, dlxExchange, routingKey);
+    }
     // Durable queue allows the service to catch up after being down.
     yield channel.assertQueue(queueName, { durable: true });
     yield channel.bindQueue(queueName, DEFAULT_EXCHANGE, routingKey);
     // Process messages one at a time per consumer to avoid overwhelming downstream DBs.
     yield channel.prefetch(1);
+    const enableInbox = getBoolEnv("RABBITMQ_ENABLE_INBOX", false);
+    const inboxModelName = process.env.RABBITMQ_INBOX_MODEL || "RentbaseInboxEvent";
+    let InboxModel;
+    let inboxWarned = false;
+    const getInbox = () => {
+        if (!enableInbox)
+            return undefined;
+        if (InboxModel)
+            return InboxModel;
+        try {
+            InboxModel = (0, inbox_1.getInboxModel)(inboxModelName);
+            return InboxModel;
+        }
+        catch (err) {
+            if (!inboxWarned) {
+                inboxWarned = true;
+                console.warn("[Consumer] Inbox dedup enabled but mongoose is unavailable; continuing without dedup.");
+            }
+            return undefined;
+        }
+    };
     channel.consume(queueName, (msg) => __awaiter(void 0, void 0, void 0, function* () {
         if (!msg)
             return;
         try {
+            const headers = (msg.properties.headers || {});
+            const eventId = msg.properties.messageId ||
+                headers["x-event-id"];
+            const Inbox = getInbox();
+            if (Inbox && eventId) {
+                const existing = yield Inbox.findById(eventId).select({ _id: 1 }).lean();
+                if (existing) {
+                    channel.ack(msg);
+                    return;
+                }
+            }
             const data = JSON.parse(msg.content.toString());
             yield onMessage(data);
+            // Mark processed only after handler succeeds.
+            if (Inbox && eventId) {
+                try {
+                    yield Inbox.create({
+                        _id: eventId,
+                        routingKey,
+                        exchange: DEFAULT_EXCHANGE,
+                        processedAt: new Date(),
+                    });
+                }
+                catch (err) {
+                    // Duplicate is fine (another consumer instance processed already).
+                    if (!(err && (err.code === 11000 || err.code === 11001))) {
+                        throw err;
+                    }
+                }
+            }
             channel.ack(msg);
         }
         catch (error) {
             console.error(`[Consumer] Error processing ${routingKey}:`, error);
-            // Requeue so transient failures don't drop events.
-            // If you see a poison-message loop, switch this to `false` or add a DLQ.
-            channel.nack(msg, false, true);
+            // If bounded retries are enabled, republish with incremented retry count.
+            if (maxRetries >= 0) {
+                const headers = (msg.properties.headers || {});
+                const currentRetry = Number(headers["x-retry-count"] || 0) || 0;
+                if (currentRetry < maxRetries) {
+                    const nextHeaders = Object.assign(Object.assign({}, headers), { "x-retry-count": currentRetry + 1, "x-original-routing-key": headers["x-original-routing-key"] || routingKey });
+                    channel.publish(DEFAULT_EXCHANGE, routingKey, msg.content, {
+                        persistent: true,
+                        contentType: msg.properties.contentType || "application/json",
+                        messageId: msg.properties.messageId,
+                        correlationId: msg.properties.correlationId,
+                        headers: nextHeaders,
+                    });
+                    channel.ack(msg);
+                    return;
+                }
+                if (enableDlq) {
+                    const nextHeaders = Object.assign(Object.assign({}, (msg.properties.headers || {})), { "x-retry-count": currentRetry, "x-final-failure": true, "x-original-routing-key": headers["x-original-routing-key"] || routingKey });
+                    channel.publish(dlxExchange, routingKey, msg.content, {
+                        persistent: true,
+                        contentType: msg.properties.contentType || "application/json",
+                        messageId: msg.properties.messageId,
+                        correlationId: msg.properties.correlationId,
+                        headers: nextHeaders,
+                    });
+                }
+                // ACK to stop poison loops. If DLQ is disabled, this drops the message.
+                channel.ack(msg);
+                return;
+            }
+            // Default behavior: requeue so transient failures don't drop events.
+            channel.nack(msg, false, requeueOnError);
         }
     }));
     console.log(`[Consumer] Listening on ${queueName} (exchange=${DEFAULT_EXCHANGE}, key=${routingKey})`);

package/build/events/event-utils.d.ts

@@ -0,0 +1,7 @@
+export declare const generateEventId: () => string;
+export declare type EventPublishMeta = {
+    eventId?: string;
+    occurredAt?: Date;
+    sourceService?: string;
+    headers?: Record<string, any>;
+};

package/build/events/event-utils.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateEventId = void 0;
+const crypto_1 = require("crypto");
+const generateEventId = () => {
+    const b = (0, crypto_1.randomBytes)(16);
+    // RFC 4122 v4
+    b[6] = (b[6] & 0x0f) | 0x40;
+    b[8] = (b[8] & 0x3f) | 0x80;
+    const hex = b.toString("hex");
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+};
+exports.generateEventId = generateEventId;

package/build/events/inbox.d.ts

@@ -0,0 +1,8 @@
+export declare const getInboxModel: (modelName?: string) => any;
+export declare const hasProcessedEvent: (eventId: string, opts?: {
+    modelName?: string;
+}) => Promise<boolean>;
+export declare const markEventProcessed: (eventId: string, routingKey: string, opts?: {
+    modelName?: string;
+    exchange?: string;
+}) => Promise<void>;

package/build/events/inbox.js

@@ -0,0 +1,47 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.markEventProcessed = exports.hasProcessedEvent = exports.getInboxModel = void 0;
+const getMongoose = () => {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    return require("mongoose");
+};
+const getInboxModel = (modelName = "RentbaseInboxEvent") => {
+    var _a;
+    const mongoose = getMongoose();
+    if ((_a = mongoose.models) === null || _a === void 0 ? void 0 : _a[modelName])
+        return mongoose.models[modelName];
+    const schema = new mongoose.Schema({
+        _id: { type: String, required: true },
+        routingKey: { type: String, required: true, index: true },
+        exchange: { type: String, required: false, index: true },
+        processedAt: { type: Date, required: true, index: true },
+    }, { timestamps: true, versionKey: false });
+    return mongoose.model(modelName, schema);
+};
+exports.getInboxModel = getInboxModel;
+const hasProcessedEvent = (eventId, opts = {}) => __awaiter(void 0, void 0, void 0, function* () {
+    const Model = (0, exports.getInboxModel)(opts.modelName);
+    const existing = yield Model.findById(eventId).select({ _id: 1 }).lean();
+    return !!existing;
+});
+exports.hasProcessedEvent = hasProcessedEvent;
+const markEventProcessed = (eventId, routingKey, opts = {}) => __awaiter(void 0, void 0, void 0, function* () {
+    const Model = (0, exports.getInboxModel)(opts.modelName);
+    const doc = {
+        _id: eventId,
+        routingKey,
+        exchange: opts.exchange,
+        processedAt: new Date(),
+    };
+    yield Model.create(doc);
+});
+exports.markEventProcessed = markEventProcessed;

package/build/events/outbox.d.ts

@@ -0,0 +1,34 @@
+import { EventMap } from "./types";
+import { EventPublishMeta } from "./event-utils";
+export declare type OutboxRecord = {
+    _id: string;
+    routingKey: string;
+    exchange: string;
+    payload: any;
+    headers: Record<string, any>;
+    occurredAt: Date;
+    status: "pending" | "publishing" | "published" | "failed";
+    attempts: number;
+    lastError?: string;
+    lockedUntil?: Date;
+    nextAttemptAt?: Date;
+    publishedAt?: Date;
+    createdAt: Date;
+    updatedAt: Date;
+};
+export declare const getOutboxModel: (modelName?: string) => any;
+export declare const enqueueOutboxEvent: <T extends keyof EventMap>(routingKey: T, payload: EventMap[T], meta?: EventPublishMeta & {
+    exchange?: string;
+    modelName?: string;
+    session?: any;
+}) => Promise<string>;
+export declare const startOutboxDispatcher: (rabbitUrl: string, opts?: {
+    modelName?: string;
+    pollIntervalMs?: number;
+    batchSize?: number;
+    lockMs?: number;
+    maxAttempts?: number;
+    logger?: Pick<Console, "log" | "error" | "warn">;
+}) => {
+    stop: () => void;
+};

package/build/events/outbox.js

@@ -0,0 +1,187 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startOutboxDispatcher = exports.enqueueOutboxEvent = exports.getOutboxModel = void 0;
+const producer_1 = require("./producer");
+const event_utils_1 = require("./event-utils");
+const getMongoose = () => {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    return require("mongoose");
+};
+const now = () => new Date();
+const getOutboxModel = (modelName = "RentbaseOutboxEvent") => {
+    var _a;
+    const mongoose = getMongoose();
+    if ((_a = mongoose.models) === null || _a === void 0 ? void 0 : _a[modelName])
+        return mongoose.models[modelName];
+    const schema = new mongoose.Schema({
+        _id: { type: String, required: true },
+        routingKey: { type: String, required: true, index: true },
+        exchange: { type: String, required: true, index: true },
+        payload: { type: mongoose.Schema.Types.Mixed, required: true },
+        headers: { type: mongoose.Schema.Types.Mixed, default: {} },
+        occurredAt: { type: Date, required: true, index: true },
+        status: {
+            type: String,
+            required: true,
+            index: true,
+            enum: ["pending", "publishing", "published", "failed"],
+        },
+        attempts: { type: Number, default: 0 },
+        lastError: { type: String },
+        lockedUntil: { type: Date, index: true },
+        nextAttemptAt: { type: Date, index: true },
+        publishedAt: { type: Date, index: true },
+    }, { timestamps: true, versionKey: false });
+    schema.index({ status: 1, nextAttemptAt: 1, lockedUntil: 1, updatedAt: 1 });
+    return mongoose.model(modelName, schema);
+};
+exports.getOutboxModel = getOutboxModel;
+const enqueueOutboxEvent = (routingKey, payload, meta = {}) => __awaiter(void 0, void 0, void 0, function* () {
+    const exchange = meta.exchange || process.env.RABBITMQ_EXCHANGE || "rentbase.events";
+    const eventId = meta.eventId || (0, event_utils_1.generateEventId)();
+    const occurredAt = meta.occurredAt || now();
+    const sourceService = meta.sourceService || process.env.SERVICE_NAME || process.env.npm_package_name;
+    const headers = Object.assign(Object.assign(Object.assign({}, (meta.headers || {})), { "x-event-id": eventId, "x-occurred-at": occurredAt.toISOString() }), (sourceService ? { "x-source-service": sourceService } : {}));
+    const Model = (0, exports.getOutboxModel)(meta.modelName);
+    const doc = {
+        _id: eventId,
+        routingKey: String(routingKey),
+        exchange,
+        payload,
+        headers,
+        occurredAt,
+        status: "pending",
+        attempts: 0,
+    };
+    yield Model.create([doc], meta.session ? { session: meta.session } : undefined);
+    return eventId;
+});
+exports.enqueueOutboxEvent = enqueueOutboxEvent;
+const isDuplicateKeyError = (err) => err && (err.code === 11000 || err.code === 11001);
+const startOutboxDispatcher = (rabbitUrl, opts = {}) => {
+    var _a, _b, _c, _d, _e;
+    const pollIntervalMs = (_a = opts.pollIntervalMs) !== null && _a !== void 0 ? _a : 1000;
+    const batchSize = (_b = opts.batchSize) !== null && _b !== void 0 ? _b : 50;
+    const lockMs = (_c = opts.lockMs) !== null && _c !== void 0 ? _c : 30000;
+    const maxAttempts = (_d = opts.maxAttempts) !== null && _d !== void 0 ? _d : 50;
+    const logger = (_e = opts.logger) !== null && _e !== void 0 ? _e : console;
+    const exchange = process.env.RABBITMQ_EXCHANGE || "rentbase.events";
+    const Model = (0, exports.getOutboxModel)(opts.modelName);
+    let stopped = false;
+    let timer;
+    const workerId = (0, event_utils_1.generateEventId)();
+    const computeBackoffMs = (attempts) => {
+        // 1s, 2s, 4s... capped at 60s
+        const ms = 1000 * Math.pow(2, Math.min(10, Math.max(0, attempts)));
+        return Math.min(ms, 60000);
+    };
+    const tick = () => __awaiter(void 0, void 0, void 0, function* () {
+        var _f;
+        if (stopped)
+            return;
+        const claimed = [];
+        const claimUntil = new Date(Date.now() + lockMs);
+        const nowTs = now();
+        for (let i = 0; i < batchSize; i++) {
+            const doc = yield Model.findOneAndUpdate({
+                status: { $in: ["pending", "failed"] },
+                $and: [
+                    {
+                        $or: [
+                            { lockedUntil: { $exists: false } },
+                            { lockedUntil: { $lte: nowTs } },
+                        ],
+                    },
+                    {
+                        $or: [
+                            { nextAttemptAt: { $exists: false } },
+                            { nextAttemptAt: { $lte: nowTs } },
+                        ],
+                    },
+                ],
+                attempts: { $lt: maxAttempts },
+            }, {
+                $set: {
+                    status: "publishing",
+                    lockedUntil: claimUntil,
+                    lastError: undefined,
+                    "headers.x-outbox-worker": workerId,
+                },
+                $inc: { attempts: 1 },
+            }, { sort: { updatedAt: 1 }, new: true });
+            if (!doc)
+                break;
+            claimed.push(doc);
+        }
+        for (const doc of claimed) {
+            try {
+                yield (0, producer_1.publishEventWithMeta)(doc.routingKey, doc.payload, {
+                    eventId: doc._id,
+                    occurredAt: doc.occurredAt,
+                    sourceService: (_f = doc.headers) === null || _f === void 0 ? void 0 : _f["x-source-service"],
+                    headers: doc.headers,
+                });
+                yield Model.updateOne({ _id: doc._id }, {
+                    $set: {
+                        status: "published",
+                        publishedAt: now(),
+                        lockedUntil: undefined,
+                        nextAttemptAt: undefined,
+                    },
+                });
+            }
+            catch (err) {
+                const backoff = computeBackoffMs(Number(doc.attempts || 0));
+                const nextAttemptAt = new Date(Date.now() + backoff);
+                logger.error(`[Outbox] Failed to publish ${doc.routingKey} (${doc._id}). Retrying in ${backoff}ms`, (err === null || err === void 0 ? void 0 : err.message) || err);
+                yield Model.updateOne({ _id: doc._id }, {
+                    $set: {
+                        status: "failed",
+                        lastError: String((err === null || err === void 0 ? void 0 : err.message) || err),
+                        lockedUntil: undefined,
+                        nextAttemptAt,
+                    },
+                });
+            }
+        }
+    });
+    const start = () => {
+        if (timer)
+            return;
+        logger.log(`[Outbox] Dispatcher started (interval=${pollIntervalMs}ms, exchange=${exchange})`);
+        timer = setInterval(() => {
+            void tick();
+        }, pollIntervalMs);
+    };
+    const stop = () => {
+        stopped = true;
+        if (timer)
+            clearInterval(timer);
+        timer = undefined;
+    };
+    // Ensure producer is connected before we start dispatching.
+    void (() => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            // no-op; kept for signature compatibility (we require rabbitUrl so callers don't forget)
+            if (!rabbitUrl)
+                throw new Error("rabbitUrl is required");
+            start();
+        }
+        catch (err) {
+            if (!isDuplicateKeyError(err)) {
+                logger.error("[Outbox] Dispatcher failed to start", (err === null || err === void 0 ? void 0 : err.message) || err);
+            }
+        }
+    }))();
+    return { stop };
+};
+exports.startOutboxDispatcher = startOutboxDispatcher;

package/build/events/producer.d.ts

@@ -1,3 +1,5 @@
 import { EventMap } from "./types";
+import { EventPublishMeta } from "./event-utils";
 export declare const connectProducer: (rabbitUrl: string, retries?: number, delay?: number) => Promise<void>;
+export declare const publishEventWithMeta: <T extends keyof EventMap>(queue: string | T, message: any, meta?: EventPublishMeta) => Promise<void>;
 export declare const publishEvent: <T extends keyof EventMap>(queue: T, message: EventMap[T]) => Promise<void>;

package/build/events/producer.js

@@ -1,4 +1,23 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 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) {
@@ -8,51 +27,115 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.publishEvent = exports.connectProducer = void 0;
-const amqplib_1 = __importDefault(require("amqplib"));
+exports.publishEvent = exports.publishEventWithMeta = exports.connectProducer = void 0;
+const amqp = __importStar(require("amqplib"));
+const event_utils_1 = require("./event-utils");
+const outbox_1 = require("./outbox");
+let rabbitConnection;
 let channel;
 const DEFAULT_EXCHANGE = process.env.RABBITMQ_EXCHANGE || "rentbase.events";
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const publishWithConfirm = (exchange, routingKey, payload, options) => {
+    if (!channel) {
+        return Promise.reject(new Error("RabbitMQ channel not initialized. Call connectProducer() first."));
+    }
+    return new Promise((resolve, reject) => {
+        channel.publish(exchange, routingKey, payload, options, (err) => {
+            if (err)
+                return reject(err);
+            resolve();
+        });
+    });
+};
+const sendToQueueWithConfirm = (queueName, payload, options) => {
+    if (!channel) {
+        return Promise.reject(new Error("RabbitMQ channel not initialized. Call connectProducer() first."));
+    }
+    return new Promise((resolve, reject) => {
+        channel.sendToQueue(queueName, payload, options, (err) => {
+            if (err)
+                return reject(err);
+            resolve();
+        });
+    });
+};
 const connectProducer = (rabbitUrl, retries = 5, delay = 3000) => __awaiter(void 0, void 0, void 0, function* () {
     try {
-        const connection = yield amqplib_1.default.connect(rabbitUrl);
-        channel = yield connection.createChannel();
+        const connection = yield amqp.connect(rabbitUrl);
+        rabbitConnection = connection;
+        connection.on("error", (err) => {
+            console.error("[RabbitMQ Producer ❌] connection error:", err);
+        });
+        connection.on("close", () => {
+            console.error("[RabbitMQ Producer ❌] connection closed");
+            rabbitConnection = undefined;
+            channel = undefined;
+        });
+        channel = yield connection.createConfirmChannel();
         yield channel.assertExchange(DEFAULT_EXCHANGE, "topic", { durable: true });
-        console.log("[RabbitMQ Producer ✅] Connected successfully");
+        if (process.env.RABBITMQ_OUTBOX_AUTO_DISPATCH === "true") {
+            try {
+                (0, outbox_1.startOutboxDispatcher)(rabbitUrl);
+            }
+            catch (err) {
+                console.error("[Outbox] Failed to start dispatcher", (err === null || err === void 0 ? void 0 : err.message) || err);
+            }
+        }
+        console.log("[RabbitMQ Producer ✅] Connected successfully (confirm channel)");
     }
     catch (err) {
-        console.error(`[RabbitMQ Producer ❌] Connection failed. Retries left: ${retries}`, err.message);
+        console.error(`[RabbitMQ Producer ❌] Connection failed. Retries left: ${retries}`, (err === null || err === void 0 ? void 0 : err.message) || err);
         if (retries > 0) {
-            setTimeout(() => (0, exports.connectProducer)(rabbitUrl, retries - 1, delay), delay);
-        }
-        else {
-            console.error("[RabbitMQ Producer 💥] Exhausted all retries. RabbitMQ unavailable.");
+            yield sleep(delay);
+            return (0, exports.connectProducer)(rabbitUrl, retries - 1, delay);
         }
+        console.error("[RabbitMQ Producer 💥] Exhausted all retries. RabbitMQ unavailable.");
     }
 });
 exports.connectProducer = connectProducer;
-const publishEvent = (queue, message) => __awaiter(void 0, void 0, void 0, function* () {
+const publishEventWithMeta = (queue, message, meta = {}) => __awaiter(void 0, void 0, void 0, function* () {
     if (!channel)
         throw new Error("RabbitMQ channel not initialized. Call connectProducer() first.");
     // Topic exchange enables pub/sub (each service can bind its own durable queue).
     yield channel.assertExchange(DEFAULT_EXCHANGE, "topic", { durable: true });
     const payload = Buffer.from(JSON.stringify(message));
     const routingKey = String(queue);
-    channel.publish(DEFAULT_EXCHANGE, routingKey, payload, {
+    const eventId = meta.eventId || (0, event_utils_1.generateEventId)();
+    const occurredAt = meta.occurredAt || new Date();
+    const sourceService = meta.sourceService || process.env.SERVICE_NAME || process.env.npm_package_name;
+    const headers = Object.assign(Object.assign(Object.assign({}, (meta.headers || {})), { "x-event-id": eventId, "x-occurred-at": occurredAt.toISOString() }), (sourceService ? { "x-source-service": sourceService } : {}));
+    yield publishWithConfirm(DEFAULT_EXCHANGE, routingKey, payload, {
         persistent: true,
         contentType: "application/json",
+        messageId: eventId,
+        headers,
     });
     // Optional legacy mode for old consumers that still read directly from a shared queue.
     if (process.env.RABBITMQ_LEGACY_QUEUE === "true") {
         yield channel.assertQueue(routingKey, { durable: true });
-        channel.sendToQueue(routingKey, payload, {
+        yield sendToQueueWithConfirm(routingKey, payload, {
             persistent: true,
             contentType: "application/json",
+            messageId: eventId,
+            headers,
         });
     }
     console.log(`[Producer ➡️] Published ${routingKey} on ${DEFAULT_EXCHANGE}:`, message);
 });
+exports.publishEventWithMeta = publishEventWithMeta;
+const publishEvent = (queue, message) => __awaiter(void 0, void 0, void 0, function* () {
+    // Optional Outbox mode: persist first, then let dispatcher publish.
+    if (process.env.RABBITMQ_USE_OUTBOX === "true") {
+        try {
+            const eventId = yield (0, outbox_1.enqueueOutboxEvent)(queue, message);
+            console.log(`[Producer ➕Outbox] Enqueued ${String(queue)} (${eventId})`);
+            return;
+        }
+        catch (err) {
+            console.warn("[Producer ➕Outbox] Enqueue failed; falling back to direct publish:", (err === null || err === void 0 ? void 0 : err.message) || err);
+        }
+    }
+    yield (0, exports.publishEventWithMeta)(queue, message);
+});
 exports.publishEvent = publishEvent;

package/build/index.d.ts

@@ -11,6 +11,9 @@ export * from "./middlewares/require-auth";
 export * from "./middlewares/validate-request";
 export * from "./events/consumer";
 export * from "./events/producer";
+export * from "./events/event-utils";
+export * from "./events/outbox";
+export * from "./events/inbox";
 export * from "./events/types/request-events";
 export * from "./events/types/user-events";
 export * from "./events/types/property-events";

package/build/index.js

@@ -24,6 +24,9 @@ __exportStar(require("./middlewares/require-auth"), exports);
 __exportStar(require("./middlewares/validate-request"), exports);
 __exportStar(require("./events/consumer"), exports);
 __exportStar(require("./events/producer"), exports);
+__exportStar(require("./events/event-utils"), exports);
+__exportStar(require("./events/outbox"), exports);
+__exportStar(require("./events/inbox"), exports);
 __exportStar(require("./events/types/request-events"), exports);
 __exportStar(require("./events/types/user-events"), exports);
 __exportStar(require("./events/types/property-events"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rentbase/common",
-  "version": "1.0.25",
+  "version": "1.0.26",
   "description": "common library for rentbase",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",