@nestjslatam/ddd-lib 1.0.51 → 1.0.52

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2023 NESTJS Latam
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2023 NESTJS Latam
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,30 +1,30 @@
-# Ddd Library
-
-Welcome to DDD Library for NESTJS, an innovative open-source library crafted to seamlessly integrate Domain-Driven Design (DDD) principles into your NESTJS applications. This powerful library is meticulously developed with a focus on TypeScript, leveraging the robust capabilities of NESTJS and ensuring seamless compatibility with Node.js.
-
-Domain-Driven Design has proven to be a game-changer in building scalable and maintainable applications by placing the domain at the heart of the software design process. With [Library Name], we aim to simplify the application of DDD concepts within the NESTJS framework, empowering developers to create well-architected, domain-centric solutions.
-
-## DISCLAIMER: This library is not ready to be used in production environments
-
-# Key Features:
-
-- NESTJS Integration: DDD Library for NESTJS is designed from the ground up to seamlessly integrate with NESTJS, a leading framework for building efficient and scalable server-side applications with TypeScript.
-- TypeScript Support: Take advantage of the static typing and modern features of TypeScript, enhancing the development experience and catching errors early in the development process.
-- Node.js Compatibility: DDD Library for NESTJS is built to support Node.js, allowing you to harness the full power of JavaScript on the server side.
-- Domain-Driven Design Principles: Embrace the core principles of DDD effortlessly. DDD Library for NESTJS provides abstractions and utilities that align with DDD concepts, allowing you to model your domain in a clear and expressive manner.
-- Modularity and Extensibility: Enjoy a modular and extensible architecture that adapts to the complexity of your application. DDD Library for NESTJS empowers you to build scalable systems by encapsulating domain logic in a modular fashion.
-- Community-Driven: As an open-source project, DDD Library for NESTJS thrives on community collaboration. Contribute, share your insights, and join the growing community of developers dedicated to enhancing DDD practices within NESTJS.
-
-# Getting Started:
-
-To start incorporating DDD principles into your NESTJS projects, DDD Library for NESTJS offers comprehensive documentation, examples, and tutorials to guide you through the implementation process. Whether you are a seasoned developer or new to DDD, our library provides the tools you need to create robust, maintainable, and scalable applications.
-
-Explore the potential of DDD Library for NESTJS today and elevate your NESTJS projects to new heights by seamlessly integrating Domain-Driven Design into your development workflow. Together, let's build software that truly reflects the intricacies of your business domain.
-
-### Install
-
-`npm install @nestjslatam/ddd-lib`
-
-### Use library
-
-This source code include a defaultr sample where we can see in detail how use this library.
+# Ddd Library
+
+Welcome to DDD Library for NESTJS, an innovative open-source library crafted to seamlessly integrate Domain-Driven Design (DDD) principles into your NESTJS applications. This powerful library is meticulously developed with a focus on TypeScript, leveraging the robust capabilities of NESTJS and ensuring seamless compatibility with Node.js.
+
+Domain-Driven Design has proven to be a game-changer in building scalable and maintainable applications by placing the domain at the heart of the software design process. With [Library Name], we aim to simplify the application of DDD concepts within the NESTJS framework, empowering developers to create well-architected, domain-centric solutions.
+
+## DISCLAIMER: This library is not ready to be used in production environments
+
+# Key Features:
+
+- NESTJS Integration: DDD Library for NESTJS is designed from the ground up to seamlessly integrate with NESTJS, a leading framework for building efficient and scalable server-side applications with TypeScript.
+- TypeScript Support: Take advantage of the static typing and modern features of TypeScript, enhancing the development experience and catching errors early in the development process.
+- Node.js Compatibility: DDD Library for NESTJS is built to support Node.js, allowing you to harness the full power of JavaScript on the server side.
+- Domain-Driven Design Principles: Embrace the core principles of DDD effortlessly. DDD Library for NESTJS provides abstractions and utilities that align with DDD concepts, allowing you to model your domain in a clear and expressive manner.
+- Modularity and Extensibility: Enjoy a modular and extensible architecture that adapts to the complexity of your application. DDD Library for NESTJS empowers you to build scalable systems by encapsulating domain logic in a modular fashion.
+- Community-Driven: As an open-source project, DDD Library for NESTJS thrives on community collaboration. Contribute, share your insights, and join the growing community of developers dedicated to enhancing DDD practices within NESTJS.
+
+# Getting Started:
+
+To start incorporating DDD principles into your NESTJS projects, DDD Library for NESTJS offers comprehensive documentation, examples, and tutorials to guide you through the implementation process. Whether you are a seasoned developer or new to DDD, our library provides the tools you need to create robust, maintainable, and scalable applications.
+
+Explore the potential of DDD Library for NESTJS today and elevate your NESTJS projects to new heights by seamlessly integrating Domain-Driven Design into your development workflow. Together, let's build software that truly reflects the intricacies of your business domain.
+
+### Install
+
+`npm install @nestjslatam/ddd-lib`
+
+### Use library
+
+This source code include a defaultr sample where we can see in detail how use this library.

package/dist/aggregate-root.d.ts

@@ -0,0 +1,63 @@
+import { AggregateRoot } from '@nestjs/cqrs';
+import { BrokenRulesManager } from './broken-rules.manager';
+import { AbstractRuleValidator, TrackingProps } from './core';
+import { TrackingStateManager } from './tracking-state-manager';
+import { ValidatorRuleManager } from './validator-rule.manager';
+import { IdValueObject } from './valueobjects';
+export declare abstract class DddAggregateRoot<TEntity, TProps, TState extends object = object> extends AggregateRoot {
+    private _props;
+    private _version;
+    private readonly _trackingStateManager;
+    private readonly _brokenRulesManager;
+    private readonly _validatorRuleManager;
+    private readonly _stateTransitionManager;
+    private readonly _guardStrategy;
+    private readonly _validatorsStrategy;
+    private _id;
+    get id(): IdValueObject;
+    private set id(value);
+    get props(): TProps;
+    private set props(value);
+    get version(): number;
+    private set version(value);
+    get brokenRules(): BrokenRulesManager;
+    get trackingState(): TrackingStateManager;
+    get validators(): ValidatorRuleManager<AbstractRuleValidator<TEntity>>;
+    get propsCopy(): Readonly<TProps & {
+        id: IdValueObject;
+        props: TProps;
+        trackingState: TrackingProps;
+    }>;
+    isValid(): boolean;
+    protected static createValidated<T extends DddAggregateRoot<any, any, any>>(createFn: () => T): T;
+    constructor(props: TProps, options?: {
+        trackingStateManager?: TrackingStateManager;
+        brokenRulesManager?: BrokenRulesManager;
+        validatorRuleManager?: ValidatorRuleManager<AbstractRuleValidator<TEntity>>;
+        id?: IdValueObject;
+        guardStrategy?: () => void;
+        validatorsStrategy?: (manager: ValidatorRuleManager<AbstractRuleValidator<TEntity>>) => void;
+        skipInitialValidation?: boolean;
+    });
+    validate(): void;
+    protected guard(): void;
+    protected addValidators(_manager: ValidatorRuleManager<AbstractRuleValidator<TEntity>>): void;
+    equals(obj: unknown): boolean;
+    private referenceEntityPropertiesEquals;
+    static areEqual<T, P>(left: DddAggregateRoot<T, P> | null, right: DddAggregateRoot<T, P> | null): boolean;
+    static areNotEqual<T, P>(left: DddAggregateRoot<T, P> | null, right: DddAggregateRoot<T, P> | null): boolean;
+    toPlainObject(): {
+        id: IdValueObject;
+        version: number;
+        isValid: boolean;
+    } & TProps;
+    toObject(): {
+        id: IdValueObject;
+        trackingState: TrackingStateManager;
+        brokenRules: BrokenRulesManager;
+        isValid: boolean;
+    } & TProps;
+    protected defineValidTransitions(transitions: Map<TState, TState[]>): void;
+    protected canTransitionTo(currentState: TState, newState: TState): boolean;
+}
+//# sourceMappingURL=aggregate-root.d.ts.map

package/dist/aggregate-root.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DddAggregateRoot = void 0;
+const cqrs_1 = require("@nestjs/cqrs");
+const broken_rules_manager_1 = require("./broken-rules.manager");
+const state_transition_manager_1 = require("./state-transition.manager");
+const tracking_state_manager_1 = require("./tracking-state-manager");
+const validator_rule_manager_1 = require("./validator-rule.manager");
+const valueobjects_1 = require("./valueobjects");
+class DddAggregateRoot extends cqrs_1.AggregateRoot {
+    get id() {
+        return this._id;
+    }
+    set id(value) {
+        this._id = value;
+    }
+    get props() {
+        return this._props;
+    }
+    set props(value) {
+        this._props = value;
+    }
+    get version() {
+        return this._version;
+    }
+    set version(value) {
+        this._version = value;
+    }
+    get brokenRules() {
+        return this._brokenRulesManager;
+    }
+    get trackingState() {
+        return this._trackingStateManager;
+    }
+    get validators() {
+        return this._validatorRuleManager;
+    }
+    get propsCopy() {
+        return Object.freeze({
+            props: this._props,
+            id: this.id,
+            trackingState: this.trackingState.trackingProps,
+        });
+    }
+    isValid() {
+        return this._brokenRulesManager.getBrokenRules().length === 0;
+    }
+    static createValidated(createFn) {
+        const aggregate = createFn();
+        aggregate.validate();
+        return aggregate;
+    }
+    constructor(props, options) {
+        super();
+        this._trackingStateManager =
+            options?.trackingStateManager ?? new tracking_state_manager_1.TrackingStateManager();
+        this._brokenRulesManager =
+            options?.brokenRulesManager ?? new broken_rules_manager_1.BrokenRulesManager();
+        this._validatorRuleManager =
+            options?.validatorRuleManager ??
+                new validator_rule_manager_1.ValidatorRuleManager();
+        this._stateTransitionManager = new state_transition_manager_1.StateTransitionManager();
+        this.id = options?.id ?? valueobjects_1.IdValueObject.create();
+        this._props = props;
+        this._guardStrategy = options?.guardStrategy ?? (() => this.guard());
+        this._validatorsStrategy =
+            options?.validatorsStrategy ?? ((manager) => this.addValidators(manager));
+        if (!options?.skipInitialValidation) {
+            this.validate();
+        }
+        this._trackingStateManager.markAsNew();
+    }
+    validate() {
+        this._guardStrategy();
+        this._validatorsStrategy(this._validatorRuleManager);
+        const entityBrokenRules = this._validatorRuleManager.getBrokenRules();
+        if (entityBrokenRules.length > 0) {
+            this.brokenRules.addRange(entityBrokenRules);
+            this._trackingStateManager.markAsDirty();
+        }
+        const propBrokenRules = broken_rules_manager_1.BrokenRulesManager.getPropertiesBrokenRules(this, Object.getOwnPropertyNames(Object.getPrototypeOf(this)));
+        if (propBrokenRules.length > 0) {
+            this.brokenRules.addRange(propBrokenRules);
+            this._trackingStateManager.markAsDirty();
+        }
+    }
+    guard() {
+    }
+    addValidators(_manager) {
+    }
+    equals(obj) {
+        if (obj === null || obj === undefined) {
+            return false;
+        }
+        if (!(obj instanceof DddAggregateRoot)) {
+            return false;
+        }
+        if (this === obj) {
+            return true;
+        }
+        if (Object.getPrototypeOf(this) !== Object.getPrototypeOf(obj)) {
+            return false;
+        }
+        return this.referenceEntityPropertiesEquals(obj);
+    }
+    referenceEntityPropertiesEquals(obj) {
+        const thisId = this.id;
+        const otherId = obj.id;
+        if (thisId === null ||
+            thisId === undefined ||
+            otherId === null ||
+            otherId === undefined) {
+            return false;
+        }
+        if (typeof thisId.equals === 'function') {
+            return thisId.equals(otherId);
+        }
+        return thisId === otherId;
+    }
+    static areEqual(left, right) {
+        if (left === null || left === undefined) {
+            return right === null || right === undefined;
+        }
+        return left.equals(right);
+    }
+    static areNotEqual(left, right) {
+        return !this.areEqual(left, right);
+    }
+    toPlainObject() {
+        return {
+            id: this.id,
+            version: this.version,
+            ...this._props,
+            isValid: this.isValid(),
+        };
+    }
+    toObject() {
+        return {
+            id: this.id,
+            ...this._props,
+            trackingState: this.trackingState,
+            brokenRules: this.brokenRules,
+            isValid: this.isValid(),
+        };
+    }
+    defineValidTransitions(transitions) {
+        this._stateTransitionManager.defineTransitions(transitions);
+    }
+    canTransitionTo(currentState, newState) {
+        return this._stateTransitionManager.canTransitionTo(currentState, newState);
+    }
+}
+exports.DddAggregateRoot = DddAggregateRoot;
+//# sourceMappingURL=aggregate-root.js.map

package/dist/broken-rules.manager.d.ts

@@ -0,0 +1,21 @@
+import { BrokenRule } from './core';
+export interface IBrokenRulesManager {
+    getBrokenRules(): ReadonlyArray<BrokenRule>;
+}
+export declare class BrokenRulesManager implements IBrokenRulesManager {
+    private _brokenRules;
+    private static readonly BROKEN_RULES_PROPERTY_NAME;
+    add(brokenRule: BrokenRule): void;
+    addRange(brokenRules: ReadonlyArray<BrokenRule>): void;
+    remove(brokenRule: BrokenRule): void;
+    clear(): void;
+    getBrokenRules(): ReadonlyArray<BrokenRule>;
+    hasErrors(): boolean;
+    getBrokenRulesAsString(): string;
+    static getPropertiesBrokenRules<T extends object>(instance: T, properties: Array<keyof T>): ReadonlyArray<BrokenRule>;
+    private validateNotNull;
+    private exists;
+    private isSameRule;
+    private static extractBrokenRulesManager;
+}
+//# sourceMappingURL=broken-rules.manager.d.ts.map

package/dist/broken-rules.manager.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BrokenRulesManager = void 0;
+const domain_exception_1 = require("./exceptions/domain.exception");
+class BrokenRulesManager {
+    constructor() {
+        this._brokenRules = [];
+    }
+    add(brokenRule) {
+        this.validateNotNull(brokenRule, 'brokenRule');
+        if (!this.exists(brokenRule)) {
+            this._brokenRules.push(brokenRule);
+        }
+    }
+    addRange(brokenRules) {
+        this.validateNotNull(brokenRules, 'brokenRules');
+        brokenRules.forEach((rule) => this.add(rule));
+    }
+    remove(brokenRule) {
+        this.validateNotNull(brokenRule, 'brokenRule');
+        const index = this._brokenRules.findIndex((rule) => this.isSameRule(rule, brokenRule));
+        if (index !== -1) {
+            this._brokenRules.splice(index, 1);
+        }
+    }
+    clear() {
+        this._brokenRules = [];
+    }
+    getBrokenRules() {
+        return Object.freeze([...this._brokenRules]);
+    }
+    hasErrors() {
+        return this._brokenRules.length > 0;
+    }
+    getBrokenRulesAsString() {
+        if (this._brokenRules.length === 0) {
+            return '';
+        }
+        return this._brokenRules
+            .map((rule) => `Property: ${rule.property}, Message: ${rule.message}`)
+            .join('\n');
+    }
+    static getPropertiesBrokenRules(instance, properties) {
+        if (instance === null || instance === undefined) {
+            throw new domain_exception_1.ArgumentNullException('instance');
+        }
+        if (!properties) {
+            throw new domain_exception_1.ArgumentNullException('properties');
+        }
+        const result = [];
+        for (const key of properties) {
+            const valueObject = instance[key];
+            if (valueObject === null || valueObject === undefined) {
+                continue;
+            }
+            const brokenRulesManager = this.extractBrokenRulesManager(valueObject);
+            if (brokenRulesManager) {
+                const brokenRules = brokenRulesManager.getBrokenRules();
+                if (brokenRules.length > 0) {
+                    result.push(...brokenRules);
+                }
+            }
+        }
+        return Object.freeze(result);
+    }
+    validateNotNull(value, parameterName) {
+        if (value === null || value === undefined) {
+            throw new domain_exception_1.ArgumentNullException(parameterName);
+        }
+    }
+    exists(brokenRule) {
+        return this._brokenRules.some((rule) => this.isSameRule(rule, brokenRule));
+    }
+    isSameRule(rule1, rule2) {
+        return (rule1.property.toLowerCase() === rule2.property.toLowerCase() &&
+            rule1.message.toLowerCase() === rule2.message.toLowerCase());
+    }
+    static extractBrokenRulesManager(valueObject) {
+        if (typeof valueObject === 'object' &&
+            valueObject !== null &&
+            BrokenRulesManager.BROKEN_RULES_PROPERTY_NAME in valueObject) {
+            const manager = valueObject[BrokenRulesManager.BROKEN_RULES_PROPERTY_NAME];
+            if (manager &&
+                typeof manager === 'object' &&
+                'getBrokenRules' in manager &&
+                typeof manager.getBrokenRules === 'function') {
+                return manager;
+            }
+        }
+        return null;
+    }
+}
+exports.BrokenRulesManager = BrokenRulesManager;
+BrokenRulesManager.BROKEN_RULES_PROPERTY_NAME = 'brokenRules';
+//# sourceMappingURL=broken-rules.manager.js.map

package/dist/core/aggregate/aggregate-equality.d.ts

@@ -0,0 +1,16 @@
+import { AggregateIdentity } from './aggregate-identity';
+export declare class AggregateEquality<T extends {
+    identity: AggregateIdentity;
+}> {
+    private readonly identity;
+    private readonly aggregateType;
+    constructor(identity: AggregateIdentity, aggregateType: new (...args: any[]) => T);
+    equals(obj: unknown): boolean;
+    static areEqual<T extends {
+        identity: AggregateIdentity;
+    }>(left: T | null | undefined, right: T | null | undefined): boolean;
+    static areNotEqual<T extends {
+        identity: AggregateIdentity;
+    }>(left: T | null | undefined, right: T | null | undefined): boolean;
+}
+//# sourceMappingURL=aggregate-equality.d.ts.map

package/dist/core/aggregate/aggregate-equality.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AggregateEquality = void 0;
+class AggregateEquality {
+    constructor(identity, aggregateType) {
+        this.identity = identity;
+        this.aggregateType = aggregateType;
+    }
+    equals(obj) {
+        if (obj === null || obj === undefined) {
+            return false;
+        }
+        if (!(obj instanceof this.aggregateType)) {
+            return false;
+        }
+        const typedObj = obj;
+        return this.identity.equals(typedObj.identity);
+    }
+    static areEqual(left, right) {
+        if (left === null || left === undefined) {
+            return right === null || right === undefined;
+        }
+        if (right === null || right === undefined) {
+            return false;
+        }
+        return left.identity.equals(right.identity);
+    }
+    static areNotEqual(left, right) {
+        return !this.areEqual(left, right);
+    }
+}
+exports.AggregateEquality = AggregateEquality;
+//# sourceMappingURL=aggregate-equality.js.map

package/dist/core/aggregate/aggregate-identity.d.ts

@@ -0,0 +1,11 @@
+import { IdValueObject } from '../../valueobjects';
+export declare class AggregateIdentity {
+    private readonly _id;
+    private constructor();
+    static create(): AggregateIdentity;
+    static fromExisting(id: IdValueObject): AggregateIdentity;
+    get id(): IdValueObject;
+    equals(other: AggregateIdentity | null | undefined): boolean;
+    toString(): string;
+}
+//# sourceMappingURL=aggregate-identity.d.ts.map

package/dist/core/aggregate/aggregate-identity.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AggregateIdentity = void 0;
+const valueobjects_1 = require("../../valueobjects");
+class AggregateIdentity {
+    constructor(id) {
+        this._id = id;
+    }
+    static create() {
+        return new AggregateIdentity(valueobjects_1.IdValueObject.create());
+    }
+    static fromExisting(id) {
+        return new AggregateIdentity(id);
+    }
+    get id() {
+        return this._id;
+    }
+    equals(other) {
+        if (other === null || other === undefined) {
+            return false;
+        }
+        const thisId = this._id;
+        const otherId = other._id;
+        if (thisId === null ||
+            thisId === undefined ||
+            otherId === null ||
+            otherId === undefined) {
+            return false;
+        }
+        if (typeof thisId.equals === 'function') {
+            return thisId.equals(otherId);
+        }
+        return thisId === otherId;
+    }
+    toString() {
+        return this._id.toString();
+    }
+}
+exports.AggregateIdentity = AggregateIdentity;
+//# sourceMappingURL=aggregate-identity.js.map

package/dist/core/aggregate/aggregate-serializer.d.ts

@@ -0,0 +1,28 @@
+import { IdValueObject } from '../../valueobjects';
+import { TrackingStateManager } from '../../tracking-state-manager';
+import { TrackingProps } from '../tracking-state';
+export declare class AggregateSerializer<TProps> {
+    private readonly id;
+    private readonly props;
+    private readonly version;
+    private readonly trackingState;
+    private readonly isValidFn;
+    constructor(id: IdValueObject, props: TProps, version: number, trackingState: TrackingStateManager, isValidFn: () => boolean);
+    toPlainObject(): {
+        id: IdValueObject;
+        version: number;
+        isValid: boolean;
+    } & TProps;
+    toFullObject(brokenRules: any): {
+        id: IdValueObject;
+        trackingState: TrackingStateManager;
+        brokenRules: any;
+        isValid: boolean;
+    } & TProps;
+    getFrozenCopy(): Readonly<TProps & {
+        id: IdValueObject;
+        props: TProps;
+        trackingState: TrackingProps;
+    }>;
+}
+//# sourceMappingURL=aggregate-serializer.d.ts.map

package/dist/core/aggregate/aggregate-serializer.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AggregateSerializer = void 0;
+class AggregateSerializer {
+    constructor(id, props, version, trackingState, isValidFn) {
+        this.id = id;
+        this.props = props;
+        this.version = version;
+        this.trackingState = trackingState;
+        this.isValidFn = isValidFn;
+    }
+    toPlainObject() {
+        return {
+            id: this.id,
+            version: this.version,
+            ...this.props,
+            isValid: this.isValidFn(),
+        };
+    }
+    toFullObject(brokenRules) {
+        return {
+            id: this.id,
+            ...this.props,
+            trackingState: this.trackingState,
+            brokenRules: brokenRules,
+            isValid: this.isValidFn(),
+        };
+    }
+    getFrozenCopy() {
+        return Object.freeze({
+            props: this.props,
+            id: this.id,
+            trackingState: this.trackingState.trackingProps,
+        });
+    }
+}
+exports.AggregateSerializer = AggregateSerializer;
+//# sourceMappingURL=aggregate-serializer.js.map

package/dist/core/aggregate/aggregate-validation-orchestrator.d.ts

@@ -0,0 +1,14 @@
+import { BrokenRulesManager } from '../../broken-rules.manager';
+import { AbstractRuleValidator } from '../validator-rules';
+import { ValidatorRuleManager } from '../../validator-rule.manager';
+export declare class AggregateValidationOrchestrator<TEntity> {
+    private readonly guardStrategy;
+    private readonly validatorsStrategy;
+    private readonly brokenRulesManager;
+    private readonly validatorRuleManager;
+    constructor(guardStrategy: () => void, validatorsStrategy: (manager: ValidatorRuleManager<AbstractRuleValidator<TEntity>>) => void, brokenRulesManager: BrokenRulesManager, validatorRuleManager: ValidatorRuleManager<AbstractRuleValidator<TEntity>>);
+    validate(aggregate: any): number;
+    isValid(): boolean;
+    clearBrokenRules(): void;
+}
+//# sourceMappingURL=aggregate-validation-orchestrator.d.ts.map

package/dist/core/aggregate/aggregate-validation-orchestrator.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AggregateValidationOrchestrator = void 0;
+const broken_rules_manager_1 = require("../../broken-rules.manager");
+class AggregateValidationOrchestrator {
+    constructor(guardStrategy, validatorsStrategy, brokenRulesManager, validatorRuleManager) {
+        this.guardStrategy = guardStrategy;
+        this.validatorsStrategy = validatorsStrategy;
+        this.brokenRulesManager = brokenRulesManager;
+        this.validatorRuleManager = validatorRuleManager;
+    }
+    validate(aggregate) {
+        let brokenRulesCount = 0;
+        this.guardStrategy();
+        this.validatorsStrategy(this.validatorRuleManager);
+        const entityBrokenRules = this.validatorRuleManager.getBrokenRules();
+        if (entityBrokenRules.length > 0) {
+            this.brokenRulesManager.addRange(entityBrokenRules);
+            brokenRulesCount += entityBrokenRules.length;
+        }
+        const propBrokenRules = broken_rules_manager_1.BrokenRulesManager.getPropertiesBrokenRules(aggregate, Object.getOwnPropertyNames(Object.getPrototypeOf(aggregate)));
+        if (propBrokenRules.length > 0) {
+            this.brokenRulesManager.addRange(propBrokenRules);
+            brokenRulesCount += propBrokenRules.length;
+        }
+        return brokenRulesCount;
+    }
+    isValid() {
+        return this.brokenRulesManager.getBrokenRules().length === 0;
+    }
+    clearBrokenRules() {
+        this.brokenRulesManager.clear();
+    }
+}
+exports.AggregateValidationOrchestrator = AggregateValidationOrchestrator;
+//# sourceMappingURL=aggregate-validation-orchestrator.js.map