@riligar/auth-elysia 1.6.0 → 1.6.1

package/dist/index.esm.js

@@ -1,4 +1,4 @@
-import { Elysia } from 'elysia';
+import 'elysia';
 
 /**
  * @module @riligar/auth-elysia
@@ -227,66 +227,69 @@ async function fetchAuth(url, options = {}) {
 }
 
 /**
- * Middleware de autenticação JWT com verificação JWKS local
+ * Plugin principal de autenticação
  */
-function createAuthMiddleware(config, authClient) {
-    return async ({ request, set, cookie }) => {
-        // Verificar se a rota deve ser excluída da autenticação
-        const path = new URL(request.url).pathname;
-        if (config.excludePaths.some(excluded => path.startsWith(excluded))) {
-            return
-        }
+function authPlugin(userConfig = {}) {
+    const config = { ...DEFAULT_CONFIG, ...userConfig };
 
-        // Buscar token no cookie ou header Authorization
-        let token = cookie[config.cookieName]?.value;
+    // Instanciar cliente Auth
+    const authClient = new RiLiGarAuthClient(config.apiUrl, config.secretKey);
 
-        if (!token) {
-            const authHeader = request.headers.get('authorization');
-            if (authHeader?.startsWith('Bearer ')) {
-                token = authHeader.substring(7);
+    return app => {
+        app.derive(async ({ request, cookie }) => {
+            const path = new URL(request.url).pathname;
+            // Verificar se a rota deve ser excluída da autenticação
+            if (config.excludePaths.some(excluded => path.startsWith(excluded))) {
+                return { user: null, authMeta: null }
             }
-        }
 
-        if (!token) {
-            return config.onUnauthorized(set)
-        }
+            // Buscar token no cookie ou header Authorization
+            let token = cookie[config.cookieName]?.value;
 
-        try {
-            // ⚡ Verificação otimizada com JWKS local + fallback remoto
-            const userSession = await authClient.verifySession(token);
+            if (!token) {
+                const authHeader = request.headers.get('authorization');
+                if (authHeader?.startsWith('Bearer ')) {
+                    token = authHeader.substring(7);
+                }
+            }
 
-            if (!userSession) {
-                return config.onUnauthorized(set)
+            if (!token) {
+                return { user: null, authMeta: null }
             }
 
-            // Adicionar usuário ao contexto da requisição
-            request.user = userSession.user;
-            request.authMeta = {
-                verified_locally: userSession.verified_locally,
-                cached: userSession.cached,
-            };
-        } catch (error) {
-            return config.onUnauthorized(set)
-        }
-    }
-}
+            try {
+                // ⚡ Verificação otimizada com JWKS local + fallback remoto
+                const userSession = await authClient.verifySession(token);
 
-/**
- * Plugin principal de autenticação
- */
-function authPlugin(userConfig = {}) {
-    const config = { ...DEFAULT_CONFIG, ...userConfig };
+                if (!userSession) {
+                    return { user: null, authMeta: null }
+                }
 
-    // Instanciar cliente Auth
-    const authClient = new RiLiGarAuthClient(config.apiUrl, config.secretKey);
+                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 (guard redundante por segurança)
+            if (config.excludePaths.some(excluded => path.startsWith(excluded))) {
+                return
+            }
+
+            // Se não houver usuário e a rota não for excluída, bloquear
+            if (!user) {
+                return config.onUnauthorized(set)
+            }
+        });
 
-    return new Elysia({ name: 'auth-plugin', scoped: false })
-        .onBeforeHandle(createAuthMiddleware(config, authClient))
-        .derive(({ request }) => ({
-            user: request.user || null,
-            authMeta: request.authMeta || null,
-        }))
-        .group(config.prefix, app =>
+        return app.group(config.prefix, app =>
             app
                 // Rota de login
                 .post('/login', async ({ body, set, cookie }) => {
@@ -412,6 +415,7 @@ function authPlugin(userConfig = {}) {
                     return { user }
                 })
         )
+    }
 }
 
 export { DEFAULT_CONFIG, RiLiGarAuthClient, authPlugin, authPlugin as default, fetchAuth };

package/dist/index.js

@@ -2,7 +2,7 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var elysia = require('elysia');
+require('elysia');
 
 /**
  * @module @riligar/auth-elysia
@@ -231,66 +231,69 @@ async function fetchAuth(url, options = {}) {
 }
 
 /**
- * Middleware de autenticação JWT com verificação JWKS local
+ * Plugin principal de autenticação
  */
-function createAuthMiddleware(config, authClient) {
-    return async ({ request, set, cookie }) => {
-        // Verificar se a rota deve ser excluída da autenticação
-        const path = new URL(request.url).pathname;
-        if (config.excludePaths.some(excluded => path.startsWith(excluded))) {
-            return
-        }
+function authPlugin(userConfig = {}) {
+    const config = { ...DEFAULT_CONFIG, ...userConfig };
 
-        // Buscar token no cookie ou header Authorization
-        let token = cookie[config.cookieName]?.value;
+    // Instanciar cliente Auth
+    const authClient = new RiLiGarAuthClient(config.apiUrl, config.secretKey);
 
-        if (!token) {
-            const authHeader = request.headers.get('authorization');
-            if (authHeader?.startsWith('Bearer ')) {
-                token = authHeader.substring(7);
+    return app => {
+        app.derive(async ({ request, cookie }) => {
+            const path = new URL(request.url).pathname;
+            // Verificar se a rota deve ser excluída da autenticação
+            if (config.excludePaths.some(excluded => path.startsWith(excluded))) {
+                return { user: null, authMeta: null }
             }
-        }
 
-        if (!token) {
-            return config.onUnauthorized(set)
-        }
+            // Buscar token no cookie ou header Authorization
+            let token = cookie[config.cookieName]?.value;
 
-        try {
-            // ⚡ Verificação otimizada com JWKS local + fallback remoto
-            const userSession = await authClient.verifySession(token);
+            if (!token) {
+                const authHeader = request.headers.get('authorization');
+                if (authHeader?.startsWith('Bearer ')) {
+                    token = authHeader.substring(7);
+                }
+            }
 
-            if (!userSession) {
-                return config.onUnauthorized(set)
+            if (!token) {
+                return { user: null, authMeta: null }
             }
 
-            // Adicionar usuário ao contexto da requisição
-            request.user = userSession.user;
-            request.authMeta = {
-                verified_locally: userSession.verified_locally,
-                cached: userSession.cached,
-            };
-        } catch (error) {
-            return config.onUnauthorized(set)
-        }
-    }
-}
+            try {
+                // ⚡ Verificação otimizada com JWKS local + fallback remoto
+                const userSession = await authClient.verifySession(token);
 
-/**
- * Plugin principal de autenticação
- */
-function authPlugin(userConfig = {}) {
-    const config = { ...DEFAULT_CONFIG, ...userConfig };
+                if (!userSession) {
+                    return { user: null, authMeta: null }
+                }
 
-    // Instanciar cliente Auth
-    const authClient = new RiLiGarAuthClient(config.apiUrl, config.secretKey);
+                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 (guard redundante por segurança)
+            if (config.excludePaths.some(excluded => path.startsWith(excluded))) {
+                return
+            }
+
+            // Se não houver usuário e a rota não for excluída, bloquear
+            if (!user) {
+                return config.onUnauthorized(set)
+            }
+        });
 
-    return new elysia.Elysia({ name: 'auth-plugin', scoped: false })
-        .onBeforeHandle(createAuthMiddleware(config, authClient))
-        .derive(({ request }) => ({
-            user: request.user || null,
-            authMeta: request.authMeta || null,
-        }))
-        .group(config.prefix, app =>
+        return app.group(config.prefix, app =>
             app
                 // Rota de login
                 .post('/login', async ({ body, set, cookie }) => {
@@ -416,6 +419,7 @@ function authPlugin(userConfig = {}) {
                     return { user }
                 })
         )
+    }
 }
 
 exports.DEFAULT_CONFIG = DEFAULT_CONFIG;

package/package.json

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

package/src/index.js

@@ -226,66 +226,69 @@ async function fetchAuth(url, options = {}) {
 }
 
 /**
- * Middleware de autenticação JWT com verificação JWKS local
+ * Plugin principal de autenticação
  */
-function createAuthMiddleware(config, authClient) {
-    return async ({ request, set, cookie }) => {
-        // Verificar se a rota deve ser excluída da autenticação
-        const path = new URL(request.url).pathname
-        if (config.excludePaths.some(excluded => path.startsWith(excluded))) {
-            return
-        }
+export function authPlugin(userConfig = {}) {
+    const config = { ...DEFAULT_CONFIG, ...userConfig }
 
-        // Buscar token no cookie ou header Authorization
-        let token = cookie[config.cookieName]?.value
+    // Instanciar cliente Auth
+    const authClient = new RiLiGarAuthClient(config.apiUrl, config.secretKey)
 
-        if (!token) {
-            const authHeader = request.headers.get('authorization')
-            if (authHeader?.startsWith('Bearer ')) {
-                token = authHeader.substring(7)
+    return app => {
+        app.derive(async ({ request, cookie }) => {
+            const path = new URL(request.url).pathname
+            // Verificar se a rota deve ser excluída da autenticação
+            if (config.excludePaths.some(excluded => path.startsWith(excluded))) {
+                return { user: null, authMeta: null }
             }
-        }
-
-        if (!token) {
-            return config.onUnauthorized(set)
-        }
 
-        try {
-            // ⚡ Verificação otimizada com JWKS local + fallback remoto
-            const userSession = await authClient.verifySession(token)
+            // Buscar token no cookie ou header Authorization
+            let token = cookie[config.cookieName]?.value
 
-            if (!userSession) {
-                return config.onUnauthorized(set)
+            if (!token) {
+                const authHeader = request.headers.get('authorization')
+                if (authHeader?.startsWith('Bearer ')) {
+                    token = authHeader.substring(7)
+                }
             }
 
-            // Adicionar usuário ao contexto da requisição
-            request.user = userSession.user
-            request.authMeta = {
-                verified_locally: userSession.verified_locally,
-                cached: userSession.cached,
+            if (!token) {
+                return { user: null, authMeta: null }
             }
-        } catch (error) {
-            return config.onUnauthorized(set)
-        }
-    }
-}
 
-/**
- * Plugin principal de autenticação
- */
-export function authPlugin(userConfig = {}) {
-    const config = { ...DEFAULT_CONFIG, ...userConfig }
+            try {
+                // ⚡ Verificação otimizada com JWKS local + fallback remoto
+                const userSession = await authClient.verifySession(token)
 
-    // Instanciar cliente Auth
-    const authClient = new RiLiGarAuthClient(config.apiUrl, config.secretKey)
+                if (!userSession) {
+                    return { user: null, authMeta: null }
+                }
 
-    return new Elysia({ name: 'auth-plugin', scoped: false })
-        .onBeforeHandle(createAuthMiddleware(config, authClient))
-        .derive(({ request }) => ({
-            user: request.user || null,
-            authMeta: request.authMeta || null,
-        }))
-        .group(config.prefix, app =>
+                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 (guard redundante por segurança)
+            if (config.excludePaths.some(excluded => path.startsWith(excluded))) {
+                return
+            }
+
+            // Se não houver usuário e a rota não for excluída, bloquear
+            if (!user) {
+                return config.onUnauthorized(set)
+            }
+        })
+
+        return app.group(config.prefix, app =>
             app
                 // Rota de login
                 .post('/login', async ({ body, set, cookie }) => {
@@ -411,6 +414,7 @@ export function authPlugin(userConfig = {}) {
                     return { user }
                 })
         )
+    }
 }
 
 // Exportar configuração padrão e utilitários