@arcraz/common 1.0.0

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,cAAc,mBAAmB,CAAC;AAGlC,cAAc,sBAAsB,CAAC;AAGrC,cAAc,qBAAqB,CAAC;AAGpC,cAAc,kBAAkB,CAAC;AAGjC,cAAc,qBAAqB,CAAC;AAGpC,cAAc,mBAAmB,CAAC;AAGlC,cAAc,oBAAoB,CAAC;AAGnC,cAAc,qBAAqB,CAAC;AAGpC,cAAc,oBAAoB,CAAC;AAGnC,cAAc,kBAAkB,CAAC"}

package/dist/index.js

@@ -0,0 +1,20 @@
+// Config
+export * from './config/index.js';
+// Constants
+export * from './constants/index.js';
+// Database
+export * from './database/index.js';
+// Redis
+export * from './redis/index.js';
+// RabbitMQ
+export * from './rabbitmq/index.js';
+// Caches
+export * from './caches/index.js';
+// Logging
+export * from './logging/index.js';
+// Security
+export * from './security/index.js';
+// Helpers
+export * from './helpers/index.js';
+// Types
+export * from './types/index.js';

package/dist/logging/formatters.d.ts

@@ -0,0 +1,19 @@
+import type { LogEntry, LogFormat } from './types.js';
+/**
+ * Formats a log entry as JSON
+ */
+export declare function formatJson(entry: LogEntry): string;
+/**
+ * Formats a log entry as logfmt
+ * Format: key=value key2=value2
+ */
+export declare function formatLogfmt(entry: LogEntry): string;
+/**
+ * Formats a log entry as pretty-printed output for development
+ */
+export declare function formatPretty(entry: LogEntry): string;
+/**
+ * Gets the appropriate formatter for the specified format
+ */
+export declare function getFormatter(format: LogFormat): (entry: LogEntry) => string;
+//# sourceMappingURL=formatters.d.ts.map

package/dist/logging/formatters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatters.d.ts","sourceRoot":"","sources":["../../src/logging/formatters.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAEtD;;GAEG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,QAAQ,GAAG,MAAM,CAElD;AAaD;;;GAGG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,QAAQ,GAAG,MAAM,CA+BpD;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,QAAQ,GAAG,MAAM,CAuCpD;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,SAAS,GAAG,CAAC,KAAK,EAAE,QAAQ,KAAK,MAAM,CAW3E"}

package/dist/logging/formatters.js

@@ -0,0 +1,94 @@
+/**
+ * Formats a log entry as JSON
+ */
+export function formatJson(entry) {
+    return JSON.stringify(entry);
+}
+/**
+ * Escapes a value for logfmt format
+ */
+function escapeLogfmtValue(value) {
+    const str = String(value);
+    if (str.includes(' ') || str.includes('"') || str.includes('=')) {
+        return `"${str.replace(/"/g, '\\"')}"`;
+    }
+    return str;
+}
+/**
+ * Formats a log entry as logfmt
+ * Format: key=value key2=value2
+ */
+export function formatLogfmt(entry) {
+    const parts = [];
+    if (entry.timestamp) {
+        parts.push(`ts=${entry.timestamp}`);
+    }
+    parts.push(`level=${entry.level}`);
+    if (entry.service) {
+        parts.push(`service=${escapeLogfmtValue(entry.service)}`);
+    }
+    parts.push(`msg=${escapeLogfmtValue(entry.message)}`);
+    if (entry.context) {
+        for (const [key, value] of Object.entries(entry.context)) {
+            if (value !== undefined && value !== null) {
+                parts.push(`${key}=${escapeLogfmtValue(value)}`);
+            }
+        }
+    }
+    if (entry.error) {
+        parts.push(`error=${escapeLogfmtValue(entry.error.message)}`);
+        if (entry.error.stack) {
+            parts.push(`stack=${escapeLogfmtValue(entry.error.stack)}`);
+        }
+    }
+    return parts.join(' ');
+}
+/**
+ * Formats a log entry as pretty-printed output for development
+ */
+export function formatPretty(entry) {
+    const levelColors = {
+        debug: '\x1b[36m', // cyan
+        info: '\x1b[32m', // green
+        warn: '\x1b[33m', // yellow
+        error: '\x1b[31m', // red
+        fatal: '\x1b[35m' // magenta
+    };
+    const reset = '\x1b[0m';
+    const dim = '\x1b[2m';
+    const color = levelColors[entry.level] || '';
+    let output = '';
+    if (entry.timestamp) {
+        output += `${dim}${entry.timestamp}${reset} `;
+    }
+    output += `${color}${entry.level.toUpperCase().padEnd(5)}${reset} `;
+    if (entry.service) {
+        output += `${dim}[${entry.service}]${reset} `;
+    }
+    output += entry.message;
+    if (entry.context && Object.keys(entry.context).length > 0) {
+        output += ` ${dim}${JSON.stringify(entry.context)}${reset}`;
+    }
+    if (entry.error) {
+        output += `\n${color}Error: ${entry.error.message}${reset}`;
+        if (entry.error.stack) {
+            output += `\n${dim}${entry.error.stack}${reset}`;
+        }
+    }
+    return output;
+}
+/**
+ * Gets the appropriate formatter for the specified format
+ */
+export function getFormatter(format) {
+    switch (format) {
+        case 'json':
+            return formatJson;
+        case 'logfmt':
+            return formatLogfmt;
+        case 'pretty':
+            return formatPretty;
+        default:
+            return formatJson;
+    }
+}

package/dist/logging/index.d.ts

@@ -0,0 +1,4 @@
+export { createLogger } from './logger-factory.js';
+export { formatJson, formatLogfmt, formatPretty, getFormatter } from './formatters.js';
+export type { Logger, LoggerConfig, LogLevel, LogFormat, LogEntry } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/logging/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/logging/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AACvF,YAAY,EAAE,MAAM,EAAE,YAAY,EAAE,QAAQ,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC"}

package/dist/logging/index.js

@@ -0,0 +1,2 @@
+export { createLogger } from './logger-factory.js';
+export { formatJson, formatLogfmt, formatPretty, getFormatter } from './formatters.js';

package/dist/logging/logger-factory.d.ts

@@ -0,0 +1,8 @@
+import type { Logger, LoggerConfig } from './types.js';
+/**
+ * Creates a logger instance
+ * @param config Logger configuration
+ * @returns Logger instance
+ */
+export declare function createLogger(config?: LoggerConfig): Logger;
+//# sourceMappingURL=logger-factory.d.ts.map

package/dist/logging/logger-factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger-factory.d.ts","sourceRoot":"","sources":["../../src/logging/logger-factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,YAAY,EAAsB,MAAM,YAAY,CAAC;AAW3E;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,MAAM,GAAE,YAAiB,GAAG,MAAM,CAoF9D"}

package/dist/logging/logger-factory.js

@@ -0,0 +1,86 @@
+import { getFormatter } from './formatters.js';
+const LOG_LEVELS = {
+    debug: 0,
+    info: 1,
+    warn: 2,
+    error: 3,
+    fatal: 4
+};
+/**
+ * Creates a logger instance
+ * @param config Logger configuration
+ * @returns Logger instance
+ */
+export function createLogger(config = {}) {
+    const { level = 'info', format = 'json', serviceName, defaultContext = {}, timestamps = true, includeStackTrace = true } = config;
+    const minLevel = LOG_LEVELS[level];
+    const formatter = getFormatter(format);
+    function shouldLog(logLevel) {
+        return LOG_LEVELS[logLevel] >= minLevel;
+    }
+    function formatError(error) {
+        if (!error)
+            return undefined;
+        if (error instanceof Error) {
+            return {
+                message: error.message,
+                name: error.name,
+                stack: includeStackTrace ? error.stack : undefined
+            };
+        }
+        return {
+            message: typeof error === 'string' ? error : JSON.stringify(error),
+            name: 'Error'
+        };
+    }
+    function log(logLevel, message, error, context) {
+        if (!shouldLog(logLevel))
+            return;
+        const entry = {
+            level: logLevel,
+            message,
+            timestamp: timestamps ? new Date().toISOString() : undefined,
+            service: serviceName,
+            context: { ...defaultContext, ...context },
+            error: formatError(error)
+        };
+        const output = formatter(entry);
+        if (logLevel === 'error' || logLevel === 'fatal') {
+            console.error(output);
+        }
+        else if (logLevel === 'warn') {
+            console.warn(output);
+        }
+        else {
+            console.log(output);
+        }
+    }
+    const logger = {
+        debug(message, context) {
+            log('debug', message, undefined, context);
+        },
+        info(message, context) {
+            log('info', message, undefined, context);
+        },
+        warn(message, context) {
+            log('warn', message, undefined, context);
+        },
+        error(message, error, context) {
+            log('error', message, error, context);
+        },
+        fatal(message, error, context) {
+            log('fatal', message, error, context);
+        },
+        child(childContext) {
+            return createLogger({
+                level,
+                format,
+                serviceName,
+                defaultContext: { ...defaultContext, ...childContext },
+                timestamps,
+                includeStackTrace
+            });
+        }
+    };
+    return logger;
+}

package/dist/logging/types.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Log levels
+ */
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error' | 'fatal';
+/**
+ * Log format types
+ */
+export type LogFormat = 'json' | 'logfmt' | 'pretty';
+/**
+ * Logger configuration
+ */
+export interface LoggerConfig {
+    /** Minimum log level to output */
+    level?: LogLevel;
+    /** Output format */
+    format?: LogFormat;
+    /** Service name for log context */
+    serviceName?: string;
+    /** Additional default context fields */
+    defaultContext?: Record<string, unknown>;
+    /** Whether to include timestamps */
+    timestamps?: boolean;
+    /** Whether to include stack traces for errors */
+    includeStackTrace?: boolean;
+}
+/**
+ * Log entry structure
+ */
+export interface LogEntry {
+    level: LogLevel;
+    message: string;
+    timestamp?: string;
+    service?: string;
+    context?: Record<string, unknown>;
+    error?: {
+        message: string;
+        name: string;
+        stack?: string;
+    };
+}
+/**
+ * Logger interface
+ */
+export interface Logger {
+    debug(message: string, context?: Record<string, unknown>): void;
+    info(message: string, context?: Record<string, unknown>): void;
+    warn(message: string, context?: Record<string, unknown>): void;
+    error(message: string, error?: unknown, context?: Record<string, unknown>): void;
+    fatal(message: string, error?: unknown, context?: Record<string, unknown>): void;
+    child(context: Record<string, unknown>): Logger;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/logging/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/logging/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,QAAQ,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,OAAO,CAAC;AAErE;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG,MAAM,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAErD;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,kCAAkC;IAClC,KAAK,CAAC,EAAE,QAAQ,CAAC;IACjB,oBAAoB;IACpB,MAAM,CAAC,EAAE,SAAS,CAAC;IACnB,mCAAmC;IACnC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,wCAAwC;IACxC,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACzC,oCAAoC;IACpC,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,iDAAiD;IACjD,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B;AAED;;GAEG;AACH,MAAM,WAAW,QAAQ;IACvB,KAAK,EAAE,QAAQ,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC,KAAK,CAAC,EAAE;QACN,OAAO,EAAE,MAAM,CAAC;QAChB,IAAI,EAAE,MAAM,CAAC;QACb,KAAK,CAAC,EAAE,MAAM,CAAC;KAChB,CAAC;CACH;AAED;;GAEG;AACH,MAAM,WAAW,MAAM;IACrB,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IAChE,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IAC/D,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IAC/D,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IACjF,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IACjF,KAAK,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC;CACjD"}

package/dist/logging/types.js

@@ -0,0 +1 @@
+export {};

package/dist/rabbitmq/connection-factory.d.ts

@@ -0,0 +1,8 @@
+import type { RabbitMQConnection, RabbitMQConnectionConfig } from './types.js';
+/**
+ * Creates a RabbitMQ connection
+ * @param config Connection configuration
+ * @returns RabbitMQConnection instance
+ */
+export declare function createRabbitMQConnection(config: RabbitMQConnectionConfig): Promise<RabbitMQConnection>;
+//# sourceMappingURL=connection-factory.d.ts.map

package/dist/rabbitmq/connection-factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection-factory.d.ts","sourceRoot":"","sources":["../../src/rabbitmq/connection-factory.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAC;AAkB/E;;;;GAIG;AACH,wBAAsB,wBAAwB,CAAC,MAAM,EAAE,wBAAwB,GAAG,OAAO,CAAC,kBAAkB,CAAC,CA0G5G"}

package/dist/rabbitmq/connection-factory.js

@@ -0,0 +1,117 @@
+import * as amqplib from 'amqplib';
+import { hostname } from 'node:os';
+import { RABBITMQ_DEFAULTS } from '../constants/defaults.js';
+/**
+ * Builds AMQP URL from configuration
+ */
+function buildUrl(config) {
+    const protocol = config.protocol ?? 'amqp';
+    const host = config.host;
+    const port = config.port ?? RABBITMQ_DEFAULTS.PORT;
+    const vhost = encodeURIComponent(config.vhost ?? '/');
+    const username = encodeURIComponent(config.username);
+    const password = encodeURIComponent(config.password);
+    const heartbeat = config.heartbeat ?? RABBITMQ_DEFAULTS.HEARTBEAT;
+    return `${protocol}://${username}:${password}@${host}:${port}/${vhost}?heartbeat=${heartbeat}`;
+}
+/**
+ * Creates a RabbitMQ connection
+ * @param config Connection configuration
+ * @returns RabbitMQConnection instance
+ */
+export async function createRabbitMQConnection(config) {
+    const namespace = config.namespace || process.env.NODE_ENV || 'local';
+    const appName = config.appName || 'Unknown';
+    const connectionName = `${hostname()}:${appName}`;
+    let connection;
+    let channel;
+    let connected = false;
+    let reconnecting = false;
+    async function connect() {
+        const url = buildUrl(config);
+        connection = await amqplib.connect(url, {
+            timeout: config.connectionTimeout ?? RABBITMQ_DEFAULTS.CONNECTION_TIMEOUT_MS,
+            clientProperties: {
+                connection_name: connectionName
+            }
+        });
+        channel = await connection.createChannel();
+        await channel.prefetch(RABBITMQ_DEFAULTS.PREFETCH_COUNT);
+        connected = true;
+        console.log(`RabbitMQ connected: ${connectionName}`);
+        connection.on('error', (err) => {
+            console.error('RabbitMQ connection error:', err);
+            connected = false;
+        });
+        connection.on('close', () => {
+            console.log('RabbitMQ connection closed');
+            connected = false;
+            if (!reconnecting) {
+                scheduleReconnect();
+            }
+        });
+        channel.on('error', (err) => {
+            console.error('RabbitMQ channel error:', err);
+        });
+        channel.on('close', () => {
+            console.log('RabbitMQ channel closed');
+        });
+    }
+    function scheduleReconnect() {
+        if (reconnecting)
+            return;
+        reconnecting = true;
+        setTimeout(async () => {
+            try {
+                await connect();
+                reconnecting = false;
+            }
+            catch (err) {
+                console.error('RabbitMQ reconnection failed:', err);
+                reconnecting = false;
+                scheduleReconnect();
+            }
+        }, config.connectionTimeout ?? RABBITMQ_DEFAULTS.RECONNECT_DELAY_MS);
+    }
+    async function closeConnection() {
+        try {
+            if (channel) {
+                await channel.close();
+            }
+            if (connection) {
+                await connection.close();
+            }
+            connected = false;
+        }
+        catch (err) {
+            console.error('Error closing RabbitMQ connection:', err);
+        }
+    }
+    // Initial connection
+    await connect();
+    // Cast to satisfy the interface - amqplib types don't match perfectly
+    const rabbitConnection = {
+        get connection() {
+            return connection;
+        },
+        get channel() {
+            return channel;
+        },
+        namespace,
+        appName,
+        close: closeConnection,
+        isConnected() {
+            return connected;
+        },
+        async reconnect() {
+            try {
+                await closeConnection();
+            }
+            catch {
+                // Ignore close errors during reconnect
+            }
+            await connect();
+        }
+    };
+    return rabbitConnection;
+}

package/dist/rabbitmq/consumer.d.ts

@@ -0,0 +1,44 @@
+import type { ConsumeMessage } from 'amqplib';
+import type { RabbitMQConnection, RabbitMQConsumer, MessageHandler, ConsumeOptions } from './types.js';
+/**
+ * Creates a consumer for a queue
+ * @param conn RabbitMQ connection
+ * @param queue Queue name (will be namespaced)
+ * @param handler Message handler function
+ * @param options Consumer options
+ * @returns RabbitMQConsumer instance
+ */
+export declare function consume(conn: RabbitMQConnection, queue: string, handler: MessageHandler, options?: ConsumeOptions): Promise<RabbitMQConsumer>;
+/**
+ * Consumer class with retry logic and error handling
+ */
+export declare class RabbitConsumer {
+    private conn;
+    private queue;
+    private consumer;
+    private _retryAttempts;
+    private _retryDelayMs;
+    onMessage?: MessageHandler;
+    onError?: (error: Error, message: ConsumeMessage) => void | Promise<void>;
+    constructor(conn: RabbitMQConnection, queue: string, options?: {
+        retryAttempts?: number;
+        retryDelayMs?: number;
+    });
+    /** Maximum retry attempts for reconnection */
+    get retryAttempts(): number;
+    /** Delay between retry attempts in milliseconds */
+    get retryDelayMs(): number;
+    /**
+     * Start consuming messages
+     */
+    start(): Promise<void>;
+    /**
+     * Stop consuming messages
+     */
+    stop(): Promise<void>;
+    /**
+     * Get the current consumer tag
+     */
+    get consumerTag(): string | null;
+}
+//# sourceMappingURL=consumer.d.ts.map

package/dist/rabbitmq/consumer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consumer.d.ts","sourceRoot":"","sources":["../../src/rabbitmq/consumer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAC9C,OAAO,KAAK,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAIvG;;;;;;;GAOG;AACH,wBAAsB,OAAO,CAAC,IAAI,EAAE,kBAAkB,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc,EAAE,OAAO,GAAE,cAAmB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAgDvJ;AAED;;GAEG;AACH,qBAAa,cAAc;IACzB,OAAO,CAAC,IAAI,CAAqB;IACjC,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,QAAQ,CAAiC;IACjD,OAAO,CAAC,cAAc,CAAS;IAC/B,OAAO,CAAC,aAAa,CAAS;IAEvB,SAAS,CAAC,EAAE,cAAc,CAAC;IAC3B,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,cAAc,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;gBAG/E,IAAI,EAAE,kBAAkB,EACxB,KAAK,EAAE,MAAM,EACb,OAAO,GAAE;QACP,aAAa,CAAC,EAAE,MAAM,CAAC;QACvB,YAAY,CAAC,EAAE,MAAM,CAAC;KAClB;IAQR,8CAA8C;IAC9C,IAAI,aAAa,IAAI,MAAM,CAE1B;IAED,mDAAmD;IACnD,IAAI,YAAY,IAAI,MAAM,CAEzB;IAED;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAa5B;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAO3B;;OAEG;IACH,IAAI,WAAW,IAAI,MAAM,GAAG,IAAI,CAE/B;CACF"}

package/dist/rabbitmq/consumer.js

@@ -0,0 +1,107 @@
+import { getNamespacedQueue } from './namespace-helpers.js';
+import { RABBITMQ_DEFAULTS } from '../constants/defaults.js';
+/**
+ * Creates a consumer for a queue
+ * @param conn RabbitMQ connection
+ * @param queue Queue name (will be namespaced)
+ * @param handler Message handler function
+ * @param options Consumer options
+ * @returns RabbitMQConsumer instance
+ */
+export async function consume(conn, queue, handler, options = {}) {
+    const finalQueue = getNamespacedQueue(queue, conn.namespace);
+    // Set prefetch if specified
+    if (options.prefetch !== undefined) {
+        await conn.channel.prefetch(options.prefetch);
+    }
+    // Ensure queue exists
+    await conn.channel.assertQueue(finalQueue, {
+        durable: true
+    });
+    const wrappedHandler = async (msg) => {
+        if (!msg)
+            return;
+        try {
+            const content = JSON.parse(msg.content.toString());
+            await handler(msg, content);
+            if (!options.noAck) {
+                conn.channel.ack(msg);
+            }
+        }
+        catch (error) {
+            console.error(`Error processing message from ${finalQueue}:`, error);
+            if (!options.noAck) {
+                // Reject and don't requeue to avoid infinite loops
+                conn.channel.nack(msg, false, false);
+            }
+        }
+    };
+    const { consumerTag } = await conn.channel.consume(finalQueue, wrappedHandler, {
+        noAck: options.noAck ?? false,
+        consumerTag: options.consumerTag
+    });
+    console.log(`Consumer started on queue ${finalQueue} with tag ${consumerTag}`);
+    return {
+        queue: finalQueue,
+        consumerTag,
+        async cancel() {
+            await conn.channel.cancel(consumerTag);
+            console.log(`Consumer cancelled: ${consumerTag}`);
+        }
+    };
+}
+/**
+ * Consumer class with retry logic and error handling
+ */
+export class RabbitConsumer {
+    conn;
+    queue;
+    consumer = null;
+    _retryAttempts;
+    _retryDelayMs;
+    onMessage;
+    onError;
+    constructor(conn, queue, options = {}) {
+        this.conn = conn;
+        this.queue = queue;
+        this._retryAttempts = options.retryAttempts ?? RABBITMQ_DEFAULTS.MAX_RECONNECT_ATTEMPTS;
+        this._retryDelayMs = options.retryDelayMs ?? RABBITMQ_DEFAULTS.RECONNECT_DELAY_MS;
+    }
+    /** Maximum retry attempts for reconnection */
+    get retryAttempts() {
+        return this._retryAttempts;
+    }
+    /** Delay between retry attempts in milliseconds */
+    get retryDelayMs() {
+        return this._retryDelayMs;
+    }
+    /**
+     * Start consuming messages
+     */
+    async start() {
+        const handler = async (msg, content) => {
+            if (this.onMessage) {
+                await this.onMessage(msg, content);
+            }
+        };
+        this.consumer = await consume(this.conn, this.queue, handler, {
+            noAck: false,
+            prefetch: RABBITMQ_DEFAULTS.PREFETCH_COUNT
+        });
+    }
+    /**
+     * Stop consuming messages
+     */
+    async stop() {
+        if (this.consumer) {
+            await this.consumer.cancel();
+            this.consumer = null;
+        }
+    }
+    /**
+     * Get the current consumer tag
+     */
+    get consumerTag() {
+        return this.consumer?.consumerTag ?? null;
+    }
+}

package/dist/rabbitmq/index.d.ts

@@ -0,0 +1,6 @@
+export { createRabbitMQConnection } from './connection-factory.js';
+export { getNamespacedQueue, getNamespacedExchange, stripQueueNamespace, extractQueueNamespace } from './namespace-helpers.js';
+export { publish, publishWithDelay, publishToExchange } from './publisher.js';
+export { consume, RabbitConsumer } from './consumer.js';
+export type { RabbitMQConnection, RabbitMQConnectionConfig, RabbitMQConsumer, DelaySettings, PublishOptions, ConsumeOptions, MessageHandler } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/rabbitmq/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/rabbitmq/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,MAAM,yBAAyB,CAAC;AAEnE,OAAO,EAAE,kBAAkB,EAAE,qBAAqB,EAAE,mBAAmB,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AAE/H,OAAO,EAAE,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAE9E,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAExD,YAAY,EAAE,kBAAkB,EAAE,wBAAwB,EAAE,gBAAgB,EAAE,aAAa,EAAE,cAAc,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC"}

package/dist/rabbitmq/index.js

@@ -0,0 +1,4 @@
+export { createRabbitMQConnection } from './connection-factory.js';
+export { getNamespacedQueue, getNamespacedExchange, stripQueueNamespace, extractQueueNamespace } from './namespace-helpers.js';
+export { publish, publishWithDelay, publishToExchange } from './publisher.js';
+export { consume, RabbitConsumer } from './consumer.js';

package/dist/rabbitmq/namespace-helpers.d.ts

@@ -0,0 +1,33 @@
+/**
+ * CRITICAL: RabbitMQ namespace pattern - NODE_ENV-queue
+ * This MUST be preserved for environment isolation in RabbitMQ
+ */
+/**
+ * Gets the namespaced queue name with environment prefix
+ * Format: environment-queue
+ * @param queue The base queue name
+ * @param namespace Optional namespace override (defaults to NODE_ENV)
+ * @returns The namespaced queue name
+ */
+export declare function getNamespacedQueue(queue: string, namespace?: string): string;
+/**
+ * Gets the namespaced exchange name with environment prefix
+ * Format: environment-exchange
+ * @param exchange The base exchange name
+ * @param namespace Optional namespace override (defaults to NODE_ENV)
+ * @returns The namespaced exchange name
+ */
+export declare function getNamespacedExchange(exchange: string, namespace?: string): string;
+/**
+ * Strips the namespace prefix from a queue name
+ * @param queue The namespaced queue name
+ * @returns The queue name without namespace prefix
+ */
+export declare function stripQueueNamespace(queue: string): string;
+/**
+ * Extracts the namespace from a namespaced queue name
+ * @param queue The namespaced queue name
+ * @returns The namespace or null if not namespaced
+ */
+export declare function extractQueueNamespace(queue: string): string | null;
+//# sourceMappingURL=namespace-helpers.d.ts.map

package/dist/rabbitmq/namespace-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"namespace-helpers.d.ts","sourceRoot":"","sources":["../../src/rabbitmq/namespace-helpers.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,CAG5E;AAED;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,CAGlF;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAGzD;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAGlE"}