@sealcode/sealgen 0.18.10 → 0.19.2

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

@@ -1,70 +1,57 @@
 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 != "");
-  return formTemplate(create_action_name, newfilefullpath, {
+  const collection_fields = await extract_fields_from_collection(collection_name);
+  const formFieldsVar = `${toPascalCase(collection_name)}FormFields`;
+  return formTemplate(create_action_name, {
     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");
-		}
-
-	   ${field_handler_results.map(({ pre_create }) => pre_create).filter((e) => e !== "").join("\n")}
+	async onSubmit(ctx: Context, formData: FormData) {
+		const fctx = this.makeFormControlContext(ctx, formData, true);
 
-		${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})){
+			// eslint-disable-next-line no-await-in-loop
+            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,36 @@
 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);
-    })
-  );
-  return formTemplate(edit_action_name, newfilefullpath, {
+  const collection_fields = await extract_fields_from_collection(collection_name);
+  const formFieldsVar = `${toPascalCase(collection_name)}FormFields`;
+  const collectionVar = `${toPascalCase(collection_name)}`;
+  return formTemplate(edit_action_name, {
     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 +43,35 @@ 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})){
+				    // eslint-disable-next-line no-await-in-loop
+				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 +79,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 +95,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 ${uppercase_collection})["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},
@@ -188,7 +180,7 @@ export default new (class ${action_name}Page extends SealiousItemListPage<
 		ctx: Context,
 		fields: { field: string; label?: string }[]
 	): FlatTemplatable {
-		return tempstream/* HTML */ \`<thead>
+		return tempstream /* HTML */ \`<thead>
 			<tr>
 				\${fields.map(({ label, field }) => this.renderHeading(ctx, field, label))}
 				<th>Actions</th>

package/lib/templates/shared/shared-crud-form-fields.js

@@ -1,114 +1,44 @@
 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;
-}
-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 result = `import { Controls, Fields } from "@sealcode/sealgen";
-import { ${uppercase_collection} } from "${importPath(
-    "src/back/collections/collections.js"
-  )}";
-
+import { wrapAttribute } from "../../utils/wrap-attributes.js";
+async function sharedCrudFormFields(collection_name) {
+  const collection_fields = await extract_fields_from_collection(collection_name);
+  const uppercase_collection = toPascalCase(collection_name);
+  const result = `import { type 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
-      ).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/exec_async.js

@@ -2,12 +2,12 @@ import { exec } from "child_process";
 const execAsync = (cmd) => {
   return new Promise((resolve, reject) => {
     const process = exec(cmd);
-    console.log("EXECUTING", cmd);
+    console.info("EXECUTING", cmd);
     process?.stdout?.on("data", (data) => {
-      console.log(`stdout: ${data}`);
+      console.info(`stdout: ${data}`);
     });
     process?.stderr?.on("data", (data) => {
-      console.log(`stdout: ${data}`);
+      console.info(`stdout: ${data}`);
     });
     process.on("exit", (code) => {
       if (code == 0) {

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();
@@ -21,15 +22,15 @@ class RealAppTest {
     const timestamp = Date.now();
     test_app.app_path = `/tmp/sealious-minimal-${timestamp}`;
     test_app.container_name = `sealgen-test-mongo-${timestamp}`;
-    console.log("	cloning sealious-minimal...");
+    console.info("	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...");
+    console.info("	installing dependencies and sealgen...");
     await execAsync(
       `cd ${test_app.app_path} && npm ci rm -rf node_modules/@sealcode/sealgen && ln -s $OLDPWD node_modules/@sealcode/sealgen && ${callSealgenBin()} make-env`
     );
-    console.log(
+    console.info(
       "	starting the database...(if timeouts here, run 'docker pull mongo:4.4-bionic' to solve)"
     );
     await test_app.runSealgenCommand("build");
@@ -47,7 +48,7 @@ class RealAppTest {
       SEALIOUS_PORT: this.app_port.toString()
     };
     const node_args = [`${this.app_path}/dist/back/index.js`];
-    console.log(
+    console.info(
       "EXECUTING APP",
       `${Object.entries(env).map(([key, value]) => `${key}=${value}`).join(" ")} node ${node_args.join(" ")}`
     );
@@ -56,9 +57,9 @@ class RealAppTest {
     });
     app_start.stdout.on(
       "data",
-      (data) => console.log("APP OUTPUT:", data.toString())
+      (data) => console.info("APP OUTPUT:", data.toString())
     );
-    app_start.stderr.on("data", (data) => console.log(data.toString()));
+    app_start.stderr.on("data", (data) => console.info(data.toString()));
     app_start.on("exit", (code) => {
       this.emitter.emit("exit", code);
       this.emitter.emit("process_error");
@@ -72,7 +73,7 @@ class RealAppTest {
       output: "silent",
       timeout: 6e3
     });
-    console.log(
+    console.info(
       chalk.yellow(
         `App is listening on http://localhost:${this.app_port}`
       )
@@ -82,7 +83,7 @@ class RealAppTest {
     try {
       if (this.node_pid != 0)
         await execAsync(`kill -9 ${this.node_pid}`);
-    } catch (error) {
+    } catch (_error) {
       throw new Error(
         "node process exited unexpectedly, please inspect the output"
       );
@@ -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}`,
@@ -147,13 +147,11 @@ class RealAppTest {
       );
       const status = ret.status;
       const response = await ret.text();
-      console.debug("request done!");
-      console.debug({ response });
       return { status, response };
     });
   }
   async addFile(target_path, content) {
-    console.log(
+    console.info(
       chalk.yellow("Inserting file at path"),
       chalk.green(target_path),
       "with content\n",