@soapjs/soap-auth 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Radosław Kamysz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,223 @@
+# SoapAuth
+
+**SoapAuth** is a flexible authentication and authorization module designed to provide support for various authentication strategies. It is intended to be used alongside a specific framework adapter, serving as the core authentication engine.
+
+---
+
+## Installation
+
+```sh
+npm install @soapjs/soap-auth
+```
+
+---
+
+## Features
+
+- Multiple authentication strategies (local, OAuth2, JWT, API key, basic auth)
+- Custom authentication strategy support
+- Built-in session management with pluggable session stores
+- Token handling for JWT authentication
+- Extensible architecture with abstract base classes
+- Compatible with framework adapters for seamless integration
+
+---
+
+## Core Classes Overview
+
+### 1. `SoapAuth`
+This is the main entry point for managing authentication. It initializes different strategies based on the provided configuration and provides methods for authentication, authorization, and session management.
+
+### 2. `AuthStrategy`
+The base interface that all strategies must implement. Provides methods such as `authenticate`, `authorize`, `init`, and `logout`.
+
+### 3. `SessionHandler`
+Handles session operations like retrieving, storing, and generating session IDs. It supports multiple session storage mechanisms such as in-memory and file-based stores.
+
+### 4. `TokenBasedAuthStrategy`
+Abstract class for token-based authentication strategies, providing methods for handling access and refresh tokens.
+
+### 5. `CredentialBasedAuthStrategy`
+Abstract class for username-password-based authentication strategies.
+
+### 6. `HttpAuthStrategyFactory` & `SocketAuthStrategyFactory`
+Factories responsible for creating instances of HTTP and socket-based authentication strategies respectively.
+
+---
+
+## Available Authentication Strategies
+
+### 1. Local Strategy
+
+**When to use:**
+- Ideal for applications that require username and password authentication stored locally.
+
+**Configuration example:**
+```typescript
+const authConfig = {
+  http: {
+    local: {
+      usernameField: "email",
+      passwordField: "password",
+      validateUser: async (username, password) => {
+        return username === "user@example.com" && password === "securepass" ? { id: 1, name: "John Doe" } : null;
+      },
+    },
+  },
+};
+```
+
+### 2. OAuth2 Strategy
+
+**When to use:**
+- Suitable for social logins (Google, Facebook, Twitter, etc.).
+
+**Configuration example:**
+```typescript
+const authConfig = {
+  http: {
+    oauth2: {
+      google: {
+        clientId: "your-client-id",
+        clientSecret: "your-client-secret",
+        redirectUri: "https://yourapp.com/auth/callback",
+        scope: "openid profile email",
+        endpoints: {
+          authorizationUrl: "https://accounts.google.com/o/oauth2/auth",
+          tokenUrl: "https://oauth2.googleapis.com/token",
+        },
+      },
+    },
+  },
+};
+```
+
+### 3. JWT Strategy
+
+**When to use:**
+- Suitable for stateless authentication where tokens are passed between the client and server.
+
+**Configuration example:**
+```typescript
+const authConfig = {
+  http: {
+    jwt: {
+      access: {
+        secretKey: "your-secret-key",
+        expiresIn: "1h",
+        signOptions: { algorithm: "HS256" },
+      },
+    },
+  },
+};
+```
+
+### 4. API Key Strategy
+
+**When to use:**
+- Best for authenticating external services using static API keys.
+
+**Configuration example:**
+```typescript
+const authConfig = {
+  http: {
+    apiKey: {
+      extractApiKey: (context) => context.headers["x-api-key"],
+      retrieveUserByApiKey: async (apiKey) => {
+        return apiKey === "valid-api-key" ? { id: 1, role: "admin" } : null;
+      },
+    },
+  },
+};
+```
+
+### 5. Basic Authentication
+
+**When to use:**
+- Useful for simple username-password authentication with minimal overhead.
+
+**Configuration example:**
+```typescript
+const authConfig = {
+  http: {
+    basic: {
+      validateUser: async (username, password) => {
+        return username === "admin" && password === "password" ? { id: 1, role: "admin" } : null;
+      },
+    },
+  },
+};
+```
+
+---
+
+## Using SoapAuth
+
+```typescript
+import { SoapAuth } from "@soapjs/soap-auth";
+
+const auth = new SoapAuth(authConfig);
+await auth.init();
+
+const user = await auth.authenticate("local", { email: "user@example.com", password: "securepass" });
+console.log("Authenticated user:", user);
+```
+
+---
+
+## Creating a Custom Authentication Strategy
+
+To create a custom strategy, extend the appropriate base class depending on the authentication type:
+
+1. **For token-based strategies:** Extend `TokenBasedAuthStrategy`.
+2. **For credential-based strategies:** Extend `CredentialBasedAuthStrategy`.
+3. **For generic implementations:** Extend `BaseAuthStrategy` directly.
+
+**Example:**
+```typescript
+class CustomAuthStrategy extends TokenBasedAuthStrategy {
+  async authenticate(context) {
+    const token = context.headers.authorization;
+    if (token === "valid-token") {
+      return { user: { id: 1, role: "admin" }, tokens: { accessToken: token } };
+    }
+    throw new Error("Invalid token");
+  }
+}
+```
+
+---
+
+## Session Management
+
+SoapAuth supports session management through the `SessionHandler` class. The session can be stored using memory, files, or external databases via adapters.
+
+**Example Session Configuration:**
+```typescript
+const authConfig = {
+  session: {
+    secret: "your-session-secret",
+    sessionKey: "my-session-id",
+    store: new MemorySessionStore(),
+  },
+};
+```
+
+---
+
+## Framework Integration
+
+SoapAuth is designed to work with various frameworks such as Express, Koa, Fastify, and more through dedicated adapters.
+
+```typescript
+// basic example
+app.use(async (req, res, next) => {
+  try {
+    const user = await auth.authenticate("jwt", req);
+    req.user = user;
+    next();
+  } catch (error) {
+    res.status(401).send("Unauthorized");
+  }
+});
+```

package/build/errors.d.ts

@@ -0,0 +1,53 @@
+export declare class UnauthorizedRoleError extends Error {
+    constructor();
+}
+export declare class MissingAuthorizationCodeError extends Error {
+    constructor();
+}
+export declare class RateLimitExceededError extends Error {
+    constructor();
+}
+export declare class AccountLockedError extends Error {
+    constructor();
+}
+export declare class MissingCredentialsError extends Error {
+    constructor();
+}
+export declare class UserNotFoundError extends Error {
+    constructor();
+}
+export declare class InvalidCredentialsError extends Error {
+    constructor();
+}
+export declare class MissingTokenError extends Error {
+    readonly tokenType: "Access" | "Refresh";
+    constructor(tokenType?: "Access" | "Refresh");
+}
+export declare class EmptyPayloadError extends Error {
+    constructor();
+}
+export declare class UndefinedTokenError extends Error {
+    readonly tokenType: "Access" | "Refresh";
+    constructor(tokenType?: "Access" | "Refresh");
+}
+export declare class InvalidTokenError extends Error {
+    readonly tokenType: "Access" | "Refresh";
+    constructor(tokenType?: "Access" | "Refresh");
+}
+export declare class UndefinedTokenSecretError extends Error {
+    readonly tokenType: "Access" | "Refresh";
+    constructor(tokenType?: "Access" | "Refresh");
+}
+export declare class UndefinedTokenHandlerError extends Error {
+    readonly tokenType: "Access" | "Refresh";
+    readonly handler: string;
+    constructor(tokenType: "Access" | "Refresh", handler: string);
+}
+export declare class ExpiredTokenError extends Error {
+    readonly tokenType: "Access" | "Refresh";
+    constructor(tokenType?: "Access" | "Refresh");
+}
+export declare class AuthError extends Error {
+    readonly error: Error;
+    constructor(error: Error, message: string);
+}

package/build/errors.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthError = exports.ExpiredTokenError = exports.UndefinedTokenHandlerError = exports.UndefinedTokenSecretError = exports.InvalidTokenError = exports.UndefinedTokenError = exports.EmptyPayloadError = exports.MissingTokenError = exports.InvalidCredentialsError = exports.UserNotFoundError = exports.MissingCredentialsError = exports.AccountLockedError = exports.RateLimitExceededError = exports.MissingAuthorizationCodeError = exports.UnauthorizedRoleError = void 0;
+class UnauthorizedRoleError extends Error {
+    constructor() {
+        super("User does not have the required role.");
+        this.name = "UnauthorizedRoleError";
+    }
+}
+exports.UnauthorizedRoleError = UnauthorizedRoleError;
+class MissingAuthorizationCodeError extends Error {
+    constructor() {
+        super("Authorization code is required.");
+        this.name = "MissingAuthorizationCodeError";
+    }
+}
+exports.MissingAuthorizationCodeError = MissingAuthorizationCodeError;
+class RateLimitExceededError extends Error {
+    constructor() {
+        super("Rate limit exceeded for the provided credentials.");
+        this.name = "RateLimitExceededError";
+    }
+}
+exports.RateLimitExceededError = RateLimitExceededError;
+class AccountLockedError extends Error {
+    constructor() {
+        super("Account is locked due to too many failed attempts.");
+        this.name = "AccountLockedError";
+    }
+}
+exports.AccountLockedError = AccountLockedError;
+class MissingCredentialsError extends Error {
+    constructor() {
+        super("Missing credentials: Username and password are required.");
+        this.name = "MissingCredentialsError";
+    }
+}
+exports.MissingCredentialsError = MissingCredentialsError;
+class UserNotFoundError extends Error {
+    constructor() {
+        super("User not found.");
+        this.name = "UserNotFound";
+    }
+}
+exports.UserNotFoundError = UserNotFoundError;
+class InvalidCredentialsError extends Error {
+    constructor() {
+        super("Invalid credentials: Authentication failed.");
+        this.name = "InvalidCredentialsError";
+    }
+}
+exports.InvalidCredentialsError = InvalidCredentialsError;
+class MissingTokenError extends Error {
+    tokenType;
+    constructor(tokenType = "Access") {
+        super(`${tokenType} token is empty or not defined`);
+        this.tokenType = tokenType;
+    }
+}
+exports.MissingTokenError = MissingTokenError;
+class EmptyPayloadError extends Error {
+    constructor() {
+        super(`Payload is empty or not defined`);
+    }
+}
+exports.EmptyPayloadError = EmptyPayloadError;
+class UndefinedTokenError extends Error {
+    tokenType;
+    constructor(tokenType = "Access") {
+        super(`${tokenType} token not defined`);
+        this.tokenType = tokenType;
+    }
+}
+exports.UndefinedTokenError = UndefinedTokenError;
+class InvalidTokenError extends Error {
+    tokenType;
+    constructor(tokenType = "Access") {
+        super(`Invalid ${tokenType} token`);
+        this.tokenType = tokenType;
+    }
+}
+exports.InvalidTokenError = InvalidTokenError;
+class UndefinedTokenSecretError extends Error {
+    tokenType;
+    constructor(tokenType = "Access") {
+        super(`${tokenType} token secret not defined`);
+        this.tokenType = tokenType;
+    }
+}
+exports.UndefinedTokenSecretError = UndefinedTokenSecretError;
+class UndefinedTokenHandlerError extends Error {
+    tokenType;
+    handler;
+    constructor(tokenType = "Access", handler) {
+        super(`${tokenType} token "${handler}" not defined`);
+        this.tokenType = tokenType;
+        this.handler = handler;
+    }
+}
+exports.UndefinedTokenHandlerError = UndefinedTokenHandlerError;
+class ExpiredTokenError extends Error {
+    tokenType;
+    constructor(tokenType = "Access") {
+        super(`${tokenType} token expired`);
+        this.tokenType = tokenType;
+    }
+}
+exports.ExpiredTokenError = ExpiredTokenError;
+class AuthError extends Error {
+    error;
+    constructor(error, message) {
+        super(message || error.message);
+        this.error = error;
+        this.name = "AuthError";
+    }
+}
+exports.AuthError = AuthError;

package/build/factories/auth-strategy.factory.d.ts

@@ -0,0 +1,9 @@
+import * as Soap from "@soapjs/soap";
+import { AuthStrategy, SessionConfig, SoapAuthConfig } from "../types";
+import { SessionHandler } from "../session/session-handler";
+export declare abstract class AuthStrategyFactory {
+    protected logger?: Soap.Logger;
+    abstract createStrategies(config: SoapAuthConfig): Map<string, AuthStrategy>;
+    constructor(logger?: Soap.Logger);
+    protected getSessionHandler(strategyConfig: SessionConfig, globalConfig: SessionConfig): SessionHandler<unknown, any>;
+}

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthStrategyFactory = void 0;
+const tools_1 = require("../tools/tools");
+const session_handler_1 = require("../session/session-handler");
+class AuthStrategyFactory {
+    logger;
+    constructor(logger) {
+        this.logger = logger;
+    }
+    getSessionHandler(strategyConfig, globalConfig) {
+        const sessionConfig = (0, tools_1.resolveConfig)(strategyConfig, globalConfig);
+        return sessionConfig ? new session_handler_1.SessionHandler(sessionConfig) : undefined;
+    }
+}
+exports.AuthStrategyFactory = AuthStrategyFactory;

package/build/factories/http-auth-strategy.factory.d.ts

@@ -0,0 +1,5 @@
+import { AuthStrategy, SoapAuthConfig } from "../types";
+import { AuthStrategyFactory } from "./auth-strategy.factory";
+export declare class HttpAuthStrategyFactory extends AuthStrategyFactory {
+    createStrategies(config: SoapAuthConfig): Map<string, AuthStrategy>;
+}

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

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpAuthStrategyFactory = void 0;
+const oauth2_strategy_1 = require("../strategies/oauth2/oauth2.strategy");
+const api_key_strategy_1 = require("../strategies/api-key/api-key.strategy");
+const jwt_strategy_1 = require("../strategies/jwt/jwt.strategy");
+const basic_strategy_1 = require("../strategies/basic/basic.strategy");
+const auth_strategy_factory_1 = require("./auth-strategy.factory");
+const tools_1 = require("../tools/tools");
+const local_strategy_1 = require("../strategies/local/local.strategy");
+class HttpAuthStrategyFactory extends auth_strategy_factory_1.AuthStrategyFactory {
+    createStrategies(config) {
+        const strategies = new Map();
+        if (!config.http) {
+            return strategies;
+        }
+        if (config.http.oauth2) {
+            for (const provider in config.http.oauth2) {
+                strategies.set(provider, new oauth2_strategy_1.OAuth2Strategy(config.http.oauth2[provider], (0, tools_1.resolveConfig)(config.http.oauth2[provider].tokens.access, config.tokens.access), (0, tools_1.resolveConfig)(config.http.oauth2[provider].tokens.refresh, config.tokens.refresh), this.getSessionHandler(config.http.oauth2[provider].session, config.session), config.logger));
+            }
+        }
+        if (config.http.apiKey) {
+            strategies.set("apiKey", new api_key_strategy_1.ApiKeyStrategy(config.http.apiKey, this.logger));
+        }
+        if (config.http.basic) {
+            strategies.set("basic", new basic_strategy_1.BasicStrategy(config.http.basic, this.getSessionHandler(config.http.basic.session, config.session), config.logger));
+        }
+        if (config.http.local) {
+            strategies.set("local", new local_strategy_1.LocalStrategy(config.http.local, this.getSessionHandler(config.http.local.session, config.session), config.logger));
+        }
+        if (config.http.jwt) {
+            strategies.set("jwt", new jwt_strategy_1.JwtStrategy(config.http.jwt, this.getSessionHandler(config.http.jwt.session, config.session), this.logger));
+        }
+        if (config.http.custom) {
+            Object.entries(config.http.custom).forEach(([key, strategy]) => {
+                strategies.set(key, strategy);
+            });
+        }
+        return strategies;
+    }
+}
+exports.HttpAuthStrategyFactory = HttpAuthStrategyFactory;

package/build/factories/socket-auth-strategy.factory.d.ts

@@ -0,0 +1,5 @@
+import { AuthStrategy, SoapAuthConfig } from "../types";
+import { AuthStrategyFactory } from "./auth-strategy.factory";
+export declare class SocketAuthStrategyFactory extends AuthStrategyFactory {
+    createStrategies(config: SoapAuthConfig): Map<string, AuthStrategy>;
+}

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SocketAuthStrategyFactory = void 0;
+const api_key_strategy_1 = require("../strategies/api-key/api-key.strategy");
+const jwt_strategy_1 = require("../strategies/jwt/jwt.strategy");
+const auth_strategy_factory_1 = require("./auth-strategy.factory");
+class SocketAuthStrategyFactory extends auth_strategy_factory_1.AuthStrategyFactory {
+    createStrategies(config) {
+        const strategies = new Map();
+        if (!config.socket) {
+            return strategies;
+        }
+        if (config.socket.apiKey) {
+            strategies.set("apiKey", new api_key_strategy_1.ApiKeyStrategy(config.socket.apiKey, this.logger));
+        }
+        if (config.socket.jwt) {
+            strategies.set("jwt", new jwt_strategy_1.JwtStrategy(config.socket.jwt, this.getSessionHandler(config.socket.jwt.session, config.session), this.logger));
+        }
+        if (config.socket.custom) {
+            Object.entries(config.socket.custom).forEach(([key, strategy]) => {
+                strategies.set(key, strategy);
+            });
+        }
+        return strategies;
+    }
+}
+exports.SocketAuthStrategyFactory = SocketAuthStrategyFactory;

package/build/index.d.ts

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

package/build/index.js

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

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

@@ -0,0 +1,10 @@
+import { SessionData, SessionStore } from "../types";
+export declare class FileSessionStore implements SessionStore {
+    private sessionsDir;
+    constructor(sessionsDir: string);
+    init(): Promise<void>;
+    getSession<SessionData>(sid: string): Promise<SessionData | null>;
+    setSession<SessionData>(sessionId: string, sessionData: SessionData): Promise<void>;
+    destroySession(sessionId: string): Promise<void>;
+    touchSession(sessionId: string, session: SessionData): Promise<void>;
+}

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

@@ -0,0 +1,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileSessionStore = void 0;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+class FileSessionStore {
+    sessionsDir;
+    constructor(sessionsDir) {
+        this.sessionsDir = sessionsDir;
+    }
+    async init() {
+        try {
+            await promises_1.default.mkdir(this.sessionsDir, { recursive: true });
+        }
+        catch (error) {
+            console.error("Error initializing session directory:", error);
+        }
+    }
+    async getSession(sid) {
+        const sessionPath = path_1.default.join(this.sessionsDir, sid);
+        try {
+            const data = await promises_1.default.readFile(sessionPath, "utf8");
+            return JSON.parse(data);
+        }
+        catch (error) {
+            console.error("Error getting session:", error);
+            return null;
+        }
+    }
+    async setSession(sessionId, sessionData) {
+        const sessionPath = path_1.default.join(this.sessionsDir, sessionId);
+        try {
+            await promises_1.default.writeFile(sessionPath, JSON.stringify(sessionData), "utf8");
+        }
+        catch (error) {
+            console.error("Error writing session file:", error);
+            throw error;
+        }
+    }
+    async destroySession(sessionId) {
+        const sessionPath = path_1.default.join(this.sessionsDir, sessionId);
+        try {
+            await promises_1.default.unlink(sessionPath);
+        }
+        catch (error) {
+            if (error.code !== "ENOENT") {
+                console.error("Error destroying session:", error);
+                throw error;
+            }
+        }
+    }
+    async touchSession(sessionId, session) {
+        await this.setSession(sessionId, session);
+    }
+}
+exports.FileSessionStore = FileSessionStore;