Update with wiring, bundling, unittests, code coverage

src/adapters/PortResolver.ts

@@ -0,0 +1,31 @@
+
+import { IPortResolver } from '../domain/ports/IPortResolver';
+
+
+export class PortResolver implements IPortResolver {
+    private _container : any = {};
+    constructor() {
+
+    }
+    register<T>(name : string, fn : () => T) {
+        this._container[name] = fn;
+    }
+    registerInstance<T>(name  : string, fn : () => T) {
+        let _instance : any = null;
+        let getInstance = (fn : Function) => {
+            return () => {
+                if (!_instance) {
+                    _instance = fn();
+                }
+                return _instance;
+            };
+        };
+        this._container[name] = getInstance(fn);
+    }
+    resolve<T>(name : string) : T {
+        if (name in this._container && typeof this._container[name] == 'function') {
+            return this._container[name]();
+        }
+        throw new Error('PortResolver can not resolve '+ name);
+    }
+}

src/adapters/music/VinylCatalog.ts

@@ -1,7 +1,7 @@
 import { Track } from "../../domain/models/Track";
-import { MusicRepository } from "../../domain/ports/MusicRepository";
+import { IMusicRepository } from "../../domain/ports/IMusicRepository";
 
-export class VinylCatalog implements MusicRepository {
+export class VinylCatalog implements IMusicRepository {
 
     private vinylList: Track[] = new Array(
         new Track(1, "DNA.", "Kendrick Lamar", 340),
@@ -14,8 +14,8 @@ export class VinylCatalog implements MusicRepository {
     get(): Track[] {
         return this.vinylList;
     }
-    getById(id: number): Track | null {
-        return this.vinylList.filter(track => track.id == id).pop() as Track;
+    getById(id: number): Track {
+        return this.vinylList.filter(track => track.id == id).pop();
     }
     add(track: Track): number {
         return this.vinylList.push(track);
@@ -30,7 +30,7 @@ export class VinylCatalog implements MusicRepository {
         }
         throw new Error("Track not found");
     }
-    delete(id: number): Track | null {
+    delete(id: number): Track {
         var track = this.getById(id);
         if (track) {
             var targetIndex = this.vinylList.indexOf(track);

src/domain/ports/IMusicRepository.ts

@@ -0,0 +1,10 @@
+import { Track } from "../models/Track";
+
+
+export interface IMusicRepository {
+     get() : Track[];
+     getById(id: number) : Track;
+     add(track: Track) : number;
+     edit(id: number, track: Track) : Track;
+     delete(id: number) : Track;
+}

src/domain/ports/IPortResolver.ts

@@ -0,0 +1,8 @@
+
+
+export interface IPortResolver {
+    resolve<T>(name : string) : T;
+}
+
+export let currentPortResolver : IPortResolver;
+export let setCurrentPortResolver = (resolver : IPortResolver) => currentPortResolver = resolver;

src/domain/ports/Injector.ts

@@ -1,3 +0,0 @@
-export abstract class Injector {
-    abstract inject<T>(constructorFn: Function) : T;
- }

src/domain/ports/MusicRepository.ts

@@ -1,10 +0,0 @@
-import { Track } from "../models/Track";
-
-
-export abstract class MusicRepository {
-     abstract get() : Track[];
-     abstract getById(id: number) : Track | null;
-     abstract add(track: Track) : number;
-     abstract edit(id: number, track: Track) : Track;
-     abstract delete(id: number) : Track | null;
-}

src/domain/services/BaseService.ts

@@ -0,0 +1,9 @@
+
+import { IPortResolver, currentPortResolver } from '../ports/IPortResolver';
+
+export class BaseService {
+    protected PortResolver: IPortResolver;
+    constructor() {
+        this.PortResolver = currentPortResolver;
+    }
+}

src/domain/services/MusicCatalogService.spec.ts

@@ -0,0 +1,26 @@
+
+import {PortResolver} from '../../adapters/PortResolver';
+import { currentPortResolver } from '../ports/IPortResolver';
+const portResolver = currentPortResolver as PortResolver;
+
+import { MusicCatalogService } from './MusicCatalogService';
+import { IMusicRepository } from '../ports/IMusicRepository';
+import { Track } from '../models/Track';
+
+let fakeMusicRepository = { get: () =>{ console.log('fakeMusicRepository'); } } as IMusicRepository;
+
+describe("MusicCatalogService", () => {
+
+    it('should create a new MusicCatalogService', (done) => {
+
+        let spiedGet = spyOn(fakeMusicRepository, 'get').and.returnValue([]);
+        portResolver.registerInstance<IMusicRepository>('IMusicRepository', () => fakeMusicRepository);
+        let musicCatalogService = new MusicCatalogService();
+        musicCatalogService.get();
+
+        expect(spiedGet.calls.count()).toBe(1);
+
+        done();
+    });
+
+});

src/domain/services/MusicCatalogService.ts

@@ -1,20 +1,15 @@
-import { MusicRepository } from "../../domain/ports/MusicRepository";
+import { BaseService } from './BaseService';
+
+import { IMusicRepository } from "../../domain/ports/IMusicRepository";
 import { Track } from "../../domain/models/Track";
-import { Injector } from "../../domain/ports/Injector";
 
+export class MusicCatalogService extends BaseService {
+    private repository : IMusicRepository;
 
-
-export class MusicCatalogService {
-    private repository: MusicRepository;
-
-    constructor(repository:MusicRepository){
-        this.repository = repository;
+    constructor(){
+        super();
+        this.repository = this.PortResolver.resolve<IMusicRepository>('IMusicRepository');
     }
-
-    static fromInjector(injector : Injector) : MusicCatalogService {
-        return new MusicCatalogService(injector.inject(MusicRepository))
-    }
-
     get(): Track[] {
         return this.repository.get();
     }

src/index.ts

@@ -0,0 +1,3 @@
+import { Wiring } from './wiring/Wiring';
+const wiring = new Wiring();
+wiring.apply();

src/tests.ts

@@ -0,0 +1,3 @@
+import { TestWiring } from './wiring/TestWiring';
+const wiring = new TestWiring();
+wiring.apply();

src/view/MusicComponent.spec.ts

@@ -1,11 +1,26 @@
+import { PortResolver } from '../adapters/PortResolver';
+import { currentPortResolver } from '../domain/ports/IPortResolver';
+const portResolver = currentPortResolver as PortResolver;
+
 import { MusicComponent } from "./MusicComponent";
+import { MusicCatalogService } from '../domain/services/MusicCatalogService';
+import { IMusicRepository } from '../domain/ports/IMusicRepository';
+
+let fakeMusicRepository = {
+    get: () => [],
+    add: (Track: number) => null
+} as any as IMusicRepository;
 
 describe("MusicComponent", () => {
 
     it('should create a new MusicComponent', (done) => {
-        console.log('Creating MusicComponent');
+
+        //let spiedAdd = spyOn(fakeMusicRepository, 'add').and.returnValue([]);
+        portResolver.registerInstance<IMusicRepository>('IMusicRepository', () => fakeMusicRepository);
+        let musicCatalogService = new MusicCatalogService();
+
         let musicComponent = new MusicComponent();
-        console.log('MusicComponent created!');
+        expect(musicComponent).not.toBe(null);
         done();
     });
 

src/view/MusicComponent.ts

@@ -1,19 +1,16 @@
 
 import { MusicCatalogService } from "../domain/services/MusicCatalogService"
-import { MusicRepository } from "../domain/ports/MusicRepository";
+import { IMusicRepository } from "../domain/ports/IMusicRepository";
 import { Track } from "../domain/models/Track";
 import { VinylCatalog } from "../adapters/music/VinylCatalog";
-import { Wiring } from "../wiring/Wiring";
 
 export class MusicComponent {
     constructor() {
-        const injector = Wiring.getInjector();
-        let musicCatalogService = MusicCatalogService.fromInjector(injector);
+        let musicCatalogService = new MusicCatalogService();
 
         let track = new Track(8, "Niels 1st", "Niels Kooiman", 45);
         musicCatalogService.add(track);
 
         let tracks = musicCatalogService.get();
-        console.log(tracks);
     }
 }

src/wiring/Container.ts

@@ -1,22 +0,0 @@
-
-import { Injector } from "../domain/ports/Injector"
-
-export class Container implements Injector {
-    private items : any = { };
-    public registerName(name : string, fn : Function) : void {
-        console.log(`registering ${name}`);
-        this.items[name] = fn;
-    }
-    public register(nameFn : Function, fn : Function) : void {
-        let name = (nameFn as any).name  || nameFn.prototype.name;
-        console.log(`registering ${name}`);
-        this.items[name] = fn;
-    }
-    public inject<T>(fn: Function) : T {
-        let name = (fn as any).name  || fn.prototype.name;
-        if (this.items[name]) {
-            return this.items[name]();
-        }
-        throw new Error(`Failed to resolve ${name} of ${JSON.stringify(Object.keys(this.items))}`);
-    }
-}

src/wiring/TestWiring.ts

@@ -0,0 +1,13 @@
+import { IPortResolver, setCurrentPortResolver } from "../domain/ports/IPortResolver";
+import { PortResolver } from "../adapters/PortResolver";
+import { VinylCatalog } from "../adapters/music/VinylCatalog";
+import { IMusicRepository } from "../domain/ports/IMusicRepository";
+
+export class TestWiring  {
+    public apply() : void {
+        const portResolver = new PortResolver();
+        portResolver.register<IMusicRepository>('IMusicRepository', () => new VinylCatalog());
+
+        setCurrentPortResolver(portResolver);
+    }
+}

src/wiring/Wiring.ts

@@ -1,19 +1,13 @@
-import { Injector } from "../domain/ports/Injector";
-import { Container } from "./Container";
+import { IPortResolver, setCurrentPortResolver } from "../domain/ports/IPortResolver";
+import { PortResolver } from "../adapters/PortResolver";
 import { VinylCatalog } from "../adapters/music/VinylCatalog";
-import { MusicRepository } from "../domain/ports/MusicRepository";
+import { IMusicRepository } from "../domain/ports/IMusicRepository";
 
 export class Wiring  {
-    private static injector : Injector;
-    public static apply() : void {
-        const container = new Container();        
-        container.register(MusicRepository, () => new VinylCatalog());
-        Wiring.injector = container;
-    }
-    public static getInjector() : Injector {
-        if (!Wiring.injector) {
-            Wiring.apply();
-        }
-        return Wiring.injector;
+    public apply() : void {
+        const portResolver = new PortResolver();
+        portResolver.register<IMusicRepository>('IMusicRepository', () => new VinylCatalog());
+
+        setCurrentPortResolver(portResolver);
     }
 }