Implement persistence with the save() method

Author: ghidoz

README.MD

@@ -11,7 +11,10 @@ A lightweight Angular 2 adapter for [JSON API](http://jsonapi.org/)
     - [Finding Records](#finding-records)
         - [Querying for Multiple Records](#querying-for-multiple-records)
         - [Retrieving a Single Record](#retrieving-a-single-record)
-    - [Creating Records](#creating-records)
+    - [Creating, Updating and Deleting](#creating-updating-and-deleting)
+        - [Creating Records](#creating-records)
+        - [Persisting Records](#persisting-records)
+        - [Relationships](#relationships)
     - [Custom Headers](#custom-headers)
 - [TODO](#todo)
 - [Development](#development)
@@ -216,7 +219,9 @@ this.datastore.findRecord(Post, '1', {
 );
 ```
 
-### Creating Records
+### Creating, Updating and Deleting 
+
+#### Creating Records
 
 You can create records by calling the `createRecord()` method on the datastore:
 - The first argument is the type of object you want to create.
@@ -226,39 +231,53 @@ You can create records by calling the `createRecord()` method on the datastore:
 this.datastore.createRecord(Post, {
     title: 'My post',
     content: 'My content'
-}).subscribe(
+});
+```
+
+#### Persisting Records
+
+Records are persisted on a per-instance basis. Call `save()` on any instance of `JsonApiModel` and it will make a network request.
+
+```typescript
+let post = this.datastore.createRecord(Post, {
+    title: 'My post',
+    content: 'My content'
+});
+
+post.save();
+```
+
+The `save()` method will return an `Observer` that you can subscribe:
+
+```typescript
+post.save().subscribe(
     (post: Post) => console.log(post)
 );
 ```
 
+#### Relationships
+
 If the object you want to create has a **one-to-many** relationship, you can do this:
 
 ```typescript
-this.datastore.createRecord(Comment, {
+let comment = this.datastore.createRecord(Comment, {
     title: 'My comment',
     post: post
-}).subscribe(
-    (comment: Comment) => console.log(comment)
-);
+});
 ```
 
 where `post` is an object of type `Post`, previously retrieved from the API.
 
-If you want to include a relationship when creating a record to have it parsed in the response, you can pass the `params` object:
+If you want to include a relationship when creating a record to have it parsed in the response, you can pass the `params` object to the `save()` method:
 
 ```typescript
-this.datastore.createRecord(Comment, {
-    title: 'My comment',
-    post: post
-}, {
+comment.save({
 	include: 'user'
 }).subscribe(
     (comment: Comment) => console.log(comment)
 );
 ```
 
-
-
 ### Custom Headers
 
 By default, the library adds these headers, according to the [JSON API MIME Types](http://jsonapi.org/#mime-types):
@@ -277,12 +296,17 @@ this.datastore.headers = new Headers({'Authorization': 'Bearer ' + accessToken})
 Or you can pass the headers as last argument of any datastore call method:
 
 ```typescript
-this.datastore.createRecord(Post, {
-    title: 'My post',
-    content: 'My content'
+this.datastore.query(Post, {
+    include: 'comments'
 }, new Headers({'Authorization': 'Bearer ' + accessToken}));
 ```
 
+and in the `save()` method:
+
+```typescript
+post.save({}, new Headers({'Authorization': 'Bearer ' + accessToken}));
+```
+
 
 ## TODO
 - Implement everything from the [JSON API](http://jsonapi.org/) specific.

src/models/json-api.model.ts

@@ -1,61 +1,69 @@
 import * as _ from 'underscore';
 import 'reflect-metadata';
+import { Headers } from '@angular/http';
+import { Observable } from 'rxjs/Observable';
 import { JsonApiDatastore } from '../services/json-api-datastore.service';
 
 export class JsonApiModel {
 
     id: string;
     [key: string]: any;
 
-    constructor(data: any) {
-        this.id = data.id;
-        _.extend(this, data.attributes);
+    constructor(private _datastore: JsonApiDatastore, data: any) {
+        if (data) {
+            this.id = data.id;
+            _.extend(this, data.attributes);
+        }
+    }
+
+    syncRelationships(data: any, included: any) {
+        this.parseHasMany(data, included);
+        this.parseBelongsTo(data, included);
     }
 
-    syncRelationships(data: any, included: any, datastore: JsonApiDatastore) {
-        this.parseHasMany(data, included, datastore);
-        this.parseBelongsTo(data, included, datastore);
+    save(params?: any, headers?: Headers): Observable<JsonApiModel> {
+        return this._datastore.saveRecord(this, params, headers);
     }
 
-    private parseHasMany(data: any, included: any, datastore: JsonApiDatastore) {
+    private parseHasMany(data: any, included: any) {
         let hasMany = Reflect.getMetadata('HasMany', this);
         if (hasMany) {
             for (let metadata of hasMany){
                 if (data.relationships[metadata.relationship] && data.relationships[metadata.relationship].data) {
                     let typeName: string = data.relationships[metadata.relationship].data[0].type;
-                    let objectType = Reflect.getMetadata('JsonApiDatastoreConfig', datastore.constructor).models[typeName];
+                    let objectType = Reflect.getMetadata('JsonApiDatastoreConfig', this._datastore.constructor).models[typeName];
                     this[metadata.propertyName] = this.getHasManyRelationship(objectType, data, included, metadata.relationship, typeName);
                 }
             }
         }
     }
 
-    private parseBelongsTo(data: any, included: any, datastore: JsonApiDatastore) {
+    private parseBelongsTo(data: any, included: any) {
         let belongsTo = Reflect.getMetadata('BelongsTo', this);
         if (belongsTo) {
             for (let metadata of belongsTo){
                 if (data.relationships[metadata.relationship] && data.relationships[metadata.relationship].data) {
                     let typeName: string = data.relationships[metadata.relationship].data.type;
-                    let objectType = Reflect.getMetadata('JsonApiDatastoreConfig', datastore.constructor).models[typeName];
+                    let objectType = Reflect.getMetadata('JsonApiDatastoreConfig', this._datastore.constructor).models[typeName];
                     this[metadata.propertyName] = this.getBelongsToRelationship(objectType, data, included, metadata.relationship, typeName);
                 }
             }
         }
     }
 
-    private getHasManyRelationship(objectType: { new(data: any): JsonApiModel; }, data: any, included: any, relationship: string, typeName: string): JsonApiModel[] {
+    private getHasManyRelationship(objectType: { new(ds: JsonApiDatastore, data: any): JsonApiModel; }, data: any, included: any, relationship: string, typeName: string): JsonApiModel[] {
         let relationshipList: JsonApiModel[] = [];
         data.relationships[relationship].data.forEach((item: any) => {
             let relationshipData: any = _.findWhere(included, {id: item.id, type: typeName});
-            relationshipList.push(new objectType(relationshipData));
+            relationshipList.push(new objectType(this._datastore, relationshipData));
         });
         return relationshipList;
     }
 
-    private getBelongsToRelationship(objectType: { new(data: any): JsonApiModel; }, data: any, included: any, relationship: string, typeName: string): JsonApiModel {
+    private getBelongsToRelationship(objectType: { new(ds: JsonApiDatastore, data: any): JsonApiModel; }, data: any, included: any, relationship: string, typeName: string): JsonApiModel {
         let id = data.relationships[relationship].data.id;
         let relationshipData: any = _.findWhere(included, {id: id, type: typeName});
-        return new objectType(relationshipData);
+        return new objectType(this._datastore, relationshipData);
     }
 
 }

src/services/json-api-datastore.service.ts

@@ -1,3 +1,4 @@
+import * as _ from 'underscore';
 import { Injectable } from '@angular/core';
 import { Http, Headers, RequestOptions } from '@angular/http';
 import { Observable } from 'rxjs/Observable';
@@ -12,27 +13,34 @@ export class JsonApiDatastore {
 
     constructor(private http: Http) { }
 
-    query(type: { new(data: any): JsonApiModel; }, params?: any, headers?: Headers): Observable<JsonApiModel[]> {
+    query(type: { new(ds: JsonApiDatastore, data: any): JsonApiModel; }, params?: any, headers?: Headers): Observable<JsonApiModel[]> {
         let options = this.getOptions(headers);
         let url = this.buildUrl(type, params);
         return this.http.get(url, options)
             .map((res: any) => this.extractQueryData(res, type))
             .catch((res: any) => this.handleError(res));
     }
 
-    findRecord(type: { new(data: any): JsonApiModel; }, id: string, params?: any, headers?: Headers): Observable<JsonApiModel> {
+    findRecord(type: { new(ds: JsonApiDatastore, data: any): JsonApiModel; }, id: string, params?: any, headers?: Headers): Observable<JsonApiModel> {
         let options = this.getOptions(headers);
         let url = this.buildUrl(type, params, id);
         return this.http.get(url, options)
             .map((res: any) => this.extractRecordData(res, type))
             .catch((res: any) => this.handleError(res));
     }
 
-    createRecord(type: { new(data: any): JsonApiModel; }, data?: any, params?: any, headers?: Headers) {
+    createRecord(type: { new(ds: JsonApiDatastore, data: any): JsonApiModel; }, data?: any): JsonApiModel {
+        return new type(this, { attributes: data });
+    }
+
+    saveRecord(data?: any, params?: any, headers?: Headers): Observable<JsonApiModel> {
+        let type = data.constructor;
         let typeName =  Reflect.getMetadata('JsonApiModelConfig', type).type;
         let options = this.getOptions(headers);
         let relationships = this.getRelationships(data);
         let url = this.buildUrl(type, params);
+        data = _.clone(data);
+        delete data._datastore;
         return this.http.post(url, {
             data: {
                 type: typeName,
@@ -41,14 +49,14 @@ export class JsonApiDatastore {
             }
         }, options)
             .map((res: any) => this.extractRecordData(res, type))
-            .catch((res: any) => this.handleError(res))
+            .catch((res: any) => this.handleError(res));
     }
 
     set headers(headers: Headers){
         this._headers = headers;
     }
 
-    private buildUrl(type: { new(data: any): JsonApiModel; }, params?: any, id?: string) {
+    private buildUrl(type: { new(ds: JsonApiDatastore, data: any): JsonApiModel; }, params?: any, id?: string) {
         let typeName =  Reflect.getMetadata('JsonApiModelConfig', type).type;
         let baseUrl = Reflect.getMetadata('JsonApiDatastoreConfig', this.constructor).baseUrl;
         let idToken = id ? `/${id}` : null;
@@ -75,24 +83,24 @@ export class JsonApiDatastore {
         return relationships;
     }
 
-    private extractQueryData(res: any, type: { new(data: any): JsonApiModel; }): JsonApiModel[] {
+    private extractQueryData(res: any, type: { new(ds: JsonApiDatastore, data: any): JsonApiModel; }): JsonApiModel[] {
         let body = res.json();
         let models: JsonApiModel[] = [];
         body.data.forEach((data: any) => {
-            let model: JsonApiModel = new type(data);
+            let model: JsonApiModel = new type(this, data);
             if (body.included) {
-                model.syncRelationships(data, body.included, this);
+                model.syncRelationships(data, body.included);
             }
             models.push(model);
         });
         return models;
     }
 
-    private extractRecordData(res: any, type: { new(data: any): JsonApiModel; }): JsonApiModel {
+    private extractRecordData(res: any, type: { new(ds: JsonApiDatastore, data: any): JsonApiModel; }): JsonApiModel {
         let body = res.json();
-        let model: JsonApiModel = new type(body.data);
+        let model: JsonApiModel = new type(this, body.data);
         if (body.included) {
-            model.syncRelationships(body.data, body.included, this);
+            model.syncRelationships(body.data, body.included);
         }
         return model;
     }