zudojs-cli 0.1.1 → 1.0.0

package/dist/src/commands/dev.command.js

@@ -6,9 +6,10 @@
  */
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
-import { execCommand } from "../utils/utils.exec.js";
+import { runStreaming } from "../utils/utils.exec.js";
 import { CLIValidationError, CLIGenerationError } from "../errors/index.js";
 import { ManifestManager } from "../manifest/manifestManager.core.js";
+import { SAFE_PATH_SEGMENT } from "../utils/utils.name.js";
 export async function runDevCommand(context) {
     const frontendOnly = context.values["frontend-only"] === true;
     const backendOnly = context.values["backend-only"] === true;
@@ -16,7 +17,8 @@ export async function runDevCommand(context) {
     if (frontendOnly && backendOnly) {
         throw new CLIValidationError("Cannot use --frontend-only and --backend-only together.");
     }
-    const config = readProjectConfig(context.cwd);
+    const manifest = await new ManifestManager(context.cwd).read();
+    const config = readProjectConfig(context.cwd) ?? configFromManifest(manifest);
     if (!config) {
         throw new CLIValidationError("No Zudojs project found. Run `zudojs create` first.");
     }
@@ -28,11 +30,18 @@ export async function runDevCommand(context) {
     if (config.frontend) {
         context.logger.info(`Frontend: ${config.frontend.framework}`);
     }
-    const manifest = await new ManifestManager(context.cwd).read();
-    const services = manifest?.capabilities ?? [];
+    // Service names come from a manifest file on disk and are joined into
+    // filesystem paths below; a crafted entry such as "../../.." would make the
+    // dev command probe and run outside the project.
+    const services = (manifest?.services ?? []).filter((service) => {
+        if (SAFE_PATH_SEGMENT.test(service))
+            return true;
+        context.logger.warn(`Ignoring invalid service name in .zudojs/manifest.json: "${service}"`);
+        return false;
+    });
     const processes = [];
-    if ((!frontendOnly && config.type === "backend") ||
-        config.type === "fullstack") {
+    if (!frontendOnly &&
+        (config.type === "backend" || config.type === "fullstack")) {
         if (config.backend?.architecture === "microservice") {
             processes.push(...startMicroserviceDev(context.cwd, services));
         }
@@ -58,6 +67,20 @@ export async function runDevCommand(context) {
         throw new CLIGenerationError("Development server failed to start.", error);
     }
 }
+function configFromManifest(manifest) {
+    if (!manifest)
+        return null;
+    return {
+        name: "zudojs-project",
+        type: manifest.projectType ?? "backend",
+        backend: manifest.backend
+            ? { architecture: manifest.backend.architecture }
+            : { architecture: manifest.architecture },
+        frontend: manifest.frontend
+            ? { framework: manifest.frontend.framework }
+            : undefined,
+    };
+}
 function readProjectConfig(cwd) {
     const configPath = join(cwd, "zudojs.config.ts");
     const configPathJs = join(cwd, "zudojs.config.js");
@@ -113,20 +136,32 @@ function parseConfigContent(content, cwd) {
     };
 }
 async function startBackendDev(cwd, config, port) {
-    const portFlag = port ? [`--port=${port}`] : [];
-    if (config.backend?.architecture === "microservice") {
-        await execCommand("tsx", ["watch", "apps/gateway/src", ...portFlag], cwd);
-    }
-    else {
-        await execCommand("tsx", ["watch", "src", ...portFlag], cwd);
-    }
+    // `--port=N` was appended to the tsx argv, where it became an argument of
+    // the watched script and was ignored. Generated servers read PORT from the
+    // environment, so that is where the option has to land.
+    const options = port !== undefined
+        ? { env: { ...process.env, PORT: String(port) } }
+        : undefined;
+    const entry = config.backend?.architecture === "microservice"
+        ? "apps/gateway/src"
+        : "src";
+    await runStreaming("tsx", ["watch", entry], cwd, options);
 }
 function startMicroserviceDev(cwd, services) {
-    const serviceDirs = services.map((service) => join(cwd, "apps", service));
+    const serviceDirs = services.map((service) => {
+        const nested = join(cwd, "apps", "services", service);
+        return existsSync(join(nested, "src"))
+            ? nested
+            : join(cwd, "apps", service);
+    });
     const promises = [];
+    const gatewayDir = join(cwd, "apps", "gateway");
+    if (existsSync(join(gatewayDir, "src"))) {
+        promises.push(runStreaming("tsx", ["watch", "src"], gatewayDir));
+    }
     for (const dir of serviceDirs) {
         if (existsSync(join(dir, "src"))) {
-            promises.push(execCommand("tsx", ["watch", "src"], dir).then(() => { }));
+            promises.push(runStreaming("tsx", ["watch", "src"], dir));
         }
     }
     return promises;
@@ -136,40 +171,40 @@ async function startFrontendDev(cwd, config) {
     const frontendDir = join(cwd, "apps", "web");
     switch (framework) {
         case "react":
-            await execCommand("npm", ["run", "dev"], frontendDir);
+            await runStreaming("npm", ["run", "dev"], frontendDir);
             break;
         case "next":
-            await execCommand("npm", ["run", "dev"], frontendDir);
+            await runStreaming("npm", ["run", "dev"], frontendDir);
             break;
         case "vue":
-            await execCommand("npm", ["run", "dev"], frontendDir);
+            await runStreaming("npm", ["run", "dev"], frontendDir);
             break;
         case "nuxt":
-            await execCommand("npm", ["run", "dev"], frontendDir);
+            await runStreaming("npm", ["run", "dev"], frontendDir);
             break;
         case "angular":
-            await execCommand("ng", ["serve"], frontendDir);
+            await runStreaming("ng", ["serve"], frontendDir);
             break;
         case "svelte":
-            await execCommand("npm", ["run", "dev"], frontendDir);
+            await runStreaming("npm", ["run", "dev"], frontendDir);
             break;
         case "sveltekit":
-            await execCommand("npm", ["run", "dev"], frontendDir);
+            await runStreaming("npm", ["run", "dev"], frontendDir);
             break;
         case "astro":
-            await execCommand("npm", ["run", "dev"], frontendDir);
+            await runStreaming("npm", ["run", "dev"], frontendDir);
             break;
         case "vanilla":
-            await execCommand("npm", ["run", "dev"], frontendDir);
+            await runStreaming("npm", ["run", "dev"], frontendDir);
             break;
         case "flutter":
-            await execCommand("flutter", ["run", "--debug"], frontendDir);
+            await runStreaming("flutter", ["run", "--debug"], frontendDir);
             break;
         case "react-native":
-            await execCommand("npx", ["react-native", "start"], frontendDir);
+            await runStreaming("npx", ["react-native", "start"], frontendDir);
             break;
         default:
-            await execCommand("npm", ["run", "dev"], frontendDir);
+            await runStreaming("npm", ["run", "dev"], frontendDir);
     }
 }
 //# sourceMappingURL=dev.command.js.map

package/dist/src/commands/doctor.command.js

@@ -5,24 +5,29 @@
  */
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
-import { execFileSync } from "node:child_process";
+import { CLIValidationError } from "../errors/index.js";
 export async function runDoctorCommand(context) {
     const checks = [];
     const warnings = [];
     const errors = [];
     checks.push(checkNodeVersion());
-    checks.push(checkPackageManager());
-    checks.push(checkTypeScriptConfig());
-    checks.push(checkZudojsConfig());
+    checks.push(checkPackageManager(context.cwd));
+    checks.push(checkTypeScriptConfig(context.cwd));
+    checks.push(checkZudojsConfig(context.cwd));
     checks.push(checkDependencies(context));
-    checks.push(checkArchitectureViolations());
+    checks.push(checkArchitectureViolations(context.cwd));
     context.logger.info("Zudojs Doctor - Project Diagnostics");
     context.logger.info("");
     for (const check of checks) {
         const symbol = check.passed ? "✔" : "✖";
         context.logger.info(`${symbol} ${check.name}: ${check.message}`);
         if (!check.passed) {
-            errors.push(`${check.name}: ${check.message}`);
+            if (check.severity === "warning") {
+                warnings.push(`${check.name}: ${check.message}`);
+            }
+            else {
+                errors.push(`${check.name}: ${check.message}`);
+            }
         }
     }
     if (warnings.length > 0) {
@@ -40,7 +45,9 @@ export async function runDoctorCommand(context) {
         }
         context.logger.info("");
         context.logger.info("Please fix the errors above before deploying.");
-        return;
+        // Throwing is what gives `zudojs doctor` a non-zero exit code; returning
+        // here would report success to CI while diagnostics failed.
+        throw new CLIValidationError(`Zudojs doctor found ${errors.length} problem(s): ${errors.join("; ")}`);
     }
     context.logger.info("");
     context.logger.info("All checks passed!");
@@ -51,35 +58,40 @@ function checkNodeVersion() {
     const passed = major >= 24;
     return {
         name: "Node.js version",
+        severity: "error",
         passed,
         message: passed
             ? `Node.js ${version} (✓ meets minimum v24)`
             : `Node.js ${version} (✗ requires >= v24)`,
     };
 }
-function checkPackageManager() {
-    const hasPnpm = existsSync("pnpm-lock.yaml");
-    const hasNpm = existsSync("package-lock.json");
-    const hasYarn = existsSync("yarn.lock");
+function checkPackageManager(cwd) {
+    const hasPnpm = existsSync(join(cwd, "pnpm-lock.yaml"));
+    const hasNpm = existsSync(join(cwd, "package-lock.json"));
+    const hasYarn = existsSync(join(cwd, "yarn.lock"));
     const passed = hasPnpm || hasNpm || hasYarn;
     const manager = hasPnpm ? "pnpm" : hasNpm ? "npm" : hasYarn ? "yarn" : "none";
     return {
         name: "Package manager",
+        severity: "warning",
         passed,
         message: passed ? `Detected: ${manager}` : "No lock file found",
     };
 }
-function checkTypeScriptConfig() {
-    const passed = existsSync("tsconfig.json") || existsSync("tsconfig.base.json");
+function checkTypeScriptConfig(cwd) {
+    const passed = existsSync(join(cwd, "tsconfig.json")) ||
+        existsSync(join(cwd, "tsconfig.base.json"));
     return {
         name: "TypeScript configuration",
+        severity: "error",
         passed,
         message: passed ? "tsconfig.json found" : "No tsconfig.json found",
     };
 }
-function checkZudojsConfig() {
-    const hasPkgConfig = checkZudojsInPackageJson();
-    const hasConfig = existsSync("zudojs.config.ts") || existsSync("zudojs.config.js");
+function checkZudojsConfig(cwd) {
+    const hasPkgConfig = checkZudojsInPackageJson(cwd);
+    const hasConfig = existsSync(join(cwd, "zudojs.config.ts")) ||
+        existsSync(join(cwd, "zudojs.config.js"));
     const passed = hasPkgConfig || hasConfig;
     let message = "No Zudojs configuration found.";
     if (passed) {
@@ -89,11 +101,16 @@ function checkZudojsConfig() {
                 ? "zudojs.config.ts found"
                 : "Zudojs config in package.json";
     }
-    return { name: "Zudojs configuration", passed, message };
+    return {
+        name: "Zudojs configuration",
+        severity: "error",
+        passed,
+        message,
+    };
 }
-function checkZudojsInPackageJson() {
+function checkZudojsInPackageJson(cwd) {
     try {
-        const pkgPath = join(process.cwd(), "package.json");
+        const pkgPath = join(cwd, "package.json");
         if (!existsSync(pkgPath))
             return false;
         const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
@@ -108,6 +125,7 @@ function checkDependencies(context) {
     if (!existsSync(pkgPath)) {
         return {
             name: "Dependencies",
+            severity: "error",
             passed: false,
             message: "No package.json found",
         };
@@ -118,6 +136,7 @@ function checkDependencies(context) {
         const passed = zudojsDeps.length > 0;
         return {
             name: "Zudojs dependencies",
+            severity: "warning",
             passed,
             message: passed
                 ? `${zudojsDeps.length} Zudojs packages installed`
@@ -127,22 +146,24 @@ function checkDependencies(context) {
     catch {
         return {
             name: "Dependencies",
+            severity: "error",
             passed: false,
             message: "Failed to read package.json",
         };
     }
 }
-function checkArchitectureViolations() {
-    const srcDir = join(process.cwd(), "src");
+function checkArchitectureViolations(cwd) {
+    const srcDir = join(cwd, "src");
     const violations = [];
     if (!existsSync(srcDir)) {
         return {
             name: "Architecture",
+            severity: "warning",
             passed: true,
             message: "No src/ directory (not a Zudojs project?)",
         };
     }
-    const configPath = join(process.cwd(), "zudojs.config.ts");
+    const configPath = join(cwd, "zudojs.config.ts");
     let architecture = "monolith";
     if (existsSync(configPath)) {
         const configContent = readFileSync(configPath, "utf-8");
@@ -163,7 +184,7 @@ function checkArchitectureViolations() {
             violations.push("src/modules/ found in monolith architecture — consider modular-monolith or microservice architecture");
         }
     }
-    const pkgPath = join(process.cwd(), "package.json");
+    const pkgPath = join(cwd, "package.json");
     if (existsSync(pkgPath)) {
         try {
             const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
@@ -182,6 +203,7 @@ function checkArchitectureViolations() {
     }
     return {
         name: "Architecture",
+        severity: "warning",
         passed: violations.length === 0,
         message: violations.length === 0
             ? "No violations detected"

package/dist/src/commands/generate.command.js

@@ -19,8 +19,8 @@ import { generateRoute } from "../generators/route/route.generator.js";
 import { generateModel } from "../generators/model/model.generator.js";
 import { generateDto } from "../generators/dto/dto.generator.js";
 import { generateValidator } from "../generators/validator/validator.generator.js";
-import { ManifestManager } from "../manifest/manifestManager.core.js";
 import { CLIGenerationError, CLIValidationError } from "../errors/index.js";
+import { assertGeneratableName, assertSafePathSegment, } from "../utils/utils.name.js";
 const VALID_SCHEMATICS = [
     "service",
     "module",
@@ -36,7 +36,28 @@ const VALID_SCHEMATICS = [
     "dto",
     "validator",
 ];
-function getBasePath(architecture, schematic) {
+/**
+ * Resolves the directory a schematic is generated into.
+ *
+ * `moduleName` comes from `--module`, which was previously accepted,
+ * documented and then never read by any schematic. It is validated as a
+ * single safe path segment by the caller before it reaches here.
+ */
+function getBasePath(architecture, schematic, moduleName, serviceName) {
+    const root = getArchitectureRoot(architecture, schematic, serviceName);
+    if (moduleName !== undefined && schematic !== "module") {
+        return `${root}/modules/${moduleName}`;
+    }
+    return root;
+}
+/**
+ * Resolves the directory a schematic is generated into for an architecture.
+ *
+ * The microservice layout produced by `zudojs create` is
+ * `apps/gateway/src` plus `apps/services/<name>/src`; the previous
+ * `apps/default` root matched no directory the scaffolder ever writes.
+ */
+function getArchitectureRoot(architecture, schematic, serviceName) {
     switch (architecture) {
         case "modular-monolith":
             if (schematic === "module") {
@@ -45,9 +66,14 @@ function getBasePath(architecture, schematic) {
             return "src";
         case "microservice":
             if (schematic === "service") {
-                return "apps";
+                // A new service is a new app in the workspace.
+                return "apps/services";
             }
-            return "apps/default";
+            // `--service <name>` selects which app the schematic belongs to.
+            // Without it the gateway app — the one app always generated — is used.
+            return serviceName !== undefined
+                ? `apps/services/${serviceName}/src`
+                : "apps/gateway/src";
         case "monolith":
         default:
             if (schematic === "module") {
@@ -57,18 +83,40 @@ function getBasePath(architecture, schematic) {
     }
 }
 function readZudojsArchitecture(cwd) {
-    const configPath = join(cwd, "zudojs.config.ts");
-    if (!existsSync(configPath)) {
-        const configPathJs = join(cwd, "zudojs.config.js");
-        if (!existsSync(configPathJs))
-            return null;
-        const content = readFileSync(configPathJs, "utf-8");
-        const match = content.match(/architecture:\s*["'](\w[\w-]*)["']/);
-        return match?.[1] ?? null;
-    }
-    const content = readFileSync(configPath, "utf-8");
-    const match = content.match(/architecture:\s*["'](\w[\w-]*)["']/);
-    return match?.[1] ?? null;
+    for (const configFile of ["zudojs.config.ts", "zudojs.config.js"]) {
+        const configPath = join(cwd, configFile);
+        if (existsSync(configPath)) {
+            const content = readFileSync(configPath, "utf-8");
+            const match = content.match(/architecture:\s*["'](\w[\w-]*)["']/);
+            if (match?.[1])
+                return match[1];
+        }
+    }
+    // Fall back to the machine-managed manifest written by `zudojs create`.
+    const manifestPath = join(cwd, ".zudojs", "manifest.json");
+    if (existsSync(manifestPath)) {
+        try {
+            const manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
+            if (manifest.architecture)
+                return manifest.architecture;
+        }
+        catch {
+            // ignore malformed manifest
+        }
+    }
+    // Fall back to the zudojs field in package.json.
+    const pkgPath = join(cwd, "package.json");
+    if (existsSync(pkgPath)) {
+        try {
+            const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+            if (pkg.zudojs?.architecture)
+                return pkg.zudojs.architecture;
+        }
+        catch {
+            // ignore malformed package.json
+        }
+    }
+    return null;
 }
 export async function runGenerateCommand(context) {
     const schematic = context.values.schematic;
@@ -83,14 +131,25 @@ export async function runGenerateCommand(context) {
     if (!name) {
         throw new CLIValidationError("Resource name is required.");
     }
+    // Reject names that normalize to nothing (`zudojs generate event "..."`
+    // wrote src/events/.event.ts with an anonymous export), and reject option
+    // values that are interpolated verbatim into a generated path. `--service ..`
+    // used to place files outside the schematic's base directory.
+    assertGeneratableName(name, "resource name");
+    if (service !== undefined) {
+        assertSafePathSegment(service, "--service");
+    }
+    if (moduleName !== undefined) {
+        assertSafePathSegment(moduleName, "--module");
+    }
     const cwd = context.cwd;
     const architecture = readZudojsArchitecture(cwd);
-    const manifest = await new ManifestManager(cwd).read();
     if (architecture) {
         context.logger.info(`Detected architecture: ${architecture}`);
     }
     else {
-        context.logger.warn("No zudojs.config.ts found. Run `zudojs create` first to scaffold a Zudojs project.");
+        context.logger.warn("No Zudojs project detected (no zudojs.config.ts, .zudojs/manifest.json " +
+            "or `zudojs` field in package.json). Run `zudojs create` first.");
     }
     if (architecture === "microservice" && schematic === "service") {
         context.logger.warn('In microservice architecture, prefer "zudojs generate module" — services are top-level apps.');
@@ -104,42 +163,52 @@ export async function runGenerateCommand(context) {
         dryRun,
         architecture: architecture ?? undefined,
     }, cwd);
-    context.logger.info(`Generated ${result.length} files:`);
+    if (dryRun) {
+        context.logger.info(`Dry run: ${result.length} files would be generated (nothing written):`);
+    }
+    else {
+        context.logger.info(`Generated ${result.length} files:`);
+    }
     for (const file of result) {
         context.logger.info(`  - ${file}`);
     }
 }
 async function runSchematic(schematic, name, options, cwd) {
     try {
-        const basePath = getBasePath(options.architecture, schematic);
-        const moduleName = options.module ?? name;
+        const basePath = getBasePath(options.architecture, schematic, options.module, options.service);
+        const dryRun = options.dryRun;
+        // In the microservice layout `--service` selected the owning app and is
+        // already part of basePath, so it must not nest the schematic again.
+        const cqrsService = options.architecture === "microservice"
+            ? undefined
+            : (options.service ?? "default");
         switch (schematic) {
             case "service":
-                return await generateService({ name, basePath }, cwd);
+                return await generateService({ name, basePath, dryRun }, cwd);
             case "module":
-                return await generateModule({ name, feature: true, basePath }, cwd);
+                return await generateModule({ name, feature: true, basePath, dryRun }, cwd);
             case "command":
-                return await generateCommand({ name, service: options.service ?? "default", basePath }, cwd);
+                return await generateCommand({ name, ...(cqrsService ? { service: cqrsService } : {}), basePath, dryRun }, cwd);
             case "query":
-                return await generateQuery({ name, service: options.service ?? "default", basePath }, cwd);
+                return await generateQuery({ name, ...(cqrsService ? { service: cqrsService } : {}), basePath, dryRun }, cwd);
             case "controller":
-                return await generateController({ name, basePath }, cwd);
+                return await generateController({ name, basePath, dryRun }, cwd);
             case "repository":
-                return await generateRepository({ name, basePath }, cwd);
+                return await generateRepository({ name, basePath, dryRun }, cwd);
             case "middleware":
-                return await generateMiddleware({ name, basePath }, cwd);
+                return await generateMiddleware({ name, basePath, dryRun }, cwd);
             case "event":
-                return await generateEvent({ name, basePath }, cwd);
+                return await generateEvent({ name, basePath, dryRun }, cwd);
             case "job":
-                return await generateJob({ name, basePath }, cwd);
+                return await generateJob({ name, basePath, dryRun }, cwd);
             case "route":
-                return await generateRoute({ name, basePath }, cwd);
+                return await generateRoute({ name, basePath, dryRun }, cwd);
             case "model":
-                return await generateModel({ name, basePath }, cwd);
+                return await generateModel({ name, basePath, dryRun }, cwd);
             case "dto":
-                return await generateDto({ name, basePath }, cwd);
+                return await generateDto({ name, basePath, dryRun }, cwd);
             case "validator":
-                return await generateValidator({ name, basePath }, cwd);
+                return await generateValidator({ name, basePath, dryRun }, cwd);
             default:
                 throw new CLIValidationError(`Unknown schematic: "${schematic}". Available: ${VALID_SCHEMATICS.join(", ")}.`);
         }

package/dist/src/constants/index.d.ts

@@ -3,7 +3,9 @@
  *
  * Constants used by the CLI scaffolding system.
  */
-export declare const CLI_VERSION: "0.1.0";
+export { CLI_VERSION } from "../cliConstant/cliVersion.js";
+/** Published version of all @zudojs/* framework packages. */
+export declare const ZUDOJS_PACKAGES_VERSION: "1.0.0";
 export declare const ARCHITECTURE_CHOICES: readonly [{
     readonly value: "monolith";
     readonly label: "Monolith";

package/dist/src/constants/index.js

@@ -3,7 +3,9 @@
  *
  * Constants used by the CLI scaffolding system.
  */
-export const CLI_VERSION = "0.1.0";
+export { CLI_VERSION } from "../cliConstant/cliVersion.js";
+/** Published version of all @zudojs/* framework packages. */
+export const ZUDOJS_PACKAGES_VERSION = "1.0.0";
 export const ARCHITECTURE_CHOICES = [
     { value: "monolith", label: "Monolith" },
     { value: "modular-monolith", label: "Modular Monolith" },

package/dist/src/generators/command/command.generator.d.ts

@@ -7,6 +7,7 @@ export interface GenerateCommandOptions {
     readonly name: string;
     readonly service?: string;
     readonly basePath?: string;
+    readonly dryRun?: boolean;
 }
 export declare function generateCommand(options: GenerateCommandOptions, cwd: string): Promise<string[]>;
 //# sourceMappingURL=command.generator.d.ts.map

package/dist/src/generators/command/command.generator.js

@@ -4,16 +4,19 @@
  * Generates a CQRS command with handler.
  */
 import { writeFileTree } from "../../utils/utils.fileSystem.js";
-import { CLIGenerationError, CLIValidationError } from "../../errors/index.js";
+import { CLIGenerationError } from "../../errors/index.js";
 import { normalizeName } from "../../utils/utils.name.js";
 export async function generateCommand(options, cwd) {
     const name = normalizeName(options.name);
     const nameCamel = name
         .replace(/-([a-z])/g, (_m, c) => c.toUpperCase())
         .replace(/^./, (c) => c.toUpperCase());
-    const service = options.service ?? "default";
+    const service = options.service;
     const basePath = options.basePath ?? "services";
-    const servicePath = `${basePath}/${service}`;
+    // When no service grouping is given the schematic is written directly under
+    // basePath. Callers that resolved the owning app into basePath (the
+    // microservice layout) pass no service, so the path is not nested twice.
+    const servicePath = service ? `${basePath}/${service}` : basePath;
     const files = {
         [`${servicePath}/commands/${name}/${name}.command.ts`]: `import type { BaseCommand } from "@zudojs/cqrs";
 
@@ -48,12 +51,15 @@ export class ${nameCamel}CommandHandler implements CommandHandler<${nameCamel}Co
 export { ${nameCamel}CommandHandler } from "./${name}.handler.js";
 `,
     };
+    if (options.dryRun) {
+        return Object.keys(files);
+    }
     try {
         await writeFileTree(cwd, files);
         return Object.keys(files);
     }
     catch (error) {
-        throw new CLIGenerationError(`Failed to generate command: ${name} for service: ${service}`, error);
+        throw new CLIGenerationError(`Failed to generate command: ${name} in ${servicePath}`, error);
     }
 }
 //# sourceMappingURL=command.generator.js.map

package/dist/src/generators/controller/controller.generator.d.ts

@@ -5,6 +5,7 @@ export interface GenerateControllerOptions {
     readonly name: string;
     readonly service?: string;
     readonly basePath?: string;
+    readonly dryRun?: boolean;
 }
 export declare function generateController(options: GenerateControllerOptions, cwd: string): Promise<string[]>;
 //# sourceMappingURL=controller.generator.d.ts.map