@sealcode/sealgen 0.8.44 → 0.8.48

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

@@ -1,62 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,56 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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 "";
-	}
-}

package/src/forms/fields/field.ts

@@ -1,172 +0,0 @@
-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

@@ -1,89 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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

@@ -1,70 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,52 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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");
-	});
-});