@sealcode/sealgen 0.18.8 → 0.19.0

package/lib/page/mountable-with-fields.js

@@ -13,14 +13,15 @@ class MountableWithFields extends Mountable {
       this.fields = {};
   }
   init() {
-    for (const [name, field] of Object.entries(this.fields)) {
-      void field.init(name);
+    for (const [field_name, field] of Object.entries(this.fields)) {
+      void field.init();
+      field.setName(field_name);
     }
   }
   makeFormControlContext(ctx, data, validate, field_name_prefix = this.field_names_prefix, form_id = this.form_id) {
     return new FormControlContext(
       ctx,
-      data.raw_values,
+      data,
       data.messages,
       field_name_prefix,
       form_id,
@@ -44,10 +45,13 @@ class MountableWithFields extends Mountable {
     await Promise.all(
       Object.keys(this.fields).map(async (key) => {
         const field = this.fields[key];
-        const { valid: fieldvalid, message: fieldmessage } = await field.getValue(ctx, values, true);
+        const { valid: fieldvalid, message: fieldmessage } = await field.getParsedValue(ctx, values, true);
         if (!fieldvalid) {
           valid = false;
-          field_errors[field.name] = fieldmessage;
+          field_errors[field.name] = {
+            type: "error",
+            message: fieldmessage
+          };
         }
       })
     );
@@ -81,7 +85,11 @@ class MountableWithFields extends Mountable {
     const result = {};
     const promises = Object.entries(this.fields).map(
       async ([key, field]) => {
-        const { parsed } = await field.getValue(ctx, raw_values, false);
+        const { parsed } = await field.getParsedValue(
+          ctx,
+          raw_values,
+          false
+        );
         result[key] = parsed;
       }
     );

package/lib/page/mountable-with-fields.test.js

@@ -17,7 +17,7 @@ describe("mountable-with-fields", () => {
         const data = await this.getParsedValues(ctx);
         data.not_required?.trim();
         data.required.trim();
-        const { parsed: data2 } = await this.fields.not_required.getValue(
+        const { parsed: data2 } = await this.fields.not_required.getParsedValue(
           ctx,
           form_values.raw_values
         );

package/lib/templates/form.js

@@ -1,12 +1,10 @@
-import Prettier from "prettier";
-import { curryImportPath } from "../utils/import-path.js";
-import { getPrettierConfig } from "../utils/prettier.js";
+import { formatWithPrettier } from "../utils/prettier.js";
 const defaults = {
   postimport: `
          import { Fields } from "@sealcode/sealgen";
          import type {FormDataValue} from "@sealcode/sealgen";`,
   fields: `
-           password: new Fields.SimpleFormField(true),`,
+           password: new Fields.Password(true),`,
   controls: `
 		new Controls.SimpleInput(fields.password, {
 			label: "Password:",
@@ -17,8 +15,8 @@ const defaults = {
 		data: Record<string, FormDataValue>
 	): Promise<{ valid: boolean; error: string }> {
 		// just a silly example, please remove this with better logic
-		const { parsed: email } = await this.fields.email.getValue(ctx, data);
-		const { parsed: password } = await this.fields.password.getValue(ctx, data);
+		const { parsed: email } = await this.fields.email.getParsedValue(ctx, data);
+		const { parsed: password } = await this.fields.password.getParsedValue(ctx, data);
 		// eslint-disable-next-line @typescript-eslint/consistent-type-assertions
 		if ((password || "").length > ((email as string) || "").length) {
 			return { valid: false, error: "Password cannot be longer than email" };
@@ -43,11 +41,10 @@ const defaults = {
 };
 async function formTemplate(action_name, newfilefullpath, _params = defaults) {
   const params = { ...defaults, ..._params };
-  const rel = curryImportPath(newfilefullpath);
   const content = `import type { Context } from "koa";
 import type { FormData } from "@sealcode/sealgen";
 import { Form,  Controls, fieldsToShape } from "@sealcode/sealgen";
-import html from "${rel("src/back/html.js")}";
+import html from "src/back/html.js";
 
 ${params.postimport}
 
@@ -57,6 +54,8 @@ const fields = {
     ${params.fields}
 };
 
+Form.initFieldNames(fields);
+
 export const ${action_name}Shape = fieldsToShape(fields);
 
 export default new (class ${action_name}Form extends Form<typeof fields, void> {
@@ -78,7 +77,7 @@ export default new (class ${action_name}Form extends Form<typeof fields, void> {
    ${params.render}
 })();
 `;
-  return Prettier.format(content, await getPrettierConfig());
+  return formatWithPrettier(content);
 }
 export {
   formTemplate

package/lib/templates/multiform.js

@@ -9,8 +9,8 @@ import { FlatTemplatable } from "tempstream";
 export const actionName = "${action_name}";
 
 const fields1 = {
-	email: new Fields.SimpleFormField(true),
-	password: new Fields.SimpleFormField(true),
+	email: new Fields.TextBasedSimpleField(true),
+	password: new Fields.TextBasedSimpleField(true),
 };
 
 const form1 = new (class extends Form<typeof fields1, unknown> {
@@ -26,8 +26,8 @@ const form1 = new (class extends Form<typeof fields1, unknown> {
 })();
 
 const fields2 = {
-	name: new Fields.SimpleFormField(true),
-	surname: new Fields.SimpleFormField(true),
+	name: new Fields.TextBasedSimpleField(true),
+	surname: new Fields.TextBasedSimpleField(true),
 };
 
 const form2 = new (class extends Form<typeof fields2, unknown> {

package/lib/templates/page.js

@@ -1,6 +1,4 @@
-import { curryImportPath } from "../utils/import-path.js";
 async function pageTemplate(action_name, newfilefullpath) {
-  const rel = curryImportPath(newfilefullpath);
   return `import type { Context } from "koa";
 import { TempstreamJSX } from "tempstream";
 import { Page } from "@sealcode/sealgen";

package/lib/templates/shared/collection-create-form.js

@@ -1,70 +1,58 @@
 import { toKebabCase, toPascalCase } from "js-convert-case";
 import { formTemplate } from "../form.js";
-import { curryImportPath } from "../../utils/import-path.js";
 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";
 async function createItemFormTemplate(create_action_name, newfilefullpath, collection_name, list_action) {
   const collection_fields = await extract_fields_from_collection(
     collection_name
   );
-  const importPath = curryImportPath(newfilefullpath);
-  const field_handler_results = await Promise.all(
-    collection_fields.map(
-      (field) => getFieldHandler(collection_name, field, importPath)
-    )
-  );
-  const post_create_actions = field_handler_results.map(({ post_create }) => post_create).filter((e) => e != "");
+  const formFieldsVar = `${toPascalCase(collection_name)}FormFields`;
   return formTemplate(create_action_name, newfilefullpath, {
     success_message: "Created!",
-    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 } from "${importPath("src/back/routes/urls.js")}";
+        import { ${toPascalCase(
+      collection_name
+    )} } from "src/back/collections/collections.js";
 
-        import {tempstream} from "tempstream";
+		import { ${list_action}URL } from "src/back/routes/urls.js";
+		import {tempstream} from "tempstream";
 `,
     fields: `...${toPascalCase(collection_name)}FormFields`,
     controls: `
                 new Controls.FormHeader("Create ${toPascalCase(
       collection_name
     )}"), 
-                ...${toPascalCase(collection_name)}FormControls`,
+                ...get${toPascalCase(collection_name)}FormControls()`,
     can_access: `canAccess = async (ctx: Context) => {
 			 const policy = ${toPascalCase(collection_name)}.getPolicy("create");
 			 const response = await policy.check(ctx.$context);
 			 return { canAccess: response?.allowed || false, message: response?.reason || "" };
 		 };`,
-    get_initial_values: field_handler_results.filter((r) => !r.hide_initial_value_create).map(({ initial_value_create }) => initial_value_create).filter((e) => e != "").length ? `getInitialValues(ctx: Context){
-                   return {
-                        ${field_handler_results.filter((r) => !r.hide_initial_value_create).map(
-      ({ initial_value_create }) => initial_value_create
-    ).join(",\n")}
-                   }
-}` : ``,
+    get_initial_values: "",
     onsubmit: `
-	async onSubmit(ctx: Context) {
-		const data = await this.getParsedValues(ctx);
-		if (!data) {
-			throw new Error("Error when parsing the form values");
-		}
+	async onSubmit(ctx: Context, formData: FormData) {
+		const fctx = this.makeFormControlContext(ctx, formData, true);
 
-	   ${field_handler_results.map(({ pre_create }) => pre_create).filter((e) => e !== "").join("\n")}
-
-		${post_create_actions.length ? `const created = ` : ""} await ctx.$app.collections["${toKebabCase(collection_name)}"].create(
+		const created =  await ctx.$app.collections["${toKebabCase(
+      collection_name
+    )}"].createExtraSafe(
 			ctx.$context,
-			{
-			      ${field_handler_results.filter((result) => !result.hide_sealious_value).map((result) => result.sealious_value(result)).filter((e) => e != "").join(",\n")}
-			} 
-		);
-        ${post_create_actions.length ? `/* ==== POST CREATE ACTIONS ==== */` : ""}
-        ${post_create_actions.join("\n")}
+		{
+		${collection_fields.map(
+      (field_info) => field_info.form_field.generateCreateValueGetter(field_info, {
+        form_field_types: formFieldsVar,
+        sealious_field: `fields${wrapAttribute(field_info.name)}`,
+        form_fields: "fields"
+      })
+    ).join(",\n")} 
+			});
+
+    	for(const field of Object.values(${formFieldsVar})){
+            await field.postSealiousCreate(ctx, created, formData)
+        }
 	}
 `,
     render: `	async render(ctx: Context, data: FormData, show_field_errors: boolean) {

package/lib/templates/shared/collection-edit-form.js

@@ -1,53 +1,38 @@
 import { toKebabCase, toPascalCase } from "js-convert-case";
 import { formTemplate } from "../form.js";
-import { curryImportPath } from "../../utils/import-path.js";
 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";
 async function editItemFormTemplate(edit_action_name, newfilefullpath, collection_name, list_action) {
   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`,
     controls: `
                 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");
 			 const response = await policy.check(ctx.$context);
 			 return { canAccess: response?.allowed || false, message: response?.reason || "" };
 		 };`,
     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
@@ -60,33 +45,34 @@ async function editItemFormTemplate(edit_action_name, newfilefullpath, collectio
 					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 ############` : ""}
-                 ${field_handler_results.map((result) => result.post_edit).filter((e) => e != "").join("\n")}
+				for(const field of Object.values(${formFieldsVar})){
+					await field.postSealiousEdit(ctx, item, formData)
+				}
 			}
 		`,
     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);
@@ -94,7 +80,7 @@ async function editItemFormTemplate(edit_action_name, newfilefullpath, collectio
                return id
             }
         `,
-    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 {
@@ -110,36 +96,13 @@ async function editItemFormTemplate(edit_action_name, newfilefullpath, collectio
 			   }
 
 			   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"
-        );
-      }
-    }).filter((e) => e.trim() !== "").join(",\n")}
+
+			   ${collection_fields.map(
+      (field_info) => field_info.form_field.generateInitialValue(field_info, {
+        form_field_types: "FieldTypes",
+        form_fields: "fields"
+      })
+    ).join(",\n")}
 			   };
 		   }
 	   `,

package/lib/templates/shared/collection-list.js

@@ -44,12 +44,12 @@ function makeDefaultDisplayFields(collection_fields) {
       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: "",
-						});
+					}): "";
 					},
 				}`;
     }
@@ -91,7 +91,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,
@@ -104,26 +104,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/lib/templates/shared/shared-crud-form-fields.js

@@ -1,114 +1,46 @@
 import { toPascalCase } from "js-convert-case";
-import { extractCollectionClassname } from "../../generate-collections.js";
 import extract_fields_from_collection from "../../utils/extract-fields-from-collection.js";
-import _locreq from "locreq";
-import { curryImportPath } from "../../utils/import-path.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());
-const field_handlers = {
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-explicit-any
-  default: default_handler,
-  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
-};
-async function getFieldHandler(collection_name, field, importPath, fields_var) {
-  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;
-  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,
-    ...result_initial_value_edit
-  };
-  return result;
-}
+import { wrapAttribute } from "../../utils/wrap-attributes.js";
 async function sharedCrudFormFields(collection_name, newfilefullpath) {
-  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 uppercase_collection = toPascalCase(collection_name);
   const result = `import { Controls, Fields } from "@sealcode/sealgen";
-import { ${uppercase_collection} } from "${importPath(
-    "src/back/collections/collections.js"
-  )}";
-
+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
-      ).map(({ imports }) => imports.shared || "")
-    )
-  ).join("\n")}
-
-
+      collection_fields.map(
+        (field_info) => field_info.form_field.generateImportsForFieldList(field_info)
+      ).flat().map(
+        ({ what, from, as }) => `import {${what}${as ? ` as ${as}` : ""} } from "${from}"`
+      )
+    ).values()
+  ).join(";\n")}
 
-export const ${toPascalCase(collection_name)}FormFields = <const>
-{
-	${field_handler_results.filter(({ hide_field }) => !hide_field).map(({ field }) => field).filter((e) => e != "").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 != "").join(",\n")}
-];
-
-${Array.from(
-    new Set(
-      field_handler_results.map(({ top_level_shared }) => top_level_shared)
-    )
-  ).join("\n")}
+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")}
+];
 `;
   return formatWithPrettier(result);
 }
 export {
-  field_handlers,
-  getFieldHandler,
   sharedCrudFormFields
 };
 //# sourceMappingURL=shared-crud-form-fields.js.map

package/lib/test_utils/test-on-real-app.js

@@ -10,7 +10,8 @@ import { module_dirname } from "../utils/module-dirname.js";
 import EventEmitter from "events";
 const locreq = _locreq(module_dirname(import.meta.url));
 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";
 class RealAppTest {
   constructor() {
     this.emitter = new EventEmitter();
@@ -23,7 +24,7 @@ class RealAppTest {
     test_app.container_name = `sealgen-test-mongo-${timestamp}`;
     console.log("	cloning 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("	installing dependencies and sealgen...");
     await execAsync(
@@ -135,7 +136,6 @@ class RealAppTest {
     });
   }
   async httpPOST(path2, body) {
-    console.debug("POST", path2, body);
     return this.throwIfItKillsTheApp(async () => {
       const ret = await fetch(
         `http://localhost:${this.app_port}${path2}`,