1.3.3

Change logs:
+ New Event:
> relationshipAdd: user.id, type
> relationshipRemove: user.id
> client.relationships: RelationshipsManager
> User.relationships
> Update Document .-.
- DEPRECATED
> client.blocked
> client.friends
> clientUser.findFriend
> User.blocked
> User.friend
> some console.log()

src/managers/GuildMemberManager.js

@@ -432,7 +432,6 @@ class GuildMemberManager extends CachedManager {
           },
         });
       } else {
-        console.log('send lazy quest')
         let channel;
         let channels = this.guild.channels.cache.filter(c => c.isText());
         channels = channels.filter(c => c.permissionsFor(this.guild.me).has('VIEW_CHANNEL'));

src/managers/RelationshipsManager.js

@@ -0,0 +1,115 @@
+'use strict';
+
+const { Collection } = require('@discordjs/collection');
+const { GuildMember } = require('../structures/GuildMember');
+const { Message } = require('../structures/Message');
+const ThreadMember = require('../structures/ThreadMember');
+const User = require('../structures/User');
+const { RelationshipTypes } = require('../util/Constants');
+
+/**
+ * Manages API methods for users and stores their cache.
+ */
+class RelationshipsManager {
+    constructor(client, users) {
+        this.client = client;
+        this.cache = new Collection();
+        this._setup(users);
+    }
+
+    _setup(users) {
+        if (!Array.isArray(users)) return;
+        for (const relationShip of users) {
+            this.cache.set(relationShip.id, relationShip.type);
+        }
+    }
+
+    /**
+     * Resolves a {@link UserResolvable} to a {@link User} id.
+     * @param {UserResolvable} user The UserResolvable to identify
+     * @returns {?Snowflake}
+     */
+    resolveId(user) {
+        if (user instanceof ThreadMember) return user.id;
+        if (user instanceof GuildMember) return user.user.id;
+        if (user instanceof Message) return user.author.id;
+        if (user instanceof User) return user.id;
+        return user;
+    }
+
+    /**
+     * Obtains a user from Discord, or the user cache if it's already available.
+     * @param {UserResolvable} user The user to fetch
+     * @param {BaseFetchOptions} [options] Additional options for this fetch
+     * @returns {Promise<User>}
+     */
+    async fetch(user, { cache = true, force = false } = {}) {
+        const id = this.resolveId(user);
+        if (!force) {
+            const existing = this.cache.get(id);
+            if (existing && !existing.partial) return existing;
+        }
+
+        const data = await this.client.api.users['@me'].relationships.get();
+        await this._setup(data);
+        return this.cache.get(id);
+    }
+
+    // some option .-.
+
+    async deleteFriend(user) {
+        const id = this.resolveId(user);
+        // check if already friends
+        if (this.cache.get(id) !== RelationshipTypes.FRIEND) return false;
+        await this.client.api.users['@me'].relationships[id].delete(); // 204 status and no data
+        return true;
+    }
+
+    async deleteBlocked(user) {
+        const id = this.resolveId(user);
+        // check if already blocked
+        if (this.cache.get(id) !== RelationshipTypes.BLOCKED) return false;
+        await this.client.api.users['@me'].relationships[id].delete(); // 204 status and no data
+        return true;
+    }
+
+    async sendFriendRequest(username, discriminator) {
+        await this.client.api.users('@me').relationships.post({
+            data: {
+                username,
+                discriminator: parseInt(discriminator),
+            },
+        });
+        return true;
+    }
+
+    async addFriend(user) {
+        const id = this.resolveId(user);
+        // check if already friends
+        if (this.cache.get(id) === RelationshipTypes.FRIEND) return false;
+        // check if outgoing request
+        if (this.cache.get(id) === RelationshipTypes.OUTGOING_REQUEST) return false;
+        await this.client.api
+            .users['@me'].relationships[id].put({
+                data: {
+                    type: RelationshipTypes.FRIEND,
+                },
+            });
+        return true;
+    }
+
+    async addBlocked(user) {
+        const id = this.resolveId(user);
+        // check
+        if (this.cache.get(id) === RelationshipTypes.BLOCKED) return false;
+        await this.client.api
+            .users['@me'].relationships[id].put({
+                data: {
+                    type: RelationshipTypes.BLOCKED,
+                },
+            });
+        return true;
+    }
+}
+
+module.exports = RelationshipsManager;