@vunexa/lixa 0.1.6-alpha.2 → 0.1.6-alpha.4

package/dist/index.js

@@ -176,6 +176,7 @@ var Lixa = class _Lixa {
   config;
   stateHandler;
   sessionHandler;
+  resourceHandler;
   debug;
   /**
    * Creates a new Lixa instance with the provided configuration.
@@ -194,6 +195,7 @@ var Lixa = class _Lixa {
     this.config = config;
     this.stateHandler = config.stateHandler || _Lixa.LOCAL_STATE_HANDLER;
     this.sessionHandler = config.sessionHandler || _Lixa.LOCAL_SESSION_HANDLER;
+    this.resourceHandler = config.resourceHandler || _Lixa.LOCAL_RESOURCE_HANDLER;
     this.debug = config.debug || false;
     this.log("INFO", "Init", "Initializing Lixa instance", {
       providers: Object.keys(config.providers),
@@ -873,6 +875,45 @@ var Lixa = class _Lixa {
    * @param params - Object containing sessionId, provider, code, state, and requested scopes
    * @returns Updated Session containing stored resource tokens under session.resources[provider]
    */
+  static userResourceStore = /* @__PURE__ */ new Map();
+  static LOCAL_RESOURCE_HANDLER = {
+    resourceStorage: {
+      saveResource: async (userId, provider, resource) => {
+        let userMap = _Lixa.userResourceStore.get(userId);
+        if (!userMap) {
+          userMap = /* @__PURE__ */ new Map();
+          _Lixa.userResourceStore.set(userId, userMap);
+        }
+        userMap.set(provider.toLowerCase(), resource);
+      },
+      getResource: async (userId, provider) => {
+        const userMap = _Lixa.userResourceStore.get(userId);
+        return userMap?.get(provider.toLowerCase()) || null;
+      },
+      getUserResources: async (userId) => {
+        const userMap = _Lixa.userResourceStore.get(userId);
+        const result = {};
+        if (userMap) {
+          for (const [p, r] of userMap.entries()) {
+            result[p] = r;
+          }
+        }
+        return result;
+      },
+      deleteResource: async (userId, provider) => {
+        const userMap = _Lixa.userResourceStore.get(userId);
+        if (userMap) {
+          userMap.delete(provider.toLowerCase());
+        }
+      }
+    }
+  };
+  getUserKeyFromSession(session) {
+    return session.userId || session.email || session.id || "anonymous";
+  }
+  /**
+   * Handles the OAuth callback for a connected resource provider and stores resource tokens bound to user account.
+   */
   async handleResourceCallback(params) {
     const { sessionId, provider, code, state, scopes } = params;
     const sessionStorage = this.sessionHandler.sessionStorage || _Lixa.LOCAL_SESSION_HANDLER.sessionStorage;
@@ -896,44 +937,176 @@ var Lixa = class _Lixa {
       }
     }
     const tokens = await this.exchangeCodeForToken(code, providerConfig, providerImpl, codeVerifier);
-    activeSession.resources = activeSession.resources || {};
-    activeSession.resources[providerType] = {
+    const expiresAt = tokens.expires_in ? Date.now() + tokens.expires_in * 1e3 : void 0;
+    const connectedResource = {
       provider: providerType,
       accessToken: tokens.access_token,
       refreshToken: tokens.refresh_token,
+      expiresAt,
       scopes: scopes || (tokens.scope ? tokens.scope.split(" ") : []),
       raw: tokens,
       connectedAt: Date.now()
     };
+    const userKey = this.getUserKeyFromSession(activeSession);
+    const resourceStorage = this.resourceHandler.resourceStorage || _Lixa.LOCAL_RESOURCE_HANDLER.resourceStorage;
+    await resourceStorage.saveResource(userKey, providerType, connectedResource);
+    activeSession.resources = activeSession.resources || {};
+    activeSession.resources[providerType] = connectedResource;
     await sessionStorage.saveSession(sessionId, activeSession, 86400);
     return activeSession;
   }
   /**
-   * Retrieves a connected resource provider token for an active session.
+   * Retrieves a connected resource for a specific User ID / Email directly (independent of session IDs).
+   * Automatically refreshes expired access tokens if a refresh token is present.
+   * 
+   * @param userIdOrEmail - User identifier or email
+   * @param provider - Resource provider identifier (e.g. 'github', 'google')
+   */
+  async getUserResource(userIdOrEmail, provider) {
+    const resourceStorage = this.resourceHandler.resourceStorage || _Lixa.LOCAL_RESOURCE_HANDLER.resourceStorage;
+    const providerType = provider.toLowerCase();
+    const resource = await resourceStorage.getResource(userIdOrEmail, providerType);
+    if (!resource) return null;
+    if (resource.refreshToken && resource.expiresAt && Date.now() >= resource.expiresAt - 6e4) {
+      this.log("INFO", "Token", `Resource access token for user '${userIdOrEmail}' on '${providerType}' is expired. Auto-refreshing...`);
+      try {
+        return await this.refreshUserResourceToken(userIdOrEmail, providerType);
+      } catch (error) {
+        this.log("ERROR", "Token", `Failed to auto-refresh resource token for user '${userIdOrEmail}' on '${providerType}'`, { error: String(error) });
+      }
+    }
+    return resource;
+  }
+  /**
+   * Retrieves all connected resources for a specific User ID / Email.
+   */
+  async getUserResources(userIdOrEmail) {
+    const resourceStorage = this.resourceHandler.resourceStorage || _Lixa.LOCAL_RESOURCE_HANDLER.resourceStorage;
+    return await resourceStorage.getUserResources(userIdOrEmail);
+  }
+  /**
+   * Retrieves a connected resource provider token for an active session, auto-refreshing expired tokens if possible.
    * 
    * @param sessionId - Active session ID
-   * @param provider - Provider identifier (e.g. 'github')
+   * @param provider - Provider identifier (e.g. 'github', 'google')
    */
   async getConnectedResource(sessionId, provider) {
     const sessionStorage = this.sessionHandler.sessionStorage || _Lixa.LOCAL_SESSION_HANDLER.sessionStorage;
     const activeSession = await sessionStorage.getSession(sessionId);
-    if (!activeSession || !activeSession.resources) return null;
-    return activeSession.resources[provider.toLowerCase()] || null;
+    if (!activeSession) return null;
+    const providerType = provider.toLowerCase();
+    const userKey = this.getUserKeyFromSession(activeSession);
+    let resource = await this.getUserResource(userKey, providerType);
+    if (!resource && activeSession.resources) {
+      resource = activeSession.resources[providerType] || null;
+    }
+    if (resource) {
+      if (resource.refreshToken && resource.expiresAt && Date.now() >= resource.expiresAt - 6e4) {
+        this.log("INFO", "Token", `Resource access token for user '${userKey}' on '${providerType}' is expired. Auto-refreshing...`);
+        try {
+          resource = await this.refreshResourceToken(sessionId, providerType);
+        } catch (error) {
+          this.log("ERROR", "Token", `Failed to auto-refresh resource token for user '${userKey}' on '${providerType}'`, { error: String(error) });
+        }
+      }
+      activeSession.resources = activeSession.resources || {};
+      activeSession.resources[providerType] = resource;
+    }
+    return resource;
   }
   /**
-   * Disconnects a resource provider from an active session.
+   * Refreshes a user's resource access token using its refresh token.
    * 
-   * @param sessionId - Active session ID
-   * @param provider - Provider identifier to disconnect
+   * @param userIdOrEmail - User identifier or email
+   * @param provider - Provider identifier (e.g. 'google', 'github')
    */
-  async disconnectResource(sessionId, provider) {
+  async refreshUserResourceToken(userIdOrEmail, provider, existingResource) {
+    const resourceStorage = this.resourceHandler.resourceStorage || _Lixa.LOCAL_RESOURCE_HANDLER.resourceStorage;
+    const providerType = provider.toLowerCase();
+    let resource = existingResource || await resourceStorage.getResource(userIdOrEmail, providerType);
+    if (!resource || !resource.refreshToken) {
+      throw new Error(`No refresh token available for user '${userIdOrEmail}' on connected resource '${provider}'`);
+    }
+    const providerConfig = this.findProviderByType(providerType);
+    if (!providerConfig) {
+      throw new Error(`Provider '${provider}' is not configured`);
+    }
+    const providerImpl = this.getProvider(providerType, providerConfig);
+    const body = {
+      client_id: providerConfig.clientId,
+      client_secret: providerConfig.clientSecret,
+      grant_type: "refresh_token",
+      refresh_token: resource.refreshToken
+    };
+    const response = await fetch(providerImpl.tokenEndpoint, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+        Accept: "application/json"
+      },
+      body: new URLSearchParams(body).toString()
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`Failed to refresh resource token for user '${userIdOrEmail}' on '${provider}': ${response.status} - ${errorText}`);
+    }
+    const tokens = await response.json();
+    const expiresAt = tokens.expires_in ? Date.now() + tokens.expires_in * 1e3 : void 0;
+    resource.accessToken = tokens.access_token;
+    if (tokens.refresh_token) {
+      resource.refreshToken = tokens.refresh_token;
+    }
+    if (expiresAt) {
+      resource.expiresAt = expiresAt;
+    }
+    resource.raw = tokens;
+    resource.connectedAt = Date.now();
+    await resourceStorage.saveResource(userIdOrEmail, providerType, resource);
+    return resource;
+  }
+  /**
+   * Refreshes a connected resource access token for an active session.
+   */
+  async refreshResourceToken(sessionId, provider) {
     const sessionStorage = this.sessionHandler.sessionStorage || _Lixa.LOCAL_SESSION_HANDLER.sessionStorage;
     const activeSession = await sessionStorage.getSession(sessionId);
-    if (!activeSession || !activeSession.resources) return false;
-    delete activeSession.resources[provider.toLowerCase()];
+    if (!activeSession) {
+      throw new Error("Active session not found.");
+    }
+    const providerType = provider.toLowerCase();
+    const userKey = this.getUserKeyFromSession(activeSession);
+    const existingResource = activeSession.resources ? activeSession.resources[providerType] : void 0;
+    const refreshed = await this.refreshUserResourceToken(userKey, providerType, existingResource);
+    activeSession.resources = activeSession.resources || {};
+    activeSession.resources[providerType] = refreshed;
     await sessionStorage.saveSession(sessionId, activeSession, 86400);
+    return refreshed;
+  }
+  /**
+   * Disconnects a resource provider for a specific User ID / Email.
+   */
+  async disconnectUserResource(userIdOrEmail, provider) {
+    const resourceStorage = this.resourceHandler.resourceStorage || _Lixa.LOCAL_RESOURCE_HANDLER.resourceStorage;
+    await resourceStorage.deleteResource(userIdOrEmail, provider.toLowerCase());
     return true;
   }
+  /**
+   * Disconnects a resource provider from an active session and user account.
+   */
+  async disconnectResource(sessionId, provider) {
+    const sessionStorage = this.sessionHandler.sessionStorage || _Lixa.LOCAL_SESSION_HANDLER.sessionStorage;
+    const activeSession = await sessionStorage.getSession(sessionId);
+    if (activeSession) {
+      const userKey = this.getUserKeyFromSession(activeSession);
+      await this.disconnectUserResource(userKey, provider);
+      if (activeSession.resources) {
+        delete activeSession.resources[provider.toLowerCase()];
+        await sessionStorage.saveSession(sessionId, activeSession, 86400);
+      }
+      return true;
+    }
+    return false;
+  }
   async fetchSessionInfo(sessionId) {
     const sessionStorage = this.sessionHandler.sessionStorage || _Lixa.LOCAL_SESSION_HANDLER.sessionStorage;
     return await sessionStorage.getSession(sessionId);