add-nest-auth 1.0.5 → 1.0.7

package/README.md

@@ -359,9 +359,9 @@ If this tool helped you, please consider:
 
 ## 🔗 Links
 
-- **GitHub**: https://github.com/yourusername/add-nest-auth
+- **GitHub**: https://github.com/Islamawad132/add-nest-auth
 - **npm**: https://www.npmjs.com/package/add-nest-auth
-- **Issues**: https://github.com/yourusername/add-nest-auth/issues
+- **Issues**: https://github.com/Islamawad132/add-nest-auth/issues
 
 ---
 

package/dist/cli.js

@@ -127,6 +127,7 @@ var init_file_writer = __esm({
     fs3 = __toESM(require("fs-extra"));
     FileWriter = class {
       writtenFiles = [];
+      skippedFiles = [];
       backups = /* @__PURE__ */ new Map();
       /**
        * Write a file to disk
@@ -135,7 +136,8 @@ var init_file_writer = __esm({
         const { overwrite = false, backup = true } = options;
         const exists = await fs3.pathExists(filePath);
         if (exists && !overwrite) {
-          throw new Error(`File already exists: ${filePath}`);
+          this.skippedFiles.push(filePath);
+          return;
         }
         if (exists && backup) {
           await this.createBackup(filePath);
@@ -187,6 +189,12 @@ var init_file_writer = __esm({
       getWrittenFiles() {
         return [...this.writtenFiles];
       }
+      /**
+       * Get list of skipped files (already existed)
+       */
+      getSkippedFiles() {
+        return [...this.skippedFiles];
+      }
     };
   }
 });
@@ -243,15 +251,18 @@ var init_generator = __esm({
             });
           }
           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"
           };
@@ -357,12 +368,12 @@ var init_ast_updater = __esm({
       /**
        * Update app.module.ts with auth modules
        */
-      async update() {
+      async update(config) {
         await this.createBackup();
         try {
           this.sourceFile = this.project.addSourceFileAtPath(this.appModulePath);
-          this.addImports();
-          this.addModulesToDecorator();
+          this.addImports(config);
+          this.addModulesToDecorator(config);
           await this.sourceFile.save();
         } catch (error) {
           await this.restoreBackup();
@@ -372,11 +383,18 @@ var init_ast_updater = __esm({
       /**
        * Add necessary imports
        */
-      addImports() {
+      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"]);
+          }
+        }
         this.addImport("./auth/auth.module", ["AuthModule"]);
         this.addImport("./users/users.module", ["UsersModule"]);
       }
@@ -404,7 +422,7 @@ var init_ast_updater = __esm({
       /**
        * Add modules to @Module decorator imports array
        */
-      addModulesToDecorator() {
+      addModulesToDecorator(config) {
         if (!this.sourceFile) return;
         const appModuleClass = this.sourceFile.getClass("AppModule");
         if (!appModuleClass) {
@@ -437,6 +455,11 @@ var init_ast_updater = __esm({
         if (!existingModules.has("ConfigModule")) {
           importsArray.addElement("ConfigModule.forRoot({ isGlobal: true })");
         }
+        if (config && config.orm === "typeorm" && !existingModules.has("TypeOrmModule")) {
+          const entities = config.features.refreshTokens ? "[User, RefreshToken]" : "[User]";
+          const typeOrmConfig = this.buildTypeOrmConfig(config.database, entities);
+          importsArray.addElement(typeOrmConfig);
+        }
         if (!existingModules.has("AuthModule")) {
           importsArray.addElement("AuthModule");
         }
@@ -444,6 +467,43 @@ var init_ast_updater = __esm({
           importsArray.addElement("UsersModule");
         }
       }
+      /**
+       * 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
        */
@@ -489,13 +549,157 @@ var init_ast_updater = __esm({
   }
 });
 
+// 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
+        });
+      }
+      project;
+      sourceFile;
+      backupPath = null;
+      /**
+       * Update main.ts with global guards and validation pipe
+       */
+      async update() {
+        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();
+          this.addGlobalGuardsAndPipes();
+          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/core", ["Reflector"]);
+        this.addImport("@nestjs/common", ["ValidationPipe"]);
+        this.addImport("./auth/guards/jwt-auth.guard", ["JwtAuthGuard"]);
+      }
+      /**
+       * 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() {
+        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 codeToInsert = [
+          "",
+          "// 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));",
+          ""
+        ].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 fs5, PackageUpdater;
+var fs6, PackageUpdater;
 var init_package_updater = __esm({
   "src/installer/package-updater.ts"() {
     "use strict";
     init_cjs_shims();
-    fs5 = __toESM(require("fs-extra"));
+    fs6 = __toESM(require("fs-extra"));
     PackageUpdater = class {
       constructor(packageJsonPath) {
         this.packageJsonPath = packageJsonPath;
@@ -507,7 +711,7 @@ var init_package_updater = __esm({
       async update(config) {
         await this.createBackup();
         try {
-          const packageJson = await fs5.readJSON(this.packageJsonPath);
+          const packageJson = await fs6.readJSON(this.packageJsonPath);
           const deps = this.getDependencies(config);
           packageJson.dependencies = {
             ...packageJson.dependencies,
@@ -521,7 +725,7 @@ var init_package_updater = __esm({
           packageJson.devDependencies = this.sortObject(
             packageJson.devDependencies
           );
-          await fs5.writeJSON(this.packageJsonPath, packageJson, { spaces: 2 });
+          await fs6.writeJSON(this.packageJsonPath, packageJson, { spaces: 2 });
         } catch (error) {
           await this.restoreBackup();
           throw error;
@@ -581,23 +785,23 @@ var init_package_updater = __esm({
        */
       async createBackup() {
         this.backupPath = `${this.packageJsonPath}.backup`;
-        await fs5.copy(this.packageJsonPath, this.backupPath);
+        await fs6.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);
+        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 fs5.pathExists(this.backupPath)) {
-          await fs5.remove(this.backupPath);
+        if (this.backupPath && await fs6.pathExists(this.backupPath)) {
+          await fs6.remove(this.backupPath);
         }
       }
     };
@@ -650,6 +854,7 @@ var installer_exports = {};
 __export(installer_exports, {
   AppModuleUpdater: () => AppModuleUpdater,
   DependencyInstaller: () => DependencyInstaller,
+  MainTsUpdater: () => MainTsUpdater,
   PackageUpdater: () => PackageUpdater
 });
 var init_installer = __esm({
@@ -657,6 +862,7 @@ var init_installer = __esm({
     "use strict";
     init_cjs_shims();
     init_ast_updater();
+    init_main_ts_updater();
     init_package_updater();
     init_dependency_installer();
   }
@@ -694,6 +900,25 @@ async function detectORM(packageJson) {
   }
   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;
+}
 
 // src/analyzer/project-detector.ts
 var ProjectDetector = class {
@@ -730,7 +955,9 @@ var ProjectDetector = class {
       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");
     if (await fs.pathExists(authModulePath)) {
       errors.push("auth/ directory already exists (use --force to overwrite)");
@@ -739,9 +966,11 @@ var ProjectDetector = class {
       root,
       sourceRoot,
       appModulePath,
+      mainTsPath,
       packageJsonPath,
       nestCliConfigPath,
       orm,
+      database,
       nestVersion: packageJson.dependencies?.["@nestjs/core"],
       typescriptVersion: packageJson.devDependencies?.["typescript"],
       isValid: errors.length === 0,
@@ -781,6 +1010,7 @@ var ProjectDetector = class {
       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",
@@ -806,7 +1036,8 @@ function generateSecret(length = 32) {
 }
 
 // src/cli/prompts.ts
-async function promptConfig(detectedORM) {
+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",
@@ -878,7 +1109,7 @@ async function promptConfig(detectedORM) {
     {
       type: "confirm",
       name: "useDetectedORM",
-      message: `Detected ${detectedORM.toUpperCase()}${detectedORM === "typeorm" ? " with PostgreSQL" : ""}. Use it?`,
+      message: `Detected ${detectedORM.toUpperCase()}${dbLabel}. Use it?`,
       default: true,
       when: () => detectedORM !== "none"
     },
@@ -904,7 +1135,7 @@ async function promptConfig(detectedORM) {
   ]);
   return answers;
 }
-function buildConfig(answers, projectName, sourceRoot, detectedORM) {
+function buildConfig(answers, projectName, sourceRoot, detectedORM, detectedDB) {
   const config = {
     projectName,
     sourceRoot,
@@ -914,7 +1145,7 @@ function buildConfig(answers, projectName, sourceRoot, detectedORM) {
       roles: answers.roles || []
     },
     orm: answers.useDetectedORM !== false ? detectedORM : "typeorm",
-    database: answers.database || "postgres",
+    database: answers.database || detectedDB || "postgres",
     features: {
       refreshTokens: answers.refreshTokens
     },
@@ -1056,12 +1287,13 @@ async function run(cwd = process.cwd()) {
     orm: projectInfo.orm,
     sourceRoot: projectInfo.sourceRoot
   });
-  const answers = await promptConfig(projectInfo.orm);
+  const answers = await promptConfig(projectInfo.orm, projectInfo.database);
   const config = buildConfig(
     answers,
     projectInfo.root.split(/[/\\]/).pop() || "project",
     projectInfo.sourceRoot,
-    projectInfo.orm
+    projectInfo.orm,
+    projectInfo.database
   );
   console.log();
   console.log("\u2699\uFE0F  Generating authentication module...");
@@ -1076,11 +1308,14 @@ async function run(cwd = process.cwd()) {
     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();
+    await astUpdater.update(config);
     await astUpdater.cleanupBackup();
     astSpinner.succeed("Updated app.module.ts");
   } catch (error) {
@@ -1091,6 +1326,16 @@ async function run(cwd = process.cwd()) {
     );
     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();
+    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));
@@ -1128,8 +1373,8 @@ async function run(cwd = process.cwd()) {
       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("\u{1F41B} Issues? https://github.com/Islamawad132/add-nest-auth/issues");
+  console.log("\u2B50 Like it? https://github.com/Islamawad132/add-nest-auth");
   console.log();
 }