@dudousxd/adonis-authkit-server 0.6.0 → 0.7.0

package/build/host/views/account/security.edge

@@ -33,13 +33,26 @@
       <div class="mb-6 rounded-xl bg-white p-6 shadow-sm ring-1 ring-black/5">
         <h2 class="mb-1 text-sm font-semibold text-gray-900">{{ t('account.profile.section') }}</h2>
         <p class="mb-4 text-xs text-gray-500">{{ t('account.profile.intro') }}</p>
-        <form method="POST" action="/account/security/profile" class="space-y-4">
+        <form method="POST" action="/account/security/profile" enctype="multipart/form-data" class="space-y-4">
           <input type="hidden" name="_csrf" value="{{ csrfToken }}">
+          @if(avatarUrl)
+            <div>
+              <img src="{{ avatarUrl }}" alt="avatar" class="h-16 w-16 rounded-full object-cover ring-1 ring-black/5" />
+            </div>
+          @end
           <div>
             <label class="mb-1 block text-sm font-medium text-gray-700">{{ t('account.profile.name_label') }}</label>
             <input name="name" type="text" value="{{ name }}" maxlength="255"
               class="w-full rounded-lg border border-gray-300 px-3 py-2 text-sm outline-none focus:border-gray-900" />
           </div>
+          @if(avatarUploadSupported)
+            <div>
+              <label class="mb-1 block text-sm font-medium text-gray-700">{{ t('account.profile.avatar_upload_label') }}</label>
+              <input name="avatar" type="file" accept="image/jpeg,image/png,image/webp"
+                class="w-full rounded-lg border border-gray-300 px-3 py-2 text-sm outline-none focus:border-gray-900" />
+              <p class="mt-1 text-xs text-gray-500">{{ t('account.profile.avatar_upload_hint') }}</p>
+            </div>
+          @end
           <div>
             <label class="mb-1 block text-sm font-medium text-gray-700">{{ t('account.profile.avatar_label') }}</label>
             <input name="avatarUrl" type="url" value="{{ avatarUrl }}"

package/build/src/define_config.d.ts

@@ -161,6 +161,31 @@ export interface ResolvedDeviceFlowConfig {
     enabled: boolean;
 }
 export declare function resolveDeviceFlow(input?: DeviceFlowConfigInput): ResolvedDeviceFlowConfig;
+/**
+ * Uploads — usa o `@adonisjs/drive` JÁ configurado no app (mesmo princípio do
+ * mailer/limiter: a infra do host por padrão, sobreponível aqui). Hoje cobre o
+ * upload de avatar no console de conta. Se o drive estiver ausente, a feature
+ * degrada para o input de URL.
+ */
+export interface UploadsConfigInput {
+    avatars?: {
+        /** Disk do `@adonisjs/drive` a usar. Default: o disk DEFAULT do app. */
+        disk?: string;
+        /** Diretório/prefixo das chaves. Default: 'authkit/avatars'. */
+        directory?: string;
+        /** Tamanho máximo em MB. Default: 5. */
+        maxSizeMb?: number;
+    };
+}
+export interface ResolvedUploadsConfig {
+    avatars: {
+        /** Disk explícito; `undefined` = disk DEFAULT do app. */
+        disk?: string;
+        directory: string;
+        maxSizeMb: number;
+    };
+}
+export declare function resolveUploads(input?: UploadsConfigInput): ResolvedUploadsConfig;
 /**
  * DPoP — Demonstrating Proof of Possession (RFC 9449). Quando habilitado, o
  * oidc-provider aceita DPoP proofs e emite tokens sender-constrained
@@ -337,6 +362,8 @@ export interface AuthServerConfigInput {
     dynamicRegistration?: DynamicRegistrationConfigInput;
     /** Device Authorization Grant (RFC 8628). Default: desligado. */
     deviceFlow?: DeviceFlowConfigInput;
+    /** Uploads (avatar) via o `@adonisjs/drive` do app. Default: drive default, 5MB. */
+    uploads?: UploadsConfigInput;
     /** DPoP — sender-constrained tokens (RFC 9449). Default: desligado. */
     dpop?: DpopConfigInput;
     /** Pushed Authorization Requests (RFC 9126). Default: desligado. */
@@ -401,6 +428,8 @@ export interface ResolvedServerConfig {
     dynamicRegistration: ResolvedDynamicRegistrationConfig;
     /** Device Authorization Grant resolvido (default desligado). */
     deviceFlow: ResolvedDeviceFlowConfig;
+    /** Uploads resolvido (avatar via drive do app; sempre presente). */
+    uploads: ResolvedUploadsConfig;
     /** DPoP resolvido (default desligado). */
     dpop: ResolvedDpopConfig;
     /** PAR resolvido (default desligado). */

package/build/src/define_config.js

@@ -56,6 +56,15 @@ export function resolveDynamicRegistration(input) {
 export function resolveDeviceFlow(input) {
     return { enabled: input?.enabled ?? false };
 }
+export function resolveUploads(input) {
+    return {
+        avatars: {
+            disk: input?.avatars?.disk,
+            directory: input?.avatars?.directory ?? 'authkit/avatars',
+            maxSizeMb: input?.avatars?.maxSizeMb ?? 5,
+        },
+    };
+}
 export function resolveDpop(input) {
     return { enabled: input?.enabled ?? false };
 }
@@ -173,6 +182,7 @@ export function defineConfig(config) {
             webauthn: resolveWebauthn(config.issuer, config.mfaIssuer ?? 'AuthKit', config.webauthn),
             dynamicRegistration: resolveDynamicRegistration(config.dynamicRegistration),
             deviceFlow: resolveDeviceFlow(config.deviceFlow),
+            uploads: resolveUploads(config.uploads),
             dpop: resolveDpop(config.dpop),
             par: resolvePar(config.par),
             stepUp: resolveStepUp(config.stepUp),

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

@@ -0,0 +1,58 @@
+import type { HttpContext } from '@adonisjs/core/http';
+import type { ResolvedUploadsConfig } from '../define_config.js';
+/**
+ * Upload de avatar do host-kit usando o `@adonisjs/drive` JÁ configurado no app.
+ * Mesmo princípio do default_mailer/rate_limit: por padrão usamos a infra do
+ * host (o disk DEFAULT do drive do app), sem o dev precisar escrever nada; tudo
+ * é sobreponível via `config/authkit.ts` (`uploads.avatars`).
+ *
+ * Best-effort / fail-safe: se `@adonisjs/drive` não estiver instalado/configurado,
+ * {@link storeAvatar} retorna `null` e a feature degrada para o input de URL.
+ * Nunca lança na request por causa de drive ausente.
+ */
+/**
+ * Service do `@adonisjs/drive` resolvido de forma preguiçosa. Tipado como `any` de
+ * propósito: a lib NÃO depende do drive em tempo de compilação (peer/opt-in).
+ */
+type DriveService = any;
+/**
+ * Permite reapontar/limpar o loader do drive (usado em testes).
+ * @internal
+ */
+export declare function __setDriveLoaderForTests(fn: (() => Promise<DriveService | null>) | undefined): void;
+/** Erro de validação do upload (mensagem já localizada no controller). */
+export declare class AvatarUploadError extends Error {
+    reason: 'extname' | 'size';
+    constructor(reason: 'extname' | 'size', message: string);
+}
+/** File de multipart mínimo que precisamos do `request.file('avatar')`. */
+export interface UploadedAvatar {
+    extname?: string | null;
+    size?: number;
+    /** Caminho temporário (drive lê daqui para stream). */
+    tmpPath?: string | null;
+    /** Move o arquivo para um disk do drive (API v3+). */
+    moveToDisk?: (key: string, options?: {
+        disk?: string;
+    }) => Promise<void>;
+}
+/**
+ * Indica se o drive do app está disponível (para a view decidir mostrar o input
+ * de arquivo). Best-effort: nunca lança.
+ */
+export declare function isDriveAvailable(): Promise<boolean>;
+/**
+ * Armazena o avatar no drive do host e retorna a URL pública.
+ *
+ * - Valida extensão (jpg/jpeg/png/webp) e tamanho (≤ maxSizeMb) — lança
+ *   {@link AvatarUploadError} se inválido (o controller traduz/flasha).
+ * - Usa o disk configurado em `uploads.avatars.disk` ou o disk DEFAULT do app.
+ * - Se o drive estiver ausente/não-configurado → retorna `null` (degrada para URL).
+ *
+ * Nunca lança por causa de drive ausente; só lança em validação.
+ */
+export declare function storeAvatar(_ctx: HttpContext, cfg: ResolvedUploadsConfig, file: UploadedAvatar, accountId: string, messages: {
+    extname: string;
+    size: string;
+}): Promise<string | null>;
+export {};

package/build/src/host/avatar_storage.js

@@ -0,0 +1,125 @@
+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;
+};
+let driveServicePromise;
+/**
+ * Importa o service de drive do HOST de forma preguiçosa e fail-safe.
+ * Se `@adonisjs/drive` não estiver instalado, resolve `null`.
+ */
+async function loadDrive() {
+    if (!driveServicePromise) {
+        // Indireção via variável: o `@adonisjs/drive` é peer/opcional e pode não estar
+        // instalado na lib, então o specifier não é resolvido em build-time.
+        const specifier = '@adonisjs/drive/services/main';
+        driveServicePromise = import(__rewriteRelativeImportExtension(specifier))
+            .then((mod) => mod.default ?? null)
+            .catch(() => null);
+    }
+    return driveServicePromise;
+}
+/**
+ * Permite reapontar/limpar o loader do drive (usado em testes).
+ * @internal
+ */
+export function __setDriveLoaderForTests(fn) {
+    if (fn) {
+        driveServicePromise = fn();
+    }
+    else {
+        driveServicePromise = undefined;
+    }
+}
+/** Extensões aceitas para o avatar (imagem raster comum). */
+const ALLOWED_EXTNAMES = ['jpg', 'jpeg', 'png', 'webp'];
+/** Erro de validação do upload (mensagem já localizada no controller). */
+export class AvatarUploadError extends Error {
+    reason;
+    constructor(reason, message) {
+        super(message);
+        this.reason = reason;
+        this.name = 'AvatarUploadError';
+    }
+}
+/**
+ * Indica se o drive do app está disponível (para a view decidir mostrar o input
+ * de arquivo). Best-effort: nunca lança.
+ */
+export async function isDriveAvailable() {
+    return (await loadDrive()) !== null;
+}
+/**
+ * Resolve a extensão validada do arquivo enviado.
+ * Lança {@link AvatarUploadError} se ext/size forem inválidos.
+ */
+function validate(file, cfg, messages) {
+    const ext = (file.extname ?? '').toLowerCase().replace(/^\./, '');
+    if (!ALLOWED_EXTNAMES.includes(ext)) {
+        throw new AvatarUploadError('extname', messages.extname);
+    }
+    const maxBytes = cfg.avatars.maxSizeMb * 1024 * 1024;
+    if (typeof file.size === 'number' && file.size > maxBytes) {
+        throw new AvatarUploadError('size', messages.size);
+    }
+    return ext;
+}
+/**
+ * Gera uma chave única para o avatar dentro do diretório configurado.
+ * `${directory}/${accountId}-${random}.${ext}`
+ */
+function buildKey(cfg, accountId, ext) {
+    const random = Math.random().toString(36).slice(2, 10);
+    return `${cfg.avatars.directory}/${accountId}-${random}.${ext}`;
+}
+/**
+ * Armazena o avatar no drive do host e retorna a URL pública.
+ *
+ * - Valida extensão (jpg/jpeg/png/webp) e tamanho (≤ maxSizeMb) — lança
+ *   {@link AvatarUploadError} se inválido (o controller traduz/flasha).
+ * - Usa o disk configurado em `uploads.avatars.disk` ou o disk DEFAULT do app.
+ * - Se o drive estiver ausente/não-configurado → retorna `null` (degrada para URL).
+ *
+ * Nunca lança por causa de drive ausente; só lança em validação.
+ */
+export async function storeAvatar(_ctx, cfg, file, accountId, messages) {
+    const drive = await loadDrive();
+    if (!drive)
+        return null;
+    const ext = validate(file, cfg, messages);
+    // Resolve o disk: o configurado, ou o DEFAULT do drive do app.
+    let disk;
+    try {
+        disk = cfg.avatars.disk ? drive.use(cfg.avatars.disk) : drive.use();
+    }
+    catch {
+        // disk inválido/não-configurado — degrada para URL.
+        return null;
+    }
+    if (!disk)
+        return null;
+    const key = buildKey(cfg, accountId || 'account', ext);
+    // API @adonisjs/drive v3+: o file de multipart move-se direto para o disk.
+    // `moveToDisk` lê do tmpPath e usa o disk informado (ou o default da config).
+    if (typeof file.moveToDisk === 'function') {
+        await file.moveToDisk(key, cfg.avatars.disk ? { disk: cfg.avatars.disk } : undefined);
+    }
+    else if (file.tmpPath) {
+        // Fallback: lê do tmpPath e escreve via putStream no disk resolvido.
+        const fs = await import('node:fs');
+        await disk.putStream(key, fs.createReadStream(file.tmpPath));
+    }
+    else {
+        return null;
+    }
+    try {
+        return await disk.getUrl(key);
+    }
+    catch {
+        // disk sem getUrl público — retorna a key como referência relativa.
+        return key;
+    }
+}

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

@@ -3,6 +3,7 @@ import { ACCOUNT_SESSION_KEY } from '../middleware/account_auth.js';
 import { supportsAccountSecurity, supportsProfile } from '../../accounts/account_store.js';
 import { changePasswordValidator, changeEmailValidator, updateProfileValidator } from '../validators.js';
 import { sendEmailChangeConfirmationEmail } from '../default_mailer.js';
+import { storeAvatar, isDriveAvailable, AvatarUploadError } from '../avatar_storage.js';
 import { translate } from '../i18n.js';
 import { TRUSTED_DEVICE_COOKIE } from '../trusted_device.js';
 /**
@@ -23,6 +24,8 @@ export default class AccountSecurityController {
             csrfToken: ctx.request.csrfToken,
             supported: supportsAccountSecurity(cfg.accountStore),
             profileSupported: supportsProfile(cfg.accountStore),
+            // Só mostramos o input de arquivo se o drive do app estiver disponível.
+            avatarUploadSupported: await isDriveAvailable(),
             email: account?.email ?? '',
             name: account?.name ?? '',
             avatarUrl: account?.avatarUrl ?? '',
@@ -64,16 +67,45 @@ export default class AccountSecurityController {
             return ctx.response.redirect('/account/security');
         }
         const { name, avatarUrl } = await ctx.request.validateUsing(updateProfileValidator);
+        // Upload de avatar via o drive do app (opt-in pela presença do arquivo).
+        // Se um arquivo for enviado e o drive estiver disponível, a URL resultante
+        // tem prioridade sobre o input de URL; senão caímos no avatarUrl (texto).
+        let resolvedAvatarUrl = avatarUrl ?? null;
+        let via = 'url';
+        const file = ctx.request.file('avatar', {
+            size: `${cfg.uploads.avatars.maxSizeMb}mb`,
+            extnames: ['jpg', 'jpeg', 'png', 'webp'],
+        });
+        if (file) {
+            try {
+                const uploadedUrl = await storeAvatar(ctx, cfg.uploads, file, userId, {
+                    extname: translate(cfg.messages, 'account.profile.avatar_invalid_type'),
+                    size: translate(cfg.messages, 'account.profile.avatar_too_large'),
+                });
+                if (uploadedUrl) {
+                    resolvedAvatarUrl = uploadedUrl;
+                    via = 'upload';
+                }
+            }
+            catch (error) {
+                if (error instanceof AvatarUploadError) {
+                    ctx.session.flash('securityError', error.message);
+                    return ctx.response.redirect('/account/security');
+                }
+                throw error;
+            }
+        }
         // Campos ausentes no form viram string vazia (limpa o valor); enviamos null
         // para limpar, ou o valor trimado.
         await store.updateProfile(userId, {
             name: name ?? null,
-            avatarUrl: avatarUrl ?? null,
+            avatarUrl: resolvedAvatarUrl,
         });
         await cfg.audit?.record({
             type: 'profile.updated',
             accountId: userId,
             ip: ctx.request.ip?.() ?? null,
+            metadata: { via },
         });
         ctx.session.flash('profileUpdated', translate(cfg.messages, 'account.profile.updated'));
         return ctx.response.redirect('/account/security');

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

@@ -133,6 +133,10 @@ export declare const DEFAULT_MESSAGES: {
     'account.profile.intro': string;
     'account.profile.name_label': string;
     'account.profile.avatar_label': string;
+    'account.profile.avatar_upload_label': string;
+    'account.profile.avatar_upload_hint': string;
+    'account.profile.avatar_invalid_type': string;
+    'account.profile.avatar_too_large': string;
     'account.profile.submit': string;
     'account.profile.updated': string;
     'account.profile.not_supported': string;
@@ -432,6 +436,10 @@ export declare const PT_BR_MESSAGES: {
     'account.profile.intro': string;
     'account.profile.name_label': string;
     'account.profile.avatar_label': string;
+    'account.profile.avatar_upload_label': string;
+    'account.profile.avatar_upload_hint': string;
+    'account.profile.avatar_invalid_type': string;
+    'account.profile.avatar_too_large': string;
     'account.profile.submit': string;
     'account.profile.updated': string;
     'account.profile.not_supported': string;

package/build/src/host/i18n.js

@@ -135,6 +135,10 @@ export const DEFAULT_MESSAGES = {
     'account.profile.intro': 'Update your display name and avatar.',
     'account.profile.name_label': 'Name',
     'account.profile.avatar_label': 'Avatar URL',
+    'account.profile.avatar_upload_label': 'Upload avatar',
+    'account.profile.avatar_upload_hint': 'JPG, PNG or WebP, up to 5MB.',
+    'account.profile.avatar_invalid_type': 'Invalid image type. Use JPG, PNG or WebP.',
+    'account.profile.avatar_too_large': 'Image is too large.',
     'account.profile.submit': 'Save profile',
     'account.profile.updated': 'Profile updated successfully.',
     'account.profile.not_supported': 'Profile editing is not available in this installation.',
@@ -463,6 +467,10 @@ export const PT_BR_MESSAGES = {
     'account.profile.intro': 'Atualize seu nome de exibição e avatar.',
     'account.profile.name_label': 'Nome',
     'account.profile.avatar_label': 'URL do avatar',
+    'account.profile.avatar_upload_label': 'Enviar avatar',
+    'account.profile.avatar_upload_hint': 'JPG, PNG ou WebP, até 5MB.',
+    'account.profile.avatar_invalid_type': 'Tipo de imagem inválido. Use JPG, PNG ou WebP.',
+    'account.profile.avatar_too_large': 'A imagem é muito grande.',
     'account.profile.submit': 'Salvar perfil',
     'account.profile.updated': 'Perfil atualizado com sucesso.',
     'account.profile.not_supported': 'A edição de perfil não está disponível nesta instalação.',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dudousxd/adonis-authkit-server",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "AdonisJS OIDC/OAuth2 provider (Identity Provider) toolkit: ejectable auth server with sessions, rate-limiting, MFA/TOTP, audit log, federated logout and OpenTelemetry metrics.",
   "license": "MIT",
   "author": "dudousxd",
@@ -54,6 +54,7 @@
   "peerDependencies": {
     "@adonisjs/ally": "6.3.0",
     "@adonisjs/core": "7.3.3",
+    "@adonisjs/drive": "4.0.0",
     "@adonisjs/lucid": "22.4.2",
     "@adonisjs/session": "8.1.0",
     "@adonisjs/shield": "9.0.0",
@@ -65,6 +66,9 @@
     },
     "@adonisjs/ally": {
       "optional": true
+    },
+    "@adonisjs/drive": {
+      "optional": true
     }
   },
   "dependencies": {
@@ -81,6 +85,7 @@
   "devDependencies": {
     "@adonisjs/ally": "6.3.0",
     "@adonisjs/core": "7.3.3",
+    "@adonisjs/drive": "4.0.0",
     "@adonisjs/lucid": "22.4.2",
     "@adonisjs/session": "8.1.0",
     "@adonisjs/shield": "9.0.0",