hightjs 0.1.1 → 0.2.2

package/README.md

@@ -2,6 +2,18 @@
 
 > Um framework web full‑stack moderno para Node.js, focado em simplicidade, DX e velocidade. Bundler via esbuild, hot reload, roteamento automático, APIs, autenticação JWT, CLI e muito mais.
 
+<br>
+
+[![NPM](https://img.shields.io/npm/v/hightjs.svg?style=for-the-badge&labelColor=000000)](https://www.npmjs.com/package/HIGHTJS)
+
+# Precisa de ajuda?
+Caso tenha alguma dúvida, entre em contato por uma das redes abaixo:
+
+[![Discord](https://img.shields.io/badge/Discord-mulinfrc-5865F2?style=for-the-badge&logo=discord&logoColor=white)](https://discord.com/users/1264710048786026588)
+[![Gmail](https://img.shields.io/badge/Gmail-D14836?style=for-the-badge&logo=gmail&logoColor=white)](mailto:murillofrazaocunha@gmail.com)
+[![Instagram](https://img.shields.io/badge/Instagram-E4405F?style=for-the-badge&logo=instagram&logoColor=white)](https://instagram.com/itsmuh_)
+[![GitHub](https://img.shields.io/badge/GitHub-100000?style=for-the-badge&logo=github&logoColor=white)](https://github.com/murillo-frazao-cunha)
+
 ---
 
 ## 📑 Índice
@@ -118,7 +130,7 @@ src/
     routes/
       index.tsx             // Página inicial "/"
       about.tsx             // Página "/about"
-      blog[id].tsx         // Rota dinâmica "/blog/123"
+      blog.tsx         // Rota dinâmica "/blog/123"
     backend/
       routes/
         middleware.ts       // Middlewares globais da pasta
@@ -152,8 +164,6 @@ export default config;
 
 ### Rotas Dinâmicas com Parâmetros
 
-Use colchetes: `blog/[slug].tsx` → `/blog/post`.
-
 ```tsx
 import {RouteConfig} from "hightjs/client";
 import React from "react";
@@ -332,7 +342,7 @@ O jeito recomendado é criar as rotas diretamente no `auth.ts` e importar onde q
 `src/auth.ts`:
 
 ```ts
-import { CredentialsProvider, createAuthRoutes } from 'hightjs/auth';
+import { CredentialsProvider, DiscordProvider, createAuthRoutes } from 'hightjs/auth';
 import type { AuthConfig } from 'hightjs/auth';
 
 export const authConfig: AuthConfig = {
@@ -357,6 +367,13 @@ export const authConfig: AuthConfig = {
                 return null;
             }
         }),
+        new DiscordProvider({
+            clientId: "ID",
+            clientSecret: "TOKEN",
+            callbackUrl: "http://localhost:3000/api/auth/callback/discord",
+            scope: ['identify', 'email', 'guilds'],
+            successUrl: "http://localhost:3000/"
+        })
     ],
     session: {
         strategy: 'jwt',
@@ -382,6 +399,125 @@ import { authRoutes } from "../../../auth";
 export default authRoutes;
 ```
 
+### Configurando o Frontend
+
+Para usar autenticação no frontend, você precisa configurar o `SessionProvider` no layout:
+
+`src/web/layout.tsx`:
+
+```tsx
+import { SessionProvider } from 'hightjs/auth/react';
+
+export const metadata = { title: 'Meu App', description: 'Descrição global' };
+
+export default function Layout({ children }: { children: React.ReactNode }) {
+  return (
+    <SessionProvider>
+      {children}
+    </SessionProvider>
+  );
+}
+```
+
+### Fazendo Login no Frontend
+
+Exemplo de como implementar login com credenciais e Discord:
+
+```tsx
+import { useSession } from 'hightjs/auth/react';
+import React, { useState } from 'react';
+
+function LoginPage() {
+    const { signIn } = useSession();
+    const [username, setUsername] = useState('');
+    const [password, setPassword] = useState('');
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState<string | null>(null);
+
+    const handleDiscordLogin = async () => {
+        const result = await signIn('discord');
+        if(result) {
+            if (result.url != null) {
+                window.location.href = result.url
+            }
+        }
+    }
+
+    const handleLogin = async (e: React.FormEvent) => {
+        e.preventDefault();
+        setIsLoading(true);
+        setError(null);
+
+        try {
+            const result = await signIn('credentials', {
+                redirect: false,
+                username: username,
+                password: password,
+                callbackUrl: '/'
+            });
+
+            if (!result || result.error) {
+                setError('Credenciais inválidas. Verifique seus dados e senha.');
+                setIsLoading(false);
+                return;
+            }
+
+        } catch (err) {
+            setError('Ocorreu um erro inesperado. Tente novamente.');
+            setIsLoading(false);
+        }
+    };
+
+    return (
+        <div>
+            <form onSubmit={handleLogin}>
+                <input
+                    type="text"
+                    value={username}
+                    onChange={(e) => setUsername(e.target.value)}
+                    placeholder="Username"
+                />
+                <input
+                    type="password"
+                    value={password}
+                    onChange={(e) => setPassword(e.target.value)}
+                    placeholder="Password"
+                />
+                <button type="submit" disabled={isLoading}>Login</button>
+            </form>
+
+            <button onClick={handleDiscordLogin}>Login com Discord</button>
+
+            {error && <p style={{color: 'red'}}>{error}</p>}
+        </div>
+    );
+}
+```
+
+### Acessando Dados do Usuário
+
+Para acessar informações do usuário autenticado:
+
+```tsx
+import { useSession } from 'hightjs/auth/react';
+
+function UserProfile() {
+    const { data: session, status, signOut } = useSession();
+
+    if (status === 'loading') return <p>Carregando...</p>;
+
+    if (!session) return <p>Não autenticado</p>;
+
+    return (
+        <div>
+            <h1>Bem-vindo, {session.user?.name}</h1>
+            <p>Email: {session.user?.email}</p>
+            <button onClick={() => signOut()}>Logout</button>
+        </div>
+    );
+}
+```
+
 ### Protegendo rotas backend
 
 ```ts
@@ -408,10 +544,11 @@ export default route;
 
 ### Métodos principais
 
-- `authRoutes.auth.signIn()`
-- `authRoutes.auth.signOut()`
-- `authRoutes.auth.getSession()`
-- `authRoutes.auth.isAuthenticated()`
+- `signIn()` - Fazer login (credenciais ou provider)
+- `signOut()` - Fazer logout
+- `useSession()` - Hook para acessar sessão no frontend
+- `authRoutes.auth.getSession()` - Verificar sessão no backend
+- `authRoutes.auth.isAuthenticated()` - Verificar se está autenticado
 
 ---
 
@@ -505,4 +642,5 @@ Copyright 2025 itsmuzin
 
 Este projeto está licenciado sob a [Licença Apache 2.0](LICENSE).
 
----
+---
+

package/dist/api/http.js

@@ -362,14 +362,16 @@ class HightJSResponse {
                 res.cookie(name, value, options);
             }
         });
+        // Handle redirects specifically
+        if (this._headers['Location']) {
+            res.redirect(this._headers['Location']);
+            return;
+        }
         // Envia o corpo se foi definido
         if (this._sent && this._body !== null) {
             if (this._headers['Content-Type']?.includes('application/json')) {
                 res.json(JSON.parse(this._body));
             }
-            else if (this._headers['Location']) {
-                res.redirect(this._headers['Location']);
-            }
             else {
                 res.send(this._body);
             }

package/dist/auth/client.d.ts

@@ -1,4 +1,4 @@
-import type { Session } from './types';
+import type { SignInOptions, SignInResult, Session } from './types';
 export declare function setBasePath(path: string): void;
 /**
  * Função para obter a sessão atual (similar ao NextAuth getSession)
@@ -12,3 +12,13 @@ export declare function getCsrfToken(): Promise<string | null>;
  * Função para obter providers disponíveis
  */
 export declare function getProviders(): Promise<any[] | null>;
+/**
+ * Função para fazer login (similar ao NextAuth signIn)
+ */
+export declare function signIn(provider?: string, options?: SignInOptions): Promise<SignInResult | undefined>;
+/**
+ * Função para fazer logout (similar ao NextAuth signOut)
+ */
+export declare function signOut(options?: {
+    callbackUrl?: string;
+}): Promise<void>;

package/dist/auth/client.js

@@ -4,6 +4,8 @@ exports.setBasePath = setBasePath;
 exports.getSession = getSession;
 exports.getCsrfToken = getCsrfToken;
 exports.getProviders = getProviders;
+exports.signIn = signIn;
+exports.signOut = signOut;
 // Configuração global do client
 let basePath = '/api/auth';
 function setBasePath(path) {
@@ -66,3 +68,79 @@ async function getProviders() {
         return null;
     }
 }
+/**
+ * Função para fazer login (similar ao NextAuth signIn)
+ */
+async function signIn(provider = 'credentials', options = {}) {
+    try {
+        const { redirect = true, callbackUrl, ...credentials } = options;
+        const response = await fetch(`${basePath}/signin`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            credentials: 'include',
+            body: JSON.stringify({
+                provider,
+                ...credentials
+            })
+        });
+        const data = await response.json();
+        if (response.ok && data.success) {
+            // Se é OAuth, redireciona para URL fornecida
+            if (data.type === 'oauth' && data.redirectUrl) {
+                if (redirect && typeof window !== 'undefined') {
+                    window.location.href = data.redirectUrl;
+                }
+                return {
+                    ok: true,
+                    status: 200,
+                    url: data.redirectUrl
+                };
+            }
+            // Se é sessão (credentials), redireciona para callbackUrl
+            if (data.type === 'session') {
+                if (redirect && typeof window !== 'undefined') {
+                    window.location.href = callbackUrl || '/';
+                }
+                return {
+                    ok: true,
+                    status: 200,
+                    url: callbackUrl || '/'
+                };
+            }
+        }
+        else {
+            return {
+                error: data.error || 'Authentication failed',
+                status: response.status,
+                ok: false
+            };
+        }
+    }
+    catch (error) {
+        console.error('[hweb-auth] Erro no signIn:', error);
+        return {
+            error: 'Network error',
+            status: 500,
+            ok: false
+        };
+    }
+}
+/**
+ * Função para fazer logout (similar ao NextAuth signOut)
+ */
+async function signOut(options = {}) {
+    try {
+        await fetch(`${basePath}/signout`, {
+            method: 'POST',
+            credentials: 'include'
+        });
+        if (typeof window !== 'undefined') {
+            window.location.href = options.callbackUrl || '/';
+        }
+    }
+    catch (error) {
+        console.error('[hweb-auth] Erro no signOut:', error);
+    }
+}

package/dist/auth/core.d.ts

@@ -1,5 +1,5 @@
 import { HightJSRequest, HightJSResponse } from '../api/http';
-import type { AuthConfig, Session } from './types';
+import type { AuthConfig, AuthProviderClass, Session } from './types';
 export declare class HWebAuth {
     private config;
     private sessionManager;
@@ -9,16 +9,18 @@ export declare class HWebAuth {
      */
     private middleware;
     /**
-     * Autentica um usuário com credenciais
+     * Autentica um usuário usando um provider específico
      */
-    signIn(provider: string, credentials: Record<string, string>): Promise<{
+    signIn(providerId: string, credentials: Record<string, string>): Promise<{
         session: Session;
         token: string;
+    } | {
+        redirectUrl: string;
     } | null>;
     /**
      * Faz logout do usuário
      */
-    signOut(): HightJSResponse;
+    signOut(req: HightJSRequest): Promise<HightJSResponse>;
     /**
      * Obtém a sessão atual
      */
@@ -27,6 +29,21 @@ export declare class HWebAuth {
      * Verifica se o usuário está autenticado
      */
     isAuthenticated(req: HightJSRequest): Promise<boolean>;
+    /**
+     * Retorna todos os providers disponíveis (dados públicos)
+     */
+    getProviders(): any[];
+    /**
+     * Busca um provider específico
+     */
+    getProvider(id: string): AuthProviderClass | null;
+    /**
+     * Retorna todas as rotas adicionais dos providers
+     */
+    getAllAdditionalRoutes(): Array<{
+        provider: string;
+        route: any;
+    }>;
     /**
      * Cria resposta com cookie de autenticação - Secure implementation
      */

package/dist/auth/core.js

@@ -27,49 +27,67 @@ class HWebAuth {
         };
     }
     /**
-     * Autentica um usuário com credenciais
+     * Autentica um usuário usando um provider específico
      */
-    async signIn(provider, credentials) {
-        const authProvider = this.config.providers.find(p => p.id === provider);
-        if (!authProvider || authProvider.type !== 'credentials') {
-            return null;
-        }
-        if (!authProvider.authorize) {
+    async signIn(providerId, credentials) {
+        const provider = this.config.providers.find(p => p.id === providerId);
+        if (!provider) {
+            console.error(`[hweb-auth] Provider not found: ${providerId}`);
             return null;
         }
         try {
-            const user = await authProvider.authorize(credentials);
-            if (!user)
+            // Usa o método handleSignIn do provider
+            const result = await provider.handleSignIn(credentials);
+            if (!result)
                 return null;
+            // Se resultado é string, é URL de redirecionamento OAuth
+            if (typeof result === 'string') {
+                return { redirectUrl: result };
+            }
+            // Se resultado é User, cria sessão
+            const user = result;
             // Callback de signIn se definido
             if (this.config.callbacks?.signIn) {
-                const allowed = await this.config.callbacks.signIn(user, { provider }, {});
+                const allowed = await this.config.callbacks.signIn(user, { provider: providerId }, {});
                 if (!allowed)
                     return null;
             }
-            const result = this.sessionManager.createSession(user);
+            const sessionResult = this.sessionManager.createSession(user);
             // Callback de sessão se definido
             if (this.config.callbacks?.session) {
-                result.session = await this.config.callbacks.session(result.session, user);
+                sessionResult.session = await this.config.callbacks.session(sessionResult.session, user);
             }
-            return result;
+            return sessionResult;
         }
         catch (error) {
-            console.error('[hweb-auth] Erro no signIn:', error);
+            console.error(`[hweb-auth] Erro no signIn com provider ${providerId}:`, error);
             return null;
         }
     }
     /**
      * Faz logout do usuário
      */
-    signOut() {
+    async signOut(req) {
+        // Busca a sessão atual para saber qual provider usar
+        const { session } = await this.middleware(req);
+        if (session?.user?.provider) {
+            const provider = this.config.providers.find(p => p.id === session.user.provider);
+            if (provider && provider.handleSignOut) {
+                try {
+                    await provider.handleSignOut();
+                }
+                catch (error) {
+                    console.error(`[hweb-auth] Erro no signOut do provider ${provider.id}:`, error);
+                }
+            }
+        }
         return http_1.HightJSResponse
             .json({ success: true })
             .clearCookie('hweb-auth-token', {
             path: '/',
             httpOnly: true,
-            secure: true, // Always use secure cookies
-            sameSite: 'strict' // Stronger CSRF protection
+            secure: true,
+            sameSite: 'strict'
         });
     }
     /**
@@ -86,6 +104,37 @@ class HWebAuth {
         const session = await this.getSession(req);
         return session !== null;
     }
+    /**
+     * Retorna todos os providers disponíveis (dados públicos)
+     */
+    getProviders() {
+        return this.config.providers.map(provider => ({
+            id: provider.id,
+            name: provider.name,
+            type: provider.type,
+            config: provider.getConfig ? provider.getConfig() : {}
+        }));
+    }
+    /**
+     * Busca um provider específico
+     */
+    getProvider(id) {
+        return this.config.providers.find(p => p.id === id) || null;
+    }
+    /**
+     * Retorna todas as rotas adicionais dos providers
+     */
+    getAllAdditionalRoutes() {
+        const routes = [];
+        for (const provider of this.config.providers) {
+            if (provider.additionalRoutes) {
+                for (const route of provider.additionalRoutes) {
+                    routes.push({ provider: provider.id, route });
+                }
+            }
+        }
+        return routes;
+    }
     /**
      * Cria resposta com cookie de autenticação - Secure implementation
      */

package/dist/auth/example.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Exemplo de como usar os novos providers baseados em classes
+ */
+export declare const authRoutes: {
+    pattern: string;
+    GET(req: import("..").HightJSRequest, params: {
+        [key: string]: string;
+    }): Promise<any>;
+    POST(req: import("..").HightJSRequest, params: {
+        [key: string]: string;
+    }): Promise<any>;
+    auth: import("./core").HWebAuth;
+};
+/**
+ * Como usar em suas rotas API:
+ *
+ * // arquivo: /api/auth/[...value].ts
+ * import { authRoutes } from '../../../src/auth/example';
+ *
+ * export const GET = authRoutes.GET;
+ * export const POST = authRoutes.POST;
+ */
+/**
+ * Rotas disponíveis automaticamente:
+ *
+ * Core routes:
+ * - GET  /api/auth/session - Obter sessão atual
+ * - GET  /api/auth/providers - Listar providers
+ * - GET  /api/auth/csrf - Obter token CSRF
+ * - POST /api/auth/signin - Login
+ * - POST /api/auth/signout - Logout
+ *
+ * Provider específico (CredentialsProvider):
+ * - GET  /api/auth/credentials/config - Config do provider
+ *
+ * Provider específico (DiscordProvider):
+ * - GET  /api/auth/signin/discord - Iniciar OAuth Discord
+ * - GET  /api/auth/callback/discord - Callback OAuth Discord
+ * - GET  /api/auth/discord/config - Config do provider Discord
+ */

package/dist/auth/example.js

@@ -0,0 +1,104 @@
+"use strict";
+/**
+ * Exemplo de como usar os novos providers baseados em classes
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.authRoutes = void 0;
+const routes_1 = require("./routes");
+const providers_1 = require("./providers");
+// Exemplo de configuração com os novos providers
+const authConfig = {
+    providers: [
+        // Provider de credenciais customizado
+        new providers_1.CredentialsProvider({
+            name: "Login com Email",
+            credentials: {
+                email: {
+                    label: "Email",
+                    type: "email",
+                    placeholder: "seu@email.com"
+                },
+                password: {
+                    label: "Senha",
+                    type: "password"
+                }
+            },
+            async authorize(credentials) {
+                // Aqui você faz a validação com seu banco de dados
+                const { email, password } = credentials;
+                // Exemplo de validação (substitua pela sua lógica)
+                if (email === "admin@example.com" && password === "123456") {
+                    return {
+                        id: "1",
+                        name: "Admin User",
+                        email: email,
+                        role: "admin"
+                    };
+                }
+                // Retorna null se credenciais inválidas
+                return null;
+            }
+        }),
+        // Provider do Discord
+        new providers_1.DiscordProvider({
+            clientId: process.env.DISCORD_CLIENT_ID,
+            clientSecret: process.env.DISCORD_CLIENT_SECRET,
+            callbackUrl: "http://localhost:3000/api/auth/callback/discord"
+        })
+    ],
+    secret: process.env.HWEB_AUTH_SECRET || "seu-super-secret-aqui-32-chars-min",
+    session: {
+        strategy: 'jwt',
+        maxAge: 86400 // 24 horas
+    },
+    pages: {
+        signIn: '/auth/signin',
+        signOut: '/auth/signout'
+    },
+    callbacks: {
+        async signIn(user, account, profile) {
+            // Lógica customizada antes do login
+            console.log(`Usuário ${user.email} fazendo login via ${account.provider}`);
+            return true; // permitir login
+        },
+        async session(session, user) {
+            // Adicionar dados customizados à sessão
+            return {
+                ...session,
+                user: {
+                    ...session.user,
+                    customData: "dados extras"
+                }
+            };
+        }
+    }
+};
+// Criar as rotas de autenticação
+exports.authRoutes = (0, routes_1.createAuthRoutes)(authConfig);
+/**
+ * Como usar em suas rotas API:
+ *
+ * // arquivo: /api/auth/[...value].ts
+ * import { authRoutes } from '../../../src/auth/example';
+ *
+ * export const GET = authRoutes.GET;
+ * export const POST = authRoutes.POST;
+ */
+/**
+ * Rotas disponíveis automaticamente:
+ *
+ * Core routes:
+ * - GET  /api/auth/session - Obter sessão atual
+ * - GET  /api/auth/providers - Listar providers
+ * - GET  /api/auth/csrf - Obter token CSRF
+ * - POST /api/auth/signin - Login
+ * - POST /api/auth/signout - Logout
+ *
+ * Provider específico (CredentialsProvider):
+ * - GET  /api/auth/credentials/config - Config do provider
+ *
+ * Provider específico (DiscordProvider):
+ * - GET  /api/auth/signin/discord - Iniciar OAuth Discord
+ * - GET  /api/auth/callback/discord - Callback OAuth Discord
+ * - GET  /api/auth/discord/config - Config do provider Discord
+ */

package/dist/auth/index.d.ts

@@ -3,5 +3,5 @@ export * from './providers';
 export * from './core';
 export * from './routes';
 export * from './jwt';
-export { CredentialsProvider } from './providers';
+export { CredentialsProvider, DiscordProvider } from './providers';
 export { createAuthRoutes } from './routes';

package/dist/auth/index.js

@@ -14,7 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createAuthRoutes = exports.CredentialsProvider = void 0;
+exports.createAuthRoutes = exports.DiscordProvider = exports.CredentialsProvider = void 0;
 // Exportações principais do sistema de autenticação
 __exportStar(require("./types"), exports);
 __exportStar(require("./providers"), exports);
@@ -23,5 +23,6 @@ __exportStar(require("./routes"), exports);
 __exportStar(require("./jwt"), exports);
 var providers_1 = require("./providers");
 Object.defineProperty(exports, "CredentialsProvider", { enumerable: true, get: function () { return providers_1.CredentialsProvider; } });
+Object.defineProperty(exports, "DiscordProvider", { enumerable: true, get: function () { return providers_1.DiscordProvider; } });
 var routes_1 = require("./routes");
 Object.defineProperty(exports, "createAuthRoutes", { enumerable: true, get: function () { return routes_1.createAuthRoutes; } });