@allanfsouza/aether-sdk 2.4.6 → 2.4.9

package/dist/http-client.d.ts

@@ -1,9 +1,27 @@
-import { type AxiosInstance } from "axios";
+import { type AxiosInstance, type AxiosError, type AxiosRequestConfig } from "axios";
 import type { PlataformaClient } from "./index.js";
+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 declare const DEFAULT_RETRY_CONFIG: RetryConfig;
 /**
- * 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 declare function createHttpClient(client: PlataformaClient): AxiosInstance;
+export declare function createHttpClient(client: PlataformaClient, retryConfig?: Partial<RetryConfig>): AxiosInstance;

package/dist/http-client.js

@@ -1,13 +1,88 @@
 // src/http-client.ts
+// [MELHORIA] SDK com Retry Automático e Exponential Backoff
+// Data: 09/12/2025
 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 = [];
+export const DEFAULT_RETRY_CONFIG = {
+    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, config) {
+    // 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, config) {
+    // 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;
+        }
+    }
+    // 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, config) {
+    if (!method)
+        return false;
+    return config.retryableMethods.includes(method.toUpperCase());
+}
+/**
+ * Extrai Retry-After header (em ms)
+ */
+function getRetryAfterMs(error) {
+    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;
+}
 /**
- * Processa a fila de requisições após o refresh.
+ * Aguarda um tempo determinado
  */
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+// =============================================================================
+// FLAGS GLOBAIS (Refresh Token)
+// =============================================================================
+let isRefreshing = false;
+let failedQueue = [];
 const processQueue = (error, token = null) => {
     failedQueue.forEach((prom) => {
         if (error) {
@@ -19,15 +94,21 @@ const processQueue = (error, token = null) => {
     });
     failedQueue = [];
 };
+// =============================================================================
+// 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) {
+export function createHttpClient(client, retryConfig = {}) {
+    const config = { ...DEFAULT_RETRY_CONFIG, ...retryConfig };
     const http = axios.create({
         baseURL: `${client.apiUrl}/v1`,
+        timeout: 30000, // 30 segundos
         headers: {
             "Content-Type": "application/json",
         },
@@ -36,37 +117,84 @@ export function createHttpClient(client) {
     // 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._retryCount === undefined) {
+            reqConfig._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) => {
         const originalRequest = error.config;
-        // Verifica se é erro 401 (não autorizado) e não é retry
+        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);
+        }
+        // -----------------------------------------------------------------
+        // 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);
         }
@@ -85,26 +213,20 @@ export function createHttpClient(client) {
         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"));
             }

package/dist/index.d.ts

@@ -4,6 +4,7 @@ import { DatabaseModule } from "./database.js";
 import { StorageModule } from "./storage.js";
 import { FunctionsModule } from "./functions.js";
 import { PushModule } from "./push.js";
+import { TenantAuthModule } from "./tenant-auth.js";
 /**
  * Configuração usada para criar o cliente principal da plataforma.
  */
@@ -24,6 +25,7 @@ export declare class PlataformaClient {
     storage: StorageModule;
     functions: FunctionsModule;
     push: PushModule;
+    tenantAuth: TenantAuthModule;
     database: DatabaseModule;
     apiUrl: string;
     projectId: string;
@@ -76,3 +78,4 @@ export { AetherError } from "./errors.js";
 export type { LoginResponse, Session, User } from "./auth.js";
 export type { ListOptions } from "./database.js";
 export type { PushPlatform, PushEnvironment, PushDevice, RegisterDeviceParams, SendPushResponse, PushStatus, PushLogEntry, ListPushLogsOptions, PushStats, } from "./push.js";
+export type { TenantUser, TenantLoginResponse, TenantRegisterCredentials, TenantLoginCredentials, } from "./tenant-auth.js";

package/dist/index.js

@@ -4,6 +4,7 @@ import { DatabaseModule } from "./database.js";
 import { StorageModule } from "./storage.js";
 import { FunctionsModule } from "./functions.js";
 import { PushModule } from "./push.js";
+import { TenantAuthModule } from "./tenant-auth.js";
 // =============================================================================
 // CONSTANTES DE STORAGE
 // Chaves padronizadas para localStorage - evita conflito com outros SDKs
@@ -44,6 +45,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;
     }

package/dist/tenant-auth.d.ts

@@ -0,0 +1,172 @@
+import type { AxiosInstance } from "axios";
+import type { PlataformaClient } from "./index.js";
+/**
+ * Representa um usuário tenant (end-user de um projeto)
+ */
+export interface TenantUser {
+    id: string;
+    email: string;
+    name: string;
+    data: Record<string, any>;
+    emailVerified: boolean;
+    status: "active" | "suspended" | string;
+    createdAt: string;
+}
+/**
+ * Resposta de login do tenant
+ */
+export interface TenantLoginResponse {
+    accessToken: string;
+    user: TenantUser;
+}
+/**
+ * Credenciais para registro de tenant
+ */
+export interface TenantRegisterCredentials {
+    email: string;
+    password: string;
+    name?: string;
+    data?: Record<string, any>;
+}
+/**
+ * Credenciais para login de tenant
+ */
+export interface TenantLoginCredentials {
+    email: string;
+    password: string;
+}
+/**
+ * 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 declare class TenantAuthModule {
+    private client;
+    private http;
+    private currentToken;
+    private currentUser;
+    constructor(client: PlataformaClient, http: AxiosInstance);
+    /**
+     * 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
+     */
+    register(projectId: string, credentials: TenantRegisterCredentials): Promise<{
+        user: TenantUser;
+        message: string;
+    }>;
+    /**
+     * 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
+     */
+    login(projectId: string, credentials: TenantLoginCredentials): Promise<TenantLoginResponse>;
+    /**
+     * 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
+     */
+    forgotPassword(projectId: string, email: string): Promise<{
+        message: string;
+    }>;
+    /**
+     * 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
+     */
+    resetPassword(projectId: string, email: string, token: string, newPassword: string): Promise<{
+        message: string;
+    }>;
+    /**
+     * 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)
+     */
+    getProfile(projectId?: string): Promise<TenantUser>;
+    /**
+     * Atualiza o perfil do usuário autenticado.
+     *
+     * @param projectId - ID do projeto
+     * @param updates - Campos a atualizar (name, data)
+     */
+    updateProfile(projectId: string, updates: {
+        name?: string;
+        data?: Record<string, any>;
+    }): Promise<{
+        user: TenantUser;
+        message: string;
+    }>;
+    /**
+     * Faz logout do tenant (limpa token local).
+     */
+    logout(): void;
+    /**
+     * Alias para register com retorno { user, error }
+     */
+    signUp(projectId: string, credentials: TenantRegisterCredentials): Promise<{
+        user: TenantUser | null;
+        error: string | null;
+    }>;
+    /**
+     * Alias para login com retorno { user, accessToken, error }
+     */
+    signIn(projectId: string, credentials: TenantLoginCredentials): Promise<{
+        user: TenantUser | null;
+        accessToken: string | null;
+        error: string | null;
+    }>;
+    /**
+     * Alias para logout
+     */
+    signOut(): void;
+    /**
+     * Retorna o token atual do tenant
+     */
+    getToken(): string | null;
+    /**
+     * Define o token do tenant (útil para restaurar sessão)
+     */
+    setToken(token: string | null): void;
+    /**
+     * Retorna o usuário atual do tenant
+     */
+    getCurrentUser(): TenantUser | null;
+    /**
+     * Verifica se há um usuário autenticado
+     */
+    isAuthenticated(): boolean;
+}