webhook-bot-js
Version:
A JavaScript library for creating Webhook-Based Discord Bots
802 lines (676 loc) • 26.4 kB
JavaScript
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
var express = _interopDefault(require('express'));
var nacl = _interopDefault(require('tweetnacl'));
var v10 = require('discord-api-types/v10');
var rest = require('@discordjs/rest');
var tslog = require('tslog');
var EventEmitter = _interopDefault(require('node:events'));
function _regeneratorRuntime() {
/*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */
_regeneratorRuntime = function () {
return exports;
};
var exports = {},
Op = Object.prototype,
hasOwn = Op.hasOwnProperty,
$Symbol = "function" == typeof Symbol ? Symbol : {},
iteratorSymbol = $Symbol.iterator || "@@iterator",
asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator",
toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
function define(obj, key, value) {
return Object.defineProperty(obj, key, {
value: value,
enumerable: !0,
configurable: !0,
writable: !0
}), obj[key];
}
try {
define({}, "");
} catch (err) {
define = function (obj, key, value) {
return obj[key] = value;
};
}
function wrap(innerFn, outerFn, self, tryLocsList) {
var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator,
generator = Object.create(protoGenerator.prototype),
context = new Context(tryLocsList || []);
return generator._invoke = function (innerFn, self, context) {
var state = "suspendedStart";
return function (method, arg) {
if ("executing" === state) throw new Error("Generator is already running");
if ("completed" === state) {
if ("throw" === method) throw arg;
return doneResult();
}
for (context.method = method, context.arg = arg;;) {
var delegate = context.delegate;
if (delegate) {
var delegateResult = maybeInvokeDelegate(delegate, context);
if (delegateResult) {
if (delegateResult === ContinueSentinel) continue;
return delegateResult;
}
}
if ("next" === context.method) context.sent = context._sent = context.arg;else if ("throw" === context.method) {
if ("suspendedStart" === state) throw state = "completed", context.arg;
context.dispatchException(context.arg);
} else "return" === context.method && context.abrupt("return", context.arg);
state = "executing";
var record = tryCatch(innerFn, self, context);
if ("normal" === record.type) {
if (state = context.done ? "completed" : "suspendedYield", record.arg === ContinueSentinel) continue;
return {
value: record.arg,
done: context.done
};
}
"throw" === record.type && (state = "completed", context.method = "throw", context.arg = record.arg);
}
};
}(innerFn, self, context), generator;
}
function tryCatch(fn, obj, arg) {
try {
return {
type: "normal",
arg: fn.call(obj, arg)
};
} catch (err) {
return {
type: "throw",
arg: err
};
}
}
exports.wrap = wrap;
var ContinueSentinel = {};
function Generator() {}
function GeneratorFunction() {}
function GeneratorFunctionPrototype() {}
var IteratorPrototype = {};
define(IteratorPrototype, iteratorSymbol, function () {
return this;
});
var getProto = Object.getPrototypeOf,
NativeIteratorPrototype = getProto && getProto(getProto(values([])));
NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol) && (IteratorPrototype = NativeIteratorPrototype);
var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype);
function defineIteratorMethods(prototype) {
["next", "throw", "return"].forEach(function (method) {
define(prototype, method, function (arg) {
return this._invoke(method, arg);
});
});
}
function AsyncIterator(generator, PromiseImpl) {
function invoke(method, arg, resolve, reject) {
var record = tryCatch(generator[method], generator, arg);
if ("throw" !== record.type) {
var result = record.arg,
value = result.value;
return value && "object" == typeof value && hasOwn.call(value, "__await") ? PromiseImpl.resolve(value.__await).then(function (value) {
invoke("next", value, resolve, reject);
}, function (err) {
invoke("throw", err, resolve, reject);
}) : PromiseImpl.resolve(value).then(function (unwrapped) {
result.value = unwrapped, resolve(result);
}, function (error) {
return invoke("throw", error, resolve, reject);
});
}
reject(record.arg);
}
var previousPromise;
this._invoke = function (method, arg) {
function callInvokeWithMethodAndArg() {
return new PromiseImpl(function (resolve, reject) {
invoke(method, arg, resolve, reject);
});
}
return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
};
}
function maybeInvokeDelegate(delegate, context) {
var method = delegate.iterator[context.method];
if (undefined === method) {
if (context.delegate = null, "throw" === context.method) {
if (delegate.iterator.return && (context.method = "return", context.arg = undefined, maybeInvokeDelegate(delegate, context), "throw" === context.method)) return ContinueSentinel;
context.method = "throw", context.arg = new TypeError("The iterator does not provide a 'throw' method");
}
return ContinueSentinel;
}
var record = tryCatch(method, delegate.iterator, context.arg);
if ("throw" === record.type) return context.method = "throw", context.arg = record.arg, context.delegate = null, ContinueSentinel;
var info = record.arg;
return info ? info.done ? (context[delegate.resultName] = info.value, context.next = delegate.nextLoc, "return" !== context.method && (context.method = "next", context.arg = undefined), context.delegate = null, ContinueSentinel) : info : (context.method = "throw", context.arg = new TypeError("iterator result is not an object"), context.delegate = null, ContinueSentinel);
}
function pushTryEntry(locs) {
var entry = {
tryLoc: locs[0]
};
1 in locs && (entry.catchLoc = locs[1]), 2 in locs && (entry.finallyLoc = locs[2], entry.afterLoc = locs[3]), this.tryEntries.push(entry);
}
function resetTryEntry(entry) {
var record = entry.completion || {};
record.type = "normal", delete record.arg, entry.completion = record;
}
function Context(tryLocsList) {
this.tryEntries = [{
tryLoc: "root"
}], tryLocsList.forEach(pushTryEntry, this), this.reset(!0);
}
function values(iterable) {
if (iterable) {
var iteratorMethod = iterable[iteratorSymbol];
if (iteratorMethod) return iteratorMethod.call(iterable);
if ("function" == typeof iterable.next) return iterable;
if (!isNaN(iterable.length)) {
var i = -1,
next = function next() {
for (; ++i < iterable.length;) if (hasOwn.call(iterable, i)) return next.value = iterable[i], next.done = !1, next;
return next.value = undefined, next.done = !0, next;
};
return next.next = next;
}
}
return {
next: doneResult
};
}
function doneResult() {
return {
value: undefined,
done: !0
};
}
return GeneratorFunction.prototype = GeneratorFunctionPrototype, define(Gp, "constructor", GeneratorFunctionPrototype), define(GeneratorFunctionPrototype, "constructor", GeneratorFunction), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, toStringTagSymbol, "GeneratorFunction"), exports.isGeneratorFunction = function (genFun) {
var ctor = "function" == typeof genFun && genFun.constructor;
return !!ctor && (ctor === GeneratorFunction || "GeneratorFunction" === (ctor.displayName || ctor.name));
}, exports.mark = function (genFun) {
return Object.setPrototypeOf ? Object.setPrototypeOf(genFun, GeneratorFunctionPrototype) : (genFun.__proto__ = GeneratorFunctionPrototype, define(genFun, toStringTagSymbol, "GeneratorFunction")), genFun.prototype = Object.create(Gp), genFun;
}, exports.awrap = function (arg) {
return {
__await: arg
};
}, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, asyncIteratorSymbol, function () {
return this;
}), exports.AsyncIterator = AsyncIterator, exports.async = function (innerFn, outerFn, self, tryLocsList, PromiseImpl) {
void 0 === PromiseImpl && (PromiseImpl = Promise);
var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList), PromiseImpl);
return exports.isGeneratorFunction(outerFn) ? iter : iter.next().then(function (result) {
return result.done ? result.value : iter.next();
});
}, defineIteratorMethods(Gp), define(Gp, toStringTagSymbol, "Generator"), define(Gp, iteratorSymbol, function () {
return this;
}), define(Gp, "toString", function () {
return "[object Generator]";
}), exports.keys = function (object) {
var keys = [];
for (var key in object) keys.push(key);
return keys.reverse(), function next() {
for (; keys.length;) {
var key = keys.pop();
if (key in object) return next.value = key, next.done = !1, next;
}
return next.done = !0, next;
};
}, exports.values = values, Context.prototype = {
constructor: Context,
reset: function (skipTempReset) {
if (this.prev = 0, this.next = 0, this.sent = this._sent = undefined, this.done = !1, this.delegate = null, this.method = "next", this.arg = undefined, this.tryEntries.forEach(resetTryEntry), !skipTempReset) for (var name in this) "t" === name.charAt(0) && hasOwn.call(this, name) && !isNaN(+name.slice(1)) && (this[name] = undefined);
},
stop: function () {
this.done = !0;
var rootRecord = this.tryEntries[0].completion;
if ("throw" === rootRecord.type) throw rootRecord.arg;
return this.rval;
},
dispatchException: function (exception) {
if (this.done) throw exception;
var context = this;
function handle(loc, caught) {
return record.type = "throw", record.arg = exception, context.next = loc, caught && (context.method = "next", context.arg = undefined), !!caught;
}
for (var i = this.tryEntries.length - 1; i >= 0; --i) {
var entry = this.tryEntries[i],
record = entry.completion;
if ("root" === entry.tryLoc) return handle("end");
if (entry.tryLoc <= this.prev) {
var hasCatch = hasOwn.call(entry, "catchLoc"),
hasFinally = hasOwn.call(entry, "finallyLoc");
if (hasCatch && hasFinally) {
if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);
if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);
} else if (hasCatch) {
if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);
} else {
if (!hasFinally) throw new Error("try statement without catch or finally");
if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);
}
}
}
},
abrupt: function (type, arg) {
for (var i = this.tryEntries.length - 1; i >= 0; --i) {
var entry = this.tryEntries[i];
if (entry.tryLoc <= this.prev && hasOwn.call(entry, "finallyLoc") && this.prev < entry.finallyLoc) {
var finallyEntry = entry;
break;
}
}
finallyEntry && ("break" === type || "continue" === type) && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc && (finallyEntry = null);
var record = finallyEntry ? finallyEntry.completion : {};
return record.type = type, record.arg = arg, finallyEntry ? (this.method = "next", this.next = finallyEntry.finallyLoc, ContinueSentinel) : this.complete(record);
},
complete: function (record, afterLoc) {
if ("throw" === record.type) throw record.arg;
return "break" === record.type || "continue" === record.type ? this.next = record.arg : "return" === record.type ? (this.rval = this.arg = record.arg, this.method = "return", this.next = "end") : "normal" === record.type && afterLoc && (this.next = afterLoc), ContinueSentinel;
},
finish: function (finallyLoc) {
for (var i = this.tryEntries.length - 1; i >= 0; --i) {
var entry = this.tryEntries[i];
if (entry.finallyLoc === finallyLoc) return this.complete(entry.completion, entry.afterLoc), resetTryEntry(entry), ContinueSentinel;
}
},
catch: function (tryLoc) {
for (var i = this.tryEntries.length - 1; i >= 0; --i) {
var entry = this.tryEntries[i];
if (entry.tryLoc === tryLoc) {
var record = entry.completion;
if ("throw" === record.type) {
var thrown = record.arg;
resetTryEntry(entry);
}
return thrown;
}
}
throw new Error("illegal catch attempt");
},
delegateYield: function (iterable, resultName, nextLoc) {
return this.delegate = {
iterator: values(iterable),
resultName: resultName,
nextLoc: nextLoc
}, "next" === this.method && (this.arg = undefined), ContinueSentinel;
}
}, exports;
}
function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
try {
var info = gen[key](arg);
var value = info.value;
} catch (error) {
reject(error);
return;
}
if (info.done) {
resolve(value);
} else {
Promise.resolve(value).then(_next, _throw);
}
}
function _asyncToGenerator(fn) {
return function () {
var self = this,
args = arguments;
return new Promise(function (resolve, reject) {
var gen = fn.apply(self, args);
function _next(value) {
asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
}
function _throw(err) {
asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
}
_next(undefined);
});
};
}
function _inheritsLoose(subClass, superClass) {
subClass.prototype = Object.create(superClass.prototype);
subClass.prototype.constructor = subClass;
_setPrototypeOf(subClass, superClass);
}
function _setPrototypeOf(o, p) {
_setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
o.__proto__ = p;
return o;
};
return _setPrototypeOf(o, p);
}
function auth(public_key) {
return function (req, res, next) {
var signature = req.headers['x-signature-ed25519'];
var timestamp = req.headers['x-signature-timestamp'];
var isVerified;
var error;
try {
isVerified = nacl.sign.detached.verify(Buffer.from(timestamp + JSON.stringify(req.body)), Buffer.from(signature, 'hex'), Buffer.from(public_key, 'hex'));
} catch (e) {
error = e;
}
if (error || !isVerified) {
res.status(401).send('Unauthorized');
return;
} else {
next();
}
};
}
var slashCommands = {};
var userCommands = {};
var messageCommands = {};
var handleCommand = /*#__PURE__*/function () {
var _ref = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(commandInteraction) {
var command, slashCommand, userCommand, messageCommand;
return _regeneratorRuntime().wrap(function _callee$(_context) {
while (1) {
switch (_context.prev = _context.next) {
case 0:
command = commandInteraction.data;
_context.t0 = command.type;
_context.next = _context.t0 === v10.ApplicationCommandType.ChatInput ? 4 : _context.t0 === v10.ApplicationCommandType.User ? 8 : _context.t0 === v10.ApplicationCommandType.Message ? 12 : 16;
break;
case 4:
slashCommand = slashCommands[command.name];
if (slashCommand) {
_context.next = 7;
break;
}
return _context.abrupt("return");
case 7:
return _context.abrupt("return", slashCommand.execute(commandInteraction));
case 8:
userCommand = userCommands[command.name];
if (userCommand) {
_context.next = 11;
break;
}
return _context.abrupt("return");
case 11:
return _context.abrupt("return", userCommand.execute(commandInteraction));
case 12:
messageCommand = messageCommands[command.name];
if (messageCommand) {
_context.next = 15;
break;
}
return _context.abrupt("return");
case 15:
return _context.abrupt("return", messageCommand.execute(commandInteraction));
case 16:
return _context.abrupt("return");
case 17:
case "end":
return _context.stop();
}
}
}, _callee);
}));
return function handleCommand(_x) {
return _ref.apply(this, arguments);
};
}();
var getCommands = function getCommands() {
var commands = [];
Object.values(slashCommands).forEach(function (cmd) {
commands.push({
name: cmd.name,
type: v10.ApplicationCommandType.ChatInput,
description: cmd.description,
options: cmd.options
});
});
Object.values(userCommands).forEach(function (cmd) {
commands.push({
name: cmd.name,
type: v10.ApplicationCommandType.User
});
});
Object.values(messageCommands).forEach(function (cmd) {
commands.push({
name: cmd.name,
type: v10.ApplicationCommandType.Message
});
});
return commands;
};
var handleInteraction = /*#__PURE__*/function () {
var _ref = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(interaction) {
return _regeneratorRuntime().wrap(function _callee$(_context) {
while (1) {
switch (_context.prev = _context.next) {
case 0:
_context.t0 = interaction.type;
_context.next = _context.t0 === v10.InteractionType.Ping ? 3 : _context.t0 === v10.InteractionType.ApplicationCommand ? 4 : 7;
break;
case 3:
return _context.abrupt("return", {
type: v10.InteractionResponseType.Pong
});
case 4:
_context.next = 6;
return handleCommand(interaction);
case 6:
return _context.abrupt("return", _context.sent);
case 7:
return _context.abrupt("return");
case 8:
case "end":
return _context.stop();
}
}
}, _callee);
}));
return function handleInteraction(_x) {
return _ref.apply(this, arguments);
};
}();
var logger = /*#__PURE__*/new tslog.Logger({
name: 'webhook-bot-js',
type: 'pretty',
colorizePrettyLogs: true,
displayFunctionName: false,
displayFilePath: 'hidden'
});
var WebhookServer = /*#__PURE__*/function (_EventEmitter) {
_inheritsLoose(WebhookServer, _EventEmitter);
/**
* Creates a new WebhookServer
* @param options Options for the Server
*/
function WebhookServer(options) {
var _this;
_this = _EventEmitter.call(this) || this;
_this.app = express();
_this.port = (options == null ? void 0 : options.port) || 3600;
_this.token = (options == null ? void 0 : options.token) || '';
_this.application_id = (options == null ? void 0 : options.application_id) || '';
_this.public_key = (options == null ? void 0 : options.public_key) || '';
_this.rest = new rest.REST({
version: '10'
}).setToken(_this.token);
return _this;
}
/**
* Adds a SlashCommand to be registered.
* This method does NOT interact with Discord in any way.
* @param command The SlashCommand
*/
var _proto = WebhookServer.prototype;
_proto.registerSlashCommand = function registerSlashCommand(command) {
slashCommands[command.name] = command;
}
/**
* Adds a UserCommand to be registered.
* This method does NOT interact with Discord in any way.
* @param command The UserCommand
*/
;
_proto.registerUserCommand = function registerUserCommand(command) {
userCommands[command.name] = command;
}
/**
* Adds a MessageCommand to be registered.
* This method does NOT interact with Discord in any way.
* @param command The MessageCommand
*/
;
_proto.registerMessageCommand = function registerMessageCommand(command) {
messageCommands[command.name] = command;
}
/**
* Overwrites all global Application Commands
*/
;
_proto.pushGlobalApplicationCommands =
/*#__PURE__*/
function () {
var _pushGlobalApplicationCommands = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
var commands;
return _regeneratorRuntime().wrap(function _callee$(_context) {
while (1) {
switch (_context.prev = _context.next) {
case 0:
commands = getCommands();
_context.prev = 1;
_context.next = 4;
return this.rest.put(v10.Routes['applicationCommands'](this.application_id), {
body: commands
});
case 4:
logger.info("Succesfully overwrote application commands globally");
_context.next = 11;
break;
case 7:
_context.prev = 7;
_context.t0 = _context["catch"](1);
logger.error("Error registering application commands globally");
logger.error(_context.t0);
case 11:
case "end":
return _context.stop();
}
}
}, _callee, this, [[1, 7]]);
}));
function pushGlobalApplicationCommands() {
return _pushGlobalApplicationCommands.apply(this, arguments);
}
return pushGlobalApplicationCommands;
}()
/**
* Overwrites all Application Commands in the specified guild
*/
;
_proto.pushGuildApplicationCommands =
/*#__PURE__*/
function () {
var _pushGuildApplicationCommands = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(guildId) {
var commands;
return _regeneratorRuntime().wrap(function _callee2$(_context2) {
while (1) {
switch (_context2.prev = _context2.next) {
case 0:
commands = getCommands();
_context2.prev = 1;
_context2.next = 4;
return this.rest.put(v10.Routes['applicationGuildCommands'](this.application_id, guildId), {
body: commands
});
case 4:
logger.info("Succesfully overwrote application commands in guild");
_context2.next = 11;
break;
case 7:
_context2.prev = 7;
_context2.t0 = _context2["catch"](1);
logger.error("Error registering application commands in guild");
logger.error(_context2.t0);
case 11:
case "end":
return _context2.stop();
}
}
}, _callee2, this, [[1, 7]]);
}));
function pushGuildApplicationCommands(_x) {
return _pushGuildApplicationCommands.apply(this, arguments);
}
return pushGuildApplicationCommands;
}()
/**
* Runs the Server on "/" on the specified Port.
* Incoming request are automatically verified using the provided public key
*/
;
_proto.start = function start() {
var _this2 = this;
this.app.use(express.json());
this.app.use(auth(this.public_key));
this.app.post('/', /*#__PURE__*/function () {
var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(req, res) {
var interaction;
return _regeneratorRuntime().wrap(function _callee3$(_context3) {
while (1) {
switch (_context3.prev = _context3.next) {
case 0:
interaction = req.body;
_this2.emit('interactionReceived', interaction);
_context3.t0 = res.status(200);
_context3.next = 5;
return handleInteraction(interaction);
case 5:
_context3.t1 = _context3.sent;
_context3.t0.send.call(_context3.t0, _context3.t1);
case 7:
case "end":
return _context3.stop();
}
}
}, _callee3);
}));
return function (_x2, _x3) {
return _ref.apply(this, arguments);
};
}());
this.app.listen(this.port, function () {
logger.info("Server listening on " + _this2.port);
});
};
return WebhookServer;
}(EventEmitter);
var getOption = function getOption(interaction, name) {
var _interaction$data$opt;
return (_interaction$data$opt = interaction.data.options) == null ? void 0 : _interaction$data$opt.find(function (option) {
return option.name === name;
}).value;
};
var getStringOption = function getStringOption(interaction, name) {
return getOption(interaction, name);
};
var CommandResponse = {
Message: 4
};
var CommandOption = {
SUB_COMMAND: 1,
SUB_COMMAND_GROUP: 2,
STRING: 3,
INTEGER: 4,
BOOLEAN: 5,
USER: 6,
CHANNEL: 7,
ROLE: 8,
MENTIONABLE: 9,
NUMBER: 10,
ATTACHMENT: 11
};
exports.CommandOption = CommandOption;
exports.CommandResponse = CommandResponse;
exports.WebhookServer = WebhookServer;
exports.getOption = getOption;
exports.getStringOption = getStringOption;
//# sourceMappingURL=webhook-bot-js.cjs.development.js.map