@expressots/cli 3.0.0 → 4.0.0-preview.3

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,14 @@
-declare function addModuleToContainer(name: string, modulePath?: string, path?: string): Promise<void>;
-declare function addModuleToContainerNestedPath(name: string, path?: string): Promise<void>;
-export { addModuleToContainer, addModuleToContainerNestedPath };
+/**
+ * Register a scaffolded module in `app.ts`.
+ *
+ * The import specifier is derived from the module file's real location
+ * (`moduleOutputPath`) so it always resolves to the file on disk, regardless of
+ * the path style used to scaffold it.
+ *
+ * @param moduleClassName - Exported module symbol, e.g. `UserModule`.
+ * @param moduleOutputPath - Path to the generated `*.module.ts` file.
+ * @param folderToScaffold - Destination root, e.g. `src/useCases`.
+ * @param folderName - Folder basename used to resolve the path alias, e.g. `useCases`.
+ */
+declare function addModuleToContainerByPath(moduleClassName: string, moduleOutputPath: string, folderToScaffold: string, folderName: string): Promise<void>;
+export { addModuleToContainerByPath };

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

@@ -1,20 +1,46 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.addModuleToContainerNestedPath = exports.addModuleToContainer = void 0;
-const chalk_1 = __importDefault(require("chalk"));
+exports.addModuleToContainerByPath = void 0;
 const glob_1 = require("glob");
 const node_fs_1 = __importDefault(require("node:fs"));
+const nodePath = __importStar(require("node:path"));
 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() {
+/**
+ * Locate `app.ts` and read its raw content. We deliberately avoid any
+ * line-based parsing here so multi-line imports and nested array literals
+ * survive untouched.
+ */
+async function readAppContainer() {
     const { sourceRoot } = await compiler_1.default.loadConfig();
-    const imports = [];
-    const notImports = [];
-    // Locate the container file
     const path = (0, glob_1.globSync)(`./${sourceRoot}/${APP_CONTAINER}`, {
         absolute: true,
         ignore: "**/node_modules/**",
@@ -23,112 +49,315 @@ async function validateAppContainer() {
         (0, cli_ui_1.printError)("Module not added to Container. Container file not found!", APP_CONTAINER);
         process.exit(1);
     }
-    // Read the container file
-    const fileContent = await node_fs_1.default.promises.readFile(path[0], "utf8");
-    // Collect imports and other lines
-    fileContent.split("\n").forEach((line) => {
-        if (line.startsWith("import")) {
-            imports.push(line);
+    const content = await node_fs_1.default.promises.readFile(path[0], "utf8");
+    return { path: path[0], content };
+}
+/**
+ * Detect the indentation (leading whitespace) of the line containing `index`.
+ */
+function getLineIndent(source, index) {
+    const lineStart = source.lastIndexOf("\n", index - 1) + 1;
+    const match = /^[\t ]*/.exec(source.slice(lineStart));
+    return match ? match[0] : "";
+}
+/**
+ * Skip over a string literal starting at `i` (the index of the opening quote).
+ * Handles `"..."`, `'...'`, and template strings ``` `...` ``` including escapes.
+ * Returns the index just past the closing quote.
+ */
+function skipString(source, i) {
+    const quote = source[i];
+    i++;
+    while (i < source.length) {
+        const ch = source[i];
+        if (ch === "\\") {
+            i += 2;
+            continue;
         }
-        else {
-            notImports.push(line);
+        if (ch === quote)
+            return i + 1;
+        i++;
+    }
+    return source.length;
+}
+/**
+ * Skip over a `// line` or `/* block *\/` comment starting at `i`.
+ * Returns the index just past the comment, or `i` unchanged if not a comment.
+ */
+function skipComment(source, i) {
+    if (source[i] === "/" && source[i + 1] === "/") {
+        const nl = source.indexOf("\n", i);
+        return nl === -1 ? source.length : nl;
+    }
+    if (source[i] === "/" && source[i + 1] === "*") {
+        const close = source.indexOf("*/", i + 2);
+        return close === -1 ? source.length : close + 2;
+    }
+    return i;
+}
+/**
+ * Find the index immediately after the last top-level `import ... ;`
+ * statement. Returns 0 if no imports are present. The scan is string- and
+ * comment-aware so multi-line imports and quoted semicolons don't confuse it.
+ */
+function findLastImportEnd(source) {
+    let i = 0;
+    let lastEnd = 0;
+    while (i < source.length) {
+        while (i < source.length && /\s/.test(source[i]))
+            i++;
+        const afterComment = skipComment(source, i);
+        if (afterComment !== i) {
+            i = afterComment;
+            continue;
         }
-    });
-    // Regex to detect and extract modules from configContainer
-    const moduleRegex = /this\.configContainer\(\s*\[\s*([\s\S]*?)\s*]\s*\)/;
-    const moduleMatch = fileContent.match(moduleRegex);
-    if (!moduleMatch) {
-        (0, cli_ui_1.printError)("The App class does not contain a valid configContainer([]) declaration!", APP_CONTAINER);
-        process.exit(1);
+        if (!source.startsWith("import", i))
+            break;
+        // Walk forward until the terminating semicolon, ignoring strings/comments.
+        let j = i + "import".length;
+        while (j < source.length) {
+            const ch = source[j];
+            if (ch === '"' || ch === "'" || ch === "`") {
+                j = skipString(source, j);
+                continue;
+            }
+            const afterCmt = skipComment(source, j);
+            if (afterCmt !== j) {
+                j = afterCmt;
+                continue;
+            }
+            if (ch === ";") {
+                j++;
+                break;
+            }
+            j++;
+        }
+        lastEnd = j;
+        i = j;
     }
-    // Extract modules if present
-    const modules = moduleMatch[1]
-        .trim()
-        .split(",")
-        .filter((m) => m.trim() !== "")
-        .map((m) => m.trim());
-    return {
-        regex: moduleRegex,
-        path: path[0],
-        content: fileContent,
-        modules,
-        imports,
-        notImports,
-    };
+    return lastEnd;
 }
-async function addModuleToContainer(name, modulePath, path) {
-    console.log("To chamando esse cara");
-    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/`;
+/**
+ * Locate the call expression `callName(` starting at or after `from`, then
+ * return the `[start, end]` indices (inclusive of the opening `(` and matching
+ * `)`) of its argument list. Returns null if not found.
+ *
+ * The matcher respects strings, comments, and balanced brackets so the inner
+ * `CreateModule([...])` does not prematurely close the outer call.
+ */
+function findCallRange(source, callName, from = 0) {
+    const needle = `${callName}(`;
+    const start = source.indexOf(needle, from);
+    if (start === -1)
+        return null;
+    const open = start + needle.length - 1; // index of '('
+    let depthParen = 1;
+    let depthBracket = 0;
+    let depthBrace = 0;
+    let i = open + 1;
+    while (i < source.length && depthParen > 0) {
+        const ch = source[i];
+        if (ch === '"' || ch === "'" || ch === "`") {
+            i = skipString(source, i);
+            continue;
+        }
+        const afterCmt = skipComment(source, i);
+        if (afterCmt !== i) {
+            i = afterCmt;
+            continue;
+        }
+        if (ch === "(")
+            depthParen++;
+        else if (ch === ")")
+            depthParen--;
+        else if (ch === "[")
+            depthBracket++;
+        else if (ch === "]")
+            depthBracket--;
+        else if (ch === "{")
+            depthBrace++;
+        else if (ch === "}")
+            depthBrace--;
+        i++;
     }
-    else {
-        usecaseDir = `./`;
+    if (depthParen !== 0 || depthBracket !== 0 || depthBrace !== 0)
+        return null;
+    return { open, close: i - 1 }; // close = index of ')'
+}
+/**
+ * Locate the first array literal `[...]` at or after `from`, returning the
+ * indices of the opening `[` and matching `]`. Bracket-balanced and
+ * string/comment safe.
+ */
+function findArrayRange(source, from) {
+    let i = from;
+    while (i < source.length) {
+        const ch = source[i];
+        if (ch === "[")
+            break;
+        if (ch === '"' || ch === "'" || ch === "`") {
+            i = skipString(source, i);
+            continue;
+        }
+        const afterCmt = skipComment(source, i);
+        if (afterCmt !== i) {
+            i = afterCmt;
+            continue;
+        }
+        i++;
     }
-    let newImport = "";
-    const modulePathRegex = /^[^/]=$/;
-    if (!modulePathRegex.test(modulePath)) {
-        if (path.split("/").length > 1) {
-            newImport = `import { ${moduleName}Module } from "${usecaseDir}${name.toLowerCase()}/${name.toLowerCase()}.module";`;
+    if (i >= source.length || source[i] !== "[")
+        return null;
+    const open = i;
+    let depth = 1;
+    let j = open + 1;
+    while (j < source.length && depth > 0) {
+        const ch = source[j];
+        if (ch === '"' || ch === "'" || ch === "`") {
+            j = skipString(source, j);
+            continue;
         }
-        else {
-            newImport = `import { ${moduleName}Module } from "${usecaseDir}${name.toLowerCase()}.module";`;
+        const afterCmt = skipComment(source, j);
+        if (afterCmt !== j) {
+            j = afterCmt;
+            continue;
         }
+        if (ch === "[")
+            depth++;
+        else if (ch === "]")
+            depth--;
+        j++;
     }
-    else {
-        newImport = `import { ${moduleName}Module } from "${usecaseDir}${name}/${name.toLowerCase()}.module";`;
+    if (depth !== 0)
+        return null;
+    return { open, close: j - 1 };
+}
+/**
+ * Insert `name` as a new entry in the array literal that starts at `arrayOpen`
+ * (the index of `[`) and ends at `arrayClose` (the index of the matching `]`).
+ *
+ * Preserves the original formatting: trailing-comma style is honoured, inline
+ * arrays stay inline, and multi-line arrays receive the new entry on its own
+ * line with matching indentation. If `name` is already present in the array
+ * the source is returned unchanged.
+ */
+function insertIntoArray(source, arrayOpen, arrayClose, name) {
+    const inner = source.slice(arrayOpen + 1, arrayClose);
+    // Skip insertion if the identifier is already a top-level token in the array.
+    const tokenRegex = /\b[A-Za-z_$][\w$]*\b/g;
+    let match;
+    while ((match = tokenRegex.exec(inner)) !== null) {
+        if (match[0] === name)
+            return source;
     }
-    if (containerData.imports.includes(newImport) &&
-        containerData.modules.includes(`${moduleName}Module`)) {
-        return;
+    if (inner.trim().length === 0) {
+        return source.slice(0, arrayOpen + 1) + name + source.slice(arrayClose);
     }
-    containerData.imports.push(newImport);
-    containerData.modules.push(`${moduleName}Module`);
-    const newModule = containerData.modules.join(", ");
-    const newModuleDeclaration = `this.configContainer([${newModule}])`;
-    const newFileContent = [
-        ...containerData.imports,
-        ...containerData.notImports,
-    ]
-        .join("\n")
-        .replace(containerData.regex, newModuleDeclaration);
-    console.log(" ", chalk_1.default.greenBright(`[container]`.padEnd(14)), chalk_1.default.bold.white(`${moduleName}Module added to ${APP_CONTAINER}! ✔️`));
-    await node_fs_1.default.promises.writeFile(containerData.path, newFileContent, "utf8");
+    // Find the last meaningful character inside the array (skip trailing
+    // whitespace before `]`).
+    let lastChar = arrayClose - 1;
+    while (lastChar > arrayOpen && /\s/.test(source[lastChar]))
+        lastChar--;
+    const hasTrailingComma = source[lastChar] === ",";
+    const isMultiLine = inner.includes("\n");
+    if (!isMultiLine) {
+        const insertion = hasTrailingComma ? ` ${name}` : `, ${name}`;
+        return (source.slice(0, lastChar + 1) +
+            insertion +
+            source.slice(lastChar + 1));
+    }
+    // Multi-line: match the indentation of the last item and place the new
+    // entry on its own line just before the closing bracket.
+    const itemIndent = getLineIndent(source, lastChar);
+    const insertAt = lastChar + 1;
+    const insertion = (hasTrailingComma ? "" : ",") + `\n${itemIndent}${name},`;
+    return source.slice(0, insertAt) + insertion + source.slice(insertAt);
 }
-exports.addModuleToContainer = addModuleToContainer;
-async function addModuleToContainerNestedPath(name, path) {
-    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/`;
+/**
+ * Insert a new import statement after the last existing one, preserving any
+ * blank line that already separates imports from code. If the import is
+ * already present (textually) the file is returned unchanged.
+ */
+function insertImport(source, importLine) {
+    if (source.includes(importLine))
+        return source;
+    const insertAt = findLastImportEnd(source);
+    if (insertAt === 0) {
+        // No existing imports: prepend at top.
+        const sep = source.startsWith("\n") ? "" : "\n";
+        return importLine + "\n" + sep + source;
+    }
+    const before = source.slice(0, insertAt);
+    const after = source.slice(insertAt);
+    return before + "\n" + importLine + after;
+}
+/**
+ * Add `${moduleName}Module` to the container declaration in `app.ts`.
+ *
+ * Handles both layouts:
+ *   - v4 wrapper:  this.configContainer([CreateModule([...]), ModuleA, ModuleB])
+ *   - legacy flat: this.configContainer([ModuleA, ModuleB])
+ *
+ * Scaffolded modules are always inserted into the outer `configContainer([...])`
+ * array as peer entries alongside `CreateModule([...])`. The inner
+ * `CreateModule([...])` is reserved for orphan controllers that don't have
+ * their own module file.
+ */
+function addModuleToContainerSource(source, className) {
+    const configCall = findCallRange(source, "this.configContainer");
+    if (!configCall) {
+        (0, cli_ui_1.printError)("The App class does not contain a valid configContainer([]) declaration!", APP_CONTAINER);
+        process.exit(1);
     }
-    else {
-        usecaseDir = `./`;
+    const outerArray = findArrayRange(source, configCall.open + 1);
+    if (!outerArray || outerArray.close > configCall.close) {
+        (0, cli_ui_1.printError)("configContainer must be called with an array literal argument.", APP_CONTAINER);
+        process.exit(1);
     }
-    if (path.endsWith("/")) {
-        path = path.slice(0, -1);
+    return insertIntoArray(source, outerArray.open, outerArray.close, className);
+}
+/**
+ * Build the import specifier for a scaffolded module from its real on-disk
+ * location. In opinionated mode the path alias for the destination folder is
+ * used (e.g. `@useCases/user-create/user.module`); otherwise a relative import
+ * from the source root is produced. Deriving the specifier from the actual file
+ * path guarantees the generated import always matches where the module was
+ * written, independent of the path style (sugar/single/nested).
+ */
+async function buildModuleImportSpec(moduleOutputPath, folderToScaffold, folderName) {
+    const { opinionated, sourceRoot } = await compiler_1.default.loadConfig();
+    const normalize = (p) => p.replace(/\\/g, "/").replace(/\.ts$/, "");
+    if (opinionated) {
+        const rel = normalize(nodePath.relative(folderToScaffold, moduleOutputPath));
+        return `${(0, update_tsconfig_paths_1.getPathAliasForFolder)(folderName)}/${rel}`;
     }
-    const newImport = `import { ${moduleName}Module } from "${usecaseDir}${path}.module";`;
-    if (containerData.imports.includes(newImport) &&
-        containerData.modules.includes(`${moduleName}Module`)) {
+    const rel = normalize(nodePath.relative(sourceRoot, moduleOutputPath));
+    return `./${rel}`;
+}
+async function applyContainerEdit(className, importLine) {
+    const info = await readAppContainer();
+    let next = insertImport(info.content, importLine);
+    next = addModuleToContainerSource(next, className);
+    if (next === info.content)
         return;
-    }
-    containerData.imports.push(newImport);
-    containerData.modules.push(`${moduleName}Module`);
-    const newModule = containerData.modules.join(", ");
-    const newModuleDeclaration = `this.configContainer([${newModule}])`;
-    const newFileContent = [
-        ...containerData.imports,
-        ...containerData.notImports,
-    ]
-        .join("\n")
-        .replace(containerData.regex, newModuleDeclaration);
-    console.log(" ", chalk_1.default.greenBright(`[container]`.padEnd(14)), chalk_1.default.bold.white(`${moduleName}Module added to ${APP_CONTAINER}! ✔️`));
-    await node_fs_1.default.promises.writeFile(containerData.path, newFileContent, "utf8");
+    await node_fs_1.default.promises.writeFile(info.path, next, "utf8");
+    (0, cli_ui_1.printSuccess)(`${className} registered in ${APP_CONTAINER}`, "container");
+}
+/**
+ * Register a scaffolded module in `app.ts`.
+ *
+ * The import specifier is derived from the module file's real location
+ * (`moduleOutputPath`) so it always resolves to the file on disk, regardless of
+ * the path style used to scaffold it.
+ *
+ * @param moduleClassName - Exported module symbol, e.g. `UserModule`.
+ * @param moduleOutputPath - Path to the generated `*.module.ts` file.
+ * @param folderToScaffold - Destination root, e.g. `src/useCases`.
+ * @param folderName - Folder basename used to resolve the path alias, e.g. `useCases`.
+ */
+async function addModuleToContainerByPath(moduleClassName, moduleOutputPath, folderToScaffold, folderName) {
+    const importSpec = await buildModuleImportSpec(moduleOutputPath, folderToScaffold, folderName);
+    const importLine = `import { ${moduleClassName} } from "${importSpec}";`;
+    await applyContainerEdit(moduleClassName, importLine);
 }
-exports.addModuleToContainerNestedPath = addModuleToContainerNestedPath;
+exports.addModuleToContainerByPath = addModuleToContainerByPath;

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

@@ -1,5 +1,51 @@
-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 a section title. Intended for interactive/listing output (e.g.
+ * `templates list`, `costs compare`) where the structured logger format
+ * (`[ExpressoTS] timestamp LEVEL`) would be noisy. Leading newline keeps
+ * sections visually separated.
+ */
+export declare function printSection(title: string): void;
+/**
+ * Print an indented bullet point under a section.
+ */
+export declare function printBullet(text: string): void;
+/**
+ * Print a dim horizontal divider sized to the terminal width (capped).
+ */
+export declare function printDivider(): void;
+/**
+ * Print an aligned key/value pair (e.g. `Source:  remote`).
+ */
+export declare function printKeyValue(key: string, value: string, padding?: number): void;
+/**
+ * Print the ExpressoTS CLI header
+ */
+export declare function printHeader(version?: string): void;