Nice to have changes (more in CHANGELOG.md)

Author: Eneris

CHANGELOG.md

@@ -1 +1,5 @@
-### TODO
+# Changelog
+## 0.2.0
+ - `fetchAndActivate` now locks semaphore to prevent concurent fetch attempts
+ - Added timer to auto fetch config when cache expires
+ - Added `asConverted` on `Value` and `getAllConverted` on `RemoteConfig` which returns auto-converted values

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eneris/firebase-nodejs-client",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Firebase NodeJS client",
   "author": "Eneris<[email protected]>",
   "license": "Apache-2.0",

src/lib/remoteConfig.ts

@@ -41,6 +41,8 @@ export default class RemoteConfig<T = Record<string, string>> extends EventEmitt
     private readonly options: RemoteConfigOptions<T>
     private readonly storage: StorageInterface<RemoteConfigStore<T>>
     private readonly request: AxiosInstance
+    private refreshTimer: NodeJS.Timer
+    private semaphoreFetch: Promise<void>
 
     constructor(app: FirebaseApp, options: RemoteConfigOptions<T> = {}) {
         super()
@@ -69,12 +71,9 @@ export default class RemoteConfig<T = Record<string, string>> extends EventEmitt
             set: (key, value) => this.app.storage.set(storagePrefix + key, value),
         } as StorageInterface<RemoteConfigStore<T>>
 
-        this.on('fetch', () => console.log('Constructor - fetch'))
-        this.on('activate', () => console.log('Constructor - activate'))
-    }
+        this.fetchAndActivate()
 
-    get defaultConfig() {
-        return this.options.defaultConfig
+        this.refreshTimer = setInterval(this.fetchAndActivate, this.options.cacheMaxAge + 1000)
     }
 
     get isCacheValid() {
@@ -83,68 +82,75 @@ export default class RemoteConfig<T = Record<string, string>> extends EventEmitt
         return this.storage.get('config') && cacheAge < this.options.cacheMaxAge
     }
 
-    getActiveConfig(): T {
+    get defaultConfig() {
+        return this.options.defaultConfig
+    }
+
+    private get activeConfig() {
         return this.storage.get('config')
     }
 
-    getDefaultConfig(): T {
-        return this.options.defaultConfig
+    set defaultConfig(defaultConfig: RemoteConfigOptions<T>['defaultConfig']) {
+        this.options.defaultConfig = defaultConfig
     }
 
     getValue<K extends keyof T>(key: K): Value {
-        const config = this.getActiveConfig()
+        const config = this.activeConfig
 
+        // Has remote version
         if (config && config[key] !== undefined) {
-            return new Value('remote', String(config[key]))
+            return new Value('remote', config[key] as string)
         }
 
-        const defaultConfig = this.getDefaultConfig()
+        const defaultConfig = this.defaultConfig
 
+        // Has default version
         if (defaultConfig && defaultConfig[key] !== undefined) {
-            return new Value('default', String(defaultConfig[key]))
+            return new Value('default', defaultConfig[key] as string)
         }
 
+        // Not found, return static
         return new Value('static')
     }
 
-    getAll() {
+    getAll(): Record<string, Value> {
         const config = {
-            ...(this.getActiveConfig() || {}),
-            ...(this.getDefaultConfig() || {})
+            ...(this.activeConfig || {}),
+            ...(this.defaultConfig || {})
         }
 
         return Object.keys(config).reduce((result, key) => {
             result[key] = this.getValue(key as keyof T)
+
             return result
         }, {})
     }
 
-    getBoolean<K extends keyof T>(key: K): boolean {
-        return this.getValue(key).asBoolean()
-    }
-
-    getNumber<K extends keyof T>(key: K): number {
-        return this.getValue(key).asNumber()
-    }
+    getAllConverted(): T {
+        const config = this.getAll()
 
-    getString<K extends keyof T>(key: K): string {
-        return this.getValue(key).asString()
-    }
+        Object.keys(config).forEach((key) => {
+            config[key] = config[key].asConverted()
+        })
 
-    getJSON<K extends keyof T, V = Record<string, unknown>>(key: K): V {
-        return this.getValue(key).asJSON<V>()
+        return config as T
     }
 
     async fetchAndActivate(ignoreCache = false): Promise<void> {
         const etag = this.storage.get('etag')
 
-
         if (!ignoreCache && this.isCacheValid) {
             this.emit('fetch')
-            console.log('config cache is valid')
             return Promise.resolve()
         }
 
+        if (this.semaphoreFetch) {
+            return this.semaphoreFetch;
+        }
+
+        let resolveSemaphore = null
+        this.semaphoreFetch = new Promise((res) => { resolveSemaphore = res })
+
         const installation = await this.installations.getInstallation()
 
         const response = await this.request.post(`:fetch`, {
@@ -212,5 +218,9 @@ export default class RemoteConfig<T = Record<string, string>> extends EventEmitt
                 throw new Error(`Failed to fetch RemoteConfig status: ${status}`)
 
         }
+
+        this.semaphoreFetch = null
+
+        resolveSemaphore?.()
     }
 }

src/utils/storage.ts

@@ -1,6 +1,6 @@
 export interface StorageInterface<T = Record<string, any>> {
     get<K extends keyof T>(key: K): T[K]
-    set<K extends keyof T>(key: K, value: T[K]): this
+    set<K extends keyof T>(key: K, value: T[K]): void
 }
 
 export default class MemoryStorage<T = Record<string, any>> implements StorageInterface<T> {
@@ -12,6 +12,5 @@ export default class MemoryStorage<T = Record<string, any>> implements StorageIn
 
     set(key, value) {
         this.data[key] = value
-        return this
     }
 }

src/utils/value.ts

@@ -56,13 +56,39 @@ export default class Value {
     }
 
     asJSON<T = Record<string, unknown>>(): T {
+        if (typeof this._value !== 'string') {
+            return this._value
+        }
+
         try {
             return JSON.parse(this._value) as T
         } catch {
             return null
         }
     }
 
+    asConverted(): any {
+        if (typeof this._value !== 'string') {
+            return this._value
+        }
+
+        if (['true', 'false'].includes(this._value)) {
+            return Boolean(this._value)
+        }
+
+        const asNumber = Number(this._value)
+
+        if (asNumber !== NaN) {
+            return asNumber
+        }
+
+        try {
+            return JSON.parse(this._value)
+        } catch {
+            return this._value
+        }
+    }
+
     getSource(): ValueSource {
         return this._source
     }

wiki/RemoteConfig.md

@@ -8,3 +8,4 @@
 - `fetchAndActivate` - attempts to download config from remote server if cache is missing or invalid
 - `getValue` - Returns instance of [`Value`](Value.md) for given key
 - `getAll` - Returns all properties as collection of [`Value`](Value.md) instances
+- `getAllConverted` - Returns all properties converted into their "best guess" types