@xbibzlibrary/telebibz 3.1.6 → 3.1.8

package/README.id.md

@@ -202,6 +202,7 @@ jadi `BotError` dan mengalir ke `opts.onError` atau reporter manusiawi.
 ```js
 const bot = new TeleBibz('TOKEN', {
   allowedUpdates: [...],   // batasi tipe update (default: tipe umum + Business)
+  maxConcurrentUpdates: 256, // batas update aktif (default: 256)
   onError: (err, ctx) {},  // handle error sendiri (default: reporter manusiawi)
   silent: false,           // tanpa banner boot
   dropPending: false,      // buang update lama saat start

package/README.md

@@ -201,6 +201,7 @@ and flows to `opts.onError` or the humanized reporter.
 ```js
 const bot = new TeleBibz('TOKEN', {
   allowedUpdates: [...],   // limit update types (default: common + Business types)
+  maxConcurrentUpdates: 256, // active update limit (default: 256)
   onError: (err, ctx) {},  // custom error handler (default: humanized reporter)
   silent: false,           // hide boot banner
   dropPending: false,      // discard old updates on start

package/index.d.ts

@@ -68,6 +68,8 @@ export interface SessionOptions {
 }
 export interface TeleBibzOptions {
   allowedUpdates?: string[];
+  /** Maximum active updates per bot process. Default: 256. Updates sharing a session key are serialized. */
+  maxConcurrentUpdates?: number;
   onError?: (err: unknown, ctx?: Context) => unknown;
   silent?: boolean;
   dropPending?: boolean;

package/lib/runner.js

@@ -1,18 +1,39 @@
-// lib/runner.js — long polling tahan banting (retry 409 & jaringan, backoff halus).
+// lib/runner.js — long polling tahan banting dengan dispatch konkuren.
 'use strict';
 
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 
 /**
- * Loop getUpdates; memanggil handleUpdate per update.
- *   stop() mengamaninya keluar loop dengan bersih.
- * Perilaku:
- *  - error jaringan (fetch gagal)      → retry 1 dtk
- *  - 409 (instance lain masih polling) → log callback onConflict + retry 5 dtk
- *  - error API lain                    → oper ke onFatal (default: berhenti bersih)
+ * Loop getUpdates dengan backpressure. Update dipanggil tanpa menunggu satu sama
+ * lain; handleUpdate mengatur batas worker dan urutan per session key. Promise
+ * yang masih berjalan tetap dilacak agar stop() dapat melakukan graceful drain.
  */
-async function pollLoop({ api, handleUpdate, allowedUpdates, dropPending, onConflict, onFatal, shouldStop, conflictDelay = 5000 }) {
+async function pollLoop({
+  api,
+  handleUpdate,
+  allowedUpdates,
+  dropPending,
+  onConflict,
+  onFatal,
+  shouldStop,
+  conflictDelay = 5000,
+  maxInFlightUpdates = 800,
+}) {
   let offset = 0;
+  const inFlight = new Set();
+  const inFlightLimit = Number.isSafeInteger(maxInFlightUpdates) && maxInFlightUpdates > 0
+    ? maxInFlightUpdates
+    : 800;
+
+  const dispatch = (update) => {
+    let task;
+    task = Promise.resolve()
+      .then(() => handleUpdate(update))
+      .catch(() => { /* error sudah ditangani bot; jangan hentikan poller */ })
+      .then(() => inFlight.delete(task));
+    inFlight.add(task);
+  };
+
   if (dropPending) {
     try {
       const u = await api.callApi('getUpdates', { offset: -1, timeout: 0, allowed_updates: allowedUpdates });
@@ -20,34 +41,44 @@ async function pollLoop({ api, handleUpdate, allowedUpdates, dropPending, onConf
     } catch { /* abaikan — loop utama yang menangani */ }
   }
 
-  while (!shouldStop()) {
-    let updates;
-    try {
-      updates = await api.callApi('getUpdates', { offset, timeout: 25, allowed_updates: allowedUpdates });
-      if (!Array.isArray(updates)) updates = [];
-    } catch (err) {
-      const code = err && (err.error_code || err.code);
-      if (shouldStop()) break;
-      if (code === 409) { if (onConflict) await onConflict(err); await sleep(conflictDelay); continue; }
-      if (code === 429) {
-        const retryAfter = Number(err && err.parameters && err.parameters.retry_after);
-        await sleep(Number.isFinite(retryAfter) && retryAfter >= 0 ? retryAfter * 1000 : 1000);
-        continue;
+  try {
+    while (!shouldStop()) {
+      let updates;
+      try {
+        updates = await api.callApi('getUpdates', { offset, timeout: 25, allowed_updates: allowedUpdates });
+        if (!Array.isArray(updates)) updates = [];
+      } catch (err) {
+        const code = err && (err.error_code || err.code);
+        if (shouldStop()) break;
+        if (code === 409) { if (onConflict) await onConflict(err); await sleep(conflictDelay); continue; }
+        if (code === 429) {
+          const retryAfter = Number(err && err.parameters && err.parameters.retry_after);
+          await sleep(Number.isFinite(retryAfter) && retryAfter >= 0 ? retryAfter * 1000 : 1000);
+          continue;
+        }
+        if (Number.isInteger(code) && code >= 500 && code < 600) { await sleep(1000); continue; }
+        const networkCode = err && ['ECONNABORTED', 'ETIMEDOUT', 'ECONNRESET', 'EAI_AGAIN', 'ENOTFOUND', 'EPIPE', 'ENETUNREACH', 'ECONNREFUSED'].includes(err.code);
+        if (!err || err.network || networkCode || !err.error_code) {
+          await sleep(1000); continue; // jaringan putus/time-out: retry, bukan fatal
+        }
+        if (onFatal) await onFatal(err);
+        break;
       }
-      if (Number.isInteger(code) && code >= 500 && code < 600) { await sleep(1000); continue; }
-      const networkCode = err && ['ECONNABORTED', 'ETIMEDOUT', 'ECONNRESET', 'EAI_AGAIN', 'ENOTFOUND', 'EPIPE', 'ENETUNREACH', 'ECONNREFUSED'].includes(err.code);
-      if (!err || err.network || networkCode || !err.error_code) {
-        await sleep(1000); continue; // jaringan putus/time-out: retry, bukan fatal
-      }
-      if (onFatal) await onFatal(err);
-      break;
-    }
 
-    for (const u of updates) {
-      if (shouldStop()) break;
-      offset = u.update_id + 1;
-      try { await handleUpdate(u); } catch { /* sudah ditangani error handler bot */ }
+      for (const update of updates) {
+        if (shouldStop()) break;
+        while (inFlight.size >= inFlightLimit) {
+          await Promise.race(inFlight);
+          if (shouldStop()) break;
+        }
+        if (shouldStop()) break;
+        offset = update.update_id + 1;
+        dispatch(update);
+      }
     }
+  } finally {
+    // Stop/fatal error menghentikan intake, bukan memutus handler yang sedang berjalan.
+    await Promise.all([...inFlight]);
   }
 }
 

package/lib/session.js

@@ -6,22 +6,41 @@
  *  - default getKey: from.id + chat.id (khas), fallback chat.id.
  *  - default storage: Map di memori. Boleh kirim storage custom { read(key), write(key,val), delete(key) }.
  */
-function session(opts = {}) {
-  const initial = opts.initial || (() => ({}));
-  const store = opts.storage || new Map();
-  const getKey = opts.getKey || ((ctx) => {
-    const from = ctx.from && ctx.from.id;
-    const chat = ctx.chat && ctx.chat.id;
+const SESSION_KEY_CACHE = Symbol('telebibz.sessionKeyCache');
+
+function getSessionKey(ctx, opts = {}) {
+  const cached = ctx[SESSION_KEY_CACHE];
+  if (cached) {
+    if (cached.failed) throw cached.error;
+    return cached.key;
+  }
+
+  const getKey = opts.getKey || ((current) => {
+    const from = current.from && current.from.id;
+    const chat = current.chat && current.chat.id;
     if (from !== undefined && chat !== undefined) return `${from}:${chat}`;
     return chat !== undefined ? String(chat) : undefined;
   });
+  try {
+    const key = getKey(ctx);
+    Object.defineProperty(ctx, SESSION_KEY_CACHE, { value: { key, failed: false } });
+    return key;
+  } catch (error) {
+    Object.defineProperty(ctx, SESSION_KEY_CACHE, { value: { error, failed: true } });
+    throw error;
+  }
+}
+
+function session(opts = {}) {
+  const initial = opts.initial || (() => ({}));
+  const store = opts.storage || new Map();
 
   const read = (k) => (store.read ? store.read(k) : store.get(k));
   const write = (k, v) => (store.write ? store.write(k, v) : store.set(k, v));
   const del = (k) => (store.delete ? store.delete(k) : store.delete(k));
 
   return async (ctx, next) => {
-    const key = getKey(ctx);
+    const key = getSessionKey(ctx, opts);
     if (key === undefined) { ctx.session = {}; return next(); }
     let s = await read(key);
     if (s === undefined || s === null) s = initial();
@@ -41,4 +60,4 @@ function session(opts = {}) {
   };
 }
 
-module.exports = { session };
+module.exports = { session, getSessionKey };

package/lib/telebibz.js

@@ -4,10 +4,11 @@
 const { makeApi } = require('./api');
 const { Context } = require('./context');
 const { Composer } = require('./composer');
-const { session } = require('./session');
+const { session, getSessionKey } = require('./session');
 const { matchInlineQuery } = require('./inline-query');
 const { Menu, MenuContainer } = require('./menus');
 const { pollLoop } = require('./runner');
+const { UpdateProcessor } = require('./update-processor');
 const wizard = require('./wizard');
 const log = require('./logger');
 const { humanize } = require('./errors');
@@ -22,11 +23,13 @@ const DEFAULT_UPDATES = [
   'purchased_paid_media', 'poll', 'poll_answer', 'my_chat_member', 'chat_member',
   'chat_join_request', 'chat_boost', 'removed_chat_boost', 'stopped_message_generation',
 ];
+const DEFAULT_MAX_CONCURRENT_UPDATES = 256;
 
 class TeleBibz {
   /**
    * new TeleBibz('123:ABC', {
-   *   allowedUpdates: [...], onError(err, ctx), silent, dropPending,
+   *   allowedUpdates: [...], maxConcurrentUpdates: 256,
+   *   onError(err, ctx), silent, dropPending,
    *   transport: (method, payload) => Promise<result>,   // ← suntik untuk test
    *   session: {...opsi session}, apiRoot: 'https://api.telegram.org'
    * })
@@ -35,8 +38,14 @@ class TeleBibz {
     if (!token || !/^\d+:[\w-]+$/.test(token)) {
       throw new Error('TeleBibz: token tidak valid. Ambil dari @BotFather → /newbot.');
     }
+    const maxConcurrentUpdates = opts.maxConcurrentUpdates ?? DEFAULT_MAX_CONCURRENT_UPDATES;
+    if (!Number.isSafeInteger(maxConcurrentUpdates) || maxConcurrentUpdates < 1) {
+      throw new RangeError('TeleBibz: maxConcurrentUpdates harus bilangan bulat positif.');
+    }
     this.opts = opts;
     this.token = token;
+    this.maxConcurrentUpdates = maxConcurrentUpdates;
+    this._updateProcessor = new UpdateProcessor(maxConcurrentUpdates);
     this.api = makeApi(token, opts.transport, opts);
     this.botInfo = undefined;
 
@@ -109,8 +118,25 @@ class TeleBibz {
   /** Tangani SATU update mentah (webhook/serverless/test). */
   async handleUpdate(update) {
     const ctx = new Context(update, this.api, this.botInfo);
-    try { await this._root.run(ctx); }
-    catch (err) { await this._report({ error: err, ctx }); }
+    await this._updateProcessor.process(this._updateKey(ctx), async () => {
+      try { await this._root.run(ctx); }
+      catch (err) { await this._report({ error: err, ctx }); }
+    });
+  }
+
+  /** Updates dengan session key sama berjalan berurutan; key berbeda berjalan paralel. */
+  _updateKey(ctx) {
+    let key;
+    try { key = getSessionKey(ctx, this.opts.session || {}); }
+    catch { /* session middleware reports the cached getKey error */ }
+    if (key !== undefined) return `session:${String(key)}`;
+
+    // Updates without a session key (for example inline queries) still keep a
+    // single sender's stateful handlers ordered when sender information exists.
+    const fromId = ctx.from && ctx.from.id;
+    if (fromId !== undefined) return `user:${String(fromId)}`;
+    const chatId = ctx.chat && ctx.chat.id;
+    return chatId === undefined ? undefined : `chat:${String(chatId)}`;
   }
 
   /** Nyalakan long polling (dengan retry 409 & backoff jaringan). */
@@ -130,6 +156,7 @@ class TeleBibz {
       api: this.api,
       handleUpdate: (u) => this.handleUpdate(u),
       allowedUpdates: this.opts.allowedUpdates || DEFAULT_UPDATES,
+      maxInFlightUpdates: Math.max(100, this.maxConcurrentUpdates * 4),
       dropPending: launchOpts.dropPending ?? this.opts.dropPending ?? false,
       shouldStop: () => this._stopping,
       conflictDelay: launchOpts.conflictDelay ?? 5000,

package/lib/update-processor.js

@@ -0,0 +1,56 @@
+'use strict';
+
+/**
+ * Execute independent updates concurrently while keeping a session key ordered.
+ * A Promise returned by process() resolves only after that update is complete.
+ */
+class UpdateProcessor {
+  constructor(maxConcurrentUpdates = 256) {
+    this.maxConcurrentUpdates = maxConcurrentUpdates;
+    this.active = 0;
+    this.pending = [];
+    this.activeKeys = new Set();
+  }
+
+  process(key, handler) {
+    return new Promise((resolve, reject) => {
+      this.pending.push({ key: normalizeKey(key), handler, resolve, reject });
+      this._drain();
+    });
+  }
+
+  _drain() {
+    while (this.active < this.maxConcurrentUpdates) {
+      // Preserve FIFO ordering for the same session, but skip a busy key so
+      // updates from other users can continue through the queue.
+      const index = this.pending.findIndex((task) => task.key === undefined || !this.activeKeys.has(task.key));
+      if (index === -1) return;
+
+      const [task] = this.pending.splice(index, 1);
+      if (task.key !== undefined) this.activeKeys.add(task.key);
+      this.active++;
+
+      Promise.resolve()
+        .then(task.handler)
+        .then(
+          (value) => task.resolve(value),
+          (error) => task.reject(error),
+        )
+        .then(() => {
+          this.active--;
+          if (task.key !== undefined) this.activeKeys.delete(task.key);
+          this._drain();
+        });
+    }
+  }
+}
+
+function normalizeKey(key) {
+  if (key === undefined) return undefined;
+  if (key === null) return 'null:null';
+  const type = typeof key;
+  if (!['string', 'number', 'bigint', 'boolean'].includes(type)) return undefined;
+  return `${type}:${String(key)}`;
+}
+
+module.exports = { UpdateProcessor };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xbibzlibrary/telebibz",
-  "version": "3.1.6",
+  "version": "3.1.8",
   "description": "Telegram Bot API 10.3 framework: all 185 methods with typed payloads, rich messages, live photos, drafts, ephemeral messages, inline queries, sessions, webhooks, menus and wizards. Xbibz Technology ID",
   "main": "index.js",
   "types": "index.d.ts",

package/test/all.test.js

@@ -6,7 +6,7 @@ const { TeleBibz, btn, url, kb, webApp, copy, humanize, File, InlineKeyboard,
   Menu, MenuContainer, iq, autoRetry, throttler, limiter, InputMediaBuilder } = require('..');
 
 let N = 0, OK = 0;
-const TOTAL = 30;
+const TOTAL = 33;
 const t = (nama, fn) => {
   const done = () => { N++; if (N === TOTAL) { console.log(`\n${OK}/${N} lulus`); process.exit(OK === N ? 0 : 1); } };
   Promise.resolve()
@@ -16,7 +16,7 @@ const t = (nama, fn) => {
 };
 
 /* ===== harness: bot dengan transport palsu (merekam panggilan API) ===== */
-function buatBot(overrides = {}) {
+function buatBot(overrides = {}, options = {}) {
   const calls = [];
   const transport = async (method, payload = {}) => {
     calls.push({ method, payload });
@@ -25,7 +25,7 @@ function buatBot(overrides = {}) {
     if (overrides[method]) return overrides[method](payload);
     return true;
   };
-  const bot = new TeleBibz('123456:TESTTOKEN-TESTTOKEN-TESTTOKEN-TESTOKEN', { silent: true, transport });
+  const bot = new TeleBibz('123456:TESTTOKEN-TESTTOKEN-TESTTOKEN-TESTOKEN', { ...options, silent: true, transport });
   return { bot, calls, me: null };
 }
 async function boot(b) { await b.init(); }
@@ -202,6 +202,68 @@ t('launch: getUpdates 409 → retry halus; stop() resolve runPromise', async ()
   assert.ok(polls >= 2, `harus retry minimal sekali, polls=${polls}`);
 });
 
+/* ===== Concurrency: 256 pengguna berbeda diproses tanpa serial menunggu ===== */
+t('handleUpdate menjalankan 256 pengguna secara konkuren secara default', async () => {
+  const { bot } = buatBot();
+  await boot(bot);
+  const target = 256;
+  let active = 0, peak = 0, started = 0, release;
+  const gate = new Promise((resolve) => { release = resolve; });
+  const fallback = setTimeout(release, 1000);
+  bot.on(':text', async () => {
+    active++;
+    started++;
+    peak = Math.max(peak, active);
+    if (started === target) release();
+    await gate;
+    active--;
+  });
+  const updates = Array.from({ length: target }, (_, i) => ({
+    update_id: 10000 + i,
+    message: { message_id: i + 1, date: 1, text: `user-${i}`, from: { id: i + 1 }, chat: { id: i + 1, type: 'private' } },
+  }));
+  await Promise.all(updates.map((update) => bot.handleUpdate(update)));
+  clearTimeout(fallback);
+  assert.equal(started, target);
+  assert.equal(peak, target, 'semua 256 update harus dapat berjalan bersamaan');
+});
+
+t('maxConcurrentUpdates membatasi worker update dan memvalidasi nilai', async () => {
+  const { bot } = buatBot({}, { maxConcurrentUpdates: 3 });
+  await boot(bot);
+  let active = 0, peak = 0;
+  bot.on(':text', async () => {
+    active++;
+    peak = Math.max(peak, active);
+    await new Promise((resolve) => setTimeout(resolve, 5));
+    active--;
+  });
+  const updates = Array.from({ length: 12 }, (_, i) => ({
+    update_id: 20000 + i,
+    message: { message_id: i + 1, date: 1, text: `user-${i}`, from: { id: i + 1 }, chat: { id: i + 1, type: 'private' } },
+  }));
+  await Promise.all(updates.map((update) => bot.handleUpdate(update)));
+  assert.equal(peak, 3);
+  assert.throws(() => new TeleBibz('123456:TESTTOKEN', { maxConcurrentUpdates: 0 }), /maxConcurrentUpdates/);
+});
+
+t('update dari session key sama tetap berurutan untuk menjaga state', async () => {
+  const { bot } = buatBot();
+  await boot(bot);
+  const order = [];
+  bot.on(':text', async (ctx) => {
+    order.push(`start:${ctx.msg.text}`);
+    await new Promise((resolve) => setTimeout(resolve, 5));
+    order.push(`end:${ctx.msg.text}`);
+  });
+  const makeUpdate = (update_id, text) => ({
+    update_id,
+    message: { message_id: update_id, date: 1, text, from: { id: 700 }, chat: { id: 700, type: 'private' } },
+  });
+  await Promise.all([bot.handleUpdate(makeUpdate(1, 'first')), bot.handleUpdate(makeUpdate(2, 'second'))]);
+  assert.deepEqual(order, ['start:first', 'end:first', 'start:second', 'end:second']);
+});
+
 /* ===== 15. Proxy API generik: metode apapun ===== */
 t('Proxy: api.metodeBebas(payload) → callApi mentah', async () => {
   const { bot, calls } = buatBot(); await boot(bot);

package/test/audit.test.js

@@ -77,6 +77,30 @@ async function main() {
     assert.equal(data.get('7:7').count, 2);
   });
 
+  await test('session.getKey dihitung sekali dan menjaga urutan lintas update', async () => {
+    let keyCalls = 0;
+    const storage = new Map();
+    const bot = new TeleBibz('123456:TESTTOKEN', {
+      silent: true,
+      transport: async () => true,
+      session: { storage, getKey: (ctx) => { keyCalls++; return String(ctx.from.id); } },
+    });
+    const observed = [];
+    bot.on(':text', async (ctx) => {
+      observed.push(ctx.session.count || 0);
+      await new Promise((resolve) => setTimeout(resolve, 2));
+      ctx.session.count = (ctx.session.count || 0) + 1;
+    });
+    const makeUpdate = (update_id, chatId) => ({
+      update_id,
+      message: { message_id: update_id, date: 1, text: 'increment', from: { id: 7 }, chat: { id: chatId, type: 'group' } },
+    });
+    await Promise.all([bot.handleUpdate(makeUpdate(1, 70)), bot.handleUpdate(makeUpdate(2, 71))]);
+    assert.equal(keyCalls, 2, 'getKey hanya perlu dipanggil sekali untuk setiap update');
+    assert.deepEqual(observed, [0, 1]);
+    assert.equal(storage.get('7').count, 2);
+  });
+
   await test('guest_message diteruskan ke Context dan answerGuestQuery membentuk payload resmi', async () => {
     const calls = [];
     const bot = new TeleBibz('123456:TESTTOKEN', { silent: true, transport: async (m, p) => { calls.push({ m, p }); return true; } });
@@ -135,6 +159,35 @@ async function main() {
     assert.equal(fatals, 0);
   });
 
+  await test('poller dispatch batch secara konkuren dan menunggu handler saat stop', async () => {
+    const updates = Array.from({ length: 12 }, (_, i) => ({ update_id: i + 1 }));
+    let polls = 0, stopped = false, active = 0, peak = 0, entered = 0, release;
+    const gate = new Promise((resolve) => { release = resolve; });
+    const fallback = setTimeout(release, 1000);
+    const api = { callApi: async () => {
+      polls++;
+      if (polls === 1) return updates;
+      stopped = true;
+      return [];
+    } };
+    await pollLoop({
+      api,
+      handleUpdate: async () => {
+        active++;
+        entered++;
+        peak = Math.max(peak, active);
+        if (entered === updates.length) release();
+        await gate;
+        active--;
+      },
+      allowedUpdates: [], dropPending: false, shouldStop: () => stopped, maxInFlightUpdates: updates.length,
+    });
+    clearTimeout(fallback);
+    assert.equal(entered, updates.length);
+    assert.equal(peak, updates.length, 'poller tidak boleh menunggu satu update sebelum dispatch berikutnya');
+    assert.equal(active, 0, 'pollLoop menyelesaikan graceful drain sebelum return');
+  });
+
   await test('throttler tetap menjalankan antrean setelah satu request gagal', async () => {
     const { throttler } = require('../lib/ratelimit');
     const calls = [];