-
-
Notifications
You must be signed in to change notification settings - Fork 3.9k
/
ApplicationCommandManager.js
104 lines (92 loc) · 3.18 KB
/
ApplicationCommandManager.js
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
'use strict';
const BaseManager = require('./BaseManager');
const ApplicationCommand = require('../structures/ApplicationCommand');
const Collection = require('../util/Collection');
/**
* Manages API methods for application commands and stores their cache.
* @extends {BaseManager}
*/
class ApplicationCommandManager extends BaseManager {
constructor(client, iterable) {
super(client, iterable, ApplicationCommand);
}
/**
* The cache of this manager
* @type {Collection<Snowflake, ApplicationCommand>}
* @name ApplicationCommandManager#cache
*/
add(data, cache) {
return super.add(data, cache, { extras: [this.guild] });
}
/**
* The APIRouter path to the commands
* @type {Object}
* @readonly
* @private
*/
get commandPath() {
let path = this.client.api.applications(this.client.application.id);
if (this.guild) path = path.guilds(this.guild.id);
return path.commands;
}
/**
* Data that resolves to give an ApplicationCommand object. This can be:
* * An ApplicationCommand object
* * A Snowflake
* @typedef {ApplicationCommand|Snowflake} ApplicationCommandResolvable
*/
/**
* Obtains one or multiple application commands from Discord, or the cache if it's already available.
* @param {Snowflake} [id] ID of the application command
* @param {boolean} [cache=true] Whether to cache the new application commands if they weren't already
* @param {boolean} [force=false] Whether to skip the cache check and request the API
* @returns {Promise<ApplicationCommand|Collection<Snowflake, ApplicationCommand>>}
*/
async fetch(id, cache = true, force = false) {
if (id) {
if (!force) {
const existing = this.cache.get(id);
if (existing) return existing;
}
const command = await this.commandPath(id).get();
return this.add(command, cache);
}
const data = await this.commandPath.get();
return data.reduce((coll, command) => coll.set(command.id, this.add(command, cache)), new Collection());
}
/**
* Creates an application command.
* @param {ApplicationCommandData} command The command
* @returns {Promise<ApplicationCommand>}
*/
async create(command) {
const data = await this.commandPath.post({
data: ApplicationCommandManager.transformCommand(command),
});
return this.add(data);
}
/**
* Sets all the commands for this application or guild.
* @param {ApplicationCommandData[]} commands The commands
* @returns {Promise<Collection<Snowflake, ApplicationCommand>>}
*/
async set(commands) {
const data = await this.commandPath.put({
data: commands.map(ApplicationCommandManager.transformCommand),
});
return data.reduce((coll, command) => coll.set(command.id, this.add(command)), new Collection());
}
/**
* Transforms an {@link ApplicationCommandData} object into something that can be used with the API.
* @param {ApplicationCommandData} command The command to transform
* @returns {Object}
* @private
*/
static transformCommand(command) {
return {
...command,
options: command.options?.map(ApplicationCommand.transformOption),
};
}
}
module.exports = ApplicationCommandManager;