@nestjslatam/ddd-lib 1.0.51 → 1.0.53

package/dist/core/tracking-state/interfaces/itracking-state-manager.d.ts

@@ -0,0 +1,12 @@
+export interface ITrackingStateManager {
+    readonly isNew: boolean;
+    readonly isDirty: boolean;
+    readonly isSelfDeleted: boolean;
+    readonly isDeleted: boolean;
+    markAsDirty(): void;
+    markAsNew(): void;
+    markAsSelfDeleted(): void;
+    markAsDeleted(): void;
+    markAsClean(): void;
+}
+//# sourceMappingURL=itracking-state-manager.d.ts.map

package/{ddd-commands/interfaces/command-bus.interface.js → dist/core/tracking-state/interfaces/itracking-state-manager.js}

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=command-bus.interface.js.map
+//# sourceMappingURL=itracking-state-manager.js.map

package/dist/core/tracking-state/interfaces/itracking-state-transitions.d.ts

@@ -0,0 +1,7 @@
+export interface ITrackingStateTransitions {
+    setDirty(value: boolean): void;
+    setNew(value: boolean): void;
+    setSelfDeleted(value: boolean): void;
+    setDeleted(value: boolean): void;
+}
+//# sourceMappingURL=itracking-state-transitions.d.ts.map

package/dist/core/tracking-state/interfaces/itracking-state-transitions.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=itracking-state-transitions.js.map

package/dist/core/validator-rules/impl/abstract-rule-validator.d.ts

@@ -0,0 +1,13 @@
+import { BrokenRule } from '../../business-rules';
+import { ClassType, IRuleValidator } from '../interfaces';
+export declare abstract class AbstractRuleValidator<TSubject> implements IRuleValidator {
+    readonly subject: TSubject;
+    private brokenRules;
+    constructor(subject: TSubject);
+    abstract addRules(): void;
+    validate(): ReadonlyArray<BrokenRule>;
+    addBrokenRule(propertyName: string, message: string): void;
+    getValidatorDescriptor(): ClassType;
+    getSubjectDescriptor(): ClassType;
+}
+//# sourceMappingURL=abstract-rule-validator.d.ts.map

package/dist/core/validator-rules/impl/abstract-rule-validator.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractRuleValidator = void 0;
+class AbstractRuleValidator {
+    constructor(subject) {
+        this.subject = subject;
+        this.brokenRules = [];
+    }
+    validate() {
+        this.brokenRules = [];
+        if (this.subject !== null && this.subject !== undefined) {
+            this.addRules();
+        }
+        return this.brokenRules;
+    }
+    addBrokenRule(propertyName, message) {
+        this.brokenRules.push({
+            property: propertyName,
+            message: message,
+            severity: 'Error',
+        });
+    }
+    getValidatorDescriptor() {
+        return this.constructor;
+    }
+    getSubjectDescriptor() {
+        if (!this.subject) {
+            throw new Error('Subject is null or undefined.');
+        }
+        return this.subject.constructor;
+    }
+}
+exports.AbstractRuleValidator = AbstractRuleValidator;
+//# sourceMappingURL=abstract-rule-validator.js.map

package/dist/core/validator-rules/impl/abstract-validator.d.ts

@@ -0,0 +1,4 @@
+export declare abstract class AbstractValidator {
+    abstract validate(obj: unknown): boolean;
+}
+//# sourceMappingURL=abstract-validator.d.ts.map

package/dist/core/validator-rules/impl/abstract-validator.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractValidator = void 0;
+class AbstractValidator {
+}
+exports.AbstractValidator = AbstractValidator;
+//# sourceMappingURL=abstract-validator.js.map

package/dist/core/validator-rules/impl/entity-validator.d.ts

@@ -0,0 +1,5 @@
+import { AbstractValidator } from './abstract-validator';
+export declare class EntityValidator extends AbstractValidator {
+    validate(obj: unknown): boolean;
+}
+//# sourceMappingURL=entity-validator.d.ts.map

package/dist/core/validator-rules/impl/entity-validator.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityValidator = void 0;
+const aggregate_root_1 = require("../../../aggregate-root");
+const abstract_validator_1 = require("./abstract-validator");
+class EntityValidator extends abstract_validator_1.AbstractValidator {
+    validate(obj) {
+        return obj instanceof aggregate_root_1.DddAggregateRoot;
+    }
+}
+exports.EntityValidator = EntityValidator;
+//# sourceMappingURL=entity-validator.js.map

package/dist/core/validator-rules/impl/index.d.ts

@@ -0,0 +1,5 @@
+export * from './abstract-validator';
+export * from './entity-validator';
+export * from './value-object-validator';
+export * from './abstract-rule-validator';
+//# sourceMappingURL=index.d.ts.map

package/{ddd-core/interfaces → dist/core/validator-rules/impl}/index.js

@@ -14,8 +14,8 @@ 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("./tracking.interface"), exports);
-__exportStar(require("./message-source.interface"), exports);
-__exportStar(require("./saga.interface"), exports);
-__exportStar(require("./ddd.options"), exports);
+__exportStar(require("./abstract-validator"), exports);
+__exportStar(require("./entity-validator"), exports);
+__exportStar(require("./value-object-validator"), exports);
+__exportStar(require("./abstract-rule-validator"), exports);
 //# sourceMappingURL=index.js.map

package/dist/core/validator-rules/impl/value-object-validator.d.ts

@@ -0,0 +1,7 @@
+import { DddValueObject } from '../../../valueobject';
+import { AbstractValidator } from './abstract-validator';
+export declare class ValueObjectValidator extends AbstractValidator {
+    validate(obj: unknown): boolean;
+    static isValueObject(obj: unknown): obj is DddValueObject<any>;
+}
+//# sourceMappingURL=value-object-validator.d.ts.map

package/dist/core/validator-rules/impl/value-object-validator.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValueObjectValidator = void 0;
+const valueobject_1 = require("../../../valueobject");
+const abstract_validator_1 = require("./abstract-validator");
+class ValueObjectValidator extends abstract_validator_1.AbstractValidator {
+    validate(obj) {
+        return obj instanceof valueobject_1.DddValueObject;
+    }
+    static isValueObject(obj) {
+        return obj instanceof valueobject_1.DddValueObject;
+    }
+}
+exports.ValueObjectValidator = ValueObjectValidator;
+//# sourceMappingURL=value-object-validator.js.map

package/{ddd-events → dist/core/validator-rules}/index.d.ts

@@ -1,2 +1,3 @@
-export * from './interfaces';
 export * from './impl';
+export * from './interfaces';
+//# sourceMappingURL=index.d.ts.map

package/{ddd-events → dist/core/validator-rules}/index.js

@@ -14,6 +14,6 @@ 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("./interfaces"), exports);
 __exportStar(require("./impl"), exports);
+__exportStar(require("./interfaces"), exports);
 //# sourceMappingURL=index.js.map

package/dist/core/validator-rules/interfaces/index.d.ts

@@ -0,0 +1,3 @@
+export * from './irule-validator';
+export * from './irule-context';
+//# sourceMappingURL=index.d.ts.map

package/{ddd-ports → dist/core/validator-rules/interfaces}/index.js

@@ -14,5 +14,6 @@ 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("./interfaces"), exports);
+__exportStar(require("./irule-validator"), exports);
+__exportStar(require("./irule-context"), exports);
 //# sourceMappingURL=index.js.map

package/dist/core/validator-rules/interfaces/irule-context.d.ts

@@ -0,0 +1,5 @@
+export interface IRuleContext {
+    target: any;
+    metadata?: Record<string, any>;
+}
+//# sourceMappingURL=irule-context.d.ts.map

package/{ddd-commands/impl/command-types.js → dist/core/validator-rules/interfaces/irule-context.js}

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=command-types.js.map
+//# sourceMappingURL=irule-context.js.map

package/dist/core/validator-rules/interfaces/irule-validator.d.ts

@@ -0,0 +1,8 @@
+import { BrokenRule } from '../../business-rules';
+export type ClassType<T = any> = new (...args: any[]) => T;
+export interface IRuleValidator {
+    getValidatorDescriptor(): ClassType;
+    getSubjectDescriptor(): ClassType;
+    validate(): ReadonlyArray<BrokenRule>;
+}
+//# sourceMappingURL=irule-validator.d.ts.map

package/{ddd-core/interfaces/ddd.options.js → dist/core/validator-rules/interfaces/irule-validator.js}

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=ddd.options.js.map
+//# sourceMappingURL=irule-validator.js.map

package/dist/ddd.module.d.ts

@@ -0,0 +1,6 @@
+import { OnApplicationBootstrap } from '@nestjs/common';
+export declare class DddModule implements OnApplicationBootstrap {
+    constructor();
+    onApplicationBootstrap(): void;
+}
+//# sourceMappingURL=ddd.module.d.ts.map

package/{ddd.module.js → dist/ddd.module.js}

@@ -13,21 +13,9 @@ exports.DddModule = void 0;
 const common_1 = require("@nestjs/common");
 const core_1 = require("@nestjs/core");
 const ddd_service_1 = require("./ddd.service");
-const ddd_commands_1 = require("./ddd-commands");
-const ddd_events_1 = require("./ddd-events");
-const ddd_exceptions_1 = require("./ddd-exceptions");
 let DddModule = class DddModule {
-    constructor(explorerService, eventBus, domainCommandBus) {
-        this.explorerService = explorerService;
-        this.eventBus = eventBus;
-        this.domainCommandBus = domainCommandBus;
-    }
-    onApplicationBootstrap() {
-        const { domainEvents, sagas, domainCommands } = this.explorerService.explore();
-        this.eventBus.register(domainEvents);
-        this.domainCommandBus.register(domainCommands);
-        this.eventBus.registerSagas(sagas);
-    }
+    constructor() { }
+    onApplicationBootstrap() { }
 };
 exports.DddModule = DddModule;
 exports.DddModule = DddModule = __decorate([
@@ -41,25 +29,9 @@ exports.DddModule = DddModule = __decorate([
                 },
                 inject: [core_1.ModulesContainer],
             },
-            ddd_commands_1.DomainCommandBus,
-            ddd_events_1.DomainEventBus,
-            ddd_events_1.DomainEventPublisher,
-            ddd_exceptions_1.UnhandledExceptionDomainBus,
-            ddd_events_1.DomainEventSerializer,
-            ddd_events_1.DomainEventDeserializer,
-        ],
-        exports: [
-            ddd_service_1.DddService,
-            ddd_commands_1.DomainCommandBus,
-            ddd_events_1.DomainEventBus,
-            ddd_events_1.DomainEventPublisher,
-            ddd_exceptions_1.UnhandledExceptionDomainBus,
-            ddd_events_1.DomainEventSerializer,
-            ddd_events_1.DomainEventDeserializer,
         ],
+        exports: [ddd_service_1.DddService],
     }),
-    __metadata("design:paramtypes", [ddd_service_1.DddService,
-        ddd_events_1.DomainEventBus,
-        ddd_commands_1.DomainCommandBus])
+    __metadata("design:paramtypes", [])
 ], DddModule);
 //# sourceMappingURL=ddd.module.js.map

package/dist/ddd.service.d.ts

@@ -0,0 +1,7 @@
+import { ModulesContainer } from "@nestjs/core";
+export declare class DddService {
+    private readonly modulesContainer;
+    constructor(modulesContainer: ModulesContainer);
+    explore(): void;
+}
+//# sourceMappingURL=ddd.service.d.ts.map

package/{ddd.service.js → dist/ddd.service.js}

@@ -12,27 +12,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DddService = void 0;
 const common_1 = require("@nestjs/common");
 const core_1 = require("@nestjs/core");
-const ddd_helpers_1 = require("./ddd-helpers");
-const ddd_decorators_1 = require("./ddd-decorators");
 let DddService = class DddService {
     constructor(modulesContainer) {
         this.modulesContainer = modulesContainer;
     }
     explore() {
-        const modules = [...this.modulesContainer.values()];
-        const domainCommands = this.flatMap(modules, (instance) => this.filterProvider(instance, ddd_decorators_1.DOMAIN_COMMAND_HANDLER_METADATA));
-        const domainEvents = this.flatMap(modules, (instance) => this.filterProvider(instance, ddd_decorators_1.DOMAIN_EVENTS_HANDLER_METADATA));
-        const sagas = this.flatMap(modules, (instance) => this.filterProvider(instance, ddd_decorators_1.DOMAIN_SAGA_METADATA));
-        return { domainCommands, domainEvents, sagas };
-    }
-    flatMap(modules, callback) {
-        return ddd_helpers_1.DomainObjectHelper.flatMap(modules, callback);
-    }
-    filterProvider(wrapper, metadataKey) {
-        return ddd_helpers_1.DomainObjectHelper.filterProvider(wrapper, metadataKey);
-    }
-    extractMetadata(instance, metadataKey) {
-        return ddd_helpers_1.DomainObjectHelper.extractMetadata(instance, metadataKey);
+        return;
     }
 };
 exports.DddService = DddService;

package/dist/domain-event.d.ts

@@ -0,0 +1,56 @@
+export type EventMetadata = {
+    readonly aggregateId: string;
+    readonly aggregateType: string;
+    readonly aggregateVersion: number;
+    readonly eventVersion: number;
+    readonly correlationId?: string;
+    readonly causationId?: string;
+    readonly userId?: string;
+    readonly timestamp: string;
+};
+export declare class EventMetadataBuilder {
+    private aggregateId;
+    private aggregateType;
+    private aggregateVersion;
+    private eventVersion;
+    private correlationId?;
+    private causationId?;
+    private userId?;
+    private timestamp;
+    private constructor();
+    static create(aggregateId: string, aggregateType: string, aggregateVersion: number): EventMetadataBuilder;
+    withEventVersion(version: number): this;
+    withCorrelationId(correlationId: string): this;
+    withCausationId(causationId: string): this;
+    withUserId(userId: string): this;
+    withTimestamp(timestamp: Date | string): this;
+    build(): EventMetadata;
+}
+export interface ISerializable {
+    toJSON(): Record<string, unknown>;
+}
+export declare abstract class DomainEvent implements ISerializable {
+    readonly eventId: string;
+    readonly occurredOn: Date;
+    readonly eventType: string;
+    readonly eventVersion: number;
+    readonly metadata: EventMetadata;
+    constructor(metadata: EventMetadata, occurredOn?: Date);
+    private validateMetadata;
+    toJSON(): Record<string, unknown>;
+    protected getEventData(): Record<string, unknown>;
+    protected static extractMetadata(json: Record<string, unknown>): EventMetadata;
+    protected static extractEventData(json: Record<string, unknown>): Record<string, unknown>;
+    protected static extractOccurredOn(json: Record<string, unknown>): Date;
+    get aggregateId(): string;
+    get aggregateType(): string;
+    get aggregateVersion(): number;
+    get hasCorrelationId(): boolean;
+    get hasCausationId(): boolean;
+    get hasUserId(): boolean;
+    equals(other: DomainEvent): boolean;
+    belongsToAggregate(aggregateId: string): boolean;
+    isAggregateType(aggregateType: string): boolean;
+}
+export declare const AbstractDomainEvent: typeof DomainEvent;
+//# sourceMappingURL=domain-event.d.ts.map

package/dist/domain-event.js

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractDomainEvent = exports.DomainEvent = exports.EventMetadataBuilder = void 0;
+const uuid_1 = require("uuid");
+const domain_exception_1 = require("./exceptions/domain.exception");
+class EventMetadataBuilder {
+    constructor(aggregateId, aggregateType, aggregateVersion) {
+        this.eventVersion = 1;
+        this.aggregateId = aggregateId;
+        this.aggregateType = aggregateType;
+        this.aggregateVersion = aggregateVersion;
+        this.timestamp = new Date().toISOString();
+    }
+    static create(aggregateId, aggregateType, aggregateVersion) {
+        if (!aggregateId || !aggregateType) {
+            throw new domain_exception_1.ArgumentNullException('aggregateId and aggregateType are required');
+        }
+        if (aggregateVersion < 0) {
+            throw new Error('aggregateVersion must be non-negative');
+        }
+        return new EventMetadataBuilder(aggregateId, aggregateType, aggregateVersion);
+    }
+    withEventVersion(version) {
+        if (version < 1) {
+            throw new Error('eventVersion must be at least 1');
+        }
+        this.eventVersion = version;
+        return this;
+    }
+    withCorrelationId(correlationId) {
+        this.correlationId = correlationId;
+        return this;
+    }
+    withCausationId(causationId) {
+        this.causationId = causationId;
+        return this;
+    }
+    withUserId(userId) {
+        this.userId = userId;
+        return this;
+    }
+    withTimestamp(timestamp) {
+        this.timestamp =
+            timestamp instanceof Date ? timestamp.toISOString() : timestamp;
+        return this;
+    }
+    build() {
+        return {
+            aggregateId: this.aggregateId,
+            aggregateType: this.aggregateType,
+            aggregateVersion: this.aggregateVersion,
+            eventVersion: this.eventVersion,
+            correlationId: this.correlationId,
+            causationId: this.causationId,
+            userId: this.userId,
+            timestamp: this.timestamp,
+        };
+    }
+}
+exports.EventMetadataBuilder = EventMetadataBuilder;
+class DomainEvent {
+    constructor(metadata, occurredOn) {
+        if (!metadata) {
+            throw new domain_exception_1.ArgumentNullException('metadata');
+        }
+        this.validateMetadata(metadata);
+        this.eventId = (0, uuid_1.v4)();
+        this.occurredOn = occurredOn || new Date();
+        this.eventType = this.constructor.name;
+        this.eventVersion = metadata.eventVersion;
+        this.metadata = {
+            ...metadata,
+            timestamp: metadata.timestamp || this.occurredOn.toISOString(),
+        };
+    }
+    validateMetadata(metadata) {
+        if (!metadata.aggregateId) {
+            throw new Error('EventMetadata.aggregateId is required');
+        }
+        if (!metadata.aggregateType) {
+            throw new Error('EventMetadata.aggregateType is required');
+        }
+        if (metadata.aggregateVersion < 0) {
+            throw new Error('EventMetadata.aggregateVersion must be non-negative');
+        }
+        if (metadata.eventVersion < 1) {
+            throw new Error('EventMetadata.eventVersion must be at least 1');
+        }
+    }
+    toJSON() {
+        return {
+            eventId: this.eventId,
+            eventType: this.eventType,
+            eventVersion: this.eventVersion,
+            occurredOn: this.occurredOn.toISOString(),
+            metadata: this.metadata,
+            data: this.getEventData(),
+        };
+    }
+    getEventData() {
+        const data = {};
+        const excludeKeys = new Set([
+            'eventId',
+            'occurredOn',
+            'eventType',
+            'eventVersion',
+            'metadata',
+            'toJSON',
+            'fromJSON',
+            'getEventData',
+        ]);
+        Object.keys(this).forEach((key) => {
+            if (!excludeKeys.has(key)) {
+                const value = this[key];
+                if (value instanceof Date) {
+                    data[key] = value.toISOString();
+                }
+                else {
+                    data[key] = value;
+                }
+            }
+        });
+        return data;
+    }
+    static extractMetadata(json) {
+        const metadata = json.metadata;
+        if (!metadata) {
+            throw new Error('Event JSON missing metadata field');
+        }
+        return metadata;
+    }
+    static extractEventData(json) {
+        return json.data || {};
+    }
+    static extractOccurredOn(json) {
+        const occurredOn = json.occurredOn;
+        if (!occurredOn) {
+            throw new Error('Event JSON missing occurredOn field');
+        }
+        return new Date(occurredOn);
+    }
+    get aggregateId() {
+        return this.metadata.aggregateId;
+    }
+    get aggregateType() {
+        return this.metadata.aggregateType;
+    }
+    get aggregateVersion() {
+        return this.metadata.aggregateVersion;
+    }
+    get hasCorrelationId() {
+        return !!this.metadata.correlationId;
+    }
+    get hasCausationId() {
+        return !!this.metadata.causationId;
+    }
+    get hasUserId() {
+        return !!this.metadata.userId;
+    }
+    equals(other) {
+        if (!other) {
+            return false;
+        }
+        return this.eventId === other.eventId;
+    }
+    belongsToAggregate(aggregateId) {
+        return this.metadata.aggregateId === aggregateId;
+    }
+    isAggregateType(aggregateType) {
+        return this.metadata.aggregateType === aggregateType;
+    }
+}
+exports.DomainEvent = DomainEvent;
+exports.AbstractDomainEvent = DomainEvent;
+//# sourceMappingURL=domain-event.js.map

package/dist/enum.d.ts

@@ -0,0 +1,28 @@
+export declare abstract class DddEnum {
+    readonly id: number;
+    readonly name: string;
+    private static readonly _cache;
+    protected constructor(id: number, name: string);
+    private validateId;
+    private validateName;
+    toString(): string;
+    static getAll<T extends DddEnum>(): T[];
+    equals(other: unknown): boolean;
+    static absoluteDifference(firstValue: DddEnum, secondValue: DddEnum): number;
+    static fromValue<T extends DddEnum>(value: number): T | undefined;
+    static fromName<T extends DddEnum>(name: string): T | undefined;
+    static fromNameIgnoreCase<T extends DddEnum>(name: string): T | undefined;
+    static fromDisplayName<T extends DddEnum>(displayName: string): T | undefined;
+    compareTo(other: DddEnum): number;
+    isLessThan(other: DddEnum): boolean;
+    isLessThanOrEqual(other: DddEnum): boolean;
+    isGreaterThan(other: DddEnum): boolean;
+    isGreaterThanOrEqual(other: DddEnum): boolean;
+    static isDefined(value: number): boolean;
+    static getMinValue<T extends DddEnum>(): T | undefined;
+    static getMaxValue<T extends DddEnum>(): T | undefined;
+    isBetween(min: DddEnum, max: DddEnum): boolean;
+    static areEqual(left: DddEnum | null | undefined, right: DddEnum | null | undefined): boolean;
+    static areNotEqual(left: DddEnum | null | undefined, right: DddEnum | null | undefined): boolean;
+}
+//# sourceMappingURL=enum.d.ts.map