src/core/CommandArgumentParser.ts

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