src/core/CommandArgumentParser.ts

/*
* This file is part of SudoBot.
*
* Copyright (C) 2021-2023 OSN Developers.
*
* SudoBot is free software; you can redistribute it and/or modify it
* under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* SudoBot is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with SudoBot. If not, see <https://www.gnu.org/licenses/>.
*/

import { Awaitable, Client, GuildBasedChannel, GuildMember, Role, SnowflakeUtil, User } from "discord.js";
import { stringToTimeInterval } from "../utils/datetime";
import { logWarn } from "../utils/logger";
import CommandArgumentParserInterface, {
    ArgumentType,
    ParseOptions,
    ParseResult,
    ParserJump,
    ParsingState,
    ValidationErrorType
} from "./CommandArgumentParserInterface";

class ArgumentParseError extends Error {
    constructor(message: string, public readonly type: ValidationErrorType | ValidationErrorType[]) {
        super(`[${type}]: ${message}`);
    }
}

export default class CommandArgumentParser implements CommandArgumentParserInterface {
    protected readonly parsers: Record<ArgumentType, Extract<keyof CommandArgumentParser, `parse${string}Type`>> = {
        [ArgumentType.String]: "parseStringType",
        [ArgumentType.Snowflake]: "parseSnowflakeType",
        [ArgumentType.StringRest]: "parseStringRestType",
        [ArgumentType.Channel]: "parseEntityType",
        [ArgumentType.User]: "parseEntityType",
        [ArgumentType.Role]: "parseEntityType",
        [ArgumentType.Member]: "parseEntityType",
        [ArgumentType.Float]: "parseNumericType",
        [ArgumentType.Integer]: "parseNumericType",
        [ArgumentType.Number]: "parseNumericType",
        [ArgumentType.Link]: "parseLinkType",
        [ArgumentType.TimeInterval]: "parseTimeIntervalType"
    };

    constructor(protected readonly client: Client) {}

    parseTimeIntervalType(state: ParsingState): Awaitable<ParseResult<number>> {
        const { result, error } = stringToTimeInterval(state.currentArg!, {
            milliseconds: state.rule.time?.unit === "ms"
        });

        if (error) {
            throw new ArgumentParseError(`Error occurred while parsing time interval: ${error}`, "type:invalid");
        }

        const max = state.rule.time?.max;
        const min = state.rule.time?.min;

        if (min !== undefined && result < min) {
            throw new ArgumentParseError("Time interval is less than the minimum limit", ["time:range:min", "time:range"]);
        } else if (max !== undefined && result > max) {
            throw new ArgumentParseError("Time interval has exceeded the maximum limit", ["time:range:max", "time:range"]);
        }

        return {
            result
        };
    }

    parseLinkType(state: ParsingState): Awaitable<ParseResult<string | URL>> {
        try {
            const url = new URL(state.currentArg!);

            return {
                result: state.rule.link?.urlObject ? url : state.currentArg!
            };
        } catch (error) {
            throw new ArgumentParseError("Invalid URL", "type:invalid");
        }
    }

    parseNumericType(state: ParsingState): Awaitable<ParseResult<number>> {
        const number =
            state.type === ArgumentType.Float || state.currentArg!.includes(".")
                ? parseFloat(state.currentArg!)
                : parseInt(state.currentArg!);

        if (isNaN(number)) {
            throw new ArgumentParseError("Invalid numeric value", "type:invalid");
        }

        const max = state.rule.number?.max;
        const min = state.rule.number?.min;

        if (min !== undefined && number < min) {
            throw new ArgumentParseError("Numeric value is less than the minimum limit", ["number:range:min", "number:range"]);
        } else if (max !== undefined && number > max) {
            throw new ArgumentParseError("Numeric value exceeded the maximum limit", ["number:range:max", "number:range"]);
        }

        return {
            result: number
        };
    }

    async parseEntityType(state: ParsingState): Promise<ParseResult<GuildBasedChannel | User | Role | GuildMember | null>> {
        let id = state.currentArg!;

        if (!id.startsWith("<") && !id.endsWith(">") && !/^\d+$/.test(id)) {
            throw new ArgumentParseError("Invalid entity ID", ["type:invalid"]);
        }

        switch (state.type) {
            case ArgumentType.Role:
                id = id.startsWith("<@&") && id.endsWith(">") ? id.substring(3, id.length - 1) : id;
                break;

            case ArgumentType.Member:
            case ArgumentType.User:
                id = id.startsWith("<@") && id.endsWith(">") ? id.substring(id.includes("!") ? 3 : 2, id.length - 1) : id;
                break;

            case ArgumentType.Channel:
                id = id.startsWith("<#") && id.endsWith(">") ? id.substring(2, id.length - 1) : id;
                break;

            default:
                logWarn("parseEntityType logic error: used as unsupported argument type handler");
        }

        try {
            const entity = await (state.type === ArgumentType.Channel
                ? state.parseOptions.message?.guild?.channels.fetch(id)
                : state.type === ArgumentType.Member
                ? state.parseOptions.message?.guild?.members.fetch(id)
                : state.type === ArgumentType.Role
                ? state.parseOptions.message?.guild?.roles.fetch(id)
                : state.type === ArgumentType.User
                ? this.client.users.fetch(id)
                : null);

            if (!entity) {
                throw new Error();
            }

            return {
                result: entity
            };
        } catch (error) {
            if (state.rule.entity === true || (typeof state.rule.entity === "object" && state.rule.entity?.notNull)) {
                throw new ArgumentParseError("Failed to fetch entity", "entity:null");
            }

            return {
                result: null
            };
        }
    }

    parseStringType(state: ParsingState): Awaitable<ParseResult<string | null>> {
        this.validateStringType(state);

        return {
            result: state.currentArg == "" ? null : state.currentArg
        };
    }

    parseSnowflakeType(state: ParsingState): Awaitable<ParseResult<string>> {
        try {
            SnowflakeUtil.decode(state.currentArg!);
        } catch (error) {
            throw new ArgumentParseError("The snowflake argument is invalid", "type:invalid");
        }

        return {
            result: state.currentArg
        };
    }

    parseStringRestType(state: ParsingState): Awaitable<ParseResult<string>> {
        this.validateStringType(state, ["string:rest", "string"]);

        let string = state.parseOptions.input.trim().substring(state.parseOptions.prefix.length).trim();

        for (let i = 0; i < Object.keys(state.parsedArgs).length + 1; i++) {
            string = string.trim().substring(state.argv[i].length);
        }

        string = string.trim();

        return {
            result: string,
            jump: ParserJump.Break
        };
    }

    private validateStringType(state: ParsingState, prefixes: ("string" | "string:rest")[] = ["string"]) {
        if (
            (state.rule.string?.notEmpty || !state.rule.optional) &&
            !state.currentArg?.trim() &&
            prefixes.length === 1 &&
            prefixes.includes("string")
        )
            throw new ArgumentParseError(
                "The string must not be empty",
                !state.rule.optional ? `required` : `${prefixes[0] as "string"}:empty`
            );
        else if (state.rule.string?.minLength !== undefined && (state.currentArg?.length ?? 0) < state.rule.string.minLength)
            throw new ArgumentParseError(
                "The string is too short",
                prefixes.map(prefix => `${prefix}:length:min` as const)
            );
        else if (state.rule.string?.maxLength !== undefined && (state.currentArg?.length ?? 0) > state.rule.string.maxLength)
            throw new ArgumentParseError(
                "The string is too long",
                prefixes.map(prefix => `${prefix}:length:max` as const)
            );
    }

    async parse(parseOptions: ParseOptions) {
        const { input, rules, prefix } = parseOptions;
        const parsedArgs: Record<string | number, any> = {};
        const argv = input.trim().substring(prefix.length).trim().split(/\s+/);
        const args = [...argv];

        args.shift();

        const state = {
            argv,
            args,
            parsedArgs,
            index: 0,
            currentArg: args[0],
            rule: rules[0],
            parseOptions
        } as ParsingState;

        let counter = 0;

        ruleLoop: for (state.index = 0; state.index < rules.length; state.index++) {
            const rule = rules[state.index];
            state.currentArg = state.args[state.index];
            state.rule = rules[state.index];

            let result = null,
                lastError: ArgumentParseError | null = null;

            if (!state.currentArg) {
                if (!rule.optional) {
                    return { error: rule.errors?.["required"] ?? `Argument #${state.index} is required` };
                } else if (rule.default !== undefined) {
                    result = {
                        result: rule.default
                    } satisfies ParseResult;
                }

                state.parsedArgs[rule.name ?? counter++] = result?.result ?? null;
                continue;
            }

            for (const type of rule.types) {
                const parser = this.parsers[type];
                const handler = this[parser] as Function;

                if (!parser || !handler) {
                    throw new Error(`Parser for type "${ArgumentType[type]}" is not implemented.`);
                }

                state.type = type;

                try {
                    result = await handler.call(this, state);
                    lastError = null;
                } catch (error) {
                    if (error instanceof ArgumentParseError) {
                        lastError = error;
                    }
                }

                if (!lastError) {
                    break;
                }

                if (result?.jump === ParserJump.Break) break ruleLoop;
                else if (result?.jump === ParserJump.Next) continue ruleLoop;
                else if (result?.jump === ParserJump.Steps) {
                    state.index += result?.steps ?? 1;
                    break;
                }
            }

            if (lastError) {
                let errorMessage: string | undefined;

                if (typeof lastError.type === "string") {
                    errorMessage = rule.errors?.[lastError.type];
                } else {
                    for (const type of lastError.type) {
                        errorMessage = rule.errors?.[type];

                        if (errorMessage) {
                            break;
                        }
                    }
                }

                return { error: errorMessage ?? lastError.message };
            }

            if (!result) {
                return { error: `Failed to parse argument #${state.index}` };
            }

            state.parsedArgs[rule.name ?? counter++] = result.result;
        }

        return {
            parsedArgs
        };
    }
}
1	/*
2	* This file is part of SudoBot.
3	*
4	* Copyright (C) 2021-2023 OSN Developers.
5	*
6	* SudoBot is free software; you can redistribute it and/or modify it
7	* under the terms of the GNU Affero General Public License as published by
8	* the Free Software Foundation, either version 3 of the License, or
9	* (at your option) any later version.
10	*
11	* SudoBot is distributed in the hope that it will be useful, but
12	* WITHOUT ANY WARRANTY; without even the implied warranty of
13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14	* GNU Affero General Public License for more details.
15	*
16	* You should have received a copy of the GNU Affero General Public License
17	* along with SudoBot. If not, see <https://www.gnu.org/licenses/>.
18	*/
19
20	import { Awaitable, Client, GuildBasedChannel, GuildMember, Role, SnowflakeUtil, User } from "discord.js";
21	import { stringToTimeInterval } from "../utils/datetime";
22	import { logWarn } from "../utils/logger";
23	import CommandArgumentParserInterface, {
24	ArgumentType,
25	ParseOptions,
26	ParseResult,
27	ParserJump,
28	ParsingState,
29	ValidationErrorType
30	} from "./CommandArgumentParserInterface";
31
32	class ArgumentParseError extends Error {
33	constructor(message: string, public readonly type: ValidationErrorType \| ValidationErrorType[]) {
34	super(`[${type}]: ${message}`);
35	}
36	}
37
38	export default class CommandArgumentParser implements CommandArgumentParserInterface {
39	protected readonly parsers: Record<ArgumentType, Extract<keyof CommandArgumentParser, `parse${string}Type`>> = {
40	[ArgumentType.String]: "parseStringType",
41	[ArgumentType.Snowflake]: "parseSnowflakeType",
42	[ArgumentType.StringRest]: "parseStringRestType",
43	[ArgumentType.Channel]: "parseEntityType",
44	[ArgumentType.User]: "parseEntityType",
45	[ArgumentType.Role]: "parseEntityType",
46	[ArgumentType.Member]: "parseEntityType",
47	[ArgumentType.Float]: "parseNumericType",
48	[ArgumentType.Integer]: "parseNumericType",
49	[ArgumentType.Number]: "parseNumericType",
50	[ArgumentType.Link]: "parseLinkType",
51	[ArgumentType.TimeInterval]: "parseTimeIntervalType"
52	};
53
54	constructor(protected readonly client: Client) {}
55
56	parseTimeIntervalType(state: ParsingState): Awaitable<ParseResult<number>> {
57	const { result, error } = stringToTimeInterval(state.currentArg!, {
58	milliseconds: state.rule.time?.unit === "ms"
59	});
60
61	if (error) {
62	throw new ArgumentParseError(`Error occurred while parsing time interval: ${error}`, "type:invalid");
63	}
64
65	const max = state.rule.time?.max;
66	const min = state.rule.time?.min;
67
68	if (min !== undefined && result < min) {
69	throw new ArgumentParseError("Time interval is less than the minimum limit", ["time:range:min", "time:range"]);
70	} else if (max !== undefined && result > max) {
71	throw new ArgumentParseError("Time interval has exceeded the maximum limit", ["time:range:max", "time:range"]);
72	}
73
74	return {
75	result
76	};
77	}
78
79	parseLinkType(state: ParsingState): Awaitable<ParseResult<string \| URL>> {
80	try {
81	const url = new URL(state.currentArg!);
82
83	return {
84	result: state.rule.link?.urlObject ? url : state.currentArg!
85	};
86	} catch (error) {
87	throw new ArgumentParseError("Invalid URL", "type:invalid");
88	}
89	}
90
91	parseNumericType(state: ParsingState): Awaitable<ParseResult<number>> {
92	const number =
93	state.type === ArgumentType.Float \|\| state.currentArg!.includes(".")
94	? parseFloat(state.currentArg!)
95	: parseInt(state.currentArg!);
96
97	if (isNaN(number)) {
98	throw new ArgumentParseError("Invalid numeric value", "type:invalid");
99	}
100
101	const max = state.rule.number?.max;
102	const min = state.rule.number?.min;
103
104	if (min !== undefined && number < min) {
105	throw new ArgumentParseError("Numeric value is less than the minimum limit", ["number:range:min", "number:range"]);
106	} else if (max !== undefined && number > max) {
107	throw new ArgumentParseError("Numeric value exceeded the maximum limit", ["number:range:max", "number:range"]);
108	}
109
110	return {
111	result: number
112	};
113	}
114
115	async parseEntityType(state: ParsingState): Promise<ParseResult<GuildBasedChannel \| User \| Role \| GuildMember \| null>> {
116	let id = state.currentArg!;
117
118	if (!id.startsWith("<") && !id.endsWith(">") && !/^\d+$/.test(id)) {
119	throw new ArgumentParseError("Invalid entity ID", ["type:invalid"]);
120	}
121
122	switch (state.type) {
123	case ArgumentType.Role:
124	id = id.startsWith("<@&") && id.endsWith(">") ? id.substring(3, id.length - 1) : id;
125	break;
126
127	case ArgumentType.Member:
128	case ArgumentType.User:
129	id = id.startsWith("<@") && id.endsWith(">") ? id.substring(id.includes("!") ? 3 : 2, id.length - 1) : id;
130	break;
131
132	case ArgumentType.Channel:
133	id = id.startsWith("<#") && id.endsWith(">") ? id.substring(2, id.length - 1) : id;
134	break;
135
136	default:
137	logWarn("parseEntityType logic error: used as unsupported argument type handler");
138	}
139
140	try {
141	const entity = await (state.type === ArgumentType.Channel
142	? state.parseOptions.message?.guild?.channels.fetch(id)
143	: state.type === ArgumentType.Member
144	? state.parseOptions.message?.guild?.members.fetch(id)
145	: state.type === ArgumentType.Role
146	? state.parseOptions.message?.guild?.roles.fetch(id)
147	: state.type === ArgumentType.User
148	? this.client.users.fetch(id)
149	: null);
150
151	if (!entity) {
152	throw new Error();
153	}
154
155	return {
156	result: entity
157	};
158	} catch (error) {
159	if (state.rule.entity === true \|\| (typeof state.rule.entity === "object" && state.rule.entity?.notNull)) {
160	throw new ArgumentParseError("Failed to fetch entity", "entity:null");
161	}
162
163	return {
164	result: null
165	};
166	}
167	}
168
169	parseStringType(state: ParsingState): Awaitable<ParseResult<string \| null>> {
170	this.validateStringType(state);
171
172	return {
173	result: state.currentArg == "" ? null : state.currentArg
174	};
175	}
176
177	parseSnowflakeType(state: ParsingState): Awaitable<ParseResult<string>> {
178	try {
179	SnowflakeUtil.decode(state.currentArg!);
180	} catch (error) {
181	throw new ArgumentParseError("The snowflake argument is invalid", "type:invalid");
182	}
183
184	return {
185	result: state.currentArg
186	};
187	}
188
189	parseStringRestType(state: ParsingState): Awaitable<ParseResult<string>> {
190	this.validateStringType(state, ["string:rest", "string"]);
191
192	let string = state.parseOptions.input.trim().substring(state.parseOptions.prefix.length).trim();
193
194	for (let i = 0; i < Object.keys(state.parsedArgs).length + 1; i++) {
195	string = string.trim().substring(state.argv[i].length);
196	}
197
198	string = string.trim();
199
200	return {
201	result: string,
202	jump: ParserJump.Break
203	};
204	}
205
206	private validateStringType(state: ParsingState, prefixes: ("string" \| "string:rest")[] = ["string"]) {
207	if (
208	(state.rule.string?.notEmpty \|\| !state.rule.optional) &&
209	!state.currentArg?.trim() &&
210	prefixes.length === 1 &&
211	prefixes.includes("string")
212	)
213	throw new ArgumentParseError(
214	"The string must not be empty",
215	!state.rule.optional ? `required` : `${prefixes[0] as "string"}:empty`
216	);
217	else if (state.rule.string?.minLength !== undefined && (state.currentArg?.length ?? 0) < state.rule.string.minLength)
218	throw new ArgumentParseError(
219	"The string is too short",
220	prefixes.map(prefix => `${prefix}:length:min` as const)
221	);
222	else if (state.rule.string?.maxLength !== undefined && (state.currentArg?.length ?? 0) > state.rule.string.maxLength)
223	throw new ArgumentParseError(
224	"The string is too long",
225	prefixes.map(prefix => `${prefix}:length:max` as const)
226	);
227	}
228
229	async parse(parseOptions: ParseOptions) {
230	const { input, rules, prefix } = parseOptions;
231	const parsedArgs: Record<string \| number, any> = {};
232	const argv = input.trim().substring(prefix.length).trim().split(/\s+/);
233	const args = [...argv];
234
235	args.shift();
236
237	const state = {
238	argv,
239	args,
240	parsedArgs,
241	index: 0,
242	currentArg: args[0],
243	rule: rules[0],
244	parseOptions
245	} as ParsingState;
246
247	let counter = 0;
248
249	ruleLoop: for (state.index = 0; state.index < rules.length; state.index++) {
250	const rule = rules[state.index];
251	state.currentArg = state.args[state.index];
252	state.rule = rules[state.index];
253
254	let result = null,
255	lastError: ArgumentParseError \| null = null;
256
257	if (!state.currentArg) {
258	if (!rule.optional) {
259	return { error: rule.errors?.["required"] ?? `Argument #${state.index} is required` };
260	} else if (rule.default !== undefined) {
261	result = {
262	result: rule.default
263	} satisfies ParseResult;
264	}
265
266	state.parsedArgs[rule.name ?? counter++] = result?.result ?? null;
267	continue;
268	}
269
270	for (const type of rule.types) {
271	const parser = this.parsers[type];
272	const handler = this[parser] as Function;
273
274	if (!parser \|\| !handler) {
275	throw new Error(`Parser for type "${ArgumentType[type]}" is not implemented.`);
276	}
277
278	state.type = type;
279
280	try {
281	result = await handler.call(this, state);
282	lastError = null;
283	} catch (error) {
284	if (error instanceof ArgumentParseError) {
285	lastError = error;
286	}
287	}
288
289	if (!lastError) {
290	break;
291	}
292
293	if (result?.jump === ParserJump.Break) break ruleLoop;
294	else if (result?.jump === ParserJump.Next) continue ruleLoop;
295	else if (result?.jump === ParserJump.Steps) {
296	state.index += result?.steps ?? 1;
297	break;
298	}
299	}
300
301	if (lastError) {
302	let errorMessage: string \| undefined;
303
304	if (typeof lastError.type === "string") {
305	errorMessage = rule.errors?.[lastError.type];
306	} else {
307	for (const type of lastError.type) {
308	errorMessage = rule.errors?.[type];
309
310	if (errorMessage) {
311	break;
312	}
313	}
314	}
315
316	return { error: errorMessage ?? lastError.message };
317	}
318
319	if (!result) {
320	return { error: `Failed to parse argument #${state.index}` };
321	}
322
323	state.parsedArgs[rule.name ?? counter++] = result.result;
324	}
325
326	return {
327	parsedArgs
328	};
329	}
330	}