@dhis2/app-service-data 3.17.1 → 3.18.0-beta.2

package/src/react/hooks/mergeAndCompareVariables.test.ts

@@ -1,65 +0,0 @@
-import { mergeAndCompareVariables } from './mergeAndCompareVariables'
-import { stableVariablesHash } from './stableVariablesHash'
-jest.mock('./stableVariablesHash', () => ({
-    stableVariablesHash: (object: unknown) => JSON.stringify(object),
-}))
-
-const testVariables = {
-    question: 'What do you get when you multiply six by nine?',
-    answer: 42,
-}
-const testHash = stableVariablesHash(testVariables)
-
-describe('mergeAndCompareVariables', () => {
-    it('Should return previous variables and hash when no new variables are provided', () => {
-        expect(
-            mergeAndCompareVariables(testVariables, undefined, undefined)
-        ).toMatchObject({
-            identical: true,
-            mergedVariables: testVariables,
-            mergedVariablesHash: undefined,
-        })
-    })
-
-    it('Should return identical: true when merged variables are identical to old variables (without prev hash)', () => {
-        const newVariables = { answer: testVariables.answer }
-
-        expect(
-            mergeAndCompareVariables(testVariables, newVariables, undefined)
-        ).toMatchObject({
-            identical: true,
-            mergedVariables: testVariables,
-            mergedVariablesHash: testHash,
-        })
-    })
-
-    it('Should return identical: false with incorrect previous hash', () => {
-        const incorrectPreviousHash = 'IAmAHash'
-        const newVariables = { answer: 42 }
-
-        expect(
-            mergeAndCompareVariables(
-                testVariables,
-                newVariables,
-                incorrectPreviousHash
-            )
-        ).toMatchObject({
-            identical: false,
-            mergedVariables: testVariables,
-            mergedVariablesHash: testHash,
-        })
-    })
-
-    it('Should return identical: false when merged variables are different than old variables', () => {
-        const newVariables = { answer: 43 }
-        const expectedMergedVariables = { ...testVariables, ...newVariables }
-
-        expect(
-            mergeAndCompareVariables(testVariables, newVariables, testHash)
-        ).toMatchObject({
-            identical: false,
-            mergedVariables: expectedMergedVariables,
-            mergedVariablesHash: stableVariablesHash(expectedMergedVariables),
-        })
-    })
-})

package/src/react/hooks/mergeAndCompareVariables.ts

@@ -1,32 +0,0 @@
-import type { QueryVariables } from '@dhis2/data-engine'
-import { stableVariablesHash } from './stableVariablesHash'
-
-export const mergeAndCompareVariables = (
-    previousVariables?: QueryVariables,
-    newVariables?: QueryVariables,
-    previousHash?: string
-) => {
-    if (!newVariables) {
-        return {
-            identical: true,
-            mergedVariablesHash: previousHash,
-            mergedVariables: previousVariables,
-        }
-    }
-
-    // Use cached hash if it exists
-    const currentHash = previousHash || stableVariablesHash(previousVariables)
-
-    const mergedVariables = {
-        ...previousVariables,
-        ...newVariables,
-    }
-    const mergedVariablesHash = stableVariablesHash(mergedVariables)
-    const identical = currentHash === mergedVariablesHash
-
-    return {
-        identical,
-        mergedVariablesHash,
-        mergedVariables,
-    }
-}

package/src/react/hooks/stableVariablesHash.test.ts

@@ -1,53 +0,0 @@
-import { stableVariablesHash } from './stableVariablesHash'
-
-describe('stableVariablesHash', () => {
-    it('sorts objects before hashing', () => {
-        const one = {
-            a: {
-                one: 1,
-                two: 2,
-                three: 3,
-            },
-            b: [1, 2, 3],
-            c: 'c',
-        }
-        const two = {
-            c: 'c',
-            b: [1, 2, 3],
-            a: {
-                three: 3,
-                two: 2,
-                one: 1,
-            },
-        }
-
-        expect(stableVariablesHash(one)).toEqual(stableVariablesHash(two))
-    })
-
-    it('can handle primitives', () => {
-        const one = undefined
-        const two = 'string'
-        const three = 3
-        const four = null
-        const five = true
-
-        expect(stableVariablesHash(one)).toMatchInlineSnapshot(`undefined`)
-        expect(stableVariablesHash(two)).toMatchInlineSnapshot(`"\\"string\\""`)
-        expect(stableVariablesHash(three)).toMatchInlineSnapshot(`"3"`)
-        expect(stableVariablesHash(four)).toMatchInlineSnapshot(`"null"`)
-        expect(stableVariablesHash(five)).toMatchInlineSnapshot(`"true"`)
-    })
-
-    it('throws a clear error when the variables contain a circular reference', () => {
-        const unserializable: any = {
-            value: 'value',
-        }
-        unserializable.circular = unserializable
-
-        expect(() =>
-            stableVariablesHash(unserializable)
-        ).toThrowErrorMatchingInlineSnapshot(
-            `"Could not serialize variables. Make sure that the variables do not contain circular references and can be processed by JSON.stringify."`
-        )
-    })
-})

package/src/react/hooks/stableVariablesHash.ts

@@ -1,56 +0,0 @@
-function hasObjectPrototype(o: any): boolean {
-    return Object.prototype.toString.call(o) === '[object Object]'
-}
-
-export function isPlainObject(o: any): o is object {
-    if (!hasObjectPrototype(o)) {
-        return false
-    }
-
-    // If has modified constructor
-    const ctor = o.constructor
-    if (typeof ctor === 'undefined') {
-        return true
-    }
-
-    // If has modified prototype
-    const prot = ctor.prototype
-    if (!hasObjectPrototype(prot)) {
-        return false
-    }
-
-    // If constructor does not have an Object-specific method
-    if (!Object.prototype.hasOwnProperty.call(prot, 'isPrototypeOf')) {
-        return false
-    }
-
-    // Most likely a plain Object
-    return true
-}
-
-/**
- * Hashes the value into a stable hash.
- */
-
-export function stableVariablesHash(value: any): string {
-    let hash
-
-    try {
-        hash = JSON.stringify(value, (_, val) =>
-            isPlainObject(val)
-                ? Object.keys(val)
-                      .sort()
-                      .reduce((result: Record<string, unknown>, key) => {
-                          result[key] = (val as Record<string, unknown>)[key]
-                          return result
-                      }, {})
-                : val
-        )
-    } catch (e) {
-        throw new Error(
-            'Could not serialize variables. Make sure that the variables do not contain circular references and can be processed by JSON.stringify.'
-        )
-    }
-
-    return hash
-}

package/src/react/hooks/useDataEngine.ts

@@ -1,8 +0,0 @@
-import { useContext } from 'react'
-import { DataContext } from '../context/DataContext'
-
-export const useDataEngine = () => {
-    const context = useContext(DataContext)
-
-    return context.engine
-}

package/src/react/hooks/useDataMutation.test.tsx

@@ -1,296 +0,0 @@
-import type {
-    CreateMutation,
-    UpdateMutation,
-    QueryVariables,
-} from '@dhis2/data-engine'
-import { renderHook, act, waitFor } from '@testing-library/react'
-import * as React from 'react'
-import { CustomDataProvider } from '../components/CustomDataProvider'
-import { useDataEngine } from './useDataEngine'
-import { useDataMutation } from './useDataMutation'
-
-describe('useDataMutation', () => {
-    it('should render without failing', async () => {
-        const mutation: CreateMutation = {
-            type: 'create',
-            resource: 'answer',
-            data: { answer: '?' },
-        }
-        const data = { answer: 42 }
-        const wrapper = ({ children }: { children?: React.ReactNode }) => (
-            <CustomDataProvider data={data}>{children}</CustomDataProvider>
-        )
-
-        const { result } = renderHook(() => useDataMutation(mutation), {
-            wrapper,
-        })
-
-        const [mutate, beforeMutation] = result.current
-        expect(beforeMutation).toMatchObject({
-            loading: false,
-            called: false,
-        })
-
-        act(() => {
-            mutate()
-        })
-
-        await waitFor(() => {
-            const [, duringMutation] = result.current
-            expect(duringMutation).toMatchObject({
-                loading: true,
-                called: true,
-            })
-        })
-
-        await waitFor(() => {
-            const [, afterMutation] = result.current
-            expect(afterMutation).toMatchObject({
-                loading: false,
-                called: true,
-                data: 42,
-            })
-        })
-    })
-
-    it('should run immediately with lazy: false', async () => {
-        const mutation: CreateMutation = {
-            type: 'create',
-            resource: 'answer',
-            data: { answer: '?' },
-        }
-        const data = { answer: 42 }
-        const wrapper = ({ children }: { children?: React.ReactNode }) => (
-            <CustomDataProvider data={data}>{children}</CustomDataProvider>
-        )
-
-        const { result } = renderHook(
-            () => useDataMutation(mutation, { lazy: false }),
-            { wrapper }
-        )
-
-        const [, duringMutation] = result.current
-        expect(duringMutation).toMatchObject({
-            loading: true,
-            called: true,
-        })
-
-        await waitFor(() => {
-            const [, afterMutation] = result.current
-            expect(afterMutation).toMatchObject({
-                loading: false,
-                called: true,
-                data: 42,
-            })
-        })
-    })
-
-    it('should call onComplete on success', async () => {
-        const onComplete = jest.fn()
-        const mutation: CreateMutation = {
-            type: 'create',
-            resource: 'answer',
-            data: { answer: '?' },
-        }
-        const data = { answer: 42 }
-        const wrapper = ({ children }: { children?: React.ReactNode }) => (
-            <CustomDataProvider data={data}>{children}</CustomDataProvider>
-        )
-
-        const { result } = renderHook(
-            () => useDataMutation(mutation, { onComplete }),
-            { wrapper }
-        )
-
-        expect(onComplete).toHaveBeenCalledTimes(0)
-        const [mutate] = result.current
-        act(() => {
-            mutate()
-        })
-
-        await waitFor(() => {
-            const [, state] = result.current
-            expect(state).toMatchObject({
-                loading: false,
-                called: true,
-                data: 42,
-            })
-            expect(onComplete).toHaveBeenCalledTimes(1)
-            expect(onComplete).toHaveBeenLastCalledWith(42)
-        })
-    })
-
-    it('should call onError on error', async () => {
-        const error = new Error('Something went wrong')
-        const onError = jest.fn()
-        const mutation: CreateMutation = {
-            type: 'create',
-            resource: 'answer',
-            data: { answer: 42 },
-        }
-        const data = {
-            answer: () => {
-                throw error
-            },
-        }
-        const wrapper = ({ children }: { children?: React.ReactNode }) => (
-            <CustomDataProvider data={data}>{children}</CustomDataProvider>
-        )
-
-        const { result } = renderHook(
-            () => useDataMutation(mutation, { onError }),
-            { wrapper }
-        )
-
-        expect(onError).toHaveBeenCalledTimes(0)
-        const [mutate] = result.current
-
-        act(() => {
-            mutate()
-        })
-
-        await waitFor(() => {
-            const [, state] = result.current
-            expect(state).toMatchObject({
-                loading: false,
-                called: true,
-                error,
-            })
-        })
-        expect(onError).toHaveBeenCalledTimes(1)
-        expect(onError).toHaveBeenLastCalledWith(error)
-    })
-
-    it('should resolve variables', async () => {
-        const mutation = {
-            type: 'update',
-            resource: 'answer',
-            id: ({ id }: QueryVariables) => id as string,
-            data: { answer: '?' },
-        } as unknown as UpdateMutation
-        const answerSpy = jest.fn(() => Promise.resolve(42))
-        const data = { answer: answerSpy }
-        const wrapper = ({ children }: { children?: React.ReactNode }) => (
-            <CustomDataProvider data={data}>{children}</CustomDataProvider>
-        )
-
-        const { result } = renderHook(
-            () =>
-                useDataMutation(mutation, {
-                    lazy: false,
-                    variables: { id: '1' },
-                }),
-            { wrapper }
-        )
-
-        await waitFor(() => {
-            expect(answerSpy).toHaveBeenLastCalledWith(
-                expect.any(String),
-                expect.objectContaining({
-                    id: '1',
-                }),
-                expect.any(Object)
-            )
-        })
-
-        const [mutate] = result.current
-        act(() => {
-            mutate({ id: '2' })
-        })
-
-        await waitFor(() => {
-            expect(answerSpy).toHaveBeenLastCalledWith(
-                expect.any(String),
-                expect.objectContaining({
-                    id: '2',
-                }),
-                expect.any(Object)
-            )
-        })
-    })
-
-    it('should return a reference to the engine', async () => {
-        const mutation: CreateMutation = {
-            type: 'create',
-            resource: 'answer',
-            data: { answer: '?' },
-        }
-        const wrapper = ({ children }: { children?: React.ReactNode }) => (
-            <CustomDataProvider data={{}}>{children}</CustomDataProvider>
-        )
-
-        const engineHook = renderHook(() => useDataEngine(), { wrapper })
-        const mutationHook = renderHook(() => useDataMutation(mutation), {
-            wrapper,
-        })
-
-        /**
-         * Ideally we'd check referential equality here with .toBe, but since
-         * both hooks run in a different context that doesn't work.
-         */
-        expect(mutationHook.result.current[1].engine).toStrictEqual(
-            engineHook.result.current
-        )
-    })
-
-    it('should return a stable mutate function', async () => {
-        const mutation: CreateMutation = {
-            type: 'create',
-            resource: 'answer',
-            data: { answer: '?' },
-        }
-        const data = { answer: 42 }
-        const wrapper = ({ children }: { children?: React.ReactNode }) => (
-            <CustomDataProvider data={data}>{children}</CustomDataProvider>
-        )
-
-        const { result } = renderHook(() => useDataMutation(mutation), {
-            wrapper,
-        })
-
-        const [firstMutate] = result.current
-
-        await act(async () => {
-            await firstMutate({ variable: 'variable' })
-        })
-
-        const [secondMutate, state] = result.current
-        expect(state).toMatchObject({
-            loading: false,
-            called: true,
-        })
-        expect(firstMutate).toBe(secondMutate)
-    })
-
-    it('should resolve with the data from mutate on success', async () => {
-        const mutation: CreateMutation = {
-            type: 'create',
-            resource: 'answer',
-            data: { answer: '?' },
-        }
-        const data = { answer: 42 }
-        const wrapper = ({ children }: { children?: React.ReactNode }) => (
-            <CustomDataProvider data={data}>{children}</CustomDataProvider>
-        )
-
-        const { result } = renderHook(() => useDataMutation(mutation), {
-            wrapper,
-        })
-
-        let mutatePromise!: Promise<unknown>
-        const [mutate] = result.current
-        act(() => {
-            mutatePromise = mutate()
-        })
-
-        await waitFor(() => {
-            const [, state] = result.current
-            expect(state).toMatchObject({
-                loading: false,
-                called: true,
-                data: 42,
-            })
-            expect(mutatePromise).resolves.toBe(42)
-        })
-    })
-})

package/src/react/hooks/useDataMutation.ts

@@ -1,42 +0,0 @@
-import type {
-    QueryOptions,
-    Mutation,
-    QueryExecuteOptions,
-} from '@dhis2/data-engine'
-import { useCallback } from 'react'
-import { MutationRenderInput } from '../../types'
-import { useDataEngine } from './useDataEngine'
-import { useQueryExecutor } from './useQueryExecutor'
-import { useStaticInput } from './useStaticInput'
-
-const empty = {}
-export const useDataMutation = (
-    mutation: Mutation,
-    { onComplete, onError, variables = empty, lazy = true }: QueryOptions = {}
-): MutationRenderInput => {
-    const engine = useDataEngine()
-    const [theMutation] = useStaticInput<Mutation>(mutation, {
-        warn: true,
-        name: 'mutation',
-    })
-    const execute = useCallback(
-        (options: QueryExecuteOptions) => engine.mutate(theMutation, options),
-        [engine, theMutation]
-    )
-    const {
-        refetch: mutate,
-        called,
-        loading,
-        error,
-        data,
-    } = useQueryExecutor({
-        execute,
-        variables,
-        singular: false,
-        immediate: !lazy,
-        onComplete,
-        onError,
-    })
-
-    return [mutate, { engine, called, loading, error, data }]
-}