Merge pull request #17 from mqchau/JsonApiLink

Support links as indicated in JSON:API specification

Author: wadetandy

src/decorators.ts

@@ -165,6 +165,27 @@ const AttrDecoratorFactory: {
   }
 }
 
+const LinkDecoratorFactory = function(
+  fieldDetail?: FieldDecoratorDescriptor
+): any {
+  const trackLink = (Model: typeof SpraypaintBase, propKey: string) => {
+    ensureModelInheritance(Model)
+    Model.linkList.push(propKey)
+  }
+
+  if (isModernDecoratorDescriptor(fieldDetail)) {
+    return Object.assign(fieldDetail, {
+      finisher: (Model: typeof SpraypaintBase) => {
+        trackLink(Model, fieldDetail.key)
+      }
+    })
+  } else {
+    return (target: SpraypaintBase, propKey: string) => {
+      trackLink(<any>target.constructor, propKey)
+    }
+  }
+}
+
 const ensureModelInheritance = (ModelClass: typeof SpraypaintBase) => {
   if (ModelClass.currentClass !== ModelClass) {
     ModelClass.currentClass.inherited(ModelClass)
@@ -319,6 +340,7 @@ const BelongsToDecoratorFactory = AssociationDecoratorFactoryBuilder(BelongsTo)
 export {
   ModelDecorator as Model,
   AttrDecoratorFactory as Attr,
+  LinkDecoratorFactory as Link,
   HasManyDecoratorFactory as HasMany,
   HasOneDecoratorFactory as HasOne,
   BelongsToDecoratorFactory as BelongsTo

src/index.ts

@@ -4,7 +4,7 @@ export { Attribute, attr } from "./attribute"
 
 export { hasMany, hasOne, belongsTo } from "./associations"
 
-export { Model, Attr, HasMany, HasOne, BelongsTo } from "./decorators"
+export { Model, Attr, HasMany, HasOne, BelongsTo, Link } from "./decorators"
 
 export { MiddlewareStack } from "./middleware-stack"
 

src/model.ts

@@ -165,6 +165,7 @@ export class SpraypaintBase {
   static clientApplication: string | null = null
 
   static attributeList: Record<string, Attribute> = {}
+  static linkList: Array<string> = []
   static extendOptions: any
   static parentClass: typeof SpraypaintBase
   static currentClass: typeof SpraypaintBase = SpraypaintBase
@@ -245,6 +246,7 @@ export class SpraypaintBase {
     subclass.currentClass = subclass
     subclass.prototype.klass = subclass
     subclass.attributeList = cloneDeep(subclass.attributeList)
+    subclass.linkList = cloneDeep(subclass.linkList)
   }
 
   static setAsBase(): void {
@@ -369,6 +371,7 @@ export class SpraypaintBase {
     }
 
     Subclass.attributeList = Object.assign({}, Subclass.attributeList, attrs)
+    Subclass.linkList = Subclass.linkList.slice()
 
     applyModelConfig(Subclass, options.static || {})
 
@@ -407,13 +410,17 @@ export class SpraypaintBase {
   > = {}
   @nonenumerable private _attributes!: ModelRecord<this>
   @nonenumerable private _originalAttributes: ModelRecord<this>
+  @nonenumerable private _links!: ModelRecord<this>
+  @nonenumerable private _originalLinks!: ModelRecord<this>
   @nonenumerable private __meta__: any
   @nonenumerable private _errors: ValidationErrors<this> = {}
 
   constructor(attrs?: Record<string, any>) {
     this._initializeAttributes()
+    this._initializeLinks()
     this.assignAttributes(attrs)
     this._originalAttributes = cloneDeep(this._attributes)
+    this._originalLinks = cloneDeep(this._links)
     this._originalRelationships = this.relationshipResourceIdentifiers(
       Object.keys(this.relationships)
     )
@@ -424,6 +431,10 @@ export class SpraypaintBase {
     this._copyPrototypeDescriptors()
   }
 
+  private _initializeLinks() {
+    this._links = {}
+  }
+
   /*
    * VueJS, along with a few other frameworks rely on objects being "reactive". In practice, this
    * means that when passing an object into an context where you would need change detection, vue
@@ -672,6 +683,7 @@ export class SpraypaintBase {
     cloned.isMarkedForDestruction = this.isMarkedForDestruction
     cloned.isMarkedForDisassociation = this.isMarkedForDisassociation
     cloned.errors = Object.assign({}, this.errors)
+    cloned.links = Object.assign({}, this.links)
     return cloned
   }
 
@@ -967,6 +979,25 @@ export class SpraypaintBase {
       Object.keys(includeDirective)
     )
   }
+
+  get links(): Record<string, any> {
+    return this._links
+  }
+
+  set links(links: Record<string, any>) {
+    this._links = {}
+    this.assignLinks(links)
+  }
+
+  assignLinks(links?: Record<string, any>): void {
+    if (!links) return
+    for (const key in links) {
+      const attributeName = this.klass.deserializeKey(key)
+      if (this.klass.linkList.indexOf(attributeName) > -1) {
+        this._links[attributeName] = links[key]
+      }
+    }
+  }
 }
 
 ;(<any>SpraypaintBase.prototype).klass = SpraypaintBase

src/util/deserialize.ts

@@ -130,6 +130,9 @@ class Deserializer {
     // assign attrs
     instance.assignAttributes(datum.attributes)
 
+    // assign links
+    instance.assignLinks(datum.links)
+
     // assign meta
     instance.setMeta(datum.meta)
 

test/es6-compatibility/decorators.test.mjs

@@ -4,7 +4,8 @@ import {
   Attr,
   HasMany,
   HasOne,
-  BelongsTo
+  BelongsTo,
+  Link
 } from "../../lib-esm"
 import { expect } from "chai"
 
@@ -27,6 +28,12 @@ describe("Decorators work with ES6/Babel", () => {
         @BelongsTo author
       }
 
+      @Model({ jsonapiType: "users_with_link" })
+      class UserWithLink extends ApplicationRecord {
+        @Attr name
+        @Link self
+      }
+
       expect(ApplicationRecord.parentClass).to.eq(SpraypaintBase)
       expect(ApplicationRecord.typeRegistry.get("users")).to.eq(User)
       expect(Object.keys(User.attributeList)).to.deep.eq([
@@ -35,6 +42,7 @@ describe("Decorators work with ES6/Babel", () => {
         "supervisor"
       ])
       expect(Object.keys(Post.attributeList)).to.deep.eq(["title", "author"])
+      expect(UserWithLink.linkList).to.deep.eq(["self"])
     })
   })
 })

test/fixtures.ts

@@ -7,7 +7,7 @@ import {
   hasOne
 } from "../src/index"
 
-import { Attr, BelongsTo, HasMany, HasOne } from "../src/decorators"
+import { Attr, BelongsTo, HasMany, HasOne, Link } from "../src/decorators"
 
 @Model({
   baseUrl: "http://example.com",
@@ -30,6 +30,15 @@ export class PersonWithExtraAttr extends Person {
   @Attr({ persist: false }) extraThing!: string
 }
 
+@Model()
+export class PersonWithLinks extends Person {
+  static endpoint = "/v1/people_with_links"
+  static jsonapiType = "people_with_links"
+
+  @Link() self!: string
+  @Link() webView!: string
+}
+
 @Model({ keyCase: { server: "snake", client: "snake" } })
 export class PersonWithoutCamelizedKeys extends Person {
   @Attr first_name!: string

test/unit/decorators.test.ts

@@ -5,6 +5,7 @@ import {
   HasOne,
   HasMany,
   BelongsTo,
+  Link,
   initModel
 } from "../../src/decorators"
 import { Association } from "../../src/associations"
@@ -157,6 +158,40 @@ describe("Decorators", () => {
     )
   })
 
+  describe("@Link", () => {
+    let BaseModel: typeof SpraypaintBase
+
+    beforeEach(() => {
+      @Model()
+      class MyBase extends SpraypaintBase {}
+      BaseModel = MyBase
+    })
+
+    it("adds to the link list", () => {
+      @Model()
+      class TestClass extends BaseModel {
+        @Link() link1!: string
+      }
+
+      expect(TestClass.linkList).to.include("link1")
+    })
+
+    it("child class adds to the link list of parent", () => {
+      @Model()
+      class TestClass extends BaseModel {
+        @Link() link1!: string
+      }
+
+      class ChildTestClass extends TestClass {
+        @Link() link2!: string
+      }
+
+      expect(ChildTestClass.linkList).to.include("link1")
+      expect(ChildTestClass.linkList).to.include("link2")
+      expect(TestClass.linkList).to.not.include("link2")
+    })
+  })
+
   const singleDecorators = [
     { Assoc: HasMany, Name: "@HasMany" },
     { Assoc: HasOne, Name: "@HasOne" },

test/unit/model.test.ts

@@ -15,6 +15,7 @@ import { EventBus } from "../../src/event-bus"
 import {
   ApplicationRecord,
   Person,
+  PersonWithLinks,
   Book,
   Author,
   Genre,
@@ -1530,4 +1531,65 @@ describe("Model", () => {
       expect(headers["Content-Type"]).to.eq("application/vnd.api+json")
     })
   })
+
+  describe("links", () => {
+    it("duplicates the links when object is duplicated", () => {
+      let author = new PersonWithLinks({ id: "1", firstName: "Stephen" })
+      author.assignLinks({ self: "/api/person/1", web_view: "/person/1" })
+
+      let duped = author.dup()
+      duped.assignLinks({ self: "/api/humans/1" })
+
+      expect(author.links.self).to.eq("/api/person/1")
+      expect(author.links.webView).to.eq("/person/1")
+      expect(duped.links.self).to.eq("/api/humans/1")
+      expect(duped.links.webView).to.eq("/person/1")
+    })
+
+    it("discard links that are undeclared but included in payload", () => {
+      let author = new PersonWithLinks({ id: "1", firstName: "Stephen" })
+      author.assignLinks({
+        self: "/api/person/1",
+        web_view: "/person/1",
+        undeclared: "/something"
+      })
+      expect(author.links.self).to.eq("/api/person/1")
+      expect(author.links.webView).to.eq("/person/1")
+      expect(author.links.undeclared).to.be.undefined
+    })
+
+    describe("deserialize from payload correctly", () => {
+      const doc = {
+        data: {
+          id: "1",
+          type: "people_with_links",
+          attributes: { firstName: "Donald Budge" },
+          links: {
+            self: { href: "/api/person/1", meta: { count: 10 } },
+            web_view: "/person/1"
+          }
+        }
+      }
+
+      function assertPersonIsCorrect(person: PersonWithLinks) {
+        expect(person.links.self).to.deep.equal({
+          href: "/api/person/1",
+          meta: { count: 10 }
+        })
+        expect(person.links.webView).to.eq("/person/1")
+        expect(person.links.comments).to
+      }
+
+      it("from instance", () => {
+        const person = new PersonWithLinks({ id: "1", firstName: "Stephen" })
+        person.fromJsonapi(doc.data, doc)
+        assertPersonIsCorrect(person)
+      })
+
+      it("from class", () => {
+        const person = PersonWithLinks.fromJsonapi(doc.data, doc)
+        assertPersonIsCorrect(person)
+      })
+    })
+  })
 })