feat(useDataEngine): make engine instance a referential constant

[Mohammer5]

I was trying to ensure that a hook preserves the referential identity of a function with jest by using the rerender function returned by @testing-library/react-hooks's renderHook function. This will render the wrapper twice as well, which causes the engine object to be created again. Any hook that makes use of memoisation doesn't work with this, so I created a hook called useConst (inspired by @amcgee) and made sure that the engine only gets created once.

// a hook that a jest test might want to test
const useMemoisation = () => {
  const engine = useDataEngine()
  const memoisedCallback = useCallback(() => engine.query(...), [engine])

  return memoisedCallback
}

// test
test('memoisation', () => {
  const { result, rerender } = useMemoisation()
  rerender()
  expect(result.all).toHaveLengthOf(2)
  expect(result.all[0]).toBe(result.current) 
})

This change assumes that apiVersion and baseUrl won't change throughout an app's lifetime (as these changing would mean we need a new link and engine)

[amcgee]

this is a good change! Here's a suggestion which might address what @mediremi mentioned (though I think those cases should be rare)

[amcgee]

Suggested change

	function useConst<T>(initializer: () => T): T {
	const [value] = useState(initializer)
	return value
	}
	function useInstanceVariable<T>(initializer: () => T, dependencies: any[]): T {
	const [value, setValue] = useState(initializer)
	const initializedRef = useRef(false)
	useEffect(() => {
	if (!initializedRef.current) {
	initializedRef.current = true
	return
	}
	setValue(initializer())
	}, dependencies)
	return value
	}

[amcgee]

Maybe something like this instead, to support updates when deps change?

[amcgee]

Note however that this will cause double-renders on dependency updates...

[mediremi]

useInstanceVariable would be used in DataProvider and CustomDataProvider instead of in useDataEngine right?

[Mohammer5]

Sounds a lot like we could just use useMemo instead of useConst?

[amcgee]

@Mohammer5 this is super old... but no, there's a difference because useConst guarantees referential integrity while useMemo might re-initialize in certain situations since it is only considered a performance optimization.

[Mohammer5]

Yeah, I also figured out the other day that useMemo does not guarantee that..
I think for simplicity's sake, the following might be the most pragmatic with the least amount of abstractions:

function useDataEngine = (): DataEngine => {
    const context = useContext(DataContext)
    const [instance, setInstance] = useState(context.engine)
    
   useEffect(() => {
        setInstance(context.engine)
    }, [context.engine])

    return value
}