@tryty/easydc-js 0.0.0-stage → 1.2.0

package/src/parser.js

@@ -0,0 +1,168 @@
+'use strict';
+const { ParseError } = require('./errors');
+
+// Karakter yang bisa di-escape dengan backslash: \$ \[ \] \; \\
+const ESCAPABLE = '$[];\\';
+const IDENT = /[A-Za-z][A-Za-z0-9_]*/y;
+const BLOCK = new Set(['if', 'elseif', 'else', 'endif']);
+
+function lineCol(root, pos) {
+  let line = 1;
+  let col = 1;
+  for (let i = 0; i < pos && i < root.length; i++) {
+    if (root[i] === '\n') { line++; col = 1; } else col++;
+  }
+  return { line, col };
+}
+
+function fail(message, pos, state) {
+  return new ParseError(message, lineCol(state.root, pos));
+}
+
+/** Cari "]" penutup yang cocok untuk "[" di indeks `open` (menghormati escape & nesting). */
+function findClose(src, open) {
+  let depth = 0;
+  for (let i = open; i < src.length; i++) {
+    const c = src[i];
+    if (c === '\\') { i++; continue; }
+    if (c === '[') depth++;
+    else if (c === ']') {
+      depth--;
+      if (depth === 0) return i;
+    }
+  }
+  return -1;
+}
+
+/** Pecah isi kurung dengan ";" level-0 lalu parse tiap argumen. */
+function splitArgs(inner, base, state) {
+  if (inner === '') return [];
+  const ranges = [];
+  let depth = 0;
+  let start = 0;
+  for (let i = 0; i < inner.length; i++) {
+    const c = inner[i];
+    if (c === '\\') { i++; continue; }
+    if (c === '[') depth++;
+    else if (c === ']') depth--;
+    else if (c === ';' && depth === 0) { ranges.push([start, i]); start = i + 1; }
+  }
+  ranges.push([start, inner.length]);
+  return ranges.map(([s, e]) => structure(parseFlat(inner.slice(s, e), base + s, state), state));
+}
+
+function describeArity(def) {
+  if (def.min === def.max) return `tepat ${def.min}`;
+  if (def.max === Infinity) return `minimal ${def.min}`;
+  return `${def.min}-${def.max}`;
+}
+
+/** Tahap 1: teks + pemanggilan fungsi (belum ada struktur $if). */
+function parseFlat(src, base, state) {
+  const nodes = [];
+  let text = '';
+  const flush = () => {
+    if (text) { nodes.push({ type: 'text', value: text }); text = ''; }
+  };
+  let i = 0;
+  while (i < src.length) {
+    const ch = src[i];
+    if (ch === '\\' && i + 1 < src.length && ESCAPABLE.includes(src[i + 1])) {
+      text += src[i + 1];
+      i += 2;
+      continue;
+    }
+    if (ch !== '$') { text += ch; i++; continue; }
+
+    IDENT.lastIndex = i + 1;
+    const m = IDENT.exec(src);
+    if (!m) { text += '$'; i++; continue; } // "$5", "$" sendirian = teks biasa
+
+    const ident = m[0];
+    let len = 0;
+    for (let l = ident.length; l >= 1; l--) {
+      if (state.registry.has(ident.slice(0, l).toLowerCase())) { len = l; break; }
+    }
+    if (!len) {
+      throw fail(`Fungsi $${ident} tidak dikenal (kalau maksudnya teks biasa, tulis \\$${ident})`, base + i, state);
+    }
+    const def = state.registry.get(ident.slice(0, len).toLowerCase());
+    let j = i + 1 + len;
+    let args = null;
+    if (src[j] === '[' && def.brackets !== 'none') {
+      const close = findClose(src, j);
+      if (close === -1) throw fail(`Tanda ] penutup untuk ${def.display} tidak ditemukan`, base + i, state);
+      args = splitArgs(src.slice(j + 1, close), base + j + 1, state);
+      j = close + 1;
+    }
+    if (def.brackets === 'required' && args === null) {
+      throw fail(`${def.display} wajib memakai tanda kurung, contoh: ${def.display}[...]`, base + i, state);
+    }
+    const n = args ? args.length : 0;
+    if (n < def.min || n > def.max) {
+      throw fail(`${def.display} membutuhkan ${describeArity(def)} argumen, tetapi diberi ${n}`, base + i, state);
+    }
+    flush();
+    nodes.push({ type: 'fn', name: def.name, def, args, pos: base + i });
+    if (BLOCK.has(def.name)) {
+      if (src[j] === '\r' && src[j + 1] === '\n') j += 2;
+      else if (src[j] === '\n') j += 1;
+    }
+    i = j;
+  }
+  flush();
+  return nodes;
+}
+
+/** Tahap 2: ubah $if/$elseif/$else/$endif menjadi node blok. */
+function structure(nodes, state) {
+  const root = { kind: 'root', body: [] };
+  const stack = [root];
+  const top = () => stack[stack.length - 1];
+
+  for (const node of nodes) {
+    if (node.type !== 'fn' || !BLOCK.has(node.def.name)) { top().body.push(node); continue; }
+    const name = node.def.name;
+    if (name === 'if') {
+      const frame = { kind: 'if', pos: node.pos, branches: [], body: null, sawElse: false };
+      const branch = { cond: node.args[0], body: [] };
+      frame.branches.push(branch);
+      frame.body = branch.body;
+      stack.push(frame);
+      continue;
+    }
+    const frame = top();
+    if (frame.kind !== 'if') throw fail(`${node.def.display} tanpa $if di depannya`, node.pos, state);
+    if (name === 'elseif') {
+      if (frame.sawElse) throw fail('$elseif tidak boleh setelah $else', node.pos, state);
+      const branch = { cond: node.args[0], body: [] };
+      frame.branches.push(branch);
+      frame.body = branch.body;
+    } else if (name === 'else') {
+      if (frame.sawElse) throw fail('$else tidak boleh dipakai dua kali dalam satu $if', node.pos, state);
+      frame.sawElse = true;
+      const branch = { cond: null, body: [] };
+      frame.branches.push(branch);
+      frame.body = branch.body;
+    } else {
+      stack.pop();
+      top().body.push({ type: 'if', branches: frame.branches, pos: frame.pos });
+    }
+  }
+  if (stack.length > 1) {
+    throw fail('$if tidak ditutup, tambahkan $endif', top().pos, state);
+  }
+  return root.body;
+}
+
+/**
+ * Parse kode menjadi AST. `registry` = Map(namaLowercase -> definisi fungsi).
+ * Melempar ParseError (dengan baris/kolom) bila ada kesalahan.
+ */
+function parse(code, registry) {
+  const src = String(code ?? '');
+  const state = { root: src, registry };
+  return structure(parseFlat(src, 0, state), state);
+}
+
+module.exports = { parse };

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('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 };

package/src/util.js

@@ -0,0 +1,188 @@
+'use strict';
+const { BotError } = require('./errors');
+
+const UNITS = { ms: 1, s: 1000, m: 60000, h: 3600000, d: 86400000, w: 604800000 };
+
+/** "10s", "5m", "1h30m", "1500" (ms) -> milidetik. */
+function parseTime(input) {
+  const s = String(input ?? '').trim().toLowerCase().replace(/\s+/g, '');
+  if (!s) throw new BotError('Waktu kosong (contoh: 10s, 5m, 1h30m)');
+  if (/^\d+$/.test(s)) return Number(s);
+  const re = /(\d+(?:\.\d+)?)(ms|s|m|h|d|w)/y;
+  let total = 0;
+  let idx = 0;
+  while (idx < s.length) {
+    re.lastIndex = idx;
+    const m = re.exec(s);
+    if (!m) throw new BotError(`Format waktu salah: "${input}" (contoh: 10s, 5m, 1h30m)`);
+    total += Number(m[1]) * UNITS[m[2]];
+    idx = re.lastIndex;
+  }
+  return Math.round(total);
+}
+
+/** ms -> "1d 2h 3m 4s". */
+function formatDuration(ms) {
+  let s = Math.floor(Math.max(0, Number(ms) || 0) / 1000);
+  const d = Math.floor(s / 86400);
+  s -= d * 86400;
+  const h = Math.floor(s / 3600);
+  s -= h * 3600;
+  const m = Math.floor(s / 60);
+  s -= m * 60;
+  const parts = [];
+  if (d) parts.push(`${d}d`);
+  if (h) parts.push(`${h}h`);
+  if (m) parts.push(`${m}m`);
+  if (s || !parts.length) parts.push(`${s}s`);
+  return parts.join(' ');
+}
+
+/** Format angka hasil hitungan tanpa noise floating point. */
+function formatNumber(n) {
+  if (!Number.isFinite(n)) throw new BotError('Hasil hitungan bukan angka yang valid');
+  if (Number.isInteger(n)) return String(n);
+  return String(parseFloat(n.toPrecision(12)));
+}
+
+/** Kalkulator aman (tanpa eval). Mendukung + - * / % ^ ( ) dan fungsi umum. */
+function safeMath(expr) {
+  const src = String(expr ?? '').toLowerCase().replace(/\s+/g, '').replace(/\*\*/g, '^');
+  if (!src) throw new BotError('Ekspresi matematika kosong');
+  const FUNCS = {
+    sqrt: Math.sqrt, abs: Math.abs, round: Math.round, floor: Math.floor, ceil: Math.ceil,
+    trunc: Math.trunc, sign: Math.sign, log: Math.log, log10: Math.log10, min: Math.min,
+    max: Math.max, pow: Math.pow,
+  };
+  const CONSTS = { pi: Math.PI, e: Math.E };
+  let i = 0;
+
+  const fail = (msg) => { throw new BotError(`${msg} pada "${expr}"`); };
+  const peek = () => src[i];
+
+  function parseExpr() {
+    let v = parseTerm();
+    while (peek() === '+' || peek() === '-') {
+      const op = src[i++];
+      const r = parseTerm();
+      v = op === '+' ? v + r : v - r;
+    }
+    return v;
+  }
+  function parseTerm() {
+    let v = parseUnary();
+    while (peek() === '*' || peek() === '/' || peek() === '%') {
+      const op = src[i++];
+      const r = parseUnary();
+      if (op === '*') v *= r;
+      else {
+        if (r === 0) throw new BotError('Pembagian dengan nol');
+        v = op === '/' ? v / r : v % r;
+      }
+    }
+    return v;
+  }
+  function parseUnary() {
+    if (peek() === '-') { i++; return -parseUnary(); }
+    if (peek() === '+') { i++; return parseUnary(); }
+    return parsePow();
+  }
+  function parsePow() {
+    const base = parsePrimary();
+    if (peek() === '^') {
+      i++;
+      return Math.pow(base, parseUnary());
+    }
+    return base;
+  }
+  function parsePrimary() {
+    if (peek() === '(') {
+      i++;
+      const v = parseExpr();
+      if (peek() !== ')') fail('Kurung tutup ")" hilang');
+      i++;
+      return v;
+    }
+    const numRe = /\d+(?:\.\d+)?|\.\d+/y;
+    numRe.lastIndex = i;
+    const nm = numRe.exec(src);
+    if (nm) { i = numRe.lastIndex; return Number(nm[0]); }
+    const idRe = /[a-z_][a-z0-9_]*/y;
+    idRe.lastIndex = i;
+    const im = idRe.exec(src);
+    if (im) {
+      i = idRe.lastIndex;
+      const name = im[0];
+      if (peek() === '(') {
+        if (!Object.hasOwn(FUNCS, name)) fail(`Fungsi "${name}" tidak dikenal`);
+        i++;
+        const args = [];
+        if (peek() !== ')') {
+          args.push(parseExpr());
+          while (peek() === ',') { i++; args.push(parseExpr()); }
+        }
+        if (peek() !== ')') fail('Kurung tutup ")" hilang');
+        i++;
+        return FUNCS[name](...args);
+      }
+      if (Object.hasOwn(CONSTS, name)) return CONSTS[name];
+      fail(`"${name}" tidak dikenal`);
+    }
+    return fail(i >= src.length ? 'Ekspresi tidak lengkap' : `Karakter "${src[i]}" tidak valid`);
+  }
+
+  const result = parseExpr();
+  if (i < src.length) fail(`Karakter "${src[i]}" tidak valid`);
+  return result;
+}
+
+/** Pecah teks panjang jadi potongan <= limit (Discord: 2000). */
+function splitMessage(text, limit = 2000) {
+  const s = String(text ?? '');
+  if (!s.trim()) return [];
+  if (s.length <= limit) return [s];
+  const chunks = [];
+  let current = '';
+  const push = () => { if (current) { chunks.push(current); current = ''; } };
+  for (const line of s.split('\n')) {
+    let rest = line;
+    while (rest.length > limit) {
+      push();
+      chunks.push(rest.slice(0, limit));
+      rest = rest.slice(limit);
+    }
+    const candidate = current ? `${current}\n${rest}` : rest;
+    if (candidate.length > limit) { push(); current = rest; } else current = candidate;
+  }
+  push();
+  return chunks;
+}
+
+/** Format tanggal sederhana: token YYYY MM DD HH mm ss pada zona waktu tertentu. */
+function formatDate(ms, format, timeZone) {
+  let parts;
+  try {
+    parts = new Intl.DateTimeFormat('en-CA', {
+      timeZone, year: 'numeric', month: '2-digit', day: '2-digit',
+      hour: '2-digit', minute: '2-digit', second: '2-digit', hourCycle: 'h23',
+    }).formatToParts(new Date(ms));
+  } catch (e) {
+    throw new BotError(`Zona waktu "${timeZone}" tidak valid atau tanggal salah`, { cause: e });
+  }
+  const map = {};
+  for (const p of parts) map[p.type] = p.value;
+  const tokens = { YYYY: map.year, MM: map.month, DD: map.day, HH: map.hour, mm: map.minute, ss: map.second };
+  return String(format).replace(/YYYY|MM|DD|HH|mm|ss/g, (t) => tokens[t]);
+}
+
+/** 1234567 -> "1.234.567" (pemisah bisa diganti). */
+function numberSeparator(value, sep = ',') {
+  const s = String(value).trim();
+  if (!/^-?\d+(\.\d+)?$/.test(s)) throw new BotError(`"${s}" bukan angka`);
+  const neg = s.startsWith('-');
+  const [int, dec] = s.replace('-', '').split('.');
+  const grouped = int.replace(/\B(?=(\d{3})+(?!\d))/g, sep);
+  return `${neg ? '-' : ''}${grouped}${dec ? `.${dec}` : ''}`;
+}
+
+module.exports = { parseTime, formatDuration, formatNumber, safeMath, splitMessage, formatDate, numberSeparator };