@sealcode/sealgen 0.8.48 → 0.8.49

package/src/forms/controls/textarea.ts

@@ -0,0 +1,60 @@
+import { Context } from "koa";
+import { FormField } from "../fields/field";
+import { FormDataValue } from "../form";
+import { FormControlContext } from "./form-control";
+import { SimpleInput, SimpleInputOptions } from "./simple-input";
+
+export class Textarea<Required extends boolean> extends SimpleInput<
+	string | null
+> {
+	constructor(
+		public field: FormField<boolean, string | null>,
+		public options: SimpleInputOptions & {
+			label?: string;
+			rows?: number;
+			cols?: number;
+			description?: string;
+			autogrow?: boolean;
+		} = {}
+	) {
+		super(field, options);
+	}
+
+	renderDescription() {
+		return this.options.description
+			? /* HTML */ `<div class="form-input__description">
+					${this.options.description}
+			  </div>`
+			: "";
+	}
+
+	async getInputAttributes(
+		fctx: FormControlContext
+	): Promise<Record<string, string | boolean>> {
+		const original = (await super.getInputAttributes(fctx)) as Record<
+			string,
+			string | boolean
+		>;
+		let onkeydown = original.onkeydown || "";
+		if (this.options.autogrow) {
+			onkeydown += `;this.style.height = '5px';this.style.height = Math.max((this.scrollHeight)+32, ${
+				((this.options.rows || 2) + 1) * 16
+			} )+'px';`;
+		}
+		return {
+			...original,
+			rows: this.options.rows ? this.options.rows.toString() : false,
+			cols: this.options.cols ? this.options.cols.toString() : false,
+			onkeydown,
+		};
+	}
+
+	async renderInput(
+		ctx: Context,
+		attributes: string,
+		data: Record<string, FormDataValue>
+	) {
+		const { parsed: value } = await this.field.getValue(ctx, data);
+		return /* HTML */ `<textarea ${attributes}>${value}</textarea>`;
+	}
+}

package/src/forms/controls/tickable.ts

@@ -0,0 +1,127 @@
+import { Context } from "koa";
+import { FlatTemplatable } from "tempstream";
+import { attribute } from "../../sanitize";
+import { getRequiredClass, inputWrapper } from "../../utils/input-wrapper";
+import { FormField } from "../fields/field";
+import { FormDataValue } from "../form";
+import { FormFieldControl } from "./controls";
+import { FormControlContext } from "./form-control";
+
+export type TickableOptions = {
+	id?: string;
+	name?: string;
+	label?: string;
+	hide_errors?: boolean;
+	readonly?: boolean;
+};
+
+export abstract class Tickable<T extends unknown> extends FormFieldControl {
+	constructor(
+		public field: FormField<boolean, T>,
+		public options: TickableOptions = {}
+	) {
+		super([field]);
+	}
+
+	public type: "checkbox" | "radio";
+
+	abstract getValueAttribute(
+		ctx: Context,
+		data: Record<string, FormDataValue>,
+		value: T
+	): string;
+
+	abstract isChecked(
+		ctx: Context,
+		data: Record<string, FormDataValue>,
+		value: T
+	): boolean;
+
+	makeInputID(
+		ctx: Context,
+		data: Record<string, FormDataValue>,
+		value: T
+	): string {
+		const value_attr = this.getValueAttribute(ctx, data, value);
+		return (
+			this.options.id ||
+			this.field.name + (value_attr ? "--" + value_attr : "")
+		);
+	}
+
+	getWrapperClasses(
+		ctx: Context,
+		data: Record<string, FormDataValue>,
+		value: T
+	): string[] {
+		return [
+			this.makeInputID(ctx, data, value),
+			this.type,
+			this.field.name.replaceAll(/\W/g, "-"),
+			getRequiredClass(this.field.required),
+			...(this.isChecked(ctx, data, value) ? ["checked"] : []),
+		];
+	}
+
+	async render<Fields extends Record<string, FormField>>(
+		fctx: FormControlContext
+	): Promise<FlatTemplatable> {
+		// eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+		const { parsed, valid, message } = await this.field.getValue(
+			fctx.ctx,
+			fctx.data
+		);
+		const value = this.getValueAttribute(fctx.ctx, fctx.data, parsed);
+		const id = this.makeInputID(fctx.ctx, fctx.data, parsed);
+		const label =
+			this.options.label != undefined
+				? this.options.label
+				: this.field.name;
+
+		// eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+		const readonly = this.options.readonly || false;
+		const required = this.field.required;
+
+		return inputWrapper(
+			this.getWrapperClasses(fctx.ctx, fctx.data, parsed),
+
+			/* HTML */ `
+				<input
+					id="${id}"
+					type="${this.type}"
+					name="${fctx.field_name_prefix}${this.options.name ||
+					this.field.name}"
+					${value ? `value="${attribute(value)}"` : ""}
+					${fctx.form_id ? `form="${fctx.form_id}"` : ""}
+					${this.isChecked(fctx.ctx, fctx.data, parsed)
+						? "checked"
+						: ""}
+					${readonly ? "readonly" : ""}
+					${required ? "required" : ""}
+					autocomplete="off"
+					onchange="this.closest('.form-container').querySelectorAll('.form-input__wrapper--${this
+						.field
+						.name}').forEach(e=>e.setAttribute('data-checked','false'));
+				this.closest('.form-input__wrapper').setAttribute('data-checked',this.checked);"
+				/>
+
+				<label for="${id}">${label}</label>
+				<script>
+					(function () {
+						let wrapper = document.currentScript.closest(
+							".form-input__wrapper"
+						);
+						wrapper.setAttribute(
+							"data-checked",
+							wrapper.querySelector("input").checked.toString()
+						);
+					})();
+				</script>
+
+				${~valid && !this.options.hide_errors && fctx.validate
+					? `<div class="input__error">${message}</div>`
+					: ""}
+			`
+		);
+	}
+}

package/src/forms/fields/boolean.test.ts

@@ -0,0 +1,36 @@
+import assert from "assert";
+import { Fields } from "../../index";
+
+describe("boolean field", () => {
+	const ctx = {} as any;
+
+	it("validation logic", async () => {
+		const required = new Fields.Boolean(true);
+		const not_required = new Fields.Boolean(false);
+
+		assert.strictEqual((await required.isValueValid(ctx, true)).valid, true);
+		assert.strictEqual((await required.isValueValid(ctx, false)).valid, false);
+		assert.strictEqual((await not_required.isValueValid(ctx, true)).valid, true);
+		assert.strictEqual((await not_required.isValueValid(ctx, false)).valid, true);
+	});
+
+	it("parse function", async () => {
+		const field = new Fields.Boolean(true);
+		const true_response = await field.parse(ctx, true as any);
+		const null_response = await field.parse(ctx, null as any);
+		const true_as_string_response = await field.parse(ctx, "true");
+		const undefined_response = await field.parse(ctx, undefined);
+		const number_response = await field.parse(ctx, 42);
+
+		assert.strictEqual(true_response.parsable, true);
+		assert.strictEqual(true_response.parsed_value, true);
+		assert.strictEqual(null_response.parsable, true);
+		assert.strictEqual(null_response.parsed_value, false);
+		assert.strictEqual(true_as_string_response.parsable, true);
+		assert.strictEqual(true_as_string_response.parsed_value, true);
+		assert.strictEqual(undefined_response.parsable, true);
+		assert.strictEqual(undefined_response.parsed_value, false);
+		assert.strictEqual(number_response.parsable, false);
+		assert.strictEqual(number_response.error, "Please enter a boolean");
+	});
+});

package/src/forms/fields/boolean.ts

@@ -0,0 +1,63 @@
+import { is, predicates } from "@sealcode/ts-predicates";
+import { Context } from "koa";
+import { FormDataValue } from "../form";
+import { FieldParseResult, FormField } from "./field";
+
+const truthy = ["true", "on", "yes", "1"];
+const falsy = ["false", "off", "no", "0"];
+
+export class Boolean<Required extends boolean> extends FormField<
+	Required,
+	boolean
+> {
+	predicate = predicates.boolean;
+	constructor(required: Required, public error_message: string = "") {
+		super(required);
+	}
+
+	public async isValueValid(
+		_: Context,
+		value: boolean
+	): Promise<{ valid: boolean; message: string }> {
+		if (this.required && !value) {
+			return { valid: false, message: this.error_message };
+		}
+		return { valid: true, message: "" };
+	}
+
+	async parse(
+		_: Context,
+		value: FormDataValue
+	): Promise<FieldParseResult<boolean>> {
+		if (is(value, predicates.boolean)) {
+			return { parsable: true, parsed_value: value, error: null };
+		} else if (
+			is(value, predicates.string) &&
+			[...truthy, ...falsy].includes(value)
+		) {
+			return {
+				parsable: true,
+				parsed_value: truthy.includes(value),
+				error: null,
+			};
+		} else if (is(value, predicates.undefined)) {
+			return {
+				parsable: true,
+				parsed_value: false,
+				error: null,
+			};
+		} else if (value === null) {
+			return { parsable: true, parsed_value: false, error: null };
+		} else {
+			return {
+				parsable: false,
+				parsed_value: null,
+				error: "Please enter a boolean",
+			};
+		}
+	}
+
+	public getEmptyValue(): boolean {
+		return false;
+	}
+}

package/src/forms/fields/checkboxed-list.ts

@@ -0,0 +1,66 @@
+import { is, predicates } from "@sealcode/ts-predicates";
+import { Context } from "koa";
+import { FormDataValue } from "../form";
+import {
+	FieldParseResult,
+	FormField,
+	FormFieldValidationResponse,
+} from "./field";
+
+export class ChekboxedListField<Required extends boolean> extends FormField<
+	Required,
+	Record<string, "on">
+> {
+	constructor(
+		public required: Required,
+		public generateOptions: (
+			ctx: Context
+		) => Promise<Record<string, string> | { [i: string]: string }>,
+		public isVisible: (ctx: Context) => Promise<boolean> = () =>
+			Promise.resolve(true)
+	) {
+		super(required);
+	}
+
+	predicate = predicates.array(predicates.string); // TODO: this is probably wrong
+
+	public async isValueValid(
+		_: Context,
+		value: unknown
+	): Promise<FormFieldValidationResponse> {
+		if (is(value, predicates.string)) {
+			return { valid: false, message: "you need an array" };
+		}
+		if (is(value, predicates.null)) {
+			return { valid: false, message: "you need an array" };
+		}
+		return { valid: true, message: "" };
+	}
+
+	async parse(
+		_: Context,
+		raw_value: FormDataValue
+	): Promise<FieldParseResult<Record<string, "on">>> {
+		if (is(raw_value, predicates.object)) {
+			return {
+				parsable: true,
+				parsed_value: Object.fromEntries(
+					Object.entries(raw_value).filter(
+						([, value]) => value === "on"
+					)
+				) as Record<string, "on">,
+				error: null,
+			};
+		} else {
+			return {
+				parsed_value: null,
+				parsable: false,
+				error: "Expected an object",
+			};
+		}
+	}
+
+	public getEmptyValue(): Record<string, "on"> {
+		return {};
+	}
+}

package/src/forms/fields/collection-field.ts

@@ -0,0 +1,62 @@
+import { predicates } from "@sealcode/ts-predicates";
+import { Context } from "koa";
+import { Depromisify, Field, FieldOutput } from "sealious";
+import { FormDataValue } from "../form";
+
+import {
+	FieldParseResult,
+	FormField,
+	FormFieldValidationResponse,
+} from "./field";
+
+export class CollectionField<
+	F extends Field,
+	Required extends boolean
+> extends FormField<Required, FieldOutput<F> | null> {
+	constructor(required: Required, public sealiousField: F) {
+		super(required);
+	}
+
+	predicate = predicates.unknown;
+
+	async parse(
+		ctx: Context,
+		raw_value: FormDataValue
+	): Promise<FieldParseResult<FieldOutput<F> | null>> {
+		if (raw_value === undefined) {
+			return { parsable: true, parsed_value: null, error: null };
+		}
+		const encoded_value = (await this.sealiousField.encode(
+			ctx.$context,
+			raw_value
+		)) as Depromisify<ReturnType<F["encode"]>>;
+		const parsed_value = (await this.sealiousField.decode(
+			ctx.$context,
+			encoded_value,
+			null,
+			{}
+		)) as Depromisify<ReturnType<F["encode"]>>;
+		return {
+			parsable: true,
+			error: null,
+			parsed_value,
+		};
+	}
+
+	public async isValueValid(
+		ctx: Context,
+		value: FieldOutput<F>
+	): Promise<FormFieldValidationResponse> {
+		const { valid, reason } = await this.sealiousField.checkValue(
+			ctx.$context,
+			value,
+			undefined,
+			null
+		);
+		return { valid, message: reason || (!valid ? "Wrong value" : "") };
+	}
+
+	public getEmptyValue(): Depromisify<ReturnType<F["decode"]>> {
+		return "" as unknown as Depromisify<ReturnType<F["decode"]>>;
+	}
+}

package/src/forms/fields/email.test.ts

@@ -0,0 +1,24 @@
+import assert from "assert";
+import { Fields } from "../../index";
+
+describe("email field", () => {
+	const ctx = {} as any;
+
+	it("validation logic", async () => {
+		const field = new Fields.EmailField(true);
+
+		assert.strictEqual((await field.isValueValid(ctx, "yes@an.email")).valid, true);
+		assert.strictEqual((await field.isValueValid(ctx, "notanemail")).valid, false);
+	});
+
+	it("parse function", async () => {
+		const field = new Fields.EmailField(true);
+		const string_response = await field.parse(ctx, "42");
+		const number_response = await field.parse(ctx, 42);
+
+		assert.strictEqual(string_response.parsable, true);
+		assert.strictEqual(string_response.parsed_value, "42");
+		assert.strictEqual(number_response.parsable, false);
+		assert.strictEqual(number_response.error, "Please enter a string");
+	});
+});

package/src/forms/fields/email.ts

@@ -0,0 +1,20 @@
+import { predicates } from "@sealcode/ts-predicates";
+import { RegExpField } from "./regexp";
+
+export class EmailField<
+	Required extends boolean
+> extends RegExpField<Required> {
+	predicate = predicates.string;
+	constructor(
+		required: Required,
+		public error_message = "Please enter a proper email address",
+		public default_value = ""
+	) {
+		super(
+			required,
+			/^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/,
+			error_message,
+			default_value
+		);
+	}
+}

package/src/forms/fields/enum-multiple.test.ts

@@ -0,0 +1,31 @@
+import assert from "assert";
+import { Fields } from "../../index";
+
+describe("enum-multiple field", () => {
+	const ctx = {} as any;
+
+	it("validation logic", async () => {
+		const field = new Fields.EnumMultipleField(true, ["sa", "mp", "le"]);
+
+		assert.strictEqual((await field.isValueValid(ctx, ["sa", "le"])).valid, true);
+		assert.strictEqual((await field.isValueValid(ctx, ["notvalid"])).valid, false);
+		assert.strictEqual((await field.isValueValid(ctx, [42] as any)).valid, false);
+	});
+
+	it("parse function", async () => {
+		const field = new Fields.EnumMultipleField(true, []);
+		const string_array_response = await field.parse(ctx, ["42"]);
+		const number_response = await field.parse(ctx, 42);
+		const string_response = await field.parse(ctx, "sample");
+		const null_response = await field.parse(ctx, null as any);
+
+		assert.strictEqual(string_array_response.parsable, true);
+		assert.deepEqual(string_array_response.parsed_value, ["42"]);
+		assert.strictEqual(number_response.parsable, false);
+		assert.strictEqual(number_response.error, "Please enter a list of strings");
+		assert.strictEqual(string_response.parsable, true);
+		assert.deepEqual(string_response.parsed_value, ["sample"]);
+		assert.strictEqual(null_response.parsable, true);
+		assert.deepEqual(null_response.parsed_value, []);
+	});
+});

package/src/forms/fields/enum-multiple.ts

@@ -0,0 +1,62 @@
+import { is, predicates } from "@sealcode/ts-predicates";
+import { Context } from "koa";
+import { FormDataValue } from "../form";
+import { FieldParseResult, FormField } from "./field";
+
+export class EnumMultipleField<
+	Options extends readonly string[],
+	Required extends boolean
+> extends FormField<Required, string[]> {
+	constructor(
+		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,
+		values: string[]
+	): Promise<{ valid: boolean; message: string }> {
+		for (const value of values) {
+			if (!is(value, predicates.string)) {
+				return { valid: false, message: "expected a string" };
+			}
+			if (!this.options.includes(value)) {
+				return { valid: false, message: "invalid value" };
+			}
+		}
+		return { valid: true, message: "" };
+	}
+
+	async parse(
+		_: Context,
+		value: FormDataValue
+	): Promise<FieldParseResult<string[]>> {
+		if (is(value, predicates.string)) {
+			return { parsable: true, parsed_value: [value], error: null };
+		} else if (is(value, predicates.array(predicates.string))) {
+			return {
+				parsable: true,
+				parsed_value: value,
+				error: null,
+			};
+		} else if (value == null) {
+			return { parsable: true, parsed_value: [], error: null };
+		} else {
+			return {
+				parsable: false,
+				parsed_value: null,
+				error: "Please enter a list of strings",
+			};
+		}
+	}
+
+	public getEmptyValue(): string[] {
+		return [];
+	}
+}

package/src/forms/fields/enum.test.ts

@@ -0,0 +1,25 @@
+import assert from "assert";
+import { Fields } from "../../index";
+
+describe("enum field", () => {
+	const ctx = {} as any;
+
+	it("validation logic", async () => {
+		const field = new Fields.EnumField(true, ["sa", "mp", "le"]);
+
+		assert.strictEqual((await field.isValueValid(ctx, 42)).valid, false);
+		assert.strictEqual((await field.isValueValid(ctx, "mp")).valid, true);
+		assert.strictEqual((await field.isValueValid(ctx, "notvalid")).valid, false);
+	});
+
+	it("parse function", async () => {
+		const field = new Fields.EnumField(true, []);
+		const string_response = await field.parse(ctx, "42");
+		const number_response = await field.parse(ctx, 42);
+
+		assert.strictEqual(string_response.parsable, true);
+		assert.strictEqual(string_response.parsed_value, "42");
+		assert.strictEqual(number_response.parsable, false);
+		assert.strictEqual(number_response.error, "Please enter a string");
+	});
+});

package/src/forms/fields/enum.ts

@@ -0,0 +1,56 @@
+import { is, predicates } from "@sealcode/ts-predicates";
+import { Context } from "koa";
+import { FormDataValue } from "../form";
+import { FieldParseResult, FormField } from "./field";
+
+export class EnumField<
+	Options extends readonly string[],
+	Required extends boolean
+> extends FormField<Required, string> {
+	constructor(
+		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
+	): Promise<{ valid: boolean; message: string }> {
+		if (!is(value, predicates.string)) {
+			return { valid: false, message: "expected a string" };
+		}
+		if (this.options.includes(value)) {
+			return { valid: true, message: "" };
+		}
+		return { valid: false, message: this.error_message(this.options) };
+	}
+
+	async parse(
+		_: Context,
+		value: FormDataValue
+	): Promise<FieldParseResult<string>> {
+		if (is(value, predicates.string)) {
+			return {
+				parsable: true,
+				parsed_value: value,
+				error: null,
+			};
+		} else {
+			return {
+				parsable: false,
+				parsed_value: null,
+				error: "Please enter a string",
+			};
+		}
+	}
+
+	public getEmptyValue(): string {
+		return "";
+	}
+}

package/src/forms/fields/existing-sealious-value.ts

@@ -0,0 +1,22 @@
+import { Field } from "sealious";
+import { PickFromListField } from "./pick-from-list";
+
+export class ExistingSealiousValue<
+	Required extends boolean
+> extends PickFromListField<Required> {
+	constructor(required: Required, field: Field) {
+		super(required, async (ctx) => {
+			const { items } = await field.collection.list(ctx.$context).fetch();
+			return Object.fromEntries(
+				items.map((item) => {
+					const value = item.get(field.name);
+					return [value, value];
+				})
+			);
+		});
+	}
+
+	getEmptyValue() {
+		return "";
+	}
+}