@soapjs/soap-auth 0.3.1 → 0.3.2

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

@@ -0,0 +1,77 @@
+"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

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

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

@@ -0,0 +1,337 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const session_handler_1 = require("../session-handler");
+const session_errors_1 = require("../session.errors");
+describe("SessionHandler", () => {
+    let mockStore;
+    let mockLogger;
+    let sessionHandler;
+    let config;
+    beforeEach(() => {
+        mockStore = {
+            getSession: jest.fn(),
+            setSession: jest.fn(),
+            touchSession: jest.fn(),
+            destroySession: jest.fn(),
+            getSessionIds: jest.fn().mockResolvedValue(["s1", "s2"]),
+        };
+        mockLogger = {
+            info: jest.fn(),
+            error: jest.fn(),
+            warn: jest.fn(),
+        };
+        config = {
+            store: mockStore,
+            sessionKey: "CUSTOMSESSION",
+            sessionHeader: "x-custom-session",
+            logger: mockLogger,
+            cookie: {
+                maxAge: 3600,
+            },
+            generateSessionId: jest.fn(),
+            getSessionId: undefined,
+            embedSessionId: undefined,
+            createSessionData: undefined,
+        };
+        sessionHandler = new session_handler_1.SessionHandler(config, mockLogger);
+    });
+    describe("constructor", () => {
+        it("should throw if store is not provided", () => {
+            expect(() => {
+                new session_handler_1.SessionHandler({});
+            }).toThrowError("Session store is required.");
+        });
+        it("should set default sessionKey and headerKey if not provided", () => {
+            const newHandler = new session_handler_1.SessionHandler({ store: mockStore });
+            expect(newHandler.sessionKey).toBe("SESSIONID");
+            expect(newHandler.headerKey).toBe("x-session-id");
+        });
+        it("should use provided sessionKey and headerKey if available", () => {
+            expect(sessionHandler.sessionKey).toBe("CUSTOMSESSION");
+            expect(sessionHandler.headerKey).toBe("x-custom-session");
+        });
+    });
+    describe("setSessionId", () => {
+        it("should call config.embedSessionId if defined", () => {
+            config.embedSessionId = jest.fn();
+            const handler = new session_handler_1.SessionHandler(config, mockLogger);
+            const context = {};
+            handler.setSessionId(context, "session123");
+            expect(config.embedSessionId).toHaveBeenCalledWith(context, "session123");
+        });
+        it("should set session ID in cookie if res.cookie is available", () => {
+            const context = {
+                res: {
+                    cookie: jest.fn(),
+                },
+            };
+            sessionHandler.setSessionId(context, "sessionABC");
+            expect(context.res.cookie).toHaveBeenCalledWith("CUSTOMSESSION", "sessionABC", expect.objectContaining({
+                httpOnly: true,
+                secure: true,
+                sameSite: "strict",
+            }));
+            expect(mockLogger.info).toHaveBeenCalledWith(`Session ID set in cookie: CUSTOMSESSION`);
+        });
+        it("should set session ID in header if res.setHeader is available", () => {
+            const context = {
+                res: {
+                    setHeader: jest.fn(),
+                },
+            };
+            sessionHandler.setSessionId(context, "headerSessionId");
+            expect(context.res.setHeader).toHaveBeenCalledWith("x-custom-session", "headerSessionId");
+            expect(mockLogger.info).toHaveBeenCalledWith(`Session ID set in header: x-custom-session`);
+        });
+        it("should set sessionId directly on context object if no res", () => {
+            const context = {};
+            sessionHandler.setSessionId(context, "direct123");
+            expect(context.sessionId).toBe("direct123");
+            expect(mockLogger.info).toHaveBeenCalledWith("Session ID set in context object");
+        });
+        it("should log error if something goes wrong", () => {
+            config.embedSessionId = jest.fn().mockImplementation(() => {
+                throw new Error("Test error");
+            });
+            const handler = new session_handler_1.SessionHandler(config, mockLogger);
+            handler.setSessionId({}, "boom");
+            expect(mockLogger.error).toHaveBeenCalledWith("Error setting session ID:", expect.any(Error));
+        });
+    });
+    describe("getSessionId", () => {
+        it("should use config.getSessionId if defined", () => {
+            config.getSessionId = jest.fn().mockReturnValue("customSessionId");
+            const handler = new session_handler_1.SessionHandler(config, mockLogger);
+            const sid = handler.getSessionId({});
+            expect(sid).toBe("customSessionId");
+            expect(config.getSessionId).toHaveBeenCalled();
+        });
+        it("should return cookie session if present", () => {
+            const context = { cookies: { CUSTOMSESSION: "cookieValue" } };
+            const sid = sessionHandler.getSessionId(context);
+            expect(sid).toBe("cookieValue");
+        });
+        it("should return header session if present", () => {
+            const context = { headers: { "x-custom-session": "headerValue" } };
+            const sid = sessionHandler.getSessionId(context);
+            expect(sid).toBe("headerValue");
+        });
+        it("should return sessionId if set directly on context", () => {
+            const context = { sessionId: "directValue" };
+            const sid = sessionHandler.getSessionId(context);
+            expect(sid).toBe("directValue");
+        });
+        it("should return null if not found", () => {
+            const context = {};
+            const sid = sessionHandler.getSessionId(context);
+            expect(sid).toBeNull();
+        });
+        it("should log error and return null if something goes wrong", () => {
+            config.getSessionId = jest.fn().mockImplementation(() => {
+                throw new Error("Get error");
+            });
+            const handler = new session_handler_1.SessionHandler(config, mockLogger);
+            const sid = handler.getSessionId({});
+            expect(mockLogger.error).toHaveBeenCalledWith("Error retrieving session ID:", expect.any(Error));
+            expect(sid).toBeNull();
+        });
+    });
+    describe("generateSessionId", () => {
+        it("should use config.generateSessionId if provided", () => {
+            config.generateSessionId.mockReturnValue("customGenerated");
+            const sid = sessionHandler.generateSessionId();
+            expect(sid).toBe("customGenerated");
+            expect(config.generateSessionId).toHaveBeenCalled();
+        });
+        it("should fallback to uuid if no config.generateSessionId is given", () => {
+            config.generateSessionId = undefined;
+            const sid = sessionHandler.generateSessionId();
+            expect(typeof sid).toBe("string");
+            expect(sid.length).toBeGreaterThan(0);
+        });
+    });
+    describe("buildSessionData", () => {
+        it("should call config.createSessionData if provided", () => {
+            config.createSessionData = jest
+                .fn()
+                .mockReturnValue({ user: "mockUser" });
+            const data = sessionHandler.buildSessionData({ id: "test" }, {});
+            expect(config.createSessionData).toHaveBeenCalledWith({ id: "test" }, {});
+            expect(data).toEqual({ user: "mockUser" });
+        });
+        it("should default to { user: data } if createSessionData not provided", () => {
+            config.createSessionData = undefined;
+            const input = { id: "testId" };
+            const data = sessionHandler.buildSessionData(input);
+            expect(data).toEqual({ user: input });
+        });
+    });
+    describe("getSessionData", () => {
+        it("should return data from the store", async () => {
+            mockStore.getSession.mockResolvedValue({ user: { id: "1" } });
+            const data = await sessionHandler.getSessionData("session123");
+            expect(data).toEqual({ user: { id: "1" } });
+        });
+        it("should return null if store.getSession fails", async () => {
+            mockStore.getSession.mockRejectedValue(new Error("Store error"));
+            const data = await sessionHandler.getSessionData("sessionX");
+            expect(data).toBeNull();
+            expect(mockLogger.error).toHaveBeenCalledWith("Error retrieving session data:", expect.any(Error));
+        });
+    });
+    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 call store.setSession with provided data", async () => {
+            await sessionHandler.setSessionData("sessionXYZ", {
+                user: { id: "abc" },
+            });
+            expect(mockStore.setSession).toHaveBeenCalledWith("sessionXYZ", {
+                user: { id: "abc" },
+            });
+            expect(mockLogger.info).toHaveBeenCalledWith("Session set for ID: sessionXYZ");
+        });
+        it("should log error if store.setSession fails", async () => {
+            mockStore.setSession.mockRejectedValue(new Error("Store error"));
+            await sessionHandler.setSessionData("session123", {
+                user: { id: "xyz" },
+            });
+            expect(mockLogger.error).toHaveBeenCalledWith("Error storing session data:", expect.any(Error));
+        });
+    });
+    describe("touch", () => {
+        it("should warn if no sessionId is provided", async () => {
+            await sessionHandler.touch("");
+            expect(mockLogger.warn).toHaveBeenCalledWith("No session ID found, unable to touch session.");
+        });
+        it("should warn if session not found", async () => {
+            mockStore.getSession.mockResolvedValue(null);
+            await sessionHandler.touch("noSuchId", { user: { id: "1" } });
+            expect(mockLogger.warn).toHaveBeenCalledWith("Session not found for ID: noSuchId");
+        });
+        it("should merge data and call store.touchSession if session found", async () => {
+            mockStore.getSession.mockResolvedValue({ user: { id: "old" } });
+            await sessionHandler.touch("session123", { user: { id: "new" } });
+            expect(mockStore.touchSession).toHaveBeenCalledWith("session123", {
+                user: { id: "new" },
+            });
+            expect(mockLogger.info).toHaveBeenCalledWith("Session touched for ID: session123");
+        });
+        it("should log error on store errors", async () => {
+            mockStore.getSession.mockResolvedValue({ user: {} });
+            mockStore.touchSession.mockRejectedValue(new Error("Touch error"));
+            await sessionHandler.touch("session123");
+            expect(mockLogger.error).toHaveBeenCalledWith("Error touching session:", expect.any(Error));
+        });
+    });
+    describe("destroy", () => {
+        it("should call store.destroySession with sessionId", async () => {
+            await sessionHandler.destroy("sessionABC");
+            expect(mockStore.destroySession).toHaveBeenCalledWith("sessionABC");
+            expect(mockLogger.info).toHaveBeenCalledWith("Session destroyed for ID: sessionABC");
+        });
+        it("should do nothing if no sessionId is provided", async () => {
+            await sessionHandler.destroy("");
+            expect(mockStore.destroySession).not.toHaveBeenCalled();
+        });
+        it("should log error on store error", async () => {
+            mockStore.destroySession.mockRejectedValue(new Error("Destroy error"));
+            await sessionHandler.destroy("sessionXYZ");
+            expect(mockLogger.error).toHaveBeenCalledWith("Error destroying session:", expect.any(Error));
+        });
+    });
+    describe("isSessionExpired", () => {
+        it("should return false if no sessionData or no createdAt", () => {
+            expect(sessionHandler.isSessionExpired({})).toBe(false);
+            expect(sessionHandler.isSessionExpired(null)).toBe(false);
+        });
+        it("should return true if now - createdAt > maxAge", () => {
+            const oldTime = Date.now() - 7200 * 1000;
+            config.cookie.maxAge = 3600 * 1000;
+            const data = { createdAt: oldTime };
+            expect(sessionHandler.isSessionExpired(data)).toBe(true);
+        });
+        it("should return false if within maxAge", () => {
+            const recentTime = Date.now() - 1000 * 100;
+            config.cookie.maxAge = 600000;
+            const data = { createdAt: recentTime };
+            expect(sessionHandler.isSessionExpired(data)).toBe(false);
+        });
+    });
+    describe("issueSession", () => {
+        it("should reuse existing sessionId if present in context", async () => {
+            jest
+                .spyOn(sessionHandler, "getSessionId")
+                .mockReturnValue("ctxSessionId");
+            await sessionHandler.issueSession({ id: "u1" }, {});
+            expect(mockStore.setSession).toHaveBeenCalledWith("ctxSessionId", {
+                user: { id: "u1" },
+            });
+        });
+        it("should generate a new sessionId if none found in context", async () => {
+            jest.spyOn(sessionHandler, "getSessionId").mockReturnValue(null);
+            jest.spyOn(sessionHandler, "generateSessionId").mockReturnValue("newID");
+            const result = await sessionHandler.issueSession({ id: "u1" }, {});
+            expect(mockStore.setSession).toHaveBeenCalledWith("newID", {
+                user: { id: "u1" },
+            });
+            expect(result.sessionId).toBe("newID");
+        });
+        it("should call session.createSessionData if provided in config", async () => {
+            config.createSessionData = jest
+                .fn()
+                .mockReturnValue({ user: { id: "custom" }, extra: "hello" });
+            config.embedSessionId = jest.fn();
+            const handler = new session_handler_1.SessionHandler(config, mockLogger);
+            jest.spyOn(handler, "getSessionId").mockReturnValue("testSid");
+            const result = await handler.issueSession({ id: "u2" }, {});
+            expect(config.createSessionData).toHaveBeenCalledWith({ id: "u2" }, {});
+            expect(mockStore.setSession).toHaveBeenCalledWith("testSid", {
+                user: { id: "custom" },
+                extra: "hello",
+            });
+            expect(result.data).toEqual({ user: { id: "custom" }, extra: "hello" });
+        });
+        it("should embed sessionId if embedSessionId is defined in config.session", async () => {
+            config.embedSessionId = jest.fn();
+            const handler = new session_handler_1.SessionHandler(config, mockLogger);
+            jest.spyOn(handler, "getSessionId").mockReturnValue("abc123");
+            await handler.issueSession({ id: "u5" }, {});
+            expect(config.embedSessionId).toHaveBeenCalledWith({}, "abc123");
+            expect(mockLogger.info).toHaveBeenCalledWith("Stored user session with ID: abc123");
+        });
+    });
+    describe("logoutSession", () => {
+        it("should throw MissingSessionIdError if sessionId not found", async () => {
+            jest.spyOn(sessionHandler, "getSessionId").mockReturnValue(null);
+            await expect(sessionHandler.logoutSession({})).rejects.toThrow(session_errors_1.MissingSessionIdError);
+        });
+        it("should destroy session with found sessionId", async () => {
+            jest
+                .spyOn(sessionHandler, "getSessionId")
+                .mockReturnValue("logoutSessionId");
+            const destroySpy = jest.spyOn(sessionHandler, "destroy");
+            await sessionHandler.logoutSession({});
+            expect(destroySpy).toHaveBeenCalledWith("logoutSessionId");
+            expect(mockLogger.info).toHaveBeenCalledWith("Session destroyed: logoutSessionId");
+        });
+    });
+    describe("clearAllSessions", () => {
+        it("should destroy all sessions if store.getSessionIds is available", async () => {
+            mockStore.getSessionIds.mockResolvedValue(["s1", "s2", "s3"]);
+            await sessionHandler.clearAllSessions();
+            expect(mockStore.destroySession).toHaveBeenCalledWith("s1");
+            expect(mockStore.destroySession).toHaveBeenCalledWith("s2");
+            expect(mockStore.destroySession).toHaveBeenCalledWith("s3");
+            expect(mockLogger.info).toHaveBeenCalledWith("All sessions have been cleared.");
+        });
+        it("should log error if something goes wrong", async () => {
+            mockStore.getSessionIds.mockRejectedValue(new Error("Store read error"));
+            await sessionHandler.clearAllSessions();
+            expect(mockLogger.error).toHaveBeenCalledWith("Error clearing all sessions:", expect.any(Error));
+        });
+    });
+});

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

@@ -7,4 +7,5 @@ export declare class FileSessionStore implements SessionStore {
     setSession<SessionData>(sessionId: string, sessionData: SessionData): Promise<void>;
     destroySession(sessionId: string): Promise<void>;
     touchSession(sessionId: string, session: SessionData): Promise<void>;
+    getSessionIds(): Promise<string[]>;
 }

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

@@ -55,5 +55,12 @@ class FileSessionStore {
     async touchSession(sessionId, session) {
         await this.setSession(sessionId, session);
     }
+    async getSessionIds() {
+        const entries = await promises_1.default.readdir(this.sessionsDir, { withFileTypes: true });
+        const ids = entries
+            .filter((entry) => entry.isFile())
+            .map((file) => path_1.default.parse(file.name).name);
+        return ids;
+    }
 }
 exports.FileSessionStore = FileSessionStore;

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

@@ -1,7 +1,10 @@
-import { SessionStore } from "../types";
+import { SessionData, SessionStore } from "../types";
 export declare class MemorySessionStore implements SessionStore {
+    private sessions;
+    constructor(sessions?: Record<string, SessionData>);
     getSession<SessionData>(sessionId: string): Promise<SessionData | null>;
     setSession<SessionData>(sessionId: string, sessionData: SessionData): Promise<void>;
     destroySession(sessionId: string): Promise<void>;
     touchSession<SessionData>(sessionId: string, session: SessionData): Promise<void>;
+    getSessionIds(): Promise<string[]>;
 }

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

@@ -1,19 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MemorySessionStore = void 0;
-const sessions = {};
 class MemorySessionStore {
+    sessions;
+    constructor(sessions) {
+        this.sessions = sessions || {};
+    }
     async getSession(sessionId) {
-        return sessions[sessionId] || null;
+        return this.sessions[sessionId] || null;
     }
     async setSession(sessionId, sessionData) {
-        sessions[sessionId] = sessionData;
+        this.sessions[sessionId] = sessionData;
     }
     async destroySession(sessionId) {
-        delete sessions[sessionId];
+        delete this.sessions[sessionId];
     }
     async touchSession(sessionId, session) {
-        sessions[sessionId] = session;
+        this.sessions[sessionId] = session;
+    }
+    async getSessionIds() {
+        return Object.keys(this.sessions);
     }
 }
 exports.MemorySessionStore = MemorySessionStore;

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

@@ -1,17 +1,22 @@
-import { SessionConfig, SessionData } from "../types";
-export declare class SessionHandler<TContext = unknown, TData = SessionData> {
+import * as Soap from "@soapjs/soap";
+import { SessionConfig, SessionData, SessionInfo } from "../types";
+export declare class SessionHandler<TContext = unknown, TUser = unknown, TData = SessionData> {
     private config;
+    private logger?;
     private store;
     private sessionKey;
     private headerKey;
-    constructor(config: SessionConfig);
+    constructor(config: SessionConfig, logger?: Soap.Logger);
     setSessionId(context: TContext, sessionId: string): void;
     getSessionId(context: TContext): string | null;
     generateSessionId(): string;
     buildSessionData(data: unknown, context?: TContext): TData;
-    get(context: TContext): Promise<TData | null>;
-    set(context: TContext, data: TData): Promise<void>;
-    touch(context: TContext, data?: Partial<TData>): Promise<void>;
-    destroy(context: TContext): Promise<void>;
+    getSessionData(sessionId: string): Promise<TData | null>;
+    setSessionData(sessionId: string, data: TData): Promise<void>;
+    touch(sessionId: string, data?: Partial<TData>): Promise<void>;
+    destroy(sessionId: string): Promise<void>;
     isSessionExpired(sessionData: TData): boolean;
+    issueSession(user: TUser, context: TContext): Promise<SessionInfo<TData>>;
+    logoutSession(context: TContext): Promise<void>;
+    clearAllSessions(): Promise<void>;
 }

package/build/session/session-handler.js

@@ -2,13 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SessionHandler = void 0;
 const uuid_1 = require("uuid");
+const session_errors_1 = require("./session.errors");
 class SessionHandler {
     config;
+    logger;
     store;
     sessionKey;
     headerKey;
-    constructor(config) {
+    constructor(config, logger) {
         this.config = config;
+        this.logger = logger;
         if (!config.store) {
             throw new Error("Session store is required.");
         }
@@ -78,22 +81,22 @@ class SessionHandler {
             ? this.config.createSessionData(data, context)
             : { user: data };
     }
-    async get(context) {
+    async getSessionData(sessionId) {
         try {
-            const sessionId = this.getSessionId(context);
-            if (!sessionId)
-                return null;
-            return await this.store.getSession(sessionId);
+            const data = await this.store.getSession(sessionId);
+            return data;
         }
         catch (error) {
             this.config.logger?.error("Error retrieving session data:", error);
             return null;
         }
     }
-    async set(context, data) {
+    async setSessionData(sessionId, data) {
         try {
-            const sessionId = this.getSessionId(context) || this.generateSessionId();
-            this.config.embedSessionId?.(context, sessionId);
+            if (!sessionId) {
+                this.config.logger?.warn("No session ID found, unable to set session.");
+                return;
+            }
             await this.store.setSession(sessionId, data);
             this.config.logger?.info(`Session set for ID: ${sessionId}`);
         }
@@ -101,9 +104,8 @@ class SessionHandler {
             this.config.logger?.error("Error storing session data:", error);
         }
     }
-    async touch(context, data) {
+    async touch(sessionId, data) {
         try {
-            const sessionId = this.getSessionId(context);
             if (!sessionId) {
                 this.config.logger?.warn("No session ID found, unable to touch session.");
                 return;
@@ -121,9 +123,8 @@ class SessionHandler {
             this.config.logger?.error("Error touching session:", error);
         }
     }
-    async destroy(context) {
+    async destroy(sessionId) {
         try {
-            const sessionId = this.getSessionId(context);
             if (sessionId) {
                 await this.store.destroySession(sessionId);
                 this.config.logger?.info(`Session destroyed for ID: ${sessionId}`);
@@ -141,5 +142,37 @@ class SessionHandler {
         const sessionExpiryMs = this.config.cookie?.maxAge || 3600000;
         return now - sessionData.createdAt > sessionExpiryMs;
     }
+    async issueSession(user, context) {
+        const sessionId = this.getSessionId(context) || this.generateSessionId();
+        const data = this.config.createSessionData
+            ? this.config.createSessionData(user, context)
+            : { user };
+        await this.store.setSession(sessionId, data);
+        this.config.embedSessionId?.(context, sessionId);
+        this.logger?.info(`Stored user session with ID: ${sessionId}`);
+        return { sessionId, data };
+    }
+    async logoutSession(context) {
+        const sessionId = this.getSessionId?.(context);
+        if (!sessionId) {
+            throw new session_errors_1.MissingSessionIdError();
+        }
+        await this.destroy(sessionId);
+        this.logger?.info(`Session destroyed: ${sessionId}`);
+    }
+    async clearAllSessions() {
+        try {
+            if (typeof this.store.destroySession === "function") {
+                const sessionIds = await this.store.getSessionIds();
+                for (const sessionId of sessionIds) {
+                    await this.store.destroySession(sessionId);
+                }
+                this.config.logger?.info("All sessions have been cleared.");
+            }
+        }
+        catch (error) {
+            this.config.logger?.error("Error clearing all sessions:", error);
+        }
+    }
 }
 exports.SessionHandler = SessionHandler;

package/build/session/session.errors.d.ts

@@ -0,0 +1,6 @@
+export declare class InvalidSessionError extends Error {
+    constructor();
+}
+export declare class MissingSessionIdError extends Error {
+    constructor();
+}

package/build/session/session.errors.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MissingSessionIdError = exports.InvalidSessionError = void 0;
+class InvalidSessionError extends Error {
+    constructor() {
+        super("Session is invalid or expired.");
+    }
+}
+exports.InvalidSessionError = InvalidSessionError;
+class MissingSessionIdError extends Error {
+    constructor() {
+        super("Session ID is missing.");
+    }
+}
+exports.MissingSessionIdError = MissingSessionIdError;