nandi.uk
This repository has no description
follow / unfollow feature implementation + notifications
author
Wesley Finck
date
(Feb 11, 2026, 6:48 PM -0800)
commit
0441cfc6
0441cfc6d788d5e58ee164a4ed51cf3e14ed3190
parent
fd2afcfb
fd2afcfb5f19e36cfae84f6ac79ceba70d67de16
+3212
-2
+29
src/modules/atproto/infrastructure/lexicon/lexicons.ts
+29
src/modules/atproto/infrastructure/lexicon/lexicons.ts
···
316
316
},
317
317
},
318
318
},
319
+
NetworkCosmikFollow: {
320
+
lexicon: 1,
321
+
id: 'network.cosmik.follow',
322
+
description: 'A record representing a follow relationship.',
323
+
defs: {
324
+
main: {
325
+
type: 'record',
326
+
description: 'A record representing a follow of a user or collection.',
327
+
key: 'tid',
328
+
record: {
329
+
type: 'object',
330
+
required: ['subject', 'createdAt'],
331
+
properties: {
332
+
subject: {
333
+
type: 'string',
334
+
description:
335
+
'DID of the user being followed, or AT URI of the collection being followed',
336
+
},
337
+
createdAt: {
338
+
type: 'string',
339
+
format: 'datetime',
340
+
description: 'Timestamp when this follow was created.',
341
+
},
342
+
},
343
+
},
344
+
},
345
+
},
346
+
},
319
347
ComAtprotoRepoStrongRef: {
320
348
lexicon: 1,
321
349
id: 'com.atproto.repo.strongRef',
···
963
991
NetworkCosmikCollectionLink: 'network.cosmik.collectionLink',
964
992
NetworkCosmikCollectionLinkRemoval: 'network.cosmik.collectionLinkRemoval',
965
993
NetworkCosmikDefs: 'network.cosmik.defs',
994
+
NetworkCosmikFollow: 'network.cosmik.follow',
966
995
ComAtprotoRepoStrongRef: 'com.atproto.repo.strongRef',
967
996
AtMarginAnnotation: 'at.margin.annotation',
968
997
AtMarginBookmark: 'at.margin.bookmark',
+34
src/modules/atproto/infrastructure/lexicon/types/network/cosmik/follow.ts
+34
src/modules/atproto/infrastructure/lexicon/types/network/cosmik/follow.ts
···
1
+
/**
2
+
* GENERATED CODE - DO NOT MODIFY
3
+
*/
4
+
import { type ValidationResult, BlobRef } from '@atproto/lexicon';
5
+
import { CID } from 'multiformats/cid';
6
+
import { validate as _validate } from '../../../lexicons';
7
+
import {
8
+
type $Typed,
9
+
is$typed as _is$typed,
10
+
type OmitKey,
11
+
} from '../../../util';
12
+
13
+
const is$typed = _is$typed,
14
+
validate = _validate;
15
+
const id = 'network.cosmik.follow';
16
+
17
+
export interface Record {
18
+
$type: 'network.cosmik.follow';
19
+
/** DID of the user being followed, or AT URI of the collection being followed */
20
+
subject: string;
21
+
/** Timestamp when this follow was created. */
22
+
createdAt: string;
23
+
[k: string]: unknown;
24
+
}
25
+
26
+
const hashRecord = 'main';
27
+
28
+
export function isRecord<V>(v: V) {
29
+
return is$typed(v, id, hashRecord);
30
+
}
31
+
32
+
export function validateRecord<V>(v: V) {
33
+
return validate<Record & V>(v, id, hashRecord, true);
34
+
}
+27
src/modules/atproto/infrastructure/lexicons/follow.json
+27
src/modules/atproto/infrastructure/lexicons/follow.json
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "network.cosmik.follow",
4
+
"description": "A record representing a follow relationship.",
5
+
"defs": {
6
+
"main": {
7
+
"type": "record",
8
+
"description": "A record representing a follow of a user or collection.",
9
+
"key": "tid",
10
+
"record": {
11
+
"type": "object",
12
+
"required": ["subject", "createdAt"],
13
+
"properties": {
14
+
"subject": {
15
+
"type": "string",
16
+
"description": "DID of the user being followed, or AT URI of the collection being followed"
17
+
},
18
+
"createdAt": {
19
+
"type": "string",
20
+
"format": "datetime",
21
+
"description": "Timestamp when this follow was created."
22
+
}
23
+
}
24
+
}
25
+
}
26
+
}
27
+
}
+178
src/modules/atproto/infrastructure/publishers/ATProtoFollowPublisher.ts
+178
src/modules/atproto/infrastructure/publishers/ATProtoFollowPublisher.ts
···
1
+
import { IFollowPublisher } from '../../../user/application/ports/IFollowPublisher';
2
+
import { Follow } from '../../../user/domain/Follow';
3
+
import { Result, ok, err } from '../../../../shared/core/Result';
4
+
import { UseCaseError } from '../../../../shared/core/UseCaseError';
5
+
import { PublishedRecordId } from '../../../cards/domain/value-objects/PublishedRecordId';
6
+
import { IAgentService } from '../../application/IAgentService';
7
+
import { DID } from '../../domain/DID';
8
+
import { ICollectionRepository } from '../../../cards/domain/ICollectionRepository';
9
+
import { CollectionId } from '../../../cards/domain/value-objects/CollectionId';
10
+
import { AuthenticationError } from '../../../../shared/core/AuthenticationError';
11
+
12
+
export class ATProtoFollowPublisher implements IFollowPublisher {
13
+
constructor(
14
+
private readonly agentService: IAgentService,
15
+
private readonly followCollection: string, // 'network.cosmik.follow'
16
+
private readonly collectionRepository: ICollectionRepository,
17
+
) {}
18
+
19
+
async publishFollow(
20
+
follow: Follow,
21
+
): Promise<Result<PublishedRecordId, UseCaseError>> {
22
+
try {
23
+
const followerDid = DID.create(follow.followerId.value);
24
+
if (followerDid.isErr()) {
25
+
return err(
26
+
new Error(`Invalid follower DID: ${followerDid.error.message}`),
27
+
);
28
+
}
29
+
30
+
const agentResult = await this.agentService.getAuthenticatedAgent(
31
+
followerDid.value,
32
+
);
33
+
34
+
if (agentResult.isErr()) {
35
+
// Propagate authentication errors as-is
36
+
if (agentResult.error instanceof AuthenticationError) {
37
+
return err(agentResult.error);
38
+
}
39
+
return err(
40
+
new Error(
41
+
`Failed to get authenticated agent: ${agentResult.error.message}`,
42
+
),
43
+
);
44
+
}
45
+
46
+
const agent = agentResult.value;
47
+
48
+
if (!agent) {
49
+
return err(new Error('No authenticated session found for follower'));
50
+
}
51
+
52
+
// Determine the subject based on target type
53
+
let subject: string;
54
+
if (follow.targetType.value === 'USER') {
55
+
// For user follows, subject is the DID
56
+
subject = follow.targetId;
57
+
} else {
58
+
// For collection follows, subject is the AT URI of the published collection
59
+
const collectionIdResult = CollectionId.createFromString(
60
+
follow.targetId,
61
+
);
62
+
if (collectionIdResult.isErr()) {
63
+
return err(
64
+
new Error(
65
+
`Invalid collection ID: ${collectionIdResult.error.message}`,
66
+
),
67
+
);
68
+
}
69
+
70
+
const collectionResult = await this.collectionRepository.findById(
71
+
collectionIdResult.value,
72
+
);
73
+
if (collectionResult.isErr()) {
74
+
return err(
75
+
new Error(
76
+
`Failed to find collection: ${collectionResult.error.message}`,
77
+
),
78
+
);
79
+
}
80
+
81
+
const collection = collectionResult.value;
82
+
if (!collection) {
83
+
return err(new Error('Collection not found'));
84
+
}
85
+
86
+
if (!collection.publishedRecordId) {
87
+
return err(
88
+
new Error('Collection must be published before it can be followed'),
89
+
);
90
+
}
91
+
92
+
// Use the AT URI of the published collection
93
+
subject = collection.publishedRecordId.uri;
94
+
}
95
+
96
+
const record = {
97
+
$type: this.followCollection,
98
+
subject: subject,
99
+
createdAt: follow.createdAt.toISOString(),
100
+
};
101
+
102
+
const createResult = await agent.com.atproto.repo.createRecord({
103
+
repo: follow.followerId.value,
104
+
collection: this.followCollection,
105
+
record,
106
+
});
107
+
108
+
const publishedRecordId = PublishedRecordId.create({
109
+
uri: createResult.data.uri,
110
+
cid: createResult.data.cid,
111
+
});
112
+
113
+
return ok(publishedRecordId);
114
+
} catch (error) {
115
+
return err(
116
+
new Error(
117
+
`Failed to publish follow: ${error instanceof Error ? error.message : 'Unknown error'}`,
118
+
),
119
+
);
120
+
}
121
+
}
122
+
123
+
async unpublishFollow(follow: Follow): Promise<Result<void, UseCaseError>> {
124
+
try {
125
+
if (!follow.publishedRecordId) {
126
+
// Already unpublished or never published
127
+
return ok(undefined);
128
+
}
129
+
130
+
const followerDid = DID.create(follow.followerId.value);
131
+
if (followerDid.isErr()) {
132
+
return err(
133
+
new Error(`Invalid follower DID: ${followerDid.error.message}`),
134
+
);
135
+
}
136
+
137
+
const agentResult = await this.agentService.getAuthenticatedAgent(
138
+
followerDid.value,
139
+
);
140
+
141
+
if (agentResult.isErr()) {
142
+
// Propagate authentication errors as-is
143
+
if (agentResult.error instanceof AuthenticationError) {
144
+
return err(agentResult.error);
145
+
}
146
+
return err(
147
+
new Error(
148
+
`Failed to get authenticated agent: ${agentResult.error.message}`,
149
+
),
150
+
);
151
+
}
152
+
153
+
const agent = agentResult.value;
154
+
155
+
if (!agent) {
156
+
return err(new Error('No authenticated session found for follower'));
157
+
}
158
+
159
+
// Extract rkey from AT URI (format: at://did/collection/rkey)
160
+
const uriParts = follow.publishedRecordId.uri.split('/');
161
+
const rkey = uriParts[uriParts.length - 1]!;
162
+
163
+
await agent.com.atproto.repo.deleteRecord({
164
+
repo: follow.followerId.value,
165
+
collection: this.followCollection,
166
+
rkey,
167
+
});
168
+
169
+
return ok(undefined);
170
+
} catch (error) {
171
+
return err(
172
+
new Error(
173
+
`Failed to unpublish follow: ${error instanceof Error ? error.message : 'Unknown error'}`,
174
+
),
175
+
);
176
+
}
177
+
}
178
+
}
+47
src/modules/atproto/infrastructure/publishers/FakeFollowPublisher.ts
+47
src/modules/atproto/infrastructure/publishers/FakeFollowPublisher.ts
···
1
+
import { IFollowPublisher } from '../../../user/application/ports/IFollowPublisher';
2
+
import { Follow } from '../../../user/domain/Follow';
3
+
import { Result, ok } from '../../../../shared/core/Result';
4
+
import { UseCaseError } from '../../../../shared/core/UseCaseError';
5
+
import { PublishedRecordId } from '../../../cards/domain/value-objects/PublishedRecordId';
6
+
7
+
export class FakeFollowPublisher implements IFollowPublisher {
8
+
private publishedFollows: Map<string, PublishedRecordId> = new Map();
9
+
10
+
async publishFollow(
11
+
follow: Follow,
12
+
): Promise<Result<PublishedRecordId, UseCaseError>> {
13
+
const key = `${follow.followerId.value}:${follow.targetId}`;
14
+
const fakeUri = `at://${follow.followerId.value}/network.cosmik.follow/${Date.now()}`;
15
+
const fakeCid = `fake-cid-${Date.now()}`;
16
+
17
+
const recordId = PublishedRecordId.create({
18
+
uri: fakeUri,
19
+
cid: fakeCid,
20
+
});
21
+
22
+
this.publishedFollows.set(key, recordId);
23
+
24
+
return ok(recordId);
25
+
}
26
+
27
+
async unpublishFollow(follow: Follow): Promise<Result<void, UseCaseError>> {
28
+
if (!follow.publishedRecordId) {
29
+
return ok(undefined);
30
+
}
31
+
32
+
// Find and remove from map
33
+
for (const [key, value] of this.publishedFollows.entries()) {
34
+
if (value.uri === follow.publishedRecordId.uri) {
35
+
this.publishedFollows.delete(key);
36
+
break;
37
+
}
38
+
}
39
+
40
+
return ok(undefined);
41
+
}
42
+
43
+
// Test helper
44
+
getPublishedFollows(): Map<string, PublishedRecordId> {
45
+
return this.publishedFollows;
46
+
}
47
+
}
+2
-1
src/modules/cards/tests/test-utils/createTestSchema.ts
+2
-1
src/modules/cards/tests/test-utils/createTestSchema.ts
···
110
110
updated_at TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT NOW()
111
111
)`,
112
112
113
-
// Follows table (no dependencies)
113
+
// Follows table (references published_records)
114
114
sql`CREATE TABLE IF NOT EXISTS follows (
115
115
follower_id TEXT NOT NULL,
116
116
target_id TEXT NOT NULL,
117
117
target_type TEXT NOT NULL,
118
+
published_record_id UUID REFERENCES published_records(id),
118
119
created_at TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT NOW(),
119
120
PRIMARY KEY (follower_id, target_id, target_type)
120
121
)`,
+111
src/modules/notifications/application/eventHandlers/UserFollowedTargetEventHandler.ts
+111
src/modules/notifications/application/eventHandlers/UserFollowedTargetEventHandler.ts
···
1
+
import { IEventHandler } from '../../../../shared/application/events/IEventSubscriber';
2
+
import { UserFollowedTargetEvent } from '../../../user/domain/events/UserFollowedTargetEvent';
3
+
import { Result, ok, err } from '../../../../shared/core/Result';
4
+
import { NotificationService } from '../../domain/services/NotificationService';
5
+
import { IUserRepository } from '../../../user/domain/repositories/IUserRepository';
6
+
import { ICollectionRepository } from '../../../cards/domain/ICollectionRepository';
7
+
import { CuratorId } from '../../../cards/domain/value-objects/CuratorId';
8
+
import { CollectionId } from '../../../cards/domain/value-objects/CollectionId';
9
+
10
+
export class UserFollowedTargetEventHandler
11
+
implements IEventHandler<UserFollowedTargetEvent>
12
+
{
13
+
constructor(
14
+
private notificationService: NotificationService,
15
+
private userRepository: IUserRepository,
16
+
private collectionRepository: ICollectionRepository,
17
+
) {}
18
+
19
+
async handle(event: UserFollowedTargetEvent): Promise<Result<void>> {
20
+
try {
21
+
const actorIdResult = CuratorId.create(event.followerId.value);
22
+
if (actorIdResult.isErr()) {
23
+
console.error('Invalid actor ID:', actorIdResult.error);
24
+
return err(actorIdResult.error);
25
+
}
26
+
const actorId = actorIdResult.value;
27
+
28
+
if (event.targetType.value === 'USER') {
29
+
// User followed another user - notify the followed user
30
+
const recipientIdResult = CuratorId.create(event.targetId);
31
+
if (recipientIdResult.isErr()) {
32
+
console.error('Invalid recipient ID:', recipientIdResult.error);
33
+
return err(recipientIdResult.error);
34
+
}
35
+
const recipientId = recipientIdResult.value;
36
+
37
+
// Skip if user is following themselves (shouldn't happen due to validation)
38
+
if (actorId.equals(recipientId)) {
39
+
return ok(undefined);
40
+
}
41
+
42
+
const notificationResult =
43
+
await this.notificationService.createUserFollowedYouNotification(
44
+
recipientId,
45
+
actorId,
46
+
);
47
+
48
+
if (notificationResult.isErr()) {
49
+
console.error(
50
+
'Failed to create user followed notification:',
51
+
notificationResult.error,
52
+
);
53
+
return err(notificationResult.error);
54
+
}
55
+
} else if (event.targetType.value === 'COLLECTION') {
56
+
// User followed a collection - notify the collection author
57
+
const collectionIdResult = CollectionId.createFromString(
58
+
event.targetId,
59
+
);
60
+
if (collectionIdResult.isErr()) {
61
+
console.error('Invalid collection ID:', collectionIdResult.error);
62
+
return err(collectionIdResult.error);
63
+
}
64
+
const collectionId = collectionIdResult.value;
65
+
66
+
const collectionResult =
67
+
await this.collectionRepository.findById(collectionId);
68
+
if (collectionResult.isErr()) {
69
+
console.error('Failed to find collection:', collectionResult.error);
70
+
return err(collectionResult.error);
71
+
}
72
+
73
+
const collection = collectionResult.value;
74
+
if (!collection) {
75
+
console.warn(
76
+
'Collection not found for notification:',
77
+
event.targetId,
78
+
);
79
+
return ok(undefined);
80
+
}
81
+
82
+
const recipientId = collection.authorId;
83
+
84
+
// Skip if user is following their own collection
85
+
if (actorId.equals(recipientId)) {
86
+
return ok(undefined);
87
+
}
88
+
89
+
const notificationResult =
90
+
await this.notificationService.createUserFollowedYourCollectionNotification(
91
+
recipientId,
92
+
actorId,
93
+
collectionId,
94
+
);
95
+
96
+
if (notificationResult.isErr()) {
97
+
console.error(
98
+
'Failed to create collection followed notification:',
99
+
notificationResult.error,
100
+
);
101
+
return err(notificationResult.error);
102
+
}
103
+
}
104
+
105
+
return ok(undefined);
106
+
} catch (error) {
107
+
console.error('Error handling UserFollowedTargetEvent:', error);
108
+
return err(error as Error);
109
+
}
110
+
}
111
+
}
+49
src/modules/notifications/domain/Notification.ts
+49
src/modules/notifications/domain/Notification.ts
···
12
12
collectionIds?: string[];
13
13
}
14
14
15
+
export interface FollowNotificationMetadata {
16
+
targetType: 'USER' | 'COLLECTION';
17
+
targetId?: string; // Collection ID if applicable
18
+
}
19
+
15
20
interface NotificationProps {
16
21
recipientUserId: CuratorId;
17
22
actorUserId: CuratorId;
···
124
129
actorUserId,
125
130
type: typeResult.value,
126
131
metadata,
132
+
});
133
+
}
134
+
135
+
public static createUserFollowedYou(
136
+
recipientUserId: CuratorId,
137
+
actorUserId: CuratorId,
138
+
): Result<Notification> {
139
+
const typeResult = NotificationType.userFollowedYou();
140
+
if (typeResult.isErr()) {
141
+
return err(typeResult.error);
142
+
}
143
+
144
+
const metadata: FollowNotificationMetadata = {
145
+
targetType: 'USER',
146
+
};
147
+
148
+
return this.create({
149
+
recipientUserId,
150
+
actorUserId,
151
+
type: typeResult.value,
152
+
metadata: metadata as any,
153
+
});
154
+
}
155
+
156
+
public static createUserFollowedYourCollection(
157
+
recipientUserId: CuratorId,
158
+
actorUserId: CuratorId,
159
+
collectionId: CollectionId,
160
+
): Result<Notification> {
161
+
const typeResult = NotificationType.userFollowedYourCollection();
162
+
if (typeResult.isErr()) {
163
+
return err(typeResult.error);
164
+
}
165
+
166
+
const metadata: FollowNotificationMetadata = {
167
+
targetType: 'COLLECTION',
168
+
targetId: collectionId.getStringValue(),
169
+
};
170
+
171
+
return this.create({
172
+
recipientUserId,
173
+
actorUserId,
174
+
type: typeResult.value,
175
+
metadata: metadata as any,
127
176
});
128
177
}
129
178
+94
src/modules/notifications/domain/services/NotificationService.ts
+94
src/modules/notifications/domain/services/NotificationService.ts
···
115
115
);
116
116
}
117
117
}
118
+
119
+
async createUserFollowedYouNotification(
120
+
recipientUserId: CuratorId,
121
+
actorUserId: CuratorId,
122
+
): Promise<Result<Notification, NotificationServiceError>> {
123
+
try {
124
+
// Don't create notification if user is following themselves (shouldn't happen)
125
+
if (recipientUserId.equals(actorUserId)) {
126
+
return err(
127
+
new NotificationServiceError(
128
+
'Cannot notify user about their own action',
129
+
),
130
+
);
131
+
}
132
+
133
+
const notificationResult = Notification.createUserFollowedYou(
134
+
recipientUserId,
135
+
actorUserId,
136
+
);
137
+
138
+
if (notificationResult.isErr()) {
139
+
return err(
140
+
new NotificationServiceError(notificationResult.error.message),
141
+
);
142
+
}
143
+
144
+
const notification = notificationResult.value;
145
+
const saveResult = await this.notificationRepository.save(notification);
146
+
147
+
if (saveResult.isErr()) {
148
+
return err(
149
+
new NotificationServiceError(
150
+
`Failed to save notification: ${saveResult.error.message}`,
151
+
),
152
+
);
153
+
}
154
+
155
+
return ok(notification);
156
+
} catch (error) {
157
+
return err(
158
+
new NotificationServiceError(
159
+
`Unexpected error: ${error instanceof Error ? error.message : 'Unknown error'}`,
160
+
),
161
+
);
162
+
}
163
+
}
164
+
165
+
async createUserFollowedYourCollectionNotification(
166
+
recipientUserId: CuratorId,
167
+
actorUserId: CuratorId,
168
+
collectionId: CollectionId,
169
+
): Promise<Result<Notification, NotificationServiceError>> {
170
+
try {
171
+
// Don't create notification if user is following their own collection
172
+
if (recipientUserId.equals(actorUserId)) {
173
+
return err(
174
+
new NotificationServiceError(
175
+
'Cannot notify user about their own action',
176
+
),
177
+
);
178
+
}
179
+
180
+
const notificationResult = Notification.createUserFollowedYourCollection(
181
+
recipientUserId,
182
+
actorUserId,
183
+
collectionId,
184
+
);
185
+
186
+
if (notificationResult.isErr()) {
187
+
return err(
188
+
new NotificationServiceError(notificationResult.error.message),
189
+
);
190
+
}
191
+
192
+
const notification = notificationResult.value;
193
+
const saveResult = await this.notificationRepository.save(notification);
194
+
195
+
if (saveResult.isErr()) {
196
+
return err(
197
+
new NotificationServiceError(
198
+
`Failed to save notification: ${saveResult.error.message}`,
199
+
),
200
+
);
201
+
}
202
+
203
+
return ok(notification);
204
+
} catch (error) {
205
+
return err(
206
+
new NotificationServiceError(
207
+
`Unexpected error: ${error instanceof Error ? error.message : 'Unknown error'}`,
208
+
),
209
+
);
210
+
}
211
+
}
118
212
}
+8
src/modules/notifications/domain/value-objects/NotificationType.ts
+8
src/modules/notifications/domain/value-objects/NotificationType.ts
···
37
37
public static userAddedToYourCollection(): Result<NotificationType> {
38
38
return this.create(NotificationTypeEnum.USER_ADDED_TO_YOUR_COLLECTION);
39
39
}
40
+
41
+
public static userFollowedYou(): Result<NotificationType> {
42
+
return this.create(NotificationTypeEnum.USER_FOLLOWED_YOU);
43
+
}
44
+
45
+
public static userFollowedYourCollection(): Result<NotificationType> {
46
+
return this.create(NotificationTypeEnum.USER_FOLLOWED_YOUR_COLLECTION);
47
+
}
40
48
}
+24
src/modules/user/application/ports/IFollowPublisher.ts
+24
src/modules/user/application/ports/IFollowPublisher.ts
···
1
+
import { Result } from '../../../../shared/core/Result';
2
+
import { UseCaseError } from '../../../../shared/core/UseCaseError';
3
+
import { Follow } from '../../domain/Follow';
4
+
import { PublishedRecordId } from '../../../cards/domain/value-objects/PublishedRecordId';
5
+
6
+
export interface IFollowPublisher {
7
+
/**
8
+
* Publish a follow relationship to AT Protocol.
9
+
*
10
+
* @param follow - The Follow domain object to publish
11
+
* @returns Published record ID (AT URI + CID)
12
+
*/
13
+
publishFollow(
14
+
follow: Follow,
15
+
): Promise<Result<PublishedRecordId, UseCaseError>>;
16
+
17
+
/**
18
+
* Unpublish (delete) a follow relationship from AT Protocol.
19
+
*
20
+
* @param follow - The Follow domain object with publishedRecordId to unpublish
21
+
* @returns Success or error
22
+
*/
23
+
unpublishFollow(follow: Follow): Promise<Result<void, UseCaseError>>;
24
+
}
+209
src/modules/user/application/useCases/commands/FollowTargetUseCase.ts
+209
src/modules/user/application/useCases/commands/FollowTargetUseCase.ts
···
1
+
import { Result, ok, err } from '../../../../../shared/core/Result';
2
+
import { BaseUseCase } from '../../../../../shared/core/UseCase';
3
+
import { UseCaseError } from '../../../../../shared/core/UseCaseError';
4
+
import { AppError } from '../../../../../shared/core/AppError';
5
+
import { IEventPublisher } from '../../../../../shared/application/events/IEventPublisher';
6
+
import { IFollowsRepository } from '../../../domain/repositories/IFollowsRepository';
7
+
import { IUserRepository } from '../../../domain/repositories/IUserRepository';
8
+
import { ICollectionRepository } from '../../../../cards/domain/ICollectionRepository';
9
+
import { IFollowPublisher } from '../../ports/IFollowPublisher';
10
+
import { DID } from '../../../domain/value-objects/DID';
11
+
import { FollowTargetType } from '../../../domain/value-objects/FollowTargetType';
12
+
import { Follow } from '../../../domain/Follow';
13
+
import { CollectionId } from '../../../../cards/domain/value-objects/CollectionId';
14
+
import { AuthenticationError } from '../../../../../shared/core/AuthenticationError';
15
+
16
+
export interface FollowTargetDTO {
17
+
followerId: string; // DID
18
+
targetId: string; // DID or Collection UUID
19
+
targetType: 'USER' | 'COLLECTION';
20
+
}
21
+
22
+
export interface FollowTargetResponseDTO {
23
+
followId: string;
24
+
}
25
+
26
+
export class ValidationError extends UseCaseError {
27
+
constructor(message: string) {
28
+
super(message);
29
+
}
30
+
}
31
+
32
+
export class FollowTargetUseCase extends BaseUseCase<
33
+
FollowTargetDTO,
34
+
Result<FollowTargetResponseDTO, ValidationError | AppError.UnexpectedError>
35
+
> {
36
+
constructor(
37
+
private followsRepository: IFollowsRepository,
38
+
private userRepository: IUserRepository,
39
+
private collectionRepository: ICollectionRepository,
40
+
private followPublisher: IFollowPublisher,
41
+
eventPublisher: IEventPublisher,
42
+
) {
43
+
super(eventPublisher);
44
+
}
45
+
46
+
async execute(
47
+
request: FollowTargetDTO,
48
+
): Promise<
49
+
Result<FollowTargetResponseDTO, ValidationError | AppError.UnexpectedError>
50
+
> {
51
+
try {
52
+
// 1. Validate followerId (create DID value object)
53
+
const followerDidResult = DID.create(request.followerId);
54
+
if (followerDidResult.isErr()) {
55
+
return err(
56
+
new ValidationError(
57
+
`Invalid follower ID: ${followerDidResult.error.message}`,
58
+
),
59
+
);
60
+
}
61
+
const followerDid = followerDidResult.value;
62
+
63
+
// 2. Validate targetType
64
+
const targetTypeResult = FollowTargetType.create(
65
+
request.targetType as any,
66
+
);
67
+
if (targetTypeResult.isErr()) {
68
+
return err(
69
+
new ValidationError(
70
+
`Invalid target type: ${targetTypeResult.error.message}`,
71
+
),
72
+
);
73
+
}
74
+
const targetType = targetTypeResult.value;
75
+
76
+
// 3. Prevent self-follows (only for USER type)
77
+
if (
78
+
targetType.value === 'USER' &&
79
+
request.followerId === request.targetId
80
+
) {
81
+
return err(new ValidationError('Users cannot follow themselves'));
82
+
}
83
+
84
+
// 4. Validate target exists
85
+
if (targetType.value === 'USER') {
86
+
const targetDidResult = DID.create(request.targetId);
87
+
if (targetDidResult.isErr()) {
88
+
return err(
89
+
new ValidationError(
90
+
`Invalid target ID: ${targetDidResult.error.message}`,
91
+
),
92
+
);
93
+
}
94
+
95
+
const userResult = await this.userRepository.findByDID(
96
+
targetDidResult.value,
97
+
);
98
+
if (userResult.isErr()) {
99
+
return err(AppError.UnexpectedError.create(userResult.error));
100
+
}
101
+
102
+
if (!userResult.value) {
103
+
return err(new ValidationError('Target user not found'));
104
+
}
105
+
} else if (targetType.value === 'COLLECTION') {
106
+
const collectionIdResult = CollectionId.createFromString(
107
+
request.targetId,
108
+
);
109
+
if (collectionIdResult.isErr()) {
110
+
return err(
111
+
new ValidationError(
112
+
`Invalid collection ID: ${collectionIdResult.error.message}`,
113
+
),
114
+
);
115
+
}
116
+
117
+
const collectionResult = await this.collectionRepository.findById(
118
+
collectionIdResult.value,
119
+
);
120
+
if (collectionResult.isErr()) {
121
+
return err(AppError.UnexpectedError.create(collectionResult.error));
122
+
}
123
+
124
+
if (!collectionResult.value) {
125
+
return err(new ValidationError('Target collection not found'));
126
+
}
127
+
}
128
+
129
+
// 5. Check if already following (idempotent)
130
+
const existingFollowResult =
131
+
await this.followsRepository.findByFollowerAndTarget(
132
+
request.followerId,
133
+
request.targetId,
134
+
targetType,
135
+
);
136
+
137
+
if (existingFollowResult.isErr()) {
138
+
return err(AppError.UnexpectedError.create(existingFollowResult.error));
139
+
}
140
+
141
+
if (existingFollowResult.value) {
142
+
// Already following - return success with existing follow ID
143
+
return ok({
144
+
followId: existingFollowResult.value.followId.toString(),
145
+
});
146
+
}
147
+
148
+
// 6. Create Follow aggregate (does NOT raise event yet)
149
+
const followResult = Follow.createNew(
150
+
followerDid,
151
+
request.targetId,
152
+
targetType,
153
+
);
154
+
155
+
if (followResult.isErr()) {
156
+
return err(new ValidationError(followResult.error.message));
157
+
}
158
+
159
+
let follow = followResult.value;
160
+
161
+
// 7. Publish to AT Protocol BEFORE saving
162
+
const publishResult = await this.followPublisher.publishFollow(follow);
163
+
164
+
if (publishResult.isErr()) {
165
+
// Propagate authentication errors
166
+
if (publishResult.error instanceof AuthenticationError) {
167
+
return err(publishResult.error);
168
+
}
169
+
if (publishResult.error instanceof AppError.UnexpectedError) {
170
+
return err(publishResult.error);
171
+
}
172
+
return err(new ValidationError(publishResult.error.message));
173
+
}
174
+
175
+
// 8. Mark follow as published with the returned publishedRecordId
176
+
const publishedRecordId = publishResult.value;
177
+
follow.markAsPublished(publishedRecordId);
178
+
179
+
// 9. Save to repository with publishedRecordId
180
+
const saveResult = await this.followsRepository.save(follow);
181
+
if (saveResult.isErr()) {
182
+
return err(AppError.UnexpectedError.create(saveResult.error));
183
+
}
184
+
185
+
// 10. Raise UserFollowedTargetEvent (now that publish succeeded)
186
+
const eventResult = follow.raiseFollowedEvent();
187
+
if (eventResult.isErr()) {
188
+
console.error('Failed to raise followed event:', eventResult.error);
189
+
}
190
+
191
+
// 11. Publish domain events
192
+
const publishEventsResult = await this.publishEventsForAggregate(follow);
193
+
if (publishEventsResult.isErr()) {
194
+
console.error(
195
+
'Failed to publish domain events:',
196
+
publishEventsResult.error,
197
+
);
198
+
// Don't fail the operation
199
+
}
200
+
201
+
// 12. Return success
202
+
return ok({
203
+
followId: follow.followId.toString(),
204
+
});
205
+
} catch (error) {
206
+
return err(AppError.UnexpectedError.create(error));
207
+
}
208
+
}
209
+
}
+128
src/modules/user/application/useCases/commands/UnfollowTargetUseCase.ts
+128
src/modules/user/application/useCases/commands/UnfollowTargetUseCase.ts
···
1
+
import { Result, ok, err } from '../../../../../shared/core/Result';
2
+
import { BaseUseCase } from '../../../../../shared/core/UseCase';
3
+
import { UseCaseError } from '../../../../../shared/core/UseCaseError';
4
+
import { AppError } from '../../../../../shared/core/AppError';
5
+
import { IEventPublisher } from '../../../../../shared/application/events/IEventPublisher';
6
+
import { IFollowsRepository } from '../../../domain/repositories/IFollowsRepository';
7
+
import { IFollowPublisher } from '../../ports/IFollowPublisher';
8
+
import { DID } from '../../../domain/value-objects/DID';
9
+
import { FollowTargetType } from '../../../domain/value-objects/FollowTargetType';
10
+
11
+
export interface UnfollowTargetDTO {
12
+
followerId: string; // DID
13
+
targetId: string; // DID or Collection UUID
14
+
targetType: 'USER' | 'COLLECTION';
15
+
}
16
+
17
+
export class ValidationError extends UseCaseError {
18
+
constructor(message: string) {
19
+
super(message);
20
+
}
21
+
}
22
+
23
+
export class UnfollowTargetUseCase extends BaseUseCase<
24
+
UnfollowTargetDTO,
25
+
Result<void, ValidationError | AppError.UnexpectedError>
26
+
> {
27
+
constructor(
28
+
private followsRepository: IFollowsRepository,
29
+
private followPublisher: IFollowPublisher,
30
+
eventPublisher: IEventPublisher,
31
+
) {
32
+
super(eventPublisher);
33
+
}
34
+
35
+
async execute(
36
+
request: UnfollowTargetDTO,
37
+
): Promise<Result<void, ValidationError | AppError.UnexpectedError>> {
38
+
try {
39
+
// 1. Validate followerId (create DID value object)
40
+
const followerDidResult = DID.create(request.followerId);
41
+
if (followerDidResult.isErr()) {
42
+
return err(
43
+
new ValidationError(
44
+
`Invalid follower ID: ${followerDidResult.error.message}`,
45
+
),
46
+
);
47
+
}
48
+
const followerDid = followerDidResult.value;
49
+
50
+
// 2. Validate targetType
51
+
const targetTypeResult = FollowTargetType.create(
52
+
request.targetType as any,
53
+
);
54
+
if (targetTypeResult.isErr()) {
55
+
return err(
56
+
new ValidationError(
57
+
`Invalid target type: ${targetTypeResult.error.message}`,
58
+
),
59
+
);
60
+
}
61
+
const targetType = targetTypeResult.value;
62
+
63
+
// 3. Find existing follow record
64
+
const existingFollowResult =
65
+
await this.followsRepository.findByFollowerAndTarget(
66
+
request.followerId,
67
+
request.targetId,
68
+
targetType,
69
+
);
70
+
71
+
if (existingFollowResult.isErr()) {
72
+
return err(AppError.UnexpectedError.create(existingFollowResult.error));
73
+
}
74
+
75
+
// 4. If not found, return success (idempotent)
76
+
if (!existingFollowResult.value) {
77
+
return ok(undefined);
78
+
}
79
+
80
+
const follow = existingFollowResult.value;
81
+
82
+
// 5. Unpublish from AT Protocol (if has publishedRecordId)
83
+
if (follow.publishedRecordId) {
84
+
const unpublishResult =
85
+
await this.followPublisher.unpublishFollow(follow);
86
+
if (unpublishResult.isErr()) {
87
+
// Log but don't fail - we still want to delete locally
88
+
console.error(
89
+
'Failed to unpublish follow from AT Protocol:',
90
+
unpublishResult.error,
91
+
);
92
+
}
93
+
}
94
+
95
+
// 6. Call markForRemoval() (raises UserUnfollowedTargetEvent)
96
+
const markResult = follow.markForRemoval();
97
+
if (markResult.isErr()) {
98
+
return err(new ValidationError(markResult.error.message));
99
+
}
100
+
101
+
// 7. Delete from repository
102
+
const deleteResult = await this.followsRepository.delete(
103
+
request.followerId,
104
+
request.targetId,
105
+
targetType,
106
+
);
107
+
108
+
if (deleteResult.isErr()) {
109
+
return err(AppError.UnexpectedError.create(deleteResult.error));
110
+
}
111
+
112
+
// 8. Publish domain events
113
+
const publishEventsResult = await this.publishEventsForAggregate(follow);
114
+
if (publishEventsResult.isErr()) {
115
+
console.error(
116
+
'Failed to publish domain events:',
117
+
publishEventsResult.error,
118
+
);
119
+
// Don't fail the operation
120
+
}
121
+
122
+
// 9. Return success
123
+
return ok(undefined);
124
+
} catch (error) {
125
+
return err(AppError.UnexpectedError.create(error));
126
+
}
127
+
}
128
+
}
+45
src/modules/user/domain/Follow.ts
+45
src/modules/user/domain/Follow.ts
···
4
4
import { err, ok, Result } from 'src/shared/core/Result';
5
5
import { DID } from './value-objects/DID';
6
6
import { FollowTargetType } from './value-objects/FollowTargetType';
7
+
import { PublishedRecordId } from '../../cards/domain/value-objects/PublishedRecordId';
8
+
import { UserUnfollowedTargetEvent } from './events/UserUnfollowedTargetEvent';
9
+
import { UserFollowedTargetEvent } from './events/UserFollowedTargetEvent';
7
10
8
11
export interface FollowProps {
9
12
followerId: DID;
10
13
targetId: string;
11
14
targetType: FollowTargetType;
15
+
publishedRecordId?: PublishedRecordId;
12
16
createdAt: Date;
13
17
}
14
18
···
31
35
32
36
get createdAt(): Date {
33
37
return this.props.createdAt;
38
+
}
39
+
40
+
get publishedRecordId(): PublishedRecordId | undefined {
41
+
return this.props.publishedRecordId;
42
+
}
43
+
44
+
public markAsPublished(publishedRecordId: PublishedRecordId): void {
45
+
this.props.publishedRecordId = publishedRecordId;
46
+
}
47
+
48
+
public markForRemoval(): Result<void> {
49
+
const event = UserUnfollowedTargetEvent.create(
50
+
this.followId,
51
+
this.followerId,
52
+
this.targetId,
53
+
this.targetType,
54
+
);
55
+
56
+
if (event.isErr()) {
57
+
return err(new Error(event.error.message));
58
+
}
59
+
60
+
this.addDomainEvent(event.value);
61
+
return ok(undefined);
62
+
}
63
+
64
+
public raiseFollowedEvent(): Result<void> {
65
+
const event = UserFollowedTargetEvent.create(
66
+
this.followId,
67
+
this.followerId,
68
+
this.targetId,
69
+
this.targetType,
70
+
this.createdAt,
71
+
);
72
+
73
+
if (event.isErr()) {
74
+
return err(new Error(event.error.message));
75
+
}
76
+
77
+
this.addDomainEvent(event.value);
78
+
return ok(undefined);
34
79
}
35
80
36
81
private constructor(props: FollowProps, id?: UniqueEntityID) {
+64
src/modules/user/domain/events/UserFollowedTargetEvent.ts
+64
src/modules/user/domain/events/UserFollowedTargetEvent.ts
···
1
+
import { IDomainEvent } from '../../../../shared/domain/events/IDomainEvent';
2
+
import { UniqueEntityID } from '../../../../shared/domain/UniqueEntityID';
3
+
import { DID } from '../value-objects/DID';
4
+
import { FollowTargetType } from '../value-objects/FollowTargetType';
5
+
import { EventNames } from '../../../../shared/infrastructure/events/EventConfig';
6
+
import { Result, ok } from '../../../../shared/core/Result';
7
+
8
+
export class UserFollowedTargetEvent implements IDomainEvent {
9
+
public readonly eventName = EventNames.USER_FOLLOWED_TARGET;
10
+
public readonly dateTimeOccurred: Date;
11
+
12
+
private constructor(
13
+
public readonly followId: UniqueEntityID,
14
+
public readonly followerId: DID,
15
+
public readonly targetId: string,
16
+
public readonly targetType: FollowTargetType,
17
+
public readonly createdAt: Date,
18
+
dateTimeOccurred?: Date,
19
+
) {
20
+
this.dateTimeOccurred = dateTimeOccurred || new Date();
21
+
}
22
+
23
+
public static create(
24
+
followId: UniqueEntityID,
25
+
followerId: DID,
26
+
targetId: string,
27
+
targetType: FollowTargetType,
28
+
createdAt: Date,
29
+
): Result<UserFollowedTargetEvent> {
30
+
return ok(
31
+
new UserFollowedTargetEvent(
32
+
followId,
33
+
followerId,
34
+
targetId,
35
+
targetType,
36
+
createdAt,
37
+
),
38
+
);
39
+
}
40
+
41
+
public static reconstruct(
42
+
followId: UniqueEntityID,
43
+
followerId: DID,
44
+
targetId: string,
45
+
targetType: FollowTargetType,
46
+
createdAt: Date,
47
+
dateTimeOccurred: Date,
48
+
): Result<UserFollowedTargetEvent> {
49
+
return ok(
50
+
new UserFollowedTargetEvent(
51
+
followId,
52
+
followerId,
53
+
targetId,
54
+
targetType,
55
+
createdAt,
56
+
dateTimeOccurred,
57
+
),
58
+
);
59
+
}
60
+
61
+
getAggregateId(): UniqueEntityID {
62
+
return this.followId;
63
+
}
64
+
}
+54
src/modules/user/domain/events/UserUnfollowedTargetEvent.ts
+54
src/modules/user/domain/events/UserUnfollowedTargetEvent.ts
···
1
+
import { IDomainEvent } from '../../../../shared/domain/events/IDomainEvent';
2
+
import { UniqueEntityID } from '../../../../shared/domain/UniqueEntityID';
3
+
import { DID } from '../value-objects/DID';
4
+
import { FollowTargetType } from '../value-objects/FollowTargetType';
5
+
import { EventNames } from '../../../../shared/infrastructure/events/EventConfig';
6
+
import { Result, ok } from '../../../../shared/core/Result';
7
+
8
+
export class UserUnfollowedTargetEvent implements IDomainEvent {
9
+
public readonly eventName = EventNames.USER_UNFOLLOWED_TARGET;
10
+
public readonly dateTimeOccurred: Date;
11
+
12
+
private constructor(
13
+
public readonly followId: UniqueEntityID,
14
+
public readonly followerId: DID,
15
+
public readonly targetId: string,
16
+
public readonly targetType: FollowTargetType,
17
+
dateTimeOccurred?: Date,
18
+
) {
19
+
this.dateTimeOccurred = dateTimeOccurred || new Date();
20
+
}
21
+
22
+
public static create(
23
+
followId: UniqueEntityID,
24
+
followerId: DID,
25
+
targetId: string,
26
+
targetType: FollowTargetType,
27
+
): Result<UserUnfollowedTargetEvent> {
28
+
return ok(
29
+
new UserUnfollowedTargetEvent(followId, followerId, targetId, targetType),
30
+
);
31
+
}
32
+
33
+
public static reconstruct(
34
+
followId: UniqueEntityID,
35
+
followerId: DID,
36
+
targetId: string,
37
+
targetType: FollowTargetType,
38
+
dateTimeOccurred: Date,
39
+
): Result<UserUnfollowedTargetEvent> {
40
+
return ok(
41
+
new UserUnfollowedTargetEvent(
42
+
followId,
43
+
followerId,
44
+
targetId,
45
+
targetType,
46
+
dateTimeOccurred,
47
+
),
48
+
);
49
+
}
50
+
51
+
getAggregateId(): UniqueEntityID {
52
+
return this.followId;
53
+
}
54
+
}
+40
src/modules/user/domain/repositories/IFollowsRepository.ts
+40
src/modules/user/domain/repositories/IFollowsRepository.ts
···
38
38
* (deduplication happens at use case level)
39
39
*/
40
40
getFollowersOfCollections(collectionIds: string[]): Promise<Result<Follow[]>>;
41
+
42
+
/**
43
+
* Save a follow relationship.
44
+
*
45
+
* @param follow - The follow entity to persist
46
+
* @returns Success or error
47
+
*
48
+
* Idempotency: Uses INSERT ON CONFLICT DO NOTHING on composite key
49
+
*/
50
+
save(follow: Follow): Promise<Result<void>>;
51
+
52
+
/**
53
+
* Delete a follow relationship.
54
+
*
55
+
* @param followerId - DID of the follower
56
+
* @param targetId - ID of the target (user DID or collection UUID)
57
+
* @param targetType - Type of target
58
+
* @returns Success or error
59
+
*
60
+
* Idempotency: Returns success even if follow doesn't exist
61
+
*/
62
+
delete(
63
+
followerId: string,
64
+
targetId: string,
65
+
targetType: FollowTargetType,
66
+
): Promise<Result<void>>;
67
+
68
+
/**
69
+
* Find a specific follow relationship.
70
+
*
71
+
* @param followerId - DID of the follower
72
+
* @param targetId - ID of the target
73
+
* @param targetType - Type of target
74
+
* @returns Follow entity or null if not found
75
+
*/
76
+
findByFollowerAndTarget(
77
+
followerId: string,
78
+
targetId: string,
79
+
targetType: FollowTargetType,
80
+
): Promise<Result<Follow | null>>;
41
81
}
+43
src/modules/user/infrastructure/http/controllers/FollowTargetController.ts
+43
src/modules/user/infrastructure/http/controllers/FollowTargetController.ts
···
1
+
import { Controller } from '../../../../../shared/infrastructure/http/Controller';
2
+
import { Response } from 'express';
3
+
import { FollowTargetUseCase } from '../../../application/useCases/commands/FollowTargetUseCase';
4
+
import { AuthenticatedRequest } from '../../../../../shared/infrastructure/http/middleware/AuthMiddleware';
5
+
import { AuthenticationError } from '../../../../../shared/core/AuthenticationError';
6
+
7
+
export class FollowTargetController extends Controller {
8
+
constructor(private followTargetUseCase: FollowTargetUseCase) {
9
+
super();
10
+
}
11
+
12
+
async executeImpl(req: AuthenticatedRequest, res: Response): Promise<any> {
13
+
try {
14
+
const { targetId, targetType } = req.body;
15
+
const followerId = req.did;
16
+
17
+
if (!followerId) {
18
+
return this.unauthorized(res);
19
+
}
20
+
21
+
if (!targetId || !targetType) {
22
+
return this.badRequest(res, 'Target ID and type are required');
23
+
}
24
+
25
+
const result = await this.followTargetUseCase.execute({
26
+
followerId,
27
+
targetId,
28
+
targetType,
29
+
});
30
+
31
+
if (result.isErr()) {
32
+
if (result.error instanceof AuthenticationError) {
33
+
return this.unauthorized(res, result.error.message);
34
+
}
35
+
return this.fail(res, result.error);
36
+
}
37
+
38
+
return this.ok(res, result.value);
39
+
} catch (error: any) {
40
+
return this.handleError(res, error);
41
+
}
42
+
}
43
+
}
+43
src/modules/user/infrastructure/http/controllers/UnfollowTargetController.ts
+43
src/modules/user/infrastructure/http/controllers/UnfollowTargetController.ts
···
1
+
import { Controller } from '../../../../../shared/infrastructure/http/Controller';
2
+
import { Response } from 'express';
3
+
import { UnfollowTargetUseCase } from '../../../application/useCases/commands/UnfollowTargetUseCase';
4
+
import { AuthenticatedRequest } from '../../../../../shared/infrastructure/http/middleware/AuthMiddleware';
5
+
import { AuthenticationError } from '../../../../../shared/core/AuthenticationError';
6
+
7
+
export class UnfollowTargetController extends Controller {
8
+
constructor(private unfollowTargetUseCase: UnfollowTargetUseCase) {
9
+
super();
10
+
}
11
+
12
+
async executeImpl(req: AuthenticatedRequest, res: Response): Promise<any> {
13
+
try {
14
+
const { targetId, targetType } = req.params;
15
+
const followerId = req.did;
16
+
17
+
if (!followerId) {
18
+
return this.unauthorized(res);
19
+
}
20
+
21
+
if (!targetId || !targetType) {
22
+
return this.badRequest(res, 'Target ID and type are required');
23
+
}
24
+
25
+
const result = await this.unfollowTargetUseCase.execute({
26
+
followerId,
27
+
targetId,
28
+
targetType: targetType as 'USER' | 'COLLECTION',
29
+
});
30
+
31
+
if (result.isErr()) {
32
+
if (result.error instanceof AuthenticationError) {
33
+
return this.unauthorized(res, result.error.message);
34
+
}
35
+
return this.fail(res, result.error);
36
+
}
37
+
38
+
return this.ok(res);
39
+
} catch (error: any) {
40
+
return this.handleError(res, error);
41
+
}
42
+
}
43
+
}
+15
src/modules/user/infrastructure/http/routes/userRoutes.ts
+15
src/modules/user/infrastructure/http/routes/userRoutes.ts
···
8
8
import { GetUserProfileController } from 'src/modules/cards/infrastructure/http/controllers/GetUserProfileController';
9
9
import { LogoutController } from '../controllers/LogoutController';
10
10
import { GenerateExtensionTokensController } from '../controllers/GenerateExtensionTokensController';
11
+
import { FollowTargetController } from '../controllers/FollowTargetController';
12
+
import { UnfollowTargetController } from '../controllers/UnfollowTargetController';
11
13
12
14
export const createUserRoutes = (
13
15
router: Router,
···
20
22
getUserProfileController: GetUserProfileController,
21
23
refreshAccessTokenController: RefreshAccessTokenController,
22
24
generateExtensionTokensController: GenerateExtensionTokensController,
25
+
followTargetController: FollowTargetController,
26
+
unfollowTargetController: UnfollowTargetController,
23
27
) => {
24
28
// Public routes
25
29
router.get('/login', (req, res) =>
···
50
54
'/extension/tokens',
51
55
authMiddleware.ensureAuthenticated(),
52
56
(req, res) => generateExtensionTokensController.execute(req, res),
57
+
);
58
+
59
+
// Follow/Unfollow routes
60
+
router.post('/follows', authMiddleware.ensureAuthenticated(), (req, res) =>
61
+
followTargetController.execute(req, res),
62
+
);
63
+
64
+
router.delete(
65
+
'/follows/:targetId/:targetType',
66
+
authMiddleware.ensureAuthenticated(),
67
+
(req, res) => unfollowTargetController.execute(req, res),
53
68
);
54
69
55
70
return router;
+149
src/modules/user/infrastructure/repositories/DrizzleFollowsRepository.ts
+149
src/modules/user/infrastructure/repositories/DrizzleFollowsRepository.ts
···
1
1
import { PostgresJsDatabase } from 'drizzle-orm/postgres-js';
2
2
import { eq, and, sql } from 'drizzle-orm';
3
+
import { randomUUID } from 'crypto';
3
4
import { IFollowsRepository } from '../../domain/repositories/IFollowsRepository';
4
5
import { Follow } from '../../domain/Follow';
5
6
import { DID } from '../../domain/value-objects/DID';
···
8
9
FollowTargetTypeEnum,
9
10
} from '../../domain/value-objects/FollowTargetType';
10
11
import { follows } from './schema/follows.sql';
12
+
import { publishedRecords } from '../../../cards/infrastructure/repositories/schema/publishedRecord.sql';
13
+
import { PublishedRecordId } from '../../../cards/domain/value-objects/PublishedRecordId';
11
14
import { UniqueEntityID } from 'src/shared/domain/UniqueEntityID';
12
15
import { err, ok, Result } from 'src/shared/core/Result';
13
16
···
140
143
return ok(followEntities);
141
144
} catch (error: any) {
142
145
return err(error);
146
+
}
147
+
}
148
+
149
+
async save(follow: Follow): Promise<Result<void>> {
150
+
try {
151
+
// Handle publishedRecordId persistence (similar to Card repository)
152
+
let publishedRecordIdUuid: string | undefined;
153
+
if (follow.publishedRecordId) {
154
+
const publishedRecordId = follow.publishedRecordId.getValue();
155
+
156
+
// Insert or get existing published record
157
+
const existingRecord = await this.db
158
+
.select()
159
+
.from(publishedRecords)
160
+
.where(
161
+
and(
162
+
eq(publishedRecords.uri, publishedRecordId.uri),
163
+
eq(publishedRecords.cid, publishedRecordId.cid),
164
+
),
165
+
)
166
+
.limit(1);
167
+
168
+
if (existingRecord.length > 0) {
169
+
publishedRecordIdUuid = existingRecord[0]!.id;
170
+
} else {
171
+
const insertResult = await this.db
172
+
.insert(publishedRecords)
173
+
.values({
174
+
id: randomUUID(),
175
+
uri: publishedRecordId.uri,
176
+
cid: publishedRecordId.cid,
177
+
})
178
+
.returning({ id: publishedRecords.id });
179
+
publishedRecordIdUuid = insertResult[0]!.id;
180
+
}
181
+
}
182
+
183
+
await this.db
184
+
.insert(follows)
185
+
.values({
186
+
followerId: follow.followerId.value,
187
+
targetId: follow.targetId,
188
+
targetType: follow.targetType.value,
189
+
publishedRecordId: publishedRecordIdUuid,
190
+
createdAt: follow.createdAt,
191
+
})
192
+
.onConflictDoUpdate({
193
+
target: [follows.followerId, follows.targetId, follows.targetType],
194
+
set: {
195
+
publishedRecordId: publishedRecordIdUuid,
196
+
},
197
+
});
198
+
199
+
return ok(undefined);
200
+
} catch (error) {
201
+
return err(error as Error);
202
+
}
203
+
}
204
+
205
+
async delete(
206
+
followerId: string,
207
+
targetId: string,
208
+
targetType: FollowTargetType,
209
+
): Promise<Result<void>> {
210
+
try {
211
+
await this.db
212
+
.delete(follows)
213
+
.where(
214
+
and(
215
+
eq(follows.followerId, followerId),
216
+
eq(follows.targetId, targetId),
217
+
eq(follows.targetType, targetType.value),
218
+
),
219
+
);
220
+
221
+
return ok(undefined);
222
+
} catch (error) {
223
+
return err(error as Error);
224
+
}
225
+
}
226
+
227
+
async findByFollowerAndTarget(
228
+
followerId: string,
229
+
targetId: string,
230
+
targetType: FollowTargetType,
231
+
): Promise<Result<Follow | null>> {
232
+
try {
233
+
const results = await this.db
234
+
.select({
235
+
follow: follows,
236
+
publishedRecord: publishedRecords,
237
+
})
238
+
.from(follows)
239
+
.leftJoin(
240
+
publishedRecords,
241
+
eq(follows.publishedRecordId, publishedRecords.id),
242
+
)
243
+
.where(
244
+
and(
245
+
eq(follows.followerId, followerId),
246
+
eq(follows.targetId, targetId),
247
+
eq(follows.targetType, targetType.value),
248
+
),
249
+
)
250
+
.limit(1);
251
+
252
+
if (results.length === 0) {
253
+
return ok(null);
254
+
}
255
+
256
+
const row = results[0]!;
257
+
const followerDid = DID.create(row.follow.followerId);
258
+
if (followerDid.isErr()) {
259
+
return err(followerDid.error);
260
+
}
261
+
262
+
const targetTypeVO = FollowTargetType.create(
263
+
row.follow.targetType as any,
264
+
);
265
+
if (targetTypeVO.isErr()) {
266
+
return err(targetTypeVO.error);
267
+
}
268
+
269
+
// Reconstruct publishedRecordId if present
270
+
let publishedRecordId: PublishedRecordId | undefined;
271
+
if (row.publishedRecord) {
272
+
publishedRecordId = PublishedRecordId.create({
273
+
uri: row.publishedRecord.uri,
274
+
cid: row.publishedRecord.cid,
275
+
});
276
+
}
277
+
278
+
return Follow.create(
279
+
{
280
+
followerId: followerDid.value,
281
+
targetId: row.follow.targetId,
282
+
targetType: targetTypeVO.value,
283
+
publishedRecordId,
284
+
createdAt: row.follow.createdAt,
285
+
},
286
+
new UniqueEntityID(
287
+
`${row.follow.followerId}:${row.follow.targetId}:${row.follow.targetType}`,
288
+
),
289
+
);
290
+
} catch (error) {
291
+
return err(error as Error);
143
292
}
144
293
}
145
294
}
+5
src/modules/user/infrastructure/repositories/schema/follows.sql.ts
+5
src/modules/user/infrastructure/repositories/schema/follows.sql.ts
···
4
4
timestamp,
5
5
primaryKey,
6
6
index,
7
+
uuid,
7
8
} from 'drizzle-orm/pg-core';
9
+
import { publishedRecords } from '../../../../cards/infrastructure/repositories/schema/publishedRecord.sql';
8
10
9
11
export const follows = pgTable(
10
12
'follows',
···
12
14
followerId: text('follower_id').notNull(),
13
15
targetId: text('target_id').notNull(),
14
16
targetType: text('target_type').notNull(),
17
+
publishedRecordId: uuid('published_record_id').references(
18
+
() => publishedRecords.id,
19
+
),
15
20
createdAt: timestamp('created_at').notNull().defaultNow(),
16
21
},
17
22
(table) => ({
+28
src/modules/user/tests/infrastructure/InMemoryFollowsRepository.ts
+28
src/modules/user/tests/infrastructure/InMemoryFollowsRepository.ts
···
77
77
}
78
78
}
79
79
80
+
async delete(
81
+
followerId: string,
82
+
targetId: string,
83
+
targetType: FollowTargetType,
84
+
): Promise<Result<void>> {
85
+
try {
86
+
const key = `${followerId}:${targetId}:${targetType.value}`;
87
+
this.follows.delete(key);
88
+
return ok(undefined);
89
+
} catch (error: any) {
90
+
return err(error);
91
+
}
92
+
}
93
+
94
+
async findByFollowerAndTarget(
95
+
followerId: string,
96
+
targetId: string,
97
+
targetType: FollowTargetType,
98
+
): Promise<Result<Follow | null>> {
99
+
try {
100
+
const key = `${followerId}:${targetId}:${targetType.value}`;
101
+
const follow = this.follows.get(key);
102
+
return ok(follow || null);
103
+
} catch (error: any) {
104
+
return err(error);
105
+
}
106
+
}
107
+
80
108
// Helper method for testing
81
109
clear(): void {
82
110
this.follows.clear();
+11
src/types/src/api/requests.ts
+11
src/types/src/api/requests.ts
···
241
241
export interface MarkNotificationsAsReadRequest {
242
242
notificationIds: string[];
243
243
}
244
+
245
+
// Follow request types
246
+
export interface FollowTargetRequest {
247
+
targetId: string; // DID or Collection UUID
248
+
targetType: 'USER' | 'COLLECTION';
249
+
}
250
+
251
+
export interface UnfollowTargetRequest {
252
+
targetId: string;
253
+
targetType: 'USER' | 'COLLECTION';
254
+
}
+7
src/types/src/api/responses.ts
+7
src/types/src/api/responses.ts
···
335
335
USER_ADDED_YOUR_BSKY_POST = 'USER_ADDED_YOUR_BSKY_POST',
336
336
USER_ADDED_YOUR_COLLECTION = 'USER_ADDED_YOUR_COLLECTION',
337
337
USER_ADDED_TO_YOUR_COLLECTION = 'USER_ADDED_TO_YOUR_COLLECTION',
338
+
USER_FOLLOWED_YOU = 'USER_FOLLOWED_YOU',
339
+
USER_FOLLOWED_YOUR_COLLECTION = 'USER_FOLLOWED_YOUR_COLLECTION',
338
340
}
339
341
340
342
export interface NotificationItem {
···
364
366
export interface MarkAllNotificationsAsReadResponse {
365
367
markedCount: number;
366
368
}
369
+
370
+
// Follow response types
371
+
export interface FollowTargetResponse {
372
+
followId: string;
373
+
}
+15
src/webapp/api-client/ApiClient.ts
+15
src/webapp/api-client/ApiClient.ts
···
82
82
GetGemActivityFeedParams,
83
83
SearchCollectionsParams,
84
84
GetOpenCollectionsWithContributorParams,
85
+
FollowTargetRequest,
86
+
FollowTargetResponse,
85
87
} from '@semble/types';
86
88
87
89
// Main API Client class using composition
···
324
326
325
327
async logout(): Promise<{ success: boolean; message: string }> {
326
328
return this.userClient.logout();
329
+
}
330
+
331
+
async followTarget(
332
+
request: FollowTargetRequest,
333
+
): Promise<FollowTargetResponse> {
334
+
return this.userClient.followTarget(request);
335
+
}
336
+
337
+
async unfollowTarget(
338
+
targetId: string,
339
+
targetType: 'USER' | 'COLLECTION',
340
+
): Promise<void> {
341
+
return this.userClient.unfollowTarget(targetId, targetType);
327
342
}
328
343
329
344
// Feed operations - delegate to FeedClient
+22
src/webapp/api-client/clients/UserClient.ts
+22
src/webapp/api-client/clients/UserClient.ts
···
10
10
CompleteOAuthSignInResponse,
11
11
RefreshAccessTokenResponse,
12
12
GenerateExtensionTokensResponse,
13
+
FollowTargetRequest,
14
+
FollowTargetResponse,
13
15
} from '@semble/types';
14
16
15
17
export class UserClient extends BaseClient {
···
75
77
return this.request<{ success: boolean; message: string }>(
76
78
'POST',
77
79
'/api/users/logout',
80
+
);
81
+
}
82
+
83
+
async followTarget(
84
+
request: FollowTargetRequest,
85
+
): Promise<FollowTargetResponse> {
86
+
return this.request<FollowTargetResponse>(
87
+
'POST',
88
+
'/api/users/follows',
89
+
request,
90
+
);
91
+
}
92
+
93
+
async unfollowTarget(
94
+
targetId: string,
95
+
targetType: 'USER' | 'COLLECTION',
96
+
): Promise<void> {
97
+
return this.request<void>(
98
+
'DELETE',
99
+
`/api/users/follows/${targetId}/${targetType}`,
78
100
);
79
101
}
80
102
}