discord.js-backup-v13 13.1.1

package/lib/load.js

@@ -0,0 +1,256 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadEmbedChannel = exports.loadBans = exports.loadEmojis = exports.loadAFK = exports.loadChannels = exports.loadRoles = exports.loadConfig = void 0;
+const util_1 = require("./util");
+/**
+ * Restores the guild configuration
+ */
+const loadConfig = (guild, backupData) => {
+    const configPromises = [];
+    if (backupData.name) {
+        configPromises.push(guild.setName(backupData.name));
+    }
+    if (backupData.iconBase64) {
+        configPromises.push(guild.setIcon(Buffer.from(backupData.iconBase64, 'base64')));
+    }
+    else if (backupData.iconURL) {
+        configPromises.push(guild.setIcon(backupData.iconURL));
+    }
+    if (backupData.splashBase64) {
+        configPromises.push(guild.setSplash(Buffer.from(backupData.splashBase64, 'base64')));
+    }
+    else if (backupData.splashURL) {
+        configPromises.push(guild.setSplash(backupData.splashURL));
+    }
+    if (backupData.bannerBase64) {
+        configPromises.push(guild.setBanner(Buffer.from(backupData.bannerBase64, 'base64')));
+    }
+    else if (backupData.bannerURL) {
+        configPromises.push(guild.setBanner(backupData.bannerURL));
+    }
+    if (backupData.verificationLevel) {
+        configPromises.push(guild.setVerificationLevel(backupData.verificationLevel));
+    }
+    if (backupData.defaultMessageNotifications) {
+        configPromises.push(guild.setDefaultMessageNotifications(backupData.defaultMessageNotifications));
+    }
+    const changeableExplicitLevel = guild.features.includes('COMMUNITY');
+    if (backupData.explicitContentFilter && changeableExplicitLevel) {
+        configPromises.push(guild.setExplicitContentFilter(backupData.explicitContentFilter));
+    }
+    return Promise.all(configPromises);
+};
+exports.loadConfig = loadConfig;
+/**
+ * Restore the guild roles
+ */
+const loadRoles = (guild, backupData) => {
+    const rolePromises = [];
+    backupData.roles.forEach((roleData) => {
+        if (roleData.isEveryone) {
+            rolePromises.push(guild.roles.cache.get(guild.id).edit({
+                name: roleData.name,
+                color: roleData.color,
+                permissions: BigInt(roleData.permissions),
+                mentionable: roleData.mentionable
+            }));
+        }
+        else {
+            rolePromises.push(guild.roles.create({
+                name: roleData.name,
+                color: roleData.color,
+                hoist: roleData.hoist,
+                permissions: BigInt(roleData.permissions),
+                mentionable: roleData.mentionable
+            }));
+        }
+    });
+    return Promise.all(rolePromises);
+};
+exports.loadRoles = loadRoles;
+/**
+ * Restore the guild channels
+ */
+const loadChannels = (guild, backupData, options) => {
+    const loadChannelPromises = [];
+    backupData.channels.categories.forEach((categoryData) => {
+        if (!categoryData.name) return;
+        
+        loadChannelPromises.push(new Promise(async (resolve) => {
+            try {
+                const createdCategory = await (0, util_1.loadCategory)(categoryData, guild);
+                const childChannelPromises = [];
+                
+                categoryData.children.forEach((channelData) => {
+                    if (!channelData.name) return;
+                    childChannelPromises.push((0, util_1.loadChannel)(channelData, guild, createdCategory, options));
+                });
+                
+                await Promise.all(childChannelPromises);
+                resolve(true);
+            } catch (error) {
+                resolve(false);
+            }
+        }));
+    });
+    backupData.channels.others.forEach((channelData) => {
+        if (!channelData.name) return;
+        loadChannelPromises.push((0, util_1.loadChannel)(channelData, guild, null, options));
+    });
+    return Promise.all(loadChannelPromises);
+};
+exports.loadChannels = loadChannels;
+
+/**
+ * Restore the afk configuration
+ */
+const loadAFK = (guild, backupData) => {
+    const afkPromises = [];
+    if (backupData.afk) {
+        afkPromises.push(guild.setAFKChannel(guild.channels.cache.find((ch) => ch.name === backupData.afk.name && ch.type === 'GUILD_VOICE')));
+        afkPromises.push(guild.setAFKTimeout(backupData.afk.timeout));
+    }
+    return Promise.all(afkPromises);
+};
+exports.loadAFK = loadAFK;
+/**
+ * Restore guild emojis
+ */
+const loadEmojis = (guild, backupData) => {
+    const emojiPromises = [];
+    backupData.emojis.forEach((emoji) => {
+        if (emoji.url) {
+            emojiPromises.push(guild.emojis.create(emoji.url, emoji.name));
+        }
+        else if (emoji.base64) {
+            emojiPromises.push(guild.emojis.create(Buffer.from(emoji.base64, 'base64'), emoji.name));
+        }
+    });
+    return Promise.all(emojiPromises);
+};
+exports.loadEmojis = loadEmojis;
+/**
+ * Restore guild bans
+ */
+const loadBans = (guild, backupData) => {
+    const banPromises = [];
+    backupData.bans.forEach((ban) => {
+        banPromises.push(guild.members.ban(ban.id, {
+            reason: ban.reason
+        }));
+    });
+    return Promise.all(banPromises);
+};
+exports.loadBans = loadBans;
+/**
+ * Restore embedChannel configuration
+ */
+const loadEmbedChannel = (guild, backupData) => {
+    const embedChannelPromises = [];
+    if (backupData.widget.channel) {
+        embedChannelPromises.push(guild.setWidgetSettings({
+            enabled: backupData.widget.enabled,
+            channel: guild.channels.cache.find((ch) => ch.name === backupData.widget.channel)
+        }));
+    }
+    return Promise.all(embedChannelPromises);
+};
+exports.loadEmbedChannel = loadEmbedChannel;
+
+const loadCommunity = async (guild, backupData) => {
+    if (!backupData.community) return;
+
+    const rulesChannelData = backupData.channels.categories.find(c => c.children.find(ch => ch.rulesChannel)) || backupData.channels.others.find(c => c.rulesChannel);
+    const publicUpdatesChannelData = backupData.channels.categories.find(c => c.children.find(ch => ch.publicUpdatesChannel)) || backupData.channels.others.find(c => c.publicUpdatesChannel);
+
+    let rulesChannel;
+    let publicUpdatesChannel;
+
+    try {
+        const isCommunityEnabled = guild.features.includes('COMMUNITY');
+        const shouldBeCommunityEnabled = backupData.community.enabled;
+
+        if (shouldBeCommunityEnabled && !isCommunityEnabled) {
+            if (!rulesChannel && backupData.community.rulesChannelId)
+                rulesChannel = guild.channels.cache.find(ch => ch.name == rulesChannelData?.name && ch.type === 'GUILD_TEXT');
+
+            if (!publicUpdatesChannel && backupData.community.publicUpdatesChannelId)
+                publicUpdatesChannel = guild.channels.cache.filter(ch => ch.name == publicUpdatesChannelData?.name && ch.type === 'GUILD_TEXT' && ch.id !== rulesChannel?.id).first();
+
+            if (rulesChannel && publicUpdatesChannel) {
+                try {
+                    await guild.setCommunity(true, 'Backup', rulesChannel, publicUpdatesChannel);
+                    await new Promise(r => setTimeout(r, 3000));
+                } catch (error) {
+                    false
+                }
+            }
+        }
+        else if (shouldBeCommunityEnabled && isCommunityEnabled) {
+            const currentRulesChannel = guild.rulesChannel;
+            const currentPublicUpdatesChannel = guild.publicUpdatesChannel;
+
+            let newRulesChannel = null;
+            let newPublicUpdatesChannel = null;
+
+            if (backupData.community.rulesChannelId)
+                newRulesChannel = guild.channels.cache.find(ch => ch.name == rulesChannelData?.name);
+
+            if (backupData.community.publicUpdatesChannelId)
+                newPublicUpdatesChannel = guild.channels.cache.find(ch => ch.name == publicUpdatesChannelData?.name);
+
+            const rulesChannelChanged = newRulesChannel && currentRulesChannel?.id !== newRulesChannel.id;
+            const updatesChannelChanged = newPublicUpdatesChannel && currentPublicUpdatesChannel?.id !== newPublicUpdatesChannel.id;
+
+            if ((rulesChannelChanged || updatesChannelChanged) && newRulesChannel && newPublicUpdatesChannel) {
+                try {
+                    await guild.setRulesChannel(newRulesChannel.id).catch(() => false);
+                    await guild.setPublicUpdatesChannel(newPublicUpdatesChannel.id).catch(() => false);
+                } catch (error) { false }
+                currentPublicUpdatesChannel.delete().catch(() => false);
+                currentRulesChannel.delete().catch(() => false);
+            }
+        }
+        else if (!shouldBeCommunityEnabled && isCommunityEnabled)
+            await guild.setCommunity(false, 'Backup');
+    } catch (error) {
+        false
+    }
+};
+
+const loadRoleChannelPermissions = async (guild, backupData, options = {}) => {
+    const { Permissions } = require('discord.js-selfbot-v13');
+    
+    for (const roleData of backupData.roles) {
+        if (!roleData.channelPermissions) continue;
+        
+        let role = guild.roles.cache.find(r => r.name === roleData.name);
+        if (!role && roleData.isEveryone) {
+            role = guild.roles.cache.get(guild.id);
+        }
+        
+        if (!role) continue;
+        
+        for (const [channelName, permissions] of Object.entries(roleData.channelPermissions)) {
+            const channel = guild.channels.cache.find(c => c.name === channelName);
+            if (!channel) continue;
+            
+            try {
+                const allowBitfield = Permissions.resolve(permissions.allow);
+                const denyBitfield = Permissions.resolve(permissions.deny);
+                
+                await channel.permissionOverwrites.edit(role.id, {
+                    allow: allowBitfield,
+                    deny: denyBitfield
+                });
+                
+                await new Promise(r => setTimeout(r, 200));
+            } catch (error) {
+                continue;
+            }
+        }
+    }
+};
+
+exports.loadCommunity = loadCommunity;
+exports.loadRoleChannelPermissions = loadRoleChannelPermissions;

package/lib/types/AfkData.d.ts

@@ -0,0 +1,4 @@
+export interface AfkData {
+    name: string;
+    timeout: number;
+}

package/lib/types/AfkData.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/BackupData.d.ts

@@ -0,0 +1,25 @@
+import { DefaultMessageNotificationLevel, ExplicitContentFilterLevel, Snowflake, VerificationLevel } from 'discord.js';
+import { AfkData, BanData, ChannelsData, EmojiData, RoleData, WidgetData } from './';
+import { MemberData } from './MemberData';
+export interface BackupData {
+    name: string;
+    iconURL?: string;
+    iconBase64?: string;
+    verificationLevel: VerificationLevel;
+    explicitContentFilter: ExplicitContentFilterLevel;
+    defaultMessageNotifications: DefaultMessageNotificationLevel | number;
+    afk?: AfkData;
+    widget: WidgetData;
+    splashURL?: string;
+    splashBase64?: string;
+    bannerURL?: string;
+    bannerBase64?: string;
+    channels: ChannelsData;
+    roles: RoleData[];
+    bans: BanData[];
+    emojis: EmojiData[];
+    members: MemberData[];
+    createdTimestamp: number;
+    guildID: string;
+    id: Snowflake;
+}

package/lib/types/BackupData.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/BackupInfos.d.ts

@@ -0,0 +1,6 @@
+import { BackupData } from './';
+export interface BackupInfos {
+    id: string;
+    size: number;
+    data: BackupData;
+}

package/lib/types/BackupInfos.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/BanData.d.ts

@@ -0,0 +1,5 @@
+import { Snowflake } from 'discord.js';
+export interface BanData {
+    id: Snowflake;
+    reason: string;
+}

package/lib/types/BanData.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/BaseChannelData.d.ts

@@ -0,0 +1,8 @@
+import { TextBasedChannelTypes, VoiceBasedChannelTypes, ThreadChannelTypes } from 'discord.js';
+import { ChannelPermissionsData } from './';
+export interface BaseChannelData {
+    type: TextBasedChannelTypes | VoiceBasedChannelTypes | ThreadChannelTypes;
+    name: string;
+    parent?: string;
+    permissions: ChannelPermissionsData[];
+}

package/lib/types/BaseChannelData.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/CategoryData.d.ts

@@ -0,0 +1,6 @@
+import { ChannelPermissionsData, TextChannelData, VoiceChannelData } from './';
+export interface CategoryData {
+    name: string;
+    permissions: ChannelPermissionsData[];
+    children: Array<TextChannelData | VoiceChannelData>;
+}

package/lib/types/CategoryData.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/ChannelPermissionData.d.ts

@@ -0,0 +1,5 @@
+export interface ChannelPermissionsData {
+    roleName: string;
+    allow: string;
+    deny: string;
+}

package/lib/types/ChannelPermissionData.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/ChannelsData.d.ts

@@ -0,0 +1,5 @@
+import { CategoryData, TextChannelData, VoiceChannelData } from './';
+export interface ChannelsData {
+    categories: CategoryData[];
+    others: Array<TextChannelData | VoiceChannelData>;
+}

package/lib/types/ChannelsData.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/CreateOptions.d.ts

@@ -0,0 +1,9 @@
+export interface CreateOptions {
+    backupID?: string;
+    maxMessagesPerChannel?: number;
+    jsonSave?: boolean;
+    jsonBeautify?: boolean;
+    doNotBackup?: string[];
+    backupMembers?: boolean;
+    saveImages?: string;
+}

package/lib/types/CreateOptions.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/EmojiData.d.ts

@@ -0,0 +1,5 @@
+export interface EmojiData {
+    name: string;
+    url?: string;
+    base64?: string;
+}

package/lib/types/EmojiData.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/LoadOptions.d.ts

@@ -0,0 +1,6 @@
+import { MessageMentionOptions } from "discord.js";
+export interface LoadOptions {
+    clearGuildBeforeRestore: boolean;
+    maxMessagesPerChannel?: number;
+    allowedMentions?: MessageMentionOptions;
+}

package/lib/types/LoadOptions.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/MemberData.d.ts

@@ -0,0 +1,9 @@
+export interface MemberData {
+    userId: string;
+    username: string;
+    discriminator: string;
+    avatarUrl: string;
+    joinedTimestamp: number;
+    roles: string[];
+    bot: boolean;
+}

package/lib/types/MemberData.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/MessageData.d.ts

@@ -0,0 +1,10 @@
+import { MessageEmbed, FileOptions } from 'discord.js';
+export interface MessageData {
+    username: string;
+    avatar?: string;
+    content?: string;
+    embeds?: MessageEmbed[];
+    files?: FileOptions[];
+    pinned?: boolean;
+    sentAt: string;
+}

package/lib/types/MessageData.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/RoleData.d.ts

@@ -0,0 +1,9 @@
+export interface RoleData {
+    name: string;
+    color: `#${string}`;
+    hoist: boolean;
+    permissions: string;
+    mentionable: boolean;
+    position: number;
+    isEveryone: boolean;
+}

package/lib/types/RoleData.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/TextChannelData.d.ts

@@ -0,0 +1,10 @@
+import { BaseChannelData, MessageData, ThreadChannelData } from './';
+export interface TextChannelData extends BaseChannelData {
+    nsfw: boolean;
+    parent?: string;
+    topic?: string;
+    rateLimitPerUser?: number;
+    isNews: boolean;
+    messages: MessageData[];
+    threads: ThreadChannelData[];
+}

package/lib/types/TextChannelData.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/ThreadChannelData.d.ts

@@ -0,0 +1,11 @@
+import { ThreadAutoArchiveDuration, ThreadChannelTypes } from "discord.js";
+import { MessageData } from "./MessageData";
+export interface ThreadChannelData {
+    type: ThreadChannelTypes;
+    name: string;
+    archived: boolean;
+    autoArchiveDuration: ThreadAutoArchiveDuration;
+    locked: boolean;
+    rateLimitPerUser: number;
+    messages: MessageData[];
+}

package/lib/types/ThreadChannelData.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/VoiceChannelData.d.ts

@@ -0,0 +1,5 @@
+import { BaseChannelData } from './';
+export interface VoiceChannelData extends BaseChannelData {
+    bitrate: number;
+    userLimit: number;
+}

package/lib/types/VoiceChannelData.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/WidgetData.d.ts

@@ -0,0 +1,4 @@
+export interface WidgetData {
+    enabled: boolean;
+    channel?: string;
+}

package/lib/types/WidgetData.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/index.d.ts

@@ -0,0 +1,17 @@
+export * from './AfkData';
+export * from './BackupData';
+export * from './BackupInfos';
+export * from './BanData';
+export * from './BaseChannelData';
+export * from './CategoryData';
+export * from './ChannelPermissionData';
+export * from './ChannelsData';
+export * from './CreateOptions';
+export * from './EmojiData';
+export * from './LoadOptions';
+export * from './MessageData';
+export * from './RoleData';
+export * from './TextChannelData';
+export * from './ThreadChannelData';
+export * from './VoiceChannelData';
+export * from './WidgetData';

package/lib/types/index.js

@@ -0,0 +1,33 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./AfkData"), exports);
+__exportStar(require("./BackupData"), exports);
+__exportStar(require("./BackupInfos"), exports);
+__exportStar(require("./BanData"), exports);
+__exportStar(require("./BaseChannelData"), exports);
+__exportStar(require("./CategoryData"), exports);
+__exportStar(require("./ChannelPermissionData"), exports);
+__exportStar(require("./ChannelsData"), exports);
+__exportStar(require("./CreateOptions"), exports);
+__exportStar(require("./EmojiData"), exports);
+__exportStar(require("./LoadOptions"), exports);
+__exportStar(require("./MessageData"), exports);
+__exportStar(require("./RoleData"), exports);
+__exportStar(require("./TextChannelData"), exports);
+__exportStar(require("./ThreadChannelData"), exports);
+__exportStar(require("./VoiceChannelData"), exports);
+__exportStar(require("./WidgetData"), exports);

package/lib/util.d.ts

@@ -0,0 +1,27 @@
+import type { CategoryData, ChannelPermissionsData, CreateOptions, LoadOptions, MessageData, TextChannelData, VoiceChannelData } from './types';
+import type { CategoryChannel, Guild, TextChannel, VoiceChannel, NewsChannel, ThreadChannel } from 'discord.js';
+/**
+ * Gets the permissions for a channel
+ */
+export declare function fetchChannelPermissions(channel: TextChannel | VoiceChannel | CategoryChannel | NewsChannel): ChannelPermissionsData[];
+/**
+ * Fetches the voice channel data that is necessary for the backup
+ */
+export declare function fetchVoiceChannelData(channel: VoiceChannel): Promise<VoiceChannelData>;
+export declare function fetchChannelMessages(channel: TextChannel | NewsChannel | ThreadChannel, options: CreateOptions): Promise<MessageData[]>;
+/**
+ * Fetches the text channel data that is necessary for the backup
+ */
+export declare function fetchTextChannelData(channel: TextChannel | NewsChannel, options: CreateOptions): Promise<TextChannelData>;
+/**
+ * Creates a category for the guild
+ */
+export declare function loadCategory(categoryData: CategoryData, guild: Guild): Promise<CategoryChannel>;
+/**
+ * Create a channel and returns it
+ */
+export declare function loadChannel(channelData: TextChannelData | VoiceChannelData, guild: Guild, category?: CategoryChannel, options?: LoadOptions): Promise<unknown>;
+/**
+ * Delete all roles, all channels, all emojis, etc... of a guild
+ */
+export declare function clearGuild(guild: Guild): Promise<void>;