Cache dump to disk

.eslintrc.json

@@ -111,6 +111,7 @@
 		"prefer-numeric-literals":"error",
 		"prefer-spread":"error",
 		"prefer-template":"error",
-		"symbol-description":"error"
+		"symbol-description":"error",
+		"no-func-loop": false
 	}
 }

.gitignore

@@ -3,3 +3,7 @@ package-lock.json
 .vscode
 .eslintrc.json
 .gitattributes
+.pnp.js
+.yarnrc.yml
+yarn.lock
+.sessions

README.md

@@ -104,6 +104,7 @@ The following client options are available to control caching behavior:
 | cacheEmojis | boolean | false | Enables caching of all Emojis at login |
 | cachePresences | boolean | false | Enables caching of all Presences. If not enabled, Presences will be cached only for cached Users |
 | cacheMembers | boolean | false | Enables caching of Users and Members when possible |
+| hotReload | boolean or object | false | Enables hot reloading, an experimental feature that enables instantly restarting the bot |
 | disabledEvents | array | [] | An array of events to ignore ([Discord events](https://github.com/discordjs/discord.js/blob/master/src/util/Constants.js#L339), not Discord.JS events). Use this in combination with intents for fine tuning which events your bot should process |
 
 This library implements its own partials system, therefore the `partials` client option is not available. All other discord.js client options continue to be available and should work normally.
@@ -148,6 +149,44 @@ Voice States will be cached if the `GUILD_VOICE_STATES` intent is enabled (requi
 
 Messages are cached only if the Channel they belong to is cached. Message caching can further be controlled via discord.js's `messageCacheMaxSize`, `messageCacheLifetime` and `messageSweepInterval` client options as usual. Additionally, the `messageEditHistoryMaxSize` client option is set to `1` by default (instead of infinity).
 
+## Hot reloading
+
+**THIS FEATURE IS CURRENTLY EXPERIMENTAL USE AT YOUR OWN RISK!**
+
+When developing bots you will likely do lots of trial and error which often requires restarting your bot.
+Each restart requires reconnecting to the Discord gateway on every shard which can often take a long time and eat up your daily identifies.
+
+Hot reloading provides a way to simply resume the previous gateway sessions on startup rather than creating new ones.
+This is done by storing the process data outside the process right before it exits and reloading the data into it when it starts.
+
+This option can be overridden with a few custom methods:
+
+```js
+const cache = {
+    guilds: {
+        "581072557512458241": {} // Discord api type
+    }
+}
+
+const sessions = {
+    "0": {
+        id: "3e961ec59a7c24b91198d07dd3189fa0", // Session ID
+        sequence: 19, // The close sequence of the session
+        lastConnected: 1617382560867 // Time the session was closed at
+    }
+}
+
+new Discord.Client({
+    hotReload: {
+        cacheData: cache, // user-supplied cache data. if not present, cache will be loaded from disk
+        sessionData: sessions, // user-supplied session data. if not present, sessions will be loaded from disk
+        onExit: (sessions, cache) => {} // user-supplied data storing function. if not present, data will be stored to disk. This function can be async if the process is exited by using SIGINT (Ctrl+C), any other ways of exit are sync-only.
+    }
+})
+```
+
+Session and cache data can also be obtained at runtime using `client.dumpCache()` and `client.dumpSessions()` for storage before a manually induced exit. In this case the user should pass an empty function to onExit to override the built-in disk storage.
+
 ## Events
 
 Most events should be identical to the originals aside from the caching behavior plus they always emit regardless of caching state. When required data is missing, a partial structure where only an id is guaranteed will be given (the `.partial` property is not guaranteed to exist on all partials).

classes.js

@@ -93,6 +93,81 @@ Discord.Structures.extend("Message", M => {
 				}
 			}
 		}
+		_unpatch() {
+			return {
+				id: this.id,
+				type: Discord.Constants.MessageTypes.indexOf(this.type),
+				content: this.content,
+				author: this.author._unpatch(),
+				pinned: this.pinned,
+				tts: this.tts,
+				nonce: this.nonce,
+				embeds: this.embeds.map(x => x.toJSON()),
+				attachments: this.attachments.map(x => ({
+					filename: x.name,
+					id: x.id,
+					size: x.size,
+					url: x.url,
+					proxy_url: x.proxyURL,
+					height: x.height,
+					width: x.width
+				})),
+				edited_timestamp: this.editedTimestamp,
+				reactions: this.reactions.cache.map(x => ({
+					me: x.me,
+					emoji: {
+						animated: x.emoji.animated,
+						name: x.emoji.name,
+						id: x.emoji.id
+					},
+					count: x.count
+				})),
+				mentions: this.mentions.users.map(x => x._unpatch()),
+				mention_roles: this.mentions.roles.map(x => x._unpatch()),
+				mention_everyone: this.mentions.everyone,
+				mention_channels: this.mentions.crosspostedChannels.map(x => ({
+					id: x.channelID,
+					guild_id: x.guildID,
+					type: Discord.Constants.ChannelTypes[x.type.toUpperCase()],
+					name: x.name
+				})),
+				webhook_id: this.webhookID,
+				application: this.application ? {
+					id: this.application.id,
+					name: this.application.name,
+					description: this.application.description,
+					icon: this.application.icon,
+					cover_image: this.application.cover,
+					rpc_origins: this.application.rpcOrigins,
+					bot_require_code_grant: this.botRequireCodeGrant,
+					bot_public: this.application.botPublic,
+					team: this.application.owner instanceof Discord.Team ? {
+						id: this.application.owner.id,
+						name: this.application.owner.name,
+						icon: this.application.owner.icon,
+						owner_user_id: this.application.owner.ownerID,
+						members: this.application.owner.members.map(x => ({
+							permissions: x.permissions,
+							membership_state: x.membershipState,
+							user: x.user._unpatch()
+						}))
+					} : void 0,
+					owner: this.application.owner instanceof Discord.User ? this.application.owner._unpatch() : void 0
+				} : void 0,
+				activity: this.activity ? {
+					party_id: this.activity.partyID,
+					type: this.activity.type
+				} : void 0,
+				member: this.member?._unpatch(),
+				flags: this.flags.valueOf(),
+				message_reference: this.reference ? {
+					channel_id: this.reference.channelID,
+					guild_id: this.reference.guildID,
+					message_id: this.reference.messageID
+				} : void 0,
+				referenced_message: this.client.guilds.cache.get(this.reference?.guildID)?.channels.cache.get(this.reference?.channelID)?.messages.cache.get(this.reference?.messageID)?._unpatch()
+			};
+		}
 		get member() {
 			if(!this.guild) { return null; }
 			const id = (this.author || {}).id || (this._member || {}).id;
@@ -120,6 +195,22 @@ Discord.Structures.extend("Message", M => {
 	};
 });
 
+Discord.Structures.extend("User", U => {
+	return class User extends U {
+		_unpatch() {
+			return {
+				id: this.id,
+				username: this.username,
+				bot: this.bot,
+				discriminator: this.discriminator,
+				avatar: this.avatar,
+				system: this.system,
+				public_flags: this.flags?.valueOf()
+			};
+		}
+	};
+});
+
 Discord.Structures.extend("GuildMember", G => {
 	return class GuildMember extends G {
 		_patch(data) {
@@ -138,6 +229,16 @@ Discord.Structures.extend("GuildMember", G => {
 				}
 			}
 		}
+		_unpatch() {
+			return {
+				user: this.user._unpatch(),
+				nick: this.nickname,
+				joined_at: this.joinedTimestamp,
+				premium_since: this.premiumSinceTimestamp,
+				roles: this._roles,
+				pending: this.pending
+			};
+		}
 		equals(member) {
 			return member && this.deleted === member.deleted && this.nickname === member.nickname && this._roles.length === member._roles.length;
 		}
@@ -186,8 +287,8 @@ Discord.Structures.extend("Guild", G => {
 						this.members.add(member);
 					}
 				}
-				if(!this.members.cache.has(this.client.user.id)) {
-					this.members.fetch(this.client.user.id).catch(() => {});
+				if(!this.members.cache.has(this.client.user?.id)) {
+					this.members.fetch(this.client.user?.id).catch(() => {});
 				}
 			}
 			if(Array.isArray(data.presences)) {
@@ -216,6 +317,52 @@ Discord.Structures.extend("Guild", G => {
 				}
 			}
 		}
+		_unpatch() {
+			return {
+				unavailable: !this.available,
+				shardID: this.shardID,
+				name: this.name,
+				icon: this.icon,
+				splash: this.splash,
+				discovery_splash: this.discoverySplash,
+				region: this.region,
+				member_count: this.memberCount,
+				large: this.large,
+				features: this.features,
+				application_id: this.applicationID,
+				afk_timeout: this.afkTimeout,
+				afk_channel_id: this.afkChannelID,
+				system_channel_id: this.systemChannelID,
+				premium_tier: this.premiumTier,
+				premium_subscription_count: this.premiumSubscriptionCount,
+				widget_enabled: this.widgetEnabled,
+				widget_channel_id: this.widgetChannelID,
+				verification_level: Discord.Constants.VerificationLevels.indexOf(this.verificationLevel),
+				explicit_content_filter: Discord.Constants.ExplicitContentFilterLevels.indexOf(this.explicitContentFilter),
+				mfa_level: this.mfaLevel,
+				joinedTimestamp: this.joinedTimestamp,
+				default_message_notifications: this.defaultMessageNotifications,
+				system_channel_flags: this.systemChannelFlags?.valueOf(),
+				max_members: this.maximumMembers,
+				max_presences: this.maximumPresences,
+				approximate_member_count: this.approximateMemberCount,
+				approximate_presence_count: this.approximatePresenceCount,
+				vanity_url_code: this.vanityURLCode,
+				description: this.description,
+				banner: this.banner,
+				id: this.id,
+				rules_channel_id: this.rulesChannelID,
+				public_updates_channel_id: this.publicUpdatesChannelID,
+				preferred_locale: this.preferredLocale,
+				roles: this.roles.cache.map(x => x._unpatch()),
+				members: this.members.cache.map(x => x._unpatch()),
+				channels: this.channels.cache.map(x => x._unpatch()),
+				owner_id: this.ownerID,
+				presences: this.presences.cache.map(x => x._unpatch()),
+				voice_states: this.voiceStates.cache.map(x => x._unpatch()),
+				emojis: this.emojis?.cache.map(x => x._unpatch())
+			};
+		}
 		get nameAcronym() {
 			return this.name ? super.nameAcronym : void 0;
 		}
@@ -275,6 +422,18 @@ Discord.Structures.extend("GuildEmoji", E => {
 				this._author = data.user.id;
 			}
 		}
+		_unpatch() {
+			return {
+				animated: this.animated,
+				name: this.name,
+				id: this.id,
+				require_colons: this.requiresColons,
+				managed: this.managed,
+				available: this.available,
+				roles: this._roles,
+				user: this.author ? this.author._unpatch() : void 0
+			};
+		}
 		async fetchAuthor(cache = true) {
 			if(this.managed) {
 				throw new Error("EMOJI_MANAGED");
@@ -291,6 +450,28 @@ Discord.Structures.extend("GuildEmoji", E => {
 	};
 });
 
+Discord.Structures.extend("Role", R => {
+	return class Role extends R {
+		_unpatch() {
+			return {
+				id: this.id,
+				name: this.name,
+				color: this.color,
+				hoist: this.hoist,
+				position: this.rawPosition,
+				permissions: this.permissions.valueOf().toString(),
+				managed: this.managed,
+				mentionable: this.mentionable,
+				tags: {
+					bot_id: this.tags?.botID,
+					integration_id: this.tags?.integrationID,
+					premium_subscriber: this.tags?.premiumSubscriberRole
+				}
+			};
+		}
+	};
+});
+
 Discord.Structures.extend("VoiceState", V => {
 	return class VoiceState extends V {
 		_patch(data) {
@@ -300,6 +481,19 @@ Discord.Structures.extend("VoiceState", V => {
 			}
 			return this;
 		}
+		_unpatch() {
+			return {
+				user_id: this.id,
+				deaf: this.serverDeaf,
+				mute: this.serverMute,
+				self_deaf: this.selfDeaf,
+				self_mute: this.selfMute,
+				self_video: this.selfVideo,
+				session_id: this.sessionID,
+				self_stream: this.streaming,
+				channel_id: this.channelID
+			};
+		}
 		get channel() {
 			return this.channelID ? this.client.channels.cache.get(this.channelID) || this.client.channels.add({
 				id: this.channelID,
@@ -354,6 +548,40 @@ Discord.Structures.extend("Presence", P => {
 			}
 			return this;
 		}
+		_unpatch() {
+			return {
+				user: { id: this.userID },
+				status: this.status,
+				activities: this.activities.map(a => ({
+					name: a.name,
+					type: a.type,
+					url: a.url,
+					details: a.details,
+					state: a.state,
+					application_id: a.applicationID,
+					timestamps: a.timestamps ? {
+						start: a.timestamps.start ? a.timestamps.start.getTime() : null,
+						end: a.timestamps.end ? a.timestamps.end.getTime() : null
+					} : void 0,
+					party: a.party,
+					assets: a.assets ? {
+						large_text: a.assets.largeText,
+						small_text: a.assets.smallText,
+						large_image: a.assets.largeImage,
+						small_image: a.assets.smallImage
+					} : void 0,
+					sync_id: a.syncID,
+					flags: a.flags.valueOf(),
+					emoji: a.emoji ? {
+						animated: a.emoji.animated,
+						name: a.emoji.name,
+						id: a.emoji.id
+					} : void 0,
+					created_at: a.createdTimestamp
+				})),
+				client_status: this.clientStatus
+			};
+		}
 		get user() {
 			return this.client.users.cache.get(this.userID) || this.client.users.add((this._member || {}).user || { id: this.userID }, false);
 		}