@sealcode/sealgen 0.18.10 → 0.19.0

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}`,

package/lib/utils/extract-fields-from-collection.js

@@ -3,15 +3,20 @@ 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 { sealiousFieldInfoToFormField } from "../forms/fields/get-field-for-sealious.js";
 const counter = function* () {
   let i = 0;
   while (true) {
     yield i++;
   }
 }();
+const cache = {};
 async function extract_fields_from_collection(collection_name) {
+  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];
@@ -21,14 +26,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;
@@ -46,24 +54,56 @@ 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);
-  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
+  const result = exec("node", [extractor_code_path]).then(async ({ stdout }) => {
+    await fs.unlink(extractor_code_path);
+    const ret = JSON.parse(stdout);
+    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 result2 = await Promise.all(
+      ret.map(async (field_info) => ({
+        ...field_info,
+        form_field: await sealiousFieldInfoToFormField(field_info)
+      }))
     );
-  }
-  return ret;
+    return result2;
+  }).catch((e) => {
+    console.error("ERROR", e);
+    process.exit(1);
+  });
+  cache[collection_name] = result;
+  return result;
 }
 export {
   extract_fields_from_collection as default

package/lib/utils/make-slug.js

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

package/lib/utils/wrap-attributes.js

@@ -0,0 +1,20 @@
+function needsQuotes(str) {
+  try {
+    new Function(`var obj = { ${str}: 1 };`);
+    return false;
+  } catch {
+    return true;
+  }
+}
+function wrapAttribute(name) {
+  return needsQuotes(name) ? `["${name}"]` : `.${name}`;
+}
+function wrapKeyName(name) {
+  return needsQuotes(name) ? `["${name}"]` : `${name}`;
+}
+export {
+  needsQuotes,
+  wrapAttribute,
+  wrapKeyName
+};
+//# sourceMappingURL=wrap-attributes.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@sealcode/sealgen",
-	"version": "0.18.10",
+	"version": "0.19.0",
 	"description": "Module to automate adding routes and collections to a sealious application",
 	"main": "lib/index.js",
 	"type": "module",
@@ -55,7 +55,7 @@
 		"playwright": "^1.29.2",
 		"source-map-support": "^0.5.21",
 		"ts-node": "^10.9.1",
-		"typescript": "^4.7",
+		"typescript": "5.9",
 		"wait-port": "^1.0.4"
 	},
 	"types": "./@types/index.d.ts",
@@ -90,6 +90,7 @@
 	"peerDependencies": {
 		"koa": "^2.13.0",
 		"koa-responsive-image-router": "^0.2.24",
-		"sealious": "^0.21"
+		"sealious": "^0.21",
+		"stimulus": "^3.2.2"
 	}
 }