@sealcode/sealgen 0.18.10 → 0.19.2

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

@@ -1,193 +1,54 @@
 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 extract_fields_from_collection from "../../utils/extract-fields-from-collection.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";
-import { single_reference_handler } from "./handlers/single-reference.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,
-	all_other_handlers: Record<
-		string,
-		| FieldHandler<FieldHandlerResult, Partial<FieldHandlerResult>>
-		| undefined
-	>,
-	fields_var?: string
-) => 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,
-	"single-reference": single_reference_handler,
-};
-
-export async function getFieldHandler(
-	collection_name: string,
-	field: ExtractedFieldInfo,
-	importPath: (path: string) => string,
-	fields_var?: string
-) {
-	const defaults = await field_handlers.default(
-		collection_name,
-		field,
-		importPath,
-		{},
-		field_handlers,
-		fields_var
-	);
-
-	const result = {
-		...defaults,
-		...((await field_handlers[field.type]?.(
-			collection_name,
-			field,
-			importPath,
-			defaults,
-			field_handlers,
-			fields_var
-		)) || {}),
-	};
-	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);
+import { wrapAttribute } from "../../utils/wrap-attributes.js";
 
-	const field_handler_results = await Promise.all(
-		collection_fields.map(async (field) => {
-			return getFieldHandler(collection_name, field, importPath);
-		})
-	);
+export async function sharedCrudFormFields(collection_name: string) {
+	const collection_fields =
+		await extract_fields_from_collection(collection_name);
 
-	const result = `import { Controls, Fields } from "@sealcode/sealgen";
-import { ${uppercase_collection} } from "${importPath(
-		"src/back/collections/collections.js"
-	)}";
+	const uppercase_collection = toPascalCase(collection_name);
 
+	const result = `import { type Controls, Fields } from "@sealcode/sealgen";
+import { ${uppercase_collection} } from "src/back/collections/collections.js";
 ${Array.from(
 	new Set(
-		field_handler_results
-			.filter(
-				({ hide_field, hide_control }) => !hide_field && !hide_control
+		collection_fields
+			.map((field_info) =>
+				field_info.form_field.generateImportsForFieldList(field_info)
 			)
-			.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 != "")
+			.flat()
+			.map(
+				({ what, from, as }) =>
+					`import {${what}${as ? ` as ${as}` : ""} } from "${from}"`
+			)
+	).values()
+).join(";\n")}
+
+export const ${toPascalCase(collection_name)}FormFields = <const>{
+	${collection_fields
+		.map((field_info) => {
+			return `${
+				field_info.name
+			}: ${field_info.form_field.generateFieldDeclaration(field_info, {
+				form_field_types: "Fields",
+				sealious_field: `${uppercase_collection}.fields${wrapAttribute(
+					field_info.name
+				)}`,
+			})}`;
+		})
 		.join(",\n")}
 };
 
-export const ${toPascalCase(collection_name)}FormControls = [
-	${field_handler_results
-		.filter(({ hide_control }) => !hide_control)
-		.map(({ controls }) => controls)
-		.filter((e) => e != "")
+const fields = ${toPascalCase(collection_name)}FormFields 
+
+export const get${toPascalCase(
+		collection_name
+	)}FormControls: () => Controls.FormControl[] = () => [
+	${collection_fields
+		.map(({ name }) => `fields${wrapAttribute(name)}.getControl()`)
 		.join(",\n")}
 ];
-
-${Array.from(
-	new Set(
-		field_handler_results.map(({ top_level_shared }) => top_level_shared)
-	)
-).join("\n")}
-
 `;
 	return formatWithPrettier(result);
 }

package/src/templates/templates.ts

@@ -9,7 +9,11 @@ import { redirectTemplate } from "./redirect.js";
 import { statefulPageTemplate } from "./stateful-page.js";
 import { jddEditorTemplate } from "./jdd-editor.js";
 
-export const Templates = {
+export const Templates: Record<
+	string,
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	(action: string, params: any) => Promise<string>
+> = {
 	page: pageTemplate,
 	form: formTemplate,
 	list: listTemplate,

package/src/test_utils/exec_async.ts

@@ -1,18 +1,17 @@
-/* eslint-disable @typescript-eslint/restrict-template-expressions */
 import { exec } from "child_process";
 
 export const execAsync = (cmd: string) => {
 	return new Promise<void>((resolve, reject) => {
 		const process = exec(cmd);
 
-		console.log("EXECUTING", cmd);
+		console.info("EXECUTING", cmd);
 
 		process?.stdout?.on("data", (data) => {
-			console.log(`stdout: ${data}`);
+			console.info(`stdout: ${data}`);
 		});
 
 		process?.stderr?.on("data", (data) => {
-			console.log(`stdout: ${data}`);
+			console.info(`stdout: ${data}`);
 		});
 
 		process.on("exit", (code) => {

package/src/test_utils/test-on-real-app.ts

@@ -15,7 +15,9 @@ const locreq = _locreq(module_dirname(import.meta.url));
 
 export const callSealgenBin = () => `node ${locreq.resolve("lib/cli.js")}`;
 
-const sealious_minimal_commit = "833e70c";
+const sealious_minimal_url =
+	"https://hub.sealcode.org/source/sealious-minimal.git";
+const sealious_minimal_commit = "77e3794";
 
 export class RealAppTest {
 	public node_pid: number;
@@ -31,18 +33,18 @@ export class RealAppTest {
 		const timestamp = Date.now();
 		test_app.app_path = `/tmp/sealious-minimal-${timestamp}`;
 		test_app.container_name = `sealgen-test-mongo-${timestamp}`;
-		console.log("\tcloning sealious-minimal...");
+		console.info("\tcloning sealious-minimal...");
 		await execAsync(
-			`git clone https://hub.sealcode.org/source/sealious-minimal.git ${test_app.app_path} && cd ${test_app.app_path} && git checkout ${sealious_minimal_commit}`
+			`git clone ${sealious_minimal_url} ${test_app.app_path} && cd ${test_app.app_path} && git checkout ${sealious_minimal_commit}`
 		);
-		console.log("\tinstalling dependencies and sealgen...");
+		console.info("\tinstalling dependencies and sealgen...");
 		await execAsync(
 			`cd ${
 				test_app.app_path
 			} && npm ci rm -rf node_modules/@sealcode/sealgen && ln -s $OLDPWD node_modules/@sealcode/sealgen && ${callSealgenBin()} make-env`
 		);
 
-		console.log(
+		console.info(
 			"\tstarting the database...(if timeouts here, run 'docker pull mongo:4.4-bionic' to solve)"
 		);
 		await test_app.runSealgenCommand("build");
@@ -61,7 +63,7 @@ export class RealAppTest {
 			SEALIOUS_PORT: this.app_port.toString(),
 		};
 		const node_args = [`${this.app_path}/dist/back/index.js`];
-		console.log(
+		console.info(
 			"EXECUTING APP",
 			`${Object.entries(env)
 				.map(([key, value]) => `${key}=${value}`)
@@ -71,9 +73,9 @@ export class RealAppTest {
 			env,
 		});
 		app_start.stdout.on("data", (data) =>
-			console.log("APP OUTPUT:", data.toString())
+			console.info("APP OUTPUT:", data.toString())
 		);
-		app_start.stderr.on("data", (data) => console.log(data.toString()));
+		app_start.stderr.on("data", (data) => console.info(data.toString()));
 		app_start.on("exit", (code) => {
 			this.emitter.emit("exit", code);
 			this.emitter.emit("process_error");
@@ -86,7 +88,7 @@ export class RealAppTest {
 			output: "silent",
 			timeout: 6000,
 		});
-		console.log(
+		console.info(
 			chalk.yellow(
 				`App is listening on http://localhost:${this.app_port}`
 			)
@@ -96,7 +98,7 @@ export class RealAppTest {
 	async close() {
 		try {
 			if (this.node_pid != 0) await execAsync(`kill -9 ${this.node_pid}`);
-		} catch (error) {
+		} catch (_error) {
 			throw new Error(
 				"node process exited unexpectedly, please inspect the output"
 			);
@@ -160,7 +162,6 @@ export class RealAppTest {
 		path: string,
 		body: Record<string, unknown>
 	): Promise<{ status: number; response: string }> {
-		console.debug("POST", path, body);
 		return this.throwIfItKillsTheApp(async () => {
 			const ret = await fetch(
 				`http://localhost:${this.app_port}${path}`,
@@ -173,14 +174,12 @@ export class RealAppTest {
 			const status = ret.status;
 			const response = await ret.text();
 
-			console.debug("request done!");
-			console.debug({ response });
 			return { status, response };
 		});
 	}
 
 	async addFile(target_path: string, content: string) {
-		console.log(
+		console.info(
 			chalk.yellow("Inserting file at path"),
 			chalk.green(target_path),
 			"with content\n",

package/src/utils/browser-creator.js

@@ -2,7 +2,6 @@ import { firefox } from "playwright";
 
 let browser_promise = null;
 
-// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
 export async function getBrowser() {
 	if (!browser_promise) browser_promise = firefox.launch();
 	// eslint-disable-next-line @typescript-eslint/no-unsafe-return

package/src/utils/exec.ts

@@ -1,4 +1,3 @@
-/* eslint-disable no-console */
 import { spawn } from "child_process";
 
 export async function exec(

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

@@ -3,6 +3,8 @@ import { exec } from "./utils.js";
 const target_locreq = _locreq(process.cwd());
 import { promises as fs } from "fs";
 import { is, predicates } from "@sealcode/ts-predicates";
+import { FormField } from "../forms/fields/field.js";
+import { sealiousFieldInfoToFormField } from "../forms/fields/get-field-for-sealious.js";
 
 export type ExtractedFieldInfo = {
 	name: string;
@@ -16,6 +18,10 @@ export type ExtractedFieldInfo = {
 	subfields: { name: string }[];
 };
 
+export type ExtractedFieldInfoWithFormField = ExtractedFieldInfo & {
+	form_field: FormField;
+};
+
 const counter = (function* () {
 	let i = 0;
 	while (true) {
@@ -23,11 +29,19 @@ const counter = (function* () {
 	}
 })();
 
+const cache = {} as Record<
+	string,
+	Promise<ExtractedFieldInfoWithFormField[]> | undefined
+>;
+
 export default async function extract_fields_from_collection(
 	collection_name: string
-): Promise<ExtractedFieldInfo[]> {
+): Promise<ExtractedFieldInfoWithFormField[]> {
+	if (cache[collection_name]) {
+		return cache[collection_name];
+	}
 	const extractor_code = `import {default as the_app} from "./app.js";
-const c = new the_app().collections["${collection_name}"];
+	const c = new the_app({}).collections["${collection_name}"];
 const fields = [];
 for (const field_name in c.fields){
     let field = c.fields[field_name];
@@ -37,14 +51,17 @@ for (const field_name in c.fields){
     let referencing_field = null;
     let intermediary_field_that_points_there = null;
     let is_readonly = false;
-    let is_required = field.required;
+    let is_required = field.required || false;
     let subfields = [];
-    if(["derived-value", "cached-value", "settable-by"].includes(type)){
+    if(["derived-value", "cached-value", "settable-by",  "control-access"].includes(type)){
 	    type = field.virtual_field.typeName;
     }
     if(["derived-value", "cached-value", "reverse-single-reference"].includes(field.typeName)){
 	    is_readonly = true;
     }
+    if(type == "single-reference"){
+		target = field.target_collection;
+    }
     if(type == "deep-reverse-single-reference" || type =="reverse-single-reference"){
 		target = field.target_collection;
         referencing_collection = field.referencing_collection;
@@ -62,25 +79,59 @@ for (const field_name in c.fields){
 		`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]);
-	await fs.unlink(extractor_code_path);
-	const ret = JSON.parse(stdout) as unknown;
-	if (
-		!is(
-			ret,
-			predicates.array(
-				predicates.shape({
-					name: predicates.string,
-					type: predicates.string,
-					is_readonly: predicates.boolean,
-				})
-			)
-		)
-	) {
-		throw new Error(
-			"Encountered a problem while extracting the names of fields from collection. Got: " +
-				stdout
-		);
-	}
-	return ret as ExtractedFieldInfo[];
+	const result = exec("node", [extractor_code_path])
+		.then(async ({ stdout }) => {
+			await fs.unlink(extractor_code_path);
+			const ret = JSON.parse(stdout) as unknown;
+			if (
+				!is(
+					ret,
+					predicates.array(
+						predicates.shape({
+							name: predicates.string,
+							type: predicates.string,
+							is_readonly: predicates.boolean,
+							target: predicates.or(
+								predicates.string,
+								predicates.null
+							),
+							referencing_collection: predicates.or(
+								predicates.string,
+								predicates.null
+							),
+							referencing_field: predicates.or(
+								predicates.string,
+								predicates.null
+							),
+							is_required: predicates.boolean,
+							intermediary_field_that_points_there: predicates.or(
+								predicates.string,
+								predicates.null
+							),
+							subfields: predicates.array(
+								predicates.shape({ name: predicates.string })
+							),
+						})
+					)
+				)
+			) {
+				throw new Error(
+					"Encountered a problem while extracting the names of fields from collection. Got: " +
+						stdout
+				);
+			}
+			const result = (await Promise.all(
+				ret.map(async (field_info) => ({
+					...field_info,
+					form_field: await sealiousFieldInfoToFormField(field_info),
+				}))
+			)) as ExtractedFieldInfoWithFormField[];
+			return result;
+		})
+		.catch((e) => {
+			console.error("ERROR", e);
+			process.exit(1);
+		});
+	cache[collection_name] = result;
+	return result;
 }

package/src/utils/input-wrapper.ts

@@ -13,7 +13,7 @@ export async function inputWrapper(
 	modifiers: string[],
 	input: FlatTemplatable
 ): Promise<string> {
-	return tempstream/* HTML */ `<div
+	return tempstream /* HTML */ `<div
 		class="form-input form-input--type-${type} form-input__wrapper ${getModifierClasses(
 			modifiers
 		)}"

package/src/utils/make-slug.ts

@@ -1,5 +1,5 @@
 export function makeSlug(t: string) {
 	return t
-		.replaceAll(/\P{General_Category=Letter}/g, "-")
+		.replaceAll(/\P{General_Category=Letter}/gu, "-")
 		.replaceAll(/-+/g, "-");
 }

package/src/utils/wrap-attributes.ts

@@ -0,0 +1,17 @@
+export function needsQuotes(str: string) {
+	try {
+		// eslint-disable-next-line  @typescript-eslint/no-implied-eval
+		new Function(`var obj = { ${str}: 1 };`);
+		return false;
+	} catch {
+		return true;
+	}
+}
+
+export function wrapAttribute(name: string) {
+	return needsQuotes(name) ? `["${name}"]` : `.${name}`;
+}
+
+export function wrapKeyName(name: string) {
+	return needsQuotes(name) ? `["${name}"]` : `${name}`;
+}

package/src/utils/write-file.ts

@@ -4,5 +4,5 @@ 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`);
+	console.info(`${path} created`);
 }

package/.eslintrc.cjs

@@ -1,39 +0,0 @@
-module.exports = {
-	env: { node: true },
-	parser: "@typescript-eslint/parser",
-	plugins: ["@typescript-eslint", "prettier"],
-	extends: [
-		"eslint:recommended",
-		"plugin:@typescript-eslint/recommended",
-		"plugin:@typescript-eslint/recommended-requiring-type-checking",
-		"plugin:prettier/recommended",
-	],
-	ignorePatterns: [".eslintrc.js", "src/**/*.test.ts", "@types/*"],
-	parserOptions: {
-		sourceType: "module",
-		ecmaFeatures: {
-			modules: true,
-		},
-		project: ["./tsconfig.json"],
-	},
-	rules: {
-		"@typescript-eslint/require-await": 0,
-		"no-await-in-loop": 2,
-		"@typescript-eslint/no-unused-vars": ["warn", { args: "none", "varsIgnorePattern": "^_", }],
-		"@typescript-eslint/no-this-alias": 0
-	},
-	settings: { jsdoc: { mode: "typescript" } },
-	overrides: [
-		{
-			files: ["*.subtest.ts", "*.test.ts"],
-			rules: {
-				"@typescript-eslint/no-unsafe-member-access": 0,
-				"prefer-const": 0,
-				"@typescript-eslint/no-unsafe-call": 0,
-				"@typescript-eslint/no-unsafe-return": 0,
-				"@typescript-eslint/no-unsafe-assignment": 0,
-				"no-await-in-loop": 1, // sometimes it's easier to debug when requests run sequentially
-			},
-		},
-	],
-};