yowtech 1.0.1-rv

package/lib/Utils/message-queue.js

@@ -0,0 +1,266 @@
+/**
+ * Queue Manager — Internal queue untuk pengiriman pesan.
+ * Fitur: priority, delay, concurrency, rate limiting, deduplication.
+ * Mampu menangani ribuan pesan tanpa blocking event loop.
+ */
+
+import { QueueOverflowError, RateLimitError } from './message-error.js';
+
+// ─────────────────────────────────────────────
+// QUEUE ITEM
+// ─────────────────────────────────────────────
+
+let _itemSeq = 0;
+
+class QueueItem {
+    constructor(fn, opts = {}) {
+        this.id       = opts.id       ?? `qi_${++_itemSeq}`;
+        this.fn       = fn;
+        this.priority = opts.priority ?? 0;
+        this.delayMs  = opts.delayMs  ?? 0;
+        this.dedupKey = opts.dedupKey ?? null;
+        this.jid      = opts.jid      ?? null;
+        this.addedAt  = Date.now();
+        this._resolve = null;
+        this._reject  = null;
+        this.promise  = new Promise((res, rej) => { this._resolve = res; this._reject = rej; });
+    }
+}
+
+// ─────────────────────────────────────────────
+// MESSAGE QUEUE
+// ─────────────────────────────────────────────
+
+export class MessageQueue {
+    /**
+     * @param {object} opts
+     * @param {number}   opts.maxSize         max items in queue (default 10000)
+     * @param {number}   opts.concurrency      max concurrent executions (default 5)
+     * @param {number}   opts.rateLimitPerSec  max items per second (default 20)
+     * @param {number}   opts.rateLimitBurst   burst allowance (default 30)
+     * @param {boolean}  opts.deduplication    drop duplicate dedupKey (default true)
+     * @param {Function} opts.onError          (err, item) => void
+     * @param {Function} opts.onMetrics        (event, data) => void
+     */
+    constructor(opts = {}) {
+        this._name            = opts.name            ?? 'default';
+        this._maxSize         = opts.maxSize          ?? 10_000;
+        this._concurrency     = opts.concurrency      ?? 5;
+        this._rateLimitPerSec = opts.rateLimitPerSec  ?? 20;
+        this._rateLimitBurst  = opts.rateLimitBurst   ?? 30;
+        this._deduplication   = opts.deduplication    !== false;
+        this._onError         = opts.onError          ?? null;
+        this._onMetrics       = opts.onMetrics        ?? null;
+
+        /** @type {QueueItem[]} priority queue (sorted by priority desc, then addedAt asc) */
+        this._queue    = [];
+        this._running  = 0;         // active concurrent tasks
+        this._stopped  = false;
+        this._dedupSet = new Set(); // active dedupKeys
+
+        // Token bucket for rate limiting
+        this._tokens   = this._rateLimitBurst;
+        this._lastRefill = Date.now();
+
+        // Stats
+        this._stats = {
+            enqueued: 0, dequeued: 0, dropped: 0,
+            failed: 0, completed: 0,
+        };
+    }
+
+    // ── Public API ────────────────────────────
+
+    /**
+     * Tambahkan task ke queue. Mengembalikan Promise yang resolve dengan hasil task.
+     * @param {Function} fn      async () => result
+     * @param {object}   opts    { priority, delayMs, dedupKey, jid, id }
+     * @returns {Promise<any>}
+     */
+    enqueue(fn, opts = {}) {
+        if (this._stopped) {
+            return Promise.reject(new QueueOverflowError('Queue sudah dihentikan'));
+        }
+        if (this._queue.length >= this._maxSize) {
+            this._stats.dropped++;
+            this._emit('dropped', { size: this._queue.length, name: this._name });
+            return Promise.reject(new QueueOverflowError(
+                `Queue "${this._name}" penuh (max: ${this._maxSize})`
+            ));
+        }
+
+        const item = new QueueItem(fn, opts);
+
+        // Deduplication
+        if (this._deduplication && item.dedupKey) {
+            if (this._dedupSet.has(item.dedupKey)) {
+                // Find existing item and return its promise
+                const existing = this._queue.find(q => q.dedupKey === item.dedupKey);
+                if (existing) return existing.promise;
+            }
+            this._dedupSet.add(item.dedupKey);
+        }
+
+        this._insertByPriority(item);
+        this._stats.enqueued++;
+        this._emit('enqueued', { size: this._queue.length, name: this._name });
+
+        // Schedule with delay if needed
+        if (item.delayMs > 0) {
+            setTimeout(() => this._tick(), item.delayMs);
+        } else {
+            // Use setImmediate to avoid blocking
+            setImmediate(() => this._tick());
+        }
+
+        return item.promise;
+    }
+
+    /** Hentikan queue (pending items di-reject) */
+    stop(flush = false) {
+        this._stopped = true;
+        if (!flush) {
+            const pending = [...this._queue];
+            this._queue = [];
+            for (const item of pending) {
+                item._reject(new QueueOverflowError('Queue dihentikan'));
+            }
+        }
+    }
+
+    /** Resume queue yang dihentikan */
+    resume() {
+        this._stopped = false;
+        this._tick();
+    }
+
+    get size()      { return this._queue.length; }
+    get running()   { return this._running; }
+    get stats()     { return { ...this._stats, running: this._running, pending: this._queue.length }; }
+    get isStopped() { return this._stopped; }
+
+    // ── Internal ──────────────────────────────
+
+    _insertByPriority(item) {
+        // Binary search insert (highest priority first, then oldest first)
+        let lo = 0, hi = this._queue.length;
+        while (lo < hi) {
+            const mid = (lo + hi) >>> 1;
+            const m = this._queue[mid];
+            if (m.priority > item.priority || (m.priority === item.priority && m.addedAt <= item.addedAt))
+                lo = mid + 1;
+            else
+                hi = mid;
+        }
+        this._queue.splice(lo, 0, item);
+    }
+
+    _refillTokens() {
+        const now    = Date.now();
+        const elapsed = (now - this._lastRefill) / 1000; // seconds
+        const refill  = elapsed * this._rateLimitPerSec;
+        this._tokens  = Math.min(this._tokens + refill, this._rateLimitBurst);
+        this._lastRefill = now;
+    }
+
+    _tick() {
+        if (this._stopped) return;
+        if (this._running >= this._concurrency) return;
+        if (this._queue.length === 0) return;
+
+        this._refillTokens();
+        if (this._tokens < 1) {
+            // Rate limited — schedule next tick after refill delay
+            const waitMs = Math.ceil((1 - this._tokens) / this._rateLimitPerSec * 1000) + 1;
+            setTimeout(() => this._tick(), waitMs);
+            return;
+        }
+
+        const item = this._queue.shift();
+        if (!item) return;
+
+        this._tokens -= 1;
+        this._running++;
+
+        const waitMs = Date.now() - item.addedAt;
+        this._emit('dequeued', { size: this._queue.length, waitMs, name: this._name });
+        this._stats.dequeued++;
+
+        if (item.dedupKey) this._dedupSet.delete(item.dedupKey);
+
+        const run = async () => {
+            try {
+                const result = await item.fn();
+                item._resolve(result);
+                this._stats.completed++;
+            } catch (err) {
+                item._reject(err);
+                this._stats.failed++;
+                if (this._onError) {
+                    try { this._onError(err, item); } catch (_) {}
+                }
+            } finally {
+                this._running--;
+                // Schedule next item
+                setImmediate(() => this._tick());
+            }
+        };
+
+        run();
+
+        // Try to schedule more concurrent tasks
+        if (this._running < this._concurrency && this._queue.length > 0) {
+            setImmediate(() => this._tick());
+        }
+    }
+
+    _emit(event, data) {
+        if (this._onMetrics) {
+            try { this._onMetrics(event, data); } catch (_) {}
+        }
+    }
+}
+
+// ─────────────────────────────────────────────
+// QUEUE MANAGER
+// ─────────────────────────────────────────────
+
+export class QueueManager {
+    constructor() {
+        this._queues = new Map();
+    }
+
+    /**
+     * Ambil atau buat queue dengan nama tertentu.
+     * @param {string} name
+     * @param {object} opts — MessageQueue options
+     */
+    getQueue(name, opts = {}) {
+        if (!this._queues.has(name)) {
+            this._queues.set(name, new MessageQueue({ name, ...opts }));
+        }
+        return this._queues.get(name);
+    }
+
+    /** Hapus queue */
+    removeQueue(name) {
+        const q = this._queues.get(name);
+        if (q) { q.stop(); this._queues.delete(name); }
+    }
+
+    /** Stop semua queue */
+    stopAll(flush = false) {
+        for (const q of this._queues.values()) q.stop(flush);
+    }
+
+    /** Semua stats */
+    getAllStats() {
+        const result = {};
+        for (const [name, q] of this._queues) result[name] = q.stats;
+        return result;
+    }
+
+    get queueNames() { return [...this._queues.keys()]; }
+}
+
+export const globalQueueManager = new QueueManager();

package/lib/Utils/message-retry-adaptive.js

@@ -0,0 +1,216 @@
+/**
+ * Adaptive Retry Manager — Exponential backoff + jitter + custom policies.
+ * Berlaku untuk sendMessage, media upload, media download.
+ */
+
+import { normalizeToPipelineError, RetryExhaustedError } from './message-error.js';
+
+export const RetryStrategy = Object.freeze({
+    IMMEDIATE:    'immediate',
+    LINEAR:       'linear',
+    EXPONENTIAL:  'exponential',
+    FIBONACCI:    'fibonacci',
+});
+
+export function calcRetryDelay(attempt, strategy, baseMs, maxMs, jitterMs) {
+    let delay = 0;
+    switch (strategy) {
+        case RetryStrategy.IMMEDIATE:   delay = 0; break;
+        case RetryStrategy.LINEAR:      delay = baseMs * attempt; break;
+        case RetryStrategy.FIBONACCI: {
+            let a = 0, b = 1;
+            for (let i = 0; i < attempt; i++) { [a, b] = [b, a + b]; }
+            delay = baseMs * a;
+            break;
+        }
+        case RetryStrategy.EXPONENTIAL:
+        default:
+            delay = baseMs * Math.pow(2, attempt - 1);
+            break;
+    }
+    if (jitterMs > 0) delay += Math.random() * jitterMs;
+    return Math.min(delay, maxMs);
+}
+
+// ─────────────────────────────────────────────
+// RETRY POLICY
+// ─────────────────────────────────────────────
+
+export const DEFAULT_SEND_POLICY = {
+    maxAttempts:     5,
+    strategy:        RetryStrategy.EXPONENTIAL,
+    baseMs:          250,
+    maxMs:           30_000,
+    jitterMs:        100,
+    retryCondition:  (err) => {
+        if (err?.retryable === false) return false;
+        if (err?.isBoom) {
+            const code = err.output?.statusCode;
+            return code >= 500 || code === 429 || code === 408;
+        }
+        return true;
+    },
+    onRetry:   null,
+    onSuccess: null,
+    onFailed:  null,
+};
+
+export const DEFAULT_MEDIA_POLICY = {
+    maxAttempts:    4,
+    strategy:       RetryStrategy.EXPONENTIAL,
+    baseMs:         500,
+    maxMs:          60_000,
+    jitterMs:       200,
+    retryCondition: (err) => {
+        if (err?.retryable === false) return false;
+        if (err?.isBoom) {
+            const code = err.output?.statusCode;
+            return code >= 500 || code === 429 || code === 408;
+        }
+        return true;
+    },
+    onRetry:   null,
+    onSuccess: null,
+    onFailed:  null,
+};
+
+// ─────────────────────────────────────────────
+// ADAPTIVE RETRY MANAGER
+// ─────────────────────────────────────────────
+
+export class AdaptiveRetryManager {
+    constructor(opts = {}) {
+        this._logger  = opts.logger  ?? console;
+        this._metrics = opts.metrics ?? null;
+        this._hooks   = opts.hooks   ?? null;
+        this._history = new Map();   // operationId → RetryHistory
+        this._totalRetries  = 0;
+        this._totalSuccess  = 0;
+        this._totalFailed   = 0;
+    }
+
+    /**
+     * Run operation with retry policy.
+     * @param {Function} operation  async () => result
+     * @param {object}   policy
+     * @param {string}   operationId
+     * @param {object}   context
+     */
+    async run(operation, policy = DEFAULT_SEND_POLICY, operationId = null, context = {}) {
+        const id = operationId ?? `op_${Date.now()}_${Math.random().toString(36).slice(2, 7)}`;
+        const {
+            maxAttempts    = 5,
+            strategy       = RetryStrategy.EXPONENTIAL,
+            baseMs         = 250,
+            maxMs          = 30_000,
+            jitterMs       = 100,
+            retryCondition = () => true,
+            onRetry        = null,
+            onSuccess      = null,
+            onFailed       = null,
+        } = policy;
+
+        const history = {
+            id, operationId: id, attempts: [], startTime: Date.now(),
+            endTime: null, succeeded: false, failed: false,
+            totalRetries: 0, finalError: null,
+        };
+        this._history.set(id, history);
+        if (this._history.size > 500) {
+            // Keep history bounded
+            const firstKey = this._history.keys().next().value;
+            this._history.delete(firstKey);
+        }
+
+        let lastError = null;
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+            const attemptStart = Date.now();
+            try {
+                const result = await operation();
+
+                history.attempts.push({ attempt, success: true, durationMs: Date.now() - attemptStart, error: null });
+                history.succeeded = true;
+                history.endTime   = Date.now();
+                this._totalSuccess++;
+
+                if (this._metrics) {
+                    this._metrics.inc('messages.sent.total');
+                    if (attempt > 1) this._metrics.inc('messages.retry.total', attempt - 1);
+                }
+                if (onSuccess) try { await onSuccess(result, { attempt, history, context }); } catch (_) {}
+                await this._emitHook('message:success', { id, attempt, result, context });
+                return result;
+
+            } catch (err) {
+                lastError = normalizeToPipelineError(err);
+                history.attempts.push({
+                    attempt, success: false, durationMs: Date.now() - attemptStart,
+                    error: { message: err?.message, code: lastError.code, type: lastError.type },
+                });
+                history.totalRetries++;
+                this._totalRetries++;
+
+                const shouldRetry = attempt < maxAttempts && retryCondition(err);
+
+                if (!shouldRetry) {
+                    history.failed     = true;
+                    history.finalError = lastError;
+                    history.endTime    = Date.now();
+                    this._totalFailed++;
+
+                    if (this._metrics) {
+                        this._metrics.inc('messages.failed.total');
+                        this._metrics.inc('errors.total');
+                    }
+                    if (onFailed) try { await onFailed(lastError, { attempt, history, context }); } catch (_) {}
+                    await this._emitHook('message:error', { id, attempt, error: lastError, context });
+
+                    throw new RetryExhaustedError(
+                        `Operasi gagal setelah ${attempt} percobaan: ${err?.message}`,
+                        { originalError: err, metadata: { attempts: attempt, history: history.attempts, context } }
+                    );
+                }
+
+                const delayMs = calcRetryDelay(attempt, strategy, baseMs, maxMs, jitterMs);
+
+                this._log('debug', `[Retry] Attempt ${attempt}/${maxAttempts} gagal, retry dalam ${delayMs}ms`,
+                    { id, error: err?.message, attempt, delayMs });
+
+                if (this._metrics) {
+                    this._metrics.inc('messages.retry.total');
+                    this._metrics.observe('retry.delay_ms', delayMs);
+                }
+                if (onRetry) try { await onRetry(lastError, { attempt, delayMs, history, context }); } catch (_) {}
+                await this._emitHook('message:retry', { id, attempt, error: lastError, delayMs, context });
+
+                if (delayMs > 0) await new Promise(r => setTimeout(r, delayMs));
+            }
+        }
+        throw lastError ?? new RetryExhaustedError('Operasi gagal setelah semua percobaan');
+    }
+
+    getHistory(operationId) { return this._history.get(operationId); }
+
+    getStats() {
+        return {
+            totalRetries: this._totalRetries,
+            totalSuccess: this._totalSuccess,
+            totalFailed:  this._totalFailed,
+            historySize:  this._history.size,
+        };
+    }
+
+    clear() { this._history.clear(); return this; }
+
+    async _emitHook(event, data) {
+        if (this._hooks) try { await this._hooks.emit(event, data); } catch (_) {}
+    }
+
+    _log(level, msg, data) {
+        if (this._logger?.[level]) this._logger[level](data ?? {}, msg);
+        else if (level === 'error') console.error(msg, data);
+        else console.log(msg, data);
+    }
+}
+
+export const globalRetryManager = new AdaptiveRetryManager();

package/lib/Utils/message-retry-manager.d.ts

@@ -0,0 +1,80 @@
+export const RetryReason: any;
+export class MessageRetryManager {
+    constructor(logger: any, maxMsgRetryCount: any);
+    logger: any;
+    recentMessagesMap: any;
+    messageKeyIndex: Map<any, any>;
+    sessionRecreateHistory: any;
+    retryCounters: any;
+    baseKeys: any;
+    pendingPhoneRequests: {};
+    maxMsgRetryCount: any;
+    statistics: {
+        totalRetries: number;
+        successfulRetries: number;
+        failedRetries: number;
+        mediaRetries: number;
+        sessionRecreations: number;
+        phoneRequests: number;
+    };
+    /**
+     * Add a recent message to the cache for retry handling
+     */
+    addRecentMessage(to: any, id: any, message: any): void;
+    /**
+     * Get a recent message from the cache
+     */
+    getRecentMessage(to: any, id: any): any;
+    /**
+     * Check if a session should be recreated based on retry count, history, and error code.
+     * MAC errors (codes 4 and 7) trigger immediate session recreation regardless of timeout.
+     */
+    shouldRecreateSession(jid: any, hasSession: any, errorCode: any): {
+        reason: string;
+        recreate: boolean;
+    };
+    /**
+     * Parse error code from retry receipt's retry node.
+     * Returns undefined if no error code is present.
+     */
+    parseRetryErrorCode(errorAttr: any): any;
+    /**
+     * Check if an error code indicates a MAC failure
+     */
+    isMacError(errorCode: any): boolean;
+    /**
+     * Increment retry counter for a message
+     */
+    incrementRetryCount(messageId: any): any;
+    /**
+     * Get retry count for a message
+     */
+    getRetryCount(messageId: any): any;
+    /**
+     * Check if message has exceeded maximum retry attempts
+     */
+    hasExceededMaxRetries(messageId: any): boolean;
+    /**
+     * Mark retry as successful
+     */
+    markRetrySuccess(messageId: any): void;
+    /**
+     * Mark retry as failed
+     */
+    markRetryFailed(messageId: any): void;
+    /**
+     * Schedule a phone request with delay
+     */
+    schedulePhoneRequest(messageId: any, callback: any, delay?: number): void;
+    /**
+     * Cancel pending phone request
+     */
+    cancelPendingPhoneRequest(messageId: any): void;
+    clear(): void;
+    saveBaseKey(addr: any, msgId: any, baseKey: any): void;
+    hasSameBaseKey(addr: any, msgId: any, baseKey: any): boolean;
+    deleteBaseKey(addr: any, msgId: any): void;
+    keyToString(key: any): string;
+    removeRecentMessage(messageId: any): void;
+}
+//# sourceMappingURL=message-retry-manager.d.ts.map

package/lib/Utils/message-retry-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"message-retry-manager.d.ts","sourceRoot":"","sources":["../../src/Utils/message-retry-manager.js"],"names":[],"mappings":"AAQA,8BAAuB;AAqBvB;IACI,gDAwCC;IAvCG,YAAoB;IACpB,uBAWE;IACF,+BAAgC;IAChC,4BAGE;IACF,mBAIE;IACF,cAIE;IACF,yBAA8B;IAC9B,sBAAyB;IACzB;;;;;;;MAOC;IAGL;;OAEG;IACH,uDAUC;IACD;;OAEG;IACH,wCAIC;IACD;;;OAGG;IACH;;;MAgCC;IACD;;;OAGG;IACH,yCAaC;IACD;;OAEG;IACH,oCAEC;IACD;;OAEG;IACH,yCAIC;IACD;;OAEG;IACH,mCAEC;IACD;;OAEG;IACH,+CAEC;IACD;;OAEG;IACH,uCAMC;IACD;;OAEG;IACH,sCAKC;IACD;;OAEG;IACH,0EASC;IACD;;OAEG;IACH,gDAOC;IACD,cAiBC;IACD,uDAEC;IACD,6DAUC;IACD,2CAEC;IACD,8BAEC;IACD,0CAOC;CACJ"}