@vatts/auth 1.0.2-alpha.2 → 1.0.2-alpha.4

package/dist/providers/github.d.ts

@@ -0,0 +1,63 @@
+import type { AuthProviderClass, AuthRoute, User } from '../types';
+export interface GithubConfig {
+    id?: string;
+    name?: string;
+    clientId: string;
+    clientSecret: string;
+    callbackUrl?: string;
+    successUrl?: string;
+    scope?: string[];
+}
+/**
+ * Provider para autenticação com GitHub OAuth2
+ *
+ * Este provider permite autenticação usando GitHub.
+ * Automaticamente gerencia o fluxo OAuth completo e rotas necessárias.
+ *
+ * Exemplo de uso:
+ * ```typescript
+ * new GithubProvider({
+ * clientId: process.env.GITHUB_CLIENT_ID!,
+ * clientSecret: process.env.GITHUB_CLIENT_SECRET!,
+ * callbackUrl: "http://localhost:3000/api/auth/callback/github"
+ * })
+ * ```
+ *
+ * Fluxo de autenticação:
+ * 1. GET /api/auth/signin/github - Gera URL e redireciona para GitHub
+ * 2. GitHub redireciona para /api/auth/callback/github com código
+ * 3. Provider troca código por token e busca dados do usuário
+ * 4. Retorna objeto User com dados do GitHub
+ */
+export declare class GithubProvider implements AuthProviderClass {
+    readonly id: string;
+    readonly name: string;
+    readonly type: string;
+    private config;
+    private readonly defaultScope;
+    constructor(config: GithubConfig);
+    /**
+     * 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 GitHub OAuth
+     */
+    additionalRoutes: AuthRoute[];
+    /**
+     * Gera a URL de autorização do GitHub
+     */
+    getAuthorizationUrl(): string;
+    /**
+     * Retorna a configuração pública do provider
+     */
+    getConfig(): any;
+}

package/dist/providers/github.js

@@ -0,0 +1,218 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GithubProvider = void 0;
+const vatts_1 = require("vatts");
+/**
+ * Provider para autenticação com GitHub OAuth2
+ *
+ * Este provider permite autenticação usando GitHub.
+ * Automaticamente gerencia o fluxo OAuth completo e rotas necessárias.
+ *
+ * Exemplo de uso:
+ * ```typescript
+ * new GithubProvider({
+ * clientId: process.env.GITHUB_CLIENT_ID!,
+ * clientSecret: process.env.GITHUB_CLIENT_SECRET!,
+ * callbackUrl: "http://localhost:3000/api/auth/callback/github"
+ * })
+ * ```
+ *
+ * Fluxo de autenticação:
+ * 1. GET /api/auth/signin/github - Gera URL e redireciona para GitHub
+ * 2. GitHub redireciona para /api/auth/callback/github com código
+ * 3. Provider troca código por token e busca dados do usuário
+ * 4. Retorna objeto User com dados do GitHub
+ */
+class GithubProvider {
+    constructor(config) {
+        this.type = 'github';
+        this.defaultScope = [
+            'read:user',
+            'user:email'
+        ];
+        /**
+         * Rotas adicionais específicas do GitHub OAuth
+         */
+        this.additionalRoutes = [
+            // Rota de callback do GitHub
+            {
+                method: 'GET',
+                path: '/api/auth/callback/github',
+                handler: async (req, params) => {
+                    const url = new URL(req.url || '', 'http://localhost');
+                    const code = url.searchParams.get('code');
+                    if (!code) {
+                        return vatts_1.VattsResponse.json({ error: 'Authorization code not provided' }, { status: 400 });
+                    }
+                    try {
+                        // Delega o 'code' para o endpoint de signin principal
+                        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 e redireciona para a URL de sucesso
+                            const setCookieHeader = authResponse.headers.get('set-cookie');
+                            if (this.config.successUrl) {
+                                return vatts_1.VattsResponse
+                                    .redirect(this.config.successUrl)
+                                    .header('Set-Cookie', setCookieHeader || '');
+                            }
+                            return vatts_1.VattsResponse.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 vatts_1.VattsResponse.json({ error: 'Session creation failed' }, { status: 500 });
+                        }
+                    }
+                    catch (error) {
+                        console.error(`[${this.id} Provider] Callback handler fetch error:`, error);
+                        return vatts_1.VattsResponse.json({ error: 'Internal server error' }, { status: 500 });
+                    }
+                }
+            }
+        ];
+        this.config = config;
+        this.id = config.id || 'github';
+        this.name = config.name || 'GitHub';
+    }
+    /**
+     * Método para gerar URL OAuth (usado pelo handleSignIn)
+     */
+    handleOauth(credentials = {}) {
+        return this.getAuthorizationUrl();
+    }
+    /**
+     * Método principal - redireciona para OAuth ou processa o callback
+     */
+    async handleSignIn(credentials) {
+        // Se tem código, é o callback - processa a autenticação
+        if (credentials.code) {
+            return await this.processOAuthCallback(credentials);
+        }
+        // Se não tem código, é o início do OAuth - retorna a URL
+        return this.handleOauth(credentials);
+    }
+    /**
+     * Processa o callback do OAuth (troca o código pelo usuário)
+     */
+    async processOAuthCallback(credentials) {
+        try {
+            const { code } = credentials;
+            if (!code) {
+                throw new Error('Authorization code not provided');
+            }
+            // Troca o código por um access token
+            // Nota: O GitHub requer o header Accept: application/json para retornar JSON
+            const tokenResponse = await fetch('https://github.com/login/oauth/access_token', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Accept': 'application/json'
+                },
+                body: JSON.stringify({
+                    client_id: this.config.clientId,
+                    client_secret: this.config.clientSecret,
+                    code,
+                    redirect_uri: this.config.callbackUrl || undefined,
+                }),
+            });
+            if (!tokenResponse.ok) {
+                const error = await tokenResponse.text();
+                throw new Error(`Failed to exchange code for token: ${error}`);
+            }
+            const tokens = await tokenResponse.json();
+            if (tokens.error) {
+                throw new Error(`GitHub Token Error: ${tokens.error_description || tokens.error}`);
+            }
+            // Busca os dados do usuário com o access token
+            const userResponse = await fetch('https://api.github.com/user', {
+                headers: {
+                    'Authorization': `Bearer ${tokens.access_token}`,
+                    'Accept': 'application/vnd.github.v3+json',
+                },
+            });
+            if (!userResponse.ok) {
+                throw new Error('Failed to fetch user data');
+            }
+            const githubUser = await userResponse.json();
+            // Lógica específica do GitHub: O email pode ser privado e não vir no objeto user principal
+            let email = githubUser.email;
+            if (!email) {
+                try {
+                    const emailsResponse = await fetch('https://api.github.com/user/emails', {
+                        headers: {
+                            'Authorization': `Bearer ${tokens.access_token}`,
+                            'Accept': 'application/vnd.github.v3+json',
+                        },
+                    });
+                    if (emailsResponse.ok) {
+                        const emails = await emailsResponse.json();
+                        // Tenta pegar o email primário e verificado, ou o primeiro disponível
+                        const primaryEmail = emails.find((e) => e.primary && e.verified) ||
+                            emails.find((e) => e.verified) ||
+                            emails[0];
+                        if (primaryEmail) {
+                            email = primaryEmail.email;
+                        }
+                    }
+                }
+                catch (emailError) {
+                    console.warn(`[${this.id} Provider] Could not fetch private emails`, emailError);
+                }
+            }
+            // Retorna o objeto User padronizado
+            return {
+                id: String(githubUser.id), // GitHub retorna ID numérico
+                name: githubUser.name || githubUser.login, // Fallback para o username se não tiver nome configurado
+                email: email,
+                image: githubUser.avatar_url || null,
+                provider: this.id,
+                providerId: String(githubUser.id),
+                accessToken: tokens.access_token,
+                // GitHub geralmente não retorna refresh tokens em Apps OAuth padrão (web flow)
+                // a menos que especificamente configurado, mas mantemos o campo se vier
+                refreshToken: tokens.refresh_token || undefined
+            };
+        }
+        catch (error) {
+            console.error(`[${this.id} Provider] Error during OAuth callback:`, error);
+            return null;
+        }
+    }
+    /**
+     * Gera a URL de autorização do GitHub
+     */
+    getAuthorizationUrl() {
+        const params = new URLSearchParams({
+            client_id: this.config.clientId,
+            redirect_uri: this.config.callbackUrl || '',
+            scope: (this.config.scope || this.defaultScope).join(' '),
+            // GitHub não usa 'response_type=code' explicitamente na URL padrão, mas aceita.
+            // O padrão é web application flow.
+        });
+        return `https://github.com/login/oauth/authorize?${params.toString()}`;
+    }
+    /**
+     * Retorna a 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.GithubProvider = GithubProvider;

package/dist/providers.d.ts

@@ -1,3 +1,4 @@
 export { CredentialsProvider } from './providers/credentials';
 export { DiscordProvider } from './providers/discord';
 export { GoogleProvider } from './providers/google';
+export { GithubProvider } from "./providers/github";

package/dist/providers.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GoogleProvider = exports.DiscordProvider = exports.CredentialsProvider = void 0;
+exports.GithubProvider = exports.GoogleProvider = exports.DiscordProvider = exports.CredentialsProvider = void 0;
 /*
  * This file is part of the Vatts.js Project.
  * Copyright (c) 2026 itsmuzin
@@ -24,3 +24,5 @@ var discord_1 = require("./providers/discord");
 Object.defineProperty(exports, "DiscordProvider", { enumerable: true, get: function () { return discord_1.DiscordProvider; } });
 var google_1 = require("./providers/google");
 Object.defineProperty(exports, "GoogleProvider", { enumerable: true, get: function () { return google_1.GoogleProvider; } });
+var github_1 = require("./providers/github");
+Object.defineProperty(exports, "GithubProvider", { enumerable: true, get: function () { return github_1.GithubProvider; } });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vatts/auth",
-  "version": "1.0.2-alpha.2",
+  "version": "1.0.2-alpha.4",
   "description": "Authentication package for Vatts.js framework",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -42,7 +42,7 @@
   "peerDependencies": {
     "react": "^19.2.0",
     "react-dom": "^19.2.0",
-    "vatts": "^1.0.2-alpha.2"
+    "vatts": "^1.0.2-alpha.4"
   },
   "peerDependenciesMeta": {
     "react-dom": {