npm - react-query-lightbase-codegen - Versions diffs - 0.0.17 → 0.0.18 - Mend

react-query-lightbase-codegen 0.0.17 → 0.0.18

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (5) hide show

package/lib/cjs/import-open-api.js +213 -67
package/lib/cjs/react-query-codegen-import.js +8 -2
package/lib/esm/import-open-api.js +213 -67
package/lib/esm/react-query-codegen-import.js +8 -2
package/package.json +1 -1

package/lib/cjs/import-open-api.js CHANGED Viewed

@@ -399,35 +399,49 @@ const generateRestfulComponent = ({ operation, verb, route, operationIds, parame
     // QUERIES
     if (!requestBodyComponent && paramsInPath.length && !queryParam && !headerParam) {
         output += `
+    type ${componentName}Response = ${genericsTypes}
     type ${componentName}Variables = {
       ${paramsTypes}
     }
     use${componentName}Query.fetch = async (props: ${componentName}Variables ) => {
-      const result = await api.${verb}<${genericsTypes}>(\`${route.replace(/\{/g, '{props.')}\`);
+      const result = await api.${verb}<${componentName}Response>(\`${route.replace(/\{/g, '{props.')}\`);
       return result.data;
     }
     use${componentName}Query.baseKey = (): QueryKey => ["${componentName.toLowerCase()}"];
     use${componentName}Query.queryKey = (params: ${componentName}Variables ): QueryKey => [...use${componentName}Query.baseKey(), params];
-    type ${componentName}QueryProps<T = ${genericsTypes}> = ${componentName}Variables & {
-      options?: UseQueryOptions<${genericsTypes}, AxiosError, T, any>
+    use${componentName}Query.updateCache = (
+      params: ${componentName}Variables,
+      updater: Updater<${componentName}Response | undefined, ${componentName}Response>,
+      options?: SetDataOptions | undefined
+    ) => queryClient.setQueryData<${componentName}Response>(use${componentName}Query.queryKey(params), updater, options);
+    use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
+    queryClient.prefetchQuery<${componentName}Response>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
+    use${componentName}Query.invalidate = (params: ${componentName}Variables) =>
+      queryClient.invalidateQueries<${componentName}Response>(use${componentName}Query.queryKey(params));
+    type ${componentName}QueryProps<T = ${componentName}Response> = ${componentName}Variables & {
+      options?: UseQueryOptions<${componentName}Response, AxiosError, T, any>
     }
-    export function use${componentName}Query<T = ${genericsTypes}>({ options = {}, ...props }: ${componentName}QueryProps<T>) {
+    export function use${componentName}Query<T = ${componentName}Response>({ options = {}, ...props }: ${componentName}QueryProps<T>) {
       return useQuery(use${componentName}Query.queryKey(props), async () => use${componentName}Query.fetch(props),
       { enabled: !!props.${paramsInPath.join(' && !!props.')}, ...options }
     );}
     type ${componentName}MutationProps<T> = {
-      options?: UseMutationOptions<${genericsTypes}, AxiosError, ${componentName}Variables, T>
+      options?: UseMutationOptions<${componentName}Response, AxiosError, ${componentName}Variables, T>
     }
-    export function use${componentName}Mutation<T = ${genericsTypes}>(props?: ${componentName}MutationProps<T>) {
+    export function use${componentName}Mutation<T = ${componentName}Response>(props?: ${componentName}MutationProps<T>) {
       return useMutation(async (data) => use${componentName}Query.fetch(data),
     props?.options
   )};`;
     }
     if (!requestBodyComponent && paramsInPath.length && queryParam && !headerParam) {
         output += `
+    type ${componentName}Response = ${genericsTypes}
     type ${componentName}Variables = {
       ${paramsTypes}
       ${queryParamsType};
@@ -436,75 +450,114 @@ const generateRestfulComponent = ({ operation, verb, route, operationIds, parame
     use${componentName}Query.fetch = async (props:${componentName}Variables) => {
       const {${paramsInPath.join(', ')}, ...queryParams} = props
       const params = queryString.stringify(queryParams);
-      const result = await api.${verb}<${genericsTypes}>(\`${route}?\${params}\`)
+      const result = await api.${verb}<${componentName}Response>(\`${route}?\${params}\`)
       return result.data;
     }
     use${componentName}Query.baseKey = (): QueryKey => ["${componentName.toLowerCase()}"];
-    use${componentName}Query.queryKey = (params:${componentName}Variables): QueryKey => [...use${componentName}Query.baseKey(), params];
+    use${componentName}Query.queryKey = (params: ${componentName}Variables ): QueryKey => [...use${componentName}Query.baseKey(), params];
+    use${componentName}Query.updateCache = (
+      params: ${componentName}Variables,
+      updater: Updater<${componentName}Response | undefined, ${componentName}Response>,
+      options?: SetDataOptions | undefined
+    ) => queryClient.setQueryData<${componentName}Response>(use${componentName}Query.queryKey(params), updater, options);
+    use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
+    queryClient.prefetchQuery<${componentName}Response>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
-    type ${componentName}QueryProps<T = ${genericsTypes}> ${componentName}Variables & {
-      options?: UseQueryOptions<${genericsTypes}, AxiosError, T, any>
+    use${componentName}Query.invalidate = (params: ${componentName}Variables) =>
+      queryClient.invalidateQueries<${componentName}Response>(use${componentName}Query.queryKey(params));
+    type ${componentName}QueryProps<T = ${componentName}Response> ${componentName}Variables & {
+      options?: UseQueryOptions<${componentName}Response, AxiosError, T, any>
     }
-    export function use${componentName}Query<T = ${genericsTypes}>({ options = {}, ...props }: ${componentName}QueryProps<T>) {
+    export function use${componentName}Query<T = ${componentName}Response>({ options = {}, ...props }: ${componentName}QueryProps<T>) {
     return useQuery(use${componentName}Query.queryKey(props), async () => use${componentName}Query.fetch(props), { enabled: !!props.${paramsInPath.join(' && !!props.')}, ...options }
     );}
     type ${componentName}MutationProps<T> = {
-      options?: UseMutationOptions<${genericsTypes}, AxiosError, ${componentName}Variables, T>
+      options?: UseMutationOptions<${componentName}Response, AxiosError, ${componentName}Variables, T>
     }
-    export function use${componentName}Mutation<T = ${genericsTypes}>(props?: ${componentName}MutationProps<T>) {
+    export function use${componentName}Mutation<T = ${componentName}Response>(props?: ${componentName}MutationProps<T>) {
     return useMutation(async (data) => use${componentName}Query.fetch(data),
     props?.options
   )};`;
     }
     if (!requestBodyComponent && !paramsInPath.length && !queryParam && !headerParam) {
         output += `
+    type ${componentName}Response = ${genericsTypes}
     use${componentName}Query.fetch = async () => {
-      const result = await api.${verb}<${genericsTypes}>(\`${route}\`);
+      const result = await api.${verb}<${componentName}Response>(\`${route}\`);
       return result.data;
     }
     use${componentName}Query.baseKey = (): QueryKey => ["${componentName.toLowerCase()}"];
     use${componentName}Query.queryKey = (): QueryKey => use${componentName}Query.baseKey()
-    type ${componentName}QueryProps<T = ${genericsTypes}> = {
-      options?: UseQueryOptions<${genericsTypes}, AxiosError, T, any>
+    use${componentName}Query.updateCache = (
+      params: ${componentName}Variables,
+      updater: Updater<${componentName}Response | undefined, ${componentName}Response>,
+      options?: SetDataOptions | undefined
+    ) => queryClient.setQueryData<${componentName}Response>(use${componentName}Query.queryKey(params), updater, options);
+    use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
+    queryClient.prefetchQuery<${componentName}Response>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
+    use${componentName}Query.invalidate = (params: ${componentName}Variables) =>
+      queryClient.invalidateQueries<${componentName}Response>(use${componentName}Query.queryKey(params));
+    type ${componentName}QueryProps<T = ${componentName}Response> = {
+      options?: UseQueryOptions<${componentName}Response, AxiosError, T, any>
     }
-    export function use${componentName}Query<T = ${genericsTypes}>(props?: ${componentName}QueryProps<T>) {
+    export function use${componentName}Query<T = ${componentName}Response>(props?: ${componentName}QueryProps<T>) {
       return useQuery(use${componentName}Query.queryKey(), use${componentName}Query.fetch, props?.options
       );}
       type ${componentName}MutationProps<T> = {
-        options?: UseMutationOptions<${genericsTypes}, AxiosError, void, T>
+        options?: UseMutationOptions<${componentName}Response, AxiosError, void, T>
       }
-      export function use${componentName}Mutation<T = ${genericsTypes}>(props?: ${componentName}MutationProps<T>) {
+      export function use${componentName}Mutation<T = ${componentName}Response>(props?: ${componentName}MutationProps<T>) {
       return useMutation(async () => use${componentName}Query.fetch(),
       props?.options
     )};`;
     }
     if (!requestBodyComponent && !paramsInPath.length && queryParam && !headerParam) {
         output += `
+    type ${componentName}Response = ${genericsTypes}
     type ${componentName}Variables = {
       ${queryParamsType}
     }
-    use${componentName}Query.baseKey = (): QueryKey => ["${componentName.toLowerCase()}"];
-    use${componentName}Query.queryKey = (params: ${componentName}Variables ): QueryKey => [...use${componentName}Query.baseKey(), params];
     use${componentName}Query.fetch = async (props: ${componentName}Variables) => {
       const params = queryString.stringify({${queryParams
             .map((param) => `"${param.name}": props["${param.name}"]`)
             .join(',')}});
-      const result = await api.${verb}<${genericsTypes}>(\`${route}?\${params}\`)
+      const result = await api.${verb}<${componentName}Response>(\`${route}?\${params}\`)
       return result.data;
     }
-    export function use${componentName}Query<T = ${genericsTypes}>({ options = {}, ...props }: ${componentName}Variables & { options?: UseQueryOptions<${genericsTypes}, AxiosError, T, any>}) {
+    use${componentName}Query.baseKey = (): QueryKey => ["${componentName.toLowerCase()}"];
+    use${componentName}Query.queryKey = (params: ${componentName}Variables ): QueryKey => [...use${componentName}Query.baseKey(), params];
+    use${componentName}Query.updateCache = (
+      params: ${componentName}Variables,
+      updater: Updater<${componentName}Response | undefined, ${componentName}Response>,
+      options?: SetDataOptions | undefined
+    ) => queryClient.setQueryData<${componentName}Response>(use${componentName}Query.queryKey(params), updater, options);
+    use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
+    queryClient.prefetchQuery<${componentName}Response>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
+    use${componentName}Query.invalidate = (params: ${componentName}Variables) =>
+      queryClient.invalidateQueries<${componentName}Response>(use${componentName}Query.queryKey(params));
+    export function use${componentName}Query<T = ${componentName}Response>({ options = {}, ...props }: ${componentName}Variables & { options?: UseQueryOptions<${componentName}Response, AxiosError, T, any>}) {
     return useQuery(use${componentName}Query.queryKey(props), async () => use${componentName}Query.fetch(props),
     { enabled: !!props${queryParams.map((param) => `["${param.name}"]`).join(' && !!props')}, ...options }
     );}
-    export function use${componentName}Mutation<T = ${genericsTypes}>(props?: { options?: UseMutationOptions<${genericsTypes}, AxiosError, ${componentName}Variables, T>}) {
+    export function use${componentName}Mutation<T = ${componentName}Response>(props?: { options?: UseMutationOptions<${componentName}Response, AxiosError, ${componentName}Variables, T>}) {
       return useMutation(async (data) => use${componentName}Query.fetch(data),
       props?.options
     )};
@@ -512,67 +565,96 @@ const generateRestfulComponent = ({ operation, verb, route, operationIds, parame
     }
     if (requestBodyComponent && !paramsInPath.length && !queryParam && !headerParam) {
         output += `
+    type ${componentName}Response = ${genericsTypes}
     type ${componentName}Variables = ${requestBodyComponent};
     use${componentName}Query.fetch = async (body: ${componentName}Variables) => {
-      const result = await api.${verb}<${genericsTypes}>(\`${route}\`, body)
+      const result = await api.${verb}<${componentName}Response>(\`${route}\`, body)
         return result.data
       }
     use${componentName}Query.baseKey = (): QueryKey => ["${componentName.toLowerCase()}"];
     use${componentName}Query.queryKey = (params: ${componentName}Variables ): QueryKey => [...use${componentName}Query.baseKey(), params];
-    type ${componentName}QueryProps<T = ${genericsTypes}> = ${componentName}Variables & {
-      options?: UseQueryOptions<${genericsTypes}, AxiosError, T, any>
+    use${componentName}Query.updateCache = (
+      params: ${componentName}Variables,
+      updater: Updater<${componentName}Response | undefined, ${componentName}Response>,
+      options?: SetDataOptions | undefined
+    ) => queryClient.setQueryData<${componentName}Response>(use${componentName}Query.queryKey(params), updater, options);
+    use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
+    queryClient.prefetchQuery<${componentName}Response>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
+    use${componentName}Query.invalidate = (params: ${componentName}Variables) =>
+      queryClient.invalidateQueries<${componentName}Response>(use${componentName}Query.queryKey(params));
+    type ${componentName}QueryProps<T = ${componentName}Response> = ${componentName}Variables & {
+      options?: UseQueryOptions<${componentName}Response, AxiosError, T, any>
     }
-    export function use${componentName}Query<T = ${genericsTypes}>({ options = {}, ...body }: ${componentName}QueryProps<T>) {
+    export function use${componentName}Query<T = ${componentName}Response>({ options = {}, ...body }: ${componentName}QueryProps<T>) {
       return useQuery(use${componentName}Query.queryKey(body), async () => use${componentName}Query.fetch(body), options
     );}
     type ${componentName}MutationProps<T> = {
-      options?: UseMutationOptions<${genericsTypes}, AxiosError, ${componentName}Variables, T>
+      options?: UseMutationOptions<${componentName}Response, AxiosError, ${componentName}Variables, T>
     }
-    export function use${componentName}Mutation<T = ${genericsTypes}>(props?: ${componentName}MutationProps<T>) {
+    export function use${componentName}Mutation<T = ${componentName}Response>(props?: ${componentName}MutationProps<T>) {
       return useMutation(async (body) => use${componentName}Query.fetch(body),
     props?.options
   )};`;
     }
     if (requestBodyComponent && paramsInPath.length && !queryParam && !headerParam) {
         output += `
+    type ${componentName}Response = ${genericsTypes}
     type ${componentName}Variables = ${requestBodyComponent} & {${paramsTypes}}
-    type ${componentName}QueryProps<T = ${genericsTypes}> =  ${componentName}Variables & {
-      options?: UseQueryOptions<${genericsTypes}, AxiosError, T, any>
+    type ${componentName}QueryProps<T = ${componentName}Response> =  ${componentName}Variables & {
+      options?: UseQueryOptions<${componentName}Response, AxiosError, T, any>
     }
     use${componentName}Query.fetch = async (props: ${componentName}Variables) => {
       const {${paramsInPath.join(', ')}, ...body} = props
-      const result = await api.${verb}<${genericsTypes}>(\`${route}\`, body)
+      const result = await api.${verb}<${componentName}Response>(\`${route}\`, body)
       return result.data
     }
     use${componentName}Query.baseKey = (): QueryKey => ["${componentName.toLowerCase()}"];
     use${componentName}Query.queryKey = (params: ${componentName}Variables ): QueryKey => [...use${componentName}Query.baseKey(), params];
-    export function use${componentName}Query<T = ${genericsTypes}>({ options = {}, ...props }: ${componentName}QueryProps<T>) {
+    use${componentName}Query.updateCache = (
+      params: ${componentName}Variables,
+      updater: Updater<${componentName}Response | undefined, ${componentName}Response>,
+      options?: SetDataOptions | undefined
+    ) => queryClient.setQueryData<${componentName}Response>(use${componentName}Query.queryKey(params), updater, options);
+    use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
+    queryClient.prefetchQuery<${componentName}Response>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
+    use${componentName}Query.invalidate = (params: ${componentName}Variables) =>
+      queryClient.invalidateQueries<${componentName}Response>(use${componentName}Query.queryKey(params));
+    export function use${componentName}Query<T = ${componentName}Response>({ options = {}, ...props }: ${componentName}QueryProps<T>) {
     return useQuery(use${componentName}Query.queryKey(props), async () =>  use${componentName}Query.fetch(props), { enabled: !!props.${paramsInPath.join(' && !!props.')}, ...options }
     );}
     type ${componentName}MutationProps<T> = {
-      options?: UseMutationOptions<${genericsTypes}, AxiosError, ${componentName}Variables, T>
+      options?: UseMutationOptions<${componentName}Response, AxiosError, ${componentName}Variables, T>
     }
-    export function use${componentName}Mutation<T = ${genericsTypes}>(props?: ${componentName}MutationProps<T>) {
+    export function use${componentName}Mutation<T = ${componentName}Response>(props?: ${componentName}MutationProps<T>) {
     return useMutation(async (body) => use${componentName}Query.fetch(body),
    props?.options
   )};`;
     }
     if (requestBodyComponent && !paramsInPath.length && queryParam && !headerParam) {
         output += `
+    type ${componentName}Response = ${genericsTypes}
     type ${componentName}Variables = ${requestBodyComponent} & {
       ${queryParamsType}
     }
-    type ${componentName}QueryProps<T = ${genericsTypes}> = ${componentName}Variables & {
-      options?: UseQueryOptions<${genericsTypes}, AxiosError, T, any>
+    type ${componentName}QueryProps<T = ${componentName}Response> = ${componentName}Variables & {
+      options?: UseQueryOptions<${componentName}Response, AxiosError, T, any>
     }
     use${componentName}Query.fetch = async (props: ${componentName}Variables) => {
@@ -582,13 +664,26 @@ const generateRestfulComponent = ({ operation, verb, route, operationIds, parame
       const params = queryString.stringify({
         ${queryParams.map((param) => `["${param.name}"]: props["${param.name}"]`).join(',')}
       });
-      const result = await api.${verb}<${genericsTypes}>(\`${route}?\${params}\`, body)
+      const result = await api.${verb}<${componentName}Response>(\`${route}?\${params}\`, body)
       return result.data
     }
     use${componentName}Query.baseKey = (): QueryKey => ["${componentName.toLowerCase()}"];
     use${componentName}Query.queryKey = (params: ${componentName}Variables ): QueryKey => [...use${componentName}Query.baseKey(), params];
-    export function use${componentName}Query<T = ${genericsTypes}>({ options = {}, ...props }: ${componentName}QueryProps<T>) {
+    use${componentName}Query.updateCache = (
+      params: ${componentName}Variables,
+      updater: Updater<${componentName}Response | undefined, ${componentName}Response>,
+      options?: SetDataOptions | undefined
+    ) => queryClient.setQueryData<${componentName}Response>(use${componentName}Query.queryKey(params), updater, options);
+    use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
+    queryClient.prefetchQuery<${componentName}Response>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
+    use${componentName}Query.invalidate = (params: ${componentName}Variables) =>
+      queryClient.invalidateQueries<${componentName}Response>(use${componentName}Query.queryKey(params));
+    export function use${componentName}Query<T = ${componentName}Response>({ options = {}, ...props }: ${componentName}QueryProps<T>) {
     return useQuery(use${componentName}Query.queryKey(props), async () =>  use${componentName}Query.fetch(props), { enabled: !!props${queryParams
             .map((param) => `["${param.name}"]`)
             .join(' && !!props')}, ...options }
@@ -596,9 +691,9 @@ const generateRestfulComponent = ({ operation, verb, route, operationIds, parame
     type ${componentName}MutationProps<T> = {
-      options?: UseMutationOptions<${genericsTypes}, AxiosError, ${componentName}Variables, T>
+      options?: UseMutationOptions<${componentName}Response, AxiosError, ${componentName}Variables, T>
     }
-    export function use${componentName}Mutation<T = ${genericsTypes}>(props?: ${componentName}MutationProps<T>) {
+    export function use${componentName}Mutation<T = ${componentName}Response>(props?: ${componentName}MutationProps<T>) {
     return useMutation(async (body) => use${componentName}Query.fetch(body),
    props?.options
   )};`;
@@ -620,23 +715,36 @@ const generateRestfulComponent = ({ operation, verb, route, operationIds, parame
     }
     if (!requestBodyComponent && !paramsInPath.length && !queryParam && headerParam) {
         output += `
+    type ${componentName}Response = ${genericsTypes}
     type ${componentName}Variables = {
       ${headerParam}
     };
     use${componentName}Query.fetch = async (headers: ${componentName}Variables) => {
-      const result = await api.${verb}<${genericsTypes}>(\`${route}\`, {headers: headers});
+      const result = await api.${verb}<${componentName}Response>(\`${route}\`, {headers: headers});
       return result.data;
     }
     use${componentName}Query.baseKey = (): QueryKey => ["${componentName.toLowerCase()}"];
     use${componentName}Query.queryKey = (params: ${componentName}Variables ): QueryKey => [...use${componentName}Query.baseKey(), params];
-    type ${componentName}QueryProps<T = ${genericsTypes}> = ${componentName}Variables & {
-      options?: UseQueryOptions<${genericsTypes}, AxiosError, T, any>
+    use${componentName}Query.updateCache = (
+      params: ${componentName}Variables,
+      updater: Updater<${componentName}Response | undefined, ${componentName}Response>,
+      options?: SetDataOptions | undefined
+    ) => queryClient.setQueryData<${componentName}Response>(use${componentName}Query.queryKey(params), updater, options);
+    use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
+    queryClient.prefetchQuery<${componentName}Response>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
+    use${componentName}Query.invalidate = (params: ${componentName}Variables) =>
+      queryClient.invalidateQueries<${componentName}Response>(use${componentName}Query.queryKey(params));
+    type ${componentName}QueryProps<T = ${componentName}Response> = ${componentName}Variables & {
+      options?: UseQueryOptions<${componentName}Response, AxiosError, T, any>
     }
-    export function use${componentName}Query<T = ${genericsTypes}>({ options = {}, ...props }: ${componentName}QueryProps<T>) {
+    export function use${componentName}Query<T = ${componentName}Response>({ options = {}, ...props }: ${componentName}QueryProps<T>) {
       return useQuery(use${componentName}Query.queryKey(props), async () => use${componentName}Query.fetch(props),
       { enabled: !!props${headerParams.map((param) => `["${param.name}"]`).join(' && !!props')}, ...options }
       );}
@@ -644,15 +752,17 @@ const generateRestfulComponent = ({ operation, verb, route, operationIds, parame
       type ${componentName}MutationProps<T> = {
-        options?: UseMutationOptions<${genericsTypes}, AxiosError, ${componentName}Variables, T>
+        options?: UseMutationOptions<${componentName}Response, AxiosError, ${componentName}Variables, T>
       }
-      export function use${componentName}Mutation<T = ${genericsTypes}>(props?: ${componentName}MutationProps<T>) {
+      export function use${componentName}Mutation<T = ${componentName}Response>(props?: ${componentName}MutationProps<T>) {
       return useMutation(async (data) => use${componentName}Query.fetch(data),
       props?.options
     )};`;
     }
     if (!requestBodyComponent && !paramsInPath.length && queryParam && headerParam) {
         output += `
+    type ${componentName}Response = ${genericsTypes}
     type ${componentName}Variables = {
       ${headerParam}
       ${queryParamsType};
@@ -660,21 +770,33 @@ const generateRestfulComponent = ({ operation, verb, route, operationIds, parame
     use${componentName}Query.fetch = async (data: ${componentName}Variables) => {
       const params = queryString.stringify({
-        ${queryParams.map((param) => `${param.name}: data.${param.name}`).join(',')}
+        ${queryParams.map((p) => `"${p.name}": data["${p.name}"]`).join(',')}
       });
       const headers = {
-        ${headerParams.map((param) => `"${param.name}": data["${param.name}"]`).join(',')}
+        ${headerParams.map((p) => `"${p.name}": data["${p.name}"]`).join(',')}
       }
-      const result = await api.${verb}<${genericsTypes}>(\`${route}?\${params}\`, {headers})
+      const result = await api.${verb}<${componentName}Response>(\`${route}?\${params}\`, {headers})
       return result.data;
     }
     use${componentName}Query.baseKey = (): QueryKey => ["${componentName.toLowerCase()}"];
     use${componentName}Query.queryKey = (params: ${componentName}Variables ): QueryKey => [...use${componentName}Query.baseKey(), params];
-    type ${componentName}QueryProps<T = ${genericsTypes}> = ${componentName}Variables & {
-      options?: UseQueryOptions<${genericsTypes}, AxiosError, T, any>
+    use${componentName}Query.updateCache = (
+      params: ${componentName}Variables,
+      updater: Updater<${componentName}Response | undefined, ${componentName}Response>,
+      options?: SetDataOptions | undefined
+    ) => queryClient.setQueryData<${componentName}Response>(use${componentName}Query.queryKey(params), updater, options);
+    use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
+      queryClient.prefetchQuery<${componentName}Response>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
+    use${componentName}Query.invalidate = (params: ${componentName}Variables) =>
+      queryClient.invalidateQueries<${componentName}Response>(use${componentName}Query.queryKey(params));
+    type ${componentName}QueryProps<T = ${componentName}Response> = ${componentName}Variables & {
+      options?: UseQueryOptions<${componentName}Response, AxiosError, T, any>
     }
-    export function use${componentName}Query<T = ${genericsTypes}>({ options = {}, ...props }: ${componentName}QueryProps<T>) {
+    export function use${componentName}Query<T = ${componentName}Response>({ options = {}, ...props }: ${componentName}QueryProps<T>) {
     return useQuery(use${componentName}Query.queryKey(props), async () => use${componentName}Query.fetch(props),
     { enabled: !!props${[...queryParams, ...headerParams]
             .map((param) => `["${param.name}"]`)
@@ -682,16 +804,18 @@ const generateRestfulComponent = ({ operation, verb, route, operationIds, parame
     );}
     type ${componentName}MutationProps<T> = {
-      options?: UseMutationOptions<${genericsTypes}, AxiosError, ${componentName}Variables, T>
+      options?: UseMutationOptions<${componentName}Response, AxiosError, ${componentName}Variables, T>
     }
-    export function use${componentName}Mutation<T = ${genericsTypes}>(props?: ${componentName}MutationProps<T>) {
+    export function use${componentName}Mutation<T = ${componentName}Response>(props?: ${componentName}MutationProps<T>) {
     return useMutation(async (data) => use${componentName}Query.fetch(data),
     props?.options
   )};`;
     }
     if (requestBodyComponent && !paramsInPath.length && !queryParam && headerParam) {
         output += `
+    type ${componentName}Response = ${genericsTypes}
     type ${componentName}Variables = ${requestBodyComponent} & {
       ${headerParam}
     };
@@ -700,16 +824,29 @@ const generateRestfulComponent = ({ operation, verb, route, operationIds, parame
       const headers = {
         ${headerParams.map((param) => `"${param.name}": body["${param.name}"]`).join(',')}
       }
-      const result = await api.${verb}<${genericsTypes}>(\`${route}\`, body, {headers})
+      const result = await api.${verb}<${componentName}Response>(\`${route}\`, body, {headers})
         return result.data
       }
     use${componentName}Query.baseKey = (): QueryKey => ["${componentName.toLowerCase()}"];
     use${componentName}Query.queryKey = (params: ${componentName}Variables ): QueryKey => [...use${componentName}Query.baseKey(), params];
-    type ${componentName}QueryProps<T = ${genericsTypes}> = ${componentName}Variables & {
-      options?: UseQueryOptions<${genericsTypes}, AxiosError, T, any>
+    use${componentName}Query.updateCache = (
+      params: ${componentName}Variables,
+      updater: Updater<${componentName}Response | undefined, ${componentName}Response>,
+      options?: SetDataOptions | undefined
+    ) => queryClient.setQueryData<${componentName}Response>(use${componentName}Query.queryKey(params), updater, options);
+    use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
+    queryClient.prefetchQuery<${componentName}Response>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
+    use${componentName}Query.invalidate = (params: ${componentName}Variables) =>
+      queryClient.invalidateQueries<${componentName}Response>(use${componentName}Query.queryKey(params));
+    type ${componentName}QueryProps<T = ${componentName}Response> = ${componentName}Variables & {
+      options?: UseQueryOptions<${componentName}Response, AxiosError, T, any>
     }
-    export function use${componentName}Query<T = ${genericsTypes}>({ options = {}, ...body }: ${componentName}QueryProps<T>) {
+    export function use${componentName}Query<T = ${componentName}Response>({ options = {}, ...body }: ${componentName}QueryProps<T>) {
       return useQuery(use${componentName}Query.queryKey(body), async () => use${componentName}Query.fetch(body),{ enabled: !!body${headerParams
             .map((param) => `["${param.name}"]`)
             .join(' && !!props')}, ...options }
@@ -717,9 +854,9 @@ const generateRestfulComponent = ({ operation, verb, route, operationIds, parame
     type ${componentName}MutationProps<T> = {
-      options?: UseMutationOptions<${genericsTypes}, AxiosError, ${componentName}Variables, T>
+      options?: UseMutationOptions<${componentName}Response, AxiosError, ${componentName}Variables, T>
     }
-    export function use${componentName}Mutation<T = ${genericsTypes}>(props?: ${componentName}MutationProps<T>) {
+    export function use${componentName}Mutation<T = ${componentName}Response>(props?: ${componentName}MutationProps<T>) {
     return useMutation(async (body) => use${componentName}Query.fetch(body),
     props?.options
   )};`;
@@ -753,17 +890,26 @@ const generateQueryHooks = (spec, operationIds, headerFilters) => {
 /**
  * Main entry of the generator. Generate react-query component from openAPI.
  */
-const importOpenApi = async ({ data, format, apiDir, headerFilters = [], }) => {
+const importOpenApi = async ({ data, format, apiDirectory, queryClientDir, headerFilters = [], }) => {
     const operationIds = [];
     let specs = await importSpecs(data, format);
-    console.log(JSON.stringify(Object.keys(specs), null, 2));
     (0, exports.resolveDiscriminator)(specs);
     let output = '';
     output = `
-  import { useQuery, useMutation, UseQueryOptions, UseMutationOptions, QueryKey } from 'react-query';
+  import {
+    useQuery,
+    useMutation,
+    UseQueryOptions,
+    UseMutationOptions,
+    QueryKey,
+    SetDataOptions,
+  } from 'react-query';
+  import { Updater } from 'react-query/types/core/utils';
   import queryString from 'query-string';
   import {AxiosError} from 'axios';
-  import { api } from '${apiDir}';
+  import { api } from '${apiDirectory}';
+  import { queryClient } from '${queryClientDir}';
   // SCEHMAS
   ${(0, exports.generateSchemasDefinition)(specs.components?.schemas)}

package/lib/cjs/react-query-codegen-import.js CHANGED Viewed

@@ -10,7 +10,7 @@ const path_1 = require("path");
 const import_open_api_1 = require("./import-open-api");
 const log = console.log; // tslint:disable-line:no-console
 const createSuccessMessage = (backend) => chalk_1.default.green(`🎉 ${backend ? `[${backend}] ` : ''} Your OpenAPI spec has been converted into react query hooks`);
-function importSpecs({ sourceDirectory, exportDirectory, apiDirectory, headerFilters, }) {
+function importSpecs({ sourceDirectory, exportDirectory, apiDirectory, queryClientDir, headerFilters, }) {
     (0, fs_1.readdir)(sourceDirectory, function (err, filenames) {
         if (err) {
             throw err;
@@ -21,7 +21,13 @@ function importSpecs({ sourceDirectory, exportDirectory, apiDirectory, headerFil
             const format = ['.yaml', '.yml'].includes(ext.toLowerCase()) ? 'yaml' : 'json';
             try {
                 const name = `useQueries${filename.split('.')[0]}.tsx`;
-                const fileExports = await (0, import_open_api_1.importOpenApi)({ data, format, apiDir: apiDirectory, headerFilters });
+                const fileExports = await (0, import_open_api_1.importOpenApi)({
+                    data,
+                    format,
+                    apiDirectory,
+                    headerFilters,
+                    queryClientDir,
+                });
                 (0, fs_1.writeFileSync)((0, path_1.join)(process.cwd(), `${exportDirectory}/${name}`), fileExports);
                 log(createSuccessMessage(filename));
             }

package/lib/esm/import-open-api.js CHANGED Viewed

@@ -379,35 +379,49 @@ export const generateRestfulComponent = ({ operation, verb, route, operationIds,
     // QUERIES
     if (!requestBodyComponent && paramsInPath.length && !queryParam && !headerParam) {
         output += `
+    type ${componentName}Response = ${genericsTypes}
     type ${componentName}Variables = {
       ${paramsTypes}
     }
     use${componentName}Query.fetch = async (props: ${componentName}Variables ) => {
-      const result = await api.${verb}<${genericsTypes}>(\`${route.replace(/\{/g, '{props.')}\`);
+      const result = await api.${verb}<${componentName}Response>(\`${route.replace(/\{/g, '{props.')}\`);
       return result.data;
     }
     use${componentName}Query.baseKey = (): QueryKey => ["${componentName.toLowerCase()}"];
     use${componentName}Query.queryKey = (params: ${componentName}Variables ): QueryKey => [...use${componentName}Query.baseKey(), params];
-    type ${componentName}QueryProps<T = ${genericsTypes}> = ${componentName}Variables & {
-      options?: UseQueryOptions<${genericsTypes}, AxiosError, T, any>
+    use${componentName}Query.updateCache = (
+      params: ${componentName}Variables,
+      updater: Updater<${componentName}Response | undefined, ${componentName}Response>,
+      options?: SetDataOptions | undefined
+    ) => queryClient.setQueryData<${componentName}Response>(use${componentName}Query.queryKey(params), updater, options);
+    use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
+    queryClient.prefetchQuery<${componentName}Response>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
+    use${componentName}Query.invalidate = (params: ${componentName}Variables) =>
+      queryClient.invalidateQueries<${componentName}Response>(use${componentName}Query.queryKey(params));
+    type ${componentName}QueryProps<T = ${componentName}Response> = ${componentName}Variables & {
+      options?: UseQueryOptions<${componentName}Response, AxiosError, T, any>
     }
-    export function use${componentName}Query<T = ${genericsTypes}>({ options = {}, ...props }: ${componentName}QueryProps<T>) {
+    export function use${componentName}Query<T = ${componentName}Response>({ options = {}, ...props }: ${componentName}QueryProps<T>) {
       return useQuery(use${componentName}Query.queryKey(props), async () => use${componentName}Query.fetch(props),
       { enabled: !!props.${paramsInPath.join(' && !!props.')}, ...options }
     );}
     type ${componentName}MutationProps<T> = {
-      options?: UseMutationOptions<${genericsTypes}, AxiosError, ${componentName}Variables, T>
+      options?: UseMutationOptions<${componentName}Response, AxiosError, ${componentName}Variables, T>
     }
-    export function use${componentName}Mutation<T = ${genericsTypes}>(props?: ${componentName}MutationProps<T>) {
+    export function use${componentName}Mutation<T = ${componentName}Response>(props?: ${componentName}MutationProps<T>) {
       return useMutation(async (data) => use${componentName}Query.fetch(data),
     props?.options
   )};`;
     }
     if (!requestBodyComponent && paramsInPath.length && queryParam && !headerParam) {
         output += `
+    type ${componentName}Response = ${genericsTypes}
     type ${componentName}Variables = {
       ${paramsTypes}
       ${queryParamsType};
@@ -416,75 +430,114 @@ export const generateRestfulComponent = ({ operation, verb, route, operationIds,
     use${componentName}Query.fetch = async (props:${componentName}Variables) => {
       const {${paramsInPath.join(', ')}, ...queryParams} = props
       const params = queryString.stringify(queryParams);
-      const result = await api.${verb}<${genericsTypes}>(\`${route}?\${params}\`)
+      const result = await api.${verb}<${componentName}Response>(\`${route}?\${params}\`)
       return result.data;
     }
     use${componentName}Query.baseKey = (): QueryKey => ["${componentName.toLowerCase()}"];
-    use${componentName}Query.queryKey = (params:${componentName}Variables): QueryKey => [...use${componentName}Query.baseKey(), params];
+    use${componentName}Query.queryKey = (params: ${componentName}Variables ): QueryKey => [...use${componentName}Query.baseKey(), params];
+    use${componentName}Query.updateCache = (
+      params: ${componentName}Variables,
+      updater: Updater<${componentName}Response | undefined, ${componentName}Response>,
+      options?: SetDataOptions | undefined
+    ) => queryClient.setQueryData<${componentName}Response>(use${componentName}Query.queryKey(params), updater, options);
+    use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
+    queryClient.prefetchQuery<${componentName}Response>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
-    type ${componentName}QueryProps<T = ${genericsTypes}> ${componentName}Variables & {
-      options?: UseQueryOptions<${genericsTypes}, AxiosError, T, any>
+    use${componentName}Query.invalidate = (params: ${componentName}Variables) =>
+      queryClient.invalidateQueries<${componentName}Response>(use${componentName}Query.queryKey(params));
+    type ${componentName}QueryProps<T = ${componentName}Response> ${componentName}Variables & {
+      options?: UseQueryOptions<${componentName}Response, AxiosError, T, any>
     }
-    export function use${componentName}Query<T = ${genericsTypes}>({ options = {}, ...props }: ${componentName}QueryProps<T>) {
+    export function use${componentName}Query<T = ${componentName}Response>({ options = {}, ...props }: ${componentName}QueryProps<T>) {
     return useQuery(use${componentName}Query.queryKey(props), async () => use${componentName}Query.fetch(props), { enabled: !!props.${paramsInPath.join(' && !!props.')}, ...options }
     );}
     type ${componentName}MutationProps<T> = {
-      options?: UseMutationOptions<${genericsTypes}, AxiosError, ${componentName}Variables, T>
+      options?: UseMutationOptions<${componentName}Response, AxiosError, ${componentName}Variables, T>
     }
-    export function use${componentName}Mutation<T = ${genericsTypes}>(props?: ${componentName}MutationProps<T>) {
+    export function use${componentName}Mutation<T = ${componentName}Response>(props?: ${componentName}MutationProps<T>) {
     return useMutation(async (data) => use${componentName}Query.fetch(data),
     props?.options
   )};`;
     }
     if (!requestBodyComponent && !paramsInPath.length && !queryParam && !headerParam) {
         output += `
+    type ${componentName}Response = ${genericsTypes}
     use${componentName}Query.fetch = async () => {
-      const result = await api.${verb}<${genericsTypes}>(\`${route}\`);
+      const result = await api.${verb}<${componentName}Response>(\`${route}\`);
       return result.data;
     }
     use${componentName}Query.baseKey = (): QueryKey => ["${componentName.toLowerCase()}"];
     use${componentName}Query.queryKey = (): QueryKey => use${componentName}Query.baseKey()
-    type ${componentName}QueryProps<T = ${genericsTypes}> = {
-      options?: UseQueryOptions<${genericsTypes}, AxiosError, T, any>
+    use${componentName}Query.updateCache = (
+      params: ${componentName}Variables,
+      updater: Updater<${componentName}Response | undefined, ${componentName}Response>,
+      options?: SetDataOptions | undefined
+    ) => queryClient.setQueryData<${componentName}Response>(use${componentName}Query.queryKey(params), updater, options);
+    use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
+    queryClient.prefetchQuery<${componentName}Response>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
+    use${componentName}Query.invalidate = (params: ${componentName}Variables) =>
+      queryClient.invalidateQueries<${componentName}Response>(use${componentName}Query.queryKey(params));
+    type ${componentName}QueryProps<T = ${componentName}Response> = {
+      options?: UseQueryOptions<${componentName}Response, AxiosError, T, any>
     }
-    export function use${componentName}Query<T = ${genericsTypes}>(props?: ${componentName}QueryProps<T>) {
+    export function use${componentName}Query<T = ${componentName}Response>(props?: ${componentName}QueryProps<T>) {
       return useQuery(use${componentName}Query.queryKey(), use${componentName}Query.fetch, props?.options
       );}
       type ${componentName}MutationProps<T> = {
-        options?: UseMutationOptions<${genericsTypes}, AxiosError, void, T>
+        options?: UseMutationOptions<${componentName}Response, AxiosError, void, T>
       }
-      export function use${componentName}Mutation<T = ${genericsTypes}>(props?: ${componentName}MutationProps<T>) {
+      export function use${componentName}Mutation<T = ${componentName}Response>(props?: ${componentName}MutationProps<T>) {
       return useMutation(async () => use${componentName}Query.fetch(),
       props?.options
     )};`;
     }
     if (!requestBodyComponent && !paramsInPath.length && queryParam && !headerParam) {
         output += `
+    type ${componentName}Response = ${genericsTypes}
     type ${componentName}Variables = {
       ${queryParamsType}
     }
-    use${componentName}Query.baseKey = (): QueryKey => ["${componentName.toLowerCase()}"];
-    use${componentName}Query.queryKey = (params: ${componentName}Variables ): QueryKey => [...use${componentName}Query.baseKey(), params];
     use${componentName}Query.fetch = async (props: ${componentName}Variables) => {
       const params = queryString.stringify({${queryParams
             .map((param) => `"${param.name}": props["${param.name}"]`)
             .join(',')}});
-      const result = await api.${verb}<${genericsTypes}>(\`${route}?\${params}\`)
+      const result = await api.${verb}<${componentName}Response>(\`${route}?\${params}\`)
       return result.data;
     }
-    export function use${componentName}Query<T = ${genericsTypes}>({ options = {}, ...props }: ${componentName}Variables & { options?: UseQueryOptions<${genericsTypes}, AxiosError, T, any>}) {
+    use${componentName}Query.baseKey = (): QueryKey => ["${componentName.toLowerCase()}"];
+    use${componentName}Query.queryKey = (params: ${componentName}Variables ): QueryKey => [...use${componentName}Query.baseKey(), params];
+    use${componentName}Query.updateCache = (
+      params: ${componentName}Variables,
+      updater: Updater<${componentName}Response | undefined, ${componentName}Response>,
+      options?: SetDataOptions | undefined
+    ) => queryClient.setQueryData<${componentName}Response>(use${componentName}Query.queryKey(params), updater, options);
+    use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
+    queryClient.prefetchQuery<${componentName}Response>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
+    use${componentName}Query.invalidate = (params: ${componentName}Variables) =>
+      queryClient.invalidateQueries<${componentName}Response>(use${componentName}Query.queryKey(params));
+    export function use${componentName}Query<T = ${componentName}Response>({ options = {}, ...props }: ${componentName}Variables & { options?: UseQueryOptions<${componentName}Response, AxiosError, T, any>}) {
     return useQuery(use${componentName}Query.queryKey(props), async () => use${componentName}Query.fetch(props),
     { enabled: !!props${queryParams.map((param) => `["${param.name}"]`).join(' && !!props')}, ...options }
     );}
-    export function use${componentName}Mutation<T = ${genericsTypes}>(props?: { options?: UseMutationOptions<${genericsTypes}, AxiosError, ${componentName}Variables, T>}) {
+    export function use${componentName}Mutation<T = ${componentName}Response>(props?: { options?: UseMutationOptions<${componentName}Response, AxiosError, ${componentName}Variables, T>}) {
       return useMutation(async (data) => use${componentName}Query.fetch(data),
       props?.options
     )};
@@ -492,67 +545,96 @@ export const generateRestfulComponent = ({ operation, verb, route, operationIds,
     }
     if (requestBodyComponent && !paramsInPath.length && !queryParam && !headerParam) {
         output += `
+    type ${componentName}Response = ${genericsTypes}
     type ${componentName}Variables = ${requestBodyComponent};
     use${componentName}Query.fetch = async (body: ${componentName}Variables) => {
-      const result = await api.${verb}<${genericsTypes}>(\`${route}\`, body)
+      const result = await api.${verb}<${componentName}Response>(\`${route}\`, body)
         return result.data
       }
     use${componentName}Query.baseKey = (): QueryKey => ["${componentName.toLowerCase()}"];
     use${componentName}Query.queryKey = (params: ${componentName}Variables ): QueryKey => [...use${componentName}Query.baseKey(), params];
-    type ${componentName}QueryProps<T = ${genericsTypes}> = ${componentName}Variables & {
-      options?: UseQueryOptions<${genericsTypes}, AxiosError, T, any>
+    use${componentName}Query.updateCache = (
+      params: ${componentName}Variables,
+      updater: Updater<${componentName}Response | undefined, ${componentName}Response>,
+      options?: SetDataOptions | undefined
+    ) => queryClient.setQueryData<${componentName}Response>(use${componentName}Query.queryKey(params), updater, options);
+    use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
+    queryClient.prefetchQuery<${componentName}Response>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
+    use${componentName}Query.invalidate = (params: ${componentName}Variables) =>
+      queryClient.invalidateQueries<${componentName}Response>(use${componentName}Query.queryKey(params));
+    type ${componentName}QueryProps<T = ${componentName}Response> = ${componentName}Variables & {
+      options?: UseQueryOptions<${componentName}Response, AxiosError, T, any>
     }
-    export function use${componentName}Query<T = ${genericsTypes}>({ options = {}, ...body }: ${componentName}QueryProps<T>) {
+    export function use${componentName}Query<T = ${componentName}Response>({ options = {}, ...body }: ${componentName}QueryProps<T>) {
       return useQuery(use${componentName}Query.queryKey(body), async () => use${componentName}Query.fetch(body), options
     );}
     type ${componentName}MutationProps<T> = {
-      options?: UseMutationOptions<${genericsTypes}, AxiosError, ${componentName}Variables, T>
+      options?: UseMutationOptions<${componentName}Response, AxiosError, ${componentName}Variables, T>
     }
-    export function use${componentName}Mutation<T = ${genericsTypes}>(props?: ${componentName}MutationProps<T>) {
+    export function use${componentName}Mutation<T = ${componentName}Response>(props?: ${componentName}MutationProps<T>) {
       return useMutation(async (body) => use${componentName}Query.fetch(body),
     props?.options
   )};`;
     }
     if (requestBodyComponent && paramsInPath.length && !queryParam && !headerParam) {
         output += `
+    type ${componentName}Response = ${genericsTypes}
     type ${componentName}Variables = ${requestBodyComponent} & {${paramsTypes}}
-    type ${componentName}QueryProps<T = ${genericsTypes}> =  ${componentName}Variables & {
-      options?: UseQueryOptions<${genericsTypes}, AxiosError, T, any>
+    type ${componentName}QueryProps<T = ${componentName}Response> =  ${componentName}Variables & {
+      options?: UseQueryOptions<${componentName}Response, AxiosError, T, any>
     }
     use${componentName}Query.fetch = async (props: ${componentName}Variables) => {
       const {${paramsInPath.join(', ')}, ...body} = props
-      const result = await api.${verb}<${genericsTypes}>(\`${route}\`, body)
+      const result = await api.${verb}<${componentName}Response>(\`${route}\`, body)
       return result.data
     }
     use${componentName}Query.baseKey = (): QueryKey => ["${componentName.toLowerCase()}"];
     use${componentName}Query.queryKey = (params: ${componentName}Variables ): QueryKey => [...use${componentName}Query.baseKey(), params];
-    export function use${componentName}Query<T = ${genericsTypes}>({ options = {}, ...props }: ${componentName}QueryProps<T>) {
+    use${componentName}Query.updateCache = (
+      params: ${componentName}Variables,
+      updater: Updater<${componentName}Response | undefined, ${componentName}Response>,
+      options?: SetDataOptions | undefined
+    ) => queryClient.setQueryData<${componentName}Response>(use${componentName}Query.queryKey(params), updater, options);
+    use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
+    queryClient.prefetchQuery<${componentName}Response>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
+    use${componentName}Query.invalidate = (params: ${componentName}Variables) =>
+      queryClient.invalidateQueries<${componentName}Response>(use${componentName}Query.queryKey(params));
+    export function use${componentName}Query<T = ${componentName}Response>({ options = {}, ...props }: ${componentName}QueryProps<T>) {
     return useQuery(use${componentName}Query.queryKey(props), async () =>  use${componentName}Query.fetch(props), { enabled: !!props.${paramsInPath.join(' && !!props.')}, ...options }
     );}
     type ${componentName}MutationProps<T> = {
-      options?: UseMutationOptions<${genericsTypes}, AxiosError, ${componentName}Variables, T>
+      options?: UseMutationOptions<${componentName}Response, AxiosError, ${componentName}Variables, T>
     }
-    export function use${componentName}Mutation<T = ${genericsTypes}>(props?: ${componentName}MutationProps<T>) {
+    export function use${componentName}Mutation<T = ${componentName}Response>(props?: ${componentName}MutationProps<T>) {
     return useMutation(async (body) => use${componentName}Query.fetch(body),
    props?.options
   )};`;
     }
     if (requestBodyComponent && !paramsInPath.length && queryParam && !headerParam) {
         output += `
+    type ${componentName}Response = ${genericsTypes}
     type ${componentName}Variables = ${requestBodyComponent} & {
       ${queryParamsType}
     }
-    type ${componentName}QueryProps<T = ${genericsTypes}> = ${componentName}Variables & {
-      options?: UseQueryOptions<${genericsTypes}, AxiosError, T, any>
+    type ${componentName}QueryProps<T = ${componentName}Response> = ${componentName}Variables & {
+      options?: UseQueryOptions<${componentName}Response, AxiosError, T, any>
     }
     use${componentName}Query.fetch = async (props: ${componentName}Variables) => {
@@ -562,13 +644,26 @@ export const generateRestfulComponent = ({ operation, verb, route, operationIds,
       const params = queryString.stringify({
         ${queryParams.map((param) => `["${param.name}"]: props["${param.name}"]`).join(',')}
       });
-      const result = await api.${verb}<${genericsTypes}>(\`${route}?\${params}\`, body)
+      const result = await api.${verb}<${componentName}Response>(\`${route}?\${params}\`, body)
       return result.data
     }
     use${componentName}Query.baseKey = (): QueryKey => ["${componentName.toLowerCase()}"];
     use${componentName}Query.queryKey = (params: ${componentName}Variables ): QueryKey => [...use${componentName}Query.baseKey(), params];
-    export function use${componentName}Query<T = ${genericsTypes}>({ options = {}, ...props }: ${componentName}QueryProps<T>) {
+    use${componentName}Query.updateCache = (
+      params: ${componentName}Variables,
+      updater: Updater<${componentName}Response | undefined, ${componentName}Response>,
+      options?: SetDataOptions | undefined
+    ) => queryClient.setQueryData<${componentName}Response>(use${componentName}Query.queryKey(params), updater, options);
+    use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
+    queryClient.prefetchQuery<${componentName}Response>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
+    use${componentName}Query.invalidate = (params: ${componentName}Variables) =>
+      queryClient.invalidateQueries<${componentName}Response>(use${componentName}Query.queryKey(params));
+    export function use${componentName}Query<T = ${componentName}Response>({ options = {}, ...props }: ${componentName}QueryProps<T>) {
     return useQuery(use${componentName}Query.queryKey(props), async () =>  use${componentName}Query.fetch(props), { enabled: !!props${queryParams
             .map((param) => `["${param.name}"]`)
             .join(' && !!props')}, ...options }
@@ -576,9 +671,9 @@ export const generateRestfulComponent = ({ operation, verb, route, operationIds,
     type ${componentName}MutationProps<T> = {
-      options?: UseMutationOptions<${genericsTypes}, AxiosError, ${componentName}Variables, T>
+      options?: UseMutationOptions<${componentName}Response, AxiosError, ${componentName}Variables, T>
     }
-    export function use${componentName}Mutation<T = ${genericsTypes}>(props?: ${componentName}MutationProps<T>) {
+    export function use${componentName}Mutation<T = ${componentName}Response>(props?: ${componentName}MutationProps<T>) {
     return useMutation(async (body) => use${componentName}Query.fetch(body),
    props?.options
   )};`;
@@ -600,23 +695,36 @@ export const generateRestfulComponent = ({ operation, verb, route, operationIds,
     }
     if (!requestBodyComponent && !paramsInPath.length && !queryParam && headerParam) {
         output += `
+    type ${componentName}Response = ${genericsTypes}
     type ${componentName}Variables = {
       ${headerParam}
     };
     use${componentName}Query.fetch = async (headers: ${componentName}Variables) => {
-      const result = await api.${verb}<${genericsTypes}>(\`${route}\`, {headers: headers});
+      const result = await api.${verb}<${componentName}Response>(\`${route}\`, {headers: headers});
       return result.data;
     }
     use${componentName}Query.baseKey = (): QueryKey => ["${componentName.toLowerCase()}"];
     use${componentName}Query.queryKey = (params: ${componentName}Variables ): QueryKey => [...use${componentName}Query.baseKey(), params];
-    type ${componentName}QueryProps<T = ${genericsTypes}> = ${componentName}Variables & {
-      options?: UseQueryOptions<${genericsTypes}, AxiosError, T, any>
+    use${componentName}Query.updateCache = (
+      params: ${componentName}Variables,
+      updater: Updater<${componentName}Response | undefined, ${componentName}Response>,
+      options?: SetDataOptions | undefined
+    ) => queryClient.setQueryData<${componentName}Response>(use${componentName}Query.queryKey(params), updater, options);
+    use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
+    queryClient.prefetchQuery<${componentName}Response>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
+    use${componentName}Query.invalidate = (params: ${componentName}Variables) =>
+      queryClient.invalidateQueries<${componentName}Response>(use${componentName}Query.queryKey(params));
+    type ${componentName}QueryProps<T = ${componentName}Response> = ${componentName}Variables & {
+      options?: UseQueryOptions<${componentName}Response, AxiosError, T, any>
     }
-    export function use${componentName}Query<T = ${genericsTypes}>({ options = {}, ...props }: ${componentName}QueryProps<T>) {
+    export function use${componentName}Query<T = ${componentName}Response>({ options = {}, ...props }: ${componentName}QueryProps<T>) {
       return useQuery(use${componentName}Query.queryKey(props), async () => use${componentName}Query.fetch(props),
       { enabled: !!props${headerParams.map((param) => `["${param.name}"]`).join(' && !!props')}, ...options }
       );}
@@ -624,15 +732,17 @@ export const generateRestfulComponent = ({ operation, verb, route, operationIds,
       type ${componentName}MutationProps<T> = {
-        options?: UseMutationOptions<${genericsTypes}, AxiosError, ${componentName}Variables, T>
+        options?: UseMutationOptions<${componentName}Response, AxiosError, ${componentName}Variables, T>
       }
-      export function use${componentName}Mutation<T = ${genericsTypes}>(props?: ${componentName}MutationProps<T>) {
+      export function use${componentName}Mutation<T = ${componentName}Response>(props?: ${componentName}MutationProps<T>) {
       return useMutation(async (data) => use${componentName}Query.fetch(data),
       props?.options
     )};`;
     }
     if (!requestBodyComponent && !paramsInPath.length && queryParam && headerParam) {
         output += `
+    type ${componentName}Response = ${genericsTypes}
     type ${componentName}Variables = {
       ${headerParam}
       ${queryParamsType};
@@ -640,21 +750,33 @@ export const generateRestfulComponent = ({ operation, verb, route, operationIds,
     use${componentName}Query.fetch = async (data: ${componentName}Variables) => {
       const params = queryString.stringify({
-        ${queryParams.map((param) => `${param.name}: data.${param.name}`).join(',')}
+        ${queryParams.map((p) => `"${p.name}": data["${p.name}"]`).join(',')}
       });
       const headers = {
-        ${headerParams.map((param) => `"${param.name}": data["${param.name}"]`).join(',')}
+        ${headerParams.map((p) => `"${p.name}": data["${p.name}"]`).join(',')}
       }
-      const result = await api.${verb}<${genericsTypes}>(\`${route}?\${params}\`, {headers})
+      const result = await api.${verb}<${componentName}Response>(\`${route}?\${params}\`, {headers})
       return result.data;
     }
     use${componentName}Query.baseKey = (): QueryKey => ["${componentName.toLowerCase()}"];
     use${componentName}Query.queryKey = (params: ${componentName}Variables ): QueryKey => [...use${componentName}Query.baseKey(), params];
-    type ${componentName}QueryProps<T = ${genericsTypes}> = ${componentName}Variables & {
-      options?: UseQueryOptions<${genericsTypes}, AxiosError, T, any>
+    use${componentName}Query.updateCache = (
+      params: ${componentName}Variables,
+      updater: Updater<${componentName}Response | undefined, ${componentName}Response>,
+      options?: SetDataOptions | undefined
+    ) => queryClient.setQueryData<${componentName}Response>(use${componentName}Query.queryKey(params), updater, options);
+    use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
+      queryClient.prefetchQuery<${componentName}Response>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
+    use${componentName}Query.invalidate = (params: ${componentName}Variables) =>
+      queryClient.invalidateQueries<${componentName}Response>(use${componentName}Query.queryKey(params));
+    type ${componentName}QueryProps<T = ${componentName}Response> = ${componentName}Variables & {
+      options?: UseQueryOptions<${componentName}Response, AxiosError, T, any>
     }
-    export function use${componentName}Query<T = ${genericsTypes}>({ options = {}, ...props }: ${componentName}QueryProps<T>) {
+    export function use${componentName}Query<T = ${componentName}Response>({ options = {}, ...props }: ${componentName}QueryProps<T>) {
     return useQuery(use${componentName}Query.queryKey(props), async () => use${componentName}Query.fetch(props),
     { enabled: !!props${[...queryParams, ...headerParams]
             .map((param) => `["${param.name}"]`)
@@ -662,16 +784,18 @@ export const generateRestfulComponent = ({ operation, verb, route, operationIds,
     );}
     type ${componentName}MutationProps<T> = {
-      options?: UseMutationOptions<${genericsTypes}, AxiosError, ${componentName}Variables, T>
+      options?: UseMutationOptions<${componentName}Response, AxiosError, ${componentName}Variables, T>
     }
-    export function use${componentName}Mutation<T = ${genericsTypes}>(props?: ${componentName}MutationProps<T>) {
+    export function use${componentName}Mutation<T = ${componentName}Response>(props?: ${componentName}MutationProps<T>) {
     return useMutation(async (data) => use${componentName}Query.fetch(data),
     props?.options
   )};`;
     }
     if (requestBodyComponent && !paramsInPath.length && !queryParam && headerParam) {
         output += `
+    type ${componentName}Response = ${genericsTypes}
     type ${componentName}Variables = ${requestBodyComponent} & {
       ${headerParam}
     };
@@ -680,16 +804,29 @@ export const generateRestfulComponent = ({ operation, verb, route, operationIds,
       const headers = {
         ${headerParams.map((param) => `"${param.name}": body["${param.name}"]`).join(',')}
       }
-      const result = await api.${verb}<${genericsTypes}>(\`${route}\`, body, {headers})
+      const result = await api.${verb}<${componentName}Response>(\`${route}\`, body, {headers})
         return result.data
       }
     use${componentName}Query.baseKey = (): QueryKey => ["${componentName.toLowerCase()}"];
     use${componentName}Query.queryKey = (params: ${componentName}Variables ): QueryKey => [...use${componentName}Query.baseKey(), params];
-    type ${componentName}QueryProps<T = ${genericsTypes}> = ${componentName}Variables & {
-      options?: UseQueryOptions<${genericsTypes}, AxiosError, T, any>
+    use${componentName}Query.updateCache = (
+      params: ${componentName}Variables,
+      updater: Updater<${componentName}Response | undefined, ${componentName}Response>,
+      options?: SetDataOptions | undefined
+    ) => queryClient.setQueryData<${componentName}Response>(use${componentName}Query.queryKey(params), updater, options);
+    use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
+    queryClient.prefetchQuery<${componentName}Response>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
+    use${componentName}Query.invalidate = (params: ${componentName}Variables) =>
+      queryClient.invalidateQueries<${componentName}Response>(use${componentName}Query.queryKey(params));
+    type ${componentName}QueryProps<T = ${componentName}Response> = ${componentName}Variables & {
+      options?: UseQueryOptions<${componentName}Response, AxiosError, T, any>
     }
-    export function use${componentName}Query<T = ${genericsTypes}>({ options = {}, ...body }: ${componentName}QueryProps<T>) {
+    export function use${componentName}Query<T = ${componentName}Response>({ options = {}, ...body }: ${componentName}QueryProps<T>) {
       return useQuery(use${componentName}Query.queryKey(body), async () => use${componentName}Query.fetch(body),{ enabled: !!body${headerParams
             .map((param) => `["${param.name}"]`)
             .join(' && !!props')}, ...options }
@@ -697,9 +834,9 @@ export const generateRestfulComponent = ({ operation, verb, route, operationIds,
     type ${componentName}MutationProps<T> = {
-      options?: UseMutationOptions<${genericsTypes}, AxiosError, ${componentName}Variables, T>
+      options?: UseMutationOptions<${componentName}Response, AxiosError, ${componentName}Variables, T>
     }
-    export function use${componentName}Mutation<T = ${genericsTypes}>(props?: ${componentName}MutationProps<T>) {
+    export function use${componentName}Mutation<T = ${componentName}Response>(props?: ${componentName}MutationProps<T>) {
     return useMutation(async (body) => use${componentName}Query.fetch(body),
     props?.options
   )};`;
@@ -732,17 +869,26 @@ const generateQueryHooks = (spec, operationIds, headerFilters) => {
 /**
  * Main entry of the generator. Generate react-query component from openAPI.
  */
-export const importOpenApi = async ({ data, format, apiDir, headerFilters = [], }) => {
+export const importOpenApi = async ({ data, format, apiDirectory, queryClientDir, headerFilters = [], }) => {
     const operationIds = [];
     let specs = await importSpecs(data, format);
-    console.log(JSON.stringify(Object.keys(specs), null, 2));
     resolveDiscriminator(specs);
     let output = '';
     output = `
-  import { useQuery, useMutation, UseQueryOptions, UseMutationOptions, QueryKey } from 'react-query';
+  import {
+    useQuery,
+    useMutation,
+    UseQueryOptions,
+    UseMutationOptions,
+    QueryKey,
+    SetDataOptions,
+  } from 'react-query';
+  import { Updater } from 'react-query/types/core/utils';
   import queryString from 'query-string';
   import {AxiosError} from 'axios';
-  import { api } from '${apiDir}';
+  import { api } from '${apiDirectory}';
+  import { queryClient } from '${queryClientDir}';
   // SCEHMAS
   ${generateSchemasDefinition(specs.components?.schemas)}

package/lib/esm/react-query-codegen-import.js CHANGED Viewed

@@ -4,7 +4,7 @@ import { join, parse } from 'path';
 import { importOpenApi } from './import-open-api';
 const log = console.log; // tslint:disable-line:no-console
 const createSuccessMessage = (backend) => chalk.green(`🎉 ${backend ? `[${backend}] ` : ''} Your OpenAPI spec has been converted into react query hooks`);
-export function importSpecs({ sourceDirectory, exportDirectory, apiDirectory, headerFilters, }) {
+export function importSpecs({ sourceDirectory, exportDirectory, apiDirectory, queryClientDir, headerFilters, }) {
     readdir(sourceDirectory, function (err, filenames) {
         if (err) {
             throw err;
@@ -15,7 +15,13 @@ export function importSpecs({ sourceDirectory, exportDirectory, apiDirectory, he
             const format = ['.yaml', '.yml'].includes(ext.toLowerCase()) ? 'yaml' : 'json';
             try {
                 const name = `useQueries${filename.split('.')[0]}.tsx`;
-                const fileExports = await importOpenApi({ data, format, apiDir: apiDirectory, headerFilters });
+                const fileExports = await importOpenApi({
+                    data,
+                    format,
+                    apiDirectory,
+                    headerFilters,
+                    queryClientDir,
+                });
                 writeFileSync(join(process.cwd(), `${exportDirectory}/${name}`), fileExports);
                 log(createSuccessMessage(filename));
             }

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "react-query-lightbase-codegen",
-  "version": "0.0.17",
+  "version": "0.0.18",
   "license": "MIT",
   "main": "./lib/cjs/index.js",
   "module": "./lib/esm/index.js",