@nestjslatam/ddd-lib 1.0.51 → 1.0.52

package/dist/validator-rule.manager.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidatorRuleManager = void 0;
+const domain_exception_1 = require("./exceptions/domain.exception");
+class ValidatorRuleManager {
+    constructor() {
+        this._validators = [];
+    }
+    add(rule) {
+        if (!rule) {
+            throw new domain_exception_1.ArgumentNullException('rule');
+        }
+        if (!this.hasValidatorOfType(rule.constructor)) {
+            this._validators.push(rule);
+        }
+    }
+    addRange(rules) {
+        if (!rules) {
+            throw new domain_exception_1.ArgumentNullException('rules');
+        }
+        if (rules.length === 0) {
+            return;
+        }
+        rules.forEach((rule) => this.add(rule));
+    }
+    remove(rule) {
+        if (!rule) {
+            throw new domain_exception_1.ArgumentNullException('rule');
+        }
+        const index = this._validators.indexOf(rule);
+        if (index !== -1) {
+            this._validators.splice(index, 1);
+        }
+    }
+    clear() {
+        this._validators.length = 0;
+    }
+    getValidators() {
+        return Object.freeze([...this._validators]);
+    }
+    getBrokenRules() {
+        const result = [];
+        const seen = new Set();
+        for (const validator of this._validators) {
+            const brokenRules = validator.validate();
+            if (brokenRules && brokenRules.length > 0) {
+                for (const brokenRule of brokenRules) {
+                    const key = this.getBrokenRuleKey(brokenRule);
+                    if (!seen.has(key)) {
+                        seen.add(key);
+                        result.push(brokenRule);
+                    }
+                }
+            }
+        }
+        return Object.freeze(result);
+    }
+    isEmpty() {
+        return this._validators.length === 0;
+    }
+    count() {
+        return this._validators.length;
+    }
+    has(validatorType) {
+        return this.hasValidatorOfType(validatorType);
+    }
+    findByType(validatorType) {
+        return this._validators.find((v) => v.constructor === validatorType);
+    }
+    hasValidatorOfType(validatorType) {
+        return this._validators.some((v) => v.constructor === validatorType);
+    }
+    getBrokenRuleKey(brokenRule) {
+        const property = brokenRule.property.trim().toUpperCase();
+        const message = brokenRule.message.trim().toUpperCase();
+        return `${property}:${message}`;
+    }
+}
+exports.ValidatorRuleManager = ValidatorRuleManager;
+//# sourceMappingURL=validator-rule.manager.js.map

package/dist/valueobject.d.ts

@@ -0,0 +1,23 @@
+import { BrokenRulesManager } from './broken-rules.manager';
+import { AbstractNotifyPropertyChanged, AbstractRuleValidator } from './core';
+import { TrackingStateManager } from './tracking-state-manager';
+import { ValidatorRuleManager } from './validator-rule.manager';
+export declare abstract class DddValueObject<TValue> extends AbstractNotifyPropertyChanged {
+    readonly trackingState: TrackingStateManager;
+    readonly validatorRules: ValidatorRuleManager<AbstractRuleValidator<DddValueObject<TValue>>>;
+    readonly brokenRules: BrokenRulesManager;
+    get isValid(): boolean;
+    protected constructor(value: TValue);
+    private valuePropertyChanged;
+    setValue(value: TValue): void;
+    getValue(): TValue;
+    addValidators(): void;
+    private validate;
+    protected abstract getEqualityComponents(): Iterable<any>;
+    private getTypeConstructor;
+    equals(obj: unknown): boolean;
+    getHashCode(): number;
+    getCopy(): DddValueObject<TValue>;
+    clone(): object;
+}
+//# sourceMappingURL=valueobject.d.ts.map

package/dist/valueobject.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DddValueObject = void 0;
+const broken_rules_manager_1 = require("./broken-rules.manager");
+const core_1 = require("./core");
+const domain_exception_1 = require("./exceptions/domain.exception");
+const tracking_state_manager_1 = require("./tracking-state-manager");
+const validator_rule_manager_1 = require("./validator-rule.manager");
+class DddValueObject extends core_1.AbstractNotifyPropertyChanged {
+    get isValid() {
+        return this.brokenRules.getBrokenRules().length === 0;
+    }
+    constructor(value) {
+        super();
+        if (value === null || value === undefined) {
+            throw new domain_exception_1.ArgumentNullException('value');
+        }
+        this.brokenRules = new broken_rules_manager_1.BrokenRulesManager();
+        this.validatorRules = new validator_rule_manager_1.ValidatorRuleManager();
+        this.trackingState = new tracking_state_manager_1.TrackingStateManager();
+        const valueType = this.getTypeConstructor(typeof value, value);
+        this.registerProperty('internalValue', valueType, value, this.valuePropertyChanged.bind(this));
+        this.trackingState.markAsNew();
+        this.addValidators();
+        this.validate();
+    }
+    valuePropertyChanged() {
+        this.trackingState.markAsDirty();
+        this.validate();
+    }
+    setValue(value) {
+        if (value === null || value === undefined) {
+            throw new domain_exception_1.ArgumentNullException('value');
+        }
+        this.setValuePropertyChanged(value, 'internalValue');
+    }
+    getValue() {
+        return this.getValuePropertyChanged('internalValue');
+    }
+    addValidators() {
+    }
+    validate() {
+        this.brokenRules.clear();
+        const brokenRulesArray = this.validatorRules.getBrokenRules();
+        if (brokenRulesArray && brokenRulesArray.length > 0) {
+            this.brokenRules.addRange(brokenRulesArray);
+        }
+    }
+    getTypeConstructor(typeString, value) {
+        const typeMap = {
+            string: String,
+            number: Number,
+            boolean: Boolean,
+            symbol: Symbol,
+            bigint: BigInt,
+        };
+        if (typeString in typeMap) {
+            return typeMap[typeString];
+        }
+        if (value?.constructor) {
+            return value.constructor;
+        }
+        return typeString;
+    }
+    equals(obj) {
+        if (obj === null ||
+            obj === undefined ||
+            Object.getPrototypeOf(this) !== Object.getPrototypeOf(obj)) {
+            return false;
+        }
+        const other = obj;
+        const thisComponents = Array.from(this.getEqualityComponents());
+        const otherComponents = Array.from(other.getEqualityComponents());
+        if (thisComponents.length !== otherComponents.length)
+            return false;
+        return thisComponents.every((val, index) => val === otherComponents[index]);
+    }
+    getHashCode() {
+        const components = Array.from(this.getEqualityComponents());
+        return components.reduce((hash, item) => {
+            const itemHash = item ? JSON.stringify(item).length : 0;
+            return Math.trunc((hash << 5) - hash + itemHash);
+        }, 0);
+    }
+    getCopy() {
+        return Object.assign(Object.create(Object.getPrototypeOf(this)), this);
+    }
+    clone() {
+        return this.getCopy();
+    }
+}
+exports.DddValueObject = DddValueObject;
+//# sourceMappingURL=valueobject.js.map

package/dist/valueobjects/id.valueobject.d.ts

@@ -0,0 +1,16 @@
+import { DddValueObject } from '../valueobject';
+export declare class IdValueObject extends DddValueObject<string> {
+    protected constructor(value: string);
+    addValidators(): void;
+    static create(): IdValueObject;
+    static load(value: string): IdValueObject;
+    static loadFromString(value: string): IdValueObject;
+    protected getEqualityComponents(): Iterable<any>;
+    static empty(): IdValueObject;
+    static get defaultValue(): IdValueObject;
+    isEmpty(): boolean;
+    isDefault(): boolean;
+    toString(): string;
+    toJSON(): string;
+}
+//# sourceMappingURL=id.valueobject.d.ts.map

package/dist/valueobjects/id.valueobject.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IdValueObject = void 0;
+const uuid_1 = require("uuid");
+const valueobject_1 = require("../valueobject");
+const domain_exception_1 = require("../exceptions/domain.exception");
+class IdValueObject extends valueobject_1.DddValueObject {
+    constructor(value) {
+        super(value);
+    }
+    addValidators() {
+        super.addValidators();
+    }
+    static create() {
+        return new IdValueObject((0, uuid_1.v4)());
+    }
+    static load(value) {
+        if (value === null || value === undefined) {
+            throw new domain_exception_1.ArgumentNullException('value');
+        }
+        if (!(0, uuid_1.validate)(value)) {
+            throw new domain_exception_1.InvalidFormatException('value', 'valid UUID v4', value);
+        }
+        return new IdValueObject(value);
+    }
+    static loadFromString(value) {
+        return IdValueObject.load(value);
+    }
+    getEqualityComponents() {
+        return [this.getValue()];
+    }
+    static empty() {
+        return new IdValueObject('00000000-0000-0000-0000-000000000000');
+    }
+    static get defaultValue() {
+        return IdValueObject.empty();
+    }
+    isEmpty() {
+        return this.getValue() === '00000000-0000-0000-0000-000000000000';
+    }
+    isDefault() {
+        return this.isEmpty();
+    }
+    toString() {
+        return this.getValue();
+    }
+    toJSON() {
+        return this.getValue();
+    }
+}
+exports.IdValueObject = IdValueObject;
+//# sourceMappingURL=id.valueobject.js.map

package/dist/valueobjects/index.d.ts

@@ -0,0 +1,7 @@
+export * from './id.valueobject';
+export * from './string.valueobject';
+export * from './string-notnullorempty.validator';
+export * from './number.valueobject';
+export * from './number-notnull.validator';
+export * from './number-positive.validator';
+//# sourceMappingURL=index.d.ts.map

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

@@ -14,9 +14,10 @@ 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("./command.base"), exports);
-__exportStar(require("./domain-command-bus"), exports);
-__exportStar(require("./default-command-publisher"), exports);
-__exportStar(require("../../ddd-decorators/reflect-command.helper"), exports);
-__exportStar(require("./command-types"), exports);
+__exportStar(require("./id.valueobject"), exports);
+__exportStar(require("./string.valueobject"), exports);
+__exportStar(require("./string-notnullorempty.validator"), exports);
+__exportStar(require("./number.valueobject"), exports);
+__exportStar(require("./number-notnull.validator"), exports);
+__exportStar(require("./number-positive.validator"), exports);
 //# sourceMappingURL=index.js.map

package/dist/valueobjects/number-notnull.validator.d.ts

@@ -0,0 +1,13 @@
+import { AbstractRuleValidator } from '../core';
+import { DddValueObject } from '../valueobject';
+export declare class NumberNotNullValidator extends AbstractRuleValidator<DddValueObject<number>> {
+    private readonly options;
+    constructor(subject: DddValueObject<number>, options?: Partial<NumberValidationOptions>);
+    addRules(): void;
+}
+export interface NumberValidationOptions {
+    allowNaN: boolean;
+    allowInfinity: boolean;
+    propertyName: string;
+}
+//# sourceMappingURL=number-notnull.validator.d.ts.map

package/dist/valueobjects/number-notnull.validator.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NumberNotNullValidator = void 0;
+const core_1 = require("../core");
+class NumberNotNullValidator extends core_1.AbstractRuleValidator {
+    constructor(subject, options) {
+        super(subject);
+        this.options = {
+            allowNaN: false,
+            allowInfinity: false,
+            propertyName: 'value',
+            ...options,
+        };
+    }
+    addRules() {
+        const value = this.subject.getValue();
+        const propertyName = this.options.propertyName;
+        if (value === null || value === undefined) {
+            this.addBrokenRule(propertyName, `${propertyName} cannot be null or undefined`);
+            return;
+        }
+        if (!this.options.allowNaN && Number.isNaN(value)) {
+            this.addBrokenRule(propertyName, `${propertyName} cannot be NaN`);
+        }
+        if (!this.options.allowInfinity && !Number.isFinite(value)) {
+            this.addBrokenRule(propertyName, `${propertyName} must be a finite number`);
+        }
+    }
+}
+exports.NumberNotNullValidator = NumberNotNullValidator;
+//# sourceMappingURL=number-notnull.validator.js.map

package/dist/valueobjects/number-positive.validator.d.ts

@@ -0,0 +1,13 @@
+import { AbstractRuleValidator } from '../core';
+import { DddValueObject } from '../valueobject';
+export declare class NumberPositiveValidator extends AbstractRuleValidator<DddValueObject<number>> {
+    private readonly options;
+    constructor(subject: DddValueObject<number>, options?: Partial<NumberPositiveValidationOptions>);
+    addRules(): void;
+}
+export interface NumberPositiveValidationOptions {
+    allowZero: boolean;
+    propertyName: string;
+    epsilon: number;
+}
+//# sourceMappingURL=number-positive.validator.d.ts.map

package/dist/valueobjects/number-positive.validator.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NumberPositiveValidator = void 0;
+const core_1 = require("../core");
+class NumberPositiveValidator extends core_1.AbstractRuleValidator {
+    constructor(subject, options) {
+        super(subject);
+        this.options = {
+            allowZero: false,
+            propertyName: 'value',
+            epsilon: 0,
+            ...options,
+        };
+    }
+    addRules() {
+        const value = this.subject.getValue();
+        const propertyName = this.options.propertyName;
+        if (value === null || value === undefined) {
+            this.addBrokenRule(propertyName, `${propertyName} cannot be null or undefined`);
+            return;
+        }
+        if (Number.isNaN(value)) {
+            this.addBrokenRule(propertyName, `${propertyName} cannot be NaN`);
+            return;
+        }
+        if (!Number.isFinite(value)) {
+            this.addBrokenRule(propertyName, `${propertyName} must be a finite number`);
+            return;
+        }
+        if (this.options.allowZero) {
+            if (value < -this.options.epsilon) {
+                this.addBrokenRule(propertyName, `${propertyName} must be non-negative (greater than or equal to zero)`);
+            }
+        }
+        else {
+            if (value <= this.options.epsilon) {
+                this.addBrokenRule(propertyName, `${propertyName} must be a positive number (greater than zero)`);
+            }
+        }
+    }
+}
+exports.NumberPositiveValidator = NumberPositiveValidator;
+//# sourceMappingURL=number-positive.validator.js.map

package/dist/valueobjects/number.valueobject.d.ts

@@ -0,0 +1,25 @@
+import { DddValueObject } from '../valueobject';
+export declare class NumberValueObject extends DddValueObject<number> {
+    private readonly options;
+    protected constructor(value: number, options?: Partial<NumberValueObjectOptions>);
+    static create(value: number, options?: Partial<NumberValueObjectOptions>): NumberValueObject;
+    static load(value: number, options?: Partial<NumberValueObjectOptions>): NumberValueObject;
+    static zero(options?: Partial<NumberValueObjectOptions>): NumberValueObject;
+    static one(options?: Partial<NumberValueObjectOptions>): NumberValueObject;
+    isZero(): boolean;
+    isPositive(): boolean;
+    isNegative(): boolean;
+    toNumber(): number;
+    toString(): string;
+    toJSON(): number;
+    protected getEqualityComponents(): Iterable<any>;
+    addValidators(): void;
+}
+export interface NumberValueObjectOptions {
+    requirePositive: boolean;
+    allowZero: boolean;
+    allowNaN: boolean;
+    allowInfinity: boolean;
+    epsilon: number;
+}
+//# sourceMappingURL=number.valueobject.d.ts.map

package/dist/valueobjects/number.valueobject.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NumberValueObject = void 0;
+const valueobject_1 = require("../valueobject");
+const number_notnull_validator_1 = require("./number-notnull.validator");
+const number_positive_validator_1 = require("./number-positive.validator");
+class NumberValueObject extends valueobject_1.DddValueObject {
+    constructor(value, options) {
+        super(value);
+        this.options = {
+            requirePositive: true,
+            allowZero: false,
+            allowNaN: false,
+            allowInfinity: false,
+            epsilon: 0,
+            ...options,
+        };
+    }
+    static create(value, options) {
+        return new NumberValueObject(value, options);
+    }
+    static load(value, options) {
+        return new NumberValueObject(value, options);
+    }
+    static zero(options) {
+        return new NumberValueObject(0, { ...options, allowZero: true });
+    }
+    static one(options) {
+        return new NumberValueObject(1, options);
+    }
+    isZero() {
+        return this.getValue() === 0;
+    }
+    isPositive() {
+        return this.getValue() > 0;
+    }
+    isNegative() {
+        return this.getValue() < 0;
+    }
+    toNumber() {
+        return this.getValue();
+    }
+    toString() {
+        return this.getValue().toString();
+    }
+    toJSON() {
+        return this.getValue();
+    }
+    getEqualityComponents() {
+        return [this.getValue()];
+    }
+    addValidators() {
+        super.addValidators();
+        this.validatorRules.add(new number_notnull_validator_1.NumberNotNullValidator(this, {
+            allowNaN: this.options.allowNaN,
+            allowInfinity: this.options.allowInfinity,
+        }));
+        if (this.options.requirePositive) {
+            this.validatorRules.add(new number_positive_validator_1.NumberPositiveValidator(this, {
+                allowZero: this.options.allowZero,
+                epsilon: this.options.epsilon,
+            }));
+        }
+    }
+}
+exports.NumberValueObject = NumberValueObject;
+//# sourceMappingURL=number.valueobject.js.map

package/dist/valueobjects/string-notnullorempty.validator.d.ts

@@ -0,0 +1,14 @@
+import { AbstractRuleValidator } from '../core';
+import { DddValueObject } from '../valueobject';
+export declare class StringNotNullOrEmptyValidator extends AbstractRuleValidator<DddValueObject<string>> {
+    private readonly options;
+    constructor(subject: DddValueObject<string>, options?: Partial<StringValidationOptions>);
+    addRules(): void;
+}
+export interface StringValidationOptions {
+    allowEmpty: boolean;
+    trimWhitespace: boolean;
+    minLength: number;
+    propertyName: string;
+}
+//# sourceMappingURL=string-notnullorempty.validator.d.ts.map

package/dist/valueobjects/string-notnullorempty.validator.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StringNotNullOrEmptyValidator = void 0;
+const core_1 = require("../core");
+class StringNotNullOrEmptyValidator extends core_1.AbstractRuleValidator {
+    constructor(subject, options) {
+        super(subject);
+        this.options = {
+            allowEmpty: false,
+            trimWhitespace: false,
+            minLength: 0,
+            propertyName: 'value',
+            ...options,
+        };
+    }
+    addRules() {
+        let value = this.subject.getValue();
+        const propertyName = this.options.propertyName;
+        if (value === null || value === undefined) {
+            this.addBrokenRule(propertyName, `${propertyName} cannot be null or undefined`);
+            return;
+        }
+        if (this.options.trimWhitespace) {
+            value = value.trim();
+        }
+        if (!this.options.allowEmpty && value === '') {
+            this.addBrokenRule(propertyName, `${propertyName} cannot be empty${this.options.trimWhitespace ? ' or contain only whitespace' : ''}`);
+            return;
+        }
+        if (this.options.minLength > 0 && value.length < this.options.minLength) {
+            this.addBrokenRule(propertyName, `${propertyName} must be at least ${this.options.minLength} character${this.options.minLength === 1 ? '' : 's'} long (current length: ${value.length})`);
+        }
+    }
+}
+exports.StringNotNullOrEmptyValidator = StringNotNullOrEmptyValidator;
+//# sourceMappingURL=string-notnullorempty.validator.js.map

package/dist/valueobjects/string.valueobject.d.ts

@@ -0,0 +1,27 @@
+import { DddValueObject } from '../valueobject';
+export declare class StringValueObject extends DddValueObject<string> {
+    private readonly options;
+    protected constructor(value: string, options?: Partial<StringValueObjectOptions>);
+    static create(value: string, options?: Partial<StringValueObjectOptions>): StringValueObject;
+    static load(value: string, options?: Partial<StringValueObjectOptions>): StringValueObject;
+    static empty(options?: Partial<StringValueObjectOptions>): StringValueObject;
+    isEmpty(): boolean;
+    get length(): number;
+    toUpperCase(): string;
+    toLowerCase(): string;
+    trim(): string;
+    contains(substring: string): boolean;
+    startsWith(prefix: string): boolean;
+    endsWith(suffix: string): boolean;
+    toString(): string;
+    toJSON(): string;
+    protected getEqualityComponents(): Iterable<any>;
+    addValidators(): void;
+}
+export interface StringValueObjectOptions {
+    allowEmpty: boolean;
+    trimWhitespace: boolean;
+    minLength: number;
+    maxLength: number;
+}
+//# sourceMappingURL=string.valueobject.d.ts.map

package/dist/valueobjects/string.valueobject.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StringValueObject = void 0;
+const valueobject_1 = require("../valueobject");
+const string_notnullorempty_validator_1 = require("./string-notnullorempty.validator");
+class StringValueObject extends valueobject_1.DddValueObject {
+    constructor(value, options) {
+        super(value);
+        this.options = {
+            allowEmpty: false,
+            trimWhitespace: false,
+            minLength: 0,
+            maxLength: Number.MAX_SAFE_INTEGER,
+            ...options,
+        };
+    }
+    static create(value, options) {
+        return new StringValueObject(value, options);
+    }
+    static load(value, options) {
+        return new StringValueObject(value, options);
+    }
+    static empty(options) {
+        return new StringValueObject('', { ...options, allowEmpty: true });
+    }
+    isEmpty() {
+        return this.getValue() === '';
+    }
+    get length() {
+        return this.getValue().length;
+    }
+    toUpperCase() {
+        return this.getValue().toUpperCase();
+    }
+    toLowerCase() {
+        return this.getValue().toLowerCase();
+    }
+    trim() {
+        return this.getValue().trim();
+    }
+    contains(substring) {
+        return this.getValue().includes(substring);
+    }
+    startsWith(prefix) {
+        return this.getValue().startsWith(prefix);
+    }
+    endsWith(suffix) {
+        return this.getValue().endsWith(suffix);
+    }
+    toString() {
+        return this.getValue();
+    }
+    toJSON() {
+        return this.getValue();
+    }
+    getEqualityComponents() {
+        return [this.getValue()];
+    }
+    addValidators() {
+        super.addValidators();
+        const options = this.options || {
+            allowEmpty: false,
+            trimWhitespace: false,
+            minLength: 0,
+            maxLength: Number.MAX_SAFE_INTEGER,
+        };
+        this.validatorRules.add(new string_notnullorempty_validator_1.StringNotNullOrEmptyValidator(this, {
+            allowEmpty: options.allowEmpty,
+            trimWhitespace: options.trimWhitespace,
+            minLength: options.minLength,
+        }));
+        if (options.maxLength !== undefined &&
+            options.maxLength < Number.MAX_SAFE_INTEGER) {
+            const value = this.getValue();
+            if (value && value.length > options.maxLength) {
+                this.validatorRules.add({
+                    addRules: () => {
+                        this.validatorRules['addBrokenRule']('value', `value must not exceed ${options.maxLength} characters (current length: ${value.length})`);
+                    },
+                });
+            }
+        }
+    }
+}
+exports.StringValueObject = StringValueObject;
+//# sourceMappingURL=string.valueobject.js.map