Merge pull request #378 from 4lessandrodev/feat/update-core-dep

[3.9.0] - 2024-04-28 - Update (Break Change)

Author: 4lessandrodev

CHANGELOG.md

@@ -4,6 +4,164 @@ All notable changes to this project will be documented in this file.
 
 ## Unreleased
 
+---
+
+## Released
+
+### [3.9.0] - 2024-04-28
+
+### Update (Break Change)
+
+- Update core to v1.23.0
+- check [Core Changelog](https://github.com/4lessandrodev/rich-domain/blob/main/CHANGELOG.md)
+
+---
+
+## Released
+
+### [3.8.3] - 2024-04-13
+
+### Update
+
+- Update core
+- Added support to multi context name
+- Details [Commit](https://github.com/4lessandrodev/rich-domain/commit/00db292f0604469c8bf2f2fddf6460901a084cc6)
+
+```ts
+
+// Example Usage
+const context = Context.events();
+
+const handler = (event) => console.log(event);
+
+// Subscribing to events under different contexts
+context.subscribe('Context-A:SIGNUP', handler);
+context.subscribe('Context-B:SIGNUP', handler);
+context.subscribe('Context-C:SIGNUP', handler);
+context.subscribe('Context-B:NOTIFY', handler);
+context.subscribe('Context-B:SEND-EMAIL', handler);
+
+// Dispatching events to specific contexts
+// Dispatches the SIGNUP event to Context-B
+context.dispatchEvent('Context-B:SIGNUP');
+// Dispatches the SIGNUP event to all contexts
+context.dispatchEvent('*:SIGNUP');
+// Dispatches all events to all contexts. Not recommended
+context.dispatchEvent('*:*');
+// Dispatches all events under Context-B
+context.dispatchEvent('Context-B:*');
+
+```
+
+---
+
+### [3.8.2] - 2024-04-12
+
+### Update
+
+- Update core
+- Added support to global events [ChangeLog](https://github.com/4lessandrodev/rich-domain/pull/139)
+
+---
+
+### [3.8.1] - 2024-03-18
+
+### Update
+
+- Update core
+- Fix logger messages
+
+---
+
+### [3.8.0] - 2024-03-18
+
+### Update
+
+- update deps core to v1.20.0 see [changes](https://github.com/4lessandrodev/rich-domain/blob/main/CHANGELOG.md)
+
+---
+
+### [3.7.2] - 2024-03-15
+
+### Update
+
+- update deps
+- added support to nodejs v21
+
+---
+
+### [3.7.1] - 2023-12-15
+
+### Update
+
+- update deps
+
+---
+
+### [3.7.0] - 2023-09-30
+
+### Update
+
+- Update core
+- update deps
+- rich-domain: update lib core to 1.19.0
+- remove support for deprecated history method
+- improve performance and save memory usage
+
+---
+
+### [3.6.4] - 2023-08-24
+
+### Update
+
+- Update core
+- update deps
+- rich-domain: update lib core to 1.18.4
+
+---
+
+### [3.6.3] - 2023-07-30
+
+### Update
+
+- Update core
+- rich-domain: update lib core to 1.18.3 #272 #282
+
+---
+
+### [3.6.2] - 2023-07-09
+
+### Update
+
+- Update core
+- rich-domain: update lib core to 1.18.2 #272
+
+---
+
+---
+### [3.6.1] - 2023-06-30
+
+### Update
+
+- Update core
+- rich-domain: update lib core to 1.18.1
+
+---
+### [3.6.0] - 2023-04-21
+
+### Update
+
+- Update core
+- rich-domain: update lib core to 1.18.0 [More](https://github.com/4lessandrodev/rich-domain/blob/main/CHANGELOG.md)
+
+
+---
+### [3.5.3] - 2023-02-18
+
+### Update
+
+- Update core
+- rich-domain: update lib core to 1.17.3
 
 ---
 

README.md

@@ -367,9 +367,175 @@ console.log(result.toObject());
 
 ```
 
----
 
-### See also how to use Aggregate.
+### Aggregate
+
+Encapsulate and are composed of entity classes and value objects that change together in a business transaction
+
+#### Create an aggregate to compose your context.
+
+In my example, let's use the context of payment. All payment transactions are encapsulated by an order (payment order) that represents a user's purchasing context.
+
+```ts
+
+import { Aggregate, Ok, Fail, Result, UID, EventHandler } from 'types-ddd';
+
+// Entities and VO that encapsulate context.
+interface Props {
+    id?: UID;
+    payment: Payment;
+    items: List<Item>;
+    status: OrderStatus;
+    customer: Customer;
+}
+
+// Simple example of an order aggregate encapsulating entities and 
+// value objects for context.
+export default class Order extends Aggregate<Props> {
+
+    // Private constructor to ensure instances creation through static methods.
+    private constructor(props: Props){
+        super(props);
+    }
+
+    // Static method to begin a new order. 
+    // Takes a customer as parameter and returns an instance of Order.
+    public static begin(customer: Customer): Order {
+        // Initialize the status of the order as "begin".
+        const status = OrderStatus.begin();
+        // Initialize the list of items as empty.
+        const items: List<Item> = List.empty();
+        // Initialize the payment as zero, since the order hasn't been paid yet.
+        const payment = Payment.none();
+        // Create a new instance of Order with the provided parameters.
+        const order = new Order({ status, payment, items, customer });
+
+        // Add an event to indicate that the order has begun.
+        order.addEvent('ORDER_HAS_BEGUN', (order) => {
+        // Perform some important operation when the order begins.
+            console.log('Do something important...');
+        });
+
+        // Alternatively, add an event by creating an
+        // instance of a class that extends EventHandler.
+        order.addEvent(new OrderBeganEventHandler());
+
+        // Return the created order instance.
+        return order;
+    }
+
+    // Method to add an item to the order. 
+    // Takes an item as parameter and returns the Order instance.
+    addItem(item: Item): Order {
+        // Add the item to the order's items list.
+        this.props.items.add(item);
+        // Sum item price to payment amount
+        this.props.payment.sum(item.price);
+        // Return the Order instance itself to allow chained calls.
+        return this;
+    }
+
+    // Method to perform the payment of the order. 
+    // Takes a payment object as parameter.
+    pay(payment: Payment): Order {
+        // Set the status of the order to "paid".
+        this.props.status = OrderStatus.paid();
+        // Set the provided payment object.
+        this.props.payment = payment;
+        // Add an event to indicate that the order has been paid.
+        // Assuming OrderPaidEvent is a class representing 
+        // the event of order payment.
+        this.addEvent(new OrderPaidEventHandler());
+        return this; 
+    }
+
+    // Static method to create an instance of Order.
+    // Returns a Result, which can be Ok (success) or Fail (failure).
+    // The value of the Result is an instance of Order, 
+    // if creation is successful.
+    public static create(props: Props): Result<Order> {
+        return Ok(new Order(props));
+    }
+}
+
+```
+
+#### How to use events
+
+Event Handler
+
+```ts
+
+import { Context, EventHandler } from 'rich-domain';
+
+
+class OrderCreatedEvent extends EventHandler<Order> {
+
+    constructor() {
+        super({ eventName: 'OrderCreated' });
+    }
+
+    dispatch(order: Order): void {
+        // dispatch event to another context
+        order.context().dispatchEvent('Context:Event', order.toObject());
+    };
+}
+
+```
+
+Aggregates domain events
+
+
+```ts
+
+order.addEvent('Event', (...args) => {
+    console.log(args);
+});
+
+// Or add an EventHandler instance
+order.addEvent(new OrderCreatedEvent());
+
+order.dispatchEvent('OrderBegun');
+
+// dispatch with args
+order.dispatchEvent('Event', { info: 'custom_args' });
+
+// OR call all added events
+await order.dispatchAll();
+
+
+```
+
+#### How to subscribe to a global event
+
+```ts
+
+import { Context } from 'rich-domain';
+
+const context = Context.events();
+
+context.subscribe('Context:Event', (event) => {
+   const [model] = event.detail;
+   console.log(model);
+});
+
+// dispatch an event to a context with args
+context.dispatchEvent('Context:Event', { name: 'Jane' });
+
+// Dispatching events to specific contexts
+// Dispatches the SIGNUP event to Context-X
+context.dispatchEvent('Context-X:Signup'); 
+
+// Dispatches the SIGNUP event to all contexts
+context.dispatchEvent('*:Signup'); 
+
+// Dispatches all events to all contexts. Not recommended
+context.dispatchEvent('*:*'); 
+
+// Dispatches all events under Context-Y
+context.dispatchEvent('Context-Y:*'); 
+
+``` 
 
 ## Lib Full Documentation
 

SECURITY.md

@@ -0,0 +1,16 @@
+# Security Policy
+
+## Supported Versions
+
+Versions of types-ddd are currently being supported with security updates.
+
+| Version | Supported          |
+| ------- | ------------------ |
+| 3.8.x   | :white_check_mark: |
+| < 3.8   | :x:                |
+
+## Reporting a Vulnerability
+
+If you find some vulnerability please report as issue.
+
+Every month security updates are published as 0.0.x version.

docs/README.md

@@ -1351,7 +1351,7 @@ Now we can dispatch the event whenever we want.
 
 ```ts
 
-DomainEvents.dispatch({ id: product.id, eventName: "ProductCreated" });
+product.dispatch("ProductCreated");
 
 > "EVENT DISPATCH: [Aggregate@Product]:6039756f-d3bc-452e-932a-ec89ff536dda"
 

lib/index.ts

@@ -32,3 +32,4 @@ export * from './patterns/index';
 export * from './core/index';
 export * from 'rich-domain/core';
 export * from 'rich-domain/utils';
+export * from 'rich-domain/types';

lib/patterns/proxy/proxy.pattern.ts

@@ -91,7 +91,7 @@ import { IProxyContext } from '../../types/types';
  */
 export abstract class TSProxy<Data, Payload, Error = string> {
 	constructor(
-		private readonly context: IProxyContext<Data, Payload, Error>
+		private readonly context: IProxyContext<Data, Payload, Error>,
 	) {}
 
 	private async canExecute(data: Data): Promise<Result<boolean, Error>> {
@@ -109,7 +109,7 @@ export abstract class TSProxy<Data, Payload, Error = string> {
 	}
 
 	private async afterExecute(
-		data: Result<Payload, Error>
+		data: Result<Payload, Error>,
 	): Promise<Result<Payload, Error>> {
 		if (!this.context.afterExecute) {
 			return Result.Ok(data.value());