use server and client instead of from and to

Author: jannishuebl

src/model.ts

@@ -39,9 +39,11 @@ import { cloneDeep } from "./util/clonedeep"
 import { nonenumerable } from "./util/decorators"
 import { IncludeScopeHash } from "./util/include-directive"
 
+export type KeyCaseValue = "dash" | "camel" | "snake"
+
 export interface KeyCase {
-  from: "dash" | "camel" | "snake"
-  to: "dash" | "camel" | "snake"
+  server: KeyCaseValue
+  client: KeyCaseValue
 }
 
 export interface ModelConfiguration {
@@ -133,7 +135,7 @@ export class JSORMBase {
   static endpoint: string
   static isBaseClass: boolean
   static jwt?: string
-  static keyCase: KeyCase = { from: "snake", to: "camel" }
+  static keyCase: KeyCase = { server: "snake", client: "camel" }
   static strictAttributes: boolean = false
   static logger: ILogger = defaultLogger
   static sync: boolean = false
@@ -349,7 +351,7 @@ export class JSORMBase {
   id?: string
   temp_id?: string
   stale: boolean = false
-  storeKey: string = ''
+  storeKey: string = ""
 
   @nonenumerable relationships: Record<string, JSORMBase | JSORMBase[]> = {}
   @nonenumerable klass: typeof JSORMBase
@@ -430,45 +432,45 @@ export class JSORMBase {
   }
 
   _onStoreChange: Function
-  private onStoreChange() : Function {
+  private onStoreChange(): Function {
     if (this._onStoreChange) return this._onStoreChange
-    this._onStoreChange =  (_event: any, attrs: any) => {
-      Object.keys(attrs).forEach((k) => {
+    this._onStoreChange = (_event: any, attrs: any) => {
+      Object.keys(attrs).forEach(k => {
         let self = this as any
         if (self[k] !== attrs[k]) self[k] = attrs[k]
       })
     }
     return this._onStoreChange
   }
 
-  unlisten() : void {
+  unlisten(): void {
     if (!this.klass.sync) return
     if (this.storeKey) {
       EventBus.removeEventListener(this.storeKey, this.onStoreChange())
     }
 
-    Object.keys(this.relationships).forEach((k) => {
+    Object.keys(this.relationships).forEach(k => {
       let related = this.relationships[k]
 
       if (related) {
         if (Array.isArray(related)) {
-          related.forEach((r) => r.unlisten() )
+          related.forEach(r => r.unlisten())
         } else {
           related.unlisten()
         }
       }
     })
   }
 
-  listen() : void {
+  listen(): void {
     if (!this.klass.sync) return
-    if (!this._onStoreChange) { // not already registered
+    if (!this._onStoreChange) {
+      // not already registered
       EventBus.addEventListener(this.storeKey, this.onStoreChange())
     }
   }
 
-
-  reset() : void {
+  reset(): void {
     if (this.klass.sync) {
       this.klass.store.updateOrCreate(this)
       this.listen()
@@ -759,7 +761,7 @@ export class JSORMBase {
   }
 
   static serializeKey(key: string): string {
-    switch (this.keyCase.from) {
+    switch (this.keyCase.server) {
       case "dash": {
         return dasherize(underscore(key))
       }
@@ -773,7 +775,7 @@ export class JSORMBase {
   }
 
   static deserializeKey(key: string): string {
-    switch (this.keyCase.to) {
+    switch (this.keyCase.client) {
       case "dash": {
         return dasherize(underscore(key))
       }
@@ -885,4 +887,4 @@ export const isModelInstance = (arg: any): arg is JSORMBase => {
     return false
   }
   return isModelClass(arg.constructor.currentClass)
-}
+}

test/fixtures.ts

@@ -30,12 +30,12 @@ export class PersonWithExtraAttr extends Person {
   extraThing: string
 }
 
-@Model({ keyCase: { from: "snake", to: "snake" } })
+@Model({ keyCase: { server: "snake", client: "snake" } })
 export class PersonWithoutCamelizedKeys extends Person {
   @Attr first_name: string
 }
 
-@Model({ keyCase: { from: "dash", to: "camel" } })
+@Model({ keyCase: { server: "dash", client: "camel" } })
 export class PersonWithDasherizedKeys extends Person {}
 
 @Model({
@@ -70,7 +70,7 @@ export const NonFictionAuthor = Author.extend({
   static: {
     endpoint: "/v1/non_fiction_authors",
     jsonapiType: "non_fiction_authors",
-    keyCase: { from: "snake", to: "snake" }
+    keyCase: { server: "snake", client: "snake" }
   },
 
   attrs: {

test/integration/validations.test.ts

@@ -124,11 +124,11 @@ describe("validations", () => {
 
   describe("when keyCase.to is snake", () => {
     beforeEach(() => {
-      instance.klass.keyCase.to = "snake"
+      instance.klass.keyCase.client = "snake"
     })
 
     afterEach(() => {
-      instance.klass.keyCase.to = "camel"
+      instance.klass.keyCase.client = "camel"
     })
 
     it("does not camelize the error keys", async () => {

test/unit/decorators.test.ts

@@ -35,8 +35,8 @@ describe("Decorators", () => {
 
       it("preserves defaults for unspecified items", () => {
         expect(TestModel.baseUrl).to.eq("http://please-set-a-base-url.com")
-        expect(TestModel.keyCase.from).to.eq("snake")
-        expect(TestModel.keyCase.to).to.eq("camel")
+        expect(TestModel.keyCase.server).to.eq("snake")
+        expect(TestModel.keyCase.client).to.eq("camel")
       })
 
       it("correctly assigns options", () => {

test/unit/model.test.ts

@@ -447,8 +447,8 @@ describe("Model", () => {
 
         it("preserves defaults for unspecified items", () => {
           expect(MyModel.baseUrl).to.eq("http://please-set-a-base-url.com")
-          expect(MyModel.keyCase.from).to.eq("snake")
-          expect(MyModel.keyCase.to).to.eq("camel")
+          expect(MyModel.keyCase.server).to.eq("snake")
+          expect(MyModel.keyCase.client).to.eq("camel")
         })
 
         it("correctly assigns options", () => {
@@ -1177,8 +1177,8 @@ describe("Model", () => {
 
     beforeEach(() => {
       ApplicationRecord.sync = true
-      sinon.spy(EventBus, 'removeEventListener')
-      book = new Book({ id : 1 })
+      sinon.spy(EventBus, "removeEventListener")
+      book = new Book({ id: 1 })
       book.isPersisted = true
       author = new Author({ id: 1, books: [book] })
       author.isPersisted = true
@@ -1211,7 +1211,7 @@ describe("Model", () => {
 
     beforeEach(() => {
       ApplicationRecord.sync = true
-      sinon.spy(EventBus, 'addEventListener')
+      sinon.spy(EventBus, "addEventListener")
       author = new Author()
     })