@sealcode/sealgen 0.18.8 → 0.19.0

package/src/forms/fields/file.ts

@@ -1,12 +1,10 @@
 import { hasFieldOfType, is, predicates } from "@sealcode/ts-predicates";
 import { Context } from "koa";
-import {
-	FileManager,
-	FilePointer,
-	PathFilePointer,
-} from "@sealcode/file-manager";
+import { FilePointer, PathFilePointer } from "@sealcode/file-manager";
 import { FormDataValue } from "../form-types.js";
 import { FieldParseResult, FormField } from "./field.js";
+import { File as FileControl } from "../controls/file.js";
+import { FormControl, FormControlContext } from "../controls/form-control.js";
 
 export type FileContainer = {
 	old: FilePointer | null;
@@ -15,22 +13,20 @@ export type FileContainer = {
 
 export class File<Required extends boolean> extends FormField<
 	Required,
-	FileContainer
+	FileContainer,
+	FormControl
 > {
-	constructor(
-		public readonly required: Required,
-		public file_manager: FileManager
-	) {
+	constructor(public readonly required: Required) {
 		super(required);
 	}
 
 	async parse(
-		_ctx: Context,
+		ctx: Context,
 		raw_value: FormDataValue
 	): Promise<FieldParseResult<FileContainer>> {
 		let result;
 		if (is(raw_value, predicates.string)) {
-			const file = await this.file_manager.fromToken(raw_value);
+			const file = await ctx.$app.fileManager.fromToken(raw_value);
 			result = {
 				parsed_value: { old: file, new: null },
 				error: null,
@@ -48,7 +44,7 @@ export class File<Required extends boolean> extends FormField<
 				"old",
 				predicates.instanceOf(PathFilePointer)
 			)
-				? await this.file_manager.toPointer(
+				? await ctx.$app.fileManager.toPointer(
 						raw_value.old as string | FilePointer
 				  )
 				: null;
@@ -70,16 +66,48 @@ export class File<Required extends boolean> extends FormField<
 				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);
+		const { parsed } = await this.getParsedValue(ctx, data);
 		return parsed?.new || undefined;
 	}
 
 	getEmptyValue() {
 		return { old: null, new: null };
 	}
+
+	getControl(...args: any[]): FileControl {
+		return new FileControl(this, { label: this.name, autocomplete: false });
+	}
+
+	async getSealiousCreateValue(
+		fctx: FormControlContext
+	): Promise<FilePointer | undefined> {
+		const { parsed: value } = await this.getParsedValue(
+			fctx.ctx,
+			fctx.data.raw_values
+		);
+		const pointer = value?.new || value?.old || undefined;
+		if (this.required && !pointer) {
+			throw new Error("File is required, but no value is provided");
+		}
+		return pointer;
+	}
+
+	async sealiousValueToForm(
+		ctx: Context,
+		sealiousValue: FilePointer | string | null
+	): Promise<{ old: FilePointer | undefined } | Record<string, never>> {
+		if (!sealiousValue) {
+			return {};
+		}
+		if (typeof sealiousValue == "string") {
+			sealiousValue = await ctx.$app.fileManager.fromToken(sealiousValue);
+		}
+		return {
+			old: sealiousValue, // FilePointer
+		};
+	}
 }

package/src/forms/fields/float.ts

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

package/src/forms/fields/get-field-for-sealious.ts

@@ -0,0 +1,304 @@
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+import {
+	Collection,
+	Field as SealiousField,
+	FieldTypes as SealiousFieldTypes,
+	RequiredField as SealiousRequiredField,
+} from "sealious";
+import { Boolean as BooleanField } from "./boolean.js";
+import { SimpleFormField, TextBasedSimpleField } from "./simple-form-field.js";
+import { File } from "./file.js";
+import { CollectionField } from "./collection-field.js";
+import { StructuredArray as StructuredArrayField } from "./structured-array.js";
+import { Color } from "./color.js";
+import { DateField } from "./date.js";
+import { DateTime } from "./datetime.js";
+import { EmailField } from "./email.js";
+import { Float } from "./float.js";
+import { HTML } from "./html.js";
+import { Int } from "./int.js";
+import { JSONField } from "./json.js";
+import { Password } from "./password.js";
+import { Text } from "./text.js";
+import { Markdown } from "./markdown.js";
+import { DeepReverseSingleReferenceTable } from "./deep-reverse-single-reference-table.js";
+import { DeepReverseSingleReferenceList } from "./deep-reverse-single-reference-list.js";
+import { Coordinates } from "./coordinates.js";
+import { SimpleInput } from "../controls/simple-input.js";
+
+import { FormField } from "./field.js";
+import { PickFromListSealious } from "./pick-from-list-sealious.js";
+import { SingleReference } from "./single-reference.js";
+import extract_fields_from_collection, {
+	ExtractedFieldInfo,
+} from "../../utils/extract-fields-from-collection.js";
+import { EnumMultipleSealious } from "./enum-multiple-sealious.js";
+import { URLField } from "./url.js";
+import { Image } from "./image.js";
+
+export type SealiousToFormField<T> = T extends SealiousFieldTypes.Boolean
+	? BooleanField<false>
+	: T extends SealiousFieldTypes.Color
+	? Color<false>
+	: T extends SealiousFieldTypes.ControlAccess<infer R>
+	? SealiousToFormField<R>
+	: T extends SealiousFieldTypes.Date
+	? DateField<false>
+	: T extends SealiousFieldTypes.DateTime
+	? DateTime<false>
+	: T extends SealiousFieldTypes.DeepReverseSingleReference
+	? DeepReverseSingleReferenceList | DeepReverseSingleReferenceTable
+	: T extends SealiousFieldTypes.DisallowUpdate<any, any, any, infer R>
+	? SealiousToFormField<R>
+	: T extends SealiousFieldTypes.Email
+	? EmailField<false>
+	: T extends SealiousFieldTypes.Enum<any>
+	? PickFromListSealious<false>
+	: T extends SealiousFieldTypes.EnumMultiple<infer R>
+	? R extends string[]
+		? EnumMultipleSealious<R>
+		: TextBasedSimpleField<false>
+	: T extends SealiousFieldTypes.File
+	? File<false>
+	: T extends SealiousFieldTypes.Float
+	? Float<false>
+	: T extends SealiousFieldTypes.HTML
+	? HTML<false>
+	: T extends SealiousFieldTypes.Image
+	? Image<false>
+	: T extends SealiousFieldTypes.Int
+	? Int<false>
+	: T extends SealiousFieldTypes.JsonObject
+	? JSONField<false>
+	: T extends SealiousFieldTypes.JDD
+	? TextBasedSimpleField<false, SimpleInput>
+	: T extends SealiousFieldTypes.Password
+	? Password<false>
+	: T extends SealiousFieldTypes.ReverseSingleReference
+	? TextBasedSimpleField<false, SimpleInput>
+	: T extends SealiousFieldTypes.SecretToken
+	? TextBasedSimpleField<false, SimpleInput>
+	: T extends SealiousFieldTypes.SettableBy<infer R>
+	? SealiousToFormField<R>
+	: T extends SealiousFieldTypes.SingleReference
+	? SingleReference<Collection, boolean, T>
+	: T extends SealiousFieldTypes.Text
+	? Text<false>
+	: T extends SealiousFieldTypes.Username
+	? CollectionField<SealiousFieldTypes.Username, false>
+	: T extends SealiousFieldTypes.ValueExistingInCollection
+	? SimpleFormField<false>
+	: T extends SealiousFieldTypes.ValueNotExistingInCollection
+	? SimpleFormField<false>
+	: T extends SealiousRequiredField<any, any, any>
+	? SimpleFormField<false>
+	: T extends SealiousFieldTypes.Url
+	? URLField<false>
+	: T extends SealiousFieldTypes.Money
+	? SimpleFormField<false>
+	: T extends SealiousFieldTypes.Markdown
+	? Markdown<false>
+	: T extends SealiousFieldTypes.Coordinates
+	? Coordinates<false>
+	: T extends SealiousFieldTypes.StructuredArray<infer R>
+	? StructuredArrayField<R>
+	: TextBasedSimpleField<any>;
+
+export function sealiousToFormField<SF extends SealiousField<any>>(
+	sealious_field: SF
+): SealiousToFormField<SF> {
+	if (sealious_field instanceof SealiousFieldTypes.Boolean) {
+		return new BooleanField(
+			sealious_field.required
+		) as SealiousToFormField<SF>;
+	}
+	if (sealious_field instanceof SealiousFieldTypes.Color) {
+		return new Color(sealious_field.required) as SealiousToFormField<SF>;
+	}
+	if (sealious_field instanceof SealiousFieldTypes.ControlAccess) {
+		const target_field = sealious_field.virtual_field;
+		return sealiousToFormField(target_field) as SealiousToFormField<SF>;
+	}
+	if (sealious_field instanceof SealiousFieldTypes.Date) {
+		return new DateField(
+			sealious_field.required
+		) as SealiousToFormField<SF>;
+	}
+	if (sealious_field instanceof SealiousFieldTypes.DateTime) {
+		return new DateTime(sealious_field.required) as SealiousToFormField<SF>;
+	}
+	if (
+		sealious_field instanceof SealiousFieldTypes.DeepReverseSingleReference
+	) {
+		const referencing_collection =
+			sealious_field.collection.app.collections[
+				sealious_field.referencing_collection
+			];
+		if (!referencing_collection) {
+			throw new Error(
+				"Unknown collection: " + sealious_field.referencing_collection
+			);
+		}
+		if (Object.keys(referencing_collection.fields).length == 2) {
+			return new DeepReverseSingleReferenceList(
+				sealious_field
+			) as SealiousToFormField<SF>;
+		} else {
+			return new DeepReverseSingleReferenceTable(
+				sealious_field
+			) as SealiousToFormField<SF>;
+		}
+	}
+	if (sealious_field instanceof SealiousFieldTypes.DisallowUpdate) {
+		return sealiousToFormField(
+			sealious_field.virtual_field
+		) as SealiousToFormField<SF>;
+	}
+	if (sealious_field instanceof SealiousFieldTypes.Email) {
+		return new EmailField(
+			sealious_field.required
+		) as SealiousToFormField<SF>;
+	}
+	if (sealious_field instanceof SealiousFieldTypes.Enum) {
+		return new PickFromListSealious(
+			sealious_field
+		) as SealiousToFormField<SF>;
+	}
+	if (sealious_field instanceof SealiousFieldTypes.EnumMultiple) {
+		return new EnumMultipleSealious(
+			sealious_field
+		) as SealiousToFormField<SF>;
+	}
+	if (sealious_field instanceof SealiousFieldTypes.File) {
+		return new File(sealious_field.required) as SealiousToFormField<SF>;
+	}
+	if (sealious_field instanceof SealiousFieldTypes.Float) {
+		return new Float(sealious_field.required) as SealiousToFormField<SF>;
+	}
+	if (sealious_field instanceof SealiousFieldTypes.HTML) {
+		return new HTML(sealious_field.required) as SealiousToFormField<SF>;
+	}
+	if (sealious_field instanceof SealiousFieldTypes.Image) {
+		return new Image(sealious_field.required) as SealiousToFormField<SF>;
+	}
+	if (sealious_field instanceof SealiousFieldTypes.Int) {
+		return new Int(sealious_field.required) as SealiousToFormField<SF>;
+	}
+	if (sealious_field instanceof SealiousFieldTypes.JsonObject) {
+		return new JSONField(
+			sealious_field.required
+		) as SealiousToFormField<SF>;
+	}
+	if (sealious_field instanceof SealiousFieldTypes.Password) {
+		return new Password(sealious_field.required) as SealiousToFormField<SF>;
+	}
+	if (sealious_field instanceof SealiousFieldTypes.SettableBy) {
+		return sealiousToFormField(
+			sealious_field.virtual_field
+		) as SealiousToFormField<SF>;
+	}
+	if (sealious_field instanceof SealiousFieldTypes.SingleReference) {
+		return new SingleReference(
+			false,
+			sealious_field
+		) as unknown as SealiousToFormField<SF>;
+	}
+	if (sealious_field instanceof SealiousFieldTypes.Text) {
+		return new Text(sealious_field.required) as SealiousToFormField<SF>;
+	}
+	if (sealious_field instanceof SealiousFieldTypes.Username) {
+		return new Text(sealious_field.required) as SealiousToFormField<SF>;
+	}
+	if (sealious_field instanceof SealiousFieldTypes.Url) {
+		return new URLField(sealious_field.required) as SealiousToFormField<SF>;
+	}
+	if (sealious_field instanceof SealiousFieldTypes.Money) {
+		return new Float(sealious_field.required) as SealiousToFormField<SF>;
+	}
+	if (sealious_field instanceof SealiousFieldTypes.Markdown) {
+		return new Markdown(sealious_field.required) as SealiousToFormField<SF>;
+	}
+	if (sealious_field instanceof SealiousFieldTypes.Coordinates) {
+		return new Coordinates(
+			sealious_field.required
+		) as SealiousToFormField<SF>;
+	}
+	if (sealious_field instanceof SealiousFieldTypes.StructuredArray) {
+		return new StructuredArrayField(
+			sealious_field
+		) as SealiousToFormField<SF>;
+	}
+	return new TextBasedSimpleField(false) as SealiousToFormField<SF>;
+}
+
+export async function sealiousFieldInfoToFormField(
+	field_info: ExtractedFieldInfo
+): Promise<FormField> {
+	switch (field_info.type) {
+		case "boolean":
+			return new BooleanField(field_info.is_required);
+		case "color":
+			return new Color(field_info.is_required);
+		case "date":
+			return new DateField(field_info.is_required);
+		case "datetime":
+			return new DateTime(field_info.is_required);
+		case "deep-reverse-single-reference": {
+			const referencing_fields = await extract_fields_from_collection(
+				field_info.referencing_collection as string
+			);
+			if (referencing_fields.length == 2) {
+				return new DeepReverseSingleReferenceList({} as any);
+			} else {
+				return new DeepReverseSingleReferenceTable({} as any);
+			}
+		}
+		case "email":
+			return new EmailField(field_info.is_required);
+		case "enum":
+			return new PickFromListSealious({} as any);
+		case "enum-multiple":
+			return new EnumMultipleSealious({} as any);
+		case "file":
+			return new File(field_info.is_required);
+		case "float":
+			return new Float(field_info.is_required);
+		case "html":
+			return new HTML(field_info.is_required);
+		case "image":
+			return new Image(field_info.is_required);
+		case "int":
+			return new Int(field_info.is_required);
+		case "json-object":
+			return new JSONField(field_info.is_required);
+		case "password":
+			return new Password(field_info.is_required);
+		case "single-reference":
+			return new SingleReference(false, {} as any);
+		case "text":
+			return new Text(field_info.is_required);
+
+		case "username":
+			return new Text(field_info.is_required);
+
+		case "url":
+			return new URLField(field_info.is_required);
+		case "money":
+			return new Float(field_info.is_required);
+
+		case "markdown":
+			return new Markdown(field_info.is_required);
+		case "coordinates":
+			return new Coordinates(field_info.is_required);
+		case "structured-array":
+			// we don't need the full thing at this point, so we don't fill in the subfields
+			return new StructuredArrayField(
+				new SealiousFieldTypes.StructuredArray({})
+			);
+
+		default:
+			return new TextBasedSimpleField(false);
+	}
+}

package/src/forms/fields/html.ts

@@ -0,0 +1,15 @@
+import { Textarea } from "../controls/textarea.js";
+import { TextBasedSimpleField } from "./simple-form-field.js";
+
+export class HTML<Required extends boolean> extends TextBasedSimpleField<
+	Required,
+	Textarea
+> {
+	constructor(required: Required) {
+		super(required, "text");
+	}
+
+	getControl(): Textarea {
+		return new Textarea(this);
+	}
+}

package/src/forms/fields/image.ts

@@ -0,0 +1,12 @@
+import { Image as ImageControl } from "../controls/image.js";
+import { File as FileField } from "./file.js";
+import { FileContainer } from "../fields/file.js";
+import { FormField } from "./field.js";
+
+export class Image<Required extends boolean> extends FileField<Required> {
+	getControl(): ImageControl {
+		return new ImageControl(
+			this as unknown as FormField<boolean, FileContainer>
+		);
+	}
+}

package/src/forms/fields/int.ts

@@ -0,0 +1,25 @@
+import { FormControlContext } from "../controls/form-control.js";
+import { NumberBasedSimpleField } from "./simple-form-field.js";
+
+export class Int<
+	Required extends boolean
+> extends NumberBasedSimpleField<Required> {
+	constructor(required: Required) {
+		super(required, "number");
+	}
+
+	async getSealiousCreateValue(
+		fctx: FormControlContext
+	): Promise<number | undefined> {
+		const { parsed } = await this.getParsedValue(
+			fctx.ctx,
+			fctx.data.raw_values
+		);
+		if (parsed == null) {
+			return undefined;
+		}
+		if (isNaN(parsed)) {
+			return undefined;
+		} else return parsed;
+	}
+}

package/src/forms/fields/json.ts

@@ -0,0 +1,48 @@
+import { Context } from "koa";
+import { FormControlContext } from "../controls/form-control.js";
+import { Textarea } from "../controls/textarea.js";
+import { FormDataValue } from "../form-types.js";
+import { FieldParseResult } from "./field.js";
+import { SimpleFormField } from "./simple-form-field.js";
+
+export class JSONField<Required extends boolean> extends SimpleFormField<
+	Required,
+	Textarea,
+	Record<string, unknown>
+> {
+	constructor(required: Required) {
+		super(required, "text");
+	}
+
+	getControl(): Textarea {
+		return new Textarea(this);
+	}
+
+	public getEmptyValue(): Record<string, unknown> {
+		return {};
+	}
+
+	async parse(
+		ctx: Context,
+		raw_value: FormDataValue
+	): Promise<FieldParseResult<Record<string, unknown>>> {
+		return {
+			parsable: true,
+			error: null,
+			parsed_value: JSON.parse(raw_value as string) as Record<
+				string,
+				unknown
+			>,
+		};
+	}
+
+	async getSealiousCreateValue(
+		fctx: FormControlContext
+	): Promise<Record<string, unknown> | null> {
+		const { parsed } = await this.getParsedValue(
+			fctx.ctx,
+			fctx.data.raw_values
+		);
+		return parsed;
+	}
+}

package/src/forms/fields/markdown.ts

@@ -0,0 +1,15 @@
+import { Textarea } from "../controls/textarea.js";
+import { TextBasedSimpleField } from "./simple-form-field.js";
+
+export class Markdown<Required extends boolean> extends TextBasedSimpleField<
+	Required,
+	Textarea
+> {
+	constructor(required: Required) {
+		super(required, "text");
+	}
+
+	getControl(): Textarea {
+		return new Textarea(this);
+	}
+}

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

@@ -1,8 +1,13 @@
 import { Context } from "koa";
 import { FieldTypes as SealiousFieldTypes } from "sealious";
 import { FormField } from "./field.js";
+import { MultipleFiles as MultipleFilesControl } from "../controls/multiple-files.js";
 
-export class MultipleFiles extends FormField<false> {
+export class MultipleFiles extends FormField<
+	false,
+	undefined,
+	MultipleFilesControl
+> {
 	constructor(
 		public collection_field: SealiousFieldTypes.ReverseSingleReference,
 		public getItemId: (ctx: Context) => Promise<string> | string
@@ -17,4 +22,8 @@ export class MultipleFiles extends FormField<false> {
 	async parse() {
 		return <const>{ parsed_value: undefined, parsable: true, error: null }; // the control is supposed to do the heavy lifting here
 	}
+
+	getControl() {
+		return new MultipleFilesControl(this);
+	}
 }

package/src/forms/fields/number.ts

@@ -1,12 +1,13 @@
 import { is, predicates } from "@sealcode/ts-predicates";
 import { Context } from "koa";
+import { SimpleInput } from "../controls/simple-input.js";
 import { FormDataValue } from "../form-types.js";
 import { FieldParseResult, FormField } from "./field.js";
 
 export class NumberField<
 	DefaultValue extends number | null = number,
 	Required extends boolean = boolean
-> extends FormField<Required, number | DefaultValue> {
+> extends FormField<Required, number | DefaultValue, SimpleInput> {
 	constructor(
 		required: Required,
 		public default_value: DefaultValue,
@@ -67,4 +68,10 @@ export class NumberField<
 	public getEmptyValue(): DefaultValue {
 		return this.default_value;
 	}
+
+	getControl(): SimpleInput {
+		return new SimpleInput(this as FormField<boolean, number>, {
+			type: "number",
+		});
+	}
 }

package/src/forms/fields/password.ts

@@ -0,0 +1,17 @@
+import { Context } from "koa";
+import { TextBasedSimpleField } from "./simple-form-field.js";
+
+export class Password<
+	Required extends boolean
+> extends TextBasedSimpleField<Required> {
+	constructor(required: Required) {
+		super(required, "password");
+	}
+
+	async sealiousValueToForm(
+		ctx: Context,
+		value: unknown
+	): Promise<undefined> {
+		return undefined;
+	}
+}

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

@@ -0,0 +1,22 @@
+import { FieldTypes as SealiousFieldTypes } from "sealious";
+import { PickFromListField } from "./pick-from-list.js";
+import { ExtractedFieldInfo } from "../../utils/extract-fields-from-collection.js";
+
+export class PickFromListSealious<
+	Required extends boolean
+> extends PickFromListField<Required> {
+	constructor(public sealious_field: SealiousFieldTypes.Enum<string>) {
+		super(sealious_field.required as Required, async (ctx) =>
+			sealious_field
+				.getAllowedValues(ctx.$app)
+				.map((value) => ({ value, label: value }))
+		);
+	}
+
+	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})`;
+	}
+}

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

@@ -1,12 +1,12 @@
 import { is, predicates } from "@sealcode/ts-predicates";
 import { Context } from "koa";
-import type { DropdownOption } from "../controls/dropdown.js";
+import { Dropdown, DropdownOption } from "../controls/dropdown.js";
 import { FormFieldValidationResponse } from "./field.js";
-import { SimpleFormField } from "./simple-form-field.js";
+import { TextBasedSimpleField } from "./simple-form-field.js";
 
 export class PickFromListField<
 	Required extends boolean
-> extends SimpleFormField<Required> {
+> extends TextBasedSimpleField<Required, Dropdown> {
 	constructor(
 		public required: Required,
 		public generateOptions: (ctx: Context) => Promise<DropdownOption[]>,
@@ -49,4 +49,8 @@ export class PickFromListField<
 	public getEmptyValue(): string {
 		return "";
 	}
+
+	getControl(): Dropdown {
+		return new Dropdown(this);
+	}
 }

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

@@ -1,6 +1,7 @@
+import { FormControl } from "../controls/form-control.js";
 import { FormField } from "./field.js";
 
-export class ProxyFormField<T> extends FormField<boolean, T> {
+export class ProxyFormField<T> extends FormField<boolean, T, any> {
 	constructor(
 		required: boolean,
 		public name: string,
@@ -21,4 +22,8 @@ export class ProxyFormField<T> extends FormField<boolean, T> {
 			parsed_value: this.parsed_value,
 		};
 	}
+
+	getControl(): FormControl {
+		throw new Error("This field does not have a default control assigned");
+	}
 }