@soapjs/soap-auth 0.1.1 → 0.3.0

package/README.md

@@ -1,223 +1,174 @@
-# SoapAuth
+# SoapAuth - Modular Authentication Solution
 
-**SoapAuth** is a flexible authentication and authorization module designed to provide support for various authentication strategies. It is intended to be used alongside a specific framework adapter, serving as the core authentication engine.
-
----
+SoapAuth is a flexible library for handling authentication and identity management. It allows you to easily implement various authentication strategies such as JWT, OAuth2, Basic Auth, Local Auth, API Key, and more. As part of the **@soapjs** ecosystem, it can be easily extended with additional components like **soap**, **soap-express**, and **soap-cli**.
 
 ## Installation
-
 ```sh
 npm install @soapjs/soap-auth
 ```
 
----
-
-## Features
-
-- Multiple authentication strategies (local, OAuth2, JWT, API key, basic auth)
-- Custom authentication strategy support
-- Built-in session management with pluggable session stores
-- Token handling for JWT authentication
-- Extensible architecture with abstract base classes
-- Compatible with framework adapters for seamless integration
+## Key Features
+- **Supports multiple authentication strategies** (JWT, OAuth2, API Key, Basic, Local, Hybrid OAuth2).
+- **Works with both HTTP and WebSocket protocols.**
+- **Manages sessions, MFA, roles, account locks, and rate limiting.**
+- **Easy configuration and extendability.**
+- **Integration with frameworks like Express, NestJS, etc.**
 
 ---
 
-## Core Classes Overview
-
-### 1. `SoapAuth`
-This is the main entry point for managing authentication. It initializes different strategies based on the provided configuration and provides methods for authentication, authorization, and session management.
-
-### 2. `AuthStrategy`
-The base interface that all strategies must implement. Provides methods such as `authenticate`, `authorize`, `init`, and `logout`.
-
-### 3. `SessionHandler`
-Handles session operations like retrieving, storing, and generating session IDs. It supports multiple session storage mechanisms such as in-memory and file-based stores.
-
-### 4. `TokenBasedAuthStrategy`
-Abstract class for token-based authentication strategies, providing methods for handling access and refresh tokens.
+## Basic Usage
+```typescript
+import { SoapAuth, JwtStrategy } from "@soapjs/soap-auth";
 
-### 5. `CredentialBasedAuthStrategy`
-Abstract class for username-password-based authentication strategies.
+const auth = new SoapAuth();
+auth.addStrategy(new JwtStrategy({ secret: "super-secret-key" }), "jwt", "http");
 
-### 6. `HttpAuthStrategyFactory` & `SocketAuthStrategyFactory`
-Factories responsible for creating instances of HTTP and socket-based authentication strategies respectively.
+const result = await auth.authenticate("http", "jwt", request);
+console.log(result.user);
+```
 
 ---
 
-## Available Authentication Strategies
-
-### 1. Local Strategy
+## Supported Authentication Strategies
 
-**When to use:**
-- Ideal for applications that require username and password authentication stored locally.
+SoapAuth supports multiple authentication strategies. Below is a description and example configuration for each.
 
-**Configuration example:**
+### **JWT Strategy** *(Token-based authentication)*
 ```typescript
-const authConfig = {
-  http: {
-    local: {
-      usernameField: "email",
-      passwordField: "password",
-      validateUser: async (username, password) => {
-        return username === "user@example.com" && password === "securepass" ? { id: 1, name: "John Doe" } : null;
-      },
-    },
+import { JwtStrategy } from "@soapjs/soap-auth";
+
+auth.addStrategy(new JwtStrategy({
+  secret: "your-secret-key",
+  accessToken: {
+    expiresIn: "1h",
+  },
+  refreshToken: {
+    expiresIn: "7d",
   },
-};
+}), "jwt", "http");
 ```
 
-### 2. OAuth2 Strategy
-
-**When to use:**
-- Suitable for social logins (Google, Facebook, Twitter, etc.).
-
-**Configuration example:**
+### **OAuth2 Strategy** *(OAuth 2.0 authentication)*
 ```typescript
-const authConfig = {
-  http: {
-    oauth2: {
-      google: {
-        clientId: "your-client-id",
-        clientSecret: "your-client-secret",
-        redirectUri: "https://yourapp.com/auth/callback",
-        scope: "openid profile email",
-        endpoints: {
-          authorizationUrl: "https://accounts.google.com/o/oauth2/auth",
-          tokenUrl: "https://oauth2.googleapis.com/token",
-        },
-      },
-    },
+import { OAuth2Strategy } from "@soapjs/soap-auth";
+
+auth.addStrategy(new OAuth2Strategy({
+  clientId: "your-client-id",
+  clientSecret: "your-client-secret",
+  redirectUri: "https://your-app.com/callback",
+  endpoints: {
+    authorizationUrl: "https://auth.server.com/auth",
+    tokenUrl: "https://auth.server.com/token",
   },
-};
+}), "oauth2", "http");
 ```
 
-### 3. JWT Strategy
-
-**When to use:**
-- Suitable for stateless authentication where tokens are passed between the client and server.
-
-**Configuration example:**
+### **API Key Strategy** *(Key-based authentication)*
 ```typescript
-const authConfig = {
-  http: {
-    jwt: {
-      access: {
-        secretKey: "your-secret-key",
-        expiresIn: "1h",
-        signOptions: { algorithm: "HS256" },
-      },
-    },
+import { ApiKeyStrategy } from "@soapjs/soap-auth";
+
+auth.addStrategy(new ApiKeyStrategy({
+  extractApiKey: (ctx) => ctx.headers["x-api-key"],
+  retrieveUserByApiKey: async (key) => {
+    return mockDatabase.findUserByApiKey(key);
   },
-};
+}), "apikey", "http");
 ```
 
-### 4. API Key Strategy
-
-**When to use:**
-- Best for authenticating external services using static API keys.
-
-**Configuration example:**
+### **Basic Auth Strategy** *(Username & Password authentication)*
 ```typescript
-const authConfig = {
-  http: {
-    apiKey: {
-      extractApiKey: (context) => context.headers["x-api-key"],
-      retrieveUserByApiKey: async (apiKey) => {
-        return apiKey === "valid-api-key" ? { id: 1, role: "admin" } : null;
-      },
-    },
+import { BasicStrategy } from "@soapjs/soap-auth";
+
+auth.addStrategy(new BasicStrategy({
+  extractCredentials: (ctx) => {
+    return { identifier: ctx.body.username, password: ctx.body.password };
   },
-};
+  verifyCredentials: async (id, pass) => {
+    return mockDatabase.verifyUser(id, pass);
+  },
+}), "basic", "http");
 ```
 
-### 5. Basic Authentication
+### **Local Strategy** *(Custom authentication logic)*
+```typescript
+import { LocalStrategy } from "@soapjs/soap-auth";
 
-**When to use:**
-- Useful for simple username-password authentication with minimal overhead.
+auth.addStrategy(new LocalStrategy({
+  extractCredentials: (ctx) => ({ identifier: ctx.query.email, password: ctx.query.pass }),
+  verifyCredentials: async (id, pass) => {
+    return mockDatabase.verifyUser(id, pass);
+  },
+}), "local", "http");
+```
 
-**Configuration example:**
+### **Hybrid OAuth2 Strategy** *(Combination of multiple authentication methods)*
 ```typescript
-const authConfig = {
-  http: {
-    basic: {
-      validateUser: async (username, password) => {
-        return username === "admin" && password === "password" ? { id: 1, role: "admin" } : null;
-      },
+import { HybridOAuth2Strategy } from "@soapjs/soap-auth";
+
+auth.addStrategy(new HybridOAuth2Strategy({
+  clientId: "your-client-id",
+  clientSecret: "your-client-secret",
+  oauth2: {
+    endpoints: {
+      authorizationUrl: "https://oauth.provider.com/auth",
+      tokenUrl: "https://oauth.provider.com/token",
     },
   },
-};
+}), "hybrid-oauth2", "http");
 ```
 
 ---
 
-## Using SoapAuth
-
+## Configuration & Extensions
+### Role Management
 ```typescript
-import { SoapAuth } from "@soapjs/soap-auth";
-
-const auth = new SoapAuth(authConfig);
-await auth.init();
-
-const user = await auth.authenticate("local", { email: "user@example.com", password: "securepass" });
-console.log("Authenticated user:", user);
+role: {
+  authorizeByRoles: async (user, roles) => roles.includes(user.role),
+  roles: ["admin", "user"]
+}
 ```
-
----
-
-## Creating a Custom Authentication Strategy
-
-To create a custom strategy, extend the appropriate base class depending on the authentication type:
-
-1. **For token-based strategies:** Extend `TokenBasedAuthStrategy`.
-2. **For credential-based strategies:** Extend `CredentialBasedAuthStrategy`.
-3. **For generic implementations:** Extend `BaseAuthStrategy` directly.
-
-**Example:**
+### Multi-Factor Authentication (MFA)
 ```typescript
-class CustomAuthStrategy extends TokenBasedAuthStrategy {
-  async authenticate(context) {
-    const token = context.headers.authorization;
-    if (token === "valid-token") {
-      return { user: { id: 1, role: "admin" }, tokens: { accessToken: token } };
-    }
-    throw new Error("Invalid token");
-  }
+mfa: {
+  isMfaRequired: (user) => user.requiresMfa,
+  validateMfaCode: async (user, code) => mockDatabase.checkMfaCode(user, code),
 }
 ```
-
----
-
-## Session Management
-
-SoapAuth supports session management through the `SessionHandler` class. The session can be stored using memory, files, or external databases via adapters.
-
-**Example Session Configuration:**
+### Account Locking after Failed Logins
 ```typescript
-const authConfig = {
-  session: {
-    secret: "your-session-secret",
-    sessionKey: "my-session-id",
-    store: new MemorySessionStore(),
-  },
-};
+lock: {
+  isAccountLocked: async (account) => mockDatabase.isLocked(account),
+  lockAccount: async (account) => mockDatabase.lock(account),
+}
+```
+### Rate Limiting
+```typescript
+rateLimit: {
+  checkRateLimit: async (ctx) => false, // No limits
+}
 ```
 
 ---
 
-## Framework Integration
+## FAQ
+**How to report an issue?**  
+Open an issue on GitHub.  
 
-SoapAuth is designed to work with various frameworks such as Express, Koa, Fastify, and more through dedicated adapters.
+**How to extend `soap-auth` with custom strategies?**  
+You can create your own class extending `BaseAuthStrategy` and implementing `authenticate()`.  
 
-```typescript
-// basic example
-app.use(async (req, res, next) => {
-  try {
-    const user = await auth.authenticate("jwt", req);
-    req.user = user;
-    next();
-  } catch (error) {
-    res.status(401).send("Unauthorized");
-  }
-});
-```
+---
+## Issues
+If you encounter any issues, please feel free to report them [here](https://github.com/soapjs/soap/issues/new/choose).
+
+## Contact
+For any questions, collaboration interests, or support needs, you can contact us through the following:
+
+- Official:
+  - Website: http://docs.soapjs.com
+- Radoslaw Kamysz:
+  - Email: [radoslaw.kamysz@gmail.com](mailto:radoslaw.kamysz@gmail.com)
+  - Warpcast: [@k4mr4ad](https://warpcast.com/k4mr4ad)
+  - Twitter: [@radoslawkamysz](https://x.com/radoslawkamysz)
+## License
+SoapAuth is licensed under the MIT License.

package/build/factories/http-auth-strategy.factory.js

@@ -15,7 +15,7 @@ class HttpAuthStrategyFactory extends auth_strategy_factory_1.AuthStrategyFactor
         }
         if (config.http.oauth2) {
             for (const provider in config.http.oauth2) {
-                strategies.set(provider, new oauth2_strategy_1.OAuth2Strategy(config.http.oauth2[provider], config.http.oauth2[provider].accessToken, config.http.oauth2[provider].refreshToken, this.getSessionHandler(config.http.oauth2[provider].session, config.session), config.logger));
+                strategies.set(provider, new oauth2_strategy_1.OAuth2Strategy(config.http.oauth2[provider], this.getSessionHandler(config.http.oauth2[provider].session, config.session), config.logger));
             }
         }
         if (config.http.apiKey) {

package/build/factories/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./auth-strategy.factory";
+export * from "./http-auth-strategy.factory";
+export * from "./socket-auth-strategy.factory";

package/build/factories/index.js

@@ -0,0 +1,19 @@
+"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("./auth-strategy.factory"), exports);
+__exportStar(require("./http-auth-strategy.factory"), exports);
+__exportStar(require("./socket-auth-strategy.factory"), exports);

package/build/index.d.ts

@@ -1,28 +1,7 @@
-export * from "./factories/auth-strategy.factory";
-export * from "./factories/http-auth-strategy.factory";
-export * from "./factories/socket-auth-strategy.factory";
-export * from "./session/file.session-store";
-export * from "./session/memory.session-store";
-export * from "./session/session-handler";
-export * from "./strategies/api-key/api-key.errors";
-export * from "./strategies/api-key/api-key.strategy";
-export * from "./strategies/api-key/api-key.types";
-export * from "./strategies/base-auth.strategy";
-export * from "./strategies/basic/basic.strategy";
-export * from "./strategies/basic/basic.types";
-export * from "./strategies/credential-based-auth.strategy";
-export * from "./strategies/jwt/jwt.strategy";
-export * from "./strategies/jwt/jwt.tools";
-export * from "./strategies/jwt/jwt.types";
-export * from "./strategies/local/local.strategy";
-export * from "./strategies/local/local.types";
-export * from "./strategies/oauth2/oauth2.strategy";
-export * from "./strategies/oauth2/oauth2.tools";
-export * from "./strategies/oauth2/oauth2.types";
-export * from "./strategies/token-based-auth.strategy";
-export * from "./tools/session.tools";
-export * from "./tools/token.tools";
-export * from "./tools/tools";
+export * from "./factories";
+export * from "./session";
+export * from "./strategies";
+export * from "./tools";
 export * from "./errors";
 export * from "./types";
 export * from "./soap-auth";

package/build/index.js

@@ -14,31 +14,10 @@ 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("./factories/auth-strategy.factory"), exports);
-__exportStar(require("./factories/http-auth-strategy.factory"), exports);
-__exportStar(require("./factories/socket-auth-strategy.factory"), exports);
-__exportStar(require("./session/file.session-store"), exports);
-__exportStar(require("./session/memory.session-store"), exports);
-__exportStar(require("./session/session-handler"), exports);
-__exportStar(require("./strategies/api-key/api-key.errors"), exports);
-__exportStar(require("./strategies/api-key/api-key.strategy"), exports);
-__exportStar(require("./strategies/api-key/api-key.types"), exports);
-__exportStar(require("./strategies/base-auth.strategy"), exports);
-__exportStar(require("./strategies/basic/basic.strategy"), exports);
-__exportStar(require("./strategies/basic/basic.types"), exports);
-__exportStar(require("./strategies/credential-based-auth.strategy"), exports);
-__exportStar(require("./strategies/jwt/jwt.strategy"), exports);
-__exportStar(require("./strategies/jwt/jwt.tools"), exports);
-__exportStar(require("./strategies/jwt/jwt.types"), exports);
-__exportStar(require("./strategies/local/local.strategy"), exports);
-__exportStar(require("./strategies/local/local.types"), exports);
-__exportStar(require("./strategies/oauth2/oauth2.strategy"), exports);
-__exportStar(require("./strategies/oauth2/oauth2.tools"), exports);
-__exportStar(require("./strategies/oauth2/oauth2.types"), exports);
-__exportStar(require("./strategies/token-based-auth.strategy"), exports);
-__exportStar(require("./tools/session.tools"), exports);
-__exportStar(require("./tools/token.tools"), exports);
-__exportStar(require("./tools/tools"), exports);
+__exportStar(require("./factories"), exports);
+__exportStar(require("./session"), exports);
+__exportStar(require("./strategies"), exports);
+__exportStar(require("./tools"), exports);
 __exportStar(require("./errors"), exports);
 __exportStar(require("./types"), exports);
 __exportStar(require("./soap-auth"), exports);

package/build/session/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./file.session-store";
+export * from "./memory.session-store";
+export * from "./session-handler";

package/build/session/index.js

@@ -0,0 +1,19 @@
+"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("./file.session-store"), exports);
+__exportStar(require("./memory.session-store"), exports);
+__exportStar(require("./session-handler"), exports);

package/build/soap-auth.d.ts

@@ -1,16 +1,16 @@
 import { AuthResult, AuthStrategy, SoapAuthConfig } from "./types";
 export declare class SoapAuth {
     private requiredStrategyMethods;
-    private httpStrategies;
-    private socketStrategies;
+    private strategies;
+    private logger?;
     constructor(config: SoapAuthConfig);
     private isAuthStrategy;
-    addStrategy(strategiesMap: Map<string, AuthStrategy>, type: string, strategyInstance: AuthStrategy | undefined): void;
-    removeStrategy(type: string): boolean;
-    hasStrategy(type: string): boolean;
-    getStrategy(strategyName: string, layer?: "http" | "socket"): AuthStrategy | undefined;
-    listStrategies(): string[];
+    addStrategy(strategyInstance: AuthStrategy | undefined, name: string, type: "http" | "socket"): void;
+    removeStrategy(name: string | string[], type: "http" | "socket"): void;
+    hasStrategy(name: string, type: "http" | "socket"): boolean;
+    getStrategy(name: string, type: "http" | "socket"): AuthStrategy | undefined;
+    listStrategies(type: "http" | "socket"): string[];
     init(sequential?: boolean): Promise<void>;
-    authenticate(strategyName: string, context: any): Promise<AuthResult<any>>;
-    logout(strategyName: string, context: any): Promise<void>;
+    authenticate(type: "http" | "socket", name: string, context: any): Promise<AuthResult<any>>;
+    logout(type: "http" | "socket", name: string, context: any): Promise<void>;
 }

package/build/soap-auth.js

@@ -5,71 +5,101 @@ const http_auth_strategy_factory_1 = require("./factories/http-auth-strategy.fac
 const socket_auth_strategy_factory_1 = require("./factories/socket-auth-strategy.factory");
 class SoapAuth {
     requiredStrategyMethods = ["authenticate", "init"];
-    httpStrategies = new Map();
-    socketStrategies = new Map();
+    strategies = new Map();
+    logger;
     constructor(config) {
         const httpFactory = new http_auth_strategy_factory_1.HttpAuthStrategyFactory(config.logger);
-        this.httpStrategies = httpFactory.createStrategies(config);
         const socketFactory = new socket_auth_strategy_factory_1.SocketAuthStrategyFactory(config.logger);
-        this.socketStrategies = socketFactory.createStrategies(config);
+        const httpStrategies = httpFactory.createStrategies(config);
+        const socketStrategies = socketFactory.createStrategies(config);
+        this.strategies.set("http", httpStrategies);
+        this.strategies.set("socket", socketStrategies);
+        this.logger = config.logger;
     }
     isAuthStrategy(strategy) {
-        const isValidStrategy = this.requiredStrategyMethods.every((method) => typeof strategy[method] === "function");
-        return isValidStrategy;
+        return (typeof strategy === "object" &&
+            strategy !== null &&
+            this.requiredStrategyMethods.every((method) => typeof strategy[method] === "function"));
     }
-    addStrategy(strategiesMap, type, strategyInstance) {
+    addStrategy(strategyInstance, name, type) {
+        if (!this.strategies.has(type)) {
+            throw new Error(`Invalid strategy type "${type}". Expected "http" or "socket".`);
+        }
         if (this.isAuthStrategy(strategyInstance)) {
-            strategiesMap.set(type, strategyInstance);
+            this.strategies.get(type).set(name, strategyInstance);
         }
-    }
-    removeStrategy(type) {
-        if (this.httpStrategies.has(type)) {
-            this.httpStrategies.delete(type);
-            return true;
+        else {
+            this.logger?.error("Invalid authentication strategy provided.");
+            throw new Error("Invalid authentication strategy: does not implement required methods.");
         }
-        if (this.socketStrategies.has(type)) {
-            this.socketStrategies.delete(type);
-            return true;
+    }
+    removeStrategy(name, type) {
+        if (!this.strategies.has(type)) {
+            throw new Error(`Invalid strategy type "${type}". Expected "http" or "socket".`);
         }
-        return false;
+        const names = Array.isArray(name) ? name : [name];
+        names.forEach((n) => {
+            this.strategies.get(type).delete(n);
+        });
     }
-    hasStrategy(type) {
-        return this.httpStrategies.has(type) || this.socketStrategies.has(type);
+    hasStrategy(name, type) {
+        if (!this.strategies.has(type)) {
+            throw new Error(`Invalid strategy type "${type}". Expected "http" or "socket".`);
+        }
+        return this.strategies.get(type).has(name);
     }
-    getStrategy(strategyName, layer = "http") {
-        return layer === "http"
-            ? this.httpStrategies.get(strategyName)
-            : this.socketStrategies.get(strategyName);
+    getStrategy(name, type) {
+        if (!this.strategies.has(type)) {
+            throw new Error(`Invalid strategy type "${type}". Expected "http" or "socket".`);
+        }
+        const strategy = this.strategies.get(type).get(name);
+        if (!strategy) {
+            throw new Error(`Authentication strategy "${name}" not found.`);
+        }
+        return strategy;
     }
-    listStrategies() {
-        return [...this.httpStrategies.keys(), ...this.socketStrategies.keys()];
+    listStrategies(type) {
+        if (!this.strategies.has(type)) {
+            throw new Error(`Invalid strategy type "${type}". Expected "http" or "socket".`);
+        }
+        return Array.from(this.strategies.get(type).keys());
     }
     async init(sequential = false) {
         const strategies = [
-            ...this.httpStrategies.values(),
-            ...this.socketStrategies.values(),
+            ...this.strategies.get("http").values(),
+            ...this.strategies.get("socket").values(),
         ];
         if (sequential) {
             for (const strategy of strategies) {
-                await strategy.init();
+                try {
+                    await strategy.init();
+                }
+                catch (error) {
+                    this.logger?.error(`Failed to initialize strategy: ${error.message}`);
+                }
             }
         }
         else {
-            await Promise.all(strategies.map((strategy) => strategy.init()));
+            await Promise.all(strategies.map((strategy) => strategy
+                .init()
+                .catch((error) => this.logger?.error(`Failed to initialize strategy: ${error.message}`))));
         }
     }
-    async authenticate(strategyName, context) {
-        const strategy = this.getStrategy(strategyName);
+    async authenticate(type, name, context) {
+        const strategy = this.getStrategy(name, type);
         if (!strategy) {
-            throw new Error(`Authentication strategy "${strategyName}" not found.`);
+            throw new Error(`Authentication strategy "${name}" not found.`);
         }
         return strategy.authenticate(context);
     }
-    async logout(strategyName, context) {
-        const strategy = this.getStrategy(strategyName);
+    async logout(type, name, context) {
+        const strategy = this.getStrategy(name, type);
         if (strategy?.logout) {
             await strategy.logout(context);
         }
+        else {
+            this.logger?.error(`No "logout" implementation in strategy "${name}".`);
+        }
     }
 }
 exports.SoapAuth = SoapAuth;