chore: update version to 4.0.0-beta.1 and introduce new v4.0 schematics including interceptor, event, handler, guard, and config generation

Author: rsaz

commitlint.config.ts

@@ -2,6 +2,11 @@ import type { UserConfig } from "@commitlint/types";
 
 const Configuration: UserConfig = {
 	extends: ["@commitlint/config-conventional"],
+	rules: {
+		"subject-max-length": [0],
+		"body-max-line-length": [0],
+		"header-max-length": [0],
+	},
 };
 
 export default Configuration;

src/cli.ts

@@ -22,7 +22,7 @@ import { scriptsCommand } from "./scripts";
  * The current version of the ExpressoTS Bundle.
  * core, adapters, and cli.
  */
-export const BUNDLE_VERSION = "3.0.0";
+export const BUNDLE_VERSION = "4.0.0-beta.1";
 
 stdout.write(`\n${[chalk.bold.green("🐎 Expressots")]}\n\n`);
 

src/commands/project.commands.ts

@@ -88,7 +88,7 @@ async function buildDevArgs(
 		"--signal",
 		"SIGTERM", // Use SIGTERM for graceful shutdown
 		"--delay",
-		"500ms", // Debounce rapid file changes
+		"1000ms", // Debounce rapid file changes (allow time for port release)
 		"--watch",
 		"src",
 		"--ext",
@@ -203,24 +203,138 @@ const compileTypescript = async () => {
 	printSuccess("Built successfully", "compile-typescript");
 };
 
+/**
+ * Transform path aliases to relative paths in compiled JavaScript files.
+ * This runs after TypeScript compilation to ensure production builds work
+ * without runtime path resolution.
+ *
+ * @param outDir - The output directory (e.g., "./dist")
+ */
+const transformPathAliases = async (outDir: string): Promise<void> => {
+	const tsconfigPath = join(process.cwd(), "tsconfig.build.json");
+
+	if (!existsSync(tsconfigPath)) {
+		return; // No tsconfig.build.json, skip transformation
+	}
+
+	const tsconfig = JSON.parse(readFileSync(tsconfigPath, "utf-8"));
+	const paths = tsconfig.compilerOptions?.paths;
+	const baseUrl = tsconfig.compilerOptions?.baseUrl;
+
+	if (!paths || !baseUrl) {
+		return; // No path aliases defined, skip
+	}
+
+	// Build regex patterns for each alias
+	const aliasPatterns: Array<{
+		pattern: RegExp;
+		alias: string;
+		target: string;
+	}> = [];
+
+	for (const [alias, targets] of Object.entries(paths)) {
+		if (!Array.isArray(targets) || targets.length === 0) continue;
+
+		// Convert @alias/* to regex pattern
+		// Matches: require("@alias/something") or require('@alias/something')
+		const aliasBase = alias.replace("/*", "");
+		const targetBase = (targets[0] as string).replace("/*", "");
+
+		// Pattern to match require("@alias/...") or require('@alias/...')
+		const pattern = new RegExp(
+			`require\\(["']${aliasBase.replace("@", "\\@")}/([^"']+)["']\\)`,
+			"g",
+		);
+
+		aliasPatterns.push({
+			pattern,
+			alias: aliasBase,
+			target: targetBase,
+		});
+	}
+
+	if (aliasPatterns.length === 0) {
+		return;
+	}
+
+	// Recursively find all .js files in outDir
+	const findJsFiles = async (dir: string): Promise<Array<string>> => {
+		const files: Array<string> = [];
+		const entries = await fs.readdir(dir, { withFileTypes: true });
+
+		for (const entry of entries) {
+			const fullPath = join(dir, entry.name);
+			if (entry.isDirectory()) {
+				files.push(...(await findJsFiles(fullPath)));
+			} else if (entry.name.endsWith(".js")) {
+				files.push(fullPath);
+			}
+		}
+
+		return files;
+	};
+
+	const jsFiles = await findJsFiles(outDir);
+	let transformedCount = 0;
+
+	for (const file of jsFiles) {
+		let content = await fs.readFile(file, "utf-8");
+		let modified = false;
+
+		// Get the directory of the current file relative to outDir
+		const fileDir = path.dirname(file);
+
+		for (const { pattern, alias, target } of aliasPatterns) {
+			// Calculate the relative path from this file to the target
+			const targetDir = join(outDir, baseUrl.replace("./", ""), target);
+			let relativePath = path.relative(fileDir, targetDir);
+
+			// Ensure it starts with ./ or ../
+			if (!relativePath.startsWith(".")) {
+				relativePath = "./" + relativePath;
+			}
+
+			// Replace Windows backslashes with forward slashes
+			relativePath = relativePath.replace(/\\/g, "/");
+
+			// Replace the alias with the relative path
+			const newContent = content.replace(pattern, (match, subPath) => {
+				modified = true;
+				return `require("${relativePath}/${subPath}")`;
+			});
+
+			if (newContent !== content) {
+				content = newContent;
+			}
+		}
+
+		if (modified) {
+			await fs.writeFile(file, content, "utf-8");
+			transformedCount++;
+		}
+	}
+
+	if (transformedCount > 0) {
+		printSuccess(
+			`Path aliases resolved in ${transformedCount} files`,
+			"transform-paths",
+		);
+	}
+};
+
 /**
  * Helper function to copy files to the dist directory
  */
 const copyFiles = async (outDir: string) => {
-	const { opinionated } = await Compiler.loadConfig();
-	let filesToCopy: Array<string> = [];
-	if (opinionated) {
-		filesToCopy = [
-			"./register-path.js",
-			"tsconfig.build.json",
-			"package.json",
-		];
-	} else {
-		filesToCopy = ["tsconfig.json", "package.json"];
+	// Only copy package.json - path aliases are resolved at build time
+	// No need for tsconfig files or register-path.js in production
+	const filesToCopy = ["package.json"];
+
+	for (const file of filesToCopy) {
+		if (existsSync(file)) {
+			await fs.copyFile(file, join(outDir, path.basename(file)));
+		}
 	}
-	filesToCopy.forEach((file) => {
-		fs.copyFile(file, join(outDir, path.basename(file)));
-	});
 };
 
 /**
@@ -269,6 +383,10 @@ export const runCommand = async ({
 				}
 				await cleanDist(outDir);
 				await compileTypescript();
+				// Transform path aliases to relative paths for production
+				if (opinionated) {
+					await transformPathAliases(outDir);
+				}
 				await copyFiles(outDir);
 				break;
 			case "prod": {
@@ -281,12 +399,11 @@ export const runCommand = async ({
 				}
 
 				let config: Array<string> = [];
+
+				// ✅ NEW: Simplified - no more register-path.js
+				// Path resolution is now built-in to @expressots/core
 				if (opinionated) {
-					config = [
-						"-r",
-						`./${outDir}/register-path.js`,
-						`./${outDir}/src/${entryPoint}.js`,
-					];
+					config = [`./${outDir}/src/${entryPoint}.js`];
 				} else {
 					config = [`./${outDir}/${entryPoint}.js`];
 				}

src/generate/cli.ts

@@ -22,6 +22,17 @@ const coerceSchematicAliases = (arg: string) => {
 			return "module";
 		case "mi":
 			return "middleware";
+		// NEW v4.0 schematics
+		case "i":
+			return "interceptor";
+		case "ev":
+			return "event";
+		case "h":
+			return "handler";
+		case "gu":
+			return "guard";
+		case "cfg":
+			return "config";
 		default:
 			return arg;
 	}
@@ -43,6 +54,12 @@ const generateProject = (): CommandModule<CommandModuleArgs, any> => {
 					"entity",
 					"module",
 					"middleware",
+					// NEW v4.0 schematics
+					"interceptor",
+					"event",
+					"handler",
+					"guard",
+					"config",
 				] as const,
 				describe: "The schematic to generate",
 				type: "string",
@@ -62,10 +79,23 @@ const generateProject = (): CommandModule<CommandModuleArgs, any> => {
 				alias: "m",
 			});
 
+			// NEW: Options for v4.0 schematics
+			yargs.option("event", {
+				describe: "Event class name for handler generation",
+				type: "string",
+			});
+
+			yargs.option("priority", {
+				describe:
+					"Priority for interceptors/handlers (lower = earlier execution)",
+				type: "number",
+				default: 10,
+			});
+
 			return yargs;
 		},
-		handler: async ({ schematic, path, method }) => {
-			await createTemplate({ schematic, path, method });
+		handler: async ({ schematic, path, method, event, priority }) => {
+			await createTemplate({ schematic, path, method, event, priority });
 		},
 	};
 };

src/generate/form.ts

@@ -8,11 +8,15 @@ import { opinionatedProcess } from "./utils/opinionated-cmd";
  * @param schematic
  * @param path
  * @param method
+ * @param event - Event class name (for handler generation)
+ * @param priority - Priority for interceptors/handlers
  */
 type CreateTemplateProps = {
 	schematic: string;
 	path: string;
 	method: string;
+	event?: string;
+	priority?: number;
 };
 
 /**
@@ -26,6 +30,8 @@ export const createTemplate = async ({
 	schematic,
 	path: target,
 	method,
+	event,
+	priority = 10,
 }: CreateTemplateProps) => {
 	const config = await Compiler.loadConfig();
 	const pathStyle = checkPathStyle(target);
@@ -38,13 +44,15 @@ export const createTemplate = async ({
 			method,
 			config,
 			pathStyle,
+			{ event, priority },
 		);
 	} else {
 		returnFile = await nonOpinionatedProcess(
 			schematic,
 			target,
 			method,
 			config,
+			{ event, priority },
 		);
 	}
 

src/generate/templates/nonopinionated/config.tpl

@@ -0,0 +1,12 @@
+import { defineConfig, Env, loadEnvSync } from "@expressots/core";
+
+loadEnvSync({ files: { development: ".env.local", production: ".env.prod" } });
+
+export const {{moduleName}}Config = defineConfig({
+    enabled: Env.boolean("{{envPrefix}}_ENABLED", { default: true }),
+    // Add more config options as needed
+});
+
+export const config = {{moduleName}}Config.values;
+export type {{className}}Config = typeof config;
+

src/generate/templates/nonopinionated/event.tpl

@@ -0,0 +1,10 @@
+/**
+ * {{className}} Event
+ */
+export class {{className}}Event {
+    constructor(
+        public readonly data: Record<string, unknown>,
+        public readonly timestamp: Date = new Date(),
+    ) {}
+}
+

src/generate/templates/nonopinionated/guard.tpl

@@ -0,0 +1,18 @@
+import { provide } from "@expressots/core";
+import { Request, Response, NextFunction } from "express";
+
+@provide({{className}}Guard)
+export class {{className}}Guard {
+    canActivate(req: Request, res: Response, next: NextFunction): void {
+        const authHeader = req.headers.authorization;
+
+        if (!authHeader) {
+            res.status(401).json({ message: "Unauthorized" });
+            return;
+        }
+
+        // TODO: Validate token
+        next();
+    }
+}
+

src/generate/templates/nonopinionated/handler.tpl

@@ -0,0 +1,12 @@
+import { provide, OnEvent, IEventHandler } from "@expressots/core";
+import { {{{eventName}}} } from "{{{eventPath}}}";
+
+@provide({{className}}Handler)
+@OnEvent({{eventName}}, { priority: {{priority}} })
+export class {{className}}Handler implements IEventHandler<{{eventName}}> {
+    async handle(event: {{eventName}}): Promise<void> {
+        // TODO: Implement handler logic
+        console.log(`Handling ${event.constructor.name}`);
+    }
+}
+

src/generate/templates/nonopinionated/interceptor.tpl

@@ -0,0 +1,27 @@
+import {
+    IInterceptor,
+    ExecutionContext,
+    CallHandler,
+    Interceptor,
+    provide,
+} from "@expressots/core";
+
+@Interceptor({ priority: {{priority}} })
+@provide({{className}}Interceptor)
+export class {{className}}Interceptor implements IInterceptor {
+    async intercept(context: ExecutionContext, next: CallHandler) {
+        const request = context.getRequest();
+
+        // Pre-processing
+        const startTime = Date.now();
+
+        const result = await next.handle();
+
+        // Post-processing
+        const duration = Date.now() - startTime;
+        console.log(`[{{className}}] ${request.method} ${request.path} - ${duration}ms`);
+
+        return result;
+    }
+}
+