106 lines
3.3 KiB
TypeScript
106 lines
3.3 KiB
TypeScript
import type { Driver } from '@gridpilot/racing/domain/entities/Driver';
|
|
import type { FeedItem } from '@gridpilot/social/domain/types/FeedItem';
|
|
import type { IFeedRepository } from '@gridpilot/social/domain/repositories/IFeedRepository';
|
|
import type { ISocialGraphRepository } from '@gridpilot/social/domain/repositories/ISocialGraphRepository';
|
|
|
|
export type Friendship = {
|
|
driverId: string;
|
|
friendId: string;
|
|
};
|
|
|
|
export type RacingSeedData = {
|
|
drivers: Driver[];
|
|
friendships: Friendship[];
|
|
feedEvents: FeedItem[];
|
|
};
|
|
|
|
export class InMemoryFeedRepository implements IFeedRepository {
|
|
private readonly feedEvents: FeedItem[];
|
|
private readonly friendships: Friendship[];
|
|
private readonly driversById: Map<string, Driver>;
|
|
|
|
constructor(seed: RacingSeedData) {
|
|
this.feedEvents = seed.feedEvents;
|
|
this.friendships = seed.friendships;
|
|
this.driversById = new Map(seed.drivers.map((d) => [d.id, d]));
|
|
}
|
|
|
|
async getFeedForDriver(driverId: string, limit?: number): Promise<FeedItem[]> {
|
|
const friendIds = new Set(
|
|
this.friendships
|
|
.filter((f) => f.driverId === driverId)
|
|
.map((f) => f.friendId),
|
|
);
|
|
|
|
const items = this.feedEvents.filter((item) => {
|
|
if (item.actorDriverId && friendIds.has(item.actorDriverId)) {
|
|
return true;
|
|
}
|
|
return false;
|
|
});
|
|
|
|
const sorted = items
|
|
.slice()
|
|
.sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime());
|
|
|
|
return typeof limit === 'number' ? sorted.slice(0, limit) : sorted;
|
|
}
|
|
|
|
async getGlobalFeed(limit?: number): Promise<FeedItem[]> {
|
|
const sorted = this.feedEvents
|
|
.slice()
|
|
.sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime());
|
|
|
|
return typeof limit === 'number' ? sorted.slice(0, limit) : sorted;
|
|
}
|
|
}
|
|
|
|
export class InMemorySocialGraphRepository implements ISocialGraphRepository {
|
|
private readonly friendships: Friendship[];
|
|
private readonly driversById: Map<string, Driver>;
|
|
|
|
constructor(seed: RacingSeedData) {
|
|
this.friendships = seed.friendships;
|
|
this.driversById = new Map(seed.drivers.map((d) => [d.id, d]));
|
|
}
|
|
|
|
async getFriendIds(driverId: string): Promise<string[]> {
|
|
return this.friendships
|
|
.filter((f) => f.driverId === driverId)
|
|
.map((f) => f.friendId);
|
|
}
|
|
|
|
async getFriends(driverId: string): Promise<Driver[]> {
|
|
const ids = await this.getFriendIds(driverId);
|
|
return ids
|
|
.map((id) => this.driversById.get(id))
|
|
.filter((d): d is Driver => Boolean(d));
|
|
}
|
|
|
|
async getSuggestedFriends(driverId: string, limit?: number): Promise<Driver[]> {
|
|
const directFriendIds = new Set(await this.getFriendIds(driverId));
|
|
const suggestions = new Map<string, number>();
|
|
|
|
for (const friendship of this.friendships) {
|
|
if (!directFriendIds.has(friendship.driverId)) continue;
|
|
const friendOfFriendId = friendship.friendId;
|
|
if (friendOfFriendId === driverId) continue;
|
|
if (directFriendIds.has(friendOfFriendId)) continue;
|
|
|
|
suggestions.set(friendOfFriendId, (suggestions.get(friendOfFriendId) ?? 0) + 1);
|
|
}
|
|
|
|
const rankedIds = Array.from(suggestions.entries())
|
|
.sort((a, b) => b[1] - a[1])
|
|
.map(([id]) => id);
|
|
|
|
const drivers = rankedIds
|
|
.map((id) => this.driversById.get(id))
|
|
.filter((d): d is Driver => Boolean(d));
|
|
|
|
if (typeof limit === 'number') {
|
|
return drivers.slice(0, limit);
|
|
}
|
|
return drivers;
|
|
}
|
|
} |