@adonis-agora/authkit-server 0.34.0

package/build/src/keys/keystore_manager.js

@@ -0,0 +1,104 @@
+import { generateSigningJwk, planRotation } from './keystore.js';
+import { FileKeystoreVault, DriveKeystoreVault, LucidKeystoreVault, RedisKeystoreVault, HashicorpVaultKeystoreVault, LazyExternalVault } from './keystore_vault.js';
+/**
+ * Único caminho de I/O do keystore managed: compõe um {@link KeystoreVault} (onde
+ * o blob mora) com um {@link KeystoreCodec} (serialização + encryption). As helpers
+ * puras (gerar chave, planejar rotação) continuam em `keystore.ts`.
+ */
+export class KeystoreManager {
+    vault;
+    codec;
+    alg;
+    constructor(vault, codec, alg) {
+        this.vault = vault;
+        this.codec = codec;
+        this.alg = alg;
+    }
+    /** Lê o keystore (privado) ou null se ausente. */
+    async read() {
+        const blob = await this.vault.read();
+        if (blob == null)
+            return null;
+        return this.codec.decode(blob);
+    }
+    /** Garante que exista: gera+persiste se ausente; senão decodifica e retorna. */
+    async ensure() {
+        const blob = await this.vault.read();
+        if (blob == null) {
+            const store = { keys: [await generateSigningJwk(this.alg)] };
+            await this.vault.write(await this.codec.encode(store));
+            return store;
+        }
+        return this.codec.decode(blob);
+    }
+    /** Rotaciona: chave nova na frente, mantém as `keep` mais recentes. Persiste. */
+    async rotate(keep = 2, retire = false) {
+        const current = (await this.read()) ?? { keys: [] };
+        const fresh = await generateSigningJwk(this.alg);
+        const next = [fresh, ...current.keys];
+        const effectiveKeep = retire ? 1 : Math.max(1, keep);
+        const kept = next.slice(0, effectiveKeep);
+        const retiredKids = next.slice(effectiveKeep).map((k) => k.kid);
+        const store = { keys: kept };
+        await this.vault.write(await this.codec.encode(store));
+        return { store, newKid: fresh.kid, retiredKids };
+    }
+    /** Plano de rotação (puro, sem I/O de escrita). */
+    async plan(keep, retire) {
+        return planRotation(await this.read(), keep, retire);
+    }
+    /** Token barato de mudança (delegado ao vault; fallback p/ read completo). */
+    async head() {
+        if (this.vault.head)
+            return this.vault.head();
+        return this.vault.read();
+    }
+}
+/** Packages-irmãos que entregam os cofres de cloud (planos futuros). */
+const CLOUD_DRIVER_PACKAGE = {
+    'aws-secrets-manager': '@adonis-agora/authkit-vault-aws',
+    'gcp-secret-manager': '@adonis-agora/authkit-vault-gcp',
+    'azure-key-vault': '@adonis-agora/authkit-vault-azure',
+};
+/**
+ * Resolve a config `store` num {@link KeystoreVault}. `ctx.makePath` = `app.makePath`
+ * (resolve paths relativos à raiz do app). Instância custom (com `read`/`write`)
+ * passa direto. Drivers de cloud lançam nesta fatia (chegam nos packages-irmãos).
+ */
+export function resolveKeystoreVault(store, ctx) {
+    if (typeof store === 'string')
+        return new FileKeystoreVault(ctx.makePath(store));
+    if (typeof store.read === 'function')
+        return store;
+    const cfg = store;
+    switch (cfg.driver) {
+        case 'file':
+            return new FileKeystoreVault(ctx.makePath(cfg.path));
+        case 'drive':
+            return new DriveKeystoreVault(cfg.key, cfg.disk);
+        case 'lucid':
+            return new LucidKeystoreVault(async () => {
+                const db = await ctx.container.make('lucid.db');
+                return cfg.connection ? db.connection(cfg.connection) : db.connection();
+            }, cfg.table, cfg.key);
+        case 'redis':
+            return new RedisKeystoreVault(async () => {
+                const rm = await ctx.container.make('redis');
+                return cfg.connection ? rm.connection(cfg.connection) : rm.connection();
+            }, cfg.key);
+        case 'hashicorp-vault':
+            return new HashicorpVaultKeystoreVault({
+                endpoint: cfg.endpoint,
+                path: cfg.path,
+                token: cfg.token,
+                mount: cfg.mount,
+                field: cfg.field,
+            });
+        default: {
+            const pkg = CLOUD_DRIVER_PACKAGE[cfg.driver];
+            if (!pkg)
+                throw new Error(`AuthKit keystore: driver "${cfg.driver}" desconhecido.`);
+            return new LazyExternalVault(pkg, cfg);
+        }
+    }
+}

package/build/src/keys/keystore_vault.d.ts

@@ -0,0 +1,113 @@
+/**
+ * Cofre onde o keystore (blob, possivelmente encriptado) é persistido. Ponto de
+ * extensão: cofres custom implementam esta interface. `head` é um token barato de
+ * detecção de mudança (mtime/etag/versão) p/ o poll de reload (Fatia C).
+ */
+export interface KeystoreVault {
+    read(): Promise<string | null>;
+    write(blob: string): Promise<void>;
+    head?(): Promise<string | null>;
+}
+/** Cofre em arquivo local (default; mode 0600). */
+export declare class FileKeystoreVault implements KeystoreVault {
+    private path;
+    constructor(path: string);
+    read(): Promise<string | null>;
+    write(blob: string): Promise<void>;
+    head(): Promise<string | null>;
+}
+/** Service do `@adonisjs/drive` resolvido lazy (peer opt-in; mesmo padrão do avatar). */
+type DriveService = any;
+/** Reaponta o loader do drive (testes). @internal */
+export declare function __setKeystoreDriveLoaderForTests(fn: (() => Promise<DriveService | null>) | undefined): void;
+/**
+ * Cofre numa tabela Lucid dedicada (`authkit_keystore`, KV de uma linha). Compartilhado
+ * entre instâncias (multi-instância nativo). Auto-cria a tabela no primeiro write — o
+ * keystore carrega na resolução do config, ANTES do `start()` (onde o schema auto-manage
+ * roda), então o vault não pode depender dela existir. `getConn` é lazy. `head()` = updated_at.
+ */
+export declare class LucidKeystoreVault implements KeystoreVault {
+    private getConn;
+    private table;
+    private key;
+    constructor(getConn: () => Promise<any>, table?: string, key?: string);
+    private ensureTable;
+    read(): Promise<string | null>;
+    write(blob: string): Promise<void>;
+    head(): Promise<string | null>;
+}
+/**
+ * Cofre numa key do Redis. Compartilhado entre instâncias (multi-instância nativo).
+ * `getClient` é lazy. `head()` devolve o próprio blob (redis get é barato).
+ *
+ * ⚠️ Requer Redis com PERSISTÊNCIA (RDB/AOF): num Redis cache-only, um flush apaga o
+ * keystore → todos os tokens invalidam. (Há um warning no boot quando o driver é redis.)
+ */
+export declare class RedisKeystoreVault implements KeystoreVault {
+    private getClient;
+    private key;
+    constructor(getClient: () => Promise<any>, key?: string);
+    read(): Promise<string | null>;
+    write(blob: string): Promise<void>;
+    head(): Promise<string | null>;
+}
+/** fetch mínimo que o vault HTTP usa (injetável p/ testes). */
+type VaultFetch = (url: string, init?: {
+    method?: string;
+    headers?: Record<string, string>;
+    body?: string;
+}) => Promise<{
+    ok: boolean;
+    status: number;
+    json(): Promise<any>;
+}>;
+export interface HashicorpVaultConfig {
+    endpoint: string;
+    path: string;
+    token?: string;
+    mount?: string;
+    field?: string;
+}
+/**
+ * Cofre no HashiCorp Vault (KV v2, via API HTTP — sem SDK). Compartilhado entre
+ * instâncias e com encryption/ACL próprios do Vault (por isso `encrypt` default OFF).
+ * Crítico: erro HTTP não-404 lança (não degrada). `head()` = versão atual (metadata).
+ */
+export declare class HashicorpVaultKeystoreVault implements KeystoreVault {
+    #private;
+    constructor(cfg: HashicorpVaultConfig, fetchImpl?: VaultFetch);
+    read(): Promise<string | null>;
+    write(blob: string): Promise<void>;
+    head(): Promise<string | null>;
+}
+type ExternalImport = (spec: string) => Promise<any>;
+/**
+ * Proxy que lazy-importa um package de cofre externo (aws/gcp/azure secrets managers)
+ * no PRIMEIRO I/O e delega. Mantém `resolveKeystoreVault` síncrono. O package precisa
+ * exportar `createKeystoreVault(cfg): KeystoreVault`. Se não estiver instalado → erro
+ * claro pedindo pra instalar (chave é crítica, não degrada).
+ */
+export declare class LazyExternalVault implements KeystoreVault {
+    #private;
+    private pkg;
+    private cfg;
+    private importFn;
+    constructor(pkg: string, cfg: any, importFn?: ExternalImport);
+    read(): Promise<string | null>;
+    write(blob: string): Promise<void>;
+    head(): Promise<string | null>;
+}
+/**
+ * Cofre num disk do `@adonisjs/drive` (S3/GCS/local). Diferente do avatar, chave é
+ * crítica: se o drive não está instalado mas foi selecionado → ERRO (não degrada).
+ */
+export declare class DriveKeystoreVault implements KeystoreVault {
+    private key;
+    private diskName?;
+    constructor(key: string, diskName?: string | undefined);
+    private disk;
+    read(): Promise<string | null>;
+    write(blob: string): Promise<void>;
+    head(): Promise<string | null>;
+}
+export {};

package/build/src/keys/keystore_vault.js

@@ -0,0 +1,265 @@
+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 { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+/** Cofre em arquivo local (default; mode 0600). */
+export class FileKeystoreVault {
+    path;
+    constructor(path) {
+        this.path = path;
+    }
+    async read() {
+        return existsSync(this.path) ? readFileSync(this.path, 'utf-8') : null;
+    }
+    async write(blob) {
+        mkdirSync(dirname(this.path), { recursive: true });
+        writeFileSync(this.path, blob.endsWith('\n') ? blob : blob + '\n', { mode: 0o600 });
+    }
+    async head() {
+        return existsSync(this.path) ? String(statSync(this.path).mtimeMs) : null;
+    }
+}
+let driveServicePromise;
+async function loadDrive() {
+    if (!driveServicePromise) {
+        const specifier = '@adonisjs/drive/services/main';
+        driveServicePromise = import(__rewriteRelativeImportExtension(specifier))
+            .then((m) => m.default ?? null)
+            .catch(() => null);
+    }
+    return driveServicePromise;
+}
+/** Reaponta o loader do drive (testes). @internal */
+export function __setKeystoreDriveLoaderForTests(fn) {
+    driveServicePromise = fn ? fn() : undefined;
+}
+/**
+ * Cofre numa tabela Lucid dedicada (`authkit_keystore`, KV de uma linha). Compartilhado
+ * entre instâncias (multi-instância nativo). Auto-cria a tabela no primeiro write — o
+ * keystore carrega na resolução do config, ANTES do `start()` (onde o schema auto-manage
+ * roda), então o vault não pode depender dela existir. `getConn` é lazy. `head()` = updated_at.
+ */
+export class LucidKeystoreVault {
+    getConn;
+    table;
+    key;
+    constructor(getConn, table = 'authkit_keystore', key = 'jwks') {
+        this.getConn = getConn;
+        this.table = table;
+        this.key = key;
+    }
+    async ensureTable(conn) {
+        if (await conn.schema.hasTable(this.table))
+            return;
+        try {
+            await conn.schema.createTable(this.table, (t) => {
+                t.string('key').notNullable().primary();
+                t.text('blob').notNullable();
+                t.bigInteger('updated_at').notNullable();
+            });
+        }
+        catch (err) {
+            // Outra instância criou a tabela entre o hasTable e o createTable (race no boot
+            // multi-instância). Se já existe agora, OK; senão propaga.
+            if (!(await conn.schema.hasTable(this.table)))
+                throw err;
+        }
+    }
+    async read() {
+        const conn = await this.getConn();
+        if (!(await conn.schema.hasTable(this.table)))
+            return null;
+        const row = await conn.from(this.table).where('key', this.key).first();
+        return row ? row.blob : null;
+    }
+    async write(blob) {
+        const conn = await this.getConn();
+        await this.ensureTable(conn);
+        await conn
+            .table(this.table)
+            .insert({ key: this.key, blob, updated_at: Date.now() })
+            .onConflict('key')
+            .merge();
+    }
+    async head() {
+        const conn = await this.getConn();
+        if (!(await conn.schema.hasTable(this.table)))
+            return null;
+        const row = await conn.from(this.table).where('key', this.key).first();
+        return row ? String(row.updated_at) : null;
+    }
+}
+/**
+ * Cofre numa key do Redis. Compartilhado entre instâncias (multi-instância nativo).
+ * `getClient` é lazy. `head()` devolve o próprio blob (redis get é barato).
+ *
+ * ⚠️ Requer Redis com PERSISTÊNCIA (RDB/AOF): num Redis cache-only, um flush apaga o
+ * keystore → todos os tokens invalidam. (Há um warning no boot quando o driver é redis.)
+ */
+export class RedisKeystoreVault {
+    getClient;
+    key;
+    constructor(getClient, key = 'authkit:jwks') {
+        this.getClient = getClient;
+        this.key = key;
+    }
+    async read() {
+        const client = await this.getClient();
+        return (await client.get(this.key)) ?? null;
+    }
+    async write(blob) {
+        const client = await this.getClient();
+        await client.set(this.key, blob);
+    }
+    async head() {
+        const client = await this.getClient();
+        return (await client.get(this.key)) ?? null;
+    }
+}
+/**
+ * Cofre no HashiCorp Vault (KV v2, via API HTTP — sem SDK). Compartilhado entre
+ * instâncias e com encryption/ACL próprios do Vault (por isso `encrypt` default OFF).
+ * Crítico: erro HTTP não-404 lança (não degrada). `head()` = versão atual (metadata).
+ */
+export class HashicorpVaultKeystoreVault {
+    #endpoint;
+    #mount;
+    #path;
+    #field;
+    #token;
+    #fetch;
+    constructor(cfg, fetchImpl) {
+        this.#endpoint = cfg.endpoint.replace(/\/+$/, '');
+        this.#mount = (cfg.mount ?? 'secret').replace(/^\/+|\/+$/g, '');
+        this.#path = cfg.path.replace(/^\/+/, '');
+        this.#field = cfg.field ?? 'value';
+        this.#token = cfg.token;
+        this.#fetch = fetchImpl ?? globalThis.fetch;
+    }
+    #headers() {
+        const h = { 'content-type': 'application/json' };
+        if (this.#token)
+            h['x-vault-token'] = this.#token;
+        return h;
+    }
+    #dataUrl() { return `${this.#endpoint}/v1/${this.#mount}/data/${this.#path}`; }
+    #metaUrl() { return `${this.#endpoint}/v1/${this.#mount}/metadata/${this.#path}`; }
+    async read() {
+        const res = await this.#fetch(this.#dataUrl(), { method: 'GET', headers: this.#headers() });
+        if (res.status === 404)
+            return null;
+        if (!res.ok)
+            throw new Error(`AuthKit keystore (hashicorp-vault): read falhou (HTTP ${res.status}).`);
+        const body = await res.json();
+        const value = body?.data?.data?.[this.#field];
+        return typeof value === 'string' ? value : null;
+    }
+    async write(blob) {
+        const res = await this.#fetch(this.#dataUrl(), {
+            method: 'POST',
+            headers: this.#headers(),
+            body: JSON.stringify({ data: { [this.#field]: blob } }),
+        });
+        if (!res.ok)
+            throw new Error(`AuthKit keystore (hashicorp-vault): write falhou (HTTP ${res.status}).`);
+    }
+    async head() {
+        const res = await this.#fetch(this.#metaUrl(), { method: 'GET', headers: this.#headers() });
+        if (res.status === 404)
+            return null;
+        if (!res.ok)
+            return null; // head é best-effort p/ o poll
+        const body = await res.json();
+        const v = body?.data?.current_version;
+        return v === undefined || v === null ? null : String(v);
+    }
+}
+/**
+ * Proxy que lazy-importa um package de cofre externo (aws/gcp/azure secrets managers)
+ * no PRIMEIRO I/O e delega. Mantém `resolveKeystoreVault` síncrono. O package precisa
+ * exportar `createKeystoreVault(cfg): KeystoreVault`. Se não estiver instalado → erro
+ * claro pedindo pra instalar (chave é crítica, não degrada).
+ */
+export class LazyExternalVault {
+    pkg;
+    cfg;
+    importFn;
+    #inner;
+    constructor(pkg, cfg, importFn = (spec) => import(__rewriteRelativeImportExtension(spec))) {
+        this.pkg = pkg;
+        this.cfg = cfg;
+        this.importFn = importFn;
+    }
+    async #resolve() {
+        if (this.#inner)
+            return this.#inner;
+        let mod;
+        try {
+            mod = await this.importFn(this.pkg);
+        }
+        catch {
+            throw new Error(`AuthKit keystore: instale o package ${this.pkg} para usar este driver.`);
+        }
+        const factory = mod?.createKeystoreVault ?? mod?.default?.createKeystoreVault;
+        if (typeof factory !== 'function') {
+            throw new Error(`AuthKit keystore: ${this.pkg} não exporta createKeystoreVault.`);
+        }
+        this.#inner = factory(this.cfg);
+        return this.#inner;
+    }
+    async read() {
+        return (await this.#resolve()).read();
+    }
+    async write(blob) {
+        return (await this.#resolve()).write(blob);
+    }
+    async head() {
+        const v = await this.#resolve();
+        return v.head ? v.head() : null;
+    }
+}
+/**
+ * Cofre num disk do `@adonisjs/drive` (S3/GCS/local). Diferente do avatar, chave é
+ * crítica: se o drive não está instalado mas foi selecionado → ERRO (não degrada).
+ */
+export class DriveKeystoreVault {
+    key;
+    diskName;
+    constructor(key, diskName) {
+        this.key = key;
+        this.diskName = diskName;
+    }
+    async disk() {
+        const drive = await loadDrive();
+        if (!drive) {
+            throw new Error('AuthKit keystore: driver "drive" selecionado mas @adonisjs/drive não está instalado.');
+        }
+        return this.diskName ? drive.use(this.diskName) : drive;
+    }
+    async read() {
+        const disk = await this.disk();
+        if (!(await disk.exists(this.key)))
+            return null;
+        return disk.get(this.key);
+    }
+    async write(blob) {
+        const disk = await this.disk();
+        await disk.put(this.key, blob);
+    }
+    async head() {
+        const disk = await this.disk();
+        try {
+            const meta = await disk.getMetaData(this.key);
+            return meta?.etag ?? (meta?.lastModified ? String(new Date(meta.lastModified).getTime()) : null);
+        }
+        catch {
+            return null;
+        }
+    }
+}

package/build/src/mixins/json_column.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Serializer canônico de coluna JSON para os mixins. Centraliza o par
+ * `prepare`/`consume` (`JSON.stringify`/`JSON.parse`) que cada mixin escrevia à
+ * mão com tratamentos de null/default ligeiramente diferentes.
+ *
+ * As opções parametrizam exatamente as variações observadas entre os mixins, de
+ * modo que o comportamento por coluna fica IDÊNTICO ao código original:
+ *
+ * - `fallback`: valor devolvido por `consume` quando a coluna é null/undefined
+ *   (ex.: `[]` para `globalRoles`/`scopes`; `null` para `recoveryCodes`/`metadata`).
+ * - `emptyOnWrite`: o que `prepare` grava quando o valor é "vazio" (null/undefined,
+ *   ou — quando `treatEmptyArrayAsEmpty` — um array de length 0). `'null'` grava
+ *   `null` na coluna; `'serialize'` ainda serializa (ex.: `globalRoles` grava
+ *   `"[]"`). Default: `'null'`.
+ * - `treatEmptyArrayAsEmpty`: quando true, um array vazio também conta como "vazio"
+ *   no write (caso do `transports`, que grava null em `[]`). Default: false.
+ */
+export interface JsonColumnOptions<T> {
+    /** Valor devolvido por `consume` quando a coluna está null/undefined. */
+    fallback: T;
+    /** O que `prepare` grava para valores vazios. Default: 'null'. */
+    emptyOnWrite?: 'null' | 'serialize';
+    /** Trata array vazio como "vazio" no write (grava null). Default: false. */
+    treatEmptyArrayAsEmpty?: boolean;
+}
+/**
+ * Devolve o par `{ prepare, consume }` para usar num `@column({...})`.
+ * `T` é o tipo lógico da coluna (ex.: `string[]` ou `Record<string, unknown>`).
+ */
+export declare function jsonColumn<T>(opts: JsonColumnOptions<T>): {
+    prepare: (value: T | null | undefined) => string | null;
+    consume: (value: unknown) => T;
+};

package/build/src/mixins/json_column.js

@@ -0,0 +1,38 @@
+/**
+ * Devolve o par `{ prepare, consume }` para usar num `@column({...})`.
+ * `T` é o tipo lógico da coluna (ex.: `string[]` ou `Record<string, unknown>`).
+ */
+export function jsonColumn(opts) {
+    const emptyOnWrite = opts.emptyOnWrite ?? 'null';
+    const treatEmptyArrayAsEmpty = opts.treatEmptyArrayAsEmpty ?? false;
+    const isEmpty = (value) => {
+        if (value === null || value === undefined)
+            return true;
+        if (treatEmptyArrayAsEmpty && Array.isArray(value) && value.length === 0)
+            return true;
+        return false;
+    };
+    return {
+        prepare: (value) => {
+            if (isEmpty(value)) {
+                return emptyOnWrite === 'serialize' ? JSON.stringify(opts.fallback) : null;
+            }
+            return JSON.stringify(value);
+        },
+        consume: (value) => {
+            if (value === null || value === undefined)
+                return opts.fallback;
+            // Drivers de Postgres entregam colunas json/jsonb JÁ desserializadas
+            // (objeto/array); SQLite entrega TEXT. Só strings precisam de JSON.parse —
+            // parsear um objeto vira JSON.parse("[object Object]") e explode.
+            if (typeof value !== 'string')
+                return value;
+            try {
+                return JSON.parse(value);
+            }
+            catch {
+                return opts.fallback;
+            }
+        },
+    };
+}

package/build/src/mixins/with_audit_log.d.ts

@@ -0,0 +1,19 @@
+import { BaseModel } from '@adonisjs/lucid/orm';
+import type { NormalizeConstructor } from '@adonisjs/core/types/helpers';
+import { DateTime } from 'luxon';
+import type { AuditEventType } from '../audit/audit_sink.js';
+/** Instância composta pelo mixin {@link withAuditLog}. */
+export interface AuditLogRow {
+    type: AuditEventType;
+    accountId: string | null;
+    email: string | null;
+    clientId: string | null;
+    actorId: string | null;
+    ip: string | null;
+    metadata: Record<string, unknown> | null;
+    createdAt: DateTime;
+}
+export type AuditLogClass<Model extends NormalizeConstructor<typeof BaseModel>> = Model & {
+    new (...args: any[]): AuditLogRow;
+};
+export declare function withAuditLog(): <Model extends NormalizeConstructor<typeof BaseModel>>(superclass: Model) => AuditLogClass<Model>;

package/build/src/mixins/with_audit_log.js

@@ -0,0 +1,39 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { column } from '@adonisjs/lucid/orm';
+import { jsonColumn } from './json_column.js';
+export function withAuditLog() {
+    return (superclass) => {
+        class AuditLogMixin extends superclass {
+        }
+        __decorate([
+            column()
+        ], AuditLogMixin.prototype, "type", void 0);
+        __decorate([
+            column()
+        ], AuditLogMixin.prototype, "accountId", void 0);
+        __decorate([
+            column()
+        ], AuditLogMixin.prototype, "email", void 0);
+        __decorate([
+            column()
+        ], AuditLogMixin.prototype, "clientId", void 0);
+        __decorate([
+            column()
+        ], AuditLogMixin.prototype, "actorId", void 0);
+        __decorate([
+            column()
+        ], AuditLogMixin.prototype, "ip", void 0);
+        __decorate([
+            column(jsonColumn({ fallback: null }))
+        ], AuditLogMixin.prototype, "metadata", void 0);
+        __decorate([
+            column.dateTime({ autoCreate: true })
+        ], AuditLogMixin.prototype, "createdAt", void 0);
+        return AuditLogMixin;
+    };
+}

package/build/src/mixins/with_auth_user.d.ts

@@ -0,0 +1,24 @@
+import { BaseModel } from '@adonisjs/lucid/orm';
+import type { NormalizeConstructor } from '@adonisjs/core/types/helpers';
+/**
+ * Instância composta pelo mixin {@link withAuthUser}.
+ */
+export interface AuthUserRow {
+    email: string;
+    password: string;
+    globalRoles: string[];
+    verifyPassword(plain: string): Promise<boolean>;
+    /**
+     * O hash armazenado precisa ser re-gerado? `true` quando o hasher atual não
+     * reconhece o formato (hash legado de outro sistema) OU os parâmetros estão
+     * desatualizados. Usado pelo lazy rehash no login.
+     */
+    passwordNeedsRehash(): boolean;
+}
+/**
+ * Classe resultante da composição com o mixin {@link withAuthUser}.
+ */
+export type AuthUserClass<Model extends NormalizeConstructor<typeof BaseModel>> = Model & {
+    new (...args: any[]): AuthUserRow;
+};
+export declare function withAuthUser(): <Model extends NormalizeConstructor<typeof BaseModel>>(superclass: Model) => AuthUserClass<Model>;