@soapjs/soap-auth 0.3.1 → 0.3.2

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

@@ -1,25 +1,24 @@
 import * as Soap from "@soapjs/soap";
 import { TokenAuthStrategy } from "../token-auth.strategy";
-import { JwtConfig } from "./jwt.types";
-import { SessionHandler } from "../../session/session-handler";
-import { TokenConfig } from "../../types";
+import { TokenAuthStrategyConfig, TokenConfig } from "../../types";
 export declare class JwtStrategy<TContext = unknown, TUser = unknown> extends TokenAuthStrategy<TContext, TUser> {
-    protected config: JwtConfig<TContext, TUser>;
-    protected session?: SessionHandler;
+    protected config: TokenAuthStrategyConfig<TContext, TUser>;
     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>;
+    constructor(config: TokenAuthStrategyConfig<TContext, TUser>, logger?: Soap.Logger);
     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 generateAccessToken(user: TUser, context: TContext): Promise<string>;
+    protected generateRefreshToken(user: TUser, context: TContext): Promise<string>;
+    protected storeAccessToken(token: string): Promise<void>;
+    protected storeRefreshToken(token: string): 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>;
+    protected extractAccessToken(context: TContext): string | undefined;
+    protected extractRefreshToken(context: TContext): string | undefined;
+    protected buildAccessTokenPayload(user: TUser, context: TContext): Record<string, any>;
+    protected buildRefreshTokenPayload(user: TUser, context: TContext): Record<string, any>;
+    invalidateRefreshToken(token: string, context?: TContext): Promise<void>;
+    protected invalidateAccessToken(token: string, context?: TContext): Promise<void>;
 }

package/build/strategies/jwt/jwt.strategy.js

@@ -10,28 +10,23 @@ const errors_1 = require("../../errors");
 const jwt_tools_1 = require("./jwt.tools");
 class JwtStrategy extends token_auth_strategy_1.TokenAuthStrategy {
     config;
-    session;
     logger;
     accessTokenConfig;
     refreshTokenConfig;
-    constructor(config, session, logger) {
+    constructor(config, logger) {
         if (!config.accessToken.issuer.secretKey) {
             throw new errors_1.UndefinedTokenSecretError("Access");
         }
         if (config.refreshToken && !config.refreshToken.issuer.secretKey) {
             throw new errors_1.UndefinedTokenSecretError("Refresh");
         }
-        super(config, session, logger);
+        super((0, jwt_tools_1.prepareJwtConfig)(config), null, logger);
         this.config = config;
-        this.session = session;
         this.logger = logger;
-        this.accessTokenConfig = (0, jwt_tools_1.prepareAccessTokenConfig)(config.accessToken);
-        this.refreshTokenConfig = (0, jwt_tools_1.prepareRefreshTokenConfig)(config.refreshToken);
+        this.accessTokenConfig = jwt_tools_1.JwtTools.prepareAccessTokenConfig(config.accessToken);
+        this.refreshTokenConfig = jwt_tools_1.JwtTools.prepareRefreshTokenConfig(config.refreshToken);
         this.logger?.info("JWTStrategy initialized with provided configurations.");
     }
-    async invalidateRefreshToken(token) {
-        await this.refreshTokenConfig.persistence.remove?.(token);
-    }
     verifyAccessToken(token) {
         try {
             if (!token)
@@ -49,7 +44,7 @@ class JwtStrategy extends token_auth_strategy_1.TokenAuthStrategy {
         }
         catch (error) {
             this.logger?.error("JWT verification failed:", error);
-            throw new errors_1.InvalidTokenError("Access");
+            throw error;
         }
     }
     verifyRefreshToken(token) {
@@ -69,29 +64,23 @@ class JwtStrategy extends token_auth_strategy_1.TokenAuthStrategy {
         }
         catch (error) {
             this.logger?.error("JWT verification failed:", error);
-            throw new errors_1.InvalidTokenError("Refresh");
+            error;
         }
     }
-    generateAccessToken(payload) {
-        const options = this.accessTokenConfig.issuer.options || {};
-        return jsonwebtoken_1.default.sign(payload, this.accessTokenConfig.issuer.secretKey, {
-            ...options,
-            jti: payload.jti || crypto.randomUUID(),
-        });
+    async generateAccessToken(user, context) {
+        const payload = this.buildAccessTokenPayload(user, context);
+        return Promise.resolve(jwt_tools_1.JwtTools.generateAccessToken(payload, this.accessTokenConfig));
     }
-    generateRefreshToken(payload) {
-        const options = this.refreshTokenConfig.issuer.options || {};
-        return jsonwebtoken_1.default.sign(payload, this.refreshTokenConfig.issuer.secretKey, {
-            ...options,
-            jti: payload.jti || crypto.randomUUID(),
-        });
+    async generateRefreshToken(user, context) {
+        const payload = this.buildAccessTokenPayload(user, context);
+        return Promise.resolve(jwt_tools_1.JwtTools.generateRefreshToken(payload, this.refreshTokenConfig));
     }
-    async storeAccessToken(token, context) {
+    async storeAccessToken(token) {
         if (this.accessTokenConfig.persistence.store) {
             await this.accessTokenConfig.persistence.store(token, null, this.accessTokenConfig.issuer.options.expiresIn);
         }
     }
-    async storeRefreshToken(token, context) {
+    async storeRefreshToken(token) {
         if (this.refreshTokenConfig.persistence.store) {
             await this.refreshTokenConfig.persistence.store(token, null, this.refreshTokenConfig.issuer.options.expiresIn);
         }
@@ -101,7 +90,7 @@ class JwtStrategy extends token_auth_strategy_1.TokenAuthStrategy {
             this.accessTokenConfig.embed(context, token);
         }
         else {
-            (0, jwt_tools_1.setDefaultJwtHeader)(token, context);
+            jwt_tools_1.JwtTools.setDefaultJwtHeader(token, context);
         }
     }
     embedRefreshToken(token, context) {
@@ -109,33 +98,57 @@ class JwtStrategy extends token_auth_strategy_1.TokenAuthStrategy {
             this.refreshTokenConfig.embed(context, token);
         }
         else {
-            (0, jwt_tools_1.setDefaultJwtCookie)(token, context);
+            jwt_tools_1.JwtTools.setDefaultJwtCookie(token, context);
         }
     }
-    retrieveAccessToken(context) {
-        if (this.accessTokenConfig.retrieve) {
-            return this.accessTokenConfig.retrieve(context);
+    extractAccessToken(context) {
+        if (this.accessTokenConfig.extract) {
+            return this.accessTokenConfig.extract(context);
         }
         else {
-            return (context.req.headers.authorization?.split(" ")[1] ||
-                context.request.headers.authorization?.split(" ")[1] ||
-                context.headers.authorization?.split(" ")[1]);
+            return (context.req?.headers?.authorization?.split(" ")[1] ||
+                context.request?.headers?.authorization?.split(" ")[1] ||
+                context.headers?.authorization?.split(" ")[1]);
         }
     }
-    retrieveRefreshToken(context) {
-        if (this.refreshTokenConfig.retrieve) {
-            return this.refreshTokenConfig.retrieve(context);
+    extractRefreshToken(context) {
+        if (this.refreshTokenConfig.extract) {
+            return this.refreshTokenConfig.extract(context);
         }
-        return (context.req.cookies?.refreshToken ||
-            context.request.cookies?.refreshToken ||
-            context.cookies.refreshToken);
+        return (context.req?.cookies?.refreshToken ||
+            context.request?.cookies?.refreshToken ||
+            context.cookies?.refreshToken);
+    }
+    buildAccessTokenPayload(user, context) {
+        return this.config.accessToken.issuer.buildPayload
+            ? this.config.accessToken.issuer.buildPayload(user, context)
+            : { id: user.id, email: user.email };
+    }
+    buildRefreshTokenPayload(user, context) {
+        return this.config.refreshToken.issuer.buildPayload
+            ? this.config.refreshToken.issuer.buildPayload(user, context)
+            : { id: user.id };
     }
-    async logout(context) {
-        const refreshToken = await this.retrieveRefreshToken(context);
+    async invalidateRefreshToken(token, context) {
+        const refreshToken = token || (await this.extractRefreshToken(context));
         if (refreshToken) {
-            await this.invalidateRefreshToken(refreshToken);
-            (0, jwt_tools_1.clearDefaultJwtCookie)(context);
-            (0, jwt_tools_1.clearDefaultJwtHeader)(context);
+            await this.refreshTokenConfig.persistence?.remove?.(refreshToken);
+            if (context) {
+                jwt_tools_1.JwtTools.clearDefaultJwtCookie(context);
+                jwt_tools_1.JwtTools.clearDefaultJwtHeader(context);
+            }
+            this.logger?.info(`Refresh token invalidated: ${refreshToken}`);
+        }
+    }
+    async invalidateAccessToken(token, context) {
+        const accessToken = token || (await this.extractAccessToken(context));
+        if (accessToken) {
+            await this.accessTokenConfig.persistence?.remove?.(accessToken);
+            if (context) {
+                jwt_tools_1.JwtTools.clearDefaultJwtCookie(context);
+                jwt_tools_1.JwtTools.clearDefaultJwtHeader(context);
+            }
+            this.logger?.info(`Access token invalidated: ${accessToken}`);
         }
     }
 }

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

@@ -1,7 +1,20 @@
-import { TokenConfig } from "../../types";
-export declare const prepareAccessTokenConfig: <TContext = any>(config: TokenConfig<TContext>) => TokenConfig<TContext>;
-export declare const prepareRefreshTokenConfig: <TContext = any>(config: TokenConfig<TContext>) => TokenConfig<TContext>;
-export declare const setDefaultJwtCookie: (token: string, context: any) => void;
-export declare const setDefaultJwtHeader: (token: string, context: any) => void;
-export declare const clearDefaultJwtHeader: (context: any) => void;
-export declare const clearDefaultJwtCookie: (context: any) => void;
+import { JwtConfig } from "./jwt.types";
+import { TokenAuthStrategyConfig, TokenConfig } from "../../types";
+export declare class JwtTools {
+    static generateAccessToken(payload: any, config: JwtConfig["accessToken"]): string;
+    static generateRefreshToken(payload: any, config: JwtConfig["refreshToken"]): string;
+    static verifyAccessToken(token: string, config: JwtConfig["accessToken"]): any;
+    static verifyRefreshToken(token: string, config: JwtConfig["refreshToken"]): any;
+    static setAccessTokenHeader(token: string, context: any): void;
+    static setRefreshTokenCookie(token: string, context: any): void;
+    static clearTokens(context: any): void;
+    static getAccessToken(context: any): string | undefined;
+    static getRefreshToken(context: any): string | undefined;
+    static prepareAccessTokenConfig: <TContext = any>(config: TokenConfig<TContext, any>) => TokenConfig<TContext, any>;
+    static prepareRefreshTokenConfig: <TContext = any>(config: TokenConfig<TContext, any>) => TokenConfig<TContext, any>;
+    static setDefaultJwtCookie: (token: string, context: any) => void;
+    static setDefaultJwtHeader: (token: string, context: any) => void;
+    static clearDefaultJwtHeader: (context: any) => void;
+    static clearDefaultJwtCookie: (context: any) => void;
+}
+export declare const prepareJwtConfig: <TContext = any, TUser = any>(config: Partial<TokenAuthStrategyConfig<TContext, TUser>>) => TokenAuthStrategyConfig<TContext, TUser>;

package/build/strategies/jwt/jwt.tools.js

@@ -22,97 +22,196 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.clearDefaultJwtCookie = exports.clearDefaultJwtHeader = exports.setDefaultJwtHeader = exports.setDefaultJwtCookie = exports.prepareRefreshTokenConfig = exports.prepareAccessTokenConfig = void 0;
+exports.prepareJwtConfig = exports.JwtTools = void 0;
 const Soap = __importStar(require("@soapjs/soap"));
-const prepareAccessTokenConfig = (config) => {
-    return Soap.removeUndefinedProperties({
-        ...config,
-        generation: {
-            ...config.issuer.options,
-            expiresIn: config.issuer.options.expiresIn || "1h",
-            algorithm: config.issuer.options.algorithm || "HS256",
-        },
-        verification: {
-            ...config.verifier.options,
-            algorithms: config.verifier.options.algorithms || ["HS256"],
-            expiresIn: config.verifier.options.expiresIn || "1h",
-        },
-    });
-};
-exports.prepareAccessTokenConfig = prepareAccessTokenConfig;
-const prepareRefreshTokenConfig = (config) => {
-    return Soap.removeUndefinedProperties({
-        ...config,
-        generation: {
-            ...config.issuer,
-            expiresIn: config.issuer.options.expiresIn || "7d",
-            algorithm: config.issuer.options.algorithm || "HS256",
-        },
-        verification: {
-            ...config.verifier.options,
-            algorithms: config.verifier.options.algorithms || ["HS256"],
-            expiresIn: config.verifier.options.expiresIn || "7d",
-        },
-    });
-};
-exports.prepareRefreshTokenConfig = prepareRefreshTokenConfig;
-const setDefaultJwtCookie = (token, context) => {
-    const options = {
-        httpOnly: true,
-        secure: true,
-        sameSite: "Strict",
-        maxAge: 7 * 24 * 60 * 60 * 1000,
-    };
-    if (context?.res) {
-        context.res.cookie("refreshToken", token, options);
+const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
+const errors_1 = require("../../errors");
+class JwtTools {
+    static generateAccessToken(payload, config) {
+        if (!config.issuer.secretKey) {
+            throw new errors_1.UndefinedTokenSecretError("Access");
+        }
+        return jsonwebtoken_1.default.sign(payload, config.issuer.secretKey, config.issuer.options);
     }
-    else if (context?.response) {
-        context.response.cookie("refreshToken", token, options);
+    static generateRefreshToken(payload, config) {
+        if (!config.issuer.secretKey) {
+            throw new errors_1.UndefinedTokenSecretError("Refresh");
+        }
+        return jsonwebtoken_1.default.sign(payload, config.issuer.secretKey, config.issuer.options);
     }
-    else if (context?.cookie) {
-        context.cookie("refreshToken", token, options);
+    static verifyAccessToken(token, config) {
+        if (!token)
+            throw new errors_1.UndefinedTokenError("Access");
+        if (!config.issuer.secretKey)
+            throw new errors_1.UndefinedTokenSecretError("Access");
+        try {
+            return jsonwebtoken_1.default.verify(token, config.issuer.secretKey, config.verifier.options);
+        }
+        catch (error) {
+            throw new errors_1.InvalidTokenError("Access");
+        }
     }
-};
-exports.setDefaultJwtCookie = setDefaultJwtCookie;
-const setDefaultJwtHeader = (token, context) => {
-    if (typeof context?.res?.setHeader === "function") {
-        context.res.setHeader("Authorization", `Bearer ${token}`);
+    static verifyRefreshToken(token, config) {
+        if (!token)
+            throw new errors_1.UndefinedTokenError("Refresh");
+        if (!config.issuer.secretKey)
+            throw new errors_1.UndefinedTokenSecretError("Refresh");
+        try {
+            return jsonwebtoken_1.default.verify(token, config.issuer.secretKey, config.verifier.options);
+        }
+        catch (error) {
+            throw new errors_1.InvalidTokenError("Refresh");
+        }
     }
-    else if (typeof context?.response?.setHeader === "function") {
-        context.response.setHeader("Authorization", `Bearer ${token}`);
+    static setAccessTokenHeader(token, context) {
+        context.res.setHeader("Authorization", `Bearer ${token}`);
     }
-    else if (typeof context?.setHeader === "function") {
-        context.setHeader("Authorization", `Bearer ${token}`);
+    static setRefreshTokenCookie(token, context) {
+        context.res.cookie("refreshToken", token, {
+            httpOnly: true,
+            secure: true,
+            sameSite: "Strict",
+        });
     }
-};
-exports.setDefaultJwtHeader = setDefaultJwtHeader;
-const clearDefaultJwtHeader = (context) => {
-    if (typeof context?.res?.setHeader === "function") {
-        context.res.setHeader("Authorization", ``);
+    static clearTokens(context) {
+        context.res.clearCookie("refreshToken");
+        context.res.setHeader("Authorization", "");
     }
-    else if (typeof context?.response?.setHeader === "function") {
-        context.response.setHeader("Authorization", ``);
+    static getAccessToken(context) {
+        return context.req.headers.authorization?.split(" ")[1];
     }
-    else if (typeof context?.setHeader === "function") {
-        context.setHeader("Authorization", ``);
+    static getRefreshToken(context) {
+        return context.req.cookies?.refreshToken;
     }
-};
-exports.clearDefaultJwtHeader = clearDefaultJwtHeader;
-const clearDefaultJwtCookie = (context) => {
-    const options = {
-        httpOnly: true,
-        secure: true,
-        sameSite: "Strict",
+    static prepareAccessTokenConfig = (config) => {
+        return Soap.removeUndefinedProperties({
+            ...config,
+            issuer: {
+                ...config.issuer,
+                options: {
+                    ...config.issuer.options,
+                    expiresIn: config.issuer.options.expiresIn || "1h",
+                    algorithm: config.issuer.options.algorithm || "HS256",
+                },
+            },
+            verifier: {
+                ...config.verifier,
+                options: {
+                    ...config.verifier.options,
+                    algorithms: config.verifier.options.algorithms || ["HS256"],
+                    expiresIn: config.verifier.options.expiresIn || "1h",
+                },
+            },
+        });
     };
-    if (typeof context?.res?.clearCookie === "function") {
-        context.res.clearCookie("refreshToken", options);
-    }
-    else if (typeof context?.response?.clearCookie === "function") {
-        context.response.clearCookie("refreshToken", options);
-    }
-    else if (typeof context?.clearCookie === "function") {
-        context.clearCookie("refreshToken", options);
-    }
+    static prepareRefreshTokenConfig = (config) => {
+        return Soap.removeUndefinedProperties({
+            ...config,
+            issuer: {
+                ...config.issuer,
+                options: {
+                    ...config.issuer.options,
+                    expiresIn: config.issuer.options.expiresIn || "7d",
+                    algorithm: config.issuer.options.algorithm || "HS256",
+                },
+            },
+            verifier: {
+                ...config.verifier,
+                options: {
+                    ...config.verifier.options,
+                    algorithms: config.verifier.options.algorithms || ["HS256"],
+                    expiresIn: config.verifier.options.expiresIn || "7d",
+                },
+            },
+        });
+    };
+    static setDefaultJwtCookie = (token, context) => {
+        const options = {
+            httpOnly: true,
+            secure: true,
+            sameSite: "Strict",
+            maxAge: 7 * 24 * 60 * 60 * 1000,
+        };
+        if (context?.res) {
+            context.res.cookie("refreshToken", token, options);
+        }
+        else if (context?.response) {
+            context.response.cookie("refreshToken", token, options);
+        }
+        else if (context?.cookie) {
+            context.cookie("refreshToken", token, options);
+        }
+    };
+    static setDefaultJwtHeader = (token, context) => {
+        if (typeof context?.res?.setHeader === "function") {
+            context.res.setHeader("Authorization", `Bearer ${token}`);
+        }
+        else if (typeof context?.response?.setHeader === "function") {
+            context.response.setHeader("Authorization", `Bearer ${token}`);
+        }
+        else if (typeof context?.setHeader === "function") {
+            context.setHeader("Authorization", `Bearer ${token}`);
+        }
+    };
+    static clearDefaultJwtHeader = (context) => {
+        if (typeof context?.res?.setHeader === "function") {
+            context.res.setHeader("Authorization", ``);
+        }
+        else if (typeof context?.response?.setHeader === "function") {
+            context.response.setHeader("Authorization", ``);
+        }
+        else if (typeof context?.setHeader === "function") {
+            context.setHeader("Authorization", ``);
+        }
+    };
+    static clearDefaultJwtCookie = (context) => {
+        const options = {
+            httpOnly: true,
+            secure: true,
+            sameSite: "Strict",
+        };
+        if (typeof context?.res?.clearCookie === "function") {
+            context.res.clearCookie("refreshToken", options);
+        }
+        else if (typeof context?.response?.clearCookie === "function") {
+            context.response.clearCookie("refreshToken", options);
+        }
+        else if (typeof context?.clearCookie === "function") {
+            context.clearCookie("refreshToken", options);
+        }
+    };
+}
+exports.JwtTools = JwtTools;
+const prepareJwtConfig = (config) => {
+    return Soap.removeUndefinedProperties({
+        ...config,
+        routes: {
+            login: config.routes?.login ?? {
+                path: "/auth/jwt/login",
+                method: "POST",
+            },
+            logout: config.routes?.logout ?? {
+                path: "/auth/jwt/logout",
+                method: "POST",
+            },
+            refresh: config.routes?.refresh ?? {
+                path: "/auth/jwt/refresh",
+                method: "POST",
+            },
+            ...config.routes,
+            user: {
+                ...config.user,
+                validateUser: config.user?.validateUser ?? (() => Promise.resolve(true)),
+            },
+            accessToken: JwtTools.prepareAccessTokenConfig(config.accessToken),
+            refreshToken: config.refreshToken
+                ? JwtTools.prepareRefreshTokenConfig(config.refreshToken)
+                : undefined,
+        },
+    });
 };
-exports.clearDefaultJwtCookie = clearDefaultJwtCookie;
+exports.prepareJwtConfig = prepareJwtConfig;

package/build/strategies/local/__tests__/local.strategy.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/strategies/local/__tests__/local.strategy.test.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const local_strategy_1 = require("../local.strategy");
+const errors_1 = require("../../../errors");
+describe("LocalStrategy", () => {
+    let strategy;
+    let mockConfig;
+    let mockSession;
+    let mockJwt;
+    beforeEach(() => {
+        mockConfig = {
+            credentials: {
+                extractCredentials: jest.fn(),
+                verifyCredentials: jest.fn(),
+            },
+            user: {
+                fetchUser: jest.fn(),
+            },
+            routes: {
+                login: {},
+                logout: {},
+            },
+        };
+        mockSession = {
+            issueSession: jest.fn(),
+        };
+        mockJwt = {
+            issueTokens: jest.fn(),
+        };
+        strategy = new local_strategy_1.LocalStrategy(mockConfig, mockSession, mockJwt);
+    });
+    describe("extractCredentials", () => {
+        it("should extract credentials from context", async () => {
+            const mockContext = { body: { username: "test", password: "pass123" } };
+            mockConfig.credentials.extractCredentials.mockResolvedValue({
+                identifier: "test",
+                password: "pass123",
+            });
+            const credentials = await strategy.extractCredentials(mockContext);
+            expect(credentials).toEqual({ identifier: "test", password: "pass123" });
+            expect(mockConfig.credentials.extractCredentials).toHaveBeenCalledWith(mockContext);
+        });
+        it("should throw MissingCredentialsError if no credentials are provided", async () => {
+            mockConfig.credentials.extractCredentials.mockRejectedValue(new errors_1.MissingCredentialsError());
+            await expect(strategy.extractCredentials({})).rejects.toThrow(errors_1.MissingCredentialsError);
+        });
+    });
+    describe("verifyCredentials", () => {
+        it("should verify credentials successfully", async () => {
+            mockConfig.credentials.verifyCredentials.mockResolvedValue(true);
+            const result = await strategy.verifyCredentials("test", "pass123");
+            expect(result).toBe(true);
+            expect(mockConfig.credentials.verifyCredentials).toHaveBeenCalledWith("test", "pass123");
+        });
+        it("should return false if credentials are invalid", async () => {
+            mockConfig.credentials.verifyCredentials.mockResolvedValue(false);
+            const result = await strategy.verifyCredentials("test", "wrongpass");
+            expect(result).toBe(false);
+            expect(mockConfig.credentials.verifyCredentials).toHaveBeenCalledWith("test", "wrongpass");
+        });
+    });
+    describe("fetchUser", () => {
+        it("should fetch user data", async () => {
+            const mockUser = { id: 1, username: "test" };
+            mockConfig.user.fetchUser.mockResolvedValue(mockUser);
+            const user = await strategy.fetchUser({
+                identifier: "test",
+                password: "pass123",
+            });
+            expect(user).toEqual(mockUser);
+            expect(mockConfig.user.fetchUser).toHaveBeenCalledWith("test");
+        });
+        it("should return null if user is not found", async () => {
+            mockConfig.user.fetchUser.mockResolvedValue(null);
+            const user = await strategy.fetchUser({
+                identifier: "unknown",
+                password: "pass123",
+            });
+            expect(user).toBeNull();
+            expect(mockConfig.user.fetchUser).toHaveBeenCalledWith("unknown");
+        });
+    });
+    describe("login", () => {
+        const mockContext = { body: { username: "test", password: "pass123" } };
+        const mockUser = { id: 1, username: "test" };
+        const mockTokens = { accessToken: "access", refreshToken: "refresh" };
+        const mockSessionData = { sessionId: "session123", data: mockUser };
+        beforeEach(() => {
+            mockConfig.credentials.extractCredentials.mockResolvedValue({
+                identifier: "test",
+                password: "pass123",
+            });
+            mockConfig.credentials.verifyCredentials.mockResolvedValue(true);
+            mockConfig.user.fetchUser.mockResolvedValue(mockUser);
+            mockJwt.issueTokens.mockResolvedValue(mockTokens);
+            mockSession.issueSession.mockResolvedValue(mockSessionData);
+        });
+        it("should login and return user with tokens and session", async () => {
+            const result = await strategy.login(mockContext);
+            expect(result.user).toEqual(mockUser);
+            expect(result.tokens).toEqual(mockTokens);
+            expect(result.session).toEqual(mockSessionData);
+            expect(mockJwt.issueTokens).toHaveBeenCalledWith(mockUser, mockContext);
+            expect(mockSession.issueSession).toHaveBeenCalledWith(mockUser, mockContext);
+        });
+        it("should throw InvalidCredentialsError if credentials are incorrect", async () => {
+            mockConfig.credentials.verifyCredentials.mockResolvedValue(false);
+            await expect(strategy.login(mockContext)).rejects.toThrow(errors_1.InvalidCredentialsError);
+        });
+        it("should throw UserNotFoundError if user is not found", async () => {
+            mockConfig.user.fetchUser.mockResolvedValue(null);
+            await expect(strategy.login(mockContext)).rejects.toThrow(errors_1.UserNotFoundError);
+        });
+    });
+});

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

@@ -2,17 +2,18 @@ import * as Soap from "@soapjs/soap";
 import { CredentialAuthStrategy } from "../credential-auth.strategy";
 import { LocalStrategyConfig } from "./local.types";
 import { SessionHandler } from "../../session/session-handler";
+import { JwtStrategy } from "../jwt/jwt.strategy";
 export declare class LocalStrategy<TContext = unknown, TUser = unknown> extends CredentialAuthStrategy<TContext, TUser> {
-    protected config: LocalStrategyConfig<TContext, TUser>;
     protected session?: SessionHandler;
+    protected jwt?: JwtStrategy<TContext, TUser>;
     protected logger?: Soap.Logger;
-    constructor(config: LocalStrategyConfig<TContext, TUser>, session?: SessionHandler, logger?: Soap.Logger);
+    constructor(config: LocalStrategyConfig<TContext, TUser>, session?: SessionHandler, jwt?: JwtStrategy<TContext, TUser>, logger?: Soap.Logger);
     protected extractCredentials(context?: TContext): Promise<{
         identifier: string;
         password: string;
     }>;
     protected verifyCredentials(identifier: string, password: string): Promise<boolean>;
-    protected retrieveUser(credentials: {
+    protected fetchUser(credentials: {
         identifier: string;
         password: string;
     }): Promise<TUser | null>;