@soapjs/soap-auth 0.3.3 → 0.4.0

package/build/services/totp.service.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TotpService = void 0;
+const crypto_1 = require("crypto");
+const BASE32_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
+function base32Encode(buf) {
+    let bits = 0;
+    let value = 0;
+    let output = "";
+    for (const byte of buf) {
+        value = (value << 8) | byte;
+        bits += 8;
+        while (bits >= 5) {
+            output += BASE32_CHARS[(value >>> (bits - 5)) & 31];
+            bits -= 5;
+        }
+    }
+    if (bits > 0) {
+        output += BASE32_CHARS[(value << (5 - bits)) & 31];
+    }
+    return output;
+}
+function base32Decode(str) {
+    const s = str.replace(/=+$/, "").toUpperCase();
+    const bytes = [];
+    let bits = 0;
+    let value = 0;
+    for (const ch of s) {
+        const idx = BASE32_CHARS.indexOf(ch);
+        if (idx === -1)
+            throw new Error(`Invalid base32 character: ${ch}`);
+        value = (value << 5) | idx;
+        bits += 5;
+        if (bits >= 8) {
+            bytes.push((value >>> (bits - 8)) & 255);
+            bits -= 8;
+        }
+    }
+    return Buffer.from(bytes);
+}
+function hotp(key, counter, digits) {
+    const buf = Buffer.alloc(8);
+    buf.writeBigUInt64BE(counter);
+    const hmac = (0, crypto_1.createHmac)("sha1", key).update(buf).digest();
+    const offset = hmac[hmac.length - 1] & 0x0f;
+    const code = ((hmac[offset] & 0x7f) << 24) |
+        ((hmac[offset + 1] & 0xff) << 16) |
+        ((hmac[offset + 2] & 0xff) << 8) |
+        (hmac[offset + 3] & 0xff);
+    return String(code % 10 ** digits).padStart(digits, "0");
+}
+class TotpService {
+    step;
+    digits;
+    window;
+    constructor(options = {}) {
+        this.step = options.step ?? 30;
+        this.digits = options.digits ?? 6;
+        this.window = options.window ?? 1;
+    }
+    generateSecret(byteLength = 20) {
+        return base32Encode((0, crypto_1.randomBytes)(byteLength));
+    }
+    generateOTP(secret, timestamp = Date.now()) {
+        const key = base32Decode(secret);
+        const counter = BigInt(Math.floor(timestamp / 1000 / this.step));
+        return hotp(key, counter, this.digits);
+    }
+    verifyOTP(secret, code, timestamp = Date.now()) {
+        if (!/^\d+$/.test(code) || code.length !== this.digits)
+            return false;
+        const key = base32Decode(secret);
+        const counter = BigInt(Math.floor(timestamp / 1000 / this.step));
+        for (let delta = -this.window; delta <= this.window; delta++) {
+            const expected = hotp(key, counter + BigInt(delta), this.digits);
+            if (expected === code)
+                return true;
+        }
+        return false;
+    }
+    generateQRUri(secret, issuer, account) {
+        const params = new URLSearchParams({
+            secret,
+            issuer,
+            algorithm: "SHA1",
+            digits: String(this.digits),
+            period: String(this.step),
+        });
+        const label = `${encodeURIComponent(issuer)}:${encodeURIComponent(account)}`;
+        return `otpauth://totp/${label}?${params.toString()}`;
+    }
+    generateBackupCodes(count = 8) {
+        return Array.from({ length: count }, () => (0, crypto_1.randomBytes)(6).toString("hex").toUpperCase());
+    }
+}
+exports.TotpService = TotpService;

package/build/session/__tests__/session-handler.test.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const session_handler_1 = require("../session-handler");
 const session_errors_1 = require("../session.errors");
+const validation_1 = require("../../utils/validation");
 describe("SessionHandler", () => {
     let mockStore;
     let mockLogger;
@@ -21,6 +22,7 @@ describe("SessionHandler", () => {
             warn: jest.fn(),
         };
         config = {
+            secret: "test-secret-key",
             store: mockStore,
             sessionKey: "CUSTOMSESSION",
             sessionHeader: "x-custom-session",
@@ -29,7 +31,7 @@ describe("SessionHandler", () => {
                 maxAge: 3600,
             },
             generateSessionId: jest.fn(),
-            getSessionId: undefined,
+            getSessionId: jest.fn(),
             embedSessionId: undefined,
             createSessionData: undefined,
         };
@@ -39,10 +41,10 @@ describe("SessionHandler", () => {
         it("should throw if store is not provided", () => {
             expect(() => {
                 new session_handler_1.SessionHandler({});
-            }).toThrowError("Session store is required.");
+            }).toThrowError("config.secret is required");
         });
         it("should set default sessionKey and headerKey if not provided", () => {
-            const newHandler = new session_handler_1.SessionHandler({ store: mockStore });
+            const newHandler = new session_handler_1.SessionHandler({ secret: "test-secret", store: mockStore });
             expect(newHandler.sessionKey).toBe("SESSIONID");
             expect(newHandler.headerKey).toBe("x-session-id");
         });
@@ -94,7 +96,7 @@ describe("SessionHandler", () => {
                 throw new Error("Test error");
             });
             const handler = new session_handler_1.SessionHandler(config, mockLogger);
-            handler.setSessionId({}, "boom");
+            expect(() => handler.setSessionId({}, "boom")).toThrow("Test error");
             expect(mockLogger.error).toHaveBeenCalledWith("Error setting session ID:", expect.any(Error));
         });
     });
@@ -107,23 +109,31 @@ describe("SessionHandler", () => {
             expect(config.getSessionId).toHaveBeenCalled();
         });
         it("should return cookie session if present", () => {
+            config.getSessionId = undefined;
+            const handler = new session_handler_1.SessionHandler(config, mockLogger);
             const context = { cookies: { CUSTOMSESSION: "cookieValue" } };
-            const sid = sessionHandler.getSessionId(context);
+            const sid = handler.getSessionId(context);
             expect(sid).toBe("cookieValue");
         });
         it("should return header session if present", () => {
+            config.getSessionId = undefined;
+            const handler = new session_handler_1.SessionHandler(config, mockLogger);
             const context = { headers: { "x-custom-session": "headerValue" } };
-            const sid = sessionHandler.getSessionId(context);
+            const sid = handler.getSessionId(context);
             expect(sid).toBe("headerValue");
         });
         it("should return sessionId if set directly on context", () => {
+            config.getSessionId = undefined;
+            const handler = new session_handler_1.SessionHandler(config, mockLogger);
             const context = { sessionId: "directValue" };
-            const sid = sessionHandler.getSessionId(context);
+            const sid = handler.getSessionId(context);
             expect(sid).toBe("directValue");
         });
         it("should return null if not found", () => {
+            config.getSessionId = undefined;
+            const handler = new session_handler_1.SessionHandler(config, mockLogger);
             const context = {};
-            const sid = sessionHandler.getSessionId(context);
+            const sid = handler.getSessionId(context);
             expect(sid).toBeNull();
         });
         it("should log error and return null if something goes wrong", () => {
@@ -180,10 +190,8 @@ describe("SessionHandler", () => {
         });
     });
     describe("setSessionData", () => {
-        it("should warn if sessionId is falsy", async () => {
-            await sessionHandler.setSessionData("", { user: {} });
-            expect(mockLogger.warn).toHaveBeenCalledWith("No session ID found, unable to set session.");
-            expect(mockStore.setSession).not.toHaveBeenCalled();
+        it("should throw ValidationError if sessionId is falsy", async () => {
+            await expect(sessionHandler.setSessionData("", { user: {} })).rejects.toThrow(validation_1.ValidationError);
         });
         it("should call store.setSession with provided data", async () => {
             await sessionHandler.setSessionData("sessionXYZ", {
@@ -196,9 +204,9 @@ describe("SessionHandler", () => {
         });
         it("should log error if store.setSession fails", async () => {
             mockStore.setSession.mockRejectedValue(new Error("Store error"));
-            await sessionHandler.setSessionData("session123", {
+            await expect(sessionHandler.setSessionData("session123", {
                 user: { id: "xyz" },
-            });
+            })).rejects.toThrow("Store error");
             expect(mockLogger.error).toHaveBeenCalledWith("Error storing session data:", expect.any(Error));
         });
     });

package/build/session/session-handler.d.ts

@@ -7,6 +7,7 @@ export declare class SessionHandler<TContext = unknown, TUser = unknown, TData =
     private sessionKey;
     private headerKey;
     constructor(config: SessionConfig, logger?: Soap.Logger);
+    private validateConfig;
     setSessionId(context: TContext, sessionId: string): void;
     getSessionId(context: TContext): string | null;
     generateSessionId(): string;

package/build/session/session-handler.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SessionHandler = void 0;
-const uuid_1 = require("uuid");
+const crypto_1 = require("crypto");
 const session_errors_1 = require("./session.errors");
+const validation_1 = require("../utils/validation");
 class SessionHandler {
     config;
     logger;
@@ -12,6 +13,7 @@ class SessionHandler {
     constructor(config, logger) {
         this.config = config;
         this.logger = logger;
+        this.validateConfig(config);
         if (!config.store) {
             throw new Error("Session store is required.");
         }
@@ -19,8 +21,37 @@ class SessionHandler {
         this.sessionKey = config.sessionKey || "SESSIONID";
         this.headerKey = config.sessionHeader || "x-session-id";
     }
+    validateConfig(config) {
+        try {
+            validation_1.ValidationUtils.required(config, "config");
+            validation_1.ValidationUtils.required(config.secret, "config.secret");
+            validation_1.ValidationUtils.nonEmptyString(config.secret, "config.secret");
+            validation_1.ValidationUtils.required(config.store, "config.store");
+            validation_1.ValidationUtils.object(config.store, "config.store");
+            if (config.sessionKey) {
+                validation_1.ValidationUtils.nonEmptyString(config.sessionKey, "config.sessionKey");
+            }
+            if (config.sessionHeader) {
+                validation_1.ValidationUtils.nonEmptyString(config.sessionHeader, "config.sessionHeader");
+            }
+            const requiredMethods = ['getSession', 'setSession', 'destroySession', 'touchSession', 'getSessionIds'];
+            for (const method of requiredMethods) {
+                if (typeof config.store[method] !== 'function') {
+                    throw new validation_1.ValidationError(`Session store must implement ${method} method`);
+                }
+            }
+        }
+        catch (error) {
+            if (error instanceof validation_1.ValidationError) {
+                throw error;
+            }
+            throw new validation_1.ValidationError(`Invalid SessionHandler configuration: ${error.message}`);
+        }
+    }
     setSessionId(context, sessionId) {
         try {
+            validation_1.ValidationUtils.required(context, "context");
+            validation_1.ValidationUtils.nonEmptyString(sessionId, "sessionId");
             if (this.config.embedSessionId) {
                 this.config.embedSessionId(context, sessionId);
                 return;
@@ -48,10 +79,12 @@ class SessionHandler {
         }
         catch (error) {
             this.config.logger?.error("Error setting session ID:", error);
+            throw error;
         }
     }
     getSessionId(context) {
         try {
+            validation_1.ValidationUtils.required(context, "context");
             if (this.config.getSessionId) {
                 return this.config.getSessionId(context);
             }
@@ -74,7 +107,7 @@ class SessionHandler {
         }
     }
     generateSessionId() {
-        return this.config.generateSessionId?.() || (0, uuid_1.v4)();
+        return this.config.generateSessionId?.() || (0, crypto_1.randomUUID)();
     }
     buildSessionData(data, context) {
         return this.config.createSessionData
@@ -83,6 +116,7 @@ class SessionHandler {
     }
     async getSessionData(sessionId) {
         try {
+            validation_1.ValidationUtils.nonEmptyString(sessionId, "sessionId");
             const data = await this.store.getSession(sessionId);
             return data;
         }
@@ -93,15 +127,14 @@ class SessionHandler {
     }
     async setSessionData(sessionId, data) {
         try {
-            if (!sessionId) {
-                this.config.logger?.warn("No session ID found, unable to set session.");
-                return;
-            }
+            validation_1.ValidationUtils.nonEmptyString(sessionId, "sessionId");
+            validation_1.ValidationUtils.required(data, "data");
             await this.store.setSession(sessionId, data);
             this.config.logger?.info(`Session set for ID: ${sessionId}`);
         }
         catch (error) {
             this.config.logger?.error("Error storing session data:", error);
+            throw error;
         }
     }
     async touch(sessionId, data) {

package/build/soap-auth.d.ts

@@ -1,17 +1,24 @@
-import { AuthCategories, AuthStrategy, SoapAuthConfig } from "./types";
+import * as Soap from "@soapjs/soap";
+import { AuthCategories, SoapAuthConfig } from "./types";
 export declare class SoapAuth {
     private requiredStrategyMethods;
     private strategies;
     private logger?;
     constructor(config: SoapAuthConfig);
+    private validateConfig;
+    private validateSessionConfig;
+    private validateJwtConfig;
+    private validateHttpStrategies;
+    private validateSocketStrategies;
     private isAuthStrategy;
-    addStrategy(strategyInstance: AuthStrategy | undefined, name: string, type: AuthCategories): void;
+    addStrategy(strategyInstance: Soap.AuthStrategy | undefined, name: string, type: AuthCategories): void;
     removeStrategy(name: string | string[], type: AuthCategories): void;
     hasStrategy(name: string, type: AuthCategories): boolean;
-    getStrategy<T extends AuthStrategy>(name: string, type: AuthCategories): T;
-    getHttpStrategy<T extends AuthStrategy>(name: string): T;
-    getSocketStrategy<T extends AuthStrategy>(name: string): T;
-    getEventStrategy<T extends AuthStrategy>(name: string): T;
+    getStrategy<T extends Soap.AuthStrategy>(name: string, type: AuthCategories): T;
+    getHttpStrategy<T extends Soap.AuthStrategy>(name: string): T;
+    getSocketStrategy<T extends Soap.AuthStrategy>(name: string): T;
+    getEventStrategy<T extends Soap.AuthStrategy>(name: string): T;
     listStrategies(type: AuthCategories): string[];
     init(sequential?: boolean): Promise<void>;
+    static create(config: SoapAuthConfig): Promise<SoapAuth>;
 }

package/build/soap-auth.js

@@ -1,11 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SoapAuth = void 0;
+const validation_1 = require("./utils/validation");
+const session_handler_1 = require("./session/session-handler");
+const jwt_strategy_1 = require("./strategies/jwt/jwt.strategy");
+const local_strategy_1 = require("./strategies/local/local.strategy");
+const basic_strategy_1 = require("./strategies/basic/basic.strategy");
+const api_key_strategy_1 = require("./strategies/api-key/api-key.strategy");
 class SoapAuth {
-    requiredStrategyMethods = ["authenticate", "init"];
+    requiredStrategyMethods = ["authenticate"];
     strategies = new Map();
     logger;
     constructor(config) {
+        this.validateConfig(config);
         this.strategies.set("http", new Map());
         this.strategies.set("socket", new Map());
         this.strategies.set("event", new Map());
@@ -15,12 +22,83 @@ class SoapAuth {
         this.strategies.set("edge", new Map());
         this.logger = config.logger;
     }
+    validateConfig(config) {
+        try {
+            validation_1.ValidationUtils.required(config, "config");
+            if (config.logger) {
+                validation_1.ValidationUtils.object(config.logger, "config.logger");
+            }
+            if (config.session) {
+                this.validateSessionConfig(config.session);
+            }
+            if (config.jwt) {
+                this.validateJwtConfig(config.jwt);
+            }
+            if (config.http) {
+                this.validateHttpStrategies(config.http);
+            }
+            if (config.socket) {
+                this.validateSocketStrategies(config.socket);
+            }
+        }
+        catch (error) {
+            if (error instanceof validation_1.ValidationError) {
+                throw error;
+            }
+            throw new validation_1.ValidationError(`Invalid configuration: ${error.message}`);
+        }
+    }
+    validateSessionConfig(session) {
+        validation_1.ValidationUtils.required(session.secret, "session.secret");
+        validation_1.ValidationUtils.nonEmptyString(session.secret, "session.secret");
+        if (session.sessionKey) {
+            validation_1.ValidationUtils.nonEmptyString(session.sessionKey, "session.sessionKey");
+        }
+        if (session.sessionHeader) {
+            validation_1.ValidationUtils.nonEmptyString(session.sessionHeader, "session.sessionHeader");
+        }
+    }
+    validateJwtConfig(jwt) {
+        if (jwt.accessToken) {
+            validation_1.ValidationUtils.required(jwt.accessToken.issuer, "jwt.accessToken.issuer");
+            validation_1.ValidationUtils.required(jwt.accessToken.issuer.secretKey, "jwt.accessToken.issuer.secretKey");
+            validation_1.ValidationUtils.nonEmptyString(jwt.accessToken.issuer.secretKey, "jwt.accessToken.issuer.secretKey");
+        }
+        if (jwt.refreshToken) {
+            validation_1.ValidationUtils.required(jwt.refreshToken.issuer, "jwt.refreshToken.issuer");
+            validation_1.ValidationUtils.required(jwt.refreshToken.issuer.secretKey, "jwt.refreshToken.issuer.secretKey");
+            validation_1.ValidationUtils.nonEmptyString(jwt.refreshToken.issuer.secretKey, "jwt.refreshToken.issuer.secretKey");
+        }
+    }
+    validateHttpStrategies(http) {
+        validation_1.ValidationUtils.object(http, "http");
+        if (http.custom) {
+            validation_1.ValidationUtils.object(http.custom, "http.custom");
+            for (const [name, strategy] of Object.entries(http.custom)) {
+                validation_1.ValidationUtils.required(strategy, `http.custom.${name}`);
+                validation_1.ValidationUtils.object(strategy, `http.custom.${name}`);
+            }
+        }
+    }
+    validateSocketStrategies(socket) {
+        validation_1.ValidationUtils.object(socket, "socket");
+        if (socket.custom) {
+            validation_1.ValidationUtils.object(socket.custom, "socket.custom");
+            for (const [name, strategy] of Object.entries(socket.custom)) {
+                validation_1.ValidationUtils.required(strategy, `socket.custom.${name}`);
+                validation_1.ValidationUtils.object(strategy, `socket.custom.${name}`);
+            }
+        }
+    }
     isAuthStrategy(strategy) {
         return (typeof strategy === "object" &&
             strategy !== null &&
             this.requiredStrategyMethods.every((method) => typeof strategy[method] === "function"));
     }
     addStrategy(strategyInstance, name, type) {
+        validation_1.ValidationUtils.required(strategyInstance, "strategyInstance");
+        validation_1.ValidationUtils.nonEmptyString(name, "name");
+        validation_1.ValidationUtils.oneOf(type, "type", ["http", "socket", "event", "isa", "webhook", "grpc", "edge"]);
         if (!this.strategies.has(type)) {
             throw new Error(`Invalid strategy type "${type}".`);
         }
@@ -33,21 +111,28 @@ class SoapAuth {
         }
     }
     removeStrategy(name, type) {
+        validation_1.ValidationUtils.required(name, "name");
+        validation_1.ValidationUtils.oneOf(type, "type", ["http", "socket", "event", "isa", "webhook", "grpc", "edge"]);
         if (!this.strategies.has(type)) {
             throw new Error(`Invalid strategy type "${type}".`);
         }
         const names = Array.isArray(name) ? name : [name];
         names.forEach((n) => {
+            validation_1.ValidationUtils.nonEmptyString(n, "strategy name");
             this.strategies.get(type).delete(n);
         });
     }
     hasStrategy(name, type) {
+        validation_1.ValidationUtils.nonEmptyString(name, "name");
+        validation_1.ValidationUtils.oneOf(type, "type", ["http", "socket", "event", "isa", "webhook", "grpc", "edge"]);
         if (!this.strategies.has(type)) {
             throw new Error(`Invalid strategy type "${type}".`);
         }
         return this.strategies.get(type).has(name);
     }
     getStrategy(name, type) {
+        validation_1.ValidationUtils.nonEmptyString(name, "name");
+        validation_1.ValidationUtils.oneOf(type, "type", ["http", "socket", "event", "isa", "webhook", "grpc", "edge"]);
         if (!this.strategies.has(type)) {
             throw new Error(`Invalid strategy type "${type}".`);
         }
@@ -101,7 +186,7 @@ class SoapAuth {
         if (sequential) {
             for (const strategy of strategies) {
                 try {
-                    await strategy.init();
+                    await strategy.init?.();
                 }
                 catch (error) {
                     this.logger?.error(`Failed to initialize strategy: ${error.message}`);
@@ -109,10 +194,52 @@ class SoapAuth {
             }
         }
         else {
-            await Promise.all(strategies.map((strategy) => strategy
-                .init()
-                .catch((error) => this.logger?.error(`Failed to initialize strategy: ${error.message}`))));
+            await Promise.all(strategies.map((strategy) => Promise.resolve(strategy.init?.()).catch((error) => this.logger?.error(`Failed to initialize strategy: ${error.message}`))));
+        }
+    }
+    static async create(config) {
+        const auth = new SoapAuth(config);
+        const logger = config.logger;
+        const sessionHandler = config.session
+            ? new session_handler_1.SessionHandler(config.session, logger)
+            : undefined;
+        if (config.http) {
+            const sharedJwt = config.http.jwt
+                ? new jwt_strategy_1.JwtStrategy(config.http.jwt, logger)
+                : undefined;
+            if (config.http.local) {
+                auth.addStrategy(new local_strategy_1.LocalStrategy(config.http.local, sessionHandler, sharedJwt, logger), "local", "http");
+            }
+            if (config.http.basic) {
+                auth.addStrategy(new basic_strategy_1.BasicStrategy(config.http.basic, sessionHandler, sharedJwt, logger), "basic", "http");
+            }
+            if (config.http.apiKey) {
+                auth.addStrategy(new api_key_strategy_1.ApiKeyStrategy(config.http.apiKey, logger), "api-key", "http");
+            }
+            if (sharedJwt) {
+                auth.addStrategy(sharedJwt, "jwt", "http");
+            }
+            if (config.http.custom) {
+                for (const [name, strategy] of Object.entries(config.http.custom)) {
+                    auth.addStrategy(strategy, name, "http");
+                }
+            }
+        }
+        if (config.socket) {
+            if (config.socket.jwt) {
+                auth.addStrategy(new jwt_strategy_1.JwtStrategy(config.socket.jwt, logger), "jwt", "socket");
+            }
+            if (config.socket.apiKey) {
+                auth.addStrategy(new api_key_strategy_1.ApiKeyStrategy(config.socket.apiKey, logger), "api-key", "socket");
+            }
+            if (config.socket.custom) {
+                for (const [name, strategy] of Object.entries(config.socket.custom)) {
+                    auth.addStrategy(strategy, name, "socket");
+                }
+            }
         }
+        await auth.init();
+        return auth;
     }
 }
 exports.SoapAuth = SoapAuth;

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

@@ -1,4 +1,4 @@
-import { AuthResult, BaseAuthStrategyConfig } from "../../../src/types";
+import { BaseAuthStrategyConfig } from "../../../src/types";
 import { SessionHandler } from "../../../src/session/session-handler";
 import * as Soap from "@soapjs/soap";
 import { BaseAuthStrategy } from "../base-auth.strategy";
@@ -9,6 +9,7 @@ export interface MockUser {
 export interface MockContext {
 }
 export declare class TestBaseAuthStrategy extends BaseAuthStrategy<MockContext, MockUser> {
+    readonly name = "test";
     constructor(config: BaseAuthStrategyConfig<MockContext, MockUser>, session?: SessionHandler, logger?: Soap.Logger);
-    authenticate(context?: MockContext): Promise<AuthResult<MockUser>>;
+    authenticate(context?: MockContext): Promise<Soap.AuthResult<MockUser> | null>;
 }

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

@@ -4,6 +4,7 @@ exports.TestBaseAuthStrategy = void 0;
 const session_errors_1 = require("../../../src/session/session.errors");
 const base_auth_strategy_1 = require("../base-auth.strategy");
 class TestBaseAuthStrategy extends base_auth_strategy_1.BaseAuthStrategy {
+    name = "test";
     constructor(config, session, logger) {
         super(config, session, logger);
     }

package/build/strategies/__tests__/credential-auth.strategy.test.d.ts

@@ -4,6 +4,7 @@ import { JwtStrategy } from "../../../src/strategies/jwt/jwt.strategy";
 import * as Soap from "@soapjs/soap";
 import { CredentialAuthStrategy } from "../credential-auth.strategy";
 export declare class TestCredentialAuthStrategy extends CredentialAuthStrategy<any, any> {
+    readonly name = "test-credential";
     constructor(config: CredentialAuthStrategyConfig<any, any>, session?: SessionHandler, jwt?: JwtStrategy<any, any>, logger?: Soap.Logger);
     protected verifyCredentials(identifier: string, password: string): Promise<boolean>;
     protected extractCredentials(context: any): Promise<{