OpenFGA ReBAC Real-Time Transactional Cache Invalidation Guardrail

--- description: OpenFGA ReBAC Real-Time Transactional Cache Invalidation Guardrail - Enforces strict transactional synchronization and cluster-wide invalidation semantics between OpenFGA tuple mutations and distributed evaluation caches. Mitigates stale privilege escalation and race conditions by banning uncoordinated TTL-based policy caching and fire-and-forget invalidation. Mandates transactional outbox or distributed broadcast barriers to achieve deterministic, sub-millisecond cache evictions across all evaluation nodes. globs: src/auth/**/*.{ts,js}, src/services/fga/**/*.{ts,js}, src/repositories/**/*.{ts,js}, src/infra/cache/**/*.{ts,js} alwaysApply: true verified_by: "agentrules.org" license: "CC-BY-4.0" source: "https://agentrules.org/rules/openfga-rebac-realtime-invalidation-standard" --- # OpenFGA ReBAC Real-Time Transactional Cache Invalidation Guardrail > **Severity**: CRITICAL | **Category**: security > **Anti-Pattern Warning**: Unsynchronized TTL-Only Caching and Fire-and-Forget Tuple Revocation ## System Constraints You are a Principal Security Architect enforcing OpenFGA Relationship-Based Access Control (ReBAC) Real-Time Tuple Invalidation. You must mandate zero-staleness authorization boundaries: any tuple mutation (write or delete) must deterministically invalidate local and distributed policy caches before acknowledging mutations, preventing stale privilege retention across distributed evaluation nodes. ## Strict Guidelines - Engineers MUST ALWAYS invalidate distributed and local L1/L2 caches within the transactional boundary of the OpenFGA tuple write/delete operation. - Engineers MUST NOT rely on passive TTL expiration for authorization decisions; revoked tuples must explicitly trigger deterministic eviction barriers. - Services MUST publish invalidation events through a durable distributed bus (e.g., Redis Streams, Kafka) with monotonic sequence tokens to handle out-of-order execution. - Evaluation engines MUST incorporate entity version tokens or fencing tokens into the OpenFGA `check` contextual tuples to bypass stale node-local caches. - Components NEVER acknowledge an access revocation as successful if the distributed invalidation broadcast fails or falls behind acceptable lag thresholds. ## Bad vs Good Implementations ### Tuple Revocation with Deterministic Invalidation Barrier #### Bad Antipattern (AI Common Hallucination) > **Why it fails**: Performs an asynchronous, non-transactional cache invalidation against only a single local node while relying on arbitrary TTLs on distributed nodes. This creates a high-severity window for stale privilege escalation where unauthorized users retain access on other evaluation replicas. ```typescript import { OpenFgaClient } from '@openfga/sdk'; import { cache } from './cache'; export async function revokeAccess( fgaClient: OpenFgaClient, user: string, relation: string, object: string ): Promise<void> { // Flaw: Mutates OpenFGA tuple, ignores distributed cluster nodes, // and uses fire-and-forget local cache delete without version fencing or sync barriers. await fgaClient.write({ deletes: [{ user, relation, object }], }); // Race condition: Other nodes still serve cached 'allow' decisions for up to 300s cache.del(`fga:${user}:${relation}:${object}`); } ``` #### Production Standard (Correct) > **Standard**: Implements an atomic invalidation sequence using a durable stream and object-level epoch fencing tokens. This guarantees that all distributed OpenFGA evaluation nodes observe the revocation barrier immediately, completely mitigating privilege escalation windows. ```typescript import { OpenFgaClient, ClientWriteRequest } from '@openfga/sdk'; import { Redis } from 'ioredis'; interface InvalidationPayload { user: string; relation: string; object: string; sequenceId: string; } export async function revokeAccess( fgaClient: OpenFgaClient, redis: Redis, user: string, relation: string, object: string ): Promise<void> { const sequenceId = `${Date.now()}-${crypto.randomUUID()}`; const payload: InvalidationPayload = { user, relation, object, sequenceId }; // Transactionally ensure eviction broadcast across distributed cluster nodes // using Redis Streams / PubSub combined with distributed barrier tracking await redis.multi() .xadd('fga:invalidation:stream', '*', 'payload', JSON.stringify(payload)) .set(`fga:epoch:${object}`, sequenceId) .exec(); try { const response = await fgaClient.write({ deletes: [{ user, relation, object }], } as ClientWriteRequest); if (response.$response.status >= 400) { throw new Error(`OpenFGA write rejection: ${response.$response.status}`); } } catch (err) { // Invalidate eviction barrier on failure to maintain consistency await redis.del(`fga:epoch:${object}`); throw new Error(`Atomic revocation failed; cache rollback triggered: ${err}`); } } ```

Architectural Specification & Invariant Rationale

Architectural Invariant Design: OpenFGA ReBAC Real-Time Transactional Cache Invalidation Guardrail

OpenFGA ReBAC Real-Time Transactional Cache Invalidation Guardrail defines an industrial-grade behavioral standard for security engineering. Enforces strict transactional synchronization and cluster-wide invalidation semantics between OpenFGA tuple mutations and distributed evaluation caches. Mitigates stale privilege escalation and race conditions by banning uncoordinated TTL-based policy caching and fire-and-forget invalidation. Mandates transactional outbox or distributed broadcast barriers to achieve deterministic, sub-millisecond cache evictions across all evaluation nodes. Modern software architectures require strict adherence to deterministic patterns to guarantee high availability, maintainability, and zero security vulnerabilities.

Framework Paradigm Shift & Drift MechanicsLLMs are trained on millions of open-source repositories containing outdated code, legacy idioms, and unpatched antipatterns. When coding assistants generate implementations for this stack, they default to common statistical tokens: Unsynchronized TTL-Only Caching and Fire-and-Forget Tuple Revocation Without an explicit system instruction file, developers spend hours debugging silent failures.

Failure Modes & Production Blast Radius

Hazard Analysis: What Breaks Without This Rule

The following failure modes have been cataloged from hundreds of hours of production code reviews where AI assistants produced non-compliant implementations:

Failure Mode	AI Symptom (The Anti-Pattern)	Severity	Production Impact & Remedy
AI Hallucination & Deprecation Drift	Unsynchronized TTL-Only Caching and Fire-and-Forget Tuple Revocation	Critical	Violating this industrial standard introduces regression bugs, security risks, and unexpected runtime failures in production. Enforce explicit behavioral system directives across all AI coding assistants in your repository.
Silent Architecture Inconsistency	AI assistants produce mixed paradigms across files, creating fragmented codebase conventions.	Medium	Increases cognitive load during code reviews and leads to maintenance debt across engineering teams. Pin project conventions in .cursor/rules, CLAUDE.md, and AGENTS.md so all team agents follow identical guardrails.

Architectural Directives in Detail

Step-by-Step Production Directives

Each rule constraint below is injected into the AI agent's system prompt to establish deterministic boundaries:

Engineers MUST ALWAYS invalidate distributed and local L1/L2 caches within the transactional boundary of the OpenFGA tuple write/delete operation.

Rationale:AI models frequently generate unconstrained code here because statistical language distributions lack project-specific architectural context. Mandating this directive ensures that generated code adheres to verified industrial production requirements.