@woltz/rich-domain 0.2.1

package/tests/to-json.test.ts

@@ -0,0 +1,91 @@
+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");
+  });
+});

package/tests/utils.ts

@@ -0,0 +1,151 @@
+// ============================================================================
+// 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 };

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

@@ -0,0 +1,228 @@
+import { z } from "zod";
+import { ValueObject, ValidationError, throwValidationError } from "../src";
+import { VOHooks, VOValidation } from "../src/types";
+
+// ============================================================================
+// Test Value Objects with Validation
+// ============================================================================
+
+interface EmailProps {
+  value: string;
+}
+
+const emailSchema = z.object({
+  value: z.string().email("Invalid email format"),
+});
+
+class Email extends ValueObject<EmailProps> {
+  protected static validation: VOValidation<EmailProps> = {
+    schema: emailSchema,
+    config: {
+      onCreate: true,
+      throwOnError: true,
+    },
+  };
+
+  get value(): string {
+    return this.props.value;
+  }
+}
+
+// ============================================================================
+// Test Value Object with Default Values and Hooks
+// ============================================================================
+
+interface MoneyProps {
+  amount: number;
+  currency: string;
+}
+
+const moneySchema = z.object({
+  amount: z.number().min(0, "Amount must be non-negative"),
+  currency: z
+    .string()
+    .length(3, "Currency must be 3 characters (e.g., USD, EUR)"),
+});
+
+class Money extends ValueObject<MoneyProps> {
+  protected static validation: VOValidation<MoneyProps> = {
+    schema: moneySchema,
+    config: {
+      onCreate: true,
+      throwOnError: true,
+    },
+  };
+
+  protected static hooks: VOHooks<MoneyProps, Money> = {
+    defaultValues: {
+      currency: "USD",
+    },
+    rules: (money) => {
+      if (money.amount > 1000000) {
+        throwValidationError("amount", "Amount cannot exceed 1,000,000");
+      }
+    },
+  };
+
+  get amount(): number {
+    return this.props.amount;
+  }
+
+  get currency(): string {
+    return this.props.currency;
+  }
+
+  add(other: Money): Money {
+    if (this.currency !== other.currency) {
+      throw new Error("Cannot add money with different currencies");
+    }
+    return this.clone({ amount: this.amount + other.amount });
+  }
+}
+
+// ============================================================================
+// Test Value Object with throwOnError: false
+// ============================================================================
+
+class EmailSafe extends ValueObject<EmailProps> {
+  protected static validation: VOValidation<EmailProps> = {
+    schema: emailSchema,
+    config: {
+      onCreate: true,
+      throwOnError: false,
+    },
+  };
+
+  get value(): string {
+    return this.props.value;
+  }
+}
+
+// ============================================================================
+// Tests
+// ============================================================================
+
+describe("ValueObject with Validation", () => {
+  describe("Email ValueObject", () => {
+    it("should create email with valid value", () => {
+      const email = new Email({ value: "test@example.com" });
+      expect(email.value).toBe("test@example.com");
+      expect(email.hasValidationErrors).toBe(false);
+    });
+
+    it("should throw on invalid email format", () => {
+      expect(() => {
+        new Email({ value: "invalid-email" });
+      }).toThrow(ValidationError);
+    });
+
+    it("should have correct error message", () => {
+      try {
+        new Email({ value: "invalid" });
+      } catch (error) {
+        expect(ValidationError.isValidationError(error)).toBe(true);
+        if (ValidationError.isValidationError(error)) {
+          expect(error.getMessages()).toContain("Invalid email format");
+        }
+      }
+    });
+  });
+
+  describe("Money ValueObject with Hooks", () => {
+    it("should create money with valid data", () => {
+      const money = new Money({ amount: 100, currency: "USD" });
+      expect(money.amount).toBe(100);
+      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" });
+      }).toThrow(ValidationError);
+    });
+
+    it("should throw on invalid currency code", () => {
+      expect(() => {
+        new Money({ amount: 100, currency: "US" });
+      }).toThrow(ValidationError);
+    });
+
+    it("should throw on custom rule violation (amount > 1M)", () => {
+      expect(() => {
+        new Money({ amount: 1000001, currency: "USD" });
+      }).toThrow(ValidationError);
+    });
+
+    it("should add money with same currency", () => {
+      const m1 = new Money({ amount: 100, currency: "USD" });
+      const m2 = new Money({ amount: 50, currency: "USD" });
+      const result = m1.add(m2);
+
+      expect(result.amount).toBe(150);
+      expect(result.currency).toBe("USD");
+    });
+
+    it("should throw when adding different currencies", () => {
+      const m1 = new Money({ amount: 100, currency: "USD" });
+      const m2 = new Money({ amount: 50, currency: "EUR" });
+
+      expect(() => m1.add(m2)).toThrow(
+        "Cannot add money with different currencies"
+      );
+    });
+  });
+
+  describe("Email ValueObject with throwOnError: false", () => {
+    it("should not throw on invalid email", () => {
+      const email = new EmailSafe({ value: "invalid" });
+      expect(email.hasValidationErrors).toBe(true);
+    });
+
+    it("should store validation errors", () => {
+      const email = new EmailSafe({ value: "not-an-email" });
+
+      expect(email.validationErrors).toBeDefined();
+      expect(email.validationErrors?.getMessages()).toContain(
+        "Invalid email format"
+      );
+    });
+
+    it("should not have errors for valid email", () => {
+      const email = new EmailSafe({ value: "valid@example.com" });
+
+      expect(email.hasValidationErrors).toBe(false);
+      expect(email.validationErrors).toBeUndefined();
+    });
+  });
+
+  describe("ValueObject Immutability", () => {
+    it("should remain immutable with validation", () => {
+      const email = new Email({ value: "test@example.com" });
+
+      expect(() => {
+        (email as any).props.value = "changed@example.com";
+      }).toThrow();
+    });
+
+    it("should create new instance when adding (immutability)", () => {
+      const m1 = new Money({ amount: 100, currency: "USD" });
+      const m2 = new Money({ amount: 50, currency: "USD" });
+      const result = m1.add(m2);
+
+      // Original instances unchanged
+      expect(m1.amount).toBe(100);
+      expect(m2.amount).toBe(50);
+
+      // New instance created
+      expect(result.amount).toBe(150);
+      expect(result).not.toBe(m1);
+      expect(result).not.toBe(m2);
+    });
+  });
+});

package/tests/value-objects.test.ts

@@ -0,0 +1,52 @@
+import { Address } from "./utils";
+
+describe("Value Object", () => {
+  it("should create immutable value object", () => {
+    const address = new Address({
+      street: "Main St",
+      city: "NYC",
+      zipCode: "10001",
+    });
+
+    expect(address.street).toBe("Main St");
+    expect(address.city).toBe("NYC");
+  });
+
+  it("should compare value objects by value", () => {
+    const address1 = new Address({
+      street: "Main St",
+      city: "NYC",
+      zipCode: "10001",
+    });
+
+    const address2 = new Address({
+      street: "Main St",
+      city: "NYC",
+      zipCode: "10001",
+    });
+
+    const address3 = new Address({
+      street: "Broadway",
+      city: "NYC",
+      zipCode: "10001",
+    });
+
+    expect(address1.equals(address2)).toBe(true);
+    expect(address1.equals(address3)).toBe(false);
+  });
+
+  it("should convert value object to JSON", () => {
+    const address = new Address({
+      street: "Main St",
+      city: "NYC",
+      zipCode: "10001",
+    });
+
+    const json = address.toJson();
+    expect(json).toEqual({
+      street: "Main St",
+      city: "NYC",
+      zipCode: "10001",
+    });
+  });
+});

package/tsconfig.json

@@ -0,0 +1,31 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "esnext",
+    "lib": ["ES2020"],
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "noImplicitAny": true,
+    "strictNullChecks": true,
+    "strictFunctionTypes": true,
+    "strictBindCallApply": true,
+    "strictPropertyInitialization": true,
+    "noImplicitThis": true,
+    "alwaysStrict": true,
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "moduleResolution": "bundler",
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "**/*.test.ts", "**/*.spec.ts"]
+}