Merge pull request #70 from jannishuebl/allow_to_use_dasherized_keys

add basic design for allowing to set letterCase

Author: wadetandy

src/model.ts

@@ -23,7 +23,7 @@ import {
   IncludeScope
 } from "./scope"
 import { JsonapiTypeRegistry } from "./jsonapi-type-registry"
-import { camelize } from "inflected"
+import { camelize, underscore, dasherize } from "inflected"
 import { ILogger, logger as defaultLogger } from "./logger"
 import { MiddlewareStack, BeforeFilter, AfterFilter } from "./middleware-stack"
 import { Omit } from "./util/omit"
@@ -39,14 +39,21 @@ 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 {
+  server: KeyCaseValue
+  client: KeyCaseValue
+}
+
 export interface ModelConfiguration {
   baseUrl: string
   apiNamespace: string
   jsonapiType: string
   endpoint: string
   jwt: string
   jwtStorage: string | false
-  camelizeKeys: boolean
+  keyCase: KeyCase
   strictAttributes: boolean
   logger: ILogger
 }
@@ -128,7 +135,7 @@ export class JSORMBase {
   static endpoint: string
   static isBaseClass: boolean
   static jwt?: string
-  static camelizeKeys: boolean = true
+  static keyCase: KeyCase = { server: "snake", client: "camel" }
   static strictAttributes: boolean = false
   static logger: ILogger = defaultLogger
   static sync: boolean = false
@@ -344,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
@@ -425,44 +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()
@@ -527,9 +535,7 @@ export class JSORMBase {
       if (attrs.hasOwnProperty(key)) {
         let attributeName = key
 
-        if (this.klass.camelizeKeys) {
-          attributeName = camelize(key, false)
-        }
+        attributeName = this.klass.deserializeKey(key)
 
         if (key === "id" || this.klass.attributeList[attributeName]) {
           ;(<any>this)[attributeName] = attrs[key]
@@ -754,6 +760,34 @@ export class JSORMBase {
     return this.baseClass
   }
 
+  static serializeKey(key: string): string {
+    switch (this.keyCase.server) {
+      case "dash": {
+        return dasherize(underscore(key))
+      }
+      case "snake": {
+        return underscore(key)
+      }
+      case "camel": {
+        return camelize(underscore(key), false)
+      }
+    }
+  }
+
+  static deserializeKey(key: string): string {
+    switch (this.keyCase.client) {
+      case "dash": {
+        return dasherize(underscore(key))
+      }
+      case "snake": {
+        return underscore(key)
+      }
+      case "camel": {
+        return camelize(underscore(key), false)
+      }
+    }
+  }
+
   async destroy(): Promise<boolean> {
     const url = this.klass.url(this.id)
     const verb = "delete"
@@ -853,4 +887,4 @@ export const isModelInstance = (arg: any): arg is JSORMBase => {
     return false
   }
   return isModelClass(arg.constructor.currentClass)
-}
+}

src/util/deserialize.ts

@@ -1,6 +1,5 @@
 import { JsonapiTypeRegistry } from "../jsonapi-type-registry"
 import { JSORMBase } from "../model"
-import { camelize } from "inflected"
 import {
   IncludeDirective,
   IncludeScopeHash,
@@ -236,11 +235,7 @@ class Deserializer {
   ) {
     for (const key in relationships) {
       if (relationships.hasOwnProperty(key)) {
-        let relationName = key
-
-        if (instance.klass.camelizeKeys) {
-          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

@@ -1,5 +1,4 @@
 import { JSORMBase } from "../model"
-import { camelize } from "inflected"
 import { JsonapiResponseDoc, JsonapiErrorMeta } from "../jsonapi-spec"
 
 export class ValidationErrors {
@@ -41,11 +40,7 @@ export class ValidationErrors {
     errorsAccumulator: Record<string, string>,
     meta: JsonapiErrorMeta
   ) {
-    let attribute = meta.attribute
-
-    if (this.model.klass.camelizeKeys) {
-      attribute = camelize(attribute, false)
-    }
+    let attribute = this.model.klass.deserializeKey(meta.attribute)
 
     errorsAccumulator[attribute] = meta.message
   }

src/util/write-payload.ts

@@ -2,7 +2,6 @@ import { JSORMBase, ModelRecord } from "../model"
 import { IncludeDirective, IncludeScopeHash } from "./include-directive"
 import { IncludeScope } from "../scope"
 import { tempId } from "./temp-id"
-import { underscore } from "inflected"
 import {
   JsonapiRequestDoc,
   JsonapiResourceIdentifier,
@@ -33,10 +32,8 @@ export class WritePayload<T extends JSORMBase> {
     const attrs: ModelRecord<T> = {}
 
     this._eachAttribute((key, value) => {
-      const snakeKey = underscore(key)
-
       if (!this.model.isPersisted || this.model.changes()[key]) {
-        attrs[snakeKey] = value
+        attrs[this.model.klass.serializeKey(key)] = value
       }
     })
 
@@ -88,8 +85,8 @@ export class WritePayload<T extends JSORMBase> {
       const nested = (<any>this.includeDirective)[key]
 
       let idOnly = false
-      if (key.indexOf('.') > -1) {
-        key = key.split('.')[0]
+      if (key.indexOf(".") > -1) {
+        key = key.split(".")[0]
         idOnly = true
       }
 
@@ -101,8 +98,8 @@ export class WritePayload<T extends JSORMBase> {
           relatedModels.forEach(relatedModel => {
             if (
               idOnly ||
-                this.model.hasDirtyRelation(key, relatedModel) ||
-                relatedModel.isDirty(nested)
+              this.model.hasDirtyRelation(key, relatedModel) ||
+              relatedModel.isDirty(nested)
             ) {
               data.push(this._processRelatedModel(relatedModel, nested, idOnly))
             }
@@ -115,15 +112,15 @@ export class WritePayload<T extends JSORMBase> {
           // (maybe the "department" is not dirty, but the employee changed departments
           if (
             idOnly ||
-              this.model.hasDirtyRelation(key, relatedModels) ||
-              relatedModels.isDirty(nested)
+            this.model.hasDirtyRelation(key, relatedModels) ||
+            relatedModels.isDirty(nested)
           ) {
             data = this._processRelatedModel(relatedModels, nested, idOnly)
           }
         }
 
         if (data) {
-          _relationships[underscore(key)] = { data }
+          _relationships[this.model.klass.serializeKey(key)] = { data }
         }
       }
     })
@@ -169,7 +166,11 @@ export class WritePayload<T extends JSORMBase> {
 
   // private
 
-  private _processRelatedModel(model: T, nested: IncludeScopeHash, idOnly: boolean) {
+  private _processRelatedModel(
+    model: T,
+    nested: IncludeScopeHash,
+    idOnly: boolean
+  ) {
     model.clearErrors()
 
     if (!model.isPersisted) {

test/fixtures.ts

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

test/integration/relations.test.ts

@@ -97,7 +97,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",
@@ -107,7 +107,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

@@ -23,7 +23,7 @@ const resetMocks = () => {
             status: "422",
             title: "Validation Error",
             detail: "Last Name cannot be blank",
-            meta: { attribute: "last_name", message: "cannot be blank" }
+            meta: { attribute: "last-name", message: "cannot be blank" }
           },
           {
             code: "unprocessable_entity",
@@ -122,13 +122,13 @@ describe("validations", () => {
     })
   })
 
-  describe("when camelizeKeys is false", () => {
+  describe("when keyCase.to is snake", () => {
     beforeEach(() => {
-      instance.klass.camelizeKeys = false
+      instance.klass.keyCase.client = "snake"
     })
 
     afterEach(() => {
-      instance.klass.camelizeKeys = true
+      instance.klass.keyCase.client = "camel"
     })
 
     it("does not camelize the error keys", async () => {

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.server).to.eq("snake")
+        expect(TestModel.keyCase.client).to.eq("camel")
       })
 
       it("correctly assigns options", () => {

test/unit/model-attributes.test.ts

@@ -20,7 +20,12 @@ describe("Model attributes", () => {
     expect(person.firstName).to.eq("Joe")
   })
 
-  it("does not camlize underscored strings if camelization is disabled", () => {
+  it("camelizes dasherized strings", function() {
+    const person = new Person({ "first-name": "Joe" })
+    expect(person.firstName).to.eq("Joe")
+  })
+
+  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
         })
       })