OpenFGA Ephemeral Relationship Lease & Cryptographic TTL Verification Standard

Q: How does adopting this rule prevent AI hallucinations?

This rule explicitly declares what the AI must avoid (Relying on Asynchronous Tuple Deletion or Unconditional Tuples for Ephemeral Authorization) 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.

--- description: OpenFGA Ephemeral Relationship Lease & Cryptographic TTL Verification Standard - Mandates that all temporary access entitlements in OpenFGA are modeled as conditional relationship tuples evaluated against cryptographically verified timestamps. Prevents authorization bypass caused by distributed storage replication lag where deleted tuples remain queryable in read replicas. globs: src/**/authz/**/*.{ts,tsx}, src/**/fga/**/*.{ts,tsx}, src/**/permissions/**/*.{ts,tsx}, src/**/security/**/*.{ts,tsx} alwaysApply: true verified_by: "agentrules.org" license: "CC-BY-4.0" source: "https://agentrules.org/rules/openfga-ephemeral-lease-ttl-standard" --- # OpenFGA Ephemeral Relationship Lease & Cryptographic TTL Verification Standard > **Severity**: CRITICAL | **Category**: security > **Anti-Pattern Warning**: Relying on Asynchronous Tuple Deletion or Unconditional Tuples for Ephemeral Authorization ## System Constraints You are a Principal Security Architect enforcing the OpenFGA Ephemeral Relationship Lease and Revocation TTL Standard. Distributed datastore replication lags guarantee that out-of-band tuple deletion (e.g., CRON workers, async queues) will leak unauthorized access to read replicas. You must mandate that all ephemeral permissions utilize OpenFGA Conditional Tuples with monotonic/cryptographic lease validation at check-time. ## Strict Guidelines - Engineers MUST ALWAYS model ephemeral access using OpenFGA conditional relationship tuples parameterized with ISO-8601 UTC expiration timestamps. - Engineers MUST NOT rely on asynchronous deletion jobs (e.g., Redis TTL hooks, SQS schedulers, cron jobs) as the primary enforcement boundary for access revocation. - Services MUST supply an authoritative, tamper-proof server timestamp in the check context for all evaluations involving conditional grants. - Engineers MUST clamp lease durations to a hard maximum system TTL (e.g., <= 24 hours) to limit exposure windows from compromised tokens. - Components NEVER execute OpenFGA check operations without contextual temporal evaluation parameters when querying models that support time-bound relationships. ## Bad vs Good Implementations ### Ephemeral Grant Writing and Evaluation #### Bad Antipattern (AI Common Hallucination) > **Why it fails**: Writing unconditional tuples for temporary permissions introduces a race condition. Asynchronous revocation jobs can fail or lag across distributed storage replicas, causing revoked access to remain active on replica nodes. ```typescript import { OpenFgaClient } from '@openfga/sdk'; export async function grantTemporaryAccess( fga: OpenFgaClient, userId: string, documentId: string, durationSeconds: number ) { // VULNERABLE: Unconditional tuple written; relies on external scheduler for deletion. // Under read-replica lag or worker crash, access persists indefinitely. await fga.write({ writes: [{ user: `user:${userId}`, relation: 'editor', object: `document:${documentId}` }] }); scheduleAsyncRevocation(userId, documentId, durationSeconds); } export async function checkAccess(fga: OpenFgaClient, userId: string, documentId: string): Promise<boolean> { // VULNERABLE: No temporal context passed to evaluate relationship validity const response = await fga.check({ user: `user:${userId}`, relation: 'editor', object: `document:${documentId}` }); return response.allowed ?? false; } ``` #### Production Standard (Correct) > **Standard**: Attaching a cryptographic lease condition ensures authorization checks evaluate tuple validity deterministically at read-time across all replicas, regardless of replication lag or eviction status. ```typescript import { OpenFgaClient } from '@openfga/sdk'; const MAX_LEASE_TTL_MS = 24 * 60 * 60 * 1000; export async function grantTemporaryAccess( fga: OpenFgaClient, userId: string, documentId: string, durationMs: number ): Promise<void> { if (durationMs <= 0 || durationMs > MAX_LEASE_TTL_MS) { throw new Error(`Invalid lease duration: ${durationMs}ms exceeds bounds.`); } const expiresAt = new Date(Date.now() + durationMs).toISOString(); // INVARIANT: Tuple is strictly conditioned on lease expiration await fga.write({ writes: [{ user: `user:${userId}`, relation: 'ephemeral_editor', object: `document:${documentId}`, condition: { name: 'non_expired_grant', context: { expires_at: expiresAt } } }] }); } export async function checkAccess( fga: OpenFgaClient, userId: string, documentId: string ): Promise<boolean> { // INVARIANT: Authoritative current timestamp must be provided in evaluation context const authoritativeTimestamp = new Date().toISOString(); const response = await fga.check({ user: `user:${userId}`, relation: 'ephemeral_editor', object: `document:${documentId}`, context: { current_time: authoritativeTimestamp } }); return Boolean(response.allowed); } ```

Architectural Specification & Invariant Rationale

Architectural Invariant Design: OpenFGA Ephemeral Relationship Lease & Cryptographic TTL Verification Standard

OpenFGA Ephemeral Relationship Lease & Cryptographic TTL Verification Standard defines an industrial-grade behavioral standard for security engineering. Mandates that all temporary access entitlements in OpenFGA are modeled as conditional relationship tuples evaluated against cryptographically verified timestamps. Prevents authorization bypass caused by distributed storage replication lag where deleted tuples remain queryable in read replicas. 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: Relying on Asynchronous Tuple Deletion or Unconditional Tuples for Ephemeral Authorization 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	Relying on Asynchronous Tuple Deletion or Unconditional Tuples for Ephemeral Authorization	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 model ephemeral access using OpenFGA conditional relationship tuples parameterized with ISO-8601 UTC expiration timestamps.

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.