README
npm -g install tgb
git clone https://github.com/Daeren/tgb.git
await require("tgb")("T", "sendmessage", [0, "+"], proxy)
await require("tgb").sendMessage("T", {chat_id: 0, text: "+"}, proxy)
> tgb-cli --polling TOKEN --echo -j
- QoS: dev
- WebHook: +
- Spy: +
- Download: +
- Proxy: +
- File as Buffer: +
- Abort/Pause: +
- TgUpload: +
- Markup: +
- Extensibility: +
- CLI: +
- Entities: +
- Redirect: +
- HashTable, Array and Map as a data source: +
- Without Dependencies: +
const tgb = require("tgb");
const token = process.env.TELEGRAM_BOT_TOKEN;
const {polling, entities} = tgb;
//-----------------------------------------------------
polling(token, function({message}, bot) {
bot.sendMessage([message.from.id, entities(message) || "empty"]);
}).catch(function(error) {
if(error.code === tgb.ERR_INVALID_TOKEN) {
this.stop();
console.log("There's a problem with the token...");
}
else {
delete error.response;
console.log(error);
}
});
// send: tg @gamebot /start x http://db.gg
// tgb.polling(token, onMsg(data, bot)).stop().start().stopped;
// tgb.polling(token, options{proxy, limit, timeout, interval}, onMsg(data, bot));
// tgb.polling(bot, onMsg(data));
// https://core.telegram.org/bots/api#getupdates
// https://core.telegram.org/bots/api#messageentity
WebHook
const tgb = require("tgb");
const bot = tgb(process.env.TELEGRAM_BOT_TOKEN);
const {webhook} = tgb;
//-----------------------------------------------------
void async function NGINX() {
const wh = await webhook({host: "localhost", port: 1490});
const url = await wh.bind(bot, "db.gg:88/custom", ({message}) => {});
}();
void async function HTTPS() {
const wh = (await webhook(8443, {
"ssl": {
"key": "./db.gg.key",
"cert": "./db.gg.crt"
}
})).catch(function(error) {}); // srv|cl errors
const url = await wh.bind(bot, "db.gg", function({message}, bot) {
this.sendMessage([message.from.id, `Hi: ${message.text}`]);
});
// url = https://db.gg:8443/tg_bot_<sha256(token)>
}();
// wh = await webhook(1490); // *:1490
// wh = await webhook({host: "localhost", port: 1490});
// url = await wh.bind(otherBot, "666.io:88", cb); // with api.setWebhook
// wh = wh.set(otherBot2, url, cb); // with no api.setWebhook
// url = await wh.unbind(otherBot); // with api.deleteWebhook
// wh = wh.delete(otherBot2); // with no api.deleteWebhook
// await wh.close();
// wh.bind(bot, options[url|objOpt.setWebhook], onMessage)
// wh.unbind(bot)
// wh.set(bot, url, onMessage)
// wh.delete(url)
// https://core.telegram.org/bots/api#setwebhook
// https://core.telegram.org/bots/self-signed
Spy
const bot = tgb(process.env.TELEGRAM_BOT_TOKEN);
const {webhook, spy, entities} = tgb;
//-----------------------------------------------------
void async function Webhook() {
const watch = spy();
const wh = await webhook({host: "localhost", port: 1490});
const url = await wh.bind(bot, "db.gg:88/custom", parseEntities);
function parseEntities(data, bot) {
const {message} = data;
if(message) {
const es = entities(message);
for(let type of Object.keys(es || {})) {
es[type].forEach((e) => data[`${type}${e}`] = message);
}
if(es) {
delete data.message;
}
}
// ^---| Mutation: bot_command, hashtag, etc
watch.update(data, bot);
}
// Second
watch("message.text", function() {}); // <|-
// |
// Third v---| Nested objects |
watch("message.from.id", function() {}); // |
// |
// Second |
watch("message.text", function() {}); // <|-
// v---| Base: always first
watch("message", function() {});
// ^---| Scope
// v---| Scope |-----v
watch("bot_command/start.text", function() {});
watch("bot_command/start", function() {});
// ^---| Base: always first
watch("hashtag#win", function() {});
// ^---| Scope
/*******************************************************
Nested objects: sort by depth |---v
[message[...], bot_command/start, hashtag#win]
^---| The Spy calls only the first available scope
| The Spy calls all listeners synchronously in the order in which they were registered
***/
}();
void async function Polling() {
const watch = spy({desc: true}); // Change the sort order
polling(bot, watch.update);
// Third
watch("message.text", function(val, bot, message) {
if(val === "die") {
this.destroy();
}
});
// Second
watch("message.from.id", function(val, bot, message) {});
// Base: always first
watch("message", function(val, bot, data) {});
}();
// EventEmitter => spy
// w = spy();
// w(type, listener(val, bot, data)); // set: listener.destroy()
// w.on(type, listener(val, bot, data));
// w.update(data[, bot]);
// https://core.telegram.org/bots/api#update
Download
const tgb = require("tgb");
const bot = tgb(process.env.TELEGRAM_BOT_TOKEN);
const {download} = tgb;
const fileId = "AgADAgAD36gxGwWj2EuIQ9vvX_3kbh-cmg4ABDhqGLqV07c_phkBAAEC";
//-----------------------------------------------------
void async function() {
await download(bot.token, fileId);
}();
// await tgb.download(token, fileId[, dir = "./", filename = ""]);
// https://core.telegram.org/bots/api#file
Proxy
const bot = tgb(process.env.TELEGRAM_BOT_TOKEN);
void async function() {
bot.proxy = "127.0.0.1:1337"; // Only HTTPS
try {
await bot.getMe();
await bot.getMe(null, "0.0.0.0:1337");
} catch(e) {
console.log(e);
}
}();
Abort/Pause/Resume
void async function() {
const bot = tgb(process.env.TELEGRAM_BOT_TOKEN);
const params = {"chat_id": "0", "audio": "O://1.mp3"};
const [res, req] = bot.sendAudio(params);
setTimeout(() => {
req.pause();
}, 500);
setTimeout(() => {
req.resume();
}, 2500);
setTimeout(() => {
req.abort();
}, 4500);
console.log(await res);
// | If a request has been aborted, this value is the time when the request was aborted,
// | in milliseconds since 1 January 1970 00:00:00 UTC.
// +-----------v
console.log(req.aborted, req.finished, req.ended, req.paused);
// response was received -^ ^- request has been sent
}();
Tg Upload
const bot = tgb(process.env.TELEGRAM_BOT_TOKEN);
// You
bot.sendPhoto({
"chat_id": "0",
"photo": "https://avatars0.githubusercontent.com/u/5007624"
});
// Tg
bot.sendPhoto({
"chat_id": "0",
"photo": "tg+https://avatars0.githubusercontent.com/u/5007624"
});
// https://core.telegram.org/bots/api#sending-files
Markup
const bot = tgb(process.env.TELEGRAM_BOT_TOKEN);
const {markup} = tgb;
// Set
bot.sendMessage(markup({
"chat_id": "0",
"text": "Hi"
}).keyboard(`A|B|C\nX|Y\nO`));
// Remove
bot.sendMessage(markup({
"chat_id": "0",
"text": "Hi"
}).keyboard()); // .removeKeyboard()
// Reply
bot.sendMessage(markup({
"chat_id": "0",
"text": "Hi"
}).reply()); // .forceReply()
// markup(message).[METHOD]
// markup.keyboard(kb, oneTime[, resize = true, selective = false])
// markup.removeKeyboard([selective = false])
// markup.forceReply([selective = false])
// markup.inlineLink(text, url) // or [text, url], ...
// https://core.telegram.org/bots/api#replykeyboardmarkup
Extensibility
const tgb = require("tgb");
const {Client} = tgb;
class MyBot extends Client {
constructor(token, msg) {
super(token);
this.msg = msg;
}
send(id) {
return this.sendMessage(id, this.msg);
}
sendMessage(cid, text) {
return super.sendMessage([cid, `watch?${text}`]);
}
}
const bot = new MyBot(process.env.TELEGRAM_BOT_TOKEN, "v=vc-PJPrueXY");
const [res, req] = bot.send("0");
console.log(await res);
File as Buffer
const fs = require("fs");
const bot = tgb(process.env.TELEGRAM_BOT_TOKEN);
bot.sendMediaGroup({
"chat_id": "0",
"media": [
{"type": "photo","media": "O://test.jpg"},
{"type": "photo","media": fs.createReadStream("O://test.jpg")},
{"type": "photo","media": ["test.jpg", fs.readFileSync("O://test.jpg")]},
{"type": "photo","media": "AgADAgAD36gxGwWj2EuIQ9vvX_3kbh-cmg4ABDhqGLqV07c_phkBAAEC"},
{"type": "photo","media": "tg+https://avatars0.githubusercontent.com/u/5007624"},
{"type": "photo","media": "https://avatars0.githubusercontent.com/u/5007624"},
]
});
CLI
> SET TELEGRAM_BOT_TOKEN=1:XXXX
> tgb-cli --method sendPhoto --d.chat_id 0 --d.photo "J://test.jpg"
> tgb-cli --method getMe -j
> tgb-cli --method getMe --token 0:XXXX
> tgb-cli --method getMe --token 0:XXXX --proxy "127.0.0.1:1337"
> tgb-cli --method sendMessage --data "{\"chat_id\":0,\"text\":\"Hi yo\"}"
> tgb-cli --method sendMessage --d.chat_id 0 --data "{\"chat_id\":1,\"text\":\"Hi yo\"}"
> tgb-cli --download TOKEN --name x --id "AgADAgAD36gxGwWj2EuIQ9vvX_3kbh-cmg4ABDhqGLqV07c_phkBAAEC"
> tgb-cli --download --dir "./temp/" --id "AgADAgAD36gxGwWj2EuIQ9vvX_3kbh-cmg4ABDhqGLqV07c_phkBAAEC"
QoS (Future development plans)
Considering Telegram's Bot documentation, currently the maximum amount of messages being sent by bots is limited to 30 messages/second for all ordinary messages and 20 messages/minute for group messages. When your bot hits spam limits, it starts to get 429 errors from Telegram API. And assuming that error handling in such case usually is coded as simple retrials, the running machine would spend a lot of CPU time retrying (or got locked down, depending on bot implementation details). And constantly retrying to send messages while ignoring API errors could result in your bot being banned for some time.
That means, if you're making a production-ready bot, which should serve numerous users it's always a good idea to use throughput limiting mechanism for messages being sent. This way you could be sure that all messages would be delivered to end-users as soon as possible in ordered way.
const tgb = require("tgb");
const {markup, qos} = tgb;
const bot = tgb(process.env.TELEGRAM_BOT_TOKEN);
bot.qos = qos();
const [res, req] = bot.sendMessage(markup({
"chat_id": "0",
"text": "NANI?!"
}).inlineLink("Omae wa ... mou shindeiru", "db.gg"));
// https://core.telegram.org/bots/faq#broadcasting-to-users
// https://en.wikipedia.org/wiki/Quality_of_service
Misc
/*
All methods in the Bot API are case-insensitive (.buffer, .json, .require)
message: buffer, stream, string
location|venue|contact: buffer, stream, string
photo|audio|voice|video|document|sticker|video_note: buffer, stream, filepath, url, file_id
certificate: buffer, stream, filepath, url
-
tgb.buffer(proxy, token, method, data, callback(error, buf, res))
tgb.json(proxy, token, method, data, callback(error, json, res))
-
x = tgb(token);
x.token; // Read|Write
x.proxy; // Read|Write
x.url; // Read (webhook.bind)
await x.method([data, proxy]);
await x(method[, data, proxy]);
-
client = await tgb(token, method[, data, proxy]);
[client, request] = tgb(token, method[, data, proxy]);
client.request === request;
request.pause();
await client;
~~~
error.response = response;
error.data = data;
error.code = data.error_code;
error.retryAfter = data.parameters.retry_after;
error.migrateToChatId = data.parameters.migrate_to_chat_id;
https://core.telegram.org/bots/api#responseparameters
~~~ Sys Code |
EBADPROXY
EBADREQUEST
EBADDATA
EWCMAXSIZE
EWCLONGREDIRECT
~~~ Tg Code |
tgb.ERR_INTERNAL_SERVER
tgb.ERR_NOT_FOUND
tgb.ERR_FORBIDDEN
tgb.ERR_MESSAGE_LIMITS
tgb.ERR_USED_WEBHOOK
tgb.ERR_INVALID_TOKEN
*/
Me? Him? Me? You? Me? ... Him? Me ... npm -g i tgb .... Whaat is Love ♫•¨•.¸¸♪
Goals:
- High stability;
- Low memory usage;
- Maximum performance;
- Flexibility.
License
MIT