@soapjs/soap-auth 0.1.1 → 0.3.0

package/build/strategies/api-key/api-key.strategy.d.ts

@@ -1,9 +1,9 @@
 import * as Soap from "@soapjs/soap";
 import { AuthResult, AuthStrategy } from "../../types";
 import { ApiKeyStrategyConfig } from "./api-key.types";
-export declare class ApiKeyStrategy<TContext = unknown, TUser = unknown> implements AuthStrategy<TContext, TUser> {
-    private config;
-    private logger;
+import { BaseAuthStrategy } from "../base-auth.strategy";
+export declare class ApiKeyStrategy<TContext = unknown, TUser = unknown> extends BaseAuthStrategy<TContext, TUser> implements AuthStrategy<TContext, TUser> {
+    protected config: ApiKeyStrategyConfig<TContext, TUser>;
     constructor(config: ApiKeyStrategyConfig<TContext, TUser>, logger: Soap.Logger);
     init(): Promise<void>;
     authenticate(context?: TContext): Promise<AuthResult<TUser>>;
@@ -11,4 +11,5 @@ export declare class ApiKeyStrategy<TContext = unknown, TUser = unknown> impleme
     revoke(apiKey: string): Promise<void>;
     private trackApiKeyUsage;
     private incrementRequestCount;
+    logout(context: TContext): Promise<void>;
 }

package/build/strategies/api-key/api-key.strategy.js

@@ -3,12 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ApiKeyStrategy = void 0;
 const api_key_errors_1 = require("./api-key.errors");
 const errors_1 = require("../../errors");
-class ApiKeyStrategy {
+const base_auth_strategy_1 = require("../base-auth.strategy");
+class ApiKeyStrategy extends base_auth_strategy_1.BaseAuthStrategy {
     config;
-    logger;
     constructor(config, logger) {
+        super(config, null, logger);
         this.config = config;
-        this.logger = logger;
         if (!this.config.extractApiKey || !this.config.retrieveUserByApiKey) {
             throw new Error("ApiKeyStrategy requires extractApiKey and retrieveUserByApiKey functions.");
         }
@@ -45,13 +45,13 @@ class ApiKeyStrategy {
             }
             await this.trackApiKeyUsage(apiKey);
             await this.incrementRequestCount(apiKey);
-            await this.config.onSuccess?.({ user, context });
+            await this.onSuccess("authenticate", { user, context });
             return { user };
         }
         catch (error) {
             this.logger.error("API Key authentication error:", error);
             try {
-                await this.config.onFailure?.({ error, context });
+                await this.onFailure("authenticate", { error, context });
             }
             catch (callbackError) {
                 this.logger.error("onFailure callback error during authentication:", callbackError);
@@ -63,7 +63,7 @@ class ApiKeyStrategy {
         if (this.config.authorize) {
             return this.config.authorize(user, action, resource);
         }
-        throw new Error("Authorization logic is not implemented.");
+        return true;
     }
     async revoke(apiKey) {
         if (this.config.revokeApiKey) {
@@ -91,5 +91,8 @@ class ApiKeyStrategy {
             this.logger.warn("Failed to increment request count:", error);
         }
     }
+    logout(context) {
+        return;
+    }
 }
 exports.ApiKeyStrategy = ApiKeyStrategy;

package/build/strategies/api-key/api-key.types.d.ts

@@ -1,11 +1,9 @@
-import { RateLimitConfig, RoleAuthorizationConfig, AuthFailureContext, AuthSuccessContext, AccountLockConfig } from "../../types";
-export interface ApiKeyStrategyConfig<TContext = unknown, TUser = unknown> extends ApiKeyTrackingConfig, RateLimitConfig, RoleAuthorizationConfig<TUser>, AccountLockConfig<TContext> {
+import { RateLimitConfig, RoleAuthorizationConfig, AccountLockConfig, AuthResultConfig } from "../../types";
+export interface ApiKeyStrategyConfig<TContext = unknown, TUser = unknown> extends AuthResultConfig<TContext, TUser>, ApiKeyTrackingConfig, RateLimitConfig, RoleAuthorizationConfig<TUser>, AccountLockConfig<TContext> {
     extractApiKey: (context: TContext) => string | null;
     retrieveUserByApiKey: (apiKey: string) => Promise<TUser | null>;
     authorize?: (user: TUser, action: string, resource?: string) => Promise<boolean>;
     revokeApiKey?: (apiKey: string) => Promise<void>;
-    onSuccess?: (context: AuthSuccessContext<TUser, TContext>) => Promise<void> | void;
-    onFailure?: (context: AuthFailureContext<TContext>) => Promise<void> | void;
 }
 export interface ApiKeyTrackingConfig {
     trackApiKeyUsage?: (apiKey: string) => Promise<void>;

package/build/strategies/base-auth.strategy.d.ts

@@ -1,17 +1,18 @@
 import * as Soap from "@soapjs/soap";
-import { AuthResult, AuthStrategy, BaseAuthStrategyConfig } from "../types";
+import { AuthFailureContext, AuthResult, AuthStrategy, AuthSuccessContext, BaseAuthStrategyConfig } from "../types";
 import { SessionHandler } from "../session/session-handler";
 export declare abstract class BaseAuthStrategy<TContext = unknown, TUser = unknown> implements AuthStrategy<TContext, TUser> {
     protected config: BaseAuthStrategyConfig<TContext, TUser>;
     protected session?: SessionHandler;
     protected logger?: Soap.Logger;
     abstract authenticate(context?: TContext): Promise<AuthResult<TUser>>;
-    protected abstract retrieveUser(context: TContext): Promise<TUser | null>;
     abstract logout(context: TContext): Promise<void>;
     constructor(config: BaseAuthStrategyConfig<TContext, TUser>, session?: SessionHandler, logger?: Soap.Logger);
     init(): Promise<void>;
-    protected isAccountLocked(account: any, ...args: unknown[]): Promise<boolean>;
+    protected isAccountLocked(account: any): Promise<boolean>;
     protected isAuthorized(user: TUser): Promise<boolean>;
     protected checkRateLimit(data: unknown): Promise<void>;
     protected checkMfa(user: TUser, context: TContext): Promise<void>;
+    protected onSuccess(action: string, context: AuthSuccessContext<TUser, TContext>): Promise<void>;
+    protected onFailure(action: string, context: AuthFailureContext<TContext>): Promise<void>;
 }

package/build/strategies/base-auth.strategy.js

@@ -14,8 +14,8 @@ class BaseAuthStrategy {
     async init() {
         return Promise.resolve();
     }
-    async isAccountLocked(account, ...args) {
-        if (await this.config.lock.isAccountLocked?.(account, ...args)) {
+    async isAccountLocked(account) {
+        if (await this.config.lock.isAccountLocked?.(account)) {
             throw new errors_1.AccountLockedError();
         }
         return false;
@@ -65,5 +65,21 @@ class BaseAuthStrategy {
             throw error;
         }
     }
+    async onSuccess(action, context) {
+        try {
+            await this.config.onSuccess?.(action, context);
+        }
+        catch (error) {
+            this.logger?.error(error);
+        }
+    }
+    async onFailure(action, context) {
+        try {
+            await this.config.onFailure?.(action, context);
+        }
+        catch (error) {
+            this.logger?.error(error);
+        }
+    }
 }
 exports.BaseAuthStrategy = BaseAuthStrategy;

package/build/strategies/basic/basic.strategy.d.ts

@@ -1,25 +1,19 @@
 import * as Soap from "@soapjs/soap";
-import { CredentialBasedAuthStrategy } from "../credential-based-auth.strategy";
+import { CredentialAuthStrategy } from "../credential-auth.strategy";
 import { BasicContext, BasicStrategyConfig } from "./basic.types";
 import { SessionHandler } from "../../session/session-handler";
-export declare class BasicStrategy<TContext extends BasicContext = BasicContext, TUser = unknown> extends CredentialBasedAuthStrategy<TContext, TUser> {
+export declare class BasicStrategy<TContext extends BasicContext = BasicContext, TUser = unknown> extends CredentialAuthStrategy<TContext, TUser> {
     protected config: BasicStrategyConfig<TContext, TUser>;
     protected session?: SessionHandler;
     protected logger?: Soap.Logger;
     constructor(config: BasicStrategyConfig<TContext, TUser>, session?: SessionHandler, logger?: Soap.Logger);
-    protected extractCredentials(context?: TContext): Promise<{
+    protected extractCredentials(context?: TContext): {
         identifier: string;
         password: string;
-    }>;
-    protected verifyCredentials(credentials: {
-        identifier: string;
-        password: string;
-    }): Promise<boolean>;
+    };
+    protected verifyCredentials(identifier: string, password: string): Promise<boolean>;
     protected retrieveUser(credentials: {
         identifier: string;
         password: string;
     }): Promise<TUser | null>;
-    requestPasswordReset(email: string): Promise<void>;
-    resetPassword(email: string, token: string, newPassword: string): Promise<void>;
-    changePassword(email: string, oldPassword: string, newPassword: string): Promise<void>;
 }

package/build/strategies/basic/basic.strategy.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BasicStrategy = void 0;
-const credential_based_auth_strategy_1 = require("../credential-based-auth.strategy");
+const credential_auth_strategy_1 = require("../credential-auth.strategy");
 const errors_1 = require("../../errors");
-class BasicStrategy extends credential_based_auth_strategy_1.CredentialBasedAuthStrategy {
+class BasicStrategy extends credential_auth_strategy_1.CredentialAuthStrategy {
     config;
     session;
     logger;
@@ -13,17 +13,21 @@ class BasicStrategy extends credential_based_auth_strategy_1.CredentialBasedAuth
         this.session = session;
         this.logger = logger;
     }
-    async extractCredentials(context) {
-        const authHeader = context?.headers?.authorization || context?.headers?.["x-custom-auth"];
+    extractCredentials(context) {
+        const authHeader = this.config.credentials.extractCredentials
+            ? this.config.credentials.extractCredentials(context)
+            : context?.headers?.authorization ||
+                context?.headers?.["x-custom-auth"] ||
+                context?.headers?.["proxy-authorization"];
         if (!authHeader) {
             throw new errors_1.MissingCredentialsError();
         }
-        const parts = authHeader.split(" ");
-        if (parts.length !== 2 || parts[0] !== "Basic") {
+        if (!authHeader || !authHeader.toLowerCase().startsWith("basic ")) {
             throw new errors_1.InvalidCredentialsError();
         }
+        const encoded = authHeader.substring(6);
         try {
-            const decoded = Buffer.from(parts[1], "base64").toString("utf-8");
+            const decoded = Buffer.from(encoded, "base64").toString("utf-8");
             const [username, password] = decoded.split(":");
             if (!username || !password) {
                 throw new errors_1.InvalidCredentialsError();
@@ -34,20 +38,11 @@ class BasicStrategy extends credential_based_auth_strategy_1.CredentialBasedAuth
             throw new errors_1.InvalidCredentialsError();
         }
     }
-    async verifyCredentials(credentials) {
-        return this.config.login.verifyUserCredentials(credentials.identifier, credentials.password);
+    async verifyCredentials(identifier, password) {
+        return this.config.credentials.verifyCredentials(identifier, password);
     }
     async retrieveUser(credentials) {
-        return this.config.login.retrieveUserData(credentials.identifier);
-    }
-    async requestPasswordReset(email) {
-        await super.requestPasswordReset(email);
-    }
-    async resetPassword(email, token, newPassword) {
-        await super.resetPassword(email, token, newPassword);
-    }
-    async changePassword(email, oldPassword, newPassword) {
-        await super.changePassword(email, oldPassword, newPassword);
+        return this.config.user.getUserData(credentials.identifier);
     }
 }
 exports.BasicStrategy = BasicStrategy;

package/build/strategies/basic/basic.types.d.ts

@@ -1,5 +1,5 @@
-import { CredentialBasedAuthStrategyConfig } from "../../types";
-export interface BasicStrategyConfig<TContext = unknown, TUser = unknown> extends CredentialBasedAuthStrategyConfig<TContext, TUser> {
+import { CredentialAuthStrategyConfig } from "../../types";
+export interface BasicStrategyConfig<TContext = unknown, TUser = unknown> extends CredentialAuthStrategyConfig<TContext, TUser> {
 }
 export type BasicContext = {
     headers: {

package/build/strategies/{credential-based-auth.strategy.d.ts → credential-auth.strategy.d.ts}

@@ -1,21 +1,24 @@
 import * as Soap from "@soapjs/soap";
-import { AuthResult, CredentialBasedAuthStrategyConfig } from "../types";
+import { AuthResult, CredentialAuthStrategyConfig } from "../types";
 import { BaseAuthStrategy } from "./base-auth.strategy";
 import { SessionHandler } from "../session/session-handler";
-export declare abstract class CredentialBasedAuthStrategy<TContext = unknown, TUser = unknown> extends BaseAuthStrategy<TContext, TUser> {
-    protected config: CredentialBasedAuthStrategyConfig<TContext, TUser>;
+export declare abstract class CredentialAuthStrategy<TContext = unknown, TUser = unknown> extends BaseAuthStrategy<TContext, TUser> {
+    protected config: CredentialAuthStrategyConfig<TContext, TUser>;
     protected session?: SessionHandler;
     protected logger?: Soap.Logger;
-    protected abstract extractCredentials(context?: TContext): Promise<{
-        identifier: string;
-        password: string;
-    }>;
-    protected abstract verifyCredentials(credentials: any): Promise<boolean>;
+    protected abstract verifyCredentials(identifier: string, password: string): Promise<boolean>;
+    protected abstract extractCredentials(context: TContext): any;
     protected abstract retrieveUser(credentials: any): Promise<TUser | null>;
-    constructor(config: CredentialBasedAuthStrategyConfig<TContext, TUser>, session?: SessionHandler, logger?: Soap.Logger);
-    authenticate(context?: TContext): Promise<AuthResult<TUser>>;
+    constructor(config: CredentialAuthStrategyConfig<TContext, TUser>, session?: SessionHandler, logger?: Soap.Logger);
+    protected storeUserSession(user: TUser, context: TContext): Promise<void>;
+    protected handleAuthenticationError(error: Error, context: TContext): Promise<never>;
+    protected preAuthChecks(identifier: string): Promise<void>;
+    protected handleFailedLogin(identifier: string): Promise<void>;
+    protected handleSuccessfulLogin(identifier: string): Promise<void>;
+    protected finalizeAuthentication(user: TUser, context: TContext): Promise<void>;
+    authenticate(context: TContext): Promise<AuthResult<TUser>>;
     protected handleSession(user: TUser, context?: TContext): Promise<void>;
-    logout(context?: TContext): Promise<void>;
+    logout(context: TContext): Promise<void>;
     requestPasswordReset(identifier: string, email?: string): Promise<void>;
     resetPassword(identifier: string, token: string, newPassword: string): Promise<void>;
     changePassword(identifier: string, oldPassword: string, newPassword: string): Promise<void>;
@@ -23,7 +26,7 @@ export declare abstract class CredentialBasedAuthStrategy<TContext = unknown, TU
     protected auditPasswordChange(identifier: string, context?: TContext): Promise<void>;
     protected validatePasswordPolicy(password: string): boolean;
     protected checkFailedAttempts(identifier: string): Promise<void>;
-    protected isAccountLocked(account: any, ...args: unknown[]): Promise<boolean>;
+    protected isAccountLocked(account: any): Promise<boolean>;
     protected incrementFailedAttempts(account: any): Promise<void>;
     protected notifyAccountLocked(identifier: string): Promise<void>;
     protected checkPasswordExpiry(identifier: string): Promise<void>;

package/build/strategies/{credential-based-auth.strategy.js → credential-auth.strategy.js}

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CredentialBasedAuthStrategy = void 0;
+exports.CredentialAuthStrategy = void 0;
 const errors_1 = require("../errors");
 const base_auth_strategy_1 = require("./base-auth.strategy");
-class CredentialBasedAuthStrategy extends base_auth_strategy_1.BaseAuthStrategy {
+class CredentialAuthStrategy extends base_auth_strategy_1.BaseAuthStrategy {
     config;
     session;
     logger;
@@ -13,34 +13,73 @@ class CredentialBasedAuthStrategy extends base_auth_strategy_1.BaseAuthStrategy
         this.session = session;
         this.logger = logger;
     }
+    async storeUserSession(user, context) {
+        if (!this.session || !this.config.session) {
+            this.logger?.info("Session management is not configured. Skipping session storage.");
+            return;
+        }
+        let sessionId = this.config.session.getSessionId?.(context);
+        if (!sessionId) {
+            sessionId = this.config.session.generateSessionId
+                ? this.config.session.generateSessionId(user, context)
+                : `sid-${Date.now()}-${Math.random().toString(36).substring(7)}`;
+        }
+        const sessionData = this.config.session.createSessionData
+            ? this.config.session.createSessionData(user, context)
+            : { user };
+        if (this.config.session.store) {
+            await this.config.session.store.setSession(sessionId, sessionData);
+        }
+        else {
+            await this.session.set(sessionId, sessionData);
+        }
+        this.config.session.embedSessionId?.(context, sessionId);
+        this.logger?.info(`Stored user session with ID: ${sessionId}`);
+    }
+    async handleAuthenticationError(error, context) {
+        this.logger?.error("Authentication failed:", error);
+        await this.onFailure("login", { context, error });
+        throw new errors_1.AuthError(error, "Authentication failed.");
+    }
+    async preAuthChecks(identifier) {
+        await this.isAccountLocked(identifier);
+        await this.checkFailedAttempts(identifier);
+        await this.checkRateLimit(identifier);
+        await this.checkPasswordExpiry(identifier);
+    }
+    async handleFailedLogin(identifier) {
+        await this.config.failedAttempts.incrementFailedAttempts?.(identifier);
+    }
+    async handleSuccessfulLogin(identifier) {
+        await this.config.failedAttempts.resetFailedAttempts?.(identifier);
+    }
+    async finalizeAuthentication(user, context) {
+        await this.checkMfa(user, context);
+        await this.isAuthorized(user);
+        await this.storeUserSession(user, context);
+    }
     async authenticate(context) {
         try {
             const credentials = await this.extractCredentials(context);
             if (!credentials)
                 throw new errors_1.MissingCredentialsError();
-            await this.isAccountLocked(credentials.identifier);
-            await this.checkFailedAttempts(credentials.identifier);
-            await this.checkRateLimit(credentials.identifier);
-            await this.checkPasswordExpiry(credentials.identifier);
-            const valid = await this.verifyCredentials(credentials);
+            await this.preAuthChecks(credentials.identifier);
+            const valid = await this.verifyCredentials(credentials.identifier, credentials.password);
             if (!valid) {
-                await this.config.login.incrementFailedAttempts?.(credentials.identifier);
+                await this.handleFailedLogin(credentials.identifier);
                 throw new errors_1.InvalidCredentialsError();
             }
-            await this.config.login.resetFailedAttempts?.(credentials.identifier);
-            const user = await this.retrieveUser(credentials);
+            await this.handleSuccessfulLogin(credentials.identifier);
+            const user = await this.retrieveUser(credentials.identifier);
             if (!user)
                 throw new errors_1.UserNotFoundError();
-            await this.checkMfa(user, context);
-            await this.isAuthorized(user);
-            await this.handleSession(user, context);
+            await this.finalizeAuthentication(user, context);
+            this.auditLoginAttempt(credentials.identifier, true, context);
             return { user };
         }
         catch (e) {
-            const error = new errors_1.AuthError(e, "Authentication failed.");
-            this.logger.error("Authentication failed:", error);
-            await this.config.logout.onFailure?.({ context, error: error });
-            throw error;
+            this.auditLoginAttempt(null, false, context);
+            return this.handleAuthenticationError(e, context);
         }
     }
     async handleSession(user, context) {
@@ -53,78 +92,87 @@ class CredentialBasedAuthStrategy extends base_auth_strategy_1.BaseAuthStrategy
         try {
             if (this.session) {
                 const sessionId = this.session.getSessionId?.(context);
-                if (!sessionId) {
+                if (!sessionId)
                     throw new Error("Session ID is missing in the context.");
-                }
                 await this.session.destroy(sessionId);
-                this.logger.info(`Session destroyed successfully, sessionId: ${sessionId}`);
+                this.logger?.info(`Session destroyed: ${sessionId}`);
             }
-            await this.config.logout.onSuccess?.(context);
-            this.logger.info(`User logged out successfully.`);
+            await this.onSuccess("logout", context);
         }
         catch (e) {
             const error = new errors_1.AuthError(e, "Logout process failed.");
-            this.logger.error("Error during logout:", e);
-            await this.config.logout.onFailure?.({ context, error: e });
+            this.logger?.error("Error during logout:", error);
+            await this.onFailure("logout", { context, error });
             throw error;
         }
     }
     async requestPasswordReset(identifier, email) {
         try {
-            if (!this.config.passwordReset?.generateResetToken) {
+            if (!this.config?.passwordPolicy.generateResetToken) {
                 throw new Error("Password reset token generation is not configured.");
             }
-            const token = await this.config.passwordReset.generateResetToken(identifier);
+            const token = await this.config.passwordPolicy.generateResetToken(identifier);
             if (email) {
-                await this.config.passwordReset.sendResetEmail?.(email, token);
+                await this.config.passwordPolicy.sendResetEmail?.(email, token);
             }
-            await this.config.passwordReset.onSuccess?.({ identifier });
+            await this.onSuccess("request_password_reset", { identifier });
             this.logger.info(`Password reset requested for identifier: ${identifier}`);
         }
         catch (e) {
             const error = new errors_1.AuthError(e, "Password reset request error.");
             this.logger.error("Password reset request error:", e);
-            await this.config.passwordReset.onFailure?.({ identifier, error: e });
+            await this.onFailure("request_password_reset", {
+                identifier,
+                error: e,
+            });
             throw error;
         }
     }
     async resetPassword(identifier, token, newPassword) {
         try {
-            if (!this.config.passwordReset?.validateResetToken) {
+            if (!this.config.passwordPolicy?.validateResetToken) {
                 throw new Error("Password reset token validation is not configured.");
             }
-            const isValid = await this.config.passwordReset.validateResetToken(token);
+            const isValid = await this.config.passwordPolicy.validateResetToken(token);
             if (!isValid) {
                 throw new Error("Invalid or expired reset token.");
             }
-            await this.config.passwordReset.updatePassword(identifier, newPassword);
-            await this.config.passwordReset.onSuccess?.({ identifier });
+            await this.config.passwordPolicy.updatePassword(identifier, newPassword);
+            await this.onSuccess("password_reset", { identifier });
             this.logger.info(`Password successfully reset for identifier: ${identifier}`);
+            this.auditPasswordChange(identifier);
         }
         catch (e) {
             const error = new errors_1.AuthError(e, "Password reset error");
             this.logger.error("Password reset error:", e);
-            await this.config.passwordReset.onFailure?.({ identifier, error: e });
+            await this.onFailure("password_reset", {
+                identifier,
+                error: e,
+            });
             throw error;
         }
     }
     async changePassword(identifier, oldPassword, newPassword) {
         try {
-            if (!this.config.login.verifyUserCredentials) {
+            if (!this.config.credentials.verifyCredentials) {
                 throw new Error("Credential verification is not configured.");
             }
-            const isAuthenticated = await this.config.login.verifyUserCredentials(identifier, oldPassword);
+            const isAuthenticated = await this.config.credentials.verifyCredentials(identifier, oldPassword);
             if (!isAuthenticated) {
                 throw new errors_1.InvalidCredentialsError();
             }
-            await this.config.passwordReset?.updatePassword?.(identifier, newPassword);
-            await this.config.passwordReset?.onSuccess?.({ identifier });
+            await this.config.passwordPolicy?.updatePassword?.(identifier, newPassword);
+            await this.onSuccess("change_password", { identifier });
             this.logger.info(`Password changed successfully for identifier: ${identifier}`);
+            this.auditPasswordChange(identifier);
         }
         catch (e) {
             const error = new errors_1.AuthError(e, "Change password error");
             this.logger.error("Change password error:", e);
-            await this.config.passwordReset?.onFailure?.({ identifier, error: e });
+            await this.onFailure("change_password", {
+                identifier,
+                error: e,
+            });
             throw error;
         }
     }
@@ -140,7 +188,8 @@ class CredentialBasedAuthStrategy extends base_auth_strategy_1.BaseAuthStrategy
     async checkFailedAttempts(identifier) {
         try {
             if (this.config.security?.maxFailedLoginAttempts) {
-                const failedAttempts = (await this.config.login.getFailedAttempts?.(identifier)) || 0;
+                const failedAttempts = (await this.config.failedAttempts.getFailedAttempts?.(identifier)) ||
+                    0;
                 if (failedAttempts >= this.config.security.maxFailedLoginAttempts) {
                     this.logger.warn(`User ${identifier} is temporarily locked out.`);
                     throw new errors_1.AccountLockedError();
@@ -151,8 +200,8 @@ class CredentialBasedAuthStrategy extends base_auth_strategy_1.BaseAuthStrategy
             this.logger.error("Check failed attempts:", e);
         }
     }
-    async isAccountLocked(account, ...args) {
-        if (await this.config.lock.isAccountLocked?.(account, ...args)) {
+    async isAccountLocked(account) {
+        if (await this.config.lock.isAccountLocked?.(account)) {
             throw new errors_1.AccountLockedError();
         }
         if (typeof account === "string" && this.config.security?.lockoutDuration) {
@@ -172,9 +221,9 @@ class CredentialBasedAuthStrategy extends base_auth_strategy_1.BaseAuthStrategy
         return false;
     }
     async incrementFailedAttempts(account) {
-        if (this.config.login.incrementFailedAttempts) {
-            await this.config.login.incrementFailedAttempts(account);
-            const failedAttempts = (await this.config.login.getFailedAttempts?.(account)) || 0;
+        if (this.config.failedAttempts.incrementFailedAttempts) {
+            await this.config.failedAttempts.incrementFailedAttempts(account);
+            const failedAttempts = (await this.config.failedAttempts.getFailedAttempts?.(account)) || 0;
             if (this.config.security?.maxFailedLoginAttempts &&
                 failedAttempts >= this.config.security.maxFailedLoginAttempts) {
                 const lockoutKey = `lockout:${account}`;
@@ -202,4 +251,4 @@ class CredentialBasedAuthStrategy extends base_auth_strategy_1.BaseAuthStrategy
         }
     }
 }
-exports.CredentialBasedAuthStrategy = CredentialBasedAuthStrategy;
+exports.CredentialAuthStrategy = CredentialAuthStrategy;

package/build/strategies/index.d.ts

@@ -0,0 +1,16 @@
+export * from "./api-key/api-key.errors";
+export * from "./api-key/api-key.strategy";
+export * from "./api-key/api-key.types";
+export * from "./base-auth.strategy";
+export * from "./basic/basic.strategy";
+export * from "./basic/basic.types";
+export * from "./credential-auth.strategy";
+export * from "./jwt/jwt.strategy";
+export * from "./jwt/jwt.tools";
+export * from "./jwt/jwt.types";
+export * from "./local/local.strategy";
+export * from "./local/local.types";
+export * from "./oauth2/oauth2.strategy";
+export * from "./oauth2/oauth2.tools";
+export * from "./oauth2/oauth2.types";
+export * from "./token-auth.strategy";

package/build/strategies/index.js

@@ -0,0 +1,32 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./api-key/api-key.errors"), exports);
+__exportStar(require("./api-key/api-key.strategy"), exports);
+__exportStar(require("./api-key/api-key.types"), exports);
+__exportStar(require("./base-auth.strategy"), exports);
+__exportStar(require("./basic/basic.strategy"), exports);
+__exportStar(require("./basic/basic.types"), exports);
+__exportStar(require("./credential-auth.strategy"), exports);
+__exportStar(require("./jwt/jwt.strategy"), exports);
+__exportStar(require("./jwt/jwt.tools"), exports);
+__exportStar(require("./jwt/jwt.types"), exports);
+__exportStar(require("./local/local.strategy"), exports);
+__exportStar(require("./local/local.types"), exports);
+__exportStar(require("./oauth2/oauth2.strategy"), exports);
+__exportStar(require("./oauth2/oauth2.tools"), exports);
+__exportStar(require("./oauth2/oauth2.types"), exports);
+__exportStar(require("./token-auth.strategy"), exports);

package/build/strategies/jwt/jwt.strategy.d.ts

@@ -1,10 +1,25 @@
 import * as Soap from "@soapjs/soap";
-import { TokenBasedAuthStrategy } from "../token-based-auth.strategy";
+import { TokenAuthStrategy } from "../token-auth.strategy";
 import { JwtConfig } from "./jwt.types";
 import { SessionHandler } from "../../session/session-handler";
-export declare class JwtStrategy<TContext = unknown, TUser = unknown> extends TokenBasedAuthStrategy<TContext, TUser> {
+import { TokenConfig } from "../../types";
+export declare class JwtStrategy<TContext = unknown, TUser = unknown> extends TokenAuthStrategy<TContext, TUser> {
     protected config: JwtConfig<TContext, TUser>;
     protected session?: SessionHandler;
     protected logger?: Soap.Logger;
+    protected accessTokenConfig: TokenConfig<TContext>;
+    protected refreshTokenConfig: TokenConfig<TContext>;
     constructor(config: JwtConfig<TContext, TUser>, session?: SessionHandler, logger?: Soap.Logger);
+    protected invalidateRefreshToken(token: string): Promise<void>;
+    protected verifyAccessToken(token: string): Promise<any>;
+    protected verifyRefreshToken(token: string): Promise<any>;
+    protected generateAccessToken(payload: any): Promise<string>;
+    protected generateRefreshToken(payload: any): Promise<string>;
+    protected storeAccessToken(token: string, context: TContext): Promise<void>;
+    protected storeRefreshToken(token: string, context: TContext): Promise<void>;
+    protected embedAccessToken(token: string, context: TContext): void;
+    protected embedRefreshToken(token: string, context: TContext): void;
+    protected retrieveAccessToken(context: TContext): Promise<string | undefined>;
+    protected retrieveRefreshToken(context: TContext): Promise<string | undefined>;
+    logout(context: TContext): Promise<void>;
 }