react-query-lightbase-codegen 0.0.9 → 0.0.12

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

@@ -4,18 +4,20 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.importOpenApi = exports.generateRestfulComponent = exports.formatDescription = exports.generateResponsesDefinition = exports.generateRequestBodiesDefinition = exports.generateSchemasDefinition = exports.resolveDiscriminator = exports.generateInterface = exports.getParamsInPath = exports.getResReqTypes = exports.resolveValue = exports.getObject = exports.getArray = exports.getRef = exports.getScalar = exports.isReference = void 0;
-const case_1 = __importDefault(require("case"));
-const lodash_1 = __importDefault(require("lodash"));
-const { pascal } = case_1.default;
-const { uniq, get, groupBy, isEmpty, set } = lodash_1.default;
+const case_1 = require("case");
+const get_1 = __importDefault(require("lodash/get"));
+const groupBy_1 = __importDefault(require("lodash/groupBy"));
+const isEmpty_1 = __importDefault(require("lodash/isEmpty"));
+const set_1 = __importDefault(require("lodash/set"));
+const uniq_1 = __importDefault(require("lodash/uniq"));
 const swagger2openapi_1 = __importDefault(require("swagger2openapi"));
-const js_yaml_1 = __importDefault(require("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
  */
 const importSpecs = (data, extension) => {
-    const schema = extension === 'yaml' ? js_yaml_1.default.load(data) : JSON.parse(data);
+    const schema = extension === 'yaml' ? yaml.load(data) : JSON.parse(data);
     return new Promise((resolve, reject) => {
         if (!schema.openapi || !schema.openapi.startsWith('3.')) {
             swagger2openapi_1.default.convertObj(schema, {}, (err, convertedObj) => {
@@ -65,16 +67,16 @@ exports.getScalar = getScalar;
  */
 const getRef = ($ref) => {
     if ($ref.startsWith('#/components/schemas')) {
-        return pascal($ref.replace('#/components/schemas/', ''));
+        return (0, case_1.pascal)($ref.replace('#/components/schemas/', ''));
     }
     else if ($ref.startsWith('#/components/responses')) {
-        return pascal($ref.replace('#/components/responses/', '')) + 'Response';
+        return (0, case_1.pascal)($ref.replace('#/components/responses/', '')) + 'Response';
     }
     else if ($ref.startsWith('#/components/parameters')) {
-        return pascal($ref.replace('#/components/parameters/', '')) + 'Parameter';
+        return (0, case_1.pascal)($ref.replace('#/components/parameters/', '')) + 'Parameter';
     }
     else if ($ref.startsWith('#/components/requestBodies')) {
-        return pascal($ref.replace('#/components/requestBodies/', '')) + 'RequestBody';
+        return (0, case_1.pascal)($ref.replace('#/components/requestBodies/', '')) + 'RequestBody';
     }
     else {
         throw new Error('This library only resolve $ref that are include into `#/components/*` for now');
@@ -117,7 +119,7 @@ const getObject = (item) => {
     // Free form object (https://swagger.io/docs/specification/data-models/data-types/#free-form)
     if (item.type === 'object' &&
         !item.properties &&
-        (!item.additionalProperties || item.additionalProperties === true || isEmpty(item.additionalProperties))) {
+        (!item.additionalProperties || item.additionalProperties === true || (0, isEmpty_1.default)(item.additionalProperties))) {
         return '{[key: string]: any}';
     }
     // Consolidation of item.properties & item.additionalProperties
@@ -155,7 +157,7 @@ exports.resolveValue = resolveValue;
 /**
  * Extract responses / request types from open-api specs
  */
-const getResReqTypes = (responsesOrRequests) => uniq(responsesOrRequests.map(([_, res]) => {
+const getResReqTypes = (responsesOrRequests) => (0, uniq_1.default)(responsesOrRequests.map(([_, res]) => {
     if (!res) {
         return 'void';
     }
@@ -199,7 +201,7 @@ exports.getParamsInPath = getParamsInPath;
  */
 const generateInterface = (name, schema) => {
     const scalar = (0, exports.getScalar)(schema);
-    return `${(0, exports.formatDescription)(schema.description)}export interface ${pascal(name)} ${scalar}`;
+    return `${(0, exports.formatDescription)(schema.description)}export interface ${(0, case_1.pascal)(name)} ${scalar}`;
 };
 exports.generateInterface = generateInterface;
 /**
@@ -218,7 +220,7 @@ const resolveDiscriminator = (specs) => {
                 if (!ref.startsWith('#/components/schemas/')) {
                     throw new Error('Discriminator mapping outside of `#/components/schemas` is not supported');
                 }
-                set(specs, `components.schemas.${ref.slice('#/components/schemas/'.length)}.properties.${propertyName}.enum`, [name]);
+                (0, set_1.default)(specs, `components.schemas.${ref.slice('#/components/schemas/'.length)}.properties.${propertyName}.enum`, [name]);
             });
         });
     }
@@ -228,7 +230,7 @@ exports.resolveDiscriminator = resolveDiscriminator;
  * Extract all types from #/components/schemas
  */
 const generateSchemasDefinition = (schemas = {}) => {
-    if (isEmpty(schemas)) {
+    if ((0, isEmpty_1.default)(schemas)) {
         return '';
     }
     return (Object.entries(schemas)
@@ -239,7 +241,7 @@ const generateSchemasDefinition = (schemas = {}) => {
         !(0, exports.isReference)(schema) &&
         !schema.nullable
         ? (0, exports.generateInterface)(name, schema)
-        : `${(0, exports.formatDescription)((0, exports.isReference)(schema) ? undefined : schema.description)}export type ${pascal(name)} = ${(0, exports.resolveValue)(schema)};`)
+        : `${(0, exports.formatDescription)((0, exports.isReference)(schema) ? undefined : schema.description)}export type ${(0, case_1.pascal)(name)} = ${(0, exports.resolveValue)(schema)};`)
         .join('\n\n') + '\n');
 };
 exports.generateSchemasDefinition = generateSchemasDefinition;
@@ -247,7 +249,7 @@ exports.generateSchemasDefinition = generateSchemasDefinition;
  * Extract all types from #/components/requestBodies
  */
 const generateRequestBodiesDefinition = (requestBodies = {}) => {
-    if (isEmpty(requestBodies)) {
+    if ((0, isEmpty_1.default)(requestBodies)) {
         return '';
     }
     return ('\n' +
@@ -257,13 +259,13 @@ const generateRequestBodiesDefinition = (requestBodies = {}) => {
             const type = (0, exports.getResReqTypes)([['', requestBody]]);
             const isEmptyInterface = type === '{}';
             if (isEmptyInterface) {
-                return `export interface ${pascal(name)}RequestBody ${type}`;
+                return `export interface ${(0, case_1.pascal)(name)}RequestBody ${type}`;
             }
             else if (type.includes('{') && !type.includes('|') && !type.includes('&')) {
-                return `${doc}export interface ${pascal(name)}RequestBody ${type}`;
+                return `${doc}export interface ${(0, case_1.pascal)(name)}RequestBody ${type}`;
             }
             else {
-                return `${doc}export type ${pascal(name)}RequestBody = ${type};`;
+                return `${doc}export type ${(0, case_1.pascal)(name)}RequestBody = ${type};`;
             }
         })
             .join('\n\n') +
@@ -274,7 +276,7 @@ exports.generateRequestBodiesDefinition = generateRequestBodiesDefinition;
  * Extract all types from #/components/responses
  */
 const generateResponsesDefinition = (responses = {}) => {
-    if (isEmpty(responses)) {
+    if ((0, isEmpty_1.default)(responses)) {
         return '';
     }
     return ('\n' +
@@ -284,13 +286,13 @@ const generateResponsesDefinition = (responses = {}) => {
             const type = (0, exports.getResReqTypes)([['', response]]);
             const isEmptyInterface = type === '{}';
             if (isEmptyInterface) {
-                return `export interface RQ${pascal(name)}Response ${type}`;
+                return `export interface RQ${(0, case_1.pascal)(name)}Response ${type}`;
             }
             else if (type.includes('{') && !type.includes('|') && !type.includes('&')) {
-                return `${doc}export interface RQ${pascal(name)}Response ${type}`;
+                return `${doc}export interface RQ${(0, case_1.pascal)(name)}Response ${type}`;
             }
             else {
-                return `${doc}export type RQ${pascal(name)}Response = ${type};`;
+                return `${doc}export type RQ${(0, case_1.pascal)(name)}Response = ${type};`;
             }
         })
             .join('\n\n') +
@@ -304,13 +306,13 @@ 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)}`
     : '';
 exports.formatDescription = formatDescription;
 /**
  * Generate a react-query component from openapi operation specs
  */
-const generateRestfulComponent = (operation, verb, route, operationIds, parameters = [], schemasComponents) => {
+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}`);
@@ -322,20 +324,21 @@ const generateRestfulComponent = (operation, verb, route, operationIds, paramete
     route = route.replace(/\{/g, '${'); // `/pet/{id}` => `/pet/${id}`
     // Remove the last param of the route if we are in the DELETE case
     let lastParamInTheRoute = null;
-    const componentName = pascal(operationId);
+    const componentName = (0, case_1.pascal)(operationId);
     const isOk = ([statusCode]) => statusCode.toString().startsWith('2');
     const responseTypes = (0, exports.getResReqTypes)(Object.entries(operation.responses).filter(isOk)) || 'void';
     const requestBodyTypes = (0, exports.getResReqTypes)([['body', operation.requestBody]]);
     const needAResponseComponent = true;
     const paramsInPath = (0, exports.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 = [], } = (0, groupBy_1.default)([...(parameters || []), ...(operation.parameters || [])].map((p) => {
         if ((0, exports.isReference)(p)) {
-            return get(schemasComponents, p.$ref.replace('#/components/', '').replace('/', '.'));
+            return (0, get_1.default)(schemasComponents, p.$ref.replace('#/components/', '').replace('/', '.'));
         }
         else {
             return p;
         }
     }), 'in');
+    const headerParams = header.filter((p) => !headerFilters?.includes(p.name));
     const paramsTypes = paramsInPath
         .map((p) => {
         try {
@@ -391,52 +394,43 @@ const generateRestfulComponent = (operation, verb, route, operationIds, paramete
     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);
@@ -445,67 +439,58 @@ const generateRestfulComponent = (operation, verb, route, operationIds, paramete
     }
     
     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(',')}});
@@ -513,37 +498,20 @@ const generateRestfulComponent = (operation, verb, route, operationIds, paramete
       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)
@@ -551,46 +519,49 @@ const generateRestfulComponent = (operation, verb, route, operationIds, paramete
       }
       
     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>) {
@@ -612,9 +583,21 @@ const generateRestfulComponent = (operation, verb, route, operationIds, paramete
     }
     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>) { 
@@ -622,95 +605,89 @@ const generateRestfulComponent = (operation, verb, route, operationIds, paramete
       { 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
   )};`;
     }
@@ -720,33 +697,51 @@ const generateRestfulComponent = (operation, verb, route, operationIds, paramete
     return output;
 };
 exports.generateRestfulComponent = generateRestfulComponent;
+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 += (0, exports.generateRestfulComponent)({
+                    operation,
+                    verb,
+                    route,
+                    operationIds,
+                    parameters: verbs.parameters,
+                    schemasComponents,
+                    headerFilters,
+                });
+            }
+        });
+    });
+    return output;
+};
 /**
  * Main entry of the generator. Generate react-query component from openAPI.
  */
-const importOpenApi = async ({ data, format, apiDir, }) => {
+const importOpenApi = async ({ data, format, apiDir, headerFilters = [], }) => {
     const operationIds = [];
     let specs = await importSpecs(data, format);
     (0, exports.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
+  ${(0, exports.generateSchemasDefinition)(specs.components?.schemas)}
+
+  // RESPONSES
+  ${(0, exports.generateResponsesDefinition)(specs.components?.responses)}
+
+  // REQUEST BODIES
+  ${(0, exports.generateRequestBodiesDefinition)(specs.components?.requestBodies)}
+
+  // HOOKS
+  ${generateQueryHooks(specs.paths, operationIds, specs.components, headerFilters)}
   `;
-    output += '\n\n// SCEHMAS\n';
-    output += (0, exports.generateSchemasDefinition)(specs.components && specs.components.schemas);
-    output += '\n\n// RESPONSES\n';
-    output += (0, exports.generateResponsesDefinition)(specs.components && specs.components.responses);
-    output += '\n\n// REQUEST BODIES\n';
-    output += (0, exports.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 += (0, exports.generateRestfulComponent)(operation, verb, route, operationIds, verbs.parameters, specs.components);
-            }
-        });
-    });
     return output;
 };
 exports.importOpenApi = importOpenApi;