@sealcode/sealgen 0.18.10 → 0.19.0

package/src/forms/controls/tickable.ts

@@ -70,11 +70,19 @@ export abstract class Tickable<T> extends FormFieldControl {
 			parsed: _parsed,
 			valid,
 			message,
-		} = await this.field.getValue(fctx.ctx, fctx.data, true);
+		} = await this.field.getParsedValue(
+			fctx.ctx,
+			fctx.data.raw_values,
+			true
+		);
 		const parsed = _parsed === null ? this.options.default_value : _parsed;
 
-		const value = this.getValueAttribute(fctx.ctx, fctx.data, parsed);
-		const id = this.makeInputID(fctx.ctx, fctx.data, parsed);
+		const value = this.getValueAttribute(
+			fctx.ctx,
+			fctx.data.raw_values,
+			parsed
+		);
+		const id = this.makeInputID(fctx.ctx, fctx.data.raw_values, parsed);
 		const label =
 			this.options.label != undefined
 				? this.options.label
@@ -86,7 +94,7 @@ export abstract class Tickable<T> extends FormFieldControl {
 
 		return inputWrapper(
 			this.type,
-			this.getWrapperClasses(fctx.ctx, fctx.data, parsed),
+			this.getWrapperClasses(fctx.ctx, fctx.data.raw_values, parsed),
 
 			/* HTML */ `
 				<input
@@ -96,7 +104,7 @@ export abstract class Tickable<T> extends FormFieldControl {
 					this.field.name}"
 					${value ? `value="${attribute(value)}"` : ""}
 					${fctx.form_id ? `form="${fctx.form_id}"` : ""}
-					${this.isChecked(fctx.ctx, fctx.data, parsed)
+					${this.isChecked(fctx.ctx, fctx.data.raw_values, parsed)
 						? "checked"
 						: ""}
 					${readonly ? "readonly" : ""}

package/src/forms/fields/boolean.ts

@@ -1,14 +1,17 @@
 import { is, predicates } from "@sealcode/ts-predicates";
 import { Context } from "koa";
+import { Checkbox } from "../controls/checkbox.js";
 import { FormDataValue } from "../form-types.js";
 import { FieldParseResult, FormField } from "./field.js";
+import { FormControlContext } from "../controls/form-control.js";
 
 const truthy = ["true", "on", "yes", "1"];
 const falsy = ["false", "off", "no", "0"];
 
 export class Boolean<Required extends boolean> extends FormField<
 	Required,
-	boolean
+	boolean,
+	Checkbox
 > {
 	predicate = predicates.boolean;
 	constructor(required: Required, public error_message: string = "") {
@@ -60,4 +63,23 @@ export class Boolean<Required extends boolean> extends FormField<
 	public getEmptyValue(): boolean {
 		return false;
 	}
+
+	public getControl(): Checkbox {
+		return new Checkbox(this, { label: this.name });
+	}
+
+	async getSealiousCreateValue(fctx: FormControlContext): Promise<boolean> {
+		const { parsed } = await this.getParsedValue(
+			fctx.ctx,
+			fctx.data.raw_values
+		);
+		return !!parsed;
+	}
+
+	async sealiousValueToForm(
+		_: Context,
+		value: boolean | null
+	): Promise<FormDataValue> {
+		return value ? "true" : "false";
+	}
 }

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

@@ -1,5 +1,6 @@
 import { is, predicates } from "@sealcode/ts-predicates";
 import { Context } from "koa";
+import { CheckboxedListInput } from "../controls/checkboxed-list-input.js";
 import { FormDataValue } from "../form-types.js";
 import {
 	FieldParseResult,
@@ -13,9 +14,13 @@ export type CheckboxedListItem = {
 	group?: string;
 };
 
-export class CheckboxedListField<Required extends boolean> extends FormField<
+export class CheckboxedListField<
+	Required extends boolean,
+	Values extends string
+> extends FormField<
 	Required,
-	Record<string, "on">
+	Record<Values, "on">,
+	CheckboxedListInput<Values>
 > {
 	constructor(
 		public required: Required,
@@ -67,4 +72,8 @@ export class CheckboxedListField<Required extends boolean> extends FormField<
 	public getEmptyValue(): Record<string, "on"> {
 		return {};
 	}
+
+	getControl(): CheckboxedListInput<Values> {
+		return new CheckboxedListInput(this, { label: this.name });
+	}
 }

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

@@ -1,6 +1,7 @@
 import { predicates } from "@sealcode/ts-predicates";
 import { Context } from "koa";
 import { Depromisify, ExtractFieldDecoded, Field } from "sealious";
+import { SimpleInput } from "../controls/controls.js";
 import { FormDataValue } from "../form-types.js";
 
 import {
@@ -8,12 +9,13 @@ import {
 	FormField,
 	FormFieldValidationResponse,
 } from "./field.js";
+import { ExtractedFieldInfo } from "../../utils/extract-fields-from-collection.js";
 
 export class CollectionField<
 	// eslint-disable-next-line @typescript-eslint/no-explicit-any
 	F extends Field<any>,
 	Required extends boolean
-> extends FormField<Required, ExtractFieldDecoded<F> | null> {
+> extends FormField<Required, ExtractFieldDecoded<F> | null, SimpleInput> {
 	constructor(required: Required, public sealiousField: F) {
 		super(required);
 	}
@@ -62,4 +64,17 @@ export class CollectionField<
 		// eslint-disable-next-line @typescript-eslint/no-unsafe-return
 		return "" as unknown as ExtractFieldDecoded<F>;
 	}
+
+	getControl(): SimpleInput {
+		return new SimpleInput(this);
+	}
+
+	generateFieldDeclaration(
+		field_info: ExtractedFieldInfo,
+		vars: { form_field_types: string; sealious_field: string }
+	): string {
+		return `new ${vars.form_field_types}.${this.constructor.name}(${String(
+			field_info.is_required
+		)}, ${vars.sealious_field})`;
+	}
 }

package/src/forms/fields/color.ts

@@ -0,0 +1,9 @@
+import { TextBasedSimpleField } from "./simple-form-field.js";
+
+export class Color<
+	Required extends boolean
+> extends TextBasedSimpleField<Required> {
+	constructor(required: Required) {
+		super(required, "color");
+	}
+}

package/src/forms/fields/coordinates.ts

@@ -0,0 +1,66 @@
+import { Context } from "koa";
+import { FormControl, FormControlContext } from "../controls/form-control.js";
+import { SimpleInput } from "../controls/simple-input.js";
+import { FormDataValue } from "../form-types.js";
+import { FieldParseResult } from "./field.js";
+import { SimpleFormField } from "./simple-form-field.js";
+
+export class Coordinates<
+	Required extends boolean,
+	DefaultControl extends FormControl = SimpleInput
+> extends SimpleFormField<Required, DefaultControl, [number, number]> {
+	async parse(
+		_: Context,
+		raw_value: FormDataValue
+	): Promise<FieldParseResult<[number, number]>> {
+		if (typeof raw_value == "string") {
+			return {
+				parsed_value: raw_value
+					?.split(",")
+					.map((e) => parseFloat(e)) as [number, number],
+				parsable: true,
+				error: null,
+			};
+		}
+		if (Array.isArray(raw_value)) {
+			return {
+				parsed_value: raw_value.map((e) => parseFloat(e)) as [
+					number,
+					number
+				],
+				parsable: true,
+				error: null,
+			};
+		}
+		return {
+			parsed_value: null,
+			parsable: false,
+			error: "should be an array or string",
+		};
+	}
+
+	async getSealiousCreateValue(
+		fctx: FormControlContext
+	): Promise<[number, number] | undefined> {
+		const { parsed } = await this.getParsedValue(
+			fctx.ctx,
+			fctx.data.raw_values
+		);
+		return parsed || undefined;
+	}
+
+	async postSealiousCreate(): Promise<void> {}
+
+	async postSealiousEdit(): Promise<void> {}
+
+	getControl(): DefaultControl {
+		return new SimpleInput(this, {
+			label: this.name,
+			type: this.type,
+		}) as unknown as DefaultControl;
+	}
+
+	public getEmptyValue(): [number, number] {
+		return [0, 0];
+	}
+}

package/src/forms/fields/date.ts

@@ -0,0 +1,50 @@
+import { Context } from "koa";
+import { FormControlContext } from "../controls/form-control.js";
+import { SimpleInput, SimpleInputOptions } from "../controls/simple-input.js";
+import { FormDataValue } from "../form-types.js";
+import { FieldParseResult } from "./field.js";
+import { SimpleFormField } from "./simple-form-field.js";
+
+export class DateField<Required extends boolean> extends SimpleFormField<
+	Required,
+	SimpleInput,
+	Date
+> {
+	constructor(required: Required) {
+		super(required, "date");
+	}
+
+	public getEmptyValue(): Date {
+		return new Date("1970-01-01 00:00");
+	}
+
+	async parse(
+		ctx: Context,
+		raw_value: FormDataValue
+	): Promise<FieldParseResult<Date>> {
+		return {
+			error: null,
+			parsable: true,
+			parsed_value: new Date(raw_value as string),
+		};
+	}
+
+	getControl(): SimpleInput<SimpleInputOptions> {
+		return new SimpleInput(this, { label: this.name, type: this.type });
+	}
+
+	async getSealiousCreateValue(
+		fctx: FormControlContext
+	): Promise<string | null> {
+		const { parsed } = await this.getParsedValue(
+			fctx.ctx,
+			fctx.data.raw_values
+		);
+		if (!parsed) {
+			return null;
+		}
+		return `${parsed.getFullYear()}-${(parsed.getMonth() + 1)
+			.toString()
+			.padStart(2, "0")}-${parsed.getDate().toString().padStart(2, "0")}`;
+	}
+}

package/src/forms/fields/datetime.ts

@@ -0,0 +1,66 @@
+import { Context } from "koa";
+import { SimpleInput } from "../controls/controls.js";
+import { FormControlContext } from "../controls/form-control.js";
+import { FormDataValue } from "../form-types.js";
+import { FieldParseResult } from "./field.js";
+import { SimpleFormField } from "./simple-form-field.js";
+
+function pad(n: number) {
+	return String(n).padStart(2, "0");
+}
+
+export class DateTime<Required extends boolean> extends SimpleFormField<
+	Required,
+	SimpleInput,
+	Date | null
+> {
+	constructor(required: Required) {
+		super(required, "datetime-local");
+	}
+
+	public getEmptyValue(): Date | null {
+		return null;
+	}
+
+	async parse(
+		ctx: Context,
+		raw_value: FormDataValue
+	): Promise<FieldParseResult<Date | null>> {
+		const parsed_value = new Date(raw_value as string);
+		return { parsable: true, error: null, parsed_value };
+	}
+
+	async getSealiousCreateValue(
+		fctx: FormControlContext
+	): Promise<number | null> {
+		const { parsed } = await this.getParsedValue(
+			fctx.ctx,
+			fctx.data.raw_values
+		);
+		if (parsed == null) {
+			return null;
+		}
+		return new Date(parsed).getTime();
+	}
+
+	getControl(): SimpleInput {
+		return new SimpleInput(this, {
+			label: this.name,
+			type: this.type,
+		});
+	}
+
+	async sealiousValueToForm(
+		ctx: Context,
+		value: number | null
+	): Promise<FormDataValue> {
+		if (value == null) {
+			return "";
+		}
+		const d = new Date(value);
+
+		return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(
+			d.getDate()
+		)}T${pad(d.getHours())}:${pad(d.getMinutes())}`;
+	}
+}

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

@@ -0,0 +1,136 @@
+import { Context } from "koa";
+import { CollectionItem, FieldTypes as SealiousFieldTypes } from "sealious";
+import { FormDataValue, FormData } from "../form-types.js";
+import { CheckboxedListField } from "./checkboxed-list.js";
+import { ExtractedFieldInfo } from "../../utils/extract-fields-from-collection.js";
+import { wrapKeyName } from "../../utils/wrap-attributes.js";
+
+export class DeepReverseSingleReferenceList extends CheckboxedListField<
+	false,
+	string
+> {
+	public item_label_getter: (item: CollectionItem<any>) => string = (item) =>
+		item.get("name") as string;
+
+	constructor(
+		public sealious_field: SealiousFieldTypes.DeepReverseSingleReference
+	) {
+		super(false, async (ctx: Context) => {
+			const { items } = await ctx.$app.collections[
+				sealious_field.target_collection
+			]
+				.list(ctx.$context)
+				.fetch();
+
+			return items.map((s) => ({
+				label: this.item_label_getter(s),
+				value: s.id,
+			}));
+		});
+	}
+
+	setItemLabelGetter(getter: (item: CollectionItem<any>) => string) {
+		this.item_label_getter = getter;
+	}
+
+	getSealiousCreateValue(): never {
+		throw new Error(
+			"This field is not set directly through field value, but instead relies on postSealiousCreate and postSealiousEdit"
+		);
+	}
+
+	async postSealiousCreate(
+		ctx: Context,
+		created_item: CollectionItem<any>,
+		form_data: FormData
+	) {
+		// First, we remove links refering to current item
+		const { items: existing_links } = await ctx.$app.collections[
+			this.sealious_field.intermediary_collection
+		]
+			.list(ctx.$context)
+			.filter({
+				[this.sealious_field.referencing_field]: created_item.id,
+			})
+			.fetch();
+		const { parsed: value } = await this.getParsedValue(
+			ctx,
+			form_data.raw_values,
+			false
+		);
+		const should_exist_ids = Object.entries(value || {})
+			.filter(([, value]) => value === "on")
+			.map(([key]) => key);
+		const to_delete = existing_links.filter(
+			(link) =>
+				!should_exist_ids.includes(
+					link.get(
+						this.sealious_field.intermediary_field_that_points_there
+					) as string
+				)
+		);
+		const to_create_ids = should_exist_ids.filter(
+			(id) =>
+				!existing_links
+					.map((link) =>
+						// eslint-disable-next-line @typescript-eslint/no-unsafe-return
+						link.get(
+							this.sealious_field
+								.intermediary_field_that_points_there
+						)
+					)
+					.includes(id)
+		);
+		await Promise.all(
+			to_delete.map((item) => {
+				return item.remove(ctx.$context);
+			})
+		);
+		// Then, we iterate over all selected values and insert appropriate missing links
+		const promises = to_create_ids.map(async (id) => {
+			await this.sealious_field
+				.getReferencingCollection()
+				.create(ctx.$context, {
+					[this.sealious_field.referencing_field]: created_item.id,
+					[this.sealious_field.intermediary_field_that_points_there]:
+						id,
+				});
+		});
+		await Promise.all(promises);
+	}
+
+	async postSealiousEdit(
+		ctx: Context,
+		edited_item: CollectionItem<any>,
+		value: FormData
+	) {
+		return this.postSealiousCreate(ctx, edited_item, value);
+	}
+
+	async sealiousValueToForm(
+		_ctx: Context,
+		value: string[] | null
+	): Promise<FormDataValue> {
+		return Object.fromEntries((value || []).map((id) => [id, "on"]));
+	}
+
+	generateFieldDeclaration(
+		_field_info: ExtractedFieldInfo,
+		vars: { form_field_types: string; sealious_field: string }
+	): string {
+		return `new ${vars.form_field_types}.${this.constructor.name}(${vars.sealious_field})`;
+	}
+
+	generateCreateValueGetter(
+		field_info: ExtractedFieldInfo,
+		vars: {
+			form_field_types: string;
+			sealious_field: string;
+			form_fields: string;
+		}
+	): string {
+		return `${wrapKeyName(
+			field_info.name
+		)}: undefined /* handled below in postSealiousCreate */`;
+	}
+}

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

@@ -0,0 +1,213 @@
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+import {
+	FieldTypes as SealiousFieldTypes,
+	Field as SealiousField,
+	CollectionItem,
+} from "sealious";
+import { Boolean, TextBasedSimpleField } from "./fields.js";
+import { sealiousToFormField } from "./get-field-for-sealious.js";
+import { Table } from "./table.js";
+import { Table as TableControl } from "../controls/table.js";
+import { Context } from "koa";
+import { FormDataValue, FormData } from "../form-types.js";
+import { FormControlContext } from "../controls/form-control.js";
+import { HiddenInput } from "../controls/hidden-input.js";
+import { FormField } from "./field.js";
+
+function getReferencingFields(
+	sealious_field: SealiousFieldTypes.DeepReverseSingleReference
+): Record<string, SealiousField<unknown>> {
+	const referencing_collection =
+		sealious_field.collection.app.collections[
+			sealious_field.referencing_collection
+		];
+	if (!referencing_collection) {
+		throw new Error(
+			"Unknown collection: " + sealious_field.referencing_collection
+		);
+	}
+	return referencing_collection.fields;
+}
+
+export class DeepReverseSingleReferenceTable extends Table<
+	Record<string, FormField>
+> {
+	constructor(
+		public sealious_field: SealiousFieldTypes.DeepReverseSingleReference
+	) {
+		super({
+			selected: new Boolean(false),
+			[sealious_field.referencing_field]: new TextBasedSimpleField(true),
+			[sealious_field.intermediary_field_that_points_there]:
+				new TextBasedSimpleField(true),
+			...Object.fromEntries(
+				Object.values(getReferencingFields(sealious_field))
+					.filter(
+						(field) =>
+							!(
+								field instanceof
+								SealiousFieldTypes.SingleReference
+							)
+					)
+					.map((field) => [field.name, sealiousToFormField(field)])
+			),
+		});
+	}
+
+	getControl(): TableControl<any> {
+		return new TableControl(this, {
+			label: this.name,
+			allow_adding: false,
+			subfield_controls: {
+				selected: this.columns.selected.getControl(),
+				[this.sealious_field.referencing_field]: new HiddenInput(
+					this.columns[this.sealious_field.referencing_field]
+				),
+				[this.sealious_field.intermediary_field_that_points_there]:
+					new HiddenInput(
+						this.columns[
+							this.sealious_field.intermediary_field_that_points_there
+						]
+					),
+				...Object.fromEntries(
+					Object.values(getReferencingFields(this.sealious_field))
+						.filter(
+							(field) =>
+								!(
+									field instanceof
+									SealiousFieldTypes.SingleReference
+								)
+						)
+						.map((field) => [
+							field.name,
+							this.columns[field.name].getControl(),
+						])
+				),
+			},
+		});
+	}
+
+	getSealiousCreateValue(_fctx: FormControlContext): Promise<unknown> {
+		throw new Error("Method not implemented.");
+	}
+
+	async postSealiousCreate(
+		ctx: Context,
+		created_item: CollectionItem<any>,
+		form_data: FormData
+	): Promise<void> {
+		// First, we remove links refering to current item
+		const { items: to_delete } = await ctx.$app.collections[
+			"${toKebabCase(referencing_collection)}"
+		]
+			.list(ctx.$context)
+			.filter({ "${referencing_field}": created_item.id })
+			.fetch();
+		await Promise.all(to_delete.map((item) => item.remove(ctx.$context)));
+
+		// Then, we iterate over all selected values and insert appropriate entries for the subcategories relation
+
+		const referencing_fields = getReferencingFields(this.sealious_field);
+
+		const { parsed: value } = await this.getParsedValue(
+			ctx,
+			form_data.raw_values,
+			false
+		);
+		const promises = (value || [])
+			.filter((s) => s.selected == true)
+			.map(async (link_info) => {
+				await ctx.$app.collections[
+					"${toKebabCase(referencing_collection)}"
+				].create(ctx.$context, {
+					"${referencing_field}": created_item.id,
+					"${intermediary_field_that_points_there}": String(
+						link_info["${intermediary_field_that_points_there}"]
+					),
+					...Object.fromEntries(
+						Object.values(referencing_fields)
+							.filter(
+								(field) =>
+									!(
+										field instanceof
+										SealiousFieldTypes.SingleReference
+									)
+							)
+							.map((field) => [field.name, link_info[field.name]])
+					),
+				});
+			});
+
+		await Promise.all(promises);
+	}
+
+	postSealiousEdit(
+		ctx: Context,
+		edited_item: CollectionItem<any>,
+		form_data: FormData
+	): Promise<void> {
+		return this.postSealiousCreate(ctx, edited_item, form_data);
+	}
+
+	async sealiousValueToForm(
+		ctx: Context,
+		_value: string[],
+		item: CollectionItem<any>
+	): Promise<FormDataValue> {
+		// convert from an array to array-like object
+		const referencing_fields = getReferencingFields(this.sealious_field);
+		return Object.fromEntries(
+			await Promise.all([
+				this.sealious_field.collection.list(ctx.$context).fetch(),
+				this.sealious_field
+					.getReferencingCollection()
+					.list(ctx.$context)
+					.fetch(),
+			]).then(([{ items: targets }, { items: links }]) =>
+				targets
+					.map((target) => {
+						return {
+							selected: (
+								(item.get(
+									this.sealious_field.name
+								) as string[]) || []
+							).includes(target.id)
+								? "on"
+								: "off",
+							[this.sealious_field.referencing_field]: item.id,
+							[this.sealious_field
+								.intermediary_field_that_points_there]:
+								target.id,
+							...Object.fromEntries(
+								Object.values(referencing_fields)
+									.filter(
+										(field) =>
+											!(
+												field instanceof
+												SealiousFieldTypes.SingleReference
+											)
+									)
+									.map((field) => [
+										field.name,
+										links
+											.find(
+												(e) =>
+													e.get(
+														this.sealious_field
+															.intermediary_field_that_points_there
+													) == target.id &&
+													e.get(
+														this.sealious_field
+															.referencing_field
+													) == item.id
+											)
+											?.get("rank") || 0,
+									])
+							),
+						};
+					})
+					.entries()
+			)
+		) as FormDataValue;
+	}
+}