zudojs-cli 1.0.0 → 1.1.0

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

@@ -3,141 +3,126 @@
  *
  * The `zudojs add` command for adding feature packages.
  */
-import { join } from "node:path";
+import { join, relative } from "node:path";
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { runStreaming } from "../utils/utils.exec.js";
+import { assertSafePathSegment } from "../utils/utils.name.js";
 import { CLIValidationError, CLIGenerationError } from "../errors/index.js";
 import { ManifestManager } from "../manifest/manifestManager.core.js";
-import { ZUDOJS_PACKAGES_VERSION } from "../constants/index.js";
-const FEATURE_PACKAGES = {
-    database: ["@zudojs/database"],
-    queue: ["@zudojs/queue"],
-    messaging: ["@zudojs/messaging"],
-    openapi: ["@zudojs/openapi"],
-    observability: ["@zudojs/observability"],
-    security: ["@zudojs/security"],
-    cache: ["@zudojs/cache"],
-    storage: ["@zudojs/storage"],
-    scheduler: ["@zudojs/queue"],
-    docs: ["@zudojs/docs"],
-};
+import { getInstallCommand } from "../installers/dependency.installer.js";
+import { FEATURE_PACKAGES, ZUDOJS_PACKAGES_VERSION, } from "../constants/index.js";
+import { resolveProjectLayout, } from "../resolvers/layout/projectLayout.core.js";
+/**
+ * Picks the `package.json` files a feature is added to.
+ *
+ * The workspace root used to be the only target. In a fullstack project
+ * that root holds no application code, so `@zudojs/database` landed where
+ * nothing could import it while `apps/api` stayed without it. Features now
+ * go to every backend app (`apps/api`, or the gateway and each service of a
+ * microservice project); `--service <name>` narrows a microservice project
+ * to one app.
+ */
+export function selectAddTargets(layout, service) {
+    if (service !== undefined) {
+        if (layout.architecture !== "microservice") {
+            throw new CLIValidationError("--service only applies to microservice projects.");
+        }
+        const match = layout.backendDirs.find((dir) => dir.endsWith(`${join("apps", "services", service)}`));
+        const gateway = layout.backendDirs.find((dir) => dir.endsWith(join("apps", "gateway")));
+        const target = service === "gateway" ? gateway : match;
+        if (!target) {
+            throw new CLIValidationError(`Unknown service "${service}". Known: ${[
+                ...(gateway ? ["gateway"] : []),
+                ...layout.services,
+            ].join(", ")}`);
+        }
+        return [join(target, "package.json")];
+    }
+    return layout.backendDirs.map((dir) => join(dir, "package.json"));
+}
+/**
+ * The version written for a new `@zudojs/*` dependency.
+ *
+ * `workspace:*` was written whenever the project was a workspace. Every
+ * generated fullstack and microservice project is a workspace, and none of
+ * them contains the framework packages, so the next install failed with
+ * "not found in workspace". The protocol is now used only when the target
+ * already links a framework package that way — i.e. inside the Zudojs
+ * monorepo itself.
+ */
+export function versionForNewDependency(pkg) {
+    const linksFramework = Object.entries({
+        ...pkg.dependencies,
+        ...pkg.devDependencies,
+    }).some(([name, version]) => name.startsWith("@zudojs/") && version.startsWith("workspace:"));
+    return linksFramework ? "workspace:*" : ZUDOJS_PACKAGES_VERSION;
+}
 export async function runAddCommand(context) {
     const feature = context.values.feature;
+    const service = context.values.service;
+    const available = Object.keys(FEATURE_PACKAGES).join(", ");
     if (!feature) {
-        throw new CLIValidationError("Feature name is required. Available: database, queue, messaging, openapi, observability, security");
+        throw new CLIValidationError(`Feature name is required. Available: ${available}`);
     }
     const packages = FEATURE_PACKAGES[feature];
     if (!packages) {
-        throw new CLIValidationError(`Unknown feature: "${feature}". Available: ${Object.keys(FEATURE_PACKAGES).join(", ")}`);
+        throw new CLIValidationError(`Unknown feature: "${feature}". Available: ${available}`);
+    }
+    if (service !== undefined) {
+        assertSafePathSegment(service, "--service");
+    }
+    const layout = resolveProjectLayout(context.cwd);
+    if (!layout) {
+        throw new CLIValidationError("No Zudojs project found in this directory. Run `zudojs create` first.");
+    }
+    if (layout.projectType === "frontend") {
+        throw new CLIValidationError("Features are backend packages; this is a frontend-only project.");
+    }
+    const targets = selectAddTargets(layout, service);
+    if (targets.length === 0) {
+        throw new CLIValidationError("No backend app with a package.json was found in this project.");
     }
     context.logger.info(`Adding feature: ${feature}`);
     context.logger.info(`Packages: ${packages.join(", ")}`);
     try {
-        const { manager, rootPkg, isWorkspace } = detectPackageManager(context.cwd);
-        const pkgPath = join(context.cwd, rootPkg);
-        const version = isWorkspace ? "workspace:*" : ZUDOJS_PACKAGES_VERSION;
-        if (!existsSync(pkgPath)) {
-            throw new CLIGenerationError(`Could not find package.json at ${pkgPath}`);
-        }
-        const pkgContent = JSON.parse(readFileSync(pkgPath, "utf-8"));
-        pkgContent.dependencies ??= {};
-        pkgContent.zudojs ??= {
-            features: [],
-        };
-        const zudojsConfig = pkgContent.zudojs;
-        const features = new Set(zudojsConfig.features);
-        if (!features.has(feature)) {
+        for (const pkgPath of targets) {
+            if (!existsSync(pkgPath)) {
+                throw new CLIGenerationError(`Could not find ${pkgPath}`);
+            }
+            const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+            const version = versionForNewDependency(pkg);
+            pkg.dependencies ??= {};
+            pkg.zudojs ??= { features: [] };
+            const block = pkg.zudojs;
+            const features = new Set(Array.isArray(block.features)
+                ? block.features.filter((f) => typeof f === "string")
+                : []);
             features.add(feature);
-            zudojsConfig.features = [...features];
-        }
-        for (const pkg of packages) {
-            if (!(pkg in pkgContent.dependencies)) {
-                pkgContent.dependencies[pkg] = version;
+            block.features = [...features];
+            for (const name of packages) {
+                if (!(name in pkg.dependencies)) {
+                    pkg.dependencies[name] = version;
+                }
             }
+            writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+            context.logger.info(`Updated ${relative(context.cwd, pkgPath) || "package.json"}`);
         }
-        writeFileSync(pkgPath, JSON.stringify(pkgContent, null, 2) + "\n");
-        context.logger.info(`Updated ${rootPkg} with new dependencies.`);
-        updateZudojsConfig(context.cwd, feature);
-        const manifest = new ManifestManager(context.cwd);
-        const current = await manifest.read();
-        if (current) {
-            await manifest.addCapability(feature);
-        }
+        // The manifest records capabilities for the whole project.
+        await new ManifestManager(layout.root).addCapability(feature);
         if (context.values["skip-install"] !== true) {
-            context.logger.info(`Installing dependencies with ${manager}...`);
-            await runStreaming(manager, ["install"], context.cwd);
+            const [file, ...args] = getInstallCommand(layout.packageManager);
+            context.logger.info(`Installing dependencies with ${file}...`);
+            await runStreaming(file, args, layout.root);
         }
         context.logger.info(`Feature "${feature}" added successfully.`);
-        context.logger.info(`Next steps:`);
-        context.logger.info(`  Configure in src/config/${feature}.config.ts`);
+        context.logger.info(`Import from ${packages.map((p) => `"${p}"`).join(", ")} in your modules.`);
     }
     catch (error) {
         if (error instanceof CLIValidationError) {
             throw error;
         }
         const message = error instanceof Error ? error.message : String(error);
-        context.logger.error(`Failed to add feature: ${feature} - ${message}`);
-        throw new CLIGenerationError(`Failed to add feature: ${feature}: ${message}`, error);
-    }
-}
-function detectPackageManager(cwd) {
-    // A project is a workspace only when a workspace definition exists:
-    // pnpm-workspace.yaml or a "workspaces" field in package.json. Lock files
-    // merely indicate the package manager.
-    const hasPnpmWorkspace = existsSync(join(cwd, "pnpm-workspace.yaml"));
-    let hasWorkspacesField = false;
-    try {
-        const pkgPath = join(cwd, "package.json");
-        if (existsSync(pkgPath)) {
-            const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
-            hasWorkspacesField = pkg.workspaces !== undefined;
-        }
-    }
-    catch {
-        // ignore malformed package.json
-    }
-    const isWorkspace = hasPnpmWorkspace || hasWorkspacesField;
-    const manager = hasPnpmWorkspace || existsSync(join(cwd, "pnpm-lock.yaml"))
-        ? "pnpm"
-        : existsSync(join(cwd, "yarn.lock"))
-            ? "yarn"
-            : existsSync(join(cwd, "bun.lock")) ||
-                existsSync(join(cwd, "bun.lockb"))
-                ? "bun"
-                : "npm";
-    return { manager, rootPkg: "package.json", isWorkspace };
-}
-function updateZudojsConfig(cwd, feature) {
-    const configPath = join(cwd, "zudojs.config.ts");
-    if (!existsSync(configPath))
-        return;
-    let content = readFileSync(configPath, "utf-8");
-    const featureMap = {
-        database: "database",
-        queue: "queue",
-        messaging: "events",
-        openapi: "openapi",
-        observability: "observability",
-        security: "security",
-        cache: "cache",
-        storage: "storage",
-        scheduler: "scheduler",
-        docs: "docs",
-    };
-    const configKey = featureMap[feature];
-    if (!configKey)
-        return;
-    const pattern = /(export\s+default\s+defineConfig\(\{[\s\S]*?)\n\}\);/;
-    const match = content.match(pattern);
-    if (!match)
-        return;
-    const featureBlock = `\n  ${configKey}: {\n    enabled: true,\n  },`;
-    if (content.includes(`${configKey}:`)) {
-        content = content.replace(new RegExp(`${configKey}:\\s*\\{[^}]*\\}`), `${configKey}: {\n    enabled: true,\n  }`);
-    }
-    else {
-        content = content.replace(pattern, `$1${featureBlock}\n});`);
+        throw new CLIGenerationError(`Failed to add feature "${feature}": ${message}`, error);
     }
-    writeFileSync(configPath, content);
 }
 //# sourceMappingURL=add.command.js.map

package/dist/src/commands/build.command.d.ts

@@ -4,5 +4,13 @@
  * The `zudojs build` command for building Zudojs projects.
  */
 import type { CLIContext } from "../cliType/cliType.type.js";
+import type { PackageManager } from "../types/index.js";
 export declare function runBuildCommand(context: CLIContext): Promise<void>;
+/**
+ * Arguments that run the `build` script.
+ *
+ * pnpm's `-r` is only meaningful in a workspace; a single-package project's
+ * root `build` script is the whole build.
+ */
+export declare function getBuildArgs(packageManager: PackageManager, isWorkspace: boolean): string[];
 //# sourceMappingURL=build.command.d.ts.map

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

@@ -3,10 +3,9 @@
  *
  * The `zudojs build` command for building Zudojs projects.
  */
-import { existsSync } from "node:fs";
-import { join } from "node:path";
 import { runStreaming } from "../utils/utils.exec.js";
 import { findProjectRoot } from "../resolvers/project.resolver.js";
+import { detectPackageManager, resolveProjectLayout, } from "../resolvers/layout/projectLayout.core.js";
 import { CLIGenerationError, CLINotInProjectError } from "../errors/index.js";
 export async function runBuildCommand(context) {
     const projectRoot = findProjectRoot(context.cwd);
@@ -16,34 +15,29 @@ export async function runBuildCommand(context) {
         throw new CLINotInProjectError();
     }
     context.logger.info(`Building project at: ${projectRoot}`);
-    const packageManager = detectPackageManager(projectRoot);
-    const buildArgs = getBuildArgs(packageManager);
+    const layout = resolveProjectLayout(projectRoot);
+    const packageManager = layout?.packageManager ?? detectPackageManager(projectRoot);
+    const buildArgs = getBuildArgs(packageManager, layout?.isWorkspace ?? false);
     try {
         await runStreaming(packageManager, buildArgs, projectRoot);
         context.logger.info("Build completed successfully.");
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
-        context.logger.error(`Build failed: ${message}`);
         // A failed build must fail the command so CI does not report success.
         throw new CLIGenerationError(`Build failed: ${message}`, error);
     }
 }
-function detectPackageManager(cwd) {
-    if (existsSync(join(cwd, "pnpm-lock.yaml")))
-        return "pnpm";
-    if (existsSync(join(cwd, "yarn.lock")))
-        return "yarn";
-    if (existsSync(join(cwd, "package-lock.json")))
-        return "npm";
-    if (existsSync(join(cwd, "bun.lock")) || existsSync(join(cwd, "bun.lockb")))
-        return "bun";
-    return "npm";
-}
-function getBuildArgs(packageManager) {
+/**
+ * Arguments that run the `build` script.
+ *
+ * pnpm's `-r` is only meaningful in a workspace; a single-package project's
+ * root `build` script is the whole build.
+ */
+export function getBuildArgs(packageManager, isWorkspace) {
     switch (packageManager) {
         case "pnpm":
-            return ["-r", "run", "build"];
+            return isWorkspace ? ["-r", "run", "build"] : ["run", "build"];
         case "yarn":
             // Plain `yarn run build` works on both Yarn classic and Berry without
             // requiring the workspace-tools plugin.

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

@@ -299,7 +299,6 @@ async function createProject(options, context) {
     try {
         spinner.start("Creating project structure");
         await mkdir(targetPath, { recursive: true });
-        rollback.trackDirectory(targetPath);
         spinner.stop("Project structure created");
         if (options.projectType === "fullstack" &&
             options.frontend &&
@@ -318,8 +317,7 @@ async function createProject(options, context) {
         else {
             spinner.start("Generating backend project");
             const result = await generateProject(options, targetPath);
-            context.logger.info(`Files created: ${result.filesCreated.length}`);
-            spinner.stop("Backend project generated");
+            spinner.stop(`Backend project generated (${result.filesCreated.length} files)`);
         }
         await writeProjectManifest(options, targetPath);
         if (options.installDeps) {
@@ -338,8 +336,11 @@ async function createProject(options, context) {
                 await runStreaming(installFile, ["install"], targetPath);
                 p.log.success("Dependencies installed");
             }
-            catch {
-                p.log.warn("Dependency installation skipped");
+            catch (error) {
+                // The project is complete without its node_modules; say what
+                // failed and how to retry instead of a bare "skipped".
+                const reason = error instanceof Error ? error.message : String(error);
+                p.log.warn(`Dependency installation failed: ${reason}\nRun "${installFile} install" inside ${projectName} to retry.`);
             }
         }
         if (options.initGit) {
@@ -445,6 +446,7 @@ async function generateFullstackProject(options, projectPath, rollback) {
             features: options.services,
         },
         projectPath,
+        installDeps: options.installDeps,
     });
     if (!result.success) {
         throw new CLIGenerationError(`Fullstack generation failed:\n${result.errors.join("\n")}`);
@@ -514,6 +516,7 @@ async function generateFrontendProject(options, projectPath) {
         architecture: options.frontendArchitecture ?? "zudojs-standard",
         language: options.language ?? "typescript",
         packageManager: options.packageManager,
+        installDeps: options.installDeps,
     });
     if (!result.success) {
         throw new CLIGenerationError(`Frontend generation failed:\n${result.errors.join("\n")}`);

package/dist/src/commands/dev.command.d.ts

@@ -1,9 +1,37 @@
 /**
  * zudojs-cli — Dev Command
  *
- * The `zudojs dev` command.
- * Starts development servers based on project configuration.
+ * The `zudojs dev` command. Starts the development servers of the project
+ * in the current directory.
+ *
+ * Servers are started through the project's package manager (`pnpm run
+ * dev`, `npm run dev`, …) rather than by spawning `tsx` or `ng` directly:
+ * those binaries are devDependencies of the generated project and are not
+ * on the user's PATH, so the direct spawn failed with ENOENT for everyone
+ * who had not installed them globally. Running the script also means the
+ * project's own `dev` script is what runs — `tsx watch src` used to be
+ * hard-coded here, which watched `src/index.ts`, a file that only exports
+ * `createApp` and never starts the server.
  */
 import type { CLIContext } from "../cliType/cliType.type.js";
+import { type ProjectLayout } from "../resolvers/layout/projectLayout.core.js";
+/** One development server to start. */
+export interface DevServerSpec {
+    readonly label: string;
+    readonly cwd: string;
+    readonly file: string;
+    readonly args: readonly string[];
+    readonly env?: NodeJS.ProcessEnv;
+}
+/**
+ * Computes the servers `zudojs dev` starts for a project layout.
+ *
+ * Exported so the selection can be tested without spawning anything.
+ */
+export declare function planDevServers(layout: ProjectLayout, options?: {
+    readonly frontendOnly?: boolean;
+    readonly backendOnly?: boolean;
+    readonly port?: number;
+}): DevServerSpec[];
 export declare function runDevCommand(context: CLIContext): Promise<void>;
 //# sourceMappingURL=dev.command.d.ts.map