djara.dev
fork
Configure Feed
Select the types of activity you want to include in your feed.
Testing implementation for private data in ATProto with ATPKeyserver and ATCute tools
fork
Configure Feed
Select the types of activity you want to include in your feed.
WIP social graph feature
+1625
-21
+13
-1
CLAUDE.md
+13
-1
CLAUDE.md
···
179
179
- XRPC server implementation
180
180
- Database patterns and migrations
181
181
- Post storage and retrieval
182
-
- Account management
182
+
- Social graph (follow relationships)
183
+
- Profile management (wafrn-specific + caching)
184
+
- Account management (operational data)
183
185
- ID resolution
184
186
185
187
- **Client**: `packages/client/CLAUDE.md`
···
262
264
- ✅ User authentication flow
263
265
- ✅ Basic UI components (Header, PostFeed, UserMenu)
264
266
- ✅ Lexicon type generation
267
+
- ✅ Social graph (follow relationships)
268
+
- Follow/unfollow operations with transaction-safe count updates
269
+
- Follower and following list queries (returns DIDs for batch enrichment)
270
+
- Denormalized follow counts for fast profile queries
271
+
- Federation-friendly (no foreign key constraints)
272
+
- ✅ Profile system (separated architecture)
273
+
- Operational account data (roles, status, moderation)
274
+
- Wafrn-specific profile customization (HTML bio, custom fields)
275
+
- Optional standard profile caching for performance
276
+
- Batch profile queries for efficient rendering
265
277
266
278
### Planned Features
267
279
- **Job Queue & Workers**: Background processing for posts, firehose consumption, timelines
+2
-9
lexicons.json
+2
-9
lexicons.json
···
1
1
{
2
-
"lexicons": [
3
-
"com.atproto.label.defs",
4
-
"com.atproto.repo.getRecord",
5
-
"com.atproto.repo.listRecords",
6
-
"com.atproto.repo.createRecord",
7
-
"com.atproto.repo.putRecord",
8
-
"com.atproto.repo.deleteRecord"
9
-
]
10
-
}
2
+
"lexicons": ["com.atproto.repo.strongRef"]
3
+
}
+54
lexicons/app/wafrn/actor/defs.json
+54
lexicons/app/wafrn/actor/defs.json
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.wafrn.actor.defs",
4
+
"defs": {
5
+
"profileView": {
6
+
"type": "object",
7
+
"description": "Wafrn-specific profile information view",
8
+
"required": ["did"],
9
+
"properties": {
10
+
"did": { "type": "string", "format": "did" },
11
+
"htmlBio": {
12
+
"type": "string",
13
+
"description": "HTML-formatted biography"
14
+
},
15
+
"serverOrigin": {
16
+
"type": "string",
17
+
"description": "User's server origin information"
18
+
},
19
+
"customFields": {
20
+
"type": "array",
21
+
"description": "Custom profile fields",
22
+
"items": {
23
+
"type": "ref",
24
+
"ref": "app.wafrn.actor.profile#customField"
25
+
}
26
+
},
27
+
"followingCount": {
28
+
"type": "integer",
29
+
"description": "Number of followers"
30
+
},
31
+
"followerCount": {
32
+
"type": "integer",
33
+
"description": "Number of users following this actor"
34
+
}
35
+
}
36
+
},
37
+
"profileViewDetailed": {
38
+
"type": "object",
39
+
"description": "Detailed profile view including operational status",
40
+
"required": ["did", "handle", "role", "active"],
41
+
"properties": {
42
+
"did": { "type": "string", "format": "did" },
43
+
"handle": { "type": "string", "format": "handle" },
44
+
"role": {
45
+
"type": "string",
46
+
"knownValues": ["user", "admin", "moderator"]
47
+
},
48
+
"active": { "type": "boolean" },
49
+
"status": { "type": "string" },
50
+
"wafrn": { "type": "ref", "ref": "#profileView" }
51
+
}
52
+
}
53
+
}
54
+
}
+41
lexicons/app/wafrn/actor/getProfiles.json
+41
lexicons/app/wafrn/actor/getProfiles.json
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.wafrn.actor.getProfiles",
4
+
"defs": {
5
+
"main": {
6
+
"type": "query",
7
+
"description": "Get wafrn-specific profile information for multiple accounts",
8
+
"parameters": {
9
+
"type": "params",
10
+
"required": ["actors"],
11
+
"properties": {
12
+
"actors": {
13
+
"type": "array",
14
+
"description": "List of DIDs to fetch profiles for",
15
+
"maxLength": 25,
16
+
"items": {
17
+
"type": "string",
18
+
"format": "did"
19
+
}
20
+
}
21
+
}
22
+
},
23
+
"output": {
24
+
"encoding": "application/json",
25
+
"schema": {
26
+
"type": "object",
27
+
"required": ["profiles"],
28
+
"properties": {
29
+
"profiles": {
30
+
"type": "array",
31
+
"items": {
32
+
"type": "ref",
33
+
"ref": "app.wafrn.actor.defs#profileView"
34
+
}
35
+
}
36
+
}
37
+
}
38
+
}
39
+
}
40
+
}
41
+
}
+51
lexicons/app/wafrn/actor/profile.json
+51
lexicons/app/wafrn/actor/profile.json
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.wafrn.actor.profile",
4
+
"defs": {
5
+
"main": {
6
+
"type": "record",
7
+
"description": "Wafrn-specific profile information (sidecar to app.bsky.actor.profile)",
8
+
"key": "literal:self",
9
+
"record": {
10
+
"type": "object",
11
+
"properties": {
12
+
"htmlBio": {
13
+
"type": "string",
14
+
"description": "HTML-formatted biography",
15
+
"maxLength": 10000
16
+
},
17
+
"serverOrigin": {
18
+
"type": "string",
19
+
"description": "User's server origin information",
20
+
"maxLength": 256
21
+
},
22
+
"customFields": {
23
+
"type": "array",
24
+
"description": "Custom profile fields",
25
+
"maxLength": 10,
26
+
"items": {
27
+
"type": "ref",
28
+
"ref": "#customField"
29
+
}
30
+
}
31
+
}
32
+
}
33
+
},
34
+
"customField": {
35
+
"type": "object",
36
+
"required": ["key", "value"],
37
+
"properties": {
38
+
"key": {
39
+
"type": "string",
40
+
"description": "Field name/label",
41
+
"maxLength": 64
42
+
},
43
+
"value": {
44
+
"type": "string",
45
+
"description": "Field value",
46
+
"maxLength": 256
47
+
}
48
+
}
49
+
}
50
+
}
51
+
}
+50
lexicons/app/wafrn/graph/cacheFollow.json
+50
lexicons/app/wafrn/graph/cacheFollow.json
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.wafrn.graph.cacheFollow",
4
+
"defs": {
5
+
"main": {
6
+
"type": "procedure",
7
+
"description": "Cache a follow record in the AppView",
8
+
"input": {
9
+
"encoding": "application/json",
10
+
"schema": {
11
+
"type": "object",
12
+
"required": ["follower", "followee", "uri", "createdAt"],
13
+
"properties": {
14
+
"follower": {
15
+
"type": "string",
16
+
"format": "did",
17
+
"description": "DID of the follower"
18
+
},
19
+
"followee": {
20
+
"type": "string",
21
+
"format": "did",
22
+
"description": "DID of the account being followed"
23
+
},
24
+
"uri": {
25
+
"type": "string",
26
+
"format": "at-uri",
27
+
"description": "URI of the follow record"
28
+
},
29
+
"createdAt": {
30
+
"type": "string",
31
+
"format": "datetime"
32
+
}
33
+
}
34
+
}
35
+
},
36
+
"output": {
37
+
"encoding": "application/json",
38
+
"schema": {
39
+
"type": "object",
40
+
"required": ["indexed"],
41
+
"properties": {
42
+
"indexed": {
43
+
"type": "boolean"
44
+
}
45
+
}
46
+
}
47
+
}
48
+
}
49
+
}
50
+
}
+41
lexicons/app/wafrn/graph/deleteFollow.json
+41
lexicons/app/wafrn/graph/deleteFollow.json
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.wafrn.graph.deleteFollow",
4
+
"defs": {
5
+
"main": {
6
+
"type": "procedure",
7
+
"description": "Remove a follow record from the AppView cache",
8
+
"input": {
9
+
"encoding": "application/json",
10
+
"schema": {
11
+
"type": "object",
12
+
"required": ["follower", "followee"],
13
+
"properties": {
14
+
"follower": {
15
+
"type": "string",
16
+
"format": "did",
17
+
"description": "DID of the follower"
18
+
},
19
+
"followee": {
20
+
"type": "string",
21
+
"format": "did",
22
+
"description": "DID of the account being followed"
23
+
}
24
+
}
25
+
}
26
+
},
27
+
"output": {
28
+
"encoding": "application/json",
29
+
"schema": {
30
+
"type": "object",
31
+
"required": ["deleted"],
32
+
"properties": {
33
+
"deleted": {
34
+
"type": "boolean"
35
+
}
36
+
}
37
+
}
38
+
}
39
+
}
40
+
}
41
+
}
+26
lexicons/app/wafrn/graph/follow.json
+26
lexicons/app/wafrn/graph/follow.json
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.wafrn.graph.follow",
4
+
"defs": {
5
+
"main": {
6
+
"type": "record",
7
+
"description": "Record representing a 'follow' relationship",
8
+
"key": "tid",
9
+
"record": {
10
+
"type": "object",
11
+
"required": ["subject", "createdAt"],
12
+
"properties": {
13
+
"subject": {
14
+
"type": "string",
15
+
"format": "did",
16
+
"description": "DID of the account being followed"
17
+
},
18
+
"createdAt": {
19
+
"type": "string",
20
+
"format": "datetime"
21
+
}
22
+
}
23
+
}
24
+
}
25
+
}
26
+
}
+69
lexicons/app/wafrn/graph/getFollowers.json
+69
lexicons/app/wafrn/graph/getFollowers.json
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.wafrn.graph.getFollowers",
4
+
"defs": {
5
+
"main": {
6
+
"type": "query",
7
+
"description": "Get a list of DIDs who follow the specified actor",
8
+
"parameters": {
9
+
"type": "params",
10
+
"required": ["actor"],
11
+
"properties": {
12
+
"actor": {
13
+
"type": "string",
14
+
"format": "did",
15
+
"description": "DID of the account"
16
+
},
17
+
"limit": {
18
+
"type": "integer",
19
+
"minimum": 1,
20
+
"maximum": 100,
21
+
"default": 50
22
+
},
23
+
"cursor": {
24
+
"type": "string",
25
+
"description": "Pagination cursor (timestamp)"
26
+
}
27
+
}
28
+
},
29
+
"output": {
30
+
"encoding": "application/json",
31
+
"schema": {
32
+
"type": "object",
33
+
"required": ["followers"],
34
+
"properties": {
35
+
"cursor": {
36
+
"type": "string"
37
+
},
38
+
"followers": {
39
+
"type": "array",
40
+
"items": {
41
+
"type": "ref",
42
+
"ref": "#follower"
43
+
}
44
+
}
45
+
}
46
+
}
47
+
}
48
+
},
49
+
"follower": {
50
+
"type": "object",
51
+
"required": ["did", "createdAt"],
52
+
"properties": {
53
+
"did": {
54
+
"type": "string",
55
+
"format": "did"
56
+
},
57
+
"createdAt": {
58
+
"type": "string",
59
+
"format": "datetime"
60
+
},
61
+
"uri": {
62
+
"type": "string",
63
+
"format": "at-uri",
64
+
"description": "URI of the follow record"
65
+
}
66
+
}
67
+
}
68
+
}
69
+
}
+69
lexicons/app/wafrn/graph/getFollows.json
+69
lexicons/app/wafrn/graph/getFollows.json
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "app.wafrn.graph.getFollows",
4
+
"defs": {
5
+
"main": {
6
+
"type": "query",
7
+
"description": "Get a list of DIDs that the specified actor follows",
8
+
"parameters": {
9
+
"type": "params",
10
+
"required": ["actor"],
11
+
"properties": {
12
+
"actor": {
13
+
"type": "string",
14
+
"format": "did",
15
+
"description": "DID of the account"
16
+
},
17
+
"limit": {
18
+
"type": "integer",
19
+
"minimum": 1,
20
+
"maximum": 100,
21
+
"default": 50
22
+
},
23
+
"cursor": {
24
+
"type": "string",
25
+
"description": "Pagination cursor (timestamp)"
26
+
}
27
+
}
28
+
},
29
+
"output": {
30
+
"encoding": "application/json",
31
+
"schema": {
32
+
"type": "object",
33
+
"required": ["follows"],
34
+
"properties": {
35
+
"cursor": {
36
+
"type": "string"
37
+
},
38
+
"follows": {
39
+
"type": "array",
40
+
"items": {
41
+
"type": "ref",
42
+
"ref": "#follow"
43
+
}
44
+
}
45
+
}
46
+
}
47
+
}
48
+
},
49
+
"follow": {
50
+
"type": "object",
51
+
"required": ["did", "createdAt"],
52
+
"properties": {
53
+
"did": {
54
+
"type": "string",
55
+
"format": "did"
56
+
},
57
+
"createdAt": {
58
+
"type": "string",
59
+
"format": "datetime"
60
+
},
61
+
"uri": {
62
+
"type": "string",
63
+
"format": "at-uri",
64
+
"description": "URI of the follow record"
65
+
}
66
+
}
67
+
}
68
+
}
69
+
}
+24
lexicons/com/atproto/repo/strongRef.json
+24
lexicons/com/atproto/repo/strongRef.json
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "com.atproto.repo.strongRef",
4
+
"description": "A URI with a content-hash fingerprint.",
5
+
"defs": {
6
+
"main": {
7
+
"type": "object",
8
+
"required": [
9
+
"uri",
10
+
"cid"
11
+
],
12
+
"properties": {
13
+
"cid": {
14
+
"type": "string",
15
+
"format": "cid"
16
+
},
17
+
"uri": {
18
+
"type": "string",
19
+
"format": "at-uri"
20
+
}
21
+
}
22
+
}
23
+
}
24
+
}
+9
packages/lexicon/index.ts
+9
packages/lexicon/index.ts
···
1
+
export * as AppWafrnActorDefs from "./types/app/wafrn/actor/defs.js";
2
+
export * as AppWafrnActorGetProfiles from "./types/app/wafrn/actor/getProfiles.js";
3
+
export * as AppWafrnActorProfile from "./types/app/wafrn/actor/profile.js";
1
4
export * as AppWafrnContentCachePost from "./types/app/wafrn/content/cachePost.js";
2
5
export * as AppWafrnContentDefs from "./types/app/wafrn/content/defs.js";
3
6
export * as AppWafrnContentGetFeed from "./types/app/wafrn/content/getFeed.js";
4
7
export * as AppWafrnContentPrivatePost from "./types/app/wafrn/content/privatePost.js";
5
8
export * as AppWafrnContentPublicPost from "./types/app/wafrn/content/publicPost.js";
9
+
export * as AppWafrnGraphCacheFollow from "./types/app/wafrn/graph/cacheFollow.js";
10
+
export * as AppWafrnGraphDeleteFollow from "./types/app/wafrn/graph/deleteFollow.js";
11
+
export * as AppWafrnGraphFollow from "./types/app/wafrn/graph/follow.js";
12
+
export * as AppWafrnGraphGetFollowers from "./types/app/wafrn/graph/getFollowers.js";
13
+
export * as AppWafrnGraphGetFollows from "./types/app/wafrn/graph/getFollows.js";
14
+
export * as ComAtprotoRepoStrongRef from "./types/com/atproto/repo/strongRef.js";
+30
packages/lexicon/types/app/bsky/graph/follow.ts
+30
packages/lexicon/types/app/bsky/graph/follow.ts
···
1
+
import type {} from "@atcute/lexicons";
2
+
import * as v from "@atcute/lexicons/validations";
3
+
import type {} from "@atcute/lexicons/ambient";
4
+
import * as ComAtprotoRepoStrongRef from "../../../com/atproto/repo/strongRef.js";
5
+
6
+
const _mainSchema = /*#__PURE__*/ v.record(
7
+
/*#__PURE__*/ v.tidString(),
8
+
/*#__PURE__*/ v.object({
9
+
$type: /*#__PURE__*/ v.literal("app.bsky.graph.follow"),
10
+
createdAt: /*#__PURE__*/ v.datetimeString(),
11
+
subject: /*#__PURE__*/ v.didString(),
12
+
get via() {
13
+
return /*#__PURE__*/ v.optional(ComAtprotoRepoStrongRef.mainSchema);
14
+
},
15
+
}),
16
+
);
17
+
18
+
type main$schematype = typeof _mainSchema;
19
+
20
+
export interface mainSchema extends main$schematype {}
21
+
22
+
export const mainSchema = _mainSchema as mainSchema;
23
+
24
+
export interface Main extends v.InferInput<typeof mainSchema> {}
25
+
26
+
declare module "@atcute/lexicons/ambient" {
27
+
interface Records {
28
+
"app.bsky.graph.follow": mainSchema;
29
+
}
30
+
}
+64
packages/lexicon/types/app/wafrn/actor/defs.ts
+64
packages/lexicon/types/app/wafrn/actor/defs.ts
···
1
+
import type {} from "@atcute/lexicons";
2
+
import * as v from "@atcute/lexicons/validations";
3
+
import * as AppWafrnActorProfile from "./profile.js";
4
+
5
+
const _profileViewSchema = /*#__PURE__*/ v.object({
6
+
$type: /*#__PURE__*/ v.optional(
7
+
/*#__PURE__*/ v.literal("app.wafrn.actor.defs#profileView"),
8
+
),
9
+
/**
10
+
* Custom profile fields
11
+
*/
12
+
get customFields() {
13
+
return /*#__PURE__*/ v.optional(
14
+
/*#__PURE__*/ v.array(AppWafrnActorProfile.customFieldSchema),
15
+
);
16
+
},
17
+
did: /*#__PURE__*/ v.didString(),
18
+
/**
19
+
* Number of users following this actor
20
+
*/
21
+
followerCount: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.integer()),
22
+
/**
23
+
* Number of followers
24
+
*/
25
+
followingCount: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.integer()),
26
+
/**
27
+
* HTML-formatted biography
28
+
*/
29
+
htmlBio: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.string()),
30
+
/**
31
+
* User's server origin information
32
+
*/
33
+
serverOrigin: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.string()),
34
+
});
35
+
const _profileViewDetailedSchema = /*#__PURE__*/ v.object({
36
+
$type: /*#__PURE__*/ v.optional(
37
+
/*#__PURE__*/ v.literal("app.wafrn.actor.defs#profileViewDetailed"),
38
+
),
39
+
active: /*#__PURE__*/ v.boolean(),
40
+
did: /*#__PURE__*/ v.didString(),
41
+
handle: /*#__PURE__*/ v.handleString(),
42
+
role: /*#__PURE__*/ v.string<
43
+
"admin" | "moderator" | "user" | (string & {})
44
+
>(),
45
+
status: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.string()),
46
+
get wafrn() {
47
+
return /*#__PURE__*/ v.optional(profileViewSchema);
48
+
},
49
+
});
50
+
51
+
type profileView$schematype = typeof _profileViewSchema;
52
+
type profileViewDetailed$schematype = typeof _profileViewDetailedSchema;
53
+
54
+
export interface profileViewSchema extends profileView$schematype {}
55
+
export interface profileViewDetailedSchema
56
+
extends profileViewDetailed$schematype {}
57
+
58
+
export const profileViewSchema = _profileViewSchema as profileViewSchema;
59
+
export const profileViewDetailedSchema =
60
+
_profileViewDetailedSchema as profileViewDetailedSchema;
61
+
62
+
export interface ProfileView extends v.InferInput<typeof profileViewSchema> {}
63
+
export interface ProfileViewDetailed
64
+
extends v.InferInput<typeof profileViewDetailedSchema> {}
+41
packages/lexicon/types/app/wafrn/actor/getProfiles.ts
+41
packages/lexicon/types/app/wafrn/actor/getProfiles.ts
···
1
+
import type {} from "@atcute/lexicons";
2
+
import * as v from "@atcute/lexicons/validations";
3
+
import type {} from "@atcute/lexicons/ambient";
4
+
import * as AppWafrnActorDefs from "./defs.js";
5
+
6
+
const _mainSchema = /*#__PURE__*/ v.query("app.wafrn.actor.getProfiles", {
7
+
params: /*#__PURE__*/ v.object({
8
+
/**
9
+
* List of DIDs to fetch profiles for
10
+
* @minLength 1
11
+
* @maxLength 25
12
+
*/
13
+
actors: /*#__PURE__*/ v.constrain(
14
+
/*#__PURE__*/ v.array(/*#__PURE__*/ v.didString()),
15
+
[/*#__PURE__*/ v.arrayLength(1, 25)],
16
+
),
17
+
}),
18
+
output: {
19
+
type: "lex",
20
+
schema: /*#__PURE__*/ v.object({
21
+
get profiles() {
22
+
return /*#__PURE__*/ v.array(AppWafrnActorDefs.profileViewSchema);
23
+
},
24
+
}),
25
+
},
26
+
});
27
+
28
+
type main$schematype = typeof _mainSchema;
29
+
30
+
export interface mainSchema extends main$schematype {}
31
+
32
+
export const mainSchema = _mainSchema as mainSchema;
33
+
34
+
export interface $params extends v.InferInput<mainSchema["params"]> {}
35
+
export interface $output extends v.InferXRPCBodyInput<mainSchema["output"]> {}
36
+
37
+
declare module "@atcute/lexicons/ambient" {
38
+
interface XRPCQueries {
39
+
"app.wafrn.actor.getProfiles": mainSchema;
40
+
}
41
+
}
+76
packages/lexicon/types/app/wafrn/actor/profile.ts
+76
packages/lexicon/types/app/wafrn/actor/profile.ts
···
1
+
import type {} from "@atcute/lexicons";
2
+
import * as v from "@atcute/lexicons/validations";
3
+
import type {} from "@atcute/lexicons/ambient";
4
+
5
+
const _customFieldSchema = /*#__PURE__*/ v.object({
6
+
$type: /*#__PURE__*/ v.optional(
7
+
/*#__PURE__*/ v.literal("app.wafrn.actor.profile#customField"),
8
+
),
9
+
/**
10
+
* Field name/label
11
+
* @maxLength 64
12
+
*/
13
+
key: /*#__PURE__*/ v.constrain(/*#__PURE__*/ v.string(), [
14
+
/*#__PURE__*/ v.stringLength(0, 64),
15
+
]),
16
+
/**
17
+
* Field value
18
+
* @maxLength 256
19
+
*/
20
+
value: /*#__PURE__*/ v.constrain(/*#__PURE__*/ v.string(), [
21
+
/*#__PURE__*/ v.stringLength(0, 256),
22
+
]),
23
+
});
24
+
const _mainSchema = /*#__PURE__*/ v.record(
25
+
/*#__PURE__*/ v.literal("self"),
26
+
/*#__PURE__*/ v.object({
27
+
$type: /*#__PURE__*/ v.literal("app.wafrn.actor.profile"),
28
+
/**
29
+
* Custom profile fields
30
+
* @maxLength 10
31
+
*/
32
+
get customFields() {
33
+
return /*#__PURE__*/ v.optional(
34
+
/*#__PURE__*/ v.constrain(/*#__PURE__*/ v.array(customFieldSchema), [
35
+
/*#__PURE__*/ v.arrayLength(0, 10),
36
+
]),
37
+
);
38
+
},
39
+
/**
40
+
* HTML-formatted biography
41
+
* @maxLength 10000
42
+
*/
43
+
htmlBio: /*#__PURE__*/ v.optional(
44
+
/*#__PURE__*/ v.constrain(/*#__PURE__*/ v.string(), [
45
+
/*#__PURE__*/ v.stringLength(0, 10000),
46
+
]),
47
+
),
48
+
/**
49
+
* User's server origin information
50
+
* @maxLength 256
51
+
*/
52
+
serverOrigin: /*#__PURE__*/ v.optional(
53
+
/*#__PURE__*/ v.constrain(/*#__PURE__*/ v.string(), [
54
+
/*#__PURE__*/ v.stringLength(0, 256),
55
+
]),
56
+
),
57
+
}),
58
+
);
59
+
60
+
type customField$schematype = typeof _customFieldSchema;
61
+
type main$schematype = typeof _mainSchema;
62
+
63
+
export interface customFieldSchema extends customField$schematype {}
64
+
export interface mainSchema extends main$schematype {}
65
+
66
+
export const customFieldSchema = _customFieldSchema as customFieldSchema;
67
+
export const mainSchema = _mainSchema as mainSchema;
68
+
69
+
export interface CustomField extends v.InferInput<typeof customFieldSchema> {}
70
+
export interface Main extends v.InferInput<typeof mainSchema> {}
71
+
72
+
declare module "@atcute/lexicons/ambient" {
73
+
interface Records {
74
+
"app.wafrn.actor.profile": mainSchema;
75
+
}
76
+
}
+47
packages/lexicon/types/app/wafrn/graph/cacheFollow.ts
+47
packages/lexicon/types/app/wafrn/graph/cacheFollow.ts
···
1
+
import type {} from "@atcute/lexicons";
2
+
import * as v from "@atcute/lexicons/validations";
3
+
import type {} from "@atcute/lexicons/ambient";
4
+
5
+
const _mainSchema = /*#__PURE__*/ v.procedure("app.wafrn.graph.cacheFollow", {
6
+
params: null,
7
+
input: {
8
+
type: "lex",
9
+
schema: /*#__PURE__*/ v.object({
10
+
createdAt: /*#__PURE__*/ v.datetimeString(),
11
+
/**
12
+
* DID of the account being followed
13
+
*/
14
+
followee: /*#__PURE__*/ v.didString(),
15
+
/**
16
+
* DID of the follower
17
+
*/
18
+
follower: /*#__PURE__*/ v.didString(),
19
+
/**
20
+
* URI of the follow record
21
+
*/
22
+
uri: /*#__PURE__*/ v.resourceUriString(),
23
+
}),
24
+
},
25
+
output: {
26
+
type: "lex",
27
+
schema: /*#__PURE__*/ v.object({
28
+
indexed: /*#__PURE__*/ v.boolean(),
29
+
}),
30
+
},
31
+
});
32
+
33
+
type main$schematype = typeof _mainSchema;
34
+
35
+
export interface mainSchema extends main$schematype {}
36
+
37
+
export const mainSchema = _mainSchema as mainSchema;
38
+
39
+
export interface $params {}
40
+
export interface $input extends v.InferXRPCBodyInput<mainSchema["input"]> {}
41
+
export interface $output extends v.InferXRPCBodyInput<mainSchema["output"]> {}
42
+
43
+
declare module "@atcute/lexicons/ambient" {
44
+
interface XRPCProcedures {
45
+
"app.wafrn.graph.cacheFollow": mainSchema;
46
+
}
47
+
}
+42
packages/lexicon/types/app/wafrn/graph/deleteFollow.ts
+42
packages/lexicon/types/app/wafrn/graph/deleteFollow.ts
···
1
+
import type {} from "@atcute/lexicons";
2
+
import * as v from "@atcute/lexicons/validations";
3
+
import type {} from "@atcute/lexicons/ambient";
4
+
5
+
const _mainSchema = /*#__PURE__*/ v.procedure("app.wafrn.graph.deleteFollow", {
6
+
params: null,
7
+
input: {
8
+
type: "lex",
9
+
schema: /*#__PURE__*/ v.object({
10
+
/**
11
+
* DID of the account being followed
12
+
*/
13
+
followee: /*#__PURE__*/ v.didString(),
14
+
/**
15
+
* DID of the follower
16
+
*/
17
+
follower: /*#__PURE__*/ v.didString(),
18
+
}),
19
+
},
20
+
output: {
21
+
type: "lex",
22
+
schema: /*#__PURE__*/ v.object({
23
+
deleted: /*#__PURE__*/ v.boolean(),
24
+
}),
25
+
},
26
+
});
27
+
28
+
type main$schematype = typeof _mainSchema;
29
+
30
+
export interface mainSchema extends main$schematype {}
31
+
32
+
export const mainSchema = _mainSchema as mainSchema;
33
+
34
+
export interface $params {}
35
+
export interface $input extends v.InferXRPCBodyInput<mainSchema["input"]> {}
36
+
export interface $output extends v.InferXRPCBodyInput<mainSchema["output"]> {}
37
+
38
+
declare module "@atcute/lexicons/ambient" {
39
+
interface XRPCProcedures {
40
+
"app.wafrn.graph.deleteFollow": mainSchema;
41
+
}
42
+
}
+29
packages/lexicon/types/app/wafrn/graph/follow.ts
+29
packages/lexicon/types/app/wafrn/graph/follow.ts
···
1
+
import type {} from "@atcute/lexicons";
2
+
import * as v from "@atcute/lexicons/validations";
3
+
import type {} from "@atcute/lexicons/ambient";
4
+
5
+
const _mainSchema = /*#__PURE__*/ v.record(
6
+
/*#__PURE__*/ v.tidString(),
7
+
/*#__PURE__*/ v.object({
8
+
$type: /*#__PURE__*/ v.literal("app.wafrn.graph.follow"),
9
+
createdAt: /*#__PURE__*/ v.datetimeString(),
10
+
/**
11
+
* DID of the account being followed
12
+
*/
13
+
subject: /*#__PURE__*/ v.didString(),
14
+
}),
15
+
);
16
+
17
+
type main$schematype = typeof _mainSchema;
18
+
19
+
export interface mainSchema extends main$schematype {}
20
+
21
+
export const mainSchema = _mainSchema as mainSchema;
22
+
23
+
export interface Main extends v.InferInput<typeof mainSchema> {}
24
+
25
+
declare module "@atcute/lexicons/ambient" {
26
+
interface Records {
27
+
"app.wafrn.graph.follow": mainSchema;
28
+
}
29
+
}
+67
packages/lexicon/types/app/wafrn/graph/getFollowers.ts
+67
packages/lexicon/types/app/wafrn/graph/getFollowers.ts
···
1
+
import type {} from "@atcute/lexicons";
2
+
import * as v from "@atcute/lexicons/validations";
3
+
import type {} from "@atcute/lexicons/ambient";
4
+
5
+
const _followerSchema = /*#__PURE__*/ v.object({
6
+
$type: /*#__PURE__*/ v.optional(
7
+
/*#__PURE__*/ v.literal("app.wafrn.graph.getFollowers#follower"),
8
+
),
9
+
createdAt: /*#__PURE__*/ v.datetimeString(),
10
+
did: /*#__PURE__*/ v.didString(),
11
+
/**
12
+
* URI of the follow record
13
+
*/
14
+
uri: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.resourceUriString()),
15
+
});
16
+
const _mainSchema = /*#__PURE__*/ v.query("app.wafrn.graph.getFollowers", {
17
+
params: /*#__PURE__*/ v.object({
18
+
/**
19
+
* DID of the account
20
+
*/
21
+
actor: /*#__PURE__*/ v.didString(),
22
+
/**
23
+
* Pagination cursor (timestamp)
24
+
*/
25
+
cursor: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.string()),
26
+
/**
27
+
* @minimum 1
28
+
* @maximum 100
29
+
* @default 50
30
+
*/
31
+
limit: /*#__PURE__*/ v.optional(
32
+
/*#__PURE__*/ v.constrain(/*#__PURE__*/ v.integer(), [
33
+
/*#__PURE__*/ v.integerRange(1, 100),
34
+
]),
35
+
50,
36
+
),
37
+
}),
38
+
output: {
39
+
type: "lex",
40
+
schema: /*#__PURE__*/ v.object({
41
+
cursor: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.string()),
42
+
get followers() {
43
+
return /*#__PURE__*/ v.array(followerSchema);
44
+
},
45
+
}),
46
+
},
47
+
});
48
+
49
+
type follower$schematype = typeof _followerSchema;
50
+
type main$schematype = typeof _mainSchema;
51
+
52
+
export interface followerSchema extends follower$schematype {}
53
+
export interface mainSchema extends main$schematype {}
54
+
55
+
export const followerSchema = _followerSchema as followerSchema;
56
+
export const mainSchema = _mainSchema as mainSchema;
57
+
58
+
export interface Follower extends v.InferInput<typeof followerSchema> {}
59
+
60
+
export interface $params extends v.InferInput<mainSchema["params"]> {}
61
+
export interface $output extends v.InferXRPCBodyInput<mainSchema["output"]> {}
62
+
63
+
declare module "@atcute/lexicons/ambient" {
64
+
interface XRPCQueries {
65
+
"app.wafrn.graph.getFollowers": mainSchema;
66
+
}
67
+
}
+67
packages/lexicon/types/app/wafrn/graph/getFollows.ts
+67
packages/lexicon/types/app/wafrn/graph/getFollows.ts
···
1
+
import type {} from "@atcute/lexicons";
2
+
import * as v from "@atcute/lexicons/validations";
3
+
import type {} from "@atcute/lexicons/ambient";
4
+
5
+
const _followSchema = /*#__PURE__*/ v.object({
6
+
$type: /*#__PURE__*/ v.optional(
7
+
/*#__PURE__*/ v.literal("app.wafrn.graph.getFollows#follow"),
8
+
),
9
+
createdAt: /*#__PURE__*/ v.datetimeString(),
10
+
did: /*#__PURE__*/ v.didString(),
11
+
/**
12
+
* URI of the follow record
13
+
*/
14
+
uri: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.resourceUriString()),
15
+
});
16
+
const _mainSchema = /*#__PURE__*/ v.query("app.wafrn.graph.getFollows", {
17
+
params: /*#__PURE__*/ v.object({
18
+
/**
19
+
* DID of the account
20
+
*/
21
+
actor: /*#__PURE__*/ v.didString(),
22
+
/**
23
+
* Pagination cursor (timestamp)
24
+
*/
25
+
cursor: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.string()),
26
+
/**
27
+
* @minimum 1
28
+
* @maximum 100
29
+
* @default 50
30
+
*/
31
+
limit: /*#__PURE__*/ v.optional(
32
+
/*#__PURE__*/ v.constrain(/*#__PURE__*/ v.integer(), [
33
+
/*#__PURE__*/ v.integerRange(1, 100),
34
+
]),
35
+
50,
36
+
),
37
+
}),
38
+
output: {
39
+
type: "lex",
40
+
schema: /*#__PURE__*/ v.object({
41
+
cursor: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.string()),
42
+
get follows() {
43
+
return /*#__PURE__*/ v.array(followSchema);
44
+
},
45
+
}),
46
+
},
47
+
});
48
+
49
+
type follow$schematype = typeof _followSchema;
50
+
type main$schematype = typeof _mainSchema;
51
+
52
+
export interface followSchema extends follow$schematype {}
53
+
export interface mainSchema extends main$schematype {}
54
+
55
+
export const followSchema = _followSchema as followSchema;
56
+
export const mainSchema = _mainSchema as mainSchema;
57
+
58
+
export interface Follow extends v.InferInput<typeof followSchema> {}
59
+
60
+
export interface $params extends v.InferInput<mainSchema["params"]> {}
61
+
export interface $output extends v.InferXRPCBodyInput<mainSchema["output"]> {}
62
+
63
+
declare module "@atcute/lexicons/ambient" {
64
+
interface XRPCQueries {
65
+
"app.wafrn.graph.getFollows": mainSchema;
66
+
}
67
+
}
+18
packages/lexicon/types/com/atproto/repo/strongRef.ts
+18
packages/lexicon/types/com/atproto/repo/strongRef.ts
···
1
+
import type {} from "@atcute/lexicons";
2
+
import * as v from "@atcute/lexicons/validations";
3
+
4
+
const _mainSchema = /*#__PURE__*/ v.object({
5
+
$type: /*#__PURE__*/ v.optional(
6
+
/*#__PURE__*/ v.literal("com.atproto.repo.strongRef"),
7
+
),
8
+
cid: /*#__PURE__*/ v.cidString(),
9
+
uri: /*#__PURE__*/ v.resourceUriString(),
10
+
});
11
+
12
+
type main$schematype = typeof _mainSchema;
13
+
14
+
export interface mainSchema extends main$schematype {}
15
+
16
+
export const mainSchema = _mainSchema as mainSchema;
17
+
18
+
export interface Main extends v.InferInput<typeof mainSchema> {}
+55
-9
packages/server/CLAUDE.md
+55
-9
packages/server/CLAUDE.md
···
69
69
│ ├── lib/
70
70
│ │ ├── env.ts # Environment variable validation
71
71
│ │ ├── account.ts # Account management logic
72
+
│ │ ├── follow.ts # Follow relationship management
73
+
│ │ ├── profile.ts # Profile management (wafrn-specific + cache)
72
74
│ │ ├── xrpcServer.ts # XRPC server instance and configuration
73
75
│ │ └── idResolver.ts # ATProto identity resolution
74
76
│ └── db/
···
78
80
│ ├── 1761580548730_accounts.ts
79
81
│ ├── 1762114354466_public_posts.ts
80
82
│ ├── 1762179949540_private_posts.ts
81
-
│ └── 1762179953814_tags.ts
83
+
│ ├── 1762179953814_tags.ts
84
+
│ └── 1762527898283_social_graph.ts
82
85
├── data/ # SQLite database files
83
86
├── package.json # Package dependencies and scripts
84
87
├── tsconfig.json # TypeScript configuration
···
105
108
- Retrieve posts by account or tag
106
109
- Tag management for posts
107
110
108
-
2. **Account Management**:
109
-
- Upsert account records (DID, handle, metadata)
111
+
2. **Social Graph**:
112
+
- Index follow relationships from ATProto network
113
+
- Query followers and following lists
114
+
- Maintain denormalized follow counts
115
+
- Cache follow data for efficient querying
116
+
117
+
3. **Profile Management**:
118
+
- Store wafrn-specific profile metadata (HTML bio, custom fields)
119
+
- Optionally cache standard profile data (avatars, display names)
120
+
- Batch profile queries for efficient client rendering
121
+
122
+
4. **Account Management**:
123
+
- Upsert account records (DID, handle, operational metadata)
110
124
- Query account information
111
125
- Account existence validation
126
+
- Operational status tracking (active, roles, moderation status)
112
127
113
-
3. **Identity Resolution**:
128
+
5. **Identity Resolution**:
114
129
- Resolve ATProto DIDs to handles
115
130
- Resolve handles to DIDs
116
131
- PDS discovery for ATProto accounts
···
120
135
121
136
### Database Architecture
122
137
123
-
**Tables:**
124
-
- `accounts` - User account records with DID (primary key), handle, PDS URL, metadata
125
-
- `public_posts` - Public posts with TID, account DID, text content, facets, created timestamp
126
-
- `private_posts` - Private posts with same structure as public posts
127
-
- `tags` - Tag associations: tag name, post type (public/private), post TID
138
+
**Core Tables:**
139
+
140
+
- **`accounts`** - Operational account data only (separated from profile data)
141
+
- Primary key: `did` (ATProto DID)
142
+
- Fields: `handle`, `role`, `active`, `status`, timestamps
143
+
- Purpose: Access control, moderation, operational tracking
144
+
- No foreign keys to preserve federation independence
145
+
146
+
- **`profiles`** - Wafrn-specific and cached profile data
147
+
- Primary key: `did`
148
+
- Wafrn fields: `html_bio`, `server_origin`, `custom_fields` (JSON)
149
+
- Cached fields: `display_name`, `avatar_url`, `description`, `banner_url`
150
+
- Foreign key to `accounts` (CASCADE on delete)
151
+
- Purpose: App-specific customization + optional standard profile cache
152
+
153
+
**Post Tables:**
154
+
- **`public_posts`** - Public posts with HTML/Markdown content
155
+
- **`private_posts`** - Encrypted private posts
156
+
- **`tags`** - Tag definitions
157
+
- **`public_post_tags`** - Junction table for post-tag associations
158
+
159
+
**Social Graph Tables:**
160
+
161
+
- **`follows`** - Follow relationships indexed from ATProto network
162
+
- Composite primary key: (`follower_did`, `followee_did`)
163
+
- Fields: `uri` (ATProto record URI), `created_at`, `indexed_at`
164
+
- No foreign keys to accounts (federated - any DID can follow any DID)
165
+
- Indexes: `follower_did`, `followee_did`, `uri`, `created_at`
166
+
167
+
- **`follow_counts`** - Denormalized follower/following counts
168
+
- Primary key: `did`
169
+
- Fields: `follower_count`, `following_count`, `updated_at`
170
+
- Updated transactionally with follow operations
171
+
- Index on `follower_count` for popularity queries
128
172
129
173
**Key Patterns:**
130
174
- Migrations run automatically on server start via `migrateDBToLatest()`
···
132
176
- Schema types auto-generated via `kysely-codegen` - regenerate after schema changes
133
177
- WAL mode enabled for better concurrent access
134
178
- TIDs (Timestamp IDs) used for post identifiers (ATProto standard)
179
+
- **Separated concerns**: Operational data (accounts) vs profile data (profiles) vs relationships (follows)
180
+
- **Federation-friendly**: No foreign key constraints on follows table
135
181
136
182
### Environment Variables
137
183
+31
packages/server/src/db/schema.d.ts
+31
packages/server/src/db/schema.d.ts
···
19
19
status: string | null;
20
20
}
21
21
22
+
export interface FollowCounts {
23
+
did: string;
24
+
follower_count: Generated<number>;
25
+
following_count: Generated<number>;
26
+
updated_at: Generated<number>;
27
+
}
28
+
29
+
export interface Follows {
30
+
created_at: number;
31
+
followee_did: string;
32
+
follower_did: string;
33
+
indexed_at: Generated<number>;
34
+
uri: string;
35
+
}
36
+
22
37
export interface PrivatePosts {
23
38
author_did: string;
24
39
created_at: Generated<number>;
···
30
45
visibility: Generated<string>;
31
46
}
32
47
48
+
export interface Profiles {
49
+
avatar_url: string | null;
50
+
banner_url: string | null;
51
+
custom_fields: string | null;
52
+
description: string | null;
53
+
did: string;
54
+
display_name: string | null;
55
+
html_bio: string | null;
56
+
profile_cached_at: number | null;
57
+
server_origin: string | null;
58
+
wafrn_updated_at: Generated<number>;
59
+
}
60
+
33
61
export interface PublicPosts {
34
62
author_did: string;
35
63
content_html: string;
···
54
82
55
83
export interface DB {
56
84
accounts: Accounts;
85
+
follow_counts: FollowCounts;
86
+
follows: Follows;
57
87
private_posts: PrivatePosts;
88
+
profiles: Profiles;
58
89
public_post_tags: PublicPostTags;
59
90
public_posts: PublicPosts;
60
91
tags: Tags;
+183
packages/server/src/lib/follow.ts
+183
packages/server/src/lib/follow.ts
···
1
+
import { sql } from 'kysely'
2
+
import { db } from '@api/db/db'
3
+
4
+
/**
5
+
* Create a follow relationship between two accounts.
6
+
* Updates follow_counts for both accounts in a transaction.
7
+
*/
8
+
export async function createFollow(
9
+
followerDid: string,
10
+
followeeDid: string,
11
+
uri: string,
12
+
createdAt: number
13
+
): Promise<void> {
14
+
await db.transaction().execute(async (trx) => {
15
+
// Step 1: Insert follow record (idempotent with onConflict)
16
+
await trx
17
+
.insertInto('follows')
18
+
.values({
19
+
follower_did: followerDid,
20
+
followee_did: followeeDid,
21
+
uri,
22
+
created_at: createdAt
23
+
})
24
+
.onConflict((oc) =>
25
+
oc.columns(['follower_did', 'followee_did']).doNothing()
26
+
)
27
+
.execute()
28
+
29
+
// Step 2: Update following_count for follower
30
+
await trx
31
+
.insertInto('follow_counts')
32
+
.values({ did: followerDid, following_count: 1, follower_count: 0 })
33
+
.onConflict((oc) =>
34
+
oc.column('did').doUpdateSet({
35
+
following_count: sql`following_count + 1`,
36
+
updated_at: sql`(unixepoch() * 1000)`
37
+
})
38
+
)
39
+
.execute()
40
+
41
+
// Step 3: Update follower_count for followee
42
+
await trx
43
+
.insertInto('follow_counts')
44
+
.values({ did: followeeDid, follower_count: 1, following_count: 0 })
45
+
.onConflict((oc) =>
46
+
oc.column('did').doUpdateSet({
47
+
follower_count: sql`follower_count + 1`,
48
+
updated_at: sql`(unixepoch() * 1000)`
49
+
})
50
+
)
51
+
.execute()
52
+
})
53
+
}
54
+
55
+
/**
56
+
* Delete a follow relationship between two accounts.
57
+
* Decrements follow_counts for both accounts in a transaction.
58
+
*/
59
+
export async function deleteFollow(
60
+
followerDid: string,
61
+
followeeDid: string
62
+
): Promise<void> {
63
+
await db.transaction().execute(async (trx) => {
64
+
// Step 1: Delete follow record
65
+
const result = await trx
66
+
.deleteFrom('follows')
67
+
.where('follower_did', '=', followerDid)
68
+
.where('followee_did', '=', followeeDid)
69
+
.execute()
70
+
71
+
// Only update counts if a row was actually deleted
72
+
if (result[0].numDeletedRows > 0n) {
73
+
// Step 2: Decrement following_count for follower (don't go below 0)
74
+
await trx
75
+
.updateTable('follow_counts')
76
+
.set({
77
+
following_count: sql`MAX(following_count - 1, 0)`,
78
+
updated_at: sql`(unixepoch() * 1000)`
79
+
})
80
+
.where('did', '=', followerDid)
81
+
.execute()
82
+
83
+
// Step 3: Decrement follower_count for followee (don't go below 0)
84
+
await trx
85
+
.updateTable('follow_counts')
86
+
.set({
87
+
follower_count: sql`MAX(follower_count - 1, 0)`,
88
+
updated_at: sql`(unixepoch() * 1000)`
89
+
})
90
+
.where('did', '=', followeeDid)
91
+
.execute()
92
+
}
93
+
})
94
+
}
95
+
96
+
/**
97
+
* Check if followerDid follows followeeDid.
98
+
*/
99
+
export async function isFollowing(
100
+
followerDid: string,
101
+
followeeDid: string
102
+
): Promise<boolean> {
103
+
const result = await db
104
+
.selectFrom('follows')
105
+
.select('follower_did')
106
+
.where('follower_did', '=', followerDid)
107
+
.where('followee_did', '=', followeeDid)
108
+
.executeTakeFirst()
109
+
110
+
return result !== undefined
111
+
}
112
+
113
+
/**
114
+
* Get the list of DIDs that follow the specified account.
115
+
* Returns DIDs only - profile enrichment should be done client-side via batch fetching.
116
+
*/
117
+
export async function getFollowers(
118
+
did: string,
119
+
limit: number = 50,
120
+
offset: number = 0
121
+
) {
122
+
return await db
123
+
.selectFrom('follows')
124
+
.select(['follower_did as did', 'created_at', 'uri'])
125
+
.where('followee_did', '=', did)
126
+
.orderBy('created_at', 'desc')
127
+
.limit(limit)
128
+
.offset(offset)
129
+
.execute()
130
+
}
131
+
132
+
/**
133
+
* Get the list of DIDs that the specified account follows.
134
+
* Returns DIDs only - profile enrichment should be done client-side via batch fetching.
135
+
*/
136
+
export async function getFollowing(
137
+
did: string,
138
+
limit: number = 50,
139
+
offset: number = 0
140
+
) {
141
+
return await db
142
+
.selectFrom('follows')
143
+
.select(['followee_did as did', 'created_at', 'uri'])
144
+
.where('follower_did', '=', did)
145
+
.orderBy('created_at', 'desc')
146
+
.limit(limit)
147
+
.offset(offset)
148
+
.execute()
149
+
}
150
+
151
+
/**
152
+
* Get follower and following counts for an account.
153
+
*/
154
+
export async function getFollowCounts(did: string) {
155
+
const counts = await db
156
+
.selectFrom('follow_counts')
157
+
.select(['follower_count', 'following_count'])
158
+
.where('did', '=', did)
159
+
.executeTakeFirst()
160
+
161
+
return {
162
+
followers: counts?.follower_count ?? 0,
163
+
following: counts?.following_count ?? 0
164
+
}
165
+
}
166
+
167
+
/**
168
+
* Get multiple accounts' follow counts in batch.
169
+
*/
170
+
export async function getFollowCountsBatch(dids: string[]) {
171
+
if (dids.length === 0) {
172
+
return []
173
+
}
174
+
175
+
const counts = await db
176
+
.selectFrom('follow_counts')
177
+
.select(['did', 'follower_count', 'following_count'])
178
+
.where('did', 'in', dids)
179
+
.execute()
180
+
181
+
// Return map for easy lookup
182
+
return counts
183
+
}
+183
packages/server/src/lib/profile.ts
+183
packages/server/src/lib/profile.ts
···
1
+
import { db } from '@api/db/db'
2
+
import type { Insertable } from 'kysely'
3
+
import type { Accounts, Profiles } from '@api/db/schema'
4
+
5
+
/**
6
+
* Ensure an account exists in the database.
7
+
* Creates the account if it doesn't exist, updates last_login_at if it does.
8
+
* This should be called on first interaction with any DID.
9
+
*/
10
+
export async function ensureAccount(did: string, handle: string): Promise<void> {
11
+
await db
12
+
.insertInto('accounts')
13
+
.values({
14
+
did,
15
+
handle,
16
+
active: 1, // SQLite stores booleans as 0/1
17
+
status: null
18
+
})
19
+
.onConflict((oc) =>
20
+
oc.column('did').doUpdateSet({
21
+
last_login_at: Date.now(),
22
+
handle // Update handle in case it changed
23
+
})
24
+
)
25
+
.execute()
26
+
}
27
+
28
+
/**
29
+
* Set or update wafrn-specific profile fields for an account.
30
+
* Creates profile if it doesn't exist, updates if it does.
31
+
*/
32
+
export async function setWafrnProfile(
33
+
did: string,
34
+
profile: {
35
+
html_bio?: string
36
+
server_origin?: string
37
+
custom_fields?: Record<string, string>
38
+
}
39
+
): Promise<void> {
40
+
await db
41
+
.insertInto('profiles')
42
+
.values({
43
+
did,
44
+
html_bio: profile.html_bio ?? null,
45
+
server_origin: profile.server_origin ?? null,
46
+
custom_fields: profile.custom_fields
47
+
? JSON.stringify(profile.custom_fields)
48
+
: null,
49
+
wafrn_updated_at: Date.now()
50
+
})
51
+
.onConflict((oc) =>
52
+
oc.column('did').doUpdateSet({
53
+
html_bio: profile.html_bio ?? null,
54
+
server_origin: profile.server_origin ?? null,
55
+
custom_fields: profile.custom_fields
56
+
? JSON.stringify(profile.custom_fields)
57
+
: null,
58
+
wafrn_updated_at: Date.now()
59
+
})
60
+
)
61
+
.execute()
62
+
}
63
+
64
+
/**
65
+
* Get wafrn-specific profiles for multiple DIDs in batch.
66
+
* Does not include cached standard profile data.
67
+
*/
68
+
export async function getWafrnProfiles(dids: string[]) {
69
+
if (dids.length === 0) {
70
+
return []
71
+
}
72
+
73
+
const profiles = await db
74
+
.selectFrom('profiles')
75
+
.select(['did', 'html_bio', 'server_origin', 'custom_fields'])
76
+
.where('did', 'in', dids)
77
+
.execute()
78
+
79
+
return profiles.map((p) => ({
80
+
did: p.did,
81
+
htmlBio: p.html_bio,
82
+
serverOrigin: p.server_origin,
83
+
customFields: p.custom_fields ? JSON.parse(p.custom_fields) : {}
84
+
}))
85
+
}
86
+
87
+
/**
88
+
* Cache standard profile data (from app.bsky.actor.profile) for faster queries.
89
+
* This is optional - used for performance optimization.
90
+
*/
91
+
export async function cacheStandardProfile(
92
+
did: string,
93
+
profile: {
94
+
display_name?: string
95
+
avatar_url?: string
96
+
description?: string
97
+
banner_url?: string
98
+
}
99
+
): Promise<void> {
100
+
await db
101
+
.insertInto('profiles')
102
+
.values({
103
+
did,
104
+
display_name: profile.display_name ?? null,
105
+
avatar_url: profile.avatar_url ?? null,
106
+
description: profile.description ?? null,
107
+
banner_url: profile.banner_url ?? null,
108
+
profile_cached_at: Date.now()
109
+
})
110
+
.onConflict((oc) =>
111
+
oc.column('did').doUpdateSet({
112
+
display_name: profile.display_name ?? null,
113
+
avatar_url: profile.avatar_url ?? null,
114
+
description: profile.description ?? null,
115
+
banner_url: profile.banner_url ?? null,
116
+
profile_cached_at: Date.now()
117
+
})
118
+
)
119
+
.execute()
120
+
}
121
+
122
+
/**
123
+
* Get profiles enriched with account operational status.
124
+
* Useful for moderation and admin interfaces.
125
+
*/
126
+
export async function getProfilesEnriched(dids: string[]) {
127
+
if (dids.length === 0) {
128
+
return []
129
+
}
130
+
131
+
const profiles = await db
132
+
.selectFrom('accounts')
133
+
.leftJoin('profiles', 'accounts.did', 'profiles.did')
134
+
.select([
135
+
'accounts.did',
136
+
'accounts.handle',
137
+
'accounts.role',
138
+
'accounts.active',
139
+
'accounts.status',
140
+
'profiles.html_bio',
141
+
'profiles.server_origin',
142
+
'profiles.custom_fields',
143
+
'profiles.display_name',
144
+
'profiles.avatar_url',
145
+
'profiles.description',
146
+
'profiles.profile_cached_at'
147
+
])
148
+
.where('accounts.did', 'in', dids)
149
+
.execute()
150
+
151
+
return profiles.map((p) => ({
152
+
did: p.did,
153
+
handle: p.handle,
154
+
role: p.role,
155
+
active: p.active === 1, // SQLite stores booleans as 0/1
156
+
status: p.status,
157
+
wafrn: {
158
+
htmlBio: p.html_bio,
159
+
serverOrigin: p.server_origin,
160
+
customFields: p.custom_fields ? JSON.parse(p.custom_fields) : {}
161
+
},
162
+
cached: p.profile_cached_at
163
+
? {
164
+
displayName: p.display_name,
165
+
avatarUrl: p.avatar_url,
166
+
description: p.description,
167
+
cachedAt: p.profile_cached_at
168
+
}
169
+
: null
170
+
}))
171
+
}
172
+
173
+
/**
174
+
* Check if a profile cache is fresh (within TTL).
175
+
* Default TTL: 24 hours
176
+
*/
177
+
export function isCacheFresh(
178
+
cachedAt: number | null,
179
+
ttlMs: number = 24 * 60 * 60 * 1000
180
+
): boolean {
181
+
if (!cachedAt) return false
182
+
return Date.now() - cachedAt < ttlMs
183
+
}
+128
-2
packages/server/src/lib/xrpcServer.ts
+128
-2
packages/server/src/lib/xrpcServer.ts
···
4
4
import {
5
5
AppWafrnContentCachePost,
6
6
AppWafrnContentDefs,
7
-
AppWafrnContentGetFeed
7
+
AppWafrnContentGetFeed,
8
+
AppWafrnGraphCacheFollow,
9
+
AppWafrnGraphDeleteFollow,
10
+
AppWafrnGraphGetFollowers,
11
+
AppWafrnGraphGetFollows,
12
+
AppWafrnActorGetProfiles
8
13
} from '@watproto/lexicon'
9
14
import { didDocResolver } from './idResolver'
10
15
import env from './env'
11
16
import { db } from '@api/db/db'
12
-
import { is, type ResourceUri } from '@atcute/lexicons'
17
+
import { is, type ResourceUri, type Did } from '@atcute/lexicons'
18
+
import {
19
+
createFollow,
20
+
deleteFollow,
21
+
getFollowCountsBatch,
22
+
getFollowers,
23
+
getFollowing
24
+
} from '@api/lib/follow'
25
+
import { getWafrnProfiles } from '@api/lib/profile'
13
26
14
27
const jwtVerifier = new ServiceJwtVerifier({
15
28
resolver: didDocResolver,
···
225
238
226
239
return json({
227
240
feed: posts
241
+
})
242
+
}
243
+
})
244
+
245
+
// ====================================
246
+
// FOLLOW ENDPOINTS
247
+
// ====================================
248
+
249
+
xrpcServer.add(AppWafrnGraphCacheFollow.mainSchema, {
250
+
async handler({ input, request }) {
251
+
const { did } = await authenticateJwt(request)
252
+
253
+
// Verify the follower matches the authenticated user
254
+
if (did !== input.follower) {
255
+
throw new XRPCError({
256
+
status: 403,
257
+
error: 'Forbidden',
258
+
description: 'You can only cache follows for your own account'
259
+
})
260
+
}
261
+
262
+
await createFollow(
263
+
input.follower,
264
+
input.followee,
265
+
input.uri,
266
+
new Date(input.createdAt).getTime()
267
+
)
268
+
269
+
return json({ indexed: true })
270
+
}
271
+
})
272
+
273
+
xrpcServer.add(AppWafrnGraphDeleteFollow.mainSchema, {
274
+
async handler({ input, request }) {
275
+
const { did } = await authenticateJwt(request)
276
+
277
+
// Verify the follower matches the authenticated user
278
+
if (did !== input.follower) {
279
+
throw new XRPCError({
280
+
status: 403,
281
+
error: 'Forbidden',
282
+
description: 'You can only delete follows for your own account'
283
+
})
284
+
}
285
+
286
+
await deleteFollow(input.follower, input.followee)
287
+
288
+
return json({ deleted: true })
289
+
}
290
+
})
291
+
292
+
xrpcServer.addQuery(AppWafrnGraphGetFollowers.mainSchema, {
293
+
async handler({ params }) {
294
+
const limit = params.limit ?? 50
295
+
const offset = params.cursor ? parseInt(params.cursor, 10) : 0
296
+
297
+
const followers = await getFollowers(params.actor, limit, offset)
298
+
299
+
return json({
300
+
cursor: followers.length === limit ? String(offset + limit) : undefined,
301
+
followers: followers.map((f) => ({
302
+
did: f.did as Did,
303
+
createdAt: new Date(f.created_at).toISOString(),
304
+
uri: f.uri as ResourceUri
305
+
}))
306
+
})
307
+
}
308
+
})
309
+
310
+
xrpcServer.addQuery(AppWafrnGraphGetFollows.mainSchema, {
311
+
async handler({ params }) {
312
+
const limit = params.limit ?? 50
313
+
const offset = params.cursor ? parseInt(params.cursor, 10) : 0
314
+
315
+
const follows = await getFollowing(params.actor, limit, offset)
316
+
317
+
return json({
318
+
cursor: follows.length === limit ? String(offset + limit) : undefined,
319
+
follows: follows.map((f) => ({
320
+
did: f.did as Did,
321
+
createdAt: new Date(f.created_at).toISOString(),
322
+
uri: f.uri as ResourceUri
323
+
}))
324
+
})
325
+
}
326
+
})
327
+
328
+
// ====================================
329
+
// PROFILE ENDPOINTS
330
+
// ====================================
331
+
332
+
xrpcServer.addQuery(AppWafrnActorGetProfiles.mainSchema, {
333
+
async handler({ params }) {
334
+
const [profiles, counts] = await Promise.all([
335
+
getWafrnProfiles(params.actors),
336
+
getFollowCountsBatch(params.actors)
337
+
])
338
+
const countMap = Object.fromEntries(
339
+
counts.map((count) => [count.did, count])
340
+
)
341
+
342
+
return json({
343
+
profiles: profiles.map((p) => ({
344
+
did: p.did as Did,
345
+
htmlBio: p.htmlBio ?? undefined,
346
+
followerCount: countMap[p.did]?.follower_count ?? 0,
347
+
followingCount: countMap[p.did]?.following_count ?? 0,
348
+
serverOrigin: p.serverOrigin ?? undefined,
349
+
customFields: Object.entries(p.customFields).map(([key, value]) => ({
350
+
key,
351
+
value: String(value)
352
+
}))
353
+
}))
228
354
})
229
355
}
230
356
})