@soapjs/soap-auth 0.1.1 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@soapjs/soap-auth",
-  "version": "0.1.1",
+  "version": "0.3.0",
   "description": "",
   "homepage": "https://docs.soapjs.com",
   "repository": "https://github.com/soapjs/soap-auth",
@@ -28,6 +28,7 @@
     "axios": "^1.7.9",
     "bcrypt": "^5.1.1",
     "jsonwebtoken": "^9.0.2",
+    "jwks-rsa": "^3.1.0",
     "uuid": "^9.0.1"
   }
 }

package/build/strategies/token-based-auth.strategy.d.ts

@@ -1,25 +0,0 @@
-import * as Soap from "@soapjs/soap";
-import { AuthResult, TokenBasedAuthStrategyConfig } from "../types";
-import { BaseAuthStrategy } from "./base-auth.strategy";
-import { TokenConfig } from "../types";
-import { SessionHandler } from "../session/session-handler";
-export declare abstract class TokenBasedAuthStrategy<TContext = unknown, TUser = unknown> extends BaseAuthStrategy<TContext, TUser> {
-    protected config: TokenBasedAuthStrategyConfig<TContext, TUser>;
-    protected accessTokenConfig?: TokenConfig;
-    protected refreshTokenConfig?: TokenConfig;
-    protected session?: SessionHandler;
-    protected logger?: Soap.Logger;
-    constructor(config: TokenBasedAuthStrategyConfig<TContext, TUser>, accessTokenConfig?: TokenConfig, refreshTokenConfig?: TokenConfig, session?: SessionHandler, logger?: Soap.Logger);
-    protected retrieveUser(decodedToken: any): Promise<TUser | null>;
-    authenticate(context: TContext): Promise<AuthResult<TUser>>;
-    logout(context: TContext): Promise<void>;
-    generateTokens(user: TUser, context: TContext): Promise<{
-        accessToken: string;
-        refreshToken?: string;
-    }>;
-    rotateToken(context: TContext): Promise<{
-        accessToken: string;
-        refreshToken?: string;
-    }>;
-    isTokenExpired(token: string): Promise<boolean>;
-}

package/build/strategies/token-based-auth.strategy.js

@@ -1,130 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TokenBasedAuthStrategy = void 0;
-const base_auth_strategy_1 = require("./base-auth.strategy");
-const errors_1 = require("../errors");
-class TokenBasedAuthStrategy extends base_auth_strategy_1.BaseAuthStrategy {
-    config;
-    accessTokenConfig;
-    refreshTokenConfig;
-    session;
-    logger;
-    constructor(config, accessTokenConfig, refreshTokenConfig, session, logger) {
-        super(config, session, logger);
-        this.config = config;
-        this.accessTokenConfig = accessTokenConfig;
-        this.refreshTokenConfig = refreshTokenConfig;
-        this.session = session;
-        this.logger = logger;
-    }
-    retrieveUser(decodedToken) {
-        return this.config.login.retrieveUserData(decodedToken);
-    }
-    async authenticate(context) {
-        try {
-            let accessToken = await this.accessTokenConfig.retrieve?.(context);
-            let refreshToken;
-            await this.checkRateLimit(context);
-            if (accessToken) {
-                try {
-                    const decoded = await this.accessTokenConfig.verify?.(accessToken);
-                    const user = await this.retrieveUser(decoded);
-                    if (!user) {
-                        throw new errors_1.UserNotFoundError();
-                    }
-                    await this.isAuthorized(user);
-                    return { user, tokens: { accessToken } };
-                }
-                catch (error) {
-                    this.logger?.warn("Access token is invalid or expired, trying refresh token...");
-                }
-            }
-            if (this.refreshTokenConfig) {
-                refreshToken = await this.refreshTokenConfig?.retrieve?.(context);
-                if (!refreshToken) {
-                    throw new errors_1.MissingTokenError("Refresh");
-                }
-                accessToken = await this.refreshTokenConfig?.rotate?.(refreshToken);
-                if (!accessToken) {
-                    throw new errors_1.MissingTokenError("Access");
-                }
-            }
-            this.accessTokenConfig.embed?.(context, accessToken);
-            const decoded = await this.accessTokenConfig.verify?.(accessToken);
-            const user = await this.retrieveUser(decoded);
-            if (!user) {
-                throw new errors_1.UserNotFoundError();
-            }
-            await this.isAuthorized(user);
-            return { user, tokens: { accessToken, refreshToken } };
-        }
-        catch (error) {
-            this.logger?.error("Authentication failed:", error);
-            throw new errors_1.AuthError(error, "Authentication failed.");
-        }
-    }
-    async logout(context) {
-        try {
-            await this.accessTokenConfig.remove?.(context);
-            if (this.refreshTokenConfig) {
-                await this.refreshTokenConfig.remove?.(context);
-            }
-            await this.config.logout.onSuccess?.(context);
-            this.logger?.info("User logged out successfully.");
-        }
-        catch (error) {
-            this.logger?.error("Error during logout:", error);
-            await this.config.logout.onFailure?.({ context, error });
-            throw new errors_1.AuthError(error, "Logout process failed.");
-        }
-    }
-    async generateTokens(user, context) {
-        const payload = { userId: user.id, roles: user.roles };
-        const accessToken = this.accessTokenConfig.generate?.(payload);
-        if (!accessToken)
-            throw new Error("Failed to generate access token.");
-        await this.accessTokenConfig.store?.(accessToken, user, +this.accessTokenConfig.expiresIn);
-        this.accessTokenConfig.embed?.(context, accessToken);
-        let refreshToken;
-        if (this.refreshTokenConfig) {
-            refreshToken = this.refreshTokenConfig.generate?.(payload);
-            if (refreshToken) {
-                await this.refreshTokenConfig.store?.(refreshToken, user, +this.refreshTokenConfig.expiresIn);
-                this.refreshTokenConfig.embed?.(context, refreshToken);
-            }
-        }
-        return { accessToken, refreshToken };
-    }
-    async rotateToken(context) {
-        try {
-            if (!this.refreshTokenConfig) {
-                throw new Error("Refresh token handler is not configured.");
-            }
-            const refreshToken = await this.refreshTokenConfig.retrieve?.(context);
-            if (!refreshToken) {
-                throw new errors_1.MissingTokenError("Refresh");
-            }
-            const newAccessToken = await this.refreshTokenConfig.rotate?.(refreshToken);
-            this.accessTokenConfig.embed?.(context, newAccessToken);
-            return { accessToken: newAccessToken, refreshToken };
-        }
-        catch (error) {
-            this.logger?.error("Token rotation failed:", error);
-            throw new errors_1.InvalidTokenError("Refresh");
-        }
-    }
-    async isTokenExpired(token) {
-        try {
-            const decoded = JSON.parse(Buffer.from(token.split(".")[1], "base64").toString());
-            if (!decoded.exp)
-                return false;
-            const currentTime = Math.floor(Date.now() / 1000);
-            return decoded.exp < currentTime;
-        }
-        catch (error) {
-            this.logger?.warn("Failed to decode token:", error);
-            return false;
-        }
-    }
-}
-exports.TokenBasedAuthStrategy = TokenBasedAuthStrategy;