@riligar/auth-elysia 1.6.2 → 1.6.3

package/dist/index.js

@@ -6,21 +6,10 @@ require('elysia');
 
 /**
  * @module @riligar/auth-elysia
- * @description Auth SDK for ElysiaJS with JWT and JWKS
- * @version See package.json
- * @since 1.0.0
- * @copyright 2024-2026 Riligar
- *
- * @license MIT
- * @author Riligar
- * @see https://github.com/riligar-solutions/auth
- * @see https://www.npmjs.com/package/@riligar/auth-elysia
+ * @description Auth SDK for ElysiaJS
  */
 
 
-/**
- * Configuração padrão do plugin
- */
 const DEFAULT_CONFIG = {
     prefix: '/auth',
     secretKey: process.env.AUTH_SECRET_KEY || 'your-secret-key',
@@ -30,392 +19,144 @@ const DEFAULT_CONFIG = {
         httpOnly: true,
         secure: process.env.NODE_ENV === 'production',
         sameSite: 'lax',
-        maxAge: 604800, // 7 dias (igual ao JWT)
+        maxAge: 604800,
     },
     excludePaths: ['/auth/login', '/auth/register', '/auth/session'],
     onUnauthorized: set => {
         set.status = 401;
-        return { error: 'Unauthorized', message: 'Token inválido ou expirado' }
+        return 'Sessão inválida ou expirada.'
     },
 };
 
-/**
- * Cliente Auth com verificação JWT local + JWKS
- */
 class RiLiGarAuthClient {
     constructor(baseUrl, secretKey) {
         this.baseUrl = baseUrl;
         this.secretKey = secretKey;
-        // 🚀 Cache para JWKS (chaves públicas)
         this.jwksCache = null;
         this.jwksCacheExpiry = 0;
-        this.jwksCacheTTL = 3600000; // 1 hora em ms
     }
 
-    // 🔑 Buscar e cachear JWKS
     async getJWKS() {
         const now = Date.now();
-
-        // Retorna cache se ainda válido
-        if (this.jwksCache && now < this.jwksCacheExpiry) {
-            return this.jwksCache
-        }
-
+        if (this.jwksCache && now < this.jwksCacheExpiry) return this.jwksCache
         try {
             const response = await fetch(`${this.baseUrl}/.well-known/jwks.json`);
             if (response.ok) {
                 this.jwksCache = await response.json();
-                this.jwksCacheExpiry = now + this.jwksCacheTTL;
+                this.jwksCacheExpiry = now + 3600000;
                 return this.jwksCache
             }
-        } catch (error) {
-            console.warn('JWKS fetch failed, falling back to remote verification:', error.message);
-        }
-
+        } catch (e) {}
         return null
     }
 
-    // ⚡ Verificação JWT local (usando crypto nativo do Bun)
     async verifyJWTLocal(token) {
         try {
             const jwks = await this.getJWKS();
-            if (!jwks?.keys?.length) return null
-
-            // Decode JWT header para pegar kid e alg
-            const [headerB64] = token.split('.');
-            const header = JSON.parse(atob(headerB64));
-
-            // Encontrar a chave correspondente
+            if (!jwks) return null
+            const [h, p, s] = token.split('.');
+            const header = JSON.parse(atob(h));
             const jwk = jwks.keys.find(k => k.kid === header.kid || k.alg === header.alg);
             if (!jwk) return null
-
-            // Preparar dados para verificação
-            const [headerB64Url, payloadB64Url, signatureB64Url] = token.split('.');
-            const data = new TextEncoder().encode(`${headerB64Url}.${payloadB64Url}`);
-
-            const signature = new Uint8Array(Array.from(atob(signatureB64Url.replace(/-/g, '+').replace(/_/g, '/'))).map(c => c.charCodeAt(0)));
-
-            let key;
-            let algorithm;
-
-            // Suporte para diferentes algoritmos
-            if (header.alg === 'HS256' || jwk.kty === 'oct') {
-                // HMAC com secret key
-                const secret = new TextEncoder().encode(this.secretKey);
-                key = await crypto.subtle.importKey('raw', secret, { name: 'HMAC', hash: 'SHA-256' }, false, ['verify']);
-                algorithm = 'HMAC';
-            } else if (header.alg === 'RS256' || jwk.kty === 'RSA') {
-                // RSA com chave pública JWKS
-                if (!jwk.n || !jwk.e) return null
-
-                // Converter base64url para ArrayBuffer
-                const nBuffer = this.base64urlToArrayBuffer(jwk.n);
-                const eBuffer = this.base64urlToArrayBuffer(jwk.e);
-
-                key = await crypto.subtle.importKey(
-                    'jwk',
-                    {
-                        kty: 'RSA',
-                        n: jwk.n,
-                        e: jwk.e,
-                        alg: 'RS256',
-                        use: 'sig',
-                    },
-                    { name: 'RSASSA-PKCS1-v1_5', hash: 'SHA-256' },
-                    false,
-                    ['verify']
-                );
-                algorithm = 'RSASSA-PKCS1-v1_5';
+            const data = new TextEncoder().encode(`${h}.${p}`);
+            const sig = Uint8Array.from(atob(s.replace(/-/g, '+').replace(/_/g, '/')), c => c.charCodeAt(0));
+            let key, algo;
+            if (header.alg === 'HS256') {
+                key = await crypto.subtle.importKey('raw', new TextEncoder().encode(this.secretKey), { name: 'HMAC', hash: 'SHA-256' }, false, ['verify']);
+                algo = 'HMAC';
             } else {
-                console.warn('Algoritmo JWT não suportado:', header.alg);
-                return null
-            }
-
-            // Verificar assinatura
-            const isValid = await crypto.subtle.verify(algorithm, key, signature, data);
-            if (!isValid) return null
-
-            // Decode payload
-            const payload = JSON.parse(atob(payloadB64Url));
-
-            // Verificar expiração
-            if (payload.exp && payload.exp < Math.floor(Date.now() / 1000)) {
-                return null
+                key = await crypto.subtle.importKey('jwk', { kty: 'RSA', n: jwk.n, e: jwk.e, alg: 'RS256', use: 'sig' }, { name: 'RSASSA-PKCS1-v1_5', hash: 'SHA-256' }, false, ['verify']);
+                algo = 'RSASSA-PKCS1-v1_5';
             }
-
-            // Map JWT standard claims to user object format
-            // JWT uses 'sub' for subject (user ID), but clients expect 'id'
-            return {
-                id: payload.sub,
-                ...payload,
-            }
-        } catch (error) {
-            console.warn('JWT local verification failed:', error.message);
+            if (!(await crypto.subtle.verify(algo, key, sig, data))) return null
+            const payload = JSON.parse(atob(p));
+            if (payload.exp && payload.exp < Date.now() / 1000) return null
+            return { id: payload.sub, ...payload }
+        } catch (e) {
             return null
         }
     }
 
-    // Utilitário para converter base64url para ArrayBuffer
-    base64urlToArrayBuffer(base64url) {
-        const base64 = base64url.replace(/-/g, '+').replace(/_/g, '/');
-        const padding = '='.repeat((4 - (base64.length % 4)) % 4);
-        const base64WithPadding = base64 + padding;
-
-        const binaryString = atob(base64WithPadding);
-        const bytes = new Uint8Array(binaryString.length);
-        for (let i = 0; i < binaryString.length; i++) {
-            bytes[i] = binaryString.charCodeAt(i);
-        }
-        return bytes.buffer
-    }
-
-    // ⚡ Verificar sessão OTIMIZADA (local + fallback remoto)
-    async verifySession(sessionToken) {
-        // 🚀 Primeira tentativa: Verificação local com JWKS
-        const localResult = await this.verifyJWTLocal(sessionToken);
-        if (localResult) {
-            return {
-                user: localResult,
-                verified_locally: true,
-                cached: true,
-            }
-        }
-
-        // 🔄 Fallback: Verificação remota
+    async verifySession(token) {
+        const local = await this.verifyJWTLocal(token);
+        if (local) return { user: local }
         try {
-            const response = await fetch(`${this.baseUrl}/auth/session`, {
-                headers: {
-                    Authorization: `Bearer ${sessionToken}`,
-                    'X-API-Key': this.secretKey,
-                },
+            const res = await fetch(`${this.baseUrl}/auth/session`, {
+                headers: { Authorization: `Bearer ${token}`, 'X-API-Key': this.secretKey },
             });
-
-            if (response.ok) {
-                const result = await response.json();
-                return {
-                    ...result,
-                    verified_locally: false,
-                    cached: false,
-                }
-            }
-        } catch (error) {
-            console.warn('Remote session verification failed:', error.message);
-        }
-
+            if (res.ok) return await res.json()
+        } catch (e) {}
         return null
     }
 }
 
-/**
- * Utilitário para fazer requisições HTTP
- */
 async function fetchAuth(url, options = {}) {
-    try {
-        const response = await fetch(url, {
-            headers: {
-                'Content-Type': 'application/json',
-                ...options.headers,
-            },
-            ...options,
-        });
-
-        if (!response.ok) {
-            throw new Error(`HTTP ${response.status}: ${response.statusText}`)
-        }
-
-        return await response.json()
-    } catch (error) {
-        console.error('Auth fetch error:', error);
-        throw error
-    }
+    const res = await fetch(url, {
+        headers: { 'Content-Type': 'application/json', ...options.headers },
+        ...options,
+    });
+    if (!res.ok) throw new Error(res.status)
+    return await res.json()
 }
 
-/**
- * Plugin principal de autenticação
- */
 function authPlugin(userConfig = {}) {
     const config = { ...DEFAULT_CONFIG, ...userConfig };
-
-    // Instanciar cliente Auth
     const authClient = new RiLiGarAuthClient(config.apiUrl, config.secretKey);
 
-    return app => {
-        app.derive(async ({ request, cookie }) => {
-            new URL(request.url).pathname;
-
-            // Buscar token no cookie ou header Authorization
-            let token = cookie[config.cookieName]?.value;
-
-            if (!token) {
-                const authHeader = request.headers.get('authorization');
-                if (authHeader?.startsWith('Bearer ')) {
-                    token = authHeader.substring(7);
-                }
-            }
-
-            if (!token) {
-                return { user: null, authMeta: null }
-            }
-
-            try {
-                // ⚡ Verificação otimizada com JWKS local + fallback remoto
-                const userSession = await authClient.verifySession(token);
-
-                if (!userSession) {
-                    return { user: null, authMeta: null }
+    return app =>
+        app
+            .derive({ as: 'global' }, async ({ request, cookie }) => {
+                const token = cookie[config.cookieName]?.value || request.headers.get('authorization')?.split(' ')[1];
+                if (!token) return { user: null }
+                const session = await authClient.verifySession(token);
+                return { user: session?.user || null }
+            })
+            .onBeforeHandle({ as: 'global' }, ({ user, set, request }) => {
+                const path = new URL(request.url).pathname;
+                if (config.excludePaths.some(p => path.startsWith(p))) return
+                if (!user) return config.onUnauthorized(set)
+            })
+            .error(({ error, set }) => {
+                if (String(error).includes('user.id') || String(error).includes('of null')) {
+                    set.status = 401;
+                    return 'Sessão inválida ou expirada.'
                 }
-
-                return {
-                    user: userSession.user,
-                    authMeta: {
-                        verified_locally: userSession.verified_locally,
-                        cached: userSession.cached,
-                    },
-                }
-            } catch (error) {
-                console.warn('Auth verification error:', error.message);
-                return { user: null, authMeta: null }
-            }
-        }).onBeforeHandle(({ user, set, request }) => {
-            const path = new URL(request.url).pathname;
-
-            // Verificar se a rota deve ser excluída da autenticação
-            const isExcluded = config.excludePaths.some(excluded => path.startsWith(excluded));
-            if (isExcluded) return
-
-            // Bloquear se não houver usuário
-            if (!user) {
-                return config.onUnauthorized(set)
-            }
-        });
-
-        return app.group(config.prefix, app =>
-            app
-                // Rota de login
-                .post('/login', async ({ body, set, cookie }) => {
-                    try {
-                        const { email, password } = body;
-
-                        if (!email || !password) {
-                            set.status = 400;
-                            return { error: 'Email e senha são obrigatórios' }
-                        }
-
-                        const response = await fetchAuth(`${config.apiUrl}/auth/sign-in/email`, {
-                            method: 'POST',
-                            body: JSON.stringify({ email, password }),
-                            headers: {
-                                'X-API-Key': config.secretKey,
-                            },
-                        });
-
-                        if (response.token) {
-                            cookie[config.cookieName].set({
-                                value: response.token,
-                                ...config.cookieOptions,
+            })
+            .group(config.prefix, app =>
+                app
+                    .post('/login', async ({ body, set, cookie }) => {
+                        try {
+                            const res = await fetchAuth(`${config.apiUrl}/auth/sign-in/email`, {
+                                method: 'POST',
+                                body: JSON.stringify(body),
+                                headers: { 'X-API-Key': config.secretKey },
                             });
+                            cookie[config.cookieName].set({ value: res.token, ...config.cookieOptions });
+                            return { message: 'OK', user: res.user, token: res.token }
+                        } catch (e) {
+                            set.status = 401;
+                            return 'Falha no login.'
                         }
-
-                        return {
-                            message: 'Login realizado com sucesso!',
-                            user: response.user,
-                            token: response.token,
-                            session: response.session,
-                        }
-                    } catch (error) {
-                        set.status = 401;
-                        return { error: 'Login failed', message: error.message }
-                    }
-                })
-
-                // Rota de registro
-                .post('/register', async ({ body, set }) => {
-                    try {
-                        const { email, password, name, organizationId } = body;
-
-                        if (!email || !password || !name) {
-                            set.status = 400;
-                            return { error: 'Email, senha e nome são obrigatórios' }
-                        }
-
-                        const response = await fetchAuth(`${config.apiUrl}/auth/sign-up/email`, {
-                            method: 'POST',
-                            body: JSON.stringify({
-                                email,
-                                password,
-                                name,
-                                ...(organizationId && { organizationId }),
-                            }),
-                            headers: {
-                                'X-API-Key': config.secretKey,
-                            },
-                        });
-
-                        return {
-                            message: 'Usuário registrado com sucesso!',
-                            user: {
-                                id: response.user?.id,
-                                email: response.user?.email,
-                                name: response.user?.name,
-                            },
-                        }
-                    } catch (error) {
-                        set.status = 400;
-                        return { error: 'Registration failed', message: error.message }
-                    }
-                })
-
-                // Rota de logout
-                .post('/logout', async ({ cookie, set, headers }) => {
-                    try {
-                        const token = headers.authorization?.replace('Bearer ', '') || cookie[config.cookieName]?.value;
-
-                        if (token) {
-                            // Fazer logout no servidor de auth
-                            await fetchAuth(`${config.apiUrl}/auth/sign-out`, {
+                    })
+                    .post('/register', async ({ body, set }) => {
+                        try {
+                            const res = await fetchAuth(`${config.apiUrl}/auth/sign-up/email`, {
                                 method: 'POST',
-                                headers: {
-                                    Authorization: `Bearer ${token}`,
-                                    'X-API-Key': config.secretKey,
-                                },
-                            }).catch(() => {
-                                // Ignorar erros do logout remoto
+                                body: JSON.stringify(body),
+                                headers: { 'X-API-Key': config.secretKey },
                             });
+                            return { message: 'OK', user: res.user }
+                        } catch (e) {
+                            set.status = 400;
+                            return 'Falha no registro.'
                         }
-
-                        // Remover cookie local
+                    })
+                    .post('/logout', async ({ cookie }) => {
                         cookie[config.cookieName].remove();
-
-                        return { message: 'Logout realizado com sucesso!' }
-                    } catch (error) {
-                        set.status = 400;
-                        return { error: 'Erro ao fazer logout', message: error.message }
-                    }
-                })
-
-                // Verificar sessão (substitui o /refresh)
-                .get('/session', ({ user, authMeta, set }) => {
-                    if (!user) {
-                        set.status = 401;
-                        return { error: 'Not authenticated' }
-                    }
-                    return {
-                        user,
-                        meta: authMeta,
-                        verified_at: new Date().toISOString(),
-                    }
-                })
-
-                // Status do usuário atual
-                .get('/me', ({ user, set }) => {
-                    if (!user) {
-                        set.status = 401;
-                        return { error: 'Not authenticated' }
-                    }
-                    return { user }
-                })
-        )
-    }
+                        return 'Sessão encerrada.'
+                    })
+                    .get('/me', ({ user, set }) => user || config.onUnauthorized(set))
+            )
 }
 
 exports.DEFAULT_CONFIG = DEFAULT_CONFIG;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@riligar/auth-elysia",
-    "version": "1.6.2",
+    "version": "1.6.3",
     "type": "module",
     "description": "Auth SDK for ElysiaJS with JWT and JWKS",
     "main": "dist/index.js",