Merge pull request #50 from cosmik-network/feature/record-key-in-api-response

Feature/record key in api response

src/modules/atproto/domain/ATUri.ts

···
+import { ValueObject } from '../../../shared/domain/ValueObject';
+import { Result, ok, err } from '../../../shared/core/Result';
 import { DID } from './DID';
 
-export class ATUri {
-  // at://did:plc:lehcqqkwzcwvjvw66uthu5oq/app.bsky.feed.post/3lnxh4zet5c2a
-  // given the uri structure above, which is composed of did, CollectionNSID, and rkey, make a value object
+export class InvalidATUriError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'InvalidATUriError';
+  }
+}
 
+interface ATUriProps {
   value: string;
   did: DID;
   collection: string;
   rkey: string;
+}
+
+export class ATUri extends ValueObject<ATUriProps> {
+  get value(): string {
+    return this.props.value;
+  }
+
+  get did(): DID {
+    return this.props.did;
+  }
+
+  get collection(): string {
+    return this.props.collection;
+  }
+
+  get rkey(): string {
+    return this.props.rkey;
+  }
 
-  constructor(uri: string) {
-    this.value = uri;
-    const parts = uri.split('/');
+  private constructor(props: ATUriProps) {
+    super(props);
+  }
+
+  public static create(uri: string): Result<ATUri, InvalidATUriError> {
+    if (!uri || uri.trim().length === 0) {
+      return err(new InvalidATUriError('AT URI cannot be empty'));
+    }
+
+    const trimmedUri = uri.trim();
+
+    if (!trimmedUri.startsWith('at://')) {
+      return err(new InvalidATUriError('AT URI must start with "at://"'));
+    }
+
+    const parts = trimmedUri.split('/');
     if (parts.length !== 5) {
-      throw new Error('Invalid AT URI');
+      return err(
+        new InvalidATUriError(
+          'AT URI must have exactly 5 parts separated by "/"',
+        ),
+      );
     }
+
     const didResult = DID.create(parts[2]!);
     if (didResult.isErr()) {
-      throw new Error(`Invalid DID in AT URI: ${didResult.error.message}`);
+      return err(
+        new InvalidATUriError(
+          `Invalid DID in AT URI: ${didResult.error.message}`,
+        ),
+      );
     }
-    this.did = didResult.value;
-    this.collection = parts[3]!;
-    this.rkey = parts[4]!;
+
+    const collection = parts[3]!;
+    const rkey = parts[4]!;
+
+    if (!collection || collection.length === 0) {
+      return err(new InvalidATUriError('Collection cannot be empty'));
+    }
+
+    if (!rkey || rkey.length === 0) {
+      return err(new InvalidATUriError('Record key cannot be empty'));
+    }
+
+    return ok(
+      new ATUri({
+        value: trimmedUri,
+        did: didResult.value,
+        collection,
+        rkey,
+      }),
+    );
+  }
+
+  public static fromParts(
+    did: DID,
+    collection: string,
+    rkey: string,
+  ): Result<ATUri, InvalidATUriError> {
+    if (!collection || collection.length === 0) {
+      return err(new InvalidATUriError('Collection cannot be empty'));
+    }
+
+    if (!rkey || rkey.length === 0) {
+      return err(new InvalidATUriError('Record key cannot be empty'));
+    }
+
+    const uri = `at://${did.value}/${collection}/${rkey}`;
+
+    return ok(
+      new ATUri({
+        value: uri,
+        did,
+        collection,
+        rkey,
+      }),
+    );
+  }
+
+  public toString(): string {
+    return this.props.value;
+  }
+
+  public equals(other: ATUri): boolean {
+    return this.props.value === other.props.value;
   }
 }

src/modules/atproto/domain/StrongRef.ts

···
 
   constructor(props: StrongRefProps) {
     super(props);
-    this._atUri = new ATUri(props.uri);
+    const atUriResult = ATUri.create(props.uri);
+    if (atUriResult.isErr()) {
+      throw new Error(`Invalid AT URI: ${atUriResult.error.message}`);
+    }
+    const atUri = atUriResult.value;
+    this._atUri = atUri;
   }
 
   equals(other: StrongRef): boolean {

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

···
+export const REPOSITORY_COLLECTION_IDS = {
+  COLLECTIONS: 'network.cosmik.collection',
+  CARDS: 'network.cosmik.card',
+  COLLECTION_LINKS: 'network.cosmik.collectionLink',
+};

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

···
+import { err, Result } from 'src/shared/core/Result';
+import { UseCase } from 'src/shared/core/UseCase';
+import { IAtUriResolutionService } from '../../../domain/services/IAtUriResolutionService';
+import { IIdentityResolutionService } from '../../../../atproto/domain/services/IIdentityResolutionService';
+import { DIDOrHandle } from '../../../../atproto/domain/DIDOrHandle';
+import { ATUri } from '../../../../atproto/domain/ATUri';
+import {
+  GetCollectionPageUseCase,
+  GetCollectionPageResult,
+  CollectionNotFoundError,
+} from './GetCollectionPageUseCase';
+import {
+  CardSortField,
+  SortOrder,
+} from 'src/modules/cards/domain/ICardQueryRepository';
+import { REPOSITORY_COLLECTION_IDS } from 'src/modules/atproto/infrastructure/services/RepositoryCollectionIds';
+
+export interface GetCollectionPageByAtUriQuery {
+  handle: string;
+  recordKey: string;
+  callerDid?: string;
+  page?: number;
+  limit?: number;
+  sortBy?: CardSortField;
+  sortOrder?: SortOrder;
+}
+
+export class GetCollectionPageByAtUriUseCase
+  implements
+    UseCase<GetCollectionPageByAtUriQuery, Result<GetCollectionPageResult>>
+{
+  constructor(
+    private identityResolutionService: IIdentityResolutionService,
+    private atUriResolutionService: IAtUriResolutionService,
+    private getCollectionPageUseCase: GetCollectionPageUseCase,
+  ) {}
+
+  async execute(
+    query: GetCollectionPageByAtUriQuery,
+  ): Promise<Result<GetCollectionPageResult>> {
+    // First resolve the handle to a DID
+    const identifierResult = DIDOrHandle.create(query.handle);
+    if (identifierResult.isErr()) {
+      return err(
+        new Error(`Invalid handle: ${identifierResult.error.message}`),
+      );
+    }
+
+    const didResult = await this.identityResolutionService.resolveToDID(
+      identifierResult.value,
+    );
+    if (didResult.isErr()) {
+      return err(
+        new Error(
+          `Failed to resolve handle to DID: ${didResult.error.message}`,
+        ),
+      );
+    }
+
+    // Construct the AT URI using the resolved DID
+    const atUriResult = ATUri.fromParts(
+      didResult.value,
+      REPOSITORY_COLLECTION_IDS.COLLECTIONS,
+      query.recordKey,
+    );
+    if (atUriResult.isErr()) {
+      return err(
+        new Error(`Failed to construct AT URI: ${atUriResult.error.message}`),
+      );
+    }
+
+    // Resolve the AT URI to a collection ID
+    const collectionIdResult =
+      await this.atUriResolutionService.resolveCollectionId(
+        atUriResult.value.value,
+      );
+
+    if (collectionIdResult.isErr()) {
+      return err(collectionIdResult.error);
+    }
+
+    if (!collectionIdResult.value) {
+      return err(
+        new CollectionNotFoundError('Collection not found for AT URI'),
+      );
+    }
+
+    // Delegate to the existing use case
+    return this.getCollectionPageUseCase.execute({
+      collectionId: collectionIdResult.value.getStringValue(),
+      callerDid: query.callerDid,
+      page: query.page,
+      limit: query.limit,
+      sortBy: query.sortBy,
+      sortOrder: query.sortOrder,
+    });
+  }
+}

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

···
 export type CollectionPageUrlCardDTO = UrlCardView;
 export interface GetCollectionPageResult {
   id: string;
+  uri?: string;
   name: string;
   description?: string;
   author: {
···
         return err(new CollectionNotFoundError('Collection not found'));
       }
 
+      const collectionPublishedRecordId = collection.publishedRecordId;
+
+      const collectionUri = collectionPublishedRecordId?.uri;
+
       // Get author profile
       const profileResult = await this.profileService.getProfile(
         collection.authorId.value,
···
 
       return ok({
         id: collection.collectionId.getStringValue(),
+        uri: collectionUri,
         name: collection.name.value,
         description: collection.description?.value,
         author: {

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

···
 // Enriched data for the final use case result
 export interface CollectionListItemDTO {
   id: string;
+  uri?: string;
   name: string;
   description?: string;
   updatedAt: Date;
···
         (item) => {
           return {
             id: item.id,
+            uri: item.uri,
             name: item.name,
             description: item.description,
             updatedAt: item.updatedAt,

src/modules/cards/domain/ICollectionQueryRepository.ts

···
 // Raw data from repository - minimal, just what's stored
 export interface CollectionQueryResultDTO {
   id: string;
+  uri?: string;
   name: string;
   description?: string;
   updatedAt: Date;

src/modules/cards/domain/services/IAtUriResolutionService.ts

···
+import { Result } from 'src/shared/core/Result';
+import { CollectionId } from '../value-objects/CollectionId';
+
+export enum AtUriResourceType {
+  COLLECTION = 'collection',
+}
+
+export interface AtUriResolutionResult {
+  type: AtUriResourceType;
+  id: CollectionId;
+}
+
+export interface IAtUriResolutionService {
+  resolveAtUri(atUri: string): Promise<Result<AtUriResolutionResult | null>>;
+
+  // Convenience methods for specific types
+  resolveCollectionId(atUri: string): Promise<Result<CollectionId | null>>;
+}

src/modules/cards/infrastructure/http/controllers/GetCollectionPageByAtUriController.ts

···
+import { Request, Response } from 'express';
+import { Controller } from 'src/shared/infrastructure/http/Controller';
+import { GetCollectionPageByAtUriUseCase } from '../../../application/useCases/queries/GetCollectionPageByAtUriUseCase';
+import { AuthenticatedRequest } from 'src/shared/infrastructure/http/middleware/AuthMiddleware';
+import { CardSortField, SortOrder } from '../../../domain/ICardQueryRepository';
+
+export class GetCollectionPageByAtUriController extends Controller {
+  constructor(
+    private getCollectionPageByAtUriUseCase: GetCollectionPageByAtUriUseCase,
+  ) {
+    super();
+  }
+
+  async executeImpl(req: AuthenticatedRequest, res: Response): Promise<any> {
+    try {
+      const { handle, recordKey } = req.params;
+      if (!handle || !recordKey) {
+        return this.badRequest(res, 'Handle and recordKey are required');
+      }
+      const { page, limit, sortBy, sortOrder } = req.query;
+      const callerDid = req.did;
+
+      const result = await this.getCollectionPageByAtUriUseCase.execute({
+        handle,
+        recordKey,
+        callerDid,
+        page: page ? parseInt(page as string) : undefined,
+        limit: limit ? parseInt(limit as string) : undefined,
+        sortBy: sortBy as CardSortField,
+        sortOrder: sortOrder as SortOrder,
+      });
+
+      if (result.isErr()) {
+        const error = result.error;
+        if (error.name === 'CollectionNotFoundError') {
+          return this.notFound(res, error.message);
+        }
+        return this.fail(res, error);
+      }
+
+      return this.ok(res, result.value);
+    } catch (error) {
+      return this.fail(res, error as Error);
+    }
+  }
+}

src/modules/cards/infrastructure/http/routes/collectionRoutes.ts

···
 import { GetCollectionPageController } from '../controllers/GetCollectionPageController';
 import { GetMyCollectionsController } from '../controllers/GetMyCollectionsController';
 import { GetUserCollectionsController } from '../controllers/GetUserCollectionsController';
+import { GetCollectionPageByAtUriController } from '../controllers/GetCollectionPageByAtUriController';
 import { AuthMiddleware } from 'src/shared/infrastructure/http/middleware';
 
 export function createCollectionRoutes(
···
   getCollectionPageController: GetCollectionPageController,
   getMyCollectionsController: GetMyCollectionsController,
   getUserCollectionsController: GetUserCollectionsController,
+  getCollectionPageByAtUriController: GetCollectionPageByAtUriController,
 ): Router {
   const router = Router();
 
···
   // GET /api/collections/user/:identifier - Get user's collections by identifier
   router.get('/user/:identifier', authMiddleware.optionalAuth(), (req, res) =>
     getUserCollectionsController.execute(req, res),
+  );
+
+  // GET /api/collections/at/:handle/:recordKey - Get collection by AT URI
+  router.get(
+    '/at/:handle/:recordKey',
+    authMiddleware.optionalAuth(),
+    (req, res) => getCollectionPageByAtUriController.execute(req, res),
   );
 
   // GET /api/collections/:collectionId - Get collection page

src/modules/cards/infrastructure/http/routes/index.ts

···
 import { AuthMiddleware } from 'src/shared/infrastructure/http/middleware';
 import { GetMyCollectionsController } from '../controllers/GetMyCollectionsController';
 import { GetUserCollectionsController } from '../controllers/GetUserCollectionsController';
+import { GetCollectionPageByAtUriController } from '../controllers/GetCollectionPageByAtUriController';
 
 export function createCardsModuleRoutes(
   authMiddleware: AuthMiddleware,
···
   updateCollectionController: UpdateCollectionController,
   deleteCollectionController: DeleteCollectionController,
   getCollectionPageController: GetCollectionPageController,
+  getCollectionPageByAtUriController: GetCollectionPageByAtUriController,
   getMyCollectionsController: GetMyCollectionsController,
   getCollectionsController: GetUserCollectionsController,
 ): Router {
···
       getCollectionPageController,
       getMyCollectionsController,
       getCollectionsController,
+      getCollectionPageByAtUriController,
     ),
   );
 

src/modules/cards/infrastructure/repositories/DrizzleCollectionQueryRepository.ts

···
   CollectionSortField,
   SortOrder,
 } from '../../domain/ICollectionQueryRepository';
-import { collections, collectionCards } from './schema/collection.sql';
+import { collections } from './schema/collection.sql';
+import { publishedRecords } from './schema/publishedRecord.sql';
 import { CollectionMapper } from './mappers/CollectionMapper';
 
 export class DrizzleCollectionQueryRepository
···
         );
       }
 
-      // Simple query: get collections with their stored card counts
+      // Simple query: get collections with their stored card counts and URIs
       const collectionsQuery = this.db
         .select({
           id: collections.id,
···
           updatedAt: collections.updatedAt,
           authorId: collections.authorId,
           cardCount: collections.cardCount,
+          uri: publishedRecords.uri,
         })
         .from(collections)
+        .leftJoin(
+          publishedRecords,
+          eq(collections.publishedRecordId, publishedRecords.id),
+        )
         .where(
           sql`${whereConditions.reduce((acc, condition, index) =>
             index === 0 ? condition : sql`${acc} AND ${condition}`,
···
       const items = collectionsResult.map((raw) =>
         CollectionMapper.toQueryResult({
           id: raw.id,
+          uri: raw.uri,
           name: raw.name,
           description: raw.description,
           createdAt: raw.createdAt,

src/modules/cards/infrastructure/repositories/mappers/CollectionMapper.ts

···
 export class CollectionMapper {
   public static toQueryResult(raw: {
     id: string;
+    uri: string | null;
     name: string;
     description?: string | null;
     createdAt: Date;
···
   }): CollectionQueryResultDTO {
     return {
       id: raw.id,
+      uri: raw.uri || undefined,
       name: raw.name,
       description: raw.description || undefined,
       createdAt: raw.createdAt,

src/modules/cards/infrastructure/repositories/schema/publishedRecord.sql.ts

···
   uuid,
   timestamp,
   uniqueIndex,
+  index,
 } from 'drizzle-orm/pg-core';
 
 // Define the published records table schema
···
     return {
       // Create a composite unique constraint to prevent exact duplicates
       uriCidUnique: uniqueIndex('uri_cid_unique_idx').on(table.uri, table.cid),
+      // Index for efficient AT URI lookups
+      uriIdx: index('published_records_uri_idx').on(table.uri),
     };
   },
 );

src/modules/cards/infrastructure/services/DrizzleAtUriResolutionService.ts

···
+import { eq } from 'drizzle-orm';
+import { PostgresJsDatabase } from 'drizzle-orm/postgres-js';
+import {
+  IAtUriResolutionService,
+  AtUriResourceType,
+  AtUriResolutionResult,
+} from '../../domain/services/IAtUriResolutionService';
+import { CollectionId } from '../../domain/value-objects/CollectionId';
+import { collections } from '../repositories/schema/collection.sql';
+import { publishedRecords } from '../repositories/schema/publishedRecord.sql';
+import { Result, ok, err } from 'src/shared/core/Result';
+
+export class DrizzleAtUriResolutionService implements IAtUriResolutionService {
+  constructor(private db: PostgresJsDatabase) {}
+
+  async resolveAtUri(
+    atUri: string,
+  ): Promise<Result<AtUriResolutionResult | null>> {
+    try {
+      // Try collections first
+      const collectionResult = await this.db
+        .select({
+          id: collections.id,
+        })
+        .from(collections)
+        .innerJoin(
+          publishedRecords,
+          eq(collections.publishedRecordId, publishedRecords.id),
+        )
+        .where(eq(publishedRecords.uri, atUri))
+        .limit(1);
+
+      if (collectionResult.length > 0) {
+        const collectionIdResult = CollectionId.createFromString(
+          collectionResult[0]!.id,
+        );
+        if (collectionIdResult.isErr()) {
+          return err(collectionIdResult.error);
+        }
+
+        return ok({
+          type: AtUriResourceType.COLLECTION,
+          id: collectionIdResult.value,
+        });
+      }
+      return ok(null);
+    } catch (error) {
+      return err(error as Error);
+    }
+  }
+
+  async resolveCollectionId(
+    atUri: string,
+  ): Promise<Result<CollectionId | null>> {
+    const result = await this.resolveAtUri(atUri);
+
+    if (result.isErr()) {
+      return err(result.error);
+    }
+
+    if (!result.value || result.value.type !== AtUriResourceType.COLLECTION) {
+      return ok(null);
+    }
+
+    return ok(result.value.id as CollectionId);
+  }
+}

src/modules/cards/tests/application/GetMyCollectionsUseCase.test.ts

···
 import { InMemoryCollectionRepository } from '../utils/InMemoryCollectionRepository';
 import { FakeProfileService } from '../utils/FakeProfileService';
 import { FakeIdentityResolutionService } from '../utils/FakeIdentityResolutionService';
+import { CollectionBuilder } from '../utils/builders/CollectionBuilder';
 import { CuratorId } from '../../domain/value-objects/CuratorId';
 import { Collection, CollectionAccessType } from '../../domain/Collection';
 import {
···
     });
 
     it("should return curator's collections with profile data", async () => {
-      // Create test collections
-      const collection1Result = Collection.create({
-        name: 'First Collection',
-        description: 'First collection description',
-        authorId: curatorId,
-        accessType: CollectionAccessType.OPEN,
-        collaboratorIds: [],
-        createdAt: new Date(),
-        updatedAt: new Date(),
-      });
-
-      const collection2Result = Collection.create({
-        name: 'Second Collection',
-        description: 'Second collection description',
-        authorId: curatorId,
-        accessType: CollectionAccessType.OPEN,
-        collaboratorIds: [],
-        createdAt: new Date(),
-        updatedAt: new Date(),
-      });
+      // Create test collections using CollectionBuilder
+      const collection1 = new CollectionBuilder()
+        .withName('First Collection')
+        .withDescription('First collection description')
+        .withAuthorId(curatorId.value)
+        .withAccessType(CollectionAccessType.OPEN)
+        .withPublished(true)
+        .buildOrThrow();
 
-      if (collection1Result.isErr() || collection2Result.isErr()) {
-        throw new Error('Failed to create test collections');
-      }
+      const collection2 = new CollectionBuilder()
+        .withName('Second Collection')
+        .withDescription('Second collection description')
+        .withAuthorId(curatorId.value)
+        .withAccessType(CollectionAccessType.OPEN)
+        .withPublished(true)
+        .buildOrThrow();
 
-      await collectionRepo.save(collection1Result.value);
-      await collectionRepo.save(collection2Result.value);
+      await collectionRepo.save(collection1);
+      await collectionRepo.save(collection2);
 
       const query = {
         curatorId: curatorId.value,
···
       expect(firstCollection.createdBy.name).toBe(userProfile.name);
       expect(firstCollection.createdBy.handle).toBe(userProfile.handle);
       expect(firstCollection.createdBy.avatarUrl).toBe(userProfile.avatarUrl);
+
+      // Verify URI is included
+      expect(firstCollection.uri).toBeDefined();
+      expect(typeof firstCollection.uri).toBe('string');
+      expect(firstCollection.uri?.length).toBeGreaterThan(0);
     });
 
     it('should only return collections for the specified curator', async () => {
       const otherCuratorId = CuratorId.create('did:plc:othercurator').unwrap();
 
-      // Create collections for different curators
-      const myCollectionResult = Collection.create({
-        name: 'My Collection',
-        authorId: curatorId,
-        accessType: CollectionAccessType.OPEN,
-        collaboratorIds: [],
-        createdAt: new Date(),
-        updatedAt: new Date(),
-      });
-
-      const otherCollectionResult = Collection.create({
-        name: 'Other Collection',
-        authorId: otherCuratorId,
-        accessType: CollectionAccessType.OPEN,
-        collaboratorIds: [],
-        createdAt: new Date(),
-        updatedAt: new Date(),
-      });
+      // Create collections for different curators using CollectionBuilder
+      const myCollection = new CollectionBuilder()
+        .withName('My Collection')
+        .withAuthorId(curatorId.value)
+        .withAccessType(CollectionAccessType.OPEN)
+        .withPublished(true)
+        .buildOrThrow();
 
-      if (myCollectionResult.isErr() || otherCollectionResult.isErr()) {
-        throw new Error('Failed to create test collections');
-      }
+      const otherCollection = new CollectionBuilder()
+        .withName('Other Collection')
+        .withAuthorId(otherCuratorId.value)
+        .withAccessType(CollectionAccessType.OPEN)
+        .withPublished(true)
+        .buildOrThrow();
 
-      await collectionRepo.save(myCollectionResult.value);
-      await collectionRepo.save(otherCollectionResult.value);
+      await collectionRepo.save(myCollection);
+      await collectionRepo.save(otherCollection);
 
       const query = {
         curatorId: curatorId.value,
···
       const response = result.unwrap();
       expect(response.collections).toHaveLength(1);
       expect(response.collections[0]!.name).toBe('My Collection');
+
+      // Verify URI is present for the collection
+      expect(response.collections[0]!.uri).toBeDefined();
+      expect(typeof response.collections[0]!.uri).toBe('string');
     });
   });
 
   describe('Pagination', () => {
     beforeEach(async () => {
-      // Create multiple collections for pagination testing
+      // Create multiple collections for pagination testing using CollectionBuilder
       for (let i = 1; i <= 5; i++) {
-        const collectionResult = Collection.create({
-          name: `Collection ${i}`,
-          authorId: curatorId,
-          accessType: CollectionAccessType.OPEN,
-          collaboratorIds: [],
-          createdAt: new Date(),
-          updatedAt: new Date(),
-        });
+        const collection = new CollectionBuilder()
+          .withName(`Collection ${i}`)
+          .withAuthorId(curatorId.value)
+          .withAccessType(CollectionAccessType.OPEN)
+          .withPublished(true)
+          .buildOrThrow();
 
-        if (collectionResult.isErr()) {
-          throw new Error(`Failed to create collection ${i}`);
-        }
-
-        await collectionRepo.save(collectionResult.value);
+        await collectionRepo.save(collection);
       }
     });
 
···
 
   describe('Sorting', () => {
     beforeEach(async () => {
-      // Create collections with different properties for sorting
+      // Create collections with different properties for sorting using CollectionBuilder
       const now = new Date();
 
-      const collection1Result = Collection.create({
-        name: 'Alpha Collection',
-        authorId: curatorId,
-        accessType: CollectionAccessType.OPEN,
-        collaboratorIds: [],
-        createdAt: new Date(now.getTime() - 2000),
-        updatedAt: new Date(now.getTime() - 1000),
-      });
+      const collection1 = new CollectionBuilder()
+        .withName('Alpha Collection')
+        .withAuthorId(curatorId.value)
+        .withAccessType(CollectionAccessType.OPEN)
+        .withCreatedAt(new Date(now.getTime() - 2000))
+        .withUpdatedAt(new Date(now.getTime() - 1000))
+        .withPublished(true)
+        .buildOrThrow();
 
-      const collection2Result = Collection.create({
-        name: 'Beta Collection',
-        authorId: curatorId,
-        accessType: CollectionAccessType.OPEN,
-        collaboratorIds: [],
-        createdAt: new Date(now.getTime() - 1000),
-        updatedAt: new Date(now.getTime() - 2000),
-      });
+      const collection2 = new CollectionBuilder()
+        .withName('Beta Collection')
+        .withAuthorId(curatorId.value)
+        .withAccessType(CollectionAccessType.OPEN)
+        .withCreatedAt(new Date(now.getTime() - 1000))
+        .withUpdatedAt(new Date(now.getTime() - 2000))
+        .withPublished(true)
+        .buildOrThrow();
 
-      if (collection1Result.isErr() || collection2Result.isErr()) {
-        throw new Error('Failed to create test collections');
-      }
-
-      await collectionRepo.save(collection1Result.value);
-      await collectionRepo.save(collection2Result.value);
+      await collectionRepo.save(collection1);
+      await collectionRepo.save(collection2);
     });
 
     it('should sort by name ascending', async () => {
···
 
   describe('Text search', () => {
     beforeEach(async () => {
-      // Create collections with different names and descriptions for search testing
+      // Create collections with different names and descriptions for search testing using CollectionBuilder
       const collections = [
         {
           name: 'Machine Learning Papers',
···
       ];
 
       for (const collectionData of collections) {
-        const collectionResult = Collection.create({
-          name: collectionData.name,
-          description: collectionData.description,
-          authorId: curatorId,
-          accessType: CollectionAccessType.OPEN,
-          collaboratorIds: [],
-          createdAt: new Date(),
-          updatedAt: new Date(),
-        });
-
-        if (collectionResult.isErr()) {
-          throw new Error(
-            `Failed to create collection: ${collectionData.name}`,
-          );
-        }
+        const collection = new CollectionBuilder()
+          .withName(collectionData.name)
+          .withDescription(collectionData.description)
+          .withAuthorId(curatorId.value)
+          .withAccessType(CollectionAccessType.OPEN)
+          .withPublished(true)
+          .buildOrThrow();
 
-        await collectionRepo.save(collectionResult.value);
+        await collectionRepo.save(collection);
       }
     });
 
···
       expect(result.isOk()).toBe(true);
       const response = result.unwrap();
       expect(response.collections).toHaveLength(3);
-    });
 
-    it('should search collections with no description', async () => {
-      // Create a collection without description
-      const collectionResult = Collection.create({
-        name: 'No Description Collection',
-        authorId: curatorId,
-        accessType: CollectionAccessType.OPEN,
-        collaboratorIds: [],
-        createdAt: new Date(),
-        updatedAt: new Date(),
+      // Verify all collections have URIs
+      response.collections.forEach((collection) => {
+        expect(collection.uri).toBeDefined();
+        expect(typeof collection.uri).toBe('string');
+        expect(collection.uri?.length).toBeGreaterThan(0);
       });
+    });
 
-      if (collectionResult.isErr()) {
-        throw new Error('Failed to create collection without description');
-      }
+    it('should search collections with no description', async () => {
+      // Create a collection without description using CollectionBuilder
+      const collection = new CollectionBuilder()
+        .withName('No Description Collection')
+        .withAuthorId(curatorId.value)
+        .withAccessType(CollectionAccessType.OPEN)
+        .withPublished(true)
+        .buildOrThrow();
 
-      await collectionRepo.save(collectionResult.value);
+      await collectionRepo.save(collection);
 
       const query = {
         curatorId: curatorId.value,
···
       const response = result.unwrap();
       expect(response.collections).toHaveLength(1);
       expect(response.collections[0]!.name).toBe('No Description Collection');
+    });
+  });
+
+  describe('URI validation', () => {
+    it('should return consistent URIs across multiple calls', async () => {
+      // Create a test collection using CollectionBuilder
+      const collection = new CollectionBuilder()
+        .withName('Consistent URI Test')
+        .withDescription('Testing URI consistency')
+        .withAuthorId(curatorId.value)
+        .withAccessType(CollectionAccessType.OPEN)
+        .withPublished(true)
+        .buildOrThrow();
+
+      await collectionRepo.save(collection);
+
+      const query = {
+        curatorId: curatorId.value,
+      };
+
+      // Execute the same query twice
+      const result1 = await useCase.execute(query);
+      const result2 = await useCase.execute(query);
+
+      expect(result1.isOk()).toBe(true);
+      expect(result2.isOk()).toBe(true);
+
+      const response1 = result1.unwrap();
+      const response2 = result2.unwrap();
+
+      expect(response1.collections).toHaveLength(1);
+      expect(response2.collections).toHaveLength(1);
+
+      // URIs should be consistent across calls
+      expect(response1.collections[0]!.uri).toBe(response2.collections[0]!.uri);
     });
   });
 

src/modules/cards/tests/infrastructure/DrizzleCollectionQueryRepository.integration.test.ts

···
   SortOrder,
 } from '../../domain/ICollectionQueryRepository';
 import { createTestSchema } from '../test-utils/createTestSchema';
+import { CollectionBuilder } from '../utils/builders/CollectionBuilder';
+import { FakeCollectionPublisher } from '../utils/FakeCollectionPublisher';
 
 describe('DrizzleCollectionQueryRepository', () => {
   let container: StartedPostgreSqlContainer;
···
   let queryRepository: DrizzleCollectionQueryRepository;
   let collectionRepository: DrizzleCollectionRepository;
   let cardRepository: DrizzleCardRepository;
+  let fakePublisher: FakeCollectionPublisher;
 
   // Test data
   let curatorId: CuratorId;
···
     queryRepository = new DrizzleCollectionQueryRepository(db);
     collectionRepository = new DrizzleCollectionRepository(db);
     cardRepository = new DrizzleCardRepository(db);
+    fakePublisher = new FakeCollectionPublisher();
 
     // Create schema using helper function
     await createTestSchema(db);
···
     await db.delete(libraryMemberships);
     await db.delete(cards);
     await db.delete(publishedRecords);
+    // Clear fake publisher state between tests
+    fakePublisher.clear();
   });
 
   describe('findByCreator', () => {
···
       });
 
       expect(result.items).toHaveLength(2);
+    });
+  });
+
+  describe('published record URIs', () => {
+    it('should return empty string for collections without published records', async () => {
+      const collection = Collection.create(
+        {
+          authorId: curatorId,
+          name: 'Unpublished Collection',
+          accessType: CollectionAccessType.OPEN,
+          collaboratorIds: [],
+          createdAt: new Date(),
+          updatedAt: new Date(),
+        },
+        new UniqueEntityID(),
+      ).unwrap();
+
+      await collectionRepository.save(collection);
+
+      const result = await queryRepository.findByCreator(curatorId.value, {
+        page: 1,
+        limit: 10,
+        sortBy: CollectionSortField.UPDATED_AT,
+        sortOrder: SortOrder.DESC,
+      });
+
+      expect(result.items).toHaveLength(1);
+      expect(result.items[0]?.uri).toBeUndefined();
+    });
+
+    it('should return URI for collections with published records', async () => {
+      const testUri =
+        'at://did:plc:testcurator/network.cosmik.collection/test123';
+      const testCid = 'bafytest123';
+
+      // Create collection using builder
+      const collection = new CollectionBuilder()
+        .withAuthorId(curatorId.value)
+        .withName('Published Collection')
+        .withAccessType(CollectionAccessType.OPEN)
+        .buildOrThrow();
+
+      // Publish the collection using the fake publisher
+      const publishResult = await fakePublisher.publish(collection);
+      expect(publishResult.isOk()).toBe(true);
+
+      const publishedRecordId = publishResult.unwrap();
+
+      // Mark the collection as published in the domain model
+      collection.markAsPublished(publishedRecordId);
+
+      // Save the collection
+      await collectionRepository.save(collection);
+
+      const result = await queryRepository.findByCreator(curatorId.value, {
+        page: 1,
+        limit: 10,
+        sortBy: CollectionSortField.UPDATED_AT,
+        sortOrder: SortOrder.DESC,
+      });
+
+      expect(result.items).toHaveLength(1);
+      expect(result.items[0]?.uri).toBe(publishedRecordId.uri);
+      expect(result.items[0]?.name).toBe('Published Collection');
+    });
+
+    it('should handle mix of published and unpublished collections', async () => {
+      // Create published collection using builder
+      const publishedCollection = new CollectionBuilder()
+        .withAuthorId(curatorId.value)
+        .withName('Published Collection')
+        .withAccessType(CollectionAccessType.OPEN)
+        .withCreatedAt(new Date('2023-01-01'))
+        .withUpdatedAt(new Date('2023-01-01'))
+        .buildOrThrow();
+
+      // Create unpublished collection using builder
+      const unpublishedCollection = new CollectionBuilder()
+        .withAuthorId(curatorId.value)
+        .withName('Unpublished Collection')
+        .withAccessType(CollectionAccessType.OPEN)
+        .withCreatedAt(new Date('2023-01-02'))
+        .withUpdatedAt(new Date('2023-01-02'))
+        .buildOrThrow();
+
+      // Publish the first collection using the fake publisher
+      const publishResult = await fakePublisher.publish(publishedCollection);
+      expect(publishResult.isOk()).toBe(true);
+
+      const publishedRecordId = publishResult.unwrap();
+
+      // Mark the collection as published in the domain model
+      publishedCollection.markAsPublished(publishedRecordId);
+
+      // Save both collections
+      await collectionRepository.save(publishedCollection);
+      await collectionRepository.save(unpublishedCollection);
+
+      const result = await queryRepository.findByCreator(curatorId.value, {
+        page: 1,
+        limit: 10,
+        sortBy: CollectionSortField.UPDATED_AT,
+        sortOrder: SortOrder.DESC,
+      });
+
+      expect(result.items).toHaveLength(2);
+
+      // Find collections by name and check URIs
+      const publishedItem = result.items.find(
+        (item) => item.name === 'Published Collection',
+      );
+      const unpublishedItem = result.items.find(
+        (item) => item.name === 'Unpublished Collection',
+      );
+
+      expect(publishedItem?.uri).toBe(publishedRecordId.uri);
+      expect(unpublishedItem?.uri).toBeUndefined();
     });
   });
 

src/modules/cards/tests/test-utils/createTestSchema.ts

···
   await db.execute(sql`
     CREATE INDEX IF NOT EXISTS idx_feed_activities_actor_id ON feed_activities(actor_id);
   `);
+
+  // Index for efficient AT URI lookups
+  await db.execute(sql`
+    CREATE INDEX IF NOT EXISTS published_records_uri_idx ON published_records(uri);
+  `);
 }

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

···
+import { Result, ok, err } from '../../../../shared/core/Result';
+import {
+  IAtUriResolutionService,
+  AtUriResourceType,
+  AtUriResolutionResult,
+} from '../../domain/services/IAtUriResolutionService';
+import { CollectionId } from '../../domain/value-objects/CollectionId';
+import { InMemoryCollectionRepository } from './InMemoryCollectionRepository';
+
+export class InMemoryAtUriResolutionService implements IAtUriResolutionService {
+  constructor(private collectionRepository: InMemoryCollectionRepository) {}
+
+  async resolveAtUri(
+    atUri: string,
+  ): Promise<Result<AtUriResolutionResult | null>> {
+    try {
+      // Get all collections and check if any have a published record with this URI
+      const allCollections = this.collectionRepository.getAllCollections();
+
+      for (const collection of allCollections) {
+        if (collection.publishedRecordId?.uri === atUri) {
+          return ok({
+            type: AtUriResourceType.COLLECTION,
+            id: collection.collectionId,
+          });
+        }
+      }
+
+      return ok(null);
+    } catch (error) {
+      return err(error as Error);
+    }
+  }
+
+  async resolveCollectionId(
+    atUri: string,
+  ): Promise<Result<CollectionId | null>> {
+    const result = await this.resolveAtUri(atUri);
+
+    if (result.isErr()) {
+      return err(result.error);
+    }
+
+    if (!result.value || result.value.type !== AtUriResourceType.COLLECTION) {
+      return ok(null);
+    }
+
+    return ok(result.value.id as CollectionId);
+  }
+}

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

···
 
       // Transform to DTOs
       const items: CollectionQueryResultDTO[] = paginatedCollections.map(
-        (collection) => ({
-          id: collection.collectionId.getStringValue(),
-          authorId: collection.authorId.value,
-          name: collection.name.value,
-          description: collection.description?.value,
-          accessType: collection.accessType,
-          cardCount: collection.cardCount,
-          createdAt: collection.createdAt,
-          updatedAt: collection.updatedAt,
-        }),
+        (collection) => {
+          const collectionPublishedRecordId = collection.publishedRecordId;
+          return {
+            id: collection.collectionId.getStringValue(),
+            uri: collectionPublishedRecordId?.uri,
+            authorId: collection.authorId.value,
+            name: collection.name.value,
+            description: collection.description?.value,
+            accessType: collection.accessType,
+            cardCount: collection.cardCount,
+            createdAt: collection.createdAt,
+            updatedAt: collection.updatedAt,
+          };
+        },
       );
 
       return {

src/shared/infrastructure/database/migrations/0003_harsh_lady_mastermind.sql

···
+CREATE INDEX "published_records_uri_idx" ON "published_records" USING btree ("uri");

src/shared/infrastructure/database/migrations/meta/0003_snapshot.json

···
+{
+  "id": "69abc7ad-c872-43e9-8e83-4d9362cf62c7",
+  "prevId": "91872a6a-78f5-4bf2-a7ec-691199cdf62b",
+  "version": "7",
+  "dialect": "postgresql",
+  "tables": {
+    "public.app_password_sessions": {
+      "name": "app_password_sessions",
+      "schema": "",
+      "columns": {
+        "did": {
+          "name": "did",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "session_data": {
+          "name": "session_data",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "app_password": {
+          "name": "app_password",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.cards": {
+      "name": "cards",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "type": {
+          "name": "type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "content_data": {
+          "name": "content_data",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "url": {
+          "name": "url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "parent_card_id": {
+          "name": "parent_card_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "original_published_record_id": {
+          "name": "original_published_record_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "library_count": {
+          "name": "library_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "cards_parent_card_id_cards_id_fk": {
+          "name": "cards_parent_card_id_cards_id_fk",
+          "tableFrom": "cards",
+          "tableTo": "cards",
+          "columnsFrom": ["parent_card_id"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        },
+        "cards_original_published_record_id_published_records_id_fk": {
+          "name": "cards_original_published_record_id_published_records_id_fk",
+          "tableFrom": "cards",
+          "tableTo": "published_records",
+          "columnsFrom": ["original_published_record_id"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.collection_cards": {
+      "name": "collection_cards",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "collection_id": {
+          "name": "collection_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "card_id": {
+          "name": "card_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "added_by": {
+          "name": "added_by",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "added_at": {
+          "name": "added_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "published_record_id": {
+          "name": "published_record_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "collection_cards_collection_id_collections_id_fk": {
+          "name": "collection_cards_collection_id_collections_id_fk",
+          "tableFrom": "collection_cards",
+          "tableTo": "collections",
+          "columnsFrom": ["collection_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "collection_cards_card_id_cards_id_fk": {
+          "name": "collection_cards_card_id_cards_id_fk",
+          "tableFrom": "collection_cards",
+          "tableTo": "cards",
+          "columnsFrom": ["card_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "collection_cards_published_record_id_published_records_id_fk": {
+          "name": "collection_cards_published_record_id_published_records_id_fk",
+          "tableFrom": "collection_cards",
+          "tableTo": "published_records",
+          "columnsFrom": ["published_record_id"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.collection_collaborators": {
+      "name": "collection_collaborators",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "collection_id": {
+          "name": "collection_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "collaborator_id": {
+          "name": "collaborator_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "collection_collaborators_collection_id_collections_id_fk": {
+          "name": "collection_collaborators_collection_id_collections_id_fk",
+          "tableFrom": "collection_collaborators",
+          "tableTo": "collections",
+          "columnsFrom": ["collection_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.collections": {
+      "name": "collections",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "author_id": {
+          "name": "author_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "access_type": {
+          "name": "access_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "card_count": {
+          "name": "card_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "published_record_id": {
+          "name": "published_record_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "collections_published_record_id_published_records_id_fk": {
+          "name": "collections_published_record_id_published_records_id_fk",
+          "tableFrom": "collections",
+          "tableTo": "published_records",
+          "columnsFrom": ["published_record_id"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.library_memberships": {
+      "name": "library_memberships",
+      "schema": "",
+      "columns": {
+        "card_id": {
+          "name": "card_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "added_at": {
+          "name": "added_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "published_record_id": {
+          "name": "published_record_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "idx_user_cards": {
+          "name": "idx_user_cards",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "idx_card_users": {
+          "name": "idx_card_users",
+          "columns": [
+            {
+              "expression": "card_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "library_memberships_card_id_cards_id_fk": {
+          "name": "library_memberships_card_id_cards_id_fk",
+          "tableFrom": "library_memberships",
+          "tableTo": "cards",
+          "columnsFrom": ["card_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "library_memberships_published_record_id_published_records_id_fk": {
+          "name": "library_memberships_published_record_id_published_records_id_fk",
+          "tableFrom": "library_memberships",
+          "tableTo": "published_records",
+          "columnsFrom": ["published_record_id"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "library_memberships_card_id_user_id_pk": {
+          "name": "library_memberships_card_id_user_id_pk",
+          "columns": ["card_id", "user_id"]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.published_records": {
+      "name": "published_records",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "uri": {
+          "name": "uri",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "cid": {
+          "name": "cid",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "recorded_at": {
+          "name": "recorded_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "uri_cid_unique_idx": {
+          "name": "uri_cid_unique_idx",
+          "columns": [
+            {
+              "expression": "uri",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "cid",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "published_records_uri_idx": {
+          "name": "published_records_uri_idx",
+          "columns": [
+            {
+              "expression": "uri",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.feed_activities": {
+      "name": "feed_activities",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "actor_id": {
+          "name": "actor_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "type": {
+          "name": "type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "metadata": {
+          "name": "metadata",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.auth_session": {
+      "name": "auth_session",
+      "schema": "",
+      "columns": {
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "session": {
+          "name": "session",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.auth_state": {
+      "name": "auth_state",
+      "schema": "",
+      "columns": {
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "state": {
+          "name": "state",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.auth_refresh_tokens": {
+      "name": "auth_refresh_tokens",
+      "schema": "",
+      "columns": {
+        "token_id": {
+          "name": "token_id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_did": {
+          "name": "user_did",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "refresh_token": {
+          "name": "refresh_token",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "issued_at": {
+          "name": "issued_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "revoked": {
+          "name": "revoked",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "auth_refresh_tokens_user_did_users_id_fk": {
+          "name": "auth_refresh_tokens_user_did_users_id_fk",
+          "tableFrom": "auth_refresh_tokens",
+          "tableTo": "users",
+          "columnsFrom": ["user_did"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.users": {
+      "name": "users",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "handle": {
+          "name": "handle",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "linked_at": {
+          "name": "linked_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "last_login_at": {
+          "name": "last_login_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    }
+  },
+  "enums": {},
+  "schemas": {},
+  "sequences": {},
+  "roles": {},
+  "policies": {},
+  "views": {},
+  "_meta": {
+    "columns": {},
+    "schemas": {},
+    "tables": {}
+  }
+}

src/shared/infrastructure/database/migrations/meta/_journal.json

···
       "when": 1754082459527,
       "tag": "0002_hesitant_caretaker",
       "breakpoints": true
+    },
+    {
+      "idx": 3,
+      "version": "7",
+      "when": 1758934838107,
+      "tag": "0003_harsh_lady_mastermind",
+      "breakpoints": true
     }
   ]
 }

src/shared/infrastructure/http/app.ts

···
     controllers.updateCollectionController,
     controllers.deleteCollectionController,
     controllers.getCollectionPageController,
+    controllers.getCollectionPageByAtUriController,
     controllers.getMyCollectionsController,
     controllers.getCollectionsController,
   );

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

···
 import { LogoutController } from 'src/modules/user/infrastructure/http/controllers/LogoutController';
 import { GenerateExtensionTokensController } from 'src/modules/user/infrastructure/http/controllers/GenerateExtensionTokensController';
 import { GetUserCollectionsController } from 'src/modules/cards/infrastructure/http/controllers/GetUserCollectionsController';
+import { GetCollectionPageByAtUriController } from 'src/modules/cards/infrastructure/http/controllers/GetCollectionPageByAtUriController';
 
 export interface Controllers {
   // User controllers
···
   updateCollectionController: UpdateCollectionController;
   deleteCollectionController: DeleteCollectionController;
   getCollectionPageController: GetCollectionPageController;
+  getCollectionPageByAtUriController: GetCollectionPageByAtUriController;
   getMyCollectionsController: GetMyCollectionsController;
   getCollectionsController: GetUserCollectionsController;
   // Feed controllers
···
       getCollectionPageController: new GetCollectionPageController(
         useCases.getCollectionPageUseCase,
       ),
+      getCollectionPageByAtUriController:
+        new GetCollectionPageByAtUriController(
+          useCases.getCollectionPageByAtUriUseCase,
+        ),
       getMyCollectionsController: new GetMyCollectionsController(
         useCases.getCollectionsUseCase,
       ),

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

···
 import { DrizzleFeedRepository } from '../../../../modules/feeds/infrastructure/repositories/DrizzleFeedRepository';
 import { InMemoryFeedRepository } from '../../../../modules/feeds/tests/infrastructure/InMemoryFeedRepository';
 import { IFeedRepository } from '../../../../modules/feeds/domain/IFeedRepository';
+import { IAtUriResolutionService } from '../../../../modules/cards/domain/services/IAtUriResolutionService';
+import { DrizzleAtUriResolutionService } from '../../../../modules/cards/infrastructure/services/DrizzleAtUriResolutionService';
+import { InMemoryAtUriResolutionService } from '../../../../modules/cards/tests/utils/InMemoryAtUriResolutionService';
 
 export interface Repositories {
   userRepository: IUserRepository;
···
   collectionQueryRepository: ICollectionQueryRepository;
   appPasswordSessionRepository: IAppPasswordSessionRepository;
   feedRepository: IFeedRepository;
+  atUriResolutionService: IAtUriResolutionService;
   oauthStateStore: NodeSavedStateStore;
   oauthSessionStore: NodeSavedSessionStore;
 }
···
       const appPasswordSessionRepository =
         new InMemoryAppPasswordSessionRepository();
       const feedRepository = InMemoryFeedRepository.getInstance();
+      const atUriResolutionService = new InMemoryAtUriResolutionService(
+        collectionRepository,
+      );
       const oauthStateStore = new InMemoryStateStore();
       const oauthSessionStore = new InMemorySessionStore();
 
···
         collectionQueryRepository,
         appPasswordSessionRepository,
         feedRepository,
+        atUriResolutionService,
         oauthStateStore,
         oauthSessionStore,
       };
···
       collectionQueryRepository: new DrizzleCollectionQueryRepository(db),
       appPasswordSessionRepository: new DrizzleAppPasswordSessionRepository(db),
       feedRepository: new DrizzleFeedRepository(db),
+      atUriResolutionService: new DrizzleAtUriResolutionService(db),
       oauthStateStore,
       oauthSessionStore,
     };

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

···
 import { GetGlobalFeedUseCase } from '../../../../modules/feeds/application/useCases/queries/GetGlobalFeedUseCase';
 import { AddActivityToFeedUseCase } from '../../../../modules/feeds/application/useCases/commands/AddActivityToFeedUseCase';
 import { GetCollectionsUseCase } from 'src/modules/cards/application/useCases/queries/GetCollectionsUseCase';
+import { GetCollectionPageByAtUriUseCase } from 'src/modules/cards/application/useCases/queries/GetCollectionPageByAtUriUseCase';
 
 export interface UseCases {
   // User use cases
···
   updateCollectionUseCase: UpdateCollectionUseCase;
   deleteCollectionUseCase: DeleteCollectionUseCase;
   getCollectionPageUseCase: GetCollectionPageUseCase;
+  getCollectionPageByAtUriUseCase: GetCollectionPageByAtUriUseCase;
   getCollectionsUseCase: GetCollectionsUseCase;
   // Feed use cases
   getGlobalFeedUseCase: GetGlobalFeedUseCase;
···
     repositories: Repositories,
     services: Services,
   ): UseCases {
+    const getCollectionPageUseCase = new GetCollectionPageUseCase(
+      repositories.collectionRepository,
+      repositories.cardQueryRepository,
+      services.profileService,
+    );
+
     return {
       // User use cases
       loginWithAppPasswordUseCase: new LoginWithAppPasswordUseCase(
···
         repositories.collectionRepository,
         services.collectionPublisher,
       ),
-      getCollectionPageUseCase: new GetCollectionPageUseCase(
-        repositories.collectionRepository,
-        repositories.cardQueryRepository,
-        services.profileService,
+      getCollectionPageUseCase,
+      getCollectionPageByAtUriUseCase: new GetCollectionPageByAtUriUseCase(
+        services.identityResolutionService,
+        repositories.atUriResolutionService,
+        getCollectionPageUseCase,
       ),
       getCollectionsUseCase: new GetCollectionsUseCase(
         repositories.collectionQueryRepository,

src/webapp/api-client/ApiClient.ts

···
   GenerateExtensionTokensRequest,
   GetMyUrlCardsParams,
   GetCollectionPageParams,
+  GetCollectionPageByAtUriParams,
   GetMyCollectionsParams,
   GetGlobalFeedParams,
   // Response types
···
     params?: GetCollectionPageParams,
   ): Promise<GetCollectionPageResponse> {
     return this.queryClient.getCollectionPage(collectionId, params);
+  }
+
+  async getCollectionPageByAtUri(
+    params: GetCollectionPageByAtUriParams,
+  ): Promise<GetCollectionPageResponse> {
+    return this.queryClient.getCollectionPageByAtUri(params);
   }
 
   async getMyCollections(

src/webapp/api-client/clients/QueryClient.ts

···
   GetCollectionPageParams,
   GetMyCollectionsParams,
   GetCollectionsParams,
+  GetCollectionPageByAtUriParams,
   GetProfileParams,
 } from '../types';
 
···
     const endpoint = queryString
       ? `/api/collections/${collectionId}?${queryString}`
       : `/api/collections/${collectionId}`;
+
+    return this.request<GetCollectionPageResponse>('GET', endpoint);
+  }
+
+  async getCollectionPageByAtUri(
+    params: GetCollectionPageByAtUriParams,
+  ): Promise<GetCollectionPageResponse> {
+    const { handle, recordKey, ...queryParams } = params;
+    const searchParams = new URLSearchParams();
+
+    if (queryParams.page) searchParams.set('page', queryParams.page.toString());
+    if (queryParams.limit)
+      searchParams.set('limit', queryParams.limit.toString());
+    if (queryParams.sortBy) searchParams.set('sortBy', queryParams.sortBy);
+    if (queryParams.sortOrder)
+      searchParams.set('sortOrder', queryParams.sortOrder);
+
+    const queryString = searchParams.toString();
+    const endpoint = queryString
+      ? `/api/collections/at/${handle}/${recordKey}?${queryString}`
+      : `/api/collections/at/${handle}/${recordKey}`;
 
     return this.request<GetCollectionPageResponse>('GET', endpoint);
   }

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

···
   searchText?: string;
 }
 
+export interface GetCollectionPageByAtUriParams {
+  handle: string;
+  recordKey: string;
+  page?: number;
+  limit?: number;
+  sortBy?: string;
+  sortOrder?: 'asc' | 'desc';
+}
+
 // Feed request types
 export interface GetGlobalFeedParams {
   page?: number;

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

···
 
 export interface GetCollectionPageResponse {
   id: string;
+  uri?: string;
   name: string;
   description?: string;
   author: {
···
 }
 
 export interface GetCollectionsResponse {
-  collections: Array<{
+  collections: {
     id: string;
+    uri?: string;
     name: string;
     description?: string;
     cardCount: number;
···
       handle: string;
       avatarUrl?: string;
     };
-  }>;
+  }[];
   pagination: Pagination;
   sorting: {
     sortBy: 'name' | 'createdAt' | 'updatedAt' | 'cardCount';