cosmik.network
A social knowledge tool for researchers built on ATProto
can sort results reverse chronologically
+43
-26
src/modules/cards/tests/infrastructure/DrizzleCardQueryRepository.getLibrariesForUrl.integration.test.ts
+43
-26
src/modules/cards/tests/infrastructure/DrizzleCardQueryRepository.getLibrariesForUrl.integration.test.ts
···
15
15
import { CardSortField, SortOrder } from '../../domain/ICardQueryRepository';
16
16
import { createTestSchema } from '../test-utils/createTestSchema';
17
17
import { CardTypeEnum } from '../../domain/value-objects/CardType';
18
+
import { PublishedRecordId } from '../../domain/value-objects/PublishedRecordId';
18
19
19
20
describe('DrizzleCardQueryRepository - getLibrariesForUrl', () => {
20
21
let container: StartedPostgreSqlContainer;
···
296
297
.withUrl(url)
297
298
.buildOrThrow();
298
299
300
+
await new Promise((resolve) => setTimeout(resolve, 1000));
299
301
const card2 = new CardBuilder()
300
302
.withCuratorId(curator2.value)
301
303
.withType(CardTypeEnum.URL)
302
304
.withUrl(url)
303
305
.buildOrThrow();
304
306
307
+
await new Promise((resolve) => setTimeout(resolve, 1000));
305
308
const card3 = new CardBuilder()
306
309
.withCuratorId(curator3.value)
307
310
.withType(CardTypeEnum.URL)
···
314
317
315
318
// Save cards with slight delays to ensure different timestamps
316
319
await cardRepository.save(card1);
317
-
await new Promise(resolve => setTimeout(resolve, 10));
320
+
await new Promise((resolve) => setTimeout(resolve, 10));
318
321
await cardRepository.save(card2);
319
-
await new Promise(resolve => setTimeout(resolve, 10));
322
+
await new Promise((resolve) => setTimeout(resolve, 10));
320
323
await cardRepository.save(card3);
321
324
322
325
const result = await queryRepository.getLibrariesForUrl(testUrl, {
···
327
330
});
328
331
329
332
expect(result.items).toHaveLength(3);
330
-
333
+
331
334
// Should be sorted by creation time, newest first
332
-
const cardIds = result.items.map(lib => lib.card.id);
335
+
const cardIds = result.items.map((lib) => lib.card.id);
333
336
expect(cardIds[0]).toBe(card3.cardId.getStringValue()); // Most recent
334
337
expect(cardIds[1]).toBe(card2.cardId.getStringValue()); // Middle
335
338
expect(cardIds[2]).toBe(card1.cardId.getStringValue()); // Oldest
···
357
360
358
361
// Save cards with slight delay to ensure different timestamps
359
362
await cardRepository.save(card1);
360
-
await new Promise(resolve => setTimeout(resolve, 10));
363
+
await new Promise((resolve) => setTimeout(resolve, 10));
361
364
await cardRepository.save(card2);
362
365
363
366
const result = await queryRepository.getLibrariesForUrl(testUrl, {
···
368
371
});
369
372
370
373
expect(result.items).toHaveLength(2);
371
-
374
+
372
375
// Should be sorted by creation time, oldest first
373
-
const cardIds = result.items.map(lib => lib.card.id);
376
+
const cardIds = result.items.map((lib) => lib.card.id);
374
377
expect(cardIds[0]).toBe(card1.cardId.getStringValue()); // Oldest
375
378
expect(cardIds[1]).toBe(card2.cardId.getStringValue()); // Newest
376
379
});
···
400
403
await cardRepository.save(card2);
401
404
402
405
// Update card1 to have a more recent updatedAt
403
-
await new Promise(resolve => setTimeout(resolve, 10));
406
+
await new Promise((resolve) => setTimeout(resolve, 1000));
407
+
card1.markAsPublished(
408
+
PublishedRecordId.create({
409
+
uri: 'at://did:plc:publishedrecord1',
410
+
cid: 'bafyreicpublishedrecord1',
411
+
}),
412
+
);
404
413
await cardRepository.save(card1); // This should update the updatedAt timestamp
405
414
406
415
const result = await queryRepository.getLibrariesForUrl(testUrl, {
···
411
420
});
412
421
413
422
expect(result.items).toHaveLength(2);
414
-
423
+
415
424
// card1 should be first since it was updated more recently
416
-
const cardIds = result.items.map(lib => lib.card.id);
425
+
const cardIds = result.items.map((lib) => lib.card.id);
417
426
expect(cardIds[0]).toBe(card1.cardId.getStringValue()); // Most recently updated
418
427
expect(cardIds[1]).toBe(card2.cardId.getStringValue()); // Less recently updated
419
428
});
···
443
452
444
453
// Add cards to libraries with different counts
445
454
card1.addToLibrary(curator1);
446
-
455
+
447
456
card2.addToLibrary(curator2);
448
457
card2.addToLibrary(curator1); // card2 has 2 library memberships
449
-
458
+
450
459
card3.addToLibrary(curator3);
451
460
card3.addToLibrary(curator1); // card3 has 3 library memberships
452
461
card3.addToLibrary(curator2);
···
464
473
465
474
// Should return all library memberships, but sorted by the card's library count
466
475
expect(result.items.length).toBeGreaterThan(0);
467
-
476
+
468
477
// Group by card ID to check sorting
469
478
const cardGroups = new Map<string, any[]>();
470
-
result.items.forEach(item => {
479
+
result.items.forEach((item) => {
471
480
const cardId = item.card.id;
472
481
if (!cardGroups.has(cardId)) {
473
482
cardGroups.set(cardId, []);
···
476
485
});
477
486
478
487
// Get the first occurrence of each card to check library count ordering
479
-
const uniqueCards = Array.from(cardGroups.entries()).map(([cardId, items]) => ({
480
-
cardId,
481
-
libraryCount: items[0]!.card.libraryCount
482
-
}));
488
+
const uniqueCards = Array.from(cardGroups.entries()).map(
489
+
([cardId, items]) => ({
490
+
cardId,
491
+
libraryCount: items[0]!.card.libraryCount,
492
+
}),
493
+
);
483
494
484
495
// Should be sorted by library count descending
485
496
for (let i = 0; i < uniqueCards.length - 1; i++) {
486
-
expect(uniqueCards[i]!.libraryCount).toBeGreaterThanOrEqual(uniqueCards[i + 1]!.libraryCount);
497
+
expect(uniqueCards[i]!.libraryCount).toBeGreaterThanOrEqual(
498
+
uniqueCards[i + 1]!.libraryCount,
499
+
);
487
500
}
488
501
});
489
502
···
520
533
});
521
534
522
535
expect(result.items.length).toBeGreaterThan(0);
523
-
536
+
524
537
// Group by card ID and check ascending order
525
538
const cardGroups = new Map<string, any[]>();
526
-
result.items.forEach(item => {
539
+
result.items.forEach((item) => {
527
540
const cardId = item.card.id;
528
541
if (!cardGroups.has(cardId)) {
529
542
cardGroups.set(cardId, []);
···
531
544
cardGroups.get(cardId)!.push(item);
532
545
});
533
546
534
-
const uniqueCards = Array.from(cardGroups.entries()).map(([cardId, items]) => ({
535
-
cardId,
536
-
libraryCount: items[0]!.card.libraryCount
537
-
}));
547
+
const uniqueCards = Array.from(cardGroups.entries()).map(
548
+
([cardId, items]) => ({
549
+
cardId,
550
+
libraryCount: items[0]!.card.libraryCount,
551
+
}),
552
+
);
538
553
539
554
// Should be sorted by library count ascending
540
555
for (let i = 0; i < uniqueCards.length - 1; i++) {
541
-
expect(uniqueCards[i]!.libraryCount).toBeLessThanOrEqual(uniqueCards[i + 1]!.libraryCount);
556
+
expect(uniqueCards[i]!.libraryCount).toBeLessThanOrEqual(
557
+
uniqueCards[i + 1]!.libraryCount,
558
+
);
542
559
}
543
560
});
544
561
});