@ackplus/nest-auth 1.1.1 → 1.1.5

package/src/lib/auth/services/{mfa.service.ts → mfa.service.js}

@@ -1,58 +1,45 @@
-import { ForbiddenException, Injectable, UnauthorizedException } from '@nestjs/common';
-import { InjectRepository } from '@nestjs/typeorm';
-import { MoreThan, Repository } from 'typeorm';
-import { NestAuthMFASecret } from '../../auth/entities/mfa-secret.entity';
-import speakeasy from 'speakeasy';
-import qrcode from 'qrcode';
-import { MFAMethodEnum, MFAOptions } from '../../core/interfaces/mfa-options.interface';
-import { INVALID_MFA_EXCEPTION_CODE, USER_NOT_FOUND_EXCEPTION_CODE } from '../../auth.constants';
-import { NestAuthUser } from '../../user/entities/user.entity';
-import { NestAuthOTP } from '../../auth/entities/otp.entity';
-import { OTPTypeEnum } from '../../core/interfaces/otp.interface';
-import { generateOtp } from '../../utils/otp';
-import ms from 'ms';
-import { AuthConfigService } from '../../core/services/auth-config.service';
-
-
-@Injectable()
-export class MfaService {
-
-    mfaConfig: MFAOptions
-
-    constructor(
-        @InjectRepository(NestAuthMFASecret)
-        private mfaSecretRepository: Repository<NestAuthMFASecret>,
-
-        @InjectRepository(NestAuthUser)
-        private userRepository: Repository<NestAuthUser>,
-
-        @InjectRepository(NestAuthOTP)
-        private otpRepository: Repository<NestAuthOTP>,
-    ) {
-        this.mfaConfig = AuthConfigService.getOptions().mfa;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MfaService = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("@nestjs/typeorm");
+const typeorm_2 = require("typeorm");
+const mfa_secret_entity_1 = require("../../auth/entities/mfa-secret.entity");
+const speakeasy_1 = tslib_1.__importDefault(require("speakeasy"));
+const qrcode_1 = tslib_1.__importDefault(require("qrcode"));
+const mfa_options_interface_1 = require("../../core/interfaces/mfa-options.interface");
+const auth_constants_1 = require("../../auth.constants");
+const user_entity_1 = require("../../user/entities/user.entity");
+const otp_entity_1 = require("../../auth/entities/otp.entity");
+const otp_interface_1 = require("../../core/interfaces/otp.interface");
+const otp_1 = require("../../utils/otp");
+const ms_1 = tslib_1.__importDefault(require("ms"));
+const auth_config_service_1 = require("../../core/services/auth-config.service");
+let MfaService = class MfaService {
+    constructor(mfaSecretRepository, userRepository, otpRepository) {
+        this.mfaSecretRepository = mfaSecretRepository;
+        this.userRepository = userRepository;
+        this.otpRepository = otpRepository;
+        this.mfaConfig = auth_config_service_1.AuthConfigService.getOptions().mfa;
     }
-
-    requireMfaEnabledForApp(throwError: boolean = true) {
+    requireMfaEnabledForApp(throwError = true) {
         if (!this.mfaConfig.enabled) {
             if (throwError) {
-                throw new ForbiddenException('MFA is not enabled for the application');
+                throw new common_1.ForbiddenException('MFA is not enabled for the application');
             }
             return false;
         }
         return true;
     }
-
-    private checkIsMfaEnabledForApp(throwError: boolean = true) {
+    checkIsMfaEnabledForApp(throwError = true) {
         return this.requireMfaEnabledForApp(throwError);
     }
-
-    async getVerifiedMethods(userId: string): Promise<MFAMethodEnum[]> {
+    async getVerifiedMethods(userId) {
         if (!this.requireMfaEnabledForApp(false)) {
             return [];
         }
-
-        const verifiedMethods: MFAMethodEnum[] = []
-
+        const verifiedMethods = [];
         // Check for verified TOTP devices
         const verifiedTotpDevice = await this.mfaSecretRepository.findOne({
             where: {
@@ -60,228 +47,176 @@ export class MfaService {
                 verified: true,
             },
         });
-
-        if (verifiedTotpDevice && this.mfaConfig.methods?.includes(MFAMethodEnum.TOTP)) {
-            verifiedMethods.push(MFAMethodEnum.TOTP)
+        if (verifiedTotpDevice && this.mfaConfig.methods?.includes(mfa_options_interface_1.MFAMethodEnum.TOTP)) {
+            verifiedMethods.push(mfa_options_interface_1.MFAMethodEnum.TOTP);
         }
-
         // Note: EMAIL and SMS methods are always available if configured
         // They don't require pre-verification like TOTP does
         // But we only include them if they're in the config
-        if (this.mfaConfig.methods?.includes(MFAMethodEnum.EMAIL)) {
-            verifiedMethods.push(MFAMethodEnum.EMAIL)
+        if (this.mfaConfig.methods?.includes(mfa_options_interface_1.MFAMethodEnum.EMAIL)) {
+            verifiedMethods.push(mfa_options_interface_1.MFAMethodEnum.EMAIL);
         }
-
-        if (this.mfaConfig.methods?.includes(MFAMethodEnum.SMS)) {
-            verifiedMethods.push(MFAMethodEnum.SMS)
+        if (this.mfaConfig.methods?.includes(mfa_options_interface_1.MFAMethodEnum.SMS)) {
+            verifiedMethods.push(mfa_options_interface_1.MFAMethodEnum.SMS);
         }
-
         return verifiedMethods;
     }
-
-    async getEnabledMethods(userId: string): Promise<MFAMethodEnum[]> {
+    async getEnabledMethods(userId) {
         if (!this.requireMfaEnabledForApp(false)) {
             return [];
         }
-
-        const isEnabled = await this.isMfaEnabled(userId)
+        const isEnabled = await this.isMfaEnabled(userId);
         if (!isEnabled) {
             return [];
         }
-
-        const enableMethod = []
-
-        if (this.mfaConfig.methods?.includes(MFAMethodEnum.EMAIL)) {
-            enableMethod.push(MFAMethodEnum.EMAIL)
+        const enableMethod = [];
+        if (this.mfaConfig.methods?.includes(mfa_options_interface_1.MFAMethodEnum.EMAIL)) {
+            enableMethod.push(mfa_options_interface_1.MFAMethodEnum.EMAIL);
         }
-
-        if (this.mfaConfig.methods?.includes(MFAMethodEnum.SMS)) {
-            enableMethod.push(MFAMethodEnum.SMS)
+        if (this.mfaConfig.methods?.includes(mfa_options_interface_1.MFAMethodEnum.SMS)) {
+            enableMethod.push(mfa_options_interface_1.MFAMethodEnum.SMS);
         }
-
         const verifiedTotpDevice = await this.mfaSecretRepository.findOne({
             where: {
                 userId,
                 verified: true,
             },
         });
-
         if (verifiedTotpDevice) {
-            enableMethod.push(MFAMethodEnum.TOTP)
+            enableMethod.push(mfa_options_interface_1.MFAMethodEnum.TOTP);
         }
-
         return enableMethod;
     }
-
-
-    async sendMfaCode(userId: string, method: MFAMethodEnum): Promise<boolean> {
-
-        this.requireMfaEnabledForApp(true)
-
-        const code = generateOtp(this.mfaConfig.otpLength);
-
-        const expiresAt = ms(this.mfaConfig.otpExpiresIn)
-
+    async sendMfaCode(userId, method) {
+        this.requireMfaEnabledForApp(true);
+        const code = (0, otp_1.generateOtp)(this.mfaConfig.otpLength);
+        const expiresAt = (0, ms_1.default)(this.mfaConfig.otpExpiresIn);
         const otp = await this.otpRepository.create({
             userId,
-            type: OTPTypeEnum.MFA,
+            type: otp_interface_1.OTPTypeEnum.MFA,
             expiresAt: new Date(Date.now() + expiresAt),
             code,
-        })
+        });
         await this.otpRepository.save(otp);
-
-        if (method === MFAMethodEnum.EMAIL) {
+        if (method === mfa_options_interface_1.MFAMethodEnum.EMAIL) {
             // TODO: Send email
-        } else if (method === MFAMethodEnum.SMS) {
+        }
+        else if (method === mfa_options_interface_1.MFAMethodEnum.SMS) {
             // TODO: Send SMS
         }
-
         return true;
     }
-
-    async verifyMfa(userId: string, inputOtp: string, method: MFAMethodEnum): Promise<boolean> {
-
-        this.requireMfaEnabledForApp(true)
-
-        if (method === MFAMethodEnum.TOTP) {
+    async verifyMfa(userId, inputOtp, method) {
+        this.requireMfaEnabledForApp(true);
+        if (method === mfa_options_interface_1.MFAMethodEnum.TOTP) {
             const devices = await this.mfaSecretRepository.find({
                 where: { userId, verified: true }
             });
-
             for (const device of devices) {
-                const isValid = speakeasy.totp.verify({
+                const isValid = speakeasy_1.default.totp.verify({
                     secret: device.secret,
                     encoding: 'base32',
                     token: inputOtp,
                     window: 1
                 });
-
                 if (isValid) {
                     // Update last used timestamp
-                    await this.mfaSecretRepository.update(
-                        { id: device.id },
-                        { lastUsedAt: new Date() }
-                    );
+                    await this.mfaSecretRepository.update({ id: device.id }, { lastUsedAt: new Date() });
                     return true;
                 }
             }
             return false;
         }
-
-        if (method === MFAMethodEnum.EMAIL || method === MFAMethodEnum.SMS) {
+        if (method === mfa_options_interface_1.MFAMethodEnum.EMAIL || method === mfa_options_interface_1.MFAMethodEnum.SMS) {
             const otp = await this.otpRepository.findOne({
                 where: {
                     userId,
-                    type: OTPTypeEnum.MFA,
+                    type: otp_interface_1.OTPTypeEnum.MFA,
                     used: false,
-                    expiresAt: MoreThan(new Date()),
+                    expiresAt: (0, typeorm_2.MoreThan)(new Date()),
                     code: inputOtp
                 }
             });
-
             if (!otp) {
                 return false;
             }
             await this.otpRepository.delete(otp.id);
             return true;
         }
-
         return false;
     }
-
-
-    async setupTotpDevice(userId: string, deviceName?: string): Promise<{ secret: string; qrCode: string }> {
-        this.requireMfaEnabledForApp(true)
-
+    async setupTotpDevice(userId, deviceName) {
+        this.requireMfaEnabledForApp(true);
         const user = await this.userRepository.findOne({ where: { id: userId } });
         if (!user) {
             throw new Error('User not found');
         }
-
-        const secret = speakeasy.generateSecret();
-
+        const secret = speakeasy_1.default.generateSecret();
         await this.mfaSecretRepository.save({
             userId,
             secret: secret.base32,
             deviceName: deviceName || 'Authenticator',
             verified: false
         });
-
-        const qrCode = await qrcode.toDataURL(secret.otpauth_url);
+        const qrCode = await qrcode_1.default.toDataURL(secret.otpauth_url);
         return { secret: secret.base32, qrCode };
     }
-
-    async verifyTotpSetup(userId: string, secret: string, inputOtp: string): Promise<boolean> {
-
-        this.requireMfaEnabledForApp(true)
-
+    async verifyTotpSetup(userId, secret, inputOtp) {
+        this.requireMfaEnabledForApp(true);
         const device = await this.mfaSecretRepository.findOne({
             where: { userId, secret }
         });
-
         if (device) {
             if (device.verified) {
                 return true;
             }
-
-            const isValid = speakeasy.totp.verify({
+            const isValid = speakeasy_1.default.totp.verify({
                 secret: device.secret,
                 encoding: 'base32',
                 token: inputOtp,
                 window: 1
             });
-
             if (isValid) {
                 await this.mfaSecretRepository.update({ id: device.id }, { verified: true });
                 return true;
             }
         }
-
         return false;
     }
-
-    async getTotpDevices(userId: string) {
-        this.requireMfaEnabledForApp(true)
-
+    async getTotpDevices(userId) {
+        this.requireMfaEnabledForApp(true);
         const devices = await this.mfaSecretRepository.find({
             select: ['id', 'deviceName', 'lastUsedAt', 'verified', 'createdAt'],
             where: { userId },
             order: { lastUsedAt: 'DESC', createdAt: 'DESC' }
         });
-
         return devices.map(device => ({
             id: device.id,
             deviceName: device.deviceName,
-            method: MFAMethodEnum.TOTP,
+            method: mfa_options_interface_1.MFAMethodEnum.TOTP,
             lastUsedAt: device.lastUsedAt,
             createdAt: device.createdAt,
             verified: device.verified,
         }));
     }
-
-    async removeDevice(deviceId: string): Promise<void> {
-        this.requireMfaEnabledForApp(true)
-
+    async removeDevice(deviceId) {
+        this.requireMfaEnabledForApp(true);
         await this.mfaSecretRepository.delete({ id: deviceId });
     }
-
-    async isRequiresMfa(userId: string): Promise<boolean> {
+    async isRequiresMfa(userId) {
         if (!this.mfaConfig.enabled) {
             return false;
         }
-
         if (this.mfaConfig.required) {
             return true;
         }
-
         const user = await this.userRepository.findOne({
             select: ['id', 'isMfaEnabled'],
             where: { id: userId },
         });
         return !!user?.isMfaEnabled;
     }
-
-    async isMfaEnabled(userId: string): Promise<boolean> {
+    async isMfaEnabled(userId) {
         if (this.mfaConfig.enabled) {
             const user = await this.userRepository.findOne({
                 select: ['id', 'isMfaEnabled'],
@@ -291,101 +226,87 @@ export class MfaService {
         }
         return false;
     }
-
-    async markAsVerified(userId: string, deviceId: string): Promise<void> {
-        this.requireMfaEnabledForApp(true)
-        await this.mfaSecretRepository.update(
-            { id: deviceId, userId },
-            { verified: true }
-        );
+    async markAsVerified(userId, deviceId) {
+        this.requireMfaEnabledForApp(true);
+        await this.mfaSecretRepository.update({ id: deviceId, userId }, { verified: true });
     }
-
-    async enableMFA(userId: string) {
-        this.requireMfaEnabledForApp(true)
-
+    async enableMFA(userId) {
+        this.requireMfaEnabledForApp(true);
         if (!this.mfaConfig.allowUserToggle) {
             throw new Error('MFA toggling is not allowed');
         }
-
         const verifiedMethods = await this.getVerifiedMethods(userId);
         if (verifiedMethods.length === 0) {
-            throw new ForbiddenException('Cannot enable MFA without at least one verified method');
+            throw new common_1.ForbiddenException('Cannot enable MFA without at least one verified method');
         }
-
         await this.userRepository.update(userId, { isMfaEnabled: true });
     }
-
-    async disableMFA(userId: string) {
+    async disableMFA(userId) {
         this.checkIsMfaEnabledForApp(true);
-
         if (!this.mfaConfig.allowUserToggle) {
             throw new Error('MFA toggling is not allowed');
         }
         await this.userRepository.update(userId, { isMfaEnabled: false });
     }
-
-    async removeTotpDevice(deviceId: string): Promise<void> {
-        this.checkIsMfaEnabledForApp(true)
-
+    async removeTotpDevice(deviceId) {
+        this.checkIsMfaEnabledForApp(true);
         await this.mfaSecretRepository.delete({ id: deviceId });
     }
-
-    async generateRecoveryCode(userId: string): Promise<string> {
-        this.checkIsMfaEnabledForApp(true)
-
-        const secret = speakeasy.generateSecret({
+    async generateRecoveryCode(userId) {
+        this.checkIsMfaEnabledForApp(true);
+        const secret = speakeasy_1.default.generateSecret({
             name: `NestAuth:${userId}`,
         });
         await this.userRepository.update(userId, { mfaRecoveryCode: secret.base32 });
         return secret.base32;
     }
-
-    async resetMfa(userId: string, code: string): Promise<{ message: string }> {
-
-        this.checkIsMfaEnabledForApp(true)
-
+    async resetMfa(userId, code) {
+        this.checkIsMfaEnabledForApp(true);
         const user = await this.userRepository.findOne({ where: { id: userId } });
         if (!user) {
-            throw new UnauthorizedException({
+            throw new common_1.UnauthorizedException({
                 message: 'User not found',
-                code: USER_NOT_FOUND_EXCEPTION_CODE
+                code: auth_constants_1.USER_NOT_FOUND_EXCEPTION_CODE
             });
         }
         if (user.mfaRecoveryCode === code) {
             // Delete recovery code
             await this.userRepository.update(userId, { mfaRecoveryCode: null });
-
             // Delete all mfa secrets
             await this.mfaSecretRepository.delete({ userId });
-
             return {
                 message: 'Recovery code verified',
             };
         }
-
-        throw new UnauthorizedException({
+        throw new common_1.UnauthorizedException({
             message: 'Invalid recovery code',
-            code: INVALID_MFA_EXCEPTION_CODE
+            code: auth_constants_1.INVALID_MFA_EXCEPTION_CODE
         });
     }
-
-    getAvailableMethods(): MFAMethodEnum[] {
+    getAvailableMethods() {
         if (!this.requireMfaEnabledForApp(false)) {
             return [];
         }
         return this.mfaConfig.methods ?? [];
     }
-
-    async hasRecoveryCode(userId: string): Promise<boolean> {
+    async hasRecoveryCode(userId) {
         if (!this.checkIsMfaEnabledForApp(false)) {
             return false;
         }
-
         const user = await this.userRepository.findOne({
             select: ['id', 'mfaRecoveryCode'],
             where: { id: userId },
         });
-
         return Boolean(user?.mfaRecoveryCode);
     }
-}
+};
+exports.MfaService = MfaService;
+exports.MfaService = MfaService = tslib_1.__decorate([
+    (0, common_1.Injectable)(),
+    tslib_1.__param(0, (0, typeorm_1.InjectRepository)(mfa_secret_entity_1.NestAuthMFASecret)),
+    tslib_1.__param(1, (0, typeorm_1.InjectRepository)(user_entity_1.NestAuthUser)),
+    tslib_1.__param(2, (0, typeorm_1.InjectRepository)(otp_entity_1.NestAuthOTP)),
+    tslib_1.__metadata("design:paramtypes", [typeorm_2.Repository,
+        typeorm_2.Repository,
+        typeorm_2.Repository])
+], MfaService);

package/src/lib/auth.constants.d.ts

@@ -0,0 +1,43 @@
+export declare const AUTH_MODULE_OPTIONS = "NEST_AUTH_AUTH_MODULE_OPTIONS";
+export declare const NEST_AUTH_ASYNC_OPTIONS_PROVIDER = "NEST_AUTH_ASYNC_OPTIONS_PROVIDER";
+export declare const JWT_AUTH_PROVIDER = "jwt";
+export declare const GOOGLE_AUTH_PROVIDER = "google";
+export declare const FACEBOOK_AUTH_PROVIDER = "facebook";
+export declare const APPLE_AUTH_PROVIDER = "apple";
+export declare const GITHUB_AUTH_PROVIDER = "github";
+export declare const EMAIL_AUTH_PROVIDER = "email";
+export declare const PHONE_AUTH_PROVIDER = "phone";
+export declare const USER_NOT_FOUND_EXCEPTION_CODE = "USER_NOT_FOUND";
+export declare const UNAUTHORIZED_EXCEPTION_CODE = "UNAUTHORIZED";
+export declare const INVALID_MFA_EXCEPTION_CODE = "INVALID_MFA";
+export declare const INVALID_REFRESH_TOKEN_EXCEPTION_CODE = "INVALID_REFRESH_TOKEN";
+export declare const SESSION_NOT_FOUND_ERROR = "SESSION_NOT_FOUND";
+export declare const USER_NOT_ACTIVE_ERROR = "USER_NOT_ACTIVE";
+export declare const REFRESH_TOKEN_INVALID = "REFRESH_TOKEN_INVALID";
+export declare const REFRESH_TOKEN_EXPIRED = "REFRESH_TOKEN_EXPIRED";
+export declare const ACCESS_TOKEN_COOKIE_NAME = "accessToken";
+export declare const REFRESH_TOKEN_COOKIE_NAME = "refreshToken";
+export declare const DEFAULT_GUARD_NAME = "web";
+export declare const NestAuthEvents: {
+    readonly EMAIL_VERIFICATION_REQUESTED: "email.verification.requested";
+    readonly EMAIL_VERIFIED: "email.verified";
+    readonly LOGGED_IN: "nest_auth.logged_in";
+    readonly REGISTERED: "nest_auth.registered";
+    readonly TWO_FACTOR_VERIFIED: "nest_auth.two_factor_verified";
+    readonly REFRESH_TOKEN: "nest_auth.refresh_token";
+    readonly PASSWORD_RESET_REQUESTED: "nest_auth.password_reset_requested";
+    readonly PASSWORD_RESET: "nest_auth.password_reset";
+    readonly LOGGED_OUT: "nest_auth.logged_out";
+    readonly LOGGED_OUT_ALL: "nest_auth.logged_out_all";
+    readonly USER_CREATED: "nest_auth.user.created";
+    readonly USER_UPDATED: "nest_auth.user.updated";
+    readonly USER_DELETED: "nest_auth.user.deleted";
+    readonly TENANT_CREATED: "nest_auth.tenant.created";
+    readonly TENANT_UPDATED: "nest_auth.tenant.updated";
+    readonly TENANT_DELETED: "nest_auth.tenant.deleted";
+    readonly ACCESS_KEY_CREATED: "nest_auth.access_key.created";
+    readonly ACCESS_KEY_DELETED: "nest_auth.access_key.deleted";
+    readonly ACCESS_KEY_UPDATED: "nest_auth.access_key.updated";
+    readonly ACCESS_KEY_DEACTIVATED: "nest_auth.access_key.deactivated";
+};
+//# sourceMappingURL=auth.constants.d.ts.map

package/src/lib/auth.constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.constants.d.ts","sourceRoot":"","sources":["../../../../../packages/nest-auth/src/lib/auth.constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,mBAAmB,kCAAkC,CAAC;AACnE,eAAO,MAAM,gCAAgC,qCAAqC,CAAC;AAInF,eAAO,MAAM,iBAAiB,QAAQ,CAAC;AACvC,eAAO,MAAM,oBAAoB,WAAW,CAAC;AAC7C,eAAO,MAAM,sBAAsB,aAAa,CAAC;AACjD,eAAO,MAAM,mBAAmB,UAAU,CAAC;AAC3C,eAAO,MAAM,oBAAoB,WAAW,CAAC;AAC7C,eAAO,MAAM,mBAAmB,UAAU,CAAC;AAC3C,eAAO,MAAM,mBAAmB,UAAU,CAAC;AAI3C,eAAO,MAAM,6BAA6B,mBAAmB,CAAC;AAC9D,eAAO,MAAM,2BAA2B,iBAAiB,CAAC;AAC1D,eAAO,MAAM,0BAA0B,gBAAgB,CAAC;AACxD,eAAO,MAAM,oCAAoC,0BAA0B,CAAC;AAC5E,eAAO,MAAM,uBAAuB,sBAAsB,CAAC;AAC3D,eAAO,MAAM,qBAAqB,oBAAoB,CAAC;AAEvD,eAAO,MAAM,qBAAqB,0BAA0B,CAAC;AAC7D,eAAO,MAAM,qBAAqB,0BAA0B,CAAC;AAI7D,eAAO,MAAM,wBAAwB,gBAAgB,CAAC;AACtD,eAAO,MAAM,yBAAyB,iBAAiB,CAAC;AAGxD,eAAO,MAAM,kBAAkB,QAAQ,CAAC;AAGxC,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;CA4BjB,CAAC"}

package/src/lib/auth.constants.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NestAuthEvents = exports.DEFAULT_GUARD_NAME = exports.REFRESH_TOKEN_COOKIE_NAME = exports.ACCESS_TOKEN_COOKIE_NAME = exports.REFRESH_TOKEN_EXPIRED = exports.REFRESH_TOKEN_INVALID = exports.USER_NOT_ACTIVE_ERROR = exports.SESSION_NOT_FOUND_ERROR = exports.INVALID_REFRESH_TOKEN_EXCEPTION_CODE = exports.INVALID_MFA_EXCEPTION_CODE = exports.UNAUTHORIZED_EXCEPTION_CODE = exports.USER_NOT_FOUND_EXCEPTION_CODE = exports.PHONE_AUTH_PROVIDER = exports.EMAIL_AUTH_PROVIDER = exports.GITHUB_AUTH_PROVIDER = exports.APPLE_AUTH_PROVIDER = exports.FACEBOOK_AUTH_PROVIDER = exports.GOOGLE_AUTH_PROVIDER = exports.JWT_AUTH_PROVIDER = exports.NEST_AUTH_ASYNC_OPTIONS_PROVIDER = exports.AUTH_MODULE_OPTIONS = void 0;
+exports.AUTH_MODULE_OPTIONS = 'NEST_AUTH_AUTH_MODULE_OPTIONS';
+exports.NEST_AUTH_ASYNC_OPTIONS_PROVIDER = 'NEST_AUTH_ASYNC_OPTIONS_PROVIDER';
+// Provider tokens
+exports.JWT_AUTH_PROVIDER = 'jwt';
+exports.GOOGLE_AUTH_PROVIDER = 'google';
+exports.FACEBOOK_AUTH_PROVIDER = 'facebook';
+exports.APPLE_AUTH_PROVIDER = 'apple';
+exports.GITHUB_AUTH_PROVIDER = 'github';
+exports.EMAIL_AUTH_PROVIDER = 'email';
+exports.PHONE_AUTH_PROVIDER = 'phone';
+// Exception codes
+exports.USER_NOT_FOUND_EXCEPTION_CODE = 'USER_NOT_FOUND';
+exports.UNAUTHORIZED_EXCEPTION_CODE = 'UNAUTHORIZED';
+exports.INVALID_MFA_EXCEPTION_CODE = 'INVALID_MFA';
+exports.INVALID_REFRESH_TOKEN_EXCEPTION_CODE = 'INVALID_REFRESH_TOKEN';
+exports.SESSION_NOT_FOUND_ERROR = 'SESSION_NOT_FOUND';
+exports.USER_NOT_ACTIVE_ERROR = 'USER_NOT_ACTIVE';
+exports.REFRESH_TOKEN_INVALID = 'REFRESH_TOKEN_INVALID';
+exports.REFRESH_TOKEN_EXPIRED = 'REFRESH_TOKEN_EXPIRED';
+// Auth Cookie Names
+exports.ACCESS_TOKEN_COOKIE_NAME = 'accessToken';
+exports.REFRESH_TOKEN_COOKIE_NAME = 'refreshToken';
+// Default values
+exports.DEFAULT_GUARD_NAME = 'web';
+// Events Const
+exports.NestAuthEvents = {
+    EMAIL_VERIFICATION_REQUESTED: 'email.verification.requested',
+    EMAIL_VERIFIED: 'email.verified',
+    // Auth events
+    LOGGED_IN: 'nest_auth.logged_in',
+    REGISTERED: 'nest_auth.registered',
+    TWO_FACTOR_VERIFIED: 'nest_auth.two_factor_verified',
+    REFRESH_TOKEN: 'nest_auth.refresh_token',
+    PASSWORD_RESET_REQUESTED: 'nest_auth.password_reset_requested',
+    PASSWORD_RESET: 'nest_auth.password_reset',
+    LOGGED_OUT: 'nest_auth.logged_out',
+    LOGGED_OUT_ALL: 'nest_auth.logged_out_all',
+    // User events
+    USER_CREATED: 'nest_auth.user.created',
+    USER_UPDATED: 'nest_auth.user.updated',
+    USER_DELETED: 'nest_auth.user.deleted',
+    // Tenant events
+    TENANT_CREATED: 'nest_auth.tenant.created',
+    TENANT_UPDATED: 'nest_auth.tenant.updated',
+    TENANT_DELETED: 'nest_auth.tenant.deleted',
+    // Access key events
+    ACCESS_KEY_CREATED: 'nest_auth.access_key.created',
+    ACCESS_KEY_DELETED: 'nest_auth.access_key.deleted',
+    ACCESS_KEY_UPDATED: 'nest_auth.access_key.updated',
+    ACCESS_KEY_DEACTIVATED: 'nest_auth.access_key.deactivated',
+};

package/src/lib/core/core.module.d.ts

@@ -0,0 +1,7 @@
+/**
+ * CoreModule provides core authentication services and providers.
+ * Imports TypeOrmModule.forFeature to provide DataSource for auth providers.
+ */
+export declare class CoreModule {
+}
+//# sourceMappingURL=core.module.d.ts.map

package/src/lib/core/core.module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.module.d.ts","sourceRoot":"","sources":["../../../../../../packages/nest-auth/src/lib/core/core.module.ts"],"names":[],"mappings":"AAkBA;;;GAGG;AACH,qBA2Ba,UAAU;CAAI"}