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

package/build/src/testing/contract.js

@@ -1922,6 +1922,33 @@ export function registerAuthorizationDriverContract(harness, api) {
             await driver.revoke(alice, 'lead', unitA1);
             assert.isFalse(await driver.authorize(alice, 'docs:write', unitA1));
         });
+        since('2.2', 'un deny en el OWNER sigue ganando sobre su rol local mientras el scope sale del owner y vuelve: authorize false antes, fuera y de vuelta (invariantes 2 y 18; lote «antes de RC» · F4, F-1); sin el deny: true, false, true', async ({ assert, }) => {
+            // F-1 del tester (`loteRC-6b-estudio-tester.md` §6): PARIDAD entre drivers del `moved` con un rol LOCAL y un deny
+            // en su owner. En `database` no hay estado intermedio (la regla se evalúa en cada pregunta); en `openfga` el
+            // barrido F4 borra el binding ANTES de escribir la arista, así que tampoco lo hay (el prefijo lo juzga la
+            // propiedad `openfga.roles.moved.order` de la guardia). Aquí se observa el estado de reposo en los tres puntos.
+            const denied = subject();
+            const plain = subject();
+            const orgA = await orgUnder(tree, APP_SCOPE);
+            const orgB = await orgUnder(tree, APP_SCOPE);
+            const unit = await unitUnder(tree, orgA);
+            const leaf = await unitUnder(tree, unit);
+            await localRole(orgA, { slug: 'lead', scopeType: 'unit', permissions: ['docs:write'] });
+            await driver.grant(denied, 'lead', unit);
+            await driver.grant(plain, 'lead', unit);
+            await driver.deny(denied, 'docs:write', orgA);
+            const both = async () => [
+                await driver.authorize(denied, 'docs:write', unit),
+                await driver.authorize(denied, 'docs:write', leaf),
+                await driver.authorize(plain, 'docs:write', unit),
+                await driver.authorize(plain, 'docs:write', leaf),
+            ];
+            assert.deepEqual(await both(), [false, false, true, true], 'dentro del owner: el deny gana, sin él concede (también abajo)');
+            await tree.move(unit, orgB);
+            assert.deepEqual(await both(), [false, false, false, false], 'fuera del owner: el rol local no existe (y el deny ya no hace falta)');
+            await tree.move(unit, orgA);
+            assert.deepEqual(await both(), [false, false, true, true], 'de vuelta: restaura lo concedido y el deny sigue ganando');
+        });
         since('2.2', 'la visibilidad se decide POR NIVEL, no por el conjunto de la cadena: si el árbol se recuelga y el owner queda POR DEBAJO del scope de la asignación, esa asignación deja de contar aunque el owner siga en la cadena de la pregunta', async ({ assert, }) => {
             // 3B · B2 (desviación 2 del lote, sin caso hasta aquí). La regla es
             // «una asignación en el scope S cuenta si su rol EXISTE EN S»: el owner
@@ -2072,6 +2099,35 @@ export function registerAuthorizationDriverContract(harness, api) {
             assert.isFalse(await driver.authorize(victima, 'docs:write', unitU1), 'el rol de A ya no existe aquí');
             assert.isTrue(await driver.hasRole(victima, 'lead', unitU1));
         });
+        since('2.2', 'K4 · revoke por SLUG decide con el catálogo EN FRESCO aunque el memo sirva con ventana { everyMs }: un rol local recién definido en OTRO proceso con el slug de uno global también se revoca (nunca un «revocado» mudo)', async ({ assert, }) => {
+            // Asentar · cierre 2 (D-1 del re-ataque del cierre 1; gemelo del 🟡 5 de `openfga`). `{ everyMs }` es una ventana
+            // de DECISIÓN (invariante 14); una ESCRITURA decide con la versión en fresco (K4). Con el memo de la ventana,
+            // `revoke(alice, 'unit-editor', unit)` solo veía el global y el DELETE no tocaba la asignación del local homónimo:
+            // seguía concediendo, en silencio y para siempre (al caducar la ventana, también en este proceso). La ventana solo se
+            // construye si `driver.catalog` es un `CatalogCache` (los dos drivers del paquete): un driver con memo PROPIO corre
+            // el caso SIN ventana y el K4 de `revoke` NO queda juzgado para él (cierre 3 · 🟡 B del tester: es su deber escrito,
+            // no juzgado; un hook de harness para su memo sería contrato nuevo).
+            const alice = subject();
+            const orgA = await orgUnder(tree, APP_SCOPE);
+            const unit = await unitUnder(tree, orgA);
+            const memo = new CatalogCache({ revalidate: { everyMs: 3_600_000 } });
+            let windowed = driver;
+            if (driver.catalog instanceof CatalogCache) {
+                windowed = Object.create(driver);
+                Object.defineProperty(windowed, 'catalog', { value: memo, enumerable: true });
+                await memo.view();
+            }
+            // «Otro proceso» define el local con el slug del global `unit-editor` (fila + versión, sin señal en memoria).
+            const local = await localRole(orgA, { slug: 'unit-editor', scopeType: 'unit', permissions: ['docs:write'] });
+            await driver.grant(alice, { uuid: local }, unit);
+            assert.isTrue(await driver.authorize(alice, 'docs:write', unit));
+            if (windowed !== driver) {
+                assert.isNull((await memo.view()).roleByUuid(local), 'la ventana del memo sigue sirviendo la foto SIN el local (si no, el caso no juzga nada)');
+            }
+            await windowed.revoke(alice, 'unit-editor', unit);
+            assert.isFalse(await driver.authorize(alice, 'docs:write', unit), 'la asignación del local homónimo también se revoca');
+            assert.isFalse(await driver.hasRole(alice, { uuid: local }, unit));
+        });
         since('2.2', 'paridad entre drivers (3D · N1): una asignación cuyo rol está declarado para OTRO nivel no cuenta en ninguno de los dos — ni concede, ni es membresía, ni se enumera — y vuelve a contar en cuanto el nivel del rol coincide otra vez', async ({ assert, }) => {
             // Desviación 3 del lote 3B («`database.authorize` exige además
             // `r.scope_type = a.scope_type`, como ya hacía `openfga`») era una
@@ -3738,6 +3794,27 @@ export function registerAuthorizationDriverContract(harness, api) {
                 tree.chainOf = original;
             }
         }
+        // ── Estrategia 2.5.0 · firma 4 · `experimental` (regla D15) ─────────
+        // La capacidad DICE algo que el consumidor tiene que saber —«este driver está fuera de la garantía de la versión»— y
+        // no apaga ningún caso: el juez corre ENTERO contra un driver experimental. Lo que se observa es la declaración: la
+        // del driver y la copia normalizada que publica `authorization.capabilities()`, en las DOS caras.
+        caseFor('experimental', {
+            whenTrue: () => {
+                test('experimental:true · el driver se declara EXPERIMENTAL (capabilities.experimental === true) y `authorization.capabilities()` lo publica tal cual; el juez corre igual contra él', async ({ assert, }) => {
+                    assert.strictEqual(driver.capabilities?.experimental, true, 'el harness declara experimental: true y el driver no: declara lo observable');
+                    const published = await managerOver().capabilities();
+                    assert.strictEqual(published.experimental, true);
+                    assert.isTrue(Object.isFrozen(published));
+                });
+            },
+            whenFalse: () => {
+                test('experimental:false · el driver NO se declara experimental (ausente o false) y `authorization.capabilities().experimental` es false, nunca undefined (D15)', async ({ assert, }) => {
+                    assert.notStrictEqual(driver.capabilities?.experimental, true, 'el harness declara experimental: false y el driver declara true: declara lo observable');
+                    const published = await managerOver().capabilities();
+                    assert.strictEqual(published.experimental, false);
+                });
+            },
+        });
         // ── 3b-2e · E2 · `roleInheritanceNative` ─────────────────────────────
         caseFor('roleInheritanceNative', {
             whenFalse: () => {
@@ -3868,4 +3945,3 @@ export function uncoveredCapabilities(capabilities, covered) {
  * un skip disfrazado — «rechazo activo» sería una etiqueta.
  */
 const BOTH_FACES_REQUIRED = new Set(['transactionalWrites']);
-//# sourceMappingURL=contract.js.map

package/build/src/testing/main.d.ts

@@ -12,7 +12,7 @@ export { memoryScopeTree, resolveChainFrom, descendantsFrom } from './scope_tree
 export { runMigrationContract, registerMigrationContract, runMigrationDirection, makeMigrationSeed, migrationQuestions, plantMigrationFacts, plantMigrationTree, MIGRATION_CATALOG, MIGRATION_PERMISSIONS, MIGRATION_ROLES, MIGRATION_QUESTION_COUNT, } from './migration_contract.js';
 export type { MigrationContractHarness, MigrationDirection, MigrationQuestion, MigrationSeed, MigrationVerdict, ExpectedLoss, } from './migration_contract.js';
 export type { ContractScopeTree } from './scope_tree.js';
-export { runRelationsDriverContract, registerRelationsDriverContract, makeRelationsDriver, contractRelationsConfig, RELATIONS_HOLDER_TYPES, RELATIONS_CONTRACT_OBJECT_TYPES, lucidRelationsContractTransactions, } from './relations_contract.js';
+export { runRelationsDriverContract, registerRelationsDriverContract, makeRelationsDriver, contractRelationsConfig, contractDenyRelationsConfig, RELATIONS_CONTRACT_DENY_TYPES, RELATIONS_HOLDER_TYPES, RELATIONS_CONTRACT_OBJECT_TYPES, lucidRelationsContractTransactions, } from './relations_contract.js';
 export { createTestClock } from './test_clock.js';
 export type { TestClock } from './test_clock.js';
 export type { RelationsDriverContractHarness, RelationsContractTransactions, MakeRelationsDriverOptions, } from './relations_contract.js';
@@ -20,4 +20,3 @@ export { runRelationsReconcileContract, registerRelationsReconcileContract, } fr
 export type { RelationsReconcileHarness } from './relations_reconcile_contract.js';
 export { runScopeOutboxContract, registerScopeOutboxContract, makeScopeOutbox, SCOPE_OUTBOX_CAPABILITY_KEYS, } from './scope_outbox_contract.js';
 export type { ScopeOutboxCapabilities, ScopeOutboxContractHarness, ScopeOutboxContractTransactions, MakeScopeOutboxOptions, } from './scope_outbox_contract.js';
-//# sourceMappingURL=main.d.ts.map

package/build/src/testing/main.js

@@ -9,8 +9,7 @@
 export { runAuthorizationDriverContract, lucidContractTransactions } from './contract.js';
 export { memoryScopeTree, resolveChainFrom, descendantsFrom } from './scope_tree.js';
 export { runMigrationContract, registerMigrationContract, runMigrationDirection, makeMigrationSeed, migrationQuestions, plantMigrationFacts, plantMigrationTree, MIGRATION_CATALOG, MIGRATION_PERMISSIONS, MIGRATION_ROLES, MIGRATION_QUESTION_COUNT, } from './migration_contract.js';
-export { runRelationsDriverContract, registerRelationsDriverContract, makeRelationsDriver, contractRelationsConfig, RELATIONS_HOLDER_TYPES, RELATIONS_CONTRACT_OBJECT_TYPES, lucidRelationsContractTransactions, } from './relations_contract.js';
+export { runRelationsDriverContract, registerRelationsDriverContract, makeRelationsDriver, contractRelationsConfig, contractDenyRelationsConfig, RELATIONS_CONTRACT_DENY_TYPES, RELATIONS_HOLDER_TYPES, RELATIONS_CONTRACT_OBJECT_TYPES, lucidRelationsContractTransactions, } from './relations_contract.js';
 export { createTestClock } from './test_clock.js';
 export { runRelationsReconcileContract, registerRelationsReconcileContract, } from './relations_reconcile_contract.js';
 export { runScopeOutboxContract, registerScopeOutboxContract, makeScopeOutbox, SCOPE_OUTBOX_CAPABILITY_KEYS, } from './scope_outbox_contract.js';
-//# sourceMappingURL=main.js.map

package/build/src/testing/migration_contract.d.ts

@@ -290,4 +290,3 @@ export declare function runMigrationDirection(harness: MigrationContractHarness,
  */
 export declare function runMigrationContract(harness: MigrationContractHarness): void;
 export declare function registerMigrationContract(harness: MigrationContractHarness, api: ContractTestApi): void;
-//# sourceMappingURL=migration_contract.d.ts.map

package/build/src/testing/migration_contract.js

@@ -586,4 +586,3 @@ export function registerMigrationContract(harness, api) {
         }
     });
 }
-//# sourceMappingURL=migration_contract.js.map

package/build/src/testing/relations_contract.d.ts

@@ -22,6 +22,31 @@ export declare const RELATIONS_CONTRACT_OBJECT_TYPES: readonly ["document", "wor
  * editor ⊆ viewer` (includes de un nivel) y `membersOf` habilitado en `database`.
  */
 export declare function contractRelationsConfig(): RelationsConfig;
+/**
+ * **La config del contrato CON techo de anidación de grupos** (lote «antes de RC» · R1, cierre: el runner publicado no
+ * tenía ningún caso del techo y un driver de terceros no tenía juez): la MISMA config que `contractRelationsConfig` con
+ * `maxGroupDepth` (por defecto 3) y el opt-in de `database` (`database.enforceGroupDepth`). Un driver que declare
+ * `groupDepthLimit()` tiene que responder con un techo ≤ ese número (la config solo BAJA el del driver) y aplicarlo.
+ */
+export declare function contractGroupDepthRelationsConfig(maxGroupDepth?: number): RelationsConfig;
+/**
+ * **La config del contrato CON deny** (plan 2.5 · lote D · D1): los MISMOS dos tipos con el mismo retículo y, además,
+ * un tercero sin opt-in —para que «deny sobre un tipo sin deny ⇒ 422» y «D8: un tipo sin opt-in también honra»
+ * se juzguen con la config fija—:
+ *
+ *  - `document`: `deny: 'write'` (fase 2: se escriben denies);
+ *  - `workspace`: `deny: 'read'` (fase 1: el modelo y las lecturas honran; `deny()` ⇒ 422);
+ *  - `note`: sin opt-in.
+ *
+ * Es una config APARTE (no se tocó `contractRelationsConfig`): un tipo sin `deny` genera el modelo de 2.4.0-alpha.10
+ * byte a byte (D-29) y los casos de antes no cambian de config.
+ */
+export declare const RELATIONS_CONTRACT_DENY_TYPES: {
+    readonly document: "write";
+    readonly workspace: "read";
+    readonly note: undefined;
+};
+export declare function contractDenyRelationsConfig(): RelationsConfig;
 export interface RelationsDriverContractHarness {
     name: string;
     /** Lo que este driver DECLARA. Cada valor se juzga con su cara. */
@@ -84,4 +109,3 @@ export declare function registerRelationsDriverContract(harness: RelationsDriver
     registered: number;
     covered: Set<keyof RelationsDriverCapabilities>;
 };
-//# sourceMappingURL=relations_contract.d.ts.map