OpenFGA Recursive Contextual Tuple Evaluation Bound and Cycle Guard

Q: How does adopting this rule prevent AI hallucinations?

This rule explicitly declares what the AI must avoid (Injecting unconstrained or cyclic contextual tuples into OpenFGA Check requests without depth bounding or cycle screening) 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 Recursive Contextual Tuple Evaluation Bound and Cycle Guard

--- description: OpenFGA Recursive Contextual Tuple Evaluation Bound and Cycle Guard - Enforces strict validation, cycle detection, and traversal depth limits on contextual tuples passed during runtime OpenFGA Check and ListObjects operations. Unbounded or cyclic relationship-based access control (ReBAC) evaluations through dynamic contextual tuples induce catastrophic resource exhaustion and denial-of-service across the authorization pipeline. globs: src/auth/**/*.{ts,js}, src/services/authz/**/*.{ts,js}, src/middleware/**/*.{ts,js}, src/lib/openfga/**/*.{ts,js} alwaysApply: true verified_by: "agentrules.org" license: "CC-BY-4.0" source: "https://agentrules.org/rules/openfga-recursive-contextual-tuple-bound" --- # OpenFGA Recursive Contextual Tuple Evaluation Bound and Cycle Guard > **Severity**: CRITICAL | **Category**: security > **Anti-Pattern Warning**: Injecting unconstrained or cyclic contextual tuples into OpenFGA Check requests without depth bounding or cycle screening ## System Constraints You are a Principal Security Architect enforcing deterministic traversal depth bounds and cycle mitigation for OpenFGA authorization workflows. You must mandate strict limits on contextual tuple injection to eliminate infinite graph recursion, ReBAC evaluation timeouts, and denial-of-service vulnerabilities. ## Strict Guidelines - Engineers MUST ALWAYS sanitize, validate, and limit the cardinality of contextual tuples submitted to OpenFGA Check and ListObjects calls (maximum recommended: 20 contextual tuples per evaluation context). - Engineers MUST ALWAYS implement deterministic cycle detection (e.g., Directed Acyclic Graph validation) over user-supplied dynamic contextual tuples prior to dispatching queries to the OpenFGA client. - Engineers MUST NOT allow client-controlled contextual tuples to define arbitrary transitive user-set mappings that bypass pre-configured OpenFGA resolution depth caps (MAX_TUPLE_RESOLUTION_DEPTH). - Services MUST enforce explicit request timeouts (e.g., <= 1500ms) and wire-level deadline propagation on all OpenFGA client SDK invocations. - Components NEVER construct transitive contextual loops where an entity transitively or reflexively references itself across contextual tuples (e.g., document:A#parent@folder:B and folder:B#parent@document:A). ## Bad vs Good Implementations ### Contextual Tuple Cyclic Graph Injection vs. Bounded DAG Validation #### Bad Antipattern (AI Common Hallucination) > **Why it fails**: Client-controlled contextual tuples are passed directly to the OpenFGA cluster without depth constraints, size limits, or cycle detection, exposing the service to algorithmic complexity DoS via cyclic graph resolution. ```typescript import { OpenFgaClient, ClientCheckRequest, TupleKey } from '@openfga/sdk'; const fgaClient = new OpenFgaClient({ apiUrl: process.env.FGA_API_URL! }); // ANTI-PATTERN: Blindly forwarding unbounded, user-supplied contextual tuples. // If the client injects reciprocal parent relationships, OpenFGA evaluation // exhausts engine resources or triggers unbounded recursive graph walks. export async function checkAccessUnsafe( userId: string, relation: string, object: string, untrustedContextTuples: TupleKey[] ): Promise<boolean> { const payload: ClientCheckRequest = { user: `user:${userId}`, relation, object, contextualTuples: untrustedContextTuples, // Dangerous: no cycle checks, no limit }; const response = await fgaClient.check(payload); return !!response.allowed; } ``` #### Production Standard (Correct) > **Standard**: Validates graph acyclicity prior to engine execution, limits contextual tuple cardinality to a safe threshold, and enforces an explicit AbortSignal timeout to bound evaluation latency. ```typescript import { OpenFgaClient, ClientCheckRequest, TupleKey } from '@openfga/sdk'; const fgaClient = new OpenFgaClient({ apiUrl: process.env.FGA_API_URL!, storeId: process.env.FGA_STORE_ID!, }); const MAX_CONTEXTUAL_TUPLES = 10; const CHECK_TIMEOUT_MS = 1200; class CyclicalRebacError extends Error { constructor(message: string) { super(message); this.name = 'CyclicalRebacError'; } } function validateAcyclicContext(tuples: TupleKey[]): void { if (tuples.length > MAX_CONTEXTUAL_TUPLES) { throw new CyclicalRebacError(`Contextual tuples count (${tuples.length}) exceeds bound (${MAX_CONTEXTUAL_TUPLES})`); } const adjacency = new Map<string, Set<string>>(); for (const t of tuples) { if (t.user === t.object) { throw new CyclicalRebacError(`Self-referential contextual tuple detected: ${t.user}`); } const neighbors = adjacency.get(t.user) ?? new Set<string>(); neighbors.add(t.object); adjacency.set(t.user, neighbors); } const visited = new Set<string>(); const inStack = new Set<string>(); function hasCycle(node: string): boolean { visited.add(node); inStack.add(node); const edges = adjacency.get(node) ?? new Set<string>(); for (const neighbor of edges) { if (!visited.has(neighbor) && hasCycle(neighbor)) return true; if (inStack.has(neighbor)) return true; } inStack.delete(node); return false; } for (const node of adjacency.keys()) { if (!visited.has(node) && hasCycle(node)) { throw new CyclicalRebacError(`Cycle detected in contextual graph at node: ${node}`); } } } export async function checkAccessSafe( userId: string, relation: string, object: string, contextTuples: TupleKey[] = [] ): Promise<boolean> { validateAcyclicContext(contextTuples); const payload: ClientCheckRequest = { user: `user:${userId}`, relation, object, contextualTuples: contextTuples, }; const abortController = new AbortController(); const timeout = setTimeout(() => abortController.abort(), CHECK_TIMEOUT_MS); try { const response = await fgaClient.check(payload, { signal: abortController.signal, }); return !!response.allowed; } finally { clearTimeout(timeout); } } ```

Architectural Specification & Invariant Rationale

Architectural Invariant Design: OpenFGA Recursive Contextual Tuple Evaluation Bound and Cycle Guard

OpenFGA Recursive Contextual Tuple Evaluation Bound and Cycle Guard defines an industrial-grade behavioral standard for security engineering. Enforces strict validation, cycle detection, and traversal depth limits on contextual tuples passed during runtime OpenFGA Check and ListObjects operations. Unbounded or cyclic relationship-based access control (ReBAC) evaluations through dynamic contextual tuples induce catastrophic resource exhaustion and denial-of-service across the authorization pipeline. 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: Injecting unconstrained or cyclic contextual tuples into OpenFGA Check requests without depth bounding or cycle screening 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	Injecting unconstrained or cyclic contextual tuples into OpenFGA Check requests without depth bounding or cycle screening	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 sanitize, validate, and limit the cardinality of contextual tuples submitted to OpenFGA Check and ListObjects calls (maximum recommended

Engineers MUST ALWAYS sanitize, validate, and limit the cardinality of contextual tuples submitted to OpenFGA Check and ListObjects calls (maximum recommended: 20 contextual tuples per evaluation context).

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.