yowtech 1.0.1-rv

package/lib/Utils/message-builder.js

@@ -0,0 +1,198 @@
+/**
+ * Message Builder — Pipeline berbasis stage untuk membangun pesan.
+ * Stage: validate → normalize → prepareMedia → interactive → mentions → quoted → encode → send
+ * Setiap stage dapat di-override oleh plugin.
+ */
+
+import { LifecycleEvents } from './message-pipeline.js';
+import { ValidationError } from './message-error.js';
+
+export const BuildStage = Object.freeze({
+    VALIDATE:       'validate',
+    NORMALIZE:      'normalize',
+    PREPARE_MEDIA:  'prepareMedia',
+    INTERACTIVE:    'interactive',
+    MENTIONS:       'mentions',
+    QUOTED:         'quoted',
+    ENCODE:         'encode',
+    PRE_SEND:       'preSend',
+});
+
+// ─────────────────────────────────────────────
+// BUILD CONTEXT
+// ─────────────────────────────────────────────
+
+export function createBuildContext(overrides = {}) {
+    return {
+        jid:         null,
+        content:     null,
+        options:     {},
+        message:     null,
+        media:       null,
+        mentions:    [],
+        quoted:      null,
+        interactive: null,
+        metadata:    {},
+        cancelled:   false,
+        cancelReason: null,
+        error:       null,
+        timestamps: {
+            created:   Date.now(),
+            validated: null,
+            prepared:  null,
+            encoded:   null,
+        },
+        ...overrides,
+    };
+}
+
+// ─────────────────────────────────────────────
+// MESSAGE BUILDER
+// ─────────────────────────────────────────────
+
+export class MessageBuilder {
+    constructor(opts = {}) {
+        this._logger  = opts.logger  ?? console;
+        this._hooks   = opts.hooks   ?? null;
+        this._metrics = opts.metrics ?? null;
+        this._plugins = opts.plugins ?? null;
+
+        // Stage overrides: stageName → async (ctx) => {}
+        this._overrides = new Map();
+        // Stage middlewares: stageName → [(ctx, next) => {}]
+        this._stageMiddlewares = new Map();
+
+        for (const stage of Object.values(BuildStage)) {
+            this._stageMiddlewares.set(stage, []);
+        }
+    }
+
+    // ── Stage Override API ────────────────────
+
+    /** Override stage default handler */
+    overrideStage(stageName, fn) {
+        if (!BuildStage[stageName.toUpperCase().replace('-', '_')] &&
+            !Object.values(BuildStage).includes(stageName)) {
+            throw new Error(`[MessageBuilder] Stage "${stageName}" tidak dikenal`);
+        }
+        this._overrides.set(stageName, fn);
+        return this;
+    }
+
+    /** Tambah middleware ke stage tertentu */
+    useStage(stageName, fn) {
+        if (!this._stageMiddlewares.has(stageName))
+            this._stageMiddlewares.set(stageName, []);
+        this._stageMiddlewares.get(stageName).push(fn);
+        return this;
+    }
+
+    // ── Build Pipeline ────────────────────────
+
+    /**
+     * Jalankan semua stage build pipeline.
+     * @param {string} jid
+     * @param {object} content  — isi pesan (format Baileys WAMessageContent)
+     * @param {object} options  — generateWAMessage options
+     * @returns {Promise<BuildContext>}
+     */
+    async build(jid, content, options = {}) {
+        const ctx = createBuildContext({ jid, content, options });
+
+        // ── STAGE 1: Validate ──
+        await this._runStage(BuildStage.VALIDATE, ctx, async (c) => {
+            if (!c.jid) throw new ValidationError('JID tidak boleh kosong');
+            if (!c.content) throw new ValidationError('Konten pesan tidak boleh kosong');
+            c.timestamps.validated = Date.now();
+        });
+        if (ctx.cancelled) return ctx;
+
+        // ── STAGE 2: Normalize ──
+        await this._runStage(BuildStage.NORMALIZE, ctx, async (c) => {
+            // Normalisasi format konten — bisa di-override plugin
+            if (typeof c.content === 'string') {
+                c.content = { text: c.content };
+            }
+        });
+        if (ctx.cancelled) return ctx;
+
+        // ── STAGE 3: PrepareMedia ──
+        await this._runStage(BuildStage.PREPARE_MEDIA, ctx, async (c) => {
+            // Default: tidak ada transformasi, diserahkan ke generateWAMessage
+            // Plugin dapat inject media preprocessing di sini
+        });
+        if (ctx.cancelled) return ctx;
+
+        // ── STAGE 4: Interactive ──
+        await this._runStage(BuildStage.INTERACTIVE, ctx, async (c) => {
+            // Plugin dapat inject button, list, flow, dll.
+        });
+        if (ctx.cancelled) return ctx;
+
+        // ── STAGE 5: Mentions ──
+        await this._runStage(BuildStage.MENTIONS, ctx, async (c) => {
+            if (c.options?.mentions && Array.isArray(c.options.mentions)) {
+                c.mentions = c.options.mentions;
+            }
+        });
+        if (ctx.cancelled) return ctx;
+
+        // ── STAGE 6: Quoted ──
+        await this._runStage(BuildStage.QUOTED, ctx, async (c) => {
+            if (c.options?.quoted) {
+                c.quoted = c.options.quoted;
+            }
+        });
+        if (ctx.cancelled) return ctx;
+
+        // ── STAGE 7: Encode ──
+        await this._runStage(BuildStage.ENCODE, ctx, async (c) => {
+            c.timestamps.encoded = Date.now();
+            if (this._metrics) this._metrics.inc('encode.total');
+        });
+        if (ctx.cancelled) return ctx;
+
+        // ── Hooks ──
+        await this._emitHook(LifecycleEvents.MESSAGE_PREPARED,  ctx);
+        await this._emitHook(LifecycleEvents.MESSAGE_VALIDATED, ctx);
+
+        // ── STAGE 8: Pre-Send ──
+        await this._runStage(BuildStage.PRE_SEND, ctx, async (c) => {
+            c.timestamps.prepared = Date.now();
+        });
+
+        return ctx;
+    }
+
+    // ── Internal ──────────────────────────────
+
+    async _runStage(stageName, ctx, defaultFn) {
+        if (ctx.cancelled) return;
+        const middlewares = this._stageMiddlewares.get(stageName) ?? [];
+        const handler     = this._overrides.get(stageName) ?? defaultFn;
+
+        if (middlewares.length > 0) {
+            let idx = -1;
+            const dispatch = async (i) => {
+                if (i <= idx) throw new Error('next() dipanggil lebih dari sekali di stage ' + stageName);
+                idx = i;
+                if (i < middlewares.length) return middlewares[i](ctx, () => dispatch(i + 1));
+                return handler(ctx);
+            };
+            await dispatch(0);
+        } else {
+            await handler(ctx);
+        }
+    }
+
+    async _emitHook(event, ctx) {
+        if (this._hooks) try { await this._hooks.emit(event, ctx); } catch (_) {}
+    }
+
+    _log(level, msg, data) {
+        if (this._logger?.[level]) this._logger[level](data ?? {}, msg);
+        else console.log(msg, data);
+    }
+}
+
+export const globalMessageBuilder = new MessageBuilder();

package/lib/Utils/message-cache.js

@@ -0,0 +1,144 @@
+/**
+ * Cache Layer — LRU Memory Cache + NamespacedCache + CacheRegistry.
+ * Support adapter: Memory (default), Redis, SQLite, MongoDB, custom.
+ */
+
+export class MemoryCacheAdapter {
+    constructor(opts = {}) {
+        this._store      = new Map();
+        this._defaultTTL = opts.ttl     ?? 5 * 60 * 1000;
+        this._maxSize    = opts.maxSize ?? 5000;
+        this._hits = 0; this._misses = 0;
+        this._order = [];
+    }
+
+    async get(key) {
+        const entry = this._store.get(key);
+        if (!entry) { this._misses++; return undefined; }
+        if (entry.expiresAt && Date.now() > entry.expiresAt) {
+            this._store.delete(key); this._removeFromOrder(key);
+            this._misses++; return undefined;
+        }
+        this._touchKey(key); this._hits++;
+        return entry.value;
+    }
+
+    async set(key, value, ttlMs) {
+        if (!this._store.has(key) && this._store.size >= this._maxSize) {
+            const oldest = this._order.shift();
+            if (oldest) this._store.delete(oldest);
+        }
+        const expiresAt = Date.now() + (ttlMs ?? this._defaultTTL);
+        this._store.set(key, { value, expiresAt });
+        this._touchKey(key);
+        return true;
+    }
+
+    async delete(key) { this._removeFromOrder(key); return this._store.delete(key); }
+    async has(key)    { return (await this.get(key)) !== undefined; }
+    async clear()     { this._store.clear(); this._order = []; return true; }
+
+    async mget(keys) {
+        const result = {};
+        for (const k of keys) { const v = await this.get(k); if (v !== undefined) result[k] = v; }
+        return result;
+    }
+    async mset(entries) {
+        for (const { key, value, ttlMs } of entries) await this.set(key, value, ttlMs);
+        return true;
+    }
+
+    _touchKey(key) { this._removeFromOrder(key); this._order.push(key); }
+    _removeFromOrder(key) {
+        const idx = this._order.indexOf(key);
+        if (idx !== -1) this._order.splice(idx, 1);
+    }
+
+    get size()    { return this._store.size; }
+    get hitRate() { const t = this._hits + this._misses; return t === 0 ? 0 : this._hits / t; }
+    get stats()   { return { size: this._store.size, hits: this._hits, misses: this._misses, hitRate: this.hitRate }; }
+}
+
+// ─────────────────────────────────────────────
+// NAMESPACED CACHE
+// ─────────────────────────────────────────────
+
+export class NamespacedCache {
+    constructor(namespace, adapter) {
+        this._ns = namespace;
+        this._adapter = adapter;
+    }
+    _key(k) { return `${this._ns}:${k}`; }
+
+    async get(key)              { return this._adapter.get(this._key(key)); }
+    async set(key, value, ttlMs){ return this._adapter.set(this._key(key), value, ttlMs); }
+    async delete(key)           { return this._adapter.delete(this._key(key)); }
+    async has(key)              { return this._adapter.has(this._key(key)); }
+    async clear()               { return this._adapter.clear(); }
+    async mget(keys) {
+        const raw = await this._adapter.mget(keys.map(k => this._key(k)));
+        const result = {};
+        for (const [k, v] of Object.entries(raw))
+            result[k.replace(`${this._ns}:`, '')] = v;
+        return result;
+    }
+    async mset(entries) {
+        return this._adapter.mset(entries.map(e => ({ ...e, key: this._key(e.key) })));
+    }
+}
+
+// ─────────────────────────────────────────────
+// CACHE REGISTRY
+// ─────────────────────────────────────────────
+
+export class CacheRegistry {
+    constructor(opts = {}) {
+        this._adapter    = opts.adapter ?? new MemoryCacheAdapter(opts);
+        this._namespaces = new Map();
+        this._ttls = {
+            jid:             opts.jidTTL             ?? 30 * 60 * 1000,
+            groupMetadata:   opts.groupMetadataTTL   ?? 10 * 60 * 1000,
+            businessProfile: opts.businessProfileTTL ?? 15 * 60 * 1000,
+            newsletter:      opts.newsletterTTL      ?? 10 * 60 * 1000,
+            mediaUpload:     opts.mediaUploadTTL     ??  5 * 60 * 1000,
+            thumbnail:       opts.thumbnailTTL       ?? 60 * 60 * 1000,
+            quotedMessage:   opts.quotedMsgTTL       ?? 30 * 60 * 1000,
+            participantInfo: opts.participantTTL     ??  5 * 60 * 1000,
+            deviceList:      opts.deviceListTTL      ??  5 * 60 * 1000,
+        };
+        for (const ns of Object.keys(this._ttls)) this._namespace(ns);
+    }
+
+    _namespace(name) {
+        if (!this._namespaces.has(name))
+            this._namespaces.set(name, new NamespacedCache(name, this._adapter));
+        return this._namespaces.get(name);
+    }
+
+    get jid()             { return this._namespace('jid'); }
+    get groupMetadata()   { return this._namespace('groupMetadata'); }
+    get businessProfile() { return this._namespace('businessProfile'); }
+    get newsletter()      { return this._namespace('newsletter'); }
+    get mediaUpload()     { return this._namespace('mediaUpload'); }
+    get thumbnail()       { return this._namespace('thumbnail'); }
+    get quotedMessage()   { return this._namespace('quotedMessage'); }
+    get participantInfo() { return this._namespace('participantInfo'); }
+    get deviceList()      { return this._namespace('deviceList'); }
+
+    ns(name) { return this._namespace(name); }
+
+    setAdapter(adapter) {
+        this._adapter = adapter;
+        for (const [name] of this._namespaces)
+            this._namespaces.set(name, new NamespacedCache(name, adapter));
+        return this;
+    }
+
+    async clearAll() { await this._adapter.clear(); return this; }
+
+    get stats() {
+        return typeof this._adapter.stats === 'object' ? this._adapter.stats : {};
+    }
+}
+
+export const globalCache = new CacheRegistry();

package/lib/Utils/message-download-pipeline.js

@@ -0,0 +1,216 @@
+/**
+ * Download Pipeline — Streaming download dengan progress, cancel, retry, checksum, cache.
+ * Stage: validate → checkCache → request → decrypt → verify → cache
+ */
+
+import { LifecycleEvents } from './message-pipeline.js';
+import { MediaDownloadError, ValidationError, TimeoutError } from './message-error.js';
+import { AdaptiveRetryManager, DEFAULT_MEDIA_POLICY } from './message-retry-adaptive.js';
+import { globalMetrics } from './message-metrics.js';
+import { globalCache } from './message-cache.js';
+
+export const DownloadStage = Object.freeze({
+    VALIDATE:    'validate',
+    CHECK_CACHE: 'checkCache',
+    REQUEST:     'request',
+    DECRYPT:     'decrypt',
+    VERIFY:      'verify',
+    CACHE:       'cache',
+});
+
+// ─────────────────────────────────────────────
+// DOWNLOAD CONTEXT
+// ─────────────────────────────────────────────
+
+export function createDownloadContext(overrides = {}) {
+    return {
+        url:              null,
+        directPath:       null,
+        mediaKey:         null,
+        mediaType:        null,
+        mimetype:         null,
+        fileEncSha256:    null,
+        fileSha256:       null,
+        fileLength:       null,
+        buffer:           null,
+        stream:           null,
+        progressBytes:    0,
+        totalBytes:       null,
+        cached:           false,
+        cacheKey:         null,
+        checksum:         null,
+        cancelled:        false,
+        retryCount:       0,
+        error:            null,
+        metadata:         {},
+        options:          {},
+        onProgress:       null,   // (downloaded, total) => void
+        timestamps: {
+            start:        null,
+            requested:    null,
+            decrypted:    null,
+            verified:     null,
+            cached:       null,
+        },
+        ...overrides,
+    };
+}
+
+// ─────────────────────────────────────────────
+// DOWNLOAD PIPELINE
+// ─────────────────────────────────────────────
+
+export class DownloadPipeline {
+    constructor(opts = {}) {
+        this._logger      = opts.logger      ?? console;
+        this._hooks       = opts.hooks       ?? null;
+        this._metrics     = opts.metrics     ?? globalMetrics;
+        this._cache       = opts.cache       ?? globalCache;
+        this._retryPolicy = opts.retryPolicy ?? DEFAULT_MEDIA_POLICY;
+        this._timeoutMs   = opts.timeoutMs   ?? 60_000;
+        this._retryMgr    = new AdaptiveRetryManager({ logger: this._logger, metrics: this._metrics });
+
+        this._overrides        = new Map();
+        this._stageMiddlewares = new Map();
+        for (const stage of Object.values(DownloadStage)) {
+            this._stageMiddlewares.set(stage, []);
+        }
+    }
+
+    overrideStage(stageName, fn) { this._overrides.set(stageName, fn); return this; }
+
+    useStage(stageName, fn) {
+        if (!this._stageMiddlewares.has(stageName)) this._stageMiddlewares.set(stageName, []);
+        this._stageMiddlewares.get(stageName).push(fn);
+        return this;
+    }
+
+    /**
+     * Jalankan download pipeline.
+     * @param {object}   ctx        — DownloadContext
+     * @param {Function} downloadFn — async (ctx) => Buffer|Stream
+     */
+    async run(ctx, downloadFn) {
+        ctx.timestamps.start = Date.now();
+        await this._emitHook(LifecycleEvents.MEDIA_DOWNLOAD_START, ctx);
+
+        // ── STAGE 1: Validate ──
+        await this._runStage(DownloadStage.VALIDATE, ctx, async (c) => {
+            if (!c.url && !c.directPath) throw new ValidationError('URL atau directPath wajib diisi');
+            if (!c.mediaKey)             throw new ValidationError('mediaKey wajib diisi');
+        });
+        if (ctx.cancelled) return ctx;
+
+        // ── STAGE 2: Check Cache ──
+        await this._runStage(DownloadStage.CHECK_CACHE, ctx, async (c) => {
+            if (c.cacheKey && this._cache) {
+                const cached = await this._cache.mediaUpload.get(c.cacheKey);
+                if (cached) {
+                    c.buffer  = cached.buffer ?? c.buffer;
+                    c.cached  = true;
+                    c.cancelled = true; // skip remaining stages
+                    c.cancelReason = 'cache_hit';
+                }
+            }
+        });
+        if (ctx.cached || ctx.cancelled) {
+            await this._emitHook(LifecycleEvents.MEDIA_DOWNLOAD_END, ctx);
+            return ctx;
+        }
+
+        // ── STAGE 3: Request (dengan retry) ──
+        await this._runStage(DownloadStage.REQUEST, ctx, async (c) => {
+            if (!downloadFn) throw new MediaDownloadError('downloadFn tidak disediakan');
+            const start = Date.now();
+            const result = await this._retryMgr.run(
+                () => this._withTimeout(
+                    downloadFn(c),
+                    this._timeoutMs,
+                    `Download timeout setelah ${this._timeoutMs}ms`
+                ),
+                this._retryPolicy,
+                `download_${Date.now()}`,
+                { mediaType: c.mediaType }
+            );
+            if (result instanceof Buffer) {
+                c.buffer = result;
+            } else if (result) {
+                c.buffer = result.buffer ?? result;
+                c.stream = result.stream ?? null;
+            }
+            const durationMs = Date.now() - start;
+            c.timestamps.requested = Date.now();
+            if (this._metrics) {
+                this._metrics.inc('media.download.total');
+                this._metrics.observe('download.duration_ms', durationMs);
+            }
+        });
+        if (ctx.cancelled) return ctx;
+
+        // ── STAGE 4: Decrypt ──
+        await this._runStage(DownloadStage.DECRYPT, ctx, async (c) => {
+            // Default: decryption dilakukan oleh Baileys downloadContentFromMessage
+            // Plugin dapat override jika butuh custom decryption
+            c.timestamps.decrypted = Date.now();
+        });
+        if (ctx.cancelled) return ctx;
+
+        // ── STAGE 5: Verify ──
+        await this._runStage(DownloadStage.VERIFY, ctx, async (c) => {
+            if (!c.buffer && !c.stream) {
+                throw new MediaDownloadError('Download selesai tapi buffer/stream kosong');
+            }
+            // Checksum verification jika ada
+            if (c.checksum && c.fileSha256 && c.buffer) {
+                // Plugin dapat override untuk verifikasi checksum
+            }
+            c.timestamps.verified = Date.now();
+        });
+        if (ctx.cancelled) return ctx;
+
+        // ── STAGE 6: Cache ──
+        await this._runStage(DownloadStage.CACHE, ctx, async (c) => {
+            if (c.cacheKey && c.buffer && this._cache) {
+                await this._cache.mediaUpload.set(c.cacheKey, { buffer: c.buffer }, 10 * 60 * 1000);
+                c.cached = true;
+                c.timestamps.cached = Date.now();
+            }
+        });
+
+        await this._emitHook(LifecycleEvents.MEDIA_DOWNLOAD_END, ctx);
+        return ctx;
+    }
+
+    async _runStage(stageName, ctx, defaultFn) {
+        if (ctx.cancelled) return;
+        const middlewares = this._stageMiddlewares.get(stageName) ?? [];
+        const handler     = this._overrides.get(stageName) ?? defaultFn;
+        if (middlewares.length > 0) {
+            let idx = -1;
+            const dispatch = async (i) => {
+                if (i <= idx) throw new Error('next() di stage ' + stageName + ' dipanggil 2x');
+                idx = i;
+                if (i < middlewares.length) return middlewares[i](ctx, () => dispatch(i + 1));
+                return handler(ctx);
+            };
+            await dispatch(0);
+        } else {
+            await handler(ctx);
+        }
+    }
+
+    _withTimeout(promise, ms, message) {
+        return new Promise((resolve, reject) => {
+            const t = setTimeout(() => reject(new TimeoutError(message)), ms);
+            Promise.resolve(promise)
+                .then(v => { clearTimeout(t); resolve(v); })
+                .catch(e => { clearTimeout(t); reject(e); });
+        });
+    }
+
+    async _emitHook(event, ctx) {
+        if (this._hooks) try { await this._hooks.emit(event, ctx); } catch (_) {}
+    }
+}
+
+export const globalDownloadPipeline = new DownloadPipeline();