add-nest-auth 1.0.0

package/dist/cli.js

@@ -0,0 +1,1133 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/tsup/assets/cjs_shims.js
+var init_cjs_shims = __esm({
+  "node_modules/tsup/assets/cjs_shims.js"() {
+    "use strict";
+  }
+});
+
+// src/generator/template-engine.ts
+var import_handlebars, path2, fs2, TemplateEngine;
+var init_template_engine = __esm({
+  "src/generator/template-engine.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_handlebars = __toESM(require("handlebars"));
+    path2 = __toESM(require("path"));
+    fs2 = __toESM(require("fs-extra"));
+    TemplateEngine = class {
+      handlebars;
+      templateCache;
+      templatesDir;
+      constructor(templatesDir) {
+        this.handlebars = import_handlebars.default.create();
+        this.templateCache = /* @__PURE__ */ new Map();
+        this.templatesDir = templatesDir || path2.join(__dirname, "templates");
+        this.registerHelpers();
+      }
+      /**
+       * Register Handlebars helpers
+       */
+      registerHelpers() {
+        this.handlebars.registerHelper("eq", (a, b) => a === b);
+        this.handlebars.registerHelper("ne", (a, b) => a !== b);
+        this.handlebars.registerHelper("includes", (arr, item) => arr?.includes(item));
+        this.handlebars.registerHelper("capitalize", (str) => {
+          if (!str) return "";
+          return str.charAt(0).toUpperCase() + str.slice(1);
+        });
+        this.handlebars.registerHelper("lowercase", (str) => {
+          if (!str) return "";
+          return str.toLowerCase();
+        });
+        this.handlebars.registerHelper("uppercase", (str) => {
+          if (!str) return "";
+          return str.toUpperCase();
+        });
+        this.handlebars.registerHelper("camelCase", (str) => {
+          if (!str) return "";
+          return str.replace(/-([a-z])/g, (g) => g[1].toUpperCase());
+        });
+        this.handlebars.registerHelper("pascalCase", (str) => {
+          if (!str) return "";
+          const camel = str.replace(/-([a-z])/g, (g) => g[1].toUpperCase());
+          return camel.charAt(0).toUpperCase() + camel.slice(1);
+        });
+      }
+      /**
+       * Render a template with context
+       */
+      async render(templatePath, context) {
+        const template = await this.loadTemplate(templatePath);
+        return template(context);
+      }
+      /**
+       * Load a template (with caching)
+       */
+      async loadTemplate(templatePath) {
+        if (this.templateCache.has(templatePath)) {
+          return this.templateCache.get(templatePath);
+        }
+        const fullPath = path2.join(this.templatesDir, templatePath);
+        if (!await fs2.pathExists(fullPath)) {
+          throw new Error(`Template not found: ${templatePath}`);
+        }
+        const source = await fs2.readFile(fullPath, "utf-8");
+        const compiled = this.handlebars.compile(source);
+        this.templateCache.set(templatePath, compiled);
+        return compiled;
+      }
+      /**
+       * Clear template cache
+       */
+      clearCache() {
+        this.templateCache.clear();
+      }
+    };
+  }
+});
+
+// src/generator/file-writer.ts
+var path3, fs3, FileWriter;
+var init_file_writer = __esm({
+  "src/generator/file-writer.ts"() {
+    "use strict";
+    init_cjs_shims();
+    path3 = __toESM(require("path"));
+    fs3 = __toESM(require("fs-extra"));
+    FileWriter = class {
+      writtenFiles = [];
+      backups = /* @__PURE__ */ new Map();
+      /**
+       * Write a file to disk
+       */
+      async writeFile(filePath, content, options = {}) {
+        const { overwrite = false, backup = true } = options;
+        const exists = await fs3.pathExists(filePath);
+        if (exists && !overwrite) {
+          throw new Error(`File already exists: ${filePath}`);
+        }
+        if (exists && backup) {
+          await this.createBackup(filePath);
+        }
+        await fs3.ensureDir(path3.dirname(filePath));
+        await fs3.writeFile(filePath, content, "utf-8");
+        this.writtenFiles.push(filePath);
+      }
+      /**
+       * Create a backup of an existing file
+       */
+      async createBackup(filePath) {
+        const backupPath = `${filePath}.backup`;
+        await fs3.copy(filePath, backupPath);
+        this.backups.set(filePath, backupPath);
+      }
+      /**
+       * Rollback all written files
+       */
+      async rollback() {
+        for (const [originalPath, backupPath] of this.backups) {
+          if (await fs3.pathExists(backupPath)) {
+            await fs3.copy(backupPath, originalPath, { overwrite: true });
+            await fs3.remove(backupPath);
+          }
+        }
+        for (const filePath of this.writtenFiles) {
+          if (!this.backups.has(filePath) && await fs3.pathExists(filePath)) {
+            await fs3.remove(filePath);
+          }
+        }
+        this.writtenFiles = [];
+        this.backups.clear();
+      }
+      /**
+       * Clean up backups
+       */
+      async cleanupBackups() {
+        for (const backupPath of this.backups.values()) {
+          if (await fs3.pathExists(backupPath)) {
+            await fs3.remove(backupPath);
+          }
+        }
+        this.backups.clear();
+      }
+      /**
+       * Get list of written files
+       */
+      getWrittenFiles() {
+        return [...this.writtenFiles];
+      }
+    };
+  }
+});
+
+// src/config/config-builder.ts
+function buildTemplateContext(config) {
+  return {
+    ...config
+    // Add any additional computed properties here
+  };
+}
+var init_config_builder = __esm({
+  "src/config/config-builder.ts"() {
+    "use strict";
+    init_cjs_shims();
+  }
+});
+
+// src/generator/generator.ts
+var path4, Generator;
+var init_generator = __esm({
+  "src/generator/generator.ts"() {
+    "use strict";
+    init_cjs_shims();
+    path4 = __toESM(require("path"));
+    init_template_engine();
+    init_file_writer();
+    init_config_builder();
+    Generator = class {
+      templateEngine;
+      fileWriter;
+      constructor() {
+        this.templateEngine = new TemplateEngine();
+        this.fileWriter = new FileWriter();
+      }
+      /**
+       * Generate all authentication files
+       */
+      async generate(config, projectInfo) {
+        try {
+          const context = buildTemplateContext(config);
+          const plan = this.buildGenerationPlan(config);
+          for (const fileSpec of plan) {
+            if (fileSpec.condition && !fileSpec.condition(config)) {
+              continue;
+            }
+            const content = await this.templateEngine.render(
+              fileSpec.template,
+              context
+            );
+            const outputPath = path4.join(projectInfo.root, fileSpec.output);
+            await this.fileWriter.writeFile(outputPath, content, {
+              overwrite: false
+            });
+          }
+          const filesCreated = this.fileWriter.getWrittenFiles();
+          await this.fileWriter.cleanupBackups();
+          return {
+            filesCreated,
+            success: true
+          };
+        } catch (error) {
+          await this.fileWriter.rollback();
+          return {
+            filesCreated: [],
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown error"
+          };
+        }
+      }
+      /**
+       * Build file generation plan
+       */
+      buildGenerationPlan(config) {
+        const plan = [];
+        plan.push(
+          { template: "jwt/auth.module.ts.hbs", output: `${config.sourceRoot}/auth/auth.module.ts` },
+          { template: "jwt/auth.service.ts.hbs", output: `${config.sourceRoot}/auth/auth.service.ts` },
+          { template: "jwt/auth.controller.ts.hbs", output: `${config.sourceRoot}/auth/auth.controller.ts` }
+        );
+        plan.push(
+          { template: "jwt/jwt.strategy.ts.hbs", output: `${config.sourceRoot}/auth/strategies/jwt.strategy.ts` },
+          { template: "jwt/local.strategy.ts.hbs", output: `${config.sourceRoot}/auth/strategies/local.strategy.ts` }
+        );
+        plan.push(
+          { template: "jwt/jwt-auth.guard.ts.hbs", output: `${config.sourceRoot}/auth/guards/jwt-auth.guard.ts` },
+          { template: "jwt/local-auth.guard.ts.hbs", output: `${config.sourceRoot}/auth/guards/local-auth.guard.ts` }
+        );
+        if (config.rbac.enabled) {
+          plan.push(
+            { template: "rbac/roles.guard.ts.hbs", output: `${config.sourceRoot}/auth/guards/roles.guard.ts` },
+            { template: "rbac/role.enum.ts.hbs", output: `${config.sourceRoot}/auth/enums/role.enum.ts` },
+            { template: "decorators/roles.decorator.ts.hbs", output: `${config.sourceRoot}/auth/decorators/roles.decorator.ts` }
+          );
+        }
+        plan.push(
+          { template: "decorators/public.decorator.ts.hbs", output: `${config.sourceRoot}/auth/decorators/public.decorator.ts` },
+          { template: "decorators/current-user.decorator.ts.hbs", output: `${config.sourceRoot}/auth/decorators/current-user.decorator.ts` }
+        );
+        plan.push(
+          { template: "dto/login.dto.ts.hbs", output: `${config.sourceRoot}/auth/dto/login.dto.ts` },
+          { template: "dto/register.dto.ts.hbs", output: `${config.sourceRoot}/auth/dto/register.dto.ts` },
+          { template: "dto/auth-response.dto.ts.hbs", output: `${config.sourceRoot}/auth/dto/auth-response.dto.ts` },
+          { template: "dto/create-user.dto.ts.hbs", output: `${config.sourceRoot}/auth/dto/create-user.dto.ts` }
+        );
+        plan.push(
+          { template: "users/users.module.ts.hbs", output: `${config.sourceRoot}/users/users.module.ts` },
+          { template: "users/users.service.ts.hbs", output: `${config.sourceRoot}/users/users.service.ts` },
+          { template: "users/users.controller.ts.hbs", output: `${config.sourceRoot}/users/users.controller.ts` }
+        );
+        if (config.orm === "typeorm") {
+          plan.push(
+            { template: "entities/user.entity.typeorm.hbs", output: `${config.sourceRoot}/users/entities/user.entity.ts` }
+          );
+          if (config.features.refreshTokens) {
+            plan.push({
+              template: "entities/refresh-token.entity.typeorm.hbs",
+              output: `${config.sourceRoot}/users/entities/refresh-token.entity.ts`
+            });
+          }
+        }
+        plan.push(
+          { template: "shared/env.template.hbs", output: ".env.example" },
+          { template: "shared/README.auth.md.hbs", output: `${config.sourceRoot}/auth/README.md` }
+        );
+        return plan;
+      }
+    };
+  }
+});
+
+// src/generator/index.ts
+var generator_exports = {};
+__export(generator_exports, {
+  FileWriter: () => FileWriter,
+  Generator: () => Generator,
+  TemplateEngine: () => TemplateEngine
+});
+var init_generator2 = __esm({
+  "src/generator/index.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_generator();
+    init_template_engine();
+    init_file_writer();
+  }
+});
+
+// src/installer/ast-updater.ts
+var import_ts_morph, fs4, AppModuleUpdater;
+var init_ast_updater = __esm({
+  "src/installer/ast-updater.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_ts_morph = require("ts-morph");
+    fs4 = __toESM(require("fs-extra"));
+    AppModuleUpdater = class {
+      constructor(appModulePath) {
+        this.appModulePath = appModulePath;
+        this.project = new import_ts_morph.Project({
+          skipAddingFilesFromTsConfig: true
+        });
+      }
+      project;
+      sourceFile;
+      backupPath = null;
+      /**
+       * Update app.module.ts with auth modules
+       */
+      async update() {
+        await this.createBackup();
+        try {
+          this.sourceFile = this.project.addSourceFileAtPath(this.appModulePath);
+          this.addImports();
+          this.addModulesToDecorator();
+          await this.sourceFile.save();
+        } catch (error) {
+          await this.restoreBackup();
+          throw error;
+        }
+      }
+      /**
+       * Add necessary imports
+       */
+      addImports() {
+        if (!this.sourceFile) {
+          throw new Error("Source file not loaded");
+        }
+        this.addImport("@nestjs/config", ["ConfigModule"]);
+        this.addImport("./auth/auth.module", ["AuthModule"]);
+        this.addImport("./users/users.module", ["UsersModule"]);
+      }
+      /**
+       * Add an import statement if it doesn't exist
+       */
+      addImport(moduleSpecifier, namedImports) {
+        if (!this.sourceFile) return;
+        const existingImport = this.sourceFile.getImportDeclarations().find((imp) => imp.getModuleSpecifierValue() === moduleSpecifier);
+        if (existingImport) {
+          const existingNames = existingImport.getNamedImports().map((ni) => ni.getName());
+          const missingImports = namedImports.filter(
+            (name) => !existingNames.includes(name)
+          );
+          if (missingImports.length > 0) {
+            existingImport.addNamedImports(missingImports);
+          }
+        } else {
+          this.sourceFile.addImportDeclaration({
+            moduleSpecifier,
+            namedImports
+          });
+        }
+      }
+      /**
+       * Add modules to @Module decorator imports array
+       */
+      addModulesToDecorator() {
+        if (!this.sourceFile) return;
+        const appModuleClass = this.sourceFile.getClass("AppModule");
+        if (!appModuleClass) {
+          throw new Error("AppModule class not found");
+        }
+        const moduleDecorator = appModuleClass.getDecorator("Module");
+        if (!moduleDecorator) {
+          throw new Error("@Module decorator not found");
+        }
+        const decoratorArgs = moduleDecorator.getArguments()[0];
+        if (!decoratorArgs || !import_ts_morph.Node.isObjectLiteralExpression(decoratorArgs)) {
+          throw new Error("Invalid @Module decorator structure");
+        }
+        let importsProperty = decoratorArgs.getProperty("imports");
+        if (!importsProperty) {
+          decoratorArgs.addPropertyAssignment({
+            name: "imports",
+            initializer: "[]"
+          });
+          importsProperty = decoratorArgs.getProperty("imports");
+        }
+        if (!importsProperty || !import_ts_morph.Node.isPropertyAssignment(importsProperty)) {
+          throw new Error("Invalid imports property");
+        }
+        const importsArray = importsProperty.getInitializer();
+        if (!import_ts_morph.Node.isArrayLiteralExpression(importsArray)) {
+          throw new Error("imports is not an array");
+        }
+        const existingModules = this.getExistingModuleNames(importsArray);
+        if (!existingModules.has("ConfigModule")) {
+          importsArray.addElement("ConfigModule.forRoot({ isGlobal: true })");
+        }
+        if (!existingModules.has("AuthModule")) {
+          importsArray.addElement("AuthModule");
+        }
+        if (!existingModules.has("UsersModule")) {
+          importsArray.addElement("UsersModule");
+        }
+      }
+      /**
+       * Get existing module names from imports array
+       */
+      getExistingModuleNames(importsArray) {
+        const moduleNames = /* @__PURE__ */ new Set();
+        if (!import_ts_morph.Node.isArrayLiteralExpression(importsArray)) {
+          return moduleNames;
+        }
+        for (const element of importsArray.getElements()) {
+          const text = element.getText();
+          const match = text.match(/^(\w+)/);
+          if (match) {
+            moduleNames.add(match[1]);
+          }
+        }
+        return moduleNames;
+      }
+      /**
+       * Create backup of app.module.ts
+       */
+      async createBackup() {
+        this.backupPath = `${this.appModulePath}.backup`;
+        await fs4.copy(this.appModulePath, this.backupPath);
+      }
+      /**
+       * Restore backup
+       */
+      async restoreBackup() {
+        if (this.backupPath && await fs4.pathExists(this.backupPath)) {
+          await fs4.copy(this.backupPath, this.appModulePath, { overwrite: true });
+          await fs4.remove(this.backupPath);
+        }
+      }
+      /**
+       * Clean up backup
+       */
+      async cleanupBackup() {
+        if (this.backupPath && await fs4.pathExists(this.backupPath)) {
+          await fs4.remove(this.backupPath);
+        }
+      }
+    };
+  }
+});
+
+// src/installer/package-updater.ts
+var fs5, PackageUpdater;
+var init_package_updater = __esm({
+  "src/installer/package-updater.ts"() {
+    "use strict";
+    init_cjs_shims();
+    fs5 = __toESM(require("fs-extra"));
+    PackageUpdater = class {
+      constructor(packageJsonPath) {
+        this.packageJsonPath = packageJsonPath;
+      }
+      backupPath = null;
+      /**
+       * Update package.json with auth dependencies
+       */
+      async update(config) {
+        await this.createBackup();
+        try {
+          const packageJson = await fs5.readJSON(this.packageJsonPath);
+          const deps = this.getDependencies(config);
+          packageJson.dependencies = {
+            ...packageJson.dependencies,
+            ...deps.dependencies
+          };
+          packageJson.devDependencies = {
+            ...packageJson.devDependencies,
+            ...deps.devDependencies
+          };
+          packageJson.dependencies = this.sortObject(packageJson.dependencies);
+          packageJson.devDependencies = this.sortObject(
+            packageJson.devDependencies
+          );
+          await fs5.writeJSON(this.packageJsonPath, packageJson, { spaces: 2 });
+        } catch (error) {
+          await this.restoreBackup();
+          throw error;
+        }
+      }
+      /**
+       * Get dependencies based on configuration
+       */
+      getDependencies(config) {
+        const dependencies = {
+          "@nestjs/jwt": "^11.0.0",
+          "@nestjs/passport": "^11.0.0",
+          "@nestjs/config": "^3.0.0",
+          passport: "^0.7.0",
+          "passport-jwt": "^4.0.1",
+          "passport-local": "^1.0.0",
+          bcrypt: "^5.1.1",
+          "class-validator": "^0.14.0",
+          "class-transformer": "^0.5.1"
+        };
+        const devDependencies = {
+          "@types/passport-jwt": "^4.0.0",
+          "@types/passport-local": "^1.0.36",
+          "@types/bcrypt": "^5.0.2"
+        };
+        if (config.orm === "typeorm") {
+          dependencies["@nestjs/typeorm"] = "^11.0.0";
+          dependencies["typeorm"] = "^0.3.20";
+          switch (config.database) {
+            case "postgres":
+              dependencies["pg"] = "^8.11.3";
+              break;
+            case "mysql":
+              dependencies["mysql2"] = "^3.9.1";
+              break;
+            case "sqlite":
+              dependencies["sqlite3"] = "^5.1.7";
+              break;
+            case "mongodb":
+              dependencies["mongodb"] = "^6.3.0";
+              break;
+          }
+        }
+        return { dependencies, devDependencies };
+      }
+      /**
+       * Sort object keys alphabetically
+       */
+      sortObject(obj) {
+        return Object.keys(obj).sort().reduce((sorted, key) => {
+          sorted[key] = obj[key];
+          return sorted;
+        }, {});
+      }
+      /**
+       * Create backup
+       */
+      async createBackup() {
+        this.backupPath = `${this.packageJsonPath}.backup`;
+        await fs5.copy(this.packageJsonPath, this.backupPath);
+      }
+      /**
+       * Restore backup
+       */
+      async restoreBackup() {
+        if (this.backupPath && await fs5.pathExists(this.backupPath)) {
+          await fs5.copy(this.backupPath, this.packageJsonPath, { overwrite: true });
+          await fs5.remove(this.backupPath);
+        }
+      }
+      /**
+       * Clean up backup
+       */
+      async cleanupBackup() {
+        if (this.backupPath && await fs5.pathExists(this.backupPath)) {
+          await fs5.remove(this.backupPath);
+        }
+      }
+    };
+  }
+});
+
+// src/installer/dependency-installer.ts
+var import_execa, import_detect_package_manager, DependencyInstaller;
+var init_dependency_installer = __esm({
+  "src/installer/dependency-installer.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_execa = require("execa");
+    import_detect_package_manager = require("detect-package-manager");
+    DependencyInstaller = class {
+      /**
+       * Install dependencies using the detected package manager
+       */
+      async install(cwd) {
+        const packageManager = await this.detectPackageManager(cwd);
+        console.log(`\u{1F4E6} Installing dependencies with ${packageManager}...`);
+        try {
+          await (0, import_execa.execa)(packageManager, ["install"], {
+            cwd,
+            stdio: "inherit"
+          });
+          console.log("\u2705 Dependencies installed successfully");
+        } catch (error) {
+          throw new Error(
+            `Failed to install dependencies with ${packageManager}: ${error instanceof Error ? error.message : "Unknown error"}`
+          );
+        }
+      }
+      /**
+       * Detect which package manager is being used
+       */
+      async detectPackageManager(cwd) {
+        try {
+          return await (0, import_detect_package_manager.detect)({ cwd });
+        } catch (error) {
+          return "npm";
+        }
+      }
+    };
+  }
+});
+
+// src/installer/index.ts
+var installer_exports = {};
+__export(installer_exports, {
+  AppModuleUpdater: () => AppModuleUpdater,
+  DependencyInstaller: () => DependencyInstaller,
+  PackageUpdater: () => PackageUpdater
+});
+var init_installer = __esm({
+  "src/installer/index.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_ast_updater();
+    init_package_updater();
+    init_dependency_installer();
+  }
+});
+
+// src/cli.ts
+init_cjs_shims();
+
+// src/index.ts
+init_cjs_shims();
+
+// src/analyzer/index.ts
+init_cjs_shims();
+
+// src/analyzer/project-detector.ts
+init_cjs_shims();
+var path = __toESM(require("path"));
+var fs = __toESM(require("fs-extra"));
+
+// src/analyzer/orm-detector.ts
+init_cjs_shims();
+async function detectORM(packageJson) {
+  const dependencies = {
+    ...packageJson.dependencies,
+    ...packageJson.devDependencies
+  };
+  if (dependencies["@nestjs/typeorm"] || dependencies["typeorm"]) {
+    return "typeorm";
+  }
+  if (dependencies["@prisma/client"] || dependencies["prisma"]) {
+    return "prisma";
+  }
+  if (dependencies["@nestjs/mongoose"] || dependencies["mongoose"]) {
+    return "mongoose";
+  }
+  return "none";
+}
+
+// src/analyzer/project-detector.ts
+var ProjectDetector = class {
+  constructor(cwd) {
+    this.cwd = cwd;
+  }
+  /**
+   * Detect and validate a NestJS project
+   */
+  async detectProject() {
+    const errors = [];
+    const root = this.cwd;
+    const packageJsonPath = path.join(root, "package.json");
+    if (!await fs.pathExists(packageJsonPath)) {
+      errors.push("package.json not found");
+      return this.createInvalidProject(root, errors);
+    }
+    const packageJson = await this.readPackageJson(packageJsonPath);
+    if (!packageJson) {
+      errors.push("Failed to read package.json");
+      return this.createInvalidProject(root, errors);
+    }
+    const hasNestCore = packageJson.dependencies?.["@nestjs/core"];
+    const hasNestCommon = packageJson.dependencies?.["@nestjs/common"];
+    if (!hasNestCore || !hasNestCommon) {
+      errors.push("Not a NestJS project (missing @nestjs/core or @nestjs/common)");
+      return this.createInvalidProject(root, errors);
+    }
+    const nestCliConfigPath = path.join(root, "nest-cli.json");
+    const nestCliConfig = await this.readNestCliConfig(nestCliConfigPath);
+    const sourceRoot = nestCliConfig?.sourceRoot || "src";
+    const appModulePath = path.join(root, sourceRoot, "app.module.ts");
+    if (!await fs.pathExists(appModulePath)) {
+      errors.push(`app.module.ts not found at ${sourceRoot}/app.module.ts`);
+      return this.createInvalidProject(root, errors);
+    }
+    const orm = await detectORM(packageJson);
+    const authModulePath = path.join(root, sourceRoot, "auth");
+    if (await fs.pathExists(authModulePath)) {
+      errors.push("auth/ directory already exists (use --force to overwrite)");
+    }
+    return {
+      root,
+      sourceRoot,
+      appModulePath,
+      packageJsonPath,
+      nestCliConfigPath,
+      orm,
+      nestVersion: packageJson.dependencies?.["@nestjs/core"],
+      typescriptVersion: packageJson.devDependencies?.["typescript"],
+      isValid: errors.length === 0,
+      errors
+    };
+  }
+  /**
+   * Read and parse package.json
+   */
+  async readPackageJson(packageJsonPath) {
+    try {
+      const content = await fs.readFile(packageJsonPath, "utf-8");
+      return JSON.parse(content);
+    } catch (error) {
+      return null;
+    }
+  }
+  /**
+   * Read and parse nest-cli.json
+   */
+  async readNestCliConfig(nestCliConfigPath) {
+    try {
+      if (!await fs.pathExists(nestCliConfigPath)) {
+        return null;
+      }
+      const content = await fs.readFile(nestCliConfigPath, "utf-8");
+      return JSON.parse(content);
+    } catch (error) {
+      return null;
+    }
+  }
+  /**
+   * Create invalid project info object
+   */
+  createInvalidProject(root, errors) {
+    return {
+      root,
+      sourceRoot: "src",
+      appModulePath: path.join(root, "src", "app.module.ts"),
+      packageJsonPath: path.join(root, "package.json"),
+      nestCliConfigPath: path.join(root, "nest-cli.json"),
+      orm: "none",
+      isValid: false,
+      errors
+    };
+  }
+};
+async function detectProject(cwd = process.cwd()) {
+  const detector = new ProjectDetector(cwd);
+  return detector.detectProject();
+}
+
+// src/cli/prompts.ts
+init_cjs_shims();
+var import_inquirer = __toESM(require("inquirer"));
+
+// src/config/utils.ts
+init_cjs_shims();
+var import_crypto = require("crypto");
+function generateSecret(length = 32) {
+  return (0, import_crypto.randomBytes)(length).toString("base64");
+}
+
+// src/cli/prompts.ts
+async function promptConfig(detectedORM) {
+  const answers = await import_inquirer.default.prompt([
+    {
+      type: "list",
+      name: "strategy",
+      message: "Choose authentication strategy:",
+      choices: [
+        { name: "JWT Authentication (Recommended)", value: "jwt" },
+        { name: "OAuth 2.0 (Google, GitHub) [v1.1]", value: "oauth", disabled: true },
+        { name: "Session-based (Traditional) [v1.2]", value: "session", disabled: true }
+      ],
+      default: "jwt"
+    },
+    {
+      type: "confirm",
+      name: "enableRBAC",
+      message: "Enable Role-Based Access Control (RBAC)?",
+      default: true
+    },
+    {
+      type: "checkbox",
+      name: "roles",
+      message: "Select default roles:",
+      choices: [
+        { name: "Admin", value: "Admin", checked: true },
+        { name: "User", value: "User", checked: true },
+        { name: "Moderator", value: "Moderator", checked: false },
+        { name: "Guest", value: "Guest", checked: false }
+      ],
+      when: (answers2) => answers2.enableRBAC,
+      validate: (input) => {
+        if (input.length === 0) {
+          return "Please select at least one role";
+        }
+        return true;
+      }
+    },
+    {
+      type: "confirm",
+      name: "refreshTokens",
+      message: "Enable Refresh Token rotation?",
+      default: true
+    },
+    {
+      type: "list",
+      name: "accessExpiration",
+      message: "JWT Access Token expiration:",
+      choices: [
+        { name: "15 minutes", value: "15m" },
+        { name: "30 minutes", value: "30m" },
+        { name: "1 hour (Recommended)", value: "1h" },
+        { name: "4 hours", value: "4h" },
+        { name: "1 day", value: "1d" }
+      ],
+      default: "1h"
+    },
+    {
+      type: "list",
+      name: "refreshExpiration",
+      message: "JWT Refresh Token expiration:",
+      choices: [
+        { name: "7 days (Recommended)", value: "7d" },
+        { name: "30 days", value: "30d" },
+        { name: "90 days", value: "90d" },
+        { name: "1 year", value: "1y" }
+      ],
+      default: "7d",
+      when: (answers2) => answers2.refreshTokens
+    },
+    {
+      type: "confirm",
+      name: "useDetectedORM",
+      message: `Detected ${detectedORM.toUpperCase()}${detectedORM === "typeorm" ? " with PostgreSQL" : ""}. Use it?`,
+      default: true,
+      when: () => detectedORM !== "none"
+    },
+    {
+      type: "list",
+      name: "database",
+      message: "Select database:",
+      choices: [
+        { name: "PostgreSQL (Recommended)", value: "postgres" },
+        { name: "MySQL", value: "mysql" },
+        { name: "SQLite (for testing)", value: "sqlite" },
+        { name: "MongoDB", value: "mongodb" }
+      ],
+      default: "postgres",
+      when: (answers2) => detectedORM === "none" || !answers2.useDetectedORM
+    },
+    {
+      type: "confirm",
+      name: "autoInstall",
+      message: "Auto-install dependencies after generation?",
+      default: true
+    }
+  ]);
+  return answers;
+}
+function buildConfig(answers, projectName, sourceRoot, detectedORM) {
+  const config = {
+    projectName,
+    sourceRoot,
+    strategy: answers.strategy,
+    rbac: {
+      enabled: answers.enableRBAC,
+      roles: answers.roles || []
+    },
+    orm: answers.useDetectedORM !== false ? detectedORM : "typeorm",
+    database: answers.database || "postgres",
+    features: {
+      refreshTokens: answers.refreshTokens
+    },
+    jwt: {
+      secret: generateSecret(),
+      accessExpiration: answers.accessExpiration,
+      refreshExpiration: answers.refreshExpiration || "7d"
+    },
+    autoInstall: answers.autoInstall,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    generatorVersion: "1.0.0"
+  };
+  return config;
+}
+
+// src/cli/ui.ts
+init_cjs_shims();
+var import_chalk = __toESM(require("chalk"));
+var import_ora = __toESM(require("ora"));
+function showBanner() {
+  console.log(import_chalk.default.cyan(`
+   ___         _   _       __  __
+  / _ \\       | | | |     |  \\/  |
+ / /_\\ \\_   _ | |_| |__   | \\  / | ___
+ |  _  | | | || __| '_ \\  | |\\/| |/ _ \\
+ | | | | |_| || |_| | | | | |  | |  __/
+ \\_| |_/\\__,_| \\__|_| |_| \\_|  |_/\\___|
+  `));
+  console.log(import_chalk.default.bold("\u{1F510} NestJS Authentication Module Generator v1.0.0"));
+  console.log();
+}
+function showProjectInfo(info) {
+  console.log(import_chalk.default.green("\u2713"), `Detected NestJS ${info.nestVersion || "project"}`);
+  if (info.orm !== "none") {
+    console.log(import_chalk.default.green("\u2713"), `Found ${info.orm.toUpperCase()}`);
+  }
+  console.log(import_chalk.default.green("\u2713"), `Source directory: ${info.sourceRoot}/`);
+  console.log(import_chalk.default.green("\u2713"), "No existing auth module found");
+  console.log();
+}
+function showError(message, errors) {
+  console.log();
+  console.log(import_chalk.default.red("\u274C Error:"), import_chalk.default.bold(message));
+  if (errors && errors.length > 0) {
+    console.log();
+    errors.forEach((error) => {
+      console.log(import_chalk.default.red("  \u2022"), error);
+    });
+  }
+  console.log();
+}
+function showNestJSHelp() {
+  console.log(import_chalk.default.yellow("To create a new NestJS project:"));
+  console.log();
+  console.log(import_chalk.default.cyan("  npm i -g @nestjs/cli"));
+  console.log(import_chalk.default.cyan("  nest new my-project"));
+  console.log();
+}
+function showSuccess(stats) {
+  console.log();
+  console.log(import_chalk.default.green.bold("\u{1F389} Success!"), "Authentication module generated.");
+  console.log();
+  console.log(import_chalk.default.bold("\u{1F4C1} Files created:"));
+  console.log(`   \u2022 ${stats.filesCreated} new files in src/auth/ and src/users/`);
+  console.log(`   \u2022 Updated src/app.module.ts`);
+  console.log(`   \u2022 Updated package.json`);
+  console.log();
+  console.log(import_chalk.default.bold("\u{1F4E6} Dependencies added:"));
+  console.log(`   \u2022 @nestjs/jwt, @nestjs/passport, @nestjs/config`);
+  console.log(`   \u2022 passport, passport-jwt, passport-local`);
+  console.log(`   \u2022 bcrypt, class-validator, class-transformer`);
+  console.log(`   \u2022 ${stats.dependenciesAdded} packages total`);
+  console.log();
+  console.log(import_chalk.default.bold("\u{1F510} JWT Configuration:"));
+  console.log(`   \u2022 Access token: ${stats.jwt.accessExpiration}`);
+  if (stats.jwt.refreshExpiration) {
+    console.log(`   \u2022 Refresh token: ${stats.jwt.refreshExpiration}`);
+  }
+  console.log(`   \u2022 Secret: Auto-generated (see .env.example)`);
+  console.log();
+  console.log(import_chalk.default.bold("\u{1F4CB} Next steps:"));
+  console.log(import_chalk.default.cyan("   1. Copy .env.example to .env"));
+  console.log(import_chalk.default.gray("      cp .env.example .env"));
+  console.log();
+  console.log(import_chalk.default.cyan("   2. Update JWT_SECRET in .env (or keep auto-generated)"));
+  console.log();
+  console.log(import_chalk.default.cyan("   3. Create database migration (if using TypeORM)"));
+  console.log(import_chalk.default.gray("      npm run migration:generate -- src/migrations/CreateUserTable"));
+  console.log(import_chalk.default.gray("      npm run migration:run"));
+  console.log();
+  console.log(import_chalk.default.cyan("   4. Start your NestJS app"));
+  console.log(import_chalk.default.gray("      npm run start:dev"));
+  console.log();
+  console.log(import_chalk.default.cyan("   5. Test authentication endpoints"));
+  console.log(import_chalk.default.gray("      POST http://localhost:3000/auth/register"));
+  console.log(import_chalk.default.gray("      POST http://localhost:3000/auth/login"));
+  console.log(import_chalk.default.gray("      GET  http://localhost:3000/users/profile (requires JWT)"));
+  console.log();
+  console.log(import_chalk.default.bold("\u{1F4D6} Full documentation:"), "src/auth/README.md");
+  console.log();
+  console.log(import_chalk.default.bold("\u{1F4A1} Tips:"));
+  console.log("   \u2022 Use @Public() decorator for routes that don't require auth");
+  console.log("   \u2022 Use @Roles('Admin') to restrict routes by role");
+  console.log("   \u2022 Access current user with @CurrentUser() decorator");
+  console.log();
+}
+function createSpinner(text) {
+  return (0, import_ora.default)({
+    text,
+    color: "cyan"
+  });
+}
+
+// src/index.ts
+async function run(cwd = process.cwd()) {
+  showBanner();
+  const spinner = createSpinner("Analyzing project...").start();
+  const projectInfo = await detectProject(cwd);
+  if (!projectInfo.isValid) {
+    spinner.fail("Project validation failed");
+    showError("Not a valid NestJS project", projectInfo.errors);
+    showNestJSHelp();
+    process.exit(1);
+  }
+  spinner.succeed("Project analyzed");
+  showProjectInfo({
+    nestVersion: projectInfo.nestVersion,
+    orm: projectInfo.orm,
+    sourceRoot: projectInfo.sourceRoot
+  });
+  const answers = await promptConfig(projectInfo.orm);
+  const config = buildConfig(
+    answers,
+    projectInfo.root.split(/[/\\]/).pop() || "project",
+    projectInfo.sourceRoot,
+    projectInfo.orm
+  );
+  console.log();
+  console.log("\u2699\uFE0F  Generating authentication module...");
+  console.log();
+  const { Generator: Generator2 } = await Promise.resolve().then(() => (init_generator2(), generator_exports));
+  const generator = new Generator2();
+  const genSpinner = createSpinner("Generating files from templates...").start();
+  const result = await generator.generate(config, projectInfo);
+  if (!result.success) {
+    genSpinner.fail("Generation failed");
+    showError("Failed to generate files", [result.error || "Unknown error"]);
+    process.exit(1);
+  }
+  genSpinner.succeed(`Generated ${result.filesCreated.length} files`);
+  const astSpinner = createSpinner("Updating app.module.ts...").start();
+  try {
+    const { AppModuleUpdater: AppModuleUpdater2 } = await Promise.resolve().then(() => (init_installer(), installer_exports));
+    const astUpdater = new AppModuleUpdater2(projectInfo.appModulePath);
+    await astUpdater.update();
+    await astUpdater.cleanupBackup();
+    astSpinner.succeed("Updated app.module.ts");
+  } catch (error) {
+    astSpinner.fail("Failed to update app.module.ts");
+    showError(
+      "AST modification failed",
+      [error instanceof Error ? error.message : "Unknown error"]
+    );
+    process.exit(1);
+  }
+  const pkgSpinner = createSpinner("Updating package.json...").start();
+  try {
+    const { PackageUpdater: PackageUpdater2 } = await Promise.resolve().then(() => (init_installer(), installer_exports));
+    const pkgUpdater = new PackageUpdater2(projectInfo.packageJsonPath);
+    await pkgUpdater.update(config);
+    await pkgUpdater.cleanupBackup();
+    pkgSpinner.succeed("Updated package.json");
+  } catch (error) {
+    pkgSpinner.fail("Failed to update package.json");
+    showError(
+      "Package update failed",
+      [error instanceof Error ? error.message : "Unknown error"]
+    );
+    process.exit(1);
+  }
+  if (config.autoInstall) {
+    const installSpinner = createSpinner("Installing dependencies...").start();
+    try {
+      const { DependencyInstaller: DependencyInstaller2 } = await Promise.resolve().then(() => (init_installer(), installer_exports));
+      const installer = new DependencyInstaller2();
+      await installer.install(projectInfo.root);
+      installSpinner.succeed("Dependencies installed");
+    } catch (error) {
+      installSpinner.fail("Failed to install dependencies");
+      console.log(
+        "\n\u26A0\uFE0F  Please run npm install manually to install dependencies\n"
+      );
+    }
+  }
+  showSuccess({
+    filesCreated: result.filesCreated.length,
+    dependenciesAdded: 8,
+    jwt: {
+      accessExpiration: config.jwt.accessExpiration,
+      refreshExpiration: config.features.refreshTokens ? config.jwt.refreshExpiration : void 0
+    }
+  });
+  console.log("\u{1F41B} Issues? https://github.com/yourusername/add-nest-auth/issues");
+  console.log("\u2B50 Like it? https://github.com/yourusername/add-nest-auth");
+  console.log();
+}
+
+// src/cli.ts
+process.on("unhandledRejection", (error) => {
+  console.error("Unhandled rejection:", error);
+  process.exit(1);
+});
+run().catch((error) => {
+  console.error("Fatal error:", error);
+  process.exit(1);
+});
+//# sourceMappingURL=cli.js.map