@sealcode/sealgen 0.15.34 → 0.15.36

package/src/templates/shared/handlers/deep-reverse-single-reference.ts

@@ -0,0 +1,244 @@
+import { toKebabCase, toPascalCase } from "js-convert-case";
+import extract_fields_from_collection from "../../../utils/extract-fields-from-collection.js";
+import {
+	FieldHandler,
+	FieldHandlerResult,
+} from "../shared-crud-form-fields.js";
+
+export const deep_reverse_single_reference_handler: FieldHandler<
+	FieldHandlerResult,
+	Partial<FieldHandlerResult>
+> = 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) {
+		// just a regular n-to-n intermediary collection
+		const post_create = (get_id: string) => `{
+			 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 {
+		// probably an n-to-n intermediary collection with an additional attribute
+		const initial_value_function_name = `get${toPascalCase(
+			name
+		)}TableInitialValues`;
+		const post_create = (get_id: string) => `{
+			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`),
+		};
+	}
+};

package/src/templates/shared/handlers/default.ts

@@ -0,0 +1,58 @@
+import { toPascalCase } from "js-convert-case";
+import {
+	FieldHandler,
+	FieldHandlerResult,
+} from "../shared-crud-form-fields.js";
+
+export const default_handler: FieldHandler<
+	Record<string, never>,
+	FieldHandlerResult
+> = 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: FieldHandlerResult) => {
+			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,
+	};
+};

package/src/templates/shared/handlers/enum.ts

@@ -0,0 +1,23 @@
+import { toPascalCase } from "js-convert-case";
+import {
+	FieldHandler,
+	FieldHandlerResult,
+} from "../shared-crud-form-fields.js";
+
+export const enum_handler: FieldHandler<
+	FieldHandlerResult,
+	Partial<FieldHandlerResult>
+> = 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}"})`,
+});

package/src/templates/shared/handlers/file.ts

@@ -0,0 +1,22 @@
+import { toCamelCase } from "js-convert-case";
+import {
+	FieldHandler,
+	FieldHandlerResult,
+} from "../shared-crud-form-fields.js";
+
+export const file_handler: FieldHandler<
+	FieldHandlerResult,
+	Partial<FieldHandlerResult>
+> = 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 } : {}),
+	};
+};

package/src/templates/shared/handlers/image.ts

@@ -0,0 +1,45 @@
+import { toCamelCase } from "js-convert-case";
+import {
+	FieldHandler,
+	FieldHandlerResult,
+} from "../shared-crud-form-fields.js";
+
+export const image_handler: FieldHandler<
+	FieldHandlerResult,
+	Partial<FieldHandlerResult>
+> = 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}`,
+	};
+};

package/src/templates/shared/handlers/int.ts

@@ -0,0 +1,15 @@
+import {
+	FieldHandler,
+	FieldHandlerResult,
+} from "../shared-crud-form-fields.js";
+
+export const int_handler: FieldHandler<
+	FieldHandlerResult,
+	Partial<FieldHandlerResult>
+> = async (_, { name }, __, { is_required_expr, fields_var }) => ({
+	field: `${name}: new Fields.NumberField(${is_required_expr}, 0)`,
+	controls: `new Controls.Number(${fields_var}.${name}, { label: "${name}" })`,
+	initial_value_edit: {
+		parsed_value: `String(item.get("${name}"))`,
+	},
+});

package/src/templates/shared/handlers/jdd.ts

@@ -0,0 +1,14 @@
+import {
+	FieldHandler,
+	FieldHandlerResult,
+} from "../shared-crud-form-fields.js";
+
+export const jdd_handler: FieldHandler<
+	FieldHandlerResult,
+	Partial<FieldHandlerResult>
+> = async (_, { name }) => ({
+	field: ``,
+	initial_value_edit: "",
+	controls: "",
+	sealious_value: () => `${name}: []`,
+});

package/src/templates/shared/handlers/single-reference.ts

@@ -0,0 +1,16 @@
+import {
+	FieldHandler,
+	FieldHandlerResult,
+} from "../shared-crud-form-fields.js";
+
+export const single_reference_handler: FieldHandler<
+	FieldHandlerResult,
+	Partial<FieldHandlerResult>
+> = async (_, { name }, __, { fields_var }) => {
+	return {
+		controls: `new Controls.SingleReferenceDropdown(${fields_var}.${name}, {
+            label: "${name}",
+            getLabel: (item)=>item.id
+        })`,
+	};
+};

package/src/templates/shared/handlers/structured-array.ts

@@ -0,0 +1,42 @@
+import {
+	FieldHandler,
+	FieldHandlerResult,
+} from "../shared-crud-form-fields.js";
+
+export const structured_array_handler: FieldHandler<
+	FieldHandlerResult,
+	Partial<FieldHandlerResult>
+> = async (_, { name, subfields }, __, { fields_var }) => ({
+	field: `${name}: new Fields.Table({
+        ${subfields
+			.map(
+				(subfield) =>
+					`${subfield.name}: new Fields.SimpleFormField(true)`
+			)
+			.join(",\n")}
+    })`,
+	controls: `new Controls.Table(${fields_var}.${name}, {
+        label: "${name}",
+		render_fields: {
+            ${subfields
+				.map(
+					({
+						name,
+					}) => `"${name}": (fctx, name, value) => /* HTML */ \`<input
+				name="\${name}"
+				value="\${value}"
+				form="\${fctx.form_id}"
+                autocomplete="off"
+			/>\``
+				)
+				.join(",\n")}
+			
+		},
+		allow_adding: true,
+        allow_removing: true,
+		make_new_row: async () => ({
+           ${subfields.map(({ name }) => `"${name}": ""`).join(",\n")}
+		}),
+	})`,
+	fallback_value_sealious: `[]`,
+});

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

@@ -0,0 +1,45 @@
+import { toKebabCase, toPascalCase } from "js-convert-case";
+import { curryImportPath } from "../../utils/import-path.js";
+import { formatWithPrettier } from "../../utils/prettier.js";
+
+export function itemDeleteTemplate(
+	delete_action_name: string,
+	collection_name: string,
+	newfilefullpath: string,
+	list_action_name: string
+): Promise<string> {
+	const importPath = curryImportPath(newfilefullpath);
+	const result = `import type { Context } from "koa";
+import { Mountable } from "@sealcode/sealgen";
+import type Router from "@koa/router";
+
+import { ${toPascalCase(collection_name)} } from "${importPath(
+		"src/back/collections/collections.js"
+	)}";
+
+import { ${list_action_name}URL } from "${importPath(
+		"src/back/routes/urls.js"
+	)}";
+
+export const actionName = "${delete_action_name}";
+
+export default new (class ${delete_action_name}Redirect extends Mountable {
+    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 || "" };
+	};
+
+	mount(router: Router, path: string) {
+		router.get(path, async (ctx) => {
+            await ctx.$app.collections["${toKebabCase(
+				collection_name
+			)}"].removeByID(ctx.$context, ctx.params.id);
+			ctx.status = 302;
+			ctx.redirect(${list_action_name}URL);
+		});
+	}
+})();
+`;
+	return formatWithPrettier(result);
+}