@lenne.tech/cli 1.9.6 → 1.11.0

package/build/commands/server/module.js

@@ -13,6 +13,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const path_1 = require("path");
+const framework_detection_1 = require("../../lib/framework-detection");
 const object_1 = __importDefault(require("./object"));
 /**
  * Detect controller type based on existing modules
@@ -272,27 +273,43 @@ const NewCommand = {
         const inputTemplate = server.propsForInput(props, { modelName: name, nullable: true });
         const createTemplate = server.propsForInput(props, { create: true, modelName: name, nullable: false });
         const modelTemplate = server.propsForModel(props, { modelName: name });
+        // Compute the correct framework-import specifier for each generated file.
+        // In vendored projects this resolves to a relative path to src/core (depth
+        // depends on file location); in npm projects it stays '@lenne.tech/nest-server'.
+        const importFor = (target) => (0, framework_detection_1.getFrameworkImportSpecifier)(path, target);
         // nest-server-module/inputs/xxx.input.ts
+        const inputTarget = (0, path_1.join)(directory, 'inputs', `${nameKebab}.input.ts`);
         yield template.generate({
-            props: { imports: inputTemplate.imports, nameCamel, nameKebab, namePascal, props: inputTemplate.props },
-            target: (0, path_1.join)(directory, 'inputs', `${nameKebab}.input.ts`),
+            props: {
+                frameworkImport: importFor(inputTarget),
+                imports: inputTemplate.imports,
+                nameCamel,
+                nameKebab,
+                namePascal,
+                props: inputTemplate.props,
+            },
+            target: inputTarget,
             template: 'nest-server-module/inputs/template.input.ts.ejs',
         });
         if (controller === 'Rest' || controller === 'Both') {
+            const controllerTarget = (0, path_1.join)(directory, `${nameKebab}.controller.ts`);
             yield template.generate({
                 props: {
+                    frameworkImport: importFor(controllerTarget),
                     lowercase: name.toLowerCase(),
                     nameCamel: camelCase(name),
                     nameKebab: kebabCase(name),
                     namePascal: pascalCase(name),
                 },
-                target: (0, path_1.join)(directory, `${nameKebab}.controller.ts`),
+                target: controllerTarget,
                 template: 'nest-server-module/template.controller.ts.ejs',
             });
         }
         // nest-server-module/inputs/xxx-create.input.ts
+        const createInputTarget = (0, path_1.join)(directory, 'inputs', `${nameKebab}-create.input.ts`);
         yield template.generate({
             props: {
+                frameworkImport: importFor(createInputTarget),
                 imports: createTemplate.imports,
                 isGql: controller === 'GraphQL' || controller === 'Both',
                 nameCamel,
@@ -300,18 +317,27 @@ const NewCommand = {
                 namePascal,
                 props: createTemplate.props,
             },
-            target: (0, path_1.join)(directory, 'inputs', `${nameKebab}-create.input.ts`),
+            target: createInputTarget,
             template: 'nest-server-module/inputs/template-create.input.ts.ejs',
         });
         // nest-server-module/output/find-and-count-xxxs-result.output.ts
+        const facOutputTarget = (0, path_1.join)(directory, 'outputs', `find-and-count-${nameKebab}s-result.output.ts`);
         yield template.generate({
-            props: { isGql: controller === 'GraphQL' || controller === 'Both', nameCamel, nameKebab, namePascal },
-            target: (0, path_1.join)(directory, 'outputs', `find-and-count-${nameKebab}s-result.output.ts`),
+            props: {
+                frameworkImport: importFor(facOutputTarget),
+                isGql: controller === 'GraphQL' || controller === 'Both',
+                nameCamel,
+                nameKebab,
+                namePascal,
+            },
+            target: facOutputTarget,
             template: 'nest-server-module/outputs/template-fac-result.output.ts.ejs',
         });
         // nest-server-module/xxx.model.ts
+        const modelTarget = (0, path_1.join)(directory, `${nameKebab}.model.ts`);
         yield template.generate({
             props: {
+                frameworkImport: importFor(modelTarget),
                 imports: modelTemplate.imports,
                 isGql: controller === 'GraphQL' || controller === 'Both',
                 mappings: modelTemplate.mappings,
@@ -320,27 +346,36 @@ const NewCommand = {
                 namePascal,
                 props: modelTemplate.props,
             },
-            target: (0, path_1.join)(directory, `${nameKebab}.model.ts`),
+            target: modelTarget,
             template: 'nest-server-module/template.model.ts.ejs',
         });
         // nest-server-module/xxx.module.ts
+        const moduleTarget = (0, path_1.join)(directory, `${nameKebab}.module.ts`);
         yield template.generate({
-            props: { controller, nameCamel, nameKebab, namePascal },
-            target: (0, path_1.join)(directory, `${nameKebab}.module.ts`),
+            props: { controller, frameworkImport: importFor(moduleTarget), nameCamel, nameKebab, namePascal },
+            target: moduleTarget,
             template: 'nest-server-module/template.module.ts.ejs',
         });
         if (controller === 'GraphQL' || controller === 'Both') {
             // nest-server-module/xxx.resolver.ts
+            const resolverTarget = (0, path_1.join)(directory, `${nameKebab}.resolver.ts`);
             yield template.generate({
-                props: { nameCamel, nameKebab, namePascal },
-                target: (0, path_1.join)(directory, `${nameKebab}.resolver.ts`),
+                props: { frameworkImport: importFor(resolverTarget), nameCamel, nameKebab, namePascal },
+                target: resolverTarget,
                 template: 'nest-server-module/template.resolver.ts.ejs',
             });
         }
         // nest-server-module/xxx.service.ts
+        const serviceTarget = (0, path_1.join)(directory, `${nameKebab}.service.ts`);
         yield template.generate({
-            props: { isGql: controller === 'GraphQL' || controller === 'Both', nameCamel, nameKebab, namePascal },
-            target: (0, path_1.join)(directory, `${nameKebab}.service.ts`),
+            props: {
+                frameworkImport: importFor(serviceTarget),
+                isGql: controller === 'GraphQL' || controller === 'Both',
+                nameCamel,
+                nameKebab,
+                namePascal,
+            },
+            target: serviceTarget,
             template: 'nest-server-module/template.service.ts.ejs',
         });
         generateSpinner.succeed('Files generated');
@@ -365,20 +400,18 @@ const NewCommand = {
                 });
                 // Ensure forwardRef is imported from @nestjs/common
                 const serverModuleContent = filesystem.read(serverModule);
-                if (serverModuleContent && !serverModuleContent.includes('forwardRef')) {
-                    // Add forwardRef to @nestjs/common import
-                    yield patching.patch(serverModule, {
-                        insert: '$1, forwardRef$2',
-                        replace: /from '@nestjs\/common'(.*?)}/,
-                    });
-                }
-                else if (serverModuleContent &&
+                if (serverModuleContent &&
                     serverModuleContent.includes('@nestjs/common') &&
-                    !serverModuleContent.match(/forwardRef.*@nestjs\/common|@nestjs\/common.*forwardRef/)) {
-                    // forwardRef exists but not in @nestjs/common import - add it
+                    !serverModuleContent.match(/import\s*\{[^}]*forwardRef[^}]*}\s*from\s+['"]@nestjs\/common['"]/)) {
+                    // Add forwardRef into the existing `import { ... } from '@nestjs/common'`
+                    // statement by inserting it before the closing brace. The regex
+                    // captures two groups: (1) everything up to (but not including) the
+                    // closing brace of the named-import list and (2) the closing brace
+                    // plus the `from '@nestjs/common'` clause. The replacement wedges
+                    // `, forwardRef` in between.
                     yield patching.patch(serverModule, {
-                        insert: '$1, forwardRef$2',
-                        replace: /(\w+)\s*}\s*from\s+'@nestjs\/common'/,
+                        insert: "$1, forwardRef$2",
+                        replace: /(import\s*\{\s*[^}]*?)(\s*\}\s*from\s+['"]@nestjs\/common['"])/,
                     });
                 }
             }

package/build/commands/server/object.js

@@ -13,6 +13,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const path_1 = require("path");
+const framework_detection_1 = require("../../lib/framework-detection");
 const module_1 = __importDefault(require("./module"));
 /**
  * Create a new server object
@@ -133,21 +134,41 @@ const NewCommand = {
         const inputTemplate = server.propsForInput(props, { modelName: name, nullable: true });
         const createTemplate = server.propsForInput(props, { create: true, modelName: name, nullable: false });
         const objectTemplate = server.propsForModel(props, { modelName: name });
+        // Framework-import specifier (bare in npm mode, relative in vendored mode)
+        const importFor = (target) => (0, framework_detection_1.getFrameworkImportSpecifier)(path, target);
         // nest-server-module/inputs/xxx.input.ts
+        const inputTarget = (0, path_1.join)(directory, `${nameKebab}.input.ts`);
         yield template.generate({
-            props: { imports: inputTemplate.imports, nameCamel, nameKebab, namePascal, props: inputTemplate.props },
-            target: (0, path_1.join)(directory, `${nameKebab}.input.ts`),
+            props: {
+                frameworkImport: importFor(inputTarget),
+                imports: inputTemplate.imports,
+                nameCamel,
+                nameKebab,
+                namePascal,
+                props: inputTemplate.props,
+            },
+            target: inputTarget,
             template: 'nest-server-object/template.input.ts.ejs',
         });
         // nest-server-object/inputs/xxx-create.input.ts
+        const createInputTarget = (0, path_1.join)(directory, `${nameKebab}-create.input.ts`);
         yield template.generate({
-            props: { imports: createTemplate.imports, nameCamel, nameKebab, namePascal, props: createTemplate.props },
-            target: (0, path_1.join)(directory, `${nameKebab}-create.input.ts`),
+            props: {
+                frameworkImport: importFor(createInputTarget),
+                imports: createTemplate.imports,
+                nameCamel,
+                nameKebab,
+                namePascal,
+                props: createTemplate.props,
+            },
+            target: createInputTarget,
             template: 'nest-server-object/template-create.input.ts.ejs',
         });
         // nest-server-module/xxx.model.ts
+        const objectTarget = (0, path_1.join)(directory, `${nameKebab}.object.ts`);
         yield template.generate({
             props: {
+                frameworkImport: importFor(objectTarget),
                 imports: objectTemplate.imports,
                 mappings: objectTemplate.mappings,
                 nameCamel,
@@ -155,7 +176,7 @@ const NewCommand = {
                 namePascal,
                 props: objectTemplate.props,
             },
-            target: (0, path_1.join)(directory, `${nameKebab}.object.ts`),
+            target: objectTarget,
             template: 'nest-server-object/template.object.ts.ejs',
         });
         generateSpinner.succeed('Files generated');

package/build/commands/server/permissions.js

@@ -12,6 +12,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const child_process_1 = require("child_process");
 const fs_1 = require("fs");
 const path_1 = require("path");
+const framework_detection_1 = require("../../lib/framework-detection");
 // ────────────────────────────────────────────────────────────────────────────
 // Helper functions (alphabetically sorted per ESLint rules)
 // ────────────────────────────────────────────────────────────────────────────
@@ -82,11 +83,23 @@ function generateJson(report, projectPath) {
  */
 function loadScanner(projectPath) {
     return __awaiter(this, void 0, void 0, function* () {
-        // Try 1: Load from project's nest-server (preferred)
-        const scannerPaths = [
-            (0, path_1.join)(projectPath, 'node_modules', '@lenne.tech', 'nest-server', 'dist', 'core', 'modules', 'permissions', 'permissions-scanner'),
-            (0, path_1.join)(projectPath, 'node_modules', '@lenne.tech', 'nest-server', 'dist', 'core', 'modules', 'permissions', 'permissions-scanner.js'),
-        ];
+        // Build an ordered list of candidate paths, mode-aware:
+        //
+        // - Vendored projects: the framework code lives in src/core/ as
+        //   project-compiled TypeScript. After `nest build` the compiled output
+        //   lands under dist/src/core/modules/permissions/. Before the build,
+        //   the .ts source sits at src/core/modules/permissions/permissions-scanner.ts
+        //   (which Node's `require()` cannot load directly). We try the dist
+        //   variant first and fall back to the bundled CLI scanner if the
+        //   project hasn't been built yet.
+        // - npm projects: classic path under node_modules/@lenne.tech/nest-server/dist.
+        const scannerPaths = [];
+        if ((0, framework_detection_1.isVendoredProject)(projectPath)) {
+            scannerPaths.push((0, path_1.join)(projectPath, 'dist', 'src', 'core', 'modules', 'permissions', 'permissions-scanner'), (0, path_1.join)(projectPath, 'dist', 'src', 'core', 'modules', 'permissions', 'permissions-scanner.js'), (0, path_1.join)(projectPath, 'dist', 'core', 'modules', 'permissions', 'permissions-scanner'), (0, path_1.join)(projectPath, 'dist', 'core', 'modules', 'permissions', 'permissions-scanner.js'));
+        }
+        else {
+            scannerPaths.push((0, path_1.join)(projectPath, 'node_modules', '@lenne.tech', 'nest-server', 'dist', 'core', 'modules', 'permissions', 'permissions-scanner'), (0, path_1.join)(projectPath, 'node_modules', '@lenne.tech', 'nest-server', 'dist', 'core', 'modules', 'permissions', 'permissions-scanner.js'));
+        }
         for (const scannerPath of scannerPaths) {
             try {
                 const mod = require(scannerPath);
@@ -101,7 +114,8 @@ function loadScanner(projectPath) {
                 // Not available at this path
             }
         }
-        // Try 2: Use CLI's bundled fallback scanner
+        // Fallback: Use CLI's bundled scanner. Covers both "not yet built" (vendor
+        // mode before `nest build`) and "framework not installed" (detached clone).
         try {
             const fallback = require('../../lib/fallback-scanner');
             if (typeof fallback.scanPermissions === 'function') {

package/build/commands/server/test.js

@@ -10,6 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const path_1 = require("path");
+const framework_detection_1 = require("../../lib/framework-detection");
 /**
  * Create a new server
  */
@@ -55,7 +56,12 @@ const NewCommand = {
         const generateSpinner = spin('Generate test file');
         // nest-server-tests/tests.e2e-spec.ts.ejs
         yield template.generate({
-            props: { nameCamel, nameKebab, namePascal },
+            props: {
+                frameworkImport: (0, framework_detection_1.getFrameworkImportSpecifier)(path, filePath),
+                nameCamel,
+                nameKebab,
+                namePascal,
+            },
             target: filePath,
             template: 'nest-server-tests/tests.e2e-spec.ts.ejs',
         });

package/build/commands/status.js

@@ -10,6 +10,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const path_1 = require("path");
+const framework_detection_1 = require("../lib/framework-detection");
+const frontend_framework_detection_1 = require("../lib/frontend-framework-detection");
 /**
  * Show project status and context
  */
@@ -27,11 +29,14 @@ const StatusCommand = {
         info(colors.dim('─'.repeat(50)));
         const projectInfo = {
             configFiles: [],
+            frameworkMode: null,
+            frontendFrameworkMode: null,
             gitBranch: null,
             gitRoot: null,
             hasGit: false,
             hasLtConfig: false,
             hasPackageJson: false,
+            monorepoSubprojects: [],
             nodeVersion: null,
             npmVersion: null,
             packageName: null,
@@ -56,14 +61,22 @@ const StatusCommand = {
                 projectInfo.packageVersion = packageJson.version || null;
                 // Detect project type
                 const deps = Object.assign(Object.assign({}, packageJson.dependencies), packageJson.devDependencies);
-                if (deps['@lenne.tech/nest-server']) {
+                // A project is a nest-server project if it EITHER has the npm dep
+                // (classic) OR has vendored the core/ directory. The frameworkMode
+                // field records which of the two modes this project runs in.
+                if (deps['@lenne.tech/nest-server'] || (0, framework_detection_1.isVendoredProject)(cwd)) {
                     projectInfo.projectType = 'nest-server';
+                    projectInfo.frameworkMode = (0, framework_detection_1.detectFrameworkMode)(cwd);
                 }
                 else if (deps['@nestjs/core']) {
                     projectInfo.projectType = 'nestjs';
                 }
                 else if (deps['nuxt']) {
                     projectInfo.projectType = 'nuxt';
+                    // Detect frontend framework mode if nuxt-extensions is present
+                    if (deps['@lenne.tech/nuxt-extensions'] || (0, frontend_framework_detection_1.isVendoredAppProject)(cwd)) {
+                        projectInfo.frontendFrameworkMode = (0, frontend_framework_detection_1.detectFrontendFrameworkMode)(cwd);
+                    }
                 }
                 else if (deps['@angular/core']) {
                     projectInfo.projectType = 'angular';
@@ -85,6 +98,52 @@ const StatusCommand = {
                 // Ignore parse errors
             }
         }
+        // Monorepo subproject detection: scan projects/api and projects/app for
+        // framework modes so that `lt status` at the monorepo root surfaces
+        // backend + frontend framework consumption modes even when the root
+        // itself is not a Nest/Nuxt project.
+        const monorepoCandidates = [
+            { kind: 'backend', path: (0, path_1.join)(cwd, 'projects', 'api') },
+            { kind: 'backend', path: (0, path_1.join)(cwd, 'packages', 'api') },
+            { kind: 'frontend', path: (0, path_1.join)(cwd, 'projects', 'app') },
+            { kind: 'frontend', path: (0, path_1.join)(cwd, 'packages', 'app') },
+        ];
+        for (const candidate of monorepoCandidates) {
+            if (!filesystem.exists((0, path_1.join)(candidate.path, 'package.json')))
+                continue;
+            if (candidate.kind === 'backend') {
+                try {
+                    const subPkg = JSON.parse(filesystem.read((0, path_1.join)(candidate.path, 'package.json')) || '{}');
+                    const subDeps = Object.assign(Object.assign({}, subPkg.dependencies), subPkg.devDependencies);
+                    if (subDeps['@lenne.tech/nest-server'] || (0, framework_detection_1.isVendoredProject)(candidate.path)) {
+                        projectInfo.monorepoSubprojects.push({
+                            frameworkMode: (0, framework_detection_1.detectFrameworkMode)(candidate.path),
+                            kind: 'backend',
+                            path: candidate.path,
+                        });
+                    }
+                }
+                catch (_d) {
+                    // ignore
+                }
+            }
+            else {
+                try {
+                    const subPkg = JSON.parse(filesystem.read((0, path_1.join)(candidate.path, 'package.json')) || '{}');
+                    const subDeps = Object.assign(Object.assign({}, subPkg.dependencies), subPkg.devDependencies);
+                    if (subDeps['@lenne.tech/nuxt-extensions'] || (0, frontend_framework_detection_1.isVendoredAppProject)(candidate.path)) {
+                        projectInfo.monorepoSubprojects.push({
+                            frameworkMode: (0, frontend_framework_detection_1.detectFrontendFrameworkMode)(candidate.path),
+                            kind: 'frontend',
+                            path: candidate.path,
+                        });
+                    }
+                }
+                catch (_e) {
+                    // ignore
+                }
+            }
+        }
         // Check for git
         try {
             const gitRoot = yield system.run('git rev-parse --show-toplevel 2>/dev/null');
@@ -95,7 +154,7 @@ const StatusCommand = {
                 projectInfo.gitBranch = (branch === null || branch === void 0 ? void 0 : branch.trim()) || null;
             }
         }
-        catch (_d) {
+        catch (_f) {
             // Not a git repository
         }
         // Get Node/npm versions
@@ -103,7 +162,7 @@ const StatusCommand = {
             projectInfo.nodeVersion = ((_a = (yield system.run('node --version 2>/dev/null'))) === null || _a === void 0 ? void 0 : _a.trim()) || null;
             projectInfo.npmVersion = ((_b = (yield system.run('npm --version 2>/dev/null'))) === null || _b === void 0 ? void 0 : _b.trim()) || null;
         }
-        catch (_e) {
+        catch (_g) {
             // Ignore errors
         }
         // Display project info
@@ -120,6 +179,38 @@ const StatusCommand = {
                 info(`  Version: ${projectInfo.packageVersion}`);
             }
             info(`  Type:    ${formatProjectType(projectInfo.projectType)}`);
+            if (projectInfo.frameworkMode) {
+                const modeLabel = projectInfo.frameworkMode === 'vendor'
+                    ? 'vendor (src/core/, VENDOR.md)'
+                    : 'npm (@lenne.tech/nest-server dependency)';
+                info(`  Framework: ${modeLabel}`);
+            }
+            if (projectInfo.frontendFrameworkMode) {
+                const frontendModeLabel = projectInfo.frontendFrameworkMode === 'vendor'
+                    ? 'vendor (app/core/, VENDOR.md)'
+                    : 'npm (@lenne.tech/nuxt-extensions dependency)';
+                info(`  Frontend Framework: ${frontendModeLabel}`);
+            }
+        }
+        // Show monorepo subprojects if we detected any (typically at monorepo root)
+        if (projectInfo.monorepoSubprojects.length > 0) {
+            info('');
+            info(colors.bold('Monorepo Subprojects:'));
+            for (const sub of projectInfo.monorepoSubprojects) {
+                const relPath = sub.path.replace(`${cwd}/`, '');
+                if (sub.kind === 'backend') {
+                    const label = sub.frameworkMode === 'vendor'
+                        ? 'vendor (src/core/, VENDOR.md)'
+                        : 'npm (@lenne.tech/nest-server dependency)';
+                    info(`  Backend:  ${relPath} → ${label}`);
+                }
+                else {
+                    const label = sub.frameworkMode === 'vendor'
+                        ? 'vendor (app/core/, VENDOR.md)'
+                        : 'npm (@lenne.tech/nuxt-extensions dependency)';
+                    info(`  Frontend: ${relPath} → ${label}`);
+                }
+            }
         }
         if (projectInfo.hasGit) {
             info('');

package/build/config/vendor-frontend-runtime-deps.json

@@ -0,0 +1,4 @@
+{
+  "$comment": "Upstream @lenne.tech/nuxt-extensions devDependencies that must be promoted to regular dependencies in vendor mode. Currently empty because nuxt-extensions has only @nuxt/kit as a direct dependency (which is handled explicitly during vendoring).",
+  "runtimeHelpers": []
+}

package/build/config/vendor-runtime-deps.json

@@ -0,0 +1,9 @@
+{
+  "$schema": "./vendor-runtime-deps.schema.json",
+  "description": "Upstream @lenne.tech/nest-server devDependencies that are actually needed at runtime in a consumer project. When vendoring, these entries are promoted from upstream devDependencies into the project's dependencies so production runtime has them available.",
+  "runtimeHelpers": [
+    "find-file-up"
+  ]
+}
+</content>
+</invoke>

package/build/extensions/api-mode.js

@@ -373,9 +373,25 @@ class ApiMode {
             }
             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');
+        // Build the "code content" view against which import usage is checked.
+        //
+        // Previous implementation: `lines.slice(maxImportEnd + 1)` — only the
+        // lines AFTER the last import. That breaks for files where imports and
+        // top-level code are interleaved (e.g. a helper `const` declared between
+        // two import groups). Those inter-import usages were never seen, so the
+        // still-used identifiers got pruned.
+        //
+        // Fix: build a mask where all import lines are blanked out but every
+        // other line is preserved, so inter-import usages still count.
+        const importLineSet = new Set();
+        for (const imp of importLines) {
+            for (let j = imp.start; j <= imp.end; j++) {
+                importLineSet.add(j);
+            }
+        }
+        const codeContent = lines
+            .map((line, idx) => (importLineSet.has(idx) ? '' : line))
+            .join('\n');
         // Check each import
         const linesToRemove = new Set();
         for (const imp of importLines) {