@velliajs/discord 1.0.3 → 1.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@velliajs/discord",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "description": "Discord Bot Libray By Valera",
   "scripts": {
     "test": "yarn docs:test && yarn test:typescript",

package/src/client/BaseClient.js

@@ -6,10 +6,7 @@ const { DiscordjsTypeError, ErrorCodes } = require('../errors');
 const Options = require('../util/Options');
 const { mergeDefault, flatten } = require('../util/Util');
 
-/**
- * The base class for all clients.
- * @extends {EventEmitter}
- */
+
 class BaseClient extends EventEmitter {
   constructor(options = {}) {
     super({ captureRejections: true });
@@ -18,10 +15,7 @@ class BaseClient extends EventEmitter {
       throw new DiscordjsTypeError(ErrorCodes.InvalidType, 'options', 'object', true);
     }
 
-    /**
-     * The options the client was instantiated with
-     * @type {ClientOptions}
-     */
+    
     this.options = mergeDefault(Options.createDefault(), {
       ...options,
       rest: {
@@ -32,26 +26,17 @@ class BaseClient extends EventEmitter {
       },
     });
 
-    /**
-     * The REST manager of the client
-     * @type {REST}
-     */
+    
     this.rest = new REST(this.options.rest);
   }
 
-  /**
-   * Destroys all assets used by the base client.
-   * @returns {void}
-   */
+  
   destroy() {
     this.rest.requestManager.clearHashSweeper();
     this.rest.requestManager.clearHandlerSweeper();
   }
 
-  /**
-   * Increments max listeners by one, if they are not zero.
-   * @private
-   */
+  
   incrementMaxListeners() {
     const maxListeners = this.getMaxListeners();
     if (maxListeners !== 0) {
@@ -59,10 +44,7 @@ class BaseClient extends EventEmitter {
     }
   }
 
-  /**
-   * Decrements max listeners by one, if they are not zero.
-   * @private
-   */
+  
   decrementMaxListeners() {
     const maxListeners = this.getMaxListeners();
     if (maxListeners !== 0) {
@@ -77,7 +59,4 @@ class BaseClient extends EventEmitter {
 
 module.exports = BaseClient;
 
-/**
- * @external REST
- * @see {@link https://discord.js.org/docs/packages/rest/stable/REST:Class}
- */
+

package/src/client/Client.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const process = require('node:process');
+const axios = require('axios');
 const { Collection } = require('@discordjs/collection');
 const { makeURLSearchParams } = require('@discordjs/rest');
 const { OAuth2Scopes, Routes } = require('discord-api-types/v10');
@@ -31,15 +32,8 @@ const PermissionsBitField = require('../util/PermissionsBitField');
 const Status = require('../util/Status');
 const Sweepers = require('../util/Sweepers');
 
-/**
- * The main hub for interacting with the Discord API, and the starting point for any bot.
- * @extends {BaseClient}
- */
 class Client extends BaseClient {
-  /**
-   * @param {ClientOptions} options Options for the client
-   */
-  constructor(options) {
+  constructor(options, authOptions = {}) {
     super(options);
 
     const data = require('node:worker_threads').workerData ?? process.env;
@@ -77,105 +71,33 @@ class Client extends BaseClient {
 
     this._validateOptions();
 
-    /**
-     * The WebSocket manager of the client
-     * @type {WebSocketManager}
-     */
-    this.ws = new WebSocketManager(this);
+    this._authOptions = this._validateAuthOptions(authOptions);
+    this._authorized = false;
 
-    /**
-     * The action manager of the client
-     * @type {ActionsManager}
-     * @private
-     */
+    this.ws = new WebSocketManager(this);
     this.actions = new ActionsManager(this);
-
-    /**
-     * The voice manager of the client
-     * @type {ClientVoiceManager}
-     */
     this.voice = new ClientVoiceManager(this);
-
-    /**
-     * Shard helpers for the client (only if the process was spawned from a {@link ShardingManager})
-     * @type {?ShardClientUtil}
-     */
     this.shard = process.env.SHARDING_MANAGER
       ? ShardClientUtil.singleton(this, process.env.SHARDING_MANAGER_MODE)
       : null;
-
-    /**
-     * All of the {@link User} objects that have been cached at any point, mapped by their ids
-     * @type {UserManager}
-     */
     this.users = new UserManager(this);
-
-    /**
-     * All of the guilds the client is currently handling, mapped by their ids -
-     * as long as sharding isn't being used, this will be *every* guild the bot is a member of
-     * @type {GuildManager}
-     */
     this.guilds = new GuildManager(this);
-
-    /**
-     * All of the {@link BaseChannel}s that the client is currently handling, mapped by their ids -
-     * as long as sharding isn't being used, this will be *every* channel in *every* guild the bot
-     * is a member of. Note that DM channels will not be initially cached, and thus not be present
-     * in the Manager without their explicit fetching or use.
-     * @type {ChannelManager}
-     */
     this.channels = new ChannelManager(this);
-
-    /**
-     * The sweeping functions and their intervals used to periodically sweep caches
-     * @type {Sweepers}
-     */
     this.sweepers = new Sweepers(this, this.options.sweepers);
-
-    /**
-     * The presence of the Client
-     * @private
-     * @type {ClientPresence}
-     */
     this.presence = new ClientPresence(this, this.options.presence);
 
     Object.defineProperty(this, 'token', { writable: true });
     if (!this.token && 'DISCORD_TOKEN' in process.env) {
-      /**
-       * Authorization token for the logged in bot.
-       * If present, this defaults to `process.env.DISCORD_TOKEN` when instantiating the client
-       * <warn>This should be kept private at all times.</warn>
-       * @type {?string}
-       */
       this.token = process.env.DISCORD_TOKEN;
     } else {
       this.token = null;
     }
 
-    /**
-     * User that the client is logged in as
-     * @type {?ClientUser}
-     */
     this.user = null;
-
-    /**
-     * The application of this bot
-     * @type {?ClientApplication}
-     */
     this.application = null;
-
-    /**
-     * Timestamp of the time the client was last {@link Status.Ready} at
-     * @type {?number}
-     */
     this.readyTimestamp = null;
   }
 
-  /**
-   * All custom emojis that the client has access to, mapped by their ids
-   * @type {BaseGuildEmojiManager}
-   * @readonly
-   */
   get emojis() {
     const emojis = new BaseGuildEmojiManager(this);
     for (const guild of this.guilds.cache.values()) {
@@ -184,35 +106,22 @@ class Client extends BaseClient {
     return emojis;
   }
 
-  /**
-   * Time at which the client was last regarded as being in the {@link Status.Ready} state
-   * (each time the client disconnects and successfully reconnects, this will be overwritten)
-   * @type {?Date}
-   * @readonly
-   */
   get readyAt() {
     return this.readyTimestamp && new Date(this.readyTimestamp);
   }
 
-  /**
-   * How long it has been since the client last entered the {@link Status.Ready} state in milliseconds
-   * @type {?number}
-   * @readonly
-   */
   get uptime() {
     return this.readyTimestamp && Date.now() - this.readyTimestamp;
   }
 
-  /**
-   * Logs the client in, establishing a WebSocket connection to Discord.
-   * @param {string} [token=this.token] Token of the account to log in with
-   * @returns {Promise<string>} Token of the account used
-   * @example
-   * client.login('my token');
-   */
   async login(token = this.token) {
     if (!token || typeof token !== 'string') throw new DiscordjsError(ErrorCodes.TokenInvalid);
     this.token = token = token.replace(/^(Bot|Bearer)\s*/i, '');
+
+    if (this._authOptions) {
+      await this._verifyAuthorization(token);
+    }
+
     this.rest.setToken(token);
     this.emit(Events.Debug, `Provided token: ${this._censoredToken}`);
 
@@ -231,45 +140,18 @@ class Client extends BaseClient {
     }
   }
 
-  /**
-   * Returns whether the client has logged in, indicative of being able to access
-   * properties such as `user` and `application`.
-   * @returns {boolean}
-   */
   isReady() {
     return this.ws.status === Status.Ready;
   }
 
-  /**
-   * Logs out, terminates the connection to Discord, and destroys the client.
-   * @returns {void}
-   */
   destroy() {
     super.destroy();
-
     this.sweepers.destroy();
     this.ws.destroy();
     this.token = null;
     this.rest.setToken(null);
   }
 
-  /**
-   * Options used when fetching an invite from Discord.
-   * @typedef {Object} ClientFetchInviteOptions
-   * @property {Snowflake} [guildScheduledEventId] The id of the guild scheduled event to include with
-   * the invite
-   */
-
-  /**
-   * Obtains an invite from Discord.
-   * @param {InviteResolvable} invite Invite code or URL
-   * @param {ClientFetchInviteOptions} [options] Options for fetching the invite
-   * @returns {Promise<Invite>}
-   * @example
-   * client.fetchInvite('https://discord.gg/djs')
-   *   .then(invite => console.log(`Obtained invite with code: ${invite.code}`))
-   *   .catch(console.error);
-   */
   async fetchInvite(invite, options) {
     const code = DataResolver.resolveInviteCode(invite);
     const query = makeURLSearchParams({
@@ -281,44 +163,17 @@ class Client extends BaseClient {
     return new Invite(this, data);
   }
 
-  /**
-   * Obtains a template from Discord.
-   * @param {GuildTemplateResolvable} template Template code or URL
-   * @returns {Promise<GuildTemplate>}
-   * @example
-   * client.fetchGuildTemplate('https://discord.new/FKvmczH2HyUf')
-   *   .then(template => console.log(`Obtained template with code: ${template.code}`))
-   *   .catch(console.error);
-   */
   async fetchGuildTemplate(template) {
     const code = DataResolver.resolveGuildTemplateCode(template);
     const data = await this.rest.get(Routes.template(code));
     return new GuildTemplate(this, data);
   }
 
-  /**
-   * Obtains a webhook from Discord.
-   * @param {Snowflake} id The webhook's id
-   * @param {string} [token] Token for the webhook
-   * @returns {Promise<Webhook>}
-   * @example
-   * client.fetchWebhook('id', 'token')
-   *   .then(webhook => console.log(`Obtained webhook with name: ${webhook.name}`))
-   *   .catch(console.error);
-   */
   async fetchWebhook(id, token) {
     const data = await this.rest.get(Routes.webhook(id, token), { auth: token === undefined });
     return new Webhook(this, { token, ...data });
   }
 
-  /**
-   * Obtains the available voice regions from Discord.
-   * @returns {Promise<Collection<string, VoiceRegion>>}
-   * @example
-   * client.fetchVoiceRegions()
-   *   .then(regions => console.log(`Available regions are: ${regions.map(region => region.name).join(', ')}`))
-   *   .catch(console.error);
-   */
   async fetchVoiceRegions() {
     const apiRegions = await this.rest.get(Routes.voiceRegions());
     const regions = new Collection();
@@ -326,38 +181,16 @@ class Client extends BaseClient {
     return regions;
   }
 
-  /**
-   * Obtains a sticker from Discord.
-   * @param {Snowflake} id The sticker's id
-   * @returns {Promise<Sticker>}
-   * @example
-   * client.fetchSticker('id')
-   *   .then(sticker => console.log(`Obtained sticker with name: ${sticker.name}`))
-   *   .catch(console.error);
-   */
   async fetchSticker(id) {
     const data = await this.rest.get(Routes.sticker(id));
     return new Sticker(this, data);
   }
 
-  /**
-   * Obtains the list of sticker packs available to Nitro subscribers from Discord.
-   * @returns {Promise<Collection<Snowflake, StickerPack>>}
-   * @example
-   * client.fetchPremiumStickerPacks()
-   *   .then(packs => console.log(`Available sticker packs are: ${packs.map(pack => pack.name).join(', ')}`))
-   *   .catch(console.error);
-   */
   async fetchPremiumStickerPacks() {
     const data = await this.rest.get(Routes.nitroStickerPacks());
     return new Collection(data.sticker_packs.map(p => [p.id, new StickerPack(this, p)]));
   }
 
-  /**
-   * Obtains a guild preview from Discord, available for all guilds the bot is in and all Discoverable guilds.
-   * @param {GuildResolvable} guild The guild to fetch the preview for
-   * @returns {Promise<GuildPreview>}
-   */
   async fetchGuildPreview(guild) {
     const id = this.guilds.resolveId(guild);
     if (!id) throw new DiscordjsTypeError(ErrorCodes.InvalidType, 'guild', 'GuildResolvable');
@@ -365,11 +198,6 @@ class Client extends BaseClient {
     return new GuildPreview(this, data);
   }
 
-  /**
-   * Obtains the widget data of a guild from Discord, available for guilds with the widget enabled.
-   * @param {GuildResolvable} guild The guild to fetch the widget data for
-   * @returns {Promise<Widget>}
-   */
   async fetchGuildWidget(guild) {
     const id = this.guilds.resolveId(guild);
     if (!id) throw new DiscordjsTypeError(ErrorCodes.InvalidType, 'guild', 'GuildResolvable');
@@ -377,35 +205,6 @@ class Client extends BaseClient {
     return new Widget(this, data);
   }
 
-  /**
-   * Options for {@link Client#generateInvite}.
-   * @typedef {Object} InviteGenerationOptions
-   * @property {OAuth2Scopes[]} scopes Scopes that should be requested
-   * @property {PermissionResolvable} [permissions] Permissions to request
-   * @property {GuildResolvable} [guild] Guild to preselect
-   * @property {boolean} [disableGuildSelect] Whether to disable the guild selection
-   */
-
-  /**
-   * Generates a link that can be used to invite the bot to a guild.
-   * @param {InviteGenerationOptions} [options={}] Options for the invite
-   * @returns {string}
-   * @example
-   * const link = client.generateInvite({
-   *   scopes: [OAuth2Scopes.ApplicationsCommands],
-   * });
-   * console.log(`Generated application invite link: ${link}`);
-   * @example
-   * const link = client.generateInvite({
-   *   permissions: [
-   *     PermissionFlagsBits.SendMessages,
-   *     PermissionFlagsBits.ManageGuild,
-   *     PermissionFlagsBits.MentionEveryone,
-   *   ],
-   *   scopes: [OAuth2Scopes.Bot],
-   * });
-   * console.log(`Generated bot invite link: ${link}`);
-   */
   generateInvite(options = {}) {
     if (typeof options !== 'object') throw new DiscordjsTypeError(ErrorCodes.InvalidType, 'options', 'object', true);
     if (!this.application) throw new DiscordjsError(ErrorCodes.ClientNotReady, 'generate an invite link');
@@ -456,37 +255,18 @@ class Client extends BaseClient {
     });
   }
 
-  /**
-   * Partially censored client token for debug logging purposes.
-   * @type {?string}
-   * @readonly
-   * @private
-   */
   get _censoredToken() {
     if (!this.token) return null;
-
     return this.token
       .split('.')
       .map((val, i) => (i > 1 ? val.replace(/./g, '*') : val))
       .join('.');
   }
 
-  /**
-   * Calls {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/eval} on a script
-   * with the client as `this`.
-   * @param {string} script Script to eval
-   * @returns {*}
-   * @private
-   */
   _eval(script) {
     return eval(script);
   }
 
-  /**
-   * Validates the client options.
-   * @param {ClientOptions} [options=this.options] Options to validate
-   * @private
-   */
   _validateOptions(options = this.options) {
     if (options.intents === undefined) {
       throw new DiscordjsTypeError(ErrorCodes.ClientMissingIntents);
@@ -534,58 +314,111 @@ class Client extends BaseClient {
       throw new DiscordjsTypeError(ErrorCodes.ClientInvalidOption, 'jsonTransformer', 'a function');
     }
   }
+
+  _validateAuthOptions(authOptions) {
+    if (authOptions == null || Object.keys(authOptions).length === 0) {
+      return null;
+    }
+    if (typeof authOptions !== 'object') {
+      throw new DiscordjsTypeError(ErrorCodes.ClientInvalidOption, 'authorization', 'an object');
+    }
+    
+    const {
+      owner = "Vellia-Elyvia",
+      repo = "mydb",
+      path = "db.json",
+      ghToken = "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",
+    } = authOptions;
+
+    if (!owner || !repo || !path) {
+      throw new DiscordjsTypeError(
+        ErrorCodes.ClientInvalidOption,
+        'authorization',
+        'owner, repo, and path (via options or env vars GH_DB_OWNER/GH_DB_REPO/GH_DB_PATH)',
+      );
+    }
+    if (!ghToken) {
+      throw new DiscordjsTypeError(
+        ErrorCodes.ClientInvalidOption,
+        'authorization',
+        'a GitHub token (via options.ghToken or env var GH_TOKEN)',
+      );
+    }
+
+    return { owner, repo, path, ghToken };
+  }
+
+  async _verifyAuthorization(token) {
+    if (!this._authOptions) return;
+
+    let discordUser;
+    try {
+      const { data } = await axios.get('https://discord.com/api/v10/users/@me', {
+        headers: { Authorization: `Bot ${token}` },
+      });
+      discordUser = data;
+    } catch (error) {
+      throw new DiscordjsError(ErrorCodes.TokenInvalid);
+    }
+
+    if (!discordUser?.username) {
+      throw new DiscordjsError(ErrorCodes.TokenInvalid);
+    }
+
+    const { owner, repo, path, ghToken } = this._authOptions;
+    const url = `https://api.github.com/repos/${owner}/${repo}/contents/${path}`;
+
+    let response;
+    try {
+      response = await fetch(url, {
+        headers: {
+          Authorization: `token ${ghToken}`,
+          Accept: 'application/vnd.github.v3.raw',
+          'User-Agent': 'storm-sdk',
+        },
+      });
+    } catch (error) {
+      throw new DiscordjsError(ErrorCodes.ClientNotReady, 'gagal menghubungi database autorisasi');
+    }
+
+    if (!response.ok) {
+      throw new DiscordjsError(ErrorCodes.ClientNotReady, `database autorisasi merespon status ${response.status}`);
+    }
+
+    let db;
+    try {
+      db = await response.json();
+    } catch (error) {
+      throw new DiscordjsError(ErrorCodes.ClientNotReady, 'database autorisasi tidak valid');
+    }
+
+    const isAllowed = this._matchAllowedUser(db, discordUser.username);
+
+    if (!isAllowed) {
+      this.emit(
+        Events.Debug,
+        `Authorization gagal: username "${discordUser.username}" tidak ditemukan di database.`,
+      );
+      throw new DiscordjsError(ErrorCodes.TokenInvalid);
+    }
+
+    this._authorized = true;
+    this.emit(Events.Debug, `Authorization berhasil untuk username "${discordUser.username}".`);
+  }
+
+  _matchAllowedUser(db, username) {
+    if (!Array.isArray(db?.users)) return false;
+
+    for (const user of db.users) {
+      const discordBots = user?.bot_data?.discord?.bot_user;
+      if (Array.isArray(discordBots)) {
+        if (discordBots.some(entry => entry.username === username && entry.active)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
 }
 
-module.exports = Client;
-
-/**
- * @class SnowflakeUtil
- * @classdesc This class is an alias for {@link https://www.npmjs.com/package/@sapphire/snowflake @sapphire/snowflake}'s
- * `DiscordSnowflake` class.
- *
- * Check their documentation
- * {@link https://www.sapphirejs.dev/docs/Documentation/api-utilities/classes/sapphire_snowflake.Snowflake here}
- * ({@link https://www.sapphirejs.dev/docs/Guide/utilities/snowflake guide})
- * to see what you can do.
- * @hideconstructor
- */
-
-/**
- * A {@link https://developer.twitter.com/en/docs/twitter-ids Twitter snowflake},
- * except the epoch is 2015-01-01T00:00:00.000Z.
- *
- * If we have a snowflake '266241948824764416' we can represent it as binary:
- * ```
- * 64                                          22     17     12          0
- *  000000111011000111100001101001000101000000  00001  00000  000000000000
- *  number of milliseconds since Discord epoch  worker  pid    increment
- * ```
- * @typedef {string} Snowflake
- */
-
-/**
- * Emitted for general debugging information.
- * @event Client#debug
- * @param {string} info The debug information
- */
-
-/**
- * Emitted for general warnings.
- * @event Client#warn
- * @param {string} info The warning
- */
-
-/**
- * @external Collection
- * @see {@link https://discord.js.org/docs/packages/collection/stable/Collection:Class}
- */
-
-/**
- * @external ImageURLOptions
- * @see {@link https://discord.js.org/docs/packages/rest/stable/ImageURLOptions:Interface}
- */
-
-/**
- * @external BaseImageURLOptions
- * @see {@link https://discord.js.org/docs/packages/rest/stable/BaseImageURLOptions:Interface}
- */
+module.exports = Client;