Add basic valibot template wrapper

Author: TheKodeToad

backend/src/common/template/formatting.ts

@@ -1,10 +1,10 @@
 import { formatUser, formatUserBold } from "../../bot/common/discord/format.ts";
 import { escapeMarkdown, makeMarkdownInlineCodeblock, makeMarkdownMultilineCodeblock, makeMarkdownQuote } from "../../bot/common/discord/markdown.ts";
 import { dateToUnixSeconds, humanizeDuration } from "../time.ts";
-import { DurationPresentationType, FormattingWrapper, ParameterType, TimestampPresentationType, UserPresentationType, type AnyParameterValue, type UserParameter } from "./index.ts";
+import { DurationPresentationType, FormattingWrapper, ParameterType, TimestampPresentationType, UserPresentationType, type ParameterRecord, type UserParameter } from "./index.ts";
 import { TokenType, type Token } from "./parsing.ts";
 
-export function format(params: Record<string, AnyParameterValue>, tokens: Token[]): string {
+export function formatTokens(params: ParameterRecord, tokens: Token[]): string {
 	let result = "";
 
 	for (const token of tokens) {

backend/src/common/template/index.ts

@@ -1,27 +1,34 @@
-import { format } from "./formatting.ts";
-import { parseTemplateTokens, type Token } from "./parsing.ts";
+/*
+ * Parsing and formatting for templates for config values like 'Hello {{user#tag}}'.
+ *
+ * The message is split in to "tokens" and validated based on the passed schema.
+ * This is a loose usage of the term, but in this case tokens consist of:
+ * - Any literal text
+ * - Parsed expressions inside {{}}
+ *
+ * These tokens are then rejoined in the formatting stage, based on the passed parameters.
+ */
 
-export class Template<P extends Record<string, ParameterType>> {
-	private _tokens: Token[];
+import { formatTokens } from "./formatting.ts";
+import { parseTemplateTokens } from "./parsing.ts";
 
-	public static parse<P extends Record<string, ParameterType>>(template: string, params: P): Template<P> | string {
-		const tokens = parseTemplateTokens(template, params);
+/**
+ * @returns A function to call to format data with the template,
+ * or an error denoting something that went wrong with parsing.
+ */
+export function parseTemplate<S extends TemplateSchema>(template: string, schema: S): ((params: ParameterRecord<S>) => string) | string {
+	// just a typed wrapper
+	const tokens = parseTemplateTokens(template, schema);
 
-		if (typeof tokens === "string")
-			return tokens;
+	if (typeof tokens === "string")
+		return tokens;
 
-		return new Template(tokens);
-	}
-
-	private constructor(tokens: Token[]) {
-		this._tokens = tokens;
-	}
-
-	public format(params: { readonly [K in keyof P]: ParameterValue<P[K]> }): string {
-		return format(params, this._tokens);
-	}
+	return params => formatTokens(params, tokens);
 }
 
+export type TemplateSchema = Record<string, ParameterType>;
+export type ParameterRecord<S extends Record<string, ParameterType> = any> = { readonly [K in keyof S]: ParameterValue<S[K]> };
+
 export const enum FormattingWrapper {
 	BlockQuote,
 	InlineCodeblock,
@@ -65,8 +72,6 @@ export const enum TimestampPresentationType {
 
 export type UserParameter = { id: string; tag: string; };
 
-export type AnyParameterValue = ParameterValue<any>;
-
 type ParameterValue<T extends ParameterType = any> =
 	T extends ParameterType.User ? UserParameter :
 	T extends ParameterType.RawString ? string :

backend/src/common/template/parsing.ts

@@ -8,7 +8,7 @@ interface FormatGroups {
 	presentation?: string;
 };
 
-export function parseTemplateTokens(template: string, params: Record<string, ParameterType>): Token[] | string {
+export function parseTemplateTokens(template: string, schema: Record<string, ParameterType>): Token[] | string {
 	const result: Token[] = [];
 
 	let match = FORMAT_PATTERN.exec(template);
@@ -23,7 +23,7 @@ export function parseTemplateTokens(template: string, params: Record<string, Par
 		}
 
 		const groups = match.groups as unknown as FormatGroups;
-		const token = parseFormatToken(groups, params);
+		const token = parseFormatToken(groups, schema);
 
 		if (typeof token === "string")
 			return token;

backend/src/schema/common/template.ts

@@ -0,0 +1,19 @@
+import { pipe, rawTransform, string } from "valibot";
+import { parseTemplate, type TemplateSchema } from "../../common/template/index.ts";
+
+// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+export function template<S extends TemplateSchema>(schema: S) {
+	return pipe(string(), rawTransform(({ dataset, addIssue, NEVER }) => {
+		if (!dataset.typed)
+			return NEVER;
+
+		const template = parseTemplate(dataset.value, schema);
+
+		if (typeof template === "string") {
+			addIssue({ message: template });
+			return NEVER;
+		}
+
+		return template;
+	}));
+}