@hightjs/auth 0.4.0

package/dist/jwt.js

@@ -0,0 +1,185 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionManager = exports.JWTManager = void 0;
+/*
+ * This file is part of the HightJS Project.
+ * Copyright (c) 2025 itsmuzin
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const crypto_1 = __importDefault(require("crypto"));
+class JWTManager {
+    constructor(secret) {
+        if (!secret && !process.env.HWEB_AUTH_SECRET) {
+            throw new Error('JWT secret is required. Set HWEB_AUTH_SECRET environment variable or provide secret parameter.');
+        }
+        this.secret = secret || process.env.HWEB_AUTH_SECRET;
+        if (this.secret.length < 32) {
+            throw new Error('JWT secret must be at least 32 characters long for security.');
+        }
+    }
+    /**
+     * Cria um JWT token com validação de algoritmo
+     */
+    sign(payload, expiresIn = 86400) {
+        const header = { alg: 'HS256', typ: 'JWT' };
+        const now = Math.floor(Date.now() / 1000);
+        // Sanitize payload to prevent injection
+        const sanitizedPayload = this.sanitizePayload(payload);
+        const tokenPayload = {
+            ...sanitizedPayload,
+            iat: now,
+            exp: now + expiresIn,
+            alg: 'HS256' // Prevent algorithm confusion attacks
+        };
+        const encodedHeader = this.base64UrlEncode(JSON.stringify(header));
+        const encodedPayload = this.base64UrlEncode(JSON.stringify(tokenPayload));
+        const signature = this.createSignature(encodedHeader + '.' + encodedPayload);
+        return `${encodedHeader}.${encodedPayload}.${signature}`;
+    }
+    /**
+     * Verifica e decodifica um JWT token com validação rigorosa
+     */
+    verify(token) {
+        try {
+            if (!token || typeof token !== 'string')
+                return null;
+            const parts = token.split('.');
+            if (parts.length !== 3)
+                return null;
+            const [headerEncoded, payloadEncoded, signature] = parts;
+            // Decode and validate header
+            const header = JSON.parse(this.base64UrlDecode(headerEncoded));
+            if (header.alg !== 'HS256' || header.typ !== 'JWT') {
+                return null; // Prevent algorithm confusion attacks
+            }
+            // Verifica a assinatura usando constant-time comparison
+            const expectedSignature = this.createSignature(headerEncoded + '.' + payloadEncoded);
+            if (!this.constantTimeEqual(signature, expectedSignature))
+                return null;
+            // Decodifica o payload
+            const decodedPayload = JSON.parse(this.base64UrlDecode(payloadEncoded));
+            // Validate algorithm in payload matches header
+            if (decodedPayload.alg !== 'HS256')
+                return null;
+            // Verifica expiração com margem de erro de 30 segundos
+            const now = Math.floor(Date.now() / 1000);
+            if (decodedPayload.exp && decodedPayload.exp < (now - 30)) {
+                return null;
+            }
+            // Validate issued at time (not too far in future)
+            if (decodedPayload.iat && decodedPayload.iat > (now + 300)) {
+                return null;
+            }
+            return decodedPayload;
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    sanitizePayload(payload) {
+        if (typeof payload !== 'object' || payload === null) {
+            return {};
+        }
+        const sanitized = {};
+        for (const [key, value] of Object.entries(payload)) {
+            // Skip dangerous properties
+            if (key.startsWith('__') || key === 'constructor' || key === 'prototype') {
+                continue;
+            }
+            sanitized[key] = value;
+        }
+        return sanitized;
+    }
+    constantTimeEqual(a, b) {
+        if (a.length !== b.length)
+            return false;
+        let result = 0;
+        for (let i = 0; i < a.length; i++) {
+            result |= a.charCodeAt(i) ^ b.charCodeAt(i);
+        }
+        return result === 0;
+    }
+    base64UrlEncode(str) {
+        return Buffer.from(str)
+            .toString('base64')
+            .replace(/\+/g, '-')
+            .replace(/\//g, '_')
+            .replace(/=/g, '');
+    }
+    base64UrlDecode(str) {
+        str += '='.repeat(4 - str.length % 4);
+        return Buffer.from(str.replace(/-/g, '+').replace(/_/g, '/'), 'base64').toString();
+    }
+    createSignature(data) {
+        return crypto_1.default
+            .createHmac('sha256', this.secret)
+            .update(data)
+            .digest('base64')
+            .replace(/\+/g, '-')
+            .replace(/\//g, '_')
+            .replace(/=/g, '');
+    }
+}
+exports.JWTManager = JWTManager;
+class SessionManager {
+    constructor(secret, maxAge = 86400) {
+        this.jwtManager = new JWTManager(secret);
+        this.maxAge = maxAge;
+    }
+    /**
+     * Cria uma nova sessão
+     */
+    createSession(user) {
+        const expires = new Date(Date.now() + this.maxAge * 1000).toISOString();
+        const session = {
+            user,
+            expires
+        };
+        const token = this.jwtManager.sign({
+            ...user
+        }, this.maxAge);
+        return { session, token };
+    }
+    /**
+     * Verifica uma sessão a partir do token
+     */
+    verifySession(token) {
+        try {
+            const payload = this.jwtManager.verify(token);
+            if (!payload)
+                return null;
+            const session = {
+                user: payload,
+                expires: new Date(payload.exp * 1000).toISOString()
+            };
+            return session;
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    /**
+     * Atualiza uma sessão existente
+     */
+    updateSession(token) {
+        const currentSession = this.verifySession(token);
+        if (!currentSession)
+            return null;
+        return this.createSession(currentSession.user);
+    }
+}
+exports.SessionManager = SessionManager;

package/dist/providers/credentials.d.ts

@@ -0,0 +1,60 @@
+import type { AuthProviderClass, User } from '../types';
+export interface CredentialsConfig {
+    id?: string;
+    name?: string;
+    credentials: Record<string, {
+        label: string;
+        type: string;
+        placeholder?: string;
+    }>;
+    authorize: (credentials: Record<string, string>) => Promise<User | null> | User | null;
+}
+/**
+ * Provider para autenticação com credenciais (email/senha)
+ *
+ * Este provider permite autenticação usando email/senha ou qualquer outro
+ * sistema de credenciais customizado. Você define a função authorize
+ * que será chamada para validar as credenciais.
+ *
+ * Exemplo de uso:
+ * ```typescript
+ * new CredentialsProvider({
+ *   name: "Credentials",
+ *   credentials: {
+ *     email: { label: "Email", type: "email" },
+ *     password: { label: "Password", type: "password" }
+ *   },
+ *   async authorize(credentials) {
+ *     // Aqui você faz a validação com seu banco de dados
+ *     const user = await validateUser(credentials.email, credentials.password);
+ *     if (user) {
+ *       return { id: user.id, name: user.name, email: user.email };
+ *     }
+ *     return null;
+ *   }
+ * })
+ * ```
+ */
+export declare class CredentialsProvider implements AuthProviderClass {
+    readonly id: string;
+    readonly name: string;
+    readonly type: string;
+    private config;
+    constructor(config: CredentialsConfig);
+    /**
+     * Método principal para autenticar usuário com credenciais
+     */
+    handleSignIn(credentials: Record<string, string>): Promise<User | null>;
+    /**
+     * Retorna configuração pública do provider
+     */
+    getConfig(): any;
+    /**
+     * Valida se as credenciais fornecidas são válidas
+     */
+    validateCredentials(credentials: Record<string, string>): boolean;
+    /**
+     * Validação simples de email
+     */
+    private isValidEmail;
+}

package/dist/providers/credentials.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CredentialsProvider = void 0;
+/**
+ * Provider para autenticação com credenciais (email/senha)
+ *
+ * Este provider permite autenticação usando email/senha ou qualquer outro
+ * sistema de credenciais customizado. Você define a função authorize
+ * que será chamada para validar as credenciais.
+ *
+ * Exemplo de uso:
+ * ```typescript
+ * new CredentialsProvider({
+ *   name: "Credentials",
+ *   credentials: {
+ *     email: { label: "Email", type: "email" },
+ *     password: { label: "Password", type: "password" }
+ *   },
+ *   async authorize(credentials) {
+ *     // Aqui você faz a validação com seu banco de dados
+ *     const user = await validateUser(credentials.email, credentials.password);
+ *     if (user) {
+ *       return { id: user.id, name: user.name, email: user.email };
+ *     }
+ *     return null;
+ *   }
+ * })
+ * ```
+ */
+class CredentialsProvider {
+    constructor(config) {
+        this.type = 'credentials';
+        this.config = config;
+        this.id = config.id || 'credentials';
+        this.name = config.name || 'Credentials';
+    }
+    /**
+     * Método principal para autenticar usuário com credenciais
+     */
+    async handleSignIn(credentials) {
+        try {
+            if (!this.config.authorize) {
+                throw new Error('Authorize function not provided');
+            }
+            const user = await this.config.authorize(credentials);
+            if (!user) {
+                return null;
+            }
+            // Adiciona informações do provider ao usuário
+            return {
+                ...user,
+                provider: this.id,
+                providerId: user.id || user.email || 'unknown'
+            };
+        }
+        catch (error) {
+            console.error(`[${this.id} Provider] Error during sign in:`, error);
+            return null;
+        }
+    }
+    /**
+     * Retorna configuração pública do provider
+     */
+    getConfig() {
+        return {
+            id: this.id,
+            name: this.name,
+            type: this.type,
+            credentials: this.config.credentials
+        };
+    }
+    /**
+     * Valida se as credenciais fornecidas são válidas
+     */
+    validateCredentials(credentials) {
+        for (const [key, field] of Object.entries(this.config.credentials)) {
+            if (!credentials[key]) {
+                console.warn(`[${this.id} Provider] Missing required credential: ${key}`);
+                return false;
+            }
+            // Validações básicas por tipo
+            if (field.type === 'email' && !this.isValidEmail(credentials[key])) {
+                console.warn(`[${this.id} Provider] Invalid email format: ${credentials[key]}`);
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Validação simples de email
+     */
+    isValidEmail(email) {
+        const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+        return emailRegex.test(email);
+    }
+}
+exports.CredentialsProvider = CredentialsProvider;

package/dist/providers/discord.d.ts

@@ -0,0 +1,63 @@
+import type { AuthProviderClass, AuthRoute, User } from '../types';
+export interface DiscordConfig {
+    id?: string;
+    name?: string;
+    clientId: string;
+    clientSecret: string;
+    callbackUrl?: string;
+    successUrl?: string;
+    scope?: string[];
+}
+/**
+ * Provider para autenticação com Discord OAuth2
+ *
+ * Este provider permite autenticação usando Discord OAuth2.
+ * Automaticamente gerencia o fluxo OAuth completo e rotas necessárias.
+ *
+ * Exemplo de uso:
+ * ```typescript
+ * new DiscordProvider({
+ * clientId: process.env.DISCORD_CLIENT_ID!,
+ * clientSecret: process.env.DISCORD_CLIENT_SECRET!,
+ * callbackUrl: "http://localhost:3000/api/auth/callback/discord"
+ * })
+ * ```
+ *
+ * Fluxo de autenticação:
+ * 1. GET /api/auth/signin/discord - Gera URL e redireciona para Discord
+ * 2. Discord redireciona para /api/auth/callback/discord com código
+ * 3. Provider troca código por token e busca dados do usuário
+ * 4. Retorna objeto User com dados do Discord
+ */
+export declare class DiscordProvider implements AuthProviderClass {
+    readonly id: string;
+    readonly name: string;
+    readonly type: string;
+    private config;
+    private readonly defaultScope;
+    constructor(config: DiscordConfig);
+    /**
+     * Método para gerar URL OAuth (usado pelo handleSignIn)
+     */
+    handleOauth(credentials?: Record<string, string>): string;
+    /**
+     * Método principal - agora redireciona para OAuth ou processa callback
+     */
+    handleSignIn(credentials: Record<string, string>): Promise<User | string | null>;
+    /**
+     * Processa o callback OAuth (código → usuário)
+     */
+    private processOAuthCallback;
+    /**
+     * Rotas adicionais específicas do Discord OAuth
+     */
+    additionalRoutes: AuthRoute[];
+    /**
+     * Gera URL de autorização do Discord
+     */
+    getAuthorizationUrl(): string;
+    /**
+     * Retorna configuração pública do provider
+     */
+    getConfig(): any;
+}

package/dist/providers/discord.js

@@ -0,0 +1,190 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiscordProvider = void 0;
+const hightjs_1 = require("hightjs");
+/**
+ * Provider para autenticação com Discord OAuth2
+ *
+ * Este provider permite autenticação usando Discord OAuth2.
+ * Automaticamente gerencia o fluxo OAuth completo e rotas necessárias.
+ *
+ * Exemplo de uso:
+ * ```typescript
+ * new DiscordProvider({
+ * clientId: process.env.DISCORD_CLIENT_ID!,
+ * clientSecret: process.env.DISCORD_CLIENT_SECRET!,
+ * callbackUrl: "http://localhost:3000/api/auth/callback/discord"
+ * })
+ * ```
+ *
+ * Fluxo de autenticação:
+ * 1. GET /api/auth/signin/discord - Gera URL e redireciona para Discord
+ * 2. Discord redireciona para /api/auth/callback/discord com código
+ * 3. Provider troca código por token e busca dados do usuário
+ * 4. Retorna objeto User com dados do Discord
+ */
+class DiscordProvider {
+    constructor(config) {
+        this.type = 'discord';
+        this.defaultScope = ['identify', 'email'];
+        /**
+         * Rotas adicionais específicas do Discord OAuth
+         */
+        this.additionalRoutes = [
+            // Rota de callback do Discord
+            {
+                method: 'GET',
+                path: '/api/auth/callback/discord',
+                handler: async (req, params) => {
+                    const url = new URL(req.url || '', 'http://localhost');
+                    const code = url.searchParams.get('code');
+                    if (!code) {
+                        return hightjs_1.HightJSResponse.json({ error: 'Authorization code not provided' }, { status: 400 });
+                    }
+                    try {
+                        // CORREÇÃO: O fluxo correto é delegar o 'code' para o endpoint de signin
+                        // principal, que processará o código uma única vez. A implementação anterior
+                        // usava o código duas vezes, causando o erro 'invalid_grant'.
+                        const authResponse = await fetch(`${req.headers.origin || 'http://localhost:3000'}/api/auth/signin`, {
+                            method: 'POST',
+                            headers: {
+                                'Content-Type': 'application/json',
+                            },
+                            body: JSON.stringify({
+                                provider: this.id,
+                                code,
+                            })
+                        });
+                        if (authResponse.ok) {
+                            // Propaga o cookie de sessão retornado pelo endpoint de signin
+                            // e redireciona o usuário para a página de sucesso.
+                            const setCookieHeader = authResponse.headers.get('set-cookie');
+                            if (this.config.successUrl) {
+                                return hightjs_1.HightJSResponse
+                                    .redirect(this.config.successUrl)
+                                    .header('Set-Cookie', setCookieHeader || '');
+                            }
+                            return hightjs_1.HightJSResponse.json({ success: true })
+                                .header('Set-Cookie', setCookieHeader || '');
+                        }
+                        else {
+                            const errorText = await authResponse.text();
+                            console.error(`[${this.id} Provider] Session creation failed during callback. Status: ${authResponse.status}, Body: ${errorText}`);
+                            return hightjs_1.HightJSResponse.json({ error: 'Session creation failed' }, { status: 500 });
+                        }
+                    }
+                    catch (error) {
+                        console.error(`[${this.id} Provider] Callback handler fetch error:`, error);
+                        return hightjs_1.HightJSResponse.json({ error: 'Internal server error' }, { status: 500 });
+                    }
+                }
+            }
+        ];
+        this.config = config;
+        this.id = config.id || 'discord';
+        this.name = config.name || 'Discord';
+    }
+    /**
+     * Método para gerar URL OAuth (usado pelo handleSignIn)
+     */
+    handleOauth(credentials = {}) {
+        return this.getAuthorizationUrl();
+    }
+    /**
+     * Método principal - agora redireciona para OAuth ou processa callback
+     */
+    async handleSignIn(credentials) {
+        // Se tem código, é callback - processa autenticação
+        if (credentials.code) {
+            return await this.processOAuthCallback(credentials);
+        }
+        // Se não tem código, é início do OAuth - retorna URL
+        return this.handleOauth(credentials);
+    }
+    /**
+     * Processa o callback OAuth (código → usuário)
+     */
+    async processOAuthCallback(credentials) {
+        try {
+            const { code } = credentials;
+            if (!code) {
+                throw new Error('Authorization code not provided');
+            }
+            // Troca o código por access token
+            const tokenResponse = await fetch('https://discord.com/api/oauth2/token', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                },
+                body: new URLSearchParams({
+                    client_id: this.config.clientId,
+                    client_secret: this.config.clientSecret,
+                    grant_type: 'authorization_code',
+                    code,
+                    redirect_uri: this.config.callbackUrl || '',
+                }),
+            });
+            if (!tokenResponse.ok) {
+                const error = await tokenResponse.text();
+                // O erro original "Invalid \"code\" in request." acontece aqui.
+                throw new Error(`Failed to exchange code for token: ${error}`);
+            }
+            const tokens = await tokenResponse.json();
+            // Busca dados do usuário
+            const userResponse = await fetch('https://discord.com/api/users/@me', {
+                headers: {
+                    'Authorization': `Bearer ${tokens.access_token}`,
+                },
+            });
+            if (!userResponse.ok) {
+                throw new Error('Failed to fetch user data');
+            }
+            const discordUser = await userResponse.json();
+            // Retorna objeto User padronizado
+            return {
+                id: discordUser.id,
+                name: discordUser.global_name || discordUser.username,
+                email: discordUser.email,
+                image: discordUser.avatar
+                    ? `https://cdn.discordapp.com/avatars/${discordUser.id}/${discordUser.avatar}.png`
+                    : null,
+                username: discordUser.username,
+                discriminator: discordUser.discriminator,
+                provider: this.id,
+                providerId: discordUser.id,
+                accessToken: tokens.access_token,
+                refreshToken: tokens.refresh_token
+            };
+        }
+        catch (error) {
+            console.error(`[${this.id} Provider] Error during OAuth callback:`, error);
+            return null;
+        }
+    }
+    /**
+     * Gera URL de autorização do Discord
+     */
+    getAuthorizationUrl() {
+        const params = new URLSearchParams({
+            client_id: this.config.clientId,
+            redirect_uri: this.config.callbackUrl || '',
+            response_type: 'code',
+            scope: (this.config.scope || this.defaultScope).join(' ')
+        });
+        return `https://discord.com/api/oauth2/authorize?${params.toString()}`;
+    }
+    /**
+     * Retorna configuração pública do provider
+     */
+    getConfig() {
+        return {
+            id: this.id,
+            name: this.name,
+            type: this.type,
+            clientId: this.config.clientId, // Público
+            scope: this.config.scope || this.defaultScope,
+            callbackUrl: this.config.callbackUrl
+        };
+    }
+}
+exports.DiscordProvider = DiscordProvider;

package/dist/providers/google.d.ts

@@ -0,0 +1,63 @@
+import type { AuthProviderClass, AuthRoute, User } from '../types';
+export interface GoogleConfig {
+    id?: string;
+    name?: string;
+    clientId: string;
+    clientSecret: string;
+    callbackUrl?: string;
+    successUrl?: string;
+    scope?: string[];
+}
+/**
+ * Provider para autenticação com Google OAuth2
+ *
+ * Este provider permite autenticação usando Google OAuth2.
+ * Automaticamente gerencia o fluxo OAuth completo e rotas necessárias.
+ *
+ * Exemplo de uso:
+ * ```typescript
+ * new GoogleProvider({
+ * clientId: process.env.GOOGLE_CLIENT_ID!,
+ * clientSecret: process.env.GOOGLE_CLIENT_SECRET!,
+ * callbackUrl: "http://localhost:3000/api/auth/callback/google"
+ * })
+ * ```
+ *
+ * Fluxo de autenticação:
+ * 1. GET /api/auth/signin/google - Gera URL e redireciona para Google
+ * 2. Google redireciona para /api/auth/callback/google com código
+ * 3. Provider troca código por token e busca dados do usuário
+ * 4. Retorna objeto User com dados do Google
+ */
+export declare class GoogleProvider implements AuthProviderClass {
+    readonly id: string;
+    readonly name: string;
+    readonly type: string;
+    private config;
+    private readonly defaultScope;
+    constructor(config: GoogleConfig);
+    /**
+     * Método para gerar URL OAuth (usado pelo handleSignIn)
+     */
+    handleOauth(credentials?: Record<string, string>): string;
+    /**
+     * Método principal - redireciona para OAuth ou processa o callback
+     */
+    handleSignIn(credentials: Record<string, string>): Promise<User | string | null>;
+    /**
+     * Processa o callback do OAuth (troca o código pelo usuário)
+     */
+    private processOAuthCallback;
+    /**
+     * Rotas adicionais específicas do Google OAuth
+     */
+    additionalRoutes: AuthRoute[];
+    /**
+     * Gera a URL de autorização do Google
+     */
+    getAuthorizationUrl(): string;
+    /**
+     * Retorna a configuração pública do provider
+     */
+    getConfig(): any;
+}