@soapjs/soap-auth 0.3.3 → 0.4.4

package/build/strategies/oauth2/providers/google.strategy.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoogleStrategy = void 0;
+const http_oauth2_strategy_1 = require("./http-oauth2.strategy");
+const GOOGLE_ENDPOINTS = {
+    authorizationUrl: "https://accounts.google.com/o/oauth2/v2/auth",
+    tokenUrl: "https://oauth2.googleapis.com/token",
+    userInfoUrl: "https://openidconnect.googleapis.com/v1/userinfo",
+    revocationUrl: "https://oauth2.googleapis.com/revoke",
+};
+class GoogleStrategy extends http_oauth2_strategy_1.HttpOAuth2Strategy {
+    name = "google";
+    constructor(config, session, jwt, logger) {
+        super({
+            grantType: "authorization_code",
+            scope: config.scope ?? ["openid", "email", "profile"],
+            routes: {
+                login: { path: "/auth/google", method: "GET" },
+                callback: { path: "/auth/google/callback", method: "GET" },
+                logout: { path: "/auth/google/logout", method: "POST" },
+                ...config.routes,
+            },
+            ...config,
+            endpoints: { ...GOOGLE_ENDPOINTS, ...config.endpoints },
+        }, session, jwt, logger);
+    }
+    async fetchUser(accessToken) {
+        try {
+            const response = await fetch(GOOGLE_ENDPOINTS.userInfoUrl, {
+                headers: { Authorization: `Bearer ${accessToken}` },
+            });
+            if (!response.ok)
+                return null;
+            const profile = await response.json();
+            if (this.config.user?.validateUser) {
+                return this.config.user.validateUser(profile);
+            }
+            return {
+                id: profile.sub,
+                email: profile.email,
+                username: profile.name,
+                picture: profile.picture,
+                emailVerified: profile.email_verified,
+            };
+        }
+        catch (error) {
+            this.logger?.error("GoogleStrategy.fetchUser failed:", error);
+            return null;
+        }
+    }
+}
+exports.GoogleStrategy = GoogleStrategy;

package/build/strategies/oauth2/providers/http-oauth2.strategy.d.ts

@@ -0,0 +1,16 @@
+import * as Soap from "@soapjs/soap";
+import { OAuth2Strategy } from "../oauth2.strategy";
+import { OAuth2StrategyConfig } from "../oauth2.types";
+import { SessionHandler } from "../../../session/session-handler";
+import { JwtStrategy } from "../../jwt/jwt.strategy";
+export declare abstract class HttpOAuth2Strategy<TUser extends Soap.AuthUser = Soap.AuthUser> extends OAuth2Strategy<Soap.HttpContext, TUser> {
+    constructor(config: OAuth2StrategyConfig<Soap.HttpContext, TUser>, session?: SessionHandler, jwt?: JwtStrategy<Soap.HttpContext, TUser>, logger?: Soap.Logger);
+    protected extractAccessToken(ctx: Soap.HttpContext): Promise<string | undefined>;
+    protected extractRefreshToken(ctx: Soap.HttpContext): Promise<string | undefined>;
+    protected storeAccessToken(_token: string, _ctx: Soap.HttpContext): Promise<void>;
+    protected storeRefreshToken(_token: string, _ctx: Soap.HttpContext): Promise<void>;
+    protected embedAccessToken(token: string, ctx: Soap.HttpContext): void;
+    protected embedRefreshToken(token: string, ctx: Soap.HttpContext): void;
+    protected extractAuthorizationCode(ctx: Soap.HttpContext): string | null;
+    protected redirectUser(ctx: Soap.HttpContext, authUrl: string): void;
+}

package/build/strategies/oauth2/providers/http-oauth2.strategy.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpOAuth2Strategy = void 0;
+const oauth2_strategy_1 = require("../oauth2.strategy");
+class HttpOAuth2Strategy extends oauth2_strategy_1.OAuth2Strategy {
+    constructor(config, session, jwt, logger) {
+        super(config, session, jwt, logger);
+    }
+    extractAccessToken(ctx) {
+        const auth = ctx.req.headers?.authorization;
+        if (typeof auth === "string" && auth.startsWith("Bearer ")) {
+            return Promise.resolve(auth.slice(7));
+        }
+        return Promise.resolve(ctx.req.cookies?.access_token);
+    }
+    extractRefreshToken(ctx) {
+        return Promise.resolve(ctx.req.cookies?.refresh_token);
+    }
+    storeAccessToken(_token, _ctx) {
+        return Promise.resolve();
+    }
+    storeRefreshToken(_token, _ctx) {
+        return Promise.resolve();
+    }
+    embedAccessToken(token, ctx) {
+        ctx.res.setHeader("Authorization", `Bearer ${token}`);
+    }
+    embedRefreshToken(token, ctx) {
+        ctx.res.cookie("refresh_token", token, {
+            httpOnly: true,
+            secure: true,
+            sameSite: "lax",
+            maxAge: 30 * 24 * 60 * 60 * 1000,
+        });
+    }
+    extractAuthorizationCode(ctx) {
+        return ctx.req.query?.code ?? null;
+    }
+    redirectUser(ctx, authUrl) {
+        if (typeof ctx.res.redirect === "function") {
+            ctx.res.redirect(authUrl);
+        }
+        else {
+            ctx.res.setHeader("Location", authUrl);
+            ctx.res.status(302).json({ message: "Redirecting", location: authUrl });
+        }
+    }
+}
+exports.HttpOAuth2Strategy = HttpOAuth2Strategy;

package/build/strategies/oauth2/providers/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./http-oauth2.strategy";
+export * from "./google.strategy";
+export * from "./github.strategy";
+export * from "./facebook.strategy";
+export * from "./provider.types";

package/build/strategies/oauth2/providers/index.js

@@ -0,0 +1,21 @@
+"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("./http-oauth2.strategy"), exports);
+__exportStar(require("./google.strategy"), exports);
+__exportStar(require("./github.strategy"), exports);
+__exportStar(require("./facebook.strategy"), exports);
+__exportStar(require("./provider.types"), exports);

package/build/strategies/oauth2/providers/provider.types.d.ts

@@ -0,0 +1,7 @@
+import * as Soap from "@soapjs/soap";
+import { OAuth2StrategyConfig, OAuth2Endpoints } from "../oauth2.types";
+export interface SocialProviderConfig<TUser extends Soap.AuthUser = Soap.AuthUser> extends Omit<OAuth2StrategyConfig<Soap.HttpContext, TUser>, "endpoints" | "grantType" | "routes"> {
+    grantType?: "authorization_code";
+    endpoints?: Partial<OAuth2Endpoints>;
+    routes?: OAuth2StrategyConfig<Soap.HttpContext, TUser>["routes"];
+}

package/build/strategies/oauth2/providers/provider.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -1,8 +1,8 @@
 import * as Soap from "@soapjs/soap";
-import { AuthResult, TokenAuthStrategyConfig } from "../types";
+import { TokenAuthStrategyConfig } from "../types";
 import { BaseAuthStrategy } from "./base-auth.strategy";
 import { SessionHandler } from "../session/session-handler";
-export declare abstract class TokenAuthStrategy<TContext = unknown, TUser = unknown> extends BaseAuthStrategy<TContext, TUser> {
+export declare abstract class TokenAuthStrategy<TContext = Soap.HttpContext, TUser extends Soap.AuthUser = Soap.AuthUser> extends BaseAuthStrategy<TContext, TUser> {
     protected config: TokenAuthStrategyConfig<TContext, TUser>;
     protected session?: SessionHandler;
     protected logger?: Soap.Logger;
@@ -20,9 +20,9 @@ export declare abstract class TokenAuthStrategy<TContext = unknown, TUser = unkn
     protected abstract embedAccessToken(token: string, context: TContext): void;
     protected abstract embedRefreshToken(token: string, context: TContext): void;
     protected fetchUser(payload: unknown): Promise<TUser | null>;
-    authenticate(context: TContext): Promise<AuthResult<TUser>>;
+    authenticate(context: TContext): Promise<Soap.AuthResult<TUser> | null>;
     private verifyAndFetchUser;
-    refreshTokens(context: TContext, existingUser?: TUser): Promise<AuthResult<TUser>>;
+    refreshTokens(context: TContext, existingUser?: TUser): Promise<Soap.AuthResult<TUser>>;
     issueTokens(user: TUser, context: TContext, rotate?: boolean): Promise<{
         accessToken: string;
         refreshToken: any;

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

@@ -145,12 +145,11 @@ class TokenAuthStrategy extends base_auth_strategy_1.BaseAuthStrategy {
             const accessToken = await this.generateAccessToken(user, context);
             let refreshToken;
             if (this.config.refreshToken) {
-                refreshToken = await this.generateRefreshToken(user, context);
-                if (rotate && this.config?.refreshToken?.rotation) {
+                if (rotate && this.config.refreshToken.rotation) {
                     const oldRefreshToken = this.extractRefreshToken(context);
                     refreshToken = await this.rotateToken(oldRefreshToken, user, context);
                 }
-                else if (this.generateRefreshToken) {
+                else {
                     refreshToken = await this.generateRefreshToken(user, context);
                 }
             }

package/build/tools/tools.js

@@ -4,10 +4,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateRandomString = exports.resolveConfig = exports.generateUUID = void 0;
-const uuid_1 = require("uuid");
 const crypto_1 = __importDefault(require("crypto"));
 const generateUUID = async () => {
-    return Promise.resolve((0, uuid_1.v4)());
+    return Promise.resolve(crypto_1.default.randomUUID());
 };
 exports.generateUUID = generateUUID;
 function resolveConfig(strategyConfig, globalConfig) {

package/build/types.d.ts

@@ -1,4 +1,6 @@
 import * as Soap from "@soapjs/soap";
+export type AuthResult<TUser extends Soap.AuthUser = Soap.AuthUser> = Soap.AuthResult<TUser>;
+export type AuthStrategy<TUser extends Soap.AuthUser = Soap.AuthUser> = Soap.AuthStrategy<TUser>;
 import { LocalStrategyConfig } from "./strategies/local/local.types";
 import { OAuth2StrategyConfig } from "./strategies/oauth2/oauth2.types";
 import { ApiKeyStrategyConfig } from "./strategies/api-key/api-key.types";
@@ -71,29 +73,43 @@ export interface MfaConfig<TUser = unknown, TContext = unknown> {
     resetMfaAttempts?: (user: TUser) => Promise<void>;
     incrementMfaAttempts?: (user: TUser) => Promise<void>;
 }
+export type PasswordType = "default" | "one-time" | "temporary";
+export type NewPasswordOptions = {
+    expiresIn?: number;
+    type: PasswordType;
+    additional?: Record<string, unknown>;
+};
+export type PasswordInfo = {
+    type: PasswordType;
+    expiresIn?: number;
+    lastChangeDate?: Date;
+};
 export interface PasswordPolicyConfig {
-    validatePassword?: (password: string) => Promise<boolean>;
-    getLastPasswordChange?: (identifier: string) => Promise<Date>;
+    validatePassword?: (password: string, previousPassword?: string) => Promise<void>;
+    getPasswordPasswordInfo?: (identifier: string) => Promise<PasswordInfo>;
     passwordExpirationDays?: number;
     generateResetToken?: (identifier: string) => Promise<string>;
-    sendResetEmail?: (identifier: string, token: string) => Promise<void>;
-    validateResetToken?: (token: string) => Promise<boolean>;
-    updatePassword?: (identifier: string, newPassword: string) => Promise<void>;
+    sendPasswordResetEmail?: (identifier: string, token: string) => Promise<void>;
+    validatePasswordResetToken?: (token: string) => Promise<boolean>;
+    updatePassword?: (identifier: string, newPassword: string, options?: NewPasswordOptions) => Promise<void>;
+    generatePassword?: (identifier: string, options: NewPasswordOptions) => Promise<string>;
 }
 export interface UserConfig<TUser = unknown> {
     fetchUser: (payload: unknown) => Promise<TUser | null>;
     validateUser?: (payload: unknown) => Promise<any>;
 }
-export interface CredentailsConfig<TContext = any> {
+export type CredentailsConfig<TContext = any> = CredentialsConfig<TContext>;
+export interface CredentialsConfig<TContext = any> {
     extractCredentials: <TCredentials = {
         identifier: string;
         password: string;
+        newPassword?: string;
     }>(context: TContext) => TCredentials;
     verifyCredentials: (identifier: string, password: string) => Promise<boolean>;
 }
 export interface CredentialAuthStrategyConfig<TContext = unknown, TUser = unknown> extends BaseAuthStrategyConfig<TContext, TUser> {
     passwordPolicy?: PasswordPolicyConfig;
-    credentials?: CredentailsConfig<TContext>;
+    credentials?: CredentialsConfig<TContext>;
     jwt?: TokenAuthConfig<TContext>;
     user?: UserConfig<TUser>;
     allowGuest?: boolean;
@@ -155,43 +171,26 @@ export type AuthFailureContext<TContext = unknown> = {
     email?: string;
     additional?: Record<string, unknown>;
 };
-export type AuthResult<TUser = unknown, TSessionData = unknown> = {
-    user: TUser;
-    session?: SessionInfo<TSessionData>;
-    tokens?: {
-        accessToken?: string;
-        refreshToken?: string | null;
-        apiKey?: string | null;
-        [key: string]: string;
-    };
-};
-export interface AuthStrategy<TContext = unknown, TUser = unknown> {
-    init?(...args: unknown[]): Promise<void>;
-    authenticate(context?: TContext, ...args: unknown[]): Promise<AuthResult<TUser> | null>;
-    authorize?(user: any, action: string, resource?: string): Promise<boolean>;
-    refresh?(refreshToken: string): Promise<string>;
-    logout?(context?: TContext): Promise<void>;
-    logout?(context?: TContext): Promise<void>;
-}
-export interface SoapHttpAuthConfig<TContext = unknown, TUser = unknown> {
+export interface SoapHttpAuthConfig<TContext = unknown, TUser extends Soap.AuthUser = Soap.AuthUser> {
     local?: LocalStrategyConfig<TContext, TUser>;
+    jwt?: JwtConfig<TContext, TUser>;
     oauth2?: {
         [provider: string]: OAuth2StrategyConfig<TContext, TUser>;
     };
     apiKey?: ApiKeyStrategyConfig<TContext, TUser>;
     basic?: BasicStrategyConfig<TContext, TUser>;
-    custom: {
-        [label: string]: AuthStrategy;
+    custom?: {
+        [label: string]: Soap.AuthStrategy;
     };
 }
-export interface SoapSocketAuthConfig<TContext = unknown, TUser = unknown> {
+export interface SoapSocketAuthConfig<TContext = unknown, TUser extends Soap.AuthUser = Soap.AuthUser> {
     jwt?: JwtConfig<TContext, TUser>;
     apiKey?: ApiKeyStrategyConfig<TContext, TUser>;
-    custom: {
-        [provider: string]: AuthStrategy;
+    custom?: {
+        [provider: string]: Soap.AuthStrategy;
     };
 }
-export interface SoapAuthConfig<TContext = unknown, TUser = unknown> {
+export interface SoapAuthConfig<TContext = unknown, TUser extends Soap.AuthUser = Soap.AuthUser> {
     session?: SessionConfig;
     jwt?: TokenAuthConfig<TContext>;
     http?: SoapHttpAuthConfig<TContext, TUser>;

package/build/utils/validation.d.ts

@@ -0,0 +1,23 @@
+export declare class ValidationError extends Error {
+    field?: string;
+    constructor(message: string, field?: string);
+}
+export declare class ValidationUtils {
+    static required(value: any, fieldName: string): void;
+    static nonEmptyString(value: any, fieldName: string): string;
+    static email(value: any, fieldName: string): string;
+    static password(value: any, fieldName: string, minLength?: number): string;
+    static positiveNumber(value: any, fieldName: string): number;
+    static range(value: any, fieldName: string, min: number, max: number): number;
+    static oneOf<T>(value: any, fieldName: string, allowedValues: T[]): T;
+    static url(value: any, fieldName: string): string;
+    static jwtToken(value: any, fieldName: string): string;
+    static uuid(value: any, fieldName: string): string;
+    static object(value: any, fieldName: string): object;
+    static array(value: any, fieldName: string): any[];
+    static function(value: any, fieldName: string): Function;
+    static validateConfig(config: any, requiredFields: string[], fieldName?: string): void;
+    static pattern(value: any, fieldName: string, regex: RegExp, message?: string): string;
+    static date(value: any, fieldName: string): Date;
+    static boolean(value: any, fieldName: string): boolean;
+}

package/build/utils/validation.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidationUtils = exports.ValidationError = void 0;
+class ValidationError extends Error {
+    field;
+    constructor(message, field) {
+        super(message);
+        this.field = field;
+        this.name = "ValidationError";
+    }
+}
+exports.ValidationError = ValidationError;
+class ValidationUtils {
+    static required(value, fieldName) {
+        if (value === null || value === undefined) {
+            throw new ValidationError(`${fieldName} is required`, fieldName);
+        }
+    }
+    static nonEmptyString(value, fieldName) {
+        this.required(value, fieldName);
+        if (typeof value !== "string" || value.trim().length === 0) {
+            throw new ValidationError(`${fieldName} must be a non-empty string`, fieldName);
+        }
+        return value.trim();
+    }
+    static email(value, fieldName) {
+        const email = this.nonEmptyString(value, fieldName);
+        const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+        if (!emailRegex.test(email)) {
+            throw new ValidationError(`${fieldName} must be a valid email address`, fieldName);
+        }
+        return email;
+    }
+    static password(value, fieldName, minLength = 8) {
+        const password = this.nonEmptyString(value, fieldName);
+        if (password.length < minLength) {
+            throw new ValidationError(`${fieldName} must be at least ${minLength} characters long`, fieldName);
+        }
+        return password;
+    }
+    static positiveNumber(value, fieldName) {
+        this.required(value, fieldName);
+        const num = Number(value);
+        if (isNaN(num) || num <= 0) {
+            throw new ValidationError(`${fieldName} must be a positive number`, fieldName);
+        }
+        return num;
+    }
+    static range(value, fieldName, min, max) {
+        const num = this.positiveNumber(value, fieldName);
+        if (num < min || num > max) {
+            throw new ValidationError(`${fieldName} must be between ${min} and ${max}`, fieldName);
+        }
+        return num;
+    }
+    static oneOf(value, fieldName, allowedValues) {
+        this.required(value, fieldName);
+        if (!allowedValues.includes(value)) {
+            throw new ValidationError(`${fieldName} must be one of: ${allowedValues.join(", ")}`, fieldName);
+        }
+        return value;
+    }
+    static url(value, fieldName) {
+        const url = this.nonEmptyString(value, fieldName);
+        try {
+            new URL(url);
+            return url;
+        }
+        catch {
+            throw new ValidationError(`${fieldName} must be a valid URL`, fieldName);
+        }
+    }
+    static jwtToken(value, fieldName) {
+        const token = this.nonEmptyString(value, fieldName);
+        const parts = token.split(".");
+        if (parts.length !== 3) {
+            throw new ValidationError(`${fieldName} must be a valid JWT token`, fieldName);
+        }
+        return token;
+    }
+    static uuid(value, fieldName) {
+        const uuid = this.nonEmptyString(value, fieldName);
+        const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+        if (!uuidRegex.test(uuid)) {
+            throw new ValidationError(`${fieldName} must be a valid UUID`, fieldName);
+        }
+        return uuid;
+    }
+    static object(value, fieldName) {
+        this.required(value, fieldName);
+        if (typeof value !== "object" || Array.isArray(value)) {
+            throw new ValidationError(`${fieldName} must be an object`, fieldName);
+        }
+        return value;
+    }
+    static array(value, fieldName) {
+        this.required(value, fieldName);
+        if (!Array.isArray(value)) {
+            throw new ValidationError(`${fieldName} must be an array`, fieldName);
+        }
+        return value;
+    }
+    static function(value, fieldName) {
+        this.required(value, fieldName);
+        if (typeof value !== "function") {
+            throw new ValidationError(`${fieldName} must be a function`, fieldName);
+        }
+        return value;
+    }
+    static validateConfig(config, requiredFields, fieldName = "config") {
+        this.object(config, fieldName);
+        for (const field of requiredFields) {
+            this.required(config[field], `${fieldName}.${field}`);
+        }
+    }
+    static pattern(value, fieldName, regex, message) {
+        const str = this.nonEmptyString(value, fieldName);
+        if (!regex.test(str)) {
+            throw new ValidationError(message || `${fieldName} does not match required pattern`, fieldName);
+        }
+        return str;
+    }
+    static date(value, fieldName) {
+        this.required(value, fieldName);
+        const date = new Date(value);
+        if (isNaN(date.getTime())) {
+            throw new ValidationError(`${fieldName} must be a valid date`, fieldName);
+        }
+        return date;
+    }
+    static boolean(value, fieldName) {
+        this.required(value, fieldName);
+        if (typeof value !== "boolean") {
+            throw new ValidationError(`${fieldName} must be a boolean`, fieldName);
+        }
+        return value;
+    }
+}
+exports.ValidationUtils = ValidationUtils;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@soapjs/soap-auth",
-  "version": "0.3.3",
+  "version": "0.4.4",
   "description": "",
   "homepage": "https://docs.soapjs.com",
   "repository": "https://github.com/soapjs/soap-auth",
@@ -15,20 +15,21 @@
     "prepublish": "npm run clean && tsc --project tsconfig.build.json"
   },
   "devDependencies": {
-    "@soapjs/soap": "^0.5.8",
+    "@soapjs/soap": "^0.12.0",
     "@types/jest": "^27.0.3",
     "jest": "^27.4.5",
     "ts-jest": "^27.1.3",
     "typescript": "^4.8.2"
   },
   "peerDependencies": {
-    "@soapjs/soap": ">=0.5.8"
+    "@soapjs/soap": ">=0.12.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
   },
   "dependencies": {
-    "axios": "^1.7.9",
-    "bcrypt": "^5.1.1",
+    "bcrypt": "^6.0.0",
     "jsonwebtoken": "^9.0.2",
-    "jwks-rsa": "^3.1.0",
-    "uuid": "^9.0.1"
+    "jwks-rsa": "^3.1.0"
   }
 }

package/build/__tests__/soap-auth.test.d.ts

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

package/build/__tests__/soap-auth.test.js

@@ -1,42 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const globals_1 = require("@jest/globals");
-const soap_auth_1 = require("../soap-auth");
-describe("SoapAuth", () => {
-    let soapAuth;
-    const mockLogger = { error: globals_1.jest.fn(), info: globals_1.jest.fn() };
-    const mockStrategy = {
-        authenticate: globals_1.jest.fn(),
-        init: globals_1.jest.fn(),
-        logout: globals_1.jest.fn(),
-    };
-    beforeEach(() => {
-        globals_1.jest.clearAllMocks();
-        soapAuth = new soap_auth_1.SoapAuth({ logger: mockLogger });
-    });
-    test("addStrategy should add a valid strategy", () => {
-        expect(() => soapAuth.addStrategy(mockStrategy, "jwt", "http")).not.toThrow();
-        expect(soapAuth.hasStrategy("jwt", "http")).toBe(true);
-    });
-    test("addStrategy should throw error if strategy is invalid", () => {
-        expect(() => soapAuth.addStrategy({}, "invalid", "http")).toThrow("Invalid authentication strategy: does not implement required methods.");
-    });
-    test("removeStrategy should remove an existing strategy", () => {
-        soapAuth.addStrategy(mockStrategy, "jwt", "http");
-        expect(soapAuth.hasStrategy("jwt", "http")).toBe(true);
-        soapAuth.removeStrategy("jwt", "http");
-        expect(soapAuth.hasStrategy("jwt", "http")).toBe(false);
-    });
-    test("getStrategy should return an existing strategy", () => {
-        soapAuth.addStrategy(mockStrategy, "jwt", "http");
-        expect(soapAuth.getStrategy("jwt", "http")).toBe(mockStrategy);
-    });
-    test("getStrategy should throw an error if strategy does not exist", () => {
-        expect(() => soapAuth.getStrategy("nonexistent", "http")).toThrow('Authentication strategy "nonexistent" not found.');
-    });
-    test("listStrategies should return all registered strategy names", () => {
-        soapAuth.addStrategy(mockStrategy, "jwt", "http");
-        soapAuth.addStrategy(mockStrategy, "oauth", "http");
-        expect(soapAuth.listStrategies("http")).toEqual(["jwt", "oauth"]);
-    });
-});

package/build/services/__tests__/account-lock.service.test.d.ts

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

package/build/services/__tests__/account-lock.service.test.js

@@ -1,55 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const errors_1 = require("../../errors");
-const account_lock_service_1 = require("../account-lock.service");
-const mockConfig = {
-    isAccountLocked: jest.fn(),
-    lockAccount: jest.fn(),
-    hasAccountLockExpired: jest.fn(),
-    removeAccountLock: jest.fn(),
-    logFailedAttempt: jest.fn(),
-    notifyOnLockout: jest.fn(),
-};
-const mockLogger = {
-    error: jest.fn(),
-};
-describe("AccountLockService", () => {
-    let service;
-    const mockAccount = { id: "123" };
-    beforeEach(() => {
-        jest.clearAllMocks();
-        service = new account_lock_service_1.AccountLockService(mockConfig, mockLogger);
-    });
-    it("isAccountLocked throws error if account is locked", async () => {
-        mockConfig.isAccountLocked.mockResolvedValue(true);
-        await expect(service.isAccountLocked(mockAccount)).rejects.toThrow(errors_1.AccountLockedError);
-    });
-    it("isAccountLocked returns false if account is not locked", async () => {
-        mockConfig.isAccountLocked.mockResolvedValue(false);
-        await expect(service.isAccountLocked(mockAccount)).resolves.toBe(false);
-    });
-    it("lockAccount locks the account and notifies if enabled", async () => {
-        mockConfig.notifyOnLockout = jest.fn();
-        await service.lockAccount(mockAccount);
-        expect(mockConfig.lockAccount).toHaveBeenCalledWith(mockAccount);
-        expect(mockConfig.notifyOnLockout).toHaveBeenCalledWith(mockAccount);
-    });
-    it("lockAccount does not notify if notifyOnLockout is not defined", async () => {
-        mockConfig.notifyOnLockout = undefined;
-        await service.lockAccount(mockAccount);
-        expect(mockConfig.lockAccount).toHaveBeenCalledWith(mockAccount);
-    });
-    it("hasAccountLockExpired returns expected value", async () => {
-        mockConfig.hasAccountLockExpired.mockResolvedValue(true);
-        await expect(service.hasAccountLockExpired(mockAccount)).resolves.toBe(true);
-    });
-    it("removeAccountLock calls the correct method", async () => {
-        await service.removeAccountLock(mockAccount);
-        expect(mockConfig.removeAccountLock).toHaveBeenCalledWith(mockAccount);
-    });
-    it("logFailedAttempt logs action and handles error if logging fails", async () => {
-        mockConfig.logFailedAttempt.mockRejectedValue(new Error("Logging failed"));
-        await service.logFailedAttempt("LOGIN_ATTEMPT", mockAccount, {});
-        expect(mockLogger.error).toHaveBeenCalled();
-    });
-});

package/build/services/__tests__/auth-throttle.service.test.d.ts

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