@exodus/atoms 3.4.0 → 3.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/atoms",
-  "version": "3.4.0",
+  "version": "3.5.0",
   "main": "src/index.js",
   "author": "Exodus Movement Inc.",
   "scripts": {
@@ -24,6 +24,7 @@
     "events": "^3.3.0",
     "lodash": "^4.17.21",
     "make-concurrent": ">=4 <6",
+    "minimalistic-assert": "^1.0.1",
     "p-defer": "^4.0.0",
     "proxy-freeze": "^1.0.0"
   },
@@ -33,5 +34,5 @@
     "eslint": "^8.33.0",
     "jest": "^29.1.2"
   },
-  "gitHead": "16e977048c07d7dd898ce0555895c43eb0a5402a"
+  "gitHead": "913199891d798e6fd2970ffda30b2a0ddf5e397c"
 }

package/src/countdown-lock.js

@@ -1,15 +1,22 @@
 import pDefer from 'p-defer'
 
-const createCountdownLock = (n) => {
-  if (typeof n !== 'number' || n <= 0) throw new Error('lock number must be positive')
+const createCountdownLock = (keys) => {
+  if (!Array.isArray(keys)) throw new Error('lock keys must be an array')
+
+  for (const key of keys) {
+    if (typeof key !== 'string') throw new Error(`lock keys must be all strings. Invalid ${key}`)
+  }
 
   const deferred = pDefer()
+
+  const unlockedKeys = []
+
   return {
     promise: deferred.promise,
-    unlock: () => {
-      if (n > 0) n--
+    unlock: (key) => {
+      if (!unlockedKeys.includes(key)) unlockedKeys.push(key)
 
-      if (n <= 0) {
+      if (unlockedKeys.length === keys.length) {
         deferred.resolve()
         return true
       }

package/src/enhancers/combine.js

@@ -4,7 +4,7 @@ import createSimpleObserver from '../simple-observer'
 
 const combine = (atoms) => {
   const { notify, observe } = createSimpleObserver()
-  const countdownLock = createCountdownLock(Object.keys(atoms).length)
+  const countdownLock = createCountdownLock(Object.keys(atoms))
 
   let values = {}
 
@@ -14,7 +14,7 @@ const combine = (atoms) => {
         ...values,
         [name]: value,
       }
-      if (countdownLock.unlock()) await notify(values)
+      if (countdownLock.unlock(name)) await notify(values)
     })
   }
 

package/src/factories/sequenced-keystore.js

@@ -0,0 +1,108 @@
+import assert from 'minimalistic-assert'
+
+import enforceObservableRules from '../enforce-rules'
+import createSimpleObserver from '../simple-observer'
+
+const getRange = (offset, length) => Array.from({ length }, (_, i) => i + offset)
+
+const createSequencedKeystoreAtom = ({
+  keystore,
+  config: {
+    //
+    key,
+    separator = '.',
+    defaultValue = [],
+    isSoleWriter,
+    getOpts,
+    setOpts,
+    deleteOpts,
+  },
+}) => {
+  assert(key, 'sequence keystore atom: key missing')
+
+  assert(typeof key === 'string', 'sequence keystore atom: key must be a string')
+
+  assert(Array.isArray(defaultValue), 'sequence keystore atom: default value must be an array')
+
+  const { notify, observe } = createSimpleObserver({ enable: isSoleWriter })
+
+  let cache
+
+  const getKey = (index) =>
+    key.endsWith(separator) ? `${key}${index}` : `${key}${separator}${index}`
+
+  const getByIndex = async (index) => {
+    const key = getKey(index)
+    const value = await keystore.getSecret(key, getOpts)
+    if (value) return { key, value }
+  }
+
+  const list = async () => {
+    let result = []
+    let batch = []
+    let offset = 0
+    const batchSize = 5
+
+    // paginate until we're out of items
+    do {
+      const range = getRange(offset, batchSize)
+      batch = await Promise.all(range.map(getByIndex))
+      batch = batch.filter(Boolean)
+      result = [...result, ...batch]
+      offset += batchSize
+    } while (batch.length > 0)
+
+    return result
+  }
+
+  const clear = async () => {
+    const items = await list()
+    await Promise.all(items.map((item) => keystore.deleteSecret(item.key, deleteOpts)))
+  }
+
+  const _set = async (value) => {
+    assert(Array.isArray(value), 'sequence keystore atom: set value must be an array')
+
+    await Promise.all(
+      value.map((value, index) => {
+        return keystore.setSecret(getKey(index), value, setOpts)
+      })
+    )
+  }
+
+  const set = async (value) => {
+    await clear()
+
+    if (value != null) {
+      await _set(value)
+    }
+
+    if (isSoleWriter) {
+      cache = value
+      await notify(value)
+    }
+  }
+
+  const get = async () => {
+    if (cache) return cache
+
+    const items = await list()
+    const value = items.map((item) => item.value)
+
+    if (isSoleWriter) {
+      cache = value
+    }
+
+    // let default value be used
+    return items.length === 0 ? undefined : value
+  }
+
+  return enforceObservableRules({
+    get,
+    set,
+    observe,
+    defaultValue,
+  })
+}
+
+export default createSequencedKeystoreAtom

package/src/index.js

@@ -5,6 +5,7 @@ export { default as createStorageAtomFactory } from './factories/storage'
 export { default as createLocalConfigAtomFactory } from './factories/local-config'
 export { default as createRemoteConfigAtomFactory } from './factories/remote-config'
 export { default as createKeystoreAtom } from './factories/keystore'
+export { default as createSequencedKeystoreAtom } from './factories/sequenced-keystore'
 export { default as fromEventEmitter } from './event-emitter'
 export { default as compute } from './enhancers/compute'
 export { default as blockUntil } from './enhancers/block-until'