Merge pull request #64 from calebuharrison/ch/keycasing-for-server-calls

Add support for keyCasing for server calls

Author: richmolj

src/scope.ts

@@ -85,7 +85,8 @@ export class Scope<T extends SpraypaintBase = SpraypaintBase> {
     const copy = this.copy()
 
     Object.keys(obj).forEach(k => {
-      copy._associations[k] = (obj as any)[k]
+      const serverCasedKey = this.model.serializeKey(k)
+      copy._associations[serverCasedKey] = (obj as any)[k]
     })
 
     return copy
@@ -107,6 +108,7 @@ export class Scope<T extends SpraypaintBase = SpraypaintBase> {
 
   where(clause: WhereClause): Scope<T> {
     const copy = this.copy()
+    clause = this._serverCasedWhereClause(clause)
 
     for (const key in clause) {
       if (clause.hasOwnProperty(key)) {
@@ -129,6 +131,7 @@ export class Scope<T extends SpraypaintBase = SpraypaintBase> {
 
   stats(clause: StatsScope): Scope<T> {
     const copy = this.copy()
+    clause = this._serverCasedStatsClause(clause)
 
     for (const key in clause) {
       if (clause.hasOwnProperty(key)) {
@@ -140,6 +143,7 @@ export class Scope<T extends SpraypaintBase = SpraypaintBase> {
 
   order(clause: SortScope | string): Scope<T> {
     const copy = this.copy()
+    clause = this._serverCasedOrderClause(clause)
 
     if (typeof clause === "object") {
       for (const key in clause) {
@@ -156,6 +160,7 @@ export class Scope<T extends SpraypaintBase = SpraypaintBase> {
 
   select(clause: FieldArg) {
     const copy = this.copy()
+    clause = this._serverCasedFieldsClause(clause)
 
     if (Array.isArray(clause)) {
       let _clause = clause as string[]
@@ -174,6 +179,7 @@ export class Scope<T extends SpraypaintBase = SpraypaintBase> {
 
   selectExtra(clause: FieldArg) {
     const copy = this.copy()
+    clause = this._serverCasedFieldsClause(clause)
 
     if (Array.isArray(clause)) {
       let _clause = clause as string[]
@@ -192,6 +198,7 @@ export class Scope<T extends SpraypaintBase = SpraypaintBase> {
 
   includes(clause: IncludeScope): Scope<T> {
     const copy = this.copy()
+    clause = this._serverCasedIncludesClause(clause)
 
     const directive = new IncludeDirective(clause)
     const directiveObject = directive.toScopeObject()
@@ -348,4 +355,53 @@ export class Scope<T extends SpraypaintBase = SpraypaintBase> {
 
     return new CollectionProxy(recordArray, jsonResult)
   }
+
+  private _serverCasedWhereClause(clause: WhereClause) {
+    return this._serverCasedClause(clause, false)
+  }
+
+  private _serverCasedOrderClause(clause: string | SortScope) {
+    if (typeof clause === "string") {
+      return this._serverCasedClause(clause, true)
+    } else {
+      return this._serverCasedClause(clause, false)
+    }
+  }
+
+  private _serverCasedFieldsClause(clause: FieldArg) {
+    return this._serverCasedClause(clause, true)
+  }
+
+  private _serverCasedIncludesClause(clause: IncludeScope) {
+    return this._serverCasedClause(clause, true)
+  }
+
+  private _serverCasedStatsClause(clause: StatsScope): StatsScope {
+    return this._serverCasedClause(clause, true)
+  }
+
+  private _serverCasedClause(thing: any, transformValues: boolean = false) {
+    if (typeof thing === "string") {
+      return transformValues ? this.model.serializeKey(thing) : thing
+    } else if (thing instanceof Array) {
+      return thing.map(
+        (item: any): any => this._serverCasedClause(item, transformValues)
+      )
+    } else if (thing instanceof Object) {
+      let serverCasedThing = {}
+      for (const property in thing) {
+        if (thing.hasOwnProperty(property)) {
+          const serverCasedProperty = this.model.serializeKey(property)
+          const serverCasedPropertyValue = this._serverCasedClause(
+            thing[property],
+            transformValues
+          )
+          serverCasedThing[serverCasedProperty] = serverCasedPropertyValue
+        }
+      }
+      return serverCasedThing
+    } else {
+      return thing
+    }
+  }
 }

test/unit/scope.test.ts

@@ -8,6 +8,8 @@ let scope: Scope<Author>
 beforeEach(() => {
   const model = sinon.stub() as any
   model.jsonapiType = "people"
+  model.serializeKey = SpraypaintBase.serializeKey
+  model.keyCase = { server: "snake", client: "camel" }
   scope = new Scope(model)
 })
 
@@ -55,6 +57,14 @@ describe("Scope", () => {
       expect(newScope).to.be.instanceof(Scope)
       expect(newScope).not.to.equal(scope)
     })
+
+    it("respects the server keycase configuration", () => {
+      scope = scope.where({ fooBar: "baz" }).where({ fooBarBaz: "fooBar" })
+      expect((scope as any)._filter).to.eql({
+        foo_bar: "baz",
+        foo_bar_baz: "fooBar"
+      })
+    })
   })
 
   describe("#stats()", () => {
@@ -72,6 +82,13 @@ describe("Scope", () => {
       expect(newScope).to.be.instanceof(Scope)
       expect(newScope).not.to.equal(scope)
     })
+
+    it("respects the server keycase configuration", () => {
+      scope = scope.stats({ someThing: "someOtherThing" })
+      expect((scope as any)._stats).to.eql({
+        some_thing: "some_other_thing"
+      })
+    })
   })
 
   describe("#order()", () => {
@@ -88,6 +105,14 @@ describe("Scope", () => {
       expect(newScope).to.be.instanceof(Scope)
       expect(newScope).not.to.equal(scope)
     })
+
+    it("respects the server keycase configuration", () => {
+      scope = scope.order("fooBar").order({ fooBarBaz: "desc" })
+      expect((scope as any)._sort).to.eql({
+        foo_bar: "asc",
+        foo_bar_baz: "desc"
+      })
+    })
   })
 
   describe("#select()", () => {
@@ -107,6 +132,13 @@ describe("Scope", () => {
       expect(newScope).not.to.equal(scope)
     })
 
+    it("respects the server keycase configuration", () => {
+      scope = scope.select({ someThing: ["firstThing", "secondThing"] })
+      expect((scope as any)._fields).to.eql({
+        some_thing: ["first_thing", "second_thing"]
+      })
+    })
+
     describe("when passed an array of strings", () => {
       it("infers the jsonapi type", () => {
         const newScope = scope.select(["foo"])
@@ -134,6 +166,13 @@ describe("Scope", () => {
       expect(newScope).not.to.equal(scope)
     })
 
+    it("respects the server keycase configuration", () => {
+      scope = scope.selectExtra({ someThing: ["firstThing", "secondThing"] })
+      expect((scope as any)._extra_fields).to.eql({
+        some_thing: ["first_thing", "second_thing"]
+      })
+    })
+
     describe("when passed an array of strings", () => {
       it("infers the jsonapi type", () => {
         const newScope = scope.selectExtra(["foo"])
@@ -152,6 +191,13 @@ describe("Scope", () => {
           foo: {}
         })
       })
+
+      it("respects the server keycase configuration", () => {
+        scope = scope.includes("fooBar")
+        expect((scope as any)._include).to.eql({
+          foo_bar: {}
+        })
+      })
     })
 
     describe("when passed an array", () => {
@@ -162,6 +208,14 @@ describe("Scope", () => {
           bar: {}
         })
       })
+
+      it("respects the server keycase configuration", () => {
+        scope = scope.includes(["fooBar", "fooBarBaz"])
+        expect((scope as any)._include).to.eql({
+          foo_bar: {},
+          foo_bar_baz: {}
+        })
+      })
     })
 
     describe("when passed a nested object", () => {
@@ -176,6 +230,20 @@ describe("Scope", () => {
           }
         })
       })
+
+      it("respects the server keycase configuration", () => {
+        scope = scope.includes({
+          fooBar: ["fooBarBaz", { fizzBuzz: "fizzBuzzBar" }]
+        })
+        expect((scope as any)._include).to.eql({
+          foo_bar: {
+            foo_bar_baz: {},
+            fizz_buzz: {
+              fizz_buzz_bar: {}
+            }
+          }
+        })
+      })
     })
 
     it("returns a new scope", () => {
@@ -185,6 +253,34 @@ describe("Scope", () => {
     })
   })
 
+  describe("#merge()", () => {
+    it("updates the scope", () => {
+      scope = scope
+        .includes(["foo_bar"])
+        .merge({ foo_bar: scope.where({ foo: "bar" }) })
+      const qp = scope.asQueryParams()
+
+      expect(qp.filter).to.eql({
+        foo_bar: {
+          foo: "bar"
+        }
+      })
+    })
+
+    it("respects the server keycase configuration", () => {
+      scope = scope
+        .includes(["foo_bar_baz"])
+        .merge({ fooBarBaz: scope.where({ foo: "bar" }) })
+      const qp = scope.asQueryParams()
+
+      expect(qp.filter).to.eql({
+        foo_bar_baz: {
+          foo: "bar"
+        }
+      })
+    })
+  })
+
   describe("#scope()", () => {
     it("returns itself", () => {
       expect(scope.scope()).to.equal(scope)
@@ -239,14 +335,14 @@ describe("Scope", () => {
       scope = scope
         .page(2)
         .per(10)
-        .where({ foo: "bar" })
+        .where({ fooBar: "baz" })
         .order("foo")
         .order({ bar: "desc" })
         .select({ people: ["name", "age"] })
         .stats({ total: "count" })
         .includes({ a: ["b", { c: "d" }] })
       expect(scope.toQueryParams()).to.eq(
-        "page[number]=2&page[size]=10&filter[foo]=bar&sort=foo,-bar&fields[people]=name,age&stats[total]=count&include=a.b,a.c.d"
+        "page[number]=2&page[size]=10&filter[foo_bar]=baz&sort=foo,-bar&fields[people]=name,age&stats[total]=count&include=a.b,a.c.d"
       )
     })