Datastore cleanup (#1892)

* Start Store cleanup

* wip store cleanup

* fix iterables initiating datastores

* handle the possibility of a datastore with no holds and no its own 'create' method

* more cleanup (instances that need more than just client/data)

* missed RoleStore extras

* not sure how eslint didn't catch that tab...

* avoid re-getting the channel we already have...

* cleanup resolvers and refactor them into DataStores

* ^

* and remove

* fix some bugs

* fix lint

* fix documentation maybe?

* formatting

* fix presences

* really fix presences this time

* bad fix was bad... let;s see how bad this one is..

* forgot to save a file

* make presence resolving take userresolveables too

* fix tabs in jsdocs

* fix bad fix from last night that caused issues, with better fix...

* oops

src/stores/ChannelStore.js

@@ -16,7 +16,7 @@ class ChannelStore extends DataStore {
       options = iterableOrOptions;
       iterableOrOptions = undefined;
     }
-    super(client, iterableOrOptions);
+    super(client, iterableOrOptions, Channel);
 
     if (options.lru) {
       const lru = this[kLru] = [];
@@ -72,6 +72,29 @@ class ChannelStore extends DataStore {
     if (channel.guild) channel.guild.channels.remove(id);
     super.remove(id);
   }
+
+  /**
+   * Data that can be resolved to give a Channel object. This can be:
+   * * A Channel object
+   * * A Snowflake
+   * @typedef {Channel|Snowflake} ChannelResolvable
+   */
+
+  /**
+   * Resolves a ChannelResolvable to a Channel object.
+   * @method resolve
+   * @memberof ChannelStore
+   * @param {ChannelResolvable} channel The channel resolvable to resolve
+   * @returns {?Channel}
+   */
+
+  /**
+   * Resolves a ChannelResolvable to a channel ID string.
+   * @method resolveID
+   * @memberof ChannelStore
+   * @param {ChannelResolvable} channel The channel resolvable to resolve
+   * @returns {?string}
+   */
 }
 
 module.exports = ChannelStore;

src/stores/DataStore.js

@@ -5,15 +5,45 @@ const Collection = require('../util/Collection');
  * @extends {Collection}
  */
 class DataStore extends Collection {
-  constructor(client, iterable) {
+  constructor(client, iterable, holds) {
     super();
     Object.defineProperty(this, 'client', { value: client });
+    Object.defineProperty(this, 'holds', { value: holds });
     if (iterable) for (const item of iterable) this.create(item);
   }
 
-  // Stubs
-  create() { return undefined; }
+  create(data, cache = true, { id, extras = [] } = {}) {
+    const existing = this.get(id || data.id);
+    if (existing) return existing;
+
+    const entry = this.holds ? new this.holds(this.client, data, ...extras) : data;
+    if (cache) this.set(id || entry.id, entry);
+    return entry;
+  }
+
   remove(key) { return this.delete(key); }
+
+  /**
+   * Resolves a data entry to a data Object.
+   * @param {string|Object} idOrInstance The id or instance of something in this datastore
+   * @returns {?Object} An instance from this datastore
+   */
+  resolve(idOrInstance) {
+    if (idOrInstance instanceof this.holds) return idOrInstance;
+    if (typeof idOrInstance === 'string') return this.get(idOrInstance) || null;
+    return null;
+  }
+
+  /**
+   * Resolves a data entry to a instance ID.
+   * @param {string|Instance} idOrInstance The id or instance of something in this datastore
+   * @returns {?string}
+   */
+  resolveID(idOrInstance) {
+    if (idOrInstance instanceof this.holds) return idOrInstance.id;
+    if (typeof channel === 'string') return idOrInstance;
+    return null;
+  }
 }
 
 module.exports = DataStore;

src/stores/EmojiStore.js

@@ -1,5 +1,7 @@
 const DataStore = require('./DataStore');
 const Emoji = require('../structures/Emoji');
+const ReactionEmoji = require('../structures/ReactionEmoji');
+
 /**
  * Stores emojis.
  * @private
@@ -7,20 +9,62 @@ const Emoji = require('../structures/Emoji');
  */
 class EmojiStore extends DataStore {
   constructor(guild, iterable) {
-    super(guild.client, iterable);
+    super(guild.client, iterable, Emoji);
     this.guild = guild;
   }
 
-  create(data) {
-    const guild = this.guild;
+  create(data, cache) {
+    super.create(data, cache, { extras: [this.guild] });
+  }
 
-    const existing = guild.emojis.get(data.id);
-    if (existing) return existing;
+  /**
+   * Data that can be resolved into an Emoji object. This can be:
+   * * A custom emoji ID
+   * * An Emoji object
+   * * A ReactionEmoji object
+   * @typedef {Snowflake|Emoji|ReactionEmoji} EmojiResolvable
+   */
 
-    const emoji = new Emoji(guild, data);
-    guild.emojis.set(emoji.id, emoji);
+  /**
+   * Resolves a EmojiResolvable to a Emoji object.
+   * @param {EmojiResolvable} emoji The Emoji resolvable to identify
+   * @returns {?Emoji}
+   */
+  resolve(emoji) {
+    if (emoji instanceof ReactionEmoji) return super.resolve(emoji.id);
+    return super.resolve(emoji);
+  }
 
-    return emoji;
+  /**
+   * Resolves a EmojiResolvable to a Emoji ID string.
+   * @param {EmojiResolvable} emoji The Emoji resolvable to identify
+   * @returns {?string}
+   */
+  resolveID(emoji) {
+    if (emoji instanceof ReactionEmoji) return emoji.id;
+    return super.resolveID(emoji);
+  }
+
+  /**
+   * Data that can be resolved to give an emoji identifier. This can be:
+   * * The unicode representation of an emoji
+   * * An EmojiResolveable
+   * @typedef {string|EmojiResolvable} EmojiIdentifierResolvable
+   */
+
+  /**
+   * Resolves an EmojiResolvable to an emoji identifier.
+   * @param {EmojiIdentifierResolvable} emoji The emoji resolvable to resolve
+   * @returns {?string}
+   */
+  resolveIdentifier(emoji) {
+    const emojiResolveable = this.resolve(emoji);
+    if (emojiResolveable) return emojiResolveable.identifier;
+    if (typeof emoji === 'string') {
+      if (!emoji.includes('%')) return encodeURIComponent(emoji);
+      else return emoji;
+    }
+    return null;
   }
 }
 

src/stores/GuildChannelStore.js

@@ -1,5 +1,6 @@
 const DataStore = require('./DataStore');
 const Channel = require('../structures/Channel');
+const GuildChannel = require('../structures/GuildChannel');
 
 /**
  * Stores guild channels.
@@ -8,7 +9,7 @@ const Channel = require('../structures/Channel');
  */
 class GuildChannelStore extends DataStore {
   constructor(guild, iterable) {
-    super(guild.client, iterable);
+    super(guild.client, iterable, GuildChannel);
     this.guild = guild;
   }
 
@@ -18,6 +19,29 @@ class GuildChannelStore extends DataStore {
 
     return Channel.create(this.client, data, this.guild);
   }
+
+  /**
+   * Data that can be resolved to give a Channel object. This can be:
+   * * A GuildChannel object
+   * * A Snowflake
+   * @typedef {Channel|Snowflake} GuildChannelResolvable
+   */
+
+  /**
+   * Resolves a GuildChannelResolvable to a Channel object.
+   * @method resolve
+   * @memberof GuildChannelStore
+   * @param {GuildChannelResolvable} channel The GuildChannel resolvable to resolve
+   * @returns {?Channel}
+   */
+
+  /**
+   * Resolves a GuildChannelResolvable to a channel ID string.
+   * @method resolveID
+   * @memberof GuildChannelStore
+   * @param {GuildChannelResolvable} channel The GuildChannel resolvable to resolve
+   * @returns {?string}
+   */
 }
 
 module.exports = GuildChannelStore;

src/stores/GuildMemberStore.js

@@ -10,18 +10,44 @@ const { Error } = require('../errors');
  */
 class GuildMemberStore extends DataStore {
   constructor(guild, iterable) {
-    super(guild.client, iterable);
+    super(guild.client, iterable, GuildMember);
     this.guild = guild;
   }
 
-  create(data, cache = true) {
-    const existing = this.get(data.user.id);
-    if (existing) return existing;
+  create(data, cache) {
+    return super.create(data, cache, { extras: [this.guild] });
+  }
 
-    const member = new GuildMember(this.guild, data);
-    if (cache) this.set(member.id, member);
+  /**
+   * Data that resolves to give a GuildMember object. This can be:
+   * * A GuildMember object
+   * * A User resolvable
+   * @typedef {GuildMember|UserResolveable} GuildMemberResolvable
+   */
 
-    return member;
+  /**
+   * Resolves a GuildMemberResolvable to a GuildMember object.
+   * @param {GuildMemberResolvable} member The user that is part of the guild
+   * @returns {?GuildMember}
+   */
+  resolve(member) {
+    const memberResolveable = super.resolve(member);
+    if (memberResolveable) return memberResolveable;
+    const userResolveable = this.client.users.resolveID(member);
+    if (userResolveable) return super.resolve(userResolveable);
+    return null;
+  }
+
+  /**
+   * Resolves a GuildMemberResolvable to an member ID string.
+   * @param {GuildMemberResolvable} member The user that is part of the guild
+   * @returns {?string}
+   */
+  resolveID(member) {
+    const memberResolveable = super.resolveID(member);
+    if (memberResolveable) return memberResolveable;
+    const userResolveable = this.client.users.resolveID(member);
+    return this.has(userResolveable) ? userResolveable : null;
   }
 
   /**
@@ -64,10 +90,10 @@ class GuildMemberStore extends DataStore {
    */
   fetch(options) {
     if (!options) return this._fetchMany();
-    const user = this.client.resolver.resolveUserID(options);
+    const user = this.resolveID(options);
     if (user) return this._fetchSingle({ user, cache: true });
     if (options.user) {
-      options.user = this.client.resolver.resolveUserID(options.user);
+      options.user = this.resolveID(options.user);
       if (options.user) return this._fetchSingle(options);
     }
     return this._fetchMany(options);

src/stores/GuildStore.js

@@ -1,20 +1,38 @@
 const DataStore = require('./DataStore');
 const Guild = require('../structures/Guild');
+
 /**
  * Stores guilds.
  * @private
  * @extends {DataStore}
  */
 class GuildStore extends DataStore {
-  create(data, cache = true) {
-    const existing = this.get(data.id);
-    if (existing) return existing;
-
-    const guild = new Guild(this.client, data);
-    if (cache) this.set(guild.id, guild);
-
-    return guild;
+  constructor(client, iterable) {
+    super(client, iterable, Guild);
   }
+
+  /**
+   * Data that resolves to give a Guild object. This can be:
+   * * A Guild object
+   * * A Snowflake
+   * @typedef {Guild|Snowflake} GuildResolvable
+   */
+
+  /**
+   * Resolves a GuildResolvable to a Guild object.
+   * @method resolve
+   * @memberof GuildStore
+   * @param {GuildResolvable} guild The guild resolvable to identify
+   * @returns {?Guild}
+   */
+
+  /**
+   * Resolves a GuildResolvable to a Guild ID string.
+   * @method resolveID
+   * @memberof GuildStore
+   * @param {GuildResolvable} guild The guild resolvable to identify
+   * @returns {?string}
+   */
 }
 
 module.exports = GuildStore;

src/stores/MessageStore.js

@@ -1,7 +1,7 @@
 const DataStore = require('./DataStore');
 const Collection = require('../util/Collection');
+const Message = require('../structures/Message');
 const { Error } = require('../errors');
-let Message;
 
 /**
  * Stores messages for text-based channels.
@@ -9,19 +9,12 @@ let Message;
  */
 class MessageStore extends DataStore {
   constructor(channel, iterable) {
-    super(channel.client, iterable);
+    super(channel.client, iterable, Message);
     this.channel = channel;
-    Message = require('../structures/Message');
   }
 
-  create(data, cache = true) {
-    const existing = this.get(data.id);
-    if (existing) return existing;
-
-    const message = new Message(this.client.channels.get(data.channel_id), data, this.client);
-
-    if (cache) this.set(message.id, message);
-    return message;
+  create(data, cache) {
+    return super.create(data, cache, { extras: [this.channel] });
   }
 
   set(key, value) {
@@ -62,7 +55,7 @@ class MessageStore extends DataStore {
 
   /**
    * Fetches the pinned messages of this channel and returns a collection of them.
-   * <info>The returned Collection does not contain the reactions of the messages. 
+   * <info>The returned Collection does not contain the reactions of the messages.
    * Those need to be fetched seperately.</info>
    * @returns {Promise<Collection<Snowflake, Message>>}
    */
@@ -95,6 +88,30 @@ class MessageStore extends DataStore {
         return messages;
       });
   }
+
+
+  /**
+   * Data that can be resolved to a Message object. This can be:
+   * * A Message
+   * * A Snowflake
+   * @typedef {Message|Snowflake} MessageResolvable
+   */
+
+  /**
+	* Resolves a MessageResolvable to a Message object.
+	* @method resolve
+	* @memberof MessageStore
+    * @param {MessageResolvable} message The message resolvable to resolve
+    * @returns {?Message}
+    */
+
+  /**
+	* Resolves a MessageResolvable to a Message ID string.
+	* @method MessageStore
+	* @memberof PresenceStore
+    * @param {MessageResolvable} message The message resolvable to resolve
+    * @returns {?string}
+    */
 }
 
 module.exports = MessageStore;

src/stores/PresenceStore.js

@@ -2,13 +2,46 @@ const DataStore = require('./DataStore');
 const { Presence } = require('../structures/Presence');
 
 class PresenceStore extends DataStore {
-  create(data) {
-    if (this.has(data.user.id)) {
-      this.get(data.user.id).patch(data);
-    } else {
-      this.set(data.user.id, new Presence(this.client, data));
-    }
-    return this.get(data.user.id);
+  constructor(client, iterable) {
+    super(client, iterable, Presence);
+  }
+
+  create(data, cache) {
+    const existing = this.get(data.user.id);
+    return existing ? existing.patch(data) : super.create(data, cache, { id: data.user.id });
+  }
+
+  /**
+   * Data that can be resolved to a Presence object. This can be:
+   * * A Presence
+   * * A UserResolveable
+   * * A Snowflake
+   * @typedef {Presence|UserResolveable|Snowflake} PresenceResolvable
+   */
+
+  /**
+    * Resolves a PresenceResolvable to a Presence object.
+    * @param {PresenceResolvable} presence The presence resolvable to resolve
+    * @returns {?Presence}
+    */
+  resolve(presence) {
+    const presenceResolveable = super.resolve(presence);
+    if (presenceResolveable) return presenceResolveable;
+    const UserResolveable = this.client.users.resolveID(presence);
+    return super.resolve(UserResolveable) || null;
+  }
+
+
+  /**
+    * Resolves a PresenceResolvable to a Presence ID string.
+    * @param {PresenceResolvable} presence The presence resolvable to resolve
+    * @returns {?string}
+	*/
+  resolveID(presence) {
+    const presenceResolveable = super.resolveID(presence);
+    if (presenceResolveable) return presenceResolveable;
+    const userResolveable = this.client.users.resolveID(presence);
+    return this.has(userResolveable) ? userResolveable : null;
   }
 }
 

src/stores/ReactionStore.js

@@ -1,5 +1,6 @@
 const DataStore = require('./DataStore');
 const MessageReaction = require('../structures/MessageReaction');
+
 /**
  * Stores reactions.
  * @private
@@ -7,21 +8,37 @@ const MessageReaction = require('../structures/MessageReaction');
  */
 class ReactionStore extends DataStore {
   constructor(message, iterable) {
-    super(message.client, iterable);
+    super(message.client, iterable, MessageReaction);
     this.message = message;
   }
 
-  create(data) {
-    const emojiID = data.emoji.id || decodeURIComponent(data.emoji.name);
-
-    const existing = this.get(emojiID);
-    if (existing) return existing;
-
-    const reaction = new MessageReaction(this.message, data.emoji, data.count, data.me);
-    this.set(emojiID, reaction);
-
-    return reaction;
+  create(data, cache) {
+    data.emoji.id = data.emoji.id || decodeURIComponent(data.emoji.name);
+    return super.create(data, cache, { id: data.emoji.id, extras: [this.message] });
   }
+
+  /**
+   * Data that can be resolved to a MessageReaction object. This can be:
+   * * A MessageReaction
+   * * A Snowflake
+   * @typedef {MessageReaction|Snowflake} MessageReactionResolvable
+   */
+
+  /**
+	* Resolves a MessageReactionResolvable to a MessageReaction object.
+	* @method resolve
+	* @memberof ReactionStore
+    * @param {MessageReactionResolvable} reaction The MessageReaction to resolve
+    * @returns {?MessageReaction}
+    */
+
+  /**
+	* Resolves a MessageReactionResolvable to a MessageReaction ID string.
+	* @method resolveID
+	* @memberof ReactionStore
+    * @param {MessageReactionResolvable} role The role resolvable to resolve
+    * @returns {?string}
+    */
 }
 
 module.exports = ReactionStore;

src/stores/RoleStore.js

@@ -1,5 +1,6 @@
 const DataStore = require('./DataStore');
 const Role = require('../structures/Role');
+
 /**
  * Stores roles.
  * @private
@@ -7,19 +8,36 @@ const Role = require('../structures/Role');
  */
 class RoleStore extends DataStore {
   constructor(guild, iterable) {
-    super(guild.client, iterable);
+    super(guild.client, iterable, Role);
     this.guild = guild;
   }
 
-  create(data) {
-    const existing = this.get(data.id);
-    if (existing) return existing;
-
-    const role = new Role(this.guild, data);
-    this.set(role.id, role);
-
-    return role;
+  create(data, cache) {
+    return super.create(data, cache, { extras: [this.guild] });
   }
+
+  /**
+   * Data that can be resolved to a Role object. This can be:
+   * * A Role
+   * * A Snowflake
+   * @typedef {Role|Snowflake} RoleResolvable
+   */
+
+  /**
+	* Resolves a RoleResolvable to a Role object.
+	* @method resolve
+	* @memberof RoleStore
+    * @param {RoleResolvable} role The role resolvable to resolve
+    * @returns {?Role}
+    */
+
+  /**
+	* Resolves a RoleResolvable to a role ID string.
+	* @method resolveID
+	* @memberof RoleStore
+    * @param {RoleResolvable} role The role resolvable to resolve
+    * @returns {?string}
+    */
 }
 
 module.exports = RoleStore;

src/stores/UserStore.js

@@ -1,18 +1,46 @@
 const DataStore = require('./DataStore');
 const User = require('../structures/User');
+const GuildMember = require('../structures/GuildMember');
+const Message = require('../structures/Message');
 
 /**
  * A data store to store User models.
  * @extends {DataStore}
  */
 class UserStore extends DataStore {
-  create(data, cache = true) {
-    const existing = this.get(data.id);
-    if (existing) return existing;
+  constructor(client, iterable) {
+    super(client, iterable, User);
+  }
 
-    const user = new User(this.client, data);
-    if (cache) this.set(user.id, user);
-    return user;
+  /**
+   * Data that resolves to give a User object. This can be:
+   * * A User object
+   * * A Snowflake
+   * * A Message object (resolves to the message author)
+   * * A GuildMember object
+   * @typedef {User|Snowflake|Message|GuildMember} UserResolvable
+   */
+
+  /**
+   * Resolves a UserResolvable to a User object.
+   * @param {UserResolvable} user The UserResolvable to identify
+   * @returns {?User}
+   */
+  resolve(user) {
+    if (user instanceof GuildMember) return user.user;
+    if (user instanceof Message) return user.author;
+    return super.resolve(user);
+  }
+
+  /**
+   * Resolves a UserResolvable to a user ID string.
+   * @param {UserResolvable} user The UserResolvable to identify
+   * @returns {?string}
+   */
+  resolveID(user) {
+    if (user instanceof GuildMember) return user.user.id;
+    if (user instanceof Message) return user.author.id;
+    return super.resolveID(user);
   }
 
   /**