@woltz/rich-domain 0.2.2 → 1.1.0

package/tests/repository.test.ts

@@ -1,6 +1,8 @@
-import { Id, Aggregate, Criteria, BaseProps, PaginatedResult } from "../src";
-import { InMemoryRepository, Mapper } from "../src/repository";
+import { Id, Aggregate, Criteria, PaginatedResult } from "../src";
+import { Mapper } from "../src/repository";
 import { Repository } from "../src/repository/base-repository";
+import { BaseProps } from "../src/types";
+import { InMemoryRepository } from "./utils";
 
 // ============================================================================
 // Test Domain Models
@@ -482,7 +484,7 @@ describe("Repository", () => {
     });
 
     it("should save new user (insert)", async () => {
-      expect(user.isNew).toBe(true);
+      expect(user.isNew()).toBe(true);
       await repository.create(user);
 
       const found = await repository.findById(user.id.value);
@@ -644,7 +646,9 @@ describe("Repository", () => {
         }),
       ];
 
-      const persistenceList = domainList.map((d) => toPersistenceMapper.build(d));
+      const persistenceList = domainList.map((d) =>
+        toPersistenceMapper.build(d)
+      );
 
       expect(persistenceList).toHaveLength(2);
       expect(persistenceList[0].id).toBe("1");

package/tests/to-json.test.ts

@@ -1,91 +1,103 @@
-import { Id } from "../src";
-import { Post, User, Address, Comment } from "./utils";
-
-describe("toJson Functionality", () => {
-  it("should convert simple entity to JSON", () => {
-    const post = new Post({
-      id: new Id("1"),
-      title: "First Post",
-      content: "Hello World",
-      likes: 5,
-    });
-
-    const json = post.toJson();
-    expect(json).toEqual({
-      id: "1",
-      title: "First Post",
-      content: "Hello World",
-      likes: 5,
-    });
-  });
-
-  it("should convert nested entities to JSON", () => {
-    const user = new User({
-      id: new Id("1"),
-      name: "John Doe",
-      email: "john@example.com",
-      posts: [
-        new Post({
-          id: new Id("1"),
-          title: "Post 1",
-          content: "Content 1",
-          likes: 0,
-        }),
-        new Post({
-          id: new Id("2"),
-          title: "Post 2",
-          content: "Content 2",
-          likes: 5,
-        }),
-      ],
-      address: new Address({
-        street: "Main St",
-        city: "NYC",
-        zipCode: "10001",
-      }),
-      comments: [
-        new Comment({
-          id: new Id("1"),
-          text: "Great post!",
-          author: "Alice",
-        }),
-      ],
-    });
-
-    const json = user.toJson();
-
-    expect(json.id).toBe("1");
-    expect(json.name).toBe("John Doe");
-    expect(json.posts).toHaveLength(2);
-    expect(json.posts[0].title).toBe("Post 1");
-    expect(json.address.city).toBe("NYC");
-    expect(json.comments[0].text).toBe("Great post!");
-  });
-
-  it("should handle deeply nested structures", () => {
-    const user = new User({
-      id: new Id("1"),
-      name: "John Doe",
-      email: "john@example.com",
-      posts: [
-        new Post({
-          id: new Id("1"),
-          title: "Post 1",
-          content: "Content 1",
-          likes: 0,
-        }),
-      ],
-      address: new Address({
-        street: "Main St",
-        city: "NYC",
-        zipCode: "10001",
-      }),
-      comments: [],
-    });
-
-    const json = user.toJson();
-    expect(typeof json).toBe("object");
-    expect(Array.isArray(json.posts)).toBe(true);
-    expect(json.posts[0].id).toBe("1");
-  });
-});
+import { Entity, Id } from "../src";
+import { Post, User, Address, Comment } from "./utils";
+
+describe("toJson Functionality", () => {
+  it("should convert simple entity to JSON", () => {
+    const post = new Post({
+      id: new Id("1"),
+      title: "First Post",
+      content: "Hello World",
+      likes: 5,
+    });
+
+    const json = post.toJson();
+    expect(json).toEqual({
+      id: "1",
+      title: "First Post",
+      content: "Hello World",
+      likes: 5,
+    });
+  });
+
+  it("should convert nested entities to JSON", () => {
+    const user = new User({
+      id: new Id("1"),
+      name: "John Doe",
+      email: "john@example.com",
+      posts: [
+        new Post({
+          id: new Id("1"),
+          title: "Post 1",
+          content: "Content 1",
+          likes: 0,
+        }),
+        new Post({
+          id: new Id("2"),
+          title: "Post 2",
+          content: "Content 2",
+          likes: 5,
+        }),
+      ],
+      address: new Address({
+        street: "Main St",
+        city: "NYC",
+        zipCode: "10001",
+      }),
+      comments: [
+        new Comment({
+          id: new Id("1"),
+          text: "Great post!",
+          author: "Alice",
+        }),
+      ],
+    });
+
+    const json = user.toJson();
+
+    expect(json.id).toBe("1");
+    expect(json.name).toBe("John Doe");
+    expect(json.posts).toHaveLength(2);
+    expect(json.posts[0].title).toBe("Post 1");
+    expect(json.address.city).toBe("NYC");
+    expect(json.comments[0].text).toBe("Great post!");
+  });
+
+  it("should handle deeply nested structures", () => {
+    const user = new User({
+      id: new Id("1"),
+      name: "John Doe",
+      email: "john@example.com",
+      posts: [
+        new Post({
+          id: new Id("1"),
+          title: "Post 1",
+          content: "Content 1",
+          likes: 0,
+        }),
+      ],
+      address: new Address({
+        street: "Main St",
+        city: "NYC",
+        zipCode: "10001",
+      }),
+      comments: [],
+    });
+
+    const json = user.toJson();
+    expect(typeof json).toBe("object");
+    expect(Array.isArray(json.posts)).toBe(true);
+    expect(json.posts[0].id).toBe("1");
+  });
+
+  it("should serialize date correctly", () => {
+    class Test extends Entity<{ id: Id; createdAt: Date }> {}
+
+    const test = new Test({
+      id: new Id("1"),
+      createdAt: new Date(),
+    });
+
+    const json = test.toJson();
+    expect(json.createdAt).toBe(test.props.createdAt.toISOString());
+  });
+});

package/tests/utils.ts

@@ -1,151 +1,254 @@
-// ============================================================================
-// Test Entities & Value Objects
-// ============================================================================
-
-import { Aggregate, Entity, Id, ValueObject } from "../src";
-
-interface AddressProps {
-  street: string;
-  city: string;
-  zipCode: string;
-}
-
-class Address extends ValueObject<AddressProps> {
-  get street(): string {
-    return this.props.street;
-  }
-
-  get city(): string {
-    return this.props.city;
-  }
-
-  get zipCode(): string {
-    return this.props.zipCode;
-  }
-}
-
-interface PostProps {
-  id: Id;
-  title: string;
-  content: string;
-  likes: number;
-}
-
-class Post extends Entity<PostProps> {
-  get title(): string {
-    return this.props.title;
-  }
-
-  set title(value: string) {
-    this.props.title = value;
-  }
-
-  get content(): string {
-    return this.props.content;
-  }
-
-  set content(value: string) {
-    this.props.content = value;
-  }
-
-  get likes(): number {
-    return this.props.likes;
-  }
-
-  set likes(value: number) {
-    this.props.likes = value;
-  }
-}
-
-interface CommentProps {
-  id: Id;
-  text: string;
-  author: string;
-}
-
-class Comment extends Entity<CommentProps> {
-  get text(): string {
-    return this.props.text;
-  }
-
-  set text(value: string) {
-    this.props.text = value;
-  }
-
-  get author(): string {
-    return this.props.author;
-  }
-}
-
-interface UserProps {
-  id: Id;
-  name: string;
-  email: string;
-  posts: Post[];
-  address: Address;
-  comments: Comment[];
-  extra?: {
-    age: number;
-    height: number;
-  };
-}
-
-class User extends Aggregate<UserProps> {
-  get name(): string {
-    return this.props.name;
-  }
-
-  set name(value: string) {
-    this.props.name = value;
-  }
-
-  get email(): string {
-    return this.props.email;
-  }
-
-  get posts(): Post[] {
-    return this.props.posts;
-  }
-
-  set posts(value: Post[]) {
-    this.props.posts = value;
-  }
-
-  get address(): Address {
-    return this.props.address;
-  }
-
-  set address(value: Address) {
-    this.props.address = value;
-  }
-
-  get comments(): Comment[] {
-    return this.props.comments;
-  }
-
-  set comments(value: Comment[]) {
-    this.props.comments = value;
-  }
-
-  public addPost(post: Post) {
-    this.props.posts.push(post);
-  }
-
-  public addManyPosts(posts: Post[]) {
-    this.props.posts.push(...posts);
-  }
-
-  public removePostById(id: string) {
-    this.props.posts = this.props.posts.filter((post) => post.id.value !== id);
-  }
-
-  public changeEmail(email: string) {
-    this.props.email = email;
-  }
-
-  public changeExtra(extra: { age: number; height: number }) {
-    this.props.extra = extra;
-  }
-}
-
-export { User, Post, Comment, Address };
+// ============================================================================
+// Test Entities & Value Objects
+// ============================================================================
+
+import {
+  Aggregate,
+  Criteria,
+  Entity,
+  Id,
+  Mapper,
+  PaginatedResult,
+  Repository,
+  UnitOfWork,
+  ValueObject,
+} from "../src";
+
+interface AddressProps {
+  street: string;
+  city: string;
+  zipCode: string;
+}
+
+class Address extends ValueObject<AddressProps> {
+  get street(): string {
+    return this.props.street;
+  }
+
+  get city(): string {
+    return this.props.city;
+  }
+
+  get zipCode(): string {
+    return this.props.zipCode;
+  }
+}
+
+interface PostProps {
+  id: Id;
+  title: string;
+  content: string;
+  likes: number;
+}
+
+class Post extends Entity<PostProps> {
+  get title(): string {
+    return this.props.title;
+  }
+
+  set title(value: string) {
+    this.props.title = value;
+  }
+
+  get content(): string {
+    return this.props.content;
+  }
+
+  set content(value: string) {
+    this.props.content = value;
+  }
+
+  get likes(): number {
+    return this.props.likes;
+  }
+
+  set likes(value: number) {
+    this.props.likes = value;
+  }
+}
+
+interface CommentProps {
+  id: Id;
+  text: string;
+  author: string;
+}
+
+class Comment extends Entity<CommentProps> {
+  get text(): string {
+    return this.props.text;
+  }
+
+  set text(value: string) {
+    this.props.text = value;
+  }
+
+  get author(): string {
+    return this.props.author;
+  }
+}
+
+interface UserProps {
+  id: Id;
+  name: string;
+  email: string;
+  posts: Post[];
+  address: Address;
+  comments: Comment[];
+  extra?: {
+    age: number;
+    height: number;
+  };
+}
+
+class User extends Aggregate<UserProps> {
+  get name(): string {
+    return this.props.name;
+  }
+
+  set name(value: string) {
+    this.props.name = value;
+  }
+
+  get email(): string {
+    return this.props.email;
+  }
+
+  get posts(): Post[] {
+    return this.props.posts;
+  }
+
+  set posts(value: Post[]) {
+    this.props.posts = value;
+  }
+
+  get address(): Address {
+    return this.props.address;
+  }
+
+  set address(value: Address) {
+    this.props.address = value;
+  }
+
+  get comments(): Comment[] {
+    return this.props.comments;
+  }
+
+  set comments(value: Comment[]) {
+    this.props.comments = value;
+  }
+
+  public addPost(post: Post) {
+    this.props.posts.push(post);
+  }
+
+  public addManyPosts(posts: Post[]) {
+    this.props.posts.push(...posts);
+  }
+
+  public removePostById(id: string) {
+    this.props.posts = this.props.posts.filter((post) => post.id.value !== id);
+  }
+
+  public changeEmail(email: string) {
+    this.props.email = email;
+  }
+
+  public changeExtra(extra: { age: number; height: number }) {
+    this.props.extra = extra;
+  }
+}
+
+class InMemoryRepository<
+  TDomain extends Aggregate<any>
+> extends Repository<TDomain> {
+  protected items: Map<string, TDomain> = new Map();
+  readonly uow: UnitOfWork;
+  constructor(
+    protected readonly mapperToDomain: Mapper<unknown, TDomain>,
+    protected readonly mapperToPersistence: Mapper<TDomain, unknown>
+  ) {
+    super();
+    this.uow = {} as UnitOfWork;
+  }
+
+  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>> {
+    const allItems = Array.from(this.items.values());
+    return PaginatedResult.fromArray(allItems, criteria);
+  }
+
+  async findAll(criteria?: Criteria<TDomain>): Promise<TDomain[]> {
+    if (criteria) {
+      const result = await this.find(criteria);
+      return result.data;
+    }
+
+    return Array.from(this.items.values());
+  }
+
+  async findOne(criteria: Criteria<TDomain>): Promise<TDomain | null> {
+    const result = await this.find(criteria.clone().limit(1));
+    return result.data.length > 0 ? result.data[0] : null;
+  }
+
+  async create(aggregate: TDomain): Promise<void> {
+    this.items.set(aggregate.id.value, aggregate);
+  }
+
+  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.create(aggregate);
+    }
+  }
+
+  async delete(aggregate: TDomain): Promise<void> {
+    this.items.delete(aggregate.id.value);
+  }
+
+  async exists(id: string): Promise<boolean> {
+    return this.items.has(id);
+  }
+
+  async count(criteria?: Criteria<TDomain>): Promise<number> {
+    if (criteria) {
+      const result = await this.find(criteria);
+      return result.meta.total;
+    }
+    return this.items.size;
+  }
+
+  /**
+   * Clear all items (useful for test cleanup)
+   */
+  clear(): void {
+    this.items.clear();
+  }
+
+  /**
+   * Get all items as array (useful for debugging)
+   */
+  getAll(): TDomain[] {
+    return Array.from(this.items.values());
+  }
+
+  /**
+   * Get items count
+   */
+  size(): number {
+    return this.items.size;
+  }
+}
+
+export { User, Post, Comment, Address, InMemoryRepository };

package/tests/value-object-validation.test.ts

@@ -54,9 +54,6 @@ class Money extends ValueObject<MoneyProps> {
   };
 
   protected static hooks: VOHooks<MoneyProps, Money> = {
-    defaultValues: {
-      currency: "USD",
-    },
     rules: (money) => {
       if (money.amount > 1000000) {
         throwValidationError("amount", "Amount cannot exceed 1,000,000");
@@ -135,12 +132,6 @@ describe("ValueObject with Validation", () => {
       expect(money.currency).toBe("USD");
     });
 
-    it("should apply default currency", () => {
-      const money = new Money({ amount: 50 } as any);
-      expect(money.amount).toBe(50);
-      expect(money.currency).toBe("USD");
-    });
-
     it("should throw on negative amount", () => {
       expect(() => {
         new Money({ amount: -10, currency: "USD" });