discord.js-backup-v13 13.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Androz2091
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/lib/create.d.ts

@@ -0,0 +1,35 @@
+import type { BanData, ChannelsData, CreateOptions, EmojiData, RoleData } from './types';
+import type { Guild } from 'discord.js';
+import { MemberData } from './types/MemberData';
+/**
+ * Returns an array with the banned members of the guild
+ * @param {Guild} guild The Discord guild
+ * @returns {Promise<BanData[]>} The banned members
+ */
+export declare function getBans(guild: Guild): Promise<BanData[]>;
+/**
+ * Returns an array with the members of the guild
+ * @param {Guild} guild The Discord guild
+ * @returns {Promise<MemberData>}
+ */
+export declare function getMembers(guild: Guild): Promise<MemberData[]>;
+/**
+ * Returns an array with the roles of the guild
+ * @param {Guild} guild The discord guild
+ * @returns {Promise<RoleData[]>} The roles of the guild
+ */
+export declare function getRoles(guild: Guild): Promise<RoleData[]>;
+/**
+ * Returns an array with the emojis of the guild
+ * @param {Guild} guild The discord guild
+ * @param {CreateOptions} options The backup options
+ * @returns {Promise<EmojiData[]>} The emojis of the guild
+ */
+export declare function getEmojis(guild: Guild, options: CreateOptions): Promise<EmojiData[]>;
+/**
+ * Returns an array with the channels of the guild
+ * @param {Guild} guild The discord guild
+ * @param {CreateOptions} options The backup options
+ * @returns {ChannelData[]} The channels of the guild
+ */
+export declare function getChannels(guild: Guild, options: CreateOptions): Promise<ChannelsData>;

package/lib/create.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getChannels = exports.getEmojis = exports.getRoles = exports.getMembers = exports.getBans = void 0;
+const node_fetch_1 = require("node-fetch");
+const util_1 = require("./util");
+/**
+ * Returns an array with the banned members of the guild
+ * @param {Guild} guild The Discord guild
+ * @returns {Promise<BanData[]>} The banned members
+ */
+async function getBans(guild) {
+    const bans = [];
+    const cases = await guild.bans.fetch();
+    cases.forEach((ban) => {
+        bans.push({
+            id: ban.user.id,
+            reason: ban.reason
+        });
+    });
+    return bans;
+}
+exports.getBans = getBans;
+/**
+ * Returns an array with the members of the guild
+ * @param {Guild} guild The Discord guild
+ * @returns {Promise<MemberData>}
+ */
+async function getMembers(guild) {
+    const members = [];
+    guild.members.cache.forEach((member) => {
+        members.push({
+            userId: member.user.id,
+            username: member.user.username,
+            discriminator: member.user.discriminator,
+            avatarUrl: member.user.avatarURL(),
+            joinedTimestamp: member.joinedTimestamp,
+            roles: member.roles.cache.map((role) => role.id),
+            bot: member.user.bot
+        });
+    });
+    return members;
+}
+exports.getMembers = getMembers;
+/**
+ * Returns an array with the roles of the guild
+ * @param {Guild} guild The discord guild
+ * @returns {Promise<RoleData[]>} The roles of the guild
+ */
+async function getRoles(guild) {
+    const roles = [];
+    guild.roles.cache
+        .filter((role) => !role.managed)
+        .sort((a, b) => b.position - a.position)
+        .forEach((role) => {
+            const roleData = {
+                name: role.name,
+                color: role.hexColor,
+                hoist: role.hoist,
+                permissions: role.permissions.bitfield.toString(),
+                mentionable: role.mentionable,
+                position: role.position,
+                isEveryone: guild.id === role.id
+            };
+            roles.push(roleData);
+        });
+    return roles;
+}
+exports.getRoles = getRoles;
+/**
+ * Returns an array with the emojis of the guild
+ * @param {Guild} guild The discord guild
+ * @param {CreateOptions} options The backup options
+ * @returns {Promise<EmojiData[]>} The emojis of the guild
+ */
+async function getEmojis(guild, options) {
+    const emojis = [];
+    guild.emojis.cache.forEach(async (emoji) => {
+        const eData = {
+            name: emoji.name
+        };
+        if (options.saveImages && options.saveImages === 'base64') {
+            eData.base64 = (await (0, node_fetch_1.default)(emoji.url).then((res) => res.buffer())).toString('base64');
+        }
+        else {
+            eData.url = emoji.url;
+        }
+        emojis.push(eData);
+    });
+    return emojis;
+}
+exports.getEmojis = getEmojis;
+/**
+ * Returns an array with the channels of the guild
+ * @param {Guild} guild The discord guild
+ * @param {CreateOptions} options The backup options
+ * @returns {ChannelData[]} The channels of the guild
+ */
+async function getChannels(guild, options) {
+    return new Promise(async (resolve) => {
+        const channels = {
+            categories: [],
+            others: []
+        };
+
+        const categories = guild.channels.cache
+            .filter((ch) => ch.type === 'GUILD_CATEGORY')
+            .sort((a, b) => a.position - b.position)
+
+        for (const category of categories.values()) {
+
+            const categoryData = {
+                name: category.name,
+                permissions: (0, util_1.fetchChannelPermissions)(category),
+                children: []
+            };
+            const children = guild.channels.cache.filter(c => c.parentId == category.id).sort((a, b) => a.position - b.position)
+
+            for (const child of children.values()) {
+
+                if (child.type === 'GUILD_TEXT' || child.type === 'GUILD_NEWS') {
+                    const channelData = await (0, util_1.fetchTextChannelData)(child, options);
+                    categoryData.children.push(channelData);
+                }
+                else {
+                    const channelData = await (0, util_1.fetchVoiceChannelData)(child);
+                    categoryData.children.push(channelData);
+                }
+            }
+            channels.categories.push(categoryData);
+        }
+        const others = guild.channels.cache
+            .filter((ch) => {
+                return !ch.parent && ch.type !== 'GUILD_CATEGORY'
+                    && ch.type !== 'GUILD_STORE'
+                    && ch.type !== 'GUILD_NEWS_THREAD' && ch.type !== 'GUILD_PRIVATE_THREAD' && ch.type !== 'GUILD_PUBLIC_THREAD';
+            })
+            .sort((a, b) => a.position - b.position)
+            .toJSON();
+        for (const channel of others.values()) {
+            if (channel.type === 'GUILD_TEXT' || channel.type === 'GUILD_NEWS') {
+                const channelData = await (0, util_1.fetchTextChannelData)(channel, options);
+                channels.others.push(channelData);
+            }
+            else {
+                const channelData = await (0, util_1.fetchVoiceChannelData)(channel);
+                channels.others.push(channelData);
+            }
+        }
+        resolve(channels);
+    });
+}
+exports.getChannels = getChannels;

package/lib/index.d.ts

@@ -0,0 +1,34 @@
+import type { BackupData, BackupInfos, CreateOptions, LoadOptions } from './types/';
+import type { Guild } from 'discord.js';
+/**
+ * Fetches a backyp and returns the information about it
+ */
+export declare const fetch: (backupID: string) => Promise<BackupInfos>;
+/**
+ * Creates a new backup and saves it to the storage
+ */
+export declare const create: (guild: Guild, options?: CreateOptions) => Promise<BackupData>;
+/**
+ * Loads a backup for a guild
+ */
+export declare const load: (backup: string | BackupData, guild: Guild, options?: LoadOptions) => Promise<unknown>;
+/**
+ * Removes a backup
+ */
+export declare const remove: (backupID: string) => Promise<void>;
+/**
+ * Returns the list of all backup
+ */
+export declare const list: () => Promise<string[]>;
+/**
+ * Change the storage path
+ */
+export declare const setStorageFolder: (path: string) => void;
+declare const _default: {
+    create: (guild: Guild, options?: CreateOptions) => Promise<BackupData>;
+    fetch: (backupID: string) => Promise<BackupInfos>;
+    list: () => Promise<string[]>;
+    load: (backup: string | BackupData, guild: Guild, options?: LoadOptions) => Promise<unknown>;
+    remove: (backupID: string) => Promise<void>;
+};
+export default _default;

package/lib/index.js

@@ -0,0 +1,240 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setStorageFolder = exports.list = exports.remove = exports.load = exports.create = exports.fetch = void 0;
+const discord_js_1 = require("discord.js-selfbot-v13");
+const node_fetch_1 = require("node-fetch");
+const path_1 = require("path");
+const fs_1 = require("fs");
+const promises_1 = require("fs/promises");
+const createMaster = require("./create");
+const loadMaster = require("./load");
+const utilMaster = require("./util");
+let backups = `${__dirname}/backups`;
+if (!(0, fs_1.existsSync)(backups)) {
+    (0, fs_1.mkdirSync)(backups);
+}
+/**
+ * Checks if a backup exists and returns its data
+ */
+const getBackupData = async (backupID) => {
+    return new Promise(async (resolve, reject) => {
+        const files = await (0, promises_1.readdir)(backups);
+        const file = files.filter((f) => f.split('.').pop() === 'json').find((f) => f === `${backupID}.json`);
+        if (file) {
+            const backupData = require(`${backups}${path_1.sep}${file}`);
+            resolve(backupData);
+        }
+        else {
+            reject('No backup found');
+        }
+    });
+};
+/**
+ * Fetches a backyp and returns the information about it
+ */
+const fetch = (backupID) => {
+    return new Promise(async (resolve, reject) => {
+        getBackupData(backupID)
+            .then((backupData) => {
+                const size = (0, fs_1.statSync)(`${backups}${path_1.sep}${backupID}.json`).size;
+                const backupInfos = {
+                    data: backupData,
+                    id: backupID,
+                    size: Number((size / 1024).toFixed(2))
+                };
+                resolve(backupInfos);
+            })
+            .catch(() => {
+                reject('No backup found');
+            });
+    });
+};
+exports.fetch = fetch;
+/**
+ * Creates a new backup and saves it to the storage
+ */
+const create = async (guild, options = {
+    backupID: null,
+    maxMessagesPerChannel: 10,
+    jsonSave: true,
+    jsonBeautify: true,
+    doNotBackup: ['bans', 'emojis'],
+    backupMembers: false,
+    saveImages: ''
+}) => {
+    return new Promise(async (resolve, reject) => {
+        try {
+            const backupData = {
+                name: guild.name,
+                verificationLevel: guild.verificationLevel,
+                explicitContentFilter: guild.explicitContentFilter,
+                defaultMessageNotifications: guild.defaultMessageNotifications,
+                afk: guild.afkChannel ? { name: guild.afkChannel.name, timeout: guild.afkTimeout } : null,
+                widget: {
+                    enabled: guild.widgetEnabled,
+                    channel: guild.widgetChannel ? guild.widgetChannel.name : null
+                },
+                community: {
+                    enabled: guild.features.includes('COMMUNITY'),
+                    systemChannelFlags: guild.systemChannelFlags ? guild.systemChannelFlags.bitfield : null,
+                    systemChannelId: guild.systemChannelId,
+                    rulesChannelId: guild.rulesChannelId,
+                    publicUpdatesChannelId: guild.publicUpdatesChannelId,
+                    safetyAlertsChannelId: guild.safetyAlertsChannelId || null
+                },
+                channels: { categories: [], others: [] },
+                roles: [],
+                bans: [],
+                emojis: [],
+                members: [],
+                createdTimestamp: Date.now(),
+                guildID: guild.id,
+                id: options.backupID ?? discord_js_1.SnowflakeUtil.generate(Date.now())
+            };
+            if (guild.iconURL()) {
+                if (options && options.saveImages && options.saveImages === 'base64') {
+                    backupData.iconBase64 = (await (0, node_fetch_1.default)(guild.iconURL({ dynamic: true })).then((res) => res.buffer())).toString('base64');
+                }
+                backupData.iconURL = guild.iconURL({ dynamic: true });
+            }
+            if (guild.splashURL()) {
+                if (options && options.saveImages && options.saveImages === 'base64') {
+                    backupData.splashBase64 = (await (0, node_fetch_1.default)(guild.splashURL()).then((res) => res.buffer())).toString('base64');
+                }
+                backupData.splashURL = guild.splashURL();
+            }
+            if (guild.bannerURL()) {
+                if (options && options.saveImages && options.saveImages === 'base64') {
+                    backupData.bannerBase64 = (await (0, node_fetch_1.default)(guild.bannerURL()).then((res) => res.buffer())).toString('base64');
+                }
+                backupData.bannerURL = guild.bannerURL();
+            }
+            if (options && options.backupMembers) {
+                backupData.members = await createMaster.getMembers(guild);
+            }
+            if (!options || !(options.doNotBackup || []).includes('bans')) {
+                backupData.bans = await createMaster.getBans(guild);
+            }
+            if (!options || !(options.doNotBackup || []).includes('roles')) {
+                backupData.roles = await createMaster.getRoles(guild);
+            }
+            if (!options || !(options.doNotBackup || []).includes('emojis')) {
+                backupData.emojis = await createMaster.getEmojis(guild, options);
+            }
+            if (!options || !(options.doNotBackup || []).includes('channels')) {
+                backupData.channels = await createMaster.getChannels(guild, options);
+            }
+            if (!options || options.jsonSave === undefined || options.jsonSave) {
+                const backupJSON = options.jsonBeautify
+                    ? JSON.stringify(backupData, null, 4)
+                    : JSON.stringify(backupData);
+                await (0, promises_1.writeFile)(`${backups}${path_1.sep}${backupData.id}.json`, backupJSON, 'utf-8');
+            }
+            resolve(backupData);
+        }
+        catch (e) {
+            return reject(e);
+        }
+    });
+};
+exports.create = create;
+/**
+ * Loads a backup for a guild
+ */
+const load = async (backup, guild, options = {
+    clearGuildBeforeRestore: true,
+    maxMessagesPerChannel: 10
+}) => {
+    return new Promise(async (resolve, reject) => {
+        if (!guild) {
+            return reject('Invalid guild');
+        }
+        try {
+            const backupData = typeof backup === 'string' ? await getBackupData(backup) : backup;
+            try {
+                if (options.clearGuildBeforeRestore === undefined || options.clearGuildBeforeRestore) {
+                    await utilMaster.clearGuild(guild);
+                }
+                await Promise.all([
+                    loadMaster.loadConfig(guild, backupData),
+                    loadMaster.loadRoles(guild, backupData)
+                ]);
+
+                await new Promise(r => setTimeout(r, 3000));
+
+                await loadMaster.loadChannels(guild, backupData, options);
+
+                const restorePromises = [
+                    loadMaster.loadAFK(guild, backupData),
+                    loadMaster.loadEmbedChannel(guild, backupData)
+                ];
+
+                if (!options.doNotBackup || !options.doNotBackup.includes('emojis')) {
+                    restorePromises.push(loadMaster.loadEmojis(guild, backupData));
+                }
+
+                if (!options.doNotBackup || !options.doNotBackup.includes('bans')) {
+                    restorePromises.push(loadMaster.loadBans(guild, backupData));
+                }
+
+                await Promise.all(restorePromises);
+
+                await loadMaster.loadCommunity(guild, backupData);
+
+                await loadMaster.loadRoleChannelPermissions(guild, backupData, options);
+            }
+            catch (e) {
+                return reject(e);
+            }
+            return resolve(backupData);
+        }
+        catch (e) {
+            return reject('No backup found');
+        }
+    });
+};
+exports.load = load;
+/**
+ * Removes a backup
+ */
+const remove = async (backupID) => {
+    return new Promise((resolve, reject) => {
+        try {
+            require(`${backups}${path_1.sep}${backupID}.json`);
+            (0, fs_1.unlinkSync)(`${backups}${path_1.sep}${backupID}.json`);
+            resolve();
+        }
+        catch (error) {
+            reject('Backup not found');
+        }
+    });
+};
+exports.remove = remove;
+/**
+ * Returns the list of all backup
+ */
+const list = async () => {
+    const files = await (0, promises_1.readdir)(backups);
+    return files.map((f) => f.split('.')[0]);
+};
+exports.list = list;
+/**
+ * Change the storage path
+ */
+const setStorageFolder = (path) => {
+    if (path.endsWith(path_1.sep)) {
+        path = path.substr(0, path.length - 1);
+    }
+    backups = path;
+    if (!(0, fs_1.existsSync)(backups)) {
+        (0, fs_1.mkdirSync)(backups);
+    }
+};
+exports.setStorageFolder = setStorageFolder;
+exports.default = {
+    create: exports.create,
+    fetch: exports.fetch,
+    list: exports.list,
+    load: exports.load,
+    remove: exports.remove
+};

package/lib/load.d.ts

@@ -0,0 +1,30 @@
+import type { BackupData, LoadOptions } from './types';
+import type { Emoji, Guild, Role } from 'discord.js';
+/**
+ * Restores the guild configuration
+ */
+export declare const loadConfig: (guild: Guild, backupData: BackupData) => Promise<Guild[]>;
+/**
+ * Restore the guild roles
+ */
+export declare const loadRoles: (guild: Guild, backupData: BackupData) => Promise<Role[]>;
+/**
+ * Restore the guild channels
+ */
+export declare const loadChannels: (guild: Guild, backupData: BackupData, options: LoadOptions) => Promise<unknown[]>;
+/**
+ * Restore the afk configuration
+ */
+export declare const loadAFK: (guild: Guild, backupData: BackupData) => Promise<Guild[]>;
+/**
+ * Restore guild emojis
+ */
+export declare const loadEmojis: (guild: Guild, backupData: BackupData) => Promise<Emoji[]>;
+/**
+ * Restore guild bans
+ */
+export declare const loadBans: (guild: Guild, backupData: BackupData) => Promise<string[]>;
+/**
+ * Restore embedChannel configuration
+ */
+export declare const loadEmbedChannel: (guild: Guild, backupData: BackupData) => Promise<Guild[]>;