getRelationship method

lexicons/app/wafrn/graph/getRelationship.json

···
+{
+  "lexicon": 1,
+  "id": "app.wafrn.graph.getRelationship",
+  "defs": {
+    "main": {
+      "type": "query",
+      "description": "Get the follow relationship between two users (bidirectional)",
+      "parameters": {
+        "type": "params",
+        "required": ["actor", "viewer"],
+        "properties": {
+          "actor": {
+            "type": "string",
+            "format": "did",
+            "description": "DID of the actor (typically the profile being viewed)"
+          },
+          "viewer": {
+            "type": "string",
+            "format": "did",
+            "description": "DID of the viewer (typically the current user)"
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["following", "followedBy"],
+          "properties": {
+            "following": {
+              "type": "boolean",
+              "description": "True if viewer follows actor"
+            },
+            "followedBy": {
+              "type": "boolean",
+              "description": "True if actor follows viewer"
+            }
+          }
+        }
+      }
+    }
+  }
+}

packages/lexicon/index.ts

···
 export * as AppWafrnGraphFollow from "./types/app/wafrn/graph/follow.js";
 export * as AppWafrnGraphGetFollowers from "./types/app/wafrn/graph/getFollowers.js";
 export * as AppWafrnGraphGetFollows from "./types/app/wafrn/graph/getFollows.js";
+export * as AppWafrnGraphGetRelationship from "./types/app/wafrn/graph/getRelationship.js";
 export * as ComAtprotoRepoStrongRef from "./types/com/atproto/repo/strongRef.js";

packages/lexicon/types/app/wafrn/graph/getRelationship.ts

···
+import type {} from "@atcute/lexicons";
+import * as v from "@atcute/lexicons/validations";
+import type {} from "@atcute/lexicons/ambient";
+
+const _mainSchema = /*#__PURE__*/ v.query("app.wafrn.graph.getRelationship", {
+  params: /*#__PURE__*/ v.object({
+    /**
+     * DID of the actor (typically the profile being viewed)
+     */
+    actor: /*#__PURE__*/ v.didString(),
+    /**
+     * DID of the viewer (typically the current user)
+     */
+    viewer: /*#__PURE__*/ v.didString(),
+  }),
+  output: {
+    type: "lex",
+    schema: /*#__PURE__*/ v.object({
+      /**
+       * True if actor follows viewer
+       */
+      followedBy: /*#__PURE__*/ v.boolean(),
+      /**
+       * True if viewer follows actor
+       */
+      following: /*#__PURE__*/ v.boolean(),
+    }),
+  },
+});
+
+type main$schematype = typeof _mainSchema;
+
+export interface mainSchema extends main$schematype {}
+
+export const mainSchema = _mainSchema as mainSchema;
+
+export interface $params extends v.InferInput<mainSchema["params"]> {}
+export interface $output extends v.InferXRPCBodyInput<mainSchema["output"]> {}
+
+declare module "@atcute/lexicons/ambient" {
+  interface XRPCQueries {
+    "app.wafrn.graph.getRelationship": mainSchema;
+  }
+}

packages/server/CLAUDE.md

···
 
 **Design rationale**: Post feeds are the hottest query path in the application. By making counts optional and defaulting to `false`, we optimize the most common case while supporting full profile views when needed.
 
+**Checking User Relationships**:
+
+The `app.wafrn.graph.getRelationship` endpoint checks the bidirectional follow relationship between two users:
+
+```typescript
+// Check relationship between viewer and profile
+const relationship = await serverClient.get('app.wafrn.graph.getRelationship', {
+  params: {
+    actor: profileUserDid,      // Profile being viewed
+    viewer: currentUserDid       // Current user viewing
+  }
+})
+
+// Display appropriate UI based on relationship
+if (relationship.following && relationship.followedBy) {
+  // Mutual follows - show "Following" with mutual badge
+  return <button className="btn">Following · Mutual</button>
+} else if (relationship.following) {
+  // You follow them - show "Following"
+  return <button className="btn">Following</button>
+} else if (relationship.followedBy) {
+  // They follow you - show "Follow Back"
+  return <button className="btn btn-primary">Follow Back</button>
+} else {
+  // No relationship - show "Follow"
+  return <button className="btn btn-primary">Follow</button>
+}
+```
+
+**Response fields**:
+- `following` - True if viewer follows actor
+- `followedBy` - True if actor follows viewer
+
+**Common UI patterns**:
+- No relationship: "Follow" button
+- Viewer follows actor: "Following" button
+- Actor follows viewer: "Follow Back" button (encourages reciprocation)
+- Mutual follows: "Following" button with "Mutual" badge
+
+**Performance**: Uses `Promise.all` to check both directions in parallel (efficient).
+
 ### Path Aliases
 
 The server uses the `@api/*` path alias for clean internal imports:

packages/server/src/lib/xrpcServer.ts

···
   AppWafrnGraphDeleteFollow,
   AppWafrnGraphGetFollowers,
   AppWafrnGraphGetFollows,
+  AppWafrnGraphGetRelationship,
   AppWafrnActorGetProfiles
 } from '@watproto/lexicon'
 import { didDocResolver } from './idResolver'
···
   deleteFollow,
   getFollowCountsBatch,
   getFollowers,
-  getFollowing
+  getFollowing,
+  isFollowing
 } from '@api/lib/follow'
 import { getWafrnProfiles } from '@api/lib/profile'
 
···
         createdAt: new Date(f.created_at).toISOString(),
         uri: f.uri as ResourceUri
       }))
+    })
+  }
+})
+
+xrpcServer.addQuery(AppWafrnGraphGetRelationship.mainSchema, {
+  async handler({ params }) {
+    // Check both directions in parallel
+    const [following, followedBy] = await Promise.all([
+      isFollowing(params.viewer, params.actor), // viewer -> actor
+      isFollowing(params.actor, params.viewer) // actor -> viewer
+    ])
+
+    return json({
+      following, // Does viewer follow actor?
+      followedBy // Does actor follow viewer?
     })
   }
 })