@woltz/rich-domain 1.2.4 → 1.3.1

package/tests/load-test/entities.ts

@@ -1,97 +0,0 @@
-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

@@ -1,81 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

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