@woltz/rich-domain 1.2.4 → 1.3.1

package/tests/to-json.test.ts

@@ -1,99 +0,0 @@
-import { Entity, Id } from "../src";
-import { Post, User, Address } 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",
-      published: false,
-      comments: [],
-    });
-
-    const json = post.toJson();
-    expect(json).toEqual({
-      id: "1",
-      title: "First Post",
-      content: "Hello World",
-      published: false,
-      comments: [],
-    });
-  });
-
-  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",
-          published: false,
-          comments: [],
-        }),
-        new Post({
-          id: new Id("2"),
-          title: "Post 2",
-          content: "Content 2",
-          published: false,
-          comments: [],
-        }),
-      ],
-      address: new Address({
-        street: "Main St",
-        city: "NYC",
-      }),
-      tags: [],
-    });
-
-    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");
-  });
-
-  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",
-          published: false,
-          comments: [],
-        }),
-      ],
-      address: new Address({
-        street: "Main St",
-        city: "NYC",
-      }),
-      tags: [],
-    });
-
-    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,290 +0,0 @@
-import {
-  Aggregate,
-  Criteria,
-  Entity,
-  Id,
-  Mapper,
-  PaginatedResult,
-  Repository,
-  UnitOfWork,
-  ValueObject,
-} from "../src";
-
-export class Like extends ValueObject<{
-  postId: string;
-  userId: string;
-  createdAt: Date;
-}> {
-  static readonly identityKey = ["postId", "userId"];
-
-  get postId() {
-    return this.props.postId;
-  }
-  get userId() {
-    return this.props.userId;
-  }
-}
-
-export class Address extends Entity<{
-  id: Id;
-  street: string;
-  city: string;
-}> {
-  get street() {
-    return this.props.street;
-  }
-  get city() {
-    return this.props.city;
-  }
-
-  changeStreet(street: string) {
-    this.props.street = street;
-  }
-}
-
-export class TagReference extends ValueObject<{ tagId: string; name: string }> {
-  static readonly identityKey = "tagId";
-
-  get tagId() {
-    return this.props.tagId;
-  }
-  get name() {
-    return this.props.name;
-  }
-}
-
-export class Comment extends Entity<{
-  id: Id;
-  text: string;
-  authorId: string;
-  likes: Like[];
-}> {
-  get text() {
-    return this.props.text;
-  }
-  get authorId() {
-    return this.props.authorId;
-  }
-  get likes() {
-    return this.props.likes;
-  }
-
-  changeText(text: string) {
-    this.props.text = text;
-  }
-
-  addLike(like: Like) {
-    this.props.likes.push(like);
-  }
-
-  removeLike(postId: string, userId: string) {
-    this.props.likes = this.props.likes.filter(
-      (l) => !(l.postId === postId && l.userId === userId)
-    );
-  }
-}
-export class Post extends Entity<{
-  id: Id;
-  title: string;
-  content: string;
-  published: boolean;
-  comments: Comment[];
-}> {
-  get title() {
-    return this.props.title;
-  }
-  get content() {
-    return this.props.content;
-  }
-  get published() {
-    return this.props.published;
-  }
-  get comments() {
-    return this.props.comments;
-  }
-
-  set comments(comments: Comment[]) {
-    this.props.comments = comments;
-  }
-
-  changeTitle(title: string) {
-    this.props.title = title;
-  }
-
-  publish() {
-    this.props.published = true;
-  }
-
-  addComment(comment: Comment) {
-    this.props.comments.push(comment);
-  }
-
-  removeComment(commentId: Id) {
-    this.props.comments = this.props.comments.filter(
-      (c) => c.id.value !== commentId.value
-    );
-  }
-}
-
-export class User extends Entity<{
-  id: Id;
-  name: string;
-  email: string;
-  address: Address | null;
-  posts: Post[];
-  tags: TagReference[];
-}> {
-  get name() {
-    return this.props.name;
-  }
-  get email() {
-    return this.props.email;
-  }
-  get address() {
-    return this.props.address;
-  }
-  get posts() {
-    return this.props.posts;
-  }
-  get tags() {
-    return this.props.tags;
-  }
-
-  set posts(posts: Post[]) {
-    this.props.posts = posts;
-  }
-
-  changeName(name: string) {
-    this.props.name = name;
-  }
-
-  changeEmail(email: string) {
-    this.props.email = email;
-  }
-
-  setAddress(address: Address) {
-    this.props.address = address;
-  }
-
-  removeAddress() {
-    this.props.address = null;
-  }
-
-  addPost(post: Post) {
-    this.props.posts.push(post);
-  }
-
-  removePost(postId: Id) {
-    this.props.posts = this.props.posts.filter(
-      (p) => p.id.value !== postId.value
-    );
-  }
-
-  addTag(tag: TagReference) {
-    this.props.tags.push(tag);
-  }
-
-  addManyTags(tags: TagReference[]) {
-    this.props.tags.push(...tags);
-  }
-
-  addManyPosts(posts: Post[]) {
-    this.props.posts.push(...posts);
-  }
-
-  removeTag(tagId: string) {
-    this.props.tags = this.props.tags.filter((t) => t.tagId !== tagId);
-  }
-
-  public getTypedChanges() {
-    type UserEntities = {
-      User: User;
-      Post: Post;
-      Comment: Comment;
-      Address: Address;
-      TagReference: TagReference;
-      Like: Like;
-    };
-    return this.getChanges<UserEntities>();
-  }
-}
-
-export 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 save(aggregate: TDomain): Promise<void> {
-    this.items.set(aggregate.id.value, aggregate);
-  }
-
-  async createMany(aggregates: TDomain[]): Promise<void> {
-    for (const aggregate of aggregates) {
-      await this.save(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(): void {
-    this.items.clear();
-  }
-
-  getAll(): TDomain[] {
-    return Array.from(this.items.values());
-  }
-
-  size(): number {
-    return this.items.size;
-  }
-}

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

@@ -1,219 +0,0 @@
-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> = {
-    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 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

@@ -1,80 +0,0 @@
-import { TagReference } from "./utils";
-
-describe("Value Object", () => {
-  it("should create immutable value object", () => {
-    const tag = new TagReference({
-      tagId: "1",
-      name: "Tag 1",
-    });
-
-    expect(tag.tagId).toBe("1");
-    expect(tag.name).toBe("Tag 1");
-  });
-
-  it("should compare value objects by value", () => {
-      const tag1 = new TagReference({
-      tagId: "1",
-      name: "Tag 1",
-    });
-
-    const tag2 = new TagReference({
-      tagId: "1",
-      name: "Tag 1",
-    });
-
-    const tag3 = new TagReference({
-      tagId: "2",
-      name: "Tag 2",
-    });
-
-    expect(tag1.equals(tag2)).toBe(true);
-    expect(tag1.equals(tag3)).toBe(false);
-  });
-
-  it("should convert value object to JSON", () => {
-    const tag = new TagReference({
-     name: "Tag 1",
-     tagId: "1",
-    });
-
-    const json = tag.toJson();
-    expect(json).toEqual({
-      name: "Tag 1",
-      tagId: "1",
-    });
-  });
-
-  describe("Value Object", () => {
-    it("should be immutable", () => {
-      const tag = new TagReference({
-        tagId: "1",
-        name: "Tag 1",
-      });
-
-      expect(tag.tagId).toBe("1");
-      expect(() => {
-        (tag as any).props.tagId = "2";
-      }).toThrow();
-    });
-
-    it("should compare by value", () => {
-      const tag1 = new TagReference({
-        tagId: "1",
-        name: "Tag 1",
-      });
-
-      const tag2 = new TagReference({
-        tagId: "1",
-        name: "Tag 1",
-      });
-
-      const tag3 = new TagReference({
-        tagId: "2",
-        name: "Tag 2",
-      });
-
-      expect(tag1.equals(tag2)).toBe(true);
-      expect(tag1.equals(tag3)).toBe(false);
-    });
-  });
-});

package/tsconfig.json

@@ -1,9 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "outDir": "./dist",
-    "rootDir": "./src"
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist", "**/*.test.ts", "**/*.spec.ts"]
-}