@sealcode/sealgen 0.8.47 → 0.8.48

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");
-	});
-});

package/src/forms/fields/regexp.ts

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

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

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

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