initial pass at relationships

Author: Lee Richmond

gulpfile.js

@@ -12,7 +12,7 @@ gulp.task('clean:test', function () {
 
 gulp.task('test', ['clean:test'], () =>
   gulp
-    .src(['./index.d.ts.', './src/**/*.ts', './test/fixtures.ts', './test/test-helper.ts', './test/**/*-test.ts'], { base: '.' })
+    .src(['./index.d.ts.', './src/main.ts', './src/**/*.ts', './test/fixtures.ts', './test/test-helper.ts', './test/**/*-test.ts'], { base: '.' })
     .pipe(tsProject())
     .pipe(gulp.dest('tmp/test'))
     .pipe(mocha())

index.d.ts

@@ -11,25 +11,9 @@ declare module NodeJS  {
   }
 }
 
-interface IModel {
-  id: string;
-  [propName: string]: any;
-}
-
-interface anyObject {
-  [propName: string]: any;
-}
-
-interface modelsConfig {
-  [key: string]: any;
-}
-
-interface japiDocArray {
-  data: Array<japiResource>;
-}
-
 interface japiDoc {
-  data: japiResource;
+  data: any; // can't do Array | japiResource
+  included: Array<japiResource>;
 }
 
 interface japiResourceIdentifier {

src/associations.ts

@@ -0,0 +1,44 @@
+import Attribute from './attribute';
+import Model from './model';
+
+class Base extends Attribute {
+  getter(context: Model) {
+    return context.relationships[this.name];
+  }
+
+  setter(context: Model, val: any) : void {
+    context.relationships[this.name] = val;
+  }
+}
+
+class HasMany extends Base {
+  getter(context: Model) {
+    let gotten = super.getter(context);
+    if (!gotten) {
+      this.setter(context, []);
+      return super.getter(context);
+    } else {
+      return gotten;
+    }
+  }
+}
+
+class HasOne extends Base {
+}
+
+class BelongsTo extends Base {
+}
+
+const hasMany = function() : HasMany {
+  return new HasMany();
+}
+
+const hasOne = function() : HasOne {
+  return new HasOne();
+}
+
+const belongsTo = function() : BelongsTo {
+  return new BelongsTo();
+}
+
+export { hasMany, hasOne, belongsTo };

src/attribute.ts

@@ -5,43 +5,52 @@ import Model from './model';
 
 export default class Attribute {
   name: string;
-  private _value: any;
 
   isAttr: boolean = true;
 
   static applyAll(klass: typeof Model) : void {
     this._eachAttribute(klass, (attr) => {
       klass.attributeList.push(attr.name);
 
-      Object.defineProperty(klass.prototype, attr.name, {
-        get() : any {
-          return attr.getter(this);
-        },
-
-        set(value) : void {
-          attr.setter(this, value);
-        }
-      });
+      Object.defineProperty(klass.prototype, attr.name, attr.getSet());
     });
   }
 
   private static _eachAttribute(klass: typeof Model, callback: Function) : void {
     let instance = new klass();
     for (let propName in instance) {
       if (instance[propName] && instance[propName].hasOwnProperty('isAttr')) {
+
         let attrInstance = instance[propName];
         attrInstance.name = propName;
         callback(attrInstance);
       }
     }
   }
 
-  setter(context: Model, val: any) : void {
-    if (!val.hasOwnProperty('isAttr')) {
-      context.attributes[this.name] = val;
+  // This returns the getters/setters for use on the *model*
+  getSet() {
+    let attr = this;
+
+    return {
+      get() : any {
+        return attr.getter(this);
+      },
+
+      set(value) : void {
+        if (!value.hasOwnProperty('isAttr')) {
+          attr.setter(this, value);
+        }
+      }
     }
   }
 
+  // The model calls this setter
+  setter(context: Model, val: any) : void {
+    context.attributes[this.name] = val;
+  }
+
+  // The model calls this getter
   getter(context: Model) : any {
     return context.attributes[this.name];
   }

src/main.ts

@@ -11,9 +11,10 @@ global.__extends = (this && this.__extends) || function (d, b) {
 import Config from './configuration';
 import Model from './model';
 import Attribute from './attribute';
+import { hasMany, hasOne, belongsTo } from './associations';
 
 const attr = function() : any {
   return new Attribute();
 }
 
-export { Config, Model, attr };
+export { Config, Model, attr, hasMany, hasOne, belongsTo };

src/model.ts

@@ -6,14 +6,15 @@ import Attribute from './attribute';
 import deserialize from './util/deserialize';
 import _extend from './util/extend';
 
-export default class Model implements IModel {
+export default class Model {
   static baseUrl = process.env.BROWSER? '': 'http://localhost:9999'
   static endpoint = 'define-in-subclass';
   static apiNamespace = '/';
   static jsonapiType = 'define-in-subclass';
 
   id: string;
   attributes: Object = {};
+  relationships: Object = {};
   __meta__: Object | void = null;
   parentClass: typeof Model;
   klass: typeof Model;
@@ -35,7 +36,7 @@ export default class Model implements IModel {
     return this._scope || new Scope(this);
   }
 
-  constructor(attributes?: anyObject) {
+  constructor(attributes?: Object) {
     this._assignAttributes(attributes);
   }
 
@@ -85,8 +86,8 @@ export default class Model implements IModel {
     return base;
   }
 
-  static fromJsonapi(resource: japiResource) : any {
-    return deserialize(resource);
+  static fromJsonapi(resource: japiResource, payload: japiDoc) : any {
+    return deserialize(resource, payload);
   }
 
   private _assignAttributes(attrs: Object) : void {

src/scope.ts

@@ -16,16 +16,16 @@ export default class Scope {
   }
 
   all() : Promise<Array<Model>> {
-    return this._fetch(this.model.url()).then((json : japiDocArray) => {
+    return this._fetch(this.model.url()).then((json : japiDoc) => {
       return json.data.map((datum : japiResource) => {
-        return Model.fromJsonapi(datum);
+        return Model.fromJsonapi(datum, json);
       });
     });
   }
 
   find(id : string | number) : Promise<Model> {
     return this._fetch(this.model.url(id)).then((json : japiDoc) => {
-      return Model.fromJsonapi(json.data);
+      return Model.fromJsonapi(json.data, json);
     });
   }
 

src/util/deserialize.ts

@@ -3,14 +3,82 @@
 import Config from '../configuration';
 import Model from '../model';
 
-export default function deserialize(resource : japiResource) : Model {
-  let klass = Config.modelForType(resource.type);
+export default function deserialize(resource : japiResource, payload: japiDoc) : Model {
+  let deserializer = new Deserializer(payload);
+  return deserializer.deserialize(resource);
+}
+
+class Deserializer {
+  _models = [];
+  _resources = [];
+  payload: japiDoc;
+
+  constructor(payload) {
+    this.payload = payload;
+    this.addResources(payload.data);
+    this.addResources(payload.included);
+  }
+
+  addResources(data) {
+    if (Array.isArray(data)) {
+      for (let datum of data) {
+        this._resources.push(datum);
+      }
+    } else {
+      this._resources.push(data);
+    }
+  }
+
+  deserialize(resource: japiResource, isRelation?: boolean) : Model {
+    let record = this.findModel(resource);
+    if (!record) {
+      if (isRelation) {
+        resource = this.findResource(resource);
+      }
+      record = this._deserialize(resource);
+    }
+
+    return record;
+  }
+
+  _deserialize(resource: japiResource) : Model {
+    let klass = Config.modelForType(resource.type);
+    let instance = new klass({ id: resource.id });
+    this._models.push(instance);
+
+    for (let key in resource.attributes) {
+      instance[key] = resource.attributes[key];
+    }
+    this._processRelationships(instance, resource.relationships);
+    instance.__meta__ = resource.meta;
+    return instance;
+  }
 
-  let instance = new klass({ id: resource.id });
-  for (let key in resource.attributes) {
-    instance[key] = resource.attributes[key];
+  _processRelationships(instance, relationships) {
+    for (let key in relationships) {
+      let relationData = relationships[key].data;
+
+      if (Array.isArray(relationData)) {
+        for (let datum of relationData) {
+          let relatedRecord = this.deserialize(datum, true);
+          instance[key].push(relatedRecord);
+        }
+      } else {
+        let relatedRecord = this.deserialize(relationData, true);
+        instance[key] = relatedRecord;
+      }
+    }
+  }
+
+  findModel(resourceIdentifier) {
+    return this._models.filter((m) => {
+      return m.id == resourceIdentifier.id && m.klass.jsonapiType == resourceIdentifier.type;
+    })[0];
   }
-  instance.__meta__ = resource.meta;
 
-  return instance;
+  findResource(resourceIdentifier) {
+    return this._resources.filter((r) => {
+      return r.id == resourceIdentifier.id && r.type == resourceIdentifier.type;
+    })[0];
+  }
 }

test/fixtures.ts

@@ -1,4 +1,4 @@
-import { Model, Config, attr } from '../src/main';
+import { Model, Config, attr, hasMany, belongsTo } from '../src/main';
 
 // typescript class
 class Person extends Model {
@@ -15,9 +15,26 @@ class Person extends Model {
 let Author = Person.extend({
   static: {
     jsonapiType: 'authors'
-  }
+  },
+
+  books: hasMany(),
+  genre: belongsTo()
 });
 
+class Book extends Model {
+  static jsonapiType = 'books';
+
+  title: string = attr();
+}
+
+class Genre extends Model {
+  static jsonapiType = 'genres';
+
+  authors: any = hasMany()
+
+  name: string = attr();
+}
+
 Config.bootstrap();
 
-export { Author, Person };
+export { Author, Person, Book, Genre };