@soapjs/soap-auth 0.3.3 → 0.4.4

package/build/services/__tests__/auth-throttle.service.test.js

@@ -1,48 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const errors_1 = require("../../errors");
-const auth_throttle_service_1 = require("../auth-throttle.service");
-const mockConfig = {
-    getFailedAttempts: jest.fn(),
-    incrementFailedAttempts: jest.fn(),
-    resetFailedAttempts: jest.fn(),
-    maxFailedAttempts: 3,
-};
-const mockLogger = {
-    warn: jest.fn(),
-    error: jest.fn(),
-};
-describe("AuthThrottleService", () => {
-    let service;
-    const mockIdentifier = "user123";
-    beforeEach(() => {
-        jest.clearAllMocks();
-        service = new auth_throttle_service_1.AuthThrottleService(mockConfig, mockLogger);
-    });
-    it("checkFailedAttempts throws error if max failed attempts reached", async () => {
-        mockConfig.getFailedAttempts.mockResolvedValue(3);
-        await expect(service.checkFailedAttempts(mockIdentifier)).rejects.toThrow(errors_1.AccountLockedError);
-        expect(mockLogger.warn).toHaveBeenCalledWith(`User ${mockIdentifier} is temporarily locked out.`);
-    });
-    it("checkFailedAttempts does not throw error if failed attempts are below threshold", async () => {
-        mockConfig.getFailedAttempts.mockResolvedValue(2);
-        await expect(service.checkFailedAttempts(mockIdentifier)).resolves.not.toThrow();
-    });
-    it("checkFailedAttempts logs error if an exception occurs", async () => {
-        mockConfig.getFailedAttempts.mockRejectedValue(new Error("DB error"));
-        await service.checkFailedAttempts(mockIdentifier);
-        expect(mockLogger.error).toHaveBeenCalledWith("Check failed attempts:", expect.any(Error));
-    });
-    it("incrementFailedAttempts increments counter and throws if max reached", async () => {
-        mockConfig.getFailedAttempts.mockResolvedValue(3);
-        await expect(service.incrementFailedAttempts(mockIdentifier)).rejects.toThrow(errors_1.AccountLockedError);
-    });
-    it("incrementFailedAttempts increments counter without throwing if below threshold", async () => {
-        mockConfig.getFailedAttempts.mockResolvedValue(2);
-        await expect(service.incrementFailedAttempts(mockIdentifier)).resolves.not.toThrow();
-    });
-    it("resetFailedAttempts calls the correct method", async () => {
-        await service.resetFailedAttempts(mockIdentifier);
-        expect(mockConfig.resetFailedAttempts).toHaveBeenCalledWith(mockIdentifier);
-    });
-});

package/build/services/__tests__/jwks.service.test.d.ts

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

package/build/services/__tests__/jwks.service.test.js

@@ -1,39 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
-const jwks_service_1 = require("../jwks.service");
-const oauth2_errors_1 = require("../../strategies/oauth2/oauth2.errors");
-describe("JwtService", () => {
-    let service;
-    let mockConfig;
-    const mockIdToken = "mock.id.token";
-    beforeEach(() => {
-        jest.clearAllMocks();
-        mockConfig = {
-            jwks: {
-                jwksUri: "https://mock-jwks-uri.com",
-                algorithms: ["RS256"],
-                issuer: "mock-issuer",
-                audience: "mock-client-id",
-            },
-        };
-        service = new jwks_service_1.JwtService(mockConfig);
-    });
-    it("verify throws error if ID token structure is invalid", async () => {
-        jest.spyOn(jsonwebtoken_1.default, "decode").mockReturnValue(null);
-        await expect(service.verify(mockIdToken)).rejects.toThrow("Invalid ID Token structure.");
-    });
-    it("verify throws error if ID token is expired", async () => {
-        jest.spyOn(jsonwebtoken_1.default, "decode").mockReturnValue({ header: { kid: "mock-kid" } });
-        jest
-            .spyOn(service.client, "getSigningKey")
-            .mockResolvedValue({ getPublicKey: () => "mock-public-key" });
-        jest
-            .spyOn(jsonwebtoken_1.default, "verify")
-            .mockReturnValue({ exp: Math.floor(Date.now() / 1000) - 10 });
-        await expect(service.verify(mockIdToken)).rejects.toThrow(oauth2_errors_1.InvalidIdTokenError);
-    });
-});

package/build/services/__tests__/mfa.service.test.d.ts

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

package/build/services/__tests__/mfa.service.test.js

@@ -1,66 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const mfa_service_1 = require("../mfa.service");
-const mockConfig = {
-    isMfaRequired: jest.fn(),
-    extractMfaCode: jest.fn(),
-    sendMfaCode: jest.fn(),
-    validateMfaCode: jest.fn(),
-    maxMfaAttempts: 3,
-    getMfaAttempts: jest.fn(),
-    incrementMfaAttempts: jest.fn(),
-    resetMfaAttempts: jest.fn(),
-    lockMfaOnFailure: jest.fn(),
-};
-const mockLogger = {
-    info: jest.fn(),
-    warn: jest.fn(),
-    error: jest.fn(),
-};
-describe("MfaService", () => {
-    let service;
-    const mockUser = { id: "user123" };
-    const mockContext = { token: "mock-token" };
-    beforeEach(() => {
-        jest.clearAllMocks();
-        service = new mfa_service_1.MfaService(mockConfig, mockLogger);
-    });
-    it("checkMfa sends code if required and no code provided", async () => {
-        mockConfig.isMfaRequired.mockReturnValue(true);
-        mockConfig.extractMfaCode.mockReturnValue(null);
-        await expect(service.checkMfa(mockUser, mockContext)).rejects.toThrow("2FA required. A verification code has been sent.");
-        expect(mockConfig.sendMfaCode).toHaveBeenCalledWith(mockUser, mockContext);
-    });
-    it("checkMfa locks account after too many failed attempts", async () => {
-        mockConfig.isMfaRequired.mockReturnValue(true);
-        mockConfig.extractMfaCode.mockReturnValue("wrong-code");
-        mockConfig.getMfaAttempts.mockResolvedValue(3);
-        await expect(service.checkMfa(mockUser, mockContext)).rejects.toThrow("Your account has been temporarily locked due to too many failed 2FA attempts.");
-        expect(mockLogger.warn).toHaveBeenCalledWith(`User ${mockUser} exceeded maximum MFA attempts.`);
-        expect(mockConfig.lockMfaOnFailure).toHaveBeenCalledWith(mockUser);
-    });
-    it("checkMfa rejects invalid MFA codes", async () => {
-        mockConfig.isMfaRequired.mockReturnValue(true);
-        mockConfig.extractMfaCode.mockReturnValue("invalid-code");
-        mockConfig.getMfaAttempts.mockResolvedValue(1);
-        mockConfig.validateMfaCode.mockResolvedValue(false);
-        await expect(service.checkMfa(mockUser, mockContext)).rejects.toThrow("Invalid 2FA code provided.");
-        expect(mockLogger.warn).toHaveBeenCalledWith(`Invalid MFA code attempt for user: ${mockUser}`);
-        expect(mockConfig.incrementMfaAttempts).toHaveBeenCalledWith(mockUser);
-    });
-    it("checkMfa resets attempts on successful MFA validation", async () => {
-        mockConfig.isMfaRequired.mockReturnValue(true);
-        mockConfig.extractMfaCode.mockReturnValue("valid-code");
-        mockConfig.validateMfaCode.mockResolvedValue(true);
-        await expect(service.checkMfa(mockUser, mockContext)).resolves.not.toThrow();
-        expect(mockConfig.resetMfaAttempts).toHaveBeenCalledWith(mockUser);
-        expect(mockLogger.info).toHaveBeenCalledWith(`2FA successfully validated for user: ${mockUser}`);
-    });
-    it("lockMfaOnFailure logs error if an exception occurs", async () => {
-        mockConfig.lockMfaOnFailure.mockImplementation(() => {
-            throw new Error("Lock failed");
-        });
-        service.lockMfaOnFailure(mockUser);
-        expect(mockLogger.error).toHaveBeenCalledWith(expect.any(Error));
-    });
-});

package/build/services/__tests__/password.service.test.d.ts

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

package/build/services/__tests__/password.service.test.js

@@ -1,66 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const password_service_1 = require("../password.service");
-const soap_1 = require("@soapjs/soap");
-const globals_1 = require("@jest/globals");
-describe("PasswordService", () => {
-    let service;
-    let mockConfig;
-    const mockLogger = { error: globals_1.jest.fn() };
-    const mockIdentifier = "user123";
-    const mockPassword = "SecurePass123!";
-    beforeEach(() => {
-        globals_1.jest.clearAllMocks();
-        mockConfig = {
-            validatePassword: globals_1.jest.fn(),
-            getLastPasswordChange: globals_1.jest.fn(),
-            generateResetToken: globals_1.jest.fn(),
-            sendResetEmail: globals_1.jest.fn(),
-            validateResetToken: globals_1.jest.fn(),
-            updatePassword: globals_1.jest.fn(),
-            passwordExpirationDays: 30,
-        };
-        service = new password_service_1.PasswordService(mockConfig, mockLogger);
-    });
-    it("validatePassword calls config method", async () => {
-        mockConfig.validatePassword.mockReturnValue(true);
-        await expect(service.validatePassword(mockPassword)).resolves.toBe(true);
-        expect(mockConfig.validatePassword).toHaveBeenCalledWith(mockPassword);
-    });
-    it("getLastPasswordChange calls config method", async () => {
-        const mockDate = new Date();
-        mockConfig.getLastPasswordChange.mockReturnValue(mockDate);
-        await expect(service.getLastPasswordChange(mockIdentifier)).resolves.toBe(mockDate);
-        expect(mockConfig.getLastPasswordChange).toHaveBeenCalledWith(mockIdentifier);
-    });
-    it("generateResetToken calls config method", async () => {
-        mockConfig.generateResetToken.mockResolvedValue("mock-token");
-        await expect(service.generateResetToken(mockIdentifier)).resolves.toBe("mock-token");
-    });
-    it("sendResetEmail calls config method", async () => {
-        await expect(service.sendResetEmail(mockIdentifier, "mock-token")).resolves.not.toThrow();
-        expect(mockConfig.sendResetEmail).toHaveBeenCalledWith(mockIdentifier, "mock-token");
-    });
-    it("validateResetToken calls config method", async () => {
-        mockConfig.validateResetToken.mockResolvedValue(true);
-        await expect(service.validateResetToken("mock-token")).resolves.toBe(true);
-    });
-    it("updatePassword calls config method", async () => {
-        await expect(service.updatePassword(mockIdentifier, mockPassword)).resolves.not.toThrow();
-        expect(mockConfig.updatePassword).toHaveBeenCalledWith(mockIdentifier, mockPassword);
-    });
-    it("isPasswordChangeRequired returns true if password is expired", async () => {
-        const pastDate = new Date(Date.now() - 31 * 86400000);
-        mockConfig.getLastPasswordChange.mockResolvedValue(pastDate);
-        await expect(service.isPasswordChangeRequired(mockIdentifier)).resolves.toBe(true);
-    });
-    it("isPasswordChangeRequired returns false if password is within expiration period", async () => {
-        const recentDate = new Date(Date.now() - 15 * 86400000);
-        mockConfig.getLastPasswordChange.mockResolvedValue(recentDate);
-        await expect(service.isPasswordChangeRequired(mockIdentifier)).resolves.toBe(false);
-    });
-    it("isPasswordChangeRequired throws NotImplementedError if getLastPasswordChange is not defined", async () => {
-        service = new password_service_1.PasswordService({ passwordExpirationDays: 30 }, mockLogger);
-        await expect(service.isPasswordChangeRequired(mockIdentifier)).rejects.toThrow(soap_1.NotImplementedError);
-    });
-});

package/build/services/__tests__/pkce.service.test.d.ts

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

package/build/services/__tests__/pkce.service.test.js

@@ -1,77 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const pkce_service_1 = require("../pkce.service");
-class InMemoryPKCEPersistence {
-    storeMap = new Map();
-    async store(key, meta) {
-        this.storeMap.set(key, meta || {});
-    }
-    async read(verifierOrChallenge) {
-        return this.storeMap.get(verifierOrChallenge);
-    }
-    async remove(key) {
-        this.storeMap.delete(key);
-    }
-}
-describe("PKCEService", () => {
-    let service;
-    let config;
-    beforeEach(() => {
-        config = {
-            verifier: {
-                expiresIn: 1,
-                embed: jest.fn(),
-                extract: jest.fn().mockImplementation((ctx) => ctx.verifier),
-                persistence: new InMemoryPKCEPersistence(),
-            },
-            challenge: {
-                expiresIn: 1,
-                embed: jest.fn(),
-                extract: jest.fn().mockImplementation((ctx) => ctx.challenge),
-                persistence: new InMemoryPKCEPersistence(),
-            },
-        };
-        service = new pkce_service_1.PKCEService(config);
-    });
-    it("should generate and store a code verifier", async () => {
-        const context = { key: "code_verifier_test" };
-        const verifier = await service.generateCodeVerifier(context);
-        expect(verifier).toBeDefined();
-        expect(config.verifier.embed).toHaveBeenCalledWith(context, verifier);
-    });
-    it("should generate and store a code challenge", async () => {
-        const context = { key: "code_challenge_test" };
-        const challenge = await service.generateCodeChallenge("test_verifier", context);
-        expect(challenge).toBeDefined();
-        expect(config.challenge.embed).toHaveBeenCalledWith(context, challenge);
-    });
-    it("should detect expired code verifier", async () => {
-        config.verifier.embed = (ctx, cv) => {
-            ctx.verifier = cv;
-        };
-        const context = { key: "expired_verifier_test" };
-        await service.generateCodeVerifier(context);
-        await new Promise((resolve) => setTimeout(resolve, 1500));
-        const isExpired = await service.isCodeVerifierExpired(context);
-        expect(isExpired).toBe(true);
-    });
-    it("should detect not-expired code verifier", async () => {
-        config.verifier.embed = (ctx, cv) => {
-            ctx.verifier = cv;
-        };
-        const context = {
-            key: "not_expired_verifier_test",
-        };
-        await service.generateCodeVerifier(context);
-        await new Promise((resolve) => setTimeout(resolve, 500));
-        const isExpired = await service.isCodeVerifierExpired(context);
-        expect(isExpired).toBe(false);
-    });
-    it("should clear code verifier", async () => {
-        const context = {
-            key: "clear_verifier_test",
-            verifier: "test_verifier_value",
-        };
-        await service.clearCodeVerifier(context);
-    });
-});

package/build/services/__tests__/rate-limit.service.test.d.ts

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

package/build/services/__tests__/rate-limit.service.test.js

@@ -1,37 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const errors_1 = require("../../errors");
-const rate_limit_service_1 = require("../rate-limit.service");
-const mockConfig = {
-    incrementRequestCount: jest.fn(),
-    checkRateLimit: jest.fn(),
-};
-const mockLogger = {
-    error: jest.fn(),
-};
-describe("RateLimitService", () => {
-    let service;
-    const mockData = { userId: "user123" };
-    beforeEach(() => {
-        jest.clearAllMocks();
-        service = new rate_limit_service_1.RateLimitService(mockConfig, mockLogger);
-    });
-    it("incrementRequestCount calls config method and handles errors", async () => {
-        mockConfig.incrementRequestCount.mockResolvedValue(undefined);
-        await expect(service.incrementRequestCount(mockData)).resolves.not.toThrow();
-        expect(mockConfig.incrementRequestCount).toHaveBeenCalledWith(mockData);
-    });
-    it("incrementRequestCount logs error if an exception occurs", async () => {
-        mockConfig.incrementRequestCount.mockRejectedValue(new Error("Increment failed"));
-        await expect(service.incrementRequestCount(mockData)).resolves.not.toThrow();
-        expect(mockLogger.error).toHaveBeenCalledWith(expect.any(Error));
-    });
-    it("checkRateLimit throws RateLimitExceededError if limit is exceeded", async () => {
-        mockConfig.checkRateLimit.mockResolvedValue(true);
-        await expect(service.checkRateLimit(mockData)).rejects.toThrow(errors_1.RateLimitExceededError);
-    });
-    it("checkRateLimit does not throw error if limit is not exceeded", async () => {
-        mockConfig.checkRateLimit.mockResolvedValue(false);
-        await expect(service.checkRateLimit(mockData)).resolves.not.toThrow();
-    });
-});

package/build/services/__tests__/role.service.test.d.ts

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

package/build/services/__tests__/role.service.test.js

@@ -1,31 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const errors_1 = require("../../errors");
-const role_service_1 = require("../role.service");
-const mockConfig = {
-    authorizeByRoles: jest.fn(),
-    roles: ["admin", "editor"],
-};
-const mockLogger = {
-    error: jest.fn(),
-};
-describe("RoleService", () => {
-    let service;
-    const mockUser = { id: "user123", role: "viewer" };
-    beforeEach(() => {
-        jest.clearAllMocks();
-        service = new role_service_1.RoleService(mockConfig, mockLogger);
-    });
-    it("isAuthorized throws UnauthorizedRoleError if user is not authorized", async () => {
-        mockConfig.authorizeByRoles.mockResolvedValue(false);
-        await expect(service.isAuthorized(mockUser)).rejects.toThrow(errors_1.UnauthorizedRoleError);
-    });
-    it("isAuthorized returns true if user is authorized", async () => {
-        mockConfig.authorizeByRoles.mockResolvedValue(true);
-        await expect(service.isAuthorized(mockUser)).resolves.toBe(true);
-    });
-    it("isAuthorized bypasses role check if authorizeByRoles is not defined", async () => {
-        service = new role_service_1.RoleService({ roles: [] }, mockLogger);
-        await expect(service.isAuthorized(mockUser)).resolves.toBe(true);
-    });
-});

package/build/session/__tests__/file.session-store.test.d.ts

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

package/build/session/__tests__/file.session-store.test.js

@@ -1,117 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const file_session_store_1 = require("../file.session-store");
-const promises_1 = __importDefault(require("fs/promises"));
-const path_1 = __importDefault(require("path"));
-jest.mock("fs/promises", () => ({
-    mkdir: jest.fn(),
-    readFile: jest.fn(),
-    writeFile: jest.fn(),
-    unlink: jest.fn(),
-    readdir: jest.fn(),
-}));
-describe("FileSessionStore", () => {
-    let store;
-    const mockSessionsDir = "/mock/sessions";
-    beforeEach(() => {
-        store = new file_session_store_1.FileSessionStore(mockSessionsDir);
-        jest.clearAllMocks();
-    });
-    describe("init", () => {
-        it("should create the sessions directory recursively", async () => {
-            await store.init();
-            expect(promises_1.default.mkdir).toHaveBeenCalledWith(mockSessionsDir, {
-                recursive: true,
-            });
-        });
-        it("should catch and log errors if mkdir fails", async () => {
-            const consoleSpy = jest
-                .spyOn(console, "error")
-                .mockImplementation(() => { });
-            promises_1.default.mkdir.mockRejectedValueOnce(new Error("mkdir error"));
-            await store.init();
-            expect(consoleSpy).toHaveBeenCalledWith("Error initializing session directory:", expect.any(Error));
-            consoleSpy.mockRestore();
-        });
-    });
-    describe("getSession", () => {
-        it("should return parsed JSON if file read is successful", async () => {
-            const mockData = { user: { id: "123" } };
-            promises_1.default.readFile.mockResolvedValueOnce(JSON.stringify(mockData));
-            const session = await store.getSession("session123");
-            expect(session).toEqual(mockData);
-            expect(promises_1.default.readFile).toHaveBeenCalledWith(path_1.default.join(mockSessionsDir, "session123"), "utf8");
-        });
-        it("should return null and log error if readFile fails", async () => {
-            const consoleSpy = jest
-                .spyOn(console, "error")
-                .mockImplementation(() => { });
-            promises_1.default.readFile.mockRejectedValueOnce(new Error("read error"));
-            const session = await store.getSession("badSession");
-            expect(session).toBeNull();
-            expect(consoleSpy).toHaveBeenCalledWith("Error getting session:", expect.any(Error));
-            consoleSpy.mockRestore();
-        });
-        it("should return null if JSON parse fails", async () => {
-            const consoleSpy = jest
-                .spyOn(console, "error")
-                .mockImplementation(() => { });
-            promises_1.default.readFile.mockResolvedValueOnce("invalid-json");
-            const session = await store.getSession("corruptSession");
-            expect(session).toBeNull();
-            expect(consoleSpy).toHaveBeenCalledWith("Error getting session:", expect.any(Error));
-            consoleSpy.mockRestore();
-        });
-    });
-    describe("setSession", () => {
-        it("should write stringified session data to a file", async () => {
-            const mockData = { user: { id: "xyz" } };
-            await store.setSession("sessionABC", mockData);
-            expect(promises_1.default.writeFile).toHaveBeenCalledWith(path_1.default.join(mockSessionsDir, "sessionABC"), JSON.stringify(mockData), "utf8");
-        });
-        it("should throw error if writeFile fails", async () => {
-            promises_1.default.writeFile.mockRejectedValueOnce(new Error("write error"));
-            await expect(store.setSession("sessionError", { user: { id: "1" } })).rejects.toThrow("write error");
-        });
-    });
-    describe("destroySession", () => {
-        it("should unlink the file associated with the session ID", async () => {
-            await store.destroySession("destroyMe");
-            expect(promises_1.default.unlink).toHaveBeenCalledWith(path_1.default.join(mockSessionsDir, "destroyMe"));
-        });
-        it("should ignore ENOENT errors (file not found)", async () => {
-            promises_1.default.unlink.mockRejectedValueOnce({ code: "ENOENT" });
-            await expect(store.destroySession("notExists")).resolves.toBeUndefined();
-        });
-        it("should rethrow other errors", async () => {
-            promises_1.default.unlink.mockRejectedValueOnce(new Error("unlink error"));
-            await expect(store.destroySession("sessionX")).rejects.toThrow("unlink error");
-        });
-    });
-    describe("touchSession", () => {
-        it("should call setSession with updated data", async () => {
-            const setSessionSpy = jest.spyOn(store, "setSession").mockResolvedValue();
-            const newData = { user: { id: "touchMe" } };
-            await store.touchSession("touchId", newData);
-            expect(setSessionSpy).toHaveBeenCalledWith("touchId", newData);
-        });
-    });
-    describe("getSessionIds", () => {
-        it("should return the base names of files in the sessions directory", async () => {
-            promises_1.default.readdir.mockResolvedValueOnce([
-                { name: "abc", isFile: () => true },
-                { name: "def.json", isFile: () => true },
-                { name: "subdir", isFile: () => false },
-            ]);
-            const result = await store.getSessionIds();
-            expect(result).toEqual(["abc", "def"]);
-        });
-        it("should throw if readdir fails", async () => {
-            promises_1.default.readdir.mockRejectedValueOnce(new Error("readdir error"));
-            await expect(store.getSessionIds()).rejects.toThrow("readdir error");
-        });
-    });
-});

package/build/session/__tests__/memory.session-store.test.d.ts

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

package/build/session/__tests__/memory.session-store.test.js

@@ -1,77 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const memory_session_store_1 = require("../memory.session-store");
-describe("MemorySessionStore", () => {
-    let store;
-    beforeEach(() => {
-        store = new memory_session_store_1.MemorySessionStore();
-    });
-    describe("getSession", () => {
-        it("should return null if session does not exist", async () => {
-            const data = await store.getSession("nonExistent");
-            expect(data).toBeNull();
-        });
-        it("should return the stored session data if present", async () => {
-            await store.setSession("session1", {
-                user: { id: "123", name: "John" },
-            });
-            const session = await store.getSession("session1");
-            expect(session).toEqual({ user: { id: "123", name: "John" } });
-        });
-    });
-    describe("setSession", () => {
-        it("should store session data in memory", async () => {
-            await store.setSession("session2", {
-                user: { id: "abc", name: "Alice" },
-            });
-            const session = await store.getSession("session2");
-            expect(session).toEqual({ user: { id: "abc", name: "Alice" } });
-        });
-    });
-    describe("destroySession", () => {
-        it("should delete the session from memory", async () => {
-            await store.setSession("sessionDelete", {
-                user: { id: "xyz", name: "Jane" },
-            });
-            await store.destroySession("sessionDelete");
-            const session = await store.getSession("sessionDelete");
-            expect(session).toBeNull();
-        });
-        it("should not throw if the session does not exist", async () => {
-            await expect(store.destroySession("noSession")).resolves.not.toThrow();
-        });
-    });
-    describe("touchSession", () => {
-        it("should update the session data if it exists", async () => {
-            await store.setSession("sessionTouch", {
-                user: { id: "initial", name: "Old" },
-            });
-            await store.touchSession("sessionTouch", {
-                user: { id: "updated", name: "New" },
-            });
-            const updated = await store.getSession("sessionTouch");
-            expect(updated).toEqual({ user: { id: "updated", name: "New" } });
-        });
-        it("should create a new session if it doesn't exist (similar to setSession)", async () => {
-            await store.touchSession("sessionNew", {
-                user: { id: "newId", name: "New Name" },
-            });
-            const data = await store.getSession("sessionNew");
-            expect(data).toEqual({ user: { id: "newId", name: "New Name" } });
-        });
-    });
-    describe("getSessionIds", () => {
-        it("should return an empty array if no sessions exist", async () => {
-            const ids = await store.getSessionIds();
-            expect(ids).toEqual([]);
-        });
-        it("should return all session IDs currently in memory", async () => {
-            await store.setSession("id1", { user: { id: "one" } });
-            await store.setSession("id2", { user: { id: "two" } });
-            const ids = await store.getSessionIds();
-            expect(ids).toContain("id1");
-            expect(ids).toContain("id2");
-            expect(ids.length).toBe(2);
-        });
-    });
-});

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

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