@allanfsouza/aether-sdk 2.4.4 → 2.4.6

package/dist/auth.d.ts

@@ -25,7 +25,6 @@ export interface Session {
 export declare class AuthModule {
     private client;
     private http;
-    private refreshToken;
     private currentUser;
     constructor(client: PlataformaClient, http: AxiosInstance);
     login(email: string, password: string): Promise<LoginResponse>;
@@ -43,7 +42,13 @@ export declare class AuthModule {
     getSessions(): Promise<Session[]>;
     forgotPassword(email: string): Promise<any>;
     resetPassword(token: string, newPassword: string): Promise<any>;
+    /**
+     * @deprecated Use client.getRefreshToken() - mantido para compatibilidade
+     */
     getRefreshToken(): string | null;
+    /**
+     * @deprecated Use client.setRefreshToken() - mantido para compatibilidade
+     */
     setRefreshToken(token: string | null): void;
     /**
      * Alias para login, retornando { user, error } padrão do Showcase
@@ -82,10 +87,16 @@ export declare class AuthModule {
     }>;
     /**
      * Recupera a sessão atual (User + Token).
-     * Se não tiver logado, retorna null ou tenta validar o token.
+     * Primeiro tenta memória, depois localStorage.
+     * Se não encontrar, retorna null.
      */
     getSession(): Promise<{
         user: User;
         access_token: string;
     } | null>;
+    /**
+     * Retorna o usuário atual (sem validar token).
+     * Útil para acesso síncrono aos dados do usuário.
+     */
+    getCurrentUser(): User | null;
 }

package/dist/auth.js

@@ -1,14 +1,16 @@
 export class AuthModule {
     constructor(client, http) {
-        this.refreshToken = null;
-        // Armazena o user localmente para acesso rápido via getSession
+        // Armazena o user em memória para acesso rápido
+        // Persistência fica no PlataformaClient (localStorage)
         this.currentUser = null;
         this.client = client;
         this.http = http;
+        // Restaura user do localStorage se existir
+        this.currentUser = this.client.getUser();
     }
-    // =================================================================
-    // MÉTODOS ORIGINAIS (MANTIDOS)
-    // =================================================================
+    // ==========================================================================
+    // MÉTODOS PRINCIPAIS
+    // ==========================================================================
     async login(email, password) {
         try {
             const { data } = await this.http.post("/auth/login", {
@@ -16,15 +18,17 @@ export class AuthModule {
                 password,
             });
             if (data.accessToken) {
+                // Persiste automaticamente via PlataformaClient
                 this.client.setToken(data.accessToken);
-                this.refreshToken = data.refreshToken;
+                this.client.setRefreshToken(data.refreshToken);
+                this.client.setUser(data.user);
                 this.currentUser = data.user;
             }
             return data;
         }
         catch (e) {
-            this.client.setToken(null);
-            this.refreshToken = null;
+            // Limpa tudo em caso de erro
+            this.client.clearSession();
             this.currentUser = null;
             throw e;
         }
@@ -32,9 +36,11 @@ export class AuthModule {
     async register(credentials) {
         try {
             const { data } = await this.http.post("/auth/register", credentials);
-            // Se o register já retornar token, configura:
+            // Se o register retornar token (auto-login), configura sessão
             if (data.accessToken) {
                 this.client.setToken(data.accessToken);
+                this.client.setRefreshToken(data.refreshToken);
+                this.client.setUser(data.user);
                 this.currentUser = data.user;
             }
             return data;
@@ -44,21 +50,28 @@ export class AuthModule {
         }
     }
     async refresh() {
-        if (!this.refreshToken) {
+        // Tenta pegar do localStorage primeiro, depois da memória
+        const refreshToken = this.client.getRefreshToken() || this.getRefreshToken();
+        if (!refreshToken) {
             throw new Error("Nenhum refresh token disponível");
         }
         try {
             const { data } = await this.http.post("/auth/refresh", {
-                refreshToken: this.refreshToken,
+                refreshToken,
             });
             if (data.accessToken) {
                 this.client.setToken(data.accessToken);
+                // Se vier novo refresh token, atualiza
+                if (data.refreshToken) {
+                    this.client.setRefreshToken(data.refreshToken);
+                }
             }
             return data;
         }
         catch (e) {
-            this.client.setToken(null);
-            this.refreshToken = null;
+            // Token expirado - limpa sessão
+            this.client.clearSession();
+            this.currentUser = null;
             throw e;
         }
     }
@@ -66,18 +79,17 @@ export class AuthModule {
         return `${this.client.apiUrl}/v1/auth/google`;
     }
     async logout() {
-        if (this.refreshToken) {
+        const refreshToken = this.client.getRefreshToken();
+        if (refreshToken) {
             try {
-                await this.http.post("/auth/logout", {
-                    refreshToken: this.refreshToken,
-                });
+                await this.http.post("/auth/logout", { refreshToken });
             }
-            catch (e) {
-                // Ignora erro de logout
+            catch {
+                // Ignora erro de logout no servidor
             }
         }
-        this.client.setToken(null);
-        this.refreshToken = null;
+        // Limpa tudo (memória + localStorage)
+        this.client.clearSession();
         this.currentUser = null;
     }
     async logoutAll() {
@@ -85,8 +97,7 @@ export class AuthModule {
             await this.http.post("/auth/logout-all");
         }
         finally {
-            this.client.setToken(null);
-            this.refreshToken = null;
+            this.client.clearSession();
             this.currentUser = null;
         }
     }
@@ -105,15 +116,21 @@ export class AuthModule {
         });
         return data;
     }
+    /**
+     * @deprecated Use client.getRefreshToken() - mantido para compatibilidade
+     */
     getRefreshToken() {
-        return this.refreshToken;
+        return this.client.getRefreshToken();
     }
+    /**
+     * @deprecated Use client.setRefreshToken() - mantido para compatibilidade
+     */
     setRefreshToken(token) {
-        this.refreshToken = token;
+        this.client.setRefreshToken(token);
     }
-    // =================================================================
-    // NOVOS MÉTODOS (COMPATIBILIDADE COM SHOWCASE / SUPABASE STYLE)
-    // =================================================================
+    // ==========================================================================
+    // MÉTODOS COMPATÍVEIS COM SUPABASE / SHOWCASE STYLE
+    // ==========================================================================
     /**
      * Alias para login, retornando { user, error } padrão do Showcase
      */
@@ -134,7 +151,7 @@ export class AuthModule {
             const data = await this.register({
                 email: credentials.email,
                 password: credentials.password,
-                name: credentials.data?.name || credentials.email.split('@')[0],
+                name: credentials.data?.name || credentials.email.split("@")[0],
             });
             return { user: data.user, error: null };
         }
@@ -151,20 +168,51 @@ export class AuthModule {
     }
     /**
      * Recupera a sessão atual (User + Token).
-     * Se não tiver logado, retorna null ou tenta validar o token.
+     * Primeiro tenta memória, depois localStorage.
+     * Se não encontrar, retorna null.
      */
     async getSession() {
         const token = this.client.getToken();
         if (!token)
             return null;
-        // Se já temos o user em memória, retorna.
-        // O ideal seria validar o token no backend (/auth/me), mas vamos simplificar.
+        // Tenta memória primeiro
         if (this.currentUser) {
             return {
                 user: this.currentUser,
-                access_token: token
+                access_token: token,
+            };
+        }
+        // Tenta localStorage
+        const savedUser = this.client.getUser();
+        if (savedUser) {
+            this.currentUser = savedUser;
+            return {
+                user: savedUser,
+                access_token: token,
+            };
+        }
+        // Última opção: valida token no backend
+        try {
+            const { data } = await this.http.get("/auth/me");
+            this.currentUser = data.user;
+            this.client.setUser(data.user);
+            return {
+                user: data.user,
+                access_token: token,
             };
         }
-        return null;
+        catch {
+            // Token inválido/expirado - limpa sessão
+            this.client.clearSession();
+            this.currentUser = null;
+            return null;
+        }
+    }
+    /**
+     * Retorna o usuário atual (sem validar token).
+     * Útil para acesso síncrono aos dados do usuário.
+     */
+    getCurrentUser() {
+        return this.currentUser || this.client.getUser();
     }
 }

package/dist/http-client.d.ts

@@ -3,6 +3,7 @@ import type { PlataformaClient } from "./index.js";
 /**
  * Cria uma instância do Axios pré-configurada.
  * - Injeta automaticamente headers de Auth e Projeto.
+ * - Renova token automaticamente quando expira (401).
  * - Converte erros em AetherError.
  */
 export declare function createHttpClient(client: PlataformaClient): AxiosInstance;

package/dist/http-client.js

@@ -1,20 +1,41 @@
 // src/http-client.ts
 import axios from "axios";
 import { handleAxiosError } from "./errors.js";
+// Flag para evitar múltiplos refreshes simultâneos
+let isRefreshing = false;
+// Fila de requisições aguardando o refresh
+let failedQueue = [];
+/**
+ * Processa a fila de requisições após o refresh.
+ */
+const processQueue = (error, token = null) => {
+    failedQueue.forEach((prom) => {
+        if (error) {
+            prom.reject(error);
+        }
+        else {
+            prom.resolve(token);
+        }
+    });
+    failedQueue = [];
+};
 /**
  * Cria uma instância do Axios pré-configurada.
  * - Injeta automaticamente headers de Auth e Projeto.
+ * - Renova token automaticamente quando expira (401).
  * - Converte erros em AetherError.
  */
 export function createHttpClient(client) {
     const http = axios.create({
-        // Adiciona o /v1 automaticamente em todas as chamadas do SDK
         baseURL: `${client.apiUrl}/v1`,
         headers: {
             "Content-Type": "application/json",
         },
     });
-    // Interceptor de REQUEST
+    // ===========================================================================
+    // INTERCEPTOR DE REQUEST
+    // Injeta token e projectId em todas as requisições
+    // ===========================================================================
     http.interceptors.request.use((config) => {
         const token = client.getToken();
         if (token) {
@@ -25,7 +46,73 @@ export function createHttpClient(client) {
         }
         return config;
     });
-    // Interceptor de RESPONSE
-    http.interceptors.response.use((response) => response, (error) => handleAxiosError(error));
+    // ===========================================================================
+    // INTERCEPTOR DE RESPONSE
+    // Detecta 401 e tenta refresh automático do token
+    // ===========================================================================
+    http.interceptors.response.use((response) => response, async (error) => {
+        const originalRequest = error.config;
+        // Verifica se é erro 401 (não autorizado) e não é retry
+        const isUnauthorized = error.response?.status === 401;
+        const isRetry = originalRequest?._retry;
+        const isAuthRoute = originalRequest?.url?.includes("/auth/");
+        // Não tenta refresh se:
+        // - Não é 401
+        // - Já é um retry
+        // - É uma rota de auth (login, register, refresh)
+        // - Não tem refresh token disponível
+        if (!isUnauthorized || isRetry || isAuthRoute) {
+            return handleAxiosError(error);
+        }
+        const refreshToken = client.getRefreshToken();
+        if (!refreshToken) {
+            // Sem refresh token, limpa sessão e propaga erro
+            client.clearSession();
+            return handleAxiosError(error);
+        }
+        // Se já está fazendo refresh, aguarda na fila
+        if (isRefreshing) {
+            return new Promise((resolve, reject) => {
+                failedQueue.push({ resolve, reject });
+            })
+                .then((token) => {
+                originalRequest.headers.Authorization = `Bearer ${token}`;
+                return http(originalRequest);
+            })
+                .catch((err) => handleAxiosError(err));
+        }
+        // Marca como retry e inicia refresh
+        originalRequest._retry = true;
+        isRefreshing = true;
+        try {
+            // Chama endpoint de refresh diretamente (sem interceptor)
+            const { data } = await axios.post(`${client.apiUrl}/v1/auth/refresh`, { refreshToken }, { headers: { "Content-Type": "application/json" } });
+            const newAccessToken = data.accessToken;
+            const newRefreshToken = data.refreshToken;
+            // Atualiza tokens no client (persiste no localStorage)
+            client.setToken(newAccessToken);
+            if (newRefreshToken) {
+                client.setRefreshToken(newRefreshToken);
+            }
+            // Processa fila de requisições pendentes
+            processQueue(null, newAccessToken);
+            // Refaz a requisição original com novo token
+            originalRequest.headers.Authorization = `Bearer ${newAccessToken}`;
+            return http(originalRequest);
+        }
+        catch (refreshError) {
+            // Refresh falhou - sessão expirada
+            processQueue(refreshError, null);
+            client.clearSession();
+            // Emite evento de sessão expirada (se houver listener)
+            if (typeof window !== "undefined") {
+                window.dispatchEvent(new CustomEvent("aether:session-expired"));
+            }
+            return handleAxiosError(refreshError);
+        }
+        finally {
+            isRefreshing = false;
+        }
+    });
     return http;
 }

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import type { AxiosInstance } from "axios";
-import { AuthModule } from "./auth.js";
+import { AuthModule, User } from "./auth.js";
 import { DatabaseModule } from "./database.js";
 import { StorageModule } from "./storage.js";
 import { FunctionsModule } from "./functions.js";
@@ -12,6 +12,11 @@ export type ClientConfig = {
     baseUrl?: string;
     projectId?: string;
     apiKey?: string;
+    /**
+     * Habilita persistência automática de sessão no localStorage.
+     * Padrão: true em browsers, false em Node.js/SSR.
+     */
+    persistSession?: boolean;
 };
 export declare class PlataformaClient {
     auth: AuthModule;
@@ -24,9 +29,48 @@ export declare class PlataformaClient {
     projectId: string;
     http: AxiosInstance;
     private _token;
+    private _persistSession;
     constructor(config: ClientConfig);
+    /**
+     * Define o token de acesso (JWT).
+     * Se persistSession estiver ativo, salva automaticamente no localStorage.
+     */
     setToken(token: string | null): void;
+    /**
+     * Retorna o token de acesso atual.
+     */
     getToken(): string | null;
+    /**
+     * Salva o refresh token.
+     * Usado internamente pelo AuthModule após login.
+     */
+    setRefreshToken(token: string | null): void;
+    /**
+     * Retorna o refresh token salvo no localStorage.
+     */
+    getRefreshToken(): string | null;
+    /**
+     * Salva dados do usuário logado no localStorage.
+     */
+    setUser(user: User | null): void;
+    /**
+     * Retorna dados do usuário salvo no localStorage.
+     */
+    getUser(): User | null;
+    /**
+     * Limpa toda a sessão (token, refresh, user).
+     * Chamado automaticamente no logout.
+     */
+    clearSession(): void;
+    /**
+     * Verifica se existe uma sessão salva (token presente).
+     */
+    hasSession(): boolean;
+    /**
+     * Restaura sessão do localStorage ao inicializar o client.
+     * Executado automaticamente no constructor.
+     */
+    private _restoreSession;
 }
 export { AetherError } from "./errors.js";
 export type { LoginResponse, Session, User } from "./auth.js";

package/dist/index.js

@@ -1,9 +1,26 @@
 import { createHttpClient } from "./http-client.js";
-import { AuthModule } from "./auth.js"; // Importando User
+import { AuthModule } from "./auth.js";
 import { DatabaseModule } from "./database.js";
 import { StorageModule } from "./storage.js";
 import { FunctionsModule } from "./functions.js";
 import { PushModule } from "./push.js";
+// =============================================================================
+// CONSTANTES DE STORAGE
+// Chaves padronizadas para localStorage - evita conflito com outros SDKs
+// =============================================================================
+const STORAGE_KEYS = {
+    TOKEN: "aether_token",
+    REFRESH_TOKEN: "aether_refresh_token",
+    USER: "aether_user",
+};
+/**
+ * Verifica se estamos em ambiente browser com localStorage disponível.
+ * Necessário para evitar erros em SSR (Next.js, Nuxt, etc).
+ */
+function isBrowser() {
+    return (typeof window !== "undefined" &&
+        typeof window.localStorage !== "undefined");
+}
 export class PlataformaClient {
     constructor(config) {
         this._token = null;
@@ -15,6 +32,11 @@ export class PlataformaClient {
         }
         this.apiUrl = url.replace(/\/+$/, "");
         this.projectId = project;
+        // Persistência habilitada por padrão apenas em browsers
+        this._persistSession = config.persistSession ?? isBrowser();
+        // Restaura sessão salva ANTES de criar o httpClient
+        // Isso garante que requisições iniciais já tenham o token
+        this._restoreSession();
         this.http = createHttpClient(this);
         // Inicializa módulos
         this.auth = new AuthModule(this, this.http);
@@ -25,12 +47,125 @@ export class PlataformaClient {
         // Cria o alias que o Showcase App espera
         this.database = this.db;
     }
+    // ===========================================================================
+    // TOKEN DE ACESSO
+    // ===========================================================================
+    /**
+     * Define o token de acesso (JWT).
+     * Se persistSession estiver ativo, salva automaticamente no localStorage.
+     */
     setToken(token) {
         this._token = token;
+        if (this._persistSession && isBrowser()) {
+            if (token) {
+                localStorage.setItem(STORAGE_KEYS.TOKEN, token);
+            }
+            else {
+                localStorage.removeItem(STORAGE_KEYS.TOKEN);
+            }
+        }
     }
+    /**
+     * Retorna o token de acesso atual.
+     */
     getToken() {
         return this._token;
     }
+    // ===========================================================================
+    // REFRESH TOKEN
+    // ===========================================================================
+    /**
+     * Salva o refresh token.
+     * Usado internamente pelo AuthModule após login.
+     */
+    setRefreshToken(token) {
+        if (this._persistSession && isBrowser()) {
+            if (token) {
+                localStorage.setItem(STORAGE_KEYS.REFRESH_TOKEN, token);
+            }
+            else {
+                localStorage.removeItem(STORAGE_KEYS.REFRESH_TOKEN);
+            }
+        }
+    }
+    /**
+     * Retorna o refresh token salvo no localStorage.
+     */
+    getRefreshToken() {
+        if (this._persistSession && isBrowser()) {
+            return localStorage.getItem(STORAGE_KEYS.REFRESH_TOKEN);
+        }
+        return null;
+    }
+    // ===========================================================================
+    // DADOS DO USUÁRIO
+    // ===========================================================================
+    /**
+     * Salva dados do usuário logado no localStorage.
+     */
+    setUser(user) {
+        if (this._persistSession && isBrowser()) {
+            if (user) {
+                localStorage.setItem(STORAGE_KEYS.USER, JSON.stringify(user));
+            }
+            else {
+                localStorage.removeItem(STORAGE_KEYS.USER);
+            }
+        }
+    }
+    /**
+     * Retorna dados do usuário salvo no localStorage.
+     */
+    getUser() {
+        if (this._persistSession && isBrowser()) {
+            const saved = localStorage.getItem(STORAGE_KEYS.USER);
+            if (saved) {
+                try {
+                    return JSON.parse(saved);
+                }
+                catch {
+                    // JSON corrompido - limpa
+                    localStorage.removeItem(STORAGE_KEYS.USER);
+                    return null;
+                }
+            }
+        }
+        return null;
+    }
+    // ===========================================================================
+    // GERENCIAMENTO DE SESSÃO
+    // ===========================================================================
+    /**
+     * Limpa toda a sessão (token, refresh, user).
+     * Chamado automaticamente no logout.
+     */
+    clearSession() {
+        this._token = null;
+        if (isBrowser()) {
+            localStorage.removeItem(STORAGE_KEYS.TOKEN);
+            localStorage.removeItem(STORAGE_KEYS.REFRESH_TOKEN);
+            localStorage.removeItem(STORAGE_KEYS.USER);
+        }
+    }
+    /**
+     * Verifica se existe uma sessão salva (token presente).
+     */
+    hasSession() {
+        return this._token !== null;
+    }
+    /**
+     * Restaura sessão do localStorage ao inicializar o client.
+     * Executado automaticamente no constructor.
+     */
+    _restoreSession() {
+        if (!this._persistSession || !isBrowser()) {
+            return;
+        }
+        const savedToken = localStorage.getItem(STORAGE_KEYS.TOKEN);
+        if (savedToken) {
+            this._token = savedToken;
+        }
+    }
 }
 // ===== EXPORTS =====
 export { AetherError } from "./errors.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allanfsouza/aether-sdk",
-  "version": "2.4.4",
+  "version": "2.4.6",
   "description": "SDK do Cliente para a Plataforma Aether",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -32,4 +32,4 @@
     "@types/ws": "^8.5.10",
     "typescript": "^5.3.0"
   }
-}
+}

package/src/auth.ts

@@ -31,18 +31,22 @@ export interface Session {
 export class AuthModule {
   private client: PlataformaClient;
   private http: AxiosInstance;
-  private refreshToken: string | null = null;
-  // Armazena o user localmente para acesso rápido via getSession
+
+  // Armazena o user em memória para acesso rápido
+  // Persistência fica no PlataformaClient (localStorage)
   private currentUser: User | null = null;
 
   constructor(client: PlataformaClient, http: AxiosInstance) {
     this.client = client;
     this.http = http;
+
+    // Restaura user do localStorage se existir
+    this.currentUser = this.client.getUser();
   }
 
-  // =================================================================
-  // MÉTODOS ORIGINAIS (MANTIDOS)
-  // =================================================================
+  // ==========================================================================
+  // MÉTODOS PRINCIPAIS
+  // ==========================================================================
 
   async login(email: string, password: string): Promise<LoginResponse> {
     try {
@@ -52,15 +56,17 @@ export class AuthModule {
       });
 
       if (data.accessToken) {
+        // Persiste automaticamente via PlataformaClient
         this.client.setToken(data.accessToken);
-        this.refreshToken = data.refreshToken;
+        this.client.setRefreshToken(data.refreshToken);
+        this.client.setUser(data.user);
         this.currentUser = data.user;
       }
 
       return data;
     } catch (e) {
-      this.client.setToken(null);
-      this.refreshToken = null;
+      // Limpa tudo em caso de erro
+      this.client.clearSession();
       this.currentUser = null;
       throw e;
     }
@@ -73,11 +79,15 @@ export class AuthModule {
   }) {
     try {
       const { data } = await this.http.post("/auth/register", credentials);
-      // Se o register já retornar token, configura:
+
+      // Se o register retornar token (auto-login), configura sessão
       if (data.accessToken) {
         this.client.setToken(data.accessToken);
+        this.client.setRefreshToken(data.refreshToken);
+        this.client.setUser(data.user);
         this.currentUser = data.user;
       }
+
       return data;
     } catch (e) {
       throw e;
@@ -85,23 +95,32 @@ export class AuthModule {
   }
 
   async refresh(): Promise<{ accessToken: string }> {
-    if (!this.refreshToken) {
+    // Tenta pegar do localStorage primeiro, depois da memória
+    const refreshToken = this.client.getRefreshToken() || this.getRefreshToken();
+
+    if (!refreshToken) {
       throw new Error("Nenhum refresh token disponível");
     }
 
     try {
       const { data } = await this.http.post("/auth/refresh", {
-        refreshToken: this.refreshToken,
+        refreshToken,
       });
 
       if (data.accessToken) {
         this.client.setToken(data.accessToken);
+
+        // Se vier novo refresh token, atualiza
+        if (data.refreshToken) {
+          this.client.setRefreshToken(data.refreshToken);
+        }
       }
 
       return data;
     } catch (e) {
-      this.client.setToken(null);
-      this.refreshToken = null;
+      // Token expirado - limpa sessão
+      this.client.clearSession();
+      this.currentUser = null;
       throw e;
     }
   }
@@ -111,17 +130,18 @@ export class AuthModule {
   }
 
   async logout(): Promise<void> {
-    if (this.refreshToken) {
+    const refreshToken = this.client.getRefreshToken();
+
+    if (refreshToken) {
       try {
-        await this.http.post("/auth/logout", {
-          refreshToken: this.refreshToken,
-        });
-      } catch (e) {
-        // Ignora erro de logout
+        await this.http.post("/auth/logout", { refreshToken });
+      } catch {
+        // Ignora erro de logout no servidor
       }
     }
-    this.client.setToken(null);
-    this.refreshToken = null;
+
+    // Limpa tudo (memória + localStorage)
+    this.client.clearSession();
     this.currentUser = null;
   }
 
@@ -129,8 +149,7 @@ export class AuthModule {
     try {
       await this.http.post("/auth/logout-all");
     } finally {
-      this.client.setToken(null);
-      this.refreshToken = null;
+      this.client.clearSession();
       this.currentUser = null;
     }
   }
@@ -155,17 +174,23 @@ export class AuthModule {
     return data;
   }
 
+  /**
+   * @deprecated Use client.getRefreshToken() - mantido para compatibilidade
+   */
   getRefreshToken(): string | null {
-    return this.refreshToken;
+    return this.client.getRefreshToken();
   }
 
+  /**
+   * @deprecated Use client.setRefreshToken() - mantido para compatibilidade
+   */
   setRefreshToken(token: string | null) {
-    this.refreshToken = token;
+    this.client.setRefreshToken(token);
   }
 
-  // =================================================================
-  // NOVOS MÉTODOS (COMPATIBILIDADE COM SHOWCASE / SUPABASE STYLE)
-  // =================================================================
+  // ==========================================================================
+  // MÉTODOS COMPATÍVEIS COM SUPABASE / SHOWCASE STYLE
+  // ==========================================================================
 
   /**
    * Alias para login, retornando { user, error } padrão do Showcase
@@ -182,12 +207,16 @@ export class AuthModule {
   /**
    * Alias para register, retornando { user, error }
    */
-  async signUp(credentials: { email: string; password: string; data?: { name: string } }) {
+  async signUp(credentials: {
+    email: string;
+    password: string;
+    data?: { name: string };
+  }) {
     try {
       const data = await this.register({
         email: credentials.email,
         password: credentials.password,
-        name: credentials.data?.name || credentials.email.split('@')[0],
+        name: credentials.data?.name || credentials.email.split("@")[0],
       });
       return { user: data.user, error: null };
     } catch (err: any) {
@@ -205,21 +234,53 @@ export class AuthModule {
 
   /**
    * Recupera a sessão atual (User + Token).
-   * Se não tiver logado, retorna null ou tenta validar o token.
+   * Primeiro tenta memória, depois localStorage.
+   * Se não encontrar, retorna null.
    */
   async getSession() {
     const token = this.client.getToken();
     if (!token) return null;
 
-    // Se já temos o user em memória, retorna.
-    // O ideal seria validar o token no backend (/auth/me), mas vamos simplificar.
+    // Tenta memória primeiro
     if (this.currentUser) {
       return {
         user: this.currentUser,
-        access_token: token
+        access_token: token,
+      };
+    }
+
+    // Tenta localStorage
+    const savedUser = this.client.getUser();
+    if (savedUser) {
+      this.currentUser = savedUser;
+      return {
+        user: savedUser,
+        access_token: token,
+      };
+    }
+
+    // Última opção: valida token no backend
+    try {
+      const { data } = await this.http.get<{ user: User }>("/auth/me");
+      this.currentUser = data.user;
+      this.client.setUser(data.user);
+      return {
+        user: data.user,
+        access_token: token,
       };
+    } catch {
+      // Token inválido/expirado - limpa sessão
+      this.client.clearSession();
+      this.currentUser = null;
+      return null;
     }
+  }
 
-    return null;
+  /**
+   * Retorna o usuário atual (sem validar token).
+   * Útil para acesso síncrono aos dados do usuário.
+   */
+  getCurrentUser(): User | null {
+    return this.currentUser || this.client.getUser();
   }
 }

package/src/http-client.ts

@@ -1,23 +1,53 @@
 // src/http-client.ts
-import axios, { type AxiosInstance } from "axios";
+import axios, {
+  type AxiosInstance,
+  type AxiosError,
+  type InternalAxiosRequestConfig,
+} from "axios";
 import type { PlataformaClient } from "./index.js";
 import { handleAxiosError } from "./errors.js";
 
+// Flag para evitar múltiplos refreshes simultâneos
+let isRefreshing = false;
+
+// Fila de requisições aguardando o refresh
+let failedQueue: Array<{
+  resolve: (token: string) => void;
+  reject: (error: any) => void;
+}> = [];
+
+/**
+ * Processa a fila de requisições após o refresh.
+ */
+const processQueue = (error: any, token: string | null = null) => {
+  failedQueue.forEach((prom) => {
+    if (error) {
+      prom.reject(error);
+    } else {
+      prom.resolve(token!);
+    }
+  });
+  failedQueue = [];
+};
+
 /**
  * Cria uma instância do Axios pré-configurada.
  * - Injeta automaticamente headers de Auth e Projeto.
+ * - Renova token automaticamente quando expira (401).
  * - Converte erros em AetherError.
  */
 export function createHttpClient(client: PlataformaClient): AxiosInstance {
   const http = axios.create({
-    // Adiciona o /v1 automaticamente em todas as chamadas do SDK
     baseURL: `${client.apiUrl}/v1`,
     headers: {
       "Content-Type": "application/json",
     },
   });
 
-  // Interceptor de REQUEST
+  // ===========================================================================
+  // INTERCEPTOR DE REQUEST
+  // Injeta token e projectId em todas as requisições
+  // ===========================================================================
   http.interceptors.request.use((config) => {
     const token = client.getToken();
     if (token) {
@@ -31,10 +61,92 @@ export function createHttpClient(client: PlataformaClient): AxiosInstance {
     return config;
   });
 
-  // Interceptor de RESPONSE
+  // ===========================================================================
+  // INTERCEPTOR DE RESPONSE
+  // Detecta 401 e tenta refresh automático do token
+  // ===========================================================================
   http.interceptors.response.use(
     (response) => response,
-    (error) => handleAxiosError(error)
+    async (error: AxiosError) => {
+      const originalRequest = error.config as InternalAxiosRequestConfig & {
+        _retry?: boolean;
+      };
+
+      // Verifica se é erro 401 (não autorizado) e não é retry
+      const isUnauthorized = error.response?.status === 401;
+      const isRetry = originalRequest?._retry;
+      const isAuthRoute = originalRequest?.url?.includes("/auth/");
+
+      // Não tenta refresh se:
+      // - Não é 401
+      // - Já é um retry
+      // - É uma rota de auth (login, register, refresh)
+      // - Não tem refresh token disponível
+      if (!isUnauthorized || isRetry || isAuthRoute) {
+        return handleAxiosError(error);
+      }
+
+      const refreshToken = client.getRefreshToken();
+      if (!refreshToken) {
+        // Sem refresh token, limpa sessão e propaga erro
+        client.clearSession();
+        return handleAxiosError(error);
+      }
+
+      // Se já está fazendo refresh, aguarda na fila
+      if (isRefreshing) {
+        return new Promise((resolve, reject) => {
+          failedQueue.push({ resolve, reject });
+        })
+          .then((token) => {
+            originalRequest.headers.Authorization = `Bearer ${token}`;
+            return http(originalRequest);
+          })
+          .catch((err) => handleAxiosError(err));
+      }
+
+      // Marca como retry e inicia refresh
+      originalRequest._retry = true;
+      isRefreshing = true;
+
+      try {
+        // Chama endpoint de refresh diretamente (sem interceptor)
+        const { data } = await axios.post(
+          `${client.apiUrl}/v1/auth/refresh`,
+          { refreshToken },
+          { headers: { "Content-Type": "application/json" } }
+        );
+
+        const newAccessToken = data.accessToken;
+        const newRefreshToken = data.refreshToken;
+
+        // Atualiza tokens no client (persiste no localStorage)
+        client.setToken(newAccessToken);
+        if (newRefreshToken) {
+          client.setRefreshToken(newRefreshToken);
+        }
+
+        // Processa fila de requisições pendentes
+        processQueue(null, newAccessToken);
+
+        // Refaz a requisição original com novo token
+        originalRequest.headers.Authorization = `Bearer ${newAccessToken}`;
+        return http(originalRequest);
+      } catch (refreshError: any) {
+        // Refresh falhou - sessão expirada
+        processQueue(refreshError, null);
+        client.clearSession();
+
+        // Emite evento de sessão expirada (se houver listener)
+        if (typeof window !== "undefined") {
+          window.dispatchEvent(new CustomEvent("aether:session-expired"));
+        }
+
+        return handleAxiosError(refreshError);
+      } finally {
+        isRefreshing = false;
+      }
+    }
   );
 
   return http;

package/src/index.ts

@@ -1,26 +1,50 @@
 // src/index.ts
 import type { AxiosInstance } from "axios";
 import { createHttpClient } from "./http-client.js";
-import { AuthModule, User } from "./auth.js"; // Importando User
+import { AuthModule, User } from "./auth.js";
 import { DatabaseModule } from "./database.js";
 import { StorageModule } from "./storage.js";
 import { FunctionsModule } from "./functions.js";
 import { PushModule } from "./push.js";
 
+// =============================================================================
+// CONSTANTES DE STORAGE
+// Chaves padronizadas para localStorage - evita conflito com outros SDKs
+// =============================================================================
+const STORAGE_KEYS = {
+  TOKEN: "aether_token",
+  REFRESH_TOKEN: "aether_refresh_token",
+  USER: "aether_user",
+} as const;
+
 /**
  * Configuração usada para criar o cliente principal da plataforma.
  */
 export type ClientConfig = {
   // Suporte duplo para compatibilidade:
-  // apiUrl (nome original) OU baseUrl (nome novo do App)
   apiUrl?: string;
   baseUrl?: string;
-
-  // projectId (nome original) OU apiKey (nome novo do App)
   projectId?: string;
   apiKey?: string;
+
+  /**
+   * Habilita persistência automática de sessão no localStorage.
+   * Padrão: true em browsers, false em Node.js/SSR.
+   */
+  persistSession?: boolean;
 };
 
+/**
+ * Verifica se estamos em ambiente browser com localStorage disponível.
+ * Necessário para evitar erros em SSR (Next.js, Nuxt, etc).
+ */
+function isBrowser(): boolean {
+  return (
+    typeof window !== "undefined" &&
+    typeof window.localStorage !== "undefined"
+  );
+}
+
 export class PlataformaClient {
   public auth: AuthModule;
   public db: DatabaseModule;
@@ -35,7 +59,9 @@ export class PlataformaClient {
   public projectId: string;
 
   public http: AxiosInstance;
+
   private _token: string | null = null;
+  private _persistSession: boolean;
 
   constructor(config: ClientConfig) {
     // Resolve URL (prioridade para baseUrl se existir, senão apiUrl)
@@ -49,6 +75,13 @@ export class PlataformaClient {
     this.apiUrl = url.replace(/\/+$/, "");
     this.projectId = project;
 
+    // Persistência habilitada por padrão apenas em browsers
+    this._persistSession = config.persistSession ?? isBrowser();
+
+    // Restaura sessão salva ANTES de criar o httpClient
+    // Isso garante que requisições iniciais já tenham o token
+    this._restoreSession();
+
     this.http = createHttpClient(this);
 
     // Inicializa módulos
@@ -62,18 +95,141 @@ export class PlataformaClient {
     this.database = this.db;
   }
 
-  setToken(token: string | null) {
+  // ===========================================================================
+  // TOKEN DE ACESSO
+  // ===========================================================================
+
+  /**
+   * Define o token de acesso (JWT).
+   * Se persistSession estiver ativo, salva automaticamente no localStorage.
+   */
+  setToken(token: string | null): void {
     this._token = token;
+
+    if (this._persistSession && isBrowser()) {
+      if (token) {
+        localStorage.setItem(STORAGE_KEYS.TOKEN, token);
+      } else {
+        localStorage.removeItem(STORAGE_KEYS.TOKEN);
+      }
+    }
   }
 
+  /**
+   * Retorna o token de acesso atual.
+   */
   getToken(): string | null {
     return this._token;
   }
+
+  // ===========================================================================
+  // REFRESH TOKEN
+  // ===========================================================================
+
+  /**
+   * Salva o refresh token.
+   * Usado internamente pelo AuthModule após login.
+   */
+  setRefreshToken(token: string | null): void {
+    if (this._persistSession && isBrowser()) {
+      if (token) {
+        localStorage.setItem(STORAGE_KEYS.REFRESH_TOKEN, token);
+      } else {
+        localStorage.removeItem(STORAGE_KEYS.REFRESH_TOKEN);
+      }
+    }
+  }
+
+  /**
+   * Retorna o refresh token salvo no localStorage.
+   */
+  getRefreshToken(): string | null {
+    if (this._persistSession && isBrowser()) {
+      return localStorage.getItem(STORAGE_KEYS.REFRESH_TOKEN);
+    }
+    return null;
+  }
+
+  // ===========================================================================
+  // DADOS DO USUÁRIO
+  // ===========================================================================
+
+  /**
+   * Salva dados do usuário logado no localStorage.
+   */
+  setUser(user: User | null): void {
+    if (this._persistSession && isBrowser()) {
+      if (user) {
+        localStorage.setItem(STORAGE_KEYS.USER, JSON.stringify(user));
+      } else {
+        localStorage.removeItem(STORAGE_KEYS.USER);
+      }
+    }
+  }
+
+  /**
+   * Retorna dados do usuário salvo no localStorage.
+   */
+  getUser(): User | null {
+    if (this._persistSession && isBrowser()) {
+      const saved = localStorage.getItem(STORAGE_KEYS.USER);
+      if (saved) {
+        try {
+          return JSON.parse(saved) as User;
+        } catch {
+          // JSON corrompido - limpa
+          localStorage.removeItem(STORAGE_KEYS.USER);
+          return null;
+        }
+      }
+    }
+    return null;
+  }
+
+  // ===========================================================================
+  // GERENCIAMENTO DE SESSÃO
+  // ===========================================================================
+
+  /**
+   * Limpa toda a sessão (token, refresh, user).
+   * Chamado automaticamente no logout.
+   */
+  clearSession(): void {
+    this._token = null;
+
+    if (isBrowser()) {
+      localStorage.removeItem(STORAGE_KEYS.TOKEN);
+      localStorage.removeItem(STORAGE_KEYS.REFRESH_TOKEN);
+      localStorage.removeItem(STORAGE_KEYS.USER);
+    }
+  }
+
+  /**
+   * Verifica se existe uma sessão salva (token presente).
+   */
+  hasSession(): boolean {
+    return this._token !== null;
+  }
+
+  /**
+   * Restaura sessão do localStorage ao inicializar o client.
+   * Executado automaticamente no constructor.
+   */
+  private _restoreSession(): void {
+    if (!this._persistSession || !isBrowser()) {
+      return;
+    }
+
+    const savedToken = localStorage.getItem(STORAGE_KEYS.TOKEN);
+    if (savedToken) {
+      this._token = savedToken;
+    }
+  }
 }
 
 // ===== EXPORTS =====
 export { AetherError } from "./errors.js";
-export type { LoginResponse, Session, User } from "./auth.js"; // User exportado!
+export type { LoginResponse, Session, User } from "./auth.js";
 export type { ListOptions } from "./database.js";
 export type {
   PushPlatform,