zudojs-cli 1.2.1 → 2.0.0

package/dist/src/utils/utils.name.js

@@ -9,18 +9,32 @@ export function normalizeName(name) {
         .replace(/^-+/, "")
         .replace(/(?<!-)-+$/, "");
 }
+/**
+ * Prefixes an underscore when the first character cannot start a TypeScript
+ * identifier.
+ *
+ * `normalizeName` keeps digits, so `2fa` came out of the converters as `2fa`
+ * and was emitted verbatim as a class name — a syntax error in the generated
+ * file, and in every barrel and `app.ts` that imports it. Generators reject
+ * such a name up front (see {@link assertGeneratableName}); this is the
+ * last-resort guarantee for the callers that do not, such as the project
+ * templates rendering `--services 2fa`.
+ */
+function toIdentifier(value) {
+    return /^[0-9]/.test(value) ? `_${value}` : value;
+}
 /** Converts an arbitrary name to PascalCase (safe as a TS identifier). */
 export function toPascalCase(name) {
-    return normalizeName(name)
+    return toIdentifier(normalizeName(name)
         .split("-")
         .filter(Boolean)
         .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
-        .join("");
+        .join(""));
 }
 /** Converts an arbitrary name to camelCase (safe as a TS identifier). */
 export function toCamelCase(name) {
     const pascal = toPascalCase(name);
-    return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+    return toIdentifier(pascal.charAt(0).toLowerCase() + pascal.slice(1));
 }
 /**
  * Pattern for names that may be used verbatim as a path segment
@@ -34,12 +48,24 @@ export const SAFE_PATH_SEGMENT = /^[A-Za-z0-9][A-Za-z0-9_-]*$/;
  * `normalizeName` strips everything outside `[a-z0-9-]`, so a name such as
  * `"..."` or `"!!!"` collapses to the empty string and the generator writes
  * `src//.event.ts` with an anonymous exported class. Reject it up front.
+ *
+ * A name whose normalized form starts with a digit (`2fa`, `401-handler`) is
+ * rejected for the same reason: it becomes a class name, and `2faModule` is
+ * not a TypeScript identifier. The generated file, the barrel it is appended
+ * to and the `app.ts` it is registered in would all stop compiling, and the
+ * appends mean the overwrite guard cannot undo it. The converters would
+ * rather rename it to `_2faModule`, but a class whose name no longer contains
+ * the name that was asked for — and disagrees with its own file name — is a
+ * worse surprise than a one-line failure the author can act on.
  */
 export function assertGeneratableName(name, kind = "name") {
     const normalized = normalizeName(name);
     if (normalized === "") {
         throw new CLIValidationError(`Invalid ${kind}: "${name}". It must contain at least one letter or digit.`);
     }
+    if (/^[0-9]/.test(normalized)) {
+        throw new CLIValidationError(`Invalid ${kind}: "${name}". It must start with a letter: the name becomes a TypeScript class name, and "${normalized}" is not a valid identifier. Try "two-factor-auth" instead of "2fa".`);
+    }
     return normalized;
 }
 /**

package/dist/src/validators/environment/environmentValidator.core.d.ts

@@ -3,6 +3,7 @@
  *
  * @module validators/environment
  */
+import type { PackageManager } from "../../types/index.js";
 /**
  * Environment check result.
  */
@@ -26,10 +27,19 @@ export interface EnvironmentValidationResult {
 export declare class EnvironmentValidator {
     /**
      * Validates the environment for a given project type.
+     *
+     * `packageManager` is the one the project will actually use. Without it
+     * the check probed pnpm, yarn, bun and npm in turn and reported the first
+     * one found, so it said "valid" while the chosen manager was missing.
      */
-    validate(projectType: "backend" | "frontend" | "fullstack"): Promise<EnvironmentValidationResult>;
+    validate(projectType: "backend" | "frontend" | "fullstack", packageManager?: PackageManager): Promise<EnvironmentValidationResult>;
     private checkNode;
     private checkGit;
+    /**
+     * Checks the selected package manager, or — when none was selected — the
+     * first one that is installed.
+     */
     private checkPackageManager;
+    private checkBinary;
 }
 //# sourceMappingURL=environmentValidator.core.d.ts.map

package/dist/src/validators/environment/environmentValidator.core.js

@@ -4,20 +4,30 @@
  * @module validators/environment
  */
 import { execCommand } from "../../utils/utils.exec.js";
+const PACKAGE_MANAGER_CANDIDATES = [
+    "pnpm",
+    "yarn",
+    "bun",
+    "npm",
+];
 /**
  * Validates the development environment before project generation.
  */
 export class EnvironmentValidator {
     /**
      * Validates the environment for a given project type.
+     *
+     * `packageManager` is the one the project will actually use. Without it
+     * the check probed pnpm, yarn, bun and npm in turn and reported the first
+     * one found, so it said "valid" while the chosen manager was missing.
      */
-    async validate(projectType) {
+    async validate(projectType, packageManager) {
         const checks = [];
         checks.push(await this.checkNode());
         checks.push(await this.checkGit());
-        if (projectType === "frontend" || projectType === "fullstack") {
-            checks.push(await this.checkPackageManager());
-        }
+        // A backend project installs dependencies too, so the package manager
+        // is checked for every project type, not just frontend and fullstack.
+        checks.push(await this.checkPackageManager(packageManager));
         const missing = checks
             .filter((c) => c.required && !c.installed)
             .map((c) => c.name);
@@ -28,28 +38,36 @@ export class EnvironmentValidator {
         };
     }
     async checkNode() {
-        try {
-            const result = await execCommand("node", ["--version"], ".");
-            return {
-                name: "Node.js",
-                installed: true,
-                version: result.stdout.trim(),
-                required: true,
-            };
+        return this.checkBinary("Node.js", "node");
+    }
+    async checkGit() {
+        return this.checkBinary("Git", "git");
+    }
+    /**
+     * Checks the selected package manager, or — when none was selected — the
+     * first one that is installed.
+     */
+    async checkPackageManager(packageManager) {
+        if (packageManager !== undefined) {
+            return this.checkBinary(packageManager, packageManager);
         }
-        catch {
-            return {
-                name: "Node.js",
-                installed: false,
-                required: true,
-            };
+        for (const candidate of PACKAGE_MANAGER_CANDIDATES) {
+            const check = await this.checkBinary(candidate, candidate);
+            if (check.installed) {
+                return check;
+            }
         }
+        return {
+            name: "Package Manager",
+            installed: false,
+            required: true,
+        };
     }
-    async checkGit() {
+    async checkBinary(name, binary) {
         try {
-            const result = await execCommand("git", ["--version"], ".");
+            const result = await execCommand(binary, ["--version"], ".");
             return {
-                name: "Git",
+                name,
                 installed: true,
                 version: result.stdout.trim(),
                 required: true,
@@ -57,62 +75,11 @@ export class EnvironmentValidator {
         }
         catch {
             return {
-                name: "Git",
+                name,
                 installed: false,
                 required: true,
             };
         }
     }
-    async checkPackageManager() {
-        try {
-            const result = await execCommand("pnpm", ["--version"], ".");
-            return {
-                name: "pnpm",
-                installed: true,
-                version: result.stdout.trim(),
-                required: true,
-            };
-        }
-        catch {
-            try {
-                const result = await execCommand("yarn", ["--version"], ".");
-                return {
-                    name: "yarn",
-                    installed: true,
-                    version: result.stdout.trim(),
-                    required: true,
-                };
-            }
-            catch {
-                try {
-                    const result = await execCommand("bun", ["--version"], ".");
-                    return {
-                        name: "bun",
-                        installed: true,
-                        version: result.stdout.trim(),
-                        required: true,
-                    };
-                }
-                catch {
-                    try {
-                        const result = await execCommand("npm", ["--version"], ".");
-                        return {
-                            name: "npm",
-                            installed: true,
-                            version: result.stdout.trim(),
-                            required: true,
-                        };
-                    }
-                    catch {
-                        return {
-                            name: "Package Manager",
-                            installed: false,
-                            required: true,
-                        };
-                    }
-                }
-            }
-        }
-    }
 }
 //# sourceMappingURL=environmentValidator.core.js.map

package/dist/src/validators/project/index.d.ts

@@ -3,6 +3,6 @@
  *
  * @module validators/project
  */
-export type { ProjectCheck, ProjectValidationResult, } from "./projectValidator.core.js";
+export type { ProjectCheck, ProjectValidationResult, ProjectValidationOptions, } from "./projectValidator.core.js";
 export { ProjectValidator } from "./projectValidator.core.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/src/validators/project/projectValidator.core.d.ts

@@ -13,8 +13,18 @@ export interface ProjectCheck {
     readonly passed: boolean;
     readonly message?: string;
 }
+/** What a validation run should look at. */
+export interface ProjectValidationOptions {
+    /**
+     * Whether dependencies are expected to be installed. A project created
+     * with `--no-install` has no node_modules on purpose.
+     */
+    readonly expectInstalled?: boolean;
+    /** Whether to run the project's own TypeScript compiler. */
+    readonly typecheck?: boolean;
+}
 export declare class ProjectValidator {
-    validate(projectPath: string): Promise<ProjectValidationResult>;
+    validate(projectPath: string, options?: ProjectValidationOptions): Promise<ProjectValidationResult>;
     private checkPackageJson;
     private checkTsConfig;
     private checkNodeModules;

package/dist/src/validators/project/projectValidator.core.js

@@ -9,14 +9,19 @@ import { stat } from "node:fs/promises";
 import { join } from "node:path";
 import { execCommand } from "../../utils/utils.exec.js";
 export class ProjectValidator {
-    async validate(projectPath) {
+    async validate(projectPath, options = {}) {
+        const { expectInstalled = true, typecheck = true } = options;
         const checks = [];
         const errors = [];
         checks.push(await this.checkPackageJson(projectPath));
         checks.push(await this.checkTsConfig(projectPath));
-        checks.push(await this.checkNodeModules(projectPath));
+        if (expectInstalled) {
+            checks.push(await this.checkNodeModules(projectPath));
+        }
         checks.push(await this.checkSourceFiles(projectPath));
-        checks.push(await this.checkTypeScript(projectPath));
+        if (typecheck) {
+            checks.push(await this.checkTypeScript(projectPath));
+        }
         for (const check of checks) {
             if (!check.passed && check.message) {
                 errors.push(check.message);
@@ -96,8 +101,19 @@ export class ProjectValidator {
                 message: "Skipped (no tsconfig)",
             };
         }
+        // `npx tsc` downloads TypeScript from the registry when the project has
+        // no local copy — a network fetch nobody asked for. Only the project's
+        // own compiler is used, and the check is skipped when it is absent.
+        const tsc = join(projectPath, "node_modules", ".bin", process.platform === "win32" ? "tsc.cmd" : "tsc");
+        if (!existsSync(tsc)) {
+            return {
+                name: "typescript",
+                passed: true,
+                message: "Skipped (typescript is not installed in this project)",
+            };
+        }
         try {
-            await execCommand("npx", ["tsc", "--noEmit"], projectPath);
+            await execCommand(tsc, ["--noEmit"], projectPath);
             return { name: "typescript", passed: true };
         }
         catch {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zudojs-cli",
-  "version": "1.2.1",
+  "version": "2.0.0",
   "description": "Command-line interface for scaffolding, generating, and managing Zudojs framework projects.",
   "license": "MIT",
   "author": {