@woltz/rich-domain 1.2.0 → 1.2.1

package/tests/load-test/entities.ts

@@ -0,0 +1,97 @@
+import { z } from "zod";
+import {
+  Aggregate,
+  Entity,
+  EntityValidation,
+  Id,
+  ValueObject,
+  VOValidation,
+} from "../../src";
+
+const DateSchema = z.union([z.date(), z.string().datetime()]);
+
+const AddressProps = z.object({
+  street: z.string(),
+  city: z.string(),
+  state: z.string(),
+  zip: z.string(),
+  country: z.string(),
+});
+
+type AddressProps = z.infer<typeof AddressProps>;
+
+export class Address extends ValueObject<AddressProps> {
+  protected static validation: VOValidation<AddressProps> = {
+    schema: AddressProps,
+  };
+}
+
+const ProposalProps = z.object({
+  id: z.instanceof(Id),
+  leadId: z.string(),
+  contractId: z.string(),
+  status: z.enum(["pending", "approved", "rejected"]),
+  createdAt: DateSchema,
+  updatedAt: DateSchema,
+  value: z.number(),
+});
+
+type ProposalProps = z.infer<typeof ProposalProps>;
+
+export class Proposal extends Entity<ProposalProps> {
+  protected static validation: EntityValidation<ProposalProps> = {
+    schema: ProposalProps,
+  };
+}
+
+const ContactProps = z.object({
+  id: z.instanceof(Id),
+  userId: z.string().optional(),
+  leadId: z.string().optional(),
+  name: z.string(),
+  email: z.string().email(),
+  phone: z.string(),
+});
+
+type ContactProps = z.infer<typeof ContactProps>;
+
+export class Contact extends Entity<ContactProps> {
+  protected static validation: EntityValidation<ContactProps> = {
+    schema: ContactProps,
+  };
+}
+
+const ContractProps = z.object({
+  id: z.instanceof(Id),
+  proposalId: z.string(),
+  proposal: z.instanceof(Proposal),
+  signes: z.array(ContactProps),
+  createdAt: DateSchema,
+  updatedAt: DateSchema,
+  signedAt: DateSchema.optional(),
+});
+
+type ContractProps = z.infer<typeof ContractProps>;
+
+export class Contract extends Aggregate<ContractProps> {
+  protected static validation: EntityValidation<ContractProps> = {
+    schema: ContractProps,
+  };
+}
+
+const LeadProps = z.object({
+  id: z.instanceof(Id),
+  capturedName: z.string(),
+  capturedEmail: z.string().email(),
+  proposals: z.array(z.instanceof(Proposal)),
+  address: z.instanceof(Address),
+  contact: z.instanceof(Contact),
+});
+
+export type LeadProps = z.infer<typeof LeadProps>;
+
+export class Lead extends Aggregate<LeadProps> {
+  protected static validation: EntityValidation<LeadProps> = {
+    schema: LeadProps,
+  };
+}

package/tests/load-test/generate-data.ts

@@ -0,0 +1,81 @@
+import { faker } from "@faker-js/faker";
+import fs from "fs";
+
+const LEADS_COUNT = 10000;
+
+const createId = () => faker.string.uuid();
+
+const createAddress = () => {
+  return {
+    street: faker.location.streetAddress(),
+    city: faker.location.city(),
+    state: faker.location.state(),
+    zip: faker.location.zipCode(),
+    country: faker.location.country(),
+  };
+};
+
+const createProposal = (leadId: string) => {
+  const createdDate = faker.date.past();
+  return {
+    id: createId(),
+    leadId: leadId,
+    contractId: createId(),
+    status: faker.helpers.arrayElement(["pending", "approved", "rejected"]),
+    createdAt: createdDate,
+    updatedAt: faker.date.between({ from: createdDate, to: new Date() }),
+    value: parseFloat(faker.finance.amount({ min: 1000, max: 50000, dec: 2 })),
+  };
+};
+
+const createContact = (leadId: string) => {
+  return {
+    id: createId(),
+    userId: faker.datatype.boolean() ? createId() : undefined,
+    leadId: leadId,
+    name: faker.person.fullName(),
+    email: faker.internet.email(),
+    phone: faker.phone.number(),
+  };
+};
+
+const createLead = () => {
+  const leadId = createId();
+  const firstName = faker.person.firstName();
+  const lastName = faker.person.lastName();
+
+  const numProposals = faker.number.int({ min: 0, max: 3 });
+
+  const proposalsArray = Array.from({ length: numProposals }).map(() =>
+    createProposal(leadId)
+  );
+
+  return {
+    id: leadId,
+    capturedName: `${firstName} ${lastName}`,
+    capturedEmail: faker.internet.email({ firstName, lastName }),
+
+    address: createAddress(),
+
+    contact: createContact(leadId),
+    proposals: proposalsArray,
+  };
+};
+
+export async function generateData() {
+  return await new Promise((resolve, reject) => {
+    try {
+      console.log(`Generating ${LEADS_COUNT} leads...`);
+      const leads: any[] = [];
+      for (let i = 0; i < LEADS_COUNT; i++) {
+        leads.push(createLead());
+      }
+      const jsonOutput = JSON.stringify(leads, null, 2);
+      fs.writeFileSync(`${__dirname}/data.json`, jsonOutput);
+      console.log(`Success! data.json created with ${leads.length} items.`);
+      resolve(true);
+    } catch (error) {
+      reject(error);
+    }
+  });
+}

package/tests/load-test/lead-to-domain.mapper.ts

@@ -0,0 +1,24 @@
+import { Id, Mapper } from "../../src";
+import { Address, Contact, Lead, Proposal } from "./entities";
+
+export class LeadToDomainMapper extends Mapper<any, Lead> {
+  public build(props: any): Lead {
+    return new Lead({
+      id: Id.from(props.id),
+      capturedName: props.capturedName,
+      capturedEmail: props.capturedEmail,
+      address: new Address(props.address),
+      contact: new Contact({
+        ...props.contact,
+        id: Id.from(props.contact.id),
+      }),
+      proposals: props.proposals.map(
+        (proposal: any) =>
+          new Proposal({
+            ...proposal,
+            id: Id.from(proposal.id),
+          })
+      ),
+    });
+  }
+}

package/tests/load-test/load.test.ts

@@ -0,0 +1,38 @@
+import { Lead } from "./entities";
+import fs from "fs";
+import { generateData } from "./generate-data";
+import { LeadToDomainMapper } from "./lead-to-domain.mapper";
+import { PaginatedResult } from "../../src";
+
+describe("Big Data", () => {
+  let leads: Lead[] = [];
+
+  function populateLeads() {
+    const data = fs.readFileSync(`${__dirname}/data.json`, "utf8");
+    const leadsData = JSON.parse(data);
+    const toDomainMapper = new LeadToDomainMapper();
+    leads = leadsData.map((lead: any) => toDomainMapper.build(lead));
+  }
+
+  beforeAll(async () => {
+    const hasData = fs.existsSync(`${__dirname}/data.json`);
+    if (!hasData) {
+      await generateData();
+    }
+    populateLeads();
+  });
+
+  it("should have 10000 leads", () => {
+    expect(leads.length).toBe(10000);
+  });
+
+  it("should deserialize to JSON correctly", () => {
+    const paginationResult = PaginatedResult.create(
+      leads,
+      { page: 1, limit: 10, offset: 0 },
+      1000
+    );
+    const json = paginationResult.toJSON();
+    expect(json.data.length).toBe(10000);
+  });
+});

package/tests/repository.test.ts

@@ -4,10 +4,6 @@ import { Repository } from "../src/repository/base-repository";
 import { BaseProps } from "../src/types";
 import { InMemoryRepository } from "./utils";
 
-// ============================================================================
-// Test Domain Models
-// ============================================================================
-
 interface UserProps extends BaseProps {
   name: string;
   email: string;
@@ -55,10 +51,6 @@ class User extends Aggregate<UserProps> {
   }
 }
 
-// ============================================================================
-// Mock Persistence Model
-// ============================================================================
-
 type UserPersistence = {
   id: string;
   name: string;
@@ -69,9 +61,6 @@ type UserPersistence = {
   updatedAt: Date;
 };
 
-// ============================================================================
-// Mapper Implementation
-// ============================================================================
 class UserToDomainMapper extends Mapper<UserPersistence, User> {
   public build(persistence: UserPersistence): User {
     return User.create({
@@ -98,10 +87,6 @@ class UserToPersistenceMapper extends Mapper<User, UserPersistence> {
   }
 }
 
-// ============================================================================
-// Mock Repository Implementation
-// ============================================================================
-
 class MockUserRepository extends Repository<User> {
   private store: Map<string, UserPersistence> = new Map();
 
@@ -116,8 +101,8 @@ class MockUserRepository extends Repository<User> {
     return "users";
   }
 
-  async create(entity: User) {
-    const persistence = this.mapperToPersistence.build(entity);
+  async save(entity: User) {
+    const persistence = await this.mapperToPersistence.build(entity);
     this.store.set(entity.id.value, persistence);
   }
 
@@ -135,18 +120,13 @@ class MockUserRepository extends Repository<User> {
 
   async find(criteria: Criteria<User>): Promise<PaginatedResult<User>> {
     const result = await this.applyCriteria(criteria);
-    return result;
+    return result as PaginatedResult<User>;
   }
 
   async findById(id: string): Promise<User | null> {
     const persistence = this.store.get(id);
     if (!persistence) return null;
-    return this.mapperToDomain.build(persistence);
-  }
-
-  async update(entity: User): Promise<void> {
-    const persistence = this.mapperToPersistence.build(entity);
-    this.store.set(entity.id.value, persistence);
+    return await this.mapperToDomain.build(persistence);
   }
 
   protected async applyCriteria(criteria: Criteria<User>) {
@@ -217,10 +197,6 @@ class MockUserRepository extends Repository<User> {
   }
 }
 
-// ============================================================================
-// Tests
-// ============================================================================
-
 describe("Repository", () => {
   describe("InMemoryRepository", () => {
     let repository: InMemoryRepository<User>;
@@ -262,7 +238,7 @@ describe("Repository", () => {
 
     describe("save and findById", () => {
       it("should save and retrieve user", async () => {
-        await repository.create(user1);
+        await repository.save(user1);
         const found = await repository.findById(user1.id.value);
 
         expect(found).toBeDefined();
@@ -276,9 +252,9 @@ describe("Repository", () => {
       });
 
       it("should update existing user", async () => {
-        await repository.create(user1);
+        await repository.save(user1);
         user1.setName("Alice Updated");
-        await repository.create(user1);
+        await repository.save(user1);
 
         const found = await repository.findById(user1.id.value);
         expect(found?.name).toBe("Alice Updated");
@@ -292,18 +268,18 @@ describe("Repository", () => {
       });
 
       it("should return all users", async () => {
-        await repository.create(user1);
-        await repository.create(user2);
-        await repository.create(user3);
+        await repository.save(user1);
+        await repository.save(user2);
+        await repository.save(user3);
 
         const users = await repository.findAll();
         expect(users).toHaveLength(3);
       });
 
       it("should return users matching criteria", async () => {
-        await repository.create(user1);
-        await repository.create(user2);
-        await repository.create(user3);
+        await repository.save(user1);
+        await repository.save(user2);
+        await repository.save(user3);
 
         const criteria = Criteria.create<User>().whereEquals(
           "status",
@@ -318,9 +294,9 @@ describe("Repository", () => {
 
     describe("find with Criteria", () => {
       beforeEach(async () => {
-        await repository.create(user1);
-        await repository.create(user2);
-        await repository.create(user3);
+        await repository.save(user1);
+        await repository.save(user2);
+        await repository.save(user3);
       });
 
       it("should filter by equals", async () => {
@@ -375,8 +351,8 @@ describe("Repository", () => {
 
     describe("findOne", () => {
       it("should find first matching user", async () => {
-        await repository.create(user1);
-        await repository.create(user2);
+        await repository.save(user1);
+        await repository.save(user2);
 
         const criteria = Criteria.create<User>().whereEquals(
           "status",
@@ -401,7 +377,7 @@ describe("Repository", () => {
 
     describe("delete", () => {
       it("should delete by aggregate", async () => {
-        await repository.create(user1);
+        await repository.save(user1);
         await repository.delete(user1);
 
         const found = await repository.findById(user1.id.value);
@@ -409,7 +385,7 @@ describe("Repository", () => {
       });
 
       it("should delete by id", async () => {
-        await repository.create(user1);
+        await repository.save(user1);
         await repository.delete(user1);
 
         const found = await repository.findById(user1.id.value);
@@ -419,7 +395,7 @@ describe("Repository", () => {
 
     describe("exists", () => {
       it("should return true when user exists", async () => {
-        await repository.create(user1);
+        await repository.save(user1);
         const exists = await repository.exists(user1.id.value);
         expect(exists).toBe(true);
       });
@@ -432,9 +408,9 @@ describe("Repository", () => {
 
     describe("count", () => {
       beforeEach(async () => {
-        await repository.create(user1);
-        await repository.create(user2);
-        await repository.create(user3);
+        await repository.save(user1);
+        await repository.save(user2);
+        await repository.save(user3);
       });
 
       it("should count all users", async () => {
@@ -452,7 +428,7 @@ describe("Repository", () => {
       });
     });
 
-    describe("saveMany", () => {
+    describe("createMany", () => {
       it("should save multiple users", async () => {
         await repository.createMany([user1, user2, user3]);
 
@@ -485,7 +461,7 @@ describe("Repository", () => {
 
     it("should save new user (insert)", async () => {
       expect(user.isNew()).toBe(true);
-      await repository.create(user);
+      await repository.save(user);
 
       const found = await repository.findById(user.id.value);
       expect(found).toBeDefined();
@@ -493,7 +469,7 @@ describe("Repository", () => {
     });
 
     it("should update existing user", async () => {
-      await repository.create(user);
+      await repository.save(user);
 
       // Simulate existing user
       const existingUser = User.create({
@@ -504,7 +480,7 @@ describe("Repository", () => {
         status: "inactive",
       });
 
-      await repository.create(existingUser);
+      await repository.save(existingUser);
 
       const found = await repository.findById(user.id.value);
       expect(found?.name).toBe("John Updated");
@@ -512,7 +488,7 @@ describe("Repository", () => {
     });
 
     it("should convert between domain and persistence", async () => {
-      await repository.create(user);
+      await repository.save(user);
       const found = await repository.findById(user.id.value);
 
       // Should be a domain object
@@ -534,7 +510,7 @@ describe("Repository", () => {
         status: "inactive",
       });
 
-      await Promise.all([repository.create(user1), repository.create(user2)]);
+      await Promise.all([repository.save(user1), repository.save(user2)]);
 
       const result = await repository.find(
         Criteria.create<User>()

package/tests/to-json.test.ts

@@ -1,5 +1,5 @@
 import { Entity, Id } from "../src";
-import { Post, User, Address, Comment } from "./utils";
+import { Post, User, Address } from "./utils";
 
 describe("toJson Functionality", () => {
   it("should convert simple entity to JSON", () => {
@@ -7,7 +7,8 @@ describe("toJson Functionality", () => {
       id: new Id("1"),
       title: "First Post",
       content: "Hello World",
-      likes: 5,
+      published: false,
+      comments: [],
     });
 
     const json = post.toJson();
@@ -15,7 +16,8 @@ describe("toJson Functionality", () => {
       id: "1",
       title: "First Post",
       content: "Hello World",
-      likes: 5,
+      published: false,
+      comments: [],
     });
   });
 
@@ -29,27 +31,22 @@ describe("toJson Functionality", () => {
           id: new Id("1"),
           title: "Post 1",
           content: "Content 1",
-          likes: 0,
+          published: false,
+          comments: [],
         }),
         new Post({
           id: new Id("2"),
           title: "Post 2",
           content: "Content 2",
-          likes: 5,
+          published: false,
+          comments: [],
         }),
       ],
       address: new Address({
         street: "Main St",
         city: "NYC",
-        zipCode: "10001",
       }),
-      comments: [
-        new Comment({
-          id: new Id("1"),
-          text: "Great post!",
-          author: "Alice",
-        }),
-      ],
+      tags: [],
     });
 
     const json = user.toJson();
@@ -58,8 +55,7 @@ describe("toJson Functionality", () => {
     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!");
+    expect(json.address?.city).toBe("NYC");
   });
 
   it("should handle deeply nested structures", () => {
@@ -72,15 +68,15 @@ describe("toJson Functionality", () => {
           id: new Id("1"),
           title: "Post 1",
           content: "Content 1",
-          likes: 0,
+          published: false,
+          comments: [],
         }),
       ],
       address: new Address({
         street: "Main St",
         city: "NYC",
-        zipCode: "10001",
       }),
-      comments: [],
+      tags: [],
     });
 
     const json = user.toJson();