@tryty/easydc-js 1.1.0 → 1.2.2

package/src/bot.js

@@ -2,11 +2,13 @@
 const fs = require('node:fs');
 const path = require('node:path');
 const { BotError, Stop, ValidationError } = require('./errors');
+const { normalizeOwners } = require('./owners');
 const { parse } = require('./parser');
 const { Interpreter } = require('./interpreter');
 const { Context } = require('./context');
 const { Database } = require('./database');
 const { createRegistry } = require('./functions');
+const { formatNumber } = require('./util');
 const { f } = require('./functions/helpers');
 
 const DEFAULT_INTENTS = [
@@ -38,6 +40,16 @@ const EVENT_TYPES = [
 ];
 const VAR_SCOPES = ['user', 'server', 'channel', 'global'];
 
+const ADAPTER_METHODS = ['get', 'set', 'delete'];
+const looksLikeAdapter = (d) => !!d && typeof d === 'object' && ADAPTER_METHODS.some((m) => typeof d[m] === 'function');
+
+/** Pastikan adapter database punya method wajib: get(key), set(key, value), delete(key). */
+function checkAdapter(adapter) {
+  const missing = ADAPTER_METHODS.filter((m) => typeof adapter?.[m] !== 'function');
+  if (missing.length) throw new BotError(`Adapter database tidak lengkap, method yang kurang: ${missing.join(', ')}`);
+  return adapter;
+}
+
 const wildcardToRegExp = (pattern) => new RegExp(
   `^${pattern.split('*').map((s) => s.replace(/[.+?^${}()|[\]\\]/g, '\\$&')).join('.*')}$`,
 );
@@ -69,7 +81,7 @@ class Bot {
     };
     opts.prefix = (Array.isArray(opts.prefix) ? opts.prefix : [opts.prefix]).filter((p) => typeof p === 'string' && p !== '');
     if (!opts.prefix.length && !opts.mentionPrefix) throw new BotError('Isi minimal satu prefix atau aktifkan mentionPrefix');
-    opts.owners = (Array.isArray(opts.owners) ? opts.owners : [opts.owners]).filter(Boolean).map(String);
+    opts.owners = normalizeOwners(opts.owners);
     opts.messages = {
       cooldown: '⏳ Tunggu %time% lagi sebelum memakai perintah ini.',
       error: '❌ Terjadi kesalahan saat menjalankan perintah.',
@@ -80,7 +92,9 @@ class Bot {
     this.client = null;
     this.registry = createRegistry();
     this.interpreter = new Interpreter();
-    this.db = opts.database instanceof Database ? opts.database : new Database(opts.database);
+    this.db = looksLikeAdapter(opts.database) ? checkAdapter(opts.database) : new Database(opts.database);
+    this.plugins = new Map();
+    this._locks = new Map();
     this.cooldowns = new Map();
 
     this.commands = new Map(); // nama/alias -> handler
@@ -243,6 +257,16 @@ class Bot {
     return this.command({ name, aliases, code: EVAL_CODE });
   }
 
+  /**
+   * Pasang command tes otomatis (khusus owner) untuk menguji bot di Discord asli.
+   *   bot.selfTestCommand();             // lalu ketik: !selftest   atau   !selftest full
+   *   bot.selfTestCommand({ ui: true }); // + /tesauto & 2 menu klik-kanan untuk dicoba manual
+   */
+  selfTestCommand(def) {
+    // eslint-disable-next-line global-require
+    return require('./selftest').installSelfTest(this, def);
+  }
+
   /** Handler event. { type, channel?, code } */
   event(def) {
     if (!def || !EVENT_TYPES.includes(def.type)) {
@@ -280,6 +304,33 @@ class Bot {
   /** Jalan untuk setiap pesan yang BUKAN command. */
   onMessage(arg) { return this._eventShortcut('message', arg); }
 
+  /**
+   * Pasang plugin. Plugin = function(bot, opsi) atau object { name, install(bot, opsi) }.
+   * install harus sinkron (koneksi jaringan dilakukan adapter lewat connect()).
+   *   bot.use(mongodb({ uri: process.env.MONGO_URI, dbName: 'botku' }))
+   */
+  use(plugin, pluginOptions) {
+    const p = typeof plugin === 'function' ? { name: plugin.name || 'anonim', install: plugin } : plugin;
+    if (!p || typeof p.install !== 'function') {
+      throw new BotError('use: plugin harus berupa function atau object { name, install(bot) }');
+    }
+    const name = String(p.name ?? 'anonim');
+    if (name !== 'anonim' && this.plugins.has(name)) throw new BotError(`Plugin "${name}" sudah terpasang`);
+    const result = p.install(this, pluginOptions);
+    if (result && typeof result.then === 'function') {
+      throw new BotError(`Plugin "${name}": install() tidak boleh async. Lakukan koneksi di method connect() milik adapter`);
+    }
+    this.plugins.set(name, p);
+    return this;
+  }
+
+  /** Ganti database. Adapter wajib punya get/set/delete; opsional: has, keys, flush, connect, close. */
+  setDatabase(adapter) {
+    if (this._started) throw new BotError('setDatabase harus dipanggil sebelum connect()');
+    this.db = checkAdapter(adapter);
+    return this;
+  }
+
   /** Deklarasi variabel + nilai awal: bot.variables({ uang: 0, bio: '-' }) */
   variables(vars) {
     if (!vars || typeof vars !== 'object') throw new BotError('variables: berikan object { nama: nilaiAwal }');
@@ -395,18 +446,49 @@ class Bot {
     return scope === 'global' ? `global:${name}` : `${scope}:${id}:${name}`;
   }
 
-  getVar(scope, name, id) {
+  // Semua akses variabel bersifat asinkron karena adapter database (mis. MongoDB) berjalan lewat jaringan.
+  async getVar(scope, name, id) {
     const key = this._varKey(scope, name, id);
-    const stored = this.db.get(key);
-    return stored === undefined ? this.declaredVars.get(name) : stored;
+    const stored = await this.db.get(key);
+    return stored === undefined || stored === null ? this.declaredVars.get(name) : stored;
+  }
+
+  async setVar(scope, name, value, id) {
+    await this.db.set(this._varKey(scope, name, id), String(value));
   }
 
-  setVar(scope, name, value, id) {
-    this.db.set(this._varKey(scope, name, id), String(value));
+  async resetVar(scope, name, id) {
+    await this.db.delete(this._varKey(scope, name, id));
   }
 
-  resetVar(scope, name, id) {
-    this.db.delete(this._varKey(scope, name, id));
+  /**
+   * Tambah (atau kurangi, bila negatif) variabel angka. Dijalankan berurutan per variabel di dalam satu proses,
+   * sehingga dua command bersamaan tidak saling menimpa. Mengembalikan nilai baru.
+   */
+  async incVar(scope, name, amount, id) {
+    const key = this._varKey(scope, name, id);
+    const add = Number(String(amount).trim());
+    if (String(amount).trim() === '' || !Number.isFinite(add)) throw new BotError(`Jumlah "${amount}" bukan angka`);
+    const prev = this._locks.get(key) ?? Promise.resolve();
+    let release;
+    const gate = new Promise((resolve) => { release = resolve; });
+    const chain = prev.then(() => gate);
+    this._locks.set(key, chain);
+    await prev;
+    try {
+      const stored = await this.db.get(key);
+      const current = stored === undefined || stored === null ? this.declaredVars.get(name) : stored;
+      const base = Number(String(current).trim());
+      if (String(current).trim() === '' || !Number.isFinite(base)) {
+        throw new BotError(`Variabel "${name}" bernilai "${current}", bukan angka`);
+      }
+      const next = formatNumber(base + add);
+      await this.db.set(key, next);
+      return next;
+    } finally {
+      release();
+      if (this._locks.get(key) === chain) this._locks.delete(key);
+    }
   }
 
   // ===== Menjalankan =========================================================
@@ -748,6 +830,7 @@ class Bot {
       throw new BotError('Token bot belum diisi. Contoh: new Bot({ token: process.env.TOKEN })');
     }
     this.validate();
+    this._started = true;
     const discord = this._discord();
     const client = this.options.client ?? new discord.Client({
       intents: this._resolveIntents(discord),
@@ -757,19 +840,39 @@ class Bot {
     this._bind(client, discord);
     if (this.options.handleSignals && !this._signalsBound) {
       this._signalsBound = true;
-      const shutdown = () => { try { this.db.flush(); } catch { /* abaikan */ } process.exit(0); };
+      const shutdown = async () => {
+        const timeout = new Promise((resolve) => { setTimeout(resolve, 5000); });
+        try { await Promise.race([this.destroy(), timeout]); } catch { /* abaikan */ }
+        process.exit(0);
+      };
       process.once('SIGINT', shutdown);
       process.once('SIGTERM', shutdown);
-      process.once('exit', () => { try { this.db.flush(); } catch { /* abaikan */ } });
+      process.once('exit', () => {
+        try {
+          const r = this.db.flush?.();
+          if (r && typeof r.catch === 'function') r.catch(() => {});
+        } catch { /* abaikan */ }
+      });
+    }
+    try {
+      await this.db.connect?.();
+    } catch (e) {
+      throw new BotError(`Gagal terhubung ke database: ${e.message}`, { cause: e });
+    }
+    try {
+      await client.login(token);
+    } catch (e) {
+      try { await this.db.close?.(); } catch { /* abaikan */ }
+      throw e;
     }
-    await client.login(token);
     return this;
   }
 
-  /** Matikan bot dan simpan database. */
+  /** Matikan bot, simpan database, dan tutup koneksinya. */
   async destroy() {
-    this.db.flush();
+    await this.db.flush?.();
     if (this.client && typeof this.client.destroy === 'function') await this.client.destroy();
+    await this.db.close?.();
   }
 }
 

package/src/database.js

@@ -60,6 +60,9 @@ class Database {
     if (this._timer.unref) this._timer.unref();
   }
 
+  /** Dipanggil saat bot dimatikan: simpan data. */
+  close() { this.flush(); }
+
   /** Tulis ke disk sekarang juga (sinkron). */
   flush() {
     if (!this.file) return;
@@ -70,4 +73,24 @@ class Database {
   }
 }
 
-module.exports = { Database };
+/**
+ * Salin semua data dari satu database ke database lain (mis. file JSON -> MongoDB).
+ * Data yang sudah ada di tujuan tidak ditimpa, kecuali overwrite: true.
+ * Kedua adapter harus sudah connect() bila perlu, dan `from` wajib punya method keys().
+ * Mengembalikan { copied, skipped }.
+ */
+async function copyDatabase(from, to, { overwrite = false, prefix = '' } = {}) {
+  if (typeof from?.keys !== 'function') throw new Error('copyDatabase: database asal harus punya method keys()');
+  let copied = 0;
+  let skipped = 0;
+  for (const key of await from.keys(prefix)) {
+    if (!overwrite && (await to.get(key)) !== undefined) { skipped++; continue; }
+    const value = await from.get(key);
+    if (value === undefined) continue;
+    await to.set(key, value);
+    copied++;
+  }
+  return { copied, skipped };
+}
+
+module.exports = { Database, copyDatabase };

package/src/functions/control.js

@@ -2,6 +2,7 @@
 const { BotError, Stop } = require('../errors');
 const { parseTime, formatDuration } = require('../util');
 const { f, list, cleanId } = require('./helpers');
+const { isOwner } = require('../owners');
 
 const MAX_WAIT = 60 * 1000;
 const MAX_DELETE_IN = 24 * 60 * 60 * 1000;
@@ -45,7 +46,7 @@ module.exports = [
     }),
   f('onlyOwner', { max: 1, lazy: true, s: '[pesan?]', d: 'Lanjut hanya jika pengirim ada di opsi owners' },
     async (ctx, args, api) => {
-      if (ctx.bot.options.owners.includes(ctx.user?.id)) return '';
+      if (isOwner(ctx, '$onlyOwner')) return '';
       throw new Stop(await msgOf(api, args, 0));
     }),
   f('onlyForIDs', { b: 'required', min: 1, max: 2, lazy: true, s: '[id1,id2;pesan?]', d: 'Lanjut hanya untuk user dengan ID tertentu' },

package/src/functions/eval.js

@@ -3,6 +3,7 @@ const util = require('node:util');
 const { BotError, Stop } = require('../errors');
 const { parse } = require('../parser');
 const { f } = require('./helpers');
+const { isOwner } = require('../owners');
 
 const AsyncFunction = Object.getPrototypeOf(async () => {}).constructor;
 const MAX_OUTPUT = 1800;
@@ -13,7 +14,7 @@ function guard(ctx, label) {
   if (!ctx.bot.options.eval) {
     throw new Stop(`❌ ${label} dimatikan. Nyalakan dengan new Bot({ eval: true, owners: ['ID_KAMU'] }).`);
   }
-  if (!ctx.bot.options.owners.includes(ctx.user?.id)) throw new Stop('❌ Hanya owner bot yang boleh memakai eval.');
+  if (!isOwner(ctx, label)) throw new Stop('❌ Hanya owner bot yang boleh memakai eval.');
 }
 
 function clean(ctx, text) {

package/src/functions/messages.js

@@ -88,8 +88,8 @@ module.exports = [
       return '';
     }),
 
-  f('createThread', { b: 'required', min: 1, max: 3, s: '[nama;messageID?;arsipOtomatisMenit?]', d: 'Buat thread (dari pesan bila messageID diisi). Arsip: 60/1440/4320/10080. Mengembalikan ID thread' },
-    async (ctx, [name, mid, archive]) => {
+  f('createThread', { b: 'required', min: 1, max: 4, s: '[nama;messageID?;arsipOtomatisMenit?;channelID?]', d: 'Buat thread (dari pesan bila messageID diisi; channelID = channel tempat pesan itu, bawaan channel ini). Arsip: 60/1440/4320/10080. Mengembalikan ID thread' },
+    async (ctx, [name, mid, archive, cid]) => {
       if (!name.trim()) throw new BotError('Nama thread tidak boleh kosong');
       const opts = { name: limit('nama', name.trim(), 100) };
       if (has(archive)) {
@@ -99,10 +99,11 @@ module.exports = [
       }
       let thread;
       if (has(mid)) {
-        thread = await (await fetchMessage(ctx, mid)).startThread(opts);
+        thread = await (await fetchMessage(ctx, mid, cid)).startThread(opts);
       } else {
-        if (!ctx.channel?.threads || typeof ctx.channel.threads.create !== 'function') throw new BotError('Channel ini tidak mendukung thread');
-        thread = await ctx.channel.threads.create(opts);
+        const ch = await channelOrCurrent(ctx, cid);
+        if (!ch.threads || typeof ch.threads.create !== 'function') throw new BotError('Channel ini tidak mendukung thread');
+        thread = await ch.threads.create(opts);
       }
       return thread.id;
     }),

package/src/functions/vars.js

@@ -17,21 +17,25 @@ for (const [Scope, scope, defaultId, label] of SCOPES) {
   };
   out.push(
     f(`set${Scope}Var`, { b: 'required', min: 2, max: 3, s: `[nama;nilai;${label}ID?]`, d: `Simpan variabel ${label} (harus dideklarasikan dengan bot.variables)` },
-      (ctx, [name, value, id]) => { ctx.bot.setVar(scope, name, value, idFor(ctx, id)); return ''; }),
+      async (ctx, [name, value, id]) => { await ctx.bot.setVar(scope, name, value, idFor(ctx, id)); return ''; }),
     f(`get${Scope}Var`, { b: 'required', min: 1, max: 2, s: `[nama;${label}ID?]`, d: `Baca variabel ${label}` },
       (ctx, [name, id]) => ctx.bot.getVar(scope, name, idFor(ctx, id))),
     f(`reset${Scope}Var`, { b: 'required', min: 1, max: 2, s: `[nama;${label}ID?]`, d: `Kembalikan variabel ${label} ke nilai awal` },
-      (ctx, [name, id]) => { ctx.bot.resetVar(scope, name, idFor(ctx, id)); return ''; }),
+      async (ctx, [name, id]) => { await ctx.bot.resetVar(scope, name, idFor(ctx, id)); return ''; }),
+    f(`inc${Scope}Var`, { b: 'required', min: 2, max: 3, s: `[nama;jumlah;${label}ID?]`, d: `Tambah variabel ${label} berupa angka (jumlah negatif = kurangi). Aman dari tabrakan antar command. Tidak menampilkan apa pun` },
+      async (ctx, [name, amount, id]) => { await ctx.bot.incVar(scope, name, amount, idFor(ctx, id)); return ''; }),
   );
 }
 
 out.push(
   f('setGlobalVar', { b: 'required', min: 2, max: 2, s: '[nama;nilai]', d: 'Simpan variabel global' },
-    (ctx, [name, value]) => { ctx.bot.setVar('global', name, value, null); return ''; }),
+    async (ctx, [name, value]) => { await ctx.bot.setVar('global', name, value, null); return ''; }),
   f('getGlobalVar', { b: 'required', min: 1, max: 1, s: '[nama]', d: 'Baca variabel global' },
     (ctx, [name]) => ctx.bot.getVar('global', name, null)),
   f('resetGlobalVar', { b: 'required', min: 1, max: 1, s: '[nama]', d: 'Kembalikan variabel global ke nilai awal' },
-    (ctx, [name]) => { ctx.bot.resetVar('global', name, null); return ''; }),
+    async (ctx, [name]) => { await ctx.bot.resetVar('global', name, null); return ''; }),
+  f('incGlobalVar', { b: 'required', min: 2, max: 2, s: '[nama;jumlah]', d: 'Tambah variabel global berupa angka (jumlah negatif = kurangi)' },
+    async (ctx, [name, amount]) => { await ctx.bot.incVar('global', name, amount, null); return ''; }),
 );
 
 module.exports = out;

package/src/index.js

@@ -1,6 +1,6 @@
 'use strict';
 const { Bot } = require('./bot');
-const { Database } = require('./database');
+const { Database, copyDatabase } = require('./database');
 const { Context } = require('./context');
 const { BotError, ParseError, ValidationError } = require('./errors');
 const { parse } = require('./parser');
@@ -9,6 +9,7 @@ const { createRegistry, CATEGORIES } = require('./functions');
 module.exports = {
   Bot,
   Database,
+  copyDatabase,
   Context,
   BotError,
   ParseError,

package/src/owners.js

@@ -0,0 +1,36 @@
+'use strict';
+const { BotError } = require('./errors');
+
+/** Rapikan daftar owners: wajib string; angka besar ditolak karena ID Discord kehilangan ketelitian. */
+function normalizeOwners(input) {
+  const list = Array.isArray(input) ? input : [input];
+  const out = [];
+  for (const raw of list) {
+    if (raw === undefined || raw === null || raw === '' || raw === false) continue;
+    if (typeof raw === 'number' && !Number.isSafeInteger(raw)) {
+      throw new BotError(
+        `owners: angka ${raw} tidak akurat karena ID Discord terlalu besar untuk angka JavaScript. ` +
+        'Tulis ID dengan tanda kutip, contoh: owners: ["123456789012345678"]',
+      );
+    }
+    let id = String(raw).trim();
+    const mention = /^<@!?(\d+)>$/.exec(id);
+    if (mention) id = mention[1];
+    id = id.replace(/[​-‍]/g, '');
+    if (id) out.push(id);
+  }
+  return out;
+}
+
+/** Cek owner; bila ditolak, tulis petunjuk ke konsol agar mudah dicari penyebabnya. */
+function isOwner(ctx, label) {
+  const id = ctx.user?.id;
+  const owners = ctx.bot.options.owners;
+  if (owners.includes(id)) return true;
+  // eslint-disable-next-line no-console
+  console.warn(`[easydc] ${label} ditolak: ID pengirim = "${id}", owners yang terdaftar = ${JSON.stringify(owners)}. ` +
+    'Salin ID pengirim ke owners (dengan tanda kutip) bila itu memang akunmu.');
+  return false;
+}
+
+module.exports = { normalizeOwners, isOwner };

package/src/plugins/mongodb.js

@@ -0,0 +1,140 @@
+'use strict';
+const { BotError } = require('../errors');
+
+const MISSING = Symbol('missing');
+const escapeRegex = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+
+/**
+ * Adapter database MongoDB. Setiap variabel = satu dokumen { _id: kunci, v: nilai, t: waktuUbah }.
+ *
+ * Opsi:
+ *  - uri          alamat MongoDB (wajib kecuali memberi `client`), mis. process.env.MONGO_URI
+ *  - dbName       nama database (bila kosong dipakai nama dari URI, atau "test")
+ *  - collection   nama collection, bawaan "easydc"
+ *  - cache        true (bawaan): simpan data yang sudah dibaca di RAM. Matikan (false) bila
+ *                 LEBIH DARI SATU proses bot memakai database yang sama.
+ *  - cacheLimit   maksimal jumlah kunci di cache (bawaan 10000)
+ *  - client       MongoClient milik sendiri (tidak ditutup otomatis)
+ *  - driver       modul mongodb sendiri (untuk pengujian)
+ *  - clientOptions opsi tambahan untuk new MongoClient(uri, opsi)
+ */
+class MongoDatabase {
+  constructor(options = {}) {
+    if (!options.uri && !options.client) {
+      throw new BotError('mongodb: opsi "uri" wajib diisi. Contoh: mongodb({ uri: process.env.MONGO_URI, dbName: "botku" })');
+    }
+    this.options = options;
+    this.client = options.client ?? null;
+    this._ownsClient = !options.client;
+    this.collectionName = options.collection ?? 'easydc';
+    if (typeof this.collectionName !== 'string' || !/^[^$\0]{1,120}$/.test(this.collectionName) || this.collectionName.startsWith('system.')) {
+      throw new BotError(`mongodb: nama collection "${this.collectionName}" tidak valid`);
+    }
+    this.useCache = options.cache !== false;
+    this.cacheLimit = options.cacheLimit ?? 10000;
+    this.cache = new Map();
+    this._gen = new Map();
+    this.col = null;
+  }
+
+  _loadDriver() {
+    if (this.options.driver) return this.options.driver;
+    try {
+      // eslint-disable-next-line global-require
+      return require('mongodb');
+    } catch (e) {
+      throw new BotError('Package "mongodb" tidak ditemukan. Jalankan: npm install mongodb', { cause: e });
+    }
+  }
+
+  async connect() {
+    if (this.col) return;
+    if (!this.client) {
+      const { MongoClient } = this._loadDriver();
+      this.client = new MongoClient(this.options.uri, { serverSelectionTimeoutMS: 10000, ...this.options.clientOptions });
+    }
+    await this.client.connect();
+    this.col = this.client.db(this.options.dbName).collection(this.collectionName);
+  }
+
+  _ready() {
+    if (!this.col) throw new BotError('Database MongoDB belum terhubung. Pastikan bot.connect() sudah dipanggil');
+    return this.col;
+  }
+
+  _touch(key) { this._gen.set(key, (this._gen.get(key) ?? 0) + 1); }
+
+  _remember(key, value) {
+    if (!this.useCache) return;
+    this.cache.delete(key); // pindahkan ke posisi terbaru
+    this.cache.set(key, value);
+    if (this.cache.size > this.cacheLimit) this.cache.delete(this.cache.keys().next().value);
+  }
+
+  async get(key) {
+    if (this.useCache && this.cache.has(key)) {
+      const hit = this.cache.get(key);
+      return hit === MISSING ? undefined : hit;
+    }
+    const col = this._ready();
+    const gen = this._gen.get(key) ?? 0;
+    const doc = await col.findOne({ _id: key });
+    // Jangan isi cache bila kunci ini diubah selagi kita membaca (supaya tidak menyimpan data basi)
+    if ((this._gen.get(key) ?? 0) === gen) this._remember(key, doc ? doc.v : MISSING);
+    return doc ? doc.v : undefined;
+  }
+
+  async has(key) { return (await this.get(key)) !== undefined; }
+
+  async set(key, value) {
+    const col = this._ready();
+    this._touch(key);
+    await col.updateOne({ _id: key }, { $set: { v: value, t: new Date() } }, { upsert: true });
+    this._touch(key);
+    this._remember(key, value);
+  }
+
+  async delete(key) {
+    const col = this._ready();
+    this._touch(key);
+    const res = await col.deleteOne({ _id: key });
+    this._touch(key);
+    this._remember(key, MISSING);
+    return (res?.deletedCount ?? 0) > 0;
+  }
+
+  /** Daftar kunci berawalan `prefix` (langsung dari database, bukan dari cache). */
+  async keys(prefix = '') {
+    const col = this._ready();
+    const filter = prefix ? { _id: { $regex: `^${escapeRegex(prefix)}` } } : {};
+    const docs = await col.find(filter, { projection: { _id: 1 } }).toArray();
+    return docs.map((d) => d._id);
+  }
+
+  /** Penulisan ke MongoDB langsung (tanpa antrean), jadi tidak ada yang perlu di-flush. */
+  async flush() {}
+
+  async close() {
+    this.cache.clear();
+    this._gen.clear();
+    const had = this.col;
+    this.col = null;
+    if (had && this._ownsClient && this.client) await this.client.close();
+  }
+}
+
+/**
+ * Plugin MongoDB untuk Bot.
+ *   const { mongodb } = require('@tryty/easydc-js/mongodb');
+ *   bot.use(mongodb({ uri: process.env.MONGO_URI, dbName: 'botku' }));
+ */
+function mongodb(options) {
+  return {
+    name: 'mongodb',
+    install(bot) {
+      bot.setDatabase(new MongoDatabase(options));
+    },
+  };
+}
+
+module.exports = { mongodb, MongoDatabase };