nest-authme 1.0.0

package/dist/cli.js

@@ -0,0 +1,1619 @@
+"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/analyzer/orm-detector.ts
+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";
+}
+function detectDatabase(packageJson, orm) {
+  const dependencies = {
+    ...packageJson.dependencies,
+    ...packageJson.devDependencies
+  };
+  if (orm === "typeorm") {
+    if (dependencies["pg"]) return "postgres";
+    if (dependencies["mysql2"] || dependencies["mysql"]) return "mysql";
+    if (dependencies["sqlite3"]) return "sqlite";
+    if (dependencies["mongodb"]) return "mongodb";
+  }
+  if (orm === "prisma") {
+    return void 0;
+  }
+  if (orm === "mongoose") {
+    return "mongodb";
+  }
+  return void 0;
+}
+var init_orm_detector = __esm({
+  "src/analyzer/orm-detector.ts"() {
+    "use strict";
+    init_cjs_shims();
+  }
+});
+
+// src/analyzer/project-detector.ts
+async function detectProject(cwd = process.cwd()) {
+  const detector = new ProjectDetector(cwd);
+  return detector.detectProject();
+}
+var path, fs, ProjectDetector;
+var init_project_detector = __esm({
+  "src/analyzer/project-detector.ts"() {
+    "use strict";
+    init_cjs_shims();
+    path = __toESM(require("path"));
+    fs = __toESM(require("fs-extra"));
+    init_orm_detector();
+    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 mainTsPath = path.join(root, sourceRoot, "main.ts");
+        const orm = await detectORM(packageJson);
+        const database = detectDatabase(packageJson, orm);
+        const authModulePath = path.join(root, sourceRoot, "auth");
+        const authExists = await fs.pathExists(authModulePath);
+        return {
+          authExists,
+          root,
+          sourceRoot,
+          appModulePath,
+          mainTsPath,
+          packageJsonPath,
+          nestCliConfigPath,
+          orm,
+          database,
+          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"),
+          mainTsPath: path.join(root, "src", "main.ts"),
+          packageJsonPath: path.join(root, "package.json"),
+          nestCliConfigPath: path.join(root, "nest-cli.json"),
+          orm: "none",
+          isValid: false,
+          errors
+        };
+      }
+    };
+  }
+});
+
+// src/analyzer/index.ts
+var init_analyzer = __esm({
+  "src/analyzer/index.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_project_detector();
+    init_orm_detector();
+  }
+});
+
+// src/config/utils.ts
+function generateSecret(length = 32) {
+  return (0, import_crypto.randomBytes)(length).toString("base64");
+}
+var import_crypto;
+var init_utils = __esm({
+  "src/config/utils.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_crypto = require("crypto");
+  }
+});
+
+// src/cli/prompts.ts
+async function promptConfig(detectedORM, detectedDB) {
+  const dbLabel = detectedDB ? ` with ${detectedDB.charAt(0).toUpperCase() + detectedDB.slice(1)}` : "";
+  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) [Coming soon]", value: "oauth", disabled: true },
+        { name: "Session-based (Traditional) [Coming soon]", 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: "enableRateLimiting",
+      message: "Enable rate limiting on auth endpoints? (recommended)",
+      default: true
+    },
+    {
+      type: "confirm",
+      name: "enableSwagger",
+      message: "Enable Swagger API documentation? (recommended)",
+      default: true
+    },
+    {
+      type: "confirm",
+      name: "generateTests",
+      message: "Generate unit tests? (recommended)",
+      default: true
+    },
+    {
+      type: "confirm",
+      name: "useUsername",
+      message: "Add username field to user?",
+      default: false
+    },
+    {
+      type: "confirm",
+      name: "enableEmailVerification",
+      message: "Enable email verification?",
+      default: false
+    },
+    {
+      type: "confirm",
+      name: "enableResetPassword",
+      message: "Enable forgot/reset password?",
+      default: true
+    },
+    {
+      type: "confirm",
+      name: "useDetectedORM",
+      message: `Detected ${detectedORM.toUpperCase()}${dbLabel}. 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 getDefaultAnswers(detectedORM, detectedDB) {
+  return {
+    strategy: "jwt",
+    enableRBAC: true,
+    roles: ["Admin", "User"],
+    refreshTokens: true,
+    accessExpiration: "1h",
+    refreshExpiration: "7d",
+    enableRateLimiting: true,
+    enableSwagger: true,
+    generateTests: true,
+    useUsername: false,
+    enableEmailVerification: false,
+    enableResetPassword: true,
+    useDetectedORM: true,
+    database: detectedDB || "postgres",
+    autoInstall: true
+  };
+}
+function buildConfig(answers, projectName, sourceRoot, detectedORM, detectedDB) {
+  const config = {
+    projectName,
+    sourceRoot,
+    strategy: answers.strategy,
+    rbac: {
+      enabled: answers.enableRBAC,
+      roles: answers.roles || []
+    },
+    orm: answers.useDetectedORM !== false ? detectedORM : "none",
+    database: answers.database || detectedDB || "postgres",
+    features: {
+      refreshTokens: answers.refreshTokens,
+      rateLimiting: answers.enableRateLimiting,
+      swagger: answers.enableSwagger,
+      unitTests: answers.generateTests,
+      useUsername: answers.useUsername,
+      emailVerification: answers.enableEmailVerification,
+      resetPassword: answers.enableResetPassword
+    },
+    jwt: {
+      secret: generateSecret(),
+      accessExpiration: answers.accessExpiration,
+      refreshExpiration: answers.refreshExpiration || "7d"
+    },
+    autoInstall: answers.autoInstall,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    generatorVersion: "1.3.0"
+  };
+  return config;
+}
+var import_inquirer;
+var init_prompts = __esm({
+  "src/cli/prompts.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_inquirer = __toESM(require("inquirer"));
+    init_utils();
+  }
+});
+
+// src/cli/ui.ts
+function getVersion() {
+  try {
+    const packageJsonPath = (0, import_path.join)(__dirname, "../package.json");
+    const packageJson = JSON.parse((0, import_fs.readFileSync)(packageJsonPath, "utf-8"));
+    return packageJson.version;
+  } catch (error) {
+    return "1.0.0";
+  }
+}
+function showBanner() {
+  console.log(import_chalk.default.cyan(`
+     _         _   _     __  __
+    / \\  _   _| |_| |__ |  \\/  | ___
+   / _ \\| | | | __| '_ \\| |\\/| |/ _ \\
+  / ___ \\ |_| | |_| | | | |  | |  __/
+ /_/   \\_\\__,_|\\__|_| |_|_|  |_|\\___|
+  `));
+  console.log(import_chalk.default.bold(`\u{1F510} AuthMe - NestJS Auth Generator v${getVersion()}`));
+  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`);
+  if (stats.orm === "prisma") {
+    console.log(`   \u2022 @prisma/client, prisma`);
+  }
+  if (stats.swagger) {
+    console.log(`   \u2022 @nestjs/swagger`);
+  }
+  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)`);
+  console.log();
+  console.log(import_chalk.default.bold("\u{1F4CB} Next steps:"));
+  console.log(import_chalk.default.cyan("   1. Review .env file (auto-generated with secure secret)"));
+  console.log(import_chalk.default.gray("      # .env.example is also provided as a git-safe reference"));
+  console.log();
+  if (stats.orm === "prisma") {
+    console.log(import_chalk.default.cyan("   2. Add Prisma schema models (see prisma-schema-additions.prisma)"));
+    console.log(import_chalk.default.gray("      # Copy the models into your prisma/schema.prisma"));
+    console.log(import_chalk.default.gray("      npx prisma migrate dev --name add-auth-models"));
+    console.log(import_chalk.default.gray("      npx prisma generate"));
+  } else {
+    console.log(import_chalk.default.cyan("   2. 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("   3. Start your NestJS app"));
+  console.log(import_chalk.default.gray("      npm run start:dev"));
+  console.log();
+  console.log(import_chalk.default.cyan("   4. 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("      POST http://localhost:3000/auth/change-password (requires JWT)"));
+  if (stats.emailVerification) {
+    console.log(import_chalk.default.gray("      GET  http://localhost:3000/auth/verify-email?token=..."));
+    console.log(import_chalk.default.gray("      POST http://localhost:3000/auth/resend-verification"));
+  }
+  if (stats.resetPassword) {
+    console.log(import_chalk.default.gray("      POST http://localhost:3000/auth/forgot-password"));
+    console.log(import_chalk.default.gray("      POST http://localhost:3000/auth/reset-password"));
+  }
+  console.log(import_chalk.default.gray("      POST http://localhost:3000/auth/refresh"));
+  console.log(import_chalk.default.gray("      POST http://localhost:3000/auth/logout (requires JWT)"));
+  console.log(import_chalk.default.gray("      POST http://localhost:3000/auth/logout-all (requires JWT)"));
+  console.log(import_chalk.default.gray("      GET  http://localhost:3000/users/profile (requires JWT)"));
+  if (stats.swagger) {
+    console.log();
+    console.log(import_chalk.default.cyan("   5. View Swagger API documentation"));
+    console.log(import_chalk.default.gray("      http://localhost:3000/api"));
+  }
+  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");
+  if (stats.swagger) {
+    console.log("   \u2022 Visit /api for interactive Swagger documentation");
+  }
+  console.log();
+}
+function createSpinner(text) {
+  return (0, import_ora.default)({
+    text,
+    color: "cyan"
+  });
+}
+var import_chalk, import_ora, import_fs, import_path;
+var init_ui = __esm({
+  "src/cli/ui.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_chalk = __toESM(require("chalk"));
+    import_ora = __toESM(require("ora"));
+    import_fs = require("fs");
+    import_path = require("path");
+  }
+});
+
+// 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, "generator", "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("or", (a, b) => a || b);
+        this.handlebars.registerHelper("and", (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 = [];
+      skippedFiles = [];
+      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) {
+          this.skippedFiles.push(filePath);
+          return;
+        }
+        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];
+      }
+      /**
+       * Get list of skipped files (already existed)
+       */
+      getSkippedFiles() {
+        return [...this.skippedFiles];
+      }
+    };
+  }
+});
+
+// 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, overwrite = false) {
+        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
+            });
+          }
+          const filesCreated = this.fileWriter.getWrittenFiles();
+          const filesSkipped = this.fileWriter.getSkippedFiles();
+          await this.fileWriter.cleanupBackups();
+          return {
+            filesCreated,
+            filesSkipped,
+            success: true
+          };
+        } catch (error) {
+          await this.fileWriter.rollback();
+          return {
+            filesCreated: [],
+            filesSkipped: [],
+            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/change-password.dto.ts.hbs", output: `${config.sourceRoot}/auth/dto/change-password.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` }
+        );
+        if (config.features.resetPassword) {
+          plan.push(
+            { template: "dto/forgot-password.dto.ts.hbs", output: `${config.sourceRoot}/auth/dto/forgot-password.dto.ts` },
+            { template: "dto/reset-password.dto.ts.hbs", output: `${config.sourceRoot}/auth/dto/reset-password.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`
+            });
+          }
+        } else if (config.orm === "prisma") {
+          plan.push(
+            { template: "prisma/prisma.service.ts.hbs", output: `${config.sourceRoot}/prisma/prisma.service.ts` },
+            { template: "prisma/prisma.module.ts.hbs", output: `${config.sourceRoot}/prisma/prisma.module.ts` },
+            { template: "prisma/schema.prisma.additions.hbs", output: "prisma-schema-additions.prisma" }
+          );
+        }
+        if (config.features.unitTests) {
+          plan.push(
+            { template: "tests/auth.service.spec.ts.hbs", output: `${config.sourceRoot}/auth/auth.service.spec.ts` },
+            { template: "tests/auth.controller.spec.ts.hbs", output: `${config.sourceRoot}/auth/auth.controller.spec.ts` }
+          );
+        }
+        plan.push(
+          { template: "shared/env.template.hbs", output: ".env.example" },
+          { template: "shared/env.hbs", output: ".env" },
+          { template: "shared/README.auth.md.hbs", output: `${config.sourceRoot}/auth/README.md` },
+          { template: "shared/main.ts.snippet.hbs", output: "main.ts.example" }
+        );
+        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,
+          manipulationSettings: {
+            indentationText: import_ts_morph.IndentationText.TwoSpaces
+          }
+        });
+      }
+      project;
+      sourceFile;
+      backupPath = null;
+      /**
+       * Update app.module.ts with auth modules
+       */
+      async update(config) {
+        await this.createBackup();
+        try {
+          this.sourceFile = this.project.addSourceFileAtPath(this.appModulePath);
+          this.addImports(config);
+          this.addModulesToDecorator(config);
+          this.sourceFile.formatText();
+          await this.sourceFile.save();
+        } catch (error) {
+          await this.restoreBackup();
+          throw error;
+        }
+      }
+      /**
+       * Add necessary imports
+       */
+      addImports(config) {
+        if (!this.sourceFile) {
+          throw new Error("Source file not loaded");
+        }
+        this.addImport("@nestjs/config", ["ConfigModule"]);
+        if (config && config.orm === "typeorm") {
+          this.addImport("@nestjs/typeorm", ["TypeOrmModule"]);
+          this.addImport("./users/entities/user.entity", ["User"]);
+          if (config.features.refreshTokens) {
+            this.addImport("./users/entities/refresh-token.entity", ["RefreshToken"]);
+          }
+        } else if (config && config.orm === "prisma") {
+          this.addImport("./prisma/prisma.module", ["PrismaModule"]);
+        }
+        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(config) {
+        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);
+        const existingElements = importsArray.getElements().map((e) => e.getText());
+        const allElements = [...existingElements];
+        if (!existingModules.has("ConfigModule")) {
+          allElements.push("ConfigModule.forRoot({ isGlobal: true })");
+        }
+        if (config && config.orm === "typeorm" && !existingModules.has("TypeOrmModule")) {
+          const entities = config.features.refreshTokens ? "[User, RefreshToken]" : "[User]";
+          allElements.push(this.buildTypeOrmConfig(config.database, entities));
+        } else if (config && config.orm === "prisma" && !existingModules.has("PrismaModule")) {
+          allElements.push("PrismaModule");
+        }
+        if (!existingModules.has("AuthModule")) {
+          allElements.push("AuthModule");
+        }
+        if (!existingModules.has("UsersModule")) {
+          allElements.push("UsersModule");
+        }
+        const indent = "    ";
+        const formattedElements = allElements.map((el) => `${indent}${el}`).join(",\n");
+        const multiLineArray = `[
+${formattedElements},
+  ]`;
+        importsProperty.setInitializer(multiLineArray);
+      }
+      /**
+       * Build TypeORM.forRoot() configuration string based on database type
+       */
+      buildTypeOrmConfig(database, entities) {
+        switch (database) {
+          case "sqlite":
+            return `TypeOrmModule.forRoot({
+      type: 'sqlite',
+      database: 'database.sqlite',
+      entities: ${entities},
+      synchronize: true, // WARNING: disable in production!
+    })`;
+          case "mysql":
+            return `TypeOrmModule.forRoot({
+      type: 'mysql',
+      host: process.env.DATABASE_HOST || 'localhost',
+      port: parseInt(process.env.DATABASE_PORT || '3306'),
+      username: process.env.DATABASE_USER || 'root',
+      password: process.env.DATABASE_PASSWORD || '',
+      database: process.env.DATABASE_NAME || 'auth_db',
+      entities: ${entities},
+      synchronize: true, // WARNING: disable in production!
+    })`;
+          case "postgres":
+          default:
+            return `TypeOrmModule.forRoot({
+      type: 'postgres',
+      host: process.env.DATABASE_HOST || 'localhost',
+      port: parseInt(process.env.DATABASE_PORT || '5432'),
+      username: process.env.DATABASE_USER || 'postgres',
+      password: process.env.DATABASE_PASSWORD || 'postgres',
+      database: process.env.DATABASE_NAME || 'auth_db',
+      entities: ${entities},
+      synchronize: true, // WARNING: disable in production!
+    })`;
+        }
+      }
+      /**
+       * 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/main-ts-updater.ts
+var import_ts_morph2, fs5, MainTsUpdater;
+var init_main_ts_updater = __esm({
+  "src/installer/main-ts-updater.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_ts_morph2 = require("ts-morph");
+    fs5 = __toESM(require("fs-extra"));
+    MainTsUpdater = class {
+      constructor(mainTsPath) {
+        this.mainTsPath = mainTsPath;
+        this.project = new import_ts_morph2.Project({
+          skipAddingFilesFromTsConfig: true,
+          manipulationSettings: {
+            indentationText: import_ts_morph2.IndentationText.TwoSpaces
+          }
+        });
+      }
+      project;
+      sourceFile;
+      backupPath = null;
+      /**
+       * Update main.ts with global guards, validation pipe, and optionally Swagger
+       */
+      async update(config) {
+        if (!await fs5.pathExists(this.mainTsPath)) {
+          throw new Error(`main.ts not found at ${this.mainTsPath}`);
+        }
+        await this.createBackup();
+        try {
+          this.sourceFile = this.project.addSourceFileAtPath(this.mainTsPath);
+          this.addImports(config);
+          this.addGlobalGuardsAndPipes(config);
+          this.sourceFile.formatText();
+          await this.sourceFile.save();
+        } catch (error) {
+          await this.restoreBackup();
+          throw error;
+        }
+      }
+      /**
+       * Add necessary imports
+       */
+      addImports(config) {
+        if (!this.sourceFile) {
+          throw new Error("Source file not loaded");
+        }
+        this.addImport("@nestjs/core", ["Reflector"]);
+        this.addImport("@nestjs/common", ["ValidationPipe"]);
+        this.addImport("./auth/guards/jwt-auth.guard", ["JwtAuthGuard"]);
+        if (config?.features?.swagger) {
+          this.addImport("@nestjs/swagger", ["SwaggerModule", "DocumentBuilder"]);
+        }
+      }
+      /**
+       * 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 global guards and validation pipe to bootstrap function
+       */
+      addGlobalGuardsAndPipes(config) {
+        if (!this.sourceFile) return;
+        const bootstrapFunc = this.sourceFile.getFunction("bootstrap");
+        if (!bootstrapFunc) {
+          throw new Error("bootstrap function not found in main.ts");
+        }
+        const body = bootstrapFunc.getBody();
+        if (!body || !import_ts_morph2.Node.isBlock(body)) {
+          throw new Error("bootstrap function has no body");
+        }
+        const bodyText = body.getText();
+        if (bodyText.includes("useGlobalGuards") || bodyText.includes("JwtAuthGuard")) {
+          return;
+        }
+        const statements = body.getStatements();
+        let listenIndex = -1;
+        for (let i = 0; i < statements.length; i++) {
+          const text = statements[i].getText();
+          if (text.includes(".listen(") || text.includes(".listen (")) {
+            listenIndex = i;
+            break;
+          }
+        }
+        if (listenIndex === -1) {
+          listenIndex = statements.length;
+        }
+        const codeLines = [
+          "",
+          "// Enable global validation pipe",
+          "app.useGlobalPipes(",
+          "  new ValidationPipe({",
+          "    whitelist: true,",
+          "    forbidNonWhitelisted: true,",
+          "    transform: true,",
+          "  }),",
+          ");",
+          "",
+          "// Enable global JWT guard (all routes protected by default)",
+          "// Use @Public() decorator on routes that should be accessible without auth",
+          "const reflector = app.get(Reflector);",
+          "app.useGlobalGuards(new JwtAuthGuard(reflector));"
+        ];
+        if (config?.features?.swagger) {
+          codeLines.push(
+            "",
+            "// Swagger API documentation",
+            "const swaggerConfig = new DocumentBuilder()",
+            "  .setTitle('API Documentation')",
+            "  .setDescription('JWT Authentication API')",
+            "  .setVersion('1.0')",
+            "  .addBearerAuth()",
+            "  .build();",
+            "const document = SwaggerModule.createDocument(app, swaggerConfig);",
+            "SwaggerModule.setup('api', app, document);"
+          );
+        }
+        codeLines.push("");
+        const codeToInsert = codeLines.join("\n");
+        body.insertStatements(listenIndex, codeToInsert);
+      }
+      /**
+       * Create backup of main.ts
+       */
+      async createBackup() {
+        this.backupPath = `${this.mainTsPath}.backup`;
+        await fs5.copy(this.mainTsPath, this.backupPath);
+      }
+      /**
+       * Restore backup
+       */
+      async restoreBackup() {
+        if (this.backupPath && await fs5.pathExists(this.backupPath)) {
+          await fs5.copy(this.backupPath, this.mainTsPath, { 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/package-updater.ts
+var fs6, PackageUpdater;
+var init_package_updater = __esm({
+  "src/installer/package-updater.ts"() {
+    "use strict";
+    init_cjs_shims();
+    fs6 = __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 fs6.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 fs6.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": "^4.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;
+          }
+        }
+        if (config.orm === "prisma") {
+          dependencies["@prisma/client"] = "^6.0.0";
+          devDependencies["prisma"] = "^6.0.0";
+        }
+        if (config.features.rateLimiting) {
+          dependencies["@nestjs/throttler"] = "^6.0.0";
+        }
+        if (config.features.swagger) {
+          dependencies["@nestjs/swagger"] = "^11.0.0";
+        }
+        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 fs6.copy(this.packageJsonPath, this.backupPath);
+      }
+      /**
+       * Restore backup
+       */
+      async restoreBackup() {
+        if (this.backupPath && await fs6.pathExists(this.backupPath)) {
+          await fs6.copy(this.backupPath, this.packageJsonPath, { overwrite: true });
+          await fs6.remove(this.backupPath);
+        }
+      }
+      /**
+       * Clean up backup
+       */
+      async cleanupBackup() {
+        if (this.backupPath && await fs6.pathExists(this.backupPath)) {
+          await fs6.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,
+  MainTsUpdater: () => MainTsUpdater,
+  PackageUpdater: () => PackageUpdater
+});
+var init_installer = __esm({
+  "src/installer/index.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_ast_updater();
+    init_main_ts_updater();
+    init_package_updater();
+    init_dependency_installer();
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  run: () => run
+});
+async function run(cwd = process.cwd(), options = {}) {
+  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
+  });
+  if (projectInfo.authExists) {
+    if (options.yes) {
+      console.log("\n  auth/ directory already exists. Use interactive mode to overwrite.\n");
+      process.exit(0);
+    }
+    const inquirer2 = (await import("inquirer")).default;
+    const { overwrite } = await inquirer2.prompt([{
+      type: "confirm",
+      name: "overwrite",
+      message: "auth/ directory already exists. Overwrite existing files?",
+      default: false
+    }]);
+    if (!overwrite) {
+      console.log("\n\u23ED\uFE0F  Cancelled. Existing auth module unchanged.\n");
+      process.exit(0);
+    }
+  }
+  const answers = options.yes ? getDefaultAnswers(projectInfo.orm, projectInfo.database) : await promptConfig(projectInfo.orm, projectInfo.database);
+  const config = buildConfig(
+    answers,
+    projectInfo.root.split(/[/\\]/).pop() || "project",
+    projectInfo.sourceRoot,
+    projectInfo.orm,
+    projectInfo.database
+  );
+  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, !!projectInfo.authExists);
+  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`);
+  if (result.filesSkipped.length > 0) {
+    console.log(`  \u26A0\uFE0F  Skipped ${result.filesSkipped.length} existing file(s)`);
+  }
+  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(config);
+    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 mainSpinner = createSpinner("Updating main.ts with global guards...").start();
+  try {
+    const { MainTsUpdater: MainTsUpdater2 } = await Promise.resolve().then(() => (init_installer(), installer_exports));
+    const mainUpdater = new MainTsUpdater2(projectInfo.mainTsPath);
+    await mainUpdater.update(config);
+    await mainUpdater.cleanupBackup();
+    mainSpinner.succeed("Updated main.ts with global JWT guard");
+  } catch (error) {
+    mainSpinner.warn("Could not auto-update main.ts (see main.ts.example for manual setup)");
+  }
+  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
+    },
+    orm: config.orm,
+    swagger: config.features.swagger,
+    emailVerification: config.features.emailVerification,
+    resetPassword: config.features.resetPassword
+  });
+  console.log("\u{1F41B} Issues? https://github.com/Islamawad132/add-nest-auth/issues");
+  console.log("\u2B50 Like it? https://www.npmjs.com/package/nest-authme");
+  console.log();
+}
+var init_index = __esm({
+  "src/index.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_analyzer();
+    init_prompts();
+    init_ui();
+  }
+});
+
+// src/cli.ts
+init_cjs_shims();
+var import_commander = require("commander");
+process.on("unhandledRejection", (error) => {
+  console.error("Unhandled rejection:", error);
+  process.exit(1);
+});
+var program = new import_commander.Command();
+program.name("nest-authme").description("Add production-ready authentication to any NestJS project").version("1.1.0").option("-y, --yes", "Skip all prompts and use sensible defaults").action(async (options) => {
+  try {
+    const { run: run2 } = await Promise.resolve().then(() => (init_index(), index_exports));
+    await run2(process.cwd(), { yes: options.yes || false });
+  } catch (error) {
+    console.error("Fatal error:", error);
+    process.exit(1);
+  }
+});
+program.parse();
+//# sourceMappingURL=cli.js.map