allow to explixitly set keyCase.from and .to

Author: jannishuebl

src/model.ts

@@ -39,15 +39,19 @@ import { cloneDeep } from "./util/clonedeep"
 import { nonenumerable } from "./util/decorators"
 import { IncludeScopeHash } from "./util/include-directive"
 
+export interface KeyCase {
+  from: "dash" | "camel" | "snake"
+  to: "dash" | "camel" | "snake"
+}
+
 export interface ModelConfiguration {
   baseUrl: string
   apiNamespace: string
   jsonapiType: string
   endpoint: string
   jwt: string
   jwtStorage: string | false
-  camelizeKeys: boolean
-  letterCase: string
+  keyCase: KeyCase
   strictAttributes: boolean
   logger: ILogger
 }
@@ -129,8 +133,7 @@ export class JSORMBase {
   static endpoint: string
   static isBaseClass: boolean
   static jwt?: string
-  static camelizeKeys: boolean = true
-  static letterCase: string = "underscore"
+  static keyCase: KeyCase = { from: "snake", to: "camel" }
   static strictAttributes: boolean = false
   static logger: ILogger = defaultLogger
 
@@ -467,9 +470,7 @@ export class JSORMBase {
       if (attrs.hasOwnProperty(key)) {
         let attributeName = key
 
-        if (this.klass.camelizeKeys) {
-          attributeName = this.klass.deserializeKey(key)
-        }
+        attributeName = this.klass.deserializeKey(key)
 
         if (key === "id" || this.klass.attributeList[attributeName]) {
           ;(<any>this)[attributeName] = attrs[key]
@@ -695,14 +696,31 @@ export class JSORMBase {
   }
 
   static serializeKey(key: string): string {
-    if (this.letterCase == "dasherized") {
-      return dasherize(underscore(key))
+    switch (this.keyCase.from) {
+      case "dash": {
+        return dasherize(underscore(key))
+      }
+      case "snake": {
+        return underscore(key)
+      }
+      case "camel": {
+        return camelize(underscore(key), false)
+      }
     }
-    return underscore(key)
   }
 
   static deserializeKey(key: string): string {
-    return camelize(underscore(key), false)
+    switch (this.keyCase.to) {
+      case "dash": {
+        return dasherize(underscore(key))
+      }
+      case "snake": {
+        return underscore(key)
+      }
+      case "camel": {
+        return camelize(underscore(key), false)
+      }
+    }
   }
 
   async destroy(): Promise<boolean> {

src/util/deserialize.ts

@@ -1,6 +1,5 @@
 import { JsonapiTypeRegistry } from "../jsonapi-type-registry"
 import { JSORMBase } from "../model"
-import { camelize, underscore } from "inflected"
 import {
   IncludeDirective,
   IncludeScopeHash,
@@ -238,15 +237,7 @@ class Deserializer {
   ) {
     for (const key in relationships) {
       if (relationships.hasOwnProperty(key)) {
-        let relationName = key
-
-        if (instance.klass.camelizeKeys) {
-          if (instance.klass.letterCase === "dasherized") {
-            relationName = camelize(underscore(key), false)
-          } else {
-            relationName = camelize(key, false)
-          }
-        }
+        let relationName = instance.klass.deserializeKey(key)
 
         if (instance.klass.attributeList[relationName]) {
           const relationData = relationships[key].data

src/util/validation-errors.ts

@@ -40,11 +40,7 @@ export class ValidationErrors {
     errorsAccumulator: Record<string, string>,
     meta: JsonapiErrorMeta
   ) {
-    let attribute = meta.attribute
-
-    if (this.model.klass.camelizeKeys) {
-      attribute = this.model.klass.deserializeKey(attribute)
-    }
+    let attribute = this.model.klass.deserializeKey(meta.attribute)
 
     errorsAccumulator[attribute] = meta.message
   }

test/fixtures.ts

@@ -30,12 +30,12 @@ export class PersonWithExtraAttr extends Person {
   extraThing: string
 }
 
-@Model({ camelizeKeys: false })
+@Model({ keyCase: { from: "snake", to: "snake" } })
 export class PersonWithoutCamelizedKeys extends Person {
   @Attr first_name: string
 }
 
-@Model({ letterCase: "dasherized" })
+@Model({ keyCase: { from: "dash", to: "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",
-    camelizeKeys: false
+    keyCase: { from: "snake", to: "snake" }
   },
 
   attrs: {

test/integration/relations.test.ts

@@ -100,7 +100,7 @@ describe("Relations", () => {
     })
   })
 
-  describe("when camelizeKeys is false", () => {
+  describe("when keyCase is snake_case", () => {
     beforeEach(() => {
       fetchMock.get(
         "http://example.com/api/v1/non_fiction_authors/1?include=books,multi_words",
@@ -110,7 +110,7 @@ describe("Relations", () => {
 
     afterEach(fetchMock.restore)
 
-    it("Doesn't convert relationships to snake_case if camelization is off", async () => {
+    it("Doesn't convert relationships to snake_case if keyCase.to is snake is off", async () => {
       const data = await resultData(
         NonFictionAuthor.includes(["books", "multi_words"]).find(1)
       )

test/integration/validations.test.ts

@@ -122,21 +122,21 @@ describe("validations", () => {
     })
   })
 
-  describe("when camelizeKeys is false", () => {
+  describe("when keyCase.to is snake", () => {
     beforeEach(() => {
-      instance.klass.camelizeKeys = false
+      instance.klass.keyCase.to = "snake"
     })
 
     afterEach(() => {
-      instance.klass.camelizeKeys = true
+      instance.klass.keyCase.to = "camel"
     })
 
     it("does not camelize the error keys", async () => {
       await instance.save({ with: { books: "genre" } })
 
       expect(instance.errors).to.deep.equal({
         first_name: "cannot be blank",
-        "last-name": "cannot be blank"
+        last_name: "cannot be blank"
       })
     })
   })

test/unit/decorators.test.ts

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

test/unit/model-attributes.test.ts

@@ -25,7 +25,7 @@ describe("Model attributes", () => {
     expect(person.firstName).to.eq("Joe")
   })
 
-  it("does not camlize underscored strings if camelization is disabled", () => {
+  it("does not camlize underscored strings if keys.to is snake", () => {
     const person = new PersonWithoutCamelizedKeys({ first_name: "Joe" })
     expect(person.firstName).to.eq(undefined)
     expect(person.first_name).to.eq("Joe")

test/unit/model-class-typings.test.ts

@@ -44,7 +44,7 @@ describe("Model Class static attributes typings", () => {
           const endpoint: string = RootClass.endpoint
           const jwt: string | undefined = RootClass.jwt
           const jwtLocalStorage: string | false = RootClass.jwtLocalStorage
-          const camelizeKeys: boolean = RootClass.camelizeKeys
+          const keyCase: KeyCase = RootClass.keyCase
           const strictAttributes: boolean = RootClass.strictAttributes
         })
       })

test/unit/model.test.ts

@@ -446,7 +446,8 @@ describe("Model", () => {
 
         it("preserves defaults for unspecified items", () => {
           expect(MyModel.baseUrl).to.eq("http://please-set-a-base-url.com")
-          expect(MyModel.camelizeKeys).to.be.true
+          expect(MyModel.keyCase.from).to.eq("snake")
+          expect(MyModel.keyCase.to).to.eq("camel")
         })
 
         it("correctly assigns options", () => {
@@ -817,8 +818,8 @@ describe("Model", () => {
       })
     })
 
-    describe('when previously persisted, dirty, then persisted again', () => {
-      it('is no longer dirty', () => {
+    describe("when previously persisted, dirty, then persisted again", () => {
+      it("is no longer dirty", () => {
         const instance = new Author({ id: 1 })
         instance.firstName = "foo"
         instance.isPersisted = true