nest-authme 1.2.4 → 1.3.0

package/dist/gui/orchestrator.js

@@ -37,6 +37,103 @@ var init_cjs_shims = __esm({
   }
 });
 
+// src/generator/template-engine.ts
+var import_handlebars, path, fs, TemplateEngine;
+var init_template_engine = __esm({
+  "src/generator/template-engine.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_handlebars = __toESM(require("handlebars"));
+    path = __toESM(require("path"));
+    fs = __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 || path.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 = path.join(this.templatesDir, templatePath);
+        if (!await fs.pathExists(fullPath)) {
+          throw new Error(`Template not found: ${templatePath}`);
+        }
+        const source = await fs.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/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/installer/ast-updater.ts
 var import_ts_morph, fs3, AppModuleUpdater;
 var init_ast_updater = __esm({
@@ -426,13 +523,139 @@ var init_main_ts_updater = __esm({
   }
 });
 
+// src/installer/prisma-schema-updater.ts
+var fs5, import_execa, PrismaSchemaUpdater;
+var init_prisma_schema_updater = __esm({
+  "src/installer/prisma-schema-updater.ts"() {
+    "use strict";
+    init_cjs_shims();
+    fs5 = __toESM(require("fs-extra"));
+    import_execa = require("execa");
+    init_template_engine();
+    init_config_builder();
+    PrismaSchemaUpdater = class {
+      constructor(schemaPath) {
+        this.schemaPath = schemaPath;
+      }
+      backupPath = null;
+      /**
+       * Update prisma/schema.prisma with auth models
+       */
+      async update(config) {
+        const exists = await fs5.pathExists(this.schemaPath);
+        if (!exists) {
+          return {
+            updated: false,
+            message: 'prisma/schema.prisma not found. Run "npx prisma init" first, then re-run nest-authme.',
+            skippedModels: []
+          };
+        }
+        const existingContent = await fs5.readFile(this.schemaPath, "utf-8");
+        const skippedModels = [];
+        const hasUser = /^\s*model\s+User\s*\{/m.test(existingContent);
+        const hasRefreshToken = /^\s*model\s+RefreshToken\s*\{/m.test(existingContent);
+        if (hasUser) {
+          skippedModels.push("User");
+        }
+        if (hasRefreshToken && config.features.refreshTokens) {
+          skippedModels.push("RefreshToken");
+        }
+        const needsUser = !hasUser;
+        const needsRefreshToken = config.features.refreshTokens && !hasRefreshToken;
+        if (!needsUser && !needsRefreshToken) {
+          return {
+            updated: false,
+            message: `Models already exist in schema.prisma: ${skippedModels.join(", ")}. Please check that your existing models have all required auth fields.`,
+            skippedModels
+          };
+        }
+        const templateEngine = new TemplateEngine();
+        const context = buildTemplateContext(config);
+        let modelsContent = await templateEngine.render("prisma/schema.prisma.models.hbs", context);
+        if (hasUser) {
+          modelsContent = modelsContent.replace(/model\s+User\s*\{[^}]*\}\n?/s, "");
+        }
+        if (hasRefreshToken) {
+          modelsContent = modelsContent.replace(/model\s+RefreshToken\s*\{[^}]*\}\n?/s, "");
+        }
+        modelsContent = modelsContent.replace(/\n{3,}/g, "\n\n").trim();
+        if (!modelsContent) {
+          return {
+            updated: false,
+            message: "No new models to add.",
+            skippedModels
+          };
+        }
+        await this.createBackup();
+        try {
+          const separator = "\n\n// === Auth models (added by nest-authme) ===\n\n";
+          const updatedContent = existingContent.trimEnd() + separator + modelsContent + "\n";
+          await fs5.writeFile(this.schemaPath, updatedContent, "utf-8");
+          await this.tryPrismaFormat();
+          const addedModels = [];
+          if (needsUser) addedModels.push("User");
+          if (needsRefreshToken) addedModels.push("RefreshToken");
+          let message = `Added ${addedModels.join(", ")} model(s) to prisma/schema.prisma`;
+          if (skippedModels.length > 0) {
+            message += `. Skipped existing: ${skippedModels.join(", ")} (check for missing auth fields)`;
+          }
+          return {
+            updated: true,
+            message,
+            skippedModels
+          };
+        } catch (error) {
+          await this.restoreBackup();
+          throw error;
+        }
+      }
+      /**
+       * Try to run prisma format for consistent indentation
+       */
+      async tryPrismaFormat() {
+        try {
+          await (0, import_execa.execa)("npx", ["prisma", "format"], {
+            cwd: this.schemaPath.replace(/[/\\]prisma[/\\]schema\.prisma$/, ""),
+            timeout: 15e3
+          });
+        } catch {
+        }
+      }
+      /**
+       * Create backup of schema.prisma
+       */
+      async createBackup() {
+        this.backupPath = `${this.schemaPath}.backup`;
+        await fs5.copy(this.schemaPath, this.backupPath);
+      }
+      /**
+       * Restore backup on failure
+       */
+      async restoreBackup() {
+        if (this.backupPath && await fs5.pathExists(this.backupPath)) {
+          await fs5.copy(this.backupPath, this.schemaPath, { overwrite: true });
+          await fs5.remove(this.backupPath);
+        }
+      }
+      /**
+       * Clean up backup after success
+       */
+      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;
@@ -444,7 +667,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,
@@ -458,7 +681,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;
@@ -540,23 +763,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);
         }
       }
     };
@@ -564,12 +787,12 @@ var init_package_updater = __esm({
 });
 
 // src/installer/dependency-installer.ts
-var import_execa, import_detect_package_manager, DependencyInstaller;
+var import_execa2, 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_execa2 = require("execa");
     import_detect_package_manager = require("detect-package-manager");
     DependencyInstaller = class {
       /**
@@ -579,7 +802,7 @@ var init_dependency_installer = __esm({
         const packageManager = await this.detectPackageManager(cwd);
         console.log(`\u{1F4E6} Installing dependencies with ${packageManager}...`);
         try {
-          await (0, import_execa.execa)(packageManager, ["install"], {
+          await (0, import_execa2.execa)(packageManager, ["install"], {
             cwd,
             stdio: "inherit"
           });
@@ -596,7 +819,7 @@ var init_dependency_installer = __esm({
       async installCapture(cwd) {
         const packageManager = await this.detectPackageManager(cwd);
         try {
-          const result = await (0, import_execa.execa)(packageManager, ["install"], {
+          const result = await (0, import_execa2.execa)(packageManager, ["install"], {
             cwd,
             stdio: "pipe"
           });
@@ -627,7 +850,8 @@ __export(installer_exports, {
   AppModuleUpdater: () => AppModuleUpdater,
   DependencyInstaller: () => DependencyInstaller,
   MainTsUpdater: () => MainTsUpdater,
-  PackageUpdater: () => PackageUpdater
+  PackageUpdater: () => PackageUpdater,
+  PrismaSchemaUpdater: () => PrismaSchemaUpdater
 });
 var init_installer = __esm({
   "src/installer/index.ts"() {
@@ -635,6 +859,7 @@ var init_installer = __esm({
     init_cjs_shims();
     init_ast_updater();
     init_main_ts_updater();
+    init_prisma_schema_updater();
     init_package_updater();
     init_dependency_installer();
   }
@@ -649,88 +874,12 @@ module.exports = __toCommonJS(orchestrator_exports);
 init_cjs_shims();
 var import_events = require("events");
 var path4 = __toESM(require("path"));
-var fs6 = __toESM(require("fs-extra"));
+var fs7 = __toESM(require("fs-extra"));
 
 // src/generator/generator.ts
 init_cjs_shims();
 var path3 = __toESM(require("path"));
-
-// src/generator/template-engine.ts
-init_cjs_shims();
-var import_handlebars = __toESM(require("handlebars"));
-var path = __toESM(require("path"));
-var fs = __toESM(require("fs-extra"));
-var TemplateEngine = class {
-  handlebars;
-  templateCache;
-  templatesDir;
-  constructor(templatesDir) {
-    this.handlebars = import_handlebars.default.create();
-    this.templateCache = /* @__PURE__ */ new Map();
-    this.templatesDir = templatesDir || path.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 = path.join(this.templatesDir, templatePath);
-    if (!await fs.pathExists(fullPath)) {
-      throw new Error(`Template not found: ${templatePath}`);
-    }
-    const source = await fs.readFile(fullPath, "utf-8");
-    const compiled = this.handlebars.compile(source);
-    this.templateCache.set(templatePath, compiled);
-    return compiled;
-  }
-  /**
-   * Clear template cache
-   */
-  clearCache() {
-    this.templateCache.clear();
-  }
-};
+init_template_engine();
 
 // src/generator/file-writer.ts
 init_cjs_shims();
@@ -808,16 +957,8 @@ var FileWriter = class {
   }
 };
 
-// src/config/config-builder.ts
-init_cjs_shims();
-function buildTemplateContext(config) {
-  return {
-    ...config
-    // Add any additional computed properties here
-  };
-}
-
 // src/generator/generator.ts
+init_config_builder();
 var Generator = class {
   templateEngine;
   fileWriter;
@@ -935,8 +1076,7 @@ var Generator = class {
     } 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" }
+        { template: "prisma/prisma.module.ts.hbs", output: `${config.sourceRoot}/prisma/prisma.module.ts` }
       );
     }
     if (config.features.emailService) {
@@ -962,6 +1102,8 @@ var Generator = class {
 };
 
 // src/gui/orchestrator.ts
+init_template_engine();
+init_config_builder();
 var GuiOrchestrator = class extends import_events.EventEmitter {
   constructor(_cwd) {
     super();
@@ -982,7 +1124,7 @@ var GuiOrchestrator = class extends import_events.EventEmitter {
     for (const spec of plan) {
       const content = await templateEngine.render(spec.template, context);
       const fullPath = path4.join(projectInfo.root, spec.output);
-      const exists = await fs6.pathExists(fullPath);
+      const exists = await fs7.pathExists(fullPath);
       files.push({
         path: spec.output,
         content,
@@ -994,6 +1136,12 @@ var GuiOrchestrator = class extends import_events.EventEmitter {
       { path: `${config.sourceRoot}/main.ts`, description: "Add global JWT guard, ValidationPipe, Swagger setup" },
       { path: "package.json", description: "Add authentication dependencies" }
     ];
+    if (config.orm === "prisma") {
+      modifiedFiles.push({
+        path: "prisma/schema.prisma",
+        description: "Append User and RefreshToken models"
+      });
+    }
     return {
       files,
       modifiedFiles,
@@ -1028,6 +1176,26 @@ var GuiOrchestrator = class extends import_events.EventEmitter {
       errors.push(msg);
       return { success: false, filesCreated: result.filesCreated, filesSkipped: result.filesSkipped, errors, warnings };
     }
+    if (config.orm === "prisma") {
+      this.emitProgress("prisma-schema", "Updating prisma/schema.prisma...", "started");
+      try {
+        const { PrismaSchemaUpdater: PrismaSchemaUpdater2 } = await Promise.resolve().then(() => (init_installer(), installer_exports));
+        const schemaPath = path4.join(projectInfo.root, "prisma", "schema.prisma");
+        const prismaUpdater = new PrismaSchemaUpdater2(schemaPath);
+        const prismaResult = await prismaUpdater.update(config);
+        if (prismaResult.updated) {
+          await prismaUpdater.cleanupBackup();
+          this.emitProgress("prisma-schema", prismaResult.message, "completed");
+        } else {
+          this.emitProgress("prisma-schema", prismaResult.message, "warning");
+          warnings.push(prismaResult.message);
+        }
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : "Unknown error";
+        this.emitProgress("prisma-schema", "Could not update prisma/schema.prisma", "warning", msg);
+        warnings.push("Could not update prisma/schema.prisma - add models manually");
+      }
+    }
     this.emitProgress("ast-main-ts", "Updating main.ts...", "started");
     try {
       const { MainTsUpdater: MainTsUpdater2 } = await Promise.resolve().then(() => (init_installer(), installer_exports));