@exodus/atoms 8.1.1 → 9.0.0

package/CHANGELOG.md

@@ -3,6 +3,25 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [9.0.0](https://github.com/ExodusMovement/exodus-hydra/compare/@exodus/atoms@8.1.1...@exodus/atoms@9.0.0) (2024-09-26)
+
+### ⚠ BREAKING CHANGES
+
+- remove isSoleWriter from storage atom factory (#9423)
+
+### Features
+
+- don't allow get to proceed after unsubscribe ([#9441](https://github.com/ExodusMovement/exodus-hydra/issues/9441)) ([33bc642](https://github.com/ExodusMovement/exodus-hydra/commit/33bc642ad6ec32e1f31711f9dfe435d235eaca56))
+- remove isSoleWriter from storage atom factory ([#9423](https://github.com/ExodusMovement/exodus-hydra/issues/9423)) ([ab90ee1](https://github.com/ExodusMovement/exodus-hydra/commit/ab90ee13a819058c0f23c37008da2bebf4439157))
+
+### Bug Fixes
+
+- storage atom race condition ([#9403](https://github.com/ExodusMovement/exodus-hydra/issues/9403)) ([bf30d0c](https://github.com/ExodusMovement/exodus-hydra/commit/bf30d0cc90632459b6b0b9fd76fac191d20ddd0b))
+
+### Performance Improvements
+
+- reduce underlying storage reads ([#9418](https://github.com/ExodusMovement/exodus-hydra/issues/9418)) ([f3c0c23](https://github.com/ExodusMovement/exodus-hydra/commit/f3c0c232b120977a27565636f4d1a6ca9fc90b4a))
+
 ## [8.1.1](https://github.com/ExodusMovement/exodus-hydra/compare/@exodus/atoms@8.1.0...@exodus/atoms@8.1.1) (2024-09-09)
 
 ### Bug Fixes

package/lib/effects/wait-until.d.ts

@@ -1,4 +1,4 @@
-import { Atom } from '../utils/types.js';
+import type { Atom } from '../utils/types.js';
 type Params<T> = {
     atom: Atom<T>;
     predicate: (value: T) => boolean;

package/lib/enforce-rules.d.ts

@@ -1,9 +1,9 @@
-import { Atom } from './utils/types.js';
+import type { Atom } from './utils/types.js';
 type Params<T> = {
-    makeGetConcurrent?: boolean;
+    makeGetNonConcurrent?: boolean;
     getInitialized?: () => boolean;
     defaultValue?: T;
     set: (value: T) => Promise<void>;
 } & Omit<Atom<T>, 'set' | 'reset'>;
-declare const enforceObservableRules: <T>({ defaultValue, makeGetConcurrent, getInitialized, ...atom }: Params<T>) => Atom<T>;
+declare const enforceObservableRules: <T>({ defaultValue, makeGetNonConcurrent, getInitialized, ...atom }: Params<T>) => Atom<T>;
 export default enforceObservableRules;

package/lib/enforce-rules.js

@@ -14,26 +14,31 @@ const withChangeDetection = (listener) => {
         await listener(currentValue);
     };
 };
-const enforceObservableRules = ({ defaultValue, makeGetConcurrent = false, getInitialized = () => true, ...atom }) => {
+const enforceObservableRules = ({ defaultValue, makeGetNonConcurrent = false, getInitialized = () => true, ...atom }) => {
     const enqueue = makeConcurrent((fn) => fn(), { concurrency: 1 });
     const postProcessValue = (value = defaultValue) => value && typeof value === 'object' ? freeze(value) : value;
-    const _get = makeGetConcurrent ? makeConcurrent(atom.get) : atom.get;
-    const get = () => _get().then(postProcessValue);
+    const nonConcurrentGet = makeGetNonConcurrent
+        ? makeConcurrent(atom.get)
+        : atom.get;
+    const get = () => nonConcurrentGet().then(postProcessValue);
     const observe = (listener) => {
         let called = false;
         let valueEmittedFromGet;
+        let subscribed = true;
         listener = withChangeDetection(listener);
         const publishSerially = (value) => {
             called = true;
             return enqueue(() => listener(value));
         };
-        atom.get().then((value) => {
+        nonConcurrentGet().then((value) => {
+            if (!subscribed)
+                return;
             if (!called) {
                 valueEmittedFromGet = value;
                 publishSerially(postProcessValue(value));
             }
         });
-        return atom.observe((value) => {
+        const unsubscribe = atom.observe((value) => {
             if (valueEmittedFromGet !== undefined) {
                 const isAlreadyEmitted = value === valueEmittedFromGet;
                 valueEmittedFromGet = undefined;
@@ -43,6 +48,10 @@ const enforceObservableRules = ({ defaultValue, makeGetConcurrent = false, getIn
             }
             return publishSerially(postProcessValue(value));
         });
+        return () => {
+            unsubscribe();
+            subscribed = false;
+        };
     };
     const set = makeConcurrent(async (value) => {
         if (isSetter(value)) {

package/lib/enhancers/block-until.d.ts

@@ -1,4 +1,4 @@
-import { Atom, Listener } from '../utils/types.js';
+import type { Atom, Listener } from '../utils/types.js';
 type Params<T> = {
     atom: Atom<T>;
     unblock: () => Promise<unknown>;

package/lib/enhancers/combine.d.ts

@@ -1,4 +1,4 @@
-import { Atom, ReadonlyAtom } from '../utils/types.js';
+import type { Atom, ReadonlyAtom } from '../utils/types.js';
 type CombinedValue<T> = {
     [Key in keyof T]: T[Key] extends Atom<infer U> ? U : never;
 };

package/lib/enhancers/compute.d.ts

@@ -1,4 +1,4 @@
-import { Atom, ReadonlyAtom } from '../utils/types.js';
+import type { Atom, ReadonlyAtom } from '../utils/types.js';
 type Params<T, V> = {
     atom: Atom<T> | ReadonlyAtom<T>;
     selector: (value: T) => V | Promise<V>;

package/lib/enhancers/dedupe.d.ts

@@ -1,3 +1,3 @@
-import { Atom } from '../utils/types.js';
+import type { Atom } from '../utils/types.js';
 declare const dedupe: <T>(atom: Atom<T>) => Atom<T>;
 export default dedupe;

package/lib/enhancers/difference.d.ts

@@ -1,4 +1,4 @@
-import { Atom } from '../utils/types.js';
+import type { Atom } from '../utils/types.js';
 type Diff<T> = {
     previous?: T;
     current: T;

package/lib/enhancers/filter.d.ts

@@ -1,2 +1,2 @@
-import { Atom } from '../utils/types.js';
+import type { Atom } from '../utils/types.js';
 export default function filter<T>(atom: Atom<T>, predicate: (value: T) => boolean): Atom<T>;

package/lib/enhancers/merge-with-value.d.ts

@@ -1,4 +1,4 @@
-import { Atom } from '../utils/types.js';
+import type { Atom } from '../utils/types.js';
 type Params<T extends object> = {
     atom: Atom<T>;
     value: T;

package/lib/enhancers/optimistic-notifier.d.ts

@@ -1,3 +1,3 @@
-import { Atom } from '../utils/types.js';
+import type { Atom } from '../utils/types.js';
 declare const optimisticNotifier: <T>(atom: Atom<T>) => Atom<T | undefined>;
 export default optimisticNotifier;

package/lib/enhancers/read-only.d.ts

@@ -1,3 +1,3 @@
-import { Atom, ReadonlyAtom } from '../utils/types.js';
+import type { Atom, ReadonlyAtom } from '../utils/types.js';
 declare const readOnly: <T>(atom: Atom<T>) => ReadonlyAtom<T>;
 export default readOnly;

package/lib/enhancers/swallow-observer-errors.d.ts

@@ -1,4 +1,4 @@
-import { Atom, Listener, Logger } from '../utils/types.js';
+import type { Atom, Listener, Logger } from '../utils/types.js';
 type Params<T> = {
     atom: Atom<T>;
     logger: Logger;

package/lib/enhancers/timeout-observers.d.ts

@@ -1,4 +1,4 @@
-import { Atom } from '../utils/types.js';
+import type { Atom } from '../utils/types.js';
 type Params<T> = {
     atom: Atom<T>;
     timeout: number;

package/lib/enhancers/warn-on-same-value-set.d.ts

@@ -1,4 +1,4 @@
-import { Atom, Logger } from '../utils/types.js';
+import type { Atom, Logger } from '../utils/types.js';
 type Params<T> = {
     atom: Atom<T>;
     logger: Logger;

package/lib/enhancers/with-serialization.d.ts

@@ -1,4 +1,4 @@
-import { Atom } from '../utils/types.js';
+import type { Atom } from '../utils/types.js';
 type Params<T, S> = {
     atom: Atom<S>;
     serialize: (value: T) => S;

package/lib/enhancers/with-storage-cache.d.ts

@@ -1,5 +1,5 @@
-import { Atom } from '../utils/types.js';
-import { Storage } from '@exodus/storage-interface';
+import type { Atom } from '../utils/types.js';
+import type { Storage } from '@exodus/storage-interface';
 type Params<T> = {
     atom: Atom<T>;
     storage: Storage<T>;

package/lib/enhancers/with-storage-cache.js

@@ -1,7 +1,7 @@
 import createStorageAtomFactory from '../factories/storage.js';
 const getCacheAtom = ({ storage, key }) => {
     const createStorageAtom = createStorageAtomFactory({ storage });
-    return createStorageAtom({ key, isSoleWriter: true });
+    return createStorageAtom({ key });
 };
 const enhanceAtom = (params) => {
     const { atom, logger } = params;

package/lib/event-emitter.d.ts

@@ -1,4 +1,4 @@
-import { EventEmitter } from './utils/types.js';
+import type { EventEmitter } from './utils/types.js';
 type Params<T> = {
     emitter: EventEmitter;
     event: string;

package/lib/factories/keystore.d.ts

@@ -1,4 +1,4 @@
-import { Atom, Keystore, KeystoreValue } from '../utils/types.js';
+import type { Atom, Keystore, KeystoreValue } from '../utils/types.js';
 type Params = {
     keystore: Keystore;
     config: {

package/lib/factories/memory.d.ts

@@ -1,4 +1,4 @@
-import { Atom } from '../utils/types.js';
+import type { Atom } from '../utils/types.js';
 type Params<T> = {
     defaultValue?: T;
 };

package/lib/factories/observer.d.ts

@@ -1,4 +1,4 @@
-import { ReadonlyAtom, Port } from '../utils/types.js';
+import type { ReadonlyAtom, Port } from '../utils/types.js';
 type Params<T> = {
     atom: ReadonlyAtom<T>;
     port: Port<T>;

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

@@ -1,4 +1,4 @@
-import { Keystore, KeystoreValue } from '../utils/types.js';
+import type { Keystore, KeystoreValue } from '../utils/types.js';
 type Params = {
     keystore: Keystore;
     config: {

package/lib/factories/storage.d.ts

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

package/lib/factories/storage.js

@@ -1,43 +1,43 @@
 import createSimpleObserver from '../simple-observer.js';
 import enforceObservableRules from '../enforce-rules.js';
-import pDefer from 'p-defer';
 const createStorageAtomFactory = ({ storage }) => {
-    function createStorageAtom({ key, defaultValue, isSoleWriter, }) {
-        const { notify, observe } = createSimpleObserver({ enable: isSoleWriter });
+    function createStorageAtom({ key, defaultValue }) {
+        let version = 0;
+        const { notify, observe } = createSimpleObserver({ enable: true });
         let canUseCached = false;
         let cached;
-        let writePromiseDefer;
+        let pendingWrite;
         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) {
+            version++;
+            pendingWrite = (async () => {
+                if (value === undefined) {
+                    await storage.delete(key);
+                    canUseCached = false;
+                }
+                else {
+                    await storage.set(key, value);
+                    canUseCached = true;
+                }
                 cached = value;
-                canUseCached = value !== undefined;
-                await notify(value);
-            }
+                pendingWrite = undefined;
+            })();
+            await pendingWrite;
+            await notify(value);
         };
         const get = async () => {
-            if (canUseCached) {
-                return cached;
-            }
-            if (writePromiseDefer) {
-                await writePromiseDefer.promise;
+            if (pendingWrite) {
+                await pendingWrite;
             }
             if (canUseCached) {
                 return cached;
             }
+            const currentVersion = version;
             const value = await storage.get(key);
-            if (isSoleWriter) {
-                cached = value;
-                canUseCached = true;
+            if (currentVersion !== version) {
+                return get();
             }
+            cached = value;
+            canUseCached = true;
             return value;
         };
         return enforceObservableRules({
@@ -45,7 +45,7 @@ const createStorageAtomFactory = ({ storage }) => {
             set,
             observe,
             defaultValue,
-            makeGetConcurrent: isSoleWriter,
+            makeGetNonConcurrent: true,
         });
     }
     return createStorageAtom;

package/lib/simple-observer.d.ts

@@ -1,4 +1,4 @@
-import { Listener } from './utils/types.js';
+import type { Listener } from './utils/types.js';
 declare const createSimpleObserver: <T>({ enable }?: {
     enable?: boolean | undefined;
 }) => {

package/lib/utils/guards.d.ts

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/atoms",
-  "version": "8.1.1",
+  "version": "9.0.0",
   "description": "Abstraction for encapsulating a piece of data behind a simple unified interface: get, set, observe",
   "type": "module",
   "main": "lib/index.js",
@@ -40,12 +40,13 @@
   },
   "devDependencies": {
     "@exodus/atom-tests": "^1.0.0",
-    "@exodus/storage-memory": "^2.2.0",
+    "@exodus/storage-encrypted": "^1.4.1",
+    "@exodus/storage-memory": "^2.2.1",
     "@types/jest": "^29.5.11",
     "@types/json-stringify-safe": "^5.0.3",
     "@types/lodash": "^4.14.200",
     "@types/minimalistic-assert": "^1.0.2",
     "events": "^3.3.0"
   },
-  "gitHead": "d64de7579b06afe91fbded3d1f7eb29950f82e5a"
+  "gitHead": "bbcb4c47a53d1770a36213ba77fa1f46bccc8d64"
 }