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	rakinar2	577	/*
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			}