@adonis-agora/authkit-server 0.34.0

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

@@ -0,0 +1,112 @@
+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 confirmação de TROCA de e-mail para o NOVO endereço.
+ * Best-effort: no fallback (sem mail) loga o link; nunca lança.
+ */
+export declare function sendEmailChangeConfirmationEmail(ctx: HttpContext, data: {
+    email: string;
+    confirmUrl: string;
+}): Promise<void>;
+/**
+ * Envia o e-mail de alerta de NOVO acesso à conta (login de um IP novo).
+ * Best-effort: no fallback (sem mail) loga o evento; nunca lança.
+ */
+export declare function sendNewLoginEmail(ctx: HttpContext, data: {
+    email: string;
+    ip: string;
+    when: string;
+}): Promise<void>;
+/**
+ * Envia o e-mail de alerta de NOVO DISPOSITIVO (login sem cookie de dispositivo
+ * confiável). Best-effort: no fallback (sem mail) loga o evento; nunca lança.
+ */
+export declare function sendNewDeviceLoginEmail(ctx: HttpContext, data: {
+    email: string;
+    ip?: string | null;
+    userAgent?: string | null;
+    when: string;
+}): Promise<void>;
+/**
+ * Envia o e-mail de magic link (login passwordless) pelo mailer default do host.
+ * Best-effort: no fallback (sem mail) loga o link; nunca lança.
+ */
+export declare function sendMagicLinkEmail(ctx: HttpContext, data: {
+    email: string;
+    magicUrl: string;
+}): Promise<void>;
+/**
+ * Envia o e-mail de aviso de segurança ao e-mail ATUAL quando uma troca de
+ * e-mail é solicitada ("Alguém pediu troca para X — se não foi você...").
+ * Best-effort: no fallback (sem mail) loga o evento; nunca lança.
+ */
+export declare function sendEmailChangeNoticeEmail(ctx: HttpContext, data: {
+    email: string;
+    newEmail: string;
+}): Promise<void>;
+/**
+ * Envia o e-mail de aviso de segurança ao e-mail ANTIGO confirmando que a
+ * troca foi concluída ("Seu e-mail foi alterado de A para B — se não foi você...").
+ * Best-effort: no fallback (sem mail) loga o evento; nunca lança.
+ */
+export declare function sendEmailChangedCompletedEmail(ctx: HttpContext, data: {
+    oldEmail: string;
+    newEmail: string;
+}): Promise<void>;
+/**
+ * Envia um e-mail de notificação de segurança para a conta (senha alterada,
+ * MFA habilitado/desabilitado, passkey adicionada/removida, e-mail alterado).
+ * Best-effort: no fallback (sem mail) loga o evento; nunca lança.
+ */
+export declare function sendSecurityNoticeEmail(ctx: HttpContext, data: {
+    email: string;
+    kind: 'password_changed' | 'mfa_enabled' | 'mfa_disabled' | 'passkey_added' | 'passkey_removed' | 'email_changed';
+    timestamp: string;
+    ip?: string | null;
+    metadata?: Record<string, string>;
+}): Promise<void>;
+/**
+ * Envia o e-mail de desbloqueio do fator OTP (quando TOTP/recovery excede maxAttempts).
+ * Best-effort: no fallback (sem mail) loga o link; nunca lança.
+ */
+export declare function sendOtpUnlockEmail(ctx: HttpContext, data: {
+    email: string;
+    unlockUrl: 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,417 @@
+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';
+import { resolveMessages, translate, } from './i18n.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' };
+}
+/**
+ * Resolve o catálogo de mensagens i18n a partir do `config/authkit.ts` (i18n).
+ * Cai no default (`en`) se a config não for resolvível. Usado para localizar
+ * os e-mails transacionais (assunto/cabeçalho/corpo).
+ */
+function resolveMailMessages(ctx) {
+    try {
+        const resolver = ctx.containerResolver;
+        const i18n = resolver.app?.config?.get?.('authkit')?.i18n;
+        return { messages: resolveMessages(i18n), locale: i18n?.locale ?? 'en' };
+    }
+    catch {
+        // sem config authkit resolvível — usa o default `en`.
+        return { messages: resolveMessages(), locale: 'en' };
+    }
+}
+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 { messages: t, locale } = resolveMailMessages(ctx);
+        const content = renderTransactionalEmail({
+            brand,
+            locale,
+            linkFallback: translate(t, 'mail.common.link_fallback'),
+            subject: translate(t, 'mail.reset.subject'),
+            heading: translate(t, 'mail.reset.heading'),
+            intro: translate(t, 'mail.reset.intro'),
+            ctaLabel: translate(t, 'mail.reset.cta'),
+            ctaUrl: data.resetUrl,
+            footnote: translate(t, 'mail.reset.fallback'),
+        });
+        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 confirmação de TROCA de e-mail para o NOVO endereço.
+ * Best-effort: no fallback (sem mail) loga o link; nunca lança.
+ */
+export async function sendEmailChangeConfirmationEmail(ctx, data) {
+    try {
+        const brand = resolveBrand(ctx);
+        const { messages: t, locale } = resolveMailMessages(ctx);
+        const content = renderTransactionalEmail({
+            brand,
+            locale,
+            linkFallback: translate(t, 'mail.common.link_fallback'),
+            subject: translate(t, 'mail.email_change.subject'),
+            heading: translate(t, 'mail.email_change.heading'),
+            intro: translate(t, 'mail.email_change.intro'),
+            ctaLabel: translate(t, 'mail.email_change.cta'),
+            ctaUrl: data.confirmUrl,
+            footnote: translate(t, 'mail.email_change.fallback'),
+        });
+        const sent = await sendEmail(ctx, data.email, content);
+        if (!sent) {
+            ctx.logger.info({ confirmUrl: data.confirmUrl, email: data.email }, 'authkit: link de confirmação de troca de e-mail (dev — @adonisjs/mail ausente)');
+        }
+    }
+    catch (error) {
+        ctx.logger.error({ err: error, email: data.email }, 'authkit: falha ao enviar confirmação de troca de e-mail');
+    }
+}
+/**
+ * Envia o e-mail de alerta de NOVO acesso à conta (login de um IP novo).
+ * Best-effort: no fallback (sem mail) loga o evento; nunca lança.
+ */
+export async function sendNewLoginEmail(ctx, data) {
+    try {
+        const brand = resolveBrand(ctx);
+        const { messages: t, locale } = resolveMailMessages(ctx);
+        const origin = `${ctx.request.protocol()}://${ctx.request.host()}`;
+        const intro = [
+            translate(t, 'mail.new_login.intro'),
+            translate(t, 'mail.new_login.when', { date: data.when }),
+            translate(t, 'mail.new_login.ip', { ip: data.ip }),
+        ].join(' ');
+        const content = renderTransactionalEmail({
+            brand,
+            locale,
+            linkFallback: translate(t, 'mail.common.link_fallback'),
+            subject: translate(t, 'mail.new_login.subject'),
+            heading: translate(t, 'mail.new_login.heading'),
+            intro,
+            ctaLabel: translate(t, 'account.security.title'),
+            ctaUrl: `${origin}/account/security`,
+            footnote: translate(t, 'mail.new_login.fallback'),
+        });
+        const sent = await sendEmail(ctx, data.email, content);
+        if (!sent) {
+            ctx.logger.info({ ip: data.ip, email: data.email }, 'authkit: alerta de novo acesso (dev — @adonisjs/mail ausente)');
+        }
+    }
+    catch (error) {
+        ctx.logger.error({ err: error, email: data.email }, 'authkit: falha ao enviar alerta de novo acesso');
+    }
+}
+/**
+ * Envia o e-mail de alerta de NOVO DISPOSITIVO (login sem cookie de dispositivo
+ * confiável). Best-effort: no fallback (sem mail) loga o evento; nunca lança.
+ */
+export async function sendNewDeviceLoginEmail(ctx, data) {
+    try {
+        const brand = resolveBrand(ctx);
+        const { messages: t, locale } = resolveMailMessages(ctx);
+        const origin = `${ctx.request.protocol()}://${ctx.request.host()}`;
+        const lines = [translate(t, 'mail.new_login.intro'), translate(t, 'mail.new_login.when', { date: data.when })];
+        if (data.userAgent)
+            lines.push(translate(t, 'mail.new_login.device', { device: data.userAgent }));
+        if (data.ip)
+            lines.push(translate(t, 'mail.new_login.ip', { ip: data.ip }));
+        const content = renderTransactionalEmail({
+            brand,
+            locale,
+            linkFallback: translate(t, 'mail.common.link_fallback'),
+            subject: translate(t, 'mail.new_login.subject'),
+            heading: translate(t, 'mail.new_login.heading'),
+            intro: lines.join(' '),
+            ctaLabel: translate(t, 'account.security.title'),
+            ctaUrl: `${origin}/account/security`,
+            footnote: translate(t, 'mail.new_login.fallback'),
+        });
+        const sent = await sendEmail(ctx, data.email, content);
+        if (!sent) {
+            ctx.logger.info({ ip: data.ip, email: data.email, userAgent: data.userAgent }, 'authkit: alerta de novo dispositivo (dev — @adonisjs/mail ausente)');
+        }
+    }
+    catch (error) {
+        ctx.logger.error({ err: error, email: data.email }, 'authkit: falha ao enviar alerta de novo dispositivo');
+    }
+}
+/**
+ * Envia o e-mail de magic link (login passwordless) pelo mailer default do host.
+ * Best-effort: no fallback (sem mail) loga o link; nunca lança.
+ */
+export async function sendMagicLinkEmail(ctx, data) {
+    try {
+        const brand = resolveBrand(ctx);
+        const { messages: t, locale } = resolveMailMessages(ctx);
+        const content = renderTransactionalEmail({
+            brand,
+            locale,
+            linkFallback: translate(t, 'mail.common.link_fallback'),
+            subject: translate(t, 'mail.magic_link.subject'),
+            heading: translate(t, 'mail.magic_link.heading'),
+            intro: translate(t, 'mail.magic_link.intro'),
+            ctaLabel: translate(t, 'mail.magic_link.cta'),
+            ctaUrl: data.magicUrl,
+            footnote: translate(t, 'mail.magic_link.fallback'),
+        });
+        const sent = await sendEmail(ctx, data.email, content);
+        if (!sent) {
+            ctx.logger.info({ magicUrl: data.magicUrl, email: data.email }, 'authkit: magic link de login (dev — @adonisjs/mail ausente)');
+        }
+    }
+    catch (error) {
+        ctx.logger.error({ err: error, email: data.email }, 'authkit: falha ao enviar magic link de login');
+    }
+}
+/**
+ * Envia o e-mail de aviso de segurança ao e-mail ATUAL quando uma troca de
+ * e-mail é solicitada ("Alguém pediu troca para X — se não foi você...").
+ * Best-effort: no fallback (sem mail) loga o evento; nunca lança.
+ */
+export async function sendEmailChangeNoticeEmail(ctx, data) {
+    try {
+        const brand = resolveBrand(ctx);
+        const { messages: t, locale } = resolveMailMessages(ctx);
+        const origin = `${ctx.request.protocol()}://${ctx.request.host()}`;
+        const content = renderTransactionalEmail({
+            brand,
+            locale,
+            linkFallback: translate(t, 'mail.common.link_fallback'),
+            subject: translate(t, 'mail.email_change_notice.subject'),
+            heading: translate(t, 'mail.email_change_notice.heading'),
+            intro: translate(t, 'mail.email_change_notice.intro', { newEmail: data.newEmail }),
+            ctaLabel: translate(t, 'mail.email_change_notice.cta'),
+            ctaUrl: `${origin}/account/security`,
+            footnote: translate(t, 'mail.email_change_notice.fallback'),
+        });
+        const sent = await sendEmail(ctx, data.email, content);
+        if (!sent) {
+            ctx.logger.info({ newEmail: data.newEmail, email: data.email }, 'authkit: aviso de troca de e-mail (dev — @adonisjs/mail ausente)');
+        }
+    }
+    catch (error) {
+        ctx.logger.error({ err: error, email: data.email }, 'authkit: falha ao enviar aviso de troca de e-mail');
+    }
+}
+/**
+ * Envia o e-mail de aviso de segurança ao e-mail ANTIGO confirmando que a
+ * troca foi concluída ("Seu e-mail foi alterado de A para B — se não foi você...").
+ * Best-effort: no fallback (sem mail) loga o evento; nunca lança.
+ */
+export async function sendEmailChangedCompletedEmail(ctx, data) {
+    try {
+        const brand = resolveBrand(ctx);
+        const { messages: t, locale } = resolveMailMessages(ctx);
+        const origin = `${ctx.request.protocol()}://${ctx.request.host()}`;
+        const content = renderTransactionalEmail({
+            brand,
+            locale,
+            linkFallback: translate(t, 'mail.common.link_fallback'),
+            subject: translate(t, 'mail.email_changed_completed.subject'),
+            heading: translate(t, 'mail.email_changed_completed.heading'),
+            intro: translate(t, 'mail.email_changed_completed.intro', {
+                oldEmail: data.oldEmail,
+                newEmail: data.newEmail,
+            }),
+            ctaLabel: translate(t, 'mail.email_changed_completed.cta'),
+            ctaUrl: `${origin}/account/security`,
+            footnote: translate(t, 'mail.email_changed_completed.fallback'),
+        });
+        const sent = await sendEmail(ctx, data.oldEmail, content);
+        if (!sent) {
+            ctx.logger.info({ oldEmail: data.oldEmail, newEmail: data.newEmail }, 'authkit: confirmação de troca de e-mail concluída (dev — @adonisjs/mail ausente)');
+        }
+    }
+    catch (error) {
+        ctx.logger.error({ err: error, email: data.oldEmail }, 'authkit: falha ao enviar confirmação de troca de e-mail concluída');
+    }
+}
+/**
+ * Envia um e-mail de notificação de segurança para a conta (senha alterada,
+ * MFA habilitado/desabilitado, passkey adicionada/removida, e-mail alterado).
+ * Best-effort: no fallback (sem mail) loga o evento; nunca lança.
+ */
+export async function sendSecurityNoticeEmail(ctx, data) {
+    try {
+        const brand = resolveBrand(ctx);
+        const { messages: t, locale } = resolveMailMessages(ctx);
+        const origin = `${ctx.request.protocol()}://${ctx.request.host()}`;
+        const kindKey = `mail.security_notice.kind_${data.kind}`;
+        const kindLabel = translate(t, kindKey);
+        const intro = [
+            translate(t, 'mail.security_notice.intro', { kind: kindLabel }),
+            translate(t, 'mail.security_notice.when', { date: data.timestamp }),
+        ];
+        if (data.ip)
+            intro.push(translate(t, 'mail.security_notice.ip', { ip: data.ip }));
+        const content = renderTransactionalEmail({
+            brand,
+            locale,
+            linkFallback: translate(t, 'mail.common.link_fallback'),
+            subject: translate(t, 'mail.security_notice.subject', { kind: kindLabel }),
+            heading: translate(t, 'mail.security_notice.heading'),
+            intro: intro.join(' '),
+            ctaLabel: translate(t, 'account.security.title'),
+            ctaUrl: `${origin}/account/security`,
+            footnote: translate(t, 'mail.security_notice.fallback'),
+        });
+        const sent = await sendEmail(ctx, data.email, content);
+        if (!sent) {
+            ctx.logger.info({ kind: data.kind, email: data.email }, 'authkit: notificação de segurança (dev — @adonisjs/mail ausente)');
+        }
+    }
+    catch (error) {
+        ctx.logger.error({ err: error, email: data.email, kind: data.kind }, 'authkit: falha ao enviar notificação de segurança');
+    }
+}
+/**
+ * Envia o e-mail de desbloqueio do fator OTP (quando TOTP/recovery excede maxAttempts).
+ * Best-effort: no fallback (sem mail) loga o link; nunca lança.
+ */
+export async function sendOtpUnlockEmail(ctx, data) {
+    try {
+        const brand = resolveBrand(ctx);
+        const { messages: t, locale } = resolveMailMessages(ctx);
+        const content = renderTransactionalEmail({
+            brand,
+            locale,
+            linkFallback: translate(t, 'mail.common.link_fallback'),
+            subject: translate(t, 'mail.otp_unlock.subject'),
+            heading: translate(t, 'mail.otp_unlock.heading'),
+            intro: translate(t, 'mail.otp_unlock.intro'),
+            ctaLabel: translate(t, 'mail.otp_unlock.cta'),
+            ctaUrl: data.unlockUrl,
+            footnote: translate(t, 'mail.otp_unlock.fallback'),
+        });
+        const sent = await sendEmail(ctx, data.email, content);
+        if (!sent) {
+            ctx.logger.info({ unlockUrl: data.unlockUrl, email: data.email }, 'authkit: link de desbloqueio OTP (dev — @adonisjs/mail ausente)');
+        }
+    }
+    catch (error) {
+        ctx.logger.error({ err: error, email: data.email }, 'authkit: falha ao enviar e-mail de desbloqueio OTP');
+    }
+}
+/**
+ * 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 { messages: t, locale } = resolveMailMessages(ctx);
+        const content = renderTransactionalEmail({
+            brand,
+            locale,
+            linkFallback: translate(t, 'mail.common.link_fallback'),
+            subject: translate(t, 'mail.verify.subject'),
+            heading: translate(t, 'mail.verify.heading'),
+            intro: translate(t, 'mail.verify.intro'),
+            ctaLabel: translate(t, 'mail.verify.cta'),
+            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/durable/account_deletion_workflow.d.ts

@@ -0,0 +1,48 @@
+import type { OidcService } from "../../provider/oidc_service.js";
+import type { DeletionActor } from "../account_deletion_service.js";
+/** Nome canônico do workflow durável de deleção de conta. */
+export declare const ACCOUNT_DELETE_WORKFLOW = "authkit.account.delete";
+/** Input do workflow `authkit.account.delete`. */
+export interface AccountDeleteWorkflowInput {
+    accountId: string;
+    actor: DeletionActor;
+}
+/**
+ * Forma mínima do `ctx` durável que o corpo usa (um `ctx.step` checkpointado e
+ * idempotente). Tipada estruturalmente para NÃO acoplar o build do authkit ao
+ * pacote `@adonis-agora/durable` (peer OPCIONAL): o app passa o `engine.register`
+ * real e o ctx satisfaz esta interface em runtime.
+ */
+export interface DurableStepCtx {
+    step<T>(name: string, fn: (...args: any[]) => Promise<T>, options?: unknown): Promise<T>;
+}
+/** A assinatura do corpo do workflow (compatível com `engine.register`). */
+export type WorkflowBody = (ctx: DurableStepCtx, input: AccountDeleteWorkflowInput) => Promise<unknown>;
+/** Deps que o app injeta ao definir o workflow no seu próprio `WorkflowEngine`. */
+export interface AccountDeletionWorkflowDeps {
+    /** Resolve o {@link OidcService} (de onde sai a config). Chamado DENTRO de um step. */
+    oidc: () => OidcService | Promise<OidcService>;
+}
+/**
+ * Define a REGISTRAÇÃO do workflow durável `authkit.account.delete`.
+ *
+ * Retorna `{ name, version, body }` para o app registrar no seu `WorkflowEngine`:
+ *
+ * ```ts
+ * import { defineAccountDeletionWorkflow } from '@adonis-agora/authkit-server/durable'
+ * const wf = defineAccountDeletionWorkflow({ oidc: () => app.container.make('authkit.server') })
+ * engine.register(wf.name, wf.version, wf.body)
+ * ```
+ *
+ * O corpo é FORWARD-ONLY (sem compensação — nunca des-deleta): cada etapa do
+ * cascade é um `ctx.step` checkpointado, com retry por-etapa e resumabilidade. A
+ * linha da conta é a ÚLTIMA etapa. Todos os efeitos colaterais ficam DENTRO de
+ * `ctx.step` (corpo determinístico: nada de Date.now()/random no corpo). A
+ * idempotência por `accountId` é feita pelo run-id no enqueue (ver
+ * `enqueueAccountDeletion`).
+ */
+export declare function defineAccountDeletionWorkflow(deps: AccountDeletionWorkflowDeps): {
+    name: string;
+    version: string;
+    body: WorkflowBody;
+};

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

@@ -0,0 +1,86 @@
+import { anonymizeAudit, auditDeleted, deleteAccountAvatar, deleteAccountRow, disableMfa, removeFromOrgs, removePasskeys, revokePats, revokeSessions, snapshotAccount, unlinkProviders, } from "../account_deletion_ops.js";
+/** Nome canônico do workflow durável de deleção de conta. */
+export const ACCOUNT_DELETE_WORKFLOW = "authkit.account.delete";
+/** Estado inicial vazio do {@link DeletionResult} (acumulado etapa a etapa). */
+function emptyResult() {
+    return {
+        ok: false,
+        sessions: 0,
+        grants: 0,
+        accessTokens: 0,
+        refreshTokens: 0,
+        pats: 0,
+        passkeys: 0,
+        providerIdentities: 0,
+        auditAnonymized: 0,
+        avatarDeleted: false,
+        orgMemberships: 0,
+        orgInvitations: 0,
+    };
+}
+/**
+ * Define a REGISTRAÇÃO do workflow durável `authkit.account.delete`.
+ *
+ * Retorna `{ name, version, body }` para o app registrar no seu `WorkflowEngine`:
+ *
+ * ```ts
+ * import { defineAccountDeletionWorkflow } from '@adonis-agora/authkit-server/durable'
+ * const wf = defineAccountDeletionWorkflow({ oidc: () => app.container.make('authkit.server') })
+ * engine.register(wf.name, wf.version, wf.body)
+ * ```
+ *
+ * O corpo é FORWARD-ONLY (sem compensação — nunca des-deleta): cada etapa do
+ * cascade é um `ctx.step` checkpointado, com retry por-etapa e resumabilidade. A
+ * linha da conta é a ÚLTIMA etapa. Todos os efeitos colaterais ficam DENTRO de
+ * `ctx.step` (corpo determinístico: nada de Date.now()/random no corpo). A
+ * idempotência por `accountId` é feita pelo run-id no enqueue (ver
+ * `enqueueAccountDeletion`).
+ */
+export function defineAccountDeletionWorkflow(deps) {
+    const body = async (ctx, input) => {
+        const { accountId, actor } = input;
+        // Snapshot da conta ANTES de destruir (e-mail + avatar) — capturado num step
+        // para ser determinístico no replay. Se a conta não existe (ou já foi
+        // deletada num run anterior), encerra como no-op.
+        const snapshot = await ctx.step("snapshot", async () => {
+            const cfg = (await deps.oidc()).config;
+            return snapshotAccount(cfg, accountId);
+        });
+        if (!snapshot)
+            return emptyResult();
+        const result = emptyResult();
+        // 1) Audit `account.deleted` ANTES de qualquer destruição.
+        await ctx.step("audit.deleted", async () => {
+            const cfg = (await deps.oidc()).config;
+            await auditDeleted(cfg, snapshot, actor);
+        });
+        // 2) Sessões + grants (cascateia os tokens do oidc-provider).
+        const revoke = await ctx.step("revoke.sessions", async () => revokeSessions(await deps.oidc(), accountId));
+        result.sessions = revoke.sessions;
+        result.grants = revoke.grants;
+        result.accessTokens = revoke.accessTokens;
+        result.refreshTokens = revoke.refreshTokens;
+        // 3) Personal Access Tokens.
+        result.pats = (await ctx.step("revoke.pats", async () => revokePats((await deps.oidc()).config, accountId))).pats;
+        // 4) Passkeys / credenciais WebAuthn.
+        result.passkeys = (await ctx.step("remove.passkeys", async () => removePasskeys((await deps.oidc()).config, accountId))).passkeys;
+        // 5) MFA / TOTP.
+        await ctx.step("disable.mfa", async () => {
+            await disableMfa((await deps.oidc()).config, accountId);
+        });
+        // 6) Identidades de provider linkadas.
+        result.providerIdentities = (await ctx.step("unlink.providers", async () => unlinkProviders((await deps.oidc()).config, accountId))).providerIdentities;
+        // 6b) Organizations.
+        const orgResult = await ctx.step("remove.orgs", async () => removeFromOrgs((await deps.oidc()).config, accountId));
+        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;
+        // 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).
+        result.ok = (await ctx.step("delete.account", async () => deleteAccountRow((await deps.oidc()).config, accountId))).ok;
+        return result;
+    };
+    return { name: ACCOUNT_DELETE_WORKFLOW, version: "1", body };
+}