OpenFGA 0.6 Ephemeral Context Isolation & Cache Invalidation Invariant

Q: How does adopting this rule prevent AI hallucinations?

This rule explicitly declares what the AI must avoid (Persisting Ephemeral Request State or Injecting Unbounded Contextual Tuples into OpenFGA Check Calls) and prescribes verified positive examples. Grounding the LLM with negative and positive pairs eliminates guesswork.

Q: Which AI coding environments are supported?

This specification is multi-platform compatible: Cursor (.cursor/rules/*.mdc & .cursorrules), Anthropic Claude Code (CLAUDE.md), Windsurf (.windsurfrules), Codex / Cline (AGENTS.md), and GitHub Copilot (.github/copilot-instructions.md).

Q: Can I combine this rule with other technology stacks?

Yes. Use the Interactive Stack Builder or download an Agent Pack to merge this rule with other frontend, backend, database, security, and DevOps rules without syntax collision.

OpenFGA 0.6 Ephemeral Context Isolation & Cache Invalidation Invariant

--- description: OpenFGA 0.6 Ephemeral Context Isolation & Cache Invalidation Invariant - Enforces strict separation between persistent relationship graphs and ephemeral contextual claims in OpenFGA 0.6 architectures. Prevents algorithmic denial-of-service (DoS) and cache thrashing at Policy Decision Points (PDPs) by bounding contextual tuple sets and avoiding persistent store pollution. globs: src/auth/**/*.{ts,tsx}, src/security/**/*.{ts,tsx}, src/middleware/**/*.{ts,tsx}, lib/fga/**/*.{ts,tsx}, lib/auth/**/*.{ts,tsx} alwaysApply: true verified_by: "agentrules.org" license: "CC-BY-4.0" source: "https://agentrules.org/rules/openfga-contextual-tuple-cache-invalidation-standard" --- # OpenFGA 0.6 Ephemeral Context Isolation & Cache Invalidation Invariant > **Severity**: CRITICAL | **Category**: security > **Anti-Pattern Warning**: Persisting Ephemeral Request State or Injecting Unbounded Contextual Tuples into OpenFGA Check Calls ## System Constraints You are a Principal Security Architect enforcing the OpenFGA 0.6 Contextual Tuple Latency & Local Cache Invalidation Standard. You must strictly enforce millisecond-bounded ReBAC evaluations (<15ms P99) by forbidding persistent writes of ephemeral claims, bounding contextual tuple payload size, enforcing composite cache key hashing, and applying fail-closed deadline contexts on all Check calls. ## Strict Guidelines - Engineers MUST NEVER write ephemeral, temporal, or request-scoped claims (such as MFA verified state, IP address match, or short-lived session grants) to persistent OpenFGA storage via `writeTuples()`. - Engineers MUST pass request-scoped claims exclusively as ephemeral `contextual_tuples` directly within the `client.check()` call. - Services MUST validate and enforce a strict upper bound on contextual tuples (MAX_CONTEXTUAL_TUPLES <= 20) prior to dispatching authorization checks to prevent exponential graph resolution latency. - Local authorization caches MUST construct composite cache keys incorporating both the persistent entity version/revision and a deterministic cryptographic digest (SHA-256) of sorted contextual tuples. - Engineers MUST configure an explicit timeout context (<= 25ms) on all `client.check()` requests, failing closed with an AuthorizationDenyError upon timeout or cancellation. - Local PDP caches MUST synchronize invalidation via OpenFGA `ReadChanges` API (Change Data Capture) and NEVER perform blanket cache flushes on individual check completions. ## Bad vs Good Implementations ### Contextual Tuple Ingestion and ReBAC Check Execution #### Bad Antipattern (AI Common Hallucination) > **Why it fails**: Writing transient claims (MFA status) to persistent store causes database bloat and invalidates all cached ReBAC graphs. Unbounded contextual tuples allow clients to induce algorithmic denial of service via deep graph traversals without timeouts. ```typescript import { OpenFgaClient } from '@openfga/sdk'; const fgaClient = new OpenFgaClient({ apiUrl: process.env.FGA_API_URL!, storeId: process.env.FGA_STORE_ID!, }); // ANTI-PATTERN: Ephemeral MFA state is written to persistent storage, // triggering global CDC cache invalidation and database write amplification. export async function authorizeDocumentAccess( userId: string, docId: string, isMfaActive: boolean, dynamicRoles: string[] ): Promise<boolean> { if (isMfaActive) { await fgaClient.write({ writes: [{ user: `user:${userId}`, relation: 'mfa_authenticated', object: `session:${userId}` }], }); } // ANTI-PATTERN: Unbounded array injection without size limits or deadline const contextualTuples = dynamicRoles.map(role => ({ user: `user:${userId}`, relation: 'assigned', object: `role:${role}`, })); const response = await fgaClient.check({ user: `user:${userId}`, relation: 'viewer', object: `document:${docId}`, contextualTuples, }); return response.allowed ?? false; } ``` #### Production Standard (Correct) > **Standard**: Ephemeral claims are treated strictly as request-scoped contextual tuples rather than persistent state. The contextual set is defensively bounded to <= 20 tuples, and the evaluation is guarded by a 25ms AbortController timeout ensuring sub-millisecond fail-closed guarantees. ```typescript import { OpenFgaClient, ClientCheckRequest } from '@openfga/sdk'; import { createHash } from 'node:crypto'; const fgaClient = new OpenFgaClient({ apiUrl: process.env.FGA_API_URL!, storeId: process.env.FGA_STORE_ID!, }); const MAX_CONTEXTUAL_TUPLES = 20; const CHECK_TIMEOUT_MS = 25; interface EphemeralContext { userId: string; docId: string; isMfaActive: boolean; dynamicRoles: string[]; } export async function authorizeDocumentAccess( ctx: EphemeralContext ): Promise<boolean> { const contextualTuples = []; if (ctx.isMfaActive) { contextualTuples.push({ user: `user:${ctx.userId}`, relation: 'mfa_authenticated', object: `session:${ctx.userId}`, }); } for (const role of ctx.dynamicRoles) { contextualTuples.push({ user: `user:${ctx.userId}`, relation: 'assigned', object: `role:${role}`, }); } // INVARIANT 1: Bound contextual tuple quantity to prevent ReBAC resolution DoS if (contextualTuples.length > MAX_CONTEXTUAL_TUPLES) { throw new Error(`Security Violation: Contextual tuple limit exceeded (${MAX_CONTEXTUAL_TUPLES})`); } const checkPayload: ClientCheckRequest = { user: `user:${ctx.userId}`, relation: 'viewer', object: `document:${ctx.docId}`, contextualTuples, }; // INVARIANT 2: Strict timeout context enforcing millisecond PDP SLA with fail-closed semantics const controller = new AbortController(); const timeout = setTimeout(() => controller.abort(), CHECK_TIMEOUT_MS); try { const response = await fgaClient.check(checkPayload, { signal: controller.signal, }); return Boolean(response.allowed); } catch (error) { // Fail-closed on latency SLA violation or connection failure return false; } finally { clearTimeout(timeout); } } ```

Architectural Specification & Invariant Rationale

Architectural Invariant Design: OpenFGA 0.6 Ephemeral Context Isolation & Cache Invalidation Invariant

OpenFGA 0.6 Ephemeral Context Isolation & Cache Invalidation Invariant defines an industrial-grade behavioral standard for security engineering. Enforces strict separation between persistent relationship graphs and ephemeral contextual claims in OpenFGA 0.6 architectures. Prevents algorithmic denial-of-service (DoS) and cache thrashing at Policy Decision Points (PDPs) by bounding contextual tuple sets and avoiding persistent store pollution. 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: Persisting Ephemeral Request State or Injecting Unbounded Contextual Tuples into OpenFGA Check Calls 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	Persisting Ephemeral Request State or Injecting Unbounded Contextual Tuples into OpenFGA Check Calls	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 NEVER write ephemeral, temporal, or request-scoped claims (such as MFA verified state, IP address match, or short-lived session grants) to persistent OpenFGA storage via `writeTuples()`.

Engineers MUST NEVER write ephemeral, temporal, or request-scoped claims (such as MFA verified state, IP address match, or short-lived session grants) to persistent OpenFGA storage via `writeTuples()`.

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.