djs-selfbot-v13 3.7.29 → 3.7.30

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "djs-selfbot-v13",
-  "version": "3.7.29",
+  "version": "3.7.30",
   "description": "An unofficial discord.js fork for creating selfbots",
   "main": "./src/index.js",
   "types": "./typings/index.d.ts",

package/src/client/Client.js

@@ -18,6 +18,7 @@ const ClientUserSettingManager = require('../managers/ClientUserSettingManager')
 const DeveloperManager = require('../managers/DeveloperManager');
 const GuildManager = require('../managers/GuildManager');
 const PresenceManager = require('../managers/PresenceManager');
+const BackupManager = require('../managers/BackupManager');
 const QuestManager = require('../managers/QuestManager');
 const RelationshipManager = require('../managers/RelationshipManager');
 const SessionManager = require('../managers/SessionManager');
@@ -172,6 +173,12 @@ class Client extends BaseClient {
      */
     this.quests = new QuestManager(this);
 
+    /**
+     * Manages guild backup operations
+     * @type {BackupManager}
+     */
+    this.backups = new BackupManager(this);
+
     /**
      * All of the sessions of the client
      * @type {SessionManager}

package/src/index.js

@@ -75,6 +75,9 @@ exports.WebSocketManager = require('./client/websocket/WebSocketManager');
 exports.WebSocketShard = require('./client/websocket/WebSocketShard');
 exports.RelationshipManager = require('./managers/RelationshipManager');
 exports.UserNoteManager = require('./managers/UserNoteManager');
+exports.QuestManager = require('./managers/QuestManager');
+exports.Quest = require('./managers/QuestManager').Quest;
+exports.BackupManager = require('./managers/BackupManager');
 
 // Structures
 exports.Activity = require('./structures/Presence').Activity;

package/src/managers/BackupManager.js

@@ -0,0 +1,141 @@
+'use strict';
+
+const { Collection } = require('@discordjs/collection');
+const BaseManager = require('./BaseManager');
+const backup = require('../util/backup');
+
+/**
+ * Manages in-memory guild backups
+ */
+class BackupCacheManager {
+  /**
+   * @param {BackupManager} manager Parent backup manager
+   */
+  constructor(manager) {
+    /**
+     * @type {BackupManager}
+     * @private
+     */
+    this._manager = manager;
+
+    /**
+     * Cached backup data
+     * @type {Collection<string, Object>}
+     * @private
+     */
+    this._storage = new Collection();
+  }
+
+  /**
+   * The client that instantiated this manager
+   * @type {import('../client/Client')}
+   */
+  get client() {
+    return this._manager.client;
+  }
+
+  /**
+   * Resolve a guild from an ID
+   * @param {import('../util/SnowflakeUtil').Snowflake} guildId Guild ID
+   * @returns {import('../structures/Guild').Guild}
+   * @private
+   */
+  _resolveGuild(guildId) {
+    const guild = this.client.guilds.resolve(guildId);
+    if (!guild) {
+      throw new Error(`Guild "${guildId}" could not be resolved.`);
+    }
+    return guild;
+  }
+
+  /**
+   * Create a backup from a guild and store it in cache
+   * @param {import('../util/SnowflakeUtil').Snowflake} guildId Guild ID to backup
+   * @param {Object} [options] Backup creation options
+   * @returns {Promise<Object>} Backup data
+   */
+  async create(guildId, options = {}) {
+    const guild = this._resolveGuild(guildId);
+    const backupData = await backup.create(guild, options);
+    this._storage.set(backupData.id, backupData);
+    return backupData;
+  }
+
+  /**
+   * Delete a backup from cache
+   * @param {string} backupId Backup ID
+   * @returns {boolean} Whether the backup existed
+   */
+  delete(backupId) {
+    return this._storage.delete(backupId);
+  }
+
+  /**
+   * Clear all cached backups
+   */
+  clearAll() {
+    this._storage.clear();
+  }
+
+  /**
+   * Load a cached backup into a guild
+   * @param {import('../util/SnowflakeUtil').Snowflake} guildId Target guild ID
+   * @param {string} backupId Backup ID
+   * @param {Object} [options] Load options
+   * @returns {Promise<Object>} Restored backup data
+   */
+  async load(guildId, backupId, options = {}) {
+    const guild = this._resolveGuild(guildId);
+    const backupData = this._storage.get(backupId);
+
+    if (!backupData) {
+      throw new Error(`Backup "${backupId}" was not found in cache.`);
+    }
+
+    return backup.load(backupData, guild, options);
+  }
+
+  /**
+   * Get a cached backup
+   * @param {string} backupId Backup ID
+   * @returns {Object|undefined} Backup info with data, id and size
+   */
+  get(backupId) {
+    const backupData = this._storage.get(backupId);
+    if (!backupData) return undefined;
+
+    const size = Number((Buffer.byteLength(JSON.stringify(backupData), 'utf8') / 1024).toFixed(2));
+
+    return {
+      id: backupId,
+      data: backupData,
+      size,
+    };
+  }
+
+  /**
+   * List all cached backup IDs
+   * @returns {string[]}
+   */
+  list() {
+    return [...this._storage.keys()];
+  }
+}
+
+/**
+ * Manages guild backup operations
+ * @extends {BaseManager}
+ */
+class BackupManager extends BaseManager {
+  constructor(client) {
+    super(client);
+
+    /**
+     * In-memory backup cache
+     * @type {BackupCacheManager}
+     */
+    this.cache = new BackupCacheManager(this);
+  }
+}
+
+module.exports = BackupManager;