@adonis-agora/authkit-server 0.43.0 → 0.45.0

package/build/src/define_config.d.ts

@@ -249,19 +249,36 @@ export declare function resolveDeviceFlow(input?: DeviceFlowConfigInput): Resolv
  */
 export interface UploadsConfigInput {
     avatars?: {
-        /** Disk do `@adonisjs/drive` a usar. Default: o disk DEFAULT do app. */
+        /**
+         * Backend de storage do avatar. Default: `'auto'` (media se
+         * `@adonis-agora/media` estiver presente/configurado, senão o drive builtin).
+         * `'builtin'` força o `@adonisjs/drive`; `'media'` força o media (degrada para
+         * o input de URL se indisponível).
+         */
+        storage?: "auto" | "builtin" | "media";
+        /** Disk do `@adonisjs/drive` a usar (backend builtin). Default: o disk DEFAULT do app. */
         disk?: string;
-        /** Diretório/prefixo das chaves. Default: 'authkit/avatars'. */
+        /** Diretório/prefixo das chaves (backend builtin). Default: 'authkit/avatars'. */
         directory?: string;
+        /** Collection single-file do media (backend media). Default: 'avatar'. */
+        collection?: string;
+        /** ownerType do media (backend media). Default: 'AuthAccount'. */
+        ownerType?: string;
         /** Tamanho máximo em MB. Default: 5. */
         maxSizeMb?: number;
     };
 }
 export interface ResolvedUploadsConfig {
     avatars: {
-        /** Disk explícito; `undefined` = disk DEFAULT do app. */
+        /** Backend ativo (default 'auto'). */
+        storage: "auto" | "builtin" | "media";
+        /** Disk explícito; `undefined` = disk DEFAULT do app (backend builtin). */
         disk?: string;
         directory: string;
+        /** Collection single-file do media (backend media). */
+        collection: string;
+        /** ownerType do media (backend media). */
+        ownerType: string;
         maxSizeMb: number;
     };
 }

package/build/src/define_config.js

@@ -67,8 +67,11 @@ export function resolveDeviceFlow(input) {
 export function resolveUploads(input) {
     return {
         avatars: {
+            storage: input?.avatars?.storage ?? "auto",
             disk: input?.avatars?.disk,
             directory: input?.avatars?.directory ?? "authkit/avatars",
+            collection: input?.avatars?.collection ?? "avatar",
+            ownerType: input?.avatars?.ownerType ?? "AuthAccount",
             maxSizeMb: input?.avatars?.maxSizeMb ?? 5,
         },
     };

package/build/src/host/account_api/account_api_controller.js

@@ -40,7 +40,7 @@ import { resolveEffectiveEmailChange, resolveEffectivePasswordHistory, } from '.
 import { dispatchSecurityNotice } from '../security_notice_service.js';
 import { requireSudo, isSudoActive, SUDO_MODE_DEFAULTS, resolveEffectiveSudoMode } from '../sudo_mode.js';
 import { translate } from '../i18n.js';
-import { storeAvatar, isDriveAvailable, AvatarUploadError } from '../avatar_storage.js';
+import { storeAvatar, isAvatarUploadSupported, AvatarUploadError } from '../avatar_storage.js';
 import { sendEmailChangeConfirmationEmail, sendEmailChangeNoticeEmail, } from '../default_mailer.js';
 import { ACTIVE_ORG_COOKIE } from '../active_org_cookie.js';
 // ---------------------------------------------------------------------------
@@ -138,7 +138,7 @@ export default class AccountApiController {
                 passkeysSupported: supportsPasskeys(cfg.accountStore),
                 orgsSupported: supportsOrganizations(cfg.accountStore),
                 tokensSupported: !!cfg.patStore,
-                avatarUploadSupported: await isDriveAvailable(),
+                avatarUploadSupported: await isAvatarUploadSupported(cfg.uploads),
                 sessionsSupported: new AdminSessionsService(service).canList,
             },
         };

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

@@ -61,8 +61,8 @@ export declare function removeFromOrgs(cfg: ResolvedServerConfig, accountId: str
     orgMemberships: number;
     orgInvitations: number;
 }>;
-/** 7) Apaga o avatar no drive (best-effort, fail-safe). */
-export declare function deleteAccountAvatar(cfg: ResolvedServerConfig, avatarUrl: string | null): Promise<{
+/** 7) Apaga o avatar no backend ativo (drive OU media; best-effort, fail-safe). */
+export declare function deleteAccountAvatar(cfg: ResolvedServerConfig, accountId: string, avatarUrl: string | null): Promise<{
     avatarDeleted: boolean;
 }>;
 /** 8) Anonimiza o histórico de audit da conta (quando o sink suporta). */

package/build/src/host/account_deletion_ops.js

@@ -92,9 +92,9 @@ export async function removeFromOrgs(cfg, accountId) {
         orgInvitations: orgResult.invitations,
     };
 }
-/** 7) Apaga o avatar no drive (best-effort, fail-safe). */
-export async function deleteAccountAvatar(cfg, avatarUrl) {
-    const avatarDeleted = await deleteAvatar(cfg.uploads, avatarUrl);
+/** 7) Apaga o avatar no backend ativo (drive OU media; best-effort, fail-safe). */
+export async function deleteAccountAvatar(cfg, accountId, avatarUrl) {
+    const avatarDeleted = await deleteAvatar(cfg.uploads, accountId, avatarUrl);
     return { avatarDeleted };
 }
 /** 8) Anonimiza o histórico de audit da conta (quando o sink suporta). */

package/build/src/host/account_deletion_service.js

@@ -114,7 +114,7 @@ export class AccountDeletionService {
         }
         // 7) Avatar no drive (best-effort, fail-safe).
         try {
-            result.avatarDeleted = (await deleteAccountAvatar(cfg, snapshot.avatarUrl)).avatarDeleted;
+            result.avatarDeleted = (await deleteAccountAvatar(cfg, accountId, snapshot.avatarUrl)).avatarDeleted;
         }
         catch {
             /* best-effort */

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

@@ -0,0 +1,26 @@
+import type { AuthAccount } from '../accounts/account_store.js';
+/** The slice of the resolved config the role resolution needs (structurally typed). */
+type RoleResolverConfig = {
+    resolveTokenRoles?: (account: AuthAccount, context: {
+        clientId?: string;
+        activeOrg?: {
+            orgId: string;
+            orgSlug: string;
+            orgRole: string;
+        } | null;
+    }) => string[] | Promise<string[]>;
+};
+/**
+ * An account's effective roles for host-side gating (the admin console).
+ *
+ * When the host configures `resolveTokenRoles`, that hook is the single source of an account's roles
+ * — the same one the OIDC `roles` claim is minted from — so console access tracks the host's role
+ * authority (e.g. an app that keeps roles in its own table via `@adonis-agora/authz`) instead of the
+ * account's stored `globalRoles`. Falls back to `account.globalRoles ?? []` when no hook is set, so
+ * default behavior is unchanged.
+ *
+ * The console is not OIDC-client- or org-scoped for role purposes, so the hook is called with an
+ * empty context (`clientId: undefined`, `activeOrg: null`).
+ */
+export declare function resolveAccountRoles(cfg: RoleResolverConfig, account: AuthAccount): Promise<string[]>;
+export {};

package/build/src/host/account_roles.js

@@ -0,0 +1,18 @@
+/**
+ * An account's effective roles for host-side gating (the admin console).
+ *
+ * When the host configures `resolveTokenRoles`, that hook is the single source of an account's roles
+ * — the same one the OIDC `roles` claim is minted from — so console access tracks the host's role
+ * authority (e.g. an app that keeps roles in its own table via `@adonis-agora/authz`) instead of the
+ * account's stored `globalRoles`. Falls back to `account.globalRoles ?? []` when no hook is set, so
+ * default behavior is unchanged.
+ *
+ * The console is not OIDC-client- or org-scoped for role purposes, so the hook is called with an
+ * empty context (`clientId: undefined`, `activeOrg: null`).
+ */
+export async function resolveAccountRoles(cfg, account) {
+    if (cfg.resolveTokenRoles) {
+        return cfg.resolveTokenRoles(account, { clientId: undefined, activeOrg: null });
+    }
+    return account.globalRoles ?? [];
+}

package/build/src/host/admin_console/admin_shell_controller.js

@@ -1,6 +1,7 @@
 import { readFile } from 'node:fs/promises';
 import { extname } from 'node:path';
 import { getAdminPrefix } from '../admin_prefix.js';
+import { resolveAccountRoles } from '../account_roles.js';
 // ─── Shell HTML cache ─────────────────────────────────────────────────────────
 /**
  * Points to the Vite-built index.html inside build/host/ui-dist/.
@@ -120,7 +121,7 @@ export default class AdminShellController {
                 currentUser = {
                     id: account.id,
                     email: account.email,
-                    roles: account.globalRoles ?? [],
+                    roles: await resolveAccountRoles(cfg, account),
                 };
             }
         }

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

@@ -20,6 +20,18 @@ type DriveService = any;
  * @internal
  */
 export declare function __setDriveLoaderForTests(fn: (() => Promise<DriveService | null>) | undefined): void;
+/**
+ * Módulo `@adonis-agora/media/single-file` resolvido de forma preguiçosa. Tipado
+ * como `any` de propósito: a lib NÃO depende do media em tempo de compilação
+ * (peer/opt-in). Expõe `storeSingleFile`/`removeSingleFile`/`isSingleFileStoreAvailable`.
+ */
+type MediaModule = any;
+/**
+ * Permite reapontar/limpar o loader do media (usado em testes). Espelha
+ * {@link __setDriveLoaderForTests}.
+ * @internal
+ */
+export declare function __setMediaLoaderForTests(fn: (() => Promise<MediaModule | null>) | undefined): void;
 /** Erro de validação do upload (mensagem já localizada no controller). */
 export declare class AvatarUploadError extends Error {
     reason: 'extname' | 'size';
@@ -29,7 +41,9 @@ export declare class AvatarUploadError extends Error {
 export interface UploadedAvatar {
     extname?: string | null;
     size?: number;
-    /** Caminho temporário (drive lê daqui para stream). */
+    /** MIME reportado pelo multipart (ex.: 'image/png'). Usado pelo backend media. */
+    type?: string | null;
+    /** Caminho temporário (drive lê daqui para stream; media lê os bytes daqui). */
     tmpPath?: string | null;
     /** Move o arquivo para um disk do drive (API v3+). */
     moveToDisk?: (key: string, options?: {
@@ -42,27 +56,39 @@ export interface UploadedAvatar {
  */
 export declare function isDriveAvailable(): Promise<boolean>;
 /**
- * Armazena o avatar no drive do host e retorna a URL pública.
+ * Indica se o upload de avatar está disponível para a config dada — i.e. se ALGUM
+ * backend configurado consegue armazenar (mesma lógica de seleção do
+ * {@link resolveUploader}: `'builtin'` → drive; `'media'` → media; `'auto'` →
+ * media OU drive). Usado pelas views/controllers para decidir mostrar o input de
+ * arquivo. Best-effort: nunca lança.
+ *
+ * Substitui o antigo gate por {@link isDriveAvailable}, que escondia o input num
+ * host media-only (media presente, drive ausente) mesmo com o media capaz de armazenar.
+ */
+export declare function isAvatarUploadSupported(cfg: ResolvedUploadsConfig): Promise<boolean>;
+/**
+ * Armazena o avatar no backend ativo (drive OU media) e retorna a URL pública.
  *
- * - Valida extensão (jpg/jpeg/png/webp) e tamanho (≤ maxSizeMb) — lança
+ * - Resolve o backend PRIMEIRO: se nenhum estiver disponível → retorna `null`
+ *   (degrada para o input de URL, feature off) SEM validar/lançar. Isso preserva o
+ *   comportamento histórico: um host sem backend nunca vê erro de validação.
+ * - Só quando há backend valida extensão (jpg/jpeg/png/webp) e tamanho
+ *   (≤ maxSizeMb) — COMPARTILHADO, antes de entregar ao backend; 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).
+ * - Backend conforme `cfg.avatars.storage` (ver {@link resolveUploader}).
  *
- * Nunca lança por causa de drive ausente; só lança em validação.
+ * Nunca lança por causa de backend ausente; só lança em validação (com backend).
  */
-export declare function storeAvatar(_ctx: HttpContext, cfg: ResolvedUploadsConfig, file: UploadedAvatar, accountId: string, messages: {
+export declare function storeAvatar(ctx: HttpContext, cfg: ResolvedUploadsConfig, file: UploadedAvatar, accountId: string, messages: {
     extname: string;
     size: string;
 }): Promise<string | null>;
 /**
- * Deleta (best-effort, fail-safe) o avatar de uma conta no drive do host, a partir
- * da URL/key armazenada. Usado pela deleção de conta (LGPD): apaga o arquivo se
- * conseguirmos derivar a key dentro do diretório configurado.
+ * Deleta (best-effort, fail-safe) o avatar de uma conta no backend ativo. Usado
+ * pela deleção de conta (LGPD). O `accountId` é o owner — necessário para o backend
+ * media apagar por owner; o backend builtin deriva a key da `storedUrlOrKey`.
  *
- * NUNCA lança: drive ausente, key não reconhecida ou erro de I/O → no-op. A key é
- * derivada da `storedUrlOrKey` pegando o trecho a partir de `directory/` (cobre
- * tanto uma key relativa quanto uma URL pública que contenha o caminho).
+ * NUNCA lança: backend ausente, key não reconhecida ou erro de I/O → no-op.
  */
-export declare function deleteAvatar(cfg: ResolvedUploadsConfig, storedUrlOrKey: string | null | undefined): Promise<boolean>;
+export declare function deleteAvatar(cfg: ResolvedUploadsConfig, accountId: string | null | undefined, storedUrlOrKey: string | null | undefined): Promise<boolean>;
 export {};

package/build/src/host/avatar_storage.js

@@ -34,8 +34,43 @@ export function __setDriveLoaderForTests(fn) {
         driveServicePromise = undefined;
     }
 }
+let mediaModulePromise;
+/**
+ * Importa o helper single-file do `@adonis-agora/media` de forma preguiçosa e
+ * fail-safe. Espelha {@link loadDrive}: se o pacote não estiver instalado, resolve
+ * `null` (o specifier é indireto para não ser resolvido em build-time — peer opcional).
+ */
+async function loadMedia() {
+    if (!mediaModulePromise) {
+        const specifier = '@adonis-agora/media/single-file';
+        mediaModulePromise = import(__rewriteRelativeImportExtension(specifier))
+            .then((mod) => mod ?? null)
+            .catch(() => null);
+    }
+    return mediaModulePromise;
+}
+/**
+ * Permite reapontar/limpar o loader do media (usado em testes). Espelha
+ * {@link __setDriveLoaderForTests}.
+ * @internal
+ */
+export function __setMediaLoaderForTests(fn) {
+    if (fn) {
+        mediaModulePromise = fn();
+    }
+    else {
+        mediaModulePromise = undefined;
+    }
+}
 /** Extensões aceitas para o avatar (imagem raster comum). */
 const ALLOWED_EXTNAMES = ['jpg', 'jpeg', 'png', 'webp'];
+/** MIME por extensão validada — fallback quando o file de multipart não traz `type`. */
+const EXT_MIME = {
+    jpg: 'image/jpeg',
+    jpeg: 'image/jpeg',
+    png: 'image/png',
+    webp: 'image/webp',
+};
 /** Erro de validação do upload (mensagem já localizada no controller). */
 export class AvatarUploadError extends Error {
     reason;
@@ -76,91 +111,205 @@ function buildKey(cfg, accountId, ext) {
     return `${cfg.avatars.directory}/${accountId}-${random}.${ext}`;
 }
 /**
- * Armazena o avatar no drive do host e retorna a URL pública.
+ * Backend builtin: o `@adonisjs/drive` JÁ configurado no app. Comportamento
+ * BYTE-IDÊNTICO ao histórico (moveToDisk/putStream + getUrl; delete por key
+ * derivada do diretório).
+ */
+const builtinUploader = {
+    async store(_ctx, cfg, file, accountId, ext) {
+        const drive = await loadDrive();
+        if (!drive)
+            return null;
+        // 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;
+        }
+    },
+    async delete(cfg, _accountId, storedUrlOrKey) {
+        if (!storedUrlOrKey)
+            return false;
+        const drive = await loadDrive();
+        if (!drive)
+            return false;
+        // Deriva a key: trecho a partir de `<directory>/`. Se não bater, aborta (não
+        // arriscamos deletar algo fora do nosso diretório).
+        const dir = cfg.avatars.directory.replace(/\/+$/, '');
+        const marker = `${dir}/`;
+        const idx = storedUrlOrKey.indexOf(marker);
+        if (idx < 0)
+            return false;
+        // Remove querystring/fragment de uma URL pública.
+        const key = storedUrlOrKey.slice(idx).split(/[?#]/)[0];
+        let disk;
+        try {
+            disk = cfg.avatars.disk ? drive.use(cfg.avatars.disk) : drive.use();
+        }
+        catch {
+            return false;
+        }
+        if (!disk || typeof disk.delete !== 'function')
+            return false;
+        try {
+            await disk.delete(key);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    },
+};
+/**
+ * Backend media: delega ao `@adonis-agora/media` (collection single-file). O
+ * lifecycle é keyed por owner (`ownerType`/`ownerId`) — o `single: true` da
+ * collection faz o replace de slot; a URL final é o que persistimos em `avatarUrl`.
+ */
+function makeMediaUploader(media) {
+    return {
+        async store(_ctx, cfg, file, accountId, ext) {
+            if (!file.tmpPath)
+                return null;
+            const fs = await import('node:fs/promises');
+            const contents = await fs.readFile(file.tmpPath);
+            const fileName = `avatar.${ext}`;
+            const mimeType = file.type ?? EXT_MIME[ext] ?? 'application/octet-stream';
+            const result = await media.storeSingleFile({
+                ownerType: cfg.avatars.ownerType,
+                ownerId: accountId,
+                collection: cfg.avatars.collection,
+                fileName,
+                mimeType,
+                contents,
+            });
+            return result?.url ?? null;
+        },
+        async delete(cfg, accountId, _storedUrlOrKey) {
+            // media apaga por owner (a key/URL não é usada — o lifecycle é do owner).
+            if (!accountId)
+                return false;
+            try {
+                await media.removeSingleFile({
+                    ownerType: cfg.avatars.ownerType,
+                    ownerId: accountId,
+                    collection: cfg.avatars.collection,
+                });
+                return true;
+            }
+            catch {
+                return false;
+            }
+        },
+    };
+}
+/**
+ * Resolve o backend de avatar conforme `cfg.avatars.storage`:
+ * - `'builtin'` → sempre o drive (ou `null` se ausente).
+ * - `'media'`   → o media (ou `null` se ausente/indisponível — degrada gracioso).
+ * - `'auto'`    → media se disponível, senão o drive.
  *
- * - 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).
+ * "media disponível" = pacote presente E `isSingleFileStoreAvailable()` true (o
+ * MediaManager está bindado no container do app). Nunca lança.
+ */
+async function resolveUploader(cfg) {
+    const storage = cfg.avatars.storage;
+    if (storage === 'builtin') {
+        return (await loadDrive()) ? builtinUploader : null;
+    }
+    if (storage === 'media') {
+        const media = await loadMediaIfUsable();
+        return media ? makeMediaUploader(media) : null;
+    }
+    // 'auto' (default): media se disponível, senão builtin.
+    const media = await loadMediaIfUsable();
+    if (media)
+        return makeMediaUploader(media);
+    return (await loadDrive()) ? builtinUploader : null;
+}
+/**
+ * Indica se o upload de avatar está disponível para a config dada — i.e. se ALGUM
+ * backend configurado consegue armazenar (mesma lógica de seleção do
+ * {@link resolveUploader}: `'builtin'` → drive; `'media'` → media; `'auto'` →
+ * media OU drive). Usado pelas views/controllers para decidir mostrar o input de
+ * arquivo. Best-effort: nunca lança.
  *
- * Nunca lança por causa de drive ausente; só lança em validação.
+ * Substitui o antigo gate por {@link isDriveAvailable}, que escondia o input num
+ * host media-only (media presente, drive ausente) mesmo com o media capaz de armazenar.
  */
-export async function storeAvatar(_ctx, cfg, file, accountId, messages) {
-    const drive = await loadDrive();
-    if (!drive)
+export async function isAvatarUploadSupported(cfg) {
+    return (await resolveUploader(cfg)) !== null;
+}
+/**
+ * Carrega o módulo media só se ele estiver USÁVEL: pacote presente E
+ * `isSingleFileStoreAvailable()` resolve `true`. Best-effort — qualquer erro → null.
+ */
+async function loadMediaIfUsable() {
+    const media = await loadMedia();
+    if (!media)
         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();
+        return (await media.isSingleFileStoreAvailable()) ? media : null;
     }
     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 {
+}
+/**
+ * Armazena o avatar no backend ativo (drive OU media) e retorna a URL pública.
+ *
+ * - Resolve o backend PRIMEIRO: se nenhum estiver disponível → retorna `null`
+ *   (degrada para o input de URL, feature off) SEM validar/lançar. Isso preserva o
+ *   comportamento histórico: um host sem backend nunca vê erro de validação.
+ * - Só quando há backend valida extensão (jpg/jpeg/png/webp) e tamanho
+ *   (≤ maxSizeMb) — COMPARTILHADO, antes de entregar ao backend; lança
+ *   {@link AvatarUploadError} se inválido (o controller traduz/flasha).
+ * - Backend conforme `cfg.avatars.storage` (ver {@link resolveUploader}).
+ *
+ * Nunca lança por causa de backend ausente; só lança em validação (com backend).
+ */
+export async function storeAvatar(ctx, cfg, file, accountId, messages) {
+    const uploader = await resolveUploader(cfg);
+    if (!uploader)
         return null;
-    }
-    try {
-        return await disk.getUrl(key);
-    }
-    catch {
-        // disk sem getUrl público — retorna a key como referência relativa.
-        return key;
-    }
+    const ext = validate(file, cfg, messages);
+    return uploader.store(ctx, cfg, file, accountId, ext);
 }
 /**
- * Deleta (best-effort, fail-safe) o avatar de uma conta no drive do host, a partir
- * da URL/key armazenada. Usado pela deleção de conta (LGPD): apaga o arquivo se
- * conseguirmos derivar a key dentro do diretório configurado.
+ * Deleta (best-effort, fail-safe) o avatar de uma conta no backend ativo. Usado
+ * pela deleção de conta (LGPD). O `accountId` é o owner — necessário para o backend
+ * media apagar por owner; o backend builtin deriva a key da `storedUrlOrKey`.
  *
- * NUNCA lança: drive ausente, key não reconhecida ou erro de I/O → no-op. A key é
- * derivada da `storedUrlOrKey` pegando o trecho a partir de `directory/` (cobre
- * tanto uma key relativa quanto uma URL pública que contenha o caminho).
+ * NUNCA lança: backend ausente, key não reconhecida ou erro de I/O → no-op.
  */
-export async function deleteAvatar(cfg, storedUrlOrKey) {
-    if (!storedUrlOrKey)
-        return false;
-    const drive = await loadDrive();
-    if (!drive)
-        return false;
-    // Deriva a key: trecho a partir de `<directory>/`. Se não bater, aborta (não
-    // arriscamos deletar algo fora do nosso diretório).
-    const dir = cfg.avatars.directory.replace(/\/+$/, '');
-    const marker = `${dir}/`;
-    const idx = storedUrlOrKey.indexOf(marker);
-    if (idx < 0)
-        return false;
-    // Remove querystring/fragment de uma URL pública.
-    const key = storedUrlOrKey.slice(idx).split(/[?#]/)[0];
-    let disk;
-    try {
-        disk = cfg.avatars.disk ? drive.use(cfg.avatars.disk) : drive.use();
-    }
-    catch {
+export async function deleteAvatar(cfg, accountId, storedUrlOrKey) {
+    const uploader = await resolveUploader(cfg);
+    if (!uploader)
         return false;
-    }
-    if (!disk || typeof disk.delete !== 'function')
-        return false;
-    try {
-        await disk.delete(key);
-        return true;
-    }
-    catch {
-        return false;
-    }
+    return uploader.delete(cfg, accountId, storedUrlOrKey);
 }

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

@@ -3,7 +3,7 @@ import { ACCOUNT_SESSION_KEY } from "../middleware/account_auth.js";
 import { supportsAccountSecurity, supportsAccountDeletion, supportsProfile, supportsPasswordHistory, } from "../../accounts/account_store.js";
 import { changePasswordValidator, changeEmailValidator, deleteAccountValidator, updateProfileValidator, } from "../validators.js";
 import { sendEmailChangeConfirmationEmail, sendEmailChangeNoticeEmail, sendEmailChangedCompletedEmail, } from "../default_mailer.js";
-import { storeAvatar, isDriveAvailable, AvatarUploadError, } from "../avatar_storage.js";
+import { storeAvatar, isAvatarUploadSupported, AvatarUploadError, } from "../avatar_storage.js";
 import { translate } from "../i18n.js";
 import { TRUSTED_DEVICE_COOKIE } from "../trusted_device.js";
 import { AccountDeletionService } from "../account_deletion_service.js";
@@ -67,8 +67,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(),
+            // Só mostramos o input de arquivo se ALGUM backend (drive OU media) puder armazenar.
+            avatarUploadSupported: await isAvatarUploadSupported(cfg.uploads),
             email: account?.email ?? "",
             name: account?.name ?? "",
             avatarUrl: account?.avatarUrl ?? "",

package/build/src/host/durable/account_deletion_workflow.js

@@ -75,7 +75,7 @@ export function defineAccountDeletionWorkflow(deps) {
         result.orgMemberships = orgResult.orgMemberships;
         result.orgInvitations = orgResult.orgInvitations;
         // 7) Avatar no drive.
-        result.avatarDeleted = (await ctx.step("delete.avatar", async () => deleteAccountAvatar((await deps.oidc()).config, snapshot.avatarUrl))).avatarDeleted;
+        result.avatarDeleted = (await ctx.step("delete.avatar", async () => deleteAccountAvatar((await deps.oidc()).config, accountId, snapshot.avatarUrl))).avatarDeleted;
         // 8) Anonimiza o histórico de audit.
         result.auditAnonymized = (await ctx.step("anonymize.audit", async () => anonymizeAudit((await deps.oidc()).config, accountId))).auditAnonymized;
         // 9) Deleta a linha da conta (ÚLTIMA etapa, forward-only).

package/build/src/host/register_auth_host.js

@@ -2,6 +2,7 @@ import { resolveRateLimit } from '../define_config.js';
 import { createAuthThrottles } from './rate_limit.js';
 import { ACCOUNT_SESSION_KEY } from './middleware/account_auth.js';
 import { accountHome } from './account_home.js';
+import { resolveAccountRoles } from './account_roles.js';
 import { adminApiGuard } from './admin_api/admin_api_guard.js';
 import { setAdminPrefix, normalizeAdminPrefix, setAdminApiPrefix, normalizeAdminApiPrefix, } from './admin_prefix.js';
 import { resolveRuntimeSettings } from './runtime_settings.js';
@@ -112,7 +113,10 @@ export const adminGuard = async (ctx, next) => {
     }
     const allowed = cfg.admin.roles;
     const account = await cfg.accountStore.findById(accountId);
-    const roles = account?.globalRoles ?? [];
+    // Resolve roles through the host's role authority (`resolveTokenRoles`) when set — the same source
+    // the token claim is minted from — so an app-role admin reaches the console. Falls back to the
+    // account's stored `globalRoles` when no hook is configured.
+    const roles = account ? await resolveAccountRoles(cfg, account) : [];
     const isAdmin = roles.some((r) => allowed.includes(r));
     if (!isAdmin) {
         // Evita vazar a existência do console admin: redireciona para o accountHome

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adonis-agora/authkit-server",
-  "version": "0.43.0",
+  "version": "0.45.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",
@@ -56,6 +56,7 @@
   },
   "peerDependencies": {
     "@adonis-agora/durable": "^0.2.0",
+    "@adonis-agora/media": "^0.1.0",
     "@adonis-agora/telescope": "^0.1.0",
     "@adonisjs/ally": "^6.3.0",
     "@adonisjs/auth": "^10.1.0",
@@ -73,6 +74,9 @@
     "@adonis-agora/durable": {
       "optional": true
     },
+    "@adonis-agora/media": {
+      "optional": true
+    },
     "@adonis-agora/telescope": {
       "optional": true
     },