Enhance subscription management by adding root subscription source functions and updating regSub to handle string-based subscriptions. Implement validation to prevent duplicate root-key registration. Update tests to cover new functionality and error handling.

Author: flexsurfer

src/db.ts

@@ -1,5 +1,5 @@
 import type { Db } from './types';
-import { getReaction } from './registrar';
+import { getReaction, getRootSubIdBySource } from './registrar';
 import { consoleLog } from './loggers';
 import { scheduleAfterRender } from './schedule';
 
@@ -30,7 +30,16 @@ export function updateAppDbWithPatches<T = Record<string, any>>(newDb: Db<T>, pa
       const pathSegments = patch.path;
       if (pathSegments.length > 0) {
         const rootKey = pathSegments[0] as string;
-        const subVectorKey = JSON.stringify([rootKey])
+        if (typeof rootKey !== 'string') {
+          continue;
+        }
+
+        const subId = getRootSubIdBySource(rootKey);
+        if (!subId) {
+          continue;
+        }
+
+        const subVectorKey = JSON.stringify([subId])
         const reaction = getReaction(subVectorKey);
         if (reaction) {
           if (!reaction.isRoot) {
@@ -66,4 +75,4 @@ export function updateAppDbWithPatches<T = Record<string, any>>(newDb: Db<T>, pa
       });
     }
   }
-}
+}

src/registrar.ts

@@ -42,12 +42,16 @@ export function clearHandlers(kind?: Kind, id?: string): void {
         for (const k in kindToIdToHandler) {
             kindToIdToHandler[k as Kind] = {};
         }
+        clearRootSubSources();
     } else if (id == null) {
         if (!(kind in kindToIdToHandler)) {
             consoleLog('error', `[reflex] Unknown kind: ${kind}`);
             return;
         }
         kindToIdToHandler[kind] = {};
+        if (kind === 'sub') {
+            clearRootSubSources();
+        }
     } else {
         if (kindToIdToHandler[kind][id]) {
             delete kindToIdToHandler[kind][id];
@@ -90,6 +94,21 @@ export function clearReactions(id?: string): void {
     }
 }
 
+// === Root Subscription Source Registry Functions ===
+const rootSubIdBySource = new Map<string, Id>();
+
+export function setRootSubSource(subId: Id, sourceKey: string): void {
+    rootSubIdBySource.set(sourceKey, subId);
+}
+
+export function getRootSubIdBySource(sourceKey: string): Id | undefined {
+    return rootSubIdBySource.get(sourceKey);
+}
+
+export function clearRootSubSources(): void {
+    rootSubIdBySource.clear();
+}
+
 export function clearSubs(): void {
     clearReactions();
     clearHandlers('sub');
@@ -152,4 +171,4 @@ export function clearAllRegistries(): void {
     clearReactions();
     clearInterceptors();
     clearSubConfigs();
-}
+}

src/subs.ts

@@ -8,7 +8,9 @@ import {
     registerHandler,
     hasHandler,
     setSubConfig,
-    getSubConfig
+    getSubConfig,
+    setRootSubSource,
+    getRootSubIdBySource
 } from './registrar';
 import { getAppDb } from './db';
 import { mergeTrace, withTrace } from './trace';
@@ -17,18 +19,26 @@ import { getGlobalEqualityCheck } from './settings';
 const KIND = 'sub';
 const KIND_DEPS = 'subDeps';
 
+function registerRootSub (id: Id, sourceKey: string) {
+    const conflictingSubId = getRootSubIdBySource(sourceKey)
+    if (conflictingSubId && conflictingSubId !== id) {
+        consoleLog('error', `[reflex] Subscription with id '${id}' will be overridden. Root key '${sourceKey}' is already used by subscription '${conflictingSubId}'.`)
+    }
+
+    setRootSubSource(id, sourceKey)
+    registerHandler(KIND, id, () => getAppDb()[sourceKey])
+    registerHandler(KIND_DEPS, id, () => [])
+}
+
 export function regSub<R>(id: Id, computeFn?: ((...values: any[]) => R) | string, depsFn?: (...params: any[]) => SubVector[], config?: SubConfig): void {
     if (hasHandler(KIND, id)) {
         consoleLog('warn', `[reflex] Overriding. Subscription '${id}' already registered.`)
     }
-    // If only id is provided, use root subscription logic
+
     if (!computeFn) {
-        registerHandler(KIND, id, () => getAppDb()[id])
-        registerHandler(KIND_DEPS, id, () => [])
+        registerRootSub(id, id)
     } else if (typeof computeFn === 'string') {
-        // String field subscription - access field directly from appdb
-        registerHandler(KIND, id, () => getAppDb()[computeFn])
-        registerHandler(KIND_DEPS, id, () => [])
+        registerRootSub(id, computeFn as string)
     } else {
         // Computed subscriptions require depsFn
         if (!depsFn) {
@@ -100,4 +110,4 @@ export function getOrCreateReaction(subVector: SubVector): Reaction<any> {
 export function getSubscriptionValue<T>(subVector: SubVector): T {
     const reaction = getOrCreateReaction(subVector)
     return reaction ? reaction.computeValue() : undefined as T
-}
+}

src/tests/hook.test.tsx

@@ -71,6 +71,33 @@ describe('React Hooks', () => {
       expect(result.current).toBe('john@example.com');
     });
 
+    it('should update string-based root subscription when source field changes', async () => {
+      const { result } = renderHook(() => useSubscription(['user-email-str']));
+
+      expect(result.current).toBe('john@example.com');
+
+      regEvent('set-user-email', ({ draftDb }, email) => {
+        draftDb.userEmail = email;
+      });
+
+      act(() => {
+        dispatch(['set-user-email', 'jane@example.com']);
+      });
+
+      await waitFor(() => {
+        expect(result.current).toBe('jane@example.com');
+      });
+    });
+
+    it('should reject duplicate root-key registration with different sub ids', () => {
+      regSub('user-email-str-duplicate', 'userEmail');
+
+      expectLogCall(
+        'error',
+        "[reflex] Subscription with id 'user-email-str-duplicate' will be overridden. Root key 'userEmail' is already used by subscription 'user-email-str'."
+      );
+    });
+
     it('should handle subscription with parameters', () => {
       // Register a parameterized subscription
       regSub('todo-by-id', (todos, id) => {
@@ -273,4 +300,4 @@ describe('React Hooks', () => {
       });
     });
   });
-}); 
+});