@exodus/atoms 5.7.3 → 6.0.0

package/lib/factories/memory.js

@@ -0,0 +1,35 @@
+import EventEmitter from 'events/';
+import fromEventEmitter from '../event-emitter';
+import pDefer from 'p-defer';
+const createAtomMock = (options = {}) => {
+    const { defaultValue } = options;
+    let latestValue = defaultValue;
+    const emitter = new EventEmitter();
+    emitter.setMaxListeners(Number.POSITIVE_INFINITY);
+    const initialized = pDefer();
+    const get = async () => {
+        if (!('defaultValue' in options)) {
+            await initialized.promise;
+        }
+        return latestValue;
+    };
+    const set = async (data) => {
+        latestValue = data;
+        if (data !== undefined) {
+            initialized.resolve();
+            initialized.resolved = true;
+        }
+        if (initialized.resolved) {
+            emitter.emit('data', data);
+        }
+    };
+    return fromEventEmitter({
+        ...options,
+        getInitialized: () => initialized.resolved,
+        emitter,
+        event: 'data',
+        get,
+        set,
+    });
+};
+export default createAtomMock;

package/lib/factories/observer.d.ts

@@ -0,0 +1,13 @@
+import { Atom, Port } from '../utils/types';
+type Params<T> = {
+    atom: Atom<T>;
+    port: Port<T>;
+    event: string;
+    immediateRegister?: boolean;
+};
+declare const createAtomObserver: <T>({ port, atom, event, immediateRegister }: Params<T>) => {
+    register: () => void;
+    unregister: () => void;
+    start: () => Promise<void>;
+};
+export default createAtomObserver;

package/lib/factories/observer.js

@@ -0,0 +1,28 @@
+const createAtomObserver = ({ port, atom, event, immediateRegister = true }) => {
+    let emitting = false;
+    let unobserve;
+    const register = () => {
+        if (unobserve)
+            return;
+        unobserve = atom.observe((value) => {
+            if (emitting)
+                port.emit(event, value);
+        });
+    };
+    const unregister = () => {
+        unobserve?.();
+    };
+    const start = async () => {
+        emitting = true;
+        port.emit(event, await atom.get());
+    };
+    if (immediateRegister) {
+        register();
+    }
+    return {
+        register,
+        unregister,
+        start,
+    };
+};
+export default createAtomObserver;

package/lib/factories/remote-config.d.ts

@@ -0,0 +1,13 @@
+import type { RemoteConfigType } from '@exodus/remote-config';
+type FactoryParams = {
+    remoteConfig: RemoteConfigType;
+};
+type Params<T> = {
+    defaultValue?: T;
+} & ({
+    path: string;
+} | {
+    selector: (config: object) => T;
+});
+declare const createRemoteConfigAtomFactory: ({ remoteConfig }: FactoryParams) => <T>({ defaultValue, ...params }: Params<T>) => import("../utils/types").Atom<T>;
+export default createRemoteConfigAtomFactory;

package/lib/factories/remote-config.js

@@ -0,0 +1,34 @@
+import { get as getValueAtPath, isEqual } from 'lodash';
+import createSimpleObserver from '../simple-observer';
+import enforceObservableRules from '../enforce-rules';
+const createRemoteConfigAtomFactory = ({ remoteConfig }) => ({ defaultValue, ...params }) => {
+    if ('path' in params && 'selector' in params) {
+        throw new Error('Provide either a path or a selector to get data from remote config - not both.');
+    }
+    const getValue = (value) => 'path' in params ? getValueAtPath(value, params.path) : params.selector(value);
+    const { notify, observe } = createSimpleObserver();
+    const get = async () => {
+        const data = await remoteConfig.getAll();
+        return getValue(data);
+    };
+    const set = async () => {
+        throw new Error('remoteConfig is read-only');
+    };
+    remoteConfig.on('sync', async ({ current }) => {
+        const data = getValue(current);
+        return notify(data);
+    });
+    const observeDistinct = (callback) => observe(function (value) {
+        if (isEqual(this.lastValue, value))
+            return;
+        this.lastValue = value;
+        callback(value);
+    }.bind({}));
+    return enforceObservableRules({
+        get,
+        set,
+        observe: observeDistinct,
+        defaultValue,
+    });
+};
+export default createRemoteConfigAtomFactory;

package/lib/factories/sequenced-keystore.d.ts

@@ -0,0 +1,15 @@
+import { Keystore, KeystoreValue } from '../utils/types';
+type Params = {
+    keystore: Keystore;
+    config: {
+        key: string;
+        getOpts?: object;
+        setOpts?: object;
+        deleteOpts?: object;
+        separator?: string;
+        isSoleWriter?: boolean;
+        defaultValue?: KeystoreValue[];
+    };
+};
+declare const createSequencedKeystoreAtom: ({ keystore, config: { key, separator, defaultValue, isSoleWriter, getOpts, setOpts, deleteOpts, }, }: Params) => import("../utils/types").Atom<KeystoreValue[] | undefined>;
+export default createSequencedKeystoreAtom;

package/lib/factories/sequenced-keystore.js

@@ -0,0 +1,71 @@
+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;
+        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 !== undefined) {
+            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;
+        }
+        return items.length === 0 ? undefined : value;
+    };
+    return enforceObservableRules({
+        get,
+        set,
+        observe,
+        defaultValue,
+    });
+};
+export default createSequencedKeystoreAtom;

package/lib/factories/storage.d.ts

@@ -0,0 +1,12 @@
+import { Atom } from '../utils/types';
+import { Storage } from '@exodus/storage-interface';
+type FactoryParams<T> = {
+    storage: Storage<T>;
+};
+type Params<T> = {
+    key: string;
+    defaultValue?: T;
+    isSoleWriter?: boolean;
+};
+declare const createStorageAtomFactory: <T>({ storage }: FactoryParams<T>) => ({ key, defaultValue, isSoleWriter }: Params<T>) => Atom<T | undefined>;
+export default createStorageAtomFactory;

package/lib/factories/storage.js

@@ -0,0 +1,46 @@
+import createSimpleObserver from '../simple-observer';
+import enforceObservableRules from '../enforce-rules';
+import pDefer from 'p-defer';
+const createStorageAtomFactory = ({ storage }) => ({ key, defaultValue, isSoleWriter }) => {
+    const { notify, observe } = createSimpleObserver({ enable: isSoleWriter });
+    let cached;
+    let writePromiseDefer;
+    const set = async (value) => {
+        if (value === undefined) {
+            writePromiseDefer = pDefer();
+            await storage.delete(key);
+        }
+        else {
+            writePromiseDefer = pDefer();
+            await storage.set(key, value);
+        }
+        writePromiseDefer.resolve();
+        if (isSoleWriter) {
+            cached = value;
+            await notify(value);
+        }
+    };
+    const get = async () => {
+        if (cached) {
+            return cached;
+        }
+        if (writePromiseDefer) {
+            await writePromiseDefer.promise;
+        }
+        if (cached) {
+            return cached;
+        }
+        const value = await storage.get(key);
+        if (isSoleWriter) {
+            cached = value;
+        }
+        return value;
+    };
+    return enforceObservableRules({
+        get,
+        set,
+        observe,
+        defaultValue,
+    });
+};
+export default createStorageAtomFactory;

package/lib/index.d.ts

@@ -0,0 +1,22 @@
+export { default as createAtomMock } from './factories/memory';
+export { default as createInMemoryAtom } from './factories/memory';
+export { default as createStorageAtomFactory } from './factories/storage';
+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 createAtomObserver } from './factories/observer';
+export { default as compute } from './enhancers/compute';
+export { default as blockUntil } from './enhancers/block-until';
+export { default as difference } from './enhancers/difference';
+export { default as withSerialization } from './enhancers/with-serialization';
+export { default as combine } from './enhancers/combine';
+export { default as readOnly } from './enhancers/read-only';
+export { default as dedupe } from './enhancers/dedupe';
+export { default as warnOnSameValueSet } from './enhancers/warn-on-same-value-set';
+export { default as swallowObserverErrors } from './enhancers/swallow-observer-errors';
+export { default as timeoutObservers } from './enhancers/timeout-observers';
+export { default as optimisticNotifier } from './enhancers/optimistic-notifier';
+export { default as waitUntil } from './effects/wait-until';
+export { default as enforceObservableRules } from './enforce-rules';
+export { default as fromEventEmitter } from './event-emitter';
+export { Atom, ReadonlyAtom, Listener, Unsubscribe } from './utils/types';

package/{src → lib}/index.js

@@ -1,24 +1,21 @@
-export { default as createAtomMock } from './factories/memory'
-export { default as createInMemoryAtom } from './factories/memory'
-export { default as createStorageAtomFactory } from './factories/storage'
-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 createAtomObserver } from './factories/observer'
-
-export { default as compute } from './enhancers/compute'
-export { default as blockUntil } from './enhancers/block-until'
-export { default as difference } from './enhancers/difference'
-export { default as withSerialization } from './enhancers/with-serialization'
-export { default as combine } from './enhancers/combine'
-export { default as readOnly } from './enhancers/read-only'
-export { default as dedupe } from './enhancers/dedupe'
-export { default as warnOnSameValueSet } from './enhancers/warn-on-same-value-set'
-export { default as swallowObserverErrors } from './enhancers/swallow-observer-errors'
-export { default as timeoutObservers } from './enhancers/timeout-observers'
-export { default as optimisticNotifier } from './enhancers/optimistic-notifier'
-
-export { default as waitUntil } from './effects/wait-until'
-
-export { default as enforceObservableRules } from './enforce-rules'
-export { default as fromEventEmitter } from './event-emitter'
+export { default as createAtomMock } from './factories/memory';
+export { default as createInMemoryAtom } from './factories/memory';
+export { default as createStorageAtomFactory } from './factories/storage';
+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 createAtomObserver } from './factories/observer';
+export { default as compute } from './enhancers/compute';
+export { default as blockUntil } from './enhancers/block-until';
+export { default as difference } from './enhancers/difference';
+export { default as withSerialization } from './enhancers/with-serialization';
+export { default as combine } from './enhancers/combine';
+export { default as readOnly } from './enhancers/read-only';
+export { default as dedupe } from './enhancers/dedupe';
+export { default as warnOnSameValueSet } from './enhancers/warn-on-same-value-set';
+export { default as swallowObserverErrors } from './enhancers/swallow-observer-errors';
+export { default as timeoutObservers } from './enhancers/timeout-observers';
+export { default as optimisticNotifier } from './enhancers/optimistic-notifier';
+export { default as waitUntil } from './effects/wait-until';
+export { default as enforceObservableRules } from './enforce-rules';
+export { default as fromEventEmitter } from './event-emitter';

package/lib/simple-observer.d.ts

@@ -0,0 +1,8 @@
+import { Listener } from './utils/types';
+declare const createSimpleObserver: <T>({ enable }?: {
+    enable?: boolean | undefined;
+}) => {
+    observe: (listener: Listener<T>) => () => void;
+    notify: (value: T) => Promise<void[]>;
+};
+export default createSimpleObserver;

package/lib/simple-observer.js

@@ -0,0 +1,18 @@
+const createSimpleObserver = ({ enable = true } = {}) => {
+    let listeners = [];
+    const notify = async (value) => Promise.all(listeners.map((listener) => listener(value)));
+    const observe = (listener) => {
+        if (!enable) {
+            throw new Error('observe method is not supported');
+        }
+        listeners.push(listener);
+        return () => {
+            listeners = listeners.filter((fn) => fn !== listener);
+        };
+    };
+    return {
+        observe,
+        notify,
+    };
+};
+export default createSimpleObserver;

package/lib/utils/guards.d.ts

@@ -0,0 +1,2 @@
+import { Setter } from './types';
+export declare function isSetter<T>(value: T | Setter<T>): value is Setter<T>;

package/lib/utils/guards.js

@@ -0,0 +1,3 @@
+export function isSetter(value) {
+    return typeof value === 'function';
+}

package/lib/utils/types.d.ts

@@ -0,0 +1,24 @@
+export type Unsubscribe = () => void;
+export type Listener<T> = (value: T) => Promise<void> | void;
+export interface EventEmitter {
+    on<T>(event: string, listener: Listener<T>): void;
+    removeListener<T>(event: string, listener: Listener<T>): void;
+}
+export type Setter<T> = (prev: T) => T | Promise<T>;
+export interface Atom<T> {
+    get(): Promise<T>;
+    set(value: T): Promise<void>;
+    set(setter: Setter<T>): Promise<void>;
+    observe(listener: Listener<T>): Unsubscribe;
+}
+export type ReadonlyAtom<T> = Omit<Atom<T>, 'set'>;
+export type KeystoreValue = string | number;
+export interface Port<T> {
+    emit(event: string, value: T): void;
+}
+export interface Keystore {
+    getSecret(key: string, options?: object): Promise<KeystoreValue>;
+    setSecret(key: string, value: KeystoreValue, options?: object): Promise<void>;
+    deleteSecret(key: string, options?: object): Promise<string>;
+}
+export type Logger = Pick<Console, 'trace' | 'debug' | 'error' | 'info' | 'log' | 'warn'>;

package/lib/utils/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,16 +1,18 @@
 {
   "name": "@exodus/atoms",
-  "version": "5.7.3",
-  "main": "src/index.js",
+  "version": "6.0.0",
+  "main": "lib/index.js",
   "description": "Abstraction for encapsulating a piece of data behind a simple unified interface: get, set, observe",
   "author": "Exodus Movement Inc.",
   "scripts": {
+    "build": "yarn run -T tsc --build tsconfig.build.json",
+    "clean": "yarn run -T tsc --build --clean",
     "test": "jest",
     "lint": "eslint . --ignore-path ../../.gitignore",
     "lint:fix": "yarn lint --fix"
   },
   "files": [
-    "src",
+    "lib",
     "CHANGELOG.md"
   ],
   "repository": {
@@ -23,6 +25,7 @@
     "url": "https://github.com/ExodusMovement/exodus-hydra/issues?q=is%3Aissue+is%3Aopen+label%3Aatoms"
   },
   "dependencies": {
+    "@exodus/storage-interface": "^1.0.0",
     "events": "^3.3.0",
     "lodash": "^4.17.21",
     "make-concurrent": ">=4 <6",
@@ -32,10 +35,13 @@
   },
   "devDependencies": {
     "@exodus/atom-tests": "^1.0.0",
+    "@exodus/remote-config": "^2.3.0",
     "@exodus/storage-memory": "^2.1.1",
+    "@types/lodash": "^4.14.200",
+    "@types/minimalistic-assert": "^1.0.2",
     "delay": "^5.0.0",
     "eslint": "^8.44.0",
     "jest": "^29.1.2"
   },
-  "gitHead": "18791c72d9be2a75aea6621a216c1aed819442ca"
+  "gitHead": "127d91779b91ad17cb1dadbfccb7eb7559ecbf23"
 }

package/src/countdown-lock.js

@@ -1,29 +0,0 @@
-import pDefer from 'p-defer'
-
-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: (key) => {
-      if (!unlockedKeys.includes(key)) unlockedKeys.push(key)
-
-      if (unlockedKeys.length === keys.length) {
-        deferred.resolve()
-        return true
-      }
-
-      return false
-    },
-  }
-}
-
-export default createCountdownLock

package/src/effects/wait-until.js

@@ -1,29 +0,0 @@
-const waitUntil = ({ atom, predicate, rejectAfter }) => {
-  let unobserve
-  let timeout
-  const promise = new Promise((resolve, reject) => {
-    unobserve = atom.observe((v) => {
-      if (predicate(v)) {
-        clearTimeout(timeout)
-        unobserve()
-        resolve(v)
-      }
-    })
-
-    if (rejectAfter) {
-      timeout = setTimeout(() => {
-        unobserve()
-        reject(new Error('rejected by timeout'))
-      }, rejectAfter)
-    }
-  })
-
-  promise.unobserve = () => {
-    unobserve()
-    clearTimeout(timeout)
-  }
-
-  return promise
-}
-
-export default waitUntil

package/src/enforce-rules.js

@@ -1,74 +0,0 @@
-import makeConcurrent from 'make-concurrent'
-import proxyFreeze from 'proxy-freeze'
-
-const withChangeDetection = (listener) => {
-  let currentValue
-  let called = false
-
-  return async (value) => {
-    if (called && value === currentValue) return
-
-    called = true
-    currentValue = value
-
-    await listener(currentValue)
-  }
-}
-
-const enforceObservableRules = ({ defaultValue, getInitialized = () => true, logger, ...atom }) => {
-  // ensure observers get called in series
-  const enqueue = makeConcurrent((fn) => fn(), { concurrency: 1 })
-
-  const postProcessValue = (value = defaultValue) =>
-    value && typeof value === 'object' ? proxyFreeze(value) : value
-
-  const get = () => atom.get().then(postProcessValue)
-
-  const observe = (listener) => {
-    let called = false
-    let valueEmittedFromGet
-    listener = withChangeDetection(listener)
-
-    const publishSerially = (value) => {
-      called = true
-      return enqueue(() => listener(value))
-    }
-
-    // note: call observe() first to give it a chance to throw if it's not supported
-    // if the subscription already fired once, ignore first get
-    get().then((value) => {
-      if (!called) {
-        valueEmittedFromGet = value
-        publishSerially(value)
-      }
-    })
-    return atom.observe((value) => {
-      if (valueEmittedFromGet && value === valueEmittedFromGet) {
-        valueEmittedFromGet = undefined // ignore changes from observe only for first call
-        return
-      }
-
-      return publishSerially(postProcessValue(value))
-    })
-  }
-
-  const set = makeConcurrent(async (value) => {
-    // support a function a la React's setState(oldState => newState)
-    if (typeof value === 'function') {
-      const current = getInitialized() ? await get() : defaultValue
-      value = await value(current)
-
-      if (current === value) return
-    }
-
-    await atom.set(value)
-  })
-
-  return {
-    get,
-    set,
-    observe,
-  }
-}
-
-export default enforceObservableRules

package/src/enhancers/block-until.js

@@ -1,23 +0,0 @@
-export default function blockUntil({ atom, unblock }) {
-  const get = async () => unblock().then(atom.get)
-
-  return {
-    ...atom,
-    get,
-    observe: (callback) => {
-      let isSubscribed = true
-      let unsubscribe = () => {}
-
-      unblock().then(() => {
-        if (isSubscribed) {
-          unsubscribe = atom.observe(callback)
-        }
-      })
-
-      return () => {
-        isSubscribed = false
-        unsubscribe()
-      }
-    },
-  }
-}