@sealcode/sealgen 0.15.35 → 0.15.36

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

@@ -1,109 +1,37 @@
-import { toCamelCase, toKebabCase, toPascalCase } from "js-convert-case";
+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 { renderFieldForSealious } from "./collection-create-form.js";
-function renderFieldForInitialValues({
-  name,
-  type,
-  is_required,
-  is_readonly
-}) {
-  if (type == "deep-reverse-single-reference") {
-    return `${name}: Object.fromEntries((item.get("${name}") || []).map(id=>[id, "on"]))`;
-  }
-  if (type == "jdd" || is_readonly) {
-    return "";
-  }
-  if (type == "image" || type == "file") {
-    return `${name}: {old: item.get("${name}")}`;
-  }
-  let fallback_value = `""`;
-  let main_value = `item.get("${name}")`;
-  if (type == "boolean") {
-    fallback_value = `"false"`;
-    main_value = `String(item.get("${name}"))`;
-  }
-  if (is_required) {
-    return `${name}: ${main_value}`;
-  } else {
-    return `${name}: ${main_value} || ${fallback_value}`;
-  }
-}
-function renderFieldPreEditAction({ name, type }) {
-  if (type == "image" || type == "file") {
-    const tempname = toCamelCase("prepared-" + name);
-    return `const ${tempname} = data.${name}.new || data.${name}.old;
-				if(!${tempname}){
-				    throw new Error("Missing field: ${name}")
-         		}`;
-  }
-  return "";
-}
-function renderFieldPostEditAction({
-  name,
-  type,
-  referencing_collection,
-  referencing_field,
-  intermediary_field_that_points_there
-}) {
-  if (type == "deep-reverse-single-reference" && referencing_collection && referencing_field && intermediary_field_that_points_there) {
-    return `{
-            const item_id = await this.getID(ctx);
-	    	// First, we remove links refering to current item
-            const {items:to_delete} = (await ctx.$app.collections["${referencing_collection}"]
-                    .list(ctx.$context)
-                    .filter({"${referencing_field}": item_id})
-                    .fetch()
-            )
-			await Promise.all(
-				to_delete.map((item) => item.remove(ctx.$context))
-			);
-
-            // Then, we iterate over all selected values and insert appropriate entries for the ${name} relation
-			const ids = Object.entries(
-                           // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-                           data.${name} as unknown as Record<string, string>
-                        )
-                        .filter(([, value]) => value === "on")
-                        .map(([key]) => key);
-
-			const promises = ids.map(async (id) => {
-				await ctx.$app.collections["${referencing_collection}"].create(
-					new ctx.$app.SuperContext(),
-					{
-						"${referencing_field}": item_id,
-						"${intermediary_field_that_points_there}": id,
-					}
-				);
-			});
-
-			await Promise.all(promises);
-        }`;
-  }
-  return "";
-}
+import { getFieldHandler } from "./shared-crud-form-fields.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, {
     postimport: `import {${toPascalCase(
       collection_name
     )}FormFields, ${toPascalCase(
       collection_name
     )}FormControls }from "../shared.js";
-
-        import { ${toPascalCase(collection_name)} } from "${importPath(
+                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";
 
-		import { ${list_action}URL, ${toPascalCase(
-      edit_action_name
-    )}URL } from "${importPath("src/back/routes/urls.js")}";
+		${Array.from(
+      new Set(field_handler_results.map(({ imports }) => imports.edit))
+    ).join("\n")}
 
-        import {tempstream} from "tempstream";
+        ${collection_fields.filter((e) => !e.is_required).length ? `import {withFallback} from "@sealcode/sealgen";` : ""}
 `,
     fields: `...${toPascalCase(collection_name)}FormFields`,
     controls: `
@@ -130,18 +58,18 @@ async function editItemFormTemplate(edit_action_name, newfilefullpath, collectio
 					throw new Error("Error when parsing the form values");
 				}
 
-			   ${collection_fields.map((field) => renderFieldPreEditAction(field)).filter((e) => e !== "").join("\n")}
+			   ${field_handler_results.map((result) => result.pre_edit).filter((e) => e !== "").join("\n")}
 
 				item.setMultiple(
 					{
-						${collection_fields.map((field) => renderFieldForSealious(field)).filter((e) => e != "").join(",\n")}
+						${field_handler_results.filter((r) => !r.hide_sealious_value).map((result) => result.sealious_value(result)).filter((e) => e != "").join(",\n")}
 					}
 				);
                 await item.save(ctx.$context);
 
                 
-                 // ## POST-EDIT ACTIONS ############
-                 ${collection_fields.map((field) => renderFieldPostEditAction(field)).filter((e) => e != "").join("\n")}
+                ${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")}
 			}
 		`,
     other_methods: `
@@ -150,9 +78,9 @@ async function editItemFormTemplate(edit_action_name, newfilefullpath, collectio
                // of the resource to edit. 
                // If sealgen got it wrong, just return the param name that should be used here instead
                const param_name = 
-                         ${toPascalCase(edit_action_name)}URL.params
+                         ${edit_action_name}URL.params
                          .find(param => param.toLowerCase().includes("id")) 
-                     || ${toPascalCase(edit_action_name)}URL.params[0]
+                     || ${edit_action_name}URL.params[0]
 			   const id = ctx.params[param_name];
 	           if (!id) {
 				   throw new Error("Missing URL  parameter: " + param_name);
@@ -176,14 +104,43 @@ async function editItemFormTemplate(edit_action_name, newfilefullpath, collectio
 			   }
 
 			   return {
-				   ${collection_fields.map((field) => renderFieldForInitialValues(field)).filter((e) => e !== "").join(",\n")}
+				   ${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")}
 			   };
 		   }
 	   `,
     render: `	async render(ctx: Context, data: FormData, show_field_errors: boolean) {
 		return html(
 			ctx,
-			"AddBlogArticle",
+			"Edit ${toPascalCase(collection_name)}",
 			tempstream/* HTML */ \` <div class="add-opinion-form">
 				<a class="" href="\${${list_action}URL}"
 					>\u2190 Back to ${collection_name} list</a

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

@@ -6,6 +6,15 @@ import { DefaultListFilters } from "../../page/default-list-filters.js";
 import { toKebabCase, toPascalCase } from "js-convert-case";
 import { formatWithPrettier } from "../../utils/prettier.js";
 const target_locreq = _locreq(process.cwd());
+function fieldImport({ type }, importPath) {
+  if (type == "image") {
+    return `
+		import type { FilePointer } from "@sealcode/file-manager";
+		import { imageRouter } from "${importPath("src/back/image-router.js")}";
+	    `;
+  }
+  return "";
+}
 function makeDefaultFilterFields(collection_fields) {
   return collection_fields.map(
     (field) => `	{ field: "${field.name}", ...${DefaultListFilters[field.type] ? `DefaultListFilters["${field.type}"]` : `DefaultListFilters.fallback`} }`
@@ -51,7 +60,7 @@ const default_hooks = {
   pre_header_html: "",
   post_header_html: "",
   post_import_js: "",
-  render_item: (collection_name) => `	async renderItem(ctx: Context, item: CollectionItem<typeof ${toPascalCase(
+  render_item: (collection_name) => `	async renderItem(_ctx: Context, item: CollectionItem<typeof ${toPascalCase(
     collection_name
   )}>) {
 		return <tr>
@@ -74,8 +83,13 @@ async function collectionListTemplate(collection_name, action_name, newfilefullp
     extract_fields_from_collection(collection_name)
   ]);
   const importPath = curryImportPath(newfilefullpath);
+  const field_import_string = Array.from(
+    new Set(
+      collection_fields.map((field) => fieldImport(field, importPath))
+    )
+  ).join("\n");
   const result = `import type { Context } from "koa";
-import type { CollectionItem, ItemListResult } from "sealious";
+import type { CollectionItem } from "sealious";
 import type { FlatTemplatable, Templatable } from "tempstream";
 import { TempstreamJSX, tempstream } from "tempstream";
 import { ${uppercase_collection} } from "${importPath(
@@ -89,12 +103,9 @@ import {
 	DefaultListFilters,
 } from "@sealcode/sealgen";
 import qs from "qs";
-import type { FilePointer } from "@sealcode/file-manager";
-import { imageRouter } from "${importPath(
-    target_locreq.resolve("src/back/image-router.ts")
-  )}";
 
 ${hooks.post_import_js}
+${field_import_string}
 
 export const actionName = "${action_name}";
 
@@ -107,6 +118,8 @@ const filterFields = [
 	prepareValue?: (filter_value: unknown)=>unknown; // set this function to change what filter value is passed to Sealious
 }[];
 
+
+// eslint-disable-next-line @typescript-eslint/consistent-type-assertions
 const displayFields = [
 ${makeDefaultDisplayFields(collection_fields)}
 ] as {
@@ -152,10 +165,12 @@ export default new (class ${action_name}Page extends SealiousItemListPage<
         // adding opportunity to adjust the values for a given field filter before it's sent to Sealious
 		const values = await super.getFilterValues(ctx);
 		for (const filterField of filterFields) {
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
 			const key = filterField.field as keyof typeof values;
 			if (key in values) {
 				const prepare_fn = filterField.prepareValue;
 				if (prepare_fn) {
+                                        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions,  @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment
 					values[key] = prepare_fn(values[key]) as any;
 				}
 			}

package/lib/templates/shared/confirm-item-delete.js

@@ -11,22 +11,24 @@ import { ${delete_action_name}URL } from "${importPath(
     "src/back/routes/urls.js"
   )}";
 import html from "${importPath("src/back/html.ts")}";
-import { ${toPascalCase(collection_name)} } from "${importPath(
-    "src/back/collections/collections.js"
-  )}";
+import { ${toPascalCase(collection_name)} as ${toPascalCase(
+    collection_name
+  )}Collection } from "${importPath("src/back/collections/collections.js")}";
 
 export const actionName = "${ask_delete_action_name}";
 
 export default new (class ${ask_delete_action_name}Page extends Page {
 	canAccess = async (ctx: Context) => {
-        const policy = ${toPascalCase(collection_name)}.getPolicy("edit");
+        const policy = ${toPascalCase(
+    collection_name
+  )}Collection.getPolicy("edit");
 		const response = await policy.check(ctx.$context);
 		 return { canAccess: response?.allowed || false, message: response?.reason || "" };
 	};
 
     getItemTitle(_ctx: Context, item: CollectionItem<typeof ${toPascalCase(
     collection_name
-  )}>){
+  )}Collection>){
       return item.get("name")
     }
 

package/lib/templates/shared/handlers/boolean.js

@@ -0,0 +1,14 @@
+const boolean_handler = async (_, { name }, ___, { is_required_expr, fields_var }) => ({
+  field: `${name}: new Fields.Boolean(${is_required_expr})`,
+  controls: `new Controls.Checkbox(${fields_var}.${name}, { label: "${name}" })`,
+  initial_value_edit: {
+    fallback_value: `"false"`,
+    parsed_value: `String(item.get("${name}"))`
+  },
+  main_value_sealious: `!!data.${name}`,
+  fallback_value_sealious: "false"
+});
+export {
+  boolean_handler
+};
+//# sourceMappingURL=boolean.js.map

package/lib/templates/shared/handlers/date.js

@@ -0,0 +1,8 @@
+const date_handler = async (_, { name }, ___, { fields_var }) => ({
+  controls: `new Controls.SimpleInput(${fields_var}.${name}, { label: "${name}", type: "date"})`,
+  fallback_value_sealious: `undefined`
+});
+export {
+  date_handler
+};
+//# sourceMappingURL=date.js.map

package/lib/templates/shared/handlers/deep-reverse-single-reference.js

@@ -0,0 +1,209 @@
+import { toKebabCase, toPascalCase } from "js-convert-case";
+import extract_fields_from_collection from "../../../utils/extract-fields-from-collection.js";
+const deep_reverse_single_reference_handler = async (collection_name, {
+  name,
+  target,
+  referencing_collection,
+  intermediary_field_that_points_there,
+  referencing_field
+}, ___, { is_required_expr, fields_var }) => {
+  if (!referencing_collection || !target || !intermediary_field_that_points_there || !referencing_field) {
+    console.warn(
+      "missing referencing_collection, target, intermediary_field_that_points_there, or referencing_field member in extracted field info"
+    );
+    return { field: "" };
+  }
+  const referencing_fields = await extract_fields_from_collection(
+    referencing_collection
+  );
+  if (referencing_fields.length == 2) {
+    const post_create = (get_id) => `{
+			 const item_id = ${get_id};
+			 // First, we remove links refering to current item
+			 const {items: existing_links } = (await ctx.$app.collections["${referencing_collection}"]
+				 .list(ctx.$context)
+				 .filter({"${referencing_field}": item_id})
+				 .fetch()
+			 )
+			  const should_exist_ids = Object.entries(
+				  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+				  (data["${name}"] as unknown as Record<string, string>) || {}
+			  )
+				  .filter(([, value]) => value === "on")
+				  .map(([key]) => key);
+			  const to_delete = existing_links.filter(
+				  (link) => !should_exist_ids.includes(link.get("${intermediary_field_that_points_there}"))
+			  );
+			  const to_create_ids = should_exist_ids.filter(
+				  (id) => !existing_links.map(({ id }) => id).includes(id)
+			  );
+			  await Promise.all(to_delete.map((item) => item.remove(ctx.$context)));
+			  // Then, we iterate over all selected values and insert appropriate missing links
+			  const promises = to_create_ids.map(async (id) => {
+				  await ctx.$app.collections["${toKebabCase(referencing_collection)}"].create(
+					  ctx.$context,
+					  {
+						  "${referencing_field}": item_id,
+						  "${intermediary_field_that_points_there}": id,
+					  }
+				  );
+			  });
+			  await Promise.all(promises);
+		 }`;
+    return {
+      field: `${name}: new Fields.CheckboxedListField(${is_required_expr}, async (ctx) => {
+				 const { items } = await ctx.$app.collections["${target}"]
+					 .list(ctx.$context)
+					 .fetch();
+
+				 return items.map((s) => ({
+					 label: s.get("name"),
+					 value: s.id,
+				 }));
+			 })`,
+      controls: `new Controls.CheckboxedListInput(${fields_var}.${name}, {
+				label: "${name}",
+			})`,
+      post_edit: post_create(`await this.getID(ctx)`),
+      post_create: post_create(`created.id`),
+      initial_value_edit: `Object.fromEntries((item.get("${name}") || []).map(id=>[id, "on"]))`,
+      sealious_value: () => ""
+    };
+  } else {
+    const initial_value_function_name = `get${toPascalCase(
+      name
+    )}TableInitialValues`;
+    const post_create = (get_id) => `{
+			const item_id = ${get_id};
+			// First, we remove links refering to current item
+			const { items: to_delete } = await ctx.$app.collections[
+				"${toKebabCase(referencing_collection)}"
+			]
+				.list(ctx.$context)
+				.filter({ "${referencing_field}": item_id })
+				.fetch();
+			await Promise.all(to_delete.map((item) => item.remove(ctx.$context)));
+
+			// Then, we iterate over all selected values and insert appropriate entries for the subcategories relation
+
+			const promises = data["${name}"]
+				.filter((s) => s.selected == true)
+				.map(async (link_info) => {
+					await ctx.$app.collections["${toKebabCase(referencing_collection)}"].create(
+						ctx.$context,
+						{
+							"${referencing_field}": item_id,
+							"${intermediary_field_that_points_there}": String(link_info["${intermediary_field_that_points_there}"]),
+							${referencing_fields.filter(
+      ({ type }) => type !== "single-reference"
+    ).map(
+      (field) => `"${field.name}": link_info["${field.name}"]`
+    ).join(",\n")}
+						}
+					);
+				});
+
+			await Promise.all(promises);
+		}`;
+    const initial_value = `(await ${initial_value_function_name}(ctx,item)) as unknown as FormDataValue`;
+    return {
+      imports: {
+        shared: `import type { CollectionItem } from "sealious"; import type { Context } from "koa";`,
+        edit: `import {${initial_value_function_name}} from "../shared.js"; import type { FormDataValue } from "@sealcode/sealgen";`
+      },
+      field: `
+			  ${name}: new Fields.Table({
+				  selected: new Fields.Boolean(false),
+				  "${referencing_field}": new Fields.SimpleFormField(true),
+				  "${intermediary_field_that_points_there}": new Fields.SimpleFormField(true),
+				  ${referencing_fields.filter(({ type }) => type !== "single-reference").map(
+        (field) => `${field.name}: new Fields.SimpleFormField(true)`
+      ).join(",\n")}
+			  })`,
+      controls: `
+                new Controls.Table(${fields_var}.${name}, {
+                      render_fields: {
+						  selected: (fctx, name, value) => /* HTML */ \`<input
+							  type="checkbox"
+							  name=\${name}
+							  \${value?.toString() == "true" ? "checked" : ""}
+							  form="\${fctx.form_id}"
+							  autocomplete="off"
+						  />\`,
+						  "${referencing_field}": (fctx, name, value) => /* HTML */ \`<input
+							  type="hidden"
+							  name=\${name}
+							  value="\${value}"
+							  form="\${fctx.form_id}"
+						  />\`,
+						  "${intermediary_field_that_points_there}": (fctx, name, value) => /* HTML */ \`<input
+							  type="hidden"
+							  name=\${name}
+							  value="\${value}"
+							  form="\${fctx.form_id}"
+						  />\`,
+						 ${referencing_fields.filter(
+        ({ type }) => type !== "single-reference"
+      ).map(
+        (field) => `${field.name}: (fctx, name, value) => /* HTML */ \`<input
+										  name=\${name}
+										  value="\${value}"
+										  form="\${fctx.form_id}"
+										  autocomplete="off"
+									  />\``
+      ).join(",\n")}
+                      },
+                      allow_adding: false,
+				  })`,
+      top_level_shared: `export async function ${initial_value_function_name}(
+					ctx: Context,
+                    item: CollectionItem<typeof ${toPascalCase(
+        collection_name
+      )}>
+				) {
+                    // convert from an array to array-like object
+					return Object.fromEntries(
+						await Promise.all([
+							ctx.$app.collections["${toKebabCase(target)}"].list(ctx.$context).fetch(),
+							ctx.$app.collections["${toKebabCase(
+        referencing_collection
+      )}"].list(ctx.$context).fetch(),
+						]).then(([{ items: targets }, { items: links }]) =>
+							targets
+								.map((target) => {
+									return {
+										selected: (item.get("${name}") || []).includes(
+											target.id
+										)
+											? "on"
+											: "off",
+										"${referencing_field}": item.id,
+										"${intermediary_field_that_points_there}": target.id,
+                                        ${referencing_fields.filter(
+        ({ type }) => type !== "single-reference"
+      ).map(
+        (field) => `"${field.name}": links
+												.find(
+													(e) =>
+														e.get("${intermediary_field_that_points_there}") == target.id &&
+														e.get("${referencing_field}") == item.id
+												)
+												?.get("rank") || 0,`
+      ).join(",\n")}
+									};
+								})
+								.entries()
+						)
+					);
+				}`,
+      initial_value_edit: initial_value,
+      initial_value_create: initial_value,
+      post_edit: post_create(`await this.getID(ctx)`),
+      post_create: post_create(`created.id`)
+    };
+  }
+};
+export {
+  deep_reverse_single_reference_handler
+};
+//# sourceMappingURL=deep-reverse-single-reference.js.map

package/lib/templates/shared/handlers/default.js

@@ -0,0 +1,50 @@
+import { toPascalCase } from "js-convert-case";
+const default_handler = async (collection_name, { name, is_readonly, is_required }) => {
+  const required_s = `${toPascalCase(
+    collection_name
+  )}.fields.${name}.required`;
+  const fields_var = `${toPascalCase(collection_name)}FormFields`;
+  const fallback_value_initial = `""`;
+  const fallback_value_sealious = `""`;
+  const main_value_initial = `item.get("${name}")`;
+  const main_value_sealious = `data["${name}"]`;
+  const parsed_value = main_value_initial;
+  return {
+    is_required,
+    name,
+    post_create: "",
+    imports: { shared: "", edit: "" },
+    hide_field: is_readonly,
+    field: `${name}: new Fields.CollectionField(${required_s}, ${toPascalCase(
+      collection_name
+    )}.fields.${name})`,
+    hide_control: is_readonly,
+    controls: `new Controls.SimpleInput(${fields_var}.${name}, { label: "${name}"})`,
+    is_required_expr: `${toPascalCase(
+      collection_name
+    )}.fields.${name}.required`,
+    fields_var,
+    top_level_shared: "",
+    hide_initial_value_edit: is_readonly,
+    initial_value_edit: {
+      fallback_value: fallback_value_initial,
+      main_value: main_value_initial,
+      parsed_value
+    },
+    hide_initial_value_create: is_readonly,
+    initial_value_create: "",
+    pre_edit: "",
+    post_edit: "",
+    pre_create: "",
+    main_value_sealious,
+    fallback_value_sealious,
+    sealious_value: (result) => {
+      return result.is_required ? `${result.name}: ${result.main_value_sealious}` : `${result.name}: ${result.main_value_sealious} != null ? ${result.main_value_sealious} : ${result.fallback_value_sealious}`;
+    },
+    hide_sealious_value: is_readonly
+  };
+};
+export {
+  default_handler
+};
+//# sourceMappingURL=default.js.map

package/lib/templates/shared/handlers/enum.js

@@ -0,0 +1,19 @@
+import { toPascalCase } from "js-convert-case";
+const enum_handler = async (collection_name, { name }, _, { fields_var }) => ({
+  // this assertion and import is only necessary because required fields
+  // in Sealious lose the type information. Once this is fixed, we can remove this import here
+  imports: { shared: `import type { FieldTypes } from "sealious";` },
+  field: `${name}: new Fields.PickFromListField(
+			${toPascalCase(collection_name)}.fields["${name}"].required,
+			async (ctx) =>
+				// eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+				(${toPascalCase(collection_name)}.fields["${name}"])
+					.getAllowedValues(ctx.$app)
+					.map((value) => ({ value, label: value }))
+		)`,
+  controls: `new Controls.Dropdown(${fields_var}.${name}, { label: "${name}"})`
+});
+export {
+  enum_handler
+};
+//# sourceMappingURL=enum.js.map

package/lib/templates/shared/handlers/file.js

@@ -0,0 +1,18 @@
+import { toCamelCase } from "js-convert-case";
+const file_handler = async (_, { name, is_required }, __, { is_required_expr }) => {
+  const tempname = toCamelCase("prepared-" + name);
+  return {
+    field: `${name}: new Fields.File(${is_required_expr}, TheFileManager)`,
+    initial_value_edit: `${name}: {old: item.get("${name}")}`,
+    pre_edit: `const ${tempname} = data.${name}.new || data.${name}.old;
+				if(!${tempname}){
+				    throw new Error("Missing field: ${name}")
+         		}`,
+    fallback_value_sealious: "null",
+    ...is_required ? { main_value_sealious: tempname } : {}
+  };
+};
+export {
+  file_handler
+};
+//# sourceMappingURL=file.js.map

package/lib/templates/shared/handlers/image.js

@@ -0,0 +1,32 @@
+import { toCamelCase } from "js-convert-case";
+const image_handler = async (_, { name, is_required }, importPath, { is_required_expr, fields_var }) => {
+  const tempname = toCamelCase("prepared-" + name);
+  return {
+    imports: {
+      shared: `import { imageRouter } from "${importPath(
+        "src/back/image-router.js"
+      )}";
+            import { TheFileManager } from "${importPath(
+        "src/back/file-manager.js"
+      )}";`
+    },
+    field: `${name}: new Fields.File(${is_required_expr}, TheFileManager)`,
+    controls: `new Controls.Photo(${fields_var}.${name}, imageRouter, {
+			label: "${name}",
+		})`,
+    initial_value_edit: `{old: item.get("${name}")}`,
+    pre_edit: `const ${tempname} = data.${name}.new || data.${name}.old ` + (is_required ? `; if(!${tempname}){
+				    throw new Error("Missing field: ${name}")
+         		}` : " || undefined;"),
+    pre_create: `const ${tempname} = data.${name}.new || data.${name}.old;
+				if(!${tempname}){
+				    throw new Error("Missing field: ${name}")
+         		}`,
+    fallback_value_sealious: "null",
+    sealious_value: () => `${name}: ${tempname}`
+  };
+};
+export {
+  image_handler
+};
+//# sourceMappingURL=image.js.map