@dudousxd/adonis-authkit-server 0.1.0

package/build/src/host/controllers/registration_controller.js

@@ -0,0 +1,169 @@
+import '../augmentations.js';
+import { brandFor } from '../branding.js';
+import { signupValidator, forgotPasswordValidator, resetPasswordValidator } from '../validators.js';
+import { sendPasswordResetEmail, sendEmailVerificationEmail } from '../default_mailer.js';
+import { translate } from '../i18n.js';
+export default class AuthRegistrationController {
+    /** GET /auth/interaction/:uid/signup — tela de cadastro (dentro do fluxo OIDC). */
+    async showSignup(ctx) {
+        const service = await ctx.containerResolver.make('authkit.server');
+        const cfg = service.config;
+        const render = cfg.render;
+        const details = await service.interactions.details(ctx);
+        const brand = brandFor(cfg.branding, details.params.client_id);
+        return render(ctx, 'signup', {
+            uid: details.uid,
+            csrfToken: ctx.request.csrfToken,
+            brand,
+        });
+    }
+    /** POST /auth/interaction/:uid/signup — cria o usuário e finaliza o login. */
+    async signup(ctx) {
+        const service = await ctx.containerResolver.make('authkit.server');
+        const cfg = service.config;
+        const render = cfg.render;
+        const details = await service.interactions.details(ctx);
+        const brand = brandFor(cfg.branding, details.params.client_id);
+        const data = await ctx.request.validateUsing(signupValidator);
+        const accountStore = cfg.accountStore;
+        const existing = await accountStore.findByEmail(data.email);
+        if (existing) {
+            return render(ctx, 'signup', {
+                uid: ctx.request.param('uid'),
+                csrfToken: ctx.request.csrfToken,
+                error: translate(cfg.messages, 'errors.email_taken'),
+                brand,
+            });
+        }
+        const created = await accountStore.create({
+            email: data.email,
+            password: data.password,
+            fullName: data.fullName,
+        });
+        await cfg.audit?.record({
+            type: 'signup',
+            accountId: created?.id ?? null,
+            email: data.email,
+            ip: ctx.request.ip?.() ?? null,
+            clientId: details.params.client_id ?? null,
+        });
+        // Finaliza a interaction como login (interactionFinished escreve o redirect 303 que
+        // retoma o authorize; o form nativo da tela segue esse redirect no sucesso).
+        const result = await service.interactions.login(ctx, {
+            email: data.email,
+            password: data.password,
+        });
+        if (!result.ok) {
+            return render(ctx, 'signup', {
+                uid: ctx.request.param('uid'),
+                csrfToken: ctx.request.csrfToken,
+                error: translate(cfg.messages, 'errors.signup_failed'),
+                brand,
+            });
+        }
+        // Verificação de e-mail (best-effort — não bloqueia nem reverte o login).
+        try {
+            const issued = await accountStore.issueEmailVerificationToken(data.email);
+            if (issued) {
+                await cfg.audit?.record({
+                    type: 'email_verification.issued',
+                    accountId: created?.id ?? null,
+                    email: data.email,
+                    ip: ctx.request.ip?.() ?? null,
+                });
+                const origin = `${ctx.request.protocol()}://${ctx.request.host()}`;
+                const verifyUrl = `${origin}/auth/verify-email?token=${issued.token}`;
+                // Hook do config tem prioridade (override); senão usa o mailer default do host.
+                if (cfg.mail?.onEmailVerification) {
+                    await cfg.mail.onEmailVerification({ email: data.email, verifyUrl, token: issued.token });
+                }
+                else {
+                    await sendEmailVerificationEmail(ctx, { email: data.email, verifyUrl });
+                }
+            }
+        }
+        catch (error) {
+            ctx.logger.error({ err: error, email: data.email }, 'authkit: falha ao enviar verificação de e-mail');
+        }
+    }
+    /** GET /auth/forgot-password — tela standalone. */
+    async showForgot(ctx) {
+        const service = await ctx.containerResolver.make('authkit.server');
+        const cfg = service.config;
+        const render = cfg.render;
+        return render(ctx, 'forgot', { csrfToken: ctx.request.csrfToken });
+    }
+    /** POST /auth/forgot-password — gera token e (dev) loga o link. Sempre responde sucesso (não vaza emails). */
+    async forgot(ctx) {
+        const service = await ctx.containerResolver.make('authkit.server');
+        const cfg = service.config;
+        const render = cfg.render;
+        const { email } = await ctx.request.validateUsing(forgotPasswordValidator);
+        const accountStore = cfg.accountStore;
+        const result = await accountStore.issuePasswordResetToken(email);
+        if (result) {
+            await cfg.audit?.record({
+                type: 'password_reset.issued',
+                email,
+                ip: ctx.request.ip?.() ?? null,
+            });
+            const origin = `${ctx.request.protocol()}://${ctx.request.host()}`;
+            const url = `${origin}/auth/reset-password?token=${result.token}`;
+            // Hook do config tem prioridade (override); senão usa o mailer default do host.
+            if (cfg.mail?.onPasswordReset) {
+                await cfg.mail.onPasswordReset({ email, resetUrl: url, token: result.token });
+            }
+            else {
+                await sendPasswordResetEmail(ctx, { email, resetUrl: url });
+            }
+        }
+        return render(ctx, 'forgot', {
+            csrfToken: ctx.request.csrfToken,
+            sent: true,
+        });
+    }
+    /** GET /auth/reset-password?token=... — tela standalone. */
+    async showReset(ctx) {
+        const service = await ctx.containerResolver.make('authkit.server');
+        const cfg = service.config;
+        const render = cfg.render;
+        const token = ctx.request.qs().token ?? '';
+        return render(ctx, 'reset', { token, csrfToken: ctx.request.csrfToken });
+    }
+    /** POST /auth/reset-password — redefine a senha. */
+    async reset(ctx) {
+        const service = await ctx.containerResolver.make('authkit.server');
+        const cfg = service.config;
+        const render = cfg.render;
+        const { token, password } = await ctx.request.validateUsing(resetPasswordValidator);
+        const accountStore = cfg.accountStore;
+        const ok = await accountStore.consumePasswordResetToken(token, password);
+        if (!ok) {
+            return ctx.response.badRequest({ error: translate(cfg.messages, 'errors.invalid_or_expired_token') });
+        }
+        await cfg.audit?.record({
+            type: 'password_reset.consumed',
+            ip: ctx.request.ip?.() ?? null,
+        });
+        return render(ctx, 'reset', {
+            token: '',
+            csrfToken: ctx.request.csrfToken,
+            done: true,
+        });
+    }
+    /** GET /auth/verify-email?token=... — consome o token e mostra sucesso/falha. */
+    async verifyEmail(ctx) {
+        const service = await ctx.containerResolver.make('authkit.server');
+        const cfg = service.config;
+        const render = cfg.render;
+        const token = ctx.request.qs().token ?? '';
+        const ok = await cfg.accountStore.consumeEmailVerificationToken(token);
+        if (ok) {
+            await cfg.audit?.record({
+                type: 'email_verification.consumed',
+                ip: ctx.request.ip?.() ?? null,
+            });
+        }
+        return render(ctx, 'verify-email', { verified: ok });
+    }
+}

package/build/src/host/controllers/social_controller.d.ts

@@ -0,0 +1,8 @@
+import '../augmentations.js';
+import type { HttpContext } from '@adonisjs/core/http';
+export default class AuthSocialController {
+    /** GET /auth/:provider/redirect/:uid — guarda o uid e redireciona para o provider OAuth. */
+    redirect(ctx: HttpContext): Promise<void>;
+    /** GET /auth/:provider/callback — retorno do provider → acha/cria AuthUser → conclui a interaction. */
+    callback(ctx: HttpContext): Promise<void>;
+}

package/build/src/host/controllers/social_controller.js

@@ -0,0 +1,82 @@
+import '../augmentations.js';
+import { randomUUID } from 'node:crypto';
+const UID_SESSION_KEY = 'authkit_social_uid';
+/**
+ * `AllyService.use()` é tipado contra a interface `SocialProviders`, que só é
+ * preenchida pelo HOST (a lib não conhece os providers configurados). Para um
+ * nome de provider dinâmico (vindo da rota), o retorno colapsa em `never`, então
+ * resolvemos via o contrato genérico do driver — sem cast pro `HttpContext` inteiro.
+ */
+function useProvider(ctx, provider) {
+    return ctx.ally.use(provider);
+}
+export default class AuthSocialController {
+    /** GET /auth/:provider/redirect/:uid — guarda o uid e redireciona para o provider OAuth. */
+    async redirect(ctx) {
+        const provider = ctx.request.param('provider');
+        ctx.session.put(UID_SESSION_KEY, ctx.request.param('uid'));
+        return useProvider(ctx, provider).redirect();
+    }
+    /** GET /auth/:provider/callback — retorno do provider → acha/cria AuthUser → conclui a interaction. */
+    async callback(ctx) {
+        const provider = ctx.request.param('provider');
+        const social = useProvider(ctx, provider);
+        const uid = ctx.session.get(UID_SESSION_KEY);
+        const backToLogin = uid ? `/auth/interaction/${uid}` : '/health';
+        if (social.accessDenied() || social.stateMisMatch() || social.hasError()) {
+            ctx.session.forget(UID_SESSION_KEY);
+            return ctx.response.redirect(backToLogin);
+        }
+        const profile = await social.user();
+        // `profile.id` é o id estável do usuário no provider — independe do e-mail.
+        if (!profile.id) {
+            ctx.session.forget(UID_SESSION_KEY);
+            return ctx.response.redirect(backToLogin);
+        }
+        const service = await ctx.containerResolver.make('authkit.server');
+        const cfg = service.config;
+        const store = cfg.accountStore;
+        const email = profile.email ?? undefined;
+        // Precedência do account linking:
+        //  1. Identidade de provider já ligada → loga essa conta.
+        //  2. Senão, e-mail conhecido → acha por e-mail e LIGA a identidade (linking).
+        //  3. Senão → cria conta nova e liga a identidade.
+        let user = await store.findByProviderIdentity(provider, profile.id);
+        if (!user && email) {
+            const byEmail = await store.findByEmail(email);
+            if (byEmail) {
+                await store.linkProviderIdentity({
+                    accountId: byEmail.id,
+                    provider,
+                    providerUserId: profile.id,
+                    email,
+                });
+                user = byEmail;
+            }
+        }
+        if (!user) {
+            // Sem e-mail não há como criar/identificar uma conta — volta ao login.
+            if (!email) {
+                ctx.session.forget(UID_SESSION_KEY);
+                return ctx.response.redirect(backToLogin);
+            }
+            const created = await store.create({
+                email,
+                password: randomUUID(),
+                fullName: profile.name ?? null,
+                emailVerified: true,
+            });
+            await store.linkProviderIdentity({
+                accountId: created.id,
+                provider,
+                providerUserId: profile.id,
+                email,
+            });
+            user = created;
+        }
+        ctx.session.forget(UID_SESSION_KEY);
+        // Conclui a interaction OIDC para este usuário (escreve o 303 de volta ao authorize).
+        // O cookie de interaction (path '/') sobrevive ao round-trip do provider OAuth.
+        await service.interactions.completeLogin(ctx, user.id);
+    }
+}

package/build/src/host/default_mailer.d.ts

@@ -0,0 +1,39 @@
+import type { HttpContext } from '@adonisjs/core/http';
+/**
+ * Envio de e-mail default do host-kit, usando o mailer `default` do host via
+ * `@adonisjs/mail`. Permite que o dev não escreva nenhum hook: por padrão os
+ * e-mails de reset de senha / verificação são enviados pelo mailer já configurado
+ * no app, com HTML responsivo + branding (do `config/authkit.ts`) e fallback texto.
+ * Os hooks de `config/authkit.ts` (`mail.onPasswordReset` /
+ * `mail.onEmailVerification`), quando presentes, têm prioridade (override).
+ *
+ * Best-effort: se `@adonisjs/mail` não estiver instalado/configurado, cai no
+ * fallback de log (mesmo comportamento de antes) e NUNCA lança na request.
+ */
+/**
+ * Service do `@adonisjs/mail` resolvido de forma preguiçosa. Tipado como `any` de
+ * propósito: a lib NÃO depende do mail em tempo de compilação (peer/opt-in).
+ */
+type MailService = any;
+/**
+ * Permite reapontar/limpar o loader do mail (usado em testes).
+ * @internal
+ */
+export declare function __setMailLoaderForTests(fn: (() => Promise<MailService | null>) | undefined): void;
+/**
+ * Envia o e-mail de redefinição de senha pelo mailer default do host.
+ * Best-effort: no fallback (sem mail) loga o link; nunca lança.
+ */
+export declare function sendPasswordResetEmail(ctx: HttpContext, data: {
+    email: string;
+    resetUrl: string;
+}): Promise<void>;
+/**
+ * Envia o e-mail de verificação pelo mailer default do host.
+ * Best-effort: no fallback (sem mail) loga o link; nunca lança.
+ */
+export declare function sendEmailVerificationEmail(ctx: HttpContext, data: {
+    email: string;
+    verifyUrl: string;
+}): Promise<void>;
+export {};

package/build/src/host/default_mailer.js

@@ -0,0 +1,141 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { renderTransactionalEmail } from './email_templates.js';
+let mailServicePromise;
+/**
+ * Importa o service de mail do HOST de forma preguiçosa e fail-safe.
+ * Se `@adonisjs/mail` não estiver instalado, resolve `null`.
+ */
+async function loadMail() {
+    if (!mailServicePromise) {
+        // Indireção via variável: o `@adonisjs/mail` é peer/opcional e pode não estar
+        // instalado na lib, então o specifier não é resolvido em build-time.
+        const specifier = '@adonisjs/mail/services/main';
+        mailServicePromise = import(__rewriteRelativeImportExtension(specifier))
+            .then((mod) => mod.default ?? null)
+            .catch(() => null);
+    }
+    return mailServicePromise;
+}
+/**
+ * Permite reapontar/limpar o loader do mail (usado em testes).
+ * @internal
+ */
+export function __setMailLoaderForTests(fn) {
+    if (fn) {
+        mailServicePromise = fn();
+    }
+    else {
+        mailServicePromise = undefined;
+    }
+}
+/**
+ * Tenta descobrir o `from` default da config de mail do host. Se não houver,
+ * retorna `undefined` (deixa o @adonisjs/mail aplicar o default da própria config).
+ */
+function defaultFrom(ctx) {
+    try {
+        // Alcançamos a config de `mail` do HOST via o resolver do container. Esse
+        // formato é específico do app (a lib não conhece o shape da config de mail
+        // nem `containerResolver.app` é público), então tipamos apenas ESTE acesso
+        // como `unknown`/cast estreito — não o `HttpContext` inteiro.
+        const resolver = ctx.containerResolver;
+        const cfg = resolver.app?.config?.get?.('mail');
+        const from = cfg?.from;
+        if (from)
+            return from;
+    }
+    catch {
+        // sem config de mail resolvível — deixa o @adonisjs/mail decidir.
+    }
+    return undefined;
+}
+/**
+ * Resolve a marca default a partir do `config/authkit.ts` (branding.default +
+ * company). Usada para o cabeçalho/cor de acento/rodapé dos e-mails. Cai num
+ * default neutro se a config não for resolvível.
+ */
+function resolveBrand(ctx) {
+    try {
+        const resolver = ctx.containerResolver;
+        const branding = resolver.app?.config?.get?.('authkit')?.branding;
+        if (branding) {
+            return {
+                appName: branding.default?.appName || branding.company || 'AuthKit',
+                accent: branding.default?.accent,
+                company: branding.company,
+            };
+        }
+    }
+    catch {
+        // sem config authkit resolvível — usa default neutro.
+    }
+    return { appName: 'AuthKit' };
+}
+async function sendEmail(ctx, to, content) {
+    const mail = await loadMail();
+    if (!mail)
+        return false;
+    const from = defaultFrom(ctx);
+    await mail.send((message) => {
+        if (from)
+            message.from(from);
+        message.to(to).subject(content.subject).html(content.html).text(content.text);
+    });
+    return true;
+}
+/**
+ * Envia o e-mail de redefinição de senha pelo mailer default do host.
+ * Best-effort: no fallback (sem mail) loga o link; nunca lança.
+ */
+export async function sendPasswordResetEmail(ctx, data) {
+    try {
+        const brand = resolveBrand(ctx);
+        const content = renderTransactionalEmail({
+            brand,
+            subject: 'Redefinição de senha',
+            heading: 'Redefinição de senha',
+            intro: `Recebemos um pedido para redefinir a senha da sua conta em ${brand.appName}. Clique no botão abaixo para escolher uma nova senha. Se não foi você, ignore este e-mail.`,
+            ctaLabel: 'Redefinir senha',
+            ctaUrl: data.resetUrl,
+            footnote: 'Por segurança, este link expira em breve e só pode ser usado uma vez.',
+        });
+        const sent = await sendEmail(ctx, data.email, content);
+        if (!sent) {
+            ctx.logger.info({ resetUrl: data.resetUrl, email: data.email }, 'authkit: link de redefinição de senha (dev — @adonisjs/mail ausente)');
+        }
+    }
+    catch (error) {
+        ctx.logger.error({ err: error, email: data.email }, 'authkit: falha ao enviar e-mail de redefinição de senha');
+    }
+}
+/**
+ * Envia o e-mail de verificação pelo mailer default do host.
+ * Best-effort: no fallback (sem mail) loga o link; nunca lança.
+ */
+export async function sendEmailVerificationEmail(ctx, data) {
+    try {
+        const brand = resolveBrand(ctx);
+        const content = renderTransactionalEmail({
+            brand,
+            subject: 'Verifique seu e-mail',
+            heading: 'Confirme seu e-mail',
+            intro: `Bem-vindo(a) ao ${brand.appName}! Confirme seu endereço de e-mail clicando no botão abaixo para ativar sua conta.`,
+            ctaLabel: 'Verificar e-mail',
+            ctaUrl: data.verifyUrl,
+        });
+        const sent = await sendEmail(ctx, data.email, content);
+        if (!sent) {
+            ctx.logger.info({ verifyUrl: data.verifyUrl, email: data.email }, 'authkit: link de verificação de e-mail (dev — @adonisjs/mail ausente)');
+        }
+    }
+    catch (error) {
+        ctx.logger.error({ err: error, email: data.email }, 'authkit: falha ao enviar verificação de e-mail');
+    }
+}

package/build/src/host/email_templates.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Renderização de e-mails transacionais do host-kit (reset de senha / verificação).
+ *
+ * Sem dependências (template literals) e com HTML email-safe: estilos inline,
+ * layout em tabela centralizada, botão de CTA com a cor de acento da marca, e
+ * sempre um corpo `text` de fallback. Branding vem do `config/authkit.ts`
+ * (`branding.default` ou a marca do client). Tudo escapado para evitar injeção.
+ */
+export interface EmailContent {
+    subject: string;
+    html: string;
+    text: string;
+}
+interface EmailTemplateInput {
+    /** Marca usada no cabeçalho/botão/rodapé (accent/company opcionais). */
+    brand: {
+        appName: string;
+        accent?: string;
+        company?: string;
+    };
+    /** Assunto do e-mail. */
+    subject: string;
+    /** Saudação/título dentro do card. */
+    heading: string;
+    /** Parágrafo de introdução (texto puro, será escapado). */
+    intro: string;
+    /** Rótulo do botão de CTA. */
+    ctaLabel: string;
+    /** URL do CTA. */
+    ctaUrl: string;
+    /** Linha auxiliar abaixo do botão (ex.: validade do link). */
+    footnote?: string;
+}
+export declare function renderTransactionalEmail(input: EmailTemplateInput): EmailContent;
+export {};

package/build/src/host/email_templates.js

@@ -0,0 +1,66 @@
+/**
+ * Renderização de e-mails transacionais do host-kit (reset de senha / verificação).
+ *
+ * Sem dependências (template literals) e com HTML email-safe: estilos inline,
+ * layout em tabela centralizada, botão de CTA com a cor de acento da marca, e
+ * sempre um corpo `text` de fallback. Branding vem do `config/authkit.ts`
+ * (`branding.default` ou a marca do client). Tudo escapado para evitar injeção.
+ */
+/** Escapa texto para interpolação segura em HTML. */
+function esc(value) {
+    return value
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&#39;');
+}
+const FALLBACK_ACCENT = '#4f46e5';
+export function renderTransactionalEmail(input) {
+    const appName = input.brand.appName || input.brand.company || 'AuthKit';
+    const accent = input.brand.accent || FALLBACK_ACCENT;
+    const company = input.brand.company || appName;
+    const year = '©'; // ano resolvido fora (sem Date.* aqui); rodapé usa só o nome.
+    const html = `<!doctype html>
+<html lang="pt-BR">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>${esc(input.subject)}</title>
+</head>
+<body style="margin:0;padding:0;background:#f3f4f6;font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,Helvetica,Arial,sans-serif;">
+<table role="presentation" width="100%" cellpadding="0" cellspacing="0" style="background:#f3f4f6;padding:32px 12px;">
+<tr><td align="center">
+<table role="presentation" width="100%" cellpadding="0" cellspacing="0" style="max-width:480px;background:#ffffff;border-radius:14px;overflow:hidden;box-shadow:0 1px 3px rgba(0,0,0,.08);">
+<tr><td style="background:${esc(accent)};padding:20px 28px;">
+<span style="color:#ffffff;font-size:18px;font-weight:700;letter-spacing:.2px;">${esc(appName)}</span>
+</td></tr>
+<tr><td style="padding:32px 28px 8px;">
+<h1 style="margin:0 0 12px;font-size:20px;line-height:1.3;color:#111827;">${esc(input.heading)}</h1>
+<p style="margin:0 0 24px;font-size:15px;line-height:1.6;color:#374151;">${esc(input.intro)}</p>
+<table role="presentation" cellpadding="0" cellspacing="0"><tr><td style="border-radius:8px;background:${esc(accent)};">
+<a href="${esc(input.ctaUrl)}" style="display:inline-block;padding:12px 24px;font-size:15px;font-weight:600;color:#ffffff;text-decoration:none;border-radius:8px;">${esc(input.ctaLabel)}</a>
+</td></tr></table>
+${input.footnote ? `<p style="margin:24px 0 0;font-size:13px;line-height:1.5;color:#6b7280;">${esc(input.footnote)}</p>` : ''}
+<p style="margin:24px 0 0;font-size:13px;line-height:1.5;color:#6b7280;">Se o botão não funcionar, copie e cole este link no navegador:<br><a href="${esc(input.ctaUrl)}" style="color:${esc(accent)};word-break:break-all;">${esc(input.ctaUrl)}</a></p>
+</td></tr>
+<tr><td style="padding:24px 28px 28px;border-top:1px solid #f3f4f6;">
+<p style="margin:0;font-size:12px;line-height:1.5;color:#9ca3af;">${esc(company)} ${year}</p>
+</td></tr>
+</table>
+</td></tr>
+</table>
+</body>
+</html>`;
+    const text = [
+        input.heading,
+        '',
+        input.intro,
+        '',
+        `${input.ctaLabel}: ${input.ctaUrl}`,
+        ...(input.footnote ? ['', input.footnote] : []),
+        '',
+        `— ${company}`,
+    ].join('\n');
+    return { subject: input.subject, html, text };
+}