@pocket-architect/core 0.1.18 → 0.1.20

package/src/eventBus/InMemoryEventBus.ts

@@ -3,18 +3,43 @@ import { AnyDomainEvent } from '../DomainEvent';
 import { EventBus } from '../EventBus';
 import {DomainEventSubscriber} from "../DomainEventSubscriber";
 
-export class InMemoryEventBus extends EventEmitter implements EventBus {
-  async publish(events: AnyDomainEvent[]): Promise<void> {
-    for (const event of events) {
-      this.emit(event.eventName, event);
+export class InMemoryEventBus implements EventBus {
+  protected _events: AnyDomainEvent[] = [];
+  protected _emitter: EventEmitter;
+
+  constructor() {
+    this._emitter = new EventEmitter();
+  }
+
+  async push(event: AnyDomainEvent): Promise<void> {
+    this._events.push(event);
+  }
+
+  async clear(): Promise<void> {
+    this._events = [];
+  }
+
+  async publish(events: AnyDomainEvent[] = []): Promise<void> {
+    const allEvents = (this._events || []).concat(events ?? []);
+    for (const event of allEvents) {
+      this._emitter.emit(event.eventName, event);
     }
+    await this.clear();
+  }
+
+  on(event: string, listener: (...args: never[]) => void): void {
+    this._emitter.on(event, listener);
+  }
+
+  listenerCount(event: string): number {
+    return this._emitter.listenerCount(event);
   }
 
   addSubscribers(subscribers: DomainEventSubscriber[]): void {
     for (const subscriber of subscribers) {
       const events = subscriber.subscribedTo();
       for (const event of events) {
-        this.on(event.EVENT_NAME, subscriber.on.bind(subscriber));
+        this._emitter.on(event.EVENT_NAME ?? event.name, subscriber.on.bind(subscriber));
       }
     }
   }

package/src/helpers.spec.ts

@@ -0,0 +1,62 @@
+import {createSnapshot} from "./helpers";
+import {EntityId} from "./EntityId";
+import {Entity} from "./Entity";
+
+interface TestProps {
+  name: string;
+  testId?: EntityId<string>;
+}
+class TestEntity extends Entity<TestProps, string, EntityId<string>> {
+  static create(props: TestProps, id?:EntityId<string>|string): TestEntity {
+    return new TestEntity(props, id);
+  }
+
+  set name(name: string) {
+    this.props.name = name;
+  }
+
+  set testId(val: EntityId<string>) {
+    this.props.testId = val;
+  }
+
+  toSnapshot():never {
+    return {
+      ...this.props,
+      testId: undefined
+    } as never;
+  }
+}
+
+describe('helpers', () => {
+  test('createSnapshot', async () => {
+    const original = {
+      a: 1,
+      b: 'test',
+      c: {
+        d: 2,
+        e: 'nested',
+        f: {
+          g: 3
+        }
+      },
+      id: new EntityId<string>('1'),
+    };
+    const snapshot = createSnapshot(original);
+    expect(snapshot).toEqual(original);
+    expect(snapshot).not.toBe(original);
+    expect(snapshot.c).not.toBe(original.c);
+    expect(snapshot.c.f).not.toBe(original.c.f);
+    expect(snapshot.id).not.toBe(original.id);
+    expect(snapshot.id).toEqual(new EntityId<string>('1'));
+
+    const item = TestEntity.create({
+      name: 'test',
+      testId: new EntityId('2')
+    }, '2');
+    const itemSnapshot = createSnapshot(item);
+    expect(itemSnapshot).toEqual({
+      name: 'test',
+      testId: undefined
+    });
+  });
+});

package/src/helpers.ts

@@ -0,0 +1,25 @@
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function createSnapshot<T>(obj: T): T {
+  if (!obj) {
+    return obj;
+  }
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore
+  if (typeof obj.toSnapshot === 'function') {
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    return obj.toSnapshot() as T;
+  }
+  const copy:T = {} as T;
+  for (const key in obj) {
+    if (!Object.prototype.hasOwnProperty.call(obj, key)) {
+      continue;
+    }
+    if (typeof obj[key] !== 'object') {
+      copy[key] = obj[key];
+      continue;
+    }
+    copy[key] = createSnapshot(obj[key]);
+  }
+  return copy;
+}

package/src/index.ts

@@ -3,11 +3,17 @@ import { EntityId } from './EntityId';
 import { ValueObject } from './ValueObject';
 import { AggregateRoot } from './AggregateRoot';
 import { HashError } from './error/HashError';
+import { DomainEvent } from './DomainEvent';
+import { DomainEventSubscriber } from './DomainEventSubscriber';
+import { EventBus } from './EventBus';
 
 export {
   Entity,
   EntityId,
   ValueObject,
   AggregateRoot,
-  HashError
+  HashError,
+  DomainEvent,
+  DomainEventSubscriber,
+  EventBus
 }

package/src/AggregateRoot.spec.ts

@@ -1,35 +0,0 @@
-import {AggregateRoot} from "./AggregateRoot";
-import {EntityId} from "./EntityId";
-import {DomainEvent} from "./DomainEvent";
-
-interface TestProps {
-  name: string;
-}
-class TestEntity extends AggregateRoot<TestProps, number, EntityId<number>> {
-  static create(props: TestProps, id?:EntityId<number>|number): TestEntity {
-    return new TestEntity(props, id);
-  }
-}
-class TestEvent extends DomainEvent<number> {
-  readonly eventName = 'TestEvent';
-
-  toPrimitives() {
-    return {};
-  }
-}
-
-describe('AggregateRoot', () => {
-  let root: TestEntity;
-
-  beforeAll(() => {
-    root = TestEntity.create({ name: 'test' }, 1);
-  });
-
-  test('events', async () => {
-    const event = new TestEvent(root);
-    root.pushDomainEvent(event);
-
-    expect(root.pullDomainEvents()).toEqual([event]);
-    expect(root.pullDomainEvents()).toEqual([]);
-  });
-});