@woltz/rich-domain 0.2.1 → 0.2.2

package/src/repository/base-repository.ts

@@ -2,12 +2,10 @@
 // Base Repository - Abstract implementation with common logic
 // ============================================================================
 
-import type { Id } from "../id";
 import type { Aggregate } from "../entity";
 import type { Criteria } from "../criteria";
 import { PaginatedResult } from "../paginated-result";
-import type { IRepository } from "../types";
-import type { IMapper } from "./mapper";
+import { Mapper } from "../mapper";
 
 /**
  * Abstract base repository
@@ -33,120 +31,34 @@ import type { IMapper } from "./mapper";
  * }
  * ```
  */
-export abstract class BaseRepository<
-  TDomain extends Aggregate<any>,
-  TPersistence = any
-> implements IRepository<TDomain>
-{
-  constructor(protected readonly mapper: IMapper<TDomain, TPersistence>) {}
 
-  // ============================================================================
-  // Abstract methods - Must be implemented by subclasses
-  // ============================================================================
-
-  /**
-   * Insert new record in database
-   */
-  protected abstract insertOne(data: TPersistence): Promise<TPersistence>;
-
-  /**
-   * Update existing record in database
-   */
-  protected abstract updateOne(
-    id: string,
-    data: TPersistence
-  ): Promise<TPersistence>;
-
-  /**
-   * Delete record from database
-   */
-  protected abstract deleteOne(id: string): Promise<void>;
-
-  /**
-   * Find record by ID in database
-   */
-  protected abstract findOneById(id: string): Promise<TDomain | null>;
-
-  /**
-   * Find all records in database (no filtering)
-   */
-  protected abstract findMany(): Promise<TDomain[]>;
-
-  /**
-   * Apply criteria to query (filtering, ordering, pagination)
-   * Returns [data, total]
-   */
-  protected abstract applyCriteria(
-    criteria: Criteria<TDomain>
-  ): Promise<PaginatedResult<TDomain>>;
-
-  /**
-   * Count records matching criteria
-   */
-  protected abstract countByCriteria(
-    criteria?: Criteria<TDomain>
-  ): Promise<number>;
-
-  /**
-   * Check if record exists by ID
-   */
-  protected abstract existsById(id: string): Promise<boolean>;
-
-  // ============================================================================
-  // Public API - Implemented using abstract methods
-  // ============================================================================
-
-  async findById(id: Id): Promise<TDomain | null> {
-    const domain = await this.findOneById(id.value);
-    if (!domain) return null;
-    return domain;
-  }
-
-  async find(criteria: Criteria<TDomain>): Promise<PaginatedResult<TDomain>> {
-    return await this.applyCriteria(criteria);
-  }
-
-  async findAll(criteria?: Criteria<TDomain>): Promise<TDomain[]> {
-    if (criteria) {
-      const result = await this.find(criteria);
-      return result.data;
-    }
-
-    const domains = await this.findMany();
-    return domains;
-  }
-
-  async findOne(criteria: Criteria<TDomain>): Promise<TDomain | null> {
-    // Limit to 1 result
-    const limitedCriteria = criteria.clone().limit(1);
-    const result = await this.find(limitedCriteria);
-
-    return result.data.length > 0 ? result.data[0] : null;
-  }
-
-  async save(aggregate: TDomain): Promise<void> {
-    const persistence = this.mapper.toPersistence(aggregate);
-
-    if (aggregate.isNew) {
-      await this.insertOne(persistence);
-    } else {
-      await this.updateOne(aggregate.id.value, persistence);
-    }
-  }
-
-  async delete(aggregate: TDomain): Promise<void> {
-    await this.deleteOne(aggregate.id.value);
-  }
+export abstract class ReadRepository<Agg extends Aggregate<any>> {
+  abstract find(criteria: Criteria<Agg>): Promise<PaginatedResult<Agg>>;
+  abstract findById(id: string): Promise<Agg | null>;
+  abstract count(criteria: Criteria<Agg>): Promise<number>;
+  abstract exists(id: string): Promise<boolean>;
+}
 
-  async deleteById(id: Id): Promise<void> {
-    await this.deleteOne(id.value);
-  }
+export abstract class WriteRepository<Agg extends Aggregate<any>> {
+  abstract create(entity: Agg): Promise<void>;
+  abstract update(entity: Agg): Promise<void>;
+  abstract delete(entity: Agg): Promise<void>;
+}
 
-  async exists(id: Id): Promise<boolean> {
-    return this.existsById(id.value);
-  }
+export abstract class WriteAndRead<Agg extends Aggregate<any>> {
+  abstract find(criteria: Criteria<Agg>): Promise<PaginatedResult<Agg>>;
+  abstract findById(id: string): Promise<Agg | null>;
+  abstract create(entity: Agg): Promise<void>;
+  abstract update(entity: Agg): Promise<void>;
+  abstract delete(entity: Agg): Promise<void>;
+  abstract count(criteria: Criteria<Agg>): Promise<number>;
+  abstract exists(id: string): Promise<boolean>;
+}
 
-  async count(criteria?: Criteria<TDomain>): Promise<number> {
-    return this.countByCriteria(criteria);
-  }
+export abstract class Repository<
+  TDomain extends Aggregate<any>
+> extends WriteAndRead<TDomain> {
+  protected abstract readonly mapperToDomain: Mapper<unknown, TDomain>;
+  protected abstract readonly mapperToPersistence: Mapper<TDomain, unknown>;
+  abstract get model(): any;
 }

package/src/repository/in-memory-repository.ts

@@ -2,11 +2,11 @@
 // In-Memory Repository - Perfect for testing
 // ============================================================================
 
-import type { Id } from "../id";
 import type { Aggregate } from "../entity";
 import type { Criteria } from "../criteria";
 import { PaginatedResult } from "../paginated-result";
-import type { IRepository } from "../types";
+import { Repository } from "./base-repository";
+import { Mapper } from "../mapper";
 
 /**
  * In-memory repository implementation
@@ -23,13 +23,25 @@ import type { IRepository } from "../types";
  * );
  * ```
  */
-export class InMemoryRepository<TDomain extends Aggregate<any>>
-  implements IRepository<TDomain>
-{
+export class InMemoryRepository<
+  TDomain extends Aggregate<any>
+> extends Repository<TDomain> {
   protected items: Map<string, TDomain> = new Map();
 
-  async findById(id: Id): Promise<TDomain | null> {
-    return this.items.get(id.value) || null;
+  constructor(
+    protected readonly mapperToDomain: Mapper<unknown, TDomain>,
+    protected readonly mapperToPersistence: Mapper<TDomain, unknown>
+  ) {
+    super();
+  }
+
+  get model(): any {
+    // your database table name
+    return "inMemory";
+  }
+
+  async findById(id: string): Promise<TDomain | null> {
+    return this.items.get(id) || null;
   }
 
   async find(criteria: Criteria<TDomain>): Promise<PaginatedResult<TDomain>> {
@@ -51,13 +63,17 @@ export class InMemoryRepository<TDomain extends Aggregate<any>>
     return result.data.length > 0 ? result.data[0] : null;
   }
 
-  async save(aggregate: TDomain): Promise<void> {
+  async create(aggregate: TDomain): Promise<void> {
     this.items.set(aggregate.id.value, aggregate);
   }
 
-  async saveMany(aggregates: TDomain[]): Promise<void> {
+  async update(entity: TDomain): Promise<void> {
+    this.items.set(entity.id.value, entity);
+  }
+
+  async createMany(aggregates: TDomain[]): Promise<void> {
     for (const aggregate of aggregates) {
-      await this.save(aggregate);
+      await this.create(aggregate);
     }
   }
 
@@ -65,12 +81,8 @@ export class InMemoryRepository<TDomain extends Aggregate<any>>
     this.items.delete(aggregate.id.value);
   }
 
-  async deleteById(id: Id): Promise<void> {
-    this.items.delete(id.value);
-  }
-
-  async exists(id: Id): Promise<boolean> {
-    return this.items.has(id.value);
+  async exists(id: string): Promise<boolean> {
+    return this.items.has(id);
   }
 
   async count(criteria?: Criteria<TDomain>): Promise<number> {

package/src/repository/index.ts

@@ -3,11 +3,10 @@
 // ============================================================================
 
 // Mapper
-export { BaseMapper } from "./mapper";
-export type { IMapper } from "./mapper";
+export { Mapper } from "../mapper";
 
 // Base implementations
-export { BaseRepository } from "./base-repository";
+export { Repository as BaseRepository } from "./base-repository";
 export { InMemoryRepository } from "./in-memory-repository";
 
 // Unit of Work

package/src/types/index.ts

@@ -3,5 +3,4 @@ export * from "./domain";
 export * from "./history-tracker";
 export * from "./standard-schema";
 export * from "./utils";
-export * from "./repository";
 export * from "./unit-of-work";

package/src/types/unit-of-work.ts

@@ -1,5 +1,5 @@
 import { Aggregate } from "../entity";
-import { IRepository } from "./repository";
+import { Repository } from "../repository/base-repository";
 
 /**
  * Transaction context for Unit of Work
@@ -41,6 +41,6 @@ export interface IUnitOfWork {
    * Get repository within transaction context
    */
   getRepository<TDomain extends Aggregate<any>>(
-    repository: new (...args: any[]) => IRepository<TDomain>
-  ): IRepository<TDomain>;
+    repository: new (...args: any[]) => Repository<TDomain>
+  ): Repository<TDomain>;
 }

package/tests/repository.test.ts

@@ -1,9 +1,6 @@
 import { Id, Aggregate, Criteria, BaseProps, PaginatedResult } from "../src";
-import {
-  InMemoryRepository,
-  BaseRepository,
-  BaseMapper,
-} from "../src/repository";
+import { InMemoryRepository, Mapper } from "../src/repository";
+import { Repository } from "../src/repository/base-repository";
 
 // ============================================================================
 // Test Domain Models
@@ -73,9 +70,8 @@ type UserPersistence = {
 // ============================================================================
 // Mapper Implementation
 // ============================================================================
-
-class UserMapper extends BaseMapper<User, UserPersistence> {
-  toDomain(persistence: UserPersistence): User {
+class UserToDomainMapper extends Mapper<UserPersistence, User> {
+  public build(persistence: UserPersistence): User {
     return User.create({
       id: Id.from(persistence.id),
       name: persistence.name,
@@ -84,8 +80,10 @@ class UserMapper extends BaseMapper<User, UserPersistence> {
       status: persistence.status as "active" | "inactive",
     });
   }
+}
 
-  toPersistence(domain: User): UserPersistence {
+class UserToPersistenceMapper extends Mapper<User, UserPersistence> {
+  public build(domain: User): UserPersistence {
     return {
       id: domain.id.value,
       name: domain.name,
@@ -102,41 +100,51 @@ class UserMapper extends BaseMapper<User, UserPersistence> {
 // Mock Repository Implementation
 // ============================================================================
 
-class MockUserRepository extends BaseRepository<User, UserPersistence> {
+class MockUserRepository extends Repository<User> {
   private store: Map<string, UserPersistence> = new Map();
 
-  constructor() {
-    super(new UserMapper());
+  constructor(
+    protected readonly mapperToDomain: Mapper<UserPersistence, User>,
+    protected readonly mapperToPersistence: Mapper<User, UserPersistence>
+  ) {
+    super();
+  }
+
+  get model() {
+    return "users";
   }
 
-  protected async insertOne(data: UserPersistence): Promise<UserPersistence> {
-    this.store.set(data.id, data);
-    return data;
+  async create(entity: User) {
+    const persistence = this.mapperToPersistence.build(entity);
+    this.store.set(entity.id.value, persistence);
   }
 
-  protected async updateOne(
-    id: string,
-    data: UserPersistence
-  ): Promise<UserPersistence> {
-    this.store.set(id, { ...data, updatedAt: new Date() });
-    return data;
+  async delete(entity: User): Promise<void> {
+    this.store.delete(entity.id.value);
   }
 
-  protected async deleteOne(id: string): Promise<void> {
-    this.store.delete(id);
+  async count(criteria: Criteria<User>): Promise<number> {
+    return this.applyCriteria(criteria).then((result) => result.meta.total);
+  }
+
+  async exists(id: string): Promise<boolean> {
+    return this.store.has(id);
   }
 
-  protected async findOneById(id: string): Promise<User | null> {
+  async find(criteria: Criteria<User>): Promise<PaginatedResult<User>> {
+    const result = await this.applyCriteria(criteria);
+    return result;
+  }
+
+  async findById(id: string): Promise<User | null> {
     const persistence = this.store.get(id);
     if (!persistence) return null;
-    return this.mapper.toDomain(persistence);
+    return this.mapperToDomain.build(persistence);
   }
 
-  protected async findMany(): Promise<User[]> {
-    const persistence = Array.from(this.store.values());
-    return this.mapper.toDomainList
-      ? this.mapper.toDomainList(persistence)
-      : persistence.map((p) => this.mapper.toDomain(p));
+  async update(entity: User): Promise<void> {
+    const persistence = this.mapperToPersistence.build(entity);
+    this.store.set(entity.id.value, persistence);
   }
 
   protected async applyCriteria(criteria: Criteria<User>) {
@@ -183,9 +191,7 @@ class MockUserRepository extends BaseRepository<User, UserPersistence> {
       pagination.offset + pagination.limit
     );
 
-    const domains = this.mapper.toDomainList
-      ? this.mapper.toDomainList(results)
-      : results.map((p) => this.mapper.toDomain(p));
+    const domains = results.map((p) => this.mapperToDomain.build(p));
 
     return PaginatedResult.create(domains, pagination, total);
   }
@@ -221,7 +227,10 @@ describe("Repository", () => {
     let user3: User;
 
     beforeEach(() => {
-      repository = new InMemoryRepository<User>();
+      repository = new InMemoryRepository<User>(
+        new UserToDomainMapper(),
+        new UserToPersistenceMapper()
+      );
 
       user1 = User.create({
         name: "Alice",
@@ -251,8 +260,8 @@ describe("Repository", () => {
 
     describe("save and findById", () => {
       it("should save and retrieve user", async () => {
-        await repository.save(user1);
-        const found = await repository.findById(user1.id);
+        await repository.create(user1);
+        const found = await repository.findById(user1.id.value);
 
         expect(found).toBeDefined();
         expect(found?.id.equals(user1.id)).toBe(true);
@@ -260,16 +269,16 @@ describe("Repository", () => {
       });
 
       it("should return null for non-existent id", async () => {
-        const found = await repository.findById(new Id());
+        const found = await repository.findById(new Id().value);
         expect(found).toBeNull();
       });
 
       it("should update existing user", async () => {
-        await repository.save(user1);
+        await repository.create(user1);
         user1.setName("Alice Updated");
-        await repository.save(user1);
+        await repository.create(user1);
 
-        const found = await repository.findById(user1.id);
+        const found = await repository.findById(user1.id.value);
         expect(found?.name).toBe("Alice Updated");
       });
     });
@@ -281,18 +290,18 @@ describe("Repository", () => {
       });
 
       it("should return all users", async () => {
-        await repository.save(user1);
-        await repository.save(user2);
-        await repository.save(user3);
+        await repository.create(user1);
+        await repository.create(user2);
+        await repository.create(user3);
 
         const users = await repository.findAll();
         expect(users).toHaveLength(3);
       });
 
       it("should return users matching criteria", async () => {
-        await repository.save(user1);
-        await repository.save(user2);
-        await repository.save(user3);
+        await repository.create(user1);
+        await repository.create(user2);
+        await repository.create(user3);
 
         const criteria = Criteria.create<User>().whereEquals(
           "status",
@@ -307,9 +316,9 @@ describe("Repository", () => {
 
     describe("find with Criteria", () => {
       beforeEach(async () => {
-        await repository.save(user1);
-        await repository.save(user2);
-        await repository.save(user3);
+        await repository.create(user1);
+        await repository.create(user2);
+        await repository.create(user3);
       });
 
       it("should filter by equals", async () => {
@@ -364,8 +373,8 @@ describe("Repository", () => {
 
     describe("findOne", () => {
       it("should find first matching user", async () => {
-        await repository.save(user1);
-        await repository.save(user2);
+        await repository.create(user1);
+        await repository.create(user2);
 
         const criteria = Criteria.create<User>().whereEquals(
           "status",
@@ -390,40 +399,40 @@ describe("Repository", () => {
 
     describe("delete", () => {
       it("should delete by aggregate", async () => {
-        await repository.save(user1);
+        await repository.create(user1);
         await repository.delete(user1);
 
-        const found = await repository.findById(user1.id);
+        const found = await repository.findById(user1.id.value);
         expect(found).toBeNull();
       });
 
       it("should delete by id", async () => {
-        await repository.save(user1);
-        await repository.deleteById(user1.id);
+        await repository.create(user1);
+        await repository.delete(user1);
 
-        const found = await repository.findById(user1.id);
+        const found = await repository.findById(user1.id.value);
         expect(found).toBeNull();
       });
     });
 
     describe("exists", () => {
       it("should return true when user exists", async () => {
-        await repository.save(user1);
-        const exists = await repository.exists(user1.id);
+        await repository.create(user1);
+        const exists = await repository.exists(user1.id.value);
         expect(exists).toBe(true);
       });
 
       it("should return false when user does not exist", async () => {
-        const exists = await repository.exists(new Id());
+        const exists = await repository.exists(new Id().value);
         expect(exists).toBe(false);
       });
     });
 
     describe("count", () => {
       beforeEach(async () => {
-        await repository.save(user1);
-        await repository.save(user2);
-        await repository.save(user3);
+        await repository.create(user1);
+        await repository.create(user2);
+        await repository.create(user3);
       });
 
       it("should count all users", async () => {
@@ -443,7 +452,7 @@ describe("Repository", () => {
 
     describe("saveMany", () => {
       it("should save multiple users", async () => {
-        await repository.saveMany([user1, user2, user3]);
+        await repository.createMany([user1, user2, user3]);
 
         const users = await repository.findAll();
         expect(users).toHaveLength(3);
@@ -456,7 +465,10 @@ describe("Repository", () => {
     let user: User;
 
     beforeEach(() => {
-      repository = new MockUserRepository();
+      repository = new MockUserRepository(
+        new UserToDomainMapper(),
+        new UserToPersistenceMapper()
+      );
       user = User.create({
         name: "John",
         email: "john@example.com",
@@ -471,15 +483,15 @@ describe("Repository", () => {
 
     it("should save new user (insert)", async () => {
       expect(user.isNew).toBe(true);
-      await repository.save(user);
+      await repository.create(user);
 
-      const found = await repository.findById(user.id);
+      const found = await repository.findById(user.id.value);
       expect(found).toBeDefined();
       expect(found?.name).toBe("John");
     });
 
     it("should update existing user", async () => {
-      await repository.save(user);
+      await repository.create(user);
 
       // Simulate existing user
       const existingUser = User.create({
@@ -490,16 +502,16 @@ describe("Repository", () => {
         status: "inactive",
       });
 
-      await repository.save(existingUser);
+      await repository.create(existingUser);
 
-      const found = await repository.findById(user.id);
+      const found = await repository.findById(user.id.value);
       expect(found?.name).toBe("John Updated");
       expect(found?.age).toBe(29);
     });
 
     it("should convert between domain and persistence", async () => {
-      await repository.save(user);
-      const found = await repository.findById(user.id);
+      await repository.create(user);
+      const found = await repository.findById(user.id.value);
 
       // Should be a domain object
       expect(found).toBeInstanceOf(User);
@@ -520,7 +532,7 @@ describe("Repository", () => {
         status: "inactive",
       });
 
-      await Promise.all([repository.save(user1), repository.save(user2)]);
+      await Promise.all([repository.create(user1), repository.create(user2)]);
 
       const result = await repository.find(
         Criteria.create<User>()
@@ -535,10 +547,12 @@ describe("Repository", () => {
   });
 
   describe("Mapper", () => {
-    let mapper: UserMapper;
+    let toDomainMapper: UserToDomainMapper;
+    let toPersistenceMapper: UserToPersistenceMapper;
 
     beforeEach(() => {
-      mapper = new UserMapper();
+      toDomainMapper = new UserToDomainMapper();
+      toPersistenceMapper = new UserToPersistenceMapper();
     });
 
     it("should convert from persistence to domain", () => {
@@ -552,7 +566,7 @@ describe("Repository", () => {
         updatedAt: new Date(),
       };
 
-      const domain = mapper.toDomain(persistence);
+      const domain = toDomainMapper.build(persistence);
 
       expect(domain).toBeInstanceOf(User);
       expect(domain.id.value).toBe("123");
@@ -571,7 +585,7 @@ describe("Repository", () => {
         status: "active",
       });
 
-      const persistence = mapper.toPersistence(domain);
+      const persistence = toPersistenceMapper.build(domain);
 
       expect(persistence.id).toBe("123");
       expect(persistence.name).toBe("John");
@@ -604,7 +618,7 @@ describe("Repository", () => {
         },
       ];
 
-      const domainList = mapper.toDomainList(persistenceList);
+      const domainList = persistenceList.map((p) => toDomainMapper.build(p));
 
       expect(domainList).toHaveLength(2);
       expect(domainList[0]).toBeInstanceOf(User);
@@ -630,7 +644,7 @@ describe("Repository", () => {
         }),
       ];
 
-      const persistenceList = mapper.toPersistenceList(domainList);
+      const persistenceList = domainList.map((d) => toPersistenceMapper.build(d));
 
       expect(persistenceList).toHaveLength(2);
       expect(persistenceList[0].id).toBe("1");