@sealcode/sealgen 0.18.8 → 0.19.0

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

@@ -1,244 +0,0 @@
-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((link) => link.get("${intermediary_field_that_points_there}")).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

@@ -1,64 +0,0 @@
-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 },
-	_,
-	__,
-	___,
-	fields_var = `${toPascalCase(collection_name)}FormFields`
-) => {
-	const required_s = `${toPascalCase(
-		collection_name
-	)}.fields.${name}.required`;
-	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

@@ -1,23 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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 }, importPath, { is_required_expr }) => {
-	const tempname = toCamelCase("prepared-" + name);
-	return {
-		imports: {
-			shared: `import { TheFileManager } from "${importPath(
-				"src/back/file-manager.js"
-			)}";`,
-		},
-		field: `${name}: new Fields.File(${is_required_expr}, TheFileManager)`,
-		initial_value_edit: `{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

@@ -1,45 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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: `[]`,
-});