feat(stores): Implement deleteOne method for all stores

src/browser/stores/http.store.spec.ts

@@ -1,6 +1,6 @@
 import { inject, addProviders, async } from '@angular/core/testing';
 import { MockBackend, MockConnection } from '@angular/http/testing';
-import { Http, BaseRequestOptions, Response } from '@angular/http';
+import { Http, BaseRequestOptions, Response, ResponseOptions } from '@angular/http';
 import { Injectable, Injector } from '@angular/core';
 import { Logger } from '../../common/services/logger.service';
 import { LoggerMock } from '../../common/services/logger.service.mock';
@@ -101,7 +101,7 @@ describe('Http store', () => {
 
   })));
 
-  it('Retrieves a single model from http', async(inject([TestHttpStore, MockBackend], (s: TestHttpStore, b: MockBackend) => {
+  it('Retrieves a single model with http', async(inject([TestHttpStore, MockBackend], (s: TestHttpStore, b: MockBackend) => {
 
     let connection: MockConnection;
     b.connections.subscribe((c: MockConnection) => connection = c);
@@ -130,6 +130,31 @@ describe('Http store', () => {
 
   })));
 
+  it('Deletes a single model with http', async(inject([TestHttpStore, MockBackend], (s: TestHttpStore, b: MockBackend) => {
+
+    let connection: MockConnection;
+    b.connections.subscribe((c: MockConnection) => connection = c);
+
+    const model = new TestModel({id: 321, name: 'delete-me'});
+
+    const testPromise = s.deleteOne(model)
+      .then((res) => {
+
+        expect(res instanceof TestModel)
+          .toBe(true);
+        expect(res)
+          .toEqual(model);
+      });
+
+    connection.mockRespond(new Response(new ResponseOptions({
+      status: 204,
+      url: `${process.env.API_BASE}/tests/123`,
+    })));
+
+    return testPromise;
+
+  })));
+
   it('Logs error on failed model retrieval', async(inject([TestHttpStore, MockBackend], (s: TestHttpStore, b: MockBackend) => {
 
     let logSpy = spyOn((s as any).logger, 'error');

src/browser/stores/http.store.ts

@@ -25,7 +25,7 @@ export abstract class HttpStore<T extends AbstractModel> extends AbstractStore<T
   }
 
   /**
-   * Get the rest endpoint for the model 
+   * Get the rest endpoint for the model
    * @param id
    * @returns {string}
    */
@@ -83,6 +83,18 @@ export abstract class HttpStore<T extends AbstractModel> extends AbstractStore<T
       // .catch((error) => this.handleError(error));
   }
 
+  /**
+   * @inheritdoc
+   * @param model
+   */
+  public deleteOne(model: T): Promise<T> {
+
+    return this.http.delete(this.endpoint(model.getIdentifier()))
+      .toPromise()
+      .then((res: Response) => this.checkStatus(res))
+      .then(() => model); //@todo flag model as existing
+  }
+
   /**
    * Extract model from the payload
    * @param res

src/common/services/consoleLogger.service.spec.ts

@@ -295,16 +295,6 @@ describe('Console Logger', () => {
 
       expect(persistSpy)
         .toHaveBeenCalled();
-
-
-      try {
-        //do something that throws error
-      } catch (e) {
-        this.logger.error(e.message).silly.debug(e.stack);
-      }
-
-
-
     });
 
   });

src/common/stores/mock.store.ts

@@ -73,4 +73,16 @@ export abstract class MockStore<T extends AbstractModel> extends AbstractStore<T
     return Promise.resolve(model);
   }
 
+  /**
+   * Mock seleting model by id
+   *
+   * As deleting does not make sense for a mock store, this just stubs the interface by returning
+   * the model in a resolved promise
+   * @param model
+   * @returns {Promise<void>}
+   */
+  public deleteOne(model: T): Promise<T> {
+    return Promise.resolve(model);
+  }
+
 }

src/common/stores/store.spec.ts

@@ -191,6 +191,22 @@ describe('Mock Store', () => {
 
   })));
 
+  it('mocks delete action', async(inject([TestClass], (c: TestClass) => {
+
+    let shipRef: Ship = null;
+
+    return c.shipStore.findOne(1234)
+      .then((ship: Ship) => {
+        shipRef = ship;
+        return c.shipStore.deleteOne(ship)
+      })
+      .then((ship: Ship) => {
+        expect(ship instanceof Ship)
+          .toBe(true);
+      });
+
+  })));
+
   it('explicitly hydrates from raw data', async(inject([TestClass], (c: TestClass) => {
 
     let data: any = {

src/common/stores/store.ts

@@ -53,7 +53,11 @@ export abstract class AbstractStore<T extends AbstractModel> {
    */
   public abstract saveOne(model: T): Promise<T>;
 
-  // public abstract deleteOne(id: identifier): Promise<void>;
+  /**
+   * Delete the model from the store.
+   * @param model
+   */
+  public abstract deleteOne(model: T): Promise<T>;
 
   /**
    * Find multiple entities using a query for constraints

src/server/stores/db.store.spec.ts

@@ -31,7 +31,7 @@ class TestDatabaseStore extends DatabaseStore<TestModel> {
 
 describe('Database Store', () => {
 
-  const repositorySpy   = jasmine.createSpyObj('repository', ['findOneById', 'find', 'persist']);
+  const repositorySpy   = jasmine.createSpyObj('repository', ['findOneById', 'find', 'persist', 'remove']);
   const dbConnectionSpy = jasmine.createSpyObj('dbConnection', ['getRepository']);
   dbConnectionSpy.getRepository.and.returnValue(repositorySpy);
 
@@ -122,6 +122,25 @@ describe('Database Store', () => {
 
   })));
 
+
+  it('deletes a single entity from the orm', async(inject([TestDatabaseStore, Database], (store: TestDatabaseStore, db: Database) => {
+
+    (db as any).connection = dbConnectionSpy;
+
+    const testModelFixture = new TestModel({id: 10});
+
+    repositorySpy.remove.and.returnValue(Promise.resolve(testModelFixture));
+
+    return store.deleteOne(testModelFixture)
+      .then((res) => {
+        expect(repositorySpy.remove)
+          .toHaveBeenCalledWith(testModelFixture);
+        expect(res)
+          .toEqual(testModelFixture);
+      });
+
+  })));
+
   it('retrieves collection of entities from the orm', async(inject([TestDatabaseStore, Database], (store: TestDatabaseStore, db: Database) => {
 
     (db as any).connection = dbConnectionSpy;

src/server/stores/db.store.ts

@@ -40,7 +40,8 @@ export abstract class DatabaseStore<T extends AbstractModel> extends AbstractSto
    */
   public getRepository(): Promise<Repository<T>> {
     if (!this.repositoryPromise) {
-      this.repositoryPromise = this.database.getConnection().then((connection: Connection) => connection.getRepository(this.modelStatic))
+      this.repositoryPromise = this.database.getConnection()
+        .then((connection: Connection) => connection.getRepository(this.modelStatic))
     }
 
     return this.repositoryPromise;
@@ -49,8 +50,9 @@ export abstract class DatabaseStore<T extends AbstractModel> extends AbstractSto
   /**
    * @inheritdoc
    */
-  public initialized():Promise<this> {
-    return this.getRepository().then(() => this);
+  public initialized(): Promise<this> {
+    return this.getRepository()
+      .then(() => this);
   }
 
   /**
@@ -59,8 +61,8 @@ export abstract class DatabaseStore<T extends AbstractModel> extends AbstractSto
   public findOne(id: identifier): Promise<T> {
     return this.getRepository()
       .then((repo) => repo.findOneById(id))
-      .then((model:T) => {
-        if (!model){
+      .then((model: T) => {
+        if (!model) {
           throw new NotFoundException(`${this.modelStatic.name} not found with id [${id}]`);
         }
         return model;
@@ -97,4 +99,13 @@ export abstract class DatabaseStore<T extends AbstractModel> extends AbstractSto
       .then((repo) => repo.persist(model));
   }
 
+  /**
+   * @inheritdoc
+   * @param model
+   */
+  public deleteOne(model: T): Promise<T> {
+    return this.getRepository()
+      .then((repo) => repo.remove(model));
+  }
+
 }