@sealcode/sealgen 0.7.15 → 0.8.1

package/src/forms/fields/enum.ts

@@ -3,16 +3,21 @@ import { Context } from "koa";
 import { FormDataValue } from "../form";
 import { FieldParseResult, FormField } from "./field";
 
-export class EnumField extends FormField<string> {
+export class EnumField<
+	Options extends readonly string[],
+	Required extends boolean
+> extends FormField<Required, string> {
 	constructor(
-		required = false,
-		public options: string[],
-		public error_message: (options: string[]) => string = (options) =>
+		required: Required,
+		public options: Options,
+		public error_message: (options: Options) => string = (options) =>
 			options.join(", ")
 	) {
 		super(required);
 	}
 
+	predicate = predicates.enum<Options>(this.options);
+
 	public async isValueValid(
 		_: Context,
 		value: unknown

package/src/forms/fields/field.ts

@@ -1,17 +1,41 @@
+import { Predicate, predicates } from "@sealcode/ts-predicates";
 import { Context } from "koa";
 import { t } from "../../utils/translate";
 import { FormDataValue } from "../form";
+import { SimpleFormField } from "./simple-form-field";
 
 export type FormFieldValidationResponse = { valid: boolean; message: string };
 
 export type FormFieldValidationFn<ValueType> = (
 	ctx: Context,
 	value: ValueType,
-	field: FormField<ValueType>
+	field: FormField<boolean, ValueType>
 ) => Promise<FormFieldValidationResponse>;
 
 export type FieldParsedValue<T> = T extends FormField<infer R> ? R : never;
 
+export type GetPredicate<F extends FormField> = F extends FormField<true>
+	? F["predicate"]
+	: F["predicate"] | typeof predicates.undefined;
+
+// for quickly testing GetPredicate conditonally applying the undefined predicate:
+// const f = new SimpleFormField(true);
+// type p = GetPredicate<typeof f>;
+// const f2 = new SimpleFormField(false);
+// type p2 = GetPredicate<typeof f2>;
+
+export type FieldsToShape<T extends Record<string, FormField>> = {
+	[property in keyof T]: GetPredicate<T[property]>;
+};
+
+export function fieldsToShape<Fields extends Record<string, FormField>>(
+	obj: Fields
+): FieldsToShape<Fields> {
+	return Object.fromEntries(
+		Object.entries(obj).map(([key, value]) => [key, value.predicate])
+	) as FieldsToShape<Fields>;
+}
+
 export type FieldParseResult<T> =
 	| {
 			parsable: false;
@@ -20,9 +44,13 @@ export type FieldParseResult<T> =
 	  }
 	| { parsable: true; error: null; parsed_value: T };
 
-export abstract class FormField<ParsedValue extends unknown = unknown> {
+export abstract class FormField<
+	Required extends boolean = boolean,
+	ParsedValue extends unknown = unknown
+> {
 	name: string;
-	constructor(public required: boolean = false) {}
+	constructor(public readonly required: Required) {}
+	predicate: Predicate = predicates.unknown;
 
 	init(fieldname: string): void {
 		this.name = fieldname;
@@ -117,3 +145,4 @@ export * from "./pick-from-list";
 export * from "./regexp";
 export * from "./email";
 export * from "./enum";
+export * from "./boolean";

package/src/forms/fields/number.ts

@@ -4,12 +4,15 @@ import { FormDataValue } from "../form";
 import { FieldParseResult, FormField } from "./field";
 
 export class NumberField<
-	DefaultValue extends number | null = null
-> extends FormField<number | DefaultValue> {
-	constructor(required = false, public default_value: DefaultValue) {
+	DefaultValue extends number | null = null,
+	Required extends boolean = boolean
+> extends FormField<Required, number | DefaultValue> {
+	constructor(required: Required, public default_value: DefaultValue) {
 		super(required);
 	}
 
+	predicate = predicates.number;
+
 	public async isValueValid(_: Context, value: unknown) {
 		if (
 			(is(value, predicates.string) &&

package/src/forms/fields/pick-from-list.ts

@@ -3,22 +3,26 @@ import { Context } from "koa";
 import { FormFieldValidationResponse } from "./field";
 import { SimpleFormField } from "./simple-form-field";
 
-export class PickFromListField extends SimpleFormField {
+export class PickFromListField<
+	Required extends boolean
+> extends SimpleFormField<Required> {
 	constructor(
-		public required: boolean = false,
+		public required: Required,
 		public generateOptions: (
 			ctx: Context
 		) => Promise<Record<string, string> | { [i: string]: string }>,
 		public customValidation: (
 			ctx: Context,
 			value: unknown,
-			instance: PickFromListField
+			instance: PickFromListField<Required>
 		) => Promise<FormFieldValidationResponse> = (ctx, value, instance) =>
 			instance.valueInList(ctx, value)
 	) {
 		super(required);
 	}
 
+	predicate = predicates.string;
+
 	public isValueValid(
 		ctx: Context,
 		value: string

package/src/forms/fields/regexp.ts

@@ -3,9 +3,9 @@ import { Context } from "koa";
 import { FormDataValue } from "../form";
 import { FieldParseResult, FormField } from "./field";
 
-export class RegExpField extends FormField<string> {
+export class RegExpField<Required extends boolean> extends FormField<Required> {
 	constructor(
-		required = false,
+		required: Required,
 		public regexp: RegExp,
 		public error_message: string,
 		public default_value: string = ""
@@ -13,6 +13,8 @@ export class RegExpField extends FormField<string> {
 		super(required);
 	}
 
+	predicate = predicates.string;
+
 	public async isValueValid(
 		_: Context,
 		value: unknown

package/src/forms/fields/simple-form-field.ts

@@ -1,8 +1,12 @@
 import { FieldParseResult, FormField } from "./field";
 import { FormDataValue } from "../form";
 import { Context } from "koa";
+import { predicates } from "@sealcode/ts-predicates";
 
-export class SimpleFormField extends FormField<string | null> {
+export class SimpleFormField<Required extends boolean> extends FormField<
+	Required,
+	string | null
+> {
 	async parse(
 		_: Context,
 		raw_value: FormDataValue
@@ -14,7 +18,13 @@ export class SimpleFormField extends FormField<string | null> {
 		};
 	}
 
+	predicate = predicates.string;
+
 	public getEmptyValue(): string {
 		return "";
 	}
+
+	constructor(required: Required) {
+		super(required);
+	}
 }

package/src/forms/form.ts

@@ -7,14 +7,14 @@ import {
 	is,
 	predicates,
 } from "@sealcode/ts-predicates";
-import { FormField } from "./fields/field";
+import { FieldsToShape, FormField } from "./fields/field";
 import {
 	Fields,
 	MountableWithFields,
 	PageErrorMessage,
 } from "../page/mountable-with-fields";
 
-export type FormDataPrimitive = string | string[] | undefined;
+export type FormDataPrimitive = string | string[] | number | undefined;
 export type FormDataValue =
 	| FormDataPrimitive
 	| Record<string, FormDataPrimitive>;
@@ -23,7 +23,9 @@ export type FieldValueType<F extends FormField> = F extends FormField<infer R>
 	? R
 	: never;
 
-export type FormFieldsToValues<F extends Record<string, FormField<keyof F>>> = {
+export type FormFieldsToValues<
+	F extends Record<string, FormField<boolean, keyof F>>
+> = {
 	[Property in keyof F]: FieldValueType<F[Property]>;
 };
 
@@ -38,10 +40,14 @@ export type FormReaction =
 	| { action: "stay"; content: FlatTemplatable; messages?: FormMessage[] }
 	| { action: "redirect"; url: string; messages?: FormMessage[] };
 
-export abstract class Form<F extends Fields> extends MountableWithFields<F> {
+export abstract class Form<
+	F extends Fields,
+	SubmitResult extends any
+> extends MountableWithFields<F> {
 	defaultSuccessMessage = "Done";
 	submitButtonText = "Wyślij";
 	action = "./";
+	useTurbo = true;
 
 	async canAccess(
 		// eslint-disable-next-line @typescript-eslint/no-unused-vars
@@ -71,7 +77,10 @@ export abstract class Form<F extends Fields> extends MountableWithFields<F> {
 		${!this.controls.some((control) => control.role == "messages")
 			? this.renderMessages(ctx, data)
 			: ""}
-		${this.renderControls(ctx, data)} ${this.makeSubmitButton()}
+		${this.renderControls(ctx, data)}
+		${this.controls.some((control) => control.role == "submit")
+			? ""
+			: this.makeSubmitButton()}
 		${this.makeCloseFormTag()}`;
 	}
 
@@ -85,7 +94,7 @@ export abstract class Form<F extends Fields> extends MountableWithFields<F> {
 			this.action
 		}" class="${this.makeFormClasses(ctx).then((classes) =>
 			classes.join(" ")
-		)}">`;
+		)}" ${this.useTurbo ? "" : `data-turbo="false"`}>`;
 	}
 
 	public makeCloseFormTag(): FlatTemplatable {
@@ -135,11 +144,12 @@ export abstract class Form<F extends Fields> extends MountableWithFields<F> {
 	public abstract onSubmit(
 		ctx: Context,
 		data: FormData
-	): void | Promise<void>;
+	): SubmitResult | Promise<SubmitResult>;
 
 	public async onSuccess(
 		ctx: Context,
-		data: FormData
+		data: FormData,
+		_submitResult: SubmitResult
 	): Promise<FormReaction> {
 		const messages = [
 			<const>{ type: "success", text: this.defaultSuccessMessage },
@@ -164,14 +174,18 @@ export abstract class Form<F extends Fields> extends MountableWithFields<F> {
 		}
 		try {
 			ctx.status = 303;
-			await this.onSubmit(ctx, {
-				raw_values: this.extractRawValues(ctx),
-				messages: [],
-			});
-			return this.onSuccess(ctx, {
+			const result = await this.onSubmit(ctx, {
 				raw_values: this.extractRawValues(ctx),
 				messages: [],
 			});
+			return this.onSuccess(
+				ctx,
+				{
+					raw_values: this.extractRawValues(ctx),
+					messages: [],
+				},
+				result
+			);
 		} catch (e: unknown) {
 			// eslint-disable-next-line no-console
 			console.dir(e, { depth: 5 });

package/src/forms/multiform.ts

@@ -11,7 +11,7 @@ const FIELD_PREFIX_SEPARATOR = "___";
 export class Multiform extends MountableWithFields {
 	controls = [];
 	public name: string;
-	public forms: Record<string, Form<Fields>>;
+	public forms: Record<string, Form<Fields, unknown>>;
 
 	init(): void {
 		super.init();
@@ -65,7 +65,9 @@ export class Multiform extends MountableWithFields {
 	}
 
 	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	getSubformsToRender(ctx: Context): Array<readonly [string, Form<any>]> {
+	getSubformsToRender(
+		ctx: Context
+	): Array<readonly [string, Form<any, unknown>]> {
 		const requested_frame = ctx.headers["turbo-frame"];
 		if (
 			!is(

package/src/mount.ts

@@ -33,8 +33,10 @@ export function mount(router: Router, url: string, mountable: Mountable): void {
 
 	router.use(url, async (ctx, next) => {
 		ctx.set("content-type", "text/html;charset=utf-8");
-		if (!(await mountable.canAccess(ctx)).canAccess) {
-			ctx.body = "no access";
+		const access_result = await mountable.canAccess(ctx);
+		if (!access_result.canAccess) {
+			ctx.status = 403;
+			ctx.body = access_result.message || "no access";
 			return;
 		}
 		await next();

package/src/page/mountable-with-fields.ts

@@ -1,13 +1,14 @@
+import { ShapeToType } from "@sealcode/ts-predicates";
 import { Context } from "koa";
 import { FlatTemplatable, tempstream } from "tempstream";
 import { FormControl } from "../forms/controls/form-control";
-import { FormField } from "../forms/fields/field";
+import { FieldsToShape, FormField } from "../forms/fields/field";
 import { FormData, FormDataValue, FormMessage } from "../forms/form";
 import { Mountable } from "./mountable";
 
 export type PageErrorMessage = { type: "access" | "internal"; message: string };
 
-export type Fields = Record<string, FormField<unknown>>;
+export type Fields = Record<string, FormField<boolean, unknown>>;
 
 export abstract class MountableWithFields<
 	F extends Fields = Fields
@@ -109,4 +110,19 @@ export abstract class MountableWithFields<
 	}
 
 	abstract extractRawValues(ctx: Context): Record<string, FormDataValue>;
+
+	async getParsedValues(
+		ctx: Context
+	): Promise<ShapeToType<FieldsToShape<F>>> {
+		const raw_values = this.extractRawValues(ctx);
+		const result: Record<string, unknown> = {};
+		const promises = Object.entries(this.fields).map(
+			async ([key, field]) => {
+				const { parsed } = await field.getValue(ctx, raw_values);
+				result[key] = parsed;
+			}
+		);
+		await Promise.all(promises);
+		return result as ShapeToType<FieldsToShape<F>>;
+	}
 }

package/src/templates/form.ts

@@ -17,7 +17,9 @@ const fields = {
 	password: new Fields.SimpleFormField(true),
 };
 
-export default new (class ${action_name}Form extends Form<typeof fields> {
+export const ${action_name}Shape = Fields.fieldsToShape(fields);
+
+export default new (class ${action_name}Form extends Form<typeof fields, void> {
 	defaultSuccessMessage = "Formularz wypełniony poprawnie";
 	fields = fields;
 

package/src/tests/manual/multiform.ts

@@ -14,7 +14,7 @@ const fields1 = {
 	password: new Fields.SimpleFormField(true),
 };
 
-const form1 = new (class extends Form<typeof fields1> {
+const form1 = new (class extends Form<typeof fields1, void> {
 	defaultSuccessMessage = "Form1 done!";
 	controls = [
 		new Controls.FormHeader("form1"),
@@ -31,7 +31,7 @@ const fields2 = {
 	surname: new Fields.SimpleFormField(true),
 };
 
-const form2 = new (class extends Form<Record<never, unknown>> {
+const form2 = new (class extends Form<Record<never, unknown>, void> {
 	defaultSuccessMessage = "Form2 done!";
 	controls = [
 		new Controls.FormHeader("form2"),