@allanfsouza/aether-sdk 1.0.0 → 2.0.0

package/dist/auth.d.ts

@@ -2,7 +2,7 @@ import type { AxiosInstance } from "axios";
 import type { PlataformaClient } from "./index.js";
 /**
  * Módulo de Autenticação
- * Lida com login, registro e gerenciamento de token.
+ * Lida com login, registro, gerenciamento de token e recuperação de senha.
  */
 export declare class AuthModule {
     private client;
@@ -16,7 +16,7 @@ export declare class AuthModule {
      */
     login(email: string, password: string): Promise<any>;
     /**
-     * Registra um novo usuário e já o loga.
+     * 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
      */
@@ -26,7 +26,20 @@ export declare class AuthModule {
         password: string;
     }): Promise<any>;
     /**
-     * Desconecta o usuário limpando o token do SDK.
+     * Solicita um e-mail de recuperação de senha.
+     * @param email O e-mail da conta
+     * @returns A resposta da API (mensagem de sucesso)
+     */
+    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)
+     */
+    resetPassword(token: string, newPassword: string): Promise<any>;
+    /**
+     * Desconecta o usuário limpando o token da memória do SDK.
      */
     logout(): void;
 }

package/dist/auth.js

@@ -1,6 +1,6 @@
 /**
  * Módulo de Autenticação
- * Lida com login, registro e gerenciamento de token.
+ * Lida com login, registro, gerenciamento de token e recuperação de senha.
  */
 export class AuthModule {
     constructor(client, http) {
@@ -16,9 +16,9 @@ export class AuthModule {
     async login(email, password) {
         try {
             const { data } = await this.http.post("/auth/login", { email, password });
-            // Salva o token DENTRO da instância do SDK
+            // Salva o token DENTRO da instância do SDK para uso futuro
             this.client.setToken(data.token);
-            return data; // Retorna { user, token }
+            return data; // Retorna { token, user: { ... } }
         }
         catch (e) {
             this.client.setToken(null); // Limpa o token em caso de falha
@@ -26,14 +26,17 @@ export class AuthModule {
         }
     }
     /**
-     * Registra um novo usuário e já o loga.
+     * 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
      */
     async register(credentials) {
         try {
             const { data } = await this.http.post("/auth/register", credentials);
-            this.client.setToken(data.token);
+            // Se o backend retornar o token no registro, já salvamos
+            if (data.token) {
+                this.client.setToken(data.token);
+            }
             return data;
         }
         catch (e) {
@@ -42,7 +45,29 @@ export class AuthModule {
         }
     }
     /**
-     * Desconecta o usuário limpando o token do SDK.
+     * Solicita um e-mail de recuperação de senha.
+     * @param email O e-mail da conta
+     * @returns A resposta da API (mensagem de sucesso)
+     */
+    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)
+     */
+    async resetPassword(token, newPassword) {
+        const { data } = await this.http.post("/auth/reset-password", {
+            token,
+            newPassword,
+        });
+        return data;
+    }
+    /**
+     * Desconecta o usuário limpando o token da memória do SDK.
      */
     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/functions.d.ts

@@ -0,0 +1,14 @@
+import type { AxiosInstance } from "axios";
+import type { PlataformaClient } from "./index.js";
+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

@@ -0,0 +1,25 @@
+export class FunctionsModule {
+    constructor(client, http) {
+        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}`,
+            method: finalMethod,
+            data: body,
+        });
+        return response.data;
+    }
+}

package/dist/index.d.ts

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

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"; // [NOVO] Import do módulo
 /**
  * O cliente principal da Plataforma API.
- * Ponto de entrada para todos os módulos (Auth, DB, Storage).
+ * Ponto de entrada para todos os módulos (Auth, DB, Storage, Functions).
  */
 export class PlataformaClient {
     constructor(config) {
@@ -12,18 +13,20 @@ 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
+        this.apiUrl = config.apiUrl.replace(/\/$/, ""); // Remove barra final se houver
         this.projectId = config.projectId;
-        // Inicializa o cliente HTTP (passando 'this', a própria instância)
+        // Inicializa o cliente HTTP (passando 'this', a própria instância para injetar token/ID)
         this.http = createHttpClient(this);
-        // Inicializa os módulos
+        // Inicializa os módulos passando a referência do cliente e do axios
         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); // [NOVO] Inicialização
     }
     // --- Gerenciamento de Token ---
     /**
      * Armazena o token de autenticação em memória.
+     * Chamado automaticamente pelo AuthModule após login.
      * @param token O JWT (ou null para logout)
      */
     setToken(token) {
@@ -31,6 +34,7 @@ export class PlataformaClient {
     }
     /**
      * Recupera o token de autenticação atual.
+     * Usado pelo http-client para injetar o header Authorization.
      * @returns O JWT ou null
      */
     getToken() {

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

package/dist/storage.js

@@ -1,40 +1,65 @@
-import axios from "axios"; // [A CORREÇÃO ESTÁ AQUI]
-/**
- * Módulo de Storage
- * Lida com upload e download de arquivos.
- */
+import axios from "axios";
 export class StorageModule {
     constructor(client, http) {
         this.client = client;
         this.http = http;
     }
     /**
-     * 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/')
      */
-    async upload(file, fileName, contentType) {
-        const size = file.size || file.length;
-        // 1. Pedir a URL de upload para nossa API
+    async upload(file, fileName, contentType, folder // [NOVO]
+    ) {
+        // Calcula tamanho de forma segura para Browser e Node
+        let size = 0;
+        if (typeof File !== "undefined" && file instanceof File) {
+            size = file.size;
+        }
+        else if (typeof Blob !== "undefined" && file instanceof Blob) {
+            size = file.size;
+        }
+        else if (file instanceof Buffer) {
+            // Node.js
+            size = file.length;
+        }
+        // 1. Pedir URL assinada
         const { data: presignData } = await this.http.post("/storage/presign", {
-            fileName: fileName,
-            contentType: contentType,
-            size: size,
+            fileName,
+            contentType,
+            size,
+            prefix: folder || "", // [NOVO] Envia o prefixo para o backend
         });
-        // O 'presign' vem dentro de 'data'
         const presign = presignData.data;
-        if (!presign?.url) {
-            throw new Error("API não retornou uma URL de upload assinada.");
-        }
-        // 2. Enviar o arquivo diretamente para o Minio/S3 (sem auth)
-        //    Usamos o 'axios' global aqui, não o 'this.http' (que adicionaria auth)
+        if (!presign?.url)
+            throw new Error("Falha ao obter URL de upload.");
+        // 2. Upload direto para S3
         await axios.put(presign.url, file, {
             headers: { "Content-Type": contentType },
         });
-        // 3. Retorna os detalhes do objeto (downloadUrl, objectId, etc.)
-        return presign;
+        return {
+            id: presign.objectId,
+            key: presign.key,
+            downloadUrl: presign.downloadUrl,
+            url: presign.downloadUrl, // Alias amigável
+        };
+    }
+    /**
+     * Lista arquivos de uma pasta.
+     */
+    async list(folder = "") {
+        const { data } = await this.http.get("/storage/list", {
+            params: { projectId: this.client.projectId, prefix: folder },
+        });
+        return data.data; // Retorna { files: [], folders: [] }
+    }
+    /**
+     * Deleta um arquivo pelo ID.
+     */
+    async delete(fileId) {
+        await this.http.delete("/storage/delete", { data: { objectId: fileId } });
+        return true;
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allanfsouza/aether-sdk",
-  "version": "1.0.0",
+  "version": "2.0.0",
   "description": "SDK do Cliente para a Plataforma API",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/auth.ts

@@ -4,7 +4,7 @@ import type { PlataformaClient } from "./index.js";
 
 /**
  * Módulo de Autenticação
- * Lida com login, registro e gerenciamento de token.
+ * Lida com login, registro, gerenciamento de token e recuperação de senha.
  */
 export class AuthModule {
   private client: PlataformaClient;
@@ -24,9 +24,9 @@ export class AuthModule {
   async login(email: string, password: string) {
     try {
       const { data } = await this.http.post("/auth/login", { email, password });
-      // Salva o token DENTRO da instância do SDK
+      // Salva o token DENTRO da instância do SDK para uso futuro
       this.client.setToken(data.token);
-      return data; // Retorna { user, token }
+      return data; // Retorna { token, user: { ... } }
     } catch (e: unknown) {
       this.client.setToken(null); // Limpa o token em caso de falha
       throw e;
@@ -34,7 +34,7 @@ export class AuthModule {
   }
 
   /**
-   * Registra um novo usuário e já o loga.
+   * 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
    */
@@ -45,7 +45,10 @@ export class AuthModule {
   }) {
     try {
       const { data } = await this.http.post("/auth/register", credentials);
-      this.client.setToken(data.token);
+      // Se o backend retornar o token no registro, já salvamos
+      if (data.token) {
+        this.client.setToken(data.token);
+      }
       return data;
     } catch (e: unknown) {
       this.client.setToken(null);
@@ -54,7 +57,31 @@ export class AuthModule {
   }
 
   /**
-   * Desconecta o usuário limpando o token do SDK.
+   * Solicita um e-mail de recuperação de senha.
+   * @param email O e-mail da conta
+   * @returns A resposta da API (mensagem de sucesso)
+   */
+  async forgotPassword(email: string) {
+    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)
+   */
+  async resetPassword(token: string, newPassword: string) {
+    const { data } = await this.http.post("/auth/reset-password", {
+      token,
+      newPassword,
+    });
+    return data;
+  }
+
+  /**
+   * Desconecta o usuário limpando o token da memória do SDK.
    */
   logout() {
     this.client.setToken(null);

package/src/database.ts

@@ -4,15 +4,25 @@ import type { PlataformaClient } from "./index.js";
 import WebSocket from "ws";
 
 // Tipo para a mensagem que recebemos do WebSocket
-type WebSocketMessage = {
+type WebSocketMessage<T = any> = {
   action: "create" | "update" | "delete";
   collection: string;
-  data: any;
+  data: T;
+};
+
+// [NOVO] Opções de Listagem Avançada
+export type ListOptions<T> = {
+  // Filtro parcial (ex: { status: 'active' })
+  filter?: Partial<T>;
+  // Ordenação
+  sort?: {
+    field: keyof T & string; // Garante que o campo existe no tipo T
+    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 class DatabaseModule {
   private client: PlataformaClient;
@@ -24,20 +34,20 @@ export class DatabaseModule {
   }
 
   /**
-   * 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) {
-    return new CollectionReference(this.client, this.http, collectionName);
+  collection<T = any>(collectionName: string) {
+    return new CollectionReference<T>(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 {
+class CollectionReference<T> {
   private client: PlataformaClient;
   private http: AxiosInstance;
   private collectionName: string;
@@ -47,103 +57,123 @@ class CollectionReference {
     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 documentos da coleção com filtros opcionais.
+   * @param options Filtros e Ordenação
+   */
+  async list(options?: ListOptions<T>): Promise<T[]> {
+    const params: any = {};
+
+    // 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;
   }
 
   /**
-   * Lista todos os documentos da coleção.
-   * (GET /v1/db/tasks)
+   * Busca um documento pelo ID.
    */
-  async list() {
-    const { data } = await this.http.get(`/db/${this.collectionName}`);
-    return data.data; // Retorna o array de documentos
+  async get(id: string): Promise<T> {
+    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: Record<string, any>) {
+  async create(newData: Partial<T>): Promise<T> {
     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: string, updates: Record<string, any>) {
+  async update(id: string, updates: Partial<T>): Promise<T> {
     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: string) {
-    const { data } = await this.http.delete(`/db/${this.collectionName}/${id}`);
-    return data; // Retorna { ok: true, ... }
+  async delete(id: string): Promise<boolean> {
+    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: (action: "create" | "update" | "delete", data: any) => void
+    callback: (action: "create" | "update" | "delete", data: T) => void
   ) {
     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: string) => {
-      try {
-        const payload = JSON.parse(message) as WebSocketMessage;
-        // 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: WebSocket | null = null;
+
+    try {
+      ws = new WebSocket(url);
+
+      ws.onopen = () => {
+        // Conectado
+      };
+
+      ws.onmessage = (event: any) => {
+        try {
+          const raw = event.data?.toString() || event.toString();
+          if (raw === "pong") return;
+
+          const payload = JSON.parse(raw) as WebSocketMessage<T>;
+          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/src/functions.ts

@@ -0,0 +1,41 @@
+// src/functions.ts
+import type { AxiosInstance } from "axios";
+import type { PlataformaClient } from "./index.js";
+
+export class FunctionsModule {
+  private client: PlataformaClient;
+  private http: AxiosInstance;
+
+  constructor(client: PlataformaClient, http: AxiosInstance) {
+    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<T = any>(
+    functionName: string,
+    body?: any,
+    method?: "GET" | "POST" | "PUT" | "DELETE"
+  ) {
+    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<T>({
+      url: `/functions/http/${projectId}/${cleanName}`,
+      method: finalMethod,
+      data: body,
+    });
+
+    return response.data;
+  }
+}

package/src/index.ts

@@ -4,6 +4,7 @@ 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"; // [NOVO] Import do módulo
 
 type ClientConfig = {
   apiUrl: string;
@@ -12,13 +13,14 @@ type ClientConfig = {
 
 /**
  * O cliente principal da Plataforma API.
- * Ponto de entrada para todos os módulos (Auth, DB, Storage).
+ * Ponto de entrada para todos os módulos (Auth, DB, Storage, Functions).
  */
 export class PlataformaClient {
   // Propriedades públicas (os "módulos")
   public auth: AuthModule;
   public db: DatabaseModule;
   public storage: StorageModule;
+  public functions: FunctionsModule; // [NOVO] Propriedade pública
 
   // Propriedades de configuração
   public apiUrl: string;
@@ -32,22 +34,24 @@ 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
+    this.apiUrl = config.apiUrl.replace(/\/$/, ""); // Remove barra final se houver
     this.projectId = config.projectId;
 
-    // Inicializa o cliente HTTP (passando 'this', a própria instância)
+    // Inicializa o cliente HTTP (passando 'this', a própria instância para injetar token/ID)
     this.http = createHttpClient(this);
 
-    // Inicializa os módulos
+    // Inicializa os módulos passando a referência do cliente e do axios
     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); // [NOVO] Inicialização
   }
 
   // --- Gerenciamento de Token ---
 
   /**
    * Armazena o token de autenticação em memória.
+   * Chamado automaticamente pelo AuthModule após login.
    * @param token O JWT (ou null para logout)
    */
   setToken(token: string | null) {
@@ -56,6 +60,7 @@ export class PlataformaClient {
 
   /**
    * Recupera o token de autenticação atual.
+   * Usado pelo http-client para injetar o header Authorization.
    * @returns O JWT ou null
    */
   getToken(): string | null {

package/src/storage.ts

@@ -1,12 +1,8 @@
 // src/storage.ts
 import type { AxiosInstance } from "axios";
 import type { PlataformaClient } from "./index.js";
-import axios from "axios"; // [A CORREÇÃO ESTÁ AQUI]
+import axios from "axios";
 
-/**
- * Módulo de Storage
- * Lida com upload e download de arquivos.
- */
 export class StorageModule {
   private client: PlataformaClient;
   private http: AxiosInstance;
@@ -17,36 +13,68 @@ export class StorageModule {
   }
 
   /**
-   * 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/')
    */
-  async upload(file: File | Buffer, fileName: string, contentType: string) {
-    const size = (file as File).size || (file as Buffer).length;
+  async upload(
+    file: File | Buffer | Blob,
+    fileName: string,
+    contentType: string,
+    folder?: string // [NOVO]
+  ) {
+    // Calcula tamanho de forma segura para Browser e Node
+    let size = 0;
+    if (typeof File !== "undefined" && file instanceof File) {
+      size = file.size;
+    } else if (typeof Blob !== "undefined" && file instanceof Blob) {
+      size = file.size;
+    } else if (file instanceof Buffer) {
+      // Node.js
+      size = file.length;
+    }
 
-    // 1. Pedir a URL de upload para nossa API
+    // 1. Pedir URL assinada
     const { data: presignData } = await this.http.post("/storage/presign", {
-      fileName: fileName,
-      contentType: contentType,
-      size: size,
+      fileName,
+      contentType,
+      size,
+      prefix: folder || "", // [NOVO] Envia o prefixo para o backend
     });
 
-    // O 'presign' vem dentro de 'data'
     const presign = presignData.data;
-    if (!presign?.url) {
-      throw new Error("API não retornou uma URL de upload assinada.");
-    }
+    if (!presign?.url) throw new Error("Falha ao obter URL de upload.");
 
-    // 2. Enviar o arquivo diretamente para o Minio/S3 (sem auth)
-    //    Usamos o 'axios' global aqui, não o 'this.http' (que adicionaria auth)
+    // 2. Upload direto para S3
     await axios.put(presign.url, file, {
       headers: { "Content-Type": contentType },
     });
 
-    // 3. Retorna os detalhes do objeto (downloadUrl, objectId, etc.)
-    return presign;
+    return {
+      id: presign.objectId,
+      key: presign.key,
+      downloadUrl: presign.downloadUrl,
+      url: presign.downloadUrl, // Alias amigável
+    };
+  }
+
+  /**
+   * Lista arquivos de uma pasta.
+   */
+  async list(folder = "") {
+    const { data } = await this.http.get("/storage/list", {
+      params: { projectId: this.client.projectId, prefix: folder },
+    });
+    return data.data; // Retorna { files: [], folders: [] }
+  }
+
+  /**
+   * Deleta um arquivo pelo ID.
+   */
+  async delete(fileId: string) {
+    await this.http.delete("/storage/delete", { data: { objectId: fileId } });
+    return true;
   }
 }