@sealcode/sealgen 0.8.48 → 0.8.49

package/src/forms/fields/field.ts

@@ -0,0 +1,172 @@
+import { Predicate, predicates } from "@sealcode/ts-predicates";
+import { Context } from "koa";
+import { t } from "../../utils/translate";
+import { FormDataValue } from "../form";
+
+export type FormFieldValidationResponse = { valid: boolean; message: string };
+
+export type FormFieldValidationFn<ValueType> = (
+	ctx: Context,
+	value: 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: true;
+			error: null;
+			parsed_value: T;
+	  }
+	| {
+			parsable: false;
+			error: string;
+			parsed_value: null;
+	  };
+
+export abstract class FormField<
+	Required extends boolean = boolean,
+	ParsedValue extends unknown = unknown
+> {
+	name: string;
+	constructor(public readonly required: Required) {}
+	predicate: Predicate = predicates.unknown;
+	mapToFilter: (parsed: ParsedValue) => unknown = (value) => value;
+
+	async init(fieldname: string): Promise<void> {
+		this.name = fieldname;
+	}
+
+	public async _validate(
+		ctx: Context,
+		value: ParsedValue
+	): Promise<FormFieldValidationResponse> {
+		if (
+			this.required &&
+			(value === "" || value === null || value === undefined)
+		) {
+			return {
+				valid: false,
+
+				message: t(
+					ctx,
+					"field_is_required",
+					[],
+					"This field is required"
+				),
+			};
+		}
+		return this.isValueValid(ctx, value);
+	}
+
+	public abstract getEmptyValue(): ParsedValue;
+
+	public async isValueValid(
+		ctx: Context,
+		value: ParsedValue
+	): Promise<FormFieldValidationResponse> {
+		return { valid: true, message: "" };
+	}
+
+	abstract parse(
+		ctx: Context,
+		raw_value: FormDataValue
+	): Promise<FieldParseResult<ParsedValue>>;
+
+	async getValue(
+		ctx: Context,
+		all_form_values: Record<string, FormDataValue>
+	): Promise<{
+		valid: boolean;
+		message: string;
+		parsed: ParsedValue;
+		raw: FormDataValue;
+	}> {
+		if (Object.keys(all_form_values || {}).length === 0) {
+			// don't validate on virgin form
+			return {
+				parsed: this.getEmptyValue(),
+				valid: true,
+				message: "",
+				raw: "",
+			};
+		}
+		const raw = all_form_values[this.name];
+		const {
+			parsable,
+			parsed_value,
+			error: parse_error,
+		} = await this.parse(ctx, raw);
+		if (!parsable) {
+			return {
+				valid: false,
+				parsed: this.getEmptyValue(),
+				raw,
+				message: parse_error || "Error",
+			};
+		}
+		const { valid, message } = await this._validate(
+			ctx,
+			parsed_value as ParsedValue
+		);
+		return {
+			parsed: parsed_value as ParsedValue,
+			valid,
+			message,
+			raw: all_form_values[this.name],
+		};
+	}
+
+	setMapToFilter(fn: (parsed: ParsedValue) => unknown) {
+		this.mapToFilter = fn;
+		return this;
+	}
+
+	//return undefined here to delete a value
+	async getDatabaseValue(
+		ctx: Context,
+		data: Record<string, FormDataValue>
+	): Promise<unknown> {
+		const { parsed } = await this.getValue(ctx, data);
+		return parsed;
+	}
+}
+
+export * from "./simple-form-field";
+export * from "./checkboxed-list";
+export * from "./collection-field";
+export * from "./number";
+export * from "./pick-from-list";
+export * from "./regexp";
+export * from "./email";
+export * from "./enum";
+export * from "./boolean";
+export * from "./enum-multiple";
+export * from "./existing-sealious-value";
+export * from "./file";
+export * from "./multiple-files";
+export * from "./reverse-single-reference";
+export * from "./structured-array";

package/src/forms/fields/file.ts

@@ -0,0 +1,89 @@
+import {
+	hasField,
+	hasFieldOfType,
+	hasShape,
+	is,
+	predicates,
+} from "@sealcode/ts-predicates";
+import { Context } from "koa";
+import { File as SealiousFile } from "sealious";
+import { FormDataValue } from "../form";
+import { FieldParseResult, FormField } from "./field";
+
+export type FileContainer = {
+	old: SealiousFile | null;
+	new: SealiousFile | null;
+};
+
+export class File<Required extends boolean> extends FormField<
+	Required,
+	FileContainer
+> {
+	async parse(
+		ctx: Context,
+		raw_value: FormDataValue
+	): Promise<FieldParseResult<FileContainer>> {
+		let result;
+		if (
+			raw_value instanceof SealiousFile ||
+			(is(raw_value, predicates.object) &&
+				hasShape(
+					{
+						filename: predicates.string,
+						id: predicates.string,
+					},
+					raw_value
+				) &&
+				raw_value.id)
+		) {
+			const file = await SealiousFile.fromID(
+				ctx.$app,
+				raw_value.id as string
+			);
+			result = {
+				parsed_value: { old: file, new: null },
+				error: null,
+				parsable: true as true,
+			};
+		} else if (!is(raw_value, predicates.object)) {
+			result = {
+				parsed_value: null,
+				error: "Expected a field with old.id:string, old.filename:string and new?:File",
+				parsable: false as false,
+			};
+		} else {
+			const old_file =
+				hasFieldOfType(raw_value, "old", predicates.object) &&
+				hasShape(
+					{ id: predicates.string, filename: predicates.string },
+					raw_value.old
+				) &&
+				raw_value.old.id
+					? await SealiousFile.fromID(ctx.$app, raw_value.old.id)
+					: null;
+			const new_file =
+				hasFieldOfType(
+					raw_value,
+					"new",
+					predicates.array(predicates.object)
+				) && raw_value.new[0] instanceof SealiousFile
+					? raw_value.new[0]
+					: null;
+			result = {
+				parsable: true as true,
+				error: null,
+				parsed_value: { old: old_file, new: new_file },
+			};
+		}
+		return result;
+	}
+
+	async getDatabaseValue(ctx: Context, data: Record<string, FormDataValue>) {
+		const { parsed } = await this.getValue(ctx, data);
+		return parsed.new || undefined;
+	}
+
+	getEmptyValue() {
+		return { old: null, new: null };
+	}
+}

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

@@ -0,0 +1,20 @@
+import { Context } from "koa";
+import { FieldTypes as SealiousFieldTypes } from "sealious";
+import { FormField } from "./field";
+
+export class MultipleFiles extends FormField<false> {
+	constructor(
+		public collection_field: SealiousFieldTypes.ReverseSingleReference,
+		public getItemId: (ctx: Context) => Promise<string> | string
+	) {
+		super(false);
+	}
+
+	getEmptyValue() {
+		return undefined;
+	}
+
+	async parse() {
+		return <const>{ parsed_value: undefined, parsable: true, error: null }; // the control is supposed to do the heavy lifting here
+	}
+}

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

@@ -0,0 +1,34 @@
+import assert from "assert";
+import { Fields } from "../../index";
+
+describe("number field", () => {
+	const ctx = {} as any;
+
+	it("validation logic", async () => {
+		const required = new Fields.NumberField(true, 0);
+		const not_required = new Fields.NumberField(false, 0);
+
+		assert.strictEqual((await required.isValueValid(ctx, 42)).valid, true);
+		assert.strictEqual((await required.isValueValid(ctx, "42")).valid, true);
+		assert.strictEqual((await required.isValueValid(ctx, "notvalid")).valid, false);
+		assert.strictEqual((await not_required.isValueValid(ctx, "")).valid, true);
+	});
+
+	it("parse function", async () => {
+		const required = new Fields.NumberField(true, 0);
+		const decimal_digits = new Fields.NumberField(true, 0, { decimalDigits: 1 });
+		const number_as_string_response = await required.parse(ctx, "42");
+		const number_response = await required.parse(ctx, 42);
+		const not_a_number_response = await required.parse(ctx, "notanumber");
+		const decimal_number_response = await decimal_digits.parse(ctx, 42.42);
+
+		assert.strictEqual(number_as_string_response.parsable, true);
+		assert.strictEqual(number_as_string_response.parsed_value, 42);
+		assert.strictEqual(number_response.parsable, true);
+		assert.strictEqual(number_response.parsed_value, 42);
+		assert.strictEqual(not_a_number_response.parsable, false);
+		assert.strictEqual(not_a_number_response.error, "Please enter a number");
+		assert.strictEqual(decimal_number_response.parsable, true);
+		assert.strictEqual(decimal_number_response.parsed_value, 42.4);
+	});
+});

package/src/forms/fields/number.ts

@@ -0,0 +1,70 @@
+import { is, predicates } from "@sealcode/ts-predicates";
+import { Context } from "koa";
+import { FormDataValue } from "../form";
+import { FieldParseResult, FormField } from "./field";
+
+export class NumberField<
+	DefaultValue extends number | null = number,
+	Required extends boolean = boolean
+> extends FormField<Required, number | DefaultValue> {
+	constructor(
+		required: Required,
+		public default_value: DefaultValue,
+		public options: Partial<{
+			max: number;
+			min: number;
+			decimalDigits: number;
+		}> = {}
+	) {
+		super(required);
+	}
+
+	predicate = predicates.number;
+
+	public async isValueValid(_: Context, value: unknown) {
+		if (
+			(is(value, predicates.string) &&
+				!isNaN(parseFloat(value)) &&
+				parseFloat(value).toString() == value.trim()) ||
+			is(value, predicates.number) ||
+			((is(value, predicates.undefined) || value == "") && !this.required)
+		) {
+			return { valid: true, message: "" };
+		}
+		return { valid: false, message: "Proszę wprowadzić liczbę" };
+	}
+
+	async parse(
+		_: Context,
+		value: FormDataValue
+	): Promise<FieldParseResult<number>> {
+		if (
+			(is(value, predicates.string) &&
+				!isNaN(parseFloat(value)) &&
+				parseFloat(value).toString() == value.trim()) ||
+			is(value, predicates.number)
+		) {
+			return {
+				parsable: true,
+				parsed_value: this.options.decimalDigits
+					? parseFloat(
+							parseFloat(value.toString()).toFixed(
+								this.options.decimalDigits
+							)
+					  )
+					: parseFloat(value.toString()),
+				error: null,
+			};
+		} else {
+			return {
+				parsable: false,
+				parsed_value: null,
+				error: "Please enter a number",
+			};
+		}
+	}
+
+	public getEmptyValue(): DefaultValue {
+		return this.default_value;
+	}
+}

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

@@ -0,0 +1,19 @@
+import assert from "assert";
+import { Fields } from "../../index";
+
+describe("pick-from-list field", () => {
+	const ctx = {} as any;
+
+	it("validation logic", async () => {
+		const field = new Fields.PickFromListField(true, async () => {
+			return [
+				{ value: "samplev", label: "samplel" },
+				{ value: "samplevv", label: "samplell" },
+			];
+		});
+
+		assert.strictEqual((await field.isValueValid(ctx, 42 as any)).valid, false);
+		assert.strictEqual((await field.isValueValid(ctx, "samplevv")).valid, true);
+		assert.strictEqual((await field.isValueValid(ctx, "notvalid")).valid, false);
+	});
+});

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

@@ -0,0 +1,52 @@
+import { is, predicates } from "@sealcode/ts-predicates";
+import { Context } from "koa";
+import { DropdownOption } from "../controls/dropdown";
+import { FormFieldValidationResponse } from "./field";
+import { SimpleFormField } from "./simple-form-field";
+
+export class PickFromListField<
+	Required extends boolean
+> extends SimpleFormField<Required> {
+	constructor(
+		public required: Required,
+		public generateOptions: (ctx: Context) => Promise<DropdownOption[]>,
+		public customValidation: (
+			ctx: Context,
+			value: unknown,
+			instance: PickFromListField<Required>
+		) => Promise<FormFieldValidationResponse> = (ctx, value, instance) =>
+			instance.valueInList(ctx, value)
+	) {
+		super(required);
+	}
+
+	predicate = predicates.string;
+
+	public isValueValid(
+		ctx: Context,
+		value: string
+	): Promise<FormFieldValidationResponse> {
+		return this.customValidation(ctx, value, this);
+	}
+
+	async valueInList(
+		ctx: Context,
+		value: unknown
+	): Promise<FormFieldValidationResponse> {
+		const options = await this.generateOptions(ctx);
+		if (!is(value, predicates.string)) {
+			return { valid: false, message: "not a string" };
+		}
+		if (this.required && !options.map((o) => o.value).includes(value)) {
+			return {
+				valid: false,
+				message: `"${value}" is not one of the options`,
+			};
+		}
+		return { valid: true, message: "" };
+	}
+
+	public getEmptyValue(): string {
+		return "";
+	}
+}

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

@@ -0,0 +1,24 @@
+import { FormField } from "./field";
+
+export class ProxyFormField<T> extends FormField<boolean, T> {
+	constructor(
+		required: boolean,
+		public name: string,
+		public empty_value: T,
+		public parsed_value: T
+	) {
+		super(required);
+	}
+
+	getEmptyValue() {
+		return this.empty_value;
+	}
+
+	async parse() {
+		return <const>{
+			parsable: true,
+			error: null,
+			parsed_value: this.parsed_value,
+		};
+	}
+}

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

@@ -0,0 +1,25 @@
+import assert from "assert";
+import { Fields } from "../../index";
+
+describe("regexp field", () => {
+	const ctx = {} as any;
+
+	it("validation logic", async () => {
+		const field = new Fields.RegExpField(true, /^4/, "error");
+
+		assert.strictEqual((await field.isValueValid(ctx, "42")).valid, true);
+		assert.strictEqual((await field.isValueValid(ctx, "notvalid")).valid, false);
+		assert.strictEqual((await field.isValueValid(ctx, 42)).valid, false);
+	});
+
+	it("parse function", async () => {
+		const field = new Fields.RegExpField(true, /^4/, "error");
+		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/regexp.ts

@@ -0,0 +1,53 @@
+import { is, predicates } from "@sealcode/ts-predicates";
+import { Context } from "koa";
+import { FormDataValue } from "../form";
+import { FieldParseResult, FormField } from "./field";
+
+export class RegExpField<Required extends boolean> extends FormField<Required> {
+	constructor(
+		required: Required,
+		public regexp: RegExp,
+		public error_message: string,
+		public default_value: string = ""
+	) {
+		super(required);
+	}
+
+	predicate = predicates.string;
+
+	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.regexp.exec(value)) {
+			return { valid: true, message: "" };
+		}
+		return { valid: false, message: this.error_message };
+	}
+
+	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 this.default_value || "";
+	}
+}

package/src/forms/fields/reverse-single-reference.ts

@@ -0,0 +1,20 @@
+import { FormField } from "./field";
+import { FieldTypes as SealiousFields } from "sealious";
+import { Context } from "koa";
+
+export class ReverseSingleReference extends FormField {
+	constructor(
+		required: boolean,
+		public sealious_field: SealiousFields.ReverseSingleReference
+	) {
+		super(required);
+	}
+
+	async parse(ctx: Context, raw_value: unknown) {
+		return { parsable: <const>true, error: null, parsed_value: raw_value };
+	}
+
+	getEmptyValue() {
+		return [];
+	}
+}

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

@@ -0,0 +1,30 @@
+import { FieldParseResult, FormField } from "./field";
+import { FormDataValue } from "../form";
+import { Context } from "koa";
+import { predicates } from "@sealcode/ts-predicates";
+
+export class SimpleFormField<Required extends boolean> extends FormField<
+	Required,
+	string | null
+> {
+	async parse(
+		_: Context,
+		raw_value: FormDataValue
+	): Promise<FieldParseResult<string>> {
+		return {
+			parsed_value: (raw_value || "").toString(),
+			parsable: true,
+			error: null,
+		};
+	}
+
+	predicate = predicates.string;
+
+	public getEmptyValue(): string {
+		return "";
+	}
+
+	constructor(required: Required) {
+		super(required);
+	}
+}

package/src/forms/fields/structured-array.ts

@@ -0,0 +1,27 @@
+import { Context } from "koa";
+import { Field, FieldsetInput, FieldsetOutput, FieldTypes } from "sealious";
+import { FormDataValue } from "../form";
+import { FormField } from "./field";
+
+export class StructuredArrayField<
+	Fields extends Record<string, Field>
+> extends FormField<
+	true,
+	FieldTypes.ArrayStorageInput<FieldsetOutput<Fields>>
+> {
+	constructor(public sealious_field: FieldTypes.StructuredArray<Fields>) {
+		super(true);
+	}
+
+	async parse(context: Context, value: FormDataValue) {
+		return {
+			parsable: <const>true,
+			error: null,
+			parsed_value: (value as FieldsetOutput<Fields>) || [],
+		};
+	}
+
+	getEmptyValue() {
+		return [] as FieldTypes.ArrayStorageInput<FieldsetOutput<Fields>>;
+	}
+}