@nestjslatam/ddd-lib 1.0.50 → 1.0.52

package/dist/enum.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DddEnum = void 0;
+const domain_exception_1 = require("./exceptions/domain.exception");
+class DddEnum {
+    constructor(id, name) {
+        this.id = id;
+        this.name = name;
+        this.validateId(id);
+        this.validateName(name);
+    }
+    validateId(id) {
+        if (typeof id !== 'number' || !Number.isInteger(id)) {
+            throw new Error('Enum id must be an integer');
+        }
+        if (id < 0) {
+            throw new Error('Enum id must be non-negative');
+        }
+    }
+    validateName(name) {
+        if (typeof name !== 'string' || name.trim().length === 0) {
+            throw new Error('Enum name must be a non-empty string');
+        }
+    }
+    toString() {
+        return this.name;
+    }
+    static getAll() {
+        const constructor = this;
+        if (DddEnum._cache.has(constructor)) {
+            return DddEnum._cache.get(constructor);
+        }
+        const values = Object.getOwnPropertyNames(constructor)
+            .map((name) => constructor[name])
+            .filter((value) => value instanceof constructor);
+        DddEnum._cache.set(constructor, values);
+        return values;
+    }
+    equals(other) {
+        if (!(other instanceof DddEnum)) {
+            return false;
+        }
+        const typeMatches = Object.getPrototypeOf(this) === Object.getPrototypeOf(other);
+        const valueMatches = this.id === other.id;
+        return typeMatches && valueMatches;
+    }
+    static absoluteDifference(firstValue, secondValue) {
+        if (!firstValue) {
+            throw new domain_exception_1.ArgumentNullException('firstValue');
+        }
+        if (!secondValue) {
+            throw new domain_exception_1.ArgumentNullException('secondValue');
+        }
+        return Math.abs(firstValue.id - secondValue.id);
+    }
+    static fromValue(value) {
+        if (typeof value !== 'number') {
+            return undefined;
+        }
+        const allItems = this.getAll();
+        return allItems.find((item) => item.id === value);
+    }
+    static fromName(name) {
+        if (typeof name !== 'string' || name.trim().length === 0) {
+            return undefined;
+        }
+        const allItems = this.getAll();
+        return allItems.find((item) => item.name === name);
+    }
+    static fromNameIgnoreCase(name) {
+        if (typeof name !== 'string' || name.trim().length === 0) {
+            return undefined;
+        }
+        const allItems = this.getAll();
+        const lowerName = name.toLowerCase();
+        return allItems.find((item) => item.name.toLowerCase() === lowerName);
+    }
+    static fromDisplayName(displayName) {
+        return this.fromName(displayName);
+    }
+    compareTo(other) {
+        if (!other) {
+            throw new domain_exception_1.ArgumentNullException('other');
+        }
+        return this.id - other.id;
+    }
+    isLessThan(other) {
+        return this.compareTo(other) < 0;
+    }
+    isLessThanOrEqual(other) {
+        return this.compareTo(other) <= 0;
+    }
+    isGreaterThan(other) {
+        return this.compareTo(other) > 0;
+    }
+    isGreaterThanOrEqual(other) {
+        return this.compareTo(other) >= 0;
+    }
+    static isDefined(value) {
+        return this.fromValue(value) !== undefined;
+    }
+    static getMinValue() {
+        const allItems = this.getAll();
+        if (allItems.length === 0)
+            return undefined;
+        return allItems.reduce((min, item) => (item.id < min.id ? item : min));
+    }
+    static getMaxValue() {
+        const allItems = this.getAll();
+        if (allItems.length === 0)
+            return undefined;
+        return allItems.reduce((max, item) => (item.id > max.id ? item : max));
+    }
+    isBetween(min, max) {
+        return this.isGreaterThanOrEqual(min) && this.isLessThanOrEqual(max);
+    }
+    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);
+    }
+}
+exports.DddEnum = DddEnum;
+DddEnum._cache = new Map();
+//# sourceMappingURL=enum.js.map

package/dist/exceptions/domain.exception.d.ts

@@ -0,0 +1,19 @@
+export declare abstract class DomainException extends Error {
+    constructor(message: string);
+}
+export declare class ArgumentNullException extends DomainException {
+    constructor(parameterName: string);
+}
+export declare class InvalidOperationException extends DomainException {
+    constructor(message: string);
+}
+export declare class InvalidStateTransitionException extends DomainException {
+    constructor(fromState: string, toState: string);
+}
+export declare class NoTransitionsDefinedException extends DomainException {
+    constructor(stateName: string);
+}
+export declare class InvalidFormatException extends DomainException {
+    constructor(parameterName: string, expectedFormat: string, value?: string);
+}
+//# sourceMappingURL=domain.exception.d.ts.map

package/dist/exceptions/domain.exception.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidFormatException = exports.NoTransitionsDefinedException = exports.InvalidStateTransitionException = exports.InvalidOperationException = exports.ArgumentNullException = exports.DomainException = void 0;
+class DomainException extends Error {
+    constructor(message) {
+        super(message);
+        this.name = this.constructor.name;
+        Error.captureStackTrace(this, this.constructor);
+    }
+}
+exports.DomainException = DomainException;
+class ArgumentNullException extends DomainException {
+    constructor(parameterName) {
+        super(`${parameterName} cannot be null or undefined`);
+    }
+}
+exports.ArgumentNullException = ArgumentNullException;
+class InvalidOperationException extends DomainException {
+    constructor(message) {
+        super(message);
+    }
+}
+exports.InvalidOperationException = InvalidOperationException;
+class InvalidStateTransitionException extends DomainException {
+    constructor(fromState, toState) {
+        super(`Invalid state transition from '${fromState}' to '${toState}'. ` +
+            `This transition is not defined in the valid transitions map.`);
+    }
+}
+exports.InvalidStateTransitionException = InvalidStateTransitionException;
+class NoTransitionsDefinedException extends DomainException {
+    constructor(stateName) {
+        super(`No transitions defined for state '${stateName}'. ` +
+            `Define transitions first using defineTransitions().`);
+    }
+}
+exports.NoTransitionsDefinedException = NoTransitionsDefinedException;
+class InvalidFormatException extends DomainException {
+    constructor(parameterName, expectedFormat, value) {
+        const valueInfo = value ? ` Provided value: '${value}'` : '';
+        super(`${parameterName} has an invalid format. Expected: ${expectedFormat}.${valueInfo}`);
+    }
+}
+exports.InvalidFormatException = InvalidFormatException;
+//# sourceMappingURL=domain.exception.js.map

package/{ddd-helpers → dist/helpers}/datetime.helper.d.ts

@@ -2,3 +2,4 @@ export declare class DateTimeHelper {
     static getUtcDate(): Date;
     static getTimeStamp(): number;
 }
+//# sourceMappingURL=datetime.helper.d.ts.map

package/{ddd-helpers → dist/helpers}/datetime.helper.js

@@ -9,7 +9,7 @@ class DateTimeHelper {
         return new Date(Date.UTC(year, month, day));
     }
     static getTimeStamp() {
-        return +new Date();
+        return Date.now();
     }
 }
 exports.DateTimeHelper = DateTimeHelper;

package/dist/helpers/domain-object.helper.d.ts

@@ -0,0 +1,20 @@
+import { InstanceWrapper } from '@nestjs/core/injector/instance-wrapper';
+import { Module } from '@nestjs/core/injector/module';
+import { DddAggregateRoot } from '../aggregate-root';
+import { IDddPrimitive, Primitives } from '../core';
+import { Type } from '../types';
+export declare class DddObjectHelper {
+    static isEntity(obj: unknown): obj is DddAggregateRoot<any, any>;
+    static convertToPlainObject(item: any): any;
+    static isDomainEntity(entity: unknown): entity is DddAggregateRoot<any, any>;
+    static isDomainPrimitive<T>(obj: unknown): obj is IDddPrimitive<T & (Primitives | Date)>;
+    static convertPropsToObject(props: any): any;
+    static flatMap<T>(options: {
+        modules: Module[];
+        callback: (instance: InstanceWrapper) => Type<any> | undefined;
+    }): Type<T>[];
+    static filterProvider(wrapper: InstanceWrapper, metadataKey: string): Type<any> | undefined;
+    static extractMetadata(instance: Record<string, any>, metadataKey: string): Type<any>;
+    static getEventName(event: any): string;
+}
+//# sourceMappingURL=domain-object.helper.d.ts.map

package/{ddd-helpers → dist/helpers}/domain-object.helper.js

@@ -1,15 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DomainObjectHelper = void 0;
-const ddd_base_classes_1 = require("../ddd-core/ddd-base-classes");
-const ddd_validators_1 = require("../ddd-validators");
-class DomainObjectHelper {
+exports.DddObjectHelper = void 0;
+const aggregate_root_1 = require("../aggregate-root");
+const core_1 = require("../core");
+class DddObjectHelper {
     static isEntity(obj) {
-        return obj instanceof ddd_base_classes_1.DomainEntity;
+        return obj instanceof aggregate_root_1.DddAggregateRoot;
     }
     static convertToPlainObject(item) {
-        if (ddd_validators_1.ValueObjectValidator.isValueObject(item)) {
-            return item.unpack();
+        if (core_1.ValueObjectValidator.isValueObject(item)) {
+            return item.getValue ? item.getValue() : item.unpack?.() || item;
         }
         if (this.isEntity(item)) {
             return item.toObject();
@@ -17,12 +17,12 @@ class DomainObjectHelper {
         return item;
     }
     static isDomainEntity(entity) {
-        return entity instanceof ddd_base_classes_1.DomainEntity;
+        return entity instanceof aggregate_root_1.DddAggregateRoot;
     }
     static isDomainPrimitive(obj) {
-        if (!obj)
+        if (!obj || typeof obj !== 'object')
             return false;
-        return Object.prototype.hasOwnProperty.call(obj, 'value') ? true : false;
+        return Object.hasOwn(obj, 'value');
     }
     static convertPropsToObject(props) {
         if (!props)
@@ -40,10 +40,9 @@ class DomainObjectHelper {
         }
         return propsCopy;
     }
-    static flatMap(modules, callback) {
-        const items = modules
-            .map((module) => [...module.providers.values()].map(callback))
-            .reduce((a, b) => a.concat(b), []);
+    static flatMap(options) {
+        const { modules, callback } = options;
+        const items = modules.flatMap((module) => [...module.providers.values()].map(callback));
         return items.filter((element) => !!element);
     }
     static filterProvider(wrapper, metadataKey) {
@@ -60,14 +59,10 @@ class DomainObjectHelper {
         const metadata = Reflect.getMetadata(metadataKey, instance.constructor);
         return metadata ? instance.constructor : undefined;
     }
-    static getEventHandler(event) {
-        const handler = `on${this.getEventName(event)}`;
-        return this[handler];
-    }
     static getEventName(event) {
         const { constructor } = Object.getPrototypeOf(event);
         return constructor.name;
     }
 }
-exports.DomainObjectHelper = DomainObjectHelper;
+exports.DddObjectHelper = DddObjectHelper;
 //# sourceMappingURL=domain-object.helper.js.map

package/{ddd-helpers → dist/helpers}/index.d.ts

@@ -1,2 +1,3 @@
 export * from './domain-object.helper';
 export * from './datetime.helper';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+export * from './core';
+export * from './enum';
+export * from './exceptions/domain.exception';
+export * from './valueobject';
+export * from './validator-rule.manager';
+export * from './broken-rules.manager';
+export * from './tracking-state-manager';
+export * from './state-transition.manager';
+export * from './domain-event';
+export * from './aggregate-root';
+export * from './helpers';
+export * from './valueobjects';
+//# sourceMappingURL=index.d.ts.map

package/{ddd-events/impl → dist}/index.js

@@ -14,12 +14,16 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./domain-event-bus"), exports);
-__exportStar(require("./domain-event-collection"), exports);
+__exportStar(require("./core"), exports);
+__exportStar(require("./enum"), exports);
+__exportStar(require("./exceptions/domain.exception"), exports);
+__exportStar(require("./valueobject"), exports);
+__exportStar(require("./validator-rule.manager"), exports);
+__exportStar(require("./broken-rules.manager"), exports);
+__exportStar(require("./tracking-state-manager"), exports);
+__exportStar(require("./state-transition.manager"), exports);
 __exportStar(require("./domain-event"), exports);
-__exportStar(require("./domain-event-publisher"), exports);
-__exportStar(require("./domain-event-types"), exports);
-__exportStar(require("./domain-event.deserializer"), exports);
-__exportStar(require("./domain-event.serializer"), exports);
-__exportStar(require("./domain-event-cli.registry"), exports);
+__exportStar(require("./aggregate-root"), exports);
+__exportStar(require("./helpers"), exports);
+__exportStar(require("./valueobjects"), exports);
 //# sourceMappingURL=index.js.map

package/dist/state-transition.manager.d.ts

@@ -0,0 +1,23 @@
+export type StateEqualityComparator<TState> = (state1: TState, state2: TState) => boolean;
+export declare class StateTransitionManager<TState extends object> {
+    private readonly _validTransitions;
+    private readonly _stateComparator;
+    constructor(stateComparator?: StateEqualityComparator<TState>);
+    private getStateName;
+    private findState;
+    defineTransitions(transitions: Map<TState, TState[]>): void;
+    canTransitionTo(currentState: TState, newState: TState): boolean;
+    getValidTransitions(state: TState): readonly TState[];
+    hasTransitions(): boolean;
+    hasTransitionsDefined(state: TState): boolean;
+    getAllStates(): readonly TState[];
+    getTransitionGraph(): Record<string, string[]>;
+    validateTransitionGraph(): {
+        isValid: boolean;
+        warnings: string[];
+        orphanedStates: TState[];
+    };
+    clear(): void;
+    validateTransition(currentState: TState, newState: TState): void;
+}
+//# sourceMappingURL=state-transition.manager.d.ts.map

package/dist/state-transition.manager.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StateTransitionManager = void 0;
+const domain_exception_1 = require("./exceptions/domain.exception");
+class StateTransitionManager {
+    constructor(stateComparator) {
+        this._validTransitions = new Map();
+        this._stateComparator = stateComparator || ((s1, s2) => s1 === s2);
+    }
+    getStateName(state) {
+        if (!state)
+            return 'null/undefined';
+        if (typeof state.toString === 'function') {
+            const str = state.toString();
+            if (str !== '[object Object]')
+                return str;
+        }
+        if ('name' in state && typeof state.name === 'string') {
+            return state.name;
+        }
+        if ('value' in state) {
+            return String(state.value);
+        }
+        return state.constructor?.name || 'Unknown State';
+    }
+    findState(state, states) {
+        return states.some((s) => this._stateComparator(state, s));
+    }
+    defineTransitions(transitions) {
+        if (!transitions) {
+            throw new domain_exception_1.ArgumentNullException('transitions');
+        }
+        if (transitions.size === 0) {
+            throw new Error('Transitions map cannot be empty. Provide at least one state transition.');
+        }
+        transitions.forEach((targetStates, sourceState) => {
+            if (!sourceState) {
+                throw new domain_exception_1.ArgumentNullException('sourceState in transitions map');
+            }
+            if (!targetStates) {
+                throw new domain_exception_1.ArgumentNullException(`targetStates for state '${this.getStateName(sourceState)}'`);
+            }
+            if (!Array.isArray(targetStates)) {
+                throw new Error(`Target states for '${this.getStateName(sourceState)}' must be an array`);
+            }
+            if (targetStates.length === 0) {
+                throw new Error(`Target states array for '${this.getStateName(sourceState)}' cannot be empty. ` +
+                    `Remove the entry if no transitions are allowed from this state.`);
+            }
+            targetStates.forEach((targetState, index) => {
+                if (!targetState) {
+                    throw new domain_exception_1.ArgumentNullException(`targetState at index ${index} for source state '${this.getStateName(sourceState)}'`);
+                }
+            });
+        });
+        this._validTransitions.clear();
+        transitions.forEach((value, key) => {
+            this._validTransitions.set(key, [...value]);
+        });
+    }
+    canTransitionTo(currentState, newState) {
+        if (!currentState) {
+            throw new domain_exception_1.ArgumentNullException('currentState');
+        }
+        if (!newState) {
+            throw new domain_exception_1.ArgumentNullException('newState');
+        }
+        let foundKey;
+        for (const key of this._validTransitions.keys()) {
+            if (this._stateComparator(key, currentState)) {
+                foundKey = key;
+                break;
+            }
+        }
+        if (!foundKey) {
+            throw new domain_exception_1.NoTransitionsDefinedException(this.getStateName(currentState));
+        }
+        const possibleTransitions = this._validTransitions.get(foundKey);
+        return possibleTransitions
+            ? this.findState(newState, possibleTransitions)
+            : false;
+    }
+    getValidTransitions(state) {
+        if (!state) {
+            throw new domain_exception_1.ArgumentNullException('state');
+        }
+        for (const [key, value] of this._validTransitions.entries()) {
+            if (this._stateComparator(key, state)) {
+                return [...value];
+            }
+        }
+        return [];
+    }
+    hasTransitions() {
+        return this._validTransitions.size > 0;
+    }
+    hasTransitionsDefined(state) {
+        if (!state) {
+            throw new domain_exception_1.ArgumentNullException('state');
+        }
+        for (const key of this._validTransitions.keys()) {
+            if (this._stateComparator(key, state)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    getAllStates() {
+        return Array.from(this._validTransitions.keys());
+    }
+    getTransitionGraph() {
+        const graph = {};
+        this._validTransitions.forEach((targets, source) => {
+            const sourceName = this.getStateName(source);
+            graph[sourceName] = targets.map((t) => this.getStateName(t));
+        });
+        return graph;
+    }
+    validateTransitionGraph() {
+        const warnings = [];
+        const orphanedStates = [];
+        const allSourceStates = new Set(this._validTransitions.keys());
+        const allTargetStates = new Set();
+        this._validTransitions.forEach((targets) => {
+            targets.forEach((target) => allTargetStates.add(target));
+        });
+        allTargetStates.forEach((targetState) => {
+            let isOrphaned = true;
+            for (const sourceState of allSourceStates) {
+                if (this._stateComparator(targetState, sourceState)) {
+                    isOrphaned = false;
+                    break;
+                }
+            }
+            if (isOrphaned) {
+                orphanedStates.push(targetState);
+                warnings.push(`State '${this.getStateName(targetState)}' is a transition target but has no outgoing transitions defined. ` +
+                    `This might be intentional for terminal states.`);
+            }
+        });
+        return {
+            isValid: true,
+            warnings,
+            orphanedStates,
+        };
+    }
+    clear() {
+        this._validTransitions.clear();
+    }
+    validateTransition(currentState, newState) {
+        if (!currentState) {
+            throw new domain_exception_1.ArgumentNullException('currentState');
+        }
+        if (!newState) {
+            throw new domain_exception_1.ArgumentNullException('newState');
+        }
+        if (!this.canTransitionTo(currentState, newState)) {
+            throw new domain_exception_1.InvalidStateTransitionException(this.getStateName(currentState), this.getStateName(newState));
+        }
+    }
+}
+exports.StateTransitionManager = StateTransitionManager;
+//# sourceMappingURL=state-transition.manager.js.map

package/dist/tracking-state-manager.d.ts

@@ -0,0 +1,25 @@
+import { IChangeDetector, IProps, ITrackingProps, ITrackingStateManager, ITrackingStateTransitions } from './core';
+export declare class TrackingStateManager implements ITrackingStateManager, ITrackingStateTransitions {
+    private _isNew;
+    private _isDirty;
+    private _isSelfDeleted;
+    private _isDeleted;
+    private readonly changeDetector;
+    get isNew(): boolean;
+    get isDirty(): boolean;
+    get isSelfDeleted(): boolean;
+    get isDeleted(): boolean;
+    constructor(changeDetector?: IChangeDetector);
+    get trackingProps(): ITrackingProps;
+    getTracking<TProp extends IProps>(props: TProp): this;
+    markAsDirty(): void;
+    markAsNew(): void;
+    markAsSelfDeleted(): void;
+    markAsDeleted(): void;
+    markAsClean(): void;
+    setDirty(value: boolean): void;
+    setNew(value: boolean): void;
+    setSelfDeleted(value: boolean): void;
+    setDeleted(value: boolean): void;
+}
+//# sourceMappingURL=tracking-state-manager.d.ts.map

package/dist/tracking-state-manager.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrackingStateManager = void 0;
+const core_1 = require("./core");
+class TrackingStateManager {
+    get isNew() {
+        return this._isNew;
+    }
+    get isDirty() {
+        return this._isDirty;
+    }
+    get isSelfDeleted() {
+        return this._isSelfDeleted;
+    }
+    get isDeleted() {
+        return this._isDeleted;
+    }
+    constructor(changeDetector) {
+        this._isNew = false;
+        this._isDirty = false;
+        this._isSelfDeleted = false;
+        this._isDeleted = false;
+        this.changeDetector = changeDetector || new core_1.NestedPropertyChangeDetector();
+        this.markAsClean();
+    }
+    get trackingProps() {
+        return {
+            isDirty: this._isDirty,
+            isNew: this._isNew,
+            isDeleted: this._isDeleted,
+            isSelfDeleted: this._isSelfDeleted,
+        };
+    }
+    getTracking(props) {
+        this.changeDetector.detectChanges(props, this);
+        return this;
+    }
+    markAsDirty() {
+        core_1.TrackingStateTransition.toDirty(this);
+    }
+    markAsNew() {
+        core_1.TrackingStateTransition.toNew(this);
+    }
+    markAsSelfDeleted() {
+        core_1.TrackingStateTransition.toSelfDeleted(this);
+    }
+    markAsDeleted() {
+        core_1.TrackingStateTransition.toDeleted(this);
+    }
+    markAsClean() {
+        this._isDirty = false;
+        this._isNew = false;
+        this._isSelfDeleted = false;
+        this._isDeleted = false;
+    }
+    setDirty(value) {
+        this._isDirty = value;
+    }
+    setNew(value) {
+        this._isNew = value;
+    }
+    setSelfDeleted(value) {
+        this._isSelfDeleted = value;
+    }
+    setDeleted(value) {
+        this._isDeleted = value;
+    }
+}
+exports.TrackingStateManager = TrackingStateManager;
+//# sourceMappingURL=tracking-state-manager.js.map

package/dist/validator-rule.manager.d.ts

@@ -0,0 +1,17 @@
+import { BrokenRule, ClassType, IRuleValidator } from './core';
+export declare class ValidatorRuleManager<TValidator extends IRuleValidator> {
+    private readonly _validators;
+    add(rule: TValidator): void;
+    addRange(rules: TValidator[]): void;
+    remove(rule: TValidator): void;
+    clear(): void;
+    getValidators(): ReadonlyArray<TValidator>;
+    getBrokenRules(): ReadonlyArray<BrokenRule>;
+    isEmpty(): boolean;
+    count(): number;
+    has(validatorType: ClassType<TValidator>): boolean;
+    findByType(validatorType: ClassType<TValidator>): TValidator | undefined;
+    private hasValidatorOfType;
+    private getBrokenRuleKey;
+}
+//# sourceMappingURL=validator-rule.manager.d.ts.map