@exodus/atoms 3.4.1 → 3.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/atoms",
-  "version": "3.4.1",
+  "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": "0c9ed53bfe02b1d0dc0666bc83c0bd1dcd8f5e36"
+  "gitHead": "913199891d798e6fd2970ffda30b2a0ddf5e397c"
 }

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'