yowtech 1.0.1-rv

package/lib/Utils/message-metrics.js

@@ -0,0 +1,173 @@
+/**
+ * Metrics System — Counter, Gauge, Histogram + Registry.
+ * Expose via getMetrics() API.
+ */
+
+export class Counter {
+    constructor(name, description = '') {
+        this.name = name; this.description = description;
+        this._value = 0; this._labels = new Map();
+    }
+    inc(amount = 1, labels = {}) {
+        this._value += amount;
+        const key = JSON.stringify(labels);
+        this._labels.set(key, (this._labels.get(key) || 0) + amount);
+        return this;
+    }
+    get value() { return this._value; }
+    reset() { this._value = 0; this._labels.clear(); return this; }
+    toJSON() { return { name: this.name, value: this._value, description: this.description }; }
+}
+
+export class Gauge {
+    constructor(name, description = '') {
+        this.name = name; this.description = description; this._value = 0;
+    }
+    set(v) { this._value = v; return this; }
+    inc(v = 1) { this._value += v; return this; }
+    dec(v = 1) { this._value -= v; return this; }
+    get value() { return this._value; }
+    toJSON() { return { name: this.name, value: this._value, description: this.description }; }
+}
+
+export class Histogram {
+    constructor(name, description = '', buckets = [5, 10, 25, 50, 100, 250, 500, 1000, 2500, 5000, 10000]) {
+        this.name = name; this.description = description;
+        this._buckets = buckets;
+        this._counts = new Array(buckets.length + 1).fill(0);
+        this._sum = 0; this._total = 0;
+        this._min = Infinity; this._max = -Infinity;
+    }
+    observe(value) {
+        this._sum += value; this._total++;
+        if (value < this._min) this._min = value;
+        if (value > this._max) this._max = value;
+        let placed = false;
+        for (let i = 0; i < this._buckets.length; i++) {
+            if (value <= this._buckets[i]) { this._counts[i]++; placed = true; break; }
+        }
+        if (!placed) this._counts[this._counts.length - 1]++;
+        return this;
+    }
+    get avg()  { return this._total === 0 ? 0 : this._sum / this._total; }
+    get p50()  { return this._percentile(50); }
+    get p95()  { return this._percentile(95); }
+    get p99()  { return this._percentile(99); }
+    _percentile(pct) {
+        if (this._total === 0) return 0;
+        const target = Math.ceil(this._total * pct / 100);
+        let cum = 0;
+        for (let i = 0; i < this._buckets.length; i++) {
+            cum += this._counts[i];
+            if (cum >= target) return this._buckets[i];
+        }
+        return this._max;
+    }
+    toJSON() {
+        return {
+            name: this.name, description: this.description,
+            count: this._total, sum: this._sum, avg: this.avg,
+            min: this._min === Infinity ? 0 : this._min,
+            max: this._max === -Infinity ? 0 : this._max,
+            p50: this.p50, p95: this.p95, p99: this.p99,
+        };
+    }
+}
+
+// ─────────────────────────────────────────────
+// METRICS REGISTRY
+// ─────────────────────────────────────────────
+
+export class MetricsRegistry {
+    constructor() {
+        this._counters   = new Map();
+        this._gauges     = new Map();
+        this._histograms = new Map();
+
+        // Pre-define standard metrics
+        const counters = [
+            'messages.sent.total', 'messages.received.total', 'messages.failed.total',
+            'messages.retry.total', 'messages.cancelled.total', 'messages.updated.total',
+            'media.upload.total', 'media.upload.failed', 'media.download.total', 'media.download.failed',
+            'encode.total', 'decode.total', 'hooks.fired',
+            'queue.enqueued', 'queue.dequeued', 'queue.dropped',
+            'errors.total', 'retries.total',
+        ];
+        for (const name of counters) this._counters.set(name, new Counter(name));
+
+        const gauges = ['connections.active', 'queue.size'];
+        for (const name of gauges) this._gauges.set(name, new Gauge(name));
+
+        const histograms = [
+            'send.duration_ms', 'receive.duration_ms', 'encode.duration_ms',
+            'decode.duration_ms', 'upload.duration_ms', 'download.duration_ms',
+            'retry.delay_ms', 'queue.wait_ms',
+        ];
+        for (const name of histograms) this._histograms.set(name, new Histogram(name));
+    }
+
+    // ── Counter shortcuts ─────────────────────
+
+    /**
+     * Inc a counter by name. Auto-creates if missing.
+     */
+    inc(name, amount = 1, labels = {}) {
+        if (!this._counters.has(name)) this._counters.set(name, new Counter(name));
+        this._counters.get(name).inc(amount, labels);
+        return this;
+    }
+
+    counter(name) {
+        if (!this._counters.has(name)) this._counters.set(name, new Counter(name));
+        return this._counters.get(name);
+    }
+
+    // ── Gauge shortcuts ───────────────────────
+
+    set(name, value) {
+        if (!this._gauges.has(name)) this._gauges.set(name, new Gauge(name));
+        this._gauges.get(name).set(value);
+        return this;
+    }
+
+    gauge(name) {
+        if (!this._gauges.has(name)) this._gauges.set(name, new Gauge(name));
+        return this._gauges.get(name);
+    }
+
+    // ── Histogram shortcuts ───────────────────
+
+    observe(name, value) {
+        if (!this._histograms.has(name)) this._histograms.set(name, new Histogram(name));
+        this._histograms.get(name).observe(value);
+        return this;
+    }
+
+    histogram(name) {
+        if (!this._histograms.has(name)) this._histograms.set(name, new Histogram(name));
+        return this._histograms.get(name);
+    }
+
+    // ── Get all metrics ───────────────────────
+
+    getAll() {
+        const result = {};
+        for (const [k, v] of this._counters)   result[k] = v.toJSON();
+        for (const [k, v] of this._gauges)     result[k] = v.toJSON();
+        for (const [k, v] of this._histograms) result[k] = v.toJSON();
+        return result;
+    }
+
+    reset() {
+        for (const c of this._counters.values())   c.reset();
+        for (const g of this._gauges.values())     g.set(0);
+        for (const h of this._histograms.values()) {
+            h._sum = 0; h._total = 0;
+            h._min = Infinity; h._max = -Infinity;
+            h._counts = new Array(h._buckets.length + 1).fill(0);
+        }
+        return this;
+    }
+}
+
+export const globalMetrics = new MetricsRegistry();

package/lib/Utils/message-pipeline.js

@@ -0,0 +1,236 @@
+/**
+ * Message Pipeline — Middleware & Hook System
+ * Menyediakan pipeline middleware yang dapat diintervensi setiap tahap
+ * pengiriman dan penerimaan pesan.
+ */
+
+// ─────────────────────────────────────────────
+// MESSAGE CONTEXT
+// ─────────────────────────────────────────────
+
+export function createMessageContext(overrides = {}) {
+    return {
+        socket: null, jid: null, sender: null, participant: null,
+        message: null, payload: null, options: {}, metadata: {},
+        timestamps: {
+            created: Date.now(), prepared: null, encoded: null,
+            sent: null, received: null, decoded: null, decrypted: null,
+        },
+        retry: { count: 0, maxCount: 5, history: [], lastError: null, policy: null },
+        upload: {
+            started: null, finished: null, url: null, directPath: null,
+            mediaKey: null, fileEncSha256: null, fileSha256: null,
+            fileLength: null, mediaType: null, mediaKeyTimestamp: null,
+        },
+        media: {
+            type: null, mimetype: null, thumbnail: null,
+            cached: false, compressed: false, width: null, height: null, duration: null,
+        },
+        cancelled: false, cancelReason: null, result: null, error: null,
+        tags: new Set(),
+        ...overrides,
+    };
+}
+
+// ─────────────────────────────────────────────
+// MIDDLEWARE PIPELINE
+// ─────────────────────────────────────────────
+
+export class MiddlewarePipeline {
+    constructor(name = 'unnamed') {
+        this.name = name;
+        this._middlewares = [];
+    }
+
+    use(fn, priority = 0) {
+        if (typeof fn !== 'function')
+            throw new TypeError(`[MiddlewarePipeline:${this.name}] Middleware harus berupa function`);
+        this._middlewares.push({ fn, priority });
+        this._middlewares.sort((a, b) => b.priority - a.priority);
+        return this;
+    }
+
+    remove(fn) {
+        const idx = this._middlewares.findIndex(m => m.fn === fn);
+        if (idx !== -1) this._middlewares.splice(idx, 1);
+        return this;
+    }
+
+    async run(ctx, finalHandler) {
+        const fns = this._middlewares.map(m => m.fn);
+        let index = -1;
+        const dispatch = async (i) => {
+            if (i <= index)
+                throw new Error(`[MiddlewarePipeline:${this.name}] next() dipanggil lebih dari satu kali`);
+            index = i;
+            if (ctx.cancelled) return;
+            let fn = fns[i];
+            if (i === fns.length) fn = finalHandler;
+            if (!fn) return;
+            await fn(ctx, () => dispatch(i + 1));
+        };
+        return dispatch(0);
+    }
+
+    clear() { this._middlewares = []; return this; }
+    get size() { return this._middlewares.length; }
+}
+
+// ─────────────────────────────────────────────
+// HOOK SYSTEM
+// ─────────────────────────────────────────────
+
+export class HookSystem {
+    constructor() {
+        this._hooks = new Map();
+        this._wildcardHooks = [];
+        this._maxListeners = 100;
+    }
+
+    on(event, handler) {
+        if (typeof handler !== 'function')
+            throw new TypeError('[HookSystem] Handler harus berupa function');
+        if (!this._hooks.has(event)) this._hooks.set(event, []);
+        const list = this._hooks.get(event);
+        if (list.length >= this._maxListeners)
+            console.warn(`[HookSystem] Terlalu banyak handler untuk "${event}"`);
+        list.push(handler);
+        return this;
+    }
+
+    once(event, handler) {
+        const wrapper = async (ctx, ev) => { this.off(event, wrapper); return handler(ctx, ev); };
+        return this.on(event, wrapper);
+    }
+
+    onAny(handler) {
+        if (typeof handler !== 'function')
+            throw new TypeError('[HookSystem] Handler harus berupa function');
+        this._wildcardHooks.push(handler);
+        return this;
+    }
+
+    off(event, handler) {
+        const handlers = this._hooks.get(event);
+        if (!handlers) return this;
+        const idx = handlers.indexOf(handler);
+        if (idx !== -1) handlers.splice(idx, 1);
+        return this;
+    }
+
+    async emit(event, ctx) {
+        const handlers  = this._hooks.get(event) || [];
+        const wildcards = this._wildcardHooks;
+        const all = [
+            ...handlers.map(h  => this._safeCall(h,  ctx, event)),
+            ...wildcards.map(h => this._safeCall(h,  ctx, event)),
+        ];
+        if (all.length === 0) return;
+        await Promise.allSettled(all);
+    }
+
+    async _safeCall(fn, ctx, event) {
+        try { return await fn(ctx, event); }
+        catch (err) { console.warn(`[HookSystem] Hook "${event}" error:`, err?.message); }
+    }
+
+    removeAll(event) {
+        if (event) this._hooks.delete(event);
+        else { this._hooks.clear(); this._wildcardHooks = []; }
+        return this;
+    }
+
+    listEvents() { return [...this._hooks.keys()]; }
+    getHandlerCount(event) { return this._hooks.get(event)?.length ?? 0; }
+}
+
+// ─────────────────────────────────────────────
+// PIPELINE REGISTRY
+// ─────────────────────────────────────────────
+
+export class PipelineRegistry {
+    constructor() {
+        this.hooks = new HookSystem();
+
+        // Send
+        this.beforeSend          = new MiddlewarePipeline('before-send');
+        this.afterSend           = new MiddlewarePipeline('after-send');
+
+        // Receive
+        this.beforeReceive       = new MiddlewarePipeline('before-receive');
+        this.afterReceive        = new MiddlewarePipeline('after-receive');
+
+        // Decode
+        this.beforeDecode        = new MiddlewarePipeline('before-decode');
+        this.afterDecode         = new MiddlewarePipeline('after-decode');
+
+        // Upload media
+        this.beforeUploadMedia   = new MiddlewarePipeline('before-upload-media');
+        this.afterUploadMedia    = new MiddlewarePipeline('after-upload-media');
+
+        // Download media
+        this.beforeDownloadMedia = new MiddlewarePipeline('before-download-media');
+        this.afterDownloadMedia  = new MiddlewarePipeline('after-download-media');
+
+        // Encrypt / Decrypt
+        this.beforeEncrypt       = new MiddlewarePipeline('before-encrypt');
+        this.afterEncrypt        = new MiddlewarePipeline('after-encrypt');
+        this.beforeDecrypt       = new MiddlewarePipeline('before-decrypt');
+        this.afterDecrypt        = new MiddlewarePipeline('after-decrypt');
+    }
+
+    use(name, fn, priority = 0) {
+        if (!this[name] || !(this[name] instanceof MiddlewarePipeline))
+            throw new Error(`[PipelineRegistry] Pipeline "${name}" tidak dikenal`);
+        this[name].use(fn, priority);
+        return this;
+    }
+
+    hook(event, handler) { this.hooks.on(event, handler); return this; }
+
+    clearAll() {
+        for (const key of Object.keys(this))
+            if (this[key] instanceof MiddlewarePipeline) this[key].clear();
+        this.hooks.removeAll();
+        return this;
+    }
+}
+
+export const globalPipeline = new PipelineRegistry();
+
+// ─────────────────────────────────────────────
+// LIFECYCLE EVENTS
+// ─────────────────────────────────────────────
+
+export const LifecycleEvents = Object.freeze({
+    MESSAGE_CREATE:        'message:create',
+    MESSAGE_PREPARE:       'message:prepare',
+    MESSAGE_ENCODE:        'message:encode',
+    MESSAGE_SEND:          'message:send',
+    MESSAGE_SUCCESS:       'message:success',
+    MESSAGE_ERROR:         'message:error',
+    MESSAGE_RETRY:         'message:retry',
+
+    MESSAGE_RECEIVE:       'message:receive',
+    MESSAGE_DECODE:        'message:decode',
+    MESSAGE_DECRYPT:       'message:decrypt',
+    MESSAGE_UPDATE:        'message:update',
+    MESSAGE_DELETE:        'message:delete',
+
+    SEND_START:            'send:start',
+    SEND_FINISH:           'send:finish',
+    SEND_RETRY:            'send:retry',
+    SEND_FAILED:           'send:failed',
+
+    MEDIA_UPLOAD_START:    'media:upload:start',
+    MEDIA_UPLOAD_END:      'media:upload:end',
+    MEDIA_DOWNLOAD_START:  'media:download:start',
+    MEDIA_DOWNLOAD_END:    'media:download:end',
+
+    MESSAGE_PREPARED:      'message:prepared',
+    MESSAGE_VALIDATED:     'message:validated',
+    MESSAGE_QUEUED:        'message:queued',
+    MESSAGE_DEQUEUED:      'message:dequeued',
+    MESSAGE_ENCRYPTED:     'message:encrypted',
+    MESSAGE_DECRYPTED:     'message:decrypted',
+});

package/lib/Utils/message-plugin.js

@@ -0,0 +1,229 @@
+/**
+ * Plugin System — Plugin dapat memodifikasi payload/metadata, replace media/caption,
+ * tambah button, block message, audit — tanpa menyentuh kode inti.
+ */
+
+// ─────────────────────────────────────────────
+// PLUGIN BASE CLASS
+// ─────────────────────────────────────────────
+
+export class BasePlugin {
+    /** @param {string} name — nama unik plugin */
+    constructor(name) {
+        if (!name) throw new Error('Plugin harus memiliki nama');
+        this.name    = name;
+        this.version = '1.0.0';
+        this.enabled = true;
+    }
+
+    /** Dipanggil saat plugin di-install. Override untuk inisialisasi. */
+    async install(context) {}
+
+    /** Dipanggil saat plugin di-uninstall. Override untuk cleanup. */
+    async uninstall() {}
+
+    /** Middleware send: (ctx, next) => {} */
+    async onSend(ctx, next) { return next(); }
+
+    /** Middleware receive: (ctx, next) => {} */
+    async onReceive(ctx, next) { return next(); }
+
+    /** Hook lifecycle: (ctx, event) => {} */
+    async onHook(ctx, event) {}
+
+    enable()  { this.enabled = true;  return this; }
+    disable() { this.enabled = false; return this; }
+}
+
+// ─────────────────────────────────────────────
+// PLUGIN MANAGER
+// ─────────────────────────────────────────────
+
+export class PluginManager {
+    /**
+     * @param {object} opts
+     * @param {object} opts.logger
+     * @param {object} opts.hooks    — HookSystem
+     * @param {object} opts.metrics  — MetricsRegistry
+     */
+    constructor(opts = {}) {
+        this._logger  = opts.logger  ?? console;
+        this._hooks   = opts.hooks   ?? null;
+        this._metrics = opts.metrics ?? null;
+        this._plugins = new Map();  // name → plugin instance
+        this._socket  = null;
+        this._pipeline = null;
+    }
+
+    /**
+     * Attach ke socket & pipeline — dipanggil dari framework.attach()
+     */
+    attach(socket, pipeline) {
+        this._socket   = socket;
+        this._pipeline = pipeline;
+
+        // Wire semua plugin yang sudah di-install ke pipeline
+        for (const plugin of this._plugins.values()) {
+            if (plugin.enabled) this._wireToPipeline(plugin);
+        }
+    }
+
+    /**
+     * Install plugin.
+     * @param {BasePlugin|object} plugin
+     */
+    async install(plugin) {
+        if (!plugin?.name) throw new Error('[PluginManager] Plugin harus memiliki properti "name"');
+        if (this._plugins.has(plugin.name)) {
+            this._log('warn', `Plugin "${plugin.name}" sudah di-install, skip`);
+            return this;
+        }
+
+        try {
+            if (typeof plugin.install === 'function') {
+                await plugin.install({
+                    socket: this._socket,
+                    pipeline: this._pipeline,
+                    hooks: this._hooks,
+                    metrics: this._metrics,
+                    logger: this._logger,
+                });
+            }
+            this._plugins.set(plugin.name, plugin);
+
+            // Wire ke pipeline jika sudah ada
+            if (this._pipeline && plugin.enabled) {
+                this._wireToPipeline(plugin);
+            }
+
+            // Wire ke hook system
+            if (this._hooks && typeof plugin.onHook === 'function') {
+                this._hooks.onAny(async (ctx, event) => {
+                    if (plugin.enabled) {
+                        await plugin.onHook(ctx, event);
+                    }
+                });
+            }
+
+            this._log('info', `Plugin "${plugin.name}" v${plugin.version ?? '?'} berhasil di-install`);
+            if (this._metrics) this._metrics.inc('plugins.installed');
+        } catch (err) {
+            this._log('error', `Gagal install plugin "${plugin.name}": ${err?.message}`, { err });
+            throw err;
+        }
+        return this;
+    }
+
+    /**
+     * Uninstall plugin.
+     */
+    async uninstall(nameOrPlugin) {
+        const name   = typeof nameOrPlugin === 'string' ? nameOrPlugin : nameOrPlugin?.name;
+        const plugin = this._plugins.get(name);
+        if (!plugin) return this;
+
+        try {
+            if (typeof plugin.uninstall === 'function') await plugin.uninstall();
+            this._plugins.delete(name);
+            this._log('info', `Plugin "${name}" di-uninstall`);
+        } catch (err) {
+            this._log('warn', `Error saat uninstall plugin "${name}": ${err?.message}`);
+        }
+        return this;
+    }
+
+    /** Uninstall semua plugin */
+    async uninstallAll() {
+        for (const name of [...this._plugins.keys()]) await this.uninstall(name);
+    }
+
+    /** Ambil plugin berdasarkan nama */
+    get(name) { return this._plugins.get(name); }
+
+    /** List semua plugin yang ter-install */
+    list() {
+        return [...this._plugins.values()].map(p => ({
+            name: p.name, version: p.version, enabled: p.enabled,
+        }));
+    }
+
+    /** Enable plugin */
+    enablePlugin(name)  { const p = this._plugins.get(name); if (p) p.enable();  return this; }
+
+    /** Disable plugin */
+    disablePlugin(name) { const p = this._plugins.get(name); if (p) p.disable(); return this; }
+
+    /**
+     * Jalankan semua plugin onSend terhadap context.
+     * Dipanggil dari relayMessageWithPipeline sebelum send.
+     */
+    async applyToSend(ctx) {
+        for (const plugin of this._plugins.values()) {
+            if (!plugin.enabled) continue;
+            if (typeof plugin.onSend !== 'function') continue;
+            if (ctx.cancelled) break;
+            try {
+                await new Promise(async (resolve, reject) => {
+                    try {
+                        await plugin.onSend(ctx, resolve);
+                    } catch (err) {
+                        reject(err);
+                    }
+                });
+            } catch (err) {
+                this._log('warn', `Plugin "${plugin.name}" onSend error: ${err?.message}`);
+            }
+        }
+    }
+
+    /**
+     * Jalankan semua plugin onReceive terhadap context.
+     */
+    async applyToReceive(ctx) {
+        for (const plugin of this._plugins.values()) {
+            if (!plugin.enabled) continue;
+            if (typeof plugin.onReceive !== 'function') continue;
+            if (ctx.cancelled) break;
+            try {
+                await new Promise(async (resolve, reject) => {
+                    try {
+                        await plugin.onReceive(ctx, resolve);
+                    } catch (err) {
+                        reject(err);
+                    }
+                });
+            } catch (err) {
+                this._log('warn', `Plugin "${plugin.name}" onReceive error: ${err?.message}`);
+            }
+        }
+    }
+
+    // ── Internal ──────────────────────────────
+
+    _wireToPipeline(plugin) {
+        if (!this._pipeline) return;
+        // Wire onSend sebagai middleware before-send
+        if (typeof plugin.onSend === 'function') {
+            this._pipeline.beforeSend.use(
+                (ctx, next) => plugin.enabled ? plugin.onSend(ctx, next) : next(),
+                plugin.priority ?? 0
+            );
+        }
+        // Wire onReceive sebagai middleware before-receive
+        if (typeof plugin.onReceive === 'function') {
+            this._pipeline.beforeReceive.use(
+                (ctx, next) => plugin.enabled ? plugin.onReceive(ctx, next) : next(),
+                plugin.priority ?? 0
+            );
+        }
+    }
+
+    _log(level, msg, data) {
+        const prefix = '[PluginManager]';
+        if (this._logger?.[level]) this._logger[level](data ?? {}, `${prefix} ${msg}`);
+        else if (level === 'error') console.error(`${prefix} ${msg}`, data);
+        else console.log(`${prefix} ${msg}`, data);
+    }
+}
+
+export const globalPluginManager = new PluginManager();