nestjs-ddd-cli 3.2.2 → 3.3.1

package/README.md

@@ -28,8 +28,8 @@ npm install -g nestjs-ddd-cli
 # Initialize a new project
 ddd init my-project
 
-# Generate complete CRUD with typed fields
-ddd scaffold User -m users --fields "name:string email:string:unique age:number:optional"
+# Generate a financial-safe aggregate without a generic DELETE operation
+ddd scaffold Invoice -m billing --fields "amount:money tenantId:uuid:serverOwned" --no-delete
 
 # Apply authentication recipe
 ddd recipe auth-jwt --install-deps
@@ -41,6 +41,48 @@ ddd security-patterns
 ddd observability
 ```
 
+## OAuth2 token introspection
+
+Generate a bounded RFC7662 client and an owning Nest module:
+
+```sh
+ddd recipe oauth2-token-introspection --path <service> --dry-run
+ddd recipe oauth2-token-introspection --path <service>
+```
+
+The client rechecks the provider on every call and returns immutable evidence.
+The consuming service supplies principal/session/permission policy. HTTPS is the
+default; verified private HTTP requires explicit opt-in. See the
+[generated operator guide](src/templates/recipes/oauth2-token-introspection/README.md.hbs)
+for async registration, limits, failure handling and provider compatibility.
+
+## Framework-independent bounded JSON transport
+
+```sh
+ddd recipe bounded-json-http --path <application> --dry-run
+ddd recipe bounded-json-http --path <application>
+```
+
+Emit the same fixed-origin HTTP client without a Nest module or dependencies.
+The consumer owns its server-only wrapper, exact response validation and domain
+admission. GET, form POST and JSON POST/PATCH/PUT have bounded responses and
+deadlines, with no redirects or retries. See the
+[generated guide](src/templates/recipes/bounded-json-http/README.md.hbs).
+
+## Confidential OIDC BFF sessions
+
+```sh
+ddd recipe oidc-bff-session --path <app> --dry-run
+ddd recipe oidc-bff-session --path <app>
+```
+
+This emits provider-neutral verified authorization-code/S256 transport, opaque
+Lua sessions and durable token-retirement leases. Exact issuer/endpoints,
+credentials, cookie/routes, domain admission and worker scheduling remain the
+consumer's responsibility. Runtime dependencies and storage custody controls
+are explicit in the [generated guide](src/templates/recipes/oidc-bff-session/README.md.hbs).
+The recipe never installs dependencies or rewrites application configuration.
+
 ## Commands
 
 ### Core Commands
@@ -48,11 +90,15 @@ ddd observability
 | Command | Description |
 |---------|-------------|
 | `ddd init <name>` | Initialize new NestJS project with DDD structure |
-| `ddd scaffold <entity> -m <module>` | Generate complete CRUD with all layers |
+| `ddd scaffold <entity> -m <module>` | Generate a complete aggregate stack |
 | `ddd generate <type> <name> -m <module>` | Generate individual components |
 | `ddd recipe [name]` | Apply common patterns (auth, caching, etc.) |
 | `ddd shared` | Generate shared utilities and base classes |
 
+```bash
+ddd generate dto Product -m inventory --kind create
+```
+
 ### Enterprise Commands
 
 | Command | Description |
@@ -80,7 +126,7 @@ ddd observability
 Generate complete typed entities, DTOs, and migrations:
 
 ```bash
-ddd scaffold Product -m inventory --fields "name:string price:number:optional sku:string:unique"
+ddd scaffold Product -m inventory --fields "name:string price:money:optional sku:string:unique"
 ```
 
 **Field Format:** `name:type:modifier1:modifier2`
@@ -89,10 +135,37 @@ ddd scaffold Product -m inventory --fields "name:string price:number:optional sk
 |-------|-----------|
 | `string`, `text` | `optional` |
 | `number`, `int`, `float`, `decimal` | `unique` |
+| `money` (exact decimal-backed TypeScript string) | `serverOwned` (`internal` alias) |
 | `boolean` | `relation` |
 | `date`, `datetime`, `timestamp` | `OneToOne`, `OneToMany`, `ManyToOne`, `ManyToMany` |
 | `uuid`, `json`, `enum` | |
 
+Use `money` for financial values that must not pass through JavaScript floating-point
+numbers. It generates `string` in domain, TypeORM, request, and response types,
+decimal-string validation and OpenAPI metadata, plus `decimal`/Prisma `Decimal`
+storage. Existing `decimal` fields remain TypeScript `number` for compatibility.
+
+Use `serverOwned` for fields populated from trusted application context rather than
+the request body:
+
+```bash
+ddd scaffold Invoice -m billing \
+  --fields "amount:money tenantId:uuid:serverOwned bookId:uuid:serverOwned"
+```
+
+Server-owned fields remain in domain, persistence, mapper, and response generation,
+but are omitted from create/update request DTOs and request mass-assignment. The
+generated create command accepts a second typed `serverOwnedFields` argument and
+fails closed until the controller/application layer supplies it from authenticated
+context.
+
+For an aggregate with no generic deletion capability:
+
+```bash
+ddd scaffold LedgerEntry -m ledger --fields "amount:money" --no-delete
+# Equivalent project-wide default: features.delete = false in .dddrc.json
+```
+
 **Relations:**
 ```bash
 # ManyToOne relation
@@ -140,6 +213,11 @@ ddd recipe
 
 # Apply with dependency installation
 ddd recipe auth-jwt --install-deps
+ddd recipe event-backbone --install-deps
+ddd recipe oidc-dashboard --install-deps
+ddd recipe platform-service-access-request-context
+ddd recipe external-projection-worker --migration-timestamp 1790000000000 --install-deps
+ddd recipe jest-cjs-compat --path /path/to/service --dry-run
 ```
 
 | Recipe | Description |
@@ -149,6 +227,15 @@ ddd recipe auth-jwt --install-deps
 | `soft-delete` | Base entity and repository with soft delete |
 | `audit-log` | Entity change tracking with sensitive data masking |
 | `caching` | Redis caching with decorators |
+| `event-backbone` | Postgres event store/outbox source of truth with Pulsar transport |
+| `business-reference-identifiers` | Human-readable sidecar references beside canonical IDs |
+| `platform-service-runtime` | Service manifest, capabilities, actions, events, dependencies, and health contract |
+| `platform-service-access-request-context` | Fail-closed Service Access lease introspection before route-specific PARC authorization |
+| `banklink-connector-contract` | BankLink NestJS control-plane and Go sidecar connector boundary contract |
+| `oidc-dashboard` | OIDC broker integration for internal dashboards and admin APIs |
+| `external-projection-worker` | Postgres-backed external projection intents with atomic enqueue, canonical idempotency, fenced leases, and bounded retry outcomes |
+| `jest-cjs-compat` | Node/Jest-only CommonJS transformation of ESM Nest configuration; production TypeScript and dependency versions stay intact |
+| `bounded-json-http` | Fixed-origin GET/form/JSON transport without framework dependencies or domain admission policy |
 
 ## Generated Structure
 
@@ -192,13 +279,15 @@ Create `.dddrc.json` in your project root:
   "database": "postgres",
   "naming": {
     "table": "snake_case",
-    "dto": "snake_case",
+    "dto": "camelCase",
     "file": "kebab-case"
   },
   "features": {
     "swagger": true,
     "pagination": true,
+    "delete": true,
     "softDelete": true,
+    "hardDelete": false,
     "timestamps": true,
     "tests": false,
     "events": false
@@ -211,6 +300,23 @@ Create `.dddrc.json` in your project root:
 }
 ```
 
+`features.delete` controls whether aggregate scaffolds emit the generic DELETE
+controller route, delete command/use case, and repository `delete`/`hardDelete`
+surface. It defaults to `true` for compatibility. Set it to `false`, or pass
+`--no-delete` to `ddd scaffold`/`ddd generate all`, for a non-destructive aggregate
+scaffold. This does not remove existing generated files and does not disable
+soft-delete columns or active-row filtering.
+
+`features.softDelete` controls the generated domain field, ORM column or Prisma
+field, active-row filters, and repository delete behavior. When it is `false`,
+none of the generated code references `deletedAt`/`deleted_at` and the ordinary
+`delete` method performs the ORM's normal delete operation.
+
+`features.hardDelete` is disabled by default. Set it to `true` only when a
+soft-delete repository must expose a separately named `hardDelete` compatibility
+helper. It never changes the ordinary `delete` method, and it is omitted when
+`softDelete` is disabled because ordinary deletion is already physical.
+
 ## Real-World Examples
 
 ### E-commerce with Security
@@ -224,8 +330,8 @@ ddd security-patterns
 ddd recipe auth-jwt --install-deps
 
 # Domain modules
-ddd scaffold Product -m inventory --fields "name:string price:decimal sku:string:unique stock:int"
-ddd scaffold Order -m orders --fields "total:decimal status:enum:pending,paid,shipped customerId:uuid"
+ddd scaffold Product -m inventory --fields "name:string price:money sku:string:unique stock:int"
+ddd scaffold Order -m orders --fields "total:money status:enum:pending,paid,shipped customerId:uuid"
 ddd scaffold Customer -m customers --fields "email:string:unique name:string"
 
 # Enterprise features
@@ -247,7 +353,7 @@ ddd metrics-prometheus
 ddd health-probes
 
 # Domain
-ddd scaffold Transaction -m payments --fields "amount:decimal currency:string status:enum:pending,completed,failed"
+ddd scaffold Transaction -m payments --fields "amount:money currency:string status:enum:pending,completed,failed"
 ddd circuit-breaker
 ```
 
@@ -282,7 +388,7 @@ All generated APIs follow RESTful conventions with security:
 | GET | `/entities/:id` | Get single entity |
 | POST | `/entities` | Create new entity |
 | PUT | `/entities/:id` | Update entity |
-| DELETE | `/entities/:id` | Soft delete entity |
+| DELETE | `/entities/:id` | Soft delete entity (omitted with `--no-delete`) |
 
 ### Pagination
 
@@ -338,6 +444,9 @@ npm link
 
 # Test locally
 ddd scaffold Test -m test-module --fields "name:string"
+
+# External projection database proof (requires a disposable PostgreSQL URL)
+EXTERNAL_PROJECTION_TEST_DATABASE_URL=postgres://... bun run test:external-projection-postgres
 ```
 
 ## License

package/ddd.schema.json

@@ -29,7 +29,7 @@
         "dto": {
           "type": "string",
           "enum": ["snake_case", "camelCase"],
-          "default": "snake_case",
+          "default": "camelCase",
           "description": "DTO property naming convention"
         },
         "file": {
@@ -54,11 +54,21 @@
           "default": true,
           "description": "Include pagination support in list queries"
         },
+        "delete": {
+          "type": "boolean",
+          "default": true,
+          "description": "Generate the generic aggregate deletion surface"
+        },
         "softDelete": {
           "type": "boolean",
           "default": true,
           "description": "Use soft delete pattern"
         },
+        "hardDelete": {
+          "type": "boolean",
+          "default": false,
+          "description": "Generate an explicit hardDelete compatibility helper when softDelete is enabled"
+        },
         "timestamps": {
           "type": "boolean",
           "default": true,

package/dist/commands/doctor-enhanced.d.ts

@@ -1,4 +1,5 @@
 export interface DoctorOptions {
+    app?: string;
     fix?: boolean;
     verbose?: boolean;
 }

package/dist/commands/doctor-enhanced.js

@@ -40,7 +40,10 @@ exports.runEnhancedDoctor = runEnhancedDoctor;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const chalk_1 = __importDefault(require("chalk"));
+const config_utils_1 = require("../utils/config.utils");
+const doctor_1 = require("./doctor");
 async function runEnhancedDoctor(basePath, options = {}) {
+    const doctorPaths = await resolveDoctorPaths(basePath, options.app);
     const report = {
         passed: 0,
         warnings: 0,
@@ -49,14 +52,14 @@ async function runEnhancedDoctor(basePath, options = {}) {
     };
     console.log(chalk_1.default.bold.blue('\n🩺 Running Enhanced DDD Doctor...\n'));
     // Run all diagnostic checks
-    await checkProjectStructure(basePath, report);
-    await checkDddPatterns(basePath, report);
-    await checkTypeScriptStrictness(basePath, report);
-    await checkNamingConventions(basePath, report);
-    await checkTestCoverage(basePath, report);
-    await checkImportPatterns(basePath, report);
-    await checkEntityIntegrity(basePath, report);
-    await checkModuleBoundaries(basePath, report);
+    await checkProjectStructure(doctorPaths, report);
+    await checkDddPatterns(doctorPaths.modulesPath, report);
+    await checkTypeScriptStrictness(doctorPaths.projectRoot, report);
+    await checkNamingConventions(doctorPaths.modulesPath, report);
+    await checkTestCoverage(doctorPaths.modulesPath, report);
+    await checkImportPatterns(doctorPaths.modulesPath, report);
+    await checkEntityIntegrity(doctorPaths.modulesPath, report);
+    await checkModuleBoundaries(doctorPaths.modulesPath, report);
     // Print results
     printReport(report, options.verbose);
     // Auto-fix if requested
@@ -65,26 +68,32 @@ async function runEnhancedDoctor(basePath, options = {}) {
     }
     return report;
 }
-async function checkProjectStructure(basePath, report) {
-    const requiredDirs = [
-        'src/modules',
-        'src/shared',
-    ];
+async function resolveDoctorPaths(basePath, app) {
+    const projectRoot = await (0, doctor_1.resolveNestProjectPath)(basePath, app);
+    const config = await (0, config_utils_1.loadConfig)(projectRoot);
+    return {
+        projectRoot,
+        modulesPath: path.resolve(projectRoot, config.paths.modules),
+        sharedPath: path.resolve(projectRoot, config.paths.shared),
+    };
+}
+async function checkProjectStructure(paths, report) {
+    const requiredDirs = [paths.modulesPath, paths.sharedPath];
     const recommendedDirs = [
-        'src/shared/domain',
-        'src/shared/infrastructure',
-        'src/shared/application',
+        path.join(paths.sharedPath, 'domain'),
+        path.join(paths.sharedPath, 'infrastructure'),
+        path.join(paths.sharedPath, 'application'),
     ];
-    for (const dir of requiredDirs) {
-        const fullPath = path.join(basePath, dir);
+    for (const fullPath of requiredDirs) {
+        const displayPath = displayProjectPath(paths.projectRoot, fullPath);
         if (!fs.existsSync(fullPath)) {
             report.errors++;
             report.results.push({
                 category: 'Structure',
                 rule: 'required-directory',
                 severity: 'error',
-                message: `Missing required directory: ${dir}`,
-                suggestion: `Run: mkdir -p ${dir}`,
+                message: `Missing required directory: ${displayPath}`,
+                suggestion: `Run: mkdir -p ${fullPath}`,
                 autoFixable: true,
             });
         }
@@ -92,30 +101,34 @@ async function checkProjectStructure(basePath, report) {
             report.passed++;
         }
     }
-    for (const dir of recommendedDirs) {
-        const fullPath = path.join(basePath, dir);
+    for (const fullPath of recommendedDirs) {
+        const displayPath = displayProjectPath(paths.projectRoot, fullPath);
         if (!fs.existsSync(fullPath)) {
             report.warnings++;
             report.results.push({
                 category: 'Structure',
                 rule: 'recommended-directory',
                 severity: 'warning',
-                message: `Missing recommended directory: ${dir}`,
-                suggestion: `Consider adding ${dir} for better DDD organization`,
+                message: `Missing recommended directory: ${displayPath}`,
+                suggestion: `Consider adding ${displayPath} for better DDD organization`,
             });
         }
     }
 }
-async function checkDddPatterns(basePath, report) {
-    const modulesPath = path.join(basePath, 'src/modules');
+function displayProjectPath(projectRoot, targetPath) {
+    const relativePath = path.relative(projectRoot, targetPath);
+    return relativePath && !relativePath.startsWith('..') ? relativePath : targetPath;
+}
+async function checkDddPatterns(modulesPath, report) {
     if (!fs.existsSync(modulesPath))
         return;
-    const modules = fs.readdirSync(modulesPath).filter(f => fs.statSync(path.join(modulesPath, f)).isDirectory());
+    const modules = fs
+        .readdirSync(modulesPath)
+        .filter((f) => fs.statSync(path.join(modulesPath, f)).isDirectory());
     for (const moduleName of modules) {
         const modulePath = path.join(modulesPath, moduleName);
-        // Check for domain layer
-        const domainPath = path.join(modulePath, 'domain');
-        if (!fs.existsSync(domainPath)) {
+        const domainPaths = getDomainLayerPaths(modulePath);
+        if (domainPaths.length === 0) {
             report.warnings++;
             report.results.push({
                 category: 'DDD Pattern',
@@ -123,22 +136,29 @@ async function checkDddPatterns(basePath, report) {
                 severity: 'warning',
                 message: `Module "${moduleName}" missing domain layer`,
                 file: modulePath,
-                suggestion: 'Add domain/ directory with entities, value-objects, and domain services',
+                suggestion: 'Add application/domain/ (CLI layout) or domain/ (classic layout) with domain types',
             });
         }
-        // Check for entity immutability patterns
-        const entitiesPath = path.join(domainPath, 'entities');
-        if (fs.existsSync(entitiesPath)) {
-            await checkEntityImmutability(entitiesPath, moduleName, report);
+        for (const domainPath of domainPaths) {
+            // Check for entity immutability patterns
+            const entitiesPath = path.join(domainPath, 'entities');
+            if (fs.existsSync(entitiesPath)) {
+                await checkEntityImmutability(entitiesPath, report);
+            }
+            // Check for proper aggregate roots
+            await checkAggregateRoots(domainPath, report);
         }
-        // Check for proper aggregate roots
-        await checkAggregateRoots(domainPath, moduleName, report);
         // Check repository interface in domain layer
-        await checkRepositoryPattern(modulePath, moduleName, report);
+        await checkRepositoryPattern(modulePath, moduleName, domainPaths, report);
     }
 }
-async function checkEntityImmutability(entitiesPath, moduleName, report) {
-    const files = fs.readdirSync(entitiesPath).filter(f => f.endsWith('.ts'));
+function getDomainLayerPaths(modulePath) {
+    return ['application/domain', 'domain']
+        .map((relativePath) => path.join(modulePath, relativePath))
+        .filter((domainPath) => fs.existsSync(domainPath));
+}
+async function checkEntityImmutability(entitiesPath, report) {
+    const files = fs.readdirSync(entitiesPath).filter((f) => f.endsWith('.ts'));
     for (const file of files) {
         const filePath = path.join(entitiesPath, file);
         const content = fs.readFileSync(filePath, 'utf-8');
@@ -172,7 +192,7 @@ async function checkEntityImmutability(entitiesPath, moduleName, report) {
         }
     }
 }
-async function checkAggregateRoots(domainPath, moduleName, report) {
+async function checkAggregateRoots(domainPath, report) {
     if (!fs.existsSync(domainPath))
         return;
     const files = getAllTypeScriptFiles(domainPath);
@@ -180,10 +200,8 @@ async function checkAggregateRoots(domainPath, moduleName, report) {
         const content = fs.readFileSync(file, 'utf-8');
         // Check if entity extends AggregateRoot when it should
         if (content.includes('class ') && content.includes('Entity')) {
-            const hasAggregateRoot = content.includes('extends AggregateRoot') ||
-                content.includes('extends BaseEntity');
-            const hasDomainEvents = content.includes('domainEvents') ||
-                content.includes('addDomainEvent');
+            const hasAggregateRoot = content.includes('extends AggregateRoot') || content.includes('extends BaseEntity');
+            const hasDomainEvents = content.includes('domainEvents') || content.includes('addDomainEvent');
             if (hasDomainEvents && !hasAggregateRoot) {
                 report.warnings++;
                 report.results.push({
@@ -198,15 +216,12 @@ async function checkAggregateRoots(domainPath, moduleName, report) {
         }
     }
 }
-async function checkRepositoryPattern(modulePath, moduleName, report) {
-    const domainPath = path.join(modulePath, 'domain');
+async function checkRepositoryPattern(modulePath, moduleName, domainPaths, report) {
     const infraPath = path.join(modulePath, 'infrastructure');
     // Check for repository interface in domain layer
-    const domainRepoFiles = fs.existsSync(domainPath)
-        ? getAllTypeScriptFiles(domainPath).filter(f => f.includes('repository'))
-        : [];
+    const domainRepoFiles = domainPaths.flatMap((domainPath) => getAllTypeScriptFiles(domainPath).filter((file) => file.includes('repository')));
     const infraRepoFiles = fs.existsSync(infraPath)
-        ? getAllTypeScriptFiles(infraPath).filter(f => f.includes('repository'))
+        ? getAllTypeScriptFiles(infraPath).filter((f) => f.includes('repository'))
         : [];
     if (infraRepoFiles.length > 0 && domainRepoFiles.length === 0) {
         report.warnings++;
@@ -270,8 +285,7 @@ async function checkTypeScriptStrictness(basePath, report) {
         });
     }
 }
-async function checkNamingConventions(basePath, report) {
-    const modulesPath = path.join(basePath, 'src/modules');
+async function checkNamingConventions(modulesPath, report) {
     if (!fs.existsSync(modulesPath))
         return;
     const files = getAllTypeScriptFiles(modulesPath);
@@ -295,8 +309,9 @@ async function checkNamingConventions(basePath, report) {
         if (classMatch) {
             for (const match of classMatch) {
                 const className = match.replace('export class ', '');
+                const firstCharacter = className[0];
                 // Check PascalCase
-                if (className[0] !== className[0].toUpperCase()) {
+                if (firstCharacter && firstCharacter !== firstCharacter.toUpperCase()) {
                     report.errors++;
                     report.results.push({
                         category: 'Naming',
@@ -310,17 +325,17 @@ async function checkNamingConventions(basePath, report) {
         }
     }
 }
-async function checkTestCoverage(basePath, report) {
-    const modulesPath = path.join(basePath, 'src/modules');
+async function checkTestCoverage(modulesPath, report) {
     if (!fs.existsSync(modulesPath))
         return;
-    const modules = fs.readdirSync(modulesPath).filter(f => fs.statSync(path.join(modulesPath, f)).isDirectory());
+    const modules = fs
+        .readdirSync(modulesPath)
+        .filter((f) => fs.statSync(path.join(modulesPath, f)).isDirectory());
     for (const moduleName of modules) {
         const modulePath = path.join(modulesPath, moduleName);
-        const sourceFiles = getAllTypeScriptFiles(modulePath).filter(f => !f.includes('.spec.ts') && !f.includes('.test.ts'));
-        const testFiles = getAllTypeScriptFiles(modulePath).filter(f => f.includes('.spec.ts') || f.includes('.test.ts'));
+        const sourceFiles = getAllTypeScriptFiles(modulePath).filter((f) => !f.includes('.spec.ts') && !f.includes('.test.ts'));
         // Check for service tests
-        const services = sourceFiles.filter(f => f.includes('.service.ts'));
+        const services = sourceFiles.filter((f) => f.includes('.service.ts'));
         for (const service of services) {
             const testFile = service.replace('.service.ts', '.service.spec.ts');
             if (!fs.existsSync(testFile)) {
@@ -336,7 +351,7 @@ async function checkTestCoverage(basePath, report) {
             }
         }
         // Check for domain entity tests
-        const entities = sourceFiles.filter(f => f.includes('.entity.ts'));
+        const entities = sourceFiles.filter((f) => f.includes('.entity.ts'));
         for (const entity of entities) {
             const testFile = entity.replace('.entity.ts', '.entity.spec.ts');
             if (!fs.existsSync(testFile)) {
@@ -351,17 +366,15 @@ async function checkTestCoverage(basePath, report) {
         }
     }
 }
-async function checkImportPatterns(basePath, report) {
-    const modulesPath = path.join(basePath, 'src/modules');
+async function checkImportPatterns(modulesPath, report) {
     if (!fs.existsSync(modulesPath))
         return;
-    const modules = fs.readdirSync(modulesPath).filter(f => fs.statSync(path.join(modulesPath, f)).isDirectory());
+    const modules = fs
+        .readdirSync(modulesPath)
+        .filter((f) => fs.statSync(path.join(modulesPath, f)).isDirectory());
     for (const moduleName of modules) {
         const modulePath = path.join(modulesPath, moduleName);
-        const domainPath = path.join(modulePath, 'domain');
-        if (!fs.existsSync(domainPath))
-            continue;
-        const domainFiles = getAllTypeScriptFiles(domainPath);
+        const domainFiles = getDomainLayerPaths(modulePath).flatMap((domainPath) => getAllTypeScriptFiles(domainPath));
         for (const file of domainFiles) {
             const content = fs.readFileSync(file, 'utf-8');
             // Check for infrastructure imports in domain layer (violation)
@@ -395,11 +408,10 @@ async function checkImportPatterns(basePath, report) {
         }
     }
 }
-async function checkEntityIntegrity(basePath, report) {
-    const modulesPath = path.join(basePath, 'src/modules');
+async function checkEntityIntegrity(modulesPath, report) {
     if (!fs.existsSync(modulesPath))
         return;
-    const files = getAllTypeScriptFiles(modulesPath).filter(f => f.includes('.entity.ts'));
+    const files = getAllTypeScriptFiles(modulesPath).filter((f) => f.includes('.entity.ts'));
     for (const file of files) {
         const content = fs.readFileSync(file, 'utf-8');
         // Check for ID field
@@ -430,11 +442,12 @@ async function checkEntityIntegrity(basePath, report) {
         }
     }
 }
-async function checkModuleBoundaries(basePath, report) {
-    const modulesPath = path.join(basePath, 'src/modules');
+async function checkModuleBoundaries(modulesPath, report) {
     if (!fs.existsSync(modulesPath))
         return;
-    const modules = fs.readdirSync(modulesPath).filter(f => fs.statSync(path.join(modulesPath, f)).isDirectory());
+    const modules = fs
+        .readdirSync(modulesPath)
+        .filter((f) => fs.statSync(path.join(modulesPath, f)).isDirectory());
     for (const moduleName of modules) {
         const modulePath = path.join(modulesPath, moduleName);
         const files = getAllTypeScriptFiles(modulePath);
@@ -482,7 +495,7 @@ function getAllTypeScriptFiles(dir) {
     return files;
 }
 async function applyFixes(report) {
-    const fixableResults = report.results.filter(r => r.autoFixable);
+    const fixableResults = report.results.filter((r) => r.autoFixable);
     if (fixableResults.length === 0) {
         console.log(chalk_1.default.gray('\nNo auto-fixable issues found.'));
         return;
@@ -508,10 +521,12 @@ function printReport(report, verbose) {
     for (const [category, results] of byCategory) {
         console.log(chalk_1.default.bold(`\n📁 ${category}`));
         for (const result of results) {
-            const icon = result.severity === 'error' ? '❌' :
-                result.severity === 'warning' ? '⚠️' : 'ℹ️';
-            const color = result.severity === 'error' ? chalk_1.default.red :
-                result.severity === 'warning' ? chalk_1.default.yellow : chalk_1.default.gray;
+            const icon = result.severity === 'error' ? '❌' : result.severity === 'warning' ? '⚠️' : 'ℹ️';
+            const color = result.severity === 'error'
+                ? chalk_1.default.red
+                : result.severity === 'warning'
+                    ? chalk_1.default.yellow
+                    : chalk_1.default.gray;
             console.log(color(`  ${icon} ${result.message}`));
             if (verbose) {
                 if (result.file) {