@sealcode/sealgen 0.15.35 → 0.15.37

package/src/templates/shared/collection-create-form.ts

@@ -0,0 +1,121 @@
+import { toKebabCase, toPascalCase } from "js-convert-case";
+import { formTemplate } from "../form.js";
+import { curryImportPath } from "../../utils/import-path.js";
+
+import _locreq from "locreq";
+import extract_fields_from_collection from "../../utils/extract-fields-from-collection.js";
+import { getFieldHandler } from "./shared-crud-form-fields.js";
+
+export async function createItemFormTemplate(
+	create_action_name: string,
+	newfilefullpath: string,
+	collection_name: string,
+	list_action: string
+): Promise<string> {
+	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, {
+		postimport: `import {${toPascalCase(
+			collection_name
+		)}FormFields, ${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 {tempstream} from "tempstream";
+`,
+
+		fields: `...${toPascalCase(collection_name)}FormFields`,
+		controls: `
+                new Controls.FormHeader("Create ${toPascalCase(
+					collection_name
+				)}"), 
+                ...${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")}
+                   }
+}`
+			: ``,
+
+		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")}
+
+		${
+			post_create_actions.length ? `const created = ` : ""
+		} await ctx.$app.collections["${toKebabCase(collection_name)}"].create(
+			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")}
+	}
+`,
+		render: `	async render(ctx: Context, data: FormData, show_field_errors: boolean) {
+		return html(
+			ctx,
+			"Create ${toKebabCase(collection_name)}",
+			tempstream/* HTML */ \` <div class="add-opinion-form">
+				<a class="" href="\${${list_action}URL}"
+					>← Back to ${collection_name} list</a
+				>
+				\${await super.render(ctx, data, show_field_errors)}
+			</div>\`
+		);
+	}`,
+	});
+}

package/src/templates/shared/collection-edit-form.ts

@@ -0,0 +1,196 @@
+import { toKebabCase, toPascalCase } from "js-convert-case";
+import { formTemplate } from "../form.js";
+import { curryImportPath } from "../../utils/import-path.js";
+
+import _locreq from "locreq";
+import extract_fields_from_collection from "../../utils/extract-fields-from-collection.js";
+
+import { getFieldHandler } from "./shared-crud-form-fields.js";
+
+export async function editItemFormTemplate(
+	edit_action_name: string,
+	newfilefullpath: string,
+	collection_name: string,
+	list_action: string
+): Promise<string> {
+	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(
+			"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";`
+				: ""
+		}
+`,
+
+		fields: `...${toPascalCase(collection_name)}FormFields`,
+		controls: `
+                new Controls.FormHeader("Edit ${toPascalCase(
+					collection_name
+				)}"), 
+                ...${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);
+                const id = await this.getID(ctx);
+                const {items: [item]} = await ctx.$app.collections["${toKebabCase(
+					collection_name
+				)}"]
+                   .list(ctx.$context)
+                   .ids([id])
+                   .fetch();
+				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")}
+					}
+				);
+                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")}
+			}
+		`,
+
+		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 id = ctx.params[param_name];
+	           if (!id) {
+				   throw new Error("Missing URL  parameter: " + param_name);
+			   }
+               return id
+            }
+        `,
+
+		get_initial_values: `async getInitialValues(ctx: Context) {
+               const id = await this.getID(ctx);
+
+               const {
+				   items: [item],
+			   } = await ctx.$app.collections["${toKebabCase(collection_name)}"]
+				   .list(ctx.$context)
+				   .ids([id])
+				   .attach({})
+				   .fetch();
+
+			   if (!item) {
+				   throw new Error("Item with given id not found: " + id);
+			   }
+
+			   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")}
+			   };
+		   }
+	   `,
+
+		render: `	async render(ctx: Context, data: FormData, show_field_errors: boolean) {
+		return html(
+			ctx,
+			"Edit ${toPascalCase(collection_name)}",
+			tempstream/* HTML */ \` <div class="add-opinion-form">
+				<a class="" href="\${${list_action}URL}"
+					>← Back to ${collection_name} list</a
+				>
+				\${await super.render(ctx, data, show_field_errors)}
+			</div>\`
+		);
+	}`,
+	});
+}

package/src/templates/shared/collection-list.ts

@@ -0,0 +1,252 @@
+import { extractCollectionClassname } from "../../generate-collections.js";
+import extract_fields_from_collection, {
+	ExtractedFieldInfo,
+} from "../../utils/extract-fields-from-collection.js";
+import _locreq from "locreq";
+import { curryImportPath } from "../../utils/import-path.js";
+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 }: ExtractedFieldInfo,
+	importPath: (path: string) => string
+): string {
+	if (type == "image") {
+		return `
+		import type { FilePointer } from "@sealcode/file-manager";
+		import { imageRouter } from "${importPath("src/back/image-router.js")}";
+	    `;
+	}
+	return "";
+}
+
+export function makeDefaultFilterFields(
+	collection_fields: { name: string; type: string }[]
+) {
+	return collection_fields
+		.map(
+			(field) =>
+				`	{ field: "${field.name}", ...${
+					DefaultListFilters[field.type]
+						? `DefaultListFilters["${field.type}"]`
+						: `DefaultListFilters.fallback`
+				} }`
+		)
+		.join(",\n");
+}
+
+export function makeDefaultDisplayFields(
+	collection_fields: { name: string; type: string }[]
+) {
+	return collection_fields
+		.map((field) => {
+			if (field.type == "boolean") {
+				return `	{
+		field: "${field.name}",
+		label: "${field.name}",
+		format: (v: boolean) => (v ? "YES" : "NO"),
+	}`;
+			}
+			if (field.type == "datetime") {
+				return `	{
+		field: "${field.name}",
+		label: "${field.name}",
+		format: (v: number) => {
+			const d = new Date();
+			d.setTime(v);
+			return d.toString().split(" ").slice(1, 5).join(" ");
+		},
+	}`;
+			}
+			if (field.type == "image") {
+				return `{
+					field: "${field.name}",
+					label: "${field.name}",
+					format: async (value: FilePointer) => {
+						return imageRouter.image(await value.getPath(), {
+							container: { width: 45, height: 45 },
+                            crop: { width: 45, height: 45 },
+							alt: "",
+						});
+					},
+				}`;
+			}
+			return `	{ field: "${field.name}", label: "${field.name}" }`;
+		})
+		.join(",\n");
+}
+
+const default_hooks = {
+	pre_header_html: "",
+	post_header_html: "",
+	post_import_js: "",
+	render_item: (
+		collection_name: string
+	) => `	async renderItem(_ctx: Context, item: CollectionItem<typeof ${toPascalCase(
+		collection_name
+	)}>) {
+		return <tr>
+			{displayFields.map(({ field, format }) => {
+				// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/consistent-type-assertions, @typescript-eslint/no-explicit-any
+				const value = item.get(field as any);
+				return <td>{format ? format(value, item) : value}</td>;
+			})}
+		</tr>;
+    }`,
+};
+
+export async function collectionListTemplate(
+	collection_name: string,
+	action_name: string,
+	newfilefullpath: string,
+	_hooks: Partial<typeof default_hooks> = {}
+) {
+	const hooks = { ...default_hooks, ..._hooks };
+	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_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 } from "sealious";
+import type { FlatTemplatable, Templatable } from "tempstream";
+import { TempstreamJSX, tempstream } from "tempstream";
+import { ${uppercase_collection} } from "${importPath(
+		target_locreq.resolve("src/back/collections/collections.ts")
+	)}";
+import html from "${importPath(target_locreq.resolve("src/back/html.ts"))}";
+import type { ListFilterRender } from "@sealcode/sealgen";
+import {
+	SealiousItemListPage,
+	BaseListPageFields,
+	DefaultListFilters,
+} from "@sealcode/sealgen";
+import qs from "qs";
+
+${hooks.post_import_js}
+${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"];
+	render?: ListFilterRender;
+	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 {
+	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},
+	typeof BaseListPageFields
+> {
+	fields = BaseListPageFields;
+
+	async renderFilters(ctx: Context): Promise<FlatTemplatable> {
+		const query_params = qs.parse(ctx.search.slice(1));
+		query_params.page = "1";
+		const filter_values = await super.getFilterValues(ctx);
+		return <form>
+			{Object.entries(query_params).map(([key, value]) => {
+				if (key == "filter") {
+					return "";
+				}
+                // this is necessary to not lose any query params when the user changes the filter values
+				return <input type="hidden" name={key} value={value}/>;
+			})}
+			{filterFields.map(({ field, render }) => {
+				if (!render) {
+					render = DefaultListFilters.fallback.render;
+				}
+				return (
+					render(filter_values[field] || "", this.collection.fields[field]) ||
+					""
+				);
+			})}
+			<input type="submit" />
+		</form>;
+     }
+
+      async getFilterValues(ctx: Context) {
+        // 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;
+				}
+			}
+		}
+		return values;
+	}
+
+    ${hooks.render_item(collection_name)}
+
+	renderListContainer(ctx: Context, content: Templatable): FlatTemplatable {
+		return (
+			<table class="sealious-list ${toKebabCase(action_name)}-table">
+				{this.renderTableHead(ctx, displayFields)}
+				<tbody>{content}</tbody>
+			</table>
+		);
+	}
+
+	renderTableHead(
+		ctx: Context,
+		fields: { field: string; label?: string }[]
+	): FlatTemplatable {
+		return tempstream/* HTML */ \`<thead>
+			<tr>
+				\${fields.map(({ label, field }) => this.renderHeading(ctx, field, label))}
+				<th>Actions</th>
+			</tr>
+		</thead>\`;
+	}
+
+	async render(ctx: Context) {
+		return html(
+			ctx,
+			"${action_name}",
+			<div class="sealious-list-wrapper ${toKebabCase(action_name)}--wrapper">
+				${hooks.pre_header_html}
+				<h2>${action_name} List</h2>
+				${hooks.post_header_html}
+				{super.render(ctx)}
+			</div>
+		);
+	}
+
+})(${uppercase_collection});
+`;
+	return await formatWithPrettier(result);
+}

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

@@ -0,0 +1,78 @@
+import { toKebabCase, toPascalCase } from "js-convert-case";
+import { curryImportPath } from "../../utils/import-path.js";
+import { formatWithPrettier } from "../../utils/prettier.js";
+
+export async function askItemDeleteTemplate(
+	ask_delete_action_name: string,
+	collection_name: string,
+	newfilefullpath: string,
+	list_action_name: string,
+	delete_action_name: string
+): Promise<string> {
+	const importPath = curryImportPath(newfilefullpath);
+	const result = `import type { Context } from "koa";
+import { Page } from "@sealcode/sealgen";
+import type { CollectionItem } from "sealious";
+import { TempstreamJSX } from "tempstream";
+import { ${delete_action_name}URL } from "${importPath(
+		"src/back/routes/urls.js"
+	)}";
+import html from "${importPath("src/back/html.ts")}";
+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
+		)}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")
+    }
+
+	async render(ctx: Context) {
+		const id = ctx.params.id
+        if(!id){throw new Error("Could not read the id param from the URL")}
+		const { items: [item] }  = 
+			await ctx.$app.collections["${toKebabCase(
+				collection_name
+			)}"].list(ctx.$context).ids([id]).fetch();
+
+		if (!item) {
+			throw new Error("Item with given id not found");
+		}
+		return html(
+			ctx,
+			"Delete?",
+			<div>
+				<div class="confirm-delete-page confirm-delete-page--${toKebabCase(
+					collection_name
+				)}">
+					<span>
+						Are you sure you want to remove: {" "}
+						<b>{this.getItemTitle(ctx, item)}</b>
+					</span>
+					<form action={${delete_action_name}URL(item.id)}>
+						<button type="submit">
+							remove
+						</button>
+						<input type="hidden" name="id" value={item?.id} />
+					</form>
+				</div>
+			</div>
+		);
+	}
+})();
+`;
+
+	return await formatWithPrettier(result);
+}

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

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

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

@@ -0,0 +1,12 @@
+import {
+	FieldHandler,
+	FieldHandlerResult,
+} from "../shared-crud-form-fields.js";
+
+export const date_handler: FieldHandler<
+	FieldHandlerResult,
+	Partial<FieldHandlerResult>
+> = async (_, { name }, ___, { fields_var }) => ({
+	controls: `new Controls.SimpleInput(${fields_var}.${name}, { label: "${name}", type: "date"})`,
+	fallback_value_sealious: `undefined`,
+});