@allanfsouza/aether-sdk 1.0.0 → 2.1.0

package/dist/auth.d.ts

@@ -1,32 +1,16 @@
 import type { AxiosInstance } from "axios";
 import type { PlataformaClient } from "./index.js";
-/**
- * Módulo de Autenticação
- * Lida com login, registro e gerenciamento de token.
- */
 export declare class AuthModule {
     private client;
     private http;
     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(email: string, password: string): Promise<any>;
-    /**
-     * Registra um novo usuário e já o loga.
-     * @param credentials Nome, email e senha
-     * @returns O objeto do usuário e o token
-     */
     register(credentials: {
         name: string;
         email: string;
         password: string;
     }): Promise<any>;
-    /**
-     * Desconecta o usuário limpando o token do SDK.
-     */
+    forgotPassword(email: string): Promise<any>;
+    resetPassword(token: string, newPassword: string): Promise<any>;
     logout(): void;
 }

package/dist/auth.js

@@ -1,39 +1,27 @@
-/**
- * Módulo de Autenticação
- * Lida com login, registro e gerenciamento de token.
- */
 export class AuthModule {
     constructor(client, http) {
         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
-     */
     async login(email, password) {
         try {
             const { data } = await this.http.post("/auth/login", { email, password });
-            // Salva o token DENTRO da instância do SDK
-            this.client.setToken(data.token);
-            return data; // Retorna { user, token }
+            if (data.token) {
+                this.client.setToken(data.token);
+            }
+            return data;
         }
         catch (e) {
-            this.client.setToken(null); // Limpa o token em caso de falha
+            this.client.setToken(null);
             throw e;
         }
     }
-    /**
-     * Registra um novo usuário e já o loga.
-     * @param credentials Nome, email e senha
-     * @returns O objeto do usuário e o token
-     */
     async register(credentials) {
         try {
             const { data } = await this.http.post("/auth/register", credentials);
-            this.client.setToken(data.token);
+            if (data.token) {
+                this.client.setToken(data.token);
+            }
             return data;
         }
         catch (e) {
@@ -41,9 +29,14 @@ export class AuthModule {
             throw e;
         }
     }
-    /**
-     * Desconecta o usuário limpando o token do SDK.
-     */
+    async forgotPassword(email) {
+        const { data } = await this.http.post("/auth/forgot-password", { email });
+        return data;
+    }
+    async resetPassword(token, newPassword) {
+        const { data } = await this.http.post("/auth/reset-password", { token, newPassword });
+        return data;
+    }
     logout() {
         this.client.setToken(null);
     }

package/dist/database.d.ts

@@ -1,59 +1,62 @@
 import type { AxiosInstance } from "axios";
 import type { PlataformaClient } from "./index.js";
+export type ListOptions<T> = {
+    filter?: Partial<T>;
+    sort?: {
+        field: keyof T & string;
+        order: "ASC" | "DESC";
+    };
+};
 /**
- * Módulo de Banco de Dados (Firestore-like)
- * Ponto de entrada para acessar as coleções.
+ * Módulo de Banco de Dados
  */
 export declare class DatabaseModule {
     private client;
     private http;
     constructor(client: PlataformaClient, http: AxiosInstance);
     /**
-     * Seleciona uma coleção de dados (ex: 'tasks' ou 'posts').
-     * @param collectionName O nome da coleção (ex: "tasks")
-     * @returns Uma instância de CollectionReference para operar nela
+     * Seleciona uma coleção de dados.
+     * [PREMIUM] Suporta Generics <T> para tipagem forte.
+     * * @example client.db.collection<Product>('products')
      */
-    collection(collectionName: string): CollectionReference;
+    collection<T = any>(collectionName: string): CollectionReference<T>;
 }
 /**
- * Representa uma referência a uma coleção específica no banco.
- * Contém os métodos CRUD (create, list, update, delete) e subscribe.
+ * Referência a uma coleção específica.
+ * O <T> define o formato dos dados (ex: interface User).
  */
-declare class CollectionReference {
+declare class CollectionReference<T> {
     private client;
     private http;
     private collectionName;
     private wsUrl;
     constructor(client: PlataformaClient, http: AxiosInstance, name: string);
     /**
-     * Lista todos os documentos da coleção.
-     * (GET /v1/db/tasks)
+     * Lista documentos da coleção com filtros opcionais.
+     * @param options Filtros e Ordenação
      */
-    list(): Promise<any>;
+    list(options?: ListOptions<T>): Promise<T[]>;
     /**
-     * Cria um novo documento na coleção.
-     * (POST /v1/db/tasks)
-     * @param newData O objeto de dados a ser criado
+     * Busca um documento pelo ID.
      */
-    create(newData: Record<string, any>): Promise<any>;
+    get(id: string): Promise<T>;
+    /**
+     * Cria um novo documento.
+     * O Partial<T> permite criar sem passar campos gerados (como id, createdAt).
+     */
+    create(newData: Partial<T>): Promise<T>;
     /**
      * Atualiza um documento existente.
-     * (PUT /v1/db/tasks/:id)
-     * @param id O ID do documento
-     * @param updates Os campos a serem atualizados
      */
-    update(id: string, updates: Record<string, any>): Promise<any>;
+    update(id: string, updates: Partial<T>): Promise<T>;
     /**
      * Deleta um documento.
-     * (DELETE /v1/db/tasks/:id)
-     * @param id O ID do documento
      */
-    delete(id: string): Promise<any>;
+    delete(id: string): Promise<boolean>;
     /**
-     * Inscreve-se para mudanças em tempo real na coleção.
-     * @param callback A função que será chamada com (action, data)
-     * @returns Uma função 'unsubscribe' para fechar a conexão
+     * Inscreve-se para mudanças em tempo real.
+     * O callback recebe os dados já tipados como T.
      */
-    subscribe(callback: (action: "create" | "update" | "delete", data: any) => void): () => void;
+    subscribe(callback: (action: "create" | "update" | "delete", data: T) => void): () => void;
 }
 export {};

package/dist/database.js

@@ -1,7 +1,6 @@
 import WebSocket from "ws";
 /**
- * Módulo de Banco de Dados (Firestore-like)
- * Ponto de entrada para acessar as coleções.
+ * Módulo de Banco de Dados
  */
 export class DatabaseModule {
     constructor(client, http) {
@@ -9,98 +8,119 @@ export class DatabaseModule {
         this.http = http;
     }
     /**
-     * Seleciona uma coleção de dados (ex: 'tasks' ou 'posts').
-     * @param collectionName O nome da coleção (ex: "tasks")
-     * @returns Uma instância de CollectionReference para operar nela
+     * Seleciona uma coleção de dados.
+     * [PREMIUM] Suporta Generics <T> para tipagem forte.
+     * * @example client.db.collection<Product>('products')
      */
     collection(collectionName) {
         return new CollectionReference(this.client, this.http, collectionName);
     }
 }
 /**
- * Representa uma referência a uma coleção específica no banco.
- * Contém os métodos CRUD (create, list, update, delete) e subscribe.
+ * Referência a uma coleção específica.
+ * O <T> define o formato dos dados (ex: interface User).
  */
 class CollectionReference {
     constructor(client, http, name) {
         this.client = client;
         this.http = http;
         this.collectionName = name;
-        // Constrói a URL do WebSocket (substituindo http por ws)
-        this.wsUrl = client.apiUrl.replace(/^http/, "ws");
+        // Ajusta protocolo para WS/WSS
+        const protocol = client.apiUrl.startsWith("https") ? "wss" : "ws";
+        this.wsUrl = client.apiUrl.replace(/^https?/, protocol);
     }
     /**
-     * Lista todos os documentos da coleção.
-     * (GET /v1/db/tasks)
+     * Lista documentos da coleção com filtros opcionais.
+     * @param options Filtros e Ordenação
      */
-    async list() {
-        const { data } = await this.http.get(`/db/${this.collectionName}`);
-        return data.data; // Retorna o array de documentos
+    async list(options) {
+        const params = {};
+        // Converte os objetos do SDK para strings que o Backend entende
+        if (options?.filter) {
+            params.filter = JSON.stringify(options.filter);
+        }
+        if (options?.sort) {
+            // Backend espera formato array: ["campo", "DESC"]
+            params.sort = JSON.stringify([options.sort.field, options.sort.order]);
+        }
+        const { data } = await this.http.get(`/db/${this.collectionName}`, {
+            params,
+        });
+        return data.data;
+    }
+    /**
+     * Busca um documento pelo ID.
+     */
+    async get(id) {
+        const { data } = await this.http.get(`/db/${this.collectionName}/${id}`);
+        return data.data;
     }
     /**
-     * Cria um novo documento na coleção.
-     * (POST /v1/db/tasks)
-     * @param newData O objeto de dados a ser criado
+     * Cria um novo documento.
+     * O Partial<T> permite criar sem passar campos gerados (como id, createdAt).
      */
     async create(newData) {
         const { data } = await this.http.post(`/db/${this.collectionName}`, newData);
-        return data.data; // Retorna o documento criado
+        return data.data;
     }
     /**
      * Atualiza um documento existente.
-     * (PUT /v1/db/tasks/:id)
-     * @param id O ID do documento
-     * @param updates Os campos a serem atualizados
      */
     async update(id, updates) {
         const { data } = await this.http.put(`/db/${this.collectionName}/${id}`, updates);
-        return data.data; // Retorna o documento atualizado
+        return data.data;
     }
     /**
      * Deleta um documento.
-     * (DELETE /v1/db/tasks/:id)
-     * @param id O ID do documento
      */
     async delete(id) {
-        const { data } = await this.http.delete(`/db/${this.collectionName}/${id}`);
-        return data; // Retorna { ok: true, ... }
+        await this.http.delete(`/db/${this.collectionName}/${id}`);
+        return true;
     }
     /**
-     * Inscreve-se para mudanças em tempo real na coleção.
-     * @param callback A função que será chamada com (action, data)
-     * @returns Uma função 'unsubscribe' para fechar a conexão
+     * Inscreve-se para mudanças em tempo real.
+     * O callback recebe os dados já tipados como T.
      */
     subscribe(callback) {
         const token = this.client.getToken();
         const projectId = this.client.projectId;
         if (!token || !projectId) {
-            throw new Error("Não é possível se inscrever sem um token e projectId.");
+            console.warn("[SDK] Realtime falhou: Token ou ProjectId ausentes.");
+            return () => { };
         }
-        // Constrói a URL: ws://localhost:3000/v1/db/subscribe/tasks?token=...&projectId=...
         const url = `${this.wsUrl}/v1/db/subscribe/${this.collectionName}?token=${token}&projectId=${projectId}`;
-        const ws = new WebSocket(url);
-        ws.on("open", () => {
-            console.log(`[SDK] Inscrito em tempo real na coleção '${this.collectionName}'`);
-        });
-        ws.on("message", (message) => {
-            try {
-                const payload = JSON.parse(message);
-                // Chama o callback do usuário
-                callback(payload.action, payload.data);
-            }
-            catch (e) {
-                console.error("[SDK] Erro ao processar mensagem WS:", e);
-            }
-        });
-        ws.on("close", () => {
-            console.log(`[SDK] Desconectado da coleção '${this.collectionName}'`);
-        });
-        ws.on("error", (err) => {
-            console.error("[SDK] Erro no WebSocket:", err.message);
-        });
-        // Retorna uma função que o usuário pode chamar para parar de "ouvir"
-        return () => {
-            ws.close();
-        };
+        let ws = null;
+        try {
+            ws = new WebSocket(url);
+            ws.onopen = () => {
+                // Conectado
+            };
+            ws.onmessage = (event) => {
+                try {
+                    const raw = event.data?.toString() || event.toString();
+                    if (raw === "pong")
+                        return;
+                    const payload = JSON.parse(raw);
+                    callback(payload.action, payload.data);
+                }
+                catch (e) {
+                    // Erro silencioso de parse
+                }
+            };
+            // Mantém a conexão viva (Heartbeat)
+            const pingInterval = setInterval(() => {
+                if (ws?.readyState === WebSocket.OPEN)
+                    ws.send("ping");
+            }, 30000);
+            return () => {
+                clearInterval(pingInterval);
+                if (ws)
+                    ws.close();
+            };
+        }
+        catch (err) {
+            console.error("[SDK] Erro WS:", err);
+            return () => { };
+        }
     }
 }

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

@@ -0,0 +1,8 @@
+import type { AxiosInstance } from "axios";
+import type { PlataformaClient } from "./index.js";
+export declare class FunctionsModule {
+    private client;
+    private http;
+    constructor(client: PlataformaClient, http: AxiosInstance);
+    invoke<T = any>(functionName: string, body?: any, method?: "GET" | "POST" | "PUT" | "DELETE"): Promise<T>;
+}

package/dist/functions.js

@@ -0,0 +1,17 @@
+export class FunctionsModule {
+    constructor(client, http) {
+        this.client = client;
+        this.http = http;
+    }
+    async invoke(functionName, body, method) {
+        const projectId = this.client.projectId;
+        const cleanName = functionName.replace(/^\//, "");
+        const finalMethod = method || (body ? "POST" : "GET");
+        const response = await this.http.request({
+            url: `/functions/http/${projectId}/${cleanName}`,
+            method: finalMethod,
+            data: body,
+        });
+        return response.data;
+    }
+}

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;
 }

package/dist/index.d.ts

@@ -1,18 +1,23 @@
 import { AuthModule } from "./auth.js";
 import { DatabaseModule } from "./database.js";
 import { StorageModule } from "./storage.js";
-type ClientConfig = {
+import { FunctionsModule } from "./functions.js";
+/**
+ * Configuração usada para criar o cliente principal da plataforma.
+ */
+export type ClientConfig = {
     apiUrl: string;
     projectId: string;
 };
 /**
- * O cliente principal da Plataforma API.
- * Ponto de entrada para todos os módulos (Auth, DB, Storage).
+ * O cliente principal da Plataforma API (Aether).
+ * Ponto de entrada para todos os módulos (Auth, DB, Storage, Functions).
  */
 export declare class PlataformaClient {
     auth: AuthModule;
     db: DatabaseModule;
     storage: StorageModule;
+    functions: FunctionsModule;
     apiUrl: string;
     projectId: string;
     private http;
@@ -20,13 +25,14 @@ export declare class PlataformaClient {
     constructor(config: ClientConfig);
     /**
      * Armazena o token de autenticação em memória.
-     * @param token O JWT (ou null para logout)
+     * Chamado automaticamente pelo AuthModule após login/registro.
      */
     setToken(token: string | null): void;
     /**
      * Recupera o token de autenticação atual.
-     * @returns O JWT ou null
+     * Usado pelo http-client para injetar o header Authorization.
      */
     getToken(): string | null;
 }
-export {};
+export { AetherError } from "./errors.js";
+export type { ListOptions } from "./database.js";

package/dist/index.js

@@ -2,9 +2,10 @@ import { createHttpClient } from "./http-client.js";
 import { AuthModule } from "./auth.js";
 import { DatabaseModule } from "./database.js";
 import { StorageModule } from "./storage.js";
+import { FunctionsModule } from "./functions.js";
 /**
- * O cliente principal da Plataforma API.
- * Ponto de entrada para todos os módulos (Auth, DB, Storage).
+ * O cliente principal da Plataforma API (Aether).
+ * Ponto de entrada para todos os módulos (Auth, DB, Storage, Functions).
  */
 export class PlataformaClient {
     constructor(config) {
@@ -12,28 +13,32 @@ export class PlataformaClient {
         if (!config.apiUrl || !config.projectId) {
             throw new Error("apiUrl e projectId são obrigatórios.");
         }
-        this.apiUrl = config.apiUrl.replace(/\/$/, ""); // Remove barra final
+        // Normaliza apiUrl removendo barra final, se houver
+        this.apiUrl = config.apiUrl.replace(/\/$/, "");
         this.projectId = config.projectId;
-        // Inicializa o cliente HTTP (passando 'this', a própria instância)
+        // Inicializa o cliente HTTP (passando a própria instância)
         this.http = createHttpClient(this);
-        // Inicializa os módulos
+        // Inicializa os módulos de alto nível
         this.auth = new AuthModule(this, this.http);
         this.db = new DatabaseModule(this, this.http);
         this.storage = new StorageModule(this, this.http);
+        this.functions = new FunctionsModule(this, this.http);
     }
     // --- Gerenciamento de Token ---
     /**
      * Armazena o token de autenticação em memória.
-     * @param token O JWT (ou null para logout)
+     * Chamado automaticamente pelo AuthModule após login/registro.
      */
     setToken(token) {
         this._token = token;
     }
     /**
      * Recupera o token de autenticação atual.
-     * @returns O JWT ou null
+     * Usado pelo http-client para injetar o header Authorization.
      */
     getToken() {
         return this._token;
     }
 }
+// Re-exports convenientes para quem consome o SDK
+export { AetherError } from "./errors.js";

package/dist/storage.d.ts

@@ -1,20 +1,28 @@
 import type { AxiosInstance } from "axios";
 import type { PlataformaClient } from "./index.js";
-/**
- * Módulo de Storage
- * Lida com upload e download de arquivos.
- */
 export declare class StorageModule {
     private client;
     private http;
     constructor(client: PlataformaClient, http: AxiosInstance);
     /**
-     * Faz o upload de um arquivo para o Storage do projeto.
-     * Isso lida com o fluxo de "presign" (URL assinada) automaticamente.
-     * @param file O objeto 'File' (do navegador) ou um Buffer (do Node.js)
-     * @param fileName O nome do arquivo (ex: "imagem.png")
-     * @param contentType O tipo (ex: "image/png")
-     * @returns O objeto do arquivo criado no banco
+     * Faz o upload de um arquivo.
+     * @param file Arquivo (Browser: File, Node: Buffer)
+     * @param fileName Nome do arquivo (ex: 'foto.jpg')
+     * @param contentType MIME Type (ex: 'image/jpeg')
+     * @param folder (Opcional) Pasta de destino (ex: 'usuarios/123/')
      */
-    upload(file: File | Buffer, fileName: string, contentType: string): Promise<any>;
+    upload(file: File | Buffer | Blob, fileName: string, contentType: string, folder?: string): Promise<{
+        id: any;
+        key: any;
+        downloadUrl: any;
+        url: any;
+    }>;
+    /**
+     * Lista arquivos de uma pasta.
+     */
+    list(folder?: string): Promise<any>;
+    /**
+     * Deleta um arquivo pelo ID.
+     */
+    delete(fileId: string): Promise<boolean>;
 }