@lenan-soft/auth 1.0.1

package/dist/nestjs/index.cjs

@@ -0,0 +1,738 @@
+"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 __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
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+var __decorateParam = (index, decorator) => (target, key) => decorator(target, key, index);
+
+// src/nestjs/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AuthController: () => AuthController,
+  AuthService: () => AuthService,
+  CurrentUser: () => CurrentUser,
+  IS_PUBLIC_KEY: () => IS_PUBLIC_KEY,
+  JwtAuthGuard: () => JwtAuthGuard,
+  JwtStrategy: () => JwtStrategy,
+  JwtTokenService: () => JwtTokenService,
+  LENAN_AUTH_OPTIONS: () => LENAN_AUTH_OPTIONS,
+  LENAN_USER_SERVICE: () => LENAN_USER_SERVICE,
+  LenanAuthModule: () => LenanAuthModule,
+  LoginDto: () => LoginDto,
+  MessageResponseDto: () => MessageResponseDto,
+  PasswordService: () => PasswordService,
+  Public: () => Public,
+  RefreshTokenDto: () => RefreshTokenDto,
+  RefreshTokenGuard: () => RefreshTokenGuard,
+  RefreshTokenStrategy: () => RefreshTokenStrategy,
+  RegisterDto: () => RegisterDto,
+  TokensResponseDto: () => TokensResponseDto
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/nestjs/lenan-auth.module.ts
+var import_common10 = require("@nestjs/common");
+var import_jwt2 = require("@nestjs/jwt");
+var import_passport5 = require("@nestjs/passport");
+
+// src/nestjs/controllers/auth.controller.ts
+var import_common4 = require("@nestjs/common");
+
+// src/nestjs/decorators/index.ts
+var import_common = require("@nestjs/common");
+var IS_PUBLIC_KEY = "isPublic";
+var Public = () => (0, import_common.SetMetadata)(IS_PUBLIC_KEY, true);
+var CurrentUser = (0, import_common.createParamDecorator)(
+  (data, ctx) => {
+    const request = ctx.switchToHttp().getRequest();
+    const user = request.user;
+    if (!user) {
+      return null;
+    }
+    return data ? user[data] : user;
+  }
+);
+
+// src/nestjs/dto/index.ts
+var import_class_validator = require("class-validator");
+var LoginDto = class {
+  email;
+  password;
+};
+__decorateClass([
+  (0, import_class_validator.IsEmail)({}, { message: "Please provide a valid email address" })
+], LoginDto.prototype, "email", 2);
+__decorateClass([
+  (0, import_class_validator.IsString)(),
+  (0, import_class_validator.MinLength)(1, { message: "Password is required" })
+], LoginDto.prototype, "password", 2);
+var RegisterDto = class {
+  email;
+  password;
+  confirmPassword;
+};
+__decorateClass([
+  (0, import_class_validator.IsEmail)({}, { message: "Please provide a valid email address" })
+], RegisterDto.prototype, "email", 2);
+__decorateClass([
+  (0, import_class_validator.IsString)(),
+  (0, import_class_validator.MinLength)(8, { message: "Password must be at least 8 characters long" }),
+  (0, import_class_validator.MaxLength)(128, { message: "Password must be at most 128 characters long" }),
+  (0, import_class_validator.Matches)(/^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)/, {
+    message: "Password must contain at least one lowercase letter, one uppercase letter, and one number"
+  })
+], RegisterDto.prototype, "password", 2);
+__decorateClass([
+  (0, import_class_validator.IsString)(),
+  (0, import_class_validator.MinLength)(1, { message: "Password confirmation is required" })
+], RegisterDto.prototype, "confirmPassword", 2);
+var RefreshTokenDto = class {
+  refreshToken;
+};
+__decorateClass([
+  (0, import_class_validator.IsString)(),
+  (0, import_class_validator.MinLength)(1, { message: "Refresh token is required" })
+], RefreshTokenDto.prototype, "refreshToken", 2);
+var TokensResponseDto = class {
+  accessToken;
+  refreshToken;
+  constructor(accessToken, refreshToken) {
+    this.accessToken = accessToken;
+    this.refreshToken = refreshToken;
+  }
+};
+var MessageResponseDto = class {
+  message;
+  constructor(message) {
+    this.message = message;
+  }
+};
+
+// src/nestjs/guards/jwt-auth.guard.ts
+var import_common2 = require("@nestjs/common");
+var import_passport = require("@nestjs/passport");
+var JwtAuthGuard = class extends (0, import_passport.AuthGuard)("lenan-jwt") {
+  constructor(reflector) {
+    super();
+    this.reflector = reflector;
+  }
+  canActivate(context) {
+    const isPublic = this.reflector.getAllAndOverride(IS_PUBLIC_KEY, [
+      context.getHandler(),
+      context.getClass()
+    ]);
+    if (isPublic) {
+      return true;
+    }
+    return super.canActivate(context);
+  }
+};
+JwtAuthGuard = __decorateClass([
+  (0, import_common2.Injectable)()
+], JwtAuthGuard);
+
+// src/nestjs/guards/refresh-token.guard.ts
+var import_common3 = require("@nestjs/common");
+var import_passport2 = require("@nestjs/passport");
+var RefreshTokenGuard = class extends (0, import_passport2.AuthGuard)("lenan-jwt-refresh") {
+};
+RefreshTokenGuard = __decorateClass([
+  (0, import_common3.Injectable)()
+], RefreshTokenGuard);
+
+// src/nestjs/controllers/auth.controller.ts
+var AuthController = class {
+  constructor(authService) {
+    this.authService = authService;
+  }
+  async register(dto) {
+    const tokens = await this.authService.register(dto);
+    return new TokensResponseDto(tokens.accessToken, tokens.refreshToken);
+  }
+  async login(dto) {
+    const tokens = await this.authService.login(dto);
+    return new TokensResponseDto(tokens.accessToken, tokens.refreshToken);
+  }
+  async refresh(user) {
+    const tokens = await this.authService.refreshTokens(
+      user.id,
+      user.refreshToken
+    );
+    return new TokensResponseDto(tokens.accessToken, tokens.refreshToken);
+  }
+  async logout(userId) {
+    await this.authService.logout(userId);
+    return new MessageResponseDto("Logged out successfully");
+  }
+  async me(user) {
+    return user;
+  }
+};
+__decorateClass([
+  Public(),
+  (0, import_common4.Post)("register"),
+  (0, import_common4.HttpCode)(import_common4.HttpStatus.CREATED),
+  __decorateParam(0, (0, import_common4.Body)())
+], AuthController.prototype, "register", 1);
+__decorateClass([
+  Public(),
+  (0, import_common4.Post)("login"),
+  (0, import_common4.HttpCode)(import_common4.HttpStatus.OK),
+  __decorateParam(0, (0, import_common4.Body)())
+], AuthController.prototype, "login", 1);
+__decorateClass([
+  Public(),
+  (0, import_common4.UseGuards)(RefreshTokenGuard),
+  (0, import_common4.Post)("refresh"),
+  (0, import_common4.HttpCode)(import_common4.HttpStatus.OK),
+  __decorateParam(0, CurrentUser())
+], AuthController.prototype, "refresh", 1);
+__decorateClass([
+  (0, import_common4.UseGuards)(JwtAuthGuard),
+  (0, import_common4.Post)("logout"),
+  (0, import_common4.HttpCode)(import_common4.HttpStatus.OK),
+  __decorateParam(0, CurrentUser("id"))
+], AuthController.prototype, "logout", 1);
+__decorateClass([
+  (0, import_common4.UseGuards)(JwtAuthGuard),
+  (0, import_common4.Get)("me"),
+  __decorateParam(0, CurrentUser())
+], AuthController.prototype, "me", 1);
+AuthController = __decorateClass([
+  (0, import_common4.Controller)("auth")
+], AuthController);
+
+// src/nestjs/interfaces/index.ts
+var LENAN_USER_SERVICE = /* @__PURE__ */ Symbol("LENAN_USER_SERVICE");
+var LENAN_AUTH_OPTIONS = /* @__PURE__ */ Symbol("LENAN_AUTH_OPTIONS");
+
+// src/nestjs/services/auth.service.ts
+var import_common5 = require("@nestjs/common");
+var AuthService = class {
+  constructor(userService, passwordService, jwtTokenService) {
+    this.userService = userService;
+    this.passwordService = passwordService;
+    this.jwtTokenService = jwtTokenService;
+  }
+  /**
+   * Register a new user
+   * @throws ConflictException if email already exists
+   */
+  async register(dto) {
+    const existingUser = await this.userService.findByEmail(dto.email);
+    if (existingUser) {
+      throw new import_common5.ConflictException("Email already registered");
+    }
+    if (dto.password !== dto.confirmPassword) {
+      throw new import_common5.BadRequestException("Passwords do not match");
+    }
+    const passwordHash = await this.passwordService.hash(dto.password);
+    const user = await this.userService.createUser({
+      email: dto.email,
+      passwordHash
+    });
+    const tokens = await this.jwtTokenService.generateTokens(
+      user.id,
+      user.email
+    );
+    const hashedRefreshToken = await this.passwordService.hashToken(
+      tokens.refreshToken
+    );
+    await this.userService.updateRefreshToken(user.id, hashedRefreshToken);
+    return tokens;
+  }
+  /**
+   * Authenticate a user with email and password
+   * @throws UnauthorizedException if credentials are invalid
+   */
+  async login(dto) {
+    const user = await this.userService.findByEmail(dto.email);
+    if (!user) {
+      throw new import_common5.UnauthorizedException("Invalid credentials");
+    }
+    const isPasswordValid = await this.passwordService.compare(
+      dto.password,
+      user.passwordHash
+    );
+    if (!isPasswordValid) {
+      throw new import_common5.UnauthorizedException("Invalid credentials");
+    }
+    const tokens = await this.jwtTokenService.generateTokens(
+      user.id,
+      user.email
+    );
+    const hashedRefreshToken = await this.passwordService.hashToken(
+      tokens.refreshToken
+    );
+    await this.userService.updateRefreshToken(user.id, hashedRefreshToken);
+    return tokens;
+  }
+  /**
+   * Refresh tokens using a valid refresh token
+   * @throws UnauthorizedException if refresh token is invalid
+   */
+  async refreshTokens(userId, refreshToken) {
+    const user = await this.userService.findById(userId);
+    if (!user || !user.hashedRefreshToken) {
+      throw new import_common5.UnauthorizedException("Invalid refresh token");
+    }
+    const isValid = await this.passwordService.compareToken(
+      refreshToken,
+      user.hashedRefreshToken
+    );
+    if (!isValid) {
+      throw new import_common5.UnauthorizedException("Invalid refresh token");
+    }
+    const tokens = await this.jwtTokenService.generateTokens(
+      user.id,
+      user.email
+    );
+    const hashedRefreshToken = await this.passwordService.hashToken(
+      tokens.refreshToken
+    );
+    await this.userService.updateRefreshToken(user.id, hashedRefreshToken);
+    return tokens;
+  }
+  /**
+   * Log out a user by clearing their refresh token
+   */
+  async logout(userId) {
+    await this.userService.updateRefreshToken(userId, null);
+  }
+  /**
+   * Validate a user exists by ID
+   * Used by JWT strategy to validate token payloads
+   */
+  async validateUser(userId) {
+    return this.userService.findById(userId);
+  }
+  /**
+   * Get current user by ID (without sensitive fields)
+   */
+  async getCurrentUser(userId) {
+    const user = await this.userService.findById(userId);
+    if (!user) {
+      return null;
+    }
+    const { passwordHash, hashedRefreshToken, ...safeUser } = user;
+    return safeUser;
+  }
+};
+AuthService = __decorateClass([
+  (0, import_common5.Injectable)(),
+  __decorateParam(0, (0, import_common5.Inject)(LENAN_USER_SERVICE))
+], AuthService);
+
+// src/nestjs/services/jwt-token.service.ts
+var import_common6 = require("@nestjs/common");
+var JwtTokenService = class {
+  constructor(jwtService, options) {
+    this.jwtService = jwtService;
+    this.accessSecret = options.jwtSecret;
+    this.refreshSecret = options.jwtRefreshSecret ?? `${options.jwtSecret}_refresh`;
+    this.accessExpiry = options.jwtAccessExpiry ?? "15m";
+    this.refreshExpiry = options.jwtRefreshExpiry ?? "7d";
+  }
+  accessExpiry;
+  refreshExpiry;
+  accessSecret;
+  refreshSecret;
+  /**
+   * Generate access and refresh tokens for a user
+   */
+  async generateTokens(userId, email) {
+    const [accessToken, refreshToken] = await Promise.all([
+      this.generateAccessToken(userId, email),
+      this.generateRefreshToken(userId, email)
+    ]);
+    return { accessToken, refreshToken };
+  }
+  /**
+   * Generate an access token
+   */
+  async generateAccessToken(userId, email) {
+    const payload = {
+      sub: userId,
+      email,
+      type: "access"
+    };
+    return this.jwtService.signAsync(payload, {
+      secret: this.accessSecret,
+      expiresIn: this.accessExpiry
+    });
+  }
+  /**
+   * Generate a refresh token
+   */
+  async generateRefreshToken(userId, email) {
+    const payload = {
+      sub: userId,
+      email,
+      type: "refresh"
+    };
+    return this.jwtService.signAsync(payload, {
+      secret: this.refreshSecret,
+      expiresIn: this.refreshExpiry
+    });
+  }
+  /**
+   * Verify an access token and return its payload
+   */
+  async verifyAccessToken(token) {
+    try {
+      const payload = await this.jwtService.verifyAsync(
+        token,
+        {
+          secret: this.accessSecret
+        }
+      );
+      if (payload.type !== "access") {
+        return null;
+      }
+      return payload;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Verify a refresh token and return its payload
+   */
+  async verifyRefreshToken(token) {
+    try {
+      const payload = await this.jwtService.verifyAsync(
+        token,
+        {
+          secret: this.refreshSecret
+        }
+      );
+      if (payload.type !== "refresh") {
+        return null;
+      }
+      return payload;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Decode a token without verification (useful for debugging)
+   */
+  decodeToken(token) {
+    try {
+      return this.jwtService.decode(token);
+    } catch {
+      return null;
+    }
+  }
+};
+JwtTokenService = __decorateClass([
+  (0, import_common6.Injectable)(),
+  __decorateParam(1, (0, import_common6.Inject)(LENAN_AUTH_OPTIONS))
+], JwtTokenService);
+
+// src/nestjs/services/password.service.ts
+var import_common7 = require("@nestjs/common");
+var bcrypt = __toESM(require("bcryptjs"), 1);
+var PasswordService = class {
+  saltRounds = 12;
+  /**
+   * Hash a plain text password
+   */
+  async hash(password) {
+    return bcrypt.hash(password, this.saltRounds);
+  }
+  /**
+   * Compare a plain text password with a hash
+   */
+  async compare(password, hash2) {
+    return bcrypt.compare(password, hash2);
+  }
+  /**
+   * Hash a refresh token for storage
+   * Uses fewer rounds since refresh tokens are already random
+   */
+  async hashToken(token) {
+    return bcrypt.hash(token, 10);
+  }
+  /**
+   * Compare a refresh token with its hash
+   */
+  async compareToken(token, hash2) {
+    return bcrypt.compare(token, hash2);
+  }
+};
+PasswordService = __decorateClass([
+  (0, import_common7.Injectable)()
+], PasswordService);
+
+// src/nestjs/strategies/jwt.strategy.ts
+var import_common8 = require("@nestjs/common");
+var import_passport3 = require("@nestjs/passport");
+var import_passport_jwt = require("passport-jwt");
+var JwtStrategy = class extends (0, import_passport3.PassportStrategy)(import_passport_jwt.Strategy, "lenan-jwt") {
+  constructor(options, userService) {
+    super({
+      jwtFromRequest: import_passport_jwt.ExtractJwt.fromAuthHeaderAsBearerToken(),
+      ignoreExpiration: false,
+      secretOrKey: options.jwtSecret
+    });
+    this.userService = userService;
+  }
+  /**
+   * Validate the JWT payload and return the user
+   * This is called by Passport after successfully verifying the token signature
+   */
+  async validate(payload) {
+    if (payload.type !== "access") {
+      throw new import_common8.UnauthorizedException("Invalid token type");
+    }
+    const user = await this.userService.findById(payload.sub);
+    if (!user) {
+      throw new import_common8.UnauthorizedException("User not found");
+    }
+    const { passwordHash, hashedRefreshToken, ...safeUser } = user;
+    return safeUser;
+  }
+};
+JwtStrategy = __decorateClass([
+  (0, import_common8.Injectable)(),
+  __decorateParam(0, (0, import_common8.Inject)(LENAN_AUTH_OPTIONS)),
+  __decorateParam(1, (0, import_common8.Inject)(LENAN_USER_SERVICE))
+], JwtStrategy);
+
+// src/nestjs/strategies/refresh-token.strategy.ts
+var import_common9 = require("@nestjs/common");
+var import_passport4 = require("@nestjs/passport");
+var import_passport_jwt2 = require("passport-jwt");
+var RefreshTokenStrategy = class extends (0, import_passport4.PassportStrategy)(
+  import_passport_jwt2.Strategy,
+  "lenan-jwt-refresh"
+) {
+  constructor(options, userService) {
+    const refreshSecret = options.jwtRefreshSecret ?? `${options.jwtSecret}_refresh`;
+    super({
+      jwtFromRequest: import_passport_jwt2.ExtractJwt.fromBodyField("refreshToken"),
+      ignoreExpiration: false,
+      secretOrKey: refreshSecret,
+      passReqToCallback: true
+    });
+    this.userService = userService;
+  }
+  /**
+   * Validate the refresh token payload
+   * Returns user with the refresh token attached for further validation
+   */
+  async validate(req, payload) {
+    if (payload.type !== "refresh") {
+      throw new import_common9.UnauthorizedException("Invalid token type");
+    }
+    const user = await this.userService.findById(payload.sub);
+    if (!user) {
+      throw new import_common9.UnauthorizedException("User not found");
+    }
+    if (!user.hashedRefreshToken) {
+      throw new import_common9.UnauthorizedException("Refresh token has been revoked");
+    }
+    const refreshToken = req.body?.refreshToken;
+    return { ...user, refreshToken };
+  }
+};
+RefreshTokenStrategy = __decorateClass([
+  (0, import_common9.Injectable)(),
+  __decorateParam(0, (0, import_common9.Inject)(LENAN_AUTH_OPTIONS)),
+  __decorateParam(1, (0, import_common9.Inject)(LENAN_USER_SERVICE))
+], RefreshTokenStrategy);
+
+// src/nestjs/lenan-auth.module.ts
+var LenanAuthModule = class {
+  /**
+   * Register the auth module with synchronous configuration
+   *
+   * @param options - Auth module configuration options
+   * @param userService - Your UserService class implementing UserServiceInterface
+   */
+  static register(options, userService) {
+    const providers = this.createProviders(options, userService);
+    const controllers = options.useController !== false ? [AuthController] : [];
+    return {
+      module: LenanAuthModule,
+      imports: [
+        import_passport5.PassportModule.register({ defaultStrategy: "lenan-jwt" }),
+        import_jwt2.JwtModule.register({
+          secret: options.jwtSecret,
+          signOptions: { expiresIn: options.jwtAccessExpiry ?? "15m" }
+        })
+      ],
+      providers,
+      controllers,
+      exports: [
+        AuthService,
+        PasswordService,
+        JwtTokenService,
+        JwtStrategy,
+        LENAN_USER_SERVICE
+      ]
+    };
+  }
+  /**
+   * Register the auth module with async configuration
+   *
+   * @param asyncOptions - Async configuration options
+   * @param userService - Your UserService class implementing UserServiceInterface
+   */
+  static registerAsync(asyncOptions, userService) {
+    const providers = this.createAsyncProviders(asyncOptions, userService);
+    return {
+      module: LenanAuthModule,
+      imports: [
+        ...asyncOptions.imports ?? [],
+        import_passport5.PassportModule.register({ defaultStrategy: "lenan-jwt" }),
+        import_jwt2.JwtModule.registerAsync({
+          imports: asyncOptions.imports,
+          useFactory: async (...args) => {
+            let options;
+            if (asyncOptions.useFactory) {
+              options = await asyncOptions.useFactory(...args);
+            } else {
+              throw new Error("useFactory is required for async registration");
+            }
+            return {
+              secret: options.jwtSecret,
+              signOptions: {
+                expiresIn: options.jwtAccessExpiry ?? "15m"
+              }
+            };
+          },
+          inject: asyncOptions.inject ?? []
+        })
+      ],
+      providers,
+      controllers: [AuthController],
+      exports: [
+        AuthService,
+        PasswordService,
+        JwtTokenService,
+        JwtStrategy,
+        LENAN_USER_SERVICE
+      ]
+    };
+  }
+  static createProviders(options, userService) {
+    return [
+      {
+        provide: LENAN_AUTH_OPTIONS,
+        useValue: options
+      },
+      {
+        provide: LENAN_USER_SERVICE,
+        useClass: userService
+      },
+      AuthService,
+      PasswordService,
+      JwtTokenService,
+      JwtStrategy,
+      RefreshTokenStrategy
+    ];
+  }
+  static createAsyncProviders(asyncOptions, userService) {
+    const asyncOptionsProvider = this.createAsyncOptionsProvider(asyncOptions);
+    return [
+      asyncOptionsProvider,
+      {
+        provide: LENAN_USER_SERVICE,
+        useClass: userService
+      },
+      AuthService,
+      PasswordService,
+      JwtTokenService,
+      JwtStrategy,
+      RefreshTokenStrategy
+    ];
+  }
+  static createAsyncOptionsProvider(asyncOptions) {
+    if (asyncOptions.useFactory) {
+      return {
+        provide: LENAN_AUTH_OPTIONS,
+        useFactory: asyncOptions.useFactory,
+        inject: asyncOptions.inject ?? []
+      };
+    }
+    if (asyncOptions.useClass) {
+      return {
+        provide: LENAN_AUTH_OPTIONS,
+        useFactory: async (optionsFactory) => {
+          return optionsFactory.createAuthOptions();
+        },
+        inject: [asyncOptions.useClass]
+      };
+    }
+    if (asyncOptions.useExisting) {
+      return {
+        provide: LENAN_AUTH_OPTIONS,
+        useFactory: async (optionsFactory) => {
+          return optionsFactory.createAuthOptions();
+        },
+        inject: [asyncOptions.useExisting]
+      };
+    }
+    throw new Error(
+      "Invalid async options: must provide useFactory, useClass, or useExisting"
+    );
+  }
+};
+LenanAuthModule = __decorateClass([
+  (0, import_common10.Module)({})
+], LenanAuthModule);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AuthController,
+  AuthService,
+  CurrentUser,
+  IS_PUBLIC_KEY,
+  JwtAuthGuard,
+  JwtStrategy,
+  JwtTokenService,
+  LENAN_AUTH_OPTIONS,
+  LENAN_USER_SERVICE,
+  LenanAuthModule,
+  LoginDto,
+  MessageResponseDto,
+  PasswordService,
+  Public,
+  RefreshTokenDto,
+  RefreshTokenGuard,
+  RefreshTokenStrategy,
+  RegisterDto,
+  TokensResponseDto
+});
+//# sourceMappingURL=index.cjs.map