@zintrust/core 0.4.17 → 0.4.18

package/src/tools/queue/QueueTracing.js

@@ -0,0 +1,151 @@
+import { OpenTelemetry } from '../../observability/OpenTelemetry.js';
+import { generateUuid } from '../../common/utility.js';
+import { Env } from '../../config/env.js';
+import { Logger } from '../../config/logger.js';
+const storedEvents = [];
+const pendingEvents = [];
+const exporters = new Set();
+const normalizeSampleRate = () => {
+    const value = Env.getFloat('QUEUE_TRACING_SAMPLE_RATE', 1);
+    if (Number.isFinite(value) === false)
+        return 1;
+    return Math.max(0, Math.min(1, value));
+};
+const isEnabled = () => Env.getBool('QUEUE_TRACING_ENABLED', false);
+const shouldSample = () => {
+    const rate = normalizeSampleRate();
+    if (rate >= 1)
+        return true;
+    if (rate <= 0)
+        return false;
+    return Math.random() <= rate; // NOSONAR - Math.random() is sufficient for sampling decisions in this context.
+};
+const maxEvents = () => Math.max(1, Env.getInt('QUEUE_TRACING_MAX_EVENTS', 5000));
+const retentionMs = () => Math.max(1000, Env.getInt('QUEUE_TRACING_RETENTION_MS', 86400000));
+const exportBatchSize = () => Math.max(1, Env.getInt('QUEUE_TRACING_EXPORT_BATCH_SIZE', 20));
+const shouldExportToOtel = () => Env.getBool('QUEUE_TRACING_EXPORT_OTEL', true);
+const pruneStored = () => {
+    const cutoff = Date.now() - retentionMs();
+    const filtered = storedEvents.filter((event) => {
+        const ended = new Date(event.endedAt).getTime();
+        if (Number.isNaN(ended))
+            return false;
+        return ended >= cutoff;
+    });
+    storedEvents.splice(0, storedEvents.length, ...filtered);
+    const keep = maxEvents();
+    if (storedEvents.length > keep) {
+        storedEvents.splice(0, storedEvents.length - keep);
+    }
+};
+const finalize = (event) => {
+    storedEvents.push(event);
+    pendingEvents.push(event);
+    pruneStored();
+};
+const normalizeError = (error) => {
+    if (error instanceof Error)
+        return error.message;
+    return String(error);
+};
+const tryExportToOpenTelemetry = (batch) => {
+    if (shouldExportToOtel() === false)
+        return;
+    const recordQueueSpan = OpenTelemetry.recordQueueOperationSpan;
+    if (recordQueueSpan === undefined)
+        return;
+    batch.forEach((event) => {
+        recordQueueSpan({
+            queueName: event.queueName,
+            operation: event.operation,
+            durationMs: event.durationMs,
+            status: event.status,
+        });
+    });
+};
+export const QueueTracing = Object.freeze({
+    isEnabled,
+    registerExporter(exporter) {
+        exporters.add(exporter);
+    },
+    unregisterExporter(exporter) {
+        exporters.delete(exporter);
+    },
+    async flush() {
+        if (pendingEvents.length === 0)
+            return 0;
+        const batch = pendingEvents.splice(0, pendingEvents.length);
+        tryExportToOpenTelemetry(batch);
+        if (exporters.size > 0) {
+            const settled = await Promise.allSettled(Array.from(exporters).map(async (exporter) => exporter(batch)));
+            settled.forEach((result) => {
+                if (result.status === 'rejected') {
+                    Logger.warn('Queue trace exporter failed', {
+                        error: String(result.reason),
+                    });
+                }
+            });
+        }
+        return batch.length;
+    },
+    snapshot(limit = 100) {
+        const safeLimit = Math.max(1, Math.floor(limit));
+        pruneStored();
+        if (storedEvents.length <= safeLimit)
+            return [...storedEvents];
+        return storedEvents.slice(storedEvents.length - safeLimit);
+    },
+    prune() {
+        pruneStored();
+    },
+    reset() {
+        storedEvents.splice(0, storedEvents.length);
+        pendingEvents.splice(0, pendingEvents.length);
+        exporters.clear();
+    },
+    async traceOperation(input) {
+        if (isEnabled() === false || shouldSample() === false) {
+            return input.execute();
+        }
+        const startedAtMs = Date.now();
+        const traceId = generateUuid();
+        const spanId = generateUuid();
+        try {
+            const result = await input.execute();
+            finalize({
+                traceId,
+                spanId,
+                queueName: input.queueName,
+                operation: input.operation,
+                status: 'ok',
+                startedAt: new Date(startedAtMs).toISOString(),
+                endedAt: new Date().toISOString(),
+                durationMs: Math.max(0, Date.now() - startedAtMs),
+                attributes: input.attributes,
+            });
+            if (pendingEvents.length >= exportBatchSize()) {
+                void this.flush();
+            }
+            return result;
+        }
+        catch (error) {
+            finalize({
+                traceId,
+                spanId,
+                queueName: input.queueName,
+                operation: input.operation,
+                status: 'error',
+                startedAt: new Date(startedAtMs).toISOString(),
+                endedAt: new Date().toISOString(),
+                durationMs: Math.max(0, Date.now() - startedAtMs),
+                error: normalizeError(error),
+                attributes: input.attributes,
+            });
+            if (pendingEvents.length >= exportBatchSize()) {
+                void this.flush();
+            }
+            throw error;
+        }
+    },
+});
+export default QueueTracing;

package/src/tools/queue/StalledJobMonitor.d.ts

@@ -0,0 +1,5 @@
+export declare const StalledJobMonitor: Readonly<{
+    scanOnce(): Promise<number>;
+}>;
+export default StalledJobMonitor;
+//# sourceMappingURL=StalledJobMonitor.d.ts.map

package/src/tools/queue/StalledJobMonitor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StalledJobMonitor.d.ts","sourceRoot":"","sources":["../../../../src/tools/queue/StalledJobMonitor.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,iBAAiB;gBACV,OAAO,CAAC,MAAM,CAAC;EAoBjC,CAAC;AAEH,eAAe,iBAAiB,CAAC"}

package/src/tools/queue/StalledJobMonitor.js

@@ -0,0 +1,21 @@
+import { Logger } from '../../config/logger.js';
+import { JobHeartbeatStore } from './JobHeartbeatStore.js';
+import { JobStateTracker } from './JobStateTracker.js';
+export const StalledJobMonitor = Object.freeze({
+    async scanOnce() {
+        const expired = await JobHeartbeatStore.listExpired();
+        await Promise.all(expired.map(async (row) => {
+            await JobStateTracker.stalled({
+                queueName: row.queueName,
+                jobId: row.jobId,
+                reason: 'Heartbeat expired',
+            });
+            await JobHeartbeatStore.remove(row.queueName, row.jobId);
+        }));
+        if (expired.length > 0) {
+            Logger.warn('Stalled jobs detected from heartbeat store', { count: expired.length });
+        }
+        return expired.length;
+    },
+});
+export default StalledJobMonitor;

package/src/tools/queue/TimeoutManager.d.ts

@@ -0,0 +1,14 @@
+export type TimeoutRetryConfig = {
+    timeoutMs: number;
+    maxRetries: number;
+    retryDelayMs: number;
+    operationName?: string;
+};
+export declare const TimeoutManager: Readonly<{
+    getQueueJobTimeoutMs(): number;
+    withTimeout<T>(operation: () => Promise<T>, timeoutMs: number, operationName: string, timeoutHandler?: () => Promise<T>): Promise<T>;
+    withTimeoutRetry<T>(operation: () => Promise<T>, config: TimeoutRetryConfig): Promise<T>;
+    isTimeoutError: (error: unknown) => boolean;
+}>;
+export default TimeoutManager;
+//# sourceMappingURL=TimeoutManager.d.ts.map

package/src/tools/queue/TimeoutManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TimeoutManager.d.ts","sourceRoot":"","sources":["../../../../src/tools/queue/TimeoutManager.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,kBAAkB,GAAG;IAC/B,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,CAAC;AA8BF,eAAO,MAAM,cAAc;4BACD,MAAM;gBAKZ,CAAC,aACN,MAAM,OAAO,CAAC,CAAC,CAAC,aAChB,MAAM,iBACF,MAAM,mBACJ,MAAM,OAAO,CAAC,CAAC,CAAC,GAChC,OAAO,CAAC,CAAC,CAAC;qBA0BU,CAAC,aAAa,MAAM,OAAO,CAAC,CAAC,CAAC,UAAU,kBAAkB,GAAG,OAAO,CAAC,CAAC,CAAC;4BAhDjE,OAAO,KAAG,OAAO;EAwE9C,CAAC;AAEH,eAAe,cAAc,CAAC"}

package/src/tools/queue/TimeoutManager.js

@@ -0,0 +1,77 @@
+import { Env } from '../../config/env.js';
+import { ErrorFactory } from '../../exceptions/ZintrustError.js';
+const sleep = async (ms) => {
+    if (ms <= 0)
+        return;
+    await new Promise((resolve) => {
+        const timeoutRef = globalThis.setTimeout(() => {
+            clearTimeout(timeoutRef);
+            resolve();
+        }, ms);
+    });
+};
+const createTimeoutError = (operationName, timeoutMs) => ErrorFactory.createTryCatchError(`Operation timed out: ${operationName}`, {
+    code: 'QUEUE_TIMEOUT',
+    operationName,
+    timeoutMs,
+});
+const isTimeoutError = (error) => {
+    if (error === null || error === undefined || typeof error !== 'object')
+        return false;
+    const code = error.code;
+    if (code === 'QUEUE_TIMEOUT')
+        return true;
+    const details = error.details;
+    if (details !== null && details !== undefined && typeof details === 'object') {
+        return details.code === 'QUEUE_TIMEOUT';
+    }
+    return false;
+};
+export const TimeoutManager = Object.freeze({
+    getQueueJobTimeoutMs() {
+        const timeoutSeconds = Env.getInt('QUEUE_JOB_TIMEOUT', 60);
+        return Math.max(1000, timeoutSeconds * 1000);
+    },
+    async withTimeout(operation, timeoutMs, operationName, timeoutHandler) {
+        let timeoutId;
+        const timeoutPromise = new Promise((_, reject) => {
+            timeoutId = globalThis.setTimeout(() => {
+                reject(createTimeoutError(operationName, timeoutMs));
+            }, Math.max(1, timeoutMs));
+        });
+        try {
+            return await Promise.race([operation(), timeoutPromise]);
+        }
+        catch (error) {
+            if (timeoutHandler !== undefined && isTimeoutError(error)) {
+                return await timeoutHandler();
+            }
+            throw error;
+        }
+        finally {
+            if (timeoutId !== undefined) {
+                clearTimeout(timeoutId);
+            }
+        }
+    },
+    async withTimeoutRetry(operation, config) {
+        const retries = Math.max(0, Math.floor(config.maxRetries));
+        const attemptRun = async (attempt) => {
+            try {
+                return await this.withTimeout(operation, config.timeoutMs, config.operationName ?? 'queue-operation');
+            }
+            catch (error) {
+                const shouldRetry = isTimeoutError(error) && attempt < retries;
+                if (!shouldRetry) {
+                    throw error;
+                }
+                const delay = Math.max(0, Math.floor(config.retryDelayMs * 2 ** attempt));
+                await sleep(delay);
+                return attemptRun(attempt + 1);
+            }
+        };
+        return attemptRun(0);
+    },
+    isTimeoutError,
+});
+export default TimeoutManager;

package/src/tools/queue/drivers/Database.d.ts

@@ -0,0 +1,23 @@
+import type { QueueMessage } from '../../queue/Queue';
+export interface DatabaseQueueConfig {
+    connection?: string;
+    table?: string;
+    retryAttempts?: number;
+    visibilityTimeout?: number;
+}
+export interface IDatabaseQueueDriver {
+    enqueue<T = unknown>(queue: string, payload: T, connectionName?: string): Promise<string>;
+    dequeue<T = unknown>(queue: string, connectionName?: string): Promise<QueueMessage<T> | undefined>;
+    ack(queue: string, id: string, connectionName?: string): Promise<void>;
+    length(queue: string, connectionName?: string): Promise<number>;
+    drain(queue: string, connectionName?: string): Promise<void>;
+}
+export declare const DatabaseQueue: {
+    readonly enqueue: <T = unknown>(queue: string, payload: T, connectionName?: string) => Promise<string>;
+    readonly dequeue: <T = unknown>(queue: string, connectionName?: string) => Promise<QueueMessage<T> | undefined>;
+    readonly ack: (queue: string, id: string, connectionName?: string) => Promise<void>;
+    readonly length: (queue: string, connectionName?: string) => Promise<number>;
+    readonly drain: (queue: string, connectionName?: string) => Promise<void>;
+};
+export default DatabaseQueue;
+//# sourceMappingURL=Database.d.ts.map

package/src/tools/queue/drivers/Database.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Database.d.ts","sourceRoot":"","sources":["../../../../../src/tools/queue/drivers/Database.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEvD,MAAM,WAAW,mBAAmB;IAClC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,oBAAoB;IACnC,OAAO,CAAC,CAAC,GAAG,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,EAAE,cAAc,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAC1F,OAAO,CAAC,CAAC,GAAG,OAAO,EACjB,KAAK,EAAE,MAAM,EACb,cAAc,CAAC,EAAE,MAAM,GACtB,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC;IACxC,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,cAAc,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACvE,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,cAAc,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAChE,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,cAAc,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC9D;AAED,eAAO,MAAM,aAAa;uBAkBR,CAAC,mBACN,MAAM,WACJ,CAAC,mBACO,MAAM,KACtB,OAAO,CAAC,MAAM,CAAC;uBAkBJ,CAAC,mBACN,MAAM,mBACI,MAAM,KACtB,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC;0BAsEtB,MAAM,MAAM,MAAM,mBAAmB,MAAM,KAAG,OAAO,CAAC,IAAI,CAAC;6BAYxD,MAAM,mBAAmB,MAAM,KAAG,OAAO,CAAC,MAAM,CAAC;4BAoBlD,MAAM,mBAAmB,MAAM,KAAG,OAAO,CAAC,IAAI,CAAC;CASlE,CAAC;AAEL,eAAe,aAAa,CAAC"}

package/src/tools/queue/drivers/Database.js

@@ -0,0 +1,123 @@
+import { Env } from '../../../config/env.js';
+import { Logger } from '../../../config/logger.js';
+import { ErrorFactory } from '../../../exceptions/ZintrustError.js';
+import { useDatabase } from '../../../orm/Database.js';
+import { QueryBuilder } from '../../../orm/QueryBuilder.js';
+export const DatabaseQueue = (() => {
+    const connections = new Map();
+    const getConnection = (connectionName) => {
+        const name = connectionName ?? Env.get('DB_CONNECTION', 'default');
+        if (!connections.has(name)) {
+            connections.set(name, useDatabase(undefined, name));
+        }
+        const connection = connections.get(name);
+        if (!connection) {
+            throw ErrorFactory.createConfigError(`Database connection '${name}' not found`);
+        }
+        return connection;
+    };
+    const getTableName = () => Env.get('QUEUE_DB_TABLE', 'queue_jobs');
+    return {
+        async enqueue(queue, payload, connectionName) {
+            const db = getConnection(connectionName);
+            const tableName = getTableName();
+            const result = await QueryBuilder.create(tableName, db).insert({
+                queue,
+                payload: JSON.stringify(payload),
+                attempts: 0,
+                max_attempts: Env.getInt('QUEUE_DB_RETRY_ATTEMPTS', 3),
+                created_at: new Date(),
+                available_at: new Date(),
+            });
+            const jobId = result.id;
+            Logger.info(`[DatabaseQueue] Job enqueued: ${jobId} to queue: ${queue}`);
+            return jobId;
+        },
+        async dequeue(queue, connectionName) {
+            const db = getConnection(connectionName);
+            const tableName = getTableName();
+            const visibilityTimeout = Env.getInt('QUEUE_DB_VISIBILITY_TIMEOUT', 30);
+            const timeoutDate = new Date(Date.now() - visibilityTimeout * 1000);
+            // Try to reserve a job using atomic update
+            const result = await db.transaction(async (trx) => {
+                const job = await QueryBuilder.create(tableName, trx)
+                    .select('id', 'payload', 'attempts', 'max_attempts')
+                    .where('queue', '=', queue)
+                    .where('available_at', '<=', new Date())
+                    .where('reserved_at', '=', null)
+                    .orWhere('reserved_at', '<=', timeoutDate)
+                    .where('failed_at', '=', null)
+                    .orderBy('available_at', 'ASC')
+                    .limit(1)
+                    .first();
+                if (!job)
+                    return null;
+                // Check if job has exceeded max attempts
+                if (job.attempts >= job.max_attempts) {
+                    // Move to dead letter queue
+                    await QueryBuilder.create('queue_jobs_failed', trx).insert({
+                        original_id: job.id,
+                        queue,
+                        payload: job.payload,
+                        attempts: job.attempts,
+                        failed_at: new Date(),
+                        error_message: 'Max attempts exceeded',
+                    });
+                    // Remove from active queue
+                    await QueryBuilder.create(tableName, trx).where('id', '=', job.id).delete();
+                    Logger.warn(`[DatabaseQueue] Job ${job.id} exceeded max attempts (${job.max_attempts}), moved to dead letter queue`);
+                    return null;
+                }
+                // Calculate exponential backoff delay
+                const backoffDelay = Math.min(Math.pow(2, job.attempts) * 1000, 30000); // Max 30 seconds
+                const nextAvailableAt = new Date(Date.now() + backoffDelay);
+                // Reserve the job and set next available time
+                await QueryBuilder.create(tableName, trx)
+                    .where('id', '=', job.id)
+                    .update({
+                    reserved_at: new Date(),
+                    attempts: job.attempts + 1,
+                    available_at: nextAvailableAt,
+                });
+                Logger.debug(`[DatabaseQueue] Job ${job.id} reserved, attempt ${job.attempts + 1}/${job.max_attempts}, next available at ${nextAvailableAt.toISOString()}`);
+                return job;
+            });
+            if (!result)
+                return undefined;
+            return {
+                id: result.id,
+                payload: JSON.parse(result.payload),
+                attempts: result.attempts,
+            };
+        },
+        async ack(queue, id, connectionName) {
+            const db = getConnection(connectionName);
+            const tableName = getTableName();
+            await QueryBuilder.create(tableName, db)
+                .where('id', '=', id)
+                .where('queue', '=', queue)
+                .delete();
+            Logger.debug(`[DatabaseQueue] Job acknowledged: ${id} from queue: ${queue}`);
+        },
+        async length(queue, connectionName) {
+            const db = getConnection(connectionName);
+            const tableName = getTableName();
+            const result = await QueryBuilder.create(tableName, db)
+                .select('id')
+                .where('queue', '=', queue)
+                .where('available_at', '<=', new Date())
+                .where('reserved_at', '=', null)
+                .orWhere('reserved_at', '<=', new Date(Date.now() - Env.getInt('QUEUE_DB_VISIBILITY_TIMEOUT', 30) * 1000))
+                .where('failed_at', '=', null)
+                .get();
+            return result?.length ?? 0;
+        },
+        async drain(queue, connectionName) {
+            const db = getConnection(connectionName);
+            const tableName = getTableName();
+            await QueryBuilder.create(tableName, db).where('queue', '=', queue).delete();
+            Logger.info(`[DatabaseQueue] Queue drained: ${queue}`);
+        },
+    };
+})();
+export default DatabaseQueue;

package/src/tools/queue/drivers/InMemory.d.ts

@@ -0,0 +1,10 @@
+import type { QueueMessage } from '../../queue/Queue';
+export declare const InMemoryQueue: {
+    readonly enqueue: <T = unknown>(queue: string, payload: T) => Promise<string>;
+    readonly dequeue: <T = unknown>(queue: string) => Promise<QueueMessage<T> | undefined>;
+    readonly ack: (_queue: string, _id: string) => Promise<void>;
+    readonly length: (queue: string) => Promise<number>;
+    readonly drain: (queue: string) => Promise<void>;
+};
+export default InMemoryQueue;
+//# sourceMappingURL=InMemory.d.ts.map

package/src/tools/queue/drivers/InMemory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InMemory.d.ts","sourceRoot":"","sources":["../../../../../src/tools/queue/drivers/InMemory.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAIvD,eAAO,MAAM,aAAa;uBAQR,CAAC,mBAAmB,MAAM,WAAW,CAAC,KAAG,OAAO,CAAC,MAAM,CAAC;uBAmBxD,CAAC,mBAAmB,MAAM,KAAG,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC;2BAW7D,MAAM,OAAO,MAAM,KAAG,OAAO,CAAC,IAAI,CAAC;6BAKjC,MAAM,KAAG,OAAO,CAAC,MAAM,CAAC;4BAOzB,MAAM,KAAG,OAAO,CAAC,IAAI,CAAC;CAMzC,CAAC;AAEL,eAAe,aAAa,CAAC"}

package/src/tools/queue/drivers/InMemory.js

@@ -0,0 +1,55 @@
+import { generateUuid } from '../../../common/utility.js';
+export const InMemoryQueue = (() => {
+    const store = new Map();
+    const ensure = (queue) => {
+        if (!store.has(queue))
+            store.set(queue, []);
+    };
+    return {
+        async enqueue(queue, payload) {
+            await Promise.resolve();
+            ensure(queue);
+            const id = generateUuid();
+            const msg = {
+                id,
+                payload: payload,
+                attempts: 0,
+                enqueuedAt: Date.now(),
+            };
+            const arr = store.get(queue);
+            if (arr && arr.length > 0) {
+                arr.push(msg);
+            }
+            else {
+                store.set(queue, [msg]);
+            }
+            return id;
+        },
+        async dequeue(queue) {
+            await Promise.resolve();
+            ensure(queue);
+            const arr = store.get(queue);
+            if (arr && arr.length > 0) {
+                const msg = arr.shift();
+                return msg;
+            }
+            return undefined;
+        },
+        async ack(_queue, _id) {
+            // in-memory dequeue already removed the message; ack is a no-op
+            await Promise.resolve();
+        },
+        async length(queue) {
+            await Promise.resolve();
+            ensure(queue);
+            const arr = store.get(queue);
+            return Array.isArray(arr) ? arr.length : 0;
+        },
+        async drain(queue) {
+            await Promise.resolve();
+            ensure(queue);
+            store.set(queue, []);
+        },
+    };
+})();
+export default InMemoryQueue;

package/src/tools/queue/drivers/Redis.d.ts

@@ -0,0 +1,11 @@
+import type { QueueMessage } from '../../queue/Queue';
+export declare const RedisQueue: {
+    readonly __zintrustCoreRedisQueue: true;
+    readonly enqueue: <T = unknown>(queue: string, payload: T) => Promise<string>;
+    readonly dequeue: <T = unknown>(queue: string) => Promise<QueueMessage<T> | undefined>;
+    readonly ack: (_queue: string, _id: string) => Promise<void>;
+    readonly length: (queue: string) => Promise<number>;
+    readonly drain: (queue: string) => Promise<void>;
+};
+export default RedisQueue;
+//# sourceMappingURL=Redis.d.ts.map

package/src/tools/queue/drivers/Redis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Redis.d.ts","sourceRoot":"","sources":["../../../../../src/tools/queue/drivers/Redis.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEvD,eAAO,MAAM,UAAU;;uBAGL,CAAC,mBAAmB,MAAM,WAAW,CAAC,KAAG,OAAO,CAAC,MAAM,CAAC;uBAKxD,CAAC,mBAAmB,MAAM,KAAG,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC;2BAK7D,MAAM,OAAO,MAAM,KAAG,OAAO,CAAC,IAAI,CAAC;6BAKjC,MAAM,KAAG,OAAO,CAAC,MAAM,CAAC;4BAKzB,MAAM,KAAG,OAAO,CAAC,IAAI,CAAC;CAKzC,CAAC;AAEL,eAAe,UAAU,CAAC"}

package/src/tools/queue/drivers/Redis.js

@@ -0,0 +1,27 @@
+import { ensureDriver } from '../../../config/redis.js';
+export const RedisQueue = (() => {
+    return {
+        __zintrustCoreRedisQueue: true,
+        async enqueue(queue, payload) {
+            const driver = await ensureDriver();
+            return driver.enqueue(queue, payload);
+        },
+        async dequeue(queue) {
+            const driver = await ensureDriver();
+            return driver.dequeue(queue);
+        },
+        async ack(_queue, _id) {
+            const driver = await ensureDriver();
+            await driver.ack(_queue, _id);
+        },
+        async length(queue) {
+            const driver = await ensureDriver();
+            return driver.length(queue);
+        },
+        async drain(queue) {
+            const driver = await ensureDriver();
+            await driver.drain(queue);
+        },
+    };
+})();
+export default RedisQueue;

package/src/tools/queue/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Queue Module Exports
+ * Centralized exports for advanced queue patterns
+ */
+export { createAdvancedQueue, type AdvancedQueue } from './AdvancedQueue';
+export { createDeduplicationBuilder, type DeduplicationBuilder } from './DeduplicationBuilder';
+export { IdempotencyManager } from './IdempotencyManager';
+export { JobHeartbeatStore } from './JobHeartbeatStore';
+export { JobReconciliationRunner } from './JobReconciliationRunner';
+export { JobRecoveryDaemon } from './JobRecoveryDaemon';
+export { createLockProvider, createMemoryLockProvider, createRedisLockProvider, getLockProvider, registerLockProvider, } from './LockProvider';
+export { QueueDataRedactor } from './QueueDataRedactor';
+export { QueueReliabilityMetrics } from './QueueReliabilityMetrics';
+export { QueueReliabilityOrchestrator } from './QueueReliabilityOrchestrator';
+export { QueueTracing } from './QueueTracing';
+export { StalledJobMonitor } from './StalledJobMonitor';
+export { TimeoutManager } from './TimeoutManager';
+export type { AdvancedJobOptions, DeduplicationOptions, JobResult, Lock, LockOptions, LockProvider, LockProviderConfig, LockStatus, QueueConfig, ReleaseCondition, } from '../../types/Queue';
+//# sourceMappingURL=index.d.ts.map

package/src/tools/queue/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/tools/queue/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,mBAAmB,EAAE,KAAK,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAC/E,OAAO,EAAE,0BAA0B,EAAE,KAAK,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AACpG,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAC/D,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,EAAE,uBAAuB,EAAE,MAAM,gCAAgC,CAAC;AACzE,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,EACL,kBAAkB,EAClB,wBAAwB,EACxB,uBAAuB,EACvB,eAAe,EACf,oBAAoB,GACrB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,EAAE,uBAAuB,EAAE,MAAM,gCAAgC,CAAC;AACzE,OAAO,EAAE,4BAA4B,EAAE,MAAM,qCAAqC,CAAC;AACnF,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAGvD,YAAY,EACV,kBAAkB,EAClB,oBAAoB,EACpB,SAAS,EACT,IAAI,EACJ,WAAW,EACX,YAAY,EACZ,kBAAkB,EAClB,UAAU,EACV,WAAW,EACX,gBAAgB,GACjB,MAAM,eAAe,CAAC"}

package/src/tools/queue/index.js

@@ -0,0 +1,17 @@
+/**
+ * Queue Module Exports
+ * Centralized exports for advanced queue patterns
+ */
+export { createAdvancedQueue } from './AdvancedQueue.js';
+export { createDeduplicationBuilder } from './DeduplicationBuilder.js';
+export { IdempotencyManager } from './IdempotencyManager.js';
+export { JobHeartbeatStore } from './JobHeartbeatStore.js';
+export { JobReconciliationRunner } from './JobReconciliationRunner.js';
+export { JobRecoveryDaemon } from './JobRecoveryDaemon.js';
+export { createLockProvider, createMemoryLockProvider, createRedisLockProvider, getLockProvider, registerLockProvider, } from './LockProvider.js';
+export { QueueDataRedactor } from './QueueDataRedactor.js';
+export { QueueReliabilityMetrics } from './QueueReliabilityMetrics.js';
+export { QueueReliabilityOrchestrator } from './QueueReliabilityOrchestrator.js';
+export { QueueTracing } from './QueueTracing.js';
+export { StalledJobMonitor } from './StalledJobMonitor.js';
+export { TimeoutManager } from './TimeoutManager.js';

package/src/tools/redis/RedisKeyManager.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Creates a prefixed Redis key
+ * @param key - Original key name
+ * @returns Prefixed key in format: {prefix}-{key}
+ */
+export declare function createRedisKey(key: string): string;
+export declare const RedisKeys: Readonly<{
+    readonly metricsPrefix: string;
+    readonly healthPrefix: string;
+    readonly workerPrefix: string;
+    readonly queuePrefix: string;
+    readonly bullmqPrefix: string;
+    readonly queueLockPrefix: string;
+    readonly cachePrefix: string;
+    readonly sessionPrefix: string;
+    readonly csrfPrefix: string;
+    getCsrfPrefix(): string;
+    createMetricsKey(workerName: string, metricType: string, granularity: string): string;
+    createHealthKey(workerName: string): string;
+    createWorkerKey(workerName: string): string;
+    createQueueKey(queueName: string): string;
+    createBullMQKey(queueName: string): string;
+    createQueueLockKey(lockName: string): string;
+    createCacheKey(cacheKey: string): string;
+    createSessionKey(sessionId: string): string;
+    createCsrfKey(sessionId: string): string;
+    reset(): void;
+}>;
+/**
+ * Extracts original key from prefixed key
+ * @param prefixedKey - Full prefixed key
+ * @returns Original key without prefix
+ */
+export declare function extractOriginalKey(prefixedKey: string): string;
+/**
+ * Checks if a key belongs to this application
+ * @param key - Redis key to check
+ * @returns True if key belongs to this application
+ */
+export declare function isAppKey(key: string): boolean;
+/**
+ * Gets the current prefix
+ * @returns Current application prefix
+ */
+export declare function getPrefix(): string;
+export declare const getBullMQSafeQueueName: () => string;
+export type RedisKeyType = 'queue' | 'bullmq' | 'worker' | 'session' | 'cache' | 'custom';
+/**
+ * Creates a prefixed key based on type (legacy function)
+ * @deprecated Use RedisKeys methods directly
+ * @param type - Type of key
+ * @param key - Original key
+ * @returns Prefixed key
+ */
+export declare function createKeyByType(type: RedisKeyType, key: string): string;
+//# sourceMappingURL=RedisKeyManager.d.ts.map

package/src/tools/redis/RedisKeyManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RedisKeyManager.d.ts","sourceRoot":"","sources":["../../../../src/tools/redis/RedisKeyManager.ts"],"names":[],"mappings":"AAYA;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAgBlD;AA+DD,eAAO,MAAM,SAAS;;;;;;;;;;qBA6BH,MAAM;iCAGM,MAAM,cAAc,MAAM,eAAe,MAAM;gCAGhD,MAAM;gCAGN,MAAM;8BAGR,MAAM;+BAGL,MAAM;iCAGJ,MAAM;6BAGV,MAAM;gCAGH,MAAM;6BAGT,MAAM;aAGtB,IAAI;EAWb,CAAC;AAIH;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAM9D;AAED;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAE7C;AAED;;;GAGG;AACH,wBAAgB,SAAS,IAAI,MAAM,CAElC;AAED,eAAO,MAAM,sBAAsB,QAAO,MAEzC,CAAC;AAGF,MAAM,MAAM,YAAY,GAAG,OAAO,GAAG,QAAQ,GAAG,QAAQ,GAAG,SAAS,GAAG,OAAO,GAAG,QAAQ,CAAC;AAE1F;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,YAAY,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAiBvE"}