Merge pull request #24 from mqchau/handle202

Handle response with status code 202 with potential background job details

Author: richmolj

src/deferred-action-callback.ts

@@ -0,0 +1,3 @@
+export interface DeferredActionCallback {
+  (responseObject: any): void
+}

src/model.ts

@@ -40,6 +40,7 @@ import { cloneDeep } from "./util/clonedeep"
 import { nonenumerable } from "./util/decorators"
 import { IncludeScopeHash } from "./util/include-directive"
 import { ValidationErrors } from "./validation-errors"
+import { DeferredActionCallback } from "./deferred-action-callback"
 
 export type KeyCaseValue = "dash" | "camel" | "snake"
 
@@ -393,6 +394,8 @@ export class SpraypaintBase {
   temp_id?: string
   stale: boolean = false
   storeKey: string = ""
+  onDeferredDestroy?: DeferredActionCallback
+  onDeferredUpdate?: DeferredActionCallback
 
   @nonenumerable afterSync?: (diff: Record<string, any>) => any | undefined
   @nonenumerable relationships: Record<
@@ -917,6 +920,13 @@ export class SpraypaintBase {
       throw err
     }
 
+    if (response.status === 202) {
+      return await this._handleAcceptedResponse(
+        response,
+        this.onDeferredDestroy
+      )
+    }
+
     let base = this.klass.baseClass as typeof SpraypaintBase
     base.store.destroy(this)
 
@@ -964,6 +974,10 @@ export class SpraypaintBase {
       throw err
     }
 
+    if (response.status === 202) {
+      return await this._handleAcceptedResponse(response, this.onDeferredUpdate)
+    }
+
     return await this._handleResponse(response, () => {
       this.fromJsonapi(
         response.jsonPayload.data,
@@ -974,6 +988,20 @@ export class SpraypaintBase {
     })
   }
 
+  private async _handleAcceptedResponse(
+    response: any,
+    callback: DeferredActionCallback | undefined
+  ): Promise<boolean> {
+    if (response.jsonPayload && callback) {
+      const responseObject = this.klass.fromJsonapi(
+        response.jsonPayload.data,
+        response.jsonPayload
+      )
+      callback(responseObject)
+    }
+    return await this._handleResponse(response, () => {})
+  }
+
   private async _handleResponse(
     response: JsonapiResponse,
     callback: () => void

src/request.ts

@@ -120,13 +120,14 @@ export class Request {
   ) {
     let wasDelete =
       requestOptions.method === "DELETE" &&
-      [202, 204, 200].indexOf(response.status) > -1
+      [204, 200].indexOf(response.status) > -1
     if (wasDelete) return
 
     let json
     try {
       json = await response.json()
     } catch (e) {
+      if (response.status === 202) return
       throw new ResponseError(response, "invalid json", e)
     }
 

test/fixtures.ts

@@ -119,6 +119,11 @@ export class MultiWord extends ApplicationRecord {
   static jsonapiType = "multi_words"
 }
 
+@Model()
+export class BackgroundJob extends ApplicationRecord {
+  static jsonapiType = "background_jobs"
+}
+
 export const TestJWTSubclass = ApplicationRecord.extend({})
 
 export const NonJWTOwner = SpraypaintBase.extend({})

test/integration/persistence.test.ts

@@ -1,5 +1,5 @@
 import { expect, fetchMock } from "../test-helper"
-import { Person, PersonWithExtraAttr } from "../fixtures"
+import { Person, PersonWithExtraAttr, BackgroundJob } from "../fixtures"
 import { JsonapiRequestDoc, JsonapiResponseDoc } from "../../src/index"
 
 after(() => {
@@ -274,6 +274,54 @@ describe("Model persistence", () => {
         })
       })
     })
+
+    describe("when the server returns 202 accepted", () => {
+      beforeEach(() => {
+        fetchMock.restore()
+        fetchMock.post("http://example.com/api/v1/people", { status: 202 })
+      })
+
+      afterEach(() => {
+        resetMocks()
+      })
+
+      it("does not blow up", async () => {
+        expect(instance.isPersisted).to.eq(false)
+        const success = await instance.save()
+
+        expect(success).to.be.true
+        expect(instance.isPersisted).to.eq(false)
+      })
+    })
+
+    describe("when the server returns 202 and a background job object", () => {
+      beforeEach(() => {
+        fetchMock.restore()
+
+        fetchMock.post("http://example.com/api/v1/people", {
+          status: 202,
+          body: { data: { id: "23", type: "background_jobs", attributes: {} } }
+        })
+      })
+
+      afterEach(() => {
+        resetMocks()
+      })
+
+      it("deserialize the response and return the job object", async () => {
+        let job: BackgroundJob = new BackgroundJob()
+        let populateJobOnResponse = (response: any) => {
+          job = response
+        }
+        instance.onDeferredUpdate = populateJobOnResponse
+        expect(instance.isPersisted).to.eq(false)
+        await instance.save()
+
+        expect(instance.isPersisted).to.eq(false)
+        expect(job.id).to.eq("23")
+        expect(job.klass).to.eq(BackgroundJob)
+      })
+    })
   })
 
   describe("#destroy", () => {
@@ -321,21 +369,48 @@ describe("Model persistence", () => {
       beforeEach(() => {
         fetchMock.restore()
 
-        fetchMock.mock({
-          matcher: "http://example.com/api/v1/people/1",
-          response: new Response({ status: 202 } as any)
-        })
+        fetchMock.delete("http://example.com/api/v1/people/1", { status: 202 })
       })
 
       afterEach(() => {
         resetMocks()
       })
 
       it("does not blow up", async () => {
+        expect(instance.isPersisted).to.eq(true)
+        const success = await instance.destroy()
+
+        expect(success).to.be.true
+        expect(instance.isPersisted).to.eq(true)
+      })
+    })
+
+    describe("when the server returns 202 and a background job object", () => {
+      beforeEach(() => {
+        fetchMock.restore()
+
+        fetchMock.delete("http://example.com/api/v1/people/1", {
+          status: 202,
+          body: { data: { id: "23", type: "background_jobs", attributes: {} } }
+        })
+      })
+
+      afterEach(() => {
+        resetMocks()
+      })
+
+      it("deserialize the response and return the job object", async () => {
+        let job: BackgroundJob = new BackgroundJob()
+        let populateJobOnResponse = (response: any) => {
+          job = response
+        }
+        instance.onDeferredDestroy = populateJobOnResponse
         expect(instance.isPersisted).to.eq(true)
         await instance.destroy()
 
-        expect(instance.isPersisted).to.eq(false)
+        expect(instance.isPersisted).to.eq(true)
+        expect(job.id).to.eq("23")
+        expect(job.klass).to.eq(BackgroundJob)
       })
     })