@woltz/rich-domain 1.2.0 → 1.2.1

package/tests/aggregate-changes.test.ts

@@ -0,0 +1,284 @@
+// ============================================================================
+// Tests: AggregateChanges
+// ============================================================================
+
+import { AggregateChanges } from "../src/aggregate-changes";
+
+describe("AggregateChanges", () => {
+  let changes: AggregateChanges;
+
+  beforeEach(() => {
+    changes = new AggregateChanges();
+  });
+
+  describe("isEmpty / hasChanges", () => {
+    it("should be empty initially", () => {
+      expect(changes.isEmpty()).toBe(true);
+      expect(changes.hasChanges()).toBe(false);
+      expect(changes.count).toBe(0);
+    });
+
+    it("should not be empty after adding operation", () => {
+      changes.addCreate("User", { id: "1", name: "Test" }, 0);
+      expect(changes.isEmpty()).toBe(false);
+      expect(changes.hasChanges()).toBe(true);
+      expect(changes.count).toBe(1);
+    });
+  });
+
+  describe("addCreate", () => {
+    it("should add create operation", () => {
+      const data = { id: "1", name: "Test User" };
+      changes.addCreate("User", data, 0);
+
+      expect(changes.hasCreates()).toBe(true);
+      expect(changes.creates()).toHaveLength(1);
+      expect(changes.creates()[0]).toMatchObject({
+        type: "create",
+        entity: "User",
+        data,
+        depth: 0,
+      });
+    });
+
+    it("should add create with parent info", () => {
+      const data = { id: "post-1", title: "Test Post" };
+      changes.addCreate("Post", data, 1, "user-1", "User");
+
+      const create = changes.creates()[0];
+      expect(create.parentId).toBe("user-1");
+      expect(create.parentEntity).toBe("User");
+    });
+  });
+
+  describe("addUpdate", () => {
+    it("should add update operation", () => {
+      const data = { id: "1", name: "Updated" };
+      const changedFields = { name: "Updated" };
+      changes.addUpdate("User", "1", data, changedFields, 0);
+
+      expect(changes.hasUpdates()).toBe(true);
+      expect(changes.updates()).toHaveLength(1);
+      expect(changes.updates()[0]).toMatchObject({
+        type: "update",
+        entity: "User",
+        id: "1",
+        changedFields,
+        depth: 0,
+      });
+    });
+  });
+
+  describe("addDelete", () => {
+    it("should add delete operation", () => {
+      const data = { id: "1", name: "To Delete" };
+      changes.addDelete("User", "1", data, 0);
+
+      expect(changes.hasDeletes()).toBe(true);
+      expect(changes.deletes()).toHaveLength(1);
+      expect(changes.deletes()[0]).toMatchObject({
+        type: "delete",
+        entity: "User",
+        id: "1",
+        depth: 0,
+      });
+    });
+  });
+
+  describe("ordering", () => {
+    beforeEach(() => {
+      // Add operations in random order
+      changes.addCreate("Comment", { id: "c1" }, 2);
+      changes.addDelete("Like", "l1", { id: "l1" }, 3);
+      changes.addCreate("User", { id: "u1" }, 0);
+      changes.addDelete("Comment", "c2", { id: "c2" }, 2);
+      changes.addCreate("Post", { id: "p1" }, 1);
+      changes.addDelete("Post", "p2", { id: "p2" }, 1);
+    });
+
+    it("should order creates by depth ASC (root → leaf)", () => {
+      const creates = changes.creates();
+      expect(creates[0].entity).toBe("User"); // depth 0
+      expect(creates[1].entity).toBe("Post"); // depth 1
+      expect(creates[2].entity).toBe("Comment"); // depth 2
+    });
+
+    it("should order deletes by depth DESC (leaf → root)", () => {
+      const deletes = changes.deletes();
+      expect(deletes[0].entity).toBe("Like"); // depth 3
+      expect(deletes[1].entity).toBe("Comment"); // depth 2
+      expect(deletes[2].entity).toBe("Post"); // depth 1
+    });
+  });
+
+  describe("operations iterator", () => {
+    it("should yield operations in correct order: deletes, creates, updates", () => {
+      changes.addCreate("Post", { id: "p1" }, 1);
+      changes.addUpdate("User", "u1", { id: "u1" }, { name: "New" }, 0);
+      changes.addDelete("Comment", "c1", { id: "c1" }, 2);
+
+      const ops = [...changes.operations()];
+
+      expect(ops[0].type).toBe("delete"); // deletes first
+      expect(ops[1].type).toBe("create"); // creates second
+      expect(ops[2].type).toBe("update"); // updates last
+    });
+  });
+
+  describe("toBatchOperations", () => {
+    beforeEach(() => {
+      // Creates
+      changes.addCreate("User", { id: "u1" }, 0);
+      changes.addCreate("Post", { id: "p1" }, 1, "u1", "User");
+      changes.addCreate("Post", { id: "p2" }, 1, "u1", "User");
+      changes.addCreate("Comment", { id: "c1" }, 2, "p1", "Post");
+
+      // Updates
+      changes.addUpdate("User", "u2", { id: "u2" }, { name: "Updated" }, 0);
+      changes.addUpdate("Post", "p3", { id: "p3" }, { title: "New Title" }, 1);
+
+      // Deletes
+      changes.addDelete("Comment", "c2", { id: "c2" }, 2);
+      changes.addDelete("Comment", "c3", { id: "c3" }, 2);
+      changes.addDelete("Post", "p4", { id: "p4" }, 1);
+    });
+
+    it("should group deletes by entity and order by depth DESC", () => {
+      const batch = changes.toBatchOperations();
+
+      expect(batch.deletes).toHaveLength(2); // Comment and Post
+
+      // Comments should come first (depth 2)
+      expect(batch.deletes[0].entity).toBe("Comment");
+      expect(batch.deletes[0].ids).toEqual(["c2", "c3"]);
+
+      // Posts second (depth 1)
+      expect(batch.deletes[1].entity).toBe("Post");
+      expect(batch.deletes[1].ids).toEqual(["p4"]);
+    });
+
+    it("should group creates by entity and order by depth ASC", () => {
+      const batch = changes.toBatchOperations();
+
+      expect(batch.creates).toHaveLength(3); // User, Post, Comment
+
+      // User first (depth 0)
+      expect(batch.creates[0].entity).toBe("User");
+      expect(batch.creates[0].items).toHaveLength(1);
+
+      // Post second (depth 1)
+      expect(batch.creates[1].entity).toBe("Post");
+      expect(batch.creates[1].items).toHaveLength(2);
+
+      // Comment last (depth 2)
+      expect(batch.creates[2].entity).toBe("Comment");
+      expect(batch.creates[2].items).toHaveLength(1);
+    });
+
+    it("should group updates by entity", () => {
+      const batch = changes.toBatchOperations();
+
+      expect(batch.updates).toHaveLength(2); // User and Post
+
+      const userUpdates = batch.updates.find((u) => u.entity === "User");
+      expect(userUpdates?.items).toHaveLength(1);
+      expect(userUpdates?.items[0].id).toBe("u2");
+
+      const postUpdates = batch.updates.find((u) => u.entity === "Post");
+      expect(postUpdates?.items).toHaveLength(1);
+      expect(postUpdates?.items[0].id).toBe("p3");
+    });
+
+    it("should include parentId in create items", () => {
+      const batch = changes.toBatchOperations();
+
+      const postCreates = batch.creates.find((c) => c.entity === "Post");
+      expect(postCreates?.items[0].parentId).toBe("u1");
+      expect(postCreates?.items[1].parentId).toBe("u1");
+
+      const commentCreates = batch.creates.find((c) => c.entity === "Comment");
+      expect(commentCreates?.items[0].parentId).toBe("p1");
+    });
+  });
+
+  describe("for (filter by entity)", () => {
+    beforeEach(() => {
+      changes.addCreate("Post", { id: "p1", title: "Post 1" }, 1);
+      changes.addCreate("Post", { id: "p2", title: "Post 2" }, 1);
+      changes.addUpdate("Post", "p3", { id: "p3" }, { title: "Updated" }, 1);
+      changes.addDelete("Post", "p4", { id: "p4" }, 1);
+      changes.addCreate("Comment", { id: "c1" }, 2);
+    });
+
+    it("should filter creates by entity", () => {
+      const postChanges = changes.for("Post");
+      expect(postChanges.creates).toHaveLength(2);
+      expect(postChanges.creates[0].id).toBe("p1");
+    });
+
+    it("should filter updates by entity", () => {
+      const postChanges = changes.for("Post");
+      expect(postChanges.updates).toHaveLength(1);
+      expect(postChanges.updates[0].entity.id).toBe("p3");
+    });
+
+    it("should filter deletes by entity", () => {
+      const postChanges = changes.for("Post");
+      expect(postChanges.deletes).toHaveLength(1);
+      expect(postChanges.deletes[0].id).toBe("p4");
+    });
+
+    it("should return empty for non-existent entity", () => {
+      const userChanges = changes.for("User");
+      expect(userChanges.isEmpty()).toBe(true);
+    });
+
+    it("should have helper methods", () => {
+      const postChanges = changes.for("Post");
+      expect(postChanges.hasCreates()).toBe(true);
+      expect(postChanges.hasUpdates()).toBe(true);
+      expect(postChanges.hasDeletes()).toBe(true);
+      expect(postChanges.hasChanges()).toBe(true);
+    });
+  });
+
+  describe("getAffectedEntities", () => {
+    it("should return list of unique entities", () => {
+      changes.addCreate("User", { id: "u1" }, 0);
+      changes.addCreate("Post", { id: "p1" }, 1);
+      changes.addUpdate("Post", "p2", { id: "p2" }, {}, 1);
+      changes.addDelete("Comment", "c1", { id: "c1" }, 2);
+
+      const entities = changes.getAffectedEntities();
+
+      expect(entities).toContain("User");
+      expect(entities).toContain("Post");
+      expect(entities).toContain("Comment");
+      expect(entities).toHaveLength(3);
+    });
+  });
+
+  describe("clone", () => {
+    it("should create independent copy", () => {
+      changes.addCreate("User", { id: "u1" }, 0);
+
+      const cloned = changes.clone();
+      cloned.addCreate("Post", { id: "p1" }, 1);
+
+      expect(changes.count).toBe(1);
+      expect(cloned.count).toBe(2);
+    });
+  });
+
+  describe("clear", () => {
+    it("should remove all operations", () => {
+      changes.addCreate("User", { id: "u1" }, 0);
+      changes.addUpdate("Post", "p1", { id: "p1" }, {}, 1);
+
+      changes.clear();
+
+      expect(changes.isEmpty()).toBe(true);
+      expect(changes.count).toBe(0);
+    });
+  });
+});

package/tests/criteria.test.ts

@@ -24,6 +24,17 @@ interface UserWithPostsDto {
   }[];
 }
 
+interface UserWithNestedObject {
+  id: string;
+  name: string;
+  address: {
+    street: string;
+    city: string;
+    country: string;
+  };
+  tags: string[];
+}
+
 const testUsers: TestUser[] = [
   {
     id: "1",
@@ -68,26 +79,12 @@ const testUsers: TestUser[] = [
 ];
 
 describe("Criteria", () => {
-  describe("Search", () => {
-    it("should search by all items ignoring pagination and limit", () => {
-      const criteria = Criteria.create<TestUser>()
-        .search(["name"], "Eve")
-        .paginate(3, 1);
-      const result = PaginatedResult.fromArray(testUsers, criteria);
-      expect(result.data).toHaveLength(1);
-      expect(result.data[0].name).toBe("Eve");
-      expect(result.meta.total).toBe(1);
-      expect(result.meta.totalPages).toBe(1);
-      expect(result.meta.page).toBe(1);
-      expect(result.meta.limit).toBe(1);
-    });
-  });
   describe("Fluent API", () => {
     it("should create empty criteria", () => {
       const criteria = Criteria.create<TestUser>();
       expect(criteria.hasFilters()).toBe(false);
       expect(criteria.hasOrders()).toBe(false);
-      expect(criteria.hasPagination()).toBe(true); // Default pagination is set
+      expect(criteria.hasPagination()).toBe(true);
     });
 
     it("should chain methods fluently", () => {
@@ -118,27 +115,6 @@ describe("Criteria", () => {
   });
 
   describe("Filtering", () => {
-    it("should filter by equals", () => {
-      const criteria = Criteria.create<TestUser>().whereEquals(
-        "status",
-        "active"
-      );
-      const result = PaginatedResult.fromArray(testUsers, criteria);
-      expect(result.data).toHaveLength(3);
-      expect(result.data.every((u) => u.status === "active")).toBe(true);
-    });
-
-    it("should filter by notEquals", () => {
-      const criteria = Criteria.create<TestUser>().where(
-        "status",
-        "notEquals",
-        "active"
-      );
-      const result = PaginatedResult.fromArray(testUsers, criteria);
-      expect(result.data).toHaveLength(2);
-      expect(result.data.every((u) => u.status === "inactive")).toBe(true);
-    });
-
     it("should filter by search", () => {
       const criteria = Criteria.create<TestUser>().search(["name"], "Bob");
 
@@ -147,6 +123,19 @@ describe("Criteria", () => {
       expect(result.data[0].name).toBe("Bob");
     });
 
+    it("should search by all items ignoring pagination and limit", () => {
+      const criteria = Criteria.create<TestUser>()
+        .search(["name"], "Eve")
+        .paginate(3, 1);
+      const result = PaginatedResult.fromArray(testUsers, criteria);
+      expect(result.data).toHaveLength(1);
+      expect(result.data[0].name).toBe("Eve");
+      expect(result.meta.total).toBe(1);
+      expect(result.meta.totalPages).toBe(1);
+      expect(result.meta.page).toBe(1);
+      expect(result.meta.limit).toBe(1);
+    });
+
     it("should filter by greaterThan", () => {
       const criteria = Criteria.create<TestUser>().where(
         "age",
@@ -228,6 +217,20 @@ describe("Criteria", () => {
       expect(result.data).toHaveLength(2);
       expect(result.data.map((u) => u.name)).toEqual(["Bob", "Diana"]);
     });
+
+    it("should filter, order, and paginate", () => {
+      const criteria = Criteria.create<TestUser>()
+        .whereEquals("status", "active")
+        .orderByDesc("age")
+        .paginate(1, 2);
+
+      const result = PaginatedResult.fromArray(testUsers, criteria);
+
+      expect(result.data).toHaveLength(2);
+      expect(result.data.map((u) => u.name)).toEqual(["Bob", "Diana"]);
+      expect(result.meta.total).toBe(3);
+      expect(result.meta.totalPages).toBe(2);
+    });
   });
 
   describe("Ordering", () => {
@@ -274,35 +277,6 @@ describe("Criteria", () => {
       expect(result.meta.hasPrevious).toBe(false);
     });
 
-    it("should get second page", () => {
-      const criteria = Criteria.create<TestUser>().paginate(2, 2);
-      const result = PaginatedResult.fromArray(testUsers, criteria);
-
-      expect(result.data).toHaveLength(2);
-      expect(result.data.map((u) => u.name)).toEqual(["Charlie", "Diana"]);
-      expect(result.meta.page).toBe(2);
-      expect(result.meta.hasNext).toBe(true);
-      expect(result.meta.hasPrevious).toBe(true);
-    });
-
-    it("should get last page", () => {
-      const criteria = Criteria.create<TestUser>().paginate(3, 2);
-      const result = PaginatedResult.fromArray(testUsers, criteria);
-
-      expect(result.data).toHaveLength(1);
-      expect(result.data[0].name).toBe("Eve");
-      expect(result.meta.hasNext).toBe(false);
-      expect(result.meta.hasPrevious).toBe(true);
-    });
-
-    it("should handle empty page", () => {
-      const criteria = Criteria.create<TestUser>().paginate(10, 2);
-      const result = PaginatedResult.fromArray(testUsers, criteria);
-
-      expect(result.data).toHaveLength(0);
-      expect(result.meta.total).toBe(5);
-    });
-
     it("should apply limit shorthand", () => {
       const criteria = Criteria.create<TestUser>().limit(3);
       const result = PaginatedResult.fromArray(testUsers, criteria);
@@ -310,21 +284,17 @@ describe("Criteria", () => {
       expect(result.data).toHaveLength(3);
       expect(result.meta.page).toBe(1);
     });
-  });
-
-  describe("Combined Operations", () => {
-    it("should filter, order, and paginate", () => {
-      const criteria = Criteria.create<TestUser>()
-        .whereEquals("status", "active")
-        .orderByDesc("age")
-        .paginate(1, 2);
 
-      const result = PaginatedResult.fromArray(testUsers, criteria);
+    it("should create pagination meta", () => {
+      const pagination = { page: 2, limit: 10, offset: 10 };
+      const meta = PaginatedResult.createMeta(pagination, 45);
 
-      expect(result.data).toHaveLength(2);
-      expect(result.data.map((u) => u.name)).toEqual(["Bob", "Diana"]);
-      expect(result.meta.total).toBe(3);
-      expect(result.meta.totalPages).toBe(2);
+      expect(meta.page).toBe(2);
+      expect(meta.limit).toBe(10);
+      expect(meta.total).toBe(45);
+      expect(meta.totalPages).toBe(5);
+      expect(meta.hasNext).toBe(true);
+      expect(meta.hasPrevious).toBe(true);
     });
   });
 
@@ -374,12 +344,14 @@ describe("Criteria", () => {
         new Post({
           title: "Post 1",
           content: "Content 1",
-          likes: 1,
+          published: true,
+          comments: [],
         }),
         new Post({
           title: "Post 2",
           content: "Content 2",
-          likes: 2,
+          published: true,
+          comments: [],
         }),
       ];
 
@@ -421,30 +393,6 @@ describe("Criteria", () => {
     });
   });
 
-  describe("Helper Functions", () => {
-    it("should create pagination meta", () => {
-      const pagination = { page: 2, limit: 10, offset: 10 };
-      const meta = PaginatedResult.createMeta(pagination, 45);
-
-      expect(meta.page).toBe(2);
-      expect(meta.limit).toBe(10);
-      expect(meta.total).toBe(45);
-      expect(meta.totalPages).toBe(5);
-      expect(meta.hasNext).toBe(true);
-      expect(meta.hasPrevious).toBe(true);
-    });
-
-    it("should create paginated result", () => {
-      const data = [{ id: "1" }, { id: "2" }];
-      const pagination = { page: 1, limit: 2, offset: 0 };
-      const result = PaginatedResult.create(data, pagination, data.length);
-
-      expect(result.data).toEqual(data);
-      expect(result.meta.total).toBe(data.length);
-      expect(result.meta.totalPages).toBe(1);
-    });
-  });
-
   describe("Criteria from Query Params", () => {
     it("should create criteria from query params", () => {
       const queryParams = {
@@ -466,6 +414,19 @@ describe("Criteria", () => {
 
   describe("Quantifiers", () => {
     describe("Fluent API methods", () => {
+      it("should use quantifiers horthand methods", () => {
+        // CHECK: Devemos permitir o encadeamento de metodos quantifiers?
+        const criteria = Criteria.create<TestUser>()
+          .whereSome("name", "contains", "ali")
+          .whereEvery("name", "contains", "ali")
+          .whereNone("name", "contains", "ali");
+
+        const filters = criteria.getFilters().map((f) => f.options?.quantifier);
+
+        expect(filters).toHaveLength(3);
+        expect(filters).toEqual(["some", "every", "none"]);
+      });
+
       it("should create filter with whereSome", () => {
         const criteria = Criteria.create<UserWithPostsDto>().whereSome(
           "posts.title",
@@ -506,20 +467,6 @@ describe("Criteria", () => {
         expect(filters[0].options?.quantifier).toBe("none");
       });
 
-      it("should create filter without quantifier using where", () => {
-        const criteria = Criteria.create<UserWithPostsDto>().where(
-          "posts.title",
-          "contains",
-          "test"
-        );
-
-        const filters = criteria.getFilters();
-        expect(filters).toHaveLength(1);
-        expect(filters[0].options).toBeUndefined();
-      });
-    });
-
-    describe("fromQueryParams with quantifier", () => {
       it("should parse quantifier from query params with @some", () => {
         const queryParams = {
           "posts.title:contains@some": "test",
@@ -536,32 +483,6 @@ describe("Criteria", () => {
         expect(filters[0].options?.quantifier).toBe("some");
       });
 
-      it("should parse quantifier from query params with @every", () => {
-        const queryParams = {
-          "posts.title:equals@every": "test",
-        };
-
-        const criteria =
-          Criteria.fromQueryParams<UserWithPostsDto>(queryParams);
-        const filters = criteria.getFilters();
-
-        expect(filters).toHaveLength(1);
-        expect(filters[0].options?.quantifier).toBe("every");
-      });
-
-      it("should parse quantifier from query params with @none", () => {
-        const queryParams = {
-          "posts.title:contains@none": "spam",
-        };
-
-        const criteria =
-          Criteria.fromQueryParams<UserWithPostsDto>(queryParams);
-        const filters = criteria.getFilters();
-
-        expect(filters).toHaveLength(1);
-        expect(filters[0].options?.quantifier).toBe("none");
-      });
-
       it("should work with in operator and quantifier", () => {
         const queryParams = {
           "posts.title:in@some": "test1,test2,test3",
@@ -592,22 +513,6 @@ describe("Criteria", () => {
         expect(filters[0].options?.quantifier).toBe("some");
       });
 
-      it("should maintain backward compatibility without quantifier", () => {
-        const queryParams = {
-          "posts.title:contains": "test",
-        };
-
-        const criteria =
-          Criteria.fromQueryParams<UserWithPostsDto>(queryParams);
-        const filters = criteria.getFilters();
-
-        expect(filters).toHaveLength(1);
-        expect(filters[0].field).toBe("posts.title");
-        expect(filters[0].operator).toBe("contains");
-        expect(filters[0].value).toBe("test");
-        expect(filters[0].options).toBeUndefined();
-      });
-
       it("should throw error for invalid quantifier", () => {
         const queryParams = {
           "posts.title:contains@invalid": "test",
@@ -741,7 +646,7 @@ describe("Criteria", () => {
             {
               field: "posts",
               operator: "in",
-              value: [{ title: "test", content: "test" }],
+              value: [{ title: "test" }] as any,
             },
           ],
         },
@@ -751,5 +656,61 @@ describe("Criteria", () => {
       expect(filters).toHaveLength(1);
       expect(filters[0].field).toBe("user_posts");
     });
+
+    it("should only allow nested paths in fromObject for object fields", () => {
+      // Only nested paths should work for object fields
+      const criteria = Criteria.fromObject<UserWithNestedObject>({
+        filters: [
+          {
+            field: "address.street",
+            operator: "equals",
+            value: "123 Main St",
+          },
+          {
+            field: "address.city",
+            operator: "equals",
+            value: "New York",
+          },
+          {
+            field: "id",
+            operator: "equals",
+            value: "user-1",
+          },
+        ],
+      });
+
+      expect(criteria.getFilters()).toHaveLength(3);
+    });
+  });
+
+  describe("Nested Object Field Paths", () => {
+    it("should only allow nested paths for object fields, not the root", () => {
+      const criteria = Criteria.create<UserWithNestedObject>();
+
+      // These should work - nested paths
+      criteria.whereEquals("address.city", "123 Main St");
+      criteria.whereEquals("address.city", "New York");
+      criteria.whereEquals("address.country", "USA");
+
+      // These should work - primitives and arrays
+      criteria.whereEquals("id", "user-1");
+      criteria.whereEquals("name", "John Doe");
+      criteria.where("tags", "in", ["tag1", "tag2"]);
+
+      const filters = criteria.getFilters();
+      expect(filters).toHaveLength(6);
+    });
+
+    it("should work with array of objects (keeps root + nested)", () => {
+      const criteria = Criteria.create<UserWithPostsDto>();
+
+      // These should work - array root and nested paths
+      criteria.where("posts", "in", []);
+      criteria.whereEquals("posts.title", "Test Post");
+      criteria.whereEquals("posts.content", "Test Content");
+
+      const filters = criteria.getFilters();
+      expect(filters).toHaveLength(3);
+    });
   });
 });