ddd-node 2.0.3 → 3.0.0

package/dist/base/aggregate.d.ts

@@ -3,46 +3,54 @@ import { ClassStatic } from "../types/class-static";
 import { AnyCommand } from "./command";
 import { Entity, IEntityMetadata } from "./entity";
 import { AnyEvent, EventClass, IEventAggregate, NewEventMetadataOptions } from "./event";
+import { Id } from "./id";
 import { PropsOf } from "./props-envelope";
 export interface IAggregateMetadata extends IEntityMetadata {
     readonly version: number;
 }
 export type NewAggregateMetadataOptions = Partial<Omit<IAggregateMetadata, "version">>;
 export declare class Aggregate<P extends object> extends Entity<P> implements IAggregateMetadata {
-    private readonly _version;
-    private handledCommands;
-    private pastEvents;
-    private events;
+    protected readonly _version: number;
+    protected events: AnyEvent[];
     constructor(metadata: IAggregateMetadata, props?: P);
     static agggregateType(): string;
     static newAggregate<T extends AnyAggregate>(this: AggregateClass<T>, props?: PropsOf<T>, metadata?: NewAggregateMetadataOptions): T;
-    static loadAggregate<T extends AnyAggregate>(this: AggregateClass<T>, id: string, version: number, props: PropsOf<T>, pastEvents?: AnyEvent[]): T;
+    static loadAggregate<T extends AnyAggregate>(this: AggregateClass<T>, id: Id, version: number, props: PropsOf<T>): T;
     get version(): number;
     aggregateType(): string;
-    getHandledCommands(): AnyCommand[];
-    getPastEvents(): AnyEvent[];
     getEvents(): AnyEvent[];
     hasEvents(): boolean;
+    nextVersion(): number;
+    nextEventAggregate(): IEventAggregate;
+    protected newEvent<E extends AnyEvent>(eventClass: EventClass<E>, props: PropsOf<E>, metadata?: NewEventMetadataOptions): E;
+    protected addEvent<E extends AnyEvent>(event: E): void;
+}
+export declare class AggregateES<P extends object> extends Aggregate<P> {
+    protected handledCommands: AnyCommand[];
+    protected pastEvents: AnyEvent[];
+    static loadAggregate<T extends AnyAggregateES>(this: AggregateESClass<T>, id: Id, version: number, props: PropsOf<T>, pastEvents?: AnyEvent[]): T;
+    getHandledCommands(): AnyCommand[];
+    getPastEvents(): AnyEvent[];
     lastEvent(): AnyEvent | undefined;
     lastEventVersion(): number;
     nextEventVersion(): number;
     nextEventAggregate(): IEventAggregate;
-    protected newEvent<E extends AnyEvent>(eventClass: EventClass<E>, props: PropsOf<E>, metadata?: NewEventMetadataOptions): E;
-    protected addEvent<E extends AnyEvent>(event: E): void;
-    protected addPastEvent<E extends AnyEvent>(event: E): void;
-    getEventApplier(eventType: string): AggregateEventApplier<AnyEvent> | null;
+    private addPastEvent;
     private validateEventBeforeApply;
+    getEventApplier(eventType: string): AggregateEventApplier<AnyEvent> | null;
     applyEvent<E extends AnyEvent>(event: E, fromHistory?: boolean): void;
     applyEvents(events: AnyEvent[], fromHistory?: boolean): void;
     getCommandHandler(commandType: string): AggregateCommandHandler<AnyCommand> | null;
     processCommand<C extends AnyCommand>(command: C): AnyEvent[];
-    processCommands(commands: AnyCommand[]): Record<string, AnyEvent[]>;
 }
 export type AnyAggregate = Aggregate<any>;
+export type AnyAggregateES = AggregateES<any>;
 export type AggregateEventApplier<E extends AnyEvent> = (event: E) => void;
 export type AggregateCommandHandler<C extends AnyCommand, E extends AnyEvent = AnyEvent> = (command: C) => E | E[];
 export type AggregateConstructorParamsWithProps<P extends object> = ConstructorParameters<typeof Aggregate<P>>;
 export type AggregateClassWithProps<P extends object> = Class<Aggregate<P>, AggregateConstructorParamsWithProps<P>> & ClassStatic<typeof Aggregate<P>>;
+export type AggregateESClassWithProps<P extends object> = Class<AggregateES<P>, AggregateConstructorParamsWithProps<P>> & ClassStatic<typeof AggregateES<P>>;
 export type AggregateConstructorParams<T extends AnyAggregate> = AggregateConstructorParamsWithProps<PropsOf<T>>;
 export type AggregateClass<T extends AnyAggregate> = Class<T, AggregateConstructorParams<T>> & ClassStatic<typeof Aggregate<PropsOf<T>>>;
+export type AggregateESClass<T extends AnyAggregateES> = Class<T, AggregateConstructorParams<T>> & ClassStatic<typeof AggregateES<PropsOf<T>>>;
 export type AnyAggregateClass = AggregateClass<AnyAggregate>;

package/dist/base/aggregate.js

@@ -1,16 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Aggregate = void 0;
+exports.AggregateES = exports.Aggregate = void 0;
 const aggregate_1 = require("../metadata/aggregate");
-const uuid_1 = require("uuid");
 const to_array_1 = require("../utils/to-array");
 const entity_1 = require("./entity");
 const aggregate_error_1 = require("./errors/aggregate.error");
+const id_1 = require("./id");
 class Aggregate extends entity_1.Entity {
     constructor(metadata, props) {
         super({ id: metadata.id }, props);
-        this.handledCommands = [];
-        this.pastEvents = [];
         this.events = [];
         this._version = metadata.version;
     }
@@ -18,12 +16,10 @@ class Aggregate extends entity_1.Entity {
         return (0, aggregate_1.getAggregateType)(this.prototype);
     }
     static newAggregate(props, metadata) {
-        return new this(Object.assign({ id: (0, uuid_1.v4)(), version: 0 }, metadata), props);
+        return new this(Object.assign({ id: id_1.Id.unique(), version: 0 }, metadata), props);
     }
-    static loadAggregate(id, version, props, pastEvents) {
+    static loadAggregate(id, version, props) {
         const aggregate = new this({ id, version }, props);
-        if (pastEvents)
-            aggregate.applyEvents(pastEvents, true);
         return aggregate;
     }
     get version() {
@@ -33,18 +29,48 @@ class Aggregate extends entity_1.Entity {
         const prototype = Object.getPrototypeOf(this);
         return (0, aggregate_1.getAggregateType)(prototype);
     }
-    getHandledCommands() {
-        return this.handledCommands;
-    }
-    getPastEvents() {
-        return this.pastEvents;
-    }
     getEvents() {
         return this.events;
     }
     hasEvents() {
         return Boolean(this.events.length);
     }
+    nextVersion() {
+        return this.version + 1;
+    }
+    nextEventAggregate() {
+        return {
+            type: this.aggregateType(),
+            id: this.id,
+            version: this.nextVersion(),
+        };
+    }
+    newEvent(eventClass, props, metadata) {
+        return eventClass.newEvent(this.nextEventAggregate(), props, metadata);
+    }
+    addEvent(event) {
+        this.events.push(event);
+    }
+}
+exports.Aggregate = Aggregate;
+class AggregateES extends Aggregate {
+    constructor() {
+        super(...arguments);
+        this.handledCommands = [];
+        this.pastEvents = [];
+    }
+    static loadAggregate(id, version, props, pastEvents) {
+        const aggregate = new this({ id, version }, props);
+        if (pastEvents)
+            aggregate.applyEvents(pastEvents, true);
+        return aggregate;
+    }
+    getHandledCommands() {
+        return this.handledCommands;
+    }
+    getPastEvents() {
+        return this.pastEvents;
+    }
     lastEvent() {
         return this.hasEvents() ? this.events.at(-1) : this.pastEvents.at(-1);
     }
@@ -64,24 +90,11 @@ class Aggregate extends entity_1.Entity {
             version: this.nextEventVersion(),
         };
     }
-    newEvent(eventClass, props, metadata) {
-        return eventClass.newEvent(this.nextEventAggregate(), props, metadata);
-    }
-    addEvent(event) {
-        this.events.push(event);
-    }
     addPastEvent(event) {
         if (this.hasEvents())
             throw new aggregate_error_1.PastEventCannotBeAddedError();
         this.pastEvents.push(event);
     }
-    getEventApplier(eventType) {
-        const prototype = Object.getPrototypeOf(this);
-        const eventApplier = (0, aggregate_1.getAggregateEventApplier)(prototype, eventType);
-        if (eventApplier)
-            return eventApplier.bind(this);
-        return null;
-    }
     validateEventBeforeApply(event) {
         const { type, id, version } = event.aggregate;
         if (type !== this.aggregateType())
@@ -91,6 +104,13 @@ class Aggregate extends entity_1.Entity {
         if (version !== this.nextEventVersion())
             throw new aggregate_error_1.InvalidEventAggregateVersionError();
     }
+    getEventApplier(eventType) {
+        const prototype = Object.getPrototypeOf(this);
+        const eventApplier = (0, aggregate_1.getAggregateEventApplier)(prototype, eventType);
+        if (eventApplier)
+            return eventApplier.bind(this);
+        return null;
+    }
     applyEvent(event, fromHistory = false) {
         const eventType = event.eventType();
         const applier = this.getEventApplier(eventType);
@@ -132,13 +152,5 @@ class Aggregate extends entity_1.Entity {
         this.handledCommands.push(command);
         return events;
     }
-    processCommands(commands) {
-        const result = {};
-        commands.forEach((command) => {
-            const events = this.processCommand(command);
-            result[command.id] = events;
-        });
-        return result;
-    }
 }
-exports.Aggregate = Aggregate;
+exports.AggregateES = AggregateES;

package/dist/base/command.d.ts

@@ -1,8 +1,9 @@
 import { Class } from "../types/class";
 import { ClassStatic } from "../types/class-static";
+import { Id } from "./id";
 import { PropsEnvelope, PropsOf } from "./props-envelope";
 export interface ICommandMetadata {
-    readonly id: string;
+    readonly id: Id;
     readonly timestamp: number;
     correlationId?: string;
     causationId?: string;
@@ -16,7 +17,7 @@ export declare class Command<P extends object> extends PropsEnvelope<P> implemen
     constructor(metadata: ICommandMetadata, props: P);
     static commandType(): string;
     static newCommand<T extends AnyCommand>(this: CommandClass<T>, props: PropsOf<T>, metadata?: NewCommandMetadataOptions): T;
-    get id(): string;
+    get id(): Id;
     get timestamp(): number;
     get correlationId(): string | undefined;
     get causationId(): string | undefined;

package/dist/base/command.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Command = void 0;
 const command_1 = require("../metadata/command");
-const uuid_1 = require("uuid");
+const id_1 = require("./id");
 const props_envelope_1 = require("./props-envelope");
 class Command extends props_envelope_1.PropsEnvelope {
     constructor(metadata, props) {
@@ -16,7 +16,7 @@ class Command extends props_envelope_1.PropsEnvelope {
         return (0, command_1.getCommandType)(this.prototype);
     }
     static newCommand(props, metadata) {
-        return new this(Object.assign({ id: (0, uuid_1.v4)(), timestamp: Date.now() }, metadata), props);
+        return new this(Object.assign({ id: id_1.Id.unique(), timestamp: Date.now() }, metadata), props);
     }
     get id() {
         return this._id;

package/dist/base/entity.d.ts

@@ -1,8 +1,9 @@
 import { Class } from "../types/class";
 import { ClassStatic } from "../types/class-static";
+import { Id } from "./id";
 import { PropsEnvelope, PropsOf } from "./props-envelope";
 export interface IEntityMetadata {
-    readonly id: string;
+    readonly id: Id;
 }
 export type NewEntityMetadataOptions = Partial<IEntityMetadata>;
 export declare class Entity<P extends object> extends PropsEnvelope<P> implements IEntityMetadata {
@@ -10,7 +11,7 @@ export declare class Entity<P extends object> extends PropsEnvelope<P> implement
     constructor(metadata: IEntityMetadata, props?: P);
     static entityType(): string;
     static newEntity<T extends AnyEntity>(this: EntityClass<T>, props?: PropsOf<T>, metadata?: NewEntityMetadataOptions): T;
-    get id(): string;
+    get id(): Id;
     entityType(): string;
     equals<E extends AnyEntity>(entity: E): boolean;
 }

package/dist/base/entity.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Entity = void 0;
 const entity_1 = require("../metadata/entity");
-const uuid_1 = require("uuid");
+const id_1 = require("./id");
 const props_envelope_1 = require("./props-envelope");
 class Entity extends props_envelope_1.PropsEnvelope {
     constructor(metadata, props) {
@@ -13,7 +13,7 @@ class Entity extends props_envelope_1.PropsEnvelope {
         return (0, entity_1.getEntityType)(this.prototype);
     }
     static newEntity(props, metadata) {
-        return new this(Object.assign({ id: (0, uuid_1.v4)() }, metadata), props);
+        return new this(Object.assign({ id: id_1.Id.unique() }, metadata), props);
     }
     get id() {
         return this._id;
@@ -24,7 +24,7 @@ class Entity extends props_envelope_1.PropsEnvelope {
     }
     equals(entity) {
         const equalsType = entity instanceof this.constructor;
-        const equalsId = entity.id === this.id;
+        const equalsId = entity.id.equals(entity.id);
         return equalsType && equalsId;
     }
 }

package/dist/base/event.d.ts

@@ -1,13 +1,14 @@
 import { Class } from "../types/class";
 import { ClassStatic } from "../types/class-static";
+import { Id } from "./id";
 import { PropsEnvelope, PropsOf } from "./props-envelope";
 export interface IEventAggregate {
+    readonly id: Id;
     readonly type: string;
-    readonly id: string;
     readonly version: number;
 }
 export interface IEventMetadata {
-    readonly id: string;
+    readonly id: Id;
     readonly timestamp: number;
     readonly aggregate: IEventAggregate;
     correlationId?: string;
@@ -23,7 +24,7 @@ export declare class Event<P extends object> extends PropsEnvelope<P> implements
     constructor(metadata: IEventMetadata, props: P);
     static eventType(): string;
     static newEvent<T extends AnyEvent>(this: EventClass<T>, aggregate: IEventAggregate, props: PropsOf<T>, metadata?: NewEventMetadataOptions): T;
-    get id(): string;
+    get id(): Id;
     get timestamp(): number;
     get aggregate(): IEventAggregate;
     get correlationId(): string | undefined;

package/dist/base/event.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Event = void 0;
 const event_1 = require("../metadata/event");
-const uuid_1 = require("uuid");
+const id_1 = require("./id");
 const props_envelope_1 = require("./props-envelope");
 class Event extends props_envelope_1.PropsEnvelope {
     constructor(metadata, props) {
@@ -17,7 +17,7 @@ class Event extends props_envelope_1.PropsEnvelope {
         return (0, event_1.getEventType)(this.prototype);
     }
     static newEvent(aggregate, props, metadata) {
-        return new this(Object.assign({ id: (0, uuid_1.v4)(), timestamp: Date.now(), aggregate }, metadata), props);
+        return new this(Object.assign({ id: id_1.Id.unique(), timestamp: Date.now(), aggregate }, metadata), props);
     }
     get id() {
         return this._id;

package/dist/base/id.d.ts

@@ -0,0 +1,7 @@
+export declare class Id {
+    private _value;
+    constructor(value: string);
+    static unique(): Id;
+    get value(): string;
+    equals(id: Id): boolean;
+}

package/dist/base/id.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Id = void 0;
+const uuid_1 = require("uuid");
+class Id {
+    constructor(value) {
+        this._value = value;
+    }
+    static unique() {
+        const value = (0, uuid_1.v4)();
+        return new Id(value);
+    }
+    get value() {
+        return this._value;
+    }
+    equals(id) {
+        return this._value === id._value;
+    }
+}
+exports.Id = Id;

package/dist/base/index.d.ts

@@ -1,7 +1,8 @@
 export * from "./aggregate";
-export * from "./entity";
 export * from "./command";
+export * from "./entity";
 export * from "./event";
+export * from "./id";
 export * from "./props-envelope";
-export * from "./value-object";
 export * from "./repository";
+export * from "./value-object";

package/dist/base/index.js

@@ -15,9 +15,10 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./aggregate"), exports);
-__exportStar(require("./entity"), exports);
 __exportStar(require("./command"), exports);
+__exportStar(require("./entity"), exports);
 __exportStar(require("./event"), exports);
+__exportStar(require("./id"), exports);
 __exportStar(require("./props-envelope"), exports);
-__exportStar(require("./value-object"), exports);
 __exportStar(require("./repository"), exports);
+__exportStar(require("./value-object"), exports);

package/dist/base/repository.d.ts

@@ -1,4 +1,6 @@
 import { AnyAggregate } from "./aggregate";
+import { Id } from "./id";
 export interface Repository<T extends AnyAggregate> {
+    findById(id: Id): Promise<T | undefined>;
     save(aggregate: T): Promise<void>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ddd-node",
-  "version": "2.0.3",
+  "version": "3.0.0",
   "description": "Domain Driven Design base for NodeJs",
   "main": "dist/index.js",
   "scripts": {