Add BelongsTo relationship. Fix some relationship parsing issues. Parse included relationships when creating records

ghidoz · ghidoz · commit edfc2af358f6 · 2016-08-26T17:09:28.000+02:00
diff --git a/README.MD b/README.MD
@@ -74,7 +74,8 @@ import { JsonApiDatastoreConfig, JsonApiDatastore } from 'angular2-jsonapi';
   baseUrl: 'http://localhost:8000/v1/',
   models: {
     posts: Post,
-    comments: Comment
+    comments: Comment,
+    users: User
   }
 })
 export class Datastore extends JsonApiDatastore { }
@@ -83,7 +84,7 @@ export class Datastore extends JsonApiDatastore { }
 Then set up your models:
 - Extend the `JsonApiModel` class
 - Decorate it with `@JsonApiModelConfig`, passing the `type`
-- Decorate the relationships attributes with `@HasMany`
+- Decorate the relationships attributes with `@HasMany` and `@BelongsTo`
 
 ```typescript
 import { JsonApiModelConfig, JsonApiModel, HasMany } from 'angular2-jsonapi';
@@ -106,8 +107,21 @@ export class Post extends JsonApiModel {
 export class Comment extends JsonApiModel {
 
     title: string;
-
+    
+    @BelongsTo()
     post: Post;
+
+	@BelongsTo()
+    user: User;
+}
+
+@JsonApiModelConfig({
+    type: 'users'
+})
+export class User extends JsonApiModel {
+
+    name: string;
+    // ...
 }
 ```
 
@@ -191,17 +205,34 @@ this.datastore.createRecord(Post, {
 );
 ```
 
-If the object you want to create has a one-to-many relationship, you can do this:
+If the object you want to create has a **one-to-many** relationship, you can do this:
+
+```typescript
+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:
 
 ```typescript
 this.datastore.createRecord(Comment, {
     title: 'My comment',
-    post: Post
+    post: post
+}, {
+	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):
diff --git a/src/decorators/belongs-to.decorator.ts b/src/decorators/belongs-to.decorator.ts
@@ -0,0 +1,12 @@
+import 'reflect-metadata';
+
+export function BelongsTo(config: any = {}) {
+  return function(target: any, propertyName: string | symbol) {
+    let annotations = Reflect.getMetadata('BelongsTo', target) || [];
+    annotations.push({
+        propertyName: propertyName,
+        relationship: config.key || propertyName
+    });
+    Reflect.defineMetadata('BelongsTo', annotations, target);
+  };
+}
diff --git a/src/decorators/has-many.decorator.ts b/src/decorators/has-many.decorator.ts
@@ -1,11 +1,11 @@
 import 'reflect-metadata';
 
 export function HasMany(config: any = {}) {
-  return function(target: any, attributeName: string | symbol) {
+  return function(target: any, propertyName: string | symbol) {
     let annotations = Reflect.getMetadata('HasMany', target) || [];
     annotations.push({
-        attribute: attributeName,
-        key: config.key || attributeName
+        propertyName: propertyName,
+        relationship: config.key || propertyName
     });
     Reflect.defineMetadata('HasMany', annotations, target);
   };
diff --git a/src/index.ts b/src/index.ts
@@ -1,6 +1,7 @@
 import { PROVIDERS } from './services';
 
 export * from './decorators/has-many.decorator';
+export * from './decorators/belongs-to.decorator';
 export * from './decorators/json-api-model-config.decorator';
 export * from './decorators/json-api-datastore-config.decorator';
 
diff --git a/src/models/json-api.model.ts b/src/models/json-api.model.ts
@@ -13,22 +13,49 @@ export class JsonApiModel {
     }
 
     syncRelationships(data: any, included: any, datastore: JsonApiDatastore) {
+        this.parseHasMany(data, included, datastore);
+        this.parseBelongsTo(data, included, datastore);
+    }
+
+    private parseHasMany(data: any, included: any, datastore: JsonApiDatastore) {
         let hasMany = Reflect.getMetadata('HasMany', this);
-        for (let metadata of hasMany){
-            if (data.relationships[metadata.key]) {
-                let type = Reflect.getMetadata('JsonApiDatastoreConfig', datastore.constructor).models[metadata.key];
-                this[metadata.attribute] = this.getRelationship(type, data, included, metadata.key);
+        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];
+                    this[metadata.propertyName] = this.getHasManyRelationship(objectType, data, included, metadata.relationship, typeName);
+                }
+            }
+        }
+    }
+
+    private parseBelongsTo(data: any, included: any, datastore: JsonApiDatastore) {
+        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];
+                    this[metadata.propertyName] = this.getBelongsToRelationship(objectType, data, included, metadata.relationship, typeName);
+                }
             }
         }
     }
 
-    private getRelationship(type: { new(data: any): JsonApiModel; }, data: any, included: any, relationshipName: string): JsonApiModel[] {
+    private getHasManyRelationship(objectType: { new(data: any): JsonApiModel; }, data: any, included: any, relationship: string, typeName: string): JsonApiModel[] {
         let relationshipList: JsonApiModel[] = [];
-        data.relationships[relationshipName].data.forEach((item: any) => {
-            let relationship: any = _.findWhere(included, {id: item.id});
-            relationshipList.push(new type(relationship));
+        data.relationships[relationship].data.forEach((item: any) => {
+            let relationshipData: any = _.findWhere(included, {id: item.id, type: typeName});
+            relationshipList.push(new objectType(relationshipData));
         });
         return relationshipList;
     }
 
+    private getBelongsToRelationship(objectType: { new(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);
+    }
+
 }
diff --git a/src/services/json-api-datastore.service.ts b/src/services/json-api-datastore.service.ts
@@ -32,27 +32,13 @@ export class JsonApiDatastore {
             .catch((res: any) => this.handleError(res));
     }
 
-    createRecord(type: { new(data: any): JsonApiModel; }, data?: any, headers?: Headers) {
+
+    createRecord(type: { new(data: any): JsonApiModel; }, data?: any, params?: any, headers?: Headers) {
         let typeName =  Reflect.getMetadata('JsonApiModelConfig', type).type;
-        let baseUrl = Reflect.getMetadata('JsonApiDatastoreConfig', this.constructor).baseUrl;
         let options = this.getOptions(headers);
-        let relationships: any;
-        for (let key in data) {
-            if (data.hasOwnProperty(key)) {
-                if (data[key] instanceof JsonApiModel) {
-                    relationships = relationships || {};
-                    let relationshipType =  Reflect.getMetadata('JsonApiModelConfig', data[key].constructor).type;
-                    relationships[key] = {
-                        data: {
-                            type: relationshipType,
-                            id: data[key].id
-                        }
-                    }
-                    delete data[key];
-                }
-            }
-        }
-        return this.http.post(baseUrl + typeName, {
+        let relationships = this.getRelationships(data);
+        let url = this.buildUrl(type, params);
+        return this.http.post(url, {
             data: {
                 type: typeName,
                 attributes: data,
@@ -67,14 +53,34 @@ export class JsonApiDatastore {
         this._headers = headers;
     }
 
-    private buildUrl(type: { new(data: any): JsonApiModel; }, params: any = {}, id?: number){
+    private buildUrl(type: { new(data: any): JsonApiModel; }, params?: any, id?: number){
         let typeName =  Reflect.getMetadata('JsonApiModelConfig', type).type;
-        if (params.include && typeof params.include === 'function') {
+        if (params && params.include && typeof params.include === 'function') {
             params.include = Reflect.getMetadata('JsonApiModelConfig', params.include).type;
         }
         let baseUrl = Reflect.getMetadata('JsonApiDatastoreConfig', this.constructor).baseUrl;
         let idToken = id ? `/${id}` : null;
-        return [baseUrl, typeName, idToken, '?', this.toQueryString(params)].join('');
+        return [baseUrl, typeName, idToken, (params ? '?' : ''), this.toQueryString(params)].join('');
+    }
+
+    private getRelationships(data: any): any{
+        let relationships: any;
+        for (let key in data) {
+            if (data.hasOwnProperty(key)) {
+                if (data[key] instanceof JsonApiModel) {
+                    relationships = relationships || {};
+                    let relationshipType =  Reflect.getMetadata('JsonApiModelConfig', data[key].constructor).type;
+                    relationships[key] = {
+                        data: {
+                            type: relationshipType,
+                            id: data[key].id
+                        }
+                    };
+                    delete data[key];
+                }
+            }
+        }
+        return relationships;
     }
 
     private extractQueryData(res: any, type: { new(data: any): JsonApiModel; }): JsonApiModel[] {
