@vunexa/lixa 0.1.2 → 0.1.4

package/README.template.md

@@ -342,6 +342,277 @@ export interface Session<TRaw = OAuthTokenResponse> {
 
 ---
 
+## Custom Session Storage Implementations
+
+Lixa allows you to store sessions in any database or cache by implementing the `SessionStorage` interface.
+
+### 1. SQLite Session Storage (`better-sqlite3`)
+
+For relational persistence or single-node deployments using SQLite:
+
+#### Table Schema (SQL DDL)
+
+```sql
+CREATE TABLE IF NOT EXISTS sessions (
+  id TEXT PRIMARY KEY,
+  user_email TEXT,
+  data TEXT NOT NULL,
+  expires_at INTEGER NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_sessions_email ON sessions(user_email);
+CREATE INDEX IF NOT EXISTS idx_sessions_expires ON sessions(expires_at);
+```
+
+#### TypeScript Implementation
+
+```typescript
+import Database from "better-sqlite3";
+import { Lixa, type SessionStorage, type Session } from "@vunexa/lixa";
+
+export class SqliteSessionStorage implements SessionStorage {
+  private db = new Database("lixa_sessions.db");
+
+  constructor() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS sessions (
+        id TEXT PRIMARY KEY,
+        user_email TEXT,
+        data TEXT NOT NULL,
+        expires_at INTEGER NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_sessions_email ON sessions(user_email);
+    `);
+  }
+
+  async saveSession<T extends Session>(sessionId: string, session: T, expiresInSeconds: number): Promise<void> {
+    const expiresAt = Math.floor(Date.now() / 1000) + expiresInSeconds;
+    const stmt = this.db.prepare(`
+      INSERT INTO sessions (id, user_email, data, expires_at)
+      VALUES (?, ?, ?, ?)
+      ON CONFLICT(id) DO UPDATE SET
+        user_email = excluded.user_email,
+        data = excluded.data,
+        expires_at = excluded.expires_at
+    `);
+    stmt.run(sessionId, session.email || null, JSON.stringify(session), expiresAt);
+  }
+
+  async getSession<T extends Session>(sessionId: string): Promise<T | null> {
+    const now = Math.floor(Date.now() / 1000);
+    const stmt = this.db.prepare(`SELECT data FROM sessions WHERE id = ? AND expires_at > ?`);
+    const row = stmt.get(sessionId, now) as { data: string } | undefined;
+    return row ? (JSON.parse(row.data) as T) : null;
+  }
+
+  async deleteSession(sessionId: string): Promise<void> {
+    const stmt = this.db.prepare(`DELETE FROM sessions WHERE id = ?`);
+    stmt.run(sessionId);
+  }
+
+  async getSessionByEmail<T extends Session>(email: string): Promise<{ sessionId: string; session: T } | null> {
+    const now = Math.floor(Date.now() / 1000);
+    const stmt = this.db.prepare(`SELECT id, data FROM sessions WHERE user_email = ? AND expires_at > ? LIMIT 1`);
+    const row = stmt.get(email, now) as { id: string; data: string } | undefined;
+    return row ? { sessionId: row.id, session: JSON.parse(row.data) as T } : null;
+  }
+}
+
+// Pass to Lixa instance
+export const lixa = new Lixa({
+  sessionHandler: {
+    sessionStorage: new SqliteSessionStorage(),
+  },
+  providers: { /* ... */ },
+});
+```
+
+#### Saved JSON Record Example in SQLite (`data` Column)
+
+```json
+{
+  "id": "e4a91f82c3b4a07f",
+  "token": "ya29.a0ARW5m7...",
+  "userId": "1049281048",
+  "email": "alex.developer@example.com",
+  "provider": "google",
+  "accounts": {
+    "google": {
+      "provider": "google",
+      "email": "alex.developer@example.com",
+      "providerUserId": "1049281048",
+      "accessToken": "ya29.a0ARW5m7...",
+      "linkedAt": 1771657200000
+    },
+    "github": {
+      "provider": "github",
+      "email": "alex.developer@example.com",
+      "providerUserId": "5829104",
+      "accessToken": "gho_8f7b2a9e1c3...",
+      "linkedAt": 1771657250000
+    }
+  },
+  "resources": {
+    "github": {
+      "provider": "github",
+      "accessToken": "gho_resource_repo_9a8b7c...",
+      "scopes": ["repo", "read:org"],
+      "connectedAt": 1771657300000
+    }
+  },
+  "raw": {
+    "access_token": "ya29.a0ARW5m7...",
+    "token_type": "Bearer",
+    "expires_in": 3599
+  }
+}
+```
+
+---
+
+### 2. AWS DynamoDB Session Storage (`@aws-sdk/lib-dynamodb`)
+
+For serverless and distributed AWS deployments using DynamoDB:
+
+#### Table Configuration
+
+- **Table Name**: `LixaSessions`
+- **Partition Key**: `sessionId` (String)
+- **Global Secondary Index (GSI)**: `EmailIndex` (`email` as Partition Key)
+- **TTL Attribute**: `ttl` (Unix timestamp in seconds for automatic AWS expiration)
+
+#### TypeScript Implementation
+
+```typescript
+import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
+import { DynamoDBDocumentClient, PutCommand, GetCommand, DeleteCommand, QueryCommand } from "@aws-sdk/lib-dynamodb";
+import { Lixa, type SessionStorage, type Session } from "@vunexa/lixa";
+
+export class DynamoDbSessionStorage implements SessionStorage {
+  private docClient: DynamoDBDocumentClient;
+  private tableName = "LixaSessions";
+
+  constructor() {
+    const client = new DynamoDBClient({ region: process.env.AWS_REGION || "us-east-1" });
+    this.docClient = DynamoDBDocumentClient.from(client);
+  }
+
+  async saveSession<T extends Session>(sessionId: string, session: T, expiresInSeconds: number): Promise<void> {
+    const ttl = Math.floor(Date.now() / 1000) + expiresInSeconds;
+    await this.docClient.send(
+      new PutCommand({
+        TableName: this.tableName,
+        Item: {
+          sessionId,
+          email: session.email || "N/A",
+          sessionData: session,
+          ttl,
+        },
+      })
+    );
+  }
+
+  async getSession<T extends Session>(sessionId: string): Promise<T | null> {
+    const res = await this.docClient.send(
+      new GetCommand({
+        TableName: this.tableName,
+        Key: { sessionId },
+      })
+    );
+
+    if (!res.Item) return null;
+    const now = Math.floor(Date.now() / 1000);
+    if (res.Item.ttl && res.Item.ttl < now) return null;
+
+    return res.Item.sessionData as T;
+  }
+
+  async deleteSession(sessionId: string): Promise<void> {
+    await this.docClient.send(
+      new DeleteCommand({
+        TableName: this.tableName,
+        Key: { sessionId },
+      })
+    );
+  }
+
+  async getSessionByEmail<T extends Session>(email: string): Promise<{ sessionId: string; session: T } | null> {
+    const res = await this.docClient.send(
+      new QueryCommand({
+        TableName: this.tableName,
+        IndexName: "EmailIndex",
+        KeyConditionExpression: "email = :email",
+        ExpressionAttributeValues: { ":email": email },
+        Limit: 1,
+      })
+    );
+
+    if (!res.Items || res.Items.length === 0) return null;
+    const item = res.Items[0];
+    const now = Math.floor(Date.now() / 1000);
+    if (item.ttl && item.ttl < now) return null;
+
+    return { sessionId: item.sessionId, session: item.sessionData as T };
+  }
+}
+
+// Pass to Lixa instance
+export const lixa = new Lixa({
+  sessionHandler: {
+    sessionStorage: new DynamoDbSessionStorage(),
+  },
+  providers: { /* ... */ },
+});
+```
+
+#### Saved DynamoDB Item JSON Example
+
+```json
+{
+  "sessionId": "e4a91f82c3b4a07f",
+  "email": "alex.developer@example.com",
+  "ttl": 1771743600,
+  "sessionData": {
+    "id": "e4a91f82c3b4a07f",
+    "token": "ya29.a0ARW5m7...",
+    "userId": "1049281048",
+    "email": "alex.developer@example.com",
+    "provider": "google",
+    "accounts": {
+      "google": {
+        "provider": "google",
+        "email": "alex.developer@example.com",
+        "providerUserId": "1049281048",
+        "accessToken": "ya29.a0ARW5m7...",
+        "linkedAt": 1771657200000
+      },
+      "github": {
+        "provider": "github",
+        "email": "alex.developer@example.com",
+        "providerUserId": "5829104",
+        "accessToken": "gho_8f7b2a9e1c3...",
+        "linkedAt": 1771657250000
+      }
+    },
+    "resources": {
+      "github": {
+        "provider": "github",
+        "accessToken": "gho_resource_repo_9a8b7c...",
+        "scopes": ["repo", "read:org"],
+        "connectedAt": 1771657300000
+      }
+    },
+    "raw": {
+      "access_token": "ya29.a0ARW5m7...",
+      "token_type": "Bearer",
+      "expires_in": 3599
+    }
+  }
+}
+```
+
+---
+
 ## User Info Utilities
 
 Lixa provides utilities to extract user information from OAuth tokens:

package/dist/export-types/index.d.ts

@@ -740,6 +740,8 @@ export declare class Lixa<TConfig extends LixaConfig<Record<string, ProviderConf
         provider: ConfiguredProviderKey<TConfig> | string;
         scopes: string[];
         state?: string;
+        prompt?: string;
+        extraConfig?: Record<string, string>;
     }): Promise<string>;
     /**
      * Handles the OAuth callback for a connected resource provider and stores resource tokens on the session.

package/dist/index.cjs

@@ -869,7 +869,7 @@ var Lixa = class _Lixa {
    * @returns The authorization URL for resource consent
    */
   async getResourceAuthUrl(params) {
-    const { sessionId, provider, scopes, state } = params;
+    const { sessionId, provider, scopes, state, prompt, extraConfig } = params;
     const sessionStorage = this.sessionHandler.sessionStorage || _Lixa.LOCAL_SESSION_HANDLER.sessionStorage;
     const activeSession = await sessionStorage.getSession(sessionId);
     if (!activeSession) {
@@ -902,7 +902,9 @@ var Lixa = class _Lixa {
       response_type: "code",
       code_challenge: codeChallenge,
       code_challenge_method: "S256",
-      ...providerConfig.extraConfig
+      ...prompt ? { prompt } : {},
+      ...providerConfig.extraConfig,
+      ...extraConfig
     });
     return `${providerImpl.authorizationEndpoint}?${searchParams.toString()}`;
   }
@@ -934,7 +936,7 @@ var Lixa = class _Lixa {
         await stateStorage.deleteState(state);
       }
     }
-    const tokens = await this.exchangeCodeForToken(providerType, providerConfig, providerImpl, codeVerifier);
+    const tokens = await this.exchangeCodeForToken(code, providerConfig, providerImpl, codeVerifier);
     activeSession.resources = activeSession.resources || {};
     activeSession.resources[providerType] = {
       provider: providerType,