@sealcode/sealgen 0.18.10 → 0.19.2

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

@@ -1,12 +1,11 @@
 import Router from "@koa/router";
 import { Context } from "koa";
-import { FileManager, FilePointer } from "@sealcode/file-manager";
+import { FilePointer } from "@sealcode/file-manager";
 import getPort from "get-port";
 import Koa from "koa";
 import fs from "node:fs/promises";
-import { KoaResponsiveImageRouter } from "koa-responsive-image-router";
 import { mount } from "../../mount.js";
-import { Photo } from "../controls/photo.js";
+import { Image } from "../controls/image.js";
 import { Form } from "../form.js";
 import { File as FileField } from "./file.js";
 import { getBrowser } from "../../utils/browser-creator.js";
@@ -28,12 +27,12 @@ describe("file field", () => {
 
 	it("should handle as imple upload scenario", async () => {
 		const port = await getPort();
-		console.log(`Using port http://localhost:${port} form file field test`);
+		console.info(`Using port http://localhost:${port} form file field test`);
 		const app = new Koa();
 		const router = new Router();
 
 		const fields = {
-			file: new FileField(true, new FileManager("/tmp", "/uploaded_files")),
+			file: new FileField(true),
 		};
 
 		let received_values: any;
@@ -43,18 +42,7 @@ describe("file field", () => {
 			"/",
 			new (class extends Form<typeof fields, unknown> {
 				fields = fields;
-				controls = [
-					new Photo(
-						fields.file,
-						new KoaResponsiveImageRouter({
-							staticPath: "/tmp",
-							thumbnailSize: 10,
-							cacheManagerResolutionThreshold: 10,
-							imageStoragePath: "/tmp",
-							smartCropStoragePath: "/tmp",
-						})
-					),
-				];
+				controls = [new Image(fields.file)];
 
 				async onSubmit(ctx: Context) {
 					received_values = await this.getParsedValues(ctx);

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,9 +44,9 @@ 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;
 			const new_file = hasFieldOfType(
 				raw_value,
@@ -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(): 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,337 @@
+/* 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> {
+	Required extends boolean = boolean,
+> extends FormField<Required, number | DefaultValue, SimpleInput> {
 	constructor(
 		required: Required,
 		public default_value: DefaultValue,
@@ -51,7 +52,7 @@ export class NumberField<
 							parseFloat(value.toString()).toFixed(
 								this.options.decimalDigits
 							)
-					  )
+						)
 					: parseFloat(value.toString()),
 				error: null,
 			};
@@ -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",
+		});
+	}
 }