teamplay 0.3.13 → 0.3.14

package/orm/Cache.js

@@ -4,7 +4,19 @@ import WeakRef, { destroyMockWeakRef } from '../utils/MockWeakRef.js'
 export default class Cache {
   constructor () {
     this.cache = new Map()
-    this.fr = new FinalizationRegistry(([key]) => this.delete(key))
+    this.fr = new FinalizationRegistry(([key]) => {
+      // handle situation when FinalizationRegistry triggers
+      // way later after the WeakRef is already garbage collected.
+      // In this case we might already have a new value in the cache
+      // and we don't want to delete it.
+      if (this.get(key)) return
+      this.delete(key)
+    })
+  }
+
+  // for testing purposes
+  _getKeys () {
+    return Array.from(this.cache.keys()).sort()
   }
 
   get (key) {
@@ -18,6 +30,7 @@ export default class Cache {
    *                         to hold strong references to them until the value is garbage collected
    */
   set (key, value, inputs = []) {
+    if (typeof key !== 'string') throw Error('Cache key should be a string')
     this.cache.set(key, new WeakRef(value))
     this.fr.register(value, [key, ...inputs])
   }

package/orm/getSignal.js

@@ -59,7 +59,7 @@ export default function getSignal ($root, segments = [], {
   if (segments.length > 2) {
     if (segments[0] === LOCAL) {
       dependencies.push(getSignal($root, segments.slice(0, 2)))
-    } else if (isPublicCollection(segments[0])) {
+    } else if (isPublicCollection(segments[0]) || segments[0] === QUERIES || segments[0] === AGGREGATIONS) {
       dependencies.push(getSignal(undefined, segments.slice(0, 2)))
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "teamplay",
-  "version": "0.3.13",
+  "version": "0.3.14",
   "description": "Full-stack signals ORM with multiplayer",
   "type": "module",
   "main": "index.js",
@@ -19,16 +19,16 @@
     "test": "npm run test-server && npm run test-client",
     "test-server": "node --expose-gc -r ./test/_init.cjs --test",
     "test-server-only": "node --expose-gc -r ./test/_init.cjs --test --test-only",
-    "test-client": "NODE_OPTIONS=\"$NODE_OPTIONS --experimental-vm-modules\" jest"
+    "test-client": "NODE_OPTIONS=\"$NODE_OPTIONS --expose-gc --experimental-vm-modules\" jest"
   },
   "dependencies": {
     "@nx-js/observer-util": "^4.1.3",
-    "@teamplay/backend": "^0.3.13",
-    "@teamplay/cache": "^0.3.13",
-    "@teamplay/channel": "^0.3.13",
-    "@teamplay/debug": "^0.3.13",
-    "@teamplay/schema": "^0.3.13",
-    "@teamplay/utils": "^0.3.13",
+    "@teamplay/backend": "^0.3.14",
+    "@teamplay/cache": "^0.3.14",
+    "@teamplay/channel": "^0.3.14",
+    "@teamplay/debug": "^0.3.14",
+    "@teamplay/schema": "^0.3.14",
+    "@teamplay/utils": "^0.3.14",
     "diff-match-patch": "^1.0.5",
     "events": "^3.3.0",
     "json0-ot-diff": "^1.1.2",
@@ -63,5 +63,5 @@
     ]
   },
   "license": "MIT",
-  "gitHead": "c08d644eb32ef66112285de31a63201771a0eb97"
+  "gitHead": "798d2a34fcb67bf255a2b3c126a5fb052243a866"
 }

package/react/convertToObserver.js

@@ -40,9 +40,9 @@ export default function convertToObserver (BaseComponent, {
       if (throttle) update = _throttle(update, throttle)
       destroyRef.current = (where) => {
         if (!reactionRef.current) throw Error(`NO REACTION REF - ${where}`)
+        destroyRef.current = undefined
         unobserve(reactionRef.current)
         reactionRef.current = undefined
-        destroyRef.current = undefined
         destroyCache(where)
       }
       const trappedRender = trapRender({

package/react/helpers.js

@@ -46,6 +46,12 @@ export function useScheduleUpdate () {
   return context.scheduleUpdate
 }
 
+export function useCache (key) {
+  const context = useContext(ComponentMetaContext)
+  if (!context) throw Error(ERRORS.useCache)
+  return context.cache
+}
+
 export function useUnmount (fn) {
   const fnRef = useRef()
   if (fnRef.current !== fn) fnRef.current = fn
@@ -73,5 +79,9 @@ const ERRORS = {
   useNow: `
     useNow() can only be used inside a component wrapped with observer().
     You have probably forgot to wrap your component with observer().
+  `,
+  useCache: `
+    useCache() can only be used inside a component wrapped with observer().
+    You have probably forgot to wrap your component with observer().
   `
 }

package/react/universal$.js

@@ -1,5 +1,5 @@
-import { useRef } from 'react'
 import $ from '../orm/$.js'
+import { useCache } from './helpers.js'
 import executionContextTracker from './executionContextTracker.js'
 
 // universal versions of $() which work as a plain function or as a react hook
@@ -7,10 +7,10 @@ export default function universal$ ($root, value) {
   if (executionContextTracker.isActive()) {
     // within react component
     const id = executionContextTracker.newHookId()
+    const cache = useCache() // eslint-disable-line react-hooks/rules-of-hooks
     const $signal = $($root, value, id)
+    cache.set(id, $signal)
     // save signal into ref to make sure it's not garbage collected while component exists
-    const $signalRef = useRef() // eslint-disable-line react-hooks/rules-of-hooks
-    if ($signalRef.current !== $signal) $signalRef.current = $signal
     return $signal
   } else {
     return $($root, value)

package/react/useSub.js

@@ -1,6 +1,7 @@
 import { useRef, useDeferredValue } from 'react'
 import sub from '../orm/sub.js'
-import { useScheduleUpdate } from './helpers.js'
+import { useScheduleUpdate, useCache } from './helpers.js'
+import executionContextTracker from './executionContextTracker.js'
 
 let TEST_THROTTLING = false
 
@@ -47,7 +48,8 @@ export function useSubDeferred (signal, params, { async = false } = {}) {
 // classic version which initially throws promise for Suspense
 // but if we get a promise second time, we return the last signal and wait for promise to resolve
 export function useSubClassic (signal, params, { async = false } = {}) {
-  const $signalRef = useRef()
+  const id = executionContextTracker.newHookId()
+  const cache = useCache()
   const activePromiseRef = useRef()
   const scheduleUpdate = useScheduleUpdate()
   const promiseOrSignal = params != null ? sub(signal, params) : sub(signal)
@@ -55,7 +57,7 @@ export function useSubClassic (signal, params, { async = false } = {}) {
   if (promiseOrSignal.then) {
     const promise = maybeThrottle(promiseOrSignal)
     // first time we just throw the promise to be caught by Suspense
-    if (!$signalRef.current) {
+    if (!cache.has(id)) {
       // if we are in async mode, we just return nothing and let the user
       // handle appearance of signal on their own.
       // We manually schedule an update when promise resolves since we can't
@@ -71,13 +73,13 @@ export function useSubClassic (signal, params, { async = false } = {}) {
     }
     // if we already have a previous signal, we return it and wait for new promise to resolve
     scheduleUpdate(promise)
-    return $signalRef.current
+    return cache.get(id)
   // 2. if it's a signal, we save it into ref to make sure it's not garbage collected while component exists
   } else {
     const $signal = promiseOrSignal
-    if ($signalRef.current !== $signal) {
+    if (cache.get(id) !== $signal) {
       activePromiseRef.current = undefined
-      $signalRef.current = $signal
+      cache.set(id, $signal)
     }
     return $signal
   }

package/react/wrapIntoSuspense.js

@@ -3,6 +3,17 @@
 import { useSyncExternalStore, forwardRef as _forwardRef, memo, createElement as el, Suspense, useId, useRef } from 'react'
 import { pipeComponentMeta, pipeComponentDisplayName, ComponentMetaContext } from './helpers.js'
 
+// TODO: probably add FinalizationRegistry to handle destruction of observer() before it ever mounted.
+//       In such case we might have a memory leak because subscribe() would never fire and would never
+//       clean up the cache
+function destroyAdm (adm) {
+  adm.onStoreChange = undefined
+  adm.scheduledUpdatePromise = undefined
+  adm.scheduleUpdate = undefined
+  adm.cache.clear()
+  adm.cache = undefined
+}
+
 export default function wrapIntoSuspense ({
   Component,
   forwardRef,
@@ -19,6 +30,7 @@ export default function wrapIntoSuspense ({
         stateVersion: Symbol(), // eslint-disable-line symbol-description
         onStoreChange: undefined,
         scheduledUpdatePromise: undefined,
+        cache: new Map(),
         scheduleUpdate: promise => {
           if (!promise?.then) throw Error('scheduleUpdate() expects a promise')
           if (adm.scheduledUpdatePromise === promise) return
@@ -34,11 +46,7 @@ export default function wrapIntoSuspense ({
             adm.stateVersion = Symbol() // eslint-disable-line symbol-description
             onStoreChange()
           }
-          return () => {
-            adm.onStoreChange = undefined
-            adm.scheduledUpdatePromise = undefined
-            adm.scheduleUpdate = undefined
-          }
+          return () => destroyAdm(adm)
         },
         getSnapshot () {
           return adm.stateVersion
@@ -55,7 +63,12 @@ export default function wrapIntoSuspense ({
         componentId,
         createdAt: Date.now(),
         triggerUpdate: () => adm.onStoreChange?.(),
-        scheduleUpdate: promise => adm.scheduleUpdate?.(promise)
+        scheduleUpdate: promise => adm.scheduleUpdate?.(promise),
+        cache: {
+          get: key => adm.cache?.get(key),
+          set: (key, value) => adm.cache?.set(key, value),
+          has: key => adm.cache?.has(key)
+        }
       }
     }