@teamblind/axeda-better-auth 0.0.0-stage → 0.1.0-alpha.0

package/dist/plugin.js

@@ -0,0 +1,188 @@
+import { AxedaError, createAxeda, isBanned, } from '@teamblind/axeda-core';
+import { APIError, createAuthMiddleware } from 'better-auth/api';
+import { createEndpoints } from './endpoints.js';
+import { createUserEndpoints } from './endpoints-users.js';
+import { createInvitationEndpoints, createPublicEndpoints, createTenantEndpoints, } from './endpoints-tenants.js';
+import { axedaSchema } from './schema.js';
+import { createBetterAuthPersistence } from './stores.js';
+import { createBetterAuthUserAdmin } from './user-admin.js';
+import { createBetterAuthUserDirectory } from './users.js';
+/** Las opciones del núcleo: todo menos lo que es propio del plugin (reloj, envío, identidad pública). */
+function coreOptions(options) {
+    return {
+        permissions: options.permissions,
+        ...(options.roles === undefined ? {} : { roles: options.roles }),
+        ...(options.limits === undefined ? {} : { limits: options.limits }),
+        ...(options.retention === undefined ? {} : { retention: options.retention }),
+        ...(options.invitations === undefined ? {} : { invitations: options.invitations }),
+        ...(options.menus === undefined ? {} : { menus: options.menus }),
+    };
+}
+/**
+ * Opciones de Better Auth con las que Axeda se niega a arrancar. Cada una anula algo que protege
+ * a los endpoints `/axeda/*` (todos con cookie de sesión) o a la propia autorización.
+ */
+const UNSAFE_AUTH_OPTIONS = [
+    {
+        // La caché de cookie de sesión haría que `authzVersion` llegue desactualizado y que una
+        // sesión revocada siga siendo válida.
+        path: ['session', 'cookieCache', 'enabled'],
+        why: 'a revoked session or a changed permission would stay valid until the cookie expires.',
+    },
+    {
+        path: ['advanced', 'disableCSRFCheck'],
+        why: 'every /axeda/* endpoint is authenticated by a cookie and would be open to cross-site requests.',
+    },
+    {
+        path: ['advanced', 'disableOriginCheck'],
+        why: 'callback and redirect URLs would no longer be validated against trustedOrigins.',
+    },
+    {
+        path: ['advanced', 'ipAddress', 'disableIpTracking'],
+        why: 'rate limits and the audit log depend on the client address.',
+    },
+];
+function assertSafeAuthOptions(options) {
+    for (const { path, why } of UNSAFE_AUTH_OPTIONS) {
+        const value = path.reduce((node, key) => typeof node === 'object' && node !== null
+            ? node[key]
+            : undefined, options);
+        if (value === true) {
+            throw new AxedaError('AXEDA_INVALID_CONFIG', `Axeda cannot run with ${path.join('.')}: ${why} Remove the option.`);
+        }
+    }
+}
+/** Límites de peticiones por IP y minuto de los endpoints de administración. */
+const RATE_LIMITS = [
+    // El único endpoint sin sesión, más estricto (T10: enumeración).
+    { pathMatcher: (path) => path.startsWith('/axeda/public/'), max: 30, window: 60 },
+    { pathMatcher: (path) => path.startsWith('/axeda/'), max: 120, window: 60 },
+];
+/**
+ * Plugin de Axeda para Better Auth: esquema, endpoints `/axeda/*`, el hook de borrado de usuario
+ * y la conexión de la persistencia de Axeda al adaptador de base de datos de Better Auth.
+ *
+ * ```ts
+ * const axedaPlugin = axeda({ permissions: ['invoice:read'], roles: { viewer: ['invoice:read'] } });
+ * const auth = betterAuth({ plugins: [axedaPlugin] });
+ * await axedaPlugin.start(); // tras migrar la base de datos
+ * ```
+ */
+export function axeda(options) {
+    let core;
+    let persistence;
+    const instance = () => {
+        if (core === undefined) {
+            throw new AxedaError('AXEDA_INVALID_CONFIG', 'Axeda is not initialised yet: create the Better Auth instance with this plugin first.');
+        }
+        return core;
+    };
+    const plugin = {
+        id: 'axeda',
+        schema: axedaSchema,
+        endpoints: {
+            ...createEndpoints(instance),
+            ...createTenantEndpoints(instance),
+            ...createInvitationEndpoints(instance),
+            ...createUserEndpoints(instance),
+            // Siempre registrado (los tipos del cliente no dependen de la configuración); si está
+            // desactivado responde 404, igual que una compañía que no existe.
+            ...createPublicEndpoints(instance, () => options.publicIdentity === true),
+        },
+        rateLimit: RATE_LIMITS,
+        hooks: {
+            after: [
+                {
+                    // Todo lo que contesta Axeda (permisos, usuarios, auditoría, invitaciones) es de una
+                    // persona concreta: ni el navegador ni una caché intermedia deben guardarlo (ASVS V14.3.2).
+                    // También las respuestas de error.
+                    matcher: (context) => context.path?.startsWith('/axeda/') === true,
+                    handler: createAuthMiddleware(async (ctx) => {
+                        ctx.setHeader('Cache-Control', 'no-store');
+                    }),
+                },
+            ],
+        },
+        init(ctx) {
+            assertSafeAuthOptions(ctx.options);
+            const stores = createBetterAuthPersistence(ctx.adapter, {
+                ...(options.clock === undefined ? {} : { now: () => options.clock?.now() ?? new Date() }),
+            });
+            persistence = stores;
+            const { clock, invitationDelivery } = options;
+            const clockOption = clock === undefined ? {} : { now: () => clock.now() };
+            core = createAxeda(coreOptions(options), {
+                persistence: stores,
+                users: createBetterAuthUserDirectory(ctx.adapter, clockOption),
+                userAdmin: createBetterAuthUserAdmin(ctx, clockOption),
+                ...(clock === undefined ? {} : { clock }),
+                ...(invitationDelivery === undefined
+                    ? {}
+                    : {
+                        invitations: {
+                            send: (message) => invitationDelivery.send({
+                                ...message,
+                                link: invitationDelivery.acceptUrl(message.token),
+                            }),
+                        },
+                    }),
+            });
+            return {
+                options: {
+                    databaseHooks: {
+                        session: {
+                            create: {
+                                // Un usuario bloqueado no puede abrir sesión (las que tenía se cerraron al bloquearlo).
+                                // Se consulta con `internalAdapter`, que usa la transacción en curso: Better Auth abre
+                                // sesión DENTRO de la transacción del registro, y con el adaptador raíz la consulta
+                                // esperaría para siempre a una conexión que la propia transacción tiene tomada.
+                                before: async (session) => {
+                                    const row = (await ctx.internalAdapter.findUserById(session.userId));
+                                    const now = clock?.now() ?? new Date();
+                                    const banExpires = row?.banExpires ? new Date(row.banExpires) : null;
+                                    if (row !== null && isBanned({ banned: row.banned === true, banExpires }, now)) {
+                                        throw new APIError('FORBIDDEN', {
+                                            code: 'AXEDA_USER_BANNED',
+                                            message: 'This account is suspended.',
+                                        });
+                                    }
+                                },
+                            },
+                        },
+                        user: {
+                            delete: {
+                                // Las claves foráneas ya lo hacen en SQL; MongoDB no las tiene. Se deja constancia.
+                                after: async (user) => {
+                                    await stores.assignments.deleteForUser(user.id);
+                                    await stores.audit.append({
+                                        actorId: null,
+                                        action: 'user.delete',
+                                        targetType: 'user',
+                                        targetId: user.id,
+                                        scope: null,
+                                        outcome: 'success',
+                                        ip: null,
+                                        userAgent: null,
+                                        metadata: {},
+                                    });
+                                },
+                            },
+                        },
+                    },
+                },
+            };
+        },
+    };
+    return Object.assign(plugin, {
+        /** El núcleo de Axeda (`can`, `scopesFor`, `bootstrap`…). Disponible tras crear Better Auth. */
+        instance,
+        /** Comprueba la base de datos y sincroniza las funciones declaradas. Llamar tras migrar. */
+        start: () => instance().start(),
+        /** La persistencia, para herramientas de la propia aplicación. */
+        persistence: () => {
+            if (persistence === undefined)
+                throw new AxedaError('AXEDA_INVALID_CONFIG', 'Not initialised.');
+            return persistence;
+        },
+    });
+}

package/dist/preset.d.ts

@@ -0,0 +1,63 @@
+import type { BetterAuthOptions } from '@better-auth/core';
+export interface SecureAuthInput {
+    /** URL pública del servidor de autenticación. En producción, `https`. */
+    readonly baseURL: string;
+    /** Secreto de Better Auth: al menos 32 caracteres, aleatorio (p. ej. `openssl rand -base64 48`). */
+    readonly secret: string;
+    /**
+     * Orígenes (`https://app.example.com`) desde los que se permiten peticiones con cookie y a los
+     * que se puede redirigir. Sin comodines ni rutas. El `baseURL` ya cuenta como de confianza.
+     */
+    readonly trustedOrigins: readonly string[];
+    /** `production` (por defecto) exige `https` y cookies `Secure`. `development` admite `localhost`. */
+    readonly environment?: 'production' | 'development';
+    /**
+     * IPs o rangos CIDR de los proxies que tienes delante. Sin ellos solo se confía en una
+     * cabecera `X-Forwarded-For` de un único valor: una cadena la puede falsificar el cliente y
+     * evadir los límites de peticiones.
+     */
+    readonly trustedProxies?: readonly string[];
+    /**
+     * Dónde llevar la cuenta de los límites. `memory` (por defecto) es por proceso: con varias
+     * instancias, el límite efectivo se multiplica. Con varias instancias usa `database`.
+     */
+    readonly rateLimitStorage?: 'memory' | 'database' | 'secondary-storage';
+    /**
+     * Exige correo verificado para iniciar sesión (por defecto sí). Las invitaciones de Axeda solo
+     * las acepta quien tiene el correo verificado; desactivarlo solo tiene sentido en desarrollo.
+     * Con esto activo tu aplicación debe configurar `emailVerification.sendVerificationEmail`.
+     */
+    readonly requireEmailVerification?: boolean;
+}
+/** La parte de la configuración de Better Auth que fija el preset. */
+export interface SecureAuthOptions {
+    readonly baseURL: string;
+    readonly secret: string;
+    readonly trustedOrigins: string[];
+    readonly emailAndPassword: NonNullable<BetterAuthOptions['emailAndPassword']>;
+    readonly session: NonNullable<BetterAuthOptions['session']>;
+    readonly advanced: NonNullable<BetterAuthOptions['advanced']>;
+    readonly rateLimit: NonNullable<BetterAuthOptions['rateLimit']>;
+}
+/**
+ * La configuración de Better Auth que Axeda recomienda, lista para extender:
+ *
+ * ```ts
+ * betterAuth({
+ *   ...secureAuthOptions({ baseURL, secret, trustedOrigins: ['https://app.example.com'] }),
+ *   database,
+ *   plugins: [axedaPlugin],
+ * });
+ * ```
+ *
+ * Fija orígenes de confianza explícitos, cookies `HttpOnly`/`SameSite=Lax`/`Secure`, sesiones de
+ * 7 días, contraseñas de 12 a 128 caracteres, correo verificado, sesiones cerradas al restablecer
+ * la contraseña y límites de peticiones más estrictos en el inicio de sesión y el registro.
+ * **Se niega a devolver** una configuración débil: un secreto corto o repetitivo, orígenes con
+ * comodín o sin `https` en producción.
+ *
+ * No añade plugins (2FA, passkeys…): las funciones que exigen 2FA (`requireMfa`) necesitan el
+ * plugin `twoFactor` de Better Auth, y conviene desactivar «confiar en este dispositivo» en las
+ * cuentas administrativas (ver la guía de seguridad).
+ */
+export declare function secureAuthOptions(input: SecureAuthInput): SecureAuthOptions;

package/dist/preset.js

@@ -0,0 +1,130 @@
+import { AxedaError } from '@teamblind/axeda-core';
+const MIN_SECRET_LENGTH = 32;
+const MIN_DISTINCT_CHARACTERS = 8;
+const LOCAL_HOSTS = new Set(['localhost', '127.0.0.1', '[::1]']);
+const DAY = 60 * 60 * 24;
+function invalid(message) {
+    throw new AxedaError('AXEDA_INVALID_CONFIG', message);
+}
+function parseUrl(raw, label) {
+    try {
+        return new URL(raw);
+    }
+    catch {
+        return invalid(`${label} "${raw}" is not a valid URL.`);
+    }
+}
+/** Un origen es solo esquema, servidor y puerto: sin ruta, consulta, fragmento ni credenciales. */
+function assertPlainOrigin(url, raw, label) {
+    if (url.protocol !== 'https:' && url.protocol !== 'http:') {
+        invalid(`${label} "${raw}" must use http or https.`);
+    }
+    const hasPath = url.pathname !== '/' || url.search !== '' || url.hash !== '';
+    if (hasPath || url.username !== '' || url.password !== '') {
+        invalid(`${label} "${raw}" must be just an origin (scheme, host and optional port).`);
+    }
+}
+function assertTransport(url, raw, label, production) {
+    if (url.protocol === 'https:')
+        return;
+    if (production || !LOCAL_HOSTS.has(url.hostname)) {
+        invalid(`${label} "${raw}" must use https${production ? '' : ' (http is only for localhost)'}.`);
+    }
+}
+function parseOrigin(raw, production, label) {
+    if (raw.includes('*'))
+        invalid(`${label} "${raw}" has a wildcard; list each origin explicitly.`);
+    const url = parseUrl(raw, label);
+    assertPlainOrigin(url, raw, label);
+    assertTransport(url, raw, label, production);
+    return url.origin;
+}
+function assertSecret(secret) {
+    if (secret.length < MIN_SECRET_LENGTH) {
+        invalid(`The secret must have at least ${MIN_SECRET_LENGTH} characters.`);
+    }
+    if (new Set(secret).size < MIN_DISTINCT_CHARACTERS) {
+        invalid('The secret is too repetitive; generate a random one (openssl rand -base64 48).');
+    }
+}
+function trustedOriginList(input, production) {
+    // El `baseURL` puede llevar ruta (p. ej. `/api/auth`); solo se valida su origen.
+    parseOrigin(parseUrl(input.baseURL, 'baseURL').origin, production, 'baseURL');
+    if (input.trustedOrigins.length === 0) {
+        invalid('List at least one trusted origin (the front end that will call the API).');
+    }
+    const origins = input.trustedOrigins.map((origin) => parseOrigin(origin, production, 'trustedOrigins entry'));
+    return [...new Set(origins)];
+}
+/**
+ * La configuración de Better Auth que Axeda recomienda, lista para extender:
+ *
+ * ```ts
+ * betterAuth({
+ *   ...secureAuthOptions({ baseURL, secret, trustedOrigins: ['https://app.example.com'] }),
+ *   database,
+ *   plugins: [axedaPlugin],
+ * });
+ * ```
+ *
+ * Fija orígenes de confianza explícitos, cookies `HttpOnly`/`SameSite=Lax`/`Secure`, sesiones de
+ * 7 días, contraseñas de 12 a 128 caracteres, correo verificado, sesiones cerradas al restablecer
+ * la contraseña y límites de peticiones más estrictos en el inicio de sesión y el registro.
+ * **Se niega a devolver** una configuración débil: un secreto corto o repetitivo, orígenes con
+ * comodín o sin `https` en producción.
+ *
+ * No añade plugins (2FA, passkeys…): las funciones que exigen 2FA (`requireMfa`) necesitan el
+ * plugin `twoFactor` de Better Auth, y conviene desactivar «confiar en este dispositivo» en las
+ * cuentas administrativas (ver la guía de seguridad).
+ */
+export function secureAuthOptions(input) {
+    const production = (input.environment ?? 'production') === 'production';
+    const requireEmailVerification = input.requireEmailVerification ?? true;
+    assertSecret(input.secret);
+    const trustedOrigins = trustedOriginList(input, production);
+    if (!requireEmailVerification && production) {
+        invalid('requireEmailVerification: false is only for development: invitations rely on verified emails.');
+    }
+    const proxies = input.trustedProxies ?? [];
+    return {
+        baseURL: input.baseURL,
+        secret: input.secret,
+        trustedOrigins,
+        emailAndPassword: {
+            enabled: true,
+            minPasswordLength: 12,
+            maxPasswordLength: 128,
+            requireEmailVerification,
+            revokeSessionsOnPasswordReset: true,
+            autoSignIn: !requireEmailVerification,
+        },
+        session: {
+            expiresIn: 7 * DAY,
+            updateAge: DAY,
+            freshAge: 15 * 60,
+            // Axeda no arranca con la caché de cookie activa (revocaciones tardías).
+            cookieCache: { enabled: false },
+        },
+        advanced: {
+            useSecureCookies: production,
+            defaultCookieAttributes: { httpOnly: true, sameSite: 'lax', secure: production },
+            disableCSRFCheck: false,
+            disableOriginCheck: false,
+            ...(proxies.length === 0 ? {} : { ipAddress: { trustedProxies: [...proxies] } }),
+        },
+        rateLimit: {
+            enabled: true,
+            window: 60,
+            max: 100,
+            storage: input.rateLimitStorage ?? 'memory',
+            customRules: {
+                '/sign-in/email': { window: 60, max: 5 },
+                '/sign-up/email': { window: 300, max: 5 },
+                '/request-password-reset': { window: 300, max: 3 },
+                '/reset-password': { window: 300, max: 5 },
+                '/send-verification-email': { window: 300, max: 3 },
+                '/two-factor/verify-totp': { window: 60, max: 5 },
+            },
+        },
+    };
+}

package/dist/principal.d.ts

@@ -0,0 +1,61 @@
+import { type Principal } from '@teamblind/axeda-core';
+type UserRow = {
+    readonly id: string;
+} & Record<string, unknown>;
+/**
+ * Quien es el usuario para Axeda, a partir de la fila de usuario que Better Auth acaba de leer
+ * de la base de datos (nunca de lo que envíe el cliente). Se usa en todos los caminos que
+ * llegan con una sesión: los endpoints del plugin y las rutas de tu aplicación.
+ *
+ * - `authzVersion` ahorra consultas (la caché de Axeda se valida con ella).
+ * - `twoFactorEnabled` permite evaluar las funciones que exigen 2FA.
+ * - `banned` hace que un usuario bloqueado no pueda nada, incluso si llega por una vía que
+ *   no pasó por el control de inicio de sesión (p. ej. una llave de API).
+ */
+export declare function principalFromUser(user: UserRow): Principal;
+/** Lo que se necesita de Better Auth para releer la fila de un usuario (su `internalAdapter`). */
+export interface UserLookup {
+    findUserById(userId: string): Promise<{
+        readonly id: string;
+    } | null>;
+}
+/**
+ * La fila de usuario con la que decidir. Sin `secondaryStorage`, Better Auth la acaba de leer de la
+ * base de datos junto con la sesión. Con `secondaryStorage` (p. ej. Redis), la sesión trae una copia
+ * que Better Auth solo refresca cuando él mismo cambia al usuario: no se entera de que Axeda subió
+ * `authzVersion`, y la caché seguiría concediendo lo revocado. Entonces se relee de la base de datos.
+ * `null` si el usuario ya no existe.
+ */
+export declare function currentUserRow(user: UserRow, 
+/** Las opciones de Better Auth. */
+options: object | undefined, lookup: () => Promise<UserLookup | undefined> | UserLookup | undefined): Promise<UserRow | null>;
+/** Lo mínimo que se necesita de `auth` (así no se ata a la forma exacta de Better Auth). */
+export interface SessionReader {
+    readonly api: {
+        getSession(input: {
+            headers: Headers;
+        }): Promise<{
+            user: {
+                id: string;
+            } & Record<string, unknown>;
+        } | null>;
+    };
+    /** Las opciones de Better Auth: si hay `secondaryStorage`, el usuario se relee de la base de datos. */
+    readonly options?: object | undefined;
+    readonly $context?: Promise<{
+        readonly internalAdapter: UserLookup;
+    }> | undefined;
+}
+/**
+ * Cómo saber quién hace una petición de tu aplicación: pregunta a Better Auth por la sesión
+ * (cookie o, si usas ese plugin, llave de API) y la convierte en un `Principal`. Sin sesión da
+ * `null`. Se le pasa a `createAxedaExpress({ principal })`.
+ *
+ * ```ts
+ * createAxedaExpress({ axeda: axedaPlugin.instance(), principal: sessionPrincipal(auth) });
+ * ```
+ */
+export declare function sessionPrincipal(auth: SessionReader): (request: {
+    readonly headers: Headers;
+}) => Promise<Principal | null>;
+export {};

package/dist/principal.js

@@ -0,0 +1,61 @@
+import { AxedaError, isBanned } from '@teamblind/axeda-core';
+const asDate = (value) => value instanceof Date || typeof value === 'string' || typeof value === 'number'
+    ? new Date(value)
+    : null;
+/**
+ * Quien es el usuario para Axeda, a partir de la fila de usuario que Better Auth acaba de leer
+ * de la base de datos (nunca de lo que envíe el cliente). Se usa en todos los caminos que
+ * llegan con una sesión: los endpoints del plugin y las rutas de tu aplicación.
+ *
+ * - `authzVersion` ahorra consultas (la caché de Axeda se valida con ella).
+ * - `twoFactorEnabled` permite evaluar las funciones que exigen 2FA.
+ * - `banned` hace que un usuario bloqueado no pueda nada, incluso si llega por una vía que
+ *   no pasó por el control de inicio de sesión (p. ej. una llave de API).
+ */
+export function principalFromUser(user) {
+    const principal = {
+        userId: user.id,
+        authzVersion: typeof user['authzVersion'] === 'number' ? user['authzVersion'] : undefined,
+        twoFactorEnabled: user['twoFactorEnabled'] === true,
+        banned: isBanned({ banned: user['banned'] === true, banExpires: asDate(user['banExpires']) }, new Date()),
+    };
+    return principal;
+}
+/**
+ * La fila de usuario con la que decidir. Sin `secondaryStorage`, Better Auth la acaba de leer de la
+ * base de datos junto con la sesión. Con `secondaryStorage` (p. ej. Redis), la sesión trae una copia
+ * que Better Auth solo refresca cuando él mismo cambia al usuario: no se entera de que Axeda subió
+ * `authzVersion`, y la caché seguiría concediendo lo revocado. Entonces se relee de la base de datos.
+ * `null` si el usuario ya no existe.
+ */
+export async function currentUserRow(user, 
+/** Las opciones de Better Auth. */
+options, lookup) {
+    const { secondaryStorage } = (options ?? {});
+    if (secondaryStorage === undefined || secondaryStorage === null)
+        return user;
+    const users = await lookup();
+    if (users === undefined) {
+        throw new AxedaError('AXEDA_INVALID_CONFIG', 'Sessions come from secondaryStorage, so Axeda must re-read the user from the database, ' +
+            'but no internalAdapter was given to read it with.');
+    }
+    return (await users.findUserById(user.id));
+}
+/**
+ * Cómo saber quién hace una petición de tu aplicación: pregunta a Better Auth por la sesión
+ * (cookie o, si usas ese plugin, llave de API) y la convierte en un `Principal`. Sin sesión da
+ * `null`. Se le pasa a `createAxedaExpress({ principal })`.
+ *
+ * ```ts
+ * createAxedaExpress({ axeda: axedaPlugin.instance(), principal: sessionPrincipal(auth) });
+ * ```
+ */
+export function sessionPrincipal(auth) {
+    return async ({ headers }) => {
+        const session = await auth.api.getSession({ headers });
+        if (session === null)
+            return null;
+        const user = await currentUserRow(session.user, auth.options, async () => (await auth.$context)?.internalAdapter);
+        return user === null ? null : principalFromUser(user);
+    };
+}

package/dist/rows.d.ts

@@ -0,0 +1,47 @@
+import { type AssignmentScope, type AuditEvent, type Role, type RoleAssignment } from '@teamblind/axeda-core';
+/** Filas tal como las devuelve el adaptador de Better Auth. */
+export interface RoleRow {
+    id: string;
+    key: string;
+    name: string;
+    description?: string | null;
+    permissions: readonly string[];
+    requireMfa: boolean;
+    status: string;
+    managed: boolean;
+    version: number;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface AssignmentRow {
+    id: string;
+    userId: string;
+    roleId: string;
+    scopeType: string;
+    scopeId: string;
+    grantedBy?: string | null;
+    createdAt: Date;
+    expiresAt?: Date | null;
+}
+export declare function toRole(row: RoleRow): Role;
+export declare function toScope(row: Pick<AssignmentRow, 'id' | 'scopeType' | 'scopeId'>): AssignmentScope;
+export declare function toAssignment(row: AssignmentRow): RoleAssignment;
+export declare const scopeColumns: (scope: AssignmentScope) => {
+    scopeType: string;
+    scopeId: string;
+};
+export interface AuditRow {
+    id: string;
+    actorId?: string | null;
+    action: string;
+    targetType: string;
+    targetId?: string | null;
+    scopeType?: string | null;
+    scopeId?: string | null;
+    outcome: string;
+    ip?: string | null;
+    userAgent?: string | null;
+    metadata: Record<string, unknown>;
+    at: Date;
+}
+export declare function toAuditEvent(row: AuditRow): AuditEvent;

package/dist/rows.js

@@ -0,0 +1,66 @@
+import { AxedaError, GLOBAL_SCOPE, parsePermissionKey, } from '@teamblind/axeda-core';
+import { GLOBAL_SCOPE_ID } from './schema.js';
+const corrupt = (message) => new AxedaError('AXEDA_DATA_CORRUPT', message);
+export function toRole(row) {
+    return {
+        id: row.id,
+        key: row.key,
+        name: row.name,
+        description: row.description ?? null,
+        // Un permiso corrupto lanza: es preferible fallar que decidir con datos dudosos.
+        permissions: row.permissions.map(parsePermissionKey),
+        requireMfa: row.requireMfa,
+        // Un estado desconocido se trata como inactivo: ante la duda, se deniega.
+        status: row.status === 'active' ? 'active' : 'inactive',
+        managed: row.managed,
+        version: row.version,
+        createdAt: row.createdAt,
+        updatedAt: row.updatedAt,
+    };
+}
+export function toScope(row) {
+    switch (row.scopeType) {
+        case 'global':
+            return GLOBAL_SCOPE;
+        case 'company':
+        case 'business':
+            if (row.scopeId === GLOBAL_SCOPE_ID) {
+                throw corrupt(`Assignment "${row.id}" has a ${row.scopeType} scope without an id.`);
+            }
+            return { type: row.scopeType, id: row.scopeId };
+        default:
+            throw corrupt(`Assignment "${row.id}" has an unknown scope type "${row.scopeType}".`);
+    }
+}
+export function toAssignment(row) {
+    return {
+        id: row.id,
+        userId: row.userId,
+        roleId: row.roleId,
+        scope: toScope(row),
+        grantedBy: row.grantedBy ?? null,
+        createdAt: row.createdAt,
+        expiresAt: row.expiresAt ?? null,
+    };
+}
+export const scopeColumns = (scope) => scope.type === 'global'
+    ? { scopeType: 'global', scopeId: GLOBAL_SCOPE_ID }
+    : { scopeType: scope.type, scopeId: scope.id };
+export function toAuditEvent(row) {
+    return {
+        id: row.id,
+        at: row.at,
+        actorId: row.actorId ?? null,
+        // Los valores los escribe Axeda; una fila ajena o corrupta se rechaza en vez de adivinarse.
+        action: row.action,
+        targetType: row.targetType,
+        targetId: row.targetId ?? null,
+        scope: row.scopeType === null || row.scopeType === undefined
+            ? null
+            : toScope({ id: row.id, scopeType: row.scopeType, scopeId: row.scopeId ?? '' }),
+        outcome: row.outcome,
+        ip: row.ip ?? null,
+        userAgent: row.userAgent ?? null,
+        metadata: row.metadata,
+    };
+}