@allanfsouza/aether-sdk 2.0.0 → 2.2.0

package/dist/index.d.ts

@@ -1,36 +1,42 @@
+import type { AxiosInstance } from "axios";
 import { AuthModule } from "./auth.js";
 import { DatabaseModule } from "./database.js";
 import { StorageModule } from "./storage.js";
 import { FunctionsModule } from "./functions.js";
-type ClientConfig = {
+import { PushModule } from "./push.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, Functions).
+ * O cliente principal da Plataforma API (Aether).
+ * Ponto de entrada para todos os módulos (Auth, DB, Storage, Functions, Push).
  */
 export declare class PlataformaClient {
     auth: AuthModule;
     db: DatabaseModule;
     storage: StorageModule;
     functions: FunctionsModule;
+    push: PushModule;
     apiUrl: string;
     projectId: string;
-    private http;
+    http: AxiosInstance;
     private _token;
     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)
+     * Chamado automaticamente pelo AuthModule após login/registro.
      */
     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;
 }
-export {};
+export { AetherError } from "./errors.js";
+export type { ListOptions } from "./database.js";
+export type { PushPlatform, PushEnvironment, PushDevice, RegisterDeviceParams, SendPushResponse, PushStatus, PushLogEntry, ListPushLogsOptions, PushStats, } from "./push.js";

package/dist/index.js

@@ -2,10 +2,11 @@ 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
+import { FunctionsModule } from "./functions.js";
+import { PushModule } from "./push.js";
 /**
- * O cliente principal da Plataforma API.
- * Ponto de entrada para todos os módulos (Auth, DB, Storage, Functions).
+ * O cliente principal da Plataforma API (Aether).
+ * Ponto de entrada para todos os módulos (Auth, DB, Storage, Functions, Push).
  */
 export class PlataformaClient {
     constructor(config) {
@@ -13,21 +14,22 @@ 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 se houver
+        // Normaliza apiUrl removendo barras finais, se houver
+        this.apiUrl = config.apiUrl.replace(/\/+$/, "");
         this.projectId = config.projectId;
-        // Inicializa o cliente HTTP (passando 'this', a própria instância para injetar token/ID)
+        // Inicializa o cliente HTTP (passando a própria instância)
         this.http = createHttpClient(this);
-        // Inicializa os módulos passando a referência do cliente e do axios
+        // 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); // [NOVO] Inicialização
+        this.functions = new FunctionsModule(this, this.http);
+        this.push = new PushModule(this, this.http);
     }
     // --- 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)
+     * Chamado automaticamente pelo AuthModule após login/registro.
      */
     setToken(token) {
         this._token = token;
@@ -35,9 +37,10 @@ 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() {
         return this._token;
     }
 }
+// Re-exports convenientes para quem consome o SDK
+export { AetherError } from "./errors.js";

package/dist/push.d.ts

@@ -0,0 +1,72 @@
+import type { AxiosInstance } from "axios";
+import type { PlataformaClient } from "./index.js";
+export type PushPlatform = "android" | "ios" | "web";
+export type PushEnvironment = "dev" | "staging" | "prod";
+export interface RegisterDeviceParams {
+    platform: PushPlatform;
+    token: string;
+    environment?: PushEnvironment;
+}
+export interface PushDevice {
+    id: string;
+    projectId: string;
+    userId?: string | null;
+    platform: PushPlatform;
+    token: string;
+    environment: PushEnvironment;
+    createdAt: string;
+    lastSeenAt: string;
+}
+export interface RegisterDeviceResponse {
+    device: PushDevice;
+}
+export interface SendPushResponse {
+    sent: number;
+    total: number;
+    message: string;
+}
+export type PushStatus = "sent" | "failed";
+export interface PushLogEntry {
+    id: string;
+    projectId: string;
+    userId?: string | null;
+    deviceId?: string | null;
+    title: string;
+    body: string;
+    data: Record<string, string>;
+    status: PushStatus;
+    errorMessage?: string | null;
+    createdAt: string;
+}
+export interface ListPushLogsOptions {
+    limit?: number;
+    offset?: number;
+    status?: PushStatus;
+}
+export interface PushStats {
+    totalDevices: number;
+    sent24h: number;
+    successRate: number;
+}
+export declare class PushModule {
+    private client;
+    private http;
+    constructor(client: PlataformaClient, http: AxiosInstance);
+    registerDevice(params: RegisterDeviceParams): Promise<PushDevice>;
+    sendToToken(params: {
+        token: string;
+        title: string;
+        body: string;
+        data?: Record<string, string>;
+        environment?: PushEnvironment;
+    }): Promise<SendPushResponse>;
+    sendToUser(params: {
+        userId: string;
+        title: string;
+        body: string;
+        data?: Record<string, string>;
+        environment?: PushEnvironment;
+    }): Promise<SendPushResponse>;
+    listLogs(options?: ListPushLogsOptions): Promise<PushLogEntry[]>;
+    getStats(): Promise<PushStats>;
+}

package/dist/push.js

@@ -0,0 +1,53 @@
+export class PushModule {
+    constructor(client, http) {
+        this.client = client;
+        this.http = http;
+    }
+    async registerDevice(params) {
+        const projectId = this.client.projectId;
+        const { data } = await this.http.post(`/projects/${projectId}/push/devices`, {
+            platform: params.platform,
+            token: params.token,
+            environment: params.environment ?? "prod",
+        });
+        return data.device;
+    }
+    async sendToToken(params) {
+        const projectId = this.client.projectId;
+        const { data } = await this.http.post(`/projects/${projectId}/push/send`, {
+            token: params.token,
+            title: params.title,
+            body: params.body,
+            data: params.data ?? {},
+            environment: params.environment ?? "prod",
+        });
+        return data;
+    }
+    async sendToUser(params) {
+        const projectId = this.client.projectId;
+        const { data } = await this.http.post(`/projects/${projectId}/push/send`, {
+            userId: params.userId,
+            title: params.title,
+            body: params.body,
+            data: params.data ?? {},
+            environment: params.environment ?? "prod",
+        });
+        return data;
+    }
+    async listLogs(options = {}) {
+        const projectId = this.client.projectId;
+        const { data } = await this.http.get(`/projects/${projectId}/push/logs`, {
+            params: {
+                limit: options.limit,
+                offset: options.offset,
+                status: options.status,
+            },
+        });
+        return data.data;
+    }
+    async getStats() {
+        const projectId = this.client.projectId;
+        const { data } = await this.http.get(`/projects/${projectId}/push/stats`);
+        return data;
+    }
+}

package/errors.ts

@@ -0,0 +1,46 @@
+// src/errors.ts
+export class AetherError extends Error {
+  constructor(
+    public code: string,
+    public message: string,
+    public status?: number,
+    public details?: any
+  ) {
+    super(message);
+    this.name = "AetherError";
+    // Garante que instanceof AetherError funcione bem em qualquer bundler (ES5/ES6)
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
+export function handleAxiosError(error: any): never {
+  if (error?.response) {
+    // Erro vindo da API (4xx, 5xx)
+    const data = error.response.data;
+    const message =
+      data?.error || data?.message || "Erro desconhecido na API";
+    const status: number = 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 === 409) code = "conflict";
+    if (status === 429) code = "rate_limit_exceeded";
+
+    throw new AetherError(code, message, status, data);
+  }
+
+  if (error?.request && !error.response) {
+    // Erro de rede (sem resposta, offline, timeout)
+    throw new AetherError(
+      "network_error",
+      "Não foi possível conectar ao servidor Aether. Verifique sua conexão.",
+      0
+    );
+  }
+
+  // Erro na configuração / código cliente
+  const fallbackMessage = error?.message || "Erro interno no cliente SDK.";
+  throw new AetherError("client_error", fallbackMessage);
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@allanfsouza/aether-sdk",
-  "version": "2.0.0",
-  "description": "SDK do Cliente para a Plataforma API",
+  "version": "2.2.0",
+  "description": "SDK do Cliente para a Plataforma Aether",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",
@@ -15,15 +15,17 @@
     "build": "npx tsc",
     "test": "echo \"Error: no test specified\" && exit 1"
   },
-  "keywords": [],
+  "keywords": [
+    "baas",
+    "sdk",
+    "aether"
+  ],
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "axios": "^1.13.2",
-    "ws": "^8.18.0"
+    "axios": "^1.6.0"
   },
   "devDependencies": {
-    "@types/ws": "^8.5.11",
-    "typescript": "^5.9.3"
+    "typescript": "^5.3.0"
   }
-}
+}

package/src/auth.ts

@@ -2,13 +2,33 @@
 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 class AuthModule {
   private client: PlataformaClient;
   private http: AxiosInstance;
+  private refreshToken: string | null = null;
 
   constructor(client: PlataformaClient, http: AxiosInstance) {
     this.client = client;
@@ -16,27 +36,30 @@ export class AuthModule {
   }
 
   /**
-   * 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: string, password: string) {
+  async login(email: string, password: string): Promise<LoginResponse> {
     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: { ... } }
-    } catch (e: unknown) {
-      this.client.setToken(null); // Limpa o token em caso de falha
+      const { data } = await this.http.post<LoginResponse>("/auth/login", {
+        email,
+        password,
+      });
+
+      if (data.accessToken) {
+        this.client.setToken(data.accessToken);
+        this.refreshToken = data.refreshToken;
+      }
+
+      return data;
+    } catch (e) {
+      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: {
     name: string;
@@ -45,21 +68,86 @@ export class AuthModule {
   }) {
     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(): Promise<{ accessToken: string }> {
+    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: unknown) {
+    } 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(): string {
+    return `${this.client.apiUrl}/v1/auth/google`;
+  }
+
+  /**
+   * Logout da sessão atual
+   */
+  async logout(): Promise<void> {
+    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(): Promise<void> {
+    try {
+      await this.http.post("/auth/logout-all");
+    } finally {
+      this.client.setToken(null);
+      this.refreshToken = null;
+    }
+  }
+
+  /**
+   * Listar sessões ativas
+   */
+  async getSessions(): Promise<Session[]> {
+    const { data } = await this.http.get<{ sessions: Session[] }>(
+      "/auth/sessions"
+    );
+    return data.sessions;
+  }
+
+  /**
+   * Esqueci minha senha
    */
   async forgotPassword(email: string) {
     const { data } = await this.http.post("/auth/forgot-password", { email });
@@ -67,10 +155,7 @@ export class AuthModule {
   }
 
   /**
-   * 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: string, newPassword: string) {
     const { data } = await this.http.post("/auth/reset-password", {
@@ -81,9 +166,16 @@ export class AuthModule {
   }
 
   /**
-   * Desconecta o usuário limpando o token da memória do SDK.
+   * Obter refresh token atual (para armazenamento)
    */
-  logout() {
-    this.client.setToken(null);
+  getRefreshToken(): string | null {
+    return this.refreshToken;
   }
-}
+
+  /**
+   * Definir refresh token (para restaurar sessão)
+   */
+  setRefreshToken(token: string | null) {
+    this.refreshToken = token;
+  }
+}