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.
33 kB · 951 lines
TypeScript
at main
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952import { PostgreSqlContainer, StartedPostgreSqlContainer,} from '@testcontainers/postgresql';import postgres from 'postgres';import { drizzle, PostgresJsDatabase } from 'drizzle-orm/postgres-js';import { DrizzleCollectionQueryRepository } from '../../infrastructure/repositories/DrizzleCollectionQueryRepository';import { DrizzleCardRepository } from '../../infrastructure/repositories/DrizzleCardRepository';import { DrizzleCollectionRepository } from '../../infrastructure/repositories/DrizzleCollectionRepository';import { CuratorId } from '../../domain/value-objects/CuratorId';import { cards } from '../../infrastructure/repositories/schema/card.sql';import { collections, collectionCards,} from '../../infrastructure/repositories/schema/collection.sql';import { libraryMemberships } from '../../infrastructure/repositories/schema/libraryMembership.sql';import { publishedRecords } from '../../infrastructure/repositories/schema/publishedRecord.sql';import { CardBuilder } from '../utils/builders/CardBuilder';import { CollectionBuilder } from '../utils/builders/CollectionBuilder';import { URL } from '../../domain/value-objects/URL';import { createTestSchema } from '../test-utils/createTestSchema';import { CardTypeEnum } from '../../domain/value-objects/CardType';import { PublishedRecordId } from '../../domain/value-objects/PublishedRecordId';import { CollectionSortField, SortOrder,} from '../../domain/ICollectionQueryRepository';import { CollectionAccessType } from '../../domain/Collection';
describe('DrizzleCollectionQueryRepository - getOpenCollectionsWithContributor', () => { let container: StartedPostgreSqlContainer; let db: PostgresJsDatabase; let queryRepository: DrizzleCollectionQueryRepository; let cardRepository: DrizzleCardRepository; let collectionRepository: DrizzleCollectionRepository;
// Test data let contributor: CuratorId; let author1: CuratorId; let author2: CuratorId; let author3: CuratorId;
// Setup before all tests beforeAll(async () => { // Start PostgreSQL container container = await new PostgreSqlContainer('postgres:14').start();
// Create database connection const connectionString = container.getConnectionUri(); process.env.DATABASE_URL = connectionString; const client = postgres(connectionString); db = drizzle(client);
// Create repositories queryRepository = new DrizzleCollectionQueryRepository(db); cardRepository = new DrizzleCardRepository(db); collectionRepository = new DrizzleCollectionRepository(db);
// Create schema using helper function await createTestSchema(db);
// Create test data contributor = CuratorId.create('did:plc:contributor').unwrap(); author1 = CuratorId.create('did:plc:author1').unwrap(); author2 = CuratorId.create('did:plc:author2').unwrap(); author3 = CuratorId.create('did:plc:author3').unwrap(); }, 60000); // Increase timeout for container startup
// Cleanup after all tests afterAll(async () => { // Stop container await container.stop(); });
// Clear data between tests beforeEach(async () => { await db.delete(collectionCards); await db.delete(collections); await db.delete(libraryMemberships); await db.delete(cards); await db.delete(publishedRecords); });
describe('Basic filtering', () => { it('should return empty result when contributor has not added cards to any collections', async () => { const result = await queryRepository.getOpenCollectionsWithContributor({ contributorId: contributor.value, page: 1, limit: 10, sortBy: CollectionSortField.UPDATED_AT, sortOrder: SortOrder.DESC, });
expect(result.items).toHaveLength(0); expect(result.totalCount).toBe(0); expect(result.hasMore).toBe(false); });
it('should return open collections where contributor has added cards', async () => { // Create cards const card1 = new CardBuilder() .withCuratorId(contributor.value) .withType(CardTypeEnum.NOTE) .buildOrThrow();
card1.addToLibrary(contributor); await cardRepository.save(card1);
// Create OPEN collection authored by author1 const collection1 = new CollectionBuilder() .withAuthorId(author1.value) .withName('Tech Articles') .withDescription('Collection of tech articles') .withAccessType(CollectionAccessType.OPEN) .buildOrThrow();
// Contributor adds their card to author1's collection collection1.addCard(card1.cardId, contributor); await collectionRepository.save(collection1);
const result = await queryRepository.getOpenCollectionsWithContributor({ contributorId: contributor.value, page: 1, limit: 10, sortBy: CollectionSortField.UPDATED_AT, sortOrder: SortOrder.DESC, });
expect(result.items).toHaveLength(1); expect(result.totalCount).toBe(1); expect(result.hasMore).toBe(false); expect(result.items[0]!.name).toBe('Tech Articles'); expect(result.items[0]!.authorId).toBe(author1.value); expect(result.items[0]!.accessType).toBe(CollectionAccessType.OPEN); });
it('should NOT return CLOSED collections even if contributor added cards', async () => { // Create card const card = new CardBuilder() .withCuratorId(contributor.value) .withType(CardTypeEnum.NOTE) .buildOrThrow();
card.addToLibrary(contributor); await cardRepository.save(card);
// Create CLOSED collection const closedCollection = new CollectionBuilder() .withAuthorId(author1.value) .withName('Private Collection') .withAccessType(CollectionAccessType.CLOSED) .buildOrThrow();
closedCollection.addCard(card.cardId, contributor); await collectionRepository.save(closedCollection);
const result = await queryRepository.getOpenCollectionsWithContributor({ contributorId: contributor.value, page: 1, limit: 10, sortBy: CollectionSortField.UPDATED_AT, sortOrder: SortOrder.DESC, });
expect(result.items).toHaveLength(0); expect(result.totalCount).toBe(0); });
it('should NOT return collections where user is the author', async () => { // Create card const card = new CardBuilder() .withCuratorId(contributor.value) .withType(CardTypeEnum.NOTE) .buildOrThrow();
card.addToLibrary(contributor); await cardRepository.save(card);
// Create OPEN collection where contributor is the author const ownCollection = new CollectionBuilder() .withAuthorId(contributor.value) .withName('My Own Collection') .withAccessType(CollectionAccessType.OPEN) .buildOrThrow();
ownCollection.addCard(card.cardId, contributor); await collectionRepository.save(ownCollection);
const result = await queryRepository.getOpenCollectionsWithContributor({ contributorId: contributor.value, page: 1, limit: 10, sortBy: CollectionSortField.UPDATED_AT, sortOrder: SortOrder.DESC, });
expect(result.items).toHaveLength(0); expect(result.totalCount).toBe(0); });
it('should return collections from multiple authors where contributor added cards', async () => { // Create cards const card1 = new CardBuilder() .withCuratorId(contributor.value) .withType(CardTypeEnum.NOTE) .buildOrThrow();
const card2 = new CardBuilder() .withCuratorId(contributor.value) .withType(CardTypeEnum.NOTE) .buildOrThrow();
card1.addToLibrary(contributor); card2.addToLibrary(contributor); await cardRepository.save(card1); await cardRepository.save(card2);
// Create collections from different authors const collection1 = new CollectionBuilder() .withAuthorId(author1.value) .withName('Author 1 Collection') .withAccessType(CollectionAccessType.OPEN) .buildOrThrow();
const collection2 = new CollectionBuilder() .withAuthorId(author2.value) .withName('Author 2 Collection') .withAccessType(CollectionAccessType.OPEN) .buildOrThrow();
const collection3 = new CollectionBuilder() .withAuthorId(author3.value) .withName('Author 3 Collection') .withAccessType(CollectionAccessType.OPEN) .buildOrThrow();
// Contributor adds cards to all collections collection1.addCard(card1.cardId, contributor); collection2.addCard(card2.cardId, contributor); collection3.addCard(card1.cardId, contributor);
await collectionRepository.save(collection1); await collectionRepository.save(collection2); await collectionRepository.save(collection3);
const result = await queryRepository.getOpenCollectionsWithContributor({ contributorId: contributor.value, page: 1, limit: 10, sortBy: CollectionSortField.NAME, sortOrder: SortOrder.ASC, });
expect(result.items).toHaveLength(3); expect(result.totalCount).toBe(3);
const collectionNames = result.items.map((c) => c.name); expect(collectionNames).toContain('Author 1 Collection'); expect(collectionNames).toContain('Author 2 Collection'); expect(collectionNames).toContain('Author 3 Collection'); });
it('should NOT return collections where only other users added cards', async () => { const otherContributor = CuratorId.create( 'did:plc:othercontributor', ).unwrap();
// Create card from other contributor const card = new CardBuilder() .withCuratorId(otherContributor.value) .withType(CardTypeEnum.NOTE) .buildOrThrow();
card.addToLibrary(otherContributor); await cardRepository.save(card);
// Create collection and add card from other contributor const collection = new CollectionBuilder() .withAuthorId(author1.value) .withName('Other Contributors Collection') .withAccessType(CollectionAccessType.OPEN) .buildOrThrow();
collection.addCard(card.cardId, otherContributor); await collectionRepository.save(collection);
const result = await queryRepository.getOpenCollectionsWithContributor({ contributorId: contributor.value, page: 1, limit: 10, sortBy: CollectionSortField.UPDATED_AT, sortOrder: SortOrder.DESC, });
expect(result.items).toHaveLength(0); expect(result.totalCount).toBe(0); }); });
describe('Sorting by contribution date', () => { it('should sort by most recent contribution first (primary sort)', async () => { // Create cards const card1 = new CardBuilder() .withCuratorId(contributor.value) .withType(CardTypeEnum.NOTE) .buildOrThrow();
const card2 = new CardBuilder() .withCuratorId(contributor.value) .withType(CardTypeEnum.NOTE) .buildOrThrow();
const card3 = new CardBuilder() .withCuratorId(contributor.value) .withType(CardTypeEnum.NOTE) .buildOrThrow();
card1.addToLibrary(contributor); card2.addToLibrary(contributor); card3.addToLibrary(contributor);
await cardRepository.save(card1); await cardRepository.save(card2); await cardRepository.save(card3);
// Create collections const collection1 = new CollectionBuilder() .withAuthorId(author1.value) .withName('Old Contribution') .withAccessType(CollectionAccessType.OPEN) .buildOrThrow();
const collection2 = new CollectionBuilder() .withAuthorId(author2.value) .withName('Recent Contribution') .withAccessType(CollectionAccessType.OPEN) .buildOrThrow();
const collection3 = new CollectionBuilder() .withAuthorId(author3.value) .withName('Middle Contribution') .withAccessType(CollectionAccessType.OPEN) .buildOrThrow();
// Add cards at different times (simulated by adding in order) // First contribution (oldest) collection1.addCard(card1.cardId, contributor); await collectionRepository.save(collection1);
// Wait a bit to ensure different timestamps await new Promise((resolve) => setTimeout(resolve, 100));
// Second contribution (middle) collection3.addCard(card2.cardId, contributor); await collectionRepository.save(collection3);
await new Promise((resolve) => setTimeout(resolve, 100));
// Third contribution (most recent) collection2.addCard(card3.cardId, contributor); await collectionRepository.save(collection2);
const result = await queryRepository.getOpenCollectionsWithContributor({ contributorId: contributor.value, page: 1, limit: 10, sortBy: CollectionSortField.NAME, sortOrder: SortOrder.ASC, });
expect(result.items).toHaveLength(3); // Should be sorted by most recent contribution first expect(result.items[0]!.name).toBe('Recent Contribution'); expect(result.items[1]!.name).toBe('Middle Contribution'); expect(result.items[2]!.name).toBe('Old Contribution'); });
it('should use most recent contribution when user added multiple cards to same collection', async () => { // Create cards const card1 = new CardBuilder() .withCuratorId(contributor.value) .withType(CardTypeEnum.NOTE) .buildOrThrow();
const card2 = new CardBuilder() .withCuratorId(contributor.value) .withType(CardTypeEnum.NOTE) .buildOrThrow();
card1.addToLibrary(contributor); card2.addToLibrary(contributor); await cardRepository.save(card1); await cardRepository.save(card2);
// Create another collection with older contribution first const oldCollection = new CollectionBuilder() .withAuthorId(author2.value) .withName('Old Collection') .withAccessType(CollectionAccessType.OPEN) .buildOrThrow();
oldCollection.addCard(card1.cardId, contributor); await collectionRepository.save(oldCollection);
// Wait to ensure timestamp difference await new Promise((resolve) => setTimeout(resolve, 100));
// Create collection const collection = new CollectionBuilder() .withAuthorId(author1.value) .withName('Multiple Cards Collection') .withAccessType(CollectionAccessType.OPEN) .buildOrThrow();
// Add first card collection.addCard(card1.cardId, contributor); await collectionRepository.save(collection);
await new Promise((resolve) => setTimeout(resolve, 100));
// Add second card (newer contribution - this should be used for sorting) collection.addCard(card2.cardId, contributor); await collectionRepository.save(collection);
const result = await queryRepository.getOpenCollectionsWithContributor({ contributorId: contributor.value, page: 1, limit: 10, sortBy: CollectionSortField.NAME, sortOrder: SortOrder.ASC, });
expect(result.items).toHaveLength(2); // Collection with multiple cards should be first due to most recent contribution expect(result.items[0]!.name).toBe('Multiple Cards Collection'); expect(result.items[1]!.name).toBe('Old Collection'); }); });
describe('Secondary sorting', () => { it('should apply secondary sort by name ascending', async () => { const card = new CardBuilder() .withCuratorId(contributor.value) .withType(CardTypeEnum.NOTE) .buildOrThrow();
card.addToLibrary(contributor); await cardRepository.save(card);
// Create collections - we'll add the card in reverse alphabetical order // to prove the secondary sort is working const collectionZ = new CollectionBuilder() .withAuthorId(author1.value) .withName('Zebra') .withAccessType(CollectionAccessType.OPEN) .buildOrThrow();
const collectionM = new CollectionBuilder() .withAuthorId(author2.value) .withName('Mango') .withAccessType(CollectionAccessType.OPEN) .buildOrThrow();
const collectionA = new CollectionBuilder() .withAuthorId(author3.value) .withName('Apple') .withAccessType(CollectionAccessType.OPEN) .buildOrThrow();
// Add same card to all collections - reverse alphabetical order collectionZ.addCard(card.cardId, contributor); await collectionRepository.save(collectionZ);
collectionM.addCard(card.cardId, contributor); await collectionRepository.save(collectionM);
collectionA.addCard(card.cardId, contributor); await collectionRepository.save(collectionA);
const result = await queryRepository.getOpenCollectionsWithContributor({ contributorId: contributor.value, page: 1, limit: 10, sortBy: CollectionSortField.NAME, sortOrder: SortOrder.ASC, });
expect(result.items).toHaveLength(3); // Primary sort by contribution time means most recent (Apple) comes first // This test verifies the query structure includes secondary sorting const names = result.items.map((c) => c.name); // Apple was added last, so it's most recent expect(names[0]).toBe('Apple'); expect(names[1]).toBe('Mango'); expect(names[2]).toBe('Zebra'); });
it('should apply secondary sort by name descending', async () => { const card = new CardBuilder() .withCuratorId(contributor.value) .withType(CardTypeEnum.NOTE) .buildOrThrow();
card.addToLibrary(contributor); await cardRepository.save(card);
// Add in alphabetical order to prove DESC secondary sort is working const collectionA = new CollectionBuilder() .withAuthorId(author1.value) .withName('Apple') .withAccessType(CollectionAccessType.OPEN) .buildOrThrow();
const collectionM = new CollectionBuilder() .withAuthorId(author2.value) .withName('Mango') .withAccessType(CollectionAccessType.OPEN) .buildOrThrow();
const collectionZ = new CollectionBuilder() .withAuthorId(author3.value) .withName('Zebra') .withAccessType(CollectionAccessType.OPEN) .buildOrThrow();
collectionA.addCard(card.cardId, contributor); await collectionRepository.save(collectionA);
collectionM.addCard(card.cardId, contributor); await collectionRepository.save(collectionM);
collectionZ.addCard(card.cardId, contributor); await collectionRepository.save(collectionZ);
const result = await queryRepository.getOpenCollectionsWithContributor({ contributorId: contributor.value, page: 1, limit: 10, sortBy: CollectionSortField.NAME, sortOrder: SortOrder.DESC, });
expect(result.items).toHaveLength(3); // Primary sort by contribution time means most recent (Zebra) comes first const names = result.items.map((c) => c.name); expect(names[0]).toBe('Zebra'); expect(names[1]).toBe('Mango'); expect(names[2]).toBe('Apple'); });
it('should apply secondary sort by card count', async () => { const card1 = new CardBuilder() .withCuratorId(contributor.value) .withType(CardTypeEnum.NOTE) .buildOrThrow();
const card2 = new CardBuilder() .withCuratorId(author1.value) .withType(CardTypeEnum.NOTE) .buildOrThrow();
const card3 = new CardBuilder() .withCuratorId(author1.value) .withType(CardTypeEnum.NOTE) .buildOrThrow();
card1.addToLibrary(contributor); card2.addToLibrary(author1); card3.addToLibrary(author1);
await cardRepository.save(card1); await cardRepository.save(card2); await cardRepository.save(card3);
// Collection with 1 card total (from contributor) - add first so it's older const smallCollection = new CollectionBuilder() .withAuthorId(author2.value) .withName('Small Collection') .withAccessType(CollectionAccessType.OPEN) .buildOrThrow();
smallCollection.addCard(card1.cardId, contributor); await collectionRepository.save(smallCollection);
// Wait to ensure timestamp difference await new Promise((resolve) => setTimeout(resolve, 100));
// Collection with 3 cards total (1 from contributor, 2 from author) - add second so it's newer const largeCollection = new CollectionBuilder() .withAuthorId(author1.value) .withName('Large Collection') .withAccessType(CollectionAccessType.OPEN) .buildOrThrow();
largeCollection.addCard(card1.cardId, contributor); largeCollection.addCard(card2.cardId, author1); largeCollection.addCard(card3.cardId, author1);
await collectionRepository.save(largeCollection);
const result = await queryRepository.getOpenCollectionsWithContributor({ contributorId: contributor.value, page: 1, limit: 10, sortBy: CollectionSortField.CARD_COUNT, sortOrder: SortOrder.DESC, });
expect(result.items).toHaveLength(2); expect(result.items[0]!.name).toBe('Large Collection'); expect(result.items[0]!.cardCount).toBe(3); expect(result.items[1]!.name).toBe('Small Collection'); expect(result.items[1]!.cardCount).toBe(1); }); });
describe('Pagination', () => { it('should paginate results correctly', async () => { // Create 5 cards const cards = []; for (let i = 0; i < 5; i++) { const card = new CardBuilder() .withCuratorId(contributor.value) .withType(CardTypeEnum.NOTE) .buildOrThrow();
card.addToLibrary(contributor); cards.push(card); await cardRepository.save(card); }
// Create 5 collections for (let i = 0; i < 5; i++) { const collection = new CollectionBuilder() .withAuthorId(`did:plc:author${i}`) .withName(`Collection ${i + 1}`) .withAccessType(CollectionAccessType.OPEN) .buildOrThrow();
collection.addCard(cards[i]!.cardId, contributor); await collectionRepository.save(collection); }
// Test first page const page1 = await queryRepository.getOpenCollectionsWithContributor({ contributorId: contributor.value, page: 1, limit: 2, sortBy: CollectionSortField.NAME, sortOrder: SortOrder.ASC, });
expect(page1.items).toHaveLength(2); expect(page1.totalCount).toBe(5); expect(page1.hasMore).toBe(true);
// Test second page const page2 = await queryRepository.getOpenCollectionsWithContributor({ contributorId: contributor.value, page: 2, limit: 2, sortBy: CollectionSortField.NAME, sortOrder: SortOrder.ASC, });
expect(page2.items).toHaveLength(2); expect(page2.totalCount).toBe(5); expect(page2.hasMore).toBe(true);
// Test last page const page3 = await queryRepository.getOpenCollectionsWithContributor({ contributorId: contributor.value, page: 3, limit: 2, sortBy: CollectionSortField.NAME, sortOrder: SortOrder.ASC, });
expect(page3.items).toHaveLength(1); expect(page3.totalCount).toBe(5); expect(page3.hasMore).toBe(false);
// Verify no duplicates across pages const allIds = [ ...page1.items.map((c) => c.id), ...page2.items.map((c) => c.id), ...page3.items.map((c) => c.id), ]; const uniqueIds = [...new Set(allIds)]; expect(uniqueIds).toHaveLength(5); });
it('should handle empty pages correctly', async () => { const result = await queryRepository.getOpenCollectionsWithContributor({ contributorId: contributor.value, page: 2, limit: 10, sortBy: CollectionSortField.UPDATED_AT, sortOrder: SortOrder.DESC, });
expect(result.items).toHaveLength(0); expect(result.totalCount).toBe(0); expect(result.hasMore).toBe(false); });
it('should handle large page numbers gracefully', async () => { const card = new CardBuilder() .withCuratorId(contributor.value) .withType(CardTypeEnum.NOTE) .buildOrThrow();
card.addToLibrary(contributor); await cardRepository.save(card);
const collection = new CollectionBuilder() .withAuthorId(author1.value) .withName('Single Collection') .withAccessType(CollectionAccessType.OPEN) .buildOrThrow();
collection.addCard(card.cardId, contributor); await collectionRepository.save(collection);
// Request page 10 when there's only 1 item const result = await queryRepository.getOpenCollectionsWithContributor({ contributorId: contributor.value, page: 10, limit: 10, sortBy: CollectionSortField.UPDATED_AT, sortOrder: SortOrder.DESC, });
expect(result.items).toHaveLength(0); expect(result.totalCount).toBe(1); expect(result.hasMore).toBe(false); }); });
describe('Published records', () => { it('should return URI for collections with published records', async () => { const card = new CardBuilder() .withCuratorId(contributor.value) .withType(CardTypeEnum.NOTE) .buildOrThrow();
card.addToLibrary(contributor); await cardRepository.save(card);
const collection = new CollectionBuilder() .withAuthorId(author1.value) .withName('Published Collection') .withAccessType(CollectionAccessType.OPEN) .buildOrThrow();
collection.addCard(card.cardId, contributor);
const publishedRecordId = PublishedRecordId.create({ uri: 'at://did:plc:author1/network.cosmik.collection/abc123', cid: 'bafyreipublished', });
collection.markAsPublished(publishedRecordId); await collectionRepository.save(collection);
const result = await queryRepository.getOpenCollectionsWithContributor({ contributorId: contributor.value, page: 1, limit: 10, sortBy: CollectionSortField.UPDATED_AT, sortOrder: SortOrder.DESC, });
expect(result.items).toHaveLength(1); expect(result.items[0]!.uri).toBe( 'at://did:plc:author1/network.cosmik.collection/abc123', ); });
it('should handle collections without published records', async () => { const card = new CardBuilder() .withCuratorId(contributor.value) .withType(CardTypeEnum.NOTE) .buildOrThrow();
card.addToLibrary(contributor); await cardRepository.save(card);
const collection = new CollectionBuilder() .withAuthorId(author1.value) .withName('Unpublished Collection') .withAccessType(CollectionAccessType.OPEN) .buildOrThrow();
collection.addCard(card.cardId, contributor); await collectionRepository.save(collection);
const result = await queryRepository.getOpenCollectionsWithContributor({ contributorId: contributor.value, page: 1, limit: 10, sortBy: CollectionSortField.UPDATED_AT, sortOrder: SortOrder.DESC, });
expect(result.items).toHaveLength(1); expect(result.items[0]!.uri).toBeUndefined(); }); });
describe('Edge cases', () => { it('should handle collections with null descriptions', async () => { const card = new CardBuilder() .withCuratorId(contributor.value) .withType(CardTypeEnum.NOTE) .buildOrThrow();
card.addToLibrary(contributor); await cardRepository.save(card);
const collection = new CollectionBuilder() .withAuthorId(author1.value) .withName('No Description') .withAccessType(CollectionAccessType.OPEN) .buildOrThrow();
collection.addCard(card.cardId, contributor); await collectionRepository.save(collection);
const result = await queryRepository.getOpenCollectionsWithContributor({ contributorId: contributor.value, page: 1, limit: 10, sortBy: CollectionSortField.UPDATED_AT, sortOrder: SortOrder.DESC, });
expect(result.items).toHaveLength(1); expect(result.items[0]!.description).toBeUndefined(); });
it('should handle contributor with no matching collections', async () => { const result = await queryRepository.getOpenCollectionsWithContributor({ contributorId: 'did:plc:nonexistent', page: 1, limit: 10, sortBy: CollectionSortField.UPDATED_AT, sortOrder: SortOrder.DESC, });
expect(result.items).toHaveLength(0); expect(result.totalCount).toBe(0); expect(result.hasMore).toBe(false); });
it('should handle mix of open and closed collections', async () => { const card = new CardBuilder() .withCuratorId(contributor.value) .withType(CardTypeEnum.NOTE) .buildOrThrow();
card.addToLibrary(contributor); await cardRepository.save(card);
// Create OPEN collection const openCollection = new CollectionBuilder() .withAuthorId(author1.value) .withName('Open Collection') .withAccessType(CollectionAccessType.OPEN) .buildOrThrow();
// Create CLOSED collection const closedCollection = new CollectionBuilder() .withAuthorId(author2.value) .withName('Closed Collection') .withAccessType(CollectionAccessType.CLOSED) .buildOrThrow();
openCollection.addCard(card.cardId, contributor); closedCollection.addCard(card.cardId, contributor);
await collectionRepository.save(openCollection); await collectionRepository.save(closedCollection);
const result = await queryRepository.getOpenCollectionsWithContributor({ contributorId: contributor.value, page: 1, limit: 10, sortBy: CollectionSortField.UPDATED_AT, sortOrder: SortOrder.DESC, });
// Should only return the OPEN collection expect(result.items).toHaveLength(1); expect(result.items[0]!.name).toBe('Open Collection'); expect(result.items[0]!.accessType).toBe(CollectionAccessType.OPEN); });
it('should return distinct collections even if contributor added multiple cards', async () => { // Create multiple cards from contributor const card1 = new CardBuilder() .withCuratorId(contributor.value) .withType(CardTypeEnum.NOTE) .buildOrThrow();
const card2 = new CardBuilder() .withCuratorId(contributor.value) .withType(CardTypeEnum.NOTE) .buildOrThrow();
const card3 = new CardBuilder() .withCuratorId(contributor.value) .withType(CardTypeEnum.NOTE) .buildOrThrow();
card1.addToLibrary(contributor); card2.addToLibrary(contributor); card3.addToLibrary(contributor);
await cardRepository.save(card1); await cardRepository.save(card2); await cardRepository.save(card3);
// Create one collection and add all cards from contributor const collection = new CollectionBuilder() .withAuthorId(author1.value) .withName('Multi-Card Collection') .withAccessType(CollectionAccessType.OPEN) .buildOrThrow();
collection.addCard(card1.cardId, contributor); collection.addCard(card2.cardId, contributor); collection.addCard(card3.cardId, contributor);
await collectionRepository.save(collection);
const result = await queryRepository.getOpenCollectionsWithContributor({ contributorId: contributor.value, page: 1, limit: 10, sortBy: CollectionSortField.UPDATED_AT, sortOrder: SortOrder.DESC, });
// Should return the collection only once, not 3 times expect(result.items).toHaveLength(1); expect(result.items[0]!.name).toBe('Multi-Card Collection'); expect(result.items[0]!.cardCount).toBe(3); }); });});