@jantstack/adonis-authz 2.5.0-alpha.2 → 2.5.0-alpha.4

package/build/src/drivers/database_driver.js

@@ -327,12 +327,24 @@ export class DatabaseAuthorizationDriver {
             // `resolveChain` y la barrera del freeze (autoridad). Un despliegue con
             // pool 1 lo declara `false` (ver `DatabaseDriverOptions`).
             transactionalWrites: this.transactionalWrites,
+            // Estrategia 2.5.0 · firma 4 (D15): `false` EXPLÍCITO — `database` es el driver ESTABLE de 2.5.0 (el experimental
+            // es `openfga`). Explícito para que la copia de `authorization.capabilities()` y este objeto digan lo mismo.
+            experimental: false,
         });
         assertCatalogOptions('DatabaseAuthorizationDriver', options);
         this.catalog =
             options.catalog ??
                 new CatalogCache({ driver: 'database', timeoutMs: this.timeoutMs, revalidate: options.catalogRevalidate });
     }
+    /**
+     * **El catálogo de una ESCRITURA** (K4; asentar · cierre 2, D-1): con la versión contrastada en fresco SIEMPRE
+     * (`CatalogCache.freshView`), ignore o no la ventana `{ everyMs }`. Un `catalog` inyectado que no lo traiga cae en
+     * `view()` (el contrato del memo es suyo). Gemelo de `OpenFgaAuthorizationDriver.writeCatalog`.
+     */
+    writeCatalog() {
+        const catalog = this.catalog;
+        return typeof catalog.freshView === 'function' ? catalog.freshView() : catalog.view();
+    }
     /**
      * Vista de este driver con OTRO resolutor de la cadena y el mismo estado
      * (conexión, memo del catálogo, deadline). Es lo que usa
@@ -610,7 +622,11 @@ export class DatabaseAuthorizationDriver {
         // a lo sumo uno es visible ahí y los demás serían filas huérfanas; el
         // scope puede no existir ya para el árbol (D8), así que no se filtra por
         // visibilidad — quitar nunca concede.
-        const named = rolesToRevoke(await this.catalog.view(), role, scope);
+        // Asentar · cierre 2 (D-1 del re-ataque; gemelo del 🟡 5 de `openfga`, K4): el catálogo de una ESCRITURA, con la
+        // versión en fresco. Con el memo de `{ everyMs }` un local recién definido en otro proceso que ensombrece al global
+        // no salía en `rolesToRevoke`: el DELETE no tocaba su fila y la asignación local seguía concediendo (un «revocado»
+        // falso, mudo y persistente).
+        const named = rolesToRevoke(await this.writeCatalog(), role, scope);
         // Sin cadena con la que canonizar, TODAS las ortografías de las que el
         // uuid puede ser alias (3b-8 · A4, mismo fan-out que `scopes.detached`):
         // con una sola, un alias hacía del DELETE un no-op silencioso y la fila
@@ -1141,6 +1157,11 @@ export class DatabaseAuthorizationDriver {
                     scope_type: target.type,
                     scope_uuid: toDbScopeUuid(target),
                 };
+                // Cierre-2 de L11 (C1): un deny que el origen guarda con una condición ajena se migra como deny (fail-closed:
+                // perderlo concedería) pero se DECLARA: `invalid-condition` es deriva y el operador decide.
+                if (fact.invalidCondition !== undefined) {
+                    note('deny', 'invalid-condition', `${fact.detail} (${fact.invalidCondition})`);
+                }
                 usableFacts += 1;
                 const denyId = denyKey(row);
                 if (wantedDenies.has(denyId))
@@ -1309,4 +1330,3 @@ export class DatabaseAuthorizationDriver {
         }
     }
 }
-//# sourceMappingURL=database_driver.js.map

package/build/src/drivers/database_relations_driver.d.ts

@@ -1,7 +1,13 @@
 import { relationPartitionTrigger, relationPartitionTriggerDrops } from '../relation_partition_trigger.js';
 import type { Clock } from '../clock.js';
-import type { RelObject, RelSubject, RelationObjectsPage, RelationSubjectsPage, RelationPage, RelationTuplePage, RelationsDriver, RelationsDriverCapabilities, RelationTransactionOptions, RelationWriteOptions, ScopeRef } from '../types.js';
+import type { RelObject, RelSubject, RelationObjectsPage, RelationSubjectsPage, RelationPage, RelationTuplePage, RelationsDriver, RelationsDriverCapabilities, RelationTransactionOptions, RelationWriteOptions, RelationDenyOptions, RelationDecision, ScopeRef } from '../types.js';
 import type { RelationsConfig } from '../relations/define_relations_config.js';
+/**
+ * **Cota de candidatos de `membersOf` cuando el objeto tiene un deny vigente** (lote D · cierre 1 de D1, 🟡 4): con deny
+ * cada candidato se juzga con un `check` (una CTE por candidato). Pasada ⇒ 500 `E_AUTHZ_MEMBERS_DENY_LIMIT`, nunca una
+ * lista parcial. En «Limits» del README, atada a esta constante (`scope_depth.spec`).
+ */
+export declare const RELATIONS_MEMBERS_DENY_CHECK_MAX = 1000;
 export { relationPartitionTrigger, relationPartitionTriggerDrops };
 export interface DatabaseRelationsDriverOptions {
     /** Nombre de la conexión Lucid (default: la primaria). */
@@ -73,6 +79,22 @@ export declare class DatabaseRelationsDriver implements RelationsDriver {
      */
     withClock(now: Clock): RelationsDriver;
     relate(subject: RelSubject, relation: string, object: RelObject, partition: ScopeRef, options?: RelationWriteOptions): Promise<void>;
+    /**
+     * **`deny` = la tupla `denied_<rel>`, por el MISMO camino idempotente que `relate`** (lote D · D1): F-05 sobre el
+     * nombre PÚBLICO, la puerta de escritura del opt-in (fase `'write'`, D10), ni `group` ni `*`, y SIN caducidad (D3:
+     * `expiresAt` ⇒ 422; un deny escrito a mano con caducidad se rehace permanente). Por la transacción del llamante si
+     * llega (L-4, como `relate`).
+     */
+    deny(subject: RelSubject, relation: string, object: RelObject, partition: ScopeRef, options?: RelationDenyOptions): Promise<void>;
+    /** `removeDeny`: borra la tupla `denied_<rel>`. Sobre CUALQUIER tipo declarado (D8/R2-4 b). No-op si no está. */
+    removeDeny(subject: RelSubject, relation: string, object: RelObject, partition: ScopeRef, options?: RelationDenyOptions): Promise<void>;
+    /**
+     * **El techo de anidación de grupos de ESTE driver** (lote «antes de RC» · R1, decisión del dueño 2026-10-17 (5)):
+     * `database` no tiene techo técnico (la CTE deduplica y termina con ciclos), así que es `null` SALVO el opt-in
+     * explícito `database.enforceGroupDepth: true`, que aplica el `maxGroupDepth` de la config (obligatorio y numérico
+     * con el opt-in: lo valida `defineRelationsConfig` al arrancar).
+     */
+    groupDepthLimit(): Promise<number | null>;
     unrelate(subject: RelSubject, relation: string, object: RelObject, partition: ScopeRef, options?: RelationWriteOptions): Promise<void>;
     /**
      * **F-05 en las LECTURAS y las PURGAS del driver** (2.4.0-alpha.3, cierre
@@ -96,8 +118,28 @@ export declare class DatabaseRelationsDriver implements RelationsDriver {
      * de la consulta (defensa en profundidad: el manager ya lo hizo).
      */
     checkMany(subject: RelSubject, relation: string, objects: RelObject[], partition: ScopeRef): Promise<boolean[]>;
-    listObjects(subject: RelSubject, relation: string, objectType: string, partition: ScopeRef, _page?: RelationPage): Promise<RelationObjectsPage>;
-    listSubjects(relation: string, object: RelObject, partition: ScopeRef, _page?: RelationPage): Promise<RelationSubjectsPage>;
+    /**
+     * **`decideMany` = la consulta de `checkMany`** (lote D · D9): los grants de `down*(R)` y los denies de
+     * `up*(down*(R))` de cada objeto distinto, con UN `now` y en UNA consulta, y la regla AMPLIA de `decideFrom` (la
+     * misma función que el doble y `openfga` cuando alinea su `batchCheck`). Tope, `[]` y F-05 por ítem como `checkMany`.
+     */
+    decideMany(subject: RelSubject, relation: string, objects: RelObject[], partition: ScopeRef): Promise<RelationDecision[]>;
+    listObjects(subject: RelSubject, relation: string, objectType: string, partition: ScopeRef): Promise<RelationObjectsPage>;
+    listSubjects(relation: string, object: RelObject, partition: ScopeRef): Promise<RelationSubjectsPage>;
+    /**
+     * **`listDenies`** (lote D · D1): los sujetos con deny DIRECTO de `relation` sobre `object` —hechos, como
+     * `listSubjects` sobre la relación almacenada `denied_<rel>`; no resta ni deriva—. Sobre CUALQUIER tipo declarado
+     * (D8/R2-4 b: con el opt-in retirado, los denies vivos se siguen pudiendo listar y borrar).
+     */
+    listDenies(relation: string, object: RelObject, partition: ScopeRef): Promise<RelationSubjectsPage>;
+    /**
+     * **`denyPhase` — ¿admite este driver escrituras de deny en el tipo?** (lote D · D2, R2-5): la fase del opt-in EN
+     * LA CONFIG DE ESTE DRIVER (`'write'`, `'read'` o `null`). F-05 estricto del par (422), cero sentencias: es
+     * configuración. La llama `reconcileRelations` en la fase de plan cuando el origen trae denies.
+     */
+    denyPhase(object: {
+        type: string;
+    }, relation: string): Promise<'read' | 'write' | null>;
     /**
      * Membresía TRANSITIVA de un objeto-grupo: todos los HOLDERS que son `member`
      * directa o a través de grupos anidados (usersets `group#member`). CTE
@@ -105,7 +147,7 @@ export declare class DatabaseRelationsDriver implements RelationsDriver {
      * directos): en un grupo con `member(g1#member, g2)`, `membersOf(g2)` trae a
      * los holders de g1 y `listSubjects(member, g2)` solo el userset `g1#member`.
      */
-    membersOf(object: RelObject, relation: string, partition: ScopeRef, _page?: RelationPage): Promise<RelationSubjectsPage>;
+    membersOf(object: RelObject, relation: string, partition: ScopeRef): Promise<RelationSubjectsPage>;
     purgeObject(object: RelObject, partition: ScopeRef, options?: RelationTransactionOptions): Promise<void>;
     purgeSubject(subject: RelSubject, partition: ScopeRef, options?: RelationTransactionOptions): Promise<void>;
     /**
@@ -149,4 +191,3 @@ export declare class DatabaseRelationsDriver implements RelationsDriver {
      */
     enumerateRelationsMany(partitions: ScopeRef[], page?: RelationPage): Promise<RelationTuplePage>;
 }
-//# sourceMappingURL=database_relations_driver.d.ts.map