fix: improve types for useDataQuery

Author: Birkbjo

services/data/src/engine/types/Query.ts

@@ -21,6 +21,16 @@ export interface ResolvedResourceQuery extends ResourceQuery {
 export type Query = Record<string, ResourceQuery>
 export type QueryResult = JsonMap
 
+export type DataResultForQuery<TQuery = Query> = {
+    [key in keyof TQuery]: JsonMap
+}
+
+export type GetModelTypesForQuery<TQuery extends Query, Models> = {
+    [K in keyof TQuery]: TQuery[K]['resource'] extends keyof Models
+        ? Models[TQuery[K]['resource']]
+        : JsonMap
+}
+
 export interface QueryOptions {
     variables?: QueryVariables
     onComplete?: (data: QueryResult) => void

services/data/src/react/hooks/useDataQuery.ts

@@ -1,13 +1,23 @@
+import {
+    DataResultForQuery,
+    QueryResultForQuery,
+} from './../../engine/types/Query'
 import { useState, useRef, useCallback, useDebugValue } from 'react'
 import { useQuery, setLogger } from 'react-query'
 import type {
     Query,
     QueryOptions,
     QueryResult,
+    QueryResultForQuery,
     QueryVariables,
 } from '../../engine'
 import type { FetchError } from '../../engine/types/FetchError'
-import type { QueryRenderInput, QueryRefetchFunction } from '../../types'
+import type {
+    QueryRenderInput,
+    QueryRefetchFunction,
+    UseDataQueryResult,
+    UseDataQueryResultWithModels,
+} from '../../types'
 import { mergeAndCompareVariables } from './mergeAndCompareVariables'
 import { useDataEngine } from './useDataEngine'
 import { useStaticInput } from './useStaticInput'
@@ -33,16 +43,19 @@ type QueryState = {
     refetchCallback?: (data: any) => void
 }
 
-export const useDataQuery = <TQueryResult = QueryResult>(
-    query: Query,
+export const useDataQuery = <
+    TQuery extends Query,
+    TDataResult extends DataResultForQuery<TQuery> = DataResultForQuery<TQuery>
+>(
+    query: TQuery,
     {
         onComplete: userOnSuccess,
         onError: userOnError,
         variables: initialVariables = {},
         lazy: initialLazy = false,
     }: QueryOptions = {}
-): QueryRenderInput<TQueryResult> => {
-    const [staticQuery] = useStaticInput<Query>(query, {
+): UseDataQueryResult<TDataResult> => {
+    const [staticQuery] = useStaticInput<TQuery>(query, {
         warn: true,
         name: 'query',
     })

services/data/src/types.ts

@@ -2,7 +2,13 @@ import DataEngine from './engine/DataEngine'
 import { QueryExecuteOptions } from './engine/types/ExecuteOptions'
 import { FetchError } from './engine/types/FetchError'
 import { JsonValue } from './engine/types/JsonValue'
-import { QueryVariables, QueryResult } from './engine/types/Query'
+import {
+    Query,
+    QueryVariables,
+    QueryResult,
+    DataResultForQuery,
+    GetModelTypesForQuery,
+} from './engine/types/Query'
 
 export interface ContextType {
     engine: DataEngine
@@ -40,20 +46,27 @@ export interface ExecuteHookResult<ReturnType> {
     data?: ReturnType
 }
 
-export interface QueryState<TQueryResult> {
+export interface QueryState<Data = QueryResult> {
     called: boolean
     loading: boolean
     fetching: boolean
     error?: FetchError
-    data?: TQueryResult
+    data?: Data
 }
 
-export interface QueryRenderInput<TQueryResult = QueryResult>
-    extends QueryState<TQueryResult> {
+export interface QueryRenderInput<DataResult = QueryResult>
+    extends QueryState<DataResult> {
     engine: DataEngine
     refetch: QueryRefetchFunction
 }
 
+export type UseDataQueryResult<DataResult> = QueryRenderInput<DataResult>
+
+export type UseDataQueryResultWithModels<
+    TQuery extends Query,
+    Models
+> = QueryRenderInput<GetModelTypesForQuery<TQuery, Models>>
+
 export interface MutationState {
     engine: DataEngine
     called: boolean