zudojs-cli 0.1.1 → 1.0.0

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

@@ -1,17 +1,17 @@
 /**
  * zudojs-cli — Controller Generator
  */
-import { writeFileTree } from "../../utils/utils.fileSystem.js";
-import { CLIGenerationError, CLIValidationError } from "../../errors/index.js";
-import { normalizeName } from "../../utils/utils.name.js";
+import { writeFileTree, mergeBarrelExport, } from "../../utils/utils.fileSystem.js";
+import { CLIGenerationError } from "../../errors/index.js";
+import { normalizeName, toPascalCase } from "../../utils/utils.name.js";
 export async function generateController(options, cwd) {
     const name = normalizeName(options.name);
-    const nameCamel = name
-        .replace(/-([a-z])/g, (_m, c) => c.toUpperCase())
-        .replace(/^./, (c) => c.toUpperCase());
+    const nameCamel = toPascalCase(options.name);
     const basePath = options.basePath ?? "";
+    const prefix = basePath ? `${basePath}/` : "";
+    const indexPath = `${prefix}controllers/index.ts`;
     const files = {
-        [`${basePath ? `${basePath}/` : ""}controllers/${name}.controller.ts`]: `import { createLogger } from "@zudojs/logger";
+        [`${prefix}controllers/${name}.controller.ts`]: `import { createLogger } from "@zudojs/logger";
 
 export class ${nameCamel}Controller {
   private readonly logger = createLogger({ name: "${name}-controller" });
@@ -30,9 +30,12 @@ export class ${nameCamel}Controller {
   }
 }
 `,
-        [`${basePath ? `${basePath}/` : ""}controllers/index.ts`]: `export { ${nameCamel}Controller } from "./${name}.controller.js";
-`,
+        // Merge with any existing barrel content instead of overwriting it.
+        [indexPath]: mergeBarrelExport(cwd, indexPath, `export { ${nameCamel}Controller } from "./${name}.controller.js";`),
     };
+    if (options.dryRun) {
+        return Object.keys(files);
+    }
     try {
         await writeFileTree(cwd, files);
         return Object.keys(files);

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

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

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

@@ -4,17 +4,23 @@
  * Generates DTO files.
  */
 import { writeFileTree } from "../../utils/utils.fileSystem.js";
+import { normalizeName, toPascalCase } from "../../utils/utils.name.js";
 export async function generateDto(options, cwd) {
+    const name = normalizeName(options.name);
+    const namePascal = toPascalCase(options.name);
     const files = {
-        [`${options.basePath}/dtos/${options.name}.dto.ts`]: `/**
- * ${options.name} DTO.
+        [`${options.basePath}/dtos/${name}.dto.ts`]: `/**
+ * ${name} DTO.
  */
 
-export interface Create${options.name}Dto {
+export interface Create${namePascal}Dto {
   readonly name: string;
 }
 `,
     };
+    if (options.dryRun) {
+        return Object.keys(files);
+    }
     await writeFileTree(cwd, files);
     return Object.keys(files);
 }

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

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

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

@@ -4,18 +4,24 @@
  * Generates event files.
  */
 import { writeFileTree } from "../../utils/utils.fileSystem.js";
+import { normalizeName, toPascalCase } from "../../utils/utils.name.js";
 export async function generateEvent(options, cwd) {
+    const name = normalizeName(options.name);
+    const namePascal = toPascalCase(options.name);
     const files = {
-        [`${options.basePath}/events/${options.name}.event.ts`]: `/**
- * ${options.name} event.
+        [`${options.basePath}/events/${name}.event.ts`]: `/**
+ * ${name} event.
  */
 
-export interface ${options.name}Event {
-  readonly type: "${options.name}";
+export interface ${namePascal}Event {
+  readonly type: "${name}";
   readonly timestamp: Date;
 }
 `,
     };
+    if (options.dryRun) {
+        return Object.keys(files);
+    }
     await writeFileTree(cwd, files);
     return Object.keys(files);
 }

package/dist/src/generators/frontend/frontendGenerator.core.js

@@ -7,6 +7,7 @@ import { FrontendAdapterRegistry } from "../../registries/adapter/frontendAdapte
 import { PackageManagerRegistry } from "../../registries/adapter/packageManagerRegistry.core.js";
 import { DependencyResolver } from "../../resolvers/dependency/dependencyResolver.core.js";
 import { CLIGenerationError } from "../../errors/index.js";
+import { runFrontendPipeline } from "./frontendPipeline.js";
 /**
  * Generates frontend projects using framework adapters.
  */
@@ -43,34 +44,9 @@ export class FrontendGenerator {
         const files = [];
         const errors = [];
         try {
-            // 1. Scaffold using official tool
-            await adapter.scaffold(context);
-            files.push("scaffold");
-            // 2. Apply Zudojs structure
-            await adapter.applyZudojsStructure(context);
-            files.push("structure");
-            // 3. Resolve and install dependencies
-            const deps = adapter.getDependencies(context);
-            const resolution = this.dependencyResolver.resolve(deps);
-            if (resolution.conflicts.length > 0) {
-                for (const conflict of resolution.conflicts) {
-                    errors.push(`Conflict: ${conflict.reason}`);
-                }
-                return { success: false, framework: options.framework, files, errors };
-            }
-            // 4. Install dependencies
-            const pmName = options.packageManager ?? "pnpm";
-            const packageManager = this.packageManagerRegistry.get(pmName);
-            if (packageManager) {
-                const devDeps = resolution.devDependencies.map((d) => d.name);
-                await packageManager.addDev(options.projectPath, devDeps);
-                files.push("dependencies");
-            }
-            // 5. Validate
-            const validation = await adapter.validate(context);
-            if (!validation.valid) {
-                errors.push(...validation.errors);
-            }
+            const outcome = await runFrontendPipeline(adapter, context, this.packageManagerRegistry, this.dependencyResolver);
+            files.push(...outcome.files);
+            errors.push(...outcome.errors);
         }
         catch (error) {
             errors.push(error instanceof Error ? error.message : String(error));

package/dist/src/generators/frontend/frontendPipeline.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Shared frontend generation pipeline.
+ *
+ * Both `FrontendGenerator` (frontend-only projects) and `FullstackComposer`
+ * (the `apps/web` half of a fullstack project) drive frontend adapters. They
+ * used to do it with two different sequences: the fullstack path skipped
+ * availability checks, dependency resolution, dependency installation and
+ * adapter validation entirely. This module is the single sequence both use so
+ * the two paths cannot drift again.
+ *
+ * @module generators/frontend/pipeline
+ */
+import type { FrontendAdapter, FrontendGenerationContext } from "../../adapters/frontend/frontendAdapter.type.js";
+import type { PackageManagerRegistry } from "../../registries/adapter/packageManagerRegistry.core.js";
+import type { DependencyResolver } from "../../resolvers/dependency/dependencyResolver.core.js";
+/** Outcome of running the frontend pipeline for a single adapter. */
+export interface FrontendPipelineResult {
+    readonly files: readonly string[];
+    readonly errors: readonly string[];
+}
+/**
+ * Runs the full adapter sequence: availability check, scaffold, structure,
+ * integration, dependency resolution, dependency installation, validation.
+ */
+export declare function runFrontendPipeline(adapter: FrontendAdapter, context: FrontendGenerationContext, packageManagerRegistry: PackageManagerRegistry, dependencyResolver: DependencyResolver): Promise<FrontendPipelineResult>;
+//# sourceMappingURL=frontendPipeline.d.ts.map

package/dist/src/generators/frontend/frontendPipeline.js

@@ -0,0 +1,93 @@
+/**
+ * Shared frontend generation pipeline.
+ *
+ * Both `FrontendGenerator` (frontend-only projects) and `FullstackComposer`
+ * (the `apps/web` half of a fullstack project) drive frontend adapters. They
+ * used to do it with two different sequences: the fullstack path skipped
+ * availability checks, dependency resolution, dependency installation and
+ * adapter validation entirely. This module is the single sequence both use so
+ * the two paths cannot drift again.
+ *
+ * @module generators/frontend/pipeline
+ */
+/**
+ * Rejects package names a package manager would read as a flag.
+ *
+ * Adapter dependency lists are static today, but they are part of the public
+ * `FrontendAdapter` contract and a third-party adapter could return
+ * `--registry=...`. Package names go into an argv array (never a shell), so
+ * this closes argument injection rather than command injection.
+ */
+function assertSafePackageNames(names) {
+    for (const name of names) {
+        if (name.startsWith("-") || name.trim() === "" || /\s/.test(name)) {
+            throw new Error(`Refusing to install unsafe package name: "${name}"`);
+        }
+    }
+}
+/**
+ * Runs the full adapter sequence: availability check, scaffold, structure,
+ * integration, dependency resolution, dependency installation, validation.
+ */
+export async function runFrontendPipeline(adapter, context, packageManagerRegistry, dependencyResolver) {
+    const files = [];
+    const errors = [];
+    // 0. Fail fast with a readable message when the framework's own toolchain
+    //    is missing. Adapters such as Flutter shell out with no fallback, so
+    //    without this the user sees a bare ENOENT after the project directory
+    //    has already been created and rolled back.
+    const available = await adapter.isAvailable();
+    if (!available) {
+        return {
+            files,
+            errors: [
+                `The toolchain required by the "${adapter.name}" frontend is not available on this machine. Install it and re-run, or choose another frontend.`,
+            ],
+        };
+    }
+    // 1. Scaffold using the official tool (adapters fall back to built-in
+    //    templates where one exists).
+    await adapter.scaffold(context);
+    files.push("scaffold");
+    // 2. Apply the Zudojs structure over the scaffolded project.
+    await adapter.applyZudojsStructure(context);
+    files.push("structure");
+    // 3. Generate the adapter's integration files (API client, env helpers).
+    await adapter.generateIntegration(context);
+    files.push("integration");
+    // 4. Resolve dependencies and stop on conflicts.
+    const resolution = dependencyResolver.resolve(adapter.getDependencies(context));
+    if (resolution.conflicts.length > 0) {
+        for (const conflict of resolution.conflicts) {
+            errors.push(`Conflict: ${conflict.reason}`);
+        }
+        return { files, errors };
+    }
+    // 5. Install BOTH runtime and dev dependencies. Only devDependencies used
+    //    to be installed, so every runtime package an adapter declared was
+    //    resolved and then dropped on the floor.
+    const packageManager = packageManagerRegistry.get(context.packageManager);
+    if (packageManager) {
+        const deps = resolution.dependencies.map((d) => d.name);
+        const devDeps = resolution.devDependencies.map((d) => d.name);
+        assertSafePackageNames(deps);
+        assertSafePackageNames(devDeps);
+        if (deps.length > 0) {
+            await packageManager.add(context.projectPath, deps);
+        }
+        if (devDeps.length > 0) {
+            await packageManager.addDev(context.projectPath, devDeps);
+        }
+        files.push("dependencies");
+    }
+    else {
+        errors.push(`Unknown package manager: ${context.packageManager}`);
+    }
+    // 6. Validate the generated project and surface the adapter's own findings.
+    const validation = await adapter.validate(context);
+    if (!validation.valid) {
+        errors.push(...validation.errors);
+    }
+    return { files, errors };
+}
+//# sourceMappingURL=frontendPipeline.js.map

package/dist/src/generators/fullstack/fullstackComposer.core.d.ts

@@ -28,15 +28,14 @@ export declare class FullstackComposer {
     private readonly frontendRegistry;
     private readonly packageManagerRegistry;
     private readonly dependencyResolver;
-    private readonly integrationGenerator;
     constructor();
     /**
      * Generates a fullstack project.
      */
     generate(context: FullstackGenerationContext): Promise<FullstackGenerationResult>;
+    private getPackageManager;
     private createWorkspace;
     private generateSharedPackages;
     private generateFrontend;
-    private installDependencies;
 }
 //# sourceMappingURL=fullstackComposer.core.d.ts.map

package/dist/src/generators/fullstack/fullstackComposer.core.js

@@ -5,12 +5,13 @@
  *
  * @module generators/fullstack
  */
+import { mkdir } from "node:fs/promises";
+import { join } from "node:path";
 import { FrontendAdapterRegistry } from "../../registries/adapter/frontendAdapterRegistry.core.js";
 import { PackageManagerRegistry } from "../../registries/adapter/packageManagerRegistry.core.js";
 import { DependencyResolver } from "../../resolvers/dependency/dependencyResolver.core.js";
-import { IntegrationGenerator } from "../integration/integrationGenerator.core.js";
+import { runFrontendPipeline } from "../frontend/frontendPipeline.js";
 import { writeFileTree } from "../../utils/utils.fileSystem.js";
-import { execCommand } from "../../utils/utils.exec.js";
 /**
  * Composes fullstack projects by orchestrating multiple generators.
  */
@@ -18,12 +19,10 @@ export class FullstackComposer {
     frontendRegistry;
     packageManagerRegistry;
     dependencyResolver;
-    integrationGenerator;
     constructor() {
         this.frontendRegistry = new FrontendAdapterRegistry();
         this.packageManagerRegistry = new PackageManagerRegistry();
         this.dependencyResolver = new DependencyResolver();
-        this.integrationGenerator = new IntegrationGenerator();
     }
     /**
      * Generates a fullstack project.
@@ -34,7 +33,10 @@ export class FullstackComposer {
         try {
             // 1. Create workspace structure
             await this.createWorkspace(context);
-            files.push("package.json", "pnpm-workspace.yaml", "zudojs.config.ts");
+            files.push("package.json", "zudojs.config.ts");
+            if (this.getPackageManager(context) === "pnpm") {
+                files.push("pnpm-workspace.yaml");
+            }
             // 2. Generate shared packages
             await this.generateSharedPackages(context);
             files.push("packages/contracts/", "packages/shared-types/");
@@ -43,19 +45,8 @@ export class FullstackComposer {
                 const frontendFiles = await this.generateFrontend(context);
                 files.push(...frontendFiles);
             }
-            // 4. Generate integration files
-            await this.integrationGenerator.generate({
-                project: context.project,
-                projectPath: context.projectPath,
-                backendPort: 3000,
-                frontendPort: context.project.frontend?.framework === "next" ? 3000 : 5173,
-            });
-            files.push(".env.example", "config/cors.ts", ...(context.project.frontend?.framework === "react" ||
-                context.project.frontend?.framework === "vue"
-                ? ["vite.config.ts"]
-                : []));
-            // 5. Install dependencies
-            await this.installDependencies(context);
+            // Note: integration files and dependency installation are orchestrated
+            // by the create command to avoid running them twice.
         }
         catch (error) {
             errors.push(error instanceof Error ? error.message : String(error));
@@ -66,52 +57,66 @@ export class FullstackComposer {
             errors,
         };
     }
+    getPackageManager(context) {
+        return context.project.workspace?.packageManager ?? "pnpm";
+    }
     async createWorkspace(context) {
+        const packageManager = this.getPackageManager(context);
+        const workspaceGlobs = ["apps/*", "packages/*"];
+        const scriptFor = (script) => {
+            switch (packageManager) {
+                case "npm":
+                    return `npm run ${script} --workspaces --if-present`;
+                case "yarn":
+                    return `yarn workspaces run ${script}`;
+                case "bun":
+                    return `bun run --filter '*' ${script}`;
+                default:
+                    return `pnpm -r --parallel run ${script}`;
+            }
+        };
         const rootPackageJson = {
             name: context.project.name,
             private: true,
+            ...(packageManager === "pnpm" ? {} : { workspaces: workspaceGlobs }),
             scripts: {
-                dev: "pnpm --parallel dev",
-                build: "pnpm --parallel build",
-                test: "pnpm --parallel test",
-                lint: "pnpm --parallel lint",
-                typecheck: "pnpm --parallel typecheck",
+                dev: scriptFor("dev"),
+                build: scriptFor("build"),
+                test: scriptFor("test"),
+                lint: scriptFor("lint"),
+                typecheck: scriptFor("typecheck"),
             },
             devDependencies: {
                 typescript: "^5.0.0",
             },
         };
-        const workspaceYaml = `packages:
-  - "apps/*"
-  - "packages/*"
-`;
-        const zudojsConfig = `export default {
-  version: 1,
-  project: {
-    name: "${context.project.name}",
-    type: "fullstack",
-  },
-  backend: {
-    architecture: "${context.project.backend?.architecture ?? "monolith"}",
-    api: "${context.project.backend?.api ?? "rest"}",
-  },
+        // Project and framework names reach this template from user input. They
+        // are emitted as JSON string literals (valid JS) so a quote, backslash,
+        // newline or `";` sequence cannot break out of the literal and inject
+        // code into the generated zudojs.config.ts.
+        const literal = (value) => JSON.stringify(value);
+        const frontendBlock = context.project.frontend
+            ? `
   frontend: {
-    framework: "${context.project.frontend?.framework ?? "react"}",
-    architecture: "${context.project.frontend?.architecture ?? "zudojs-standard"}",
-  },
-  database: {
-    provider: "${context.project.backend?.database ?? "postgresql"}",
-  },
-  workspace: {
-    packageManager: "${context.project.workspace?.packageManager ?? "pnpm"}",
-  },
+    framework: ${literal(context.project.frontend.framework)},
+  },`
+            : "";
+        const zudojsConfig = `export default {
+  name: ${literal(context.project.name)},
+  projectType: "fullstack",
+  architecture: ${literal(context.project.backend?.architecture ?? "monolith")},${frontendBlock}
 };
 `;
-        await writeFileTree(context.projectPath, {
-            "package.json": JSON.stringify(rootPackageJson, null, 2),
-            "pnpm-workspace.yaml": workspaceYaml,
+        const files = {
+            "package.json": JSON.stringify(rootPackageJson, null, 2) + "\n",
             "zudojs.config.ts": zudojsConfig,
-        });
+        };
+        if (packageManager === "pnpm") {
+            files["pnpm-workspace.yaml"] = `packages:
+${workspaceGlobs.map((g) => `  - "${g}"`).join("\n")}
+`;
+        }
+        await writeFileTree(context.projectPath, files);
     }
     async generateSharedPackages(context) {
         const contractsIndex = `/**
@@ -150,14 +155,17 @@ export type Timestamp = string;
         if (!adapter) {
             throw new Error(`Unknown frontend framework: ${context.project.frontend.framework}`);
         }
-        const frontendPath = `${context.projectPath}/apps/web`;
+        const frontendPath = join(context.projectPath, "apps", "web");
+        // Scaffolders spawn with cwd=frontendPath; the directory must exist
+        // before the child process starts or spawn fails with ENOENT.
+        await mkdir(frontendPath, { recursive: true });
         const frontendContext = {
             project: context.project,
             projectPath: frontendPath,
             framework: adapter.framework,
             language: context.project.frontend.language ?? "typescript",
             architecture: context.project.frontend.architecture,
-            packageManager: context.project.workspace?.packageManager ?? "pnpm",
+            packageManager: this.getPackageManager(context),
             features: {
                 testing: true,
                 linting: true,
@@ -165,17 +173,15 @@ export type Timestamp = string;
                 envValidation: true,
             },
         };
-        await adapter.scaffold(frontendContext);
-        await adapter.applyZudojsStructure(frontendContext);
-        await adapter.generateIntegration(frontendContext);
-        return ["apps/web/"];
-    }
-    async installDependencies(context) {
-        const pmName = context.project.workspace?.packageManager ?? "pnpm";
-        const packageManager = this.packageManagerRegistry.get(pmName);
-        if (packageManager) {
-            await packageManager.install(context.projectPath);
+        // The same pipeline the frontend-only path uses: availability check,
+        // scaffold, structure, integration, dependency resolution + install, and
+        // adapter validation. Skipping any of it here is what let fullstack
+        // projects ship an unvalidated, dependency-less apps/web.
+        const outcome = await runFrontendPipeline(adapter, frontendContext, this.packageManagerRegistry, this.dependencyResolver);
+        if (outcome.errors.length > 0) {
+            throw new Error(`Frontend generation failed: ${outcome.errors.join("; ")}`);
         }
+        return ["apps/web/"];
     }
 }
 //# sourceMappingURL=fullstackComposer.core.js.map

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

@@ -13,6 +13,17 @@ export interface InfrastructureOptions {
 export declare class InfrastructureGenerator {
     generate(options: InfrastructureOptions, basePath: string): Promise<void>;
     private getFiles;
+    /**
+     * Install and build commands for Dockerfiles.
+     *
+     * Generated projects have no lockfile yet, so never use `npm ci` or
+     * `--frozen-lockfile`. pnpm and yarn need `corepack enable` on the bare
+     * node:24-alpine image; bun is not available there so it falls back to npm.
+     */
+    private getDockerCommands;
+    private getDatabaseCompose;
+    private getDatabaseUrl;
+    private getDbServiceBlock;
     private getAppDockerfile;
     private getServiceDockerfile;
     private getSimpleDockerCompose;