@allanfsouza/aether-sdk 2.0.0 → 2.2.0

package/dist/auth.d.ts

@@ -1,24 +1,37 @@
 import type { AxiosInstance } from "axios";
 import type { PlataformaClient } from "./index.js";
-/**
- * Módulo de Autenticação
- * Lida com login, registro, gerenciamento de token e recuperação de senha.
- */
+export interface LoginResponse {
+    accessToken: string;
+    refreshToken: string;
+    user: {
+        id: string;
+        name: string;
+        email: string;
+        avatarUrl?: string;
+        role?: string;
+        aetherRole?: string;
+        planCode?: string;
+        emailVerified?: boolean;
+    };
+}
+export interface Session {
+    id: string;
+    userAgent?: string;
+    ip?: string;
+    createdAt: string;
+    expiresAt: string;
+}
 export declare class AuthModule {
     private client;
     private http;
+    private refreshToken;
     constructor(client: PlataformaClient, http: AxiosInstance);
     /**
-     * Autentica um usuário e armazena o token no SDK.
-     * @param email O e-mail do usuário
-     * @param password A senha do usuário
-     * @returns O objeto do usuário e o token
+     * Login com email e senha
      */
-    login(email: string, password: string): Promise<any>;
+    login(email: string, password: string): Promise<LoginResponse>;
     /**
-     * Registra um novo usuário e já realiza o login automaticamente.
-     * @param credentials Nome, email e senha
-     * @returns O objeto do usuário e o token
+     * Registrar novo usuário
      */
     register(credentials: {
         name: string;
@@ -26,20 +39,41 @@ export declare class AuthModule {
         password: string;
     }): Promise<any>;
     /**
-     * Solicita um e-mail de recuperação de senha.
-     * @param email O e-mail da conta
-     * @returns A resposta da API (mensagem de sucesso)
+     * Renovar access token usando refresh token
+     */
+    refresh(): Promise<{
+        accessToken: string;
+    }>;
+    /**
+     * Obter URL de autenticação do Google
+     */
+    getGoogleAuthUrl(): string;
+    /**
+     * Logout da sessão atual
+     */
+    logout(): Promise<void>;
+    /**
+     * Logout de todas as sessões
+     */
+    logoutAll(): Promise<void>;
+    /**
+     * Listar sessões ativas
+     */
+    getSessions(): Promise<Session[]>;
+    /**
+     * Esqueci minha senha
      */
     forgotPassword(email: string): Promise<any>;
     /**
-     * Redefine a senha usando o token recebido por e-mail.
-     * @param token O código/token recebido
-     * @param newPassword A nova senha desejada
-     * @returns A resposta da API (mensagem de sucesso)
+     * Redefinir senha
      */
     resetPassword(token: string, newPassword: string): Promise<any>;
     /**
-     * Desconecta o usuário limpando o token da memória do SDK.
+     * Obter refresh token atual (para armazenamento)
+     */
+    getRefreshToken(): string | null;
+    /**
+     * Definir refresh token (para restaurar sessão)
      */
-    logout(): void;
+    setRefreshToken(token: string | null): void;
 }

package/dist/auth.js

@@ -1,63 +1,115 @@
-/**
- * Módulo de Autenticação
- * Lida com login, registro, gerenciamento de token e recuperação de senha.
- */
 export class AuthModule {
     constructor(client, http) {
+        this.refreshToken = null;
         this.client = client;
         this.http = http;
     }
     /**
-     * Autentica um usuário e armazena o token no SDK.
-     * @param email O e-mail do usuário
-     * @param password A senha do usuário
-     * @returns O objeto do usuário e o token
+     * Login com email e senha
      */
     async login(email, password) {
         try {
-            const { data } = await this.http.post("/auth/login", { email, password });
-            // Salva o token DENTRO da instância do SDK para uso futuro
-            this.client.setToken(data.token);
-            return data; // Retorna { token, user: { ... } }
+            const { data } = await this.http.post("/auth/login", {
+                email,
+                password,
+            });
+            if (data.accessToken) {
+                this.client.setToken(data.accessToken);
+                this.refreshToken = data.refreshToken;
+            }
+            return data;
         }
         catch (e) {
-            this.client.setToken(null); // Limpa o token em caso de falha
+            this.client.setToken(null);
+            this.refreshToken = null;
             throw e;
         }
     }
     /**
-     * Registra um novo usuário e já realiza o login automaticamente.
-     * @param credentials Nome, email e senha
-     * @returns O objeto do usuário e o token
+     * Registrar novo usuário
      */
     async register(credentials) {
         try {
             const { data } = await this.http.post("/auth/register", credentials);
-            // Se o backend retornar o token no registro, já salvamos
-            if (data.token) {
-                this.client.setToken(data.token);
+            return data;
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    /**
+     * Renovar access token usando refresh token
+     */
+    async refresh() {
+        if (!this.refreshToken) {
+            throw new Error("Nenhum refresh token disponível");
+        }
+        try {
+            const { data } = await this.http.post("/auth/refresh", {
+                refreshToken: this.refreshToken,
+            });
+            if (data.accessToken) {
+                this.client.setToken(data.accessToken);
             }
             return data;
         }
         catch (e) {
             this.client.setToken(null);
+            this.refreshToken = null;
             throw e;
         }
     }
     /**
-     * Solicita um e-mail de recuperação de senha.
-     * @param email O e-mail da conta
-     * @returns A resposta da API (mensagem de sucesso)
+     * Obter URL de autenticação do Google
+     */
+    getGoogleAuthUrl() {
+        return `${this.client.apiUrl}/v1/auth/google`;
+    }
+    /**
+     * Logout da sessão atual
+     */
+    async logout() {
+        if (this.refreshToken) {
+            try {
+                await this.http.post("/auth/logout", {
+                    refreshToken: this.refreshToken,
+                });
+            }
+            catch (e) {
+                // Ignora erro de logout
+            }
+        }
+        this.client.setToken(null);
+        this.refreshToken = null;
+    }
+    /**
+     * Logout de todas as sessões
+     */
+    async logoutAll() {
+        try {
+            await this.http.post("/auth/logout-all");
+        }
+        finally {
+            this.client.setToken(null);
+            this.refreshToken = null;
+        }
+    }
+    /**
+     * Listar sessões ativas
+     */
+    async getSessions() {
+        const { data } = await this.http.get("/auth/sessions");
+        return data.sessions;
+    }
+    /**
+     * Esqueci minha senha
      */
     async forgotPassword(email) {
         const { data } = await this.http.post("/auth/forgot-password", { email });
         return data;
     }
     /**
-     * Redefine a senha usando o token recebido por e-mail.
-     * @param token O código/token recebido
-     * @param newPassword A nova senha desejada
-     * @returns A resposta da API (mensagem de sucesso)
+     * Redefinir senha
      */
     async resetPassword(token, newPassword) {
         const { data } = await this.http.post("/auth/reset-password", {
@@ -67,9 +119,15 @@ export class AuthModule {
         return data;
     }
     /**
-     * Desconecta o usuário limpando o token da memória do SDK.
+     * Obter refresh token atual (para armazenamento)
      */
-    logout() {
-        this.client.setToken(null);
+    getRefreshToken() {
+        return this.refreshToken;
+    }
+    /**
+     * Definir refresh token (para restaurar sessão)
+     */
+    setRefreshToken(token) {
+        this.refreshToken = token;
     }
 }

package/dist/database.d.ts

@@ -1,11 +1,85 @@
 import type { AxiosInstance } from "axios";
 import type { PlataformaClient } from "./index.js";
 export type ListOptions<T> = {
-    filter?: Partial<T>;
+    filter?: Partial<T> | Record<string, any>;
     sort?: {
         field: keyof T & string;
         order: "ASC" | "DESC";
     };
+    limit?: number;
+    offset?: number;
+};
+/**
+ * Builder para construção fluente de queries.
+ */
+export declare class QueryBuilder<T> {
+    private collectionRef;
+    private filter;
+    private sort?;
+    private limitVal?;
+    private offsetVal?;
+    constructor(collectionRef: CollectionReference<T>);
+    /**
+     * Adiciona um filtro de igualdade.
+     */
+    eq(column: keyof T & string, value: any): this;
+    /**
+     * Adiciona um filtro de desigualdade ($ne).
+     */
+    neq(column: keyof T & string, value: any): this;
+    /**
+     * Adiciona um filtro maior que ($gt).
+     */
+    gt(column: keyof T & string, value: number | string): this;
+    /**
+     * Adiciona um filtro maior ou igual ($gte).
+     */
+    gte(column: keyof T & string, value: number | string): this;
+    /**
+     * Adiciona um filtro menor que ($lt).
+     */
+    lt(column: keyof T & string, value: number | string): this;
+    /**
+     * Adiciona um filtro menor ou igual ($lte).
+     */
+    lte(column: keyof T & string, value: number | string): this;
+    /**
+     * Adiciona um filtro LIKE ($like).
+     */
+    like(column: keyof T & string, value: string): this;
+    /**
+     * Define a ordenação.
+     */
+    order(column: keyof T & string, direction?: "ASC" | "DESC"): this;
+    /**
+     * Define o limite de registros.
+     */
+    limit(count: number): this;
+    /**
+     * Define o deslocamento (paginação).
+     */
+    offset(count: number): this;
+    /**
+     * Executa a query e retorna os resultados.
+     */
+    get(): Promise<T[]>;
+}
+/**
+ * Operação em lote.
+ */
+export type BatchOperation = {
+    type: "create";
+    collection: string;
+    data: any;
+} | {
+    type: "update";
+    collection: string;
+    id: string;
+    data: any;
+} | {
+    type: "delete";
+    collection: string;
+    id: string;
 };
 /**
  * Módulo de Banco de Dados
@@ -20,17 +94,36 @@ export declare class DatabaseModule {
      * * @example client.db.collection<Product>('products')
      */
     collection<T = any>(collectionName: string): CollectionReference<T>;
+    /**
+     * Executa múltiplas operações em uma única transação.
+     * Se uma falhar, todas são revertidas.
+     */
+    batch(operations: BatchOperation[]): Promise<any[]>;
 }
 /**
  * Referência a uma coleção específica.
  * O <T> define o formato dos dados (ex: interface User).
  */
-declare class CollectionReference<T> {
+export declare class CollectionReference<T> {
     private client;
     private http;
     private collectionName;
     private wsUrl;
     constructor(client: PlataformaClient, http: AxiosInstance, name: string);
+    /**
+     * Inicia o QueryBuilder.
+     * Atalho para .eq()
+     */
+    eq(column: keyof T & string, value: any): QueryBuilder<T>;
+    /**
+     * Inicia o QueryBuilder.
+     * Atalho para .gt()
+     */
+    gt(column: keyof T & string, value: number | string): QueryBuilder<T>;
+    /**
+     * Retorna uma nova instância do QueryBuilder.
+     */
+    query(): QueryBuilder<T>;
     /**
      * Lista documentos da coleção com filtros opcionais.
      * @param options Filtros e Ordenação
@@ -59,4 +152,3 @@ declare class CollectionReference<T> {
      */
     subscribe(callback: (action: "create" | "update" | "delete", data: T) => void): () => void;
 }
-export {};

package/dist/database.js

@@ -1,4 +1,94 @@
 import WebSocket from "ws";
+/**
+ * Builder para construção fluente de queries.
+ */
+export class QueryBuilder {
+    constructor(collectionRef) {
+        this.filter = {};
+        this.collectionRef = collectionRef;
+    }
+    /**
+     * Adiciona um filtro de igualdade.
+     */
+    eq(column, value) {
+        this.filter[column] = value;
+        return this;
+    }
+    /**
+     * Adiciona um filtro de desigualdade ($ne).
+     */
+    neq(column, value) {
+        this.filter[column] = { ...this.filter[column], $ne: value };
+        return this;
+    }
+    /**
+     * Adiciona um filtro maior que ($gt).
+     */
+    gt(column, value) {
+        this.filter[column] = { ...this.filter[column], $gt: value };
+        return this;
+    }
+    /**
+     * Adiciona um filtro maior ou igual ($gte).
+     */
+    gte(column, value) {
+        this.filter[column] = { ...this.filter[column], $gte: value };
+        return this;
+    }
+    /**
+     * Adiciona um filtro menor que ($lt).
+     */
+    lt(column, value) {
+        this.filter[column] = { ...this.filter[column], $lt: value };
+        return this;
+    }
+    /**
+     * Adiciona um filtro menor ou igual ($lte).
+     */
+    lte(column, value) {
+        this.filter[column] = { ...this.filter[column], $lte: value };
+        return this;
+    }
+    /**
+     * Adiciona um filtro LIKE ($like).
+     */
+    like(column, value) {
+        this.filter[column] = { ...this.filter[column], $like: value };
+        return this;
+    }
+    /**
+     * Define a ordenação.
+     */
+    order(column, direction = "ASC") {
+        this.sort = { field: column, order: direction };
+        return this;
+    }
+    /**
+     * Define o limite de registros.
+     */
+    limit(count) {
+        this.limitVal = count;
+        return this;
+    }
+    /**
+     * Define o deslocamento (paginação).
+     */
+    offset(count) {
+        this.offsetVal = count;
+        return this;
+    }
+    /**
+     * Executa a query e retorna os resultados.
+     */
+    async get() {
+        return this.collectionRef.list({
+            filter: this.filter,
+            sort: this.sort,
+            limit: this.limitVal,
+            offset: this.offsetVal,
+        });
+    }
+}
 /**
  * Módulo de Banco de Dados
  */
@@ -15,12 +105,20 @@ export class DatabaseModule {
     collection(collectionName) {
         return new CollectionReference(this.client, this.http, collectionName);
     }
+    /**
+     * Executa múltiplas operações em uma única transação.
+     * Se uma falhar, todas são revertidas.
+     */
+    async batch(operations) {
+        const { data } = await this.http.post("/db/batch", { operations });
+        return data.results;
+    }
 }
 /**
  * Referência a uma coleção específica.
  * O <T> define o formato dos dados (ex: interface User).
  */
-class CollectionReference {
+export class CollectionReference {
     constructor(client, http, name) {
         this.client = client;
         this.http = http;
@@ -29,6 +127,27 @@ class CollectionReference {
         const protocol = client.apiUrl.startsWith("https") ? "wss" : "ws";
         this.wsUrl = client.apiUrl.replace(/^https?/, protocol);
     }
+    /**
+     * Inicia o QueryBuilder.
+     * Atalho para .eq()
+     */
+    eq(column, value) {
+        return new QueryBuilder(this).eq(column, value);
+    }
+    /**
+     * Inicia o QueryBuilder.
+     * Atalho para .gt()
+     */
+    gt(column, value) {
+        return new QueryBuilder(this).gt(column, value);
+    }
+    // ... Outros atalhos podem ser adicionados conforme necessidade ...
+    /**
+     * Retorna uma nova instância do QueryBuilder.
+     */
+    query() {
+        return new QueryBuilder(this);
+    }
     /**
      * Lista documentos da coleção com filtros opcionais.
      * @param options Filtros e Ordenação
@@ -43,6 +162,9 @@ class CollectionReference {
             // Backend espera formato array: ["campo", "DESC"]
             params.sort = JSON.stringify([options.sort.field, options.sort.order]);
         }
+        // TODO: Backend precisa implementar limit/offset na rota GET
+        // if (options?.limit) params.limit = options.limit;
+        // if (options?.offset) params.offset = options.offset;
         const { data } = await this.http.get(`/db/${this.collectionName}`, {
             params,
         });

package/dist/errors.d.ts

@@ -0,0 +1,12 @@
+export declare class AetherError extends Error {
+    code: string;
+    message: string;
+    status?: number | undefined;
+    details?: any | undefined;
+    constructor(code: string, message: string, status?: number | undefined, details?: any | undefined);
+}
+/**
+ * Converte qualquer erro vindo do Axios em um AetherError padronizado.
+ * Essa função é pensada para ser usada no interceptor de responses.
+ */
+export declare function handleAxiosError(error: any): never;

package/dist/errors.js

@@ -0,0 +1,42 @@
+// src/errors.ts
+export class AetherError extends Error {
+    constructor(code, message, status, details) {
+        super(message);
+        this.code = code;
+        this.message = message;
+        this.status = status;
+        this.details = details;
+        this.name = "AetherError";
+        // Garante que instanceof AetherError funcione mesmo em cenários com transpile/bundler
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+/**
+ * Converte qualquer erro vindo do Axios em um AetherError padronizado.
+ * Essa função é pensada para ser usada no interceptor de responses.
+ */
+export function handleAxiosError(error) {
+    // Erro com resposta do servidor (4xx, 5xx)
+    if (error && error.response) {
+        const data = error.response.data;
+        const message = data?.error || data?.message || "Erro desconhecido na API";
+        const status = error.response.status;
+        let code = "api_error";
+        if (status === 401)
+            code = "unauthorized";
+        if (status === 403)
+            code = "permission_denied";
+        if (status === 404)
+            code = "not_found";
+        if (status === 429)
+            code = "rate_limit_exceeded";
+        throw new AetherError(code, message, status, data);
+    }
+    // Erro de rede (sem resposta do servidor)
+    if (error && error.request && !error.response) {
+        throw new AetherError("network_error", "Não foi possível conectar ao servidor Aether.", 0);
+    }
+    // Erro de configuração / código do cliente
+    const fallbackMessage = (error && error.message) || "Erro interno no cliente SDK.";
+    throw new AetherError("client_error", fallbackMessage);
+}

package/dist/functions.d.ts

@@ -4,11 +4,5 @@ export declare class FunctionsModule {
     private client;
     private http;
     constructor(client: PlataformaClient, http: AxiosInstance);
-    /**
-     * Chama uma função HTTP Serverless.
-     * @param functionName O nome da função (ou rota, ex: 'pedidos/123')
-     * @param body (Opcional) Dados para enviar no corpo (POST)
-     * @param method (Opcional) Método HTTP (padrão POST se tiver body, GET se não)
-     */
     invoke<T = any>(functionName: string, body?: any, method?: "GET" | "POST" | "PUT" | "DELETE"): Promise<T>;
 }

package/dist/functions.js

@@ -3,17 +3,9 @@ export class FunctionsModule {
         this.client = client;
         this.http = http;
     }
-    /**
-     * Chama uma função HTTP Serverless.
-     * @param functionName O nome da função (ou rota, ex: 'pedidos/123')
-     * @param body (Opcional) Dados para enviar no corpo (POST)
-     * @param method (Opcional) Método HTTP (padrão POST se tiver body, GET se não)
-     */
     async invoke(functionName, body, method) {
         const projectId = this.client.projectId;
-        // Remove barras iniciais para evitar URL malformada
         const cleanName = functionName.replace(/^\//, "");
-        // Define método automaticamente se não informado
         const finalMethod = method || (body ? "POST" : "GET");
         const response = await this.http.request({
             url: `/functions/http/${projectId}/${cleanName}`,

package/dist/http-client.d.ts

@@ -1,10 +1,8 @@
 import { type AxiosInstance } from "axios";
-import { PlataformaClient } from "./index.js";
+import type { PlataformaClient } from "./index.js";
 /**
  * Cria uma instância do Axios pré-configurada.
- * Ela usa um interceptor para adicionar dinamicamente os
- * headers 'Authorization' e 'X-Project-ID' em cada requisição.
- * * @param client A instância principal do PlataformaClient
- * @returns Uma instância configurada do Axios
+ * - Injeta automaticamente headers de Auth e Projeto.
+ * - Converte erros em AetherError.
  */
 export declare function createHttpClient(client: PlataformaClient): AxiosInstance;

package/dist/http-client.js

@@ -1,27 +1,31 @@
 // src/http-client.ts
 import axios from "axios";
+import { handleAxiosError } from "./errors.js";
 /**
  * Cria uma instância do Axios pré-configurada.
- * Ela usa um interceptor para adicionar dinamicamente os
- * headers 'Authorization' e 'X-Project-ID' em cada requisição.
- * * @param client A instância principal do PlataformaClient
- * @returns Uma instância configurada do Axios
+ * - Injeta automaticamente headers de Auth e Projeto.
+ * - Converte erros em AetherError.
  */
 export function createHttpClient(client) {
     const http = axios.create({
-        baseURL: `${client.apiUrl}/v1`, // Adiciona o /v1 automaticamente
+        // Adiciona o /v1 automaticamente em todas as chamadas do SDK
+        baseURL: `${client.apiUrl}/v1`,
+        headers: {
+            "Content-Type": "application/json",
+        },
     });
+    // Interceptor de REQUEST
     http.interceptors.request.use((config) => {
-        // 1. Pega o token atual do cliente
         const token = client.getToken();
         if (token) {
             config.headers.Authorization = `Bearer ${token}`;
         }
-        // 2. Pega o ID do projeto
         if (client.projectId) {
             config.headers["X-Project-ID"] = client.projectId;
         }
         return config;
     });
+    // Interceptor de RESPONSE
+    http.interceptors.response.use((response) => response, (error) => handleAxiosError(error));
     return http;
 }