Merge pull request #89 from wadetandy/master

Always delegate JWT to storage backend

Author: wadetandy

src/credential-storage.ts

@@ -4,15 +4,21 @@ export interface StorageBackend {
   removeItem(key: string): void
 }
 
-export class NullStorageBackend implements StorageBackend {
-  getItem(key: string) {
-    return null
+export class InMemoryStorageBackend implements StorageBackend {
+  private _data : Record<string, string | undefined>
+
+  constructor() {
+    this._data = {}
+  }
+
+  getItem(key: string) : string | null {
+    return this._data[key] || null // Cast undefined to null
   }
   setItem(key: string, value: string | undefined) {
-    /*noop*/
+    this._data[key] = value
   }
   removeItem(key: string) {
-    /*noop*/
+    delete this._data[key]
   }
 }
 
@@ -22,36 +28,34 @@ let defaultBackend: StorageBackend
 try {
   defaultBackend = localStorage
 } catch (e) {
-  defaultBackend = new NullStorageBackend()
+  defaultBackend = new InMemoryStorageBackend()
 }
 
 export class CredentialStorage {
-  private _jwtKey: string | false
+  private _jwtKey: string
   private _backend: StorageBackend
 
   constructor(
-    jwtKey: string | false,
+    jwtKey: string,
     backend: StorageBackend = defaultBackend
   ) {
     this._jwtKey = jwtKey
     this._backend = backend
   }
 
-  getJWT(): string | null {
-    if (this._jwtKey) {
-      return this._backend.getItem(this._jwtKey)
-    } else {
-      return null
-    }
+  get backend() : StorageBackend {
+    return this._backend
+  }
+
+  getJWT(): string | undefined {
+    return this._backend.getItem(this._jwtKey) || undefined
   }
 
   setJWT(value: string | undefined | null): void {
-    if (this._jwtKey) {
-      if (value) {
-        this._backend.setItem(this._jwtKey, value)
-      } else {
-        this._backend.removeItem(this._jwtKey)
-      }
+    if (value) {
+      this._backend.setItem(this._jwtKey, value)
+    } else {
+      this._backend.removeItem(this._jwtKey)
     }
   }
 }

src/model.ts

@@ -8,7 +8,7 @@ import { WritePayload } from "./util/write-payload"
 import { flipEnumerable, getNonEnumerables } from "./util/enumerables"
 import {
   CredentialStorage,
-  NullStorageBackend,
+  InMemoryStorageBackend,
   StorageBackend
 } from "./credential-storage"
 import { IDMap } from "./id-map"
@@ -53,6 +53,7 @@ export interface ModelConfiguration {
   apiNamespace: string
   jsonapiType: string
   endpoint: string
+  credentialStorageBackend: StorageBackend,
   jwt: string
   jwtStorage: string | false
   keyCase: KeyCase
@@ -117,6 +118,26 @@ export const applyModelConfig = <T extends typeof JSORMBase>(
 ): void => {
   let k: keyof ModelConfigurationOptions
 
+  config = { ...config } // clone since we're going to mutate it
+
+  // Handle all JWT configuration at once since it's run-order dependent
+  // We'll delete each key we encounter then pass the rest off to 
+  // a loop for assigning other arbitrary options
+  if (config.credentialStorageBackend) {
+    ModelClass.credentialStorageBackend = config.credentialStorageBackend
+    delete config.jwtStorage
+  }
+
+  if (config.jwtStorage) {
+    ModelClass.jwtStorage = config.jwtStorage
+    delete config.jwtStorage
+  }
+
+  if (config.jwt) {
+    ModelClass.setJWT(config.jwt)
+    delete config.jwt
+  }
+
   for (k in config) {
     if (config.hasOwnProperty(k)) {
       ModelClass[k] = config[k]
@@ -136,7 +157,6 @@ export class JSORMBase {
   static jsonapiType?: string
   static endpoint: string
   static isBaseClass: boolean
-  static jwt?: string
   static keyCase: KeyCase = { server: "snake", client: "camel" }
   static strictAttributes: boolean = false
   static logger: ILogger = defaultLogger
@@ -148,36 +168,48 @@ export class JSORMBase {
   static currentClass: typeof JSORMBase = JSORMBase
   static beforeFetch: BeforeFilter | undefined
   static afterFetch: AfterFilter | undefined
-  static jwtStorage: string | false = "jwt"
 
   private static _typeRegistry: JsonapiTypeRegistry
   private static _IDMap: IDMap
   private static _middlewareStack: MiddlewareStack
-  private static _credentialStorageBackend?: StorageBackend
-  private static _credentialStorage?: CredentialStorage
+  private static _credentialStorageBackend: StorageBackend
+  private static _credentialStorage: CredentialStorage
+  private static _jwtStorage: string | false = "jwt"
 
   static get credentialStorage(): CredentialStorage {
-    if (!this._credentialStorage) {
-      if (!this._credentialStorageBackend) {
-        if (this.jwtStorage && typeof localStorage !== "undefined") {
-          this._credentialStorageBackend = localStorage
-        } else {
-          this._credentialStorageBackend = new NullStorageBackend()
-        }
-      }
+    return this._credentialStorage
+  }
 
-      this._credentialStorage = new CredentialStorage(
-        this.jwtStorage,
-        this._credentialStorageBackend
-      )
+  static set jwtStorage(val : string | false) {
+    if (val !== this._jwtStorage) {
+      this._jwtStorage = val
+      this.credentialStorageBackend = this._credentialStorageBackend
     }
+  }
 
-    return this._credentialStorage
+  static get jwtStorage() : string | false {
+    return this._jwtStorage
   }
 
-  static set credentialStorageBackend(backend: StorageBackend | undefined) {
+  static set credentialStorageBackend(backend: StorageBackend) {
     this._credentialStorageBackend = backend
-    this._credentialStorage = undefined
+
+    this._credentialStorage = new CredentialStorage(
+      this.jwtStorage || 'jwt',
+      this._credentialStorageBackend
+    )
+  }
+
+  static get credentialStorageBackend() : StorageBackend {
+    return this._credentialStorageBackend
+  }
+
+  static initializeCredentialStorage() {
+    if (this.jwtStorage && typeof localStorage !== "undefined") {
+      this.credentialStorageBackend = localStorage
+    } else {
+      this.credentialStorageBackend = new InMemoryStorageBackend()
+    }
   }
 
   /*
@@ -228,9 +260,6 @@ export class JSORMBase {
     if (!this._IDMap) {
       this._IDMap = new IDMap()
     }
-
-    const jwt = this.credentialStorage.getJWT()
-    this.setJWT(jwt)
   }
 
   static isSubclassOf(maybeSuper: typeof JSORMBase): boolean {
@@ -753,22 +782,16 @@ export class JSORMBase {
   }
 
   static setJWT(token: string | undefined | null): void {
-    if (this.baseClass === undefined) {
-      throw new Error(`Cannot set JWT on ${this.name}: No base class present.`)
-    }
-
-    this.baseClass.jwt = token || undefined
     this.credentialStorage.setJWT(token)
   }
 
   static getJWT(): string | undefined {
-    const owner = this.baseClass
-
-    if (owner) {
-      return owner.jwt
-    }
+    return this.credentialStorage.getJWT()
   }
 
+  static get jwt(): string | undefined { return this.getJWT() }
+  static set jwt(token: string | undefined) { this.setJWT(token) }
+
   static generateAuthHeader(jwt: string): string {
     return `Token token="${jwt}"`
   }
@@ -897,6 +920,7 @@ export class JSORMBase {
 }
 
 ;(<any>JSORMBase.prototype).klass = JSORMBase
+JSORMBase.initializeCredentialStorage()
 
 export const isModelClass = (arg: any): arg is typeof JSORMBase => {
   if (!arg) {