@expressots/cli 3.0.0 → 4.0.0-preview.2

package/bin/templates/renderer.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Template renderer - processes templates with variable substitution
+ * Uses Mustache-like syntax: {{variable}}, {{#condition}}...{{/condition}}
+ */
+import type { RenderOptions } from "./types";
+export declare class TemplateRenderer {
+    /**
+     * Render template with variable substitution
+     */
+    render(template: string, options: RenderOptions): string;
+    /**
+     * Process conditional blocks {{#condition}}...{{/condition}}
+     */
+    private processConditionals;
+    /**
+     * Process negative conditional blocks {{^condition}}...{{/condition}}
+     */
+    private processNegativeConditionals;
+    /**
+     * Process loop blocks for arrays
+     */
+    private processLoops;
+    /**
+     * Process simple variable substitution {{variable}}
+     */
+    private processVariables;
+    /**
+     * Get nested value from object using dot notation. Falls back to a
+     * flat-key lookup so callers can provide either
+     * `{ app: { version: "1.0.0" } }` or `{ "app.version": "1.0.0" }`.
+     */
+    private getNestedValue;
+    /**
+     * Check if value is truthy for conditional evaluation
+     */
+    private isTruthy;
+    /**
+     * Validate template syntax
+     */
+    validateTemplate(template: string): {
+        valid: boolean;
+        errors: string[];
+    };
+    /**
+     * Extract variable names from template
+     */
+    extractVariables(template: string): string[];
+}
+export declare function getTemplateRenderer(): TemplateRenderer;

package/bin/templates/renderer.js

@@ -0,0 +1,204 @@
+"use strict";
+/**
+ * Template renderer - processes templates with variable substitution
+ * Uses Mustache-like syntax: {{variable}}, {{#condition}}...{{/condition}}
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTemplateRenderer = exports.TemplateRenderer = void 0;
+class TemplateRenderer {
+    /**
+     * Render template with variable substitution
+     */
+    render(template, options) {
+        let result = template;
+        // Process conditionals first: {{#condition}}content{{/condition}}
+        result = this.processConditionals(result, options);
+        // Process negative conditionals: {{^condition}}content{{/condition}}
+        result = this.processNegativeConditionals(result, options);
+        // Process loops: {{#items}}{{.}}{{/items}}
+        result = this.processLoops(result, options);
+        // Process simple variable substitution: {{variable}}
+        result = this.processVariables(result, options);
+        return result;
+    }
+    /**
+     * Process conditional blocks {{#condition}}...{{/condition}}
+     */
+    processConditionals(template, options) {
+        const pattern = /\{\{#(\w+)\}\}([\s\S]*?)\{\{\/\1\}\}/g;
+        return template.replace(pattern, (match, condition, content) => {
+            const value = options.conditionals?.[condition] ??
+                options.variables[condition];
+            // Check if value is truthy
+            if (this.isTruthy(value)) {
+                // Recursively process the content
+                return this.render(content, options);
+            }
+            return "";
+        });
+    }
+    /**
+     * Process negative conditional blocks {{^condition}}...{{/condition}}
+     */
+    processNegativeConditionals(template, options) {
+        const pattern = /\{\{\^(\w+)\}\}([\s\S]*?)\{\{\/\1\}\}/g;
+        return template.replace(pattern, (match, condition, content) => {
+            const value = options.conditionals?.[condition] ??
+                options.variables[condition];
+            // Check if value is falsy
+            if (!this.isTruthy(value)) {
+                return this.render(content, options);
+            }
+            return "";
+        });
+    }
+    /**
+     * Process loop blocks for arrays
+     */
+    processLoops(template, options) {
+        const pattern = /\{\{#each\s+(\w+)\}\}([\s\S]*?)\{\{\/each\}\}/g;
+        return template.replace(pattern, (match, arrayName, content) => {
+            const array = options.variables[arrayName];
+            if (!Array.isArray(array)) {
+                return "";
+            }
+            return array
+                .map((item, index) => {
+                // Create new options with item context
+                const itemOptions = {
+                    ...options,
+                    variables: {
+                        ...options.variables,
+                        ".": String(item),
+                        "@index": index,
+                        "@first": index === 0,
+                        "@last": index === array.length - 1,
+                        ...(typeof item === "object" ? item : {}),
+                    },
+                };
+                return this.render(content, itemOptions);
+            })
+                .join("");
+        });
+    }
+    /**
+     * Process simple variable substitution {{variable}}
+     */
+    processVariables(template, options) {
+        // Match {{variable}} but not {{#variable}} or {{/variable}} or {{^variable}}
+        const pattern = /\{\{([^#/^}][^}]*?)\}\}/g;
+        return template.replace(pattern, (match, variable) => {
+            const trimmedVar = variable.trim();
+            // Handle dot notation for nested variables
+            const value = this.getNestedValue(options.variables, trimmedVar);
+            if (value === undefined || value === null) {
+                // Keep the placeholder if variable not found (for debugging)
+                return "";
+            }
+            return String(value);
+        });
+    }
+    /**
+     * Get nested value from object using dot notation. Falls back to a
+     * flat-key lookup so callers can provide either
+     * `{ app: { version: "1.0.0" } }` or `{ "app.version": "1.0.0" }`.
+     */
+    getNestedValue(obj, path) {
+        if (Object.prototype.hasOwnProperty.call(obj, path)) {
+            return obj[path];
+        }
+        const parts = path.split(".");
+        let current = obj;
+        for (const part of parts) {
+            if (current === null || current === undefined) {
+                return undefined;
+            }
+            if (typeof current !== "object") {
+                return undefined;
+            }
+            current = current[part];
+        }
+        return current;
+    }
+    /**
+     * Check if value is truthy for conditional evaluation
+     */
+    isTruthy(value) {
+        if (value === undefined || value === null)
+            return false;
+        if (typeof value === "boolean")
+            return value;
+        if (typeof value === "number")
+            return value !== 0;
+        if (typeof value === "string")
+            return value.length > 0;
+        if (Array.isArray(value))
+            return value.length > 0;
+        if (typeof value === "object")
+            return Object.keys(value).length > 0;
+        return Boolean(value);
+    }
+    /**
+     * Validate template syntax
+     */
+    validateTemplate(template) {
+        const errors = [];
+        // Check for unclosed conditionals
+        const openConditionals = template.match(/\{\{#(\w+)\}\}/g) || [];
+        const closeConditionals = template.match(/\{\{\/(\w+)\}\}/g) || [];
+        for (const open of openConditionals) {
+            const name = open.match(/\{\{#(\w+)\}\}/)?.[1];
+            if (name) {
+                const closePattern = new RegExp(`\\{\\{\\/${name}\\}\\}`);
+                if (!closePattern.test(template)) {
+                    errors.push(`Unclosed conditional block: {{#${name}}}`);
+                }
+            }
+        }
+        // Check for orphaned closing tags
+        for (const close of closeConditionals) {
+            const name = close.match(/\{\{\/(\w+)\}\}/)?.[1];
+            if (name) {
+                const openPattern = new RegExp(`\\{\\{[#\\^]${name}\\}\\}`);
+                if (!openPattern.test(template)) {
+                    errors.push(`Orphaned closing tag: {{/${name}}}`);
+                }
+            }
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+        };
+    }
+    /**
+     * Extract variable names from template
+     */
+    extractVariables(template) {
+        const variables = new Set();
+        // Match simple variables
+        const simplePattern = /\{\{([^#/^}][^}]*?)\}\}/g;
+        let match;
+        while ((match = simplePattern.exec(template)) !== null) {
+            const variable = match[1].trim();
+            if (!variable.startsWith(".") && !variable.startsWith("@")) {
+                variables.add(variable.split(".")[0]); // Get root variable
+            }
+        }
+        // Match conditional variables
+        const conditionalPattern = /\{\{[#^](\w+)\}\}/g;
+        while ((match = conditionalPattern.exec(template)) !== null) {
+            variables.add(match[1]);
+        }
+        return Array.from(variables);
+    }
+}
+exports.TemplateRenderer = TemplateRenderer;
+// Singleton instance
+let rendererInstance = null;
+function getTemplateRenderer() {
+    if (!rendererInstance) {
+        rendererInstance = new TemplateRenderer();
+    }
+    return rendererInstance;
+}
+exports.getTemplateRenderer = getTemplateRenderer;

package/bin/templates/types.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Template types and interfaces
+ */
+export type TemplateCategory = "cicd" | "docker" | "kubernetes" | "migrations";
+export type CICDPlatform = "github" | "gitlab" | "circleci" | "jenkins" | "bitbucket" | "azure";
+export type CIStrategy = "basic" | "comprehensive" | "security-focused";
+export type DockerTemplate = "production" | "development" | "compose" | "compose-development";
+export type KubernetesTemplate = "deployment" | "service" | "configmap" | "ingress" | "secrets" | "kustomization";
+export interface TemplateInfo {
+    path: string;
+    version: string;
+    description?: string;
+    variables?: string[];
+}
+export interface TemplateManifest {
+    version: string;
+    updated: string;
+    templates: {
+        cicd?: Record<CICDPlatform, Record<CIStrategy, TemplateInfo>>;
+        docker?: Record<DockerTemplate, TemplateInfo>;
+        kubernetes?: Record<KubernetesTemplate, TemplateInfo>;
+        migrations?: Record<string, Record<string, TemplateInfo>>;
+    };
+}
+export interface TemplateVariable {
+    name: string;
+    value: string | number | boolean;
+}
+export interface RenderOptions {
+    variables: Record<string, string | number | boolean | undefined>;
+    conditionals?: Record<string, boolean>;
+}
+export interface CacheEntry<T> {
+    data: T;
+    timestamp: number;
+    ttl: number;
+}
+export interface CacheConfig {
+    directory: string;
+    ttl: number;
+}
+export interface TemplateConfig {
+    repository: string;
+    branch: string;
+    cacheTTL: number;
+}
+export interface FetchResult<T> {
+    data: T | null;
+    source: "cache" | "remote" | "fallback";
+    error?: string;
+}

package/bin/templates/types.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * Template types and interfaces
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/bin/utils/add-module-to-container.d.ts

@@ -1,3 +1,3 @@
-declare function addModuleToContainer(name: string, modulePath?: string, path?: string): Promise<void>;
-declare function addModuleToContainerNestedPath(name: string, path?: string): Promise<void>;
+declare function addModuleToContainer(name: string, modulePath?: string, path?: string, folderName?: string): Promise<void>;
+declare function addModuleToContainerNestedPath(name: string, path?: string, folderName?: string): Promise<void>;
 export { addModuleToContainer, addModuleToContainerNestedPath };

package/bin/utils/add-module-to-container.js

@@ -9,6 +9,7 @@ const glob_1 = require("glob");
 const node_fs_1 = __importDefault(require("node:fs"));
 const cli_ui_1 = require("./cli-ui");
 const compiler_1 = __importDefault(require("./compiler"));
+const update_tsconfig_paths_1 = require("./update-tsconfig-paths");
 const APP_CONTAINER = "app.ts";
 async function validateAppContainer() {
     const { sourceRoot } = await compiler_1.default.loadConfig();
@@ -56,14 +57,18 @@ async function validateAppContainer() {
         notImports,
     };
 }
-async function addModuleToContainer(name, modulePath, path) {
-    console.log("To chamando esse cara");
+async function addModuleToContainer(name, modulePath, path, folderName) {
     const containerData = await validateAppContainer();
     const moduleName = (name[0].toUpperCase() + name.slice(1)).trimStart();
     const { opinionated } = await compiler_1.default.loadConfig();
     let usecaseDir;
     if (opinionated) {
-        usecaseDir = `@useCases/`;
+        // Use dynamic path alias based on the actual folder
+        // Default to @useCases for backward compatibility
+        const pathAlias = folderName
+            ? (0, update_tsconfig_paths_1.getPathAliasForFolder)(folderName)
+            : "@useCases";
+        usecaseDir = `${pathAlias}/`;
     }
     else {
         usecaseDir = `./`;
@@ -99,13 +104,18 @@ async function addModuleToContainer(name, modulePath, path) {
     await node_fs_1.default.promises.writeFile(containerData.path, newFileContent, "utf8");
 }
 exports.addModuleToContainer = addModuleToContainer;
-async function addModuleToContainerNestedPath(name, path) {
+async function addModuleToContainerNestedPath(name, path, folderName) {
     const containerData = await validateAppContainer();
     const moduleName = (name[0].toUpperCase() + name.slice(1)).trimStart();
     const { opinionated } = await compiler_1.default.loadConfig();
     let usecaseDir;
     if (opinionated) {
-        usecaseDir = `@useCases/`;
+        // Use dynamic path alias based on the actual folder
+        // Default to @useCases for backward compatibility
+        const pathAlias = folderName
+            ? (0, update_tsconfig_paths_1.getPathAliasForFolder)(folderName)
+            : "@useCases";
+        usecaseDir = `${pathAlias}/`;
     }
     else {
         usecaseDir = `./`;

package/bin/utils/cli-ui.d.ts

@@ -1,5 +1,32 @@
-export declare function printError(message: string, component: string): void;
-export declare function printSuccess(message: string, component: string): void;
-export declare function printWarning(message: string, component?: string): void;
+/**
+ * Print error message (matches core logger ERROR format)
+ */
+export declare function printError(message: string, context: string): void;
+/**
+ * Print success message (matches core logger INFO format)
+ */
+export declare function printSuccess(message: string, context: string): void;
+/**
+ * Print warning message (matches core logger WARN format)
+ */
+export declare function printWarning(message: string, context?: string): void;
+/**
+ * Print info message (matches core logger INFO format)
+ */
+export declare function printInfo(message: string, context: string): void;
+/**
+ * Print debug message (matches core logger DEBUG format)
+ */
+export declare function printDebug(message: string, context: string): void;
+/**
+ * Print generate error (simplified format for scaffolding)
+ */
 export declare function printGenerateError(schematic: string, file: string): Promise<void>;
+/**
+ * Print generate success (simplified format for scaffolding)
+ */
 export declare function printGenerateSuccess(schematic: string, file: string): Promise<void>;
+/**
+ * Print the ExpressoTS CLI header
+ */
+export declare function printHeader(): void;

package/bin/utils/cli-ui.js

@@ -3,30 +3,112 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.printGenerateSuccess = exports.printGenerateError = exports.printWarning = exports.printSuccess = exports.printError = void 0;
+exports.printHeader = exports.printGenerateSuccess = exports.printGenerateError = exports.printDebug = exports.printInfo = exports.printWarning = exports.printSuccess = exports.printError = void 0;
 const chalk_1 = __importDefault(require("chalk"));
 const process_1 = require("process");
-function printError(message, component) {
-    console.error(chalk_1.default.red(`${message}:`, chalk_1.default.bold(chalk_1.default.white(`[${component}] ❌`))));
+/**
+ * Format timestamp for display (matches core logger format)
+ */
+function formatTimestamp() {
+    const date = new Date();
+    const options = {
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit",
+    };
+    return date.toLocaleString(undefined, options).replace(",", "");
+}
+/**
+ * Color a string based on log level
+ */
+function colorByLevel(level, text) {
+    switch (level) {
+        case "INFO":
+            return chalk_1.default.green(text);
+        case "WARN":
+            return chalk_1.default.yellow(text);
+        case "ERROR":
+            return chalk_1.default.red(text);
+        case "DEBUG":
+            return chalk_1.default.blue(text);
+        default:
+            return chalk_1.default.white(text);
+    }
+}
+/**
+ * Core log function matching ExpressoTS core logger format
+ * Format: [ExpressoTS] timestamp LEVEL [context] message
+ */
+function log(level, context, message, icon) {
+    const timestamp = formatTimestamp();
+    const levelStr = colorByLevel(level, level.padEnd(5, " "));
+    const contextStr = chalk_1.default.green(`[${context}]`);
+    const messageStr = colorByLevel(level, message);
+    const iconStr = icon ? ` ${icon}` : "";
+    const output = `${chalk_1.default.green("[ExpressoTS]")} ${timestamp} ${levelStr} ${contextStr} ${messageStr}${iconStr}\n`;
+    if (level === "ERROR") {
+        process.stderr.write(output);
+    }
+    else {
+        process_1.stdout.write(output);
+    }
+}
+/**
+ * Print error message (matches core logger ERROR format)
+ */
+function printError(message, context) {
+    log("ERROR", context, message, "❌");
 }
 exports.printError = printError;
-function printSuccess(message, component) {
-    process_1.stdout.write(chalk_1.default.green(`${message}:`, chalk_1.default.bold(chalk_1.default.white(`[${component}] ✔️\n`))));
+/**
+ * Print success message (matches core logger INFO format)
+ */
+function printSuccess(message, context) {
+    log("INFO", context, message, "✔️");
 }
 exports.printSuccess = printSuccess;
-function printWarning(message, component) {
-    if (component === undefined) {
-        process_1.stdout.write(chalk_1.default.yellow(`${message} ⚠️\n`));
-        return;
-    }
-    process_1.stdout.write(chalk_1.default.yellow(`${message}:`, chalk_1.default.bold(chalk_1.default.white(`[${component}] ⚠️\n`))));
+/**
+ * Print warning message (matches core logger WARN format)
+ */
+function printWarning(message, context) {
+    log("WARN", context || "cli", message, "⚠️");
 }
 exports.printWarning = printWarning;
+/**
+ * Print info message (matches core logger INFO format)
+ */
+function printInfo(message, context) {
+    log("INFO", context, message);
+}
+exports.printInfo = printInfo;
+/**
+ * Print debug message (matches core logger DEBUG format)
+ */
+function printDebug(message, context) {
+    log("DEBUG", context, message);
+}
+exports.printDebug = printDebug;
+/**
+ * Print generate error (simplified format for scaffolding)
+ */
 async function printGenerateError(schematic, file) {
-    console.error(" ", chalk_1.default.redBright(`[${schematic}]`.padEnd(14)), chalk_1.default.bold.white(`${file.split(".")[0]} not created! ❌`));
+    log("ERROR", schematic, `${file.split(".")[0]} not created!`, "❌");
 }
 exports.printGenerateError = printGenerateError;
+/**
+ * Print generate success (simplified format for scaffolding)
+ */
 async function printGenerateSuccess(schematic, file) {
-    console.log(" ", chalk_1.default.greenBright(`[${schematic}]`.padEnd(14)), chalk_1.default.bold.white(`${file.split(".")[0]} created! ✔️`));
+    log("INFO", schematic, `${file.split(".")[0]} created!`, "✔️");
 }
 exports.printGenerateSuccess = printGenerateSuccess;
+/**
+ * Print the ExpressoTS CLI header
+ */
+function printHeader() {
+    process_1.stdout.write(`\n${chalk_1.default.bold.green("🐎 ExpressoTS CLI")}\n\n`);
+}
+exports.printHeader = printHeader;

package/bin/utils/index.d.ts

@@ -1 +1,5 @@
 export * from "./compiler";
+export * from "./input-validation";
+export * from "./package-manager-commands";
+export * from "./safe-spawn";
+export * from "./update-tsconfig-paths";

package/bin/utils/index.js

@@ -15,3 +15,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./compiler"), exports);
+__exportStar(require("./input-validation"), exports);
+__exportStar(require("./package-manager-commands"), exports);
+__exportStar(require("./safe-spawn"), exports);
+__exportStar(require("./update-tsconfig-paths"), exports);

package/bin/utils/input-validation.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Input validation utilities used across the CLI to defend against
+ * command injection and path traversal when user-supplied values flow
+ * into child_process spawn/exec calls or filesystem writes.
+ */
+/**
+ * Guard against shell metacharacters in any value that will be
+ * interpolated into a shell-evaluated command line.
+ */
+export declare function containsShellMetachars(value: string): boolean;
+/**
+ * Validate an npm package name (with optional scope).
+ */
+export declare function isValidPackageName(name: unknown): name is string;
+/**
+ * Validate a version specifier passed to a package manager. Accepts
+ * `latest`, `next`, exact versions and common range syntaxes
+ * (`>=1.2.3 <2.0.0`, `*`, `1.x`). Returns false for the boolean
+ * fallback yargs sometimes assigns when the flag is absent.
+ *
+ * Versions are forwarded via argv (`shell: false`), so we whitelist
+ * the characters npm itself accepts in semver ranges and reject the
+ * rest. We do NOT layer the broader `containsShellMetachars` check
+ * here because legitimate ranges include `<`, `>`, `|`, and `*`.
+ */
+export declare function isValidVersion(version: unknown): version is string;
+/**
+ * Validate an npm/yarn/pnpm script name.
+ */
+export declare function isValidScriptName(name: unknown): name is string;
+export declare function isValidPackageManager(pm: unknown): pm is "npm" | "yarn" | "pnpm" | "bun";
+/**
+ * Resolve `target` against `base` and verify the result is contained
+ * within `base`. Returns the resolved absolute path on success, or
+ * `null` when the resolved path escapes the base directory (path
+ * traversal attempt).
+ */
+export declare function safeResolveWithin(base: string, target: string): string | null;
+/**
+ * Throws a generic `Error` if the value is not a safe package name.
+ */
+export declare function assertValidPackageName(name: unknown): asserts name is string;
+/**
+ * Throws a generic `Error` if the value is not a safe version range.
+ */
+export declare function assertValidVersion(version: unknown): asserts version is string;
+/**
+ * Throws a generic `Error` if the value is not a safe script name.
+ */
+export declare function assertValidScriptName(name: unknown): asserts name is string;