+1 -1

.vscode/settings.json

··· 1 1 { 2 2 "jest.runMode": "on-demand" 3 3 - } 3 3 + }

+5 -1

src/modules/cards/infrastructure/repositories/query-services/UrlCardQueryService.ts

··· 359 359 options: CardQueryOptions, 360 360 ): Promise<PaginatedQueryResult<LibraryForUrlDTO>> { 361 361 try { 362 362 - const { page, limit } = options; 362 362 + const { page, limit, sortBy, sortOrder } = options; 363 363 const offset = (page - 1) * limit; 364 364 + 365 365 + // Build the sort order 366 366 + const orderDirection = sortOrder === SortOrder.ASC ? asc : desc; 364 367 365 368 // Get all URL cards with this URL and their library memberships 366 369 const librariesQuery = this.db ··· 376 379 .from(libraryMemberships) 377 380 .innerJoin(cards, eq(libraryMemberships.cardId, cards.id)) 378 381 .where(and(eq(cards.url, url), eq(cards.type, CardTypeEnum.URL))) 382 382 + .orderBy(orderDirection(this.getSortColumn(sortBy))) 379 383 .limit(limit) 380 384 .offset(offset); 381 385

+276

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 18 + import { PublishedRecordId } from '../../domain/value-objects/PublishedRecordId'; 18 19 19 20 describe('DrizzleCardQueryRepository - getLibrariesForUrl', () => { 20 21 let container: StartedPostgreSqlContainer; ··· 281 282 // Should return empty since card is not in any library 282 283 expect(result.items).toHaveLength(0); 283 284 expect(result.totalCount).toBe(0); 285 285 + }); 286 286 + }); 287 287 + 288 288 + describe('sorting', () => { 289 289 + it('should sort by createdAt in descending order by default', async () => { 290 290 + const testUrl = 'https://example.com/sort-test'; 291 291 + const url = URL.create(testUrl).unwrap(); 292 292 + 293 293 + // Create cards with different creation times 294 294 + const card1 = new CardBuilder() 295 295 + .withCuratorId(curator1.value) 296 296 + .withType(CardTypeEnum.URL) 297 297 + .withUrl(url) 298 298 + .buildOrThrow(); 299 299 + 300 300 + await new Promise((resolve) => setTimeout(resolve, 1000)); 301 301 + const card2 = new CardBuilder() 302 302 + .withCuratorId(curator2.value) 303 303 + .withType(CardTypeEnum.URL) 304 304 + .withUrl(url) 305 305 + .buildOrThrow(); 306 306 + 307 307 + await new Promise((resolve) => setTimeout(resolve, 1000)); 308 308 + const card3 = new CardBuilder() 309 309 + .withCuratorId(curator3.value) 310 310 + .withType(CardTypeEnum.URL) 311 311 + .withUrl(url) 312 312 + .buildOrThrow(); 313 313 + 314 314 + card1.addToLibrary(curator1); 315 315 + card2.addToLibrary(curator2); 316 316 + card3.addToLibrary(curator3); 317 317 + 318 318 + // Save cards with slight delays to ensure different timestamps 319 319 + await cardRepository.save(card1); 320 320 + await new Promise((resolve) => setTimeout(resolve, 10)); 321 321 + await cardRepository.save(card2); 322 322 + await new Promise((resolve) => setTimeout(resolve, 10)); 323 323 + await cardRepository.save(card3); 324 324 + 325 325 + const result = await queryRepository.getLibrariesForUrl(testUrl, { 326 326 + page: 1, 327 327 + limit: 10, 328 328 + sortBy: CardSortField.CREATED_AT, 329 329 + sortOrder: SortOrder.DESC, 330 330 + }); 331 331 + 332 332 + expect(result.items).toHaveLength(3); 333 333 + 334 334 + // Should be sorted by creation time, newest first 335 335 + const cardIds = result.items.map((lib) => lib.card.id); 336 336 + expect(cardIds[0]).toBe(card3.cardId.getStringValue()); // Most recent 337 337 + expect(cardIds[1]).toBe(card2.cardId.getStringValue()); // Middle 338 338 + expect(cardIds[2]).toBe(card1.cardId.getStringValue()); // Oldest 339 339 + }); 340 340 + 341 341 + it('should sort by createdAt in ascending order when specified', async () => { 342 342 + const testUrl = 'https://example.com/sort-asc-test'; 343 343 + const url = URL.create(testUrl).unwrap(); 344 344 + 345 345 + // Create cards with different creation times 346 346 + const card1 = new CardBuilder() 347 347 + .withCuratorId(curator1.value) 348 348 + .withType(CardTypeEnum.URL) 349 349 + .withUrl(url) 350 350 + .buildOrThrow(); 351 351 + 352 352 + const card2 = new CardBuilder() 353 353 + .withCuratorId(curator2.value) 354 354 + .withType(CardTypeEnum.URL) 355 355 + .withUrl(url) 356 356 + .buildOrThrow(); 357 357 + 358 358 + card1.addToLibrary(curator1); 359 359 + card2.addToLibrary(curator2); 360 360 + 361 361 + // Save cards with slight delay to ensure different timestamps 362 362 + await cardRepository.save(card1); 363 363 + await new Promise((resolve) => setTimeout(resolve, 10)); 364 364 + await cardRepository.save(card2); 365 365 + 366 366 + const result = await queryRepository.getLibrariesForUrl(testUrl, { 367 367 + page: 1, 368 368 + limit: 10, 369 369 + sortBy: CardSortField.CREATED_AT, 370 370 + sortOrder: SortOrder.ASC, 371 371 + }); 372 372 + 373 373 + expect(result.items).toHaveLength(2); 374 374 + 375 375 + // Should be sorted by creation time, oldest first 376 376 + const cardIds = result.items.map((lib) => lib.card.id); 377 377 + expect(cardIds[0]).toBe(card1.cardId.getStringValue()); // Oldest 378 378 + expect(cardIds[1]).toBe(card2.cardId.getStringValue()); // Newest 379 379 + }); 380 380 + 381 381 + it('should sort by updatedAt in descending order', async () => { 382 382 + const testUrl = 'https://example.com/sort-updated-test'; 383 383 + const url = URL.create(testUrl).unwrap(); 384 384 + 385 385 + // Create cards 386 386 + const card1 = new CardBuilder() 387 387 + .withCuratorId(curator1.value) 388 388 + .withType(CardTypeEnum.URL) 389 389 + .withUrl(url) 390 390 + .buildOrThrow(); 391 391 + 392 392 + const card2 = new CardBuilder() 393 393 + .withCuratorId(curator2.value) 394 394 + .withType(CardTypeEnum.URL) 395 395 + .withUrl(url) 396 396 + .buildOrThrow(); 397 397 + 398 398 + card1.addToLibrary(curator1); 399 399 + card2.addToLibrary(curator2); 400 400 + 401 401 + // Save cards 402 402 + await cardRepository.save(card1); 403 403 + await cardRepository.save(card2); 404 404 + 405 405 + // Update card1 to have a more recent updatedAt 406 406 + await new Promise((resolve) => setTimeout(resolve, 1000)); 407 407 + card1.markAsPublished( 408 408 + PublishedRecordId.create({ 409 409 + uri: 'at://did:plc:publishedrecord1', 410 410 + cid: 'bafyreicpublishedrecord1', 411 411 + }), 412 412 + ); 413 413 + await cardRepository.save(card1); // This should update the updatedAt timestamp 414 414 + 415 415 + const result = await queryRepository.getLibrariesForUrl(testUrl, { 416 416 + page: 1, 417 417 + limit: 10, 418 418 + sortBy: CardSortField.UPDATED_AT, 419 419 + sortOrder: SortOrder.DESC, 420 420 + }); 421 421 + 422 422 + expect(result.items).toHaveLength(2); 423 423 + 424 424 + // card1 should be first since it was updated more recently 425 425 + const cardIds = result.items.map((lib) => lib.card.id); 426 426 + expect(cardIds[0]).toBe(card1.cardId.getStringValue()); // Most recently updated 427 427 + expect(cardIds[1]).toBe(card2.cardId.getStringValue()); // Less recently updated 428 428 + }); 429 429 + 430 430 + it('should sort by libraryCount in descending order', async () => { 431 431 + const testUrl = 'https://example.com/sort-library-count-test'; 432 432 + const url = URL.create(testUrl).unwrap(); 433 433 + 434 434 + // Create cards 435 435 + const card1 = new CardBuilder() 436 436 + .withCuratorId(curator1.value) 437 437 + .withType(CardTypeEnum.URL) 438 438 + .withUrl(url) 439 439 + .buildOrThrow(); 440 440 + 441 441 + const card2 = new CardBuilder() 442 442 + .withCuratorId(curator2.value) 443 443 + .withType(CardTypeEnum.URL) 444 444 + .withUrl(url) 445 445 + .buildOrThrow(); 446 446 + 447 447 + const card3 = new CardBuilder() 448 448 + .withCuratorId(curator3.value) 449 449 + .withType(CardTypeEnum.URL) 450 450 + .withUrl(url) 451 451 + .buildOrThrow(); 452 452 + 453 453 + // Add cards to libraries with different counts 454 454 + card1.addToLibrary(curator1); 455 455 + 456 456 + card2.addToLibrary(curator2); 457 457 + card2.addToLibrary(curator1); // card2 has 2 library memberships 458 458 + 459 459 + card3.addToLibrary(curator3); 460 460 + card3.addToLibrary(curator1); // card3 has 3 library memberships 461 461 + card3.addToLibrary(curator2); 462 462 + 463 463 + await cardRepository.save(card1); 464 464 + await cardRepository.save(card2); 465 465 + await cardRepository.save(card3); 466 466 + 467 467 + const result = await queryRepository.getLibrariesForUrl(testUrl, { 468 468 + page: 1, 469 469 + limit: 10, 470 470 + sortBy: CardSortField.LIBRARY_COUNT, 471 471 + sortOrder: SortOrder.DESC, 472 472 + }); 473 473 + 474 474 + // Should return all library memberships, but sorted by the card's library count 475 475 + expect(result.items.length).toBeGreaterThan(0); 476 476 + 477 477 + // Group by card ID to check sorting 478 478 + const cardGroups = new Map<string, any[]>(); 479 479 + result.items.forEach((item) => { 480 480 + const cardId = item.card.id; 481 481 + if (!cardGroups.has(cardId)) { 482 482 + cardGroups.set(cardId, []); 483 483 + } 484 484 + cardGroups.get(cardId)!.push(item); 485 485 + }); 486 486 + 487 487 + // Get the first occurrence of each card to check library count ordering 488 488 + const uniqueCards = Array.from(cardGroups.entries()).map( 489 489 + ([cardId, items]) => ({ 490 490 + cardId, 491 491 + libraryCount: items[0]!.card.libraryCount, 492 492 + }), 493 493 + ); 494 494 + 495 495 + // Should be sorted by library count descending 496 496 + for (let i = 0; i < uniqueCards.length - 1; i++) { 497 497 + expect(uniqueCards[i]!.libraryCount).toBeGreaterThanOrEqual( 498 498 + uniqueCards[i + 1]!.libraryCount, 499 499 + ); 500 500 + } 501 501 + }); 502 502 + 503 503 + it('should sort by libraryCount in ascending order when specified', async () => { 504 504 + const testUrl = 'https://example.com/sort-library-count-asc-test'; 505 505 + const url = URL.create(testUrl).unwrap(); 506 506 + 507 507 + // Create cards with different library counts 508 508 + const card1 = new CardBuilder() 509 509 + .withCuratorId(curator1.value) 510 510 + .withType(CardTypeEnum.URL) 511 511 + .withUrl(url) 512 512 + .buildOrThrow(); 513 513 + 514 514 + const card2 = new CardBuilder() 515 515 + .withCuratorId(curator2.value) 516 516 + .withType(CardTypeEnum.URL) 517 517 + .withUrl(url) 518 518 + .buildOrThrow(); 519 519 + 520 520 + // card1 has 1 library membership, card2 has 2 521 521 + card1.addToLibrary(curator1); 522 522 + card2.addToLibrary(curator2); 523 523 + card2.addToLibrary(curator1); 524 524 + 525 525 + await cardRepository.save(card1); 526 526 + await cardRepository.save(card2); 527 527 + 528 528 + const result = await queryRepository.getLibrariesForUrl(testUrl, { 529 529 + page: 1, 530 530 + limit: 10, 531 531 + sortBy: CardSortField.LIBRARY_COUNT, 532 532 + sortOrder: SortOrder.ASC, 533 533 + }); 534 534 + 535 535 + expect(result.items.length).toBeGreaterThan(0); 536 536 + 537 537 + // Group by card ID and check ascending order 538 538 + const cardGroups = new Map<string, any[]>(); 539 539 + result.items.forEach((item) => { 540 540 + const cardId = item.card.id; 541 541 + if (!cardGroups.has(cardId)) { 542 542 + cardGroups.set(cardId, []); 543 543 + } 544 544 + cardGroups.get(cardId)!.push(item); 545 545 + }); 546 546 + 547 547 + const uniqueCards = Array.from(cardGroups.entries()).map( 548 548 + ([cardId, items]) => ({ 549 549 + cardId, 550 550 + libraryCount: items[0]!.card.libraryCount, 551 551 + }), 552 552 + ); 553 553 + 554 554 + // Should be sorted by library count ascending 555 555 + for (let i = 0; i < uniqueCards.length - 1; i++) { 556 556 + expect(uniqueCards[i]!.libraryCount).toBeLessThanOrEqual( 557 557 + uniqueCards[i + 1]!.libraryCount, 558 558 + ); 559 559 + } 284 560 }); 285 561 }); 286 562

-2

src/webapp/app/bookmarklet/page.tsx

··· 15 15 Anchor, 16 16 CopyButton, 17 17 } from '@mantine/core'; 18 18 - import { useState } from 'react'; 19 19 - import { BiInfoCircle } from 'react-icons/bi'; 20 18 import SembleLogo from '@/assets/semble-logo.svg'; 21 19 import Link from 'next/link'; 22 20