ddd-node 4.0.0 → 4.0.1

package/dist/base/aggregate.d.ts

@@ -8,14 +8,12 @@ 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[];
@@ -24,10 +22,17 @@ export declare class Aggregate<P extends object> extends Entity<P> implements IA
     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;
@@ -40,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>;

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;
@@ -56,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() {
@@ -142,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": "4.0.0",
+  "version": "4.0.1",
   "description": "Domain Driven Design base for NodeJs",
   "main": "dist/index.js",
   "scripts": {