@sealcode/sealgen 0.15.34 → 0.15.36

package/src/templates/shared/shared-crud-form-fields.ts

@@ -0,0 +1,179 @@
+import { toPascalCase } from "js-convert-case";
+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 { 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";
+const target_locreq = _locreq(process.cwd());
+
+export type FieldHandlerResult = {
+	imports: Partial<{ shared: string; edit: string }>;
+	hide_field: boolean;
+	field: string;
+	hide_control: boolean;
+	controls: string;
+	is_required: boolean;
+	is_required_expr: string;
+	fields_var: string;
+	top_level_shared: string;
+	name: string;
+	hide_initial_value_edit: boolean;
+	initial_value_edit:
+		| Partial<{
+				main_value: string;
+				parsed_value: string;
+				fallback_value: string;
+		  }>
+		| string;
+	hide_initial_value_create: boolean;
+	initial_value_create: string;
+	pre_edit: string;
+	post_edit: string;
+	pre_create: string;
+	post_create: string;
+	sealious_value: (
+		result: Exclude<FieldHandlerResult, "sealious_value">
+	) => string;
+	hide_sealious_value: boolean;
+	fallback_value_sealious: string;
+	main_value_sealious: string;
+};
+
+export type FieldHandler<
+	Defaults extends Partial<FieldHandlerResult>,
+	Result extends Partial<FieldHandlerResult>
+> = (
+	collection_name: string,
+	field: ExtractedFieldInfo,
+	importPath: (path: string) => string,
+	defaults: Defaults
+) => Promise<Result>;
+
+export const field_handlers: Record<
+	Exclude<string, "default">,
+	FieldHandler<FieldHandlerResult, Partial<FieldHandlerResult>> | undefined
+> & {
+	default: FieldHandler<Record<string, never>, FieldHandlerResult>;
+} = {
+	// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-explicit-any
+	default: default_handler as any,
+	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,
+};
+
+export async function getFieldHandler(
+	collection_name: string,
+	field: ExtractedFieldInfo,
+	importPath: (path: string) => string
+) {
+	const defaults = await field_handlers.default(
+		collection_name,
+		field,
+		importPath,
+		{}
+	);
+	const result = {
+		...defaults,
+		...((await field_handlers[field.type]?.(
+			collection_name,
+			field,
+			importPath,
+			defaults
+		)) || {}),
+	};
+	const result_initial_value_edit = result.initial_value_edit;
+	// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+	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 as any),
+					...result_initial_value_edit,
+			  };
+	return result;
+}
+
+export async function sharedCrudFormFields(
+	collection_name: string,
+	newfilefullpath: string
+) {
+	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 result = `import { Controls, Fields } from "@sealcode/sealgen";
+import { ${uppercase_collection} } from "${importPath(
+		"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")}
+
+
+
+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)}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")}
+
+`;
+	return formatWithPrettier(result);
+}

package/src/utils/extract-fields-from-collection.ts

@@ -4,24 +4,62 @@ const target_locreq = _locreq(process.cwd());
 import { promises as fs } from "fs";
 import { is, predicates } from "@sealcode/ts-predicates";
 
+export type ExtractedFieldInfo = {
+	name: string;
+	type: string;
+	target: string | null;
+	referencing_collection: string | null;
+	referencing_field: string | null;
+	intermediary_field_that_points_there: string | null;
+	is_readonly: boolean;
+	is_required: boolean;
+	subfields: { name: string }[];
+};
+
+const counter = (function* () {
+	let i = 0;
+	while (true) {
+		yield i++;
+	}
+})();
+
 export default async function extract_fields_from_collection(
 	collection_name: string
-): Promise<{ name: string; type: string }[]> {
+): Promise<ExtractedFieldInfo[]> {
 	const extractor_code = `import {default as the_app} from "./app.js";
 const c = new the_app().collections["${collection_name}"];
 const fields = [];
 for (const field_name in c.fields){
     const field = c.fields[field_name];
     let type = field.typeName;
+    let target = null;
+    let referencing_collection = null;
+    let referencing_field = null;
+    let intermediary_field_that_points_there = null;
+    let is_readonly = false;
+    let is_required = field.required;
+    let subfields = [];
     if(["derived-value", "cached-value"].includes(type)){
-	type = field.virtual_field.typeName
+	    type = field.virtual_field.typeName;
+    }
+    if(["derived-value", "cached-value", "reverse-single-reference"].includes(field.typeName)){
+	    is_readonly = true;
+    }
+    if(type == "deep-reverse-single-reference" || type =="reverse-single-reference"){
+		target = field.target_collection;
+        referencing_collection = field.referencing_collection;
+		referencing_field = field.referencing_field;
+		intermediary_field_that_points_there = field.intermediary_field_that_points_there
+    }
+    if( type == "structured-array" ) {
+         subfields = Object.keys(field.subfields).map(key=>({name: key}));
     }
-    fields.push({name: field_name, type})
+    fields.push({ name: field_name, type, target, referencing_collection, referencing_field, intermediary_field_that_points_there, is_readonly, is_required, subfields })
 }
-console.log(JSON.stringify(fields));
+    console.log(JSON.stringify(fields));
 `;
 	const extractor_code_path = target_locreq.resolve(
-		"dist/back/___extract_fields.js"
+		`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]);
@@ -34,6 +72,7 @@ console.log(JSON.stringify(fields));
 				predicates.shape({
 					name: predicates.string,
 					type: predicates.string,
+					is_readonly: predicates.boolean,
 				})
 			)
 		)
@@ -43,5 +82,5 @@ console.log(JSON.stringify(fields));
 				stdout
 		);
 	}
-	return ret;
+	return ret as ExtractedFieldInfo[];
 }

package/src/utils/with-fallback.ts

@@ -16,7 +16,7 @@ export function withFallback<T1, T2, T3 extends NonNullable<unknown>>(
 	value1: T1,
 	value2: T2,
 	value3?: T3
-): NonNullable<T1> | NonNullable<T2> | T3;
+): NonNullable<T2> | T3;
 export function withFallback<T1, T2, T3 extends NonNullable<unknown>>(
 	value1: T1,
 	value2: T2,

package/src/utils/write-file.ts

@@ -0,0 +1,8 @@
+import { promises as fs } from "node:fs";
+import { resolve } from "path";
+
+export async function writeFile(path: string, content: string) {
+	await fs.mkdir(resolve(path, "../"), { recursive: true });
+	await fs.writeFile(path, content);
+	console.log(`${path} created`);
+}