@expressots/cli 4.0.0-preview.2 → 4.0.0-preview.3

package/bin/generate/templates/nonopinionated/handler.tpl

@@ -1,12 +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}`);
-    }
-}
-
+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}`);
+    }
+}
+

package/bin/generate/templates/nonopinionated/interceptor.tpl

@@ -1,27 +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;
-    }
-}
-
+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;
+    }
+}
+

package/bin/generate/templates/opinionated/config.tpl

@@ -1,47 +1,47 @@
-import { defineConfig, Env, loadEnvSync } from "@expressots/core";
-
-/**
- * {{className}} Configuration
- *
- * Type-safe configuration with full TypeScript inference.
- * Features:
- * - Multi-environment defaults
- * - Secret management with auto-redaction
- * - Validation with helpful errors
- */
-
-// Load environment files before config resolution
-const envFiles = {
-    development: ".env.local",
-    production: ".env.prod",
-};
-
-loadEnvSync({ files: envFiles });
-
-export const {{moduleName}}Config = defineConfig({
-    // Add your configuration schema here
-    enabled: Env.boolean("{{envPrefix}}_ENABLED", {
-        default: true,
-        description: "Enable/disable {{className}} feature",
-    }),
-    // Example settings - customize as needed
-    setting1: Env.string("{{envPrefix}}_SETTING1", {
-        default: "default-value",
-    }),
-    setting2: Env.number("{{envPrefix}}_SETTING2", {
-        default: 100,
-        min: 0,
-        max: 1000,
-    }),
-    bootstrap: {
-        envFileConfig: {
-            autoCreateTemplate: true,
-            files: envFiles,
-        },
-    },
-});
-
-// Export typed config values
-export const config = {{moduleName}}Config.values;
-export type {{className}}Config = typeof config;
-
+import { defineConfig, Env, loadEnvSync } from "@expressots/core";
+
+/**
+ * {{className}} Configuration
+ *
+ * Type-safe configuration with full TypeScript inference.
+ * Features:
+ * - Multi-environment defaults
+ * - Secret management with auto-redaction
+ * - Validation with helpful errors
+ */
+
+// Load environment files before config resolution
+const envFiles = {
+    development: ".env.local",
+    production: ".env.prod",
+};
+
+loadEnvSync({ files: envFiles });
+
+export const {{moduleName}}Config = defineConfig({
+    // Add your configuration schema here
+    enabled: Env.boolean("{{envPrefix}}_ENABLED", {
+        default: true,
+        description: "Enable/disable {{className}} feature",
+    }),
+    // Example settings - customize as needed
+    setting1: Env.string("{{envPrefix}}_SETTING1", {
+        default: "default-value",
+    }),
+    setting2: Env.number("{{envPrefix}}_SETTING2", {
+        default: 100,
+        min: 0,
+        max: 1000,
+    }),
+    bootstrap: {
+        envFileConfig: {
+            autoCreateTemplate: true,
+            files: envFiles,
+        },
+    },
+});
+
+// Export typed config values
+export const config = {{moduleName}}Config.values;
+export type {{className}}Config = typeof config;
+

package/bin/generate/templates/opinionated/event.tpl

@@ -1,15 +1,15 @@
-/**
- * {{className}} Event
- *
- * Type-safe event - no strings!
- *
- * Usage:
- * await this.eventEmitter.emit(new {{className}}Event(data));
- */
-export class {{className}}Event {
-    constructor(
-        public readonly data: Record<string, unknown>,
-        public readonly timestamp: Date = new Date(),
-    ) {}
-}
-
+/**
+ * {{className}} Event
+ *
+ * Type-safe event - no strings!
+ *
+ * Usage:
+ * await this.eventEmitter.emit(new {{className}}Event(data));
+ */
+export class {{className}}Event {
+    constructor(
+        public readonly data: Record<string, unknown>,
+        public readonly timestamp: Date = new Date(),
+    ) {}
+}
+

package/bin/generate/templates/opinionated/guard.tpl

@@ -1,41 +1,41 @@
-import { provide } from "@expressots/core";
-import { Request, Response, NextFunction } from "express";
-
-/**
- * {{className}} Guard
- *
- * Usage:
- * @controller("/protected")
- * @Use({{className}}Guard)
- * export class ProtectedController { }
- */
-@provide({{className}}Guard)
-export class {{className}}Guard {
-    /**
-     * Check if the request is authorized
-     */
-    canActivate(req: Request, res: Response, next: NextFunction): void {
-        // TODO: Implement authorization logic
-        const isAuthorized = this.checkAuthorization(req);
-
-        if (!isAuthorized) {
-            res.status(401).json({ message: "Unauthorized" });
-            return;
-        }
-
-        next();
-    }
-
-    private checkAuthorization(req: Request): boolean {
-        // Example: Check for authorization header
-        const authHeader = req.headers.authorization;
-
-        if (!authHeader) {
-            return false;
-        }
-
-        // TODO: Validate token/credentials
-        return true;
-    }
-}
-
+import { provide } from "@expressots/core";
+import { Request, Response, NextFunction } from "express";
+
+/**
+ * {{className}} Guard
+ *
+ * Usage:
+ * @controller("/protected")
+ * @Use({{className}}Guard)
+ * export class ProtectedController { }
+ */
+@provide({{className}}Guard)
+export class {{className}}Guard {
+    /**
+     * Check if the request is authorized
+     */
+    canActivate(req: Request, res: Response, next: NextFunction): void {
+        // TODO: Implement authorization logic
+        const isAuthorized = this.checkAuthorization(req);
+
+        if (!isAuthorized) {
+            res.status(401).json({ message: "Unauthorized" });
+            return;
+        }
+
+        next();
+    }
+
+    private checkAuthorization(req: Request): boolean {
+        // Example: Check for authorization header
+        const authHeader = req.headers.authorization;
+
+        if (!authHeader) {
+            return false;
+        }
+
+        // TODO: Validate token/credentials
+        return true;
+    }
+}
+

package/bin/generate/templates/opinionated/handler.tpl

@@ -1,23 +1,23 @@
-import { provide, OnEvent, IEventHandler } from "@expressots/core";
-import { {{{eventName}}} } from "{{{eventPath}}}";
-
-/**
- * Handler for {{eventName}}
- *
- * Features:
- * - Auto-discovered
- * - Priority: {{priority}}
- * - Full type safety
- */
-@provide({{className}}Handler)
-@OnEvent({{eventName}}, { priority: {{priority}} })
-export class {{className}}Handler implements IEventHandler<{{eventName}}> {
-    async handle(event: {{eventName}}): Promise<void> {
-        console.log(`Handling ${event.constructor.name}`, {
-            timestamp: event.timestamp,
-        });
-
-        // TODO: Implement handler logic
-    }
-}
-
+import { provide, OnEvent, IEventHandler } from "@expressots/core";
+import { {{{eventName}}} } from "{{{eventPath}}}";
+
+/**
+ * Handler for {{eventName}}
+ *
+ * Features:
+ * - Auto-discovered
+ * - Priority: {{priority}}
+ * - Full type safety
+ */
+@provide({{className}}Handler)
+@OnEvent({{eventName}}, { priority: {{priority}} })
+export class {{className}}Handler implements IEventHandler<{{eventName}}> {
+    async handle(event: {{eventName}}): Promise<void> {
+        console.log(`Handling ${event.constructor.name}`, {
+            timestamp: event.timestamp,
+        });
+
+        // TODO: Implement handler logic
+    }
+}
+

package/bin/generate/templates/opinionated/interceptor.tpl

@@ -1,50 +1,50 @@
-import {
-    IInterceptor,
-    ExecutionContext,
-    CallHandler,
-    Interceptor,
-    provide,
-} from "@expressots/core";
-
-/**
- * {{className}} Interceptor
- *
- * Priority: {{priority}} (lower = earlier execution)
- *
- * Usage:
- * @UseInterceptors({{className}}Interceptor)
- * @controller("/route")
- * export class MyController { }
- */
-@Interceptor({ priority: {{priority}} })
-@provide({{className}}Interceptor)
-export class {{className}}Interceptor implements IInterceptor {
-    async intercept(context: ExecutionContext, next: CallHandler) {
-        const request = context.getRequest();
-
-        // Pre-processing logic
-        console.log(`[{{className}}] Before handler`, {
-            method: request.method,
-            path: request.path,
-        });
-
-        const startTime = Date.now();
-
-        try {
-            // Execute next interceptor or handler
-            const result = await next.handle();
-
-            // Post-processing logic
-            const duration = Date.now() - startTime;
-            console.log(`[{{className}}] After handler`, {
-                duration: `${duration}ms`,
-            });
-
-            return result;
-        } catch (error) {
-            console.error(`[{{className}}] Handler error`, error);
-            throw error;
-        }
-    }
-}
-
+import {
+    IInterceptor,
+    ExecutionContext,
+    CallHandler,
+    Interceptor,
+    provide,
+} from "@expressots/core";
+
+/**
+ * {{className}} Interceptor
+ *
+ * Priority: {{priority}} (lower = earlier execution)
+ *
+ * Usage:
+ * @UseInterceptors({{className}}Interceptor)
+ * @controller("/route")
+ * export class MyController { }
+ */
+@Interceptor({ priority: {{priority}} })
+@provide({{className}}Interceptor)
+export class {{className}}Interceptor implements IInterceptor {
+    async intercept(context: ExecutionContext, next: CallHandler) {
+        const request = context.getRequest();
+
+        // Pre-processing logic
+        console.log(`[{{className}}] Before handler`, {
+            method: request.method,
+            path: request.path,
+        });
+
+        const startTime = Date.now();
+
+        try {
+            // Execute next interceptor or handler
+            const result = await next.handle();
+
+            // Post-processing logic
+            const duration = Date.now() - startTime;
+            console.log(`[{{className}}] After handler`, {
+                duration: `${duration}ms`,
+            });
+
+            return result;
+        } catch (error) {
+            console.error(`[{{className}}] Handler error`, error);
+            throw error;
+        }
+    }
+}
+

package/bin/generate/utils/command-utils.d.ts

@@ -69,9 +69,10 @@ export declare function getFileNameWithoutExtension(filePath: string): string;
  * @param schematic
  * @returns the split target
  */
-export declare const splitTarget: ({ target, schematic, }: {
+export declare const splitTarget: ({ target, schematic, opinionated, }: {
     target: string;
     schematic: string;
+    opinionated?: boolean;
 }) => Promise<{
     path: string;
     file: string;
@@ -120,7 +121,17 @@ export declare const getNameWithScaffoldPattern: (name: string) => Promise<strin
  */
 export declare function extractFirstWord(file: string): Promise<string>;
 /**
- * Check if the path is a nested path, a single path or a sugar path
+ * Determine the path style for a generate target.
+ *
+ * - `Nested`: contains an explicit separator (`billing/invoice`) → grouped
+ *   under the parent folder.
+ * - `Sugar`: a single segment that normalizes to more than one word
+ *   (`userCreate`, `user-create`, `user_create`, `UserCreate`) → grouped under
+ *   its first word as a shared module (e.g. `UserModule`). camelCase and
+ *   kebab-case forms of the same name therefore produce identical output.
+ * - `Single`: a true single-word target (`user`) → self-contained module in its
+ *   own folder.
+ *
  * @param path
  * @returns the path style
  */

package/bin/generate/utils/command-utils.js

@@ -36,6 +36,7 @@ const verify_file_exists_1 = require("../../utils/verify-file-exists");
 const compiler_1 = __importDefault(require("../../utils/compiler"));
 const update_tsconfig_paths_1 = require("../../utils/update-tsconfig-paths");
 const input_validation_1 = require("../../utils/input-validation");
+const shared_1 = require("@expressots/shared");
 /**
  * Reject generate targets that would resolve outside the project's
  * source root. We only inspect the user-supplied `rawTarget` for
@@ -79,6 +80,7 @@ async function validateAndPrepareFile(fp) {
         const { path, file, className, moduleName, modulePath } = await (0, exports.splitTarget)({
             target: fp.target,
             schematic: fp.schematic,
+            opinionated: true,
         });
         ensureWithinSourceRoot(folderToScaffold, `${path}/${file}`, fp.target);
         const outputPath = `${folderToScaffold}/${path}/${file}`;
@@ -142,7 +144,7 @@ exports.getFileNameWithoutExtension = getFileNameWithoutExtension;
  * @param schematic
  * @returns the split target
  */
-const splitTarget = async ({ target, schematic, }) => {
+const splitTarget = async ({ target, schematic, opinionated = false, }) => {
     const pathContent = target
         .split("/")
         .filter((item) => item !== "");
@@ -213,6 +215,30 @@ const splitTarget = async ({ target, schematic, }) => {
             const firstWord = name
                 .split(isCamelCase ? /(?=[A-Z])/ : kebabCaseRegex)[0]
                 .toLowerCase();
+            // Opinionated "syntactic sugar": decompose a compound name into a
+            // nested feature/use-case layout so every use-case of a feature is
+            // grouped under one module at the feature root. For example
+            // `userLogin` -> `user/login/login.{controller,usecase,dto}.ts` with
+            // the shared module at `user/user.module.ts`. A later `userLogout`
+            // adds `user/logout/...` and joins the same `UserModule`.
+            //
+            // Only applies to grouped schematics in opinionated mode; standalone
+            // schematics and non-opinionated mode keep the flat kebab folder so
+            // the developer retains full control over structure.
+            if (opinionated && shouldCreateFolder) {
+                const words = folderName.split("-").filter(Boolean);
+                if (words.length > 1) {
+                    const feature = words[0];
+                    const useCase = words.slice(1).join("-");
+                    return {
+                        path: `${feature}/${useCase}`,
+                        file: `${await (0, exports.getNameWithScaffoldPattern)(useCase)}.${schematic}.ts`,
+                        className: (0, string_utils_1.anyCaseToPascalCase)(useCase),
+                        moduleName: feature,
+                        modulePath: feature,
+                    };
+                }
+            }
             // For standalone schematics (entity, provider, middleware, etc.),
             // only create folder if explicit path is provided
             const computedPath = shouldCreateFolder
@@ -316,13 +342,13 @@ exports.schematicFolder = schematicFolder;
 const getNameWithScaffoldPattern = async (name) => {
     const configObject = await compiler_1.default.loadConfig();
     switch (configObject.scaffoldPattern) {
-        case "lowercase" /* Pattern.LOWER_CASE */:
+        case shared_1.Pattern.LOWER_CASE:
             return (0, string_utils_1.anyCaseToLowerCase)(name);
-        case "kebab-case" /* Pattern.KEBAB_CASE */:
+        case shared_1.Pattern.KEBAB_CASE:
             return (0, string_utils_1.anyCaseToKebabCase)(name);
-        case "PascalCase" /* Pattern.PASCAL_CASE */:
+        case shared_1.Pattern.PASCAL_CASE:
             return (0, string_utils_1.anyCaseToPascalCase)(name);
-        case "camelCase" /* Pattern.CAMEL_CASE */:
+        case shared_1.Pattern.CAMEL_CASE:
             return (0, string_utils_1.anyCaseToCamelCase)(name);
     }
 };
@@ -346,33 +372,40 @@ async function extractFirstWord(file) {
     const firstWord = f.split(regex)[0];
     const config = await compiler_1.default.loadConfig();
     switch (config.scaffoldPattern) {
-        case "lowercase" /* Pattern.LOWER_CASE */:
+        case shared_1.Pattern.LOWER_CASE:
             return (0, string_utils_1.anyCaseToLowerCase)(firstWord);
-        case "kebab-case" /* Pattern.KEBAB_CASE */:
+        case shared_1.Pattern.KEBAB_CASE:
             return (0, string_utils_1.anyCaseToKebabCase)(firstWord);
-        case "PascalCase" /* Pattern.PASCAL_CASE */:
+        case shared_1.Pattern.PASCAL_CASE:
             return (0, string_utils_1.anyCaseToPascalCase)(firstWord);
-        case "camelCase" /* Pattern.CAMEL_CASE */:
+        case shared_1.Pattern.CAMEL_CASE:
             return (0, string_utils_1.anyCaseToCamelCase)(firstWord);
     }
 }
 exports.extractFirstWord = extractFirstWord;
 /**
- * Check if the path is a nested path, a single path or a sugar path
+ * Determine the path style for a generate target.
+ *
+ * - `Nested`: contains an explicit separator (`billing/invoice`) → grouped
+ *   under the parent folder.
+ * - `Sugar`: a single segment that normalizes to more than one word
+ *   (`userCreate`, `user-create`, `user_create`, `UserCreate`) → grouped under
+ *   its first word as a shared module (e.g. `UserModule`). camelCase and
+ *   kebab-case forms of the same name therefore produce identical output.
+ * - `Single`: a true single-word target (`user`) → self-contained module in its
+ *   own folder.
+ *
  * @param path
  * @returns the path style
  */
 const checkPathStyle = (path) => {
-    const singleOrNestedPathRegex = /\/|\\/;
-    const sugarPathRegex = /^\w+-\w+$/;
-    if (singleOrNestedPathRegex.test(path)) {
+    const nestedPathRegex = /\/|\\/;
+    if (nestedPathRegex.test(path)) {
         return "nested" /* PathStyle.Nested */;
     }
-    else if (sugarPathRegex.test(path)) {
+    if ((0, string_utils_1.anyCaseToKebabCase)(path).includes("-")) {
         return "sugar" /* PathStyle.Sugar */;
     }
-    else {
-        return "single" /* PathStyle.Single */;
-    }
+    return "single" /* PathStyle.Single */;
 };
 exports.checkPathStyle = checkPathStyle;