hightjs 0.3.5 → 0.5.0

package/dist/auth/core.js

@@ -1,189 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HWebAuth = 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 http_1 = require("../api/http");
-const jwt_1 = require("./jwt");
-class HWebAuth {
-    constructor(config) {
-        this.config = {
-            session: { strategy: 'jwt', maxAge: 86400, ...config.session },
-            pages: { signIn: '/auth/signin', signOut: '/auth/signout', ...config.pages },
-            ...config
-        };
-        this.sessionManager = new jwt_1.SessionManager(config.secret, this.config.session?.maxAge || 86400);
-    }
-    /**
-     * Middleware para adicionar autenticação às rotas
-     */
-    async middleware(req) {
-        const token = this.getTokenFromRequest(req);
-        if (!token) {
-            return { session: null, user: null };
-        }
-        const session = this.sessionManager.verifySession(token);
-        return {
-            session,
-            user: session?.user || null
-        };
-    }
-    /**
-     * Autentica um usuário usando um provider específico
-     */
-    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 {
-            // 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: providerId }, {});
-                if (!allowed)
-                    return null;
-            }
-            const sessionResult = this.sessionManager.createSession(user);
-            // Callback de sessão se definido
-            if (this.config.callbacks?.session) {
-                sessionResult.session = await this.config.callbacks.session({ session: sessionResult.session, user, provider: providerId });
-            }
-            return sessionResult;
-        }
-        catch (error) {
-            console.error(`[hweb-auth] Error signing in with provider ${providerId}:`, error);
-            return null;
-        }
-    }
-    /**
-     * Faz logout do usuário
-     */
-    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] Signout error on provider ${provider.id}:`, error);
-                }
-            }
-        }
-        return http_1.HightJSResponse
-            .json({ success: true })
-            .clearCookie('hweb-auth-token', {
-            path: '/',
-            httpOnly: true,
-            secure: this.config.secureCookies || false,
-            sameSite: 'strict'
-        });
-    }
-    /**
-     * Obtém a sessão atual
-     */
-    async getSession(req) {
-        const { session } = await this.middleware(req);
-        return session;
-    }
-    /**
-     * Verifica se o usuário está autenticado
-     */
-    async isAuthenticated(req) {
-        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
-     */
-    createAuthResponse(token, data) {
-        return http_1.HightJSResponse
-            .json(data)
-            .cookie('hweb-auth-token', token, {
-            httpOnly: true,
-            secure: this.config.secureCookies || false, // Always secure, even in development
-            sameSite: 'strict', // Prevent CSRF attacks
-            maxAge: (this.config.session?.maxAge || 86400) * 1000,
-            path: '/',
-            domain: undefined // Let browser set automatically for security
-        })
-            .header('X-Content-Type-Options', 'nosniff')
-            .header('X-Frame-Options', 'DENY')
-            .header('X-XSS-Protection', '1; mode=block')
-            .header('Referrer-Policy', 'strict-origin-when-cross-origin');
-    }
-    /**
-     * Extrai token da requisição (cookie ou header)
-     */
-    getTokenFromRequest(req) {
-        // Primeiro tenta pegar do cookie
-        const cookieToken = req.cookie('hweb-auth-token');
-        if (cookieToken)
-            return cookieToken;
-        // Depois tenta do header Authorization
-        const authHeader = req.header('authorization');
-        if (authHeader && typeof authHeader === 'string' && authHeader.startsWith('Bearer ')) {
-            return authHeader.substring(7);
-        }
-        return null;
-    }
-}
-exports.HWebAuth = HWebAuth;

package/dist/auth/index.d.ts

@@ -1,7 +0,0 @@
-export * from './types';
-export * from './providers';
-export * from './core';
-export * from './routes';
-export * from './jwt';
-export { CredentialsProvider, DiscordProvider, GoogleProvider } from './providers';
-export { createAuthRoutes } from './routes';

package/dist/auth/index.js

@@ -1,45 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-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.GoogleProvider = exports.DiscordProvider = exports.CredentialsProvider = 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.
- */
-// Exportações principais do sistema de autenticação
-__exportStar(require("./types"), exports);
-__exportStar(require("./providers"), exports);
-__exportStar(require("./core"), exports);
-__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; } });
-Object.defineProperty(exports, "GoogleProvider", { enumerable: true, get: function () { return providers_1.GoogleProvider; } });
-var routes_1 = require("./routes");
-Object.defineProperty(exports, "createAuthRoutes", { enumerable: true, get: function () { return routes_1.createAuthRoutes; } });

package/dist/auth/jwt.d.ts

@@ -1,41 +0,0 @@
-import type { User, Session } from './types';
-export declare class JWTManager {
-    private secret;
-    constructor(secret?: string);
-    /**
-     * Cria um JWT token com validação de algoritmo
-     */
-    sign(payload: any, expiresIn?: number): string;
-    /**
-     * Verifica e decodifica um JWT token com validação rigorosa
-     */
-    verify(token: string): any | null;
-    private sanitizePayload;
-    private constantTimeEqual;
-    private base64UrlEncode;
-    private base64UrlDecode;
-    private createSignature;
-}
-export declare class SessionManager {
-    private jwtManager;
-    private maxAge;
-    constructor(secret?: string, maxAge?: number);
-    /**
-     * Cria uma nova sessão
-     */
-    createSession(user: User): {
-        session: Session;
-        token: string;
-    };
-    /**
-     * Verifica uma sessão a partir do token
-     */
-    verifySession(token: string): Session | null;
-    /**
-     * Atualiza uma sessão existente
-     */
-    updateSession(token: string): {
-        session: Session;
-        token: string;
-    } | null;
-}

package/dist/auth/jwt.js

@@ -1,185 +0,0 @@
-"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/auth/providers/credentials.d.ts

@@ -1,60 +0,0 @@
-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/auth/providers/credentials.js

@@ -1,97 +0,0 @@
-"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/auth/providers/discord.d.ts

@@ -1,63 +0,0 @@
-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;
-}