format and linting

src/modules/atproto/domain/DIDOrHandle.ts

···
     super(props);
   }
 
-  public static create(value: string): Result<DIDOrHandle, InvalidDIDOrHandleError> {
+  public static create(
+    value: string,
+  ): Result<DIDOrHandle, InvalidDIDOrHandleError> {
     if (!value || value.trim().length === 0) {
       return err(new InvalidDIDOrHandleError('Value cannot be empty'));
     }
···
     if (trimmedValue.startsWith('did:')) {
       const didResult = DID.create(trimmedValue);
       if (didResult.isErr()) {
-        return err(new InvalidDIDOrHandleError(`Invalid DID: ${didResult.error.message}`));
+        return err(
+          new InvalidDIDOrHandleError(
+            `Invalid DID: ${didResult.error.message}`,
+          ),
+        );
       }
 
-      return ok(new DIDOrHandle({
-        value: trimmedValue,
-        isDID: true,
-        did: didResult.value,
-      }));
+      return ok(
+        new DIDOrHandle({
+          value: trimmedValue,
+          isDID: true,
+          did: didResult.value,
+        }),
+      );
     }
 
     // Otherwise, try to parse as handle
     const handleResult = Handle.create(trimmedValue);
     if (handleResult.isErr()) {
-      return err(new InvalidDIDOrHandleError(`Invalid handle: ${handleResult.error.message}`));
+      return err(
+        new InvalidDIDOrHandleError(
+          `Invalid handle: ${handleResult.error.message}`,
+        ),
+      );
     }
 
-    return ok(new DIDOrHandle({
-      value: trimmedValue,
-      isDID: false,
-      handle: handleResult.value,
-    }));
+    return ok(
+      new DIDOrHandle({
+        value: trimmedValue,
+        isDID: false,
+        handle: handleResult.value,
+      }),
+    );
   }
 
   public getDID(): DID | undefined {
···
   }
 
   public equals(other: DIDOrHandle): boolean {
-    return this.props.value === other.props.value && this.props.isDID === other.props.isDID;
+    return (
+      this.props.value === other.props.value &&
+      this.props.isDID === other.props.isDID
+    );
   }
 }

src/modules/atproto/domain/Handle.ts

···
     }
 
     // Must not start or end with dot or hyphen
-    if (domain.startsWith('.') || domain.endsWith('.') || 
-        domain.startsWith('-') || domain.endsWith('-')) {
+    if (
+      domain.startsWith('.') ||
+      domain.endsWith('.') ||
+      domain.startsWith('-') ||
+      domain.endsWith('-')
+    ) {
       return false;
     }
 

src/modules/atproto/infrastructure/publishers/ATProtoCardPublisher.ts

···
     try {
       const record = CardMapper.toCreateRecordDTO(card);
       const curatorDidResult = DID.create(curatorId.value);
-      
+
       if (curatorDidResult.isErr()) {
         return err(
           new Error(`Invalid curator DID: ${curatorDidResult.error.message}`),
         );
       }
-      
+
       const curatorDid = curatorDidResult.value;
 
       // Get an authenticated agent for this curator
···
       const strongRef = new StrongRef(publishedRecordId);
       const atUri = strongRef.atUri;
       const curatorDidResult = DID.create(curatorId.value);
-      
+
       if (curatorDidResult.isErr()) {
         return err(
           new Error(`Invalid curator DID: ${curatorDidResult.error.message}`),
         );
       }
-      
+
       const curatorDid = curatorDidResult.value;
       const repo = curatorDid.value;
       const rkey = atUri.rkey;

src/modules/atproto/infrastructure/publishers/ATProtoCollectionPublisher.ts

···
   ): Promise<Result<PublishedRecordId, UseCaseError>> {
     try {
       const curatorDidResult = DID.create(collection.authorId.value);
-      
+
       if (curatorDidResult.isErr()) {
         return err(
           new Error(`Invalid curator DID: ${curatorDidResult.error.message}`),
         );
       }
-      
+
       const curatorDid = curatorDidResult.value;
 
       // Get an authenticated agent for this curator
···
   ): Promise<Result<PublishedRecordId, UseCaseError>> {
     try {
       const curatorDidResult = DID.create(curatorId.value);
-      
+
       if (curatorDidResult.isErr()) {
         return err(
           new Error(`Invalid curator DID: ${curatorDidResult.error.message}`),
         );
       }
-      
+
       const curatorDid = curatorDidResult.value;
 
       // Get an authenticated agent for this curator

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

···
 import { DIDOrHandle } from '../../domain/DIDOrHandle';
 import { IAgentService } from '../../application/IAgentService';
 
-export class ATProtoIdentityResolutionService implements IIdentityResolutionService {
+export class ATProtoIdentityResolutionService
+  implements IIdentityResolutionService
+{
   constructor(private readonly agentService: IAgentService) {}
 
   async resolveToDID(identifier: DIDOrHandle): Promise<Result<DID>> {

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

···
         const didResult = DID.create(callerDid);
         if (didResult.isErr()) {
           return err(
-            new Error(
-              `Invalid caller DID: ${didResult.error.message}`,
-            ),
+            new Error(`Invalid caller DID: ${didResult.error.message}`),
           );
         }
-        
+
         const agentResult = await this.agentService.getAuthenticatedAgent(
           didResult.value,
         );

src/modules/atproto/tests/domain/DID.test.ts

···
     });
 
     it('should reject unsupported DID method', () => {
-      const result = DID.create('did:key:z6MkhaXgBZDvotDkL5257faiztiGiC2QtKLGpbnnEGta2doK');
+      const result = DID.create(
+        'did:key:z6MkhaXgBZDvotDkL5257faiztiGiC2QtKLGpbnnEGta2doK',
+      );
 
       expect(result.isErr()).toBe(true);
       if (result.isErr()) {

src/modules/cards/application/useCases/queries/GetCollectionsUseCase.ts

···
     }
 
     // Resolve to DID
-    const didResult = await this.identityResolver.resolveToDID(identifierResult.value);
+    const didResult = await this.identityResolver.resolveToDID(
+      identifierResult.value,
+    );
     if (didResult.isErr()) {
-      return err(new ValidationError(`Could not resolve curator identifier: ${didResult.error.message}`));
+      return err(
+        new ValidationError(
+          `Could not resolve curator identifier: ${didResult.error.message}`,
+        ),
+      );
     }
 
     const resolvedDid = didResult.value.value;
 
     try {
       // Execute query to get raw collection data using the resolved DID
-      const result = await this.collectionQueryRepo.findByCreator(
-        resolvedDid,
-        {
-          page,
-          limit,
-          sortBy,
-          sortOrder,
-          searchText: query.searchText,
-        },
-      );
+      const result = await this.collectionQueryRepo.findByCreator(resolvedDid, {
+        page,
+        limit,
+        sortBy,
+        sortOrder,
+        searchText: query.searchText,
+      });
 
       // Get user profile for the curator using the resolved DID
-      const profileResult = await this.profileService.getProfile(
-        resolvedDid,
-      );
+      const profileResult = await this.profileService.getProfile(resolvedDid);
 
       if (profileResult.isErr()) {
         return err(

src/modules/cards/application/useCases/queries/GetProfileUseCase.ts

···
     }
 
     // Resolve to DID
-    const didResult = await this.identityResolver.resolveToDID(identifierResult.value);
+    const didResult = await this.identityResolver.resolveToDID(
+      identifierResult.value,
+    );
     if (didResult.isErr()) {
-      return err(new ValidationError(`Could not resolve user identifier: ${didResult.error.message}`));
+      return err(
+        new ValidationError(
+          `Could not resolve user identifier: ${didResult.error.message}`,
+        ),
+      );
     }
 
     try {
       // Fetch user profile using the resolved DID
-      const profileResult = await this.profileService.getProfile(didResult.value.value);
+      const profileResult = await this.profileService.getProfile(
+        didResult.value.value,
+      );
 
       if (profileResult.isErr()) {
         return err(

src/modules/cards/application/useCases/queries/GetUrlCardsUseCase.ts

···
     }
 
     // Resolve to DID
-    const didResult = await this.identityResolver.resolveToDID(identifierResult.value);
+    const didResult = await this.identityResolver.resolveToDID(
+      identifierResult.value,
+    );
     if (didResult.isErr()) {
-      return err(new ValidationError(`Could not resolve user identifier: ${didResult.error.message}`));
+      return err(
+        new ValidationError(
+          `Could not resolve user identifier: ${didResult.error.message}`,
+        ),
+      );
     }
 
     try {
       // Execute query to get raw card data using the resolved DID
-      const result = await this.cardQueryRepo.getUrlCardsOfUser(didResult.value.value, {
-        page,
-        limit,
-        sortBy,
-        sortOrder,
-      });
+      const result = await this.cardQueryRepo.getUrlCardsOfUser(
+        didResult.value.value,
+        {
+          page,
+          limit,
+          sortBy,
+          sortOrder,
+        },
+      );
 
       // Transform raw data to enriched DTOs
       const enrichedCards: UrlCardListItemDTO[] = result.items;

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

···
 import { DID } from 'src/modules/atproto/domain/DID';
 import { DIDOrHandle } from 'src/modules/atproto/domain/DIDOrHandle';
 
-export class FakeIdentityResolutionService implements IIdentityResolutionService {
+export class FakeIdentityResolutionService
+  implements IIdentityResolutionService
+{
   private handleToDIDMap: Map<string, string> = new Map();
   private shouldFail = false;
 
···
       // Create and return the DID
       const didResult = DID.create(mappedDID);
       if (didResult.isErr()) {
-        return err(new Error(`Invalid DID in mapping: ${didResult.error.message}`));
+        return err(
+          new Error(`Invalid DID in mapping: ${didResult.error.message}`),
+        );
       }
 
       return ok(didResult.value);

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

···
     const feedService = new FeedService(repositories.feedRepository);
 
     // Identity Resolution Service
-    const identityResolutionService = new ATProtoIdentityResolutionService(atProtoAgentService);
+    const identityResolutionService = new ATProtoIdentityResolutionService(
+      atProtoAgentService,
+    );
 
     return {
       tokenService,