nest-authme 1.2.3 → 1.3.0

package/dist/generator/templates/jwt/auth.service.ts.hbs

@@ -1,5 +1,5 @@
 import { Injectable, UnauthorizedException{{#if features.resetPassword}}, BadRequestException{{/if}}{{#if features.emailVerification}}, NotFoundException{{/if}}{{#if features.accountLockout}}, ForbiddenException{{/if}} } from '@nestjs/common';
-{{#if (or features.emailVerification features.resetPassword)}}
+{{#if (or features.emailVerification features.resetPassword features.refreshTokens)}}
 import * as crypto from 'crypto';
 {{/if}}
 import { JwtService } from '@nestjs/jwt';
@@ -57,7 +57,7 @@ export class AuthService {
    * Validate user credentials
    */
   async validateUser(email: string, password: string): Promise<any> {
-    const user = await this.usersService.findByEmail(email);
+    const user = await this.usersService.findByEmail(email.toLowerCase());
     if (!user) {
       return null;
     }
@@ -152,7 +152,7 @@ export class AuthService {
     const hashedPassword = await bcrypt.hash(registerDto.password, bcryptRounds);
 
     const user = await this.usersService.create({
-      email: registerDto.email,
+      email: registerDto.email.toLowerCase(),
 {{#if features.useUsername}}
       username: registerDto.username,
 {{/if}}
@@ -244,6 +244,10 @@ export class AuthService {
    * Verify email with token
    */
   async verifyEmail(token: string): Promise<{ message: string }> {
+    if (!token) {
+      throw new NotFoundException('Invalid verification token');
+    }
+
     const user = await this.usersService.findByVerificationToken(token);
     if (!user) {
       throw new NotFoundException('Invalid verification token');
@@ -261,7 +265,7 @@ export class AuthService {
 {{else}}
   async resendVerification(email: string): Promise<{ verificationToken: string; message: string }> {
 {{/if}}
-    const user = await this.usersService.findByEmail(email);
+    const user = await this.usersService.findByEmail(email.toLowerCase());
     if (!user) {
       throw new NotFoundException('User not found');
     }
@@ -294,7 +298,7 @@ export class AuthService {
    */
 {{#if features.emailService}}
   async forgotPassword(forgotPasswordDto: ForgotPasswordDto): Promise<{ message: string }> {
-    const user = await this.usersService.findByEmail(forgotPasswordDto.email);
+    const user = await this.usersService.findByEmail(forgotPasswordDto.email.toLowerCase());
     if (!user) {
       // Return success even if user not found to prevent email enumeration
       return { message: 'If the email exists, a password reset link has been sent' };
@@ -311,7 +315,7 @@ export class AuthService {
   }
 {{else}}
   async forgotPassword(forgotPasswordDto: ForgotPasswordDto): Promise<{ resetToken: string; message: string }> {
-    const user = await this.usersService.findByEmail(forgotPasswordDto.email);
+    const user = await this.usersService.findByEmail(forgotPasswordDto.email.toLowerCase());
     if (!user) {
       // Return success even if user not found to prevent email enumeration
       return { resetToken: '', message: 'If the email exists, a reset token has been generated' };
@@ -356,7 +360,7 @@ export class AuthService {
    */
   private async createRefreshToken(userId: string): Promise<any> {
     const token = this.jwtService.sign(
-      { sub: userId },
+      { sub: userId, jti: crypto.randomBytes(16).toString('hex') },
       { expiresIn: '{{jwt.refreshExpiration}}' }
     );
 

package/dist/generator/templates/prisma/schema.prisma.models.hbs

@@ -0,0 +1,47 @@
+model User {
+  id        String   @id @default(uuid())
+  email     String   @unique
+{{#if features.useUsername}}
+  username  String   @unique
+{{/if}}
+  password  String{{#if oauth}}?{{/if}}
+{{#if oauth}}
+{{#if oauth.google}}
+  googleId  String?  @unique
+{{/if}}
+{{#if oauth.github}}
+  githubId  String?  @unique
+{{/if}}
+{{/if}}
+{{#if rbac.enabled}}
+  roles     String[] @default(["User"])
+{{/if}}
+{{#if features.emailVerification}}
+  isEmailVerified        Boolean  @default(false)
+  emailVerificationToken String?
+{{/if}}
+{{#if features.resetPassword}}
+  passwordResetToken     String?
+  passwordResetExpires   DateTime?
+{{/if}}
+{{#if features.accountLockout}}
+  failedLoginAttempts Int      @default(0)
+  lockUntil           DateTime?
+{{/if}}
+{{#if features.refreshTokens}}
+  refreshTokens RefreshToken[]
+{{/if}}
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+}
+{{#if features.refreshTokens}}
+
+model RefreshToken {
+  id        String   @id @default(uuid())
+  token     String   @unique
+  userId    String
+  user      User     @relation(fields: [userId], references: [id], onDelete: Cascade)
+  expiresAt DateTime
+  createdAt DateTime @default(now())
+}
+{{/if}}

package/dist/gui/index.js

@@ -37,6 +37,103 @@ var init_cjs_shims = __esm({
   }
 });
 
+// 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/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, fs4, AppModuleUpdater;
 var init_ast_updater = __esm({
@@ -426,13 +523,139 @@ var init_main_ts_updater = __esm({
   }
 });
 
+// src/installer/prisma-schema-updater.ts
+var fs6, import_execa, PrismaSchemaUpdater;
+var init_prisma_schema_updater = __esm({
+  "src/installer/prisma-schema-updater.ts"() {
+    "use strict";
+    init_cjs_shims();
+    fs6 = __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 fs6.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 fs6.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 fs6.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 fs6.copy(this.schemaPath, this.backupPath);
+      }
+      /**
+       * Restore backup on failure
+       */
+      async restoreBackup() {
+        if (this.backupPath && await fs6.pathExists(this.backupPath)) {
+          await fs6.copy(this.backupPath, this.schemaPath, { overwrite: true });
+          await fs6.remove(this.backupPath);
+        }
+      }
+      /**
+       * Clean up backup after success
+       */
+      async cleanupBackup() {
+        if (this.backupPath && await fs6.pathExists(this.backupPath)) {
+          await fs6.remove(this.backupPath);
+        }
+      }
+    };
+  }
+});
+
 // src/installer/package-updater.ts
-var fs6, PackageUpdater;
+var fs7, PackageUpdater;
 var init_package_updater = __esm({
   "src/installer/package-updater.ts"() {
     "use strict";
     init_cjs_shims();
-    fs6 = __toESM(require("fs-extra"));
+    fs7 = __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 fs6.readJSON(this.packageJsonPath);
+          const packageJson = await fs7.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 fs6.writeJSON(this.packageJsonPath, packageJson, { spaces: 2 });
+          await fs7.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 fs6.copy(this.packageJsonPath, this.backupPath);
+        await fs7.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);
+        if (this.backupPath && await fs7.pathExists(this.backupPath)) {
+          await fs7.copy(this.backupPath, this.packageJsonPath, { overwrite: true });
+          await fs7.remove(this.backupPath);
         }
       }
       /**
        * Clean up backup
        */
       async cleanupBackup() {
-        if (this.backupPath && await fs6.pathExists(this.backupPath)) {
-          await fs6.remove(this.backupPath);
+        if (this.backupPath && await fs7.pathExists(this.backupPath)) {
+          await fs7.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();
   }
@@ -653,7 +878,7 @@ init_cjs_shims();
 init_cjs_shims();
 var http = __toESM(require("http"));
 var path6 = __toESM(require("path"));
-var fs8 = __toESM(require("fs-extra"));
+var fs9 = __toESM(require("fs-extra"));
 
 // src/analyzer/index.ts
 init_cjs_shims();
@@ -858,88 +1083,12 @@ function buildConfig(answers, projectName, sourceRoot, detectedORM, detectedDB)
 init_cjs_shims();
 var import_events = require("events");
 var path5 = __toESM(require("path"));
-var fs7 = __toESM(require("fs-extra"));
+var fs8 = __toESM(require("fs-extra"));
 
 // src/generator/generator.ts
 init_cjs_shims();
 var path4 = __toESM(require("path"));
-
-// src/generator/template-engine.ts
-init_cjs_shims();
-var import_handlebars = __toESM(require("handlebars"));
-var path2 = __toESM(require("path"));
-var fs2 = __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 || 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();
-  }
-};
+init_template_engine();
 
 // src/generator/file-writer.ts
 init_cjs_shims();
@@ -1017,16 +1166,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;
@@ -1144,8 +1285,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) {
@@ -1171,6 +1311,8 @@ var Generator = class {
 };
 
 // src/gui/orchestrator.ts
+init_template_engine();
+init_config_builder();
 var GuiOrchestrator = class extends import_events.EventEmitter {
   constructor(_cwd) {
     super();
@@ -1191,7 +1333,7 @@ var GuiOrchestrator = class extends import_events.EventEmitter {
     for (const spec of plan) {
       const content = await templateEngine.render(spec.template, context);
       const fullPath = path5.join(projectInfo.root, spec.output);
-      const exists = await fs7.pathExists(fullPath);
+      const exists = await fs8.pathExists(fullPath);
       files.push({
         path: spec.output,
         content,
@@ -1203,6 +1345,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,
@@ -1237,6 +1385,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 = path5.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));
@@ -1396,7 +1564,7 @@ data: ${JSON.stringify(data)}
     ];
     for (const candidate of candidates) {
       try {
-        const html = fs8.readFileSync(candidate, "utf-8");
+        const html = fs9.readFileSync(candidate, "utf-8");
         res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
         res.end(html);
         return;