Something went wrong. Try again.
A social knowledge tool for research trails, built on ATProto semble.so
research-tool social-network tools-for-thought atproto
Something went wrong. Try again.
TypeScript
at main
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695import { GetUrlCardViewUseCase } from '../../application/useCases/queries/GetUrlCardViewUseCase';import { InMemoryCardQueryRepository } from '../utils/InMemoryCardQueryRepository';import { InMemoryCardRepository } from '../utils/InMemoryCardRepository';import { InMemoryCollectionRepository } from '../utils/InMemoryCollectionRepository';import { FakeProfileService } from '../utils/FakeProfileService';import { CuratorId } from '../../domain/value-objects/CuratorId';import { Card } from '../../domain/Card';import { CardType, CardTypeEnum } from '../../domain/value-objects/CardType';import { CardContent } from '../../domain/value-objects/CardContent';import { UrlMetadata } from '../../domain/value-objects/UrlMetadata';import { URL } from '../../domain/value-objects/URL';import { UniqueEntityID } from '../../../../shared/domain/UniqueEntityID';import { Collection, CollectionAccessType } from '../../domain/Collection';
describe('GetUrlCardViewUseCase', () => { let useCase: GetUrlCardViewUseCase; let cardQueryRepo: InMemoryCardQueryRepository; let cardRepo: InMemoryCardRepository; let collectionRepo: InMemoryCollectionRepository; let profileService: FakeProfileService; let curatorId: CuratorId; let otherCuratorId: CuratorId; let cardId: string;
beforeEach(() => { cardRepo = InMemoryCardRepository.getInstance(); collectionRepo = InMemoryCollectionRepository.getInstance(); cardQueryRepo = new InMemoryCardQueryRepository(cardRepo, collectionRepo); profileService = new FakeProfileService(); useCase = new GetUrlCardViewUseCase( cardQueryRepo, profileService, collectionRepo, );
curatorId = CuratorId.create('did:plc:testcurator').unwrap(); otherCuratorId = CuratorId.create('did:plc:othercurator').unwrap(); cardId = new UniqueEntityID().toString();
// Set up profiles for the curators profileService.addProfile({ id: curatorId.value, name: 'Test Curator', handle: 'testcurator', avatarUrl: 'https://example.com/avatar1.jpg', bio: 'Test curator bio', });
profileService.addProfile({ id: otherCuratorId.value, name: 'Other Curator', handle: 'othercurator', avatarUrl: 'https://example.com/avatar2.jpg', bio: 'Other curator bio', }); });
afterEach(() => { cardRepo.clear(); collectionRepo.clear(); cardQueryRepo.clear(); profileService.clear(); });
describe('Basic functionality', () => { it('should return URL card view with enriched library data', async () => { // Create URL metadata const urlMetadata = UrlMetadata.create({ url: 'https://example.com/article1', title: 'Test Article', description: 'Description of test article', author: 'John Doe', imageUrl: 'https://example.com/thumb1.jpg', }).unwrap();
// Create URL and card content const url = URL.create('https://example.com/article1').unwrap(); const cardType = CardType.create(CardTypeEnum.URL).unwrap(); const cardContent = CardContent.createUrlContent( url, urlMetadata, ).unwrap();
// Create card with library memberships const cardResult = Card.create( { curatorId: curatorId, type: cardType, content: cardContent, url: url, libraryMemberships: [ { curatorId: curatorId, addedAt: new Date('2023-01-01') }, ], libraryCount: 1, createdAt: new Date('2023-01-01'), updatedAt: new Date('2023-01-01'), }, new UniqueEntityID(cardId), );
if (cardResult.isErr()) { throw cardResult.error; }
const card = cardResult.value; await cardRepo.save(card);
// now create a note card that references this URL card const noteCardResult = Card.create({ curatorId: curatorId, type: CardType.create(CardTypeEnum.NOTE).unwrap(), content: CardContent.createNoteContent( 'This is my note about the article', ).unwrap(), parentCardId: card.cardId, url: url, });
const noteCard = noteCardResult.unwrap(); await cardRepo.save(noteCard);
const collectionResult = Collection.create({ name: 'Reading List', authorId: curatorId, accessType: CollectionAccessType.CLOSED, createdAt: new Date('2023-01-01'), updatedAt: new Date('2023-01-01'), collaboratorIds: [], }); if (collectionResult.isErr()) { throw collectionResult.error; } const collection = collectionResult.value; collection.addCard(card.cardId, curatorId); await collectionRepo.save(collection);
const query = { cardId: cardId, };
const result = await useCase.execute(query);
expect(result.isOk()).toBe(true); const response = result.unwrap();
// Verify basic card data expect(response.id).toBe(cardId); expect(response.type).toBe(CardTypeEnum.URL); expect(response.url).toBe('https://example.com/article1'); expect(response.cardContent.title).toBe('Test Article'); expect(response.cardContent.description).toBe( 'Description of test article', ); expect(response.cardContent.author).toBe('John Doe'); expect(response.cardContent.imageUrl).toBe( 'https://example.com/thumb1.jpg', ); expect(response.libraryCount).toBe(1);
// Verify collections expect(response.collections).toHaveLength(1); expect(response.collections[0]?.name).toBe('Reading List'); expect(response.collections[0]?.author.id).toBe(curatorId.value);
// Verify note expect(response.note).toBeDefined(); expect(response.note?.text).toBe('This is my note about the article');
// Verify enriched library data expect(response.libraries).toHaveLength(1);
const testCuratorLib = response.libraries.find( (lib) => lib.id === curatorId.value, ); expect(testCuratorLib).toBeDefined(); expect(testCuratorLib?.name).toBe('Test Curator'); expect(testCuratorLib?.handle).toBe('testcurator'); expect(testCuratorLib?.avatarUrl).toBe('https://example.com/avatar1.jpg'); });
it('should return URL card view with no libraries', async () => { // Create URL metadata const urlMetadata = UrlMetadata.create({ url: 'https://example.com/lonely-article', title: 'Lonely Article', description: 'An article with no libraries', }).unwrap();
// Create URL and card content const url = URL.create('https://example.com/lonely-article').unwrap(); const cardType = CardType.create(CardTypeEnum.URL).unwrap(); const cardContent = CardContent.createUrlContent( url, urlMetadata, ).unwrap();
// Create card with no library memberships const cardResult = Card.create( { curatorId: curatorId, type: cardType, content: cardContent, url: url, libraryMemberships: [], libraryCount: 0, createdAt: new Date('2023-01-01'), updatedAt: new Date('2023-01-01'), }, new UniqueEntityID(cardId), );
if (cardResult.isErr()) { throw cardResult.error; }
const card = cardResult.value; await cardRepo.save(card);
const query = { cardId: cardId, };
const result = await useCase.execute(query);
expect(result.isOk()).toBe(true); const response = result.unwrap(); expect(response.libraries).toHaveLength(0); expect(response.collections).toHaveLength(0); expect(response.note).toBeUndefined(); });
it('should return URL card view with minimal metadata', async () => { // Create URL with minimal metadata const url = URL.create('https://example.com/minimal').unwrap(); const cardType = CardType.create(CardTypeEnum.URL).unwrap(); const cardContent = CardContent.createUrlContent(url).unwrap();
// Create card with minimal data const cardResult = Card.create( { curatorId: curatorId, type: cardType, content: cardContent, url: url, libraryMemberships: [{ curatorId: curatorId, addedAt: new Date() }], libraryCount: 1, createdAt: new Date(), updatedAt: new Date(), }, new UniqueEntityID(cardId), );
if (cardResult.isErr()) { throw cardResult.error; }
const card = cardResult.value; await cardRepo.save(card);
const query = { cardId: cardId, };
const result = await useCase.execute(query);
expect(result.isOk()).toBe(true); const response = result.unwrap(); expect(response.cardContent.title).toBeUndefined(); expect(response.cardContent.description).toBeUndefined(); expect(response.cardContent.author).toBeUndefined(); expect(response.cardContent.imageUrl).toBeUndefined(); expect(response.libraries).toHaveLength(1); });
it('should handle profiles with minimal data', async () => { // Add a curator with minimal profile data const minimalCuratorId = CuratorId.create('did:plc:minimal').unwrap(); profileService.addProfile({ id: minimalCuratorId.value, name: 'Minimal User', handle: 'minimal', // No avatarUrl or bio });
// Create URL metadata const urlMetadata = UrlMetadata.create({ url: 'https://example.com/test', title: 'Test Article', }).unwrap();
// Create URL and card content const url = URL.create('https://example.com/test').unwrap(); const cardType = CardType.create(CardTypeEnum.URL).unwrap(); const cardContent = CardContent.createUrlContent( url, urlMetadata, ).unwrap();
// Create card const cardResult = Card.create( { curatorId: minimalCuratorId, type: cardType, content: cardContent, url: url, libraryMemberships: [ { curatorId: minimalCuratorId, addedAt: new Date() }, ], libraryCount: 1, createdAt: new Date(), updatedAt: new Date(), }, new UniqueEntityID(cardId), );
if (cardResult.isErr()) { throw cardResult.error; }
const card = cardResult.value; await cardRepo.save(card);
const query = { cardId: cardId, };
const result = await useCase.execute(query);
expect(result.isOk()).toBe(true); const response = result.unwrap(); expect(response.libraries).toHaveLength(1); expect(response.libraries[0]?.name).toBe('Minimal User'); expect(response.libraries[0]?.handle).toBe('minimal'); expect(response.libraries[0]?.avatarUrl).toBeUndefined(); }); });
describe('Error handling', () => { it('should fail with invalid card ID', async () => { const query = { cardId: 'invalid-card-id', };
const result = await useCase.execute(query);
expect(result.isErr()).toBe(true); if (result.isErr()) { expect(result.error.message).toContain('URL card not found'); } });
it('should fail when card not found', async () => { const nonExistentCardId = new UniqueEntityID().toString();
const query = { cardId: nonExistentCardId, };
const result = await useCase.execute(query);
expect(result.isErr()).toBe(true); if (result.isErr()) { expect(result.error.message).toContain('URL card not found'); } });
it('should fail when profile service fails', async () => { // Create URL metadata const urlMetadata = UrlMetadata.create({ url: 'https://example.com/test', title: 'Test Article', }).unwrap();
// Create URL and card content const url = URL.create('https://example.com/test').unwrap(); const cardType = CardType.create(CardTypeEnum.URL).unwrap(); const cardContent = CardContent.createUrlContent( url, urlMetadata, ).unwrap();
// Create card const cardResult = Card.create( { curatorId: curatorId, type: cardType, content: cardContent, url: url, libraryMemberships: [{ curatorId: curatorId, addedAt: new Date() }], libraryCount: 1, createdAt: new Date(), updatedAt: new Date(), }, new UniqueEntityID(cardId), );
if (cardResult.isErr()) { throw cardResult.error; }
const card = cardResult.value; await cardRepo.save(card);
// Make profile service fail profileService.setShouldFail(true);
const query = { cardId: cardId, };
const result = await useCase.execute(query);
expect(result.isErr()).toBe(true); if (result.isErr()) { expect(result.error.message).toContain('Failed to fetch card author'); } });
it('should fail when user profile not found', async () => { const unknownUserId = 'did:plc:unknown'; const unknownCuratorId = CuratorId.create(unknownUserId).unwrap();
// Create URL metadata const urlMetadata = UrlMetadata.create({ url: 'https://example.com/test', title: 'Test Article', }).unwrap();
// Create URL and card content const url = URL.create('https://example.com/test').unwrap(); const cardType = CardType.create(CardTypeEnum.URL).unwrap(); const cardContent = CardContent.createUrlContent( url, urlMetadata, ).unwrap();
// Create card with unknown user in library const cardResult = Card.create( { curatorId: unknownCuratorId, type: cardType, content: cardContent, url: url, libraryMemberships: [ { curatorId: unknownCuratorId, addedAt: new Date() }, ], libraryCount: 1, createdAt: new Date(), updatedAt: new Date(), }, new UniqueEntityID(cardId), );
if (cardResult.isErr()) { throw cardResult.error; }
const card = cardResult.value; await cardRepo.save(card);
const query = { cardId: cardId, };
const result = await useCase.execute(query);
expect(result.isErr()).toBe(true); if (result.isErr()) { expect(result.error.message).toContain('Failed to fetch card author'); } });
it('should handle repository errors gracefully', async () => { // Create a mock repository that throws an error const errorRepo = { getUrlCardsOfUser: jest.fn(), getCardsInCollection: jest.fn(), getUrlCardView: jest .fn() .mockRejectedValue(new Error('Database connection failed')), getUrlCardBasic: jest.fn(), getLibrariesForCard: jest.fn(), getLibrariesForUrl: jest.fn(), getNoteCardsForUrl: jest.fn(), getBatchUrlCardViews: jest.fn(), getBatchUrlLibraryInfo: jest.fn(), getBatchUrlStats: jest.fn(), getUsersForUrls: jest.fn(), getUrlsSavedByUser: jest.fn(), getBatchUserActivityStats: jest.fn(), searchUrls: jest.fn(), getProfileCardStats: jest.fn(), getBatchLatestCardCreatedAt: jest.fn(), };
const errorUseCase = new GetUrlCardViewUseCase( errorRepo, profileService, collectionRepo, );
const query = { cardId: cardId, };
const result = await errorUseCase.execute(query);
expect(result.isErr()).toBe(true); if (result.isErr()) { expect(result.error.message).toContain( 'Failed to retrieve URL card view', ); expect(result.error.message).toContain('Database connection failed'); } }); });
describe('Edge cases', () => { it('should handle card with many libraries', async () => { // Create multiple users const userIds: string[] = []; const curatorIds: CuratorId[] = []; for (let i = 1; i <= 5; i++) { const userId = `did:plc:user${i}`; const curatorId = CuratorId.create(userId).unwrap(); userIds.push(userId); curatorIds.push(curatorId); profileService.addProfile({ id: userId, name: `User ${i}`, handle: `user${i}`, avatarUrl: `https://example.com/avatar${i}.jpg`, }); }
// Create URL metadata const urlMetadata = UrlMetadata.create({ url: 'https://example.com/popular-article', title: 'Very Popular Article', }).unwrap();
// Create URL and card content const url = URL.create('https://example.com/popular-article').unwrap(); const cardType = CardType.create(CardTypeEnum.URL).unwrap(); const cardContent = CardContent.createUrlContent( url, urlMetadata, ).unwrap();
// Create card with single library membership (URL cards can only be in creator's library) const cardResult = Card.create( { curatorId: curatorIds[0]!, type: cardType, content: cardContent, url: url, libraryMemberships: [ { curatorId: curatorIds[0]!, addedAt: new Date(), }, ], libraryCount: 1, createdAt: new Date(), updatedAt: new Date(), }, new UniqueEntityID(cardId), );
if (cardResult.isErr()) { throw cardResult.error; }
const card = cardResult.value; await cardRepo.save(card);
const query = { cardId: cardId, };
const result = await useCase.execute(query);
expect(result.isOk()).toBe(true); const response = result.unwrap(); expect(response.libraries).toHaveLength(1);
// Verify the creator is included with correct profile data const creatorLib = response.libraries.find( (lib) => lib.id === userIds[0], ); expect(creatorLib).toBeDefined(); expect(creatorLib?.name).toBe('User 1'); expect(creatorLib?.handle).toBe('user1'); expect(creatorLib?.avatarUrl).toBe('https://example.com/avatar1.jpg'); });
it('should handle card with many collections', async () => { // Create URL metadata const urlMetadata = UrlMetadata.create({ url: 'https://example.com/well-organized', title: 'Well Organized Article', }).unwrap();
// Create URL and card content const url = URL.create('https://example.com/well-organized').unwrap(); const cardType = CardType.create(CardTypeEnum.URL).unwrap(); const cardContent = CardContent.createUrlContent( url, urlMetadata, ).unwrap();
// Create card const cardResult = Card.create( { curatorId: curatorId, type: cardType, content: cardContent, url: url, libraryMemberships: [{ curatorId: curatorId, addedAt: new Date() }], libraryCount: 1, createdAt: new Date(), updatedAt: new Date(), }, new UniqueEntityID(cardId), );
if (cardResult.isErr()) { throw cardResult.error; }
const card = cardResult.value; await cardRepo.save(card);
// Create multiple collections and add the card to them const collectionNames = ['Reading List', 'Favorites', 'Tech Articles'];
for (const collectionName of collectionNames) { const collectionResult = Collection.create({ name: collectionName, authorId: curatorId, accessType: CollectionAccessType.CLOSED, createdAt: new Date(), updatedAt: new Date(), collaboratorIds: [], });
if (collectionResult.isErr()) { throw collectionResult.error; }
const collection = collectionResult.value; collection.addCard(card.cardId, curatorId); await collectionRepo.save(collection); }
const query = { cardId: cardId, };
const result = await useCase.execute(query);
expect(result.isOk()).toBe(true); const response = result.unwrap(); expect(response.collections).toHaveLength(3);
const collectionNamesInResponse = response.collections .map((c) => c.name) .sort(); expect(collectionNamesInResponse).toEqual([ 'Favorites', 'Reading List', 'Tech Articles', ]);
// Verify all collections have the correct author response.collections.forEach((collection) => { expect(collection.author.id).toBe(curatorId.value); }); });
it('should handle empty card ID', async () => { const query = { cardId: '', };
const result = await useCase.execute(query);
expect(result.isErr()).toBe(true); if (result.isErr()) { expect(result.error.message).toContain('URL card not found'); } }); });});