src/utils/EmbedSchemaParser.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 {
    APIEmbed,
    APIMessage,
    Embed,
    EmbedBuilder,
    GuildMember,
    JSONEncodable,
    Message,
    MessageCreateOptions,
    MessageEditOptions,
    TextBasedChannel,
    User
} from "discord.js";
import JSON5 from "json5";
import { z } from "zod";
import { log } from "./logger";

type EmbedType = Embed | APIEmbed;
type GetMessageOptions = MessageCreateOptions | APIMessage | MessageEditOptions;

export default class EmbedSchemaParser {
    private static readonly embedZodSchema = z.object({
        title: z.string().max(256).optional(),
        description: z.string().max(4096).optional(),
        url: z.string().url().optional(),
        timestamp: z.string().datetime().optional(),
        color: z.number().min(0).max(0xffffff).optional(),
        provider: z
            .union([
                z.object({
                    name: z.string(),
                    url: z.string().url()
                }),
                z.object({
                    name: z.string().optional(),
                    url: z.string().url()
                }),
                z.object({
                    name: z.string(),
                    url: z.string().url().optional()
                })
            ])
            .optional(),
        author: z
            .object({
                name: z.string().max(256),
                icon_url: z.string().url().optional(),
                url: z.string().url().optional(),
                proxy_icon_url: z.string().url().optional()
            })
            .optional(),
        footer: z
            .object({
                text: z.string().max(2048),
                icon_url: z.string().url().optional(),
                proxy_icon_url: z.string().url().optional()
            })
            .optional(),
        image: z
            .object({
                url: z.string().url(),
                proxy_url: z.string().url().optional(),
                height: z.number().int().optional(),
                width: z.number().int().optional()
            })
            .optional(),
        thumbnail: z
            .object({
                url: z.string().url(),
                proxy_url: z.string().url().optional(),
                height: z.number().int().optional(),
                width: z.number().int().optional()
            })
            .optional(),
        video: z
            .object({
                url: z.string().url(),
                proxy_url: z.string().url().optional(),
                height: z.number().int().optional(),
                width: z.number().int().optional()
            })
            .optional(),
        fields: z
            .array(
                z.object({
                    name: z.string().max(256),
                    value: z.string().max(1024),
                    inline: z.boolean().optional()
                })
            )
            .optional()
    });

    private static readonly embedRequiredFieldNames = [
        "title",
        "description",
        "author",
        "footer",
        "image",
        "video",
        "thumbnail",
        "fields"
    ];

    static parseString(string: string): [EmbedBuilder[], string] {
        const length = string.length;
        const embeds = [];
        let outString = string;

        for (let i = 0; i < length; i++) {
            if (i + 8 < length && (i === 0 || [" ", "\n"].includes(string[i - 1])) && string.substring(i, i + 8) === "embed::{") {
                const pos = i;
                i += 7;

                let jsonStream = "";

                while (string.substring(i, i + 3) !== "}::") {
                    if (string[i] === "\n") {
                        i = pos;
                        break;
                    }

                    jsonStream += string[i];
                    i++;
                }

                jsonStream += "}";

                if (i !== pos) {
                    try {
                        const parsedJSON = JSON5.parse(jsonStream);

                        if (typeof parsedJSON.color === "string") {
                            parsedJSON.color = parsedJSON.color.startsWith("#")
                                ? parseInt(parsedJSON.color.substring(1), 16)
                                : parseInt(parsedJSON.color);
                        }

                        if (!this.validate(parsedJSON)) {
                            continue;
                        }

                        embeds.push(new EmbedBuilder(parsedJSON));
                        outString = outString.replace(new RegExp(`(\\s*)embed::(.{${jsonStream.length}})::(\\s*)`, "gm"), "");
                    } catch (e) {
                        console.error(e);
                        continue;
                    }
                }
            }
        }

        return [embeds, outString];
    }

    private static validate(parsedJSON: object) {
        log(parsedJSON);

        const { success } = this.embedZodSchema.safeParse(parsedJSON);

        if (!success) {
            log("Embed validation failed");
            return false;
        }

        for (const key of this.embedRequiredFieldNames) {
            if (key in parsedJSON) {
                return true;
            }
        }

        log("Embed required key validation failed");

        return false;
    }

    private static toSchemaStringSingle(embed: EmbedType) {
        return `embed::${JSON.stringify(embed)}::`;
    }

    static toSchemaString(embed: EmbedType): string;
    static toSchemaString(embeds: EmbedType[]): string;

    static toSchemaString(embed: EmbedType | EmbedType[]) {
        if (embed instanceof Array) {
            return embed.map(this.toSchemaStringSingle.bind(this));
        }

        return this.toSchemaStringSingle(embed);
    }

    static getMessageOptions<T extends GetMessageOptions>(payload: T, withContent = true) {
        const { content, embeds = [], ...options } = payload;

        type GetMessageOptionsResult = (T extends MessageCreateOptions ? MessageCreateOptions : MessageEditOptions) & {
            embeds: (APIEmbed | JSONEncodable<APIEmbed>)[];
        };

        if (!content) {
            return {
                content,
                embeds,
                ...options
            } as unknown as GetMessageOptionsResult;
        }

        const [parsedEmbeds, strippedContent] = EmbedSchemaParser.parseString(content);

        return {
            ...options,
            embeds: [...embeds, ...parsedEmbeds.slice(0, 10)],
            content: withContent ? strippedContent : undefined
        } as unknown as (T extends MessageCreateOptions ? MessageCreateOptions : MessageEditOptions) & {
            embeds: (APIEmbed | JSONEncodable<APIEmbed>)[];
        };
    }

    static sendMessage(sendable: TextBasedChannel | User | GuildMember, options: MessageCreateOptions) {
        return sendable.send(EmbedSchemaParser.getMessageOptions(options));
    }

    static editMessage(message: Message, options: MessageEditOptions) {
        return message.edit(EmbedSchemaParser.getMessageOptions(options));
    }
}
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 {
21			APIEmbed,
22			APIMessage,
23			Embed,
24			EmbedBuilder,
25			GuildMember,
26			JSONEncodable,
27			Message,
28			MessageCreateOptions,
29			MessageEditOptions,
30			TextBasedChannel,
31			User
32			} from "discord.js";
33			import JSON5 from "json5";
34			import { z } from "zod";
35			import { log } from "./logger";
36
37			type EmbedType = Embed \| APIEmbed;
38			type GetMessageOptions = MessageCreateOptions \| APIMessage \| MessageEditOptions;
39
40			export default class EmbedSchemaParser {
41			private static readonly embedZodSchema = z.object({
42			title: z.string().max(256).optional(),
43			description: z.string().max(4096).optional(),
44			url: z.string().url().optional(),
45			timestamp: z.string().datetime().optional(),
46			color: z.number().min(0).max(0xffffff).optional(),
47			provider: z
48			.union([
49			z.object({
50			name: z.string(),
51			url: z.string().url()
52			}),
53			z.object({
54			name: z.string().optional(),
55			url: z.string().url()
56			}),
57			z.object({
58			name: z.string(),
59			url: z.string().url().optional()
60			})
61			])
62			.optional(),
63			author: z
64			.object({
65			name: z.string().max(256),
66			icon_url: z.string().url().optional(),
67			url: z.string().url().optional(),
68			proxy_icon_url: z.string().url().optional()
69			})
70			.optional(),
71			footer: z
72			.object({
73			text: z.string().max(2048),
74			icon_url: z.string().url().optional(),
75			proxy_icon_url: z.string().url().optional()
76			})
77			.optional(),
78			image: z
79			.object({
80			url: z.string().url(),
81			proxy_url: z.string().url().optional(),
82			height: z.number().int().optional(),
83			width: z.number().int().optional()
84			})
85			.optional(),
86			thumbnail: z
87			.object({
88			url: z.string().url(),
89			proxy_url: z.string().url().optional(),
90			height: z.number().int().optional(),
91			width: z.number().int().optional()
92			})
93			.optional(),
94			video: z
95			.object({
96			url: z.string().url(),
97			proxy_url: z.string().url().optional(),
98			height: z.number().int().optional(),
99			width: z.number().int().optional()
100			})
101			.optional(),
102			fields: z
103			.array(
104			z.object({
105			name: z.string().max(256),
106			value: z.string().max(1024),
107			inline: z.boolean().optional()
108			})
109			)
110			.optional()
111			});
112
113			private static readonly embedRequiredFieldNames = [
114			"title",
115			"description",
116			"author",
117			"footer",
118			"image",
119			"video",
120			"thumbnail",
121			"fields"
122			];
123
124			static parseString(string: string): [EmbedBuilder[], string] {
125			const length = string.length;
126			const embeds = [];
127			let outString = string;
128
129			for (let i = 0; i < length; i++) {
130			if (i + 8 < length && (i === 0 \|\| [" ", "\n"].includes(string[i - 1])) && string.substring(i, i + 8) === "embed::{") {
131			const pos = i;
132			i += 7;
133
134			let jsonStream = "";
135
136			while (string.substring(i, i + 3) !== "}::") {
137			if (string[i] === "\n") {
138			i = pos;
139			break;
140			}
141
142			jsonStream += string[i];
143			i++;
144			}
145
146			jsonStream += "}";
147
148			if (i !== pos) {
149			try {
150			const parsedJSON = JSON5.parse(jsonStream);
151
152			if (typeof parsedJSON.color === "string") {
153			parsedJSON.color = parsedJSON.color.startsWith("#")
154			? parseInt(parsedJSON.color.substring(1), 16)
155			: parseInt(parsedJSON.color);
156			}
157
158			if (!this.validate(parsedJSON)) {
159			continue;
160			}
161
162			embeds.push(new EmbedBuilder(parsedJSON));
163			outString = outString.replace(new RegExp(`(\\s)embed::(.{${jsonStream.length}})::(\\s)`, "gm"), "");
164			} catch (e) {
165			console.error(e);
166			continue;
167			}
168			}
169			}
170			}
171
172			return [embeds, outString];
173			}
174
175			private static validate(parsedJSON: object) {
176			log(parsedJSON);
177
178			const { success } = this.embedZodSchema.safeParse(parsedJSON);
179
180			if (!success) {
181			log("Embed validation failed");
182			return false;
183			}
184
185			for (const key of this.embedRequiredFieldNames) {
186			if (key in parsedJSON) {
187			return true;
188			}
189			}
190
191			log("Embed required key validation failed");
192
193			return false;
194			}
195
196			private static toSchemaStringSingle(embed: EmbedType) {
197			return `embed::${JSON.stringify(embed)}::`;
198			}
199
200			static toSchemaString(embed: EmbedType): string;
201			static toSchemaString(embeds: EmbedType[]): string;
202
203			static toSchemaString(embed: EmbedType \| EmbedType[]) {
204			if (embed instanceof Array) {
205			return embed.map(this.toSchemaStringSingle.bind(this));
206			}
207
208			return this.toSchemaStringSingle(embed);
209			}
210
211			static getMessageOptions<T extends GetMessageOptions>(payload: T, withContent = true) {
212			const { content, embeds = [], ...options } = payload;
213
214			type GetMessageOptionsResult = (T extends MessageCreateOptions ? MessageCreateOptions : MessageEditOptions) & {
215			embeds: (APIEmbed \| JSONEncodable<APIEmbed>)[];
216			};
217
218			if (!content) {
219			return {
220			content,
221			embeds,
222			...options
223			} as unknown as GetMessageOptionsResult;
224			}
225
226			const [parsedEmbeds, strippedContent] = EmbedSchemaParser.parseString(content);
227
228			return {
229			...options,
230			embeds: [...embeds, ...parsedEmbeds.slice(0, 10)],
231			content: withContent ? strippedContent : undefined
232			} as unknown as (T extends MessageCreateOptions ? MessageCreateOptions : MessageEditOptions) & {
233			embeds: (APIEmbed \| JSONEncodable<APIEmbed>)[];
234			};
235			}
236
237			static sendMessage(sendable: TextBasedChannel \| User \| GuildMember, options: MessageCreateOptions) {
238			return sendable.send(EmbedSchemaParser.getMessageOptions(options));
239			}
240
241			static editMessage(message: Message, options: MessageEditOptions) {
242			return message.edit(EmbedSchemaParser.getMessageOptions(options));
243			}
244			}