ddd-node 3.0.0 → 4.0.1

package/dist/base/aggregate.d.ts

@@ -2,39 +2,42 @@ import { Class } from "../types/class";
 import { ClassStatic } from "../types/class-static";
 import { AnyCommand } from "./command";
 import { Entity, IEntityMetadata } from "./entity";
-import { AnyEvent, EventClass, IEventAggregate, NewEventMetadataOptions } from "./event";
+import { AnyEvent, EventClass, 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 {
     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: Id, version: number, props: PropsOf<T>): T;
+    static aggregateType(): string;
+    static newAggregate<T extends AnyAggregate>(this: AggregateClass<T>, props?: PropsOf<T>): T;
     get version(): number;
     aggregateType(): string;
     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 interface SnapshotWithProps<P extends object> {
+    metadata: IAggregateMetadata;
+    props: P;
+}
+export interface Snapshot<T extends AnyAggregateES> extends SnapshotWithProps<PropsOf<T>> {
+}
 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;
+    static stream<T extends AnyAggregateES>(this: AggregateESClass<T>, id: Id, events: AnyEvent[]): T;
+    static snapshot<T extends AnyAggregateES>(this: AggregateESClass<T>, snapshot: Snapshot<T>, eventsAfterSnapshot: AnyEvent[]): T;
     getHandledCommands(): AnyCommand[];
     getPastEvents(): AnyEvent[];
     lastEvent(): AnyEvent | undefined;
-    lastEventVersion(): number;
-    nextEventVersion(): number;
-    nextEventAggregate(): IEventAggregate;
+    currentVersion(): number;
+    nextVersion(): number;
     private addPastEvent;
     private validateEventBeforeApply;
     getEventApplier(eventType: string): AggregateEventApplier<AnyEvent> | null;
@@ -42,6 +45,7 @@ export declare class AggregateES<P extends object> extends Aggregate<P> {
     applyEvents(events: AnyEvent[], fromHistory?: boolean): void;
     getCommandHandler(commandType: string): AggregateCommandHandler<AnyCommand> | null;
     processCommand<C extends AnyCommand>(command: C): AnyEvent[];
+    snap(): SnapshotWithProps<P>;
 }
 export type AnyAggregate = Aggregate<any>;
 export type AnyAggregateES = AggregateES<any>;
@@ -53,4 +57,5 @@ export type AggregateESClassWithProps<P extends object> = Class<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 InferAggregateClass<T extends AnyAggregate> = T extends AnyAggregateES ? AggregateESClass<T> : AggregateClass<T>;
 export type AnyAggregateClass = AggregateClass<AnyAggregate>;

package/dist/base/aggregate.js

@@ -12,15 +12,14 @@ class Aggregate extends entity_1.Entity {
         this.events = [];
         this._version = metadata.version;
     }
-    static agggregateType() {
+    static aggregateType() {
         return (0, aggregate_1.getAggregateType)(this.prototype);
     }
-    static newAggregate(props, metadata) {
-        return new this(Object.assign({ id: id_1.Id.unique(), version: 0 }, metadata), props);
-    }
-    static loadAggregate(id, version, props) {
-        const aggregate = new this({ id, version }, props);
-        return aggregate;
+    static newAggregate(props) {
+        return new this({
+            id: id_1.Id.unique(),
+            version: 0,
+        }, props);
     }
     get version() {
         return this._version;
@@ -38,15 +37,12 @@ class Aggregate extends entity_1.Entity {
     nextVersion() {
         return this.version + 1;
     }
-    nextEventAggregate() {
-        return {
-            type: this.aggregateType(),
+    newEvent(eventClass, props, metadata) {
+        return eventClass.newEvent({
             id: this.id,
+            type: this.aggregateType(),
             version: this.nextVersion(),
-        };
-    }
-    newEvent(eventClass, props, metadata) {
-        return eventClass.newEvent(this.nextEventAggregate(), props, metadata);
+        }, props, metadata);
     }
     addEvent(event) {
         this.events.push(event);
@@ -59,10 +55,15 @@ class AggregateES extends Aggregate {
         this.handledCommands = [];
         this.pastEvents = [];
     }
-    static loadAggregate(id, version, props, pastEvents) {
-        const aggregate = new this({ id, version }, props);
-        if (pastEvents)
-            aggregate.applyEvents(pastEvents, true);
+    static stream(id, events) {
+        const aggregate = new this({ id, version: 0 });
+        aggregate.applyEvents(events, true);
+        return aggregate;
+    }
+    static snapshot(snapshot, eventsAfterSnapshot) {
+        const { metadata, props } = snapshot;
+        const aggregate = new this(metadata, props);
+        aggregate.applyEvents(eventsAfterSnapshot, true);
         return aggregate;
     }
     getHandledCommands() {
@@ -74,21 +75,14 @@ class AggregateES extends Aggregate {
     lastEvent() {
         return this.hasEvents() ? this.events.at(-1) : this.pastEvents.at(-1);
     }
-    lastEventVersion() {
+    currentVersion() {
         const lastEvent = this.lastEvent();
         if (lastEvent)
             return lastEvent.aggregate.version;
         return this.version;
     }
-    nextEventVersion() {
-        return this.lastEventVersion() + 1;
-    }
-    nextEventAggregate() {
-        return {
-            type: this.aggregateType(),
-            id: this.id,
-            version: this.nextEventVersion(),
-        };
+    nextVersion() {
+        return this.currentVersion() + 1;
     }
     addPastEvent(event) {
         if (this.hasEvents())
@@ -101,7 +95,7 @@ class AggregateES extends Aggregate {
             throw new aggregate_error_1.InvalidEventAggregateTypeError();
         if (id !== this.id)
             throw new aggregate_error_1.InvalidEventAggregateIdError();
-        if (version !== this.nextEventVersion())
+        if (version !== this.nextVersion())
             throw new aggregate_error_1.InvalidEventAggregateVersionError();
     }
     getEventApplier(eventType) {
@@ -152,5 +146,14 @@ class AggregateES extends Aggregate {
         this.handledCommands.push(command);
         return events;
     }
+    snap() {
+        return {
+            metadata: {
+                id: this.id,
+                version: this.version,
+            },
+            props: this.getProps(),
+        };
+    }
 }
 exports.AggregateES = AggregateES;

package/package.json

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