Merge pull request #191 from cosmik-network/development

Development

.vscode/settings.json

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

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

···
     options: CardQueryOptions,
   ): Promise<PaginatedQueryResult<LibraryForUrlDTO>> {
     try {
-      const { page, limit } = options;
+      const { page, limit, sortBy, sortOrder } = options;
       const offset = (page - 1) * limit;
+
+      // Build the sort order
+      const orderDirection = sortOrder === SortOrder.ASC ? asc : desc;
 
       // Get all URL cards with this URL and their library memberships
       const librariesQuery = this.db
···
         .from(libraryMemberships)
         .innerJoin(cards, eq(libraryMemberships.cardId, cards.id))
         .where(and(eq(cards.url, url), eq(cards.type, CardTypeEnum.URL)))
+        .orderBy(orderDirection(this.getSortColumn(sortBy)))
         .limit(limit)
         .offset(offset);
 

src/modules/cards/tests/infrastructure/DrizzleCardQueryRepository.getLibrariesForUrl.integration.test.ts

···
 import { CardSortField, SortOrder } from '../../domain/ICardQueryRepository';
 import { createTestSchema } from '../test-utils/createTestSchema';
 import { CardTypeEnum } from '../../domain/value-objects/CardType';
+import { PublishedRecordId } from '../../domain/value-objects/PublishedRecordId';
 
 describe('DrizzleCardQueryRepository - getLibrariesForUrl', () => {
   let container: StartedPostgreSqlContainer;
···
       // Should return empty since card is not in any library
       expect(result.items).toHaveLength(0);
       expect(result.totalCount).toBe(0);
+    });
+  });
+
+  describe('sorting', () => {
+    it('should sort by createdAt in descending order by default', async () => {
+      const testUrl = 'https://example.com/sort-test';
+      const url = URL.create(testUrl).unwrap();
+
+      // Create cards with different creation times
+      const card1 = new CardBuilder()
+        .withCuratorId(curator1.value)
+        .withType(CardTypeEnum.URL)
+        .withUrl(url)
+        .buildOrThrow();
+
+      await new Promise((resolve) => setTimeout(resolve, 1000));
+      const card2 = new CardBuilder()
+        .withCuratorId(curator2.value)
+        .withType(CardTypeEnum.URL)
+        .withUrl(url)
+        .buildOrThrow();
+
+      await new Promise((resolve) => setTimeout(resolve, 1000));
+      const card3 = new CardBuilder()
+        .withCuratorId(curator3.value)
+        .withType(CardTypeEnum.URL)
+        .withUrl(url)
+        .buildOrThrow();
+
+      card1.addToLibrary(curator1);
+      card2.addToLibrary(curator2);
+      card3.addToLibrary(curator3);
+
+      // Save cards with slight delays to ensure different timestamps
+      await cardRepository.save(card1);
+      await new Promise((resolve) => setTimeout(resolve, 10));
+      await cardRepository.save(card2);
+      await new Promise((resolve) => setTimeout(resolve, 10));
+      await cardRepository.save(card3);
+
+      const result = await queryRepository.getLibrariesForUrl(testUrl, {
+        page: 1,
+        limit: 10,
+        sortBy: CardSortField.CREATED_AT,
+        sortOrder: SortOrder.DESC,
+      });
+
+      expect(result.items).toHaveLength(3);
+
+      // Should be sorted by creation time, newest first
+      const cardIds = result.items.map((lib) => lib.card.id);
+      expect(cardIds[0]).toBe(card3.cardId.getStringValue()); // Most recent
+      expect(cardIds[1]).toBe(card2.cardId.getStringValue()); // Middle
+      expect(cardIds[2]).toBe(card1.cardId.getStringValue()); // Oldest
+    });
+
+    it('should sort by createdAt in ascending order when specified', async () => {
+      const testUrl = 'https://example.com/sort-asc-test';
+      const url = URL.create(testUrl).unwrap();
+
+      // Create cards with different creation times
+      const card1 = new CardBuilder()
+        .withCuratorId(curator1.value)
+        .withType(CardTypeEnum.URL)
+        .withUrl(url)
+        .buildOrThrow();
+
+      const card2 = new CardBuilder()
+        .withCuratorId(curator2.value)
+        .withType(CardTypeEnum.URL)
+        .withUrl(url)
+        .buildOrThrow();
+
+      card1.addToLibrary(curator1);
+      card2.addToLibrary(curator2);
+
+      // Save cards with slight delay to ensure different timestamps
+      await cardRepository.save(card1);
+      await new Promise((resolve) => setTimeout(resolve, 10));
+      await cardRepository.save(card2);
+
+      const result = await queryRepository.getLibrariesForUrl(testUrl, {
+        page: 1,
+        limit: 10,
+        sortBy: CardSortField.CREATED_AT,
+        sortOrder: SortOrder.ASC,
+      });
+
+      expect(result.items).toHaveLength(2);
+
+      // Should be sorted by creation time, oldest first
+      const cardIds = result.items.map((lib) => lib.card.id);
+      expect(cardIds[0]).toBe(card1.cardId.getStringValue()); // Oldest
+      expect(cardIds[1]).toBe(card2.cardId.getStringValue()); // Newest
+    });
+
+    it('should sort by updatedAt in descending order', async () => {
+      const testUrl = 'https://example.com/sort-updated-test';
+      const url = URL.create(testUrl).unwrap();
+
+      // Create cards
+      const card1 = new CardBuilder()
+        .withCuratorId(curator1.value)
+        .withType(CardTypeEnum.URL)
+        .withUrl(url)
+        .buildOrThrow();
+
+      const card2 = new CardBuilder()
+        .withCuratorId(curator2.value)
+        .withType(CardTypeEnum.URL)
+        .withUrl(url)
+        .buildOrThrow();
+
+      card1.addToLibrary(curator1);
+      card2.addToLibrary(curator2);
+
+      // Save cards
+      await cardRepository.save(card1);
+      await cardRepository.save(card2);
+
+      // Update card1 to have a more recent updatedAt
+      await new Promise((resolve) => setTimeout(resolve, 1000));
+      card1.markAsPublished(
+        PublishedRecordId.create({
+          uri: 'at://did:plc:publishedrecord1',
+          cid: 'bafyreicpublishedrecord1',
+        }),
+      );
+      await cardRepository.save(card1); // This should update the updatedAt timestamp
+
+      const result = await queryRepository.getLibrariesForUrl(testUrl, {
+        page: 1,
+        limit: 10,
+        sortBy: CardSortField.UPDATED_AT,
+        sortOrder: SortOrder.DESC,
+      });
+
+      expect(result.items).toHaveLength(2);
+
+      // card1 should be first since it was updated more recently
+      const cardIds = result.items.map((lib) => lib.card.id);
+      expect(cardIds[0]).toBe(card1.cardId.getStringValue()); // Most recently updated
+      expect(cardIds[1]).toBe(card2.cardId.getStringValue()); // Less recently updated
+    });
+
+    it('should sort by libraryCount in descending order', async () => {
+      const testUrl = 'https://example.com/sort-library-count-test';
+      const url = URL.create(testUrl).unwrap();
+
+      // Create cards
+      const card1 = new CardBuilder()
+        .withCuratorId(curator1.value)
+        .withType(CardTypeEnum.URL)
+        .withUrl(url)
+        .buildOrThrow();
+
+      const card2 = new CardBuilder()
+        .withCuratorId(curator2.value)
+        .withType(CardTypeEnum.URL)
+        .withUrl(url)
+        .buildOrThrow();
+
+      const card3 = new CardBuilder()
+        .withCuratorId(curator3.value)
+        .withType(CardTypeEnum.URL)
+        .withUrl(url)
+        .buildOrThrow();
+
+      // Add cards to libraries with different counts
+      card1.addToLibrary(curator1);
+
+      card2.addToLibrary(curator2);
+      card2.addToLibrary(curator1); // card2 has 2 library memberships
+
+      card3.addToLibrary(curator3);
+      card3.addToLibrary(curator1); // card3 has 3 library memberships
+      card3.addToLibrary(curator2);
+
+      await cardRepository.save(card1);
+      await cardRepository.save(card2);
+      await cardRepository.save(card3);
+
+      const result = await queryRepository.getLibrariesForUrl(testUrl, {
+        page: 1,
+        limit: 10,
+        sortBy: CardSortField.LIBRARY_COUNT,
+        sortOrder: SortOrder.DESC,
+      });
+
+      // Should return all library memberships, but sorted by the card's library count
+      expect(result.items.length).toBeGreaterThan(0);
+
+      // Group by card ID to check sorting
+      const cardGroups = new Map<string, any[]>();
+      result.items.forEach((item) => {
+        const cardId = item.card.id;
+        if (!cardGroups.has(cardId)) {
+          cardGroups.set(cardId, []);
+        }
+        cardGroups.get(cardId)!.push(item);
+      });
+
+      // Get the first occurrence of each card to check library count ordering
+      const uniqueCards = Array.from(cardGroups.entries()).map(
+        ([cardId, items]) => ({
+          cardId,
+          libraryCount: items[0]!.card.libraryCount,
+        }),
+      );
+
+      // Should be sorted by library count descending
+      for (let i = 0; i < uniqueCards.length - 1; i++) {
+        expect(uniqueCards[i]!.libraryCount).toBeGreaterThanOrEqual(
+          uniqueCards[i + 1]!.libraryCount,
+        );
+      }
+    });
+
+    it('should sort by libraryCount in ascending order when specified', async () => {
+      const testUrl = 'https://example.com/sort-library-count-asc-test';
+      const url = URL.create(testUrl).unwrap();
+
+      // Create cards with different library counts
+      const card1 = new CardBuilder()
+        .withCuratorId(curator1.value)
+        .withType(CardTypeEnum.URL)
+        .withUrl(url)
+        .buildOrThrow();
+
+      const card2 = new CardBuilder()
+        .withCuratorId(curator2.value)
+        .withType(CardTypeEnum.URL)
+        .withUrl(url)
+        .buildOrThrow();
+
+      // card1 has 1 library membership, card2 has 2
+      card1.addToLibrary(curator1);
+      card2.addToLibrary(curator2);
+      card2.addToLibrary(curator1);
+
+      await cardRepository.save(card1);
+      await cardRepository.save(card2);
+
+      const result = await queryRepository.getLibrariesForUrl(testUrl, {
+        page: 1,
+        limit: 10,
+        sortBy: CardSortField.LIBRARY_COUNT,
+        sortOrder: SortOrder.ASC,
+      });
+
+      expect(result.items.length).toBeGreaterThan(0);
+
+      // Group by card ID and check ascending order
+      const cardGroups = new Map<string, any[]>();
+      result.items.forEach((item) => {
+        const cardId = item.card.id;
+        if (!cardGroups.has(cardId)) {
+          cardGroups.set(cardId, []);
+        }
+        cardGroups.get(cardId)!.push(item);
+      });
+
+      const uniqueCards = Array.from(cardGroups.entries()).map(
+        ([cardId, items]) => ({
+          cardId,
+          libraryCount: items[0]!.card.libraryCount,
+        }),
+      );
+
+      // Should be sorted by library count ascending
+      for (let i = 0; i < uniqueCards.length - 1; i++) {
+        expect(uniqueCards[i]!.libraryCount).toBeLessThanOrEqual(
+          uniqueCards[i + 1]!.libraryCount,
+        );
+      }
     });
   });
 

src/webapp/app/bookmarklet/page.tsx

···
   Anchor,
   CopyButton,
 } from '@mantine/core';
-import { useState } from 'react';
-import { BiInfoCircle } from 'react-icons/bi';
 import SembleLogo from '@/assets/semble-logo.svg';
 import Link from 'next/link';