Solidify attributes + classes

Author: Lee Richmond

example/foo.es6.js

@@ -1,5 +1,11 @@
 // babel example/foo.es6.js -o example/foo.js
 
-import { Config, Model } from '../dist/jsorm';
+import { Model, attr } from '../dist/jsorm';
 
-console.log('exmaple file', Model.baseUrl);
+const Person = Model.extend({
+  myname: attr()
+})
+
+let instance = new Person();
+instance.myname = 'asdf';
+console.log(instance.myname);

example/foo.js

@@ -2,4 +2,10 @@
 
 var _jsorm = require('../dist/jsorm');
 
-console.log('exmaple file', _jsorm.Model.baseUrl); // babel example/foo.es6.js -o example/foo.js
+var Person = _jsorm.Model.extend({
+  myname: (0, _jsorm.attr)()
+}); // babel example/foo.es6.js -o example/foo.js
+
+var instance = new Person();
+instance.myname = 'asdf';
+console.log(instance.myname);

gulpfile.js

@@ -12,7 +12,7 @@ gulp.task('clean:test', function () {
 
 gulp.task('test', ['clean:test'], () =>
   gulp
-    .src(['./index.d.ts.', './src/**/*.ts', './test/test-helper.ts', './test/**/*-test.ts'], { base: '.' })
+    .src(['./index.d.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

@@ -32,7 +32,14 @@ interface japiDoc {
   data: japiResource;
 }
 
-interface japiResource {
+interface japiResourceIdentifier {
   id: string;
   type: string;
 }
+
+interface japiResource extends japiResourceIdentifier {
+  attributes?: Object;
+  relationships?: Object;
+  meta?: Object;
+  links?: Object;
+}

src/attribute.ts

@@ -0,0 +1,48 @@
+// In the future, this class will be used for
+// transforms, default values, etc.
+
+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);
+        }
+      });
+    });
+  }
+
+  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;
+    }
+  }
+
+  getter(context: Model) : any {
+    return context.attributes[this.name];
+  }
+}

src/configuration.ts

@@ -1,5 +1,25 @@
 /// <reference path="../index.d.ts" />
 
+import Model from './model';
+import Attribute from './attribute';
+
 export default class Config {
-  static models: Object = {};
+  static models: Array<typeof Model> = [];
+  static typeMapping: Object = {};
+
+  static bootstrap() : void {
+    for (let model of this.models) {
+      this.typeMapping[model.jsonapiType] = model;
+      Attribute.applyAll(model);
+    }
+  }
+
+  static reset() : void {
+    this.typeMapping = {};
+    this.models = [];
+  }
+
+  static modelForType(type: string) : typeof Model {
+    return this.typeMapping[type];
+  }
 }

src/main.ts

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

src/model.ts

@@ -2,6 +2,9 @@
 
 import Scope from './scope';
 import Config from './configuration';
+import Attribute from './attribute';
+import deserialize from './util/deserialize';
+import _extend from './util/extend';
 
 export default class Model implements IModel {
   static baseUrl = process.env.BROWSER? '': 'http://localhost:9999'
@@ -10,23 +13,30 @@ export default class Model implements IModel {
   static jsonapiType = 'define-in-subclass';
 
   id: string;
-  // attributes
-  [key: string]: any;
+  attributes: Object = {};
+  __meta__: Object | void = null;
+  parentClass: typeof Model;
+  klass: typeof Model;
 
+  static attributeList = [];
   private static _scope: Scope;
 
-  static inherited(subclass : typeof Model) {
-    Config.models[subclass.jsonapiType] = subclass;
+  static extend(obj : any) : any {
+    return _extend(this, obj);
+  }
+
+  static inherited(subclass : any) {
+    Config.models.push(subclass)
+    subclass.parentClass = this;
+    subclass.prototype.klass = subclass;
   }
 
   static scope(): Scope {
     return this._scope || new Scope(this);
   }
 
   constructor(attributes?: anyObject) {
-    for(var key in attributes) {
-      this[key] = attributes[key];
-    }
+    this._assignAttributes(attributes);
   }
 
   static all() : Promise<Array<Model>> {
@@ -74,4 +84,16 @@ export default class Model implements IModel {
 
     return base;
   }
+
+  static fromJsonapi(resource: japiResource) : any {
+    return deserialize(resource);
+  }
+
+  private _assignAttributes(attrs: Object) : void {
+    for(var key in attrs) {
+      if (key == 'id' || this.klass.attributeList.indexOf(key) >= 0) {
+        this[key] = attrs[key];
+      }
+    }
+  }
 }

src/scope.ts

@@ -1,6 +1,5 @@
 import Model from './model';
 import Config from './configuration';
-import deserialize from './util/deserialize';
 import parameterize from './util/parameterize';
 import IncludeDirective from './util/include-directive';
 
@@ -19,14 +18,14 @@ export default class Scope {
   all() : Promise<Array<Model>> {
     return this._fetch(this.model.url()).then((json : japiDocArray) => {
       return json.data.map((datum : japiResource) => {
-        return deserialize(datum);
+        return Model.fromJsonapi(datum);
       });
     });
   }
 
   find(id : string | number) : Promise<Model> {
     return this._fetch(this.model.url(id)).then((json : japiDoc) => {
-      return deserialize(json.data);
+      return Model.fromJsonapi(json.data);
     });
   }
 

src/util/deserialize.ts

@@ -1,10 +1,16 @@
 /// <reference path="../../index.d.ts" />
 
 import Config from '../configuration';
+import Model from '../model';
 
-export default function deserialize(resource : japiResource) : IModel {
-  let klass = Config.models[resource.type];
+export default function deserialize(resource : japiResource) : Model {
+  let klass = Config.modelForType(resource.type);
 
   let instance = new klass({ id: resource.id });
+  for (let key in resource.attributes) {
+    instance[key] = resource.attributes[key];
+  }
+  instance.__meta__ = resource.meta;
+
   return instance;
 }