@sealcode/sealgen 0.18.2 → 0.18.5

package/src/register-external.test.ts

@@ -0,0 +1,469 @@
+import assert from "assert";
+import { promises as fs } from "fs";
+import path from "path";
+import { RealAppTest } from "./test_utils/test-on-real-app.js";
+
+// Helper function to ensure sealgen configuration exists
+async function ensureSealgenConfig(test_app: RealAppTest): Promise<void> {
+	const packageJsonPath = path.join(test_app.app_path, "package.json");
+	let packageJsonContent = await fs.readFile(packageJsonPath, "utf-8");
+	let packageJson = JSON.parse(packageJsonContent);
+
+	if (!packageJson.sealgen) {
+		packageJson.sealgen = {};
+	}
+
+	await fs.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2));
+}
+
+// Helper function to create mock external module
+async function createMockExternalModule(
+	test_app: RealAppTest,
+	moduleName: string,
+	subdirectory: string,
+	files: Array<{ name: string; content: string }>
+): Promise<void> {
+	const externalModulePath = path.join(test_app.app_path, "node_modules", moduleName);
+	const targetPath = path.join(externalModulePath, subdirectory);
+
+	await fs.mkdir(targetPath, { recursive: true });
+
+	for (const file of files) {
+		await fs.writeFile(path.join(targetPath, file.name), file.content);
+		// If the file is a .ts controller, also create a .js file for build import
+		if (file.name.endsWith(".ts") && file.name.includes("stimulus")) {
+			const jsName = file.name.replace(/\.ts$/, ".js");
+			const exportName = file.name.replace(/\.stimulus\.ts$/, "");
+			await fs.writeFile(
+				path.join(targetPath, jsName),
+				`export default { connect() { console.log('Dummy JS for ${exportName}'); } }`
+			);
+		}
+	}
+}
+
+describe("register-external CLI commands", () => {
+	describe("package.json configuration", () => {
+		it("registers external controllers and verifies package.json is updated", async function () {
+			const test_app = await RealAppTest.init();
+			await ensureSealgenConfig(test_app);
+
+			const moduleName = "test-controller-module";
+			const subdirectory = "controllers";
+
+			await test_app.runSealgenCommand(
+				`register-external-controllers ${moduleName} ${subdirectory}`
+			);
+
+			// Verify package.json was updated correctly
+			const packageJsonPath = path.join(test_app.app_path, "package.json");
+			const packageJsonContent = await fs.readFile(packageJsonPath, "utf-8");
+			const packageJson = JSON.parse(packageJsonContent);
+
+			assert(packageJson.sealgen, "sealgen configuration should exist");
+			assert(packageJson.sealgen.controllerDirs, "controllerDirs should exist");
+			assert(
+				Array.isArray(packageJson.sealgen.controllerDirs),
+				"controllerDirs should be an array"
+			);
+
+			const expectedPath = `node_modules/${moduleName}/${subdirectory}`;
+			assert(
+				packageJson.sealgen.controllerDirs.includes(expectedPath),
+				`controllerDirs should contain ${expectedPath}`
+			);
+
+			await test_app.close();
+		}).timeout(100 * 1000);
+
+		it("registers external styles and verifies package.json is updated", async function () {
+			const test_app = await RealAppTest.init();
+			await ensureSealgenConfig(test_app);
+
+			const moduleName = "test-style-module";
+			const subdirectory = "styles";
+
+			await test_app.runSealgenCommand(
+				`register-external-styles ${moduleName} ${subdirectory}`
+			);
+
+			// Verify package.json was updated correctly
+			const packageJsonPath = path.join(test_app.app_path, "package.json");
+			const packageJsonContent = await fs.readFile(packageJsonPath, "utf-8");
+			const packageJson = JSON.parse(packageJsonContent);
+
+			assert(packageJson.sealgen, "sealgen configuration should exist");
+			assert(packageJson.sealgen.styleDirs, "styleDirs should exist");
+			assert(Array.isArray(packageJson.sealgen.styleDirs), "styleDirs should be an array");
+
+			const expectedPath = `node_modules/${moduleName}/${subdirectory}`;
+			assert(
+				packageJson.sealgen.styleDirs.includes(expectedPath),
+				`styleDirs should contain ${expectedPath}`
+			);
+
+			await test_app.close();
+		}).timeout(100 * 1000);
+
+		it("registers both controllers and styles in the same project", async function () {
+			const test_app = await RealAppTest.init();
+			await ensureSealgenConfig(test_app);
+
+			const controllerModule = "test-controller-module";
+			const controllerSubdir = "controllers";
+			const styleModule = "test-style-module";
+			const styleSubdir = "styles";
+
+			await test_app.runSealgenCommand(
+				`register-external-controllers ${controllerModule} ${controllerSubdir}`
+			);
+			await test_app.runSealgenCommand(
+				`register-external-styles ${styleModule} ${styleSubdir}`
+			);
+
+			// Verify package.json was updated correctly for both
+			const packageJsonPath = path.join(test_app.app_path, "package.json");
+			const packageJsonContent = await fs.readFile(packageJsonPath, "utf-8");
+			const packageJson = JSON.parse(packageJsonContent);
+
+			assert(packageJson.sealgen, "sealgen configuration should exist");
+			assert(packageJson.sealgen.controllerDirs, "controllerDirs should exist");
+			assert(packageJson.sealgen.styleDirs, "styleDirs should exist");
+
+			const expectedControllerPath = `node_modules/${controllerModule}/${controllerSubdir}`;
+			const expectedStylePath = `node_modules/${styleModule}/${styleSubdir}`;
+
+			assert(
+				packageJson.sealgen.controllerDirs.includes(expectedControllerPath),
+				`controllerDirs should contain ${expectedControllerPath}`
+			);
+			assert(
+				packageJson.sealgen.styleDirs.includes(expectedStylePath),
+				`styleDirs should contain ${expectedStylePath}`
+			);
+
+			await test_app.close();
+		}).timeout(100 * 1000);
+
+		it("handles duplicate registrations gracefully", async function () {
+			const test_app = await RealAppTest.init();
+			await ensureSealgenConfig(test_app);
+
+			const moduleName = "test-duplicate-module";
+			const subdirectory = "controllers";
+
+			// Register the same module twice
+			await test_app.runSealgenCommand(
+				`register-external-controllers ${moduleName} ${subdirectory}`
+			);
+			await test_app.runSealgenCommand(
+				`register-external-controllers ${moduleName} ${subdirectory}`
+			);
+
+			// Verify package.json was updated correctly (should not have duplicates)
+			const packageJsonPath = path.join(test_app.app_path, "package.json");
+			const packageJsonContent = await fs.readFile(packageJsonPath, "utf-8");
+			const packageJson = JSON.parse(packageJsonContent);
+
+			assert(packageJson.sealgen, "sealgen configuration should exist");
+			assert(packageJson.sealgen.controllerDirs, "controllerDirs should exist");
+
+			const expectedPath = `node_modules/${moduleName}/${subdirectory}`;
+			const controllerDirs = packageJson.sealgen.controllerDirs as string[];
+
+			// Should only appear once
+			const occurrences = controllerDirs.filter((dir) => dir === expectedPath).length;
+			assert(
+				occurrences === 1,
+				`controllerDirs should contain ${expectedPath} exactly once, found ${occurrences} times`
+			);
+
+			await test_app.close();
+		}).timeout(100 * 1000);
+
+		it("preserves existing sealgen configuration when adding new entries", async function () {
+			const test_app = await RealAppTest.init();
+
+			// First, manually add some existing configuration to package.json
+			const packageJsonPath = path.join(test_app.app_path, "package.json");
+			const packageJsonContent = await fs.readFile(packageJsonPath, "utf-8");
+			const packageJson = JSON.parse(packageJsonContent);
+
+			// Add existing sealgen configuration
+			packageJson.sealgen = {
+				controllerDirs: ["node_modules/existing-controller/controllers"],
+				styleDirs: ["node_modules/existing-style/styles"],
+			};
+
+			await fs.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2));
+
+			// Now register new external modules
+			const newControllerModule = "new-controller-module";
+			const newStyleModule = "new-style-module";
+
+			await test_app.runSealgenCommand(
+				`register-external-controllers ${newControllerModule} controllers`
+			);
+			await test_app.runSealgenCommand(`register-external-styles ${newStyleModule} styles`);
+
+			// Verify both old and new configurations are preserved
+			const updatedPackageJsonContent = await fs.readFile(packageJsonPath, "utf-8");
+			const updatedPackageJson = JSON.parse(updatedPackageJsonContent);
+
+			assert(updatedPackageJson.sealgen, "sealgen configuration should exist");
+			assert(updatedPackageJson.sealgen.controllerDirs, "controllerDirs should exist");
+			assert(updatedPackageJson.sealgen.styleDirs, "styleDirs should exist");
+
+			// Check that existing entries are preserved
+			assert(
+				updatedPackageJson.sealgen.controllerDirs.includes(
+					"node_modules/existing-controller/controllers"
+				),
+				"Existing controller directory should be preserved"
+			);
+			assert(
+				updatedPackageJson.sealgen.styleDirs.includes("node_modules/existing-style/styles"),
+				"Existing style directory should be preserved"
+			);
+
+			// Check that new entries are added
+			assert(
+				updatedPackageJson.sealgen.controllerDirs.includes(
+					`node_modules/${newControllerModule}/controllers`
+				),
+				"New controller directory should be added"
+			);
+			assert(
+				updatedPackageJson.sealgen.styleDirs.includes(
+					`node_modules/${newStyleModule}/styles`
+				),
+				"New style directory should be added"
+			);
+
+			await test_app.close();
+		}).timeout(100 * 1000);
+	});
+
+	describe("build integration", () => {
+		it("registers external controllers and verifies they are included in build", async function () {
+			const test_app = await RealAppTest.init();
+			await ensureSealgenConfig(test_app);
+
+			// Create a mock external module with controllers
+			const externalModuleName = "test-external-controllers";
+			await createMockExternalModule(test_app, externalModuleName, "controllers", [
+				{
+					name: "test-external.stimulus.ts",
+					content: `
+import { Controller } from "stimulus";
+
+export default class TestExternalController extends Controller {
+	static targets = ["output"];
+	
+	connect() {
+		console.log("External controller connected!");
+	}
+}
+`,
+				},
+			]);
+
+			// Register the external controllers
+			await test_app.runSealgenCommand(
+				`register-external-controllers ${externalModuleName} controllers`
+			);
+
+			// Run the build process
+			await test_app.runSealgenCommand("build");
+
+			// Verify the controllers are included in the build
+			const controllersFilePath = path.join(test_app.app_path, "src/front/controllers.ts");
+			const controllersContent = await fs.readFile(controllersFilePath, "utf-8");
+
+			// Check that the external controller is imported
+			assert(
+				controllersContent.includes(
+					`import { default as TestExternal } from "./../../node_modules/${externalModuleName}/controllers/test-external.stimulus.js"`
+				),
+				"External controller should be imported in generated controllers file"
+			);
+
+			// Check that the controller is registered
+			assert(
+				controllersContent.includes(`application.register("test-external", TestExternal);`),
+				"External controller should be registered in generated controllers file"
+			);
+
+			// Verify the build output exists
+			const bundlePath = path.join(test_app.app_path, "public/dist/bundle.js");
+			assert(
+				await fs
+					.stat(bundlePath)
+					.then(() => true)
+					.catch(() => false),
+				"Bundle should be generated"
+			);
+
+			await test_app.close();
+		}).timeout(100 * 1000);
+
+		it("registers external styles and verifies they are included in build", async function () {
+			const test_app = await RealAppTest.init();
+			await ensureSealgenConfig(test_app);
+
+			// Create a mock external module with styles
+			const externalModuleName = "test-external-styles";
+			await createMockExternalModule(test_app, externalModuleName, "styles", [
+				{
+					name: "external.css",
+					content: `
+.external-style {
+	color: red;
+	background: blue;
+}
+`,
+				},
+			]);
+
+			// Register the external styles
+			await test_app.runSealgenCommand(
+				`register-external-styles ${externalModuleName} styles`
+			);
+
+			// Run the build process
+			await test_app.runSealgenCommand("build");
+
+			// Verify the styles are included in the build
+			const styleEntrypointPath = path.join(
+				test_app.app_path,
+				"src/style-entrypoints/default.entrypoint.css"
+			);
+			const styleEntrypointContent = await fs.readFile(styleEntrypointPath, "utf-8");
+
+			// Check that the external CSS is imported
+			assert(
+				styleEntrypointContent.includes(
+					`@import "../../node_modules/${externalModuleName}/styles/external.css"`
+				),
+				"External CSS should be imported in generated style entrypoint"
+			);
+
+			// Verify the CSS build output exists
+			const cssOutputPath = path.join(
+				test_app.app_path,
+				"public/dist/default.entrypoint.css"
+			);
+			assert(
+				await fs
+					.stat(cssOutputPath)
+					.then(() => true)
+					.catch(() => false),
+				"CSS should be generated"
+			);
+
+			await test_app.close();
+		}).timeout(100 * 1000);
+
+		it("registers both external controllers and styles and verifies complete build integration", async function () {
+			const test_app = await RealAppTest.init();
+			await ensureSealgenConfig(test_app);
+
+			// Create mock external modules
+			const controllerModuleName = "test-external-controllers";
+			const styleModuleName = "test-external-styles";
+
+			// Create controller module
+			await createMockExternalModule(test_app, controllerModuleName, "controllers", [
+				{
+					name: "combined-test.stimulus.ts",
+					content: `
+import { Controller } from "stimulus";
+
+export default class CombinedTestController extends Controller {
+	static targets = ["output"];
+	
+	connect() {
+		console.log("Combined test controller connected!");
+	}
+}
+`,
+				},
+			]);
+
+			// Create style module
+			await createMockExternalModule(test_app, styleModuleName, "styles", [
+				{
+					name: "combined-external.css",
+					content: `
+.combined-external-style {
+	color: green;
+	background: yellow;
+}
+`,
+				},
+			]);
+
+			// Register both external modules
+			await test_app.runSealgenCommand(
+				`register-external-controllers ${controllerModuleName} controllers`
+			);
+			await test_app.runSealgenCommand(`register-external-styles ${styleModuleName} styles`);
+
+			// Run the build process
+			await test_app.runSealgenCommand("build");
+
+			// Verify controllers are included
+			const controllersFilePath = path.join(test_app.app_path, "src/front/controllers.ts");
+			const controllersContent = await fs.readFile(controllersFilePath, "utf-8");
+
+			assert(
+				controllersContent.includes(
+					`import { default as CombinedTest } from "./../../node_modules/${controllerModuleName}/controllers/combined-test.stimulus.js"`
+				),
+				"Combined test controller should be imported"
+			);
+			assert(
+				controllersContent.includes(`application.register("combined-test", CombinedTest);`),
+				"Combined test controller should be registered"
+			);
+
+			// Verify styles are included
+			const styleEntrypointPath = path.join(
+				test_app.app_path,
+				"src/style-entrypoints/default.entrypoint.css"
+			);
+			const styleEntrypointContent = await fs.readFile(styleEntrypointPath, "utf-8");
+
+			assert(
+				styleEntrypointContent.includes(
+					`@import "../../node_modules/${styleModuleName}/styles/combined-external.css"`
+				),
+				"Combined external CSS should be imported"
+			);
+
+			// Verify build outputs exist
+			const bundlePath = path.join(test_app.app_path, "public/dist/bundle.js");
+			const cssOutputPath = path.join(
+				test_app.app_path,
+				"public/dist/default.entrypoint.css"
+			);
+
+			assert(
+				await fs
+					.stat(bundlePath)
+					.then(() => true)
+					.catch(() => false),
+				"Bundle should be generated"
+			);
+			assert(
+				await fs
+					.stat(cssOutputPath)
+					.then(() => true)
+					.catch(() => false),
+				"CSS should be generated"
+			);
+
+			await test_app.close();
+		}).timeout(100 * 1000);
+	});
+});

package/src/register-external.ts

@@ -0,0 +1,148 @@
+import { promises as fs, existsSync, readFileSync } from "fs";
+import { resolve, dirname } from "path";
+
+import { formatWithPrettier } from "./utils/prettier.js";
+
+interface PackageJson {
+	sealgen?: {
+		controllerDirs?: string[];
+		styleDirs?: string[];
+		[key: string]: unknown;
+	};
+	[key: string]: unknown;
+}
+
+function findParentProjectWithSealgen(): string {
+	let currentDir = process.cwd();
+
+	while (currentDir !== dirname(currentDir)) {
+		const packageJsonPath = resolve(currentDir, "package.json");
+
+		if (existsSync(packageJsonPath)) {
+			try {
+				const packageJsonContent = readFileSync(
+					packageJsonPath,
+					"utf-8"
+				);
+				const packageJson = JSON.parse(
+					packageJsonContent
+				) as PackageJson;
+
+				// Check if this package.json has a sealgen configuration
+				if (packageJson.sealgen) {
+					return currentDir;
+				}
+			} catch (error) {
+				// If we can't read or parse the package.json, continue to parent
+				console.warn(
+					`Warning: Could not read package.json at ${packageJsonPath}:`,
+					error
+				);
+			}
+		}
+
+		currentDir = dirname(currentDir);
+	}
+
+	throw new Error(
+		"Could not find a parent project with sealgen configuration"
+	);
+}
+
+async function updatePackageJson(
+	projectDir: string,
+	moduleName: string,
+	subdirectory: string,
+	type: "controllerDirs" | "styleDirs"
+): Promise<void> {
+	const packageJsonPath = resolve(projectDir, "package.json");
+	const packageJsonContent = await fs.readFile(packageJsonPath, "utf-8");
+	const packageJson = JSON.parse(packageJsonContent) as PackageJson;
+
+	// Initialize sealgen configuration if it doesn't exist
+	if (!packageJson.sealgen) {
+		packageJson.sealgen = {};
+	}
+
+	// Initialize the specific array if it doesn't exist
+	if (!packageJson.sealgen[type]) {
+		packageJson.sealgen[type] = [];
+	}
+
+	const pathToAdd = `node_modules/${moduleName}/${subdirectory}`;
+	const existingPaths = packageJson.sealgen[type] as string[];
+
+	// Check if the path is already present
+	if (existingPaths.includes(pathToAdd)) {
+		console.log(`${type} already contains: ${pathToAdd}`);
+		return;
+	}
+
+	// Add the new path
+	existingPaths.push(pathToAdd);
+
+	// Write back the updated package.json with proper formatting
+	const updatedContent = await formatWithPrettier(
+		JSON.stringify(packageJson, null, 2),
+		"json"
+	);
+
+	await fs.writeFile(packageJsonPath, updatedContent);
+	console.log(`Added ${pathToAdd} to ${type} in ${packageJsonPath}`);
+}
+
+export async function registerExternalControllers(
+	args: Record<string, string | boolean>
+): Promise<void> {
+	// Extract positional arguments from process.argv since yargs doesn't handle them for these commands
+	const moduleName = process.argv.at(3);
+	const subdirectory = process.argv.at(4);
+
+	if (!moduleName || !subdirectory) {
+		console.error(
+			"Usage: npx sealgen register-external-controllers <module-name> <subdirectory>"
+		);
+		process.exit(1);
+	}
+
+	try {
+		const projectDir = findParentProjectWithSealgen();
+		await updatePackageJson(
+			projectDir,
+			moduleName,
+			subdirectory,
+			"controllerDirs"
+		);
+	} catch (error) {
+		console.error("Error:", error instanceof Error ? error.message : error);
+		process.exit(1);
+	}
+}
+
+export async function registerExternalStyles(
+	args: Record<string, string | boolean>
+): Promise<void> {
+	// Extract positional arguments from process.argv since yargs doesn't handle them for these commands
+	const moduleName = process.argv.at(3);
+	const subdirectory = process.argv.at(4);
+
+	if (!moduleName || !subdirectory) {
+		console.error(
+			"Usage: npx sealgen register-external-styles <module-name> <subdirectory>"
+		);
+		process.exit(1);
+	}
+
+	try {
+		const projectDir = findParentProjectWithSealgen();
+		await updatePackageJson(
+			projectDir,
+			moduleName,
+			subdirectory,
+			"styleDirs"
+		);
+	} catch (error) {
+		console.error("Error:", error instanceof Error ? error.message : error);
+		process.exit(1);
+	}
+}

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

@@ -12,6 +12,7 @@ export const default_handler: FieldHandler<
 	{ name, is_readonly, is_required },
 	_,
 	__,
+	___,
 	fields_var = `${toPascalCase(collection_name)}FormFields`
 ) => {
 	const required_s = `${toPascalCase(

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

@@ -61,6 +61,11 @@ export type FieldHandler<
 	field: ExtractedFieldInfo,
 	importPath: (path: string) => string,
 	defaults: Defaults,
+	all_other_handlers: Record<
+		string,
+		| FieldHandler<FieldHandlerResult, Partial<FieldHandlerResult>>
+		| undefined
+	>,
 	fields_var?: string
 ) => Promise<Result>;
 
@@ -95,8 +100,10 @@ export async function getFieldHandler(
 		field,
 		importPath,
 		{},
+		field_handlers,
 		fields_var
 	);
+
 	const result = {
 		...defaults,
 		...((await field_handlers[field.type]?.(
@@ -104,6 +111,7 @@ export async function getFieldHandler(
 			field,
 			importPath,
 			defaults,
+			field_handlers,
 			fields_var
 		)) || {}),
 	};

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

@@ -30,7 +30,7 @@ export default async function extract_fields_from_collection(
 const c = new the_app().collections["${collection_name}"];
 const fields = [];
 for (const field_name in c.fields){
-    const field = c.fields[field_name];
+    let field = c.fields[field_name];
     let type = field.typeName;
     let target = null;
     let referencing_collection = null;
@@ -39,7 +39,7 @@ for (const field_name in c.fields){
     let is_readonly = false;
     let is_required = field.required;
     let subfields = [];
-    if(["derived-value", "cached-value"].includes(type)){
+    if(["derived-value", "cached-value", "settable-by"].includes(type)){
 	    type = field.virtual_field.typeName;
     }
     if(["derived-value", "cached-value", "reverse-single-reference"].includes(field.typeName)){
@@ -52,7 +52,7 @@ for (const field_name in c.fields){
 		intermediary_field_that_points_there = field.intermediary_field_that_points_there
     }
     if( type == "structured-array" ) {
-         subfields = Object.keys(field.subfields).map(key=>({name: key}));
+         subfields = Object.keys(field.subfields || field.virtual_field.subfields).map(key=>({name: key}));
     }
     fields.push({ name: field_name, type, target, referencing_collection, referencing_field, intermediary_field_that_points_there, is_readonly, is_required, subfields })
 }