Fix memoryStore does not support nested-looking keys

Author: slax57

packages/ra-core/src/store/memoryStore.spec.ts

@@ -40,4 +40,31 @@ describe('memoryStore', () => {
             expect(store.getItem('foo')).toEqual(undefined);
         });
     });
+
+    describe('nested-looking keys', () => {
+        it('should store and retrieve values in keys that appear nested without overriding content', () => {
+            const store = memoryStore();
+            store.setItem('foo', 'parent value');
+            store.setItem('foo.bar', 'nested value');
+
+            expect(store.getItem('foo')).toEqual('parent value');
+            expect(store.getItem('foo.bar')).toEqual('nested value');
+        });
+
+        it('should handle initial storage with nested objects', () => {
+            const initialStorage = {
+                user: {
+                    name: 'John',
+                    settings: {
+                        theme: 'dark',
+                    },
+                },
+            };
+
+            const store = memoryStore(initialStorage);
+
+            expect(store.getItem('user.name')).toEqual('John');
+            expect(store.getItem('user.settings.theme')).toEqual('dark');
+        });
+    });
 });

packages/ra-core/src/store/memoryStore.tsx

@@ -1,6 +1,3 @@
-import set from 'lodash/set.js';
-import unset from 'lodash/unset.js';
-import get from 'lodash/get.js';
 import { Store } from './types';
 
 type Subscription = {
@@ -21,8 +18,15 @@ type Subscription = {
  *   </Admin>
  * );
  */
-export const memoryStore = (storage: any = {}): Store => {
+export const memoryStore = (
+    initialStorage: Record<string, any> = {}
+): Store => {
+    // Use a flat Map to store key-value pairs directly without treating dots as nested paths
+    const storage = new Map<string, any>(
+        Object.entries(flatten(initialStorage))
+    );
     const subscriptions: { [key: string]: Subscription } = {};
+
     const publish = (key: string, value: any) => {
         Object.keys(subscriptions).forEach(id => {
             if (!subscriptions[id]) return; // may happen if a component unmounts after a first subscriber was notified
@@ -31,36 +35,44 @@ export const memoryStore = (storage: any = {}): Store => {
             }
         });
     };
+
     return {
         setup: () => {},
         teardown: () => {
-            Object.keys(storage).forEach(key => delete storage[key]);
+            storage.clear();
         },
         getItem<T = any>(key: string, defaultValue?: T): T {
-            return get(storage, key, defaultValue);
+            return storage.has(key)
+                ? (storage.get(key) as T)
+                : (defaultValue as T);
         },
         setItem<T = any>(key: string, value: T): void {
-            set(storage, key, value);
+            storage.set(key, value);
             publish(key, value);
         },
         removeItem(key: string): void {
-            unset(storage, key);
+            storage.delete(key);
             publish(key, undefined);
         },
         removeItems(keyPrefix: string): void {
-            const flatStorage = flatten(storage);
-            Object.keys(flatStorage).forEach(key => {
-                if (!key.startsWith(keyPrefix)) {
-                    return;
+            const keysToDelete: string[] = [];
+            storage.forEach((_, key) => {
+                if (key.startsWith(keyPrefix)) {
+                    keysToDelete.push(key);
                 }
-                unset(storage, key);
+            });
+            keysToDelete.forEach(key => {
+                storage.delete(key);
                 publish(key, undefined);
             });
         },
         reset(): void {
-            const flatStorage = flatten(storage);
-            Object.keys(flatStorage).forEach(key => {
-                unset(storage, key);
+            const keysToDelete: string[] = [];
+            storage.forEach((_, key) => {
+                keysToDelete.push(key);
+            });
+            storage.clear();
+            keysToDelete.forEach(key => {
                 publish(key, undefined);
             });
         },