Initial commit

Author: Roliver-Javier

README.md

@@ -0,0 +1,3 @@
+# angular-domain-driven-design
+
+[Edit on StackBlitz ⚡️](https://stackblitz.com/edit/angular-domain-driven-design)

angular.json

@@ -0,0 +1,100 @@
+{
+  "$schema": "./node_modules/@angular/cli/lib/config/schema.json",
+  "version": 1,
+  "newProjectRoot": "projects",
+  "projects": {
+    "demo": {
+      "root": "",
+      "sourceRoot": "src",
+      "projectType": "application",
+      "prefix": "app",
+      "schematics": {},
+      "architect": {
+        "build": {
+          "builder": "@angular-devkit/build-angular:browser",
+          "options": {
+            "outputPath": "dist/demo",
+            "index": "src/index.html",
+            "main": "src/main.ts",
+            "polyfills": "src/polyfills.ts",
+            "tsConfig": "src/tsconfig.app.json",
+            "assets": [
+              "src/favicon.ico",
+              "src/assets"
+            ],
+            "styles": [
+              "src/styles.css"
+            ],
+            "scripts": []
+          },
+          "configurations": {
+            "production": {
+              "fileReplacements": [
+                {
+                  "replace": "src/environments/environment.ts",
+                  "with": "src/environments/environment.prod.ts"
+                }
+              ],
+              "optimization": true,
+              "outputHashing": "all",
+              "sourceMap": false,
+              "extractCss": true,
+              "namedChunks": false,
+              "aot": true,
+              "extractLicenses": true,
+              "vendorChunk": false,
+              "buildOptimizer": true
+            }
+          }
+        },
+        "serve": {
+          "builder": "@angular-devkit/build-angular:dev-server",
+          "options": {
+            "browserTarget": "demo:build"
+          },
+          "configurations": {
+            "production": {
+              "browserTarget": "demo:build:production"
+            }
+          }
+        },
+        "extract-i18n": {
+          "builder": "@angular-devkit/build-angular:extract-i18n",
+          "options": {
+            "browserTarget": "demo:build"
+          }
+        },
+        "test": {
+          "builder": "@angular-devkit/build-angular:karma",
+          "options": {
+            "main": "src/test.ts",
+            "polyfills": "src/polyfills.ts",
+            "tsConfig": "src/tsconfig.spec.json",
+            "karmaConfig": "src/karma.conf.js",
+            "styles": [
+              "styles.css"
+            ],
+            "scripts": [],
+            "assets": [
+              "src/favicon.ico",
+              "src/assets"
+            ]
+          }
+        },
+        "lint": {
+          "builder": "@angular-devkit/build-angular:tslint",
+          "options": {
+            "tsConfig": [
+              "src/tsconfig.app.json",
+              "src/tsconfig.spec.json"
+            ],
+            "exclude": [
+              "**/node_modules/**"
+            ]
+          }
+        }
+      }
+    }
+  },
+  "defaultProject": "demo"
+}

package.json

@@ -0,0 +1,48 @@
+{
+  "name": "angular",
+  "version": "0.0.0",
+  "private": true,
+  "dependencies": {
+    "@angular/common": "^8.0.0",
+    "@angular/compiler": "^8.0.0",
+    "@angular/core": "^8.0.0",
+    "@angular/forms": "^8.0.0",
+    "@angular/platform-browser": "^8.0.0",
+    "@angular/platform-browser-dynamic": "^8.0.0",
+    "@angular/router": "^8.0.0",
+    "core-js": "2",
+    "rxjs": "^6.5.2",
+    "uuid": "^7.0.2",
+    "uuidv4": "^6.0.6",
+    "zone.js": "^0.9.1"
+  },
+  "scripts": {
+    "ng": "ng",
+    "start": "ng serve",
+    "build": "ng build",
+    "test": "ng test",
+    "lint": "ng lint",
+    "e2e": "ng e2e"
+  },
+  "devDependencies": {
+    "@angular-devkit/build-angular": "~0.10.0",
+    "@angular/cli": "~7.0.2",
+    "@angular/compiler-cli": "~7.0.0",
+    "@angular/language-service": "~7.0.0",
+    "@types/node": "~8.9.4",
+    "@types/jasmine": "~2.8.8",
+    "@types/jasminewd2": "~2.0.3",
+    "codelyzer": "~4.5.0",
+    "jasmine-core": "~2.99.1",
+    "jasmine-spec-reporter": "~4.2.1",
+    "karma": "~3.0.0",
+    "karma-chrome-launcher": "~2.2.0",
+    "karma-coverage-istanbul-reporter": "~2.0.1",
+    "karma-jasmine": "~1.1.2",
+    "karma-jasmine-html-reporter": "^0.2.2",
+    "protractor": "~5.4.0",
+    "ts-node": "~7.0.0",
+    "tslint": "~5.11.0",
+    "typescript": "~3.1.1"
+  }
+}

src/app/app.component.css

@@ -0,0 +1,3 @@
+p {
+  font-family: Lato;
+}

src/app/app.component.html

@@ -0,0 +1,7 @@
+<hello name="{{ name }}"></hello>
+<p>
+  Start editing to see some magic happen :)
+</p>
+
+<app-user></app-user>
+<app-travel></app-travel>

src/app/app.component.ts

@@ -0,0 +1,10 @@
+import { Component } from '@angular/core';
+
+@Component({
+  selector: 'my-app',
+  templateUrl: './app.component.html',
+  styleUrls: [ './app.component.css' ]
+})
+export class AppComponent  {
+  name = 'Angular';
+}

src/app/app.module.ts

@@ -0,0 +1,15 @@
+import { NgModule } from '@angular/core';
+import { BrowserModule } from '@angular/platform-browser';
+import { FormsModule } from '@angular/forms';
+
+import { AppComponent } from './app.component';
+import { HelloComponent } from './hello.component';
+import { UserComponent } from './user/feature/user.component';
+import { TravelComponent } from './travel/feature/travel.component';
+
+@NgModule({
+  imports:      [ BrowserModule, FormsModule ],
+  declarations: [ AppComponent, HelloComponent, UserComponent, TravelComponent ],
+  bootstrap:    [ AppComponent ]
+})
+export class AppModule { }

src/app/core/domain/AggregateRoot.ts

@@ -0,0 +1,57 @@
+import { Entity } from './Entity';
+import { DomainEvents } from './events/DomainEvents';
+import { Observable, BehaviorSubject } from 'rxjs';
+import { ActionEvents } from './events/ActionEvents.enum';
+import { pipe, UnaryFunction } from 'rxjs';
+import { tap, map } from 'rxjs/operators';
+
+export abstract class AggregateRoot<T> extends Entity<T> {
+  private _domainEvents: any[] = [];
+  private _domainObserver: Observable<AggregateRoot<T>>;
+  private _domainBS: BehaviorSubject<AggregateRoot<T>>;
+
+  get id() {
+    return this._id;
+  }
+
+  get domainEvents(): any[] {
+    return this._domainEvents;
+  }
+
+  get domainObserver(): Observable<AggregateRoot<T>>{
+    return this._domainObserver;
+  }
+
+  set domainObserver(domainEvent: Observable<AggregateRoot<T>>){
+    this._domainObserver = domainEvent;
+  }
+
+  get domainBS(): BehaviorSubject<AggregateRoot<T>>{
+    return this._domainBS;
+  }
+
+  set domainBS(domainEvent: BehaviorSubject<AggregateRoot<T>>){
+    this._domainBS = domainEvent;
+  }
+
+  protected addDomainEvent (domainEvent: any){
+    this._domainEvents.push(domainEvent);
+    DomainEvents.markAggregateForBS(this);
+    this.logDomainEventAdded(domainEvent);
+  } 
+
+  private logDomainEventAdded (domainEvent: any){
+    const thisClass = Reflect.getPrototypeOf(this);
+    const domainEventClass = Reflect.getPrototypeOf(domainEvent);
+    console.log('[Domain Event Created]: ', thisClass.constructor.name);
+    
+  }
+
+  protected dispatchObserver(domainPipe: UnaryFunction<any, any>){
+    DomainEvents.dispatch(this, ActionEvents.Observable,domainPipe);
+  }
+
+  protected dispatchBS(){
+    DomainEvents.dispatch(this, ActionEvents.BehaviorSubject);
+  }
+}

src/app/core/domain/Entity.ts

@@ -0,0 +1,28 @@
+import { v4 as uuid } from 'uuid';
+
+const isEntity = (v: any): v is Entity<any> => {
+  return v instanceof Entity;
+};
+
+export abstract class Entity<T>{ 
+  protected readonly _id:string;
+  public readonly props: T;
+
+  constructor (props: T, id?: string){
+    this._id = id ? id : uuid();
+    this.props = props;
+  }
+
+  public equals (object?: Entity<T>) : boolean {
+    if(object == null || object == undefined) {
+      return false;
+    }
+    if (this === object) {
+      return true;
+    }
+    if(!isEntity(object)){
+      return false;
+    }
+    return ;
+  }
+}

src/app/core/domain/UseCase.ts

@@ -0,0 +1,5 @@
+import { Observable } from 'rxjs';
+
+export interface UseCase <EntryObject, ExitObject>{
+  execute (entry?: EntryObject) : Observable<ExitObject> | Promise<ExitObject> | ExitObject;
+}

src/app/core/domain/UseCaseError.ts

@@ -0,0 +1,11 @@
+interface IUseCaseErrorError {
+  message: string;
+}
+
+export abstract class UseCaseError implements IUseCaseErrorError{
+  public readonly message: string;
+
+  constructor (message: string){
+    this.message = message;
+  }
+}

src/app/core/domain/ValueObject.ts

@@ -0,0 +1,4 @@
+export enum ActionEvents {
+  Observable = 'observable',
+  BehaviorSubject = 'behaviorSubject'
+}

src/app/core/domain/events/ActionEvents.enum.ts

@@ -0,0 +1,82 @@
+import { AggregateRoot } from '../AggregateRoot';
+import { BehaviorSubject, Observable, pipe, UnaryFunction } from 'rxjs';
+import { tap, map } from 'rxjs/operators';
+import { ActionEvents } from './ActionEvents.enum';
+
+interface GlobalBS {
+  [n: string]: {
+    behaviourSubject: BehaviorSubject<any>,
+    observable: Observable<any>,
+    className: string
+  }
+}
+
+type OptionType = ActionEvents.Observable | ActionEvents.BehaviorSubject;
+
+
+export class DomainEvents<T> {
+  private static handlersMap = {};
+  private static markedAggregates: AggregateRoot<any>[] = [];
+  private static globalBS: GlobalBS = {};
+
+  public static markAggregateForBS<T>
+    (aggregate: AggregateRoot<T>): void {
+    if (aggregate instanceof AggregateRoot) {
+      const aggregateFound = !!this.findAggregateByID(aggregate.id);
+      if (!aggregateFound) {
+        aggregate.domainBS = 
+        new BehaviorSubject<AggregateRoot<T>>(aggregate);
+
+        aggregate.domainObserver = aggregate.domainBS.asObservable();
+
+        this.markedAggregates.push(aggregate);
+
+        this.globalBS = {
+          ...this.globalBS,
+          [aggregate.id]: {
+            behaviorSubject: aggregate.domainBS,
+            observable: aggregate.domainObserver,
+            className: aggregate.constructor.name 
+          }
+        } as GlobalBS;
+      }
+    }
+  }
+
+  public static dispatch<T>
+    (aggregate: AggregateRoot<T>, 
+    option: OptionType, 
+    pipeCallback?: UnaryFunction<any, any>) {
+    switch (option) {
+      case ActionEvents.BehaviorSubject: {
+        aggregate.domainBS = this.globalBS[aggregate.id][ActionEvents.BehaviorSubject];
+        aggregate.domainBS.next(aggregate);
+        return aggregate.domainBS;
+      }
+      case ActionEvents.Observable: {
+        if (pipeCallback) {
+          aggregate.domainObserver =
+            this.globalBS[aggregate.id][ActionEvents.Observable].pipe(
+              pipeCallback
+            );
+          return aggregate.domainObserver;
+        }
+      }
+    }
+  }
+
+  private static findAggregateByClassName(className: string){
+    return Object.values(this.globalBS).filter(aggeg => aggeg.className === className)[0]
+  }
+
+  private static findAggregateByID(id: string): AggregateRoot<any> {
+    let found: AggregateRoot<any> = null;
+    for (let aggregate of this.markedAggregates) {
+      if (aggregate.id === id) {
+        found = aggregate;
+      }
+    }
+    return found;
+  }
+
+};