@expressots/cli 3.0.0 → 4.0.0-preview.2

package/bin/generate/utils/opinionated-cmd.js

@@ -41,9 +41,10 @@ const add_module_to_container_1 = require("../../utils/add-module-to-container")
  * @param method - HTTP method
  * @param expressoConfig - Expresso configuration [expressots.config.ts]
  * @param pathStyle - Path command style [sugar, nested, single]
+ * @param v4Options - Additional options for v4.0 schematics
  * @returns
  */
-async function opinionatedProcess(schematic, target, method, expressoConfig, pathStyle) {
+async function opinionatedProcess(schematic, target, method, expressoConfig, pathStyle, v4Options = {}) {
     const f = await (0, command_utils_1.validateAndPrepareFile)({
         schematic,
         target,
@@ -116,6 +117,27 @@ async function opinionatedProcess(schematic, target, method, expressoConfig, pat
             await generateModule(f.outputPath, f.className, f.moduleName, f.path);
             await (0, cli_ui_1.printGenerateSuccess)(schematic, f.file);
             break;
+        // NEW v4.0 schematics
+        case "interceptor":
+            await generateInterceptor(f.outputPath, f.className, v4Options.priority ?? 10);
+            await (0, cli_ui_1.printGenerateSuccess)("interceptor", f.file);
+            break;
+        case "event":
+            await generateEvent(f.outputPath, f.className);
+            await (0, cli_ui_1.printGenerateSuccess)("event", f.file);
+            break;
+        case "handler":
+            await generateHandler(f.outputPath, f.className, v4Options.event ?? "MyEvent", v4Options.priority ?? 10);
+            await (0, cli_ui_1.printGenerateSuccess)("handler", f.file);
+            break;
+        case "guard":
+            await generateGuard(f.outputPath, f.className);
+            await (0, cli_ui_1.printGenerateSuccess)("guard", f.file);
+            break;
+        case "config":
+            await generateConfig(f.outputPath, f.className, f.moduleName);
+            await (0, cli_ui_1.printGenerateSuccess)("config", f.file);
+            break;
     }
     return f.file;
 }
@@ -353,7 +375,7 @@ async function generateModuleServiceSugarPath(outputPathController, className, m
         .join(folderToScaffold, path, "..")
         .normalize();
     const newModuleName = `${newModuleFile}.module.ts`;
-    const newModuleOutputPath = `${newModulePath}/${newModuleName}`.replace("\\", "/");
+    const newModuleOutputPath = `${newModulePath}/${newModuleName}`.replace(/\\/g, "/");
     const controllerToModule = nodePath
         .relative(newModuleOutputPath, outputPathController)
         .normalize()
@@ -378,7 +400,9 @@ async function generateModuleServiceSugarPath(outputPathController, className, m
             },
         },
     });
-    await (0, add_module_to_container_1.addModuleToContainer)((0, string_utils_1.anyCaseToPascalCase)(moduleName), `${moduleName}/${file.replace(".ts", "")}`, path);
+    // Extract folder name from folderToScaffold (e.g., "src/useCases" -> "useCases")
+    const folderName = nodePath.basename(folderToScaffold);
+    await (0, add_module_to_container_1.addModuleToContainer)((0, string_utils_1.anyCaseToPascalCase)(moduleName), `${moduleName}/${file.replace(".ts", "")}`, path, folderName);
 }
 /**
  * Generate a module for service scaffolding with single path
@@ -391,7 +415,7 @@ async function generateModuleServiceSinglePath(outputPathController, className,
     const newModuleFile = await (0, command_utils_1.extractFirstWord)(file);
     const newModulePath = nodePath.join(folderToScaffold, path).normalize();
     const newModuleName = `${newModuleFile}.module.ts`;
-    const newModuleOutputPath = `${newModulePath}/${newModuleName}`.replace("\\", "/");
+    const newModuleOutputPath = `${newModulePath}/${newModuleName}`.replace(/\\/g, "/");
     const controllerToModule = nodePath
         .relative(newModuleOutputPath, outputPathController)
         .normalize()
@@ -416,7 +440,9 @@ async function generateModuleServiceSinglePath(outputPathController, className,
             },
         },
     });
-    await (0, add_module_to_container_1.addModuleToContainer)((0, string_utils_1.anyCaseToPascalCase)(moduleName), `${moduleName}/${file.replace(".ts", "")}`, path);
+    // Extract folder name from folderToScaffold (e.g., "src/useCases" -> "useCases")
+    const folderName = nodePath.basename(folderToScaffold);
+    await (0, add_module_to_container_1.addModuleToContainer)((0, string_utils_1.anyCaseToPascalCase)(moduleName), `${moduleName}/${file.replace(".ts", "")}`, path, folderName);
 }
 /**
  * Generate a module for service scaffolding with nested path
@@ -432,7 +458,7 @@ async function generateModuleServiceNestedPath(outputPathController, className,
         .join(folderToScaffold, path, "..")
         .normalize();
     const newModuleName = `${moduleFileName}.module.ts`;
-    const newModuleOutputPath = `${newModulePath}/${newModuleName}`.replace("\\", "/");
+    const newModuleOutputPath = `${newModulePath}/${newModuleName}`.replace(/\\/g, "/");
     const controllerToModule = nodePath
         .relative(newModuleOutputPath, outputPathController)
         .normalize()
@@ -457,7 +483,9 @@ async function generateModuleServiceNestedPath(outputPathController, className,
             },
         },
     });
-    await (0, add_module_to_container_1.addModuleToContainerNestedPath)((0, string_utils_1.anyCaseToPascalCase)(moduleFileName), path);
+    // Extract folder name from folderToScaffold (e.g., "src/useCases" -> "useCases")
+    const folderName = nodePath.basename(folderToScaffold);
+    await (0, add_module_to_container_1.addModuleToContainerNestedPath)((0, string_utils_1.anyCaseToPascalCase)(moduleFileName), path, folderName);
 }
 /**
  * Generate a module
@@ -479,3 +507,80 @@ async function generateModule(outputPath, className, moduleName, path) {
         },
     });
 }
+// NEW v4.0 Schematic Generators
+/**
+ * Generate an interceptor
+ */
+async function generateInterceptor(outputPath, className, priority) {
+    (0, command_utils_1.writeTemplate)({
+        outputPath,
+        template: {
+            path: "../templates/opinionated/interceptor.tpl",
+            data: {
+                className: (0, string_utils_1.anyCaseToPascalCase)(className),
+                priority: priority.toString(),
+            },
+        },
+    });
+}
+/**
+ * Generate an event
+ */
+async function generateEvent(outputPath, className) {
+    (0, command_utils_1.writeTemplate)({
+        outputPath,
+        template: {
+            path: "../templates/opinionated/event.tpl",
+            data: {
+                className: (0, string_utils_1.anyCaseToPascalCase)(className),
+            },
+        },
+    });
+}
+/**
+ * Generate an event handler
+ */
+async function generateHandler(outputPath, className, eventName, priority) {
+    (0, command_utils_1.writeTemplate)({
+        outputPath,
+        template: {
+            path: "../templates/opinionated/handler.tpl",
+            data: {
+                className: (0, string_utils_1.anyCaseToPascalCase)(className),
+                eventName: (0, string_utils_1.anyCaseToPascalCase)(eventName),
+                eventPath: `@events/${(0, string_utils_1.anyCaseToKebabCase)(eventName)}.event`,
+                priority: priority.toString(),
+            },
+        },
+    });
+}
+/**
+ * Generate a guard
+ */
+async function generateGuard(outputPath, className) {
+    (0, command_utils_1.writeTemplate)({
+        outputPath,
+        template: {
+            path: "../templates/opinionated/guard.tpl",
+            data: {
+                className: (0, string_utils_1.anyCaseToPascalCase)(className),
+            },
+        },
+    });
+}
+/**
+ * Generate a config module
+ */
+async function generateConfig(outputPath, className, moduleName) {
+    (0, command_utils_1.writeTemplate)({
+        outputPath,
+        template: {
+            path: "../templates/opinionated/config.tpl",
+            data: {
+                className: (0, string_utils_1.anyCaseToPascalCase)(className),
+                moduleName: (0, string_utils_1.anyCaseToCamelCase)(moduleName || className),
+                envPrefix: (0, string_utils_1.anyCaseToUpperSnakeCase)(className),
+            },
+        },
+    });
+}

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

@@ -34,3 +34,9 @@ export declare function anyCaseToUpperCase(str: string): string;
  * @returns The converted string in lower case.
  */
 export declare function anyCaseToLowerCase(str: string): string;
+/**
+ * Converts a string from any case (camelCase, PascalCase, kebab-case, snake_case) to UPPER_SNAKE_CASE.
+ * @param str - The input string to be converted.
+ * @returns The converted string in UPPER_SNAKE_CASE.
+ */
+export declare function anyCaseToUpperSnakeCase(str: string): string;

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.anyCaseToLowerCase = exports.anyCaseToUpperCase = exports.anyCaseToSnakeCase = exports.anyCaseToPascalCase = exports.anyCaseToKebabCase = exports.anyCaseToCamelCase = void 0;
+exports.anyCaseToUpperSnakeCase = exports.anyCaseToLowerCase = exports.anyCaseToUpperCase = exports.anyCaseToSnakeCase = exports.anyCaseToPascalCase = exports.anyCaseToKebabCase = exports.anyCaseToCamelCase = void 0;
 /**
  * Converts a string from any case (camelCase, PascalCase, kebab-case, snake_case) to camelCase.
  * @param str - The input string to be converted.
@@ -69,3 +69,15 @@ function anyCaseToLowerCase(str) {
         .toLowerCase();
 }
 exports.anyCaseToLowerCase = anyCaseToLowerCase;
+/**
+ * Converts a string from any case (camelCase, PascalCase, kebab-case, snake_case) to UPPER_SNAKE_CASE.
+ * @param str - The input string to be converted.
+ * @returns The converted string in UPPER_SNAKE_CASE.
+ */
+function anyCaseToUpperSnakeCase(str) {
+    return str
+        .replace(/([a-z0-9])([A-Z])/g, "$1_$2")
+        .replace(/[-]+/g, "_")
+        .toUpperCase();
+}
+exports.anyCaseToUpperSnakeCase = anyCaseToUpperSnakeCase;

package/bin/help/form.js

@@ -15,15 +15,23 @@ const helpForm = async () => {
         ],
         colWidths: [15, 15, 60],
     });
-    table.push(["new project", "new", "Generate a new project"], ["info", "i", "Provides project information"], ["resources", "r", "Displays cli commands and resources"], ["scripts", "scripts", "Run scripts list or specific scripts"], ["help", "h", "Show command help"], [
+    table.push(
+    // Project commands
+    ["new project", "new", "Generate a new project (application or micro)"], ["info", "i", "Provides project information"], ["resources", "r", "Displays cli commands and resources"], ["scripts", "scripts", "Run scripts list or specific scripts"], ["help", "h", "Show command help"], 
+    // Core schematics
+    [
         "service",
         "g s",
         "Generate a service [controller, usecase, dto, module]",
-    ], ["controller", "g c", "Generate a controller"], ["usecase", "g u", "Generate a usecase"], ["dto", "g d", "Generate a dto"], ["entity", "g e", "Generate an entity"], ["provider", "g p", "Generate internal provider"], [
+    ], ["controller", "g c", "Generate a controller"], ["usecase", "g u", "Generate a usecase"], ["dto", "g d", "Generate a dto"], ["entity", "g e", "Generate an entity"], ["module", "g mo", "Generate a module"], ["middleware", "g mi", "Generate a middleware"], 
+    // v4.0 schematics
+    ["interceptor", "g i", "Generate an interceptor (--priority)"], ["event", "g ev", "Generate a type-safe event"], ["handler", "g h", "Generate an event handler (--event, --priority)"], ["guard", "g gu", "Generate an authorization guard"], ["config", "g cfg", "Generate a config module"], 
+    // Provider commands
+    ["provider", "g p", "Generate internal provider"], [
         "provider",
         "add",
         "Add provider to the project. Use -d to add as dev dependency",
-    ], ["provider", "remove", "Remove provider from the project"], ["provider", "create", "Create external provider"], ["module", "g mo", "Generate a module"], ["middleware", "g mi", "Generate a middleware"]);
+    ], ["provider", "remove", "Remove provider from the project"], ["provider", "create", "Create external provider"]);
     console.log(chalk_1.default.bold.white("ExpressoTS:", `${chalk_1.default.green("Resources List")}`));
     console.log(chalk_1.default.whiteBright(table.toString()));
     console.log(chalk_1.default.bold.white(`📝 More info: ${chalk_1.default.green("https://doc.expresso-ts.com/docs/category/cli")}`));

package/bin/migrate/analyzers/platform-detector.d.ts

@@ -0,0 +1,14 @@
+import type { MigrationSource } from "../cli";
+/**
+ * Detect the current deployment platform based on configuration files
+ */
+export declare function detectCurrentPlatform(): Promise<MigrationSource | null>;
+/**
+ * Analyze the current platform configuration
+ */
+export declare function analyzePlatformConfig(): Promise<{
+    platform: MigrationSource | null;
+    envVars: string[];
+    services: string[];
+    databases: string[];
+}>;

package/bin/migrate/analyzers/platform-detector.js

@@ -0,0 +1,116 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzePlatformConfig = exports.detectCurrentPlatform = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+/**
+ * Detect the current deployment platform based on configuration files
+ */
+async function detectCurrentPlatform() {
+    const cwd = process.cwd();
+    // Check for platform-specific files
+    const checks = [
+        { platform: "heroku", files: ["Procfile", "app.json"] },
+        { platform: "vercel", files: ["vercel.json", ".vercel"] },
+        {
+            platform: "docker-compose",
+            files: ["docker-compose.yml", "docker-compose.yaml"],
+        },
+        {
+            platform: "aws-ecs",
+            files: ["ecs-task-definition.json", ".aws/ecs"],
+        },
+        {
+            platform: "gcp-cloudrun",
+            files: ["cloudbuild.yaml", ".gcp/cloudrun.yaml"],
+        },
+        { platform: "azure-container", files: ["azure-pipelines.yml"] },
+    ];
+    for (const check of checks) {
+        for (const file of check.files) {
+            if (fs_1.default.existsSync(path_1.default.join(cwd, file))) {
+                return check.platform;
+            }
+        }
+    }
+    // Check for platform indicators in package.json scripts
+    const packageJsonPath = path_1.default.join(cwd, "package.json");
+    if (fs_1.default.existsSync(packageJsonPath)) {
+        try {
+            const pkg = JSON.parse(fs_1.default.readFileSync(packageJsonPath, "utf-8"));
+            const scripts = JSON.stringify(pkg.scripts || {});
+            if (scripts.includes("heroku"))
+                return "heroku";
+            if (scripts.includes("vercel"))
+                return "vercel";
+            if (scripts.includes("railway"))
+                return "docker-compose"; // likely uses Docker
+            if (scripts.includes("docker-compose"))
+                return "docker-compose";
+        }
+        catch {
+            // Ignore parse errors
+        }
+    }
+    // If Dockerfile exists, assume docker-compose
+    if (fs_1.default.existsSync(path_1.default.join(cwd, "Dockerfile"))) {
+        return "docker-compose";
+    }
+    return null;
+}
+exports.detectCurrentPlatform = detectCurrentPlatform;
+/**
+ * Analyze the current platform configuration
+ */
+async function analyzePlatformConfig() {
+    const cwd = process.cwd();
+    const platform = await detectCurrentPlatform();
+    const envVars = [];
+    const services = [];
+    const databases = [];
+    // Parse .env.example for environment variables
+    const envExamplePath = path_1.default.join(cwd, ".env.example");
+    if (fs_1.default.existsSync(envExamplePath)) {
+        const content = fs_1.default.readFileSync(envExamplePath, "utf-8");
+        const lines = content.split("\n");
+        for (const line of lines) {
+            const match = line.match(/^([A-Z_][A-Z0-9_]*)=/);
+            if (match) {
+                envVars.push(match[1]);
+            }
+        }
+    }
+    // Parse docker-compose for services
+    const composePath = path_1.default.join(cwd, "docker-compose.yml");
+    if (fs_1.default.existsSync(composePath)) {
+        const content = fs_1.default.readFileSync(composePath, "utf-8");
+        const serviceMatch = content.match(/services:\n([\s\S]*?)(?=\n\w|$)/);
+        if (serviceMatch) {
+            const serviceLines = serviceMatch[1].match(/^\s{2}(\w+):/gm);
+            if (serviceLines) {
+                for (const line of serviceLines) {
+                    const name = line.trim().replace(":", "");
+                    services.push(name);
+                    // Check if it's a database
+                    if (name.includes("postgres") || name.includes("pg")) {
+                        databases.push("postgresql");
+                    }
+                    else if (name.includes("mysql")) {
+                        databases.push("mysql");
+                    }
+                    else if (name.includes("mongo")) {
+                        databases.push("mongodb");
+                    }
+                    else if (name.includes("redis")) {
+                        databases.push("redis");
+                    }
+                }
+            }
+        }
+    }
+    return { platform, envVars, services, databases };
+}
+exports.analyzePlatformConfig = analyzePlatformConfig;

package/bin/migrate/cli.d.ts

@@ -0,0 +1,6 @@
+import { CommandModule } from "yargs";
+type CommandModuleArgs = {};
+export type MigrationSource = "heroku" | "docker-compose" | "vercel" | "aws-ecs" | "gcp-cloudrun" | "azure-container";
+export type MigrationTarget = "railway" | "render" | "fly" | "kubernetes" | "aws-ecs" | "gcp-cloudrun" | "azure-container";
+declare const migrateCommand: () => CommandModule<CommandModuleArgs, any>;
+export { migrateCommand };

package/bin/migrate/cli.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.migrateCommand = void 0;
+const form_1 = require("./form");
+const migrateCommand = () => {
+    return {
+        command: "migrate <action> [options]",
+        describe: "Generate migration scripts between cloud platforms.",
+        aliases: ["migration", "mig"],
+        builder: (yargs) => {
+            yargs.positional("action", {
+                choices: ["init", "generate", "list", "analyze"],
+                describe: "Action to perform",
+                type: "string",
+                demandOption: true,
+            });
+            yargs.option("from", {
+                choices: [
+                    "heroku",
+                    "docker-compose",
+                    "vercel",
+                    "aws-ecs",
+                    "gcp-cloudrun",
+                    "azure-container",
+                ],
+                describe: "Source platform to migrate from",
+                type: "string",
+                alias: "f",
+            });
+            yargs.option("to", {
+                choices: [
+                    "railway",
+                    "render",
+                    "fly",
+                    "kubernetes",
+                    "aws-ecs",
+                    "gcp-cloudrun",
+                    "azure-container",
+                ],
+                describe: "Target platform to migrate to",
+                type: "string",
+                alias: "t",
+            });
+            yargs.option("include-data", {
+                describe: "Include data migration scripts",
+                type: "boolean",
+                default: false,
+            });
+            yargs.option("include-secrets", {
+                describe: "Include secrets/environment variable migration",
+                type: "boolean",
+                default: true,
+            });
+            yargs.option("dry-run", {
+                describe: "Show migration steps without generating files",
+                type: "boolean",
+                default: false,
+            });
+            yargs.option("output-dir", {
+                describe: "Output directory for migration files",
+                type: "string",
+                alias: "o",
+                default: "./migration",
+            });
+            return yargs;
+        },
+        handler: async (argv) => {
+            const { action, from, to, includeData, includeSecrets, dryRun, outputDir, } = argv;
+            const options = {
+                from: from,
+                to: to,
+                includeData,
+                includeSecrets,
+                dryRun,
+                outputDir,
+            };
+            switch (action) {
+                case "init":
+                    await (0, form_1.initMigration)(options);
+                    break;
+                case "generate":
+                    await (0, form_1.generateMigration)(options);
+                    break;
+                case "list":
+                    await (0, form_1.listMigrations)();
+                    break;
+                case "analyze":
+                    await (0, form_1.analyzeMigration)(options);
+                    break;
+                default:
+                    console.log(`Unknown action: ${action}`);
+            }
+        },
+    };
+};
+exports.migrateCommand = migrateCommand;

package/bin/migrate/form.d.ts

@@ -0,0 +1,25 @@
+import type { MigrationSource, MigrationTarget } from "./cli";
+export interface MigrationOptions {
+    from?: MigrationSource;
+    to?: MigrationTarget;
+    includeData: boolean;
+    includeSecrets: boolean;
+    dryRun: boolean;
+    outputDir: string;
+}
+/**
+ * Interactive migration setup wizard
+ */
+export declare function initMigration(options: MigrationOptions): Promise<void>;
+/**
+ * Generate migration scripts
+ */
+export declare function generateMigration(options: MigrationOptions): Promise<void>;
+/**
+ * List available migrations
+ */
+export declare function listMigrations(): Promise<void>;
+/**
+ * Analyze migration complexity
+ */
+export declare function analyzeMigration(options: MigrationOptions): Promise<void>;