@adonis-agora/authkit-server 0.34.0

package/build/src/commands/import_clients.d.ts

@@ -0,0 +1,40 @@
+import type { ClientConfig } from '@adonis-agora/authkit-core';
+import type { AdminClientsService } from '../host/admin_clients_service.js';
+/** Resultado da importação de um client individual. */
+export type ClientImportOutcome = 'created' | 'skipped' | 'error';
+/** Linha de relatório por client. */
+export interface ClientImportEntry {
+    clientId: string;
+    outcome: ClientImportOutcome;
+    /** Razão do erro ou 'already exists' no caso de skip. */
+    reason?: string;
+    /**
+     * Secret gerado (em claro, mostrado UMA vez) — presente apenas em `created` e
+     * somente quando o client é confidencial. Não recuperável depois.
+     */
+    clientSecret?: string;
+}
+/** Relatório agregado da operação. */
+export interface ClientsImportReport {
+    created: number;
+    skipped: number;
+    errors: number;
+    entries: ClientImportEntry[];
+}
+/**
+ * Importa a lista de clients estáticos do config para o adapter/DB via
+ * {@link AdminClientsService}. Idempotente: clients cujo `client_id` já existe no
+ * adapter são pulados (preservando o secret original). O `client_secret` do config
+ * estático é PRESERVADO na criação (passado diretamente como `clientId` ficará com
+ * o secret original). Para clients sem secret (public), `clientSecret` fica omitido.
+ *
+ * A função é PURA quanto a I/O do config (recebe os records já parseados) —
+ * testável em isolamento. O único I/O é via `svc` (adapter).
+ *
+ * @param clients - Lista de {@link ClientConfig} vindos de `config.clients`.
+ * @param svc     - Serviço admin de clients (CRUD sobre o adapter).
+ * @param options - `dryRun`: não persiste, só relata o que SERIA feito.
+ */
+export declare function importClients(clients: ClientConfig[], svc: AdminClientsService, options?: {
+    dryRun?: boolean;
+}): Promise<ClientsImportReport>;

package/build/src/commands/import_clients.js

@@ -0,0 +1,79 @@
+/**
+ * Importa a lista de clients estáticos do config para o adapter/DB via
+ * {@link AdminClientsService}. Idempotente: clients cujo `client_id` já existe no
+ * adapter são pulados (preservando o secret original). O `client_secret` do config
+ * estático é PRESERVADO na criação (passado diretamente como `clientId` ficará com
+ * o secret original). Para clients sem secret (public), `clientSecret` fica omitido.
+ *
+ * A função é PURA quanto a I/O do config (recebe os records já parseados) —
+ * testável em isolamento. O único I/O é via `svc` (adapter).
+ *
+ * @param clients - Lista de {@link ClientConfig} vindos de `config.clients`.
+ * @param svc     - Serviço admin de clients (CRUD sobre o adapter).
+ * @param options - `dryRun`: não persiste, só relata o que SERIA feito.
+ */
+export async function importClients(clients, svc, options = {}) {
+    const report = { created: 0, skipped: 0, errors: 0, entries: [] };
+    for (const client of clients) {
+        const clientId = client.clientId;
+        // Verifica se já existe no adapter.
+        let exists = false;
+        try {
+            const found = await svc.find(clientId);
+            exists = !!found;
+        }
+        catch (err) {
+            report.errors++;
+            report.entries.push({
+                clientId,
+                outcome: 'error',
+                reason: `falha ao verificar existência: ${err.message}`,
+            });
+            continue;
+        }
+        if (exists) {
+            report.skipped++;
+            report.entries.push({ clientId, outcome: 'skipped', reason: 'already exists' });
+            continue;
+        }
+        if (options.dryRun) {
+            // Dry-run: conta como "would create" sem persistir.
+            report.created++;
+            report.entries.push({ clientId, outcome: 'created' });
+            continue;
+        }
+        // Determina o auth method a partir do config estático.
+        const authMethod = client.tokenEndpointAuthMethod ?? (client.clientSecret ? 'client_secret_basic' : 'none');
+        try {
+            // Cria via AdminClientsService, que usa o mesmo caminho do console admin / registro dinâmico.
+            // Para preservar o client_secret do config estático, escrevemos diretamente via adapter —
+            // o `svc.create` gera um secret aleatório. Usamos a API interna do svc para construir o
+            // payload com o secret original e persistir.
+            const preservedSecret = client.clientSecret;
+            const created = await svc.createWithSecret({
+                clientId,
+                redirectUris: client.redirectUris ?? [],
+                postLogoutRedirectUris: client.postLogoutRedirectUris ?? [],
+                grantTypes: client.grants ?? ['authorization_code', 'refresh_token'],
+                tokenEndpointAuthMethod: authMethod,
+                backchannelLogoutUri: client.backchannelLogoutUri,
+                backchannelLogoutSessionRequired: client.backchannelLogoutSessionRequired,
+            }, preservedSecret);
+            report.created++;
+            report.entries.push({
+                clientId,
+                outcome: 'created',
+                clientSecret: created.clientSecret,
+            });
+        }
+        catch (err) {
+            report.errors++;
+            report.entries.push({
+                clientId,
+                outcome: 'error',
+                reason: err.message,
+            });
+        }
+    }
+    return report;
+}

package/build/src/commands/import_users.d.ts

@@ -0,0 +1,51 @@
+import type { AccountStore } from '../accounts/account_store.js';
+/** Uma linha do arquivo de import (campos extras viram custom — globalRoles). */
+export interface ImportUserRecord {
+    email?: string;
+    /** Hash de senha já pronto (qualquer formato). Inserido como está (lazy rehash). */
+    password_hash?: string | null;
+    name?: string | null;
+    email_verified?: boolean;
+    /** Papéis globais (opcional). */
+    global_roles?: string[];
+}
+/** Relatório agregado do import. */
+export interface ImportReport {
+    created: number;
+    /** Pulados por e-mail duplicado (já existente). */
+    skippedDuplicate: number;
+    /** Linhas com erro de parsing/validação. */
+    errors: {
+        line: number;
+        reason: string;
+    }[];
+}
+/**
+ * Faz o parse do conteúdo do arquivo: aceita NDJSON (uma linha JSON por usuário)
+ * OU um array JSON. Retorna os registros + os erros de parsing por linha. PURO
+ * (sem I/O) para ser testável.
+ */
+export declare function parseImportFile(content: string): {
+    records: {
+        line: number;
+        record: ImportUserRecord;
+    }[];
+    parseErrors: {
+        line: number;
+        reason: string;
+    }[];
+};
+/**
+ * Importa os registros pelo account store (sem re-hash — o lazy rehash no login
+ * migra). Idempotente por e-mail (duplicados são pulados). Com `dryRun`, NÃO
+ * persiste nada (só valida e conta o que SERIA criado).
+ *
+ * Lógica PURA quanto a I/O de arquivo (recebe os registros já parseados) — fácil
+ * de testar. Lança se o store não suporta import nem create.
+ */
+export declare function importUsers(store: AccountStore, records: {
+    line: number;
+    record: ImportUserRecord;
+}[], options?: {
+    dryRun?: boolean;
+}): Promise<ImportReport>;

package/build/src/commands/import_users.js

@@ -0,0 +1,94 @@
+import { supportsAccountImport } from '../accounts/account_store.js';
+/**
+ * Faz o parse do conteúdo do arquivo: aceita NDJSON (uma linha JSON por usuário)
+ * OU um array JSON. Retorna os registros + os erros de parsing por linha. PURO
+ * (sem I/O) para ser testável.
+ */
+export function parseImportFile(content) {
+    const trimmed = content.trim();
+    const records = [];
+    const parseErrors = [];
+    if (trimmed.startsWith('[')) {
+        // Array JSON.
+        try {
+            const arr = JSON.parse(trimmed);
+            if (!Array.isArray(arr)) {
+                parseErrors.push({ line: 1, reason: 'expected a JSON array or NDJSON' });
+                return { records, parseErrors };
+            }
+            arr.forEach((record, i) => records.push({ line: i + 1, record }));
+        }
+        catch (error) {
+            parseErrors.push({ line: 1, reason: `invalid JSON array: ${error.message}` });
+        }
+        return { records, parseErrors };
+    }
+    // NDJSON: uma linha JSON por usuário (linhas vazias ignoradas).
+    const lines = trimmed.split('\n');
+    lines.forEach((raw, i) => {
+        const line = raw.trim();
+        if (!line)
+            return;
+        try {
+            records.push({ line: i + 1, record: JSON.parse(line) });
+        }
+        catch (error) {
+            parseErrors.push({ line: i + 1, reason: `invalid JSON: ${error.message}` });
+        }
+    });
+    return { records, parseErrors };
+}
+/**
+ * Importa os registros pelo account store (sem re-hash — o lazy rehash no login
+ * migra). Idempotente por e-mail (duplicados são pulados). Com `dryRun`, NÃO
+ * persiste nada (só valida e conta o que SERIA criado).
+ *
+ * Lógica PURA quanto a I/O de arquivo (recebe os registros já parseados) — fácil
+ * de testar. Lança se o store não suporta import nem create.
+ */
+export async function importUsers(store, records, options = {}) {
+    const report = { created: 0, skippedDuplicate: 0, errors: [] };
+    const canImport = supportsAccountImport(store);
+    for (const { line, record } of records) {
+        const email = record.email?.trim();
+        if (!email) {
+            report.errors.push({ line, reason: 'missing email' });
+            continue;
+        }
+        // Duplicado: e-mail já existe → pula.
+        const existing = await store.findByEmail(email);
+        if (existing) {
+            report.skippedDuplicate++;
+            continue;
+        }
+        if (options.dryRun) {
+            report.created++;
+            continue;
+        }
+        try {
+            if (canImport) {
+                const created = await store.importAccount({
+                    email,
+                    passwordHash: record.password_hash ?? null,
+                    fullName: record.name ?? null,
+                    globalRoles: record.global_roles,
+                    emailVerified: record.email_verified ?? false,
+                });
+                // null = corrida (e-mail criado entre o check e o insert) → conta como dup.
+                if (created)
+                    report.created++;
+                else
+                    report.skippedDuplicate++;
+            }
+            else {
+                // Fallback: store sem import — usa create (re-hasheia e aplica política).
+                // Útil quando o registro traz senha em claro; sem hash nem senha falha.
+                report.errors.push({ line, reason: 'store does not support account import' });
+            }
+        }
+        catch (error) {
+            report.errors.push({ line, reason: error.message });
+        }
+    }
+    return report;
+}

package/build/src/commands/resolve_config.d.ts

@@ -0,0 +1,13 @@
+import type { ApplicationService } from '@adonisjs/core/types';
+/**
+ * Resolve o valor exportado por `config/authkit.ts` para a config final.
+ *
+ * `defineConfig` retorna um config PROVIDER (`{ type, resolver }`) que o service
+ * provider resolve no boot — mas `config.get('authkit')` devolve esse provider
+ * CRU. Comandos ace que leem a config diretamente (doctor, users:import,
+ * keys:rotate) precisam resolvê-lo antes de inspecionar campos, senão veem
+ * `issuer`/`accountStore`/`jwks` como ausentes mesmo num config válido.
+ *
+ * Valores planos (configs antigos/test fixtures) passam direto.
+ */
+export declare function resolveAuthkitConfig<T = Record<string, any>>(app: ApplicationService, raw: unknown): Promise<T | null>;

package/build/src/commands/resolve_config.js

@@ -0,0 +1,18 @@
+import { configProvider } from '@adonisjs/core';
+/**
+ * Resolve o valor exportado por `config/authkit.ts` para a config final.
+ *
+ * `defineConfig` retorna um config PROVIDER (`{ type, resolver }`) que o service
+ * provider resolve no boot — mas `config.get('authkit')` devolve esse provider
+ * CRU. Comandos ace que leem a config diretamente (doctor, users:import,
+ * keys:rotate) precisam resolvê-lo antes de inspecionar campos, senão veem
+ * `issuer`/`accountStore`/`jwks` como ausentes mesmo num config válido.
+ *
+ * Valores planos (configs antigos/test fixtures) passam direto.
+ */
+export async function resolveAuthkitConfig(app, raw) {
+    if (!raw)
+        return null;
+    const resolved = (await configProvider.resolve(app, raw));
+    return resolved ?? raw;
+}

package/build/src/commands/settings_commands.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Ace commands para gerenciamento de runtime settings da tabela `auth_settings`.
+ *
+ * Todos os commands usam o padrão dos commands existentes:
+ *   - resolveAuthkitConfig + container para obter a config
+ *   - SettingsCapability do store ou RuntimeSettings sobre o DB
+ *   - Auditam settings.updated com actor 'cli'
+ *
+ * Commands disponíveis:
+ *   authkit:settings:list               — lista todas as settings presentes
+ *   authkit:settings:get  <key>         — obtém uma setting por key
+ *   authkit:settings:set  <key> <json>  — grava (upsert) uma setting (valida shape se key conhecida)
+ *   authkit:settings:unset <key>        — apaga uma setting (reset to config)
+ *
+ * Todas suportam --json para output machine-readable.
+ */
+import type { ApplicationService } from '@adonisjs/core/types';
+export declare function settingsList(app: ApplicationService, opts: {
+    json?: boolean;
+    logger: {
+        info: (m: string) => void;
+        warn: (m: string) => void;
+    };
+}): Promise<void>;
+export declare function settingsGet(app: ApplicationService, key: string, opts: {
+    json?: boolean;
+    logger: {
+        info: (m: string) => void;
+        warn: (m: string) => void;
+    };
+}): Promise<void>;
+export declare function settingsSet(app: ApplicationService, key: string, jsonValue: string, opts: {
+    json?: boolean;
+    logger: {
+        info: (m: string) => void;
+        warn: (m: string) => void;
+        error: (m: string) => void;
+    };
+}): Promise<boolean>;
+export declare function settingsUnset(app: ApplicationService, key: string, opts: {
+    json?: boolean;
+    logger: {
+        info: (m: string) => void;
+        warn: (m: string) => void;
+        error: (m: string) => void;
+    };
+}): Promise<void>;

package/build/src/commands/settings_commands.js

@@ -0,0 +1,270 @@
+/**
+ * Ace commands para gerenciamento de runtime settings da tabela `auth_settings`.
+ *
+ * Todos os commands usam o padrão dos commands existentes:
+ *   - resolveAuthkitConfig + container para obter a config
+ *   - SettingsCapability do store ou RuntimeSettings sobre o DB
+ *   - Auditam settings.updated com actor 'cli'
+ *
+ * Commands disponíveis:
+ *   authkit:settings:list               — lista todas as settings presentes
+ *   authkit:settings:get  <key>         — obtém uma setting por key
+ *   authkit:settings:set  <key> <json>  — grava (upsert) uma setting (valida shape se key conhecida)
+ *   authkit:settings:unset <key>        — apaga uma setting (reset to config)
+ *
+ * Todas suportam --json para output machine-readable.
+ */
+import { RuntimeSettings } from '../host/runtime_settings.js';
+import { resolveAuthkitConfig } from './resolve_config.js';
+import { SETTING_KEYS } from '../host/runtime_toggles.js';
+// ---------------------------------------------------------------------------
+// Known-key shape validators (best-effort — warn only, não rejeita)
+// ---------------------------------------------------------------------------
+const KNOWN_KEYS = new Set(Object.values(SETTING_KEYS));
+/** Validação superficial de shape para keys conhecidas. Retorna null se ok, string de erro se inválida. */
+function validateKnownKey(key, value) {
+    if (value === null || value === undefined)
+        return null;
+    if (typeof value !== 'object' || Array.isArray(value)) {
+        return `Value for key "${key}" must be a JSON object, got ${Array.isArray(value) ? 'array' : typeof value}.`;
+    }
+    const obj = value;
+    switch (key) {
+        case SETTING_KEYS.LOCKOUT: {
+            const fields = ['enabled', 'maxAttempts', 'windowSec', 'baseLockoutSec', 'maxLockoutSec'];
+            for (const f of fields) {
+                if (f in obj && f === 'enabled' && typeof obj[f] !== 'boolean')
+                    return `lockout.${f} must be boolean`;
+                if (f in obj && f !== 'enabled' && typeof obj[f] !== 'number')
+                    return `lockout.${f} must be number`;
+            }
+            return null;
+        }
+        case SETTING_KEYS.RATE_LIMIT: {
+            for (const bucket of ['login', 'introspection']) {
+                if (bucket in obj && obj[bucket] !== null) {
+                    const b = obj[bucket];
+                    if (typeof b !== 'object' || Array.isArray(b))
+                        return `rate_limit.${bucket} must be object`;
+                    if ('points' in b && typeof b.points !== 'number')
+                        return `rate_limit.${bucket}.points must be number`;
+                    if ('duration' in b && typeof b.duration !== 'string')
+                        return `rate_limit.${bucket}.duration must be string`;
+                }
+            }
+            return null;
+        }
+        case SETTING_KEYS.PASSWORD_POLICY: {
+            const boolFields = ['requireUppercase', 'requireLowercase', 'requireNumbers', 'requireSymbols', 'checkPwned'];
+            for (const f of boolFields) {
+                if (f in obj && typeof obj[f] !== 'boolean')
+                    return `password_policy.${f} must be boolean`;
+            }
+            if ('minLength' in obj && typeof obj.minLength !== 'number')
+                return `password_policy.minLength must be number`;
+            return null;
+        }
+        case SETTING_KEYS.NOTIFICATIONS: {
+            for (const f of ['newLoginEmail', 'newDeviceEmail']) {
+                if (f in obj && typeof obj[f] !== 'boolean')
+                    return `notifications.${f} must be boolean`;
+            }
+            return null;
+        }
+        case SETTING_KEYS.TRUSTED_DEVICES: {
+            if ('enabled' in obj && typeof obj.enabled !== 'boolean')
+                return 'trusted_devices.enabled must be boolean';
+            if ('days' in obj && typeof obj.days !== 'number')
+                return 'trusted_devices.days must be number';
+            return null;
+        }
+        case SETTING_KEYS.TOKEN_TTL: {
+            const fields = ['accessTokenSec', 'idTokenSec', 'refreshTokenSec'];
+            for (const f of fields) {
+                if (f in obj && typeof obj[f] !== 'number')
+                    return `token_ttl.${f} must be number`;
+            }
+            return null;
+        }
+        case SETTING_KEYS.ADMIN_IMPERSONATION: {
+            if ('enabled' in obj && typeof obj.enabled !== 'boolean')
+                return 'admin_impersonation.enabled must be boolean';
+            return null;
+        }
+        case SETTING_KEYS.ORGANIZATIONS_POLICY: {
+            if ('allowSelfCreate' in obj && typeof obj.allowSelfCreate !== 'boolean')
+                return 'organizations_policy.allowSelfCreate must be boolean';
+            if ('invitationTtlHours' in obj && typeof obj.invitationTtlHours !== 'number')
+                return 'organizations_policy.invitationTtlHours must be number';
+            if ('roles' in obj && !Array.isArray(obj.roles))
+                return 'organizations_policy.roles must be array';
+            return null;
+        }
+        default:
+            return null;
+    }
+}
+// ---------------------------------------------------------------------------
+// Shared helper: resolve settings service
+// ---------------------------------------------------------------------------
+async function resolveSettingsService(app) {
+    try {
+        const db = await app.container.make('lucid.db');
+        // Tenta derivar a conexão do accountStore para probe searchPath-aware.
+        let connection;
+        try {
+            const cfg = await resolveCfg(app);
+            connection = cfg?.accountStore?.connectionName;
+        }
+        catch {
+            // Silencioso: sem config → default connection.
+        }
+        return new RuntimeSettings(db, connection ? { connection } : {});
+    }
+    catch {
+        return null;
+    }
+}
+async function resolveCfg(app) {
+    const raw = app.config?.get?.('authkit') ?? null;
+    return resolveAuthkitConfig(app, raw);
+}
+// ---------------------------------------------------------------------------
+// authkit:settings:list
+// ---------------------------------------------------------------------------
+export async function settingsList(app, opts) {
+    const svc = await resolveSettingsService(app);
+    if (!svc) {
+        opts.logger.warn('Could not connect to database — is lucid.db bound in the container?');
+        return;
+    }
+    const tablePresent = await svc.isTablePresent();
+    if (!tablePresent) {
+        opts.logger.warn('The `auth_settings` table is not present. Run migrations to create it.');
+        return;
+    }
+    const rows = await svc.listSettings();
+    if (opts.json) {
+        opts.logger.info(JSON.stringify(rows.map((r) => ({ key: r.key, value: r.value, updatedAt: r.updatedAt, updatedBy: r.updatedBy }))));
+        return;
+    }
+    if (rows.length === 0) {
+        opts.logger.info('No runtime settings found (table present but empty).');
+        return;
+    }
+    for (const row of rows) {
+        const updatedInfo = row.updatedAt ? ` [updated: ${row.updatedAt}]` : '';
+        const byInfo = row.updatedBy ? ` by: ${row.updatedBy}` : '';
+        opts.logger.info(`  ${row.key}${updatedInfo}${byInfo}: ${JSON.stringify(row.value)}`);
+    }
+}
+// ---------------------------------------------------------------------------
+// authkit:settings:get
+// ---------------------------------------------------------------------------
+export async function settingsGet(app, key, opts) {
+    const svc = await resolveSettingsService(app);
+    if (!svc) {
+        opts.logger.warn('Could not connect to database.');
+        return;
+    }
+    const tablePresent = await svc.isTablePresent();
+    if (!tablePresent) {
+        opts.logger.warn('The `auth_settings` table is not present.');
+        return;
+    }
+    const value = await svc.getSetting(key);
+    if (value === null) {
+        opts.logger.warn(`Setting "${key}" not found (not set — config/default applies).`);
+        return;
+    }
+    if (opts.json) {
+        opts.logger.info(JSON.stringify({ key, value }));
+        return;
+    }
+    opts.logger.info(`${key}: ${JSON.stringify(value, null, 2)}`);
+}
+// ---------------------------------------------------------------------------
+// authkit:settings:set
+// ---------------------------------------------------------------------------
+export async function settingsSet(app, key, jsonValue, opts) {
+    let parsed;
+    try {
+        parsed = JSON.parse(jsonValue);
+    }
+    catch {
+        opts.logger.error(`Invalid JSON for value: ${jsonValue}`);
+        return false;
+    }
+    // Warn on unknown keys; validate shape for known keys.
+    if (!KNOWN_KEYS.has(key)) {
+        opts.logger.warn(`Key "${key}" is not in the known setting catalog. Proceeding with write (unknown keys are stored as-is).`);
+    }
+    else {
+        const validationError = validateKnownKey(key, parsed);
+        if (validationError) {
+            opts.logger.error(`Shape validation error for key "${key}": ${validationError}`);
+            return false;
+        }
+    }
+    const svc = await resolveSettingsService(app);
+    if (!svc) {
+        opts.logger.error('Could not connect to database.');
+        return false;
+    }
+    const tablePresent = await svc.isTablePresent();
+    if (!tablePresent) {
+        opts.logger.error('The `auth_settings` table is not present. Run migrations to create it.');
+        return false;
+    }
+    await svc.setSetting(key, parsed, 'cli');
+    // Audit via config.audit if available.
+    const cfg = await resolveCfg(app);
+    await cfg?.audit?.record({
+        type: 'settings.updated',
+        actorId: 'cli',
+        ip: null,
+        metadata: { key, value: parsed },
+    });
+    if (opts.json) {
+        opts.logger.info(JSON.stringify({ key, value: parsed, updated: true }));
+        return true;
+    }
+    opts.logger.info(`Setting "${key}" saved.`);
+    return true;
+}
+// ---------------------------------------------------------------------------
+// authkit:settings:unset
+// ---------------------------------------------------------------------------
+export async function settingsUnset(app, key, opts) {
+    const svc = await resolveSettingsService(app);
+    if (!svc) {
+        opts.logger.error('Could not connect to database.');
+        return;
+    }
+    const tablePresent = await svc.isTablePresent();
+    if (!tablePresent) {
+        opts.logger.error('The `auth_settings` table is not present.');
+        return;
+    }
+    const existing = await svc.getSetting(key);
+    if (existing === null) {
+        opts.logger.warn(`Setting "${key}" was not set (nothing to unset).`);
+        if (opts.json)
+            opts.logger.info(JSON.stringify({ key, deleted: false }));
+        return;
+    }
+    await svc.deleteSetting(key);
+    // Audit.
+    const cfg = await resolveCfg(app);
+    await cfg?.audit?.record({
+        type: 'settings.updated',
+        actorId: 'cli',
+        ip: null,
+        metadata: { key, action: 'deleted' },
+    });
+    if (opts.json) {
+        opts.logger.info(JSON.stringify({ key, deleted: true }));
+        return;
+    }
+    opts.logger.info(`Setting "${key}" deleted — config/default is now the source of truth.`);
+}

package/build/src/controllers/oidc_callback_controller.d.ts

@@ -0,0 +1,22 @@
+import type { HttpContext } from '@adonisjs/core/http';
+/**
+ * Delega a requisição Adonis ao handler do oidc-provider (`service.callback`),
+ * que faz seu próprio roteamento e escreve direto na resposta Node.
+ *
+ * Quando o issuer tem um path (ex.: `/oidc`), o `service.callback` é um app Koa
+ * com o provider MONTADO sob esse path via koa-mount (vide OidcService). Por isso
+ * NÃO removemos o prefixo de `req.url`: o koa-mount cuida do mount e o provider
+ * gera URLs de discovery/redirect já prefixadas (ex.: /oidc/auth, /oidc/jwks).
+ *
+ * Resolvemos a Promise no `finish`/`close` para impedir que o Adonis tente
+ * tratar a resposta novamente.
+ *
+ * Body bridge: o bodyparser do AdonisJS consome o stream da requisição antes
+ * de chegar aqui. O oidc-provider usa `raw-body` para ler o stream — como ele
+ * já está esgotado, o provider cai no fallback `ctx.req.body || ctx.request.body`.
+ * Populamos `req.body` com o payload já parseado pelo AdonisJS para que o
+ * oidc-provider consiga ler os parâmetros do formulário (client_id, code, etc.).
+ */
+export default class OidcCallbackController {
+    handle(ctx: HttpContext): Promise<void>;
+}

package/build/src/controllers/oidc_callback_controller.js

@@ -0,0 +1,33 @@
+/**
+ * Delega a requisição Adonis ao handler do oidc-provider (`service.callback`),
+ * que faz seu próprio roteamento e escreve direto na resposta Node.
+ *
+ * Quando o issuer tem um path (ex.: `/oidc`), o `service.callback` é um app Koa
+ * com o provider MONTADO sob esse path via koa-mount (vide OidcService). Por isso
+ * NÃO removemos o prefixo de `req.url`: o koa-mount cuida do mount e o provider
+ * gera URLs de discovery/redirect já prefixadas (ex.: /oidc/auth, /oidc/jwks).
+ *
+ * Resolvemos a Promise no `finish`/`close` para impedir que o Adonis tente
+ * tratar a resposta novamente.
+ *
+ * Body bridge: o bodyparser do AdonisJS consome o stream da requisição antes
+ * de chegar aqui. O oidc-provider usa `raw-body` para ler o stream — como ele
+ * já está esgotado, o provider cai no fallback `ctx.req.body || ctx.request.body`.
+ * Populamos `req.body` com o payload já parseado pelo AdonisJS para que o
+ * oidc-provider consiga ler os parâmetros do formulário (client_id, code, etc.).
+ */
+export default class OidcCallbackController {
+    async handle(ctx) {
+        const service = await ctx.containerResolver.make('authkit.server');
+        const req = ctx.request.request;
+        const res = ctx.response.response;
+        // Repassa o body já parseado pelo AdonisJS para o req cru, pois o stream
+        // foi consumido pelo bodyparser_middleware antes de chegar neste controller.
+        req.body = ctx.request.all();
+        return new Promise((resolve) => {
+            res.on('finish', resolve);
+            res.on('close', resolve);
+            service.callback(req, res);
+        });
+    }
+}