@lenne.tech/cli 1.6.9 → 1.7.0

package/build/commands/update.js

@@ -9,6 +9,24 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+const child_process_1 = require("child_process");
+/**
+ * Get the version that a new CLI process would use by running 'lt --version'.
+ * This is the most reliable way to check if the update was successful,
+ * as it tests the actual behavior of a new process.
+ */
+function getNewProcessVersion() {
+    try {
+        const result = (0, child_process_1.execSync)('lt --version', {
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        return result.trim();
+    }
+    catch (_a) {
+        return null;
+    }
+}
 /**
  * Update @lenne.tech/cli
  */
@@ -19,12 +37,41 @@ const NewCommand = {
     name: 'update',
     run: (toolbox) => __awaiter(void 0, void 0, void 0, function* () {
         // Retrieve the tools we need
-        const { helper, runtime: { brand }, } = toolbox;
+        const { helper, meta, print: { info, warning }, runtime: { brand }, } = toolbox;
+        // Store version before update
+        const versionBefore = meta.version();
         // Update cli and show process
         yield helper.updateCli({ showInfos: true });
+        // Check what version a new process would use
+        const newProcessVersion = getNewProcessVersion();
+        // Check if update was successful and version changed
+        if (newProcessVersion && newProcessVersion !== versionBefore) {
+            info('');
+            info(`Update successful: ${versionBefore} → ${newProcessVersion}`);
+            info('');
+            const shell = process.env.SHELL || '';
+            if (shell.includes('zsh')) {
+                info(`To use the new version, run 'rehash' or open a new terminal.`);
+            }
+            else if (shell.includes('bash')) {
+                info(`To use the new version, run 'hash -r' or open a new terminal.`);
+            }
+            else {
+                info(`To use the new version, open a new terminal.`);
+            }
+        }
+        else if (newProcessVersion === versionBefore) {
+            info('');
+            info(`CLI is already up to date (${versionBefore}).`);
+        }
+        else {
+            // Could not verify update
+            warning('');
+            warning(`Could not verify update. Please run 'lt --version' to check.`);
+        }
         // For tests
         return `updated ${brand}`;
     }),
 };
 exports.default = NewCommand;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXBkYXRlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2NvbW1hbmRzL3VwZGF0ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7OztBQUlBOztHQUVHO0FBQ0gsTUFBTSxVQUFVLEdBQW1CO0lBQ2pDLEtBQUssRUFBRSxDQUFDLElBQUksQ0FBQztJQUNiLFdBQVcsRUFBRSx3QkFBd0I7SUFDckMsTUFBTSxFQUFFLEtBQUs7SUFDYixJQUFJLEVBQUUsUUFBUTtJQUNkLEdBQUcsRUFBRSxDQUFPLE9BQStCLEVBQUUsRUFBRTtRQUM3Qyw2QkFBNkI7UUFDN0IsTUFBTSxFQUNKLE1BQU0sRUFDTixPQUFPLEVBQUUsRUFBRSxLQUFLLEVBQUUsR0FDbkIsR0FBRyxPQUFPLENBQUM7UUFFWiw4QkFBOEI7UUFDOUIsTUFBTSxNQUFNLENBQUMsU0FBUyxDQUFDLEVBQUUsU0FBUyxFQUFFLElBQUksRUFBRSxDQUFDLENBQUM7UUFFNUMsWUFBWTtRQUNaLE9BQU8sV0FBVyxLQUFLLEVBQUUsQ0FBQztJQUM1QixDQUFDLENBQUE7Q0FDRixDQUFDO0FBRUYsa0JBQWUsVUFBVSxDQUFDIn0=
+//# sourceMappingURL=data:application/json;base64,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

package/build/extensions/api-mode.js

@@ -0,0 +1,440 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiMode = void 0;
+const path_1 = require("path");
+/**
+ * API Mode processing for nest-server-starter template
+ *
+ * Reads the api-mode.manifest.json from the project and processes it
+ * based on the selected API mode (Rest, GraphQL, Both).
+ */
+class ApiMode {
+    constructor(toolbox) {
+        this.toolbox = toolbox;
+        this.filesystem = toolbox.filesystem;
+    }
+    /**
+     * Process the API mode for a project
+     *
+     * @param projectPath - Path to the project root
+     * @param mode - Selected API mode
+     */
+    processApiMode(projectPath, mode) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const manifestPath = (0, path_1.join)(projectPath, 'api-mode.manifest.json');
+            // Read manifest
+            const manifestContent = this.filesystem.read(manifestPath);
+            if (!manifestContent) {
+                return; // No manifest = nothing to do
+            }
+            const manifest = JSON.parse(manifestContent);
+            if (mode === 'Both') {
+                // Both mode: just remove markers and cleanup
+                this.stripAllMarkers(projectPath);
+            }
+            else if (mode === 'Rest') {
+                // REST mode: remove graphql regions, keep rest regions
+                yield this.removeMode(projectPath, manifest, 'graphql', 'rest');
+                yield this.modifyConfigEnvForRest(projectPath);
+            }
+            else if (mode === 'GraphQL') {
+                // GraphQL mode: remove rest regions, keep graphql regions
+                yield this.removeMode(projectPath, manifest, 'rest', 'graphql');
+            }
+            // Remove manifest and strip-markers script
+            this.filesystem.remove(manifestPath);
+            this.filesystem.remove((0, path_1.join)(projectPath, 'scripts', 'strip-api-mode-markers.mjs'));
+            // Remove strip-markers script from package.json
+            this.removeScriptFromPackageJson(projectPath, 'strip-markers');
+        });
+    }
+    /**
+     * Remove a specific mode from the project
+     */
+    removeMode(projectPath, manifest, removeMarker, keepMarker) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            const modeConfig = manifest.modes[removeMarker];
+            if (!modeConfig) {
+                return;
+            }
+            // 1. Delete files matching filePatterns
+            if (modeConfig.filePatterns) {
+                for (const pattern of modeConfig.filePatterns) {
+                    const matches = this.filesystem.find(projectPath, {
+                        matching: pattern,
+                    });
+                    for (const file of matches) {
+                        this.filesystem.remove(file);
+                    }
+                }
+            }
+            // 2. Remove packages from package.json
+            const pkgPath = (0, path_1.join)(projectPath, 'package.json');
+            const pkg = JSON.parse(this.filesystem.read(pkgPath));
+            if (modeConfig.packages) {
+                for (const p of modeConfig.packages) {
+                    (_a = pkg.dependencies) === null || _a === void 0 ? true : delete _a[p];
+                }
+            }
+            if (modeConfig.devPackages) {
+                for (const p of modeConfig.devPackages) {
+                    (_b = pkg.devDependencies) === null || _b === void 0 ? true : delete _b[p];
+                }
+            }
+            // 3. Remove scripts
+            if (modeConfig.scripts) {
+                for (const s of modeConfig.scripts) {
+                    (_c = pkg.scripts) === null || _c === void 0 ? true : delete _c[s];
+                }
+            }
+            // 4. Edit scripts (e.g. remove parts from a script value)
+            if (modeConfig.scriptEdits && pkg.scripts) {
+                for (const [scriptName, edit] of Object.entries(modeConfig.scriptEdits)) {
+                    if (pkg.scripts[scriptName] && edit.remove) {
+                        pkg.scripts[scriptName] = pkg.scripts[scriptName].replace(edit.remove, '');
+                    }
+                }
+            }
+            this.filesystem.write(pkgPath, pkg, { jsonIndent: 2 });
+            // 5. Strip regions from source files
+            this.stripRegions(projectPath, removeMarker, keepMarker);
+            // 6. Clean orphan imports
+            this.cleanOrphanImports(projectPath);
+        });
+    }
+    /**
+     * Strip region markers from all .ts files
+     *
+     * For removeMarker: delete marker lines AND content between them
+     * For keepMarker: delete only the marker lines, keep content
+     */
+    stripRegions(projectPath, removeMarker, keepMarker) {
+        const dirs = [(0, path_1.join)(projectPath, 'src'), (0, path_1.join)(projectPath, 'tests')];
+        for (const dir of dirs) {
+            if (!this.filesystem.exists(dir)) {
+                continue;
+            }
+            const files = this.filesystem.find(dir, { matching: '**/*.ts' });
+            for (const file of files) {
+                const content = this.filesystem.read(file);
+                if (!content) {
+                    continue;
+                }
+                const processed = this.processFileRegions(content, removeMarker, keepMarker);
+                if (processed !== content) {
+                    this.filesystem.write(file, processed);
+                }
+            }
+        }
+    }
+    /**
+     * Process region markers in file content
+     */
+    processFileRegions(content, removeMarker, keepMarker) {
+        const lines = content.split('\n');
+        const result = [];
+        let removing = false;
+        for (const line of lines) {
+            const trimmed = line.trim();
+            // Check for region start
+            if (trimmed === `// #region ${removeMarker}`) {
+                removing = true;
+                continue; // Skip the marker line
+            }
+            // Check for region end
+            if (trimmed === `// #endregion ${removeMarker}`) {
+                removing = false;
+                continue; // Skip the marker line
+            }
+            // Check for keep markers (just remove the marker lines, keep content)
+            if (trimmed === `// #region ${keepMarker}` || trimmed === `// #endregion ${keepMarker}`) {
+                continue; // Skip marker line, content between them is kept naturally
+            }
+            // Skip content inside remove region
+            if (removing) {
+                continue;
+            }
+            result.push(line);
+        }
+        // Clean up multiple consecutive blank lines (max 1)
+        return this.collapseBlankLines(result.join('\n'));
+    }
+    /**
+     * Strip ALL markers (for Both mode) - keep all content
+     */
+    stripAllMarkers(projectPath) {
+        const dirs = [(0, path_1.join)(projectPath, 'src'), (0, path_1.join)(projectPath, 'tests')];
+        for (const dir of dirs) {
+            if (!this.filesystem.exists(dir)) {
+                continue;
+            }
+            const files = this.filesystem.find(dir, { matching: '**/*.ts' });
+            for (const file of files) {
+                const content = this.filesystem.read(file);
+                if (!content) {
+                    continue;
+                }
+                const lines = content.split('\n');
+                const filtered = lines.filter((line) => {
+                    const trimmed = line.trim();
+                    return !trimmed.match(/^\/\/ #(region|endregion)\s/);
+                });
+                const processed = filtered.join('\n');
+                if (processed !== content) {
+                    this.filesystem.write(file, processed);
+                }
+            }
+        }
+    }
+    /**
+     * Modify config.env.ts for REST mode using ts-morph AST manipulation
+     *
+     * - Replace `graphQl: { ... }` blocks with `graphQl: false`
+     * - Remove `execAfterInit` properties
+     */
+    modifyConfigEnvForRest(projectPath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const configPath = (0, path_1.join)(projectPath, 'src', 'config.env.ts');
+            if (!this.filesystem.exists(configPath)) {
+                return;
+            }
+            try {
+                const { Project, SyntaxKind } = require('ts-morph');
+                const project = new Project({ skipAddingFilesFromTsConfig: true });
+                const sourceFile = project.addSourceFileAtPath(configPath);
+                // Find the 'config' variable declaration directly
+                // Structure: export const config: { [env: string]: ... } = { ci: { ... }, develop: { ... }, ... };
+                let configObj;
+                const variableStatements = sourceFile.getVariableStatements();
+                for (const vs of variableStatements) {
+                    for (const decl of vs.getDeclarations()) {
+                        if (decl.getName() === 'config') {
+                            const init = decl.getInitializer();
+                            if ((init === null || init === void 0 ? void 0 : init.getKind()) === SyntaxKind.ObjectLiteralExpression) {
+                                configObj = init;
+                            }
+                        }
+                        // Handle merge() call: const config = merge({ default: ... }, { local: ... }, ...)
+                        if (!configObj) {
+                            const init = decl.getInitializer();
+                            if ((init === null || init === void 0 ? void 0 : init.getKind()) === SyntaxKind.CallExpression) {
+                                const args = (_a = init.getArguments) === null || _a === void 0 ? void 0 : _a.call(init);
+                                if (args) {
+                                    for (const arg of args) {
+                                        if (arg.getKind() === SyntaxKind.ObjectLiteralExpression) {
+                                            this.processConfigObject(arg, SyntaxKind);
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                if (configObj) {
+                    this.processConfigObject(configObj, SyntaxKind);
+                }
+                sourceFile.saveSync();
+            }
+            catch (_b) {
+                // If ts-morph is not available or fails, fall back to regex
+                this.modifyConfigEnvForRestFallback(projectPath);
+            }
+        });
+    }
+    /**
+     * Process a config object literal: replace graphQl and remove execAfterInit
+     */
+    processConfigObject(obj, SyntaxKind) {
+        // Process all nested object literals (environment configs)
+        const properties = obj.getProperties();
+        for (const prop of properties) {
+            if (prop.getKind() !== SyntaxKind.PropertyAssignment) {
+                continue;
+            }
+            const name = prop.getName();
+            // Replace graphQl: { ... } with graphQl: false
+            if (name === 'graphQl') {
+                const init = prop.getInitializer();
+                if (init && init.getKind() === SyntaxKind.ObjectLiteralExpression) {
+                    prop.setInitializer('false');
+                }
+                continue;
+            }
+            // Remove execAfterInit
+            if (name === 'execAfterInit') {
+                prop.remove();
+                continue;
+            }
+            // Recurse into nested objects (environment configs like default, local, etc.)
+            const init = prop.getInitializer();
+            if ((init === null || init === void 0 ? void 0 : init.getKind()) === SyntaxKind.ObjectLiteralExpression) {
+                this.processConfigObject(init, SyntaxKind);
+            }
+        }
+    }
+    /**
+     * Fallback: Regex-based config.env.ts modification
+     */
+    modifyConfigEnvForRestFallback(projectPath) {
+        const configPath = (0, path_1.join)(projectPath, 'src', 'config.env.ts');
+        let content = this.filesystem.read(configPath);
+        if (!content) {
+            return;
+        }
+        // Replace graphQl: { ... } blocks with graphQl: false
+        // Match graphQl: { ... }, handling nested braces
+        content = content.replace(/graphQl:\s*\{[^{}]*(?:\{[^{}]*\}[^{}]*)*\},?/g, 'graphQl: false,');
+        // Remove execAfterInit lines
+        content = content.replace(/\s*execAfterInit:.*,?\n/g, '\n');
+        this.filesystem.write(configPath, content);
+    }
+    /**
+     * Clean orphan imports after region stripping
+     *
+     * After removing region content, some imports may reference identifiers
+     * that no longer exist in the file. This removes those imports.
+     */
+    cleanOrphanImports(projectPath) {
+        const dirs = [(0, path_1.join)(projectPath, 'src')];
+        for (const dir of dirs) {
+            if (!this.filesystem.exists(dir)) {
+                continue;
+            }
+            const files = this.filesystem.find(dir, { matching: '**/*.ts' });
+            for (const file of files) {
+                const content = this.filesystem.read(file);
+                if (!content) {
+                    continue;
+                }
+                const cleaned = this.removeUnusedImports(content);
+                if (cleaned !== content) {
+                    this.filesystem.write(file, cleaned);
+                }
+            }
+        }
+    }
+    /**
+     * Remove unused imports from TypeScript file content
+     */
+    removeUnusedImports(content) {
+        const lines = content.split('\n');
+        const importLines = [];
+        // Parse import statements
+        let i = 0;
+        while (i < lines.length) {
+            const line = lines[i];
+            const singleImportMatch = line.match(/^import\s+\{([^}]+)\}\s+from\s+['"]/);
+            const multiImportStart = line.match(/^import\s+\{$/);
+            if (singleImportMatch) {
+                const imports = singleImportMatch[1].split(',')
+                    .map((s) => s.trim())
+                    .filter(Boolean)
+                    .map((s) => ({ original: s, resolved: this.resolveImportAlias(s) }));
+                importLines.push({ end: i, imports, start: i });
+            }
+            else if (multiImportStart) {
+                // Multi-line import
+                const start = i;
+                const imports = [];
+                i++;
+                while (i < lines.length && !lines[i].match(/^\}\s+from\s+['"]/)) {
+                    const raw = lines[i].replace(/,?\s*$/, '').trim();
+                    if (raw) {
+                        imports.push({ original: raw, resolved: this.resolveImportAlias(raw) });
+                    }
+                    i++;
+                }
+                importLines.push({ end: i, imports, start });
+            }
+            i++;
+        }
+        // Get the non-import part of the file
+        const maxImportEnd = importLines.reduce((max, il) => Math.max(max, il.end), -1);
+        const codeContent = lines.slice(maxImportEnd + 1).join('\n');
+        // Check each import
+        const linesToRemove = new Set();
+        for (const imp of importLines) {
+            const usedImports = imp.imports.filter(({ resolved }) => {
+                // Check if resolved identifier is used in code (not in imports)
+                const regex = new RegExp(`\\b${resolved.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`);
+                return regex.test(codeContent);
+            });
+            if (usedImports.length === 0) {
+                // Remove entire import
+                for (let j = imp.start; j <= imp.end; j++) {
+                    linesToRemove.add(j);
+                }
+            }
+            else if (usedImports.length < imp.imports.length) {
+                // Rebuild import with only used identifiers (using original text for aliases)
+                const fromMatch = lines[imp.end].match(/from\s+['"].*['"]/);
+                const fromClause = fromMatch ? fromMatch[0] : '';
+                if (fromClause) {
+                    // Remove old lines
+                    for (let j = imp.start; j <= imp.end; j++) {
+                        linesToRemove.add(j);
+                    }
+                    const originals = usedImports.map((ui) => ui.original);
+                    // Add rebuilt import at start position
+                    if (originals.length <= 3) {
+                        lines[imp.start] = `import { ${originals.join(', ')} } ${fromClause};`;
+                        linesToRemove.delete(imp.start);
+                    }
+                    else {
+                        // Multi-line for many imports
+                        lines[imp.start] = `import {\n  ${originals.join(',\n  ')},\n} ${fromClause};`;
+                        linesToRemove.delete(imp.start);
+                    }
+                }
+            }
+        }
+        // Remove marked lines
+        const result = lines.filter((_, idx) => !linesToRemove.has(idx));
+        return this.collapseBlankLines(result.join('\n'));
+    }
+    /**
+     * Resolve import alias: "Schema as MongooseSchema" -> "MongooseSchema"
+     * For non-aliased imports, returns the identifier as-is.
+     */
+    resolveImportAlias(identifier) {
+        const asMatch = identifier.match(/^\S+\s+as\s+(\S+)$/);
+        return asMatch ? asMatch[1] : identifier;
+    }
+    /**
+     * Collapse multiple consecutive blank lines into at most one
+     */
+    collapseBlankLines(content) {
+        return content.replace(/\n{3,}/g, '\n\n');
+    }
+    /**
+     * Remove a script from package.json
+     */
+    removeScriptFromPackageJson(projectPath, scriptName) {
+        var _a;
+        const pkgPath = (0, path_1.join)(projectPath, 'package.json');
+        const pkg = JSON.parse(this.filesystem.read(pkgPath));
+        if ((_a = pkg.scripts) === null || _a === void 0 ? void 0 : _a[scriptName]) {
+            delete pkg.scripts[scriptName];
+            this.filesystem.write(pkgPath, pkg, { jsonIndent: 2 });
+        }
+    }
+}
+exports.ApiMode = ApiMode;
+/**
+ * Extend toolbox
+ */
+exports.default = (toolbox) => {
+    toolbox.apiMode = new ApiMode(toolbox);
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api-mode.js","sourceRoot":"","sources":["../../src/extensions/api-mode.ts"],"names":[],"mappings":"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"}