@sealcode/sealgen 0.19.32 → 0.19.33

package/src/forms/fields/structured.ts

@@ -0,0 +1,151 @@
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { is, predicates } from "@sealcode/ts-predicates";
+import {
+	CollectionItem,
+	ExtractFieldDecoded,
+	ExtractFieldInput,
+	Field as SealiousField,
+	FieldTypes as SealiousFieldTypes,
+} from "sealious";
+import { FieldParseResult, FormField } from "./field.js";
+import { FieldGroup, FormControl } from "../controls/controls.js";
+import { Context } from "koa";
+import { FormDataValue } from "../form-types.js";
+import { sealiousFieldToFormField } from "./collection-field.js";
+import { ExtractedFieldInfo } from "../../utils/extract-fields-from-collection.js";
+
+export class StructuredSealiousField<
+	Structure extends Record<string, SealiousField<any>>,
+	F extends SealiousFieldTypes.Structured<Structure>,
+> extends FormField<
+	false,
+	ExtractFieldDecoded<F>,
+	FormControl,
+	ExtractFieldInput<F>
+> {
+	constructor(public sealiousField: F) {
+		super(false);
+	}
+
+	public getEmptyValue(): ExtractFieldDecoded<F> {
+		return {} as ExtractFieldDecoded<F>;
+	}
+
+	async parse(
+		ctx: Context,
+		raw_value: FormDataValue
+	): Promise<FieldParseResult<ExtractFieldDecoded<F>>> {
+		const sealiousField = this
+			.sealiousField as SealiousFieldTypes.Structured<
+			Record<string, SealiousField<any>>
+		>;
+
+		if (!is(raw_value, predicates.object)) {
+			raw_value = {};
+		}
+
+		const results = await Promise.all(
+			Object.entries(sealiousField.fields).map(async ([key, field]) => {
+				const formfield = sealiousFieldToFormField(
+					field,
+					key,
+					this.name
+				);
+				return <const>[
+					key,
+					await formfield.parse(
+						ctx,
+						((raw_value as Record<string, unknown>)[key] ||
+							"") as any
+					),
+				];
+			})
+		);
+		const parsable = results.every(([, r]) => r.parsable);
+		if (parsable) {
+			return {
+				parsable,
+				error: null,
+				parsed_value: Object.fromEntries(
+					results.map(([key, value]) => [key, value.parsed_value])
+				) as any,
+			};
+		} else
+			return {
+				parsable: <const>false,
+				parsed_value: null,
+				error: results.map(([, r]) => r.error).join("; "),
+			};
+	}
+
+	async parsedToSealious(parsed: Record<string, unknown> | null) {
+		// eslint-disable-next-line @typescript-eslint/no-unsafe-return
+		return Object.fromEntries(
+			await Promise.all(
+				Object.entries(parsed as Record<string, any>).map(
+					async ([key, value]: [string, any]) => {
+						const sealious_field = this.sealiousField.fields[key]!;
+						const formfield = sealiousFieldToFormField(
+							sealious_field,
+							key,
+							this.name
+						);
+						// eslint-disable-next-line @typescript-eslint/no-unsafe-return
+						return [key, await formfield.parsedToSealious(value)];
+					}
+				)
+			)
+		);
+	}
+
+	async sealiousValueToForm(
+		ctx: Context,
+		sealiousValue: ExtractFieldDecoded<F> | ExtractFieldInput<F> | null,
+		item: CollectionItem<any>
+	): Promise<FormDataValue> {
+		// eslint-disable-next-line @typescript-eslint/no-unsafe-return
+		return Object.fromEntries(
+			await Promise.all(
+				Object.entries(
+					(sealiousValue || {}) as Record<string, any>
+				).map(async ([key, value]: [string, any]) => {
+					const sealious_field = this.sealiousField.fields[key]!;
+					const formfield = sealiousFieldToFormField(
+						sealious_field,
+						key,
+						this.name
+					);
+					return [
+						key,
+						await formfield.sealiousValueToForm(ctx, value, item),
+					];
+				})
+			)
+		);
+	}
+
+	getControl() {
+		const structured = this.sealiousField;
+		return new FieldGroup(
+			Object.keys(structured.fields).map((key) => {
+				return sealiousFieldToFormField(
+					structured.fields[key]!,
+					key,
+					this.name
+				)
+					.setLabel(key)
+					.getControl();
+			}),
+			{ label: this.name }
+		);
+	}
+
+	generateFieldDeclaration(
+		_field_info: ExtractedFieldInfo,
+		vars: { form_field_types: string; sealious_field: string }
+	): string {
+		return `new ${vars.form_field_types}.${this.constructor.name}(${vars.sealious_field})`;
+	}
+}

package/src/forms/fields/text.ts

@@ -1,4 +1,3 @@
-import { FormControlContext } from "../controls/form-control.js";
 import { TextBasedSimpleField } from "./simple-form-field.js";
 
 export class Text<
@@ -8,11 +7,7 @@ export class Text<
 		super(required, "text");
 	}
 
-	async getSealiousCreateValue(fctx: FormControlContext): Promise<string> {
-		const { parsed } = await this.getParsedValue(
-			fctx.ctx,
-			fctx.data.raw_values
-		);
+	async parsedToSealious(parsed: string): Promise<string> {
 		return parsed || this.getEmptyValue();
 	}
 }

package/src/forms/fields/url.ts

@@ -1,4 +1,3 @@
-import { FormControlContext } from "../controls/form-control.js";
 import { TextBasedSimpleField } from "./simple-form-field.js";
 
 export class URLField<
@@ -8,13 +7,7 @@ export class URLField<
 		super(required, "text");
 	}
 
-	async getSealiousCreateValue(
-		fctx: FormControlContext
-	): Promise<string | null> {
-		const { parsed } = await this.getParsedValue(
-			fctx.ctx,
-			fctx.data.raw_values
-		);
-		return parsed || null;
+	async parsedToSealious(parsed: string | null): Promise<string> {
+		return parsed || "";
 	}
 }

package/src/forms/form.ts

@@ -280,10 +280,11 @@ export abstract class Form<
 
 		router.get(path, async (ctx) => {
 			ctx.type = "html";
+			const raw_values = await this.extractRawValues(ctx);
 			ctx.body = await this.render(
 				ctx,
 				{
-					raw_values: await this.extractRawValues(ctx),
+					raw_values,
 					messages: [],
 					field_messages: {},
 				},

package/src/templates/shared/collection-create-form.ts

@@ -46,6 +46,10 @@ export async function createItemFormTemplate(
 		onsubmit: `
 	async onSubmit(ctx: Context, formData: FormData) {
 		const fctx = this.makeFormControlContext(ctx, formData, true);
+		const data = await this.getParsedValues(ctx);
+		if (!data) {
+			throw new Error("Error when parsing the form values");
+		}
 
 		const created =  await ctx.$app.collections["${toKebabCase(
 			collection_name

package/src/templates/shared/collection-edit-form.ts

@@ -61,6 +61,11 @@ export async function editItemFormTemplate(
 					throw new Error("Unknown id: " + id);
 				}
 
+				const data = await this.getParsedValues(ctx);
+				if (!data) {
+					throw new Error("Error when parsing the form values");
+				}
+
 
 				item.setMultipleExtraSafe(
 				{

package/src/utils/input-wrapper.ts

@@ -15,13 +15,13 @@ export async function inputWrapper(
 	modifiers: string[],
 	input: FlatTemplatable
 ): Promise<string> {
-	return tempstream /* HTML */ `<div
+	return tempstream /* HTML */ `<label
 		class="form-input form-input--type-${type} form-input__wrapper ${getModifierClasses(
 			modifiers
 		)}"
 	>
 		${input}
-	</div>`;
+	</label>`;
 }
 
 export async function autoWrapInput(field: FormField, input: FlatTemplatable) {