@riligar/auth-elysia 1.6.2 → 1.6.3

package/src/index.js

@@ -1,21 +1,10 @@
 /**
  * @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
  */
 
 import { Elysia } from 'elysia'
 
-/**
- * Configuração padrão do plugin
- */
 const DEFAULT_CONFIG = {
     prefix: '/auth',
     secretKey: process.env.AUTH_SECRET_KEY || 'your-secret-key',
@@ -25,396 +14,145 @@ 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
-            }
-
-            // Map JWT standard claims to user object format
-            // JWT uses 'sub' for subject (user ID), but clients expect 'id'
-            return {
-                id: payload.sub,
-                ...payload,
+                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'
             }
-        } 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
- */
 export 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 }) => {
-            const path = 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 {
-                    user: userSession.user,
-                    authMeta: {
-                        verified_locally: userSession.verified_locally,
-                        cached: userSession.cached,
-                    },
+    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.'
                 }
-            } 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))
+            )
 }
 
-// Exportar configuração padrão e utilitários
 export { DEFAULT_CONFIG, fetchAuth, RiLiGarAuthClient }
-
-// Export default para compatibilidade
 export default authPlugin