@sealcode/sealgen 0.18.10 → 0.19.0

package/src/templates/shared/collection-edit-form.ts

@@ -1,11 +1,9 @@
 import { toKebabCase, toPascalCase } from "js-convert-case";
 import { formTemplate } from "../form.js";
-import { curryImportPath } from "../../utils/import-path.js";
 
 import _locreq from "locreq";
 import extract_fields_from_collection from "../../utils/extract-fields-from-collection.js";
-
-import { getFieldHandler } from "./shared-crud-form-fields.js";
+import { wrapAttribute } from "../../utils/wrap-attributes.js";
 
 export async function editItemFormTemplate(
 	edit_action_name: string,
@@ -16,38 +14,19 @@ export async function editItemFormTemplate(
 	const collection_fields = await extract_fields_from_collection(
 		collection_name
 	);
-	const importPath = curryImportPath(newfilefullpath);
-
-	const field_handler_results = await Promise.all(
-		collection_fields.map(async (field) => {
-			return getFieldHandler(collection_name, field, importPath);
-		})
-	);
+	const formFieldsVar = `${toPascalCase(collection_name)}FormFields`;
+	const collectionVar = `${toPascalCase(collection_name)}`;
 
 	return formTemplate(edit_action_name, newfilefullpath, {
 		success_message: "Changes saved!",
-		postimport: `import {${toPascalCase(
-			collection_name
-		)}FormFields, ${toPascalCase(
+		postimport: `import {${formFieldsVar}, get${toPascalCase(
 			collection_name
 		)}FormControls }from "../shared.js";
-                import { ${toPascalCase(collection_name)} } from "${importPath(
-			"src/back/collections/collections.js"
-		)}";
-		import { ${list_action}URL, ${edit_action_name}URL } from "${importPath(
-			"src/back/routes/urls.js"
-		)}";
-                import {tempstream} from "tempstream";
-
-		${Array.from(
-			new Set(field_handler_results.map(({ imports }) => imports.edit))
-		).join("\n")}
-
-        ${
-			collection_fields.filter((e) => !e.is_required).length
-				? `import {withFallback} from "@sealcode/sealgen";`
-				: ""
-		}
+        import { ${collectionVar} } from "src/back/collections/collections.js";
+		import { ${list_action}URL } from "src/back/routes/urls.js";
+        import {tempstream} from "tempstream";
+		import type { FormDataValue } from "@sealcode/sealgen";
+		import type { CollectionInputWithAllKeys } from "sealious";
 `,
 
 		fields: `...${toPascalCase(collection_name)}FormFields`,
@@ -55,7 +34,7 @@ export async function editItemFormTemplate(
                 new Controls.FormHeader("Edit ${toPascalCase(
 					collection_name
 				)}"), 
-                ...${toPascalCase(collection_name)}FormControls`,
+                ...get${toPascalCase(collection_name)}FormControls()`,
 
 		can_access: `canAccess = async (ctx: Context) => {
 			 const policy = ${toPascalCase(collection_name)}.getPolicy("edit");
@@ -64,8 +43,8 @@ export async function editItemFormTemplate(
 		 };`,
 
 		onsubmit: `
-	     	async onSubmit(ctx: Context) {
-		        const data = await this.getParsedValues(ctx);
+	    async onSubmit(ctx: Context, formData: FormData) {
+				const fctx = this.makeFormControlContext(ctx, formData, true);
         	    const id = await this.getID(ctx);
 	            const {items: [item]} = await ctx.$app.collections["${toKebabCase(
 					collection_name
@@ -78,50 +57,37 @@ export async function editItemFormTemplate(
 					throw new Error("Unknown id: " + id);
 				}
 
-				if (!data) {
-					throw new Error("Error when parsing the form values");
-				}
 
-			   ${field_handler_results
-					.map((result) => result.pre_edit)
-					.filter((e) => e !== "")
-					.join("\n")}
-
-				item.setMultiple(
-					{
-						${field_handler_results
-							.filter((r) => !r.hide_sealious_value)
-							.map((result) => result.sealious_value(result))
-							.filter((e) => e != "")
-							.join(",\n")}
-					}
+				item.setMultipleExtraSafe(
+				{
+				${collection_fields
+					.map((field_info) =>
+						field_info.form_field.generateCreateValueGetter(
+							field_info,
+							{
+								form_field_types: "FormFieldTypes",
+								sealious_field: `${collectionVar}.fields${wrapAttribute(
+									field_info.name
+								)}`,
+								form_fields: "fields",
+							}
+						)
+					)
+					.join(",\n")}
+    				} as CollectionInputWithAllKeys<typeof ${collectionVar}>
 				);
+
                 await item.save(ctx.$context);
 
-                
-                ${
-					field_handler_results
-						.map((result) => result.post_edit)
-						.filter((e) => e != "").length
-						? `// #### POST-EDIT ACTIONS ############`
-						: ""
+				for(const field of Object.values(${formFieldsVar})){
+					await field.postSealiousEdit(ctx, item, formData)
 				}
-                 ${field_handler_results
-						.map((result) => result.post_edit)
-						.filter((e) => e != "")
-						.join("\n")}
 			}
 		`,
 
 		other_methods: `
             async getID(ctx: Context): Promise<string>{
-               // trying to automatically guess which param is the one that represents the ID
-               // of the resource to edit. 
-               // If sealgen got it wrong, just return the param name that should be used here instead
-               const param_name = 
-                         ${edit_action_name}URL.params
-                         .find(param => param.toLowerCase().includes("id")) 
-                     || ${edit_action_name}URL.params[0]
+               const param_name = "id";
 			   const id = ctx.params[param_name];
 	           if (!id) {
 				   throw new Error("Missing URL  parameter: " + param_name);
@@ -130,7 +96,7 @@ export async function editItemFormTemplate(
             }
         `,
 
-		get_initial_values: `async getInitialValues(ctx: Context) {
+		get_initial_values: `async getInitialValues(ctx: Context): Promise<{ [key in keyof typeof fields]: FormDataValue | undefined }>  {
                const id = await this.getID(ctx);
 
                const {
@@ -146,42 +112,15 @@ export async function editItemFormTemplate(
 			   }
 
 			   return {
-				   ${field_handler_results
-						.filter((r) => !r.hide_initial_value_edit)
-						.map(({ initial_value_edit, is_required, name }) => {
-							if (typeof initial_value_edit == "string") {
-								if (initial_value_edit == "") {
-									return "";
-								}
-								return `${name}: ${initial_value_edit}`;
-							}
 
-							const main_value = initial_value_edit.main_value;
-							if (!main_value) {
-								throw new Error(
-									"Missing main_value for initial_value_edit"
-								);
-							}
-							const { parsed_value, fallback_value } =
-								initial_value_edit;
-							if (is_required) {
-								return `${name}: ${parsed_value || main_value}`;
-							}
-							if (main_value && parsed_value && fallback_value) {
-								if (main_value == parsed_value) {
-									return `${name}: withFallback(${main_value}, ${fallback_value})`;
-								} else {
-									return `${name}: withFallback(${main_value}, ${parsed_value}, ${fallback_value})`;
-								}
-							} else {
-								console.error(initial_value_edit);
-								throw new Error(
-									"Missing field info for generating initial value"
-								);
-							}
+			   ${collection_fields
+					.map((field_info) =>
+						field_info.form_field.generateInitialValue(field_info, {
+							form_field_types: "FieldTypes",
+							form_fields: "fields",
 						})
-						.filter((e) => e.trim() !== "")
-						.join(",\n")}
+					)
+					.join(",\n")}
 			   };
 		   }
 	   `,

package/src/templates/shared/collection-list.ts

@@ -60,12 +60,12 @@ export function makeDefaultDisplayFields(
 				return `{
 					field: "${field.name}",
 					label: "${field.name}",
-					format: async (value: FilePointer) => {
-						return imageRouter.image(await value.getPath(), {
+					format: async (value: FilePointer|null) => {
+						return value ? imageRouter.image(await value.getPath(), {
 							container: { width: 45, height: 45 },
                             crop: { width: 45, height: 45 },
 							alt: "",
-						});
+					}): "";
 					},
 				}`;
 			}
@@ -118,7 +118,7 @@ import type { FlatTemplatable, Templatable } from "tempstream";
 import { TempstreamJSX, tempstream } from "tempstream";
 import { ${uppercase_collection} } from "src/back/collections/collections.js";
 import html from "src/back/html.js";
-import type { ListFilterRender } from "@sealcode/sealgen";
+import type { ListFilterRender, FormDisplayInfo } from "@sealcode/sealgen";
 import {
 	SealiousItemListPage,
 	BaseListPageFields,
@@ -131,26 +131,18 @@ ${field_import_string}
 
 export const actionName = "${action_name}";
 
-// eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-const filterFields = [
-     ${makeDefaultFilterFields(collection_fields)}
-] as {
-	field: keyof (typeof ${uppercase_collection})["fields"];
+const filterFields:{
+	field: keyof (typeof HasAllFields)["fields"];
 	render?: ListFilterRender;
-	prepareValue?: (filter_value: unknown)=>unknown; // set this function to change what filter value is passed to Sealious
-}[];
+	prepareValue?: (filter_value: unknown) => unknown; // set this function to change what filter value is passed to Sealious
+}[] = [
+     ${makeDefaultFilterFields(collection_fields)}
+];
 
 
-// eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-const displayFields = [
+const displayFields: FormDisplayInfo<typeof ${uppercase_collection}>[] = [
 ${makeDefaultDisplayFields(collection_fields)}
-] as {
-	field: string;
-	label: string;
-	format?: (value: unknown, item: CollectionItem<typeof ${toPascalCase(
-		collection_name
-	)}>) => FlatTemplatable;
-}[];
+];
 
 export default new (class ${action_name}Page extends SealiousItemListPage<
 	typeof ${uppercase_collection},

package/src/templates/shared/item-delete.ts

@@ -1,5 +1,4 @@
 import { toKebabCase, toPascalCase } from "js-convert-case";
-import { curryImportPath } from "../../utils/import-path.js";
 import { formatWithPrettier } from "../../utils/prettier.js";
 
 export function itemDeleteTemplate(

package/src/templates/shared/shared-crud-form-fields.ts

@@ -1,193 +1,59 @@
 import { toPascalCase } from "js-convert-case";
-import { extractCollectionClassname } from "../../generate-collections.js";
-import extract_fields_from_collection, {
-	ExtractedFieldInfo,
-} from "../../utils/extract-fields-from-collection.js";
-
 import _locreq from "locreq";
-import { curryImportPath } from "../../utils/import-path.js";
+import extract_fields_from_collection from "../../utils/extract-fields-from-collection.js";
 import { formatWithPrettier } from "../../utils/prettier.js";
-import { default_handler } from "./handlers/default.js";
-import { enum_handler } from "./handlers/enum.js";
-import { image_handler } from "./handlers/image.js";
-import { file_handler } from "./handlers/file.js";
-import { int_handler } from "./handlers/int.js";
-import { boolean_handler } from "./handlers/boolean.js";
-import { jdd_handler } from "./handlers/jdd.js";
-import { date_handler } from "./handlers/date.js";
-import { deep_reverse_single_reference_handler } from "./handlers/deep-reverse-single-reference.js";
-import { structured_array_handler } from "./handlers/structured-array.js";
-import { single_reference_handler } from "./handlers/single-reference.js";
-const target_locreq = _locreq(process.cwd());
-
-export type FieldHandlerResult = {
-	imports: Partial<{ shared: string; edit: string }>;
-	hide_field: boolean;
-	field: string;
-	hide_control: boolean;
-	controls: string;
-	is_required: boolean;
-	is_required_expr: string;
-	fields_var: string;
-	top_level_shared: string;
-	name: string;
-	hide_initial_value_edit: boolean;
-	initial_value_edit:
-		| Partial<{
-				main_value: string;
-				parsed_value: string;
-				fallback_value: string;
-		  }>
-		| string;
-	hide_initial_value_create: boolean;
-	initial_value_create: string;
-	pre_edit: string;
-	post_edit: string;
-	pre_create: string;
-	post_create: string;
-	sealious_value: (
-		result: Exclude<FieldHandlerResult, "sealious_value">
-	) => string;
-	hide_sealious_value: boolean;
-	fallback_value_sealious: string;
-	main_value_sealious: string;
-};
-
-export type FieldHandler<
-	Defaults extends Partial<FieldHandlerResult>,
-	Result extends Partial<FieldHandlerResult>
-> = (
-	collection_name: string,
-	field: ExtractedFieldInfo,
-	importPath: (path: string) => string,
-	defaults: Defaults,
-	all_other_handlers: Record<
-		string,
-		| FieldHandler<FieldHandlerResult, Partial<FieldHandlerResult>>
-		| undefined
-	>,
-	fields_var?: string
-) => Promise<Result>;
-
-export const field_handlers: Record<
-	Exclude<string, "default">,
-	FieldHandler<FieldHandlerResult, Partial<FieldHandlerResult>> | undefined
-> & {
-	default: FieldHandler<Record<string, never>, FieldHandlerResult>;
-} = {
-	// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-explicit-any
-	default: default_handler as any,
-	enum: enum_handler,
-	image: image_handler,
-	file: file_handler,
-	int: int_handler,
-	boolean: boolean_handler,
-	jdd: jdd_handler,
-	date: date_handler,
-	"deep-reverse-single-reference": deep_reverse_single_reference_handler,
-	"structured-array": structured_array_handler,
-	"single-reference": single_reference_handler,
-};
-
-export async function getFieldHandler(
-	collection_name: string,
-	field: ExtractedFieldInfo,
-	importPath: (path: string) => string,
-	fields_var?: string
-) {
-	const defaults = await field_handlers.default(
-		collection_name,
-		field,
-		importPath,
-		{},
-		field_handlers,
-		fields_var
-	);
-
-	const result = {
-		...defaults,
-		...((await field_handlers[field.type]?.(
-			collection_name,
-			field,
-			importPath,
-			defaults,
-			field_handlers,
-			fields_var
-		)) || {}),
-	};
-	const result_initial_value_edit = result.initial_value_edit;
-	// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-	result.initial_value_edit =
-		typeof result_initial_value_edit == "string"
-			? result_initial_value_edit
-			: {
-					// eslint-disable-next-line @typescript-eslint/no-explicit-any
-					...(defaults.initial_value_edit as any),
-					...result_initial_value_edit,
-			  };
-	return result;
-}
+import { wrapAttribute } from "../../utils/wrap-attributes.js";
 
 export async function sharedCrudFormFields(
 	collection_name: string,
 	newfilefullpath: string
 ) {
-	const [uppercase_collection, collection_fields] = await Promise.all([
-		extractCollectionClassname(
-			target_locreq.resolve(
-				"src/back/collections/" + collection_name + ".ts"
-			)
-		),
-		extract_fields_from_collection(collection_name),
-	]);
-	const importPath = curryImportPath(newfilefullpath);
-
-	const field_handler_results = await Promise.all(
-		collection_fields.map(async (field) => {
-			return getFieldHandler(collection_name, field, importPath);
-		})
+	const collection_fields = await extract_fields_from_collection(
+		collection_name
 	);
 
-	const result = `import { Controls, Fields } from "@sealcode/sealgen";
-import { ${uppercase_collection} } from "${importPath(
-		"src/back/collections/collections.js"
-	)}";
+	const uppercase_collection = toPascalCase(collection_name);
 
+	const result = `import { Controls, Fields } from "@sealcode/sealgen";
+import { ${uppercase_collection} } from "src/back/collections/collections.js";
 ${Array.from(
 	new Set(
-		field_handler_results
-			.filter(
-				({ hide_field, hide_control }) => !hide_field && !hide_control
+		collection_fields
+			.map((field_info) =>
+				field_info.form_field.generateImportsForFieldList(field_info)
 			)
-			.map(({ imports }) => imports.shared || "")
-	)
-).join("\n")}
-
-
-
-export const ${toPascalCase(collection_name)}FormFields = <const>
-{
-	${field_handler_results
-		.filter(({ hide_field }) => !hide_field)
-		.map(({ field }) => field)
-		.filter((e) => e != "")
+			.flat()
+			.map(
+				({ what, from, as }) =>
+					`import {${what}${as ? ` as ${as}` : ""} } from "${from}"`
+			)
+	).values()
+).join(";\n")}
+
+export const ${toPascalCase(collection_name)}FormFields = <const>{
+	${collection_fields
+		.map((field_info) => {
+			return `${
+				field_info.name
+			}: ${field_info.form_field.generateFieldDeclaration(field_info, {
+				form_field_types: "Fields",
+				sealious_field: `${uppercase_collection}.fields${wrapAttribute(
+					field_info.name
+				)}`,
+			})}`;
+		})
 		.join(",\n")}
 };
 
-export const ${toPascalCase(collection_name)}FormControls = [
-	${field_handler_results
-		.filter(({ hide_control }) => !hide_control)
-		.map(({ controls }) => controls)
-		.filter((e) => e != "")
+const fields = ${toPascalCase(collection_name)}FormFields 
+
+export const get${toPascalCase(
+		collection_name
+	)}FormControls: () => Controls.FormControl[] = () => [
+	${collection_fields
+		.map(({ name }) => `fields${wrapAttribute(name)}.getControl()`)
 		.join(",\n")}
 ];
-
-${Array.from(
-	new Set(
-		field_handler_results.map(({ top_level_shared }) => top_level_shared)
-	)
-).join("\n")}
-
 `;
 	return formatWithPrettier(result);
 }

package/src/test_utils/test-on-real-app.ts

@@ -15,7 +15,9 @@ const locreq = _locreq(module_dirname(import.meta.url));
 
 export const callSealgenBin = () => `node ${locreq.resolve("lib/cli.js")}`;
 
-const sealious_minimal_commit = "833e70c";
+const sealious_minimal_url =
+	"https://hub.sealcode.org/source/sealious-minimal.git";
+const sealious_minimal_commit = "77e3794";
 
 export class RealAppTest {
 	public node_pid: number;
@@ -33,7 +35,7 @@ export class RealAppTest {
 		test_app.container_name = `sealgen-test-mongo-${timestamp}`;
 		console.log("\tcloning sealious-minimal...");
 		await execAsync(
-			`git clone https://hub.sealcode.org/source/sealious-minimal.git ${test_app.app_path} && cd ${test_app.app_path} && git checkout ${sealious_minimal_commit}`
+			`git clone ${sealious_minimal_url} ${test_app.app_path} && cd ${test_app.app_path} && git checkout ${sealious_minimal_commit}`
 		);
 		console.log("\tinstalling dependencies and sealgen...");
 		await execAsync(
@@ -160,7 +162,6 @@ export class RealAppTest {
 		path: string,
 		body: Record<string, unknown>
 	): Promise<{ status: number; response: string }> {
-		console.debug("POST", path, body);
 		return this.throwIfItKillsTheApp(async () => {
 			const ret = await fetch(
 				`http://localhost:${this.app_port}${path}`,

package/src/utils/extract-fields-from-collection.ts

@@ -3,6 +3,8 @@ import { exec } from "./utils.js";
 const target_locreq = _locreq(process.cwd());
 import { promises as fs } from "fs";
 import { is, predicates } from "@sealcode/ts-predicates";
+import { FormField } from "../forms/fields/field.js";
+import { sealiousFieldInfoToFormField } from "../forms/fields/get-field-for-sealious.js";
 
 export type ExtractedFieldInfo = {
 	name: string;
@@ -16,6 +18,10 @@ export type ExtractedFieldInfo = {
 	subfields: { name: string }[];
 };
 
+export type ExtractedFieldInfoWithFormField = ExtractedFieldInfo & {
+	form_field: FormField;
+};
+
 const counter = (function* () {
 	let i = 0;
 	while (true) {
@@ -23,11 +29,19 @@ const counter = (function* () {
 	}
 })();
 
+const cache = {} as Record<
+	string,
+	Promise<ExtractedFieldInfoWithFormField[]> | undefined
+>;
+
 export default async function extract_fields_from_collection(
 	collection_name: string
-): Promise<ExtractedFieldInfo[]> {
+): Promise<ExtractedFieldInfoWithFormField[]> {
+	if (cache[collection_name]) {
+		return cache[collection_name];
+	}
 	const extractor_code = `import {default as the_app} from "./app.js";
-const c = new the_app().collections["${collection_name}"];
+	const c = new the_app({}).collections["${collection_name}"];
 const fields = [];
 for (const field_name in c.fields){
     let field = c.fields[field_name];
@@ -37,14 +51,17 @@ for (const field_name in c.fields){
     let referencing_field = null;
     let intermediary_field_that_points_there = null;
     let is_readonly = false;
-    let is_required = field.required;
+    let is_required = field.required || false;
     let subfields = [];
-    if(["derived-value", "cached-value", "settable-by"].includes(type)){
+    if(["derived-value", "cached-value", "settable-by",  "control-access"].includes(type)){
 	    type = field.virtual_field.typeName;
     }
     if(["derived-value", "cached-value", "reverse-single-reference"].includes(field.typeName)){
 	    is_readonly = true;
     }
+    if(type == "single-reference"){
+		target = field.target_collection;
+    }
     if(type == "deep-reverse-single-reference" || type =="reverse-single-reference"){
 		target = field.target_collection;
         referencing_collection = field.referencing_collection;
@@ -62,25 +79,59 @@ for (const field_name in c.fields){
 		`dist/back/___extract_fields--${counter.next().value || 0}.js`
 	);
 	await fs.writeFile(extractor_code_path, extractor_code);
-	const { stdout } = await exec("node", [extractor_code_path]);
-	await fs.unlink(extractor_code_path);
-	const ret = JSON.parse(stdout) as unknown;
-	if (
-		!is(
-			ret,
-			predicates.array(
-				predicates.shape({
-					name: predicates.string,
-					type: predicates.string,
-					is_readonly: predicates.boolean,
-				})
-			)
-		)
-	) {
-		throw new Error(
-			"Encountered a problem while extracting the names of fields from collection. Got: " +
-				stdout
-		);
-	}
-	return ret as ExtractedFieldInfo[];
+	const result = exec("node", [extractor_code_path])
+		.then(async ({ stdout }) => {
+			await fs.unlink(extractor_code_path);
+			const ret = JSON.parse(stdout) as unknown;
+			if (
+				!is(
+					ret,
+					predicates.array(
+						predicates.shape({
+							name: predicates.string,
+							type: predicates.string,
+							is_readonly: predicates.boolean,
+							target: predicates.or(
+								predicates.string,
+								predicates.null
+							),
+							referencing_collection: predicates.or(
+								predicates.string,
+								predicates.null
+							),
+							referencing_field: predicates.or(
+								predicates.string,
+								predicates.null
+							),
+							is_required: predicates.boolean,
+							intermediary_field_that_points_there: predicates.or(
+								predicates.string,
+								predicates.null
+							),
+							subfields: predicates.array(
+								predicates.shape({ name: predicates.string })
+							),
+						})
+					)
+				)
+			) {
+				throw new Error(
+					"Encountered a problem while extracting the names of fields from collection. Got: " +
+						stdout
+				);
+			}
+			const result = (await Promise.all(
+				ret.map(async (field_info) => ({
+					...field_info,
+					form_field: await sealiousFieldInfoToFormField(field_info),
+				}))
+			)) as ExtractedFieldInfoWithFormField[];
+			return result;
+		})
+		.catch((e) => {
+			console.error("ERROR", e);
+			process.exit(1);
+		});
+	cache[collection_name] = result;
+	return result;
 }

package/src/utils/make-slug.ts

@@ -1,5 +1,5 @@
 export function makeSlug(t: string) {
 	return t
-		.replaceAll(/\P{General_Category=Letter}/g, "-")
+		.replaceAll(/\P{General_Category=Letter}/gu, "-")
 		.replaceAll(/-+/g, "-");
 }