OpenFGA 1.6 Deterministic Graph Traversal Depth and Cycle Ceiling Enforcement

Q: How does adopting this rule prevent AI hallucinations?

This rule explicitly declares what the AI must avoid (Unbounded Recursive Relationship Evaluation Permitting Algorithmic Graph Traversal Denial-of-Service) 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 1.6 Deterministic Graph Traversal Depth and Cycle Ceiling Enforcement

--- description: OpenFGA 1.6 Deterministic Graph Traversal Depth and Cycle Ceiling Enforcement - Enforces deterministic boundaries on OpenFGA authorization graph traversals to prevent algorithmic denial-of-service (Graph-DoS) from unbounded recursive relations and cyclic group hierarchies. Mandates schema-level cycle guards, bounded resolution node caps, contextual tuple limits, and fail-closed timeout policies across all Check and ListObjects query paths. globs: src/**/*.{ts,tsx,js,mjs}, model/**/*.fga, model/**/*.json alwaysApply: true verified_by: "agentrules.org" license: "CC-BY-4.0" source: "https://agentrules.org/rules/openfga-graph-traversal-depth-and-cycle-ceiling" --- # OpenFGA 1.6 Deterministic Graph Traversal Depth and Cycle Ceiling Enforcement > **Severity**: CRITICAL | **Category**: security > **Anti-Pattern Warning**: Unbounded Recursive Relationship Evaluation Permitting Algorithmic Graph Traversal Denial-of-Service ## System Constraints You are a Principal Security Architect and Rules Author enforcing OpenFGA 1.6 distributed graph traversal safety standards. You must strictly mandate bounded graph resolution, cycle detection, contextual tuple depth validation, and fail-closed evaluation semantics across authorization schemas and client check invocations. ## Strict Guidelines - Engineers MUST ALWAYS enforce strict request-level timeout deadlines (maximum 2000ms) and bounded retry budgets on all OpenFGA Check, Expand, and ListObjects client requests. - Engineers MUST NOT introduce unbounded recursive user sets or self-referential parent relations without an explicit termination condition or intermediate role-bound hierarchy. - Services MUST validate and bound contextual tuples dynamically injected during Check requests, capping contextual tuple counts to a strict maximum (e.g., <= 20 tuples) and rejecting self-referential subject-object pairs. - Code MUST handle OpenFGA resolution limit errors (HTTP 400 with resolution node limit exceeded or cyclic relationship detected) with a strict fail-closed rejection, never failing open or silently falling back to insecure defaults. - Schema definitions MUST NEVER permit transitive group-in-group memberships without validating that the OpenFGA deployment configures `OPENFGA_RESOLVE_NODE_LIMIT` (ceiling <= 25) and `OPENFGA_MAX_CONCURRENT_READS_FOR_CHECK`. ## Bad vs Good Implementations ### Authorization Check with Contextual Tuples and Graph Depth Protection #### Bad Antipattern (AI Common Hallucination) > **Why it fails**: Accepts arbitrary contextual tuples without cycle validation or length caps, permitting callers to craft nested cyclic chains that exhaust OpenFGA resolution nodes. Lacks request timeout handling and catastrophically fails open on traversal exhaustion errors. ```typescript import { OpenFgaClient } from '@openfga/sdk'; const fgaClient = new OpenFgaClient({ apiUrl: process.env.FGA_API_URL!, storeId: process.env.FGA_STORE_ID!, }); // ANTI-PATTERN: Injects unbounded contextual tuples from client request, // lacks client timeouts, and defaults to allow if evaluation fails/times out. export async function checkAccessUnsafe( userId: string, relation: string, documentId: string, incomingTuples: Array<{ user: string; relation: string; object: string }> ): Promise<boolean> { try { const response = await fgaClient.check({ user: `user:${userId}`, relation, object: `document:${documentId}`, contextualTuples: incomingTuples, // Vulnerable: Unvalidated depth and potential cycles }); return response.allowed ?? false; } catch (error) { // Vulnerable: Fails open on timeout or graph node exhaustion console.error('OpenFGA check failed, granting fallback access:', error); return true; } } ``` #### Production Standard (Correct) > **Standard**: Enforces contextual tuple size validation and self-referential cycle rejection before hitting the authorization engine. Applies an explicit 1500ms abort deadline and mandates a strict fail-closed posture (returning false) for timeouts, validation errors, and resolution node exhaustion. ```typescript import { OpenFgaClient, FgaApiValidationError } from '@openfga/sdk'; const fgaClient = new OpenFgaClient({ apiUrl: process.env.FGA_API_URL!, storeId: process.env.FGA_STORE_ID!, authorizationModelId: process.env.FGA_MODEL_ID, }); const MAX_CONTEXTUAL_TUPLES = 10; const CHECK_TIMEOUT_MS = 1500; interface TupleKey { user: string; relation: string; object: string; } function validateContextualGraphSafety(tuples: TupleKey[]): void { if (tuples.length > MAX_CONTEXTUAL_TUPLES) { throw new Error(`Contextual tuple limit exceeded: max ${MAX_CONTEXTUAL_TUPLES}`); } for (const tuple of tuples) { if (tuple.user === tuple.object) { throw new Error(`Self-referential cyclic tuple detected: ${tuple.user}`); } } } export async function checkAccessSafe( userId: string, relation: string, documentId: string, incomingTuples: TupleKey[] = [] ): Promise<boolean> { validateContextualGraphSafety(incomingTuples); const controller = new AbortController(); const timeoutId = setTimeout(() => controller.abort(), CHECK_TIMEOUT_MS); try { const response = await fgaClient.check( { user: `user:${userId}`, relation, object: `document:${documentId}`, contextualTuples: incomingTuples, }, { signal: controller.signal, } ); return Boolean(response.allowed); } catch (error: unknown) { // Mandatory fail-closed posture for graph exhaustion, cycles, and timeouts if (error instanceof FgaApiValidationError || (error instanceof Error && error.name === 'AbortError')) { console.warn('Authorization evaluation aborted or resolution ceiling hit:', error); return false; } console.error('Unhandled authorization evaluation error:', error); return false; } finally { clearTimeout(timeoutId); } } ```

Architectural Specification & Invariant Rationale

Architectural Invariant Design: OpenFGA 1.6 Deterministic Graph Traversal Depth and Cycle Ceiling Enforcement

OpenFGA 1.6 Deterministic Graph Traversal Depth and Cycle Ceiling Enforcement defines an industrial-grade behavioral standard for security engineering. Enforces deterministic boundaries on OpenFGA authorization graph traversals to prevent algorithmic denial-of-service (Graph-DoS) from unbounded recursive relations and cyclic group hierarchies. Mandates schema-level cycle guards, bounded resolution node caps, contextual tuple limits, and fail-closed timeout policies across all Check and ListObjects query paths. 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: Unbounded Recursive Relationship Evaluation Permitting Algorithmic Graph Traversal Denial-of-Service 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	Unbounded Recursive Relationship Evaluation Permitting Algorithmic Graph Traversal Denial-of-Service	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 enforce strict request-level timeout deadlines (maximum 2000ms) and bounded retry budgets on all OpenFGA Check, Expand, and ListObjects client requests.

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.