react-query-lightbase-codegen 0.0.10 → 0.0.13

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

@@ -7,10 +7,10 @@ exports.importSpecs = void 0;
 const chalk_1 = __importDefault(require("chalk"));
 const fs_1 = require("fs");
 const path_1 = require("path");
-const import_open_api_js_1 = require("./import-open-api.js");
+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, }) {
+function importSpecs({ sourceDirectory, exportDirectory, apiDirectory, headerFilters, }) {
     (0, fs_1.readdir)(sourceDirectory, function (err, filenames) {
         if (err) {
             throw err;
@@ -21,7 +21,7 @@ function importSpecs({ sourceDirectory, exportDirectory, apiDirectory, }) {
             const format = ['.yaml', '.yml'].includes(ext.toLowerCase()) ? 'yaml' : 'json';
             try {
                 const name = `useQueries${filename.split('.')[0]}.tsx`;
-                const fileExports = await (0, import_open_api_js_1.importOpenApi)({ data, format, apiDir: apiDirectory });
+                const fileExports = await (0, import_open_api_1.importOpenApi)({ data, format, apiDir: apiDirectory, headerFilters });
                 (0, fs_1.writeFileSync)((0, path_1.join)(process.cwd(), `${exportDirectory}/${name}`), fileExports);
                 log(createSuccessMessage(filename));
             }

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

@@ -1,9 +1,11 @@
-import _case from 'case';
-import _ from 'lodash';
-const { pascal } = _case;
-const { uniq, get, groupBy, isEmpty, set } = _;
+import { pascal } from 'case';
+import get from 'lodash/get';
+import groupBy from 'lodash/groupBy';
+import isEmpty from 'lodash/isEmpty';
+import set from 'lodash/set';
+import uniq from 'lodash/uniq';
 import swagger2openapi from 'swagger2openapi';
-import yaml from 'js-yaml';
+const yaml = require('js-yaml');
 const IdentifierRegexp = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
 /**
  * Import and parse the openapi spec from a yaml/json
@@ -285,12 +287,12 @@ export const formatDescription = (description, tabSize = 0) => description
     ? `/**\n${description
         .split('\n')
         .map((i) => `${' '.repeat(tabSize)} * ${i}`)
-        .join('\n')}\n${' '.repeat(tabSize)} */\n${' '.repeat(tabSize)}`
+        .join('\n')}\n${' '.repeat(tabSize)} */${' '.repeat(tabSize)}`
     : '';
 /**
  * Generate a react-query component from openapi operation specs
  */
-export const generateRestfulComponent = (operation, verb, route, operationIds, parameters = [], schemasComponents) => {
+export const generateRestfulComponent = ({ operation, verb, route, operationIds, parameters, schemasComponents, headerFilters, }) => {
     const { operationId = route.replace('/', '') } = operation;
     if (operationId === '*') {
         throw new Error(`Invalid operationId/Route set for ${verb} ${route}`);
@@ -308,7 +310,7 @@ export const generateRestfulComponent = (operation, verb, route, operationIds, p
     const requestBodyTypes = getResReqTypes([['body', operation.requestBody]]);
     const needAResponseComponent = true;
     const paramsInPath = getParamsInPath(route).filter((param) => !(verb === 'delete' && param === lastParamInTheRoute));
-    const { query: queryParams = [], path: pathParams = [], header: headerParams = [] } = groupBy([...parameters, ...(operation.parameters || [])].map((p) => {
+    const { query: queryParams = [], path: pathParams = [], header = [], } = groupBy([...(parameters || []), ...(operation.parameters || [])].map((p) => {
         if (isReference(p)) {
             return get(schemasComponents, p.$ref.replace('#/components/', '').replace('/', '.'));
         }
@@ -316,6 +318,7 @@ export const generateRestfulComponent = (operation, verb, route, operationIds, p
             return p;
         }
     }), 'in');
+    const headerParams = header.filter((p) => !headerFilters?.includes(p.name));
     const paramsTypes = paramsInPath
         .map((p) => {
         try {
@@ -371,52 +374,43 @@ export const generateRestfulComponent = (operation, verb, route, operationIds, p
     const headerParam = headerType && headerType !== 'void' ? `${headerType};` : '';
     const queryParam = queryParamsType && queryParamsType !== 'void' ? `${queryParamsType}` : '';
     const requestBodyComponent = requestBodyTypes && requestBodyTypes !== 'void' ? `${requestBodyTypes}` : '';
-    console.log(headerParam);
     // QUERIES
     if (!requestBodyComponent && paramsInPath.length && !queryParam && !headerParam) {
-        output += `interface ${componentName}QueryProps<T = ${genericsTypes}> {
-      ${paramsTypes}; 
-      options?: UseQueryOptions<${genericsTypes}, AxiosError, T, any> 
+        output += `
+    type ${componentName}Variables = {
+      ${paramsTypes}
     }
-    export function use${componentName}Query<T = ${genericsTypes}>({ options = {}, ...props }: ${componentName}QueryProps<T>) { 
-    return useQuery(use${componentName}Query.queryKey(props), async () => use${componentName}Query.fetch(props), 
-    { enabled: !!props.${paramsInPath.join(' && !!props.')}, ...options }
-    );}
 
     use${componentName}Query.fetch = async (props: Omit<${componentName}QueryProps, 'options'> ) => {
       const result = await api.${verb}<${genericsTypes}>(\`${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];
 
-    use${componentName}Query.queryKey = (params: {${paramsTypes}} ): QueryKey => [...use${componentName}Query.baseKey(), params];
-
-    `;
-        output += `interface ${componentName}MutationVariables {
-      ${paramsTypes}
+    type ${componentName}QueryProps<T = ${genericsTypes}> = ${componentName}Variables & {
+      options?: UseQueryOptions<${genericsTypes}, AxiosError, T, any> 
     }
-    interface ${componentName}MutationProps<T> {
+    export function use${componentName}Query<T = ${genericsTypes}>({ 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}MutationVariables, T> 
     }
     export function use${componentName}Mutation<T = ${genericsTypes}>(props?: ${componentName}MutationProps<T>) { 
-    return useMutation(async ({${paramsInPath.join(', ')}}) => {
-      const result = await api.${verb}<${genericsTypes}>(\`${route}\`) 
-      return result.data
-    },
+      return useMutation(async (data) => use${componentName}Query.fetch(data),
     props?.options
   )};`;
     }
     if (!requestBodyComponent && paramsInPath.length && queryParam && !headerParam) {
-        output += `interface ${componentName}QueryProps<T = ${genericsTypes}> {
-      ${paramsTypes}; 
+        output += `
+    type ${componentName}Variables = {
+      ${paramsTypes}
       ${queryParamsType}; 
-      options?: UseQueryOptions<${genericsTypes}, AxiosError, T, any> 
     }
-    export function use${componentName}Query<T = ${genericsTypes}>({ options = {}, ...props }: ${componentName}QueryProps<T>) { 
-    return useQuery(use${componentName}Query.queryKey(props), async () => use${componentName}Query.fetch(props), { enabled: !!props.${paramsInPath.join(' && !!props.')}, ...options }
-    );}
-    
+
     use${componentName}Query.fetch = async (props: Omit<${componentName}QueryProps, 'options'>) => {
       const {${paramsInPath.join(', ')}, ...queryParams} = props
       const params = queryString.stringify(queryParams);
@@ -425,67 +419,58 @@ export const generateRestfulComponent = (operation, verb, route, operationIds, p
     }
     
     use${componentName}Query.baseKey = (): QueryKey => ["${componentName.toLowerCase()}"];
-
     use${componentName}Query.queryKey = (params: Omit<${componentName}QueryProps, 'options'>): QueryKey => [...use${componentName}Query.baseKey(), params];
-    
-    `;
-        output += `interface ${componentName}MutationVariables {
-      ${paramsTypes}
-      ${queryParamsType}
+
+
+    type ${componentName}QueryProps<T = ${genericsTypes}> ${componentName}Variables & {
+      options?: UseQueryOptions<${genericsTypes}, AxiosError, T, any> 
     }
-    interface ${componentName}MutationProps<T> {
-      options?: UseMutationOptions<${genericsTypes}, AxiosError, ${componentName}MutationVariables, T> 
+    export function use${componentName}Query<T = ${genericsTypes}>({ 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> 
     }
     export function use${componentName}Mutation<T = ${genericsTypes}>(props?: ${componentName}MutationProps<T>) { 
-    return useMutation(async (data) => {
-      const {${paramsInPath.join(', ')}, ...queryParams} = data
-      const params = queryString.stringify(queryParams);
-      const result = await api.${verb}<${genericsTypes}>(\`${route}?\${params}\`)
-      return result.data
-    },
+    return useMutation(async (data) => use${componentName}Query.fetch(data),
     props?.options
   )};`;
     }
     if (!requestBodyComponent && !paramsInPath.length && !queryParam && !headerParam) {
-        output += `interface ${componentName}QueryProps<T = ${genericsTypes}> {
+        output += `
+    use${componentName}Query.fetch = async () => {
+      const result = await api.${verb}<${genericsTypes}>(\`${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> 
     }
     export function use${componentName}Query<T = ${genericsTypes}>(props?: ${componentName}QueryProps<T>) { 
       return useQuery(use${componentName}Query.queryKey(), use${componentName}Query.fetch, props?.options
-      );}
-
-      use${componentName}Query.fetch = async () => {
-        const result = await api.${verb}<${genericsTypes}>(\`${route}\`);
-        return result.data;
-      }
+      );} 
       
-      use${componentName}Query.baseKey = (): QueryKey => ["${componentName.toLowerCase()}"];
-
-      use${componentName}Query.queryKey = (): QueryKey => use${componentName}Query.baseKey()
-
-      `;
-        output += `interface ${componentName}MutationProps<T> {
+      type ${componentName}MutationProps<T> = {
         options?: UseMutationOptions<${genericsTypes}, AxiosError, void, T> 
       }
       export function use${componentName}Mutation<T = ${genericsTypes}>(props?: ${componentName}MutationProps<T>) { 
-      return useMutation(async () => { 
-        const result = await api.${verb}<${genericsTypes}>(\`${route}\`);
-        return result.data;
-      },
+      return useMutation(async () => use${componentName}Query.fetch(),
       props?.options
     )};`;
     }
     if (!requestBodyComponent && !paramsInPath.length && queryParam && !headerParam) {
-        output += `interface ${componentName}QueryProps<T = ${genericsTypes}> {
-      ${queryParamsType}; 
-      options?: UseQueryOptions<${genericsTypes}, AxiosError, T, any> 
+        output += `
+    // USE AS EXAMPLE
+    type ${componentName}Variables = { 
+      ${queryParamsType} 
     }
-    export function use${componentName}Query<T = ${genericsTypes}>({ 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 }
-    );}
-    
-    use${componentName}Query.fetch = async (props: Omit<${componentName}QueryProps, 'options'>) => {
+
+    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(',')}});
@@ -493,37 +478,20 @@ export const generateRestfulComponent = (operation, verb, route, operationIds, p
       return result.data;
     }
 
-    use${componentName}Query.baseKey = (): QueryKey => ["${componentName.toLowerCase()}"];
-
-    use${componentName}Query.queryKey = (params: Omit<${componentName}QueryProps, 'options'> ): QueryKey => [...use${componentName}Query.baseKey(), params];
+    export function use${componentName}Query<T = ${genericsTypes}>({ options = {}, ...props }: ${componentName}Variables & { options?: UseQueryOptions<${genericsTypes}, 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 }
+    );}
     
-    `;
-        output += `interface ${componentName}MutationVariables {
-      ${queryParamsType}
-    }
-    interface ${componentName}MutationProps<T> {
-      options?: UseMutationOptions<${genericsTypes}, AxiosError, ${componentName}MutationVariables, T> 
-    }
-  
-    export function use${componentName}Mutation<T = ${genericsTypes}>(props?: ${componentName}MutationProps<T>) { 
-    return useMutation(async (data) => {
-      const params = queryString.stringify({${queryParams
-            .map((param) => `${param.name}: data.${param.name}`)
-            .join(',')}});
-      const result = await api.${verb}<${genericsTypes}>(\`${route}?\${params}\`)
-      return result.data;
-    },
-    props?.options
-  )};`;
+    export function use${componentName}Mutation<T = ${genericsTypes}>(props?: { options?: UseMutationOptions<${genericsTypes}, AxiosError, ${componentName}Variables, T>}) { 
+      return useMutation(async (data) => use${componentName}Query.fetch(data),
+      props?.options
+    )};
+`;
     }
     if (requestBodyComponent && !paramsInPath.length && !queryParam && !headerParam) {
-        output += `type ${componentName}QueryVariables = ${requestBodyComponent};
-    interface ${componentName}QueryProps<T = ${genericsTypes}> extends ${componentName}QueryVariables {
-      options?: UseQueryOptions<${genericsTypes}, AxiosError, T, any> 
-    }
-    export function use${componentName}Query<T = ${genericsTypes}>({ options = {}, ...body }: ${componentName}QueryProps<T>) { 
-      return useQuery(use${componentName}Query.queryKey(body), async () => use${componentName}Query.fetch(body), options
-    );}
+        output += `
+    type ${componentName}QueryVariables = ${requestBodyComponent};
 
     use${componentName}Query.fetch = async (body: Omit<${componentName}QueryProps, 'options'>) => {
       const result = await api.${verb}<${genericsTypes}>(\`${route}\`, body)
@@ -531,46 +499,49 @@ export const generateRestfulComponent = (operation, verb, route, operationIds, p
       }
       
     use${componentName}Query.baseKey = (): QueryKey => ["${componentName.toLowerCase()}"];
-
     use${componentName}Query.queryKey = (params: Omit<${componentName}QueryProps, 'options'> ): QueryKey => [...use${componentName}Query.baseKey(), params];
 
-    `;
-        output += `type ${componentName}MutationVariables = ${requestBodyComponent};
-    interface ${componentName}MutationProps<T> {
+    type ${componentName}QueryProps<T = ${genericsTypes}> = ${componentName}QueryVariables & {
+      options?: UseQueryOptions<${genericsTypes}, AxiosError, T, any> 
+    }
+    export function use${componentName}Query<T = ${genericsTypes}>({ options = {}, ...body }: ${componentName}QueryProps<T>) { 
+      return useQuery(use${componentName}Query.queryKey(body), async () => use${componentName}Query.fetch(body), options
+    );}
+
+
+
+    type ${componentName}MutationVariables = ${requestBodyComponent};
+    type ${componentName}MutationProps<T> = {
       options?: UseMutationOptions<${genericsTypes}, AxiosError, ${componentName}MutationVariables, T> 
     }
     export function use${componentName}Mutation<T = ${genericsTypes}>(props?: ${componentName}MutationProps<T>) { 
-    return useMutation(async (body) => { 
-      const result = await api.${verb}<${genericsTypes}>(\`${route}\`, body)
-      return result.data
-    },
+      return useMutation(async (body) => use${componentName}Query.fetch(body),
     props?.options
   )};`;
     }
     if (requestBodyComponent && paramsInPath.length && !queryParam && !headerParam) {
-        output += `interface ${componentName}QueryProps<T = ${genericsTypes}> extends  ${requestBodyComponent
+        output += `
+    type ${componentName}QueryProps<T = ${genericsTypes}> =  ${requestBodyComponent
             .replace('{', '')
-            .replace('}', '')} {
+            .replace('}', '')} & {
       ${paramsTypes}; 
       options?: UseQueryOptions<${genericsTypes}, AxiosError, T, any> 
     }
-    export function use${componentName}Query<T = ${genericsTypes}>({ options = {}, ...props }: ${componentName}QueryProps<T>) { 
-    return useQuery(use${componentName}Query.queryKey(props), async () =>  use${componentName}Query.fetch(props), { enabled: !!props.${paramsInPath.join(' && !!props.')}, ...options }
-    );}
 
     use${componentName}Query.fetch = async (props: Omit<${componentName}QueryProps, 'options'>) => {
       const {${paramsInPath.join(', ')}, ...body} = props
       const result = await api.${verb}<${genericsTypes}>(\`${route}\`, body)
       return result.data
     }
-    
     use${componentName}Query.baseKey = (): QueryKey => ["${componentName.toLowerCase()}"];
-
     use${componentName}Query.queryKey = (params: Omit<${componentName}QueryProps, 'options'> ): QueryKey => [...use${componentName}Query.baseKey(), params];
 
-    `;
-        output += `type ${componentName}MutationVariables = {${paramsTypes}} & ${requestBodyComponent}
-    interface ${componentName}MutationProps<T> {
+    export function use${componentName}Query<T = ${genericsTypes}>({ 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}MutationVariables = {${paramsTypes}} & ${requestBodyComponent}
+    type ${componentName}MutationProps<T> = {
       options?: UseMutationOptions<${genericsTypes}, AxiosError, ${componentName}MutationVariables, T>
     }
     export function use${componentName}Mutation<T = ${genericsTypes}>(props?: ${componentName}MutationProps<T>) {
@@ -592,9 +563,21 @@ export const generateRestfulComponent = (operation, verb, route, operationIds, p
     }
     if (!requestBodyComponent && !paramsInPath.length && !queryParam && headerParam) {
         output += `
-    // HELLO
-    type ${componentName}HeaderVariables = {${headerParam}};
-    type ${componentName}QueryProps<T = ${genericsTypes}> = ${componentName}HeaderVariables & {
+    // DONE
+    type ${componentName}Variables = {
+      ${headerParam}
+    };
+
+    use${componentName}Query.fetch = async (headers: ${componentName}Variables) => {
+      const result = await api.${verb}<${genericsTypes}>(\`${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> 
     }
     export function use${componentName}Query<T = ${genericsTypes}>({ options = {}, ...props }: ${componentName}QueryProps<T>) { 
@@ -602,95 +585,89 @@ export const generateRestfulComponent = (operation, verb, route, operationIds, p
       { enabled: !!props${headerParams.map((param) => `["${param.name}"]`).join(' && !!props')}, ...options }
       );}
 
-      use${componentName}Query.fetch = async (headers: ${componentName}HeaderVariables) => {
-        const result = await api.${verb}<${genericsTypes}>(\`${route}\`, {headers: headers});
-        return result.data;
-      }
-      
-      use${componentName}Query.baseKey = (): QueryKey => ["${componentName.toLowerCase()}"];
 
-      use${componentName}Query.queryKey = (params: Omit<${componentName}QueryProps, 'options'> ): QueryKey => [...use${componentName}Query.baseKey(), params];
 
       type ${componentName}MutationProps<T> = {
-        options?: UseMutationOptions<${genericsTypes}, AxiosError, void, T> 
+        options?: UseMutationOptions<${genericsTypes}, AxiosError, ${componentName}Variables, T> 
       }
       export function use${componentName}Mutation<T = ${genericsTypes}>(props?: ${componentName}MutationProps<T>) { 
-      return useMutation(async () => { 
-        const result = await api.${verb}<${genericsTypes}>(\`${route}\`);
-        return result.data;
-      },
+      return useMutation(async (data) => use${componentName}Query.fetch(data),
       props?.options
     )};`;
     }
     if (!requestBodyComponent && !paramsInPath.length && queryParam && headerParam) {
-        output += `interface ${componentName}QueryProps<T = ${genericsTypes}> {
+        output += `
+    // DONE
+    type ${componentName}Variables = {
+      ${headerParam}
       ${queryParamsType}; 
+    };
+
+    use${componentName}Query.fetch = async (data: ${componentName}Variables) => {
+      const params = queryString.stringify({
+        ${queryParams.map((param) => `${param.name}: data.${param.name}`).join(',')}
+      });
+      const headers = {
+        ${headerParams.map((param) => `"${param.name}": data["${param.name}"]`).join(',')}
+      }
+      // HIHI
+      const result = await api.${verb}<${genericsTypes}>(\`${route}?\${params}\`, {headers})
+      return result.data;
+    }
+    use${componentName}Query.baseKey = (): QueryKey => ["${componentName.toLowerCase()}"];
+    use${componentName}Query.queryKey = (params: Omit<${componentName}QueryProps, 'options'> ): QueryKey => [...use${componentName}Query.baseKey(), params];
+
+    type ${componentName}QueryProps<T = ${genericsTypes}> = ${componentName}Variables & {
       options?: UseQueryOptions<${genericsTypes}, AxiosError, T, any> 
     }
     export function use${componentName}Query<T = ${genericsTypes}>({ 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 }
+    { enabled: !!props${[...queryParams, ...headerParams]
+            .map((param) => `["${param.name}"]`)
+            .join(' && !!props')}, ...options }
     );}
     
-    use${componentName}Query.fetch = async (props: Omit<${componentName}QueryProps, 'options'>) => {
-      const params = queryString.stringify({${queryParams
-            .map((param) => `${param.name}: props.${param.name}`)
-            .join(',')}});
-      const result = await api.${verb}<${genericsTypes}>(\`${route}?\${params}\`)
-      return result.data;
-    }
-
-    use${componentName}Query.baseKey = (): QueryKey => ["${componentName.toLowerCase()}"];
-
-    use${componentName}Query.queryKey = (params: Omit<${componentName}QueryProps, 'options'> ): QueryKey => [...use${componentName}Query.baseKey(), params];
-    
-    interface ${componentName}MutationVariables {
-      ${queryParamsType}
-    }
-    interface ${componentName}MutationProps<T> {
-      options?: UseMutationOptions<${genericsTypes}, AxiosError, ${componentName}MutationVariables, T> 
+    type ${componentName}MutationProps<T> = {
+      options?: UseMutationOptions<${genericsTypes}, AxiosError, ${componentName}Variables, T> 
     }
   
     export function use${componentName}Mutation<T = ${genericsTypes}>(props?: ${componentName}MutationProps<T>) { 
-    return useMutation(async (data) => {
-      const params = queryString.stringify({${queryParams
-            .map((param) => `${param.name}: data.${param.name}`)
-            .join(',')}});
-      const result = await api.${verb}<${genericsTypes}>(\`${route}?\${params}\`)
-      return result.data;
-    },
+    return useMutation(async (data) => use${componentName}Query.fetch(data),
     props?.options
   )};`;
     }
     if (requestBodyComponent && !paramsInPath.length && !queryParam && headerParam) {
         output += `
-    type ${componentName}QueryVariables = ${requestBodyComponent};
-    interface ${componentName}QueryProps<T = ${genericsTypes}> extends ${componentName}QueryVariables {
-      options?: UseQueryOptions<${genericsTypes}, AxiosError, T, any> 
-    }
-    export function use${componentName}Query<T = ${genericsTypes}>({ options = {}, ...body }: ${componentName}QueryProps<T>) { 
-      return useQuery(use${componentName}Query.queryKey(body), async () => use${componentName}Query.fetch(body), options
-    );}
+    // HEHEHEHEHE
+    type ${componentName}Variables = ${requestBodyComponent} & {
+      ${headerParam}
+    };
 
-    use${componentName}Query.fetch = async (body: Omit<${componentName}QueryProps, 'options'>) => {
-      const result = await api.${verb}<${genericsTypes}>(\`${route}\`, body)
+    use${componentName}Query.fetch = async (body: ${componentName}Variables) => {
+      const headers = {
+        ${headerParams.map((param) => `"${param.name}": body["${param.name}"]`).join(',')}
+      }
+      const result = await api.${verb}<${genericsTypes}>(\`${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> 
+    }
+    export function use${componentName}Query<T = ${genericsTypes}>({ 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 }
+    );}
 
-    use${componentName}Query.queryKey = (params: Omit<${componentName}QueryProps, 'options'> ): QueryKey => [...use${componentName}Query.baseKey(), params];
-
-    type ${componentName}MutationVariables = ${requestBodyComponent};
     
-    interface ${componentName}MutationProps<T> {
-      options?: UseMutationOptions<${genericsTypes}, AxiosError, ${componentName}MutationVariables, T> 
+    type ${componentName}MutationProps<T> = {
+      options?: UseMutationOptions<${genericsTypes}, AxiosError, ${componentName}Variables, T> 
     }
     export function use${componentName}Mutation<T = ${genericsTypes}>(props?: ${componentName}MutationProps<T>) { 
-    return useMutation(async (body) => { 
-      const result = await api.${verb}<${genericsTypes}>(\`${route}\`, body)
-      return result.data
-    },
+    return useMutation(async (body) => use${componentName}Query.fetch(body),
     props?.options
   )};`;
     }
@@ -699,32 +676,50 @@ export const generateRestfulComponent = (operation, verb, route, operationIds, p
     }
     return output;
 };
+const generateQueryHooks = (paths, operationIds, schemasComponents, headerFilters) => {
+    let output = '';
+    Object.entries(paths).forEach(([route, verbs]) => {
+        Object.entries(verbs).forEach(([verb, operation]) => {
+            if (['get', 'post', 'patch', 'put', 'delete'].includes(verb) && !operation.deprecated) {
+                output += generateRestfulComponent({
+                    operation,
+                    verb,
+                    route,
+                    operationIds,
+                    parameters: verbs.parameters,
+                    schemasComponents,
+                    headerFilters,
+                });
+            }
+        });
+    });
+    return output;
+};
 /**
  * Main entry of the generator. Generate react-query component from openAPI.
  */
-export const importOpenApi = async ({ data, format, apiDir, }) => {
+export const importOpenApi = async ({ data, format, apiDir, headerFilters = [], }) => {
     const operationIds = [];
     let specs = await importSpecs(data, format);
     resolveDiscriminator(specs);
-    let output = `
+    let output = '';
+    output = `
   import { useQuery, useMutation, UseQueryOptions, UseMutationOptions, QueryKey } from 'react-query';
   import queryString from 'query-string';
   import {AxiosError} from 'axios';
   import { api } from '${apiDir}';
+
+  // SCEHMAS
+  ${generateSchemasDefinition(specs.components?.schemas)}
+
+  // RESPONSES
+  ${generateResponsesDefinition(specs.components?.responses)}
+
+  // REQUEST BODIES
+  ${generateRequestBodiesDefinition(specs.components?.requestBodies)}
+
+  // HOOKS
+  ${generateQueryHooks(specs.paths, operationIds, specs.components, headerFilters)}
   `;
-    output += '\n\n// SCEHMAS\n';
-    output += generateSchemasDefinition(specs.components && specs.components.schemas);
-    output += '\n\n// RESPONSES\n';
-    output += generateResponsesDefinition(specs.components && specs.components.responses);
-    output += '\n\n// REQUEST BODIES\n';
-    output += generateRequestBodiesDefinition(specs.components && specs.components.requestBodies);
-    output += '\n\n// HOOKS\n';
-    Object.entries(specs.paths).forEach(([route, verbs]) => {
-        Object.entries(verbs).forEach(([verb, operation]) => {
-            if (['get', 'post', 'patch', 'put', 'delete'].includes(verb) && !operation.deprecated) {
-                output += generateRestfulComponent(operation, verb, route, operationIds, verbs.parameters, specs.components);
-            }
-        });
-    });
     return output;
 };

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

@@ -1,10 +1,10 @@
 import chalk from 'chalk';
 import { readFileSync, writeFileSync, readdir } from 'fs';
 import { join, parse } from 'path';
-import { importOpenApi } from './import-open-api.js';
+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, }) {
+export function importSpecs({ sourceDirectory, exportDirectory, apiDirectory, headerFilters, }) {
     readdir(sourceDirectory, function (err, filenames) {
         if (err) {
             throw err;
@@ -15,7 +15,7 @@ export function importSpecs({ sourceDirectory, exportDirectory, apiDirectory, })
             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 });
+                const fileExports = await importOpenApi({ data, format, apiDir: apiDirectory, headerFilters });
                 writeFileSync(join(process.cwd(), `${exportDirectory}/${name}`), fileExports);
                 log(createSuccessMessage(filename));
             }