Merge pull request #54 from cosmik-network/feature/handle-and-uri-for-collections-in-feed

Feature/handle and uri for collections in feed

src/modules/atproto/domain/services/IIdentityResolutionService.ts

···
 import { Result } from 'src/shared/core/Result';
 import { DID } from '../DID';
 import { DIDOrHandle } from '../DIDOrHandle';
+import { Handle } from '../Handle';
 
 export interface IIdentityResolutionService {
   resolveToDID(identifier: DIDOrHandle): Promise<Result<DID>>;
+  resolveToHandle(identifier: DIDOrHandle): Promise<Result<Handle>>;
 }

src/modules/atproto/infrastructure/services/ATProtoIdentityResolutionService.ts

···
 import { IIdentityResolutionService } from '../../domain/services/IIdentityResolutionService';
 import { DID } from '../../domain/DID';
 import { DIDOrHandle } from '../../domain/DIDOrHandle';
+import { Handle } from '../../domain/Handle';
 import { IAgentService } from '../../application/IAgentService';
 
 export class ATProtoIdentityResolutionService
···
       return err(
         new Error(
           `Error resolving identifier to DID: ${error instanceof Error ? error.message : String(error)}`,
+        ),
+      );
+    }
+  }
+
+  async resolveToHandle(identifier: DIDOrHandle): Promise<Result<Handle>> {
+    try {
+      // If it's already a handle, return it directly
+      if (identifier.isHandle) {
+        const handle = identifier.getHandle();
+        if (!handle) {
+          return err(new Error('Invalid handle in identifier'));
+        }
+        return ok(handle);
+      }
+
+      // If it's a DID, resolve it to a handle
+      const did = identifier.getDID();
+      if (!did) {
+        return err(new Error('Invalid DID in identifier'));
+      }
+
+      // Get an unauthenticated agent to resolve the DID
+      const agentResult = this.agentService.getUnauthenticatedAgent();
+      if (agentResult.isErr()) {
+        return err(
+          new Error(
+            `Failed to get agent for DID resolution: ${agentResult.error.message}`,
+          ),
+        );
+      }
+
+      const agent = agentResult.value;
+
+      // Get the profile to extract the handle
+      const profileResult = await agent.getProfile({ actor: did.value });
+
+      if (!profileResult.success) {
+        return err(
+          new Error(
+            `Failed to resolve DID ${did.value}: ${JSON.stringify(profileResult)}`,
+          ),
+        );
+      }
+
+      // Create and return the Handle
+      const handleResult = Handle.create(profileResult.data.handle);
+      if (handleResult.isErr()) {
+        return err(
+          new Error(
+            `Invalid handle returned from DID resolution: ${handleResult.error.message}`,
+          ),
+        );
+      }
+
+      return ok(handleResult.value);
+    } catch (error) {
+      return err(
+        new Error(
+          `Error resolving identifier to handle: ${error instanceof Error ? error.message : String(error)}`,
         ),
       );
     }

src/modules/cards/tests/utils/FakeIdentityResolutionService.ts

···
 import { IIdentityResolutionService } from 'src/modules/atproto/domain/services/IIdentityResolutionService';
 import { DID } from 'src/modules/atproto/domain/DID';
 import { DIDOrHandle } from 'src/modules/atproto/domain/DIDOrHandle';
+import { Handle } from 'src/modules/atproto/domain/Handle';
 
 export class FakeIdentityResolutionService
   implements IIdentityResolutionService
 {
   private handleToDIDMap: Map<string, string> = new Map();
+  private didToHandleMap: Map<string, string> = new Map();
   private shouldFail = false;
 
   async resolveToDID(identifier: DIDOrHandle): Promise<Result<DID>> {
···
     }
   }
 
+  async resolveToHandle(identifier: DIDOrHandle): Promise<Result<Handle>> {
+    if (this.shouldFail) {
+      return err(new Error('Identity resolution service failed'));
+    }
+
+    try {
+      // If it's already a handle, return it directly
+      if (identifier.isHandle) {
+        const handle = identifier.getHandle();
+        if (!handle) {
+          return err(new Error('Invalid handle in identifier'));
+        }
+        return ok(handle);
+      }
+
+      // If it's a DID, resolve it to a handle
+      const did = identifier.getDID();
+      if (!did) {
+        return err(new Error('Invalid DID in identifier'));
+      }
+
+      // Check if we have a mapping for this DID
+      const mappedHandle = this.didToHandleMap.get(did.value);
+      if (!mappedHandle) {
+        return err(new Error(`DID not found: ${did.value}`));
+      }
+
+      // Create and return the Handle
+      const handleResult = Handle.create(mappedHandle);
+      if (handleResult.isErr()) {
+        return err(
+          new Error(`Invalid handle in mapping: ${handleResult.error.message}`),
+        );
+      }
+
+      return ok(handleResult.value);
+    } catch (error) {
+      return err(
+        new Error(
+          `Error resolving identifier to handle: ${error instanceof Error ? error.message : String(error)}`,
+        ),
+      );
+    }
+  }
+
   // Test helper methods
   addHandleMapping(handle: string, did: string): void {
     this.handleToDIDMap.set(handle, did);
+    this.didToHandleMap.set(did, handle);
   }
 
   setShouldFail(shouldFail: boolean): void {
···
 
   clear(): void {
     this.handleToDIDMap.clear();
+    this.didToHandleMap.clear();
     this.shouldFail = false;
   }
 }

src/modules/feeds/application/useCases/queries/GetGlobalFeedUseCase.ts

···
 } from '../../../../cards/domain/ICardQueryRepository';
 import { ICollectionRepository } from 'src/modules/cards/domain/ICollectionRepository';
 import { CollectionId } from 'src/modules/cards/domain/value-objects/CollectionId';
+import { IIdentityResolutionService } from '../../../../atproto/domain/services/IIdentityResolutionService';
+import { DID } from '../../../../atproto/domain/DID';
+import { DIDOrHandle } from '../../../../atproto/domain/DIDOrHandle';
 
 export interface GetGlobalFeedQuery {
   page?: number;
···
   collections: {
     id: string;
     name: string;
+    authorHandle: string;
+    uri?: string;
   }[];
 }
 
···
     private profileService: IProfileService,
     private cardQueryRepository: ICardQueryRepository,
     private collectionRepository: ICollectionRepository,
+    private identityResolutionService: IIdentityResolutionService,
   ) {}
 
   async execute(
···
         ),
       ];
 
-      const collectionDataMap = new Map<string, { id: string; name: string }>();
+      const collectionDataMap = new Map<
+        string,
+        { id: string; name: string; authorHandle: string; uri?: string }
+      >();
       // Fetch all collections in parallel using Promise.all
       const collectionResults = await Promise.all(
         collectionIds.map(async (collectionId) => {
···
           const collectionResult = await this.collectionRepository.findById(
             collectionIdResult.value,
           );
-          if (collectionResult.isOk() && collectionResult.value) {
-            const collection = collectionResult.value;
-            return {
-              id: collection.collectionId.getStringValue(),
-              name: collection.name.toString(),
-              collectionId,
-            };
+          if (collectionResult.isErr() || !collectionResult.value) {
+            return null;
+          }
+
+          const collection = collectionResult.value;
+
+          const didOrHandleResult = DIDOrHandle.create(
+            collection.authorId.value,
+          );
+          if (didOrHandleResult.isErr()) {
+            return null;
+          }
+
+          const resolvedHandleResult =
+            await this.identityResolutionService.resolveToHandle(
+              didOrHandleResult.value,
+            );
+          if (resolvedHandleResult.isErr()) {
+            return null;
           }
-          return null;
+
+          const handle = resolvedHandleResult.value;
+          const uri = collection.publishedRecordId?.uri;
+
+          return {
+            id: collection.collectionId.getStringValue(),
+            name: collection.name.toString(),
+            authorHandle: handle.value,
+            uri,
+            collectionId,
+          };
         }),
       );
 
···
           collectionDataMap.set(result.collectionId, {
             id: result.id,
             name: result.name,
+            authorHandle: result.authorHandle,
+            uri: result.uri,
           });
         }
       });
···
 
         const collections = (activity.metadata.collectionIds || [])
           .map((collectionId) => collectionDataMap.get(collectionId))
-          .filter(
-            (collection): collection is { id: string; name: string } =>
-              !!collection,
-          );
+          .filter((collection) => !!collection);
 
         feedItems.push({
           id: activity.activityId.getStringValue(),
-          user: {
-            id: actor.id,
-            handle: actor.handle,
-            name: actor.name,
-            avatarUrl: actor.avatarUrl,
-          },
+          user: actor,
           card: cardData,
           createdAt: activity.createdAt,
           collections,

src/shared/infrastructure/http/factories/UseCaseFactory.ts

···
         services.profileService,
         repositories.cardQueryRepository,
         repositories.collectionRepository,
+        services.identityResolutionService,
       ),
       addActivityToFeedUseCase: new AddActivityToFeedUseCase(
         services.feedService,

src/webapp/api-client/types/responses.ts

···
   collections: {
     id: string;
     name: string;
+    authorHandle: string;
+    uri?: string;
   }[];
 }