@allanfsouza/aether-sdk 2.4.6 → 2.4.9

package/dist/tenant-auth.js

@@ -0,0 +1,221 @@
+// src/tenant-auth.ts
+// [FEATURE] Módulo de Autenticação de Tenants para SDK
+// Permite autenticação de end-users em projetos Aether
+// Compatible with Firebase Auth-style usage
+// ============================================================================
+// MODULE
+// ============================================================================
+/**
+ * Módulo de Autenticação de Tenants
+ *
+ * Permite que usuários finais (clientes) de projetos Aether
+ * se registrem, façam login e gerenciem seus perfis.
+ *
+ * Os dados são isolados por projeto (tabela prj_{id}_users).
+ *
+ * @example
+ * ```typescript
+ * const aether = new PlataformaClient({ ... });
+ *
+ * // Registrar usuário no projeto
+ * const { user, error } = await aether.tenantAuth.signUp('project-id', {
+ *   email: 'user@example.com',
+ *   password: '123456',
+ *   name: 'John Doe',
+ * });
+ *
+ * // Login
+ * const { accessToken, user } = await aether.tenantAuth.signIn('project-id', {
+ *   email: 'user@example.com',
+ *   password: '123456',
+ * });
+ *
+ * // Obter perfil
+ * const profile = await aether.tenantAuth.getProfile('project-id');
+ * ```
+ */
+export class TenantAuthModule {
+    constructor(client, http) {
+        // Armazena o token do tenant atual em memória
+        this.currentToken = null;
+        this.currentUser = null;
+        this.client = client;
+        this.http = http;
+    }
+    // ==========================================================================
+    // MÉTODOS PRINCIPAIS
+    // ==========================================================================
+    /**
+     * Registra um novo usuário tenant no projeto.
+     * A tabela de usuários é criada automaticamente se não existir.
+     *
+     * @param projectId - ID do projeto
+     * @param credentials - Email, senha, nome e dados opcionais
+     */
+    async register(projectId, credentials) {
+        const { data } = await this.http.post("/auth/tenant/register", {
+            projectId,
+            ...credentials,
+        });
+        return data;
+    }
+    /**
+     * Realiza login de usuário tenant.
+     * Armazena o token para uso em requisições subsequentes.
+     *
+     * @param projectId - ID do projeto
+     * @param credentials - Email e senha
+     */
+    async login(projectId, credentials) {
+        const { data } = await this.http.post("/auth/tenant/login", {
+            projectId,
+            ...credentials,
+        });
+        // Armazena token e usuário
+        this.currentToken = data.accessToken;
+        this.currentUser = data.user;
+        return data;
+    }
+    /**
+     * Solicita reset de senha.
+     * Retorna mensagem genérica para prevenir enumeração de usuários.
+     *
+     * @param projectId - ID do projeto
+     * @param email - Email do usuário
+     */
+    async forgotPassword(projectId, email) {
+        const { data } = await this.http.post("/auth/tenant/forgot-password", {
+            projectId,
+            email,
+        });
+        return data;
+    }
+    /**
+     * Redefine a senha usando o token recebido por email.
+     *
+     * @param projectId - ID do projeto
+     * @param email - Email do usuário
+     * @param token - Token de reset (recebido por email)
+     * @param newPassword - Nova senha
+     */
+    async resetPassword(projectId, email, token, newPassword) {
+        const { data } = await this.http.post("/auth/tenant/reset-password", {
+            projectId,
+            email,
+            token,
+            newPassword,
+        });
+        return data;
+    }
+    /**
+     * Obtém o perfil do usuário autenticado.
+     * Requer que login() tenha sido chamado antes.
+     *
+     * @param projectId - ID do projeto (opcional, usa do token se não fornecido)
+     */
+    async getProfile(projectId) {
+        const headers = this.currentToken
+            ? { Authorization: `Bearer ${this.currentToken}` }
+            : {};
+        const { data } = await this.http.get("/auth/tenant/me", { headers });
+        this.currentUser = data.user;
+        return data.user;
+    }
+    /**
+     * Atualiza o perfil do usuário autenticado.
+     *
+     * @param projectId - ID do projeto
+     * @param updates - Campos a atualizar (name, data)
+     */
+    async updateProfile(projectId, updates) {
+        const headers = this.currentToken
+            ? { Authorization: `Bearer ${this.currentToken}` }
+            : {};
+        const { data } = await this.http.put("/auth/tenant/profile", {
+            projectId,
+            ...updates,
+        }, { headers });
+        this.currentUser = data.user;
+        return data;
+    }
+    /**
+     * Faz logout do tenant (limpa token local).
+     */
+    logout() {
+        this.currentToken = null;
+        this.currentUser = null;
+    }
+    // ==========================================================================
+    // MÉTODOS ESTILO SUPABASE/FIREBASE
+    // ==========================================================================
+    /**
+     * Alias para register com retorno { user, error }
+     */
+    async signUp(projectId, credentials) {
+        try {
+            const { user } = await this.register(projectId, credentials);
+            return { user, error: null };
+        }
+        catch (err) {
+            const axiosError = err;
+            return {
+                user: null,
+                error: axiosError.response?.data?.error ||
+                    axiosError.response?.data?.message ||
+                    err.message,
+            };
+        }
+    }
+    /**
+     * Alias para login com retorno { user, accessToken, error }
+     */
+    async signIn(projectId, credentials) {
+        try {
+            const { user, accessToken } = await this.login(projectId, credentials);
+            return { user, accessToken, error: null };
+        }
+        catch (err) {
+            const axiosError = err;
+            return {
+                user: null,
+                accessToken: null,
+                error: axiosError.response?.data?.error ||
+                    axiosError.response?.data?.message ||
+                    err.message,
+            };
+        }
+    }
+    /**
+     * Alias para logout
+     */
+    signOut() {
+        this.logout();
+    }
+    // ==========================================================================
+    // ACCESSORS
+    // ==========================================================================
+    /**
+     * Retorna o token atual do tenant
+     */
+    getToken() {
+        return this.currentToken;
+    }
+    /**
+     * Define o token do tenant (útil para restaurar sessão)
+     */
+    setToken(token) {
+        this.currentToken = token;
+    }
+    /**
+     * Retorna o usuário atual do tenant
+     */
+    getCurrentUser() {
+        return this.currentUser;
+    }
+    /**
+     * Verifica se há um usuário autenticado
+     */
+    isAuthenticated() {
+        return this.currentToken !== null;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allanfsouza/aether-sdk",
-  "version": "2.4.6",
+  "version": "2.4.9",
   "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/http-client.ts

@@ -1,24 +1,135 @@
 // src/http-client.ts
+// [MELHORIA] SDK com Retry Automático e Exponential Backoff
+// Data: 09/12/2025
+
 import axios, {
   type AxiosInstance,
   type AxiosError,
+  type AxiosRequestConfig,
   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;
+// =============================================================================
+// CONFIGURAÇÕES DE RETRY
+// =============================================================================
+
+export interface RetryConfig {
+  /** Número máximo de tentativas (padrão: 3) */
+  maxRetries: number;
+  /** Delay base em ms para exponential backoff (padrão: 1000) */
+  baseDelay: number;
+  /** Delay máximo em ms (padrão: 30000) */
+  maxDelay: number;
+  /** Status codes que devem ser retried (padrão: [408, 429, 500, 502, 503, 504]) */
+  retryableStatuses: number[];
+  /** Métodos HTTP que podem ser retried (padrão: GET, HEAD, OPTIONS, PUT, DELETE) */
+  retryableMethods: string[];
+  /** Habilita retry para erros de rede (padrão: true) */
+  retryOnNetworkError: boolean;
+  /** Callback chamado antes de cada retry */
+  onRetry?: (retryCount: number, error: AxiosError, config: AxiosRequestConfig) => void;
+}
+
+export const DEFAULT_RETRY_CONFIG: RetryConfig = {
+  maxRetries: 3,
+  baseDelay: 1000,
+  maxDelay: 30000,
+  retryableStatuses: [408, 429, 500, 502, 503, 504],
+  retryableMethods: ["GET", "HEAD", "OPTIONS", "PUT", "DELETE"],
+  retryOnNetworkError: true,
+};
+
+// =============================================================================
+// HELPERS
+// =============================================================================
+
+/**
+ * Calcula o delay com exponential backoff + jitter
+ */
+function calculateDelay(retryCount: number, config: RetryConfig): number {
+  // Exponential: baseDelay * 2^retryCount
+  const exponentialDelay = config.baseDelay * Math.pow(2, retryCount);
+
+  // Adiciona jitter (±25%) para evitar thundering herd
+  const jitter = exponentialDelay * 0.25 * (Math.random() * 2 - 1);
+
+  // Limita ao maxDelay
+  return Math.min(exponentialDelay + jitter, config.maxDelay);
+}
+
+/**
+ * Verifica se o erro é retryable
+ */
+function isRetryable(error: AxiosError, config: RetryConfig): boolean {
+  // Erro de rede (sem response)
+  if (!error.response && config.retryOnNetworkError) {
+    // Verifica se é erro de rede real (não cancelamento)
+    if (error.code === "ECONNABORTED" || error.code === "ETIMEDOUT" ||
+      error.code === "ENOTFOUND" || error.code === "ENETUNREACH" ||
+      error.message === "Network Error") {
+      return true;
+    }
+  }
 
-// Fila de requisições aguardando o refresh
+  // Verifica status code
+  const status = error.response?.status;
+  if (status && config.retryableStatuses.includes(status)) {
+    return true;
+  }
+
+  return false;
+}
+
+/**
+ * Verifica se o método HTTP pode ser retried
+ */
+function isMethodRetryable(method: string | undefined, config: RetryConfig): boolean {
+  if (!method) return false;
+  return config.retryableMethods.includes(method.toUpperCase());
+}
+
+/**
+ * Extrai Retry-After header (em ms)
+ */
+function getRetryAfterMs(error: AxiosError): number | null {
+  const retryAfter = error.response?.headers?.["retry-after"];
+
+  if (!retryAfter) return null;
+
+  // Se for número, é segundos
+  const seconds = parseInt(retryAfter, 10);
+  if (!isNaN(seconds)) {
+    return seconds * 1000;
+  }
+
+  // Se for data HTTP, calcula diferença
+  const date = new Date(retryAfter);
+  if (!isNaN(date.getTime())) {
+    return Math.max(0, date.getTime() - Date.now());
+  }
+
+  return null;
+}
+
+/**
+ * Aguarda um tempo determinado
+ */
+function sleep(ms: number): Promise<void> {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+// =============================================================================
+// FLAGS GLOBAIS (Refresh Token)
+// =============================================================================
+
+let isRefreshing = false;
 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) {
@@ -30,15 +141,35 @@ const processQueue = (error: any, token: string | null = null) => {
   failedQueue = [];
 };
 
+// =============================================================================
+// EXTENDED CONFIG TYPE
+// =============================================================================
+
+interface ExtendedAxiosRequestConfig extends InternalAxiosRequestConfig {
+  _retry?: boolean;
+  _retryCount?: number;
+}
+
+// =============================================================================
+// CRIAR HTTP CLIENT
+// =============================================================================
+
 /**
- * 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.
+ * Cria uma instância do Axios pré-configurada com:
+ * - Injeção automática de headers (Auth, Project)
+ * - Refresh automático de token (401)
+ * - Retry automático com exponential backoff
+ * - Tratamento de erros padronizado
  */
-export function createHttpClient(client: PlataformaClient): AxiosInstance {
+export function createHttpClient(
+  client: PlataformaClient,
+  retryConfig: Partial<RetryConfig> = {}
+): AxiosInstance {
+  const config: RetryConfig = { ...DEFAULT_RETRY_CONFIG, ...retryConfig };
+
   const http = axios.create({
     baseURL: `${client.apiUrl}/v1`,
+    timeout: 30000, // 30 segundos
     headers: {
       "Content-Type": "application/json",
     },
@@ -48,47 +179,106 @@ export function createHttpClient(client: PlataformaClient): AxiosInstance {
   // INTERCEPTOR DE REQUEST
   // Injeta token e projectId em todas as requisições
   // ===========================================================================
-  http.interceptors.request.use((config) => {
+  http.interceptors.request.use((reqConfig) => {
     const token = client.getToken();
     if (token) {
-      config.headers.Authorization = `Bearer ${token}`;
+      reqConfig.headers.Authorization = `Bearer ${token}`;
     }
 
     if (client.projectId) {
-      config.headers["X-Project-ID"] = client.projectId;
+      reqConfig.headers["X-Project-ID"] = client.projectId;
+    }
+
+    // Inicializa contador de retry
+    if ((reqConfig as ExtendedAxiosRequestConfig)._retryCount === undefined) {
+      (reqConfig as ExtendedAxiosRequestConfig)._retryCount = 0;
     }
 
-    return config;
+    return reqConfig;
   });
 
   // ===========================================================================
   // INTERCEPTOR DE RESPONSE
-  // Detecta 401 e tenta refresh automático do token
+  // 1. Retry automático para erros de rede/servidor
+  // 2. Refresh automático de token (401)
   // ===========================================================================
   http.interceptors.response.use(
     (response) => response,
     async (error: AxiosError) => {
-      const originalRequest = error.config as InternalAxiosRequestConfig & {
-        _retry?: boolean;
-      };
+      const originalRequest = error.config as ExtendedAxiosRequestConfig;
+
+      if (!originalRequest) {
+        return handleAxiosError(error);
+      }
+
+      // -----------------------------------------------------------------
+      // PARTE 1: RETRY AUTOMÁTICO (erros de rede e servidor)
+      // -----------------------------------------------------------------
+      const retryCount = originalRequest._retryCount || 0;
+      const canRetry = retryCount < config.maxRetries;
+      const isRetryableError = isRetryable(error, config);
+      const isRetryableMethod = isMethodRetryable(originalRequest.method, config);
+
+      // Não faz retry para 401 (tratado pelo refresh token)
+      const is401 = error.response?.status === 401;
+
+      if (canRetry && isRetryableError && isRetryableMethod && !is401) {
+        originalRequest._retryCount = retryCount + 1;
+
+        // Calcula delay (respeita Retry-After se presente)
+        const delay = getRetryAfterMs(error) || calculateDelay(retryCount, config);
+
+        // Callback de retry (para logging/métricas)
+        if (config.onRetry) {
+          config.onRetry(originalRequest._retryCount, error, originalRequest);
+        }
+
+        // Emite evento para monitoramento
+        if (typeof window !== "undefined") {
+          window.dispatchEvent(new CustomEvent("aether:retry", {
+            detail: {
+              attempt: originalRequest._retryCount,
+              maxRetries: config.maxRetries,
+              delay,
+              url: originalRequest.url,
+              method: originalRequest.method,
+              status: error.response?.status,
+              error: error.message,
+            }
+          }));
+        }
+
+        // Log em desenvolvimento
+        if (process.env.NODE_ENV === "development") {
+          console.log(
+            `[Aether SDK] Retry ${originalRequest._retryCount}/${config.maxRetries}`,
+            `em ${delay}ms para ${originalRequest.method} ${originalRequest.url}`,
+            `(${error.response?.status || error.message})`
+          );
+        }
+
+        // Aguarda e refaz a requisição
+        await sleep(delay);
+        return http(originalRequest);
+      }
 
-      // Verifica se é erro 401 (não autorizado) e não é retry
+      // -----------------------------------------------------------------
+      // PARTE 2: REFRESH TOKEN (erro 401)
+      // -----------------------------------------------------------------
       const isUnauthorized = error.response?.status === 401;
-      const isRetry = originalRequest?._retry;
-      const isAuthRoute = originalRequest?.url?.includes("/auth/");
+      const isRetry = originalRequest._retry;
+      const isAuthRoute = originalRequest.url?.includes("/auth/");
 
       // Não tenta refresh se:
       // - Não é 401
-      // - Já é um retry
+      // - Já é um retry de refresh
       // - É 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);
       }
@@ -110,7 +300,6 @@ export function createHttpClient(client: PlataformaClient): AxiosInstance {
       isRefreshing = true;
 
       try {
-        // Chama endpoint de refresh diretamente (sem interceptor)
         const { data } = await axios.post(
           `${client.apiUrl}/v1/auth/refresh`,
           { refreshToken },
@@ -120,24 +309,19 @@ export function createHttpClient(client: PlataformaClient): AxiosInstance {
         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"));
         }

package/src/index.ts

@@ -6,6 +6,7 @@ import { DatabaseModule } from "./database.js";
 import { StorageModule } from "./storage.js";
 import { FunctionsModule } from "./functions.js";
 import { PushModule } from "./push.js";
+import { TenantAuthModule, TenantUser, TenantLoginResponse, TenantRegisterCredentials, TenantLoginCredentials } from "./tenant-auth.js";
 
 // =============================================================================
 // CONSTANTES DE STORAGE
@@ -51,6 +52,7 @@ export class PlataformaClient {
   public storage: StorageModule;
   public functions: FunctionsModule;
   public push: PushModule;
+  public tenantAuth: TenantAuthModule;
 
   // Alias para 'db' que o showcase tenta usar como 'database'
   public database: DatabaseModule;
@@ -90,6 +92,7 @@ export class PlataformaClient {
     this.storage = new StorageModule(this, this.http);
     this.functions = new FunctionsModule(this, this.http);
     this.push = new PushModule(this, this.http);
+    this.tenantAuth = new TenantAuthModule(this, this.http);
 
     // Cria o alias que o Showcase App espera
     this.database = this.db;
@@ -241,4 +244,10 @@ export type {
   PushLogEntry,
   ListPushLogsOptions,
   PushStats,
-} from "./push.js";
+} from "./push.js";
+export type {
+  TenantUser,
+  TenantLoginResponse,
+  TenantRegisterCredentials,
+  TenantLoginCredentials,
+} from "./tenant-auth.js";