Merge pull request #76 from jannishuebl/use_patch_for_updating_in_1.x

use patch for updating a resource

Author: wadetandy

src/model.ts

@@ -817,7 +817,7 @@ export class JSORMBase {
 
     if (this.isPersisted) {
       url = this.klass.url(this.id)
-      verb = "put"
+      verb = "patch"
     }
 
     const json = payload.asJSON()

src/request.ts

@@ -34,12 +34,12 @@ export class Request {
     return this._fetchWithLogging(url, options)
   }
 
-  put(
+  patch(
     url: string,
     payload: JsonapiRequestDoc,
     options: RequestInit
   ): Promise<any> {
-    options.method = "PUT"
+    options.method = "PATCH"
     options.body = JSON.stringify(payload)
 
     return this._fetchWithLogging(url, options)
@@ -98,8 +98,12 @@ export class Request {
     return response
   }
 
-  private async _handleResponse(response: Response, requestOptions: RequestInit) {
-    let wasDelete = requestOptions.method === 'DELETE' &&
+  private async _handleResponse(
+    response: Response,
+    requestOptions: RequestInit
+  ) {
+    let wasDelete =
+      requestOptions.method === "DELETE" &&
       [202, 204, 200].indexOf(response.status) > -1
     if (wasDelete) return
 

test/integration/dirty-tracking.test.ts

@@ -23,22 +23,22 @@ describe("Dirty tracking", () => {
 
   beforeEach(() => {
     let url = "http://example.com/api/v1/authors"
-    fetchMock.post(url, responsePayload('John'))
-    fetchMock.put(`${url}/1`, responsePayload('Jake'))
+    fetchMock.post(url, responsePayload("John"))
+    fetchMock.patch(`${url}/1`, responsePayload("Jake"))
   })
 
   describe("when persisted, dirty, updated", () => {
     it("calls reset()", async () => {
-      let instance = new Author({ firstName: 'John' })
+      let instance = new Author({ firstName: "John" })
       await instance.save()
       expect(instance.isPersisted).to.eq(true)
       expect(instance.isDirty()).to.eq(false)
-      instance.firstName = 'Jake'
+      instance.firstName = "Jake"
       expect(instance.isDirty()).to.eq(true)
       let spy = sinon.spy()
       instance.reset = spy
       await instance.save()
       expect(spy.callCount).to.eq(2)
     })
   })
-})
+})

test/integration/id-map.test.ts

@@ -21,7 +21,7 @@ describe("ID Map", () => {
 
     fetchMock.get(
       "http://example.com/api/v1/authors/1",
-      responsePayload('John')
+      responsePayload("John")
     )
 
     fetchMock.delete("http://example.com/api/v1/authors/1", {
@@ -57,24 +57,24 @@ describe("ID Map", () => {
     it("is added to the ID map", async () => {
       let { data } = await Author.find(1)
       let stored = ApplicationRecord.store.data
-      expect(Object.keys(stored)[0]).to.eq('authors-1')
-      expect(stored['authors-1']).to.deep.eq(data.attributes)
+      expect(Object.keys(stored)[0]).to.eq("authors-1")
+      expect(stored["authors-1"]).to.deep.eq(data.attributes)
     })
 
     it("syncs with id map", async () => {
       let author1 = (await Author.find(1)).data
-      author1.firstName = 'updated'
+      author1.firstName = "updated"
       let author2 = (await Author.find(1)).data
-      expect(author1.firstName).to.eq('John')
+      expect(author1.firstName).to.eq("John")
     })
 
     describe("when syncing, then unlistening", () => {
       it("no longer syncs with id map", async () => {
         let author1 = (await Author.find(1)).data
-        author1.firstName = 'updated'
+        author1.firstName = "updated"
         author1.unlisten()
         let author2 = (await Author.find(1)).data
-        expect(author1.firstName).to.eq('updated')
+        expect(author1.firstName).to.eq("updated")
       })
     })
 
@@ -89,7 +89,7 @@ describe("ID Map", () => {
     // we wouldn't want the user typing in the form to update the grid,
     // until the form was saved.
     it("syncs multiple instances", async () => {
-      fetchMock.put("http://example.com/api/v1/authors/1", {
+      fetchMock.patch("http://example.com/api/v1/authors/1", {
         data: {
           id: "1",
           type: "authors",
@@ -105,17 +105,17 @@ describe("ID Map", () => {
       let author2 = response.data
 
       // not synced prior to save
-      author1.firstName = 'updated'
-      expect(author2.firstName).to.not.eq('updated')
+      author1.firstName = "updated"
+      expect(author2.firstName).to.not.eq("updated")
 
       await author1.save()
 
       // now synced after save
-      expect(author2.firstName).to.eq('updated')
+      expect(author2.firstName).to.eq("updated")
 
       // now back to unsynced
-      author1.firstName = 'updated again'
-      expect(author2.firstName).to.eq('updated')
+      author1.firstName = "updated again"
+      expect(author2.firstName).to.eq("updated")
     })
   })
 
@@ -142,48 +142,48 @@ describe("ID Map", () => {
       })
     })
 
-    describe('and associated to a hasMany relationship', () => {
+    describe("and associated to a hasMany relationship", () => {
       let book: Book
       let author: Author
 
       beforeEach(() => {
-        book = new Book({ id: 1, title: 'original' })
+        book = new Book({ id: 1, title: "original" })
         book.isPersisted = true
         author = new Author({ id: 1, books: [book] })
       })
 
       it("is also updated within the relationship", async () => {
-        expect(author.books[0].title).to.eq('original')
+        expect(author.books[0].title).to.eq("original")
         let { data } = await Book.find(1)
-        expect(data.title).to.eq('updated')
-        expect(author.books[0].title).to.eq('updated')
+        expect(data.title).to.eq("updated")
+        expect(author.books[0].title).to.eq("updated")
       })
     })
 
-    describe('and associated to a belongsTo relationship', () => {
+    describe("and associated to a belongsTo relationship", () => {
       let book: Book
       let author: Author
 
       beforeEach(() => {
-        author = new Author({ id: 1, firstName: 'original' })
+        author = new Author({ id: 1, firstName: "original" })
         author.isPersisted = true
         book = new Book({ id: 1, author })
         book.isPersisted = true
       })
 
       it("is also updated within the relationship", async () => {
-        expect(book.author.firstName).to.eq('original')
+        expect(book.author.firstName).to.eq("original")
         await Author.find(1)
-        expect(book.author.firstName).to.eq('John')
+        expect(book.author.firstName).to.eq("John")
       })
     })
 
-    describe('and associated to a hasOne relationship', () => {
+    describe("and associated to a hasOne relationship", () => {
       let author: Author
       let bio: Bio
 
       beforeEach(() => {
-        bio = new Bio({ id: 1, description: 'original' })
+        bio = new Bio({ id: 1, description: "original" })
         bio.isPersisted = true
         author = new Author({ id: 1, bio })
         author.isPersisted = true
@@ -199,14 +199,14 @@ describe("ID Map", () => {
 
   describe("when destroyed via sideposting", () => {
     beforeEach(async () => {
-      fetchMock.put("http://example.com/api/v1/authors/1", {
+      fetchMock.patch("http://example.com/api/v1/authors/1", {
         data: {
           id: "1",
           type: "authors"
         }
       })
 
-      fetchMock.put("http://example.com/api/books/1", {
+      fetchMock.patch("http://example.com/api/books/1", {
         data: {
           id: "1",
           type: "books"
@@ -224,7 +224,7 @@ describe("ID Map", () => {
         author = new Author({ id: 1, books: [book] })
         author.isPersisted = true
         book.isMarkedForDestruction = true
-        await author.save({ with: 'books' })
+        await author.save({ with: "books" })
       })
 
       it("is removed from the ID map + relationship", async () => {
@@ -244,7 +244,7 @@ describe("ID Map", () => {
         book = new Book({ id: 1, author })
         book.isPersisted = true
         author.isMarkedForDestruction = true
-        await book.save({ with: 'author' })
+        await book.save({ with: "author" })
       })
 
       it("is removed from the ID map", async () => {
@@ -264,7 +264,7 @@ describe("ID Map", () => {
         author = new Author({ id: 1, bio })
         author.isPersisted = true
         bio.isMarkedForDestruction = true
-        await author.save({ with: 'bio' })
+        await author.save({ with: "bio" })
       })
 
       it("is removed from the ID map", async () => {
@@ -277,14 +277,14 @@ describe("ID Map", () => {
 
   describe("when disassociated via sideposting", () => {
     beforeEach(async () => {
-      fetchMock.put("http://example.com/api/v1/authors/1", {
+      fetchMock.patch("http://example.com/api/v1/authors/1", {
         data: {
           id: "1",
           type: "authors"
         }
       })
 
-      fetchMock.put("http://example.com/api/books/1", {
+      fetchMock.patch("http://example.com/api/books/1", {
         data: {
           id: "1",
           type: "books"
@@ -302,7 +302,7 @@ describe("ID Map", () => {
         author = new Author({ id: 1, books: [book] })
         author.isPersisted = true
         book.isMarkedForDisassociation = true
-        await author.save({ with: 'books' })
+        await author.save({ with: "books" })
       })
 
       it("is still in the store, but removed from the relation", async () => {
@@ -322,7 +322,7 @@ describe("ID Map", () => {
         book = new Book({ id: 1, author })
         book.isPersisted = true
         author.isMarkedForDisassociation = true
-        await book.save({ with: 'author' }) || this
+        ;(await book.save({ with: "author" })) || this
       })
 
       it("is still in the store, but removed from the relation", async () => {
@@ -342,7 +342,7 @@ describe("ID Map", () => {
         author = new Author({ id: 1, bio })
         author.isPersisted = true
         bio.isMarkedForDisassociation = true
-        await author.save({ with: 'bio' })
+        await author.save({ with: "bio" })
       })
 
       it("is still in the store, but removed from the relation", async () => {
@@ -361,27 +361,27 @@ describe("ID Map", () => {
       expect(ApplicationRecord.store.count).to.eq(0)
     })
 
-    describe('and associated to a hasMany relationship', () => {
+    describe("and associated to a hasMany relationship", () => {
       let book: Book
       let author: Author
 
       beforeEach(() => {
         author = new Author({ id: 1 })
         author.isPersisted = true
-        book = new Book({ id: 1})
+        book = new Book({ id: 1 })
         book.isPersisted = true
         author.books = [book]
       })
 
-      it('is no longer returned in the relationship', async () => {
+      it("is no longer returned in the relationship", async () => {
         expect(author.books.length).to.eq(1)
         await book.destroy()
         expect(ApplicationRecord.store.find(book)).to.eq(undefined)
         expect(author.books.length).to.eq(0)
       })
     })
 
-    describe('and associated to a belongsTo relationship', () => {
+    describe("and associated to a belongsTo relationship", () => {
       let author: Author
       let book: Book
 
@@ -392,14 +392,14 @@ describe("ID Map", () => {
         book.isPersisted = true
       })
 
-      it('is no longer returned in the relationship', async () => {
+      it("is no longer returned in the relationship", async () => {
         expect(book.author).to.not.eq(undefined)
         await author.destroy()
         expect(book.author).to.eq(undefined)
       })
     })
 
-    describe('and associated to a hasOne relationship', () => {
+    describe("and associated to a hasOne relationship", () => {
       let author: Author
       let bio: Bio
 
@@ -410,11 +410,11 @@ describe("ID Map", () => {
         author.isPersisted = true
       })
 
-      it('is no longer returned in the relationship', async () => {
+      it("is no longer returned in the relationship", async () => {
         expect(author.bio).to.not.eq(undefined)
         await bio.destroy()
         expect(author.bio).to.eq(undefined)
       })
     })
   })
-})
+})