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 { AnyFunction } from "../types/Utils";
import { logWarn } from "../utils/Logger";
import { stringToTimeInterval } from "../utils/datetime";
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, unknown> = {};
        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 AnyFunction;

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

                state.type = type;

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