@sealcode/sealgen 0.18.10 → 0.19.2

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

@@ -0,0 +1,130 @@
+/* eslint  @typescript-eslint/no-explicit-any: off */
+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): 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  @typescript-eslint/no-explicit-any: off */
+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;
+	}
+}

package/src/forms/fields/email.ts

@@ -1,8 +1,9 @@
 import { predicates } from "@sealcode/ts-predicates";
 import { RegExpField } from "./regexp.js";
+import { SimpleInput } from "../controls/controls.js";
 
 export class EmailField<
-	Required extends boolean
+	Required extends boolean,
 > extends RegExpField<Required> {
 	predicate = predicates.string;
 	constructor(
@@ -17,4 +18,12 @@ export class EmailField<
 			default_value
 		);
 	}
+
+	setErrorMessage(message: string) {
+		this.error_message = message;
+	}
+
+	public getControl(): SimpleInput {
+		return new SimpleInput(this, { label: this.name, type: "email" });
+	}
 }

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

@@ -0,0 +1,48 @@
+import { FieldTypes as SealiousFieldTypes } from "sealious";
+import { Context } from "koa";
+import { ExtractedFieldInfo } from "../../utils/extract-fields-from-collection.js";
+import { CheckboxedListField } from "./checkboxed-list.js";
+import { FormControlContext } from "../controls/form-control.js";
+import { FormDataValue } from "../form-types.js";
+
+export class EnumMultipleSealious<
+	Values extends string,
+> extends CheckboxedListField<boolean, Values> {
+	public sealious_field: SealiousFieldTypes.EnumMultiple<Values>;
+
+	constructor(sealious_field: SealiousFieldTypes.EnumMultiple<Values>) {
+		super(sealious_field.required, async (ctx: Context) =>
+			(await sealious_field.getAllowedValues(ctx.$context)).map(
+				(value: Values) => ({ value, label: value })
+			)
+		);
+		this.sealious_field = sealious_field;
+	}
+
+	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})`;
+	}
+
+	async getSealiousCreateValue(fctx: FormControlContext): Promise<Values[]> {
+		const { parsed } = await this.getParsedValue(
+			fctx.ctx,
+			fctx.data.raw_values
+		);
+		const result = Object.entries(parsed || {})
+			.filter(([, value]) => value == "on")
+			.map(([key]) => key as Values);
+		return result;
+	}
+
+	async sealiousValueToForm(
+		ctx: Context,
+		sealious_value: Values[] | null
+	): Promise<FormDataValue> {
+		return Object.fromEntries(
+			(sealious_value || []).map((key) => [key, "on"])
+		);
+	}
+}

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

@@ -2,7 +2,7 @@ import { Field } from "sealious";
 import { PickFromListField } from "./pick-from-list.js";
 
 export class ExistingSealiousValue<
-	Required extends boolean
+	Required extends boolean,
 > extends PickFromListField<Required> {
 	constructor(required: Required, field: Field<unknown>) {
 		super(required, async (ctx) => {

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

@@ -7,7 +7,7 @@ import { mount } from "../../mount.js";
 import { Form } from "../form.js";
 import { getBrowser } from "../../utils/browser-creator.js";
 import assert from "assert";
-import { SimpleFormField } from "./simple-form-field.js";
+import { TextBasedSimpleField } from "./simple-form-field.js";
 import { SimpleInput } from "../controls/simple-input.js";
 import { FormData } from "../form-types.js";
 import { Boolean } from "./boolean.js";
@@ -25,12 +25,12 @@ describe("basic field", () => {
 
 		it("sends the values", async () => {
 			const port = await getPort();
-			console.log(`Using port ${port} form checkboxed-list-input.test.ts`);
+			console.info(`Using port ${port} form checkboxed-list-input.test.ts`);
 			const app = new Koa();
 			const router = new Router();
 
 			const fields = {
-				text: new SimpleFormField(true),
+				text: new TextBasedSimpleField(true),
 			};
 
 			let received_values: unknown;
@@ -44,7 +44,7 @@ describe("basic field", () => {
 
 					async onSubmit(ctx: Context, data: FormData) {
 						received_values = await this.getParsedValues(ctx);
-						const { parsed: email } = await this.fields.text.getValue(
+						const { parsed: email } = await this.fields.text.getParsedValue(
 							ctx,
 							data.raw_values
 						);
@@ -68,7 +68,7 @@ describe("basic field", () => {
 
 		it("Doesn't call `isValueValid` and `parse` if the value is empty", async () => {
 			const port = await getPort();
-			console.log(`Using port ${port} form checkboxed-list-input.test.ts`);
+			console.info(`Using port ${port} form checkboxed-list-input.test.ts`);
 			const app = new Koa();
 			const router = new Router();
 
@@ -76,7 +76,7 @@ describe("basic field", () => {
 			let parse_called = false;
 
 			const fields = {
-				text: new (class MockField extends SimpleFormField<false> {
+				text: new (class MockField extends TextBasedSimpleField<false> {
 					public async isValueValid() {
 						is_value_valid_called = true;
 						return true as any;
@@ -120,14 +120,14 @@ describe("basic field", () => {
 
 		it("Accepts a form where non-required values are empty", async () => {
 			const port = await getPort();
-			console.log(`Using port ${port} form checkboxed-list-input.test.ts`);
+			console.info(`Using port ${port} form checkboxed-list-input.test.ts`);
 			const app = new Koa();
 			const router = new Router();
 
 			let submit_called = false;
 
 			const fields = {
-				text: new SimpleFormField(false),
+				text: new TextBasedSimpleField(false),
 				checkbox: new Boolean(false),
 			};
 

package/src/forms/fields/field.ts

@@ -1,10 +1,21 @@
+/* eslint  @typescript-eslint/no-unused-vars: off, @typescript-eslint/no-explicit-any: off */
 import { Predicate, predicates } from "@sealcode/ts-predicates";
 import { Context } from "koa";
+import { Collection, CollectionItem } from "sealious";
 import { t } from "../../utils/translate.js";
-import { FormDataValue } from "../form-types.js";
+import { FormControl, FormControlContext } from "../controls/form-control.js";
+import { FormDataValue, FormData } from "../form-types.js";
+import { ExtractedFieldInfo } from "../../utils/extract-fields-from-collection.js";
+import { wrapAttribute, wrapKeyName } from "../../utils/wrap-attributes.js";
 
 export type FormFieldValidationResponse = { valid: boolean; message: string };
 
+export type FormDisplayInfo<C extends Collection> = {
+	field: keyof C["fields"];
+	label: string;
+	format?: (value: unknown, item: CollectionItem<C>) => JSX.Element;
+};
+
 export type FormFieldValidationFn<ValueType> = (
 	ctx: Context,
 	value: ValueType,
@@ -13,9 +24,10 @@ export type FormFieldValidationFn<ValueType> = (
 
 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;
+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);
@@ -49,15 +61,20 @@ export type FieldParseResult<T> =
 
 export abstract class FormField<
 	Required extends boolean = boolean,
-	ParsedValue = unknown
+	ParsedValue = unknown,
+	DefaultFormControl extends FormControl = FormControl,
+	SealiousValue = any,
 > {
 	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;
+	async init(): Promise<void> {}
+
+	setName(name: string): this {
+		this.name = name;
+		return this;
 	}
 
 	public async _validate(
@@ -100,7 +117,7 @@ export abstract class FormField<
 		raw_value: FormDataValue
 	): Promise<FieldParseResult<ParsedValue>>;
 
-	async getValue(
+	async getParsedValue(
 		ctx: Context,
 		all_form_values: Record<string, FormDataValue>,
 		validate: true
@@ -110,7 +127,7 @@ export abstract class FormField<
 		parsed: ParsedValue | null;
 		raw: FormDataValue;
 	}>;
-	async getValue(
+	async getParsedValue(
 		ctx: Context,
 		all_form_values: Record<string, FormDataValue>,
 		validate?: false
@@ -119,7 +136,7 @@ export abstract class FormField<
 		parsed: ParsedValue | null;
 		raw: FormDataValue;
 	}>;
-	async getValue(
+	async getParsedValue(
 		ctx: Context,
 		all_form_values: Record<string, FormDataValue>,
 		validate = false
@@ -176,7 +193,77 @@ export abstract class FormField<
 		ctx: Context,
 		data: Record<string, FormDataValue>
 	): Promise<unknown> {
-		const { parsed } = await this.getValue(ctx, data);
+		const { parsed } = await this.getParsedValue(ctx, data);
 		return parsed;
 	}
+
+	abstract getControl(): DefaultFormControl;
+
+	getSealiousCreateValue(fctx: FormControlContext): Promise<SealiousValue> {
+		throw new Error("This field does not have a default sealious mapping");
+	}
+
+	sealiousValueToForm(
+		ctx: Context,
+		sealiousValue: SealiousValue | null,
+		item: CollectionItem<any>
+	): Promise<FormDataValue> {
+		throw new Error("This field does not have a default sealious mapping");
+	}
+
+	async postSealiousCreate(
+		ctx: Context,
+		created_item: CollectionItem<any>,
+		form_data: FormData
+	): Promise<void> {}
+
+	async postSealiousEdit(
+		ctx: Context,
+		edited_item: CollectionItem<any>,
+		form_data: FormData
+	): Promise<void> {}
+
+	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
+		)})`;
+	}
+
+	generateCreateValueGetter(
+		field_info: ExtractedFieldInfo,
+		vars: {
+			form_field_types: string;
+			sealious_field: string;
+			form_fields: string;
+		}
+	): string {
+		return `${wrapKeyName(field_info.name)}: await ${
+			vars.form_fields
+		}${wrapAttribute(field_info.name)}.getSealiousCreateValue(fctx)`;
+	}
+
+	generateInitialValue(
+		field_info: ExtractedFieldInfo,
+		vars: {
+			form_field_types: string;
+			form_fields: string;
+		}
+	): string {
+		return `${wrapKeyName(field_info.name)}: await ${
+			vars.form_fields
+		}${wrapAttribute(field_info.name)}.sealiousValueToForm(ctx, item.get("${
+			field_info.name
+		}"))`;
+	}
+
+	generateImportsForFieldList(field_info: ExtractedFieldInfo): {
+		what: string;
+		from: string;
+		as?: string;
+	}[] {
+		return [];
+	}
 }

package/src/forms/fields/fields.ts

@@ -1,16 +1,31 @@
-export * from "./simple-form-field.js";
+export * from "./boolean.js";
 export * from "./checkboxed-list.js";
 export * from "./collection-field.js";
-export * from "./number.js";
-export * from "./pick-from-list.js";
-export * from "./regexp.js";
+export * from "./color.js";
+export * from "./coordinates.js";
+export * from "./date.js";
+export * from "./datetime.js";
+export * from "./deep-reverse-single-reference-list.js";
+export * from "./deep-reverse-single-reference-table.js";
 export * from "./email.js";
-export * from "./enum.js";
-export * from "./boolean.js";
-export * from "./enum-multiple.js";
+export * from "./enum-multiple-sealious.js";
 export * from "./existing-sealious-value.js";
 export * from "./file.js";
+export * from "./float.js";
+export * from "./html.js";
+export * from "./image.js";
+export * from "./int.js";
+export * from "./json.js";
+export * from "./markdown.js";
 export * from "./multiple-files.js";
-export * from "./reverse-single-reference.js";
+export * from "./number.js";
+export * from "./password.js";
+export * from "./pick-from-list-sealious.js";
+export * from "./pick-from-list.js";
+export * from "./regexp.js";
+export * from "./simple-form-field.js";
+export * from "./single-reference.js";
 export * from "./structured-array.js";
 export * from "./table.js";
+export * from "./text.js";
+export * from "./url.js";