react-query-lightbase-codegen 0.2.0 → 0.5.0

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

@@ -1,205 +1,13 @@
-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';
-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' ? yaml.load(data) : JSON.parse(data);
-    return new Promise((resolve, reject) => {
-        if (!schema.openapi || !schema.openapi.startsWith('3.')) {
-            swagger2openapi.convertObj(schema, {}, (err, convertedObj) => {
-                if (err) {
-                    reject(err);
-                }
-                else {
-                    // @ts-ignore
-                    convertedObj.openapi.basePath = convertedObj.original.basePath;
-                    resolve(convertedObj.openapi);
-                }
-            });
-        }
-        else {
-            resolve(schema);
-        }
-    });
-};
-/**
- * Discriminator helper for `ReferenceObject`
- */
-export const isReference = (property) => {
-    return Boolean(property.$ref);
-};
-/**
- * Return the typescript equivalent of open-api data type
- */
-export const getScalar = (item) => {
-    const nullable = item.nullable ? ' | null' : '';
-    switch (item.type) {
-        case 'number':
-        case 'integer':
-            return 'number' + nullable;
-        case 'boolean':
-            return 'boolean' + nullable;
-        case 'array':
-            return getArray(item) + nullable;
-        case 'string':
-            return (item.enum ? `"${item.enum.join(`" | "`)}"` : 'string') + nullable;
-        case 'object':
-        default:
-            return getObject(item) + nullable;
-    }
-};
-/**
- * Return the output type from the $ref
- */
-export const getRef = ($ref) => {
-    if ($ref.startsWith('#/components/schemas')) {
-        return pascal($ref.replace('#/components/schemas/', ''));
-    }
-    else if ($ref.startsWith('#/components/responses')) {
-        return pascal($ref.replace('#/components/responses/', '')) + 'Response';
-    }
-    else if ($ref.startsWith('#/components/parameters')) {
-        return pascal($ref.replace('#/components/parameters/', '')) + 'Parameter';
-    }
-    else if ($ref.startsWith('#/components/requestBodies')) {
-        return pascal($ref.replace('#/components/requestBodies/', '')) + 'RequestBody';
-    }
-    else {
-        throw new Error('This library only resolve $ref that are include into `#/components/*` for now');
-    }
-};
-/**
- * Return the output type from an array
- */
-export const getArray = (item) => {
-    if (item.items) {
-        if (!isReference(item.items) && (item.items.oneOf || item.items.allOf || item.items.enum)) {
-            return `(${resolveValue(item.items)})[]`;
-        }
-        else {
-            return `${resolveValue(item.items)}[]`;
-        }
-    }
-    else {
-        throw new Error('All arrays must have an `items` key define');
-    }
-};
-/**
- * Return the output type from an object
- */
-export const getObject = (item) => {
-    if (isReference(item)) {
-        return getRef(item.$ref);
-    }
-    if (item.allOf) {
-        return item.allOf.map(resolveValue).join(' & ');
-    }
-    if (item.oneOf) {
-        return item.oneOf.map(resolveValue).join(' | ');
-    }
-    if (!item.type && !item.properties && !item.additionalProperties) {
-        return '{}';
-    }
-    // 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))) {
-        return '{[key: string]: any}';
-    }
-    // Consolidation of item.properties & item.additionalProperties
-    let output = '{\n';
-    if (item.properties) {
-        output += Object.entries(item.properties)
-            .map(([key, prop]) => {
-            const doc = isReference(prop) ? '' : formatDescription(prop.description, 2);
-            const isRequired = (item.required || []).includes(key);
-            const processedKey = IdentifierRegexp.test(key) ? key : `"${key}"`;
-            return `${doc}\n${processedKey}${isRequired ? '' : '?'}: ${resolveValue(prop)};`;
-        })
-            .join('\n');
-    }
-    if (item.additionalProperties) {
-        if (item.properties) {
-            output += '\n';
-        }
-        output += `} & { [key: string]: ${item.additionalProperties === true ? 'any' : resolveValue(item.additionalProperties)}`;
-    }
-    if (item.properties || item.additionalProperties) {
-        if (output === '{\n') {
-            return '{}';
-        }
-        return output + '\n}';
-    }
-    return item.type === 'object' ? '{[key: string]: any}' : 'any';
-};
-/**
- * Resolve the value of a schema object to a proper type definition.
- */
-export const resolveValue = (schema) => isReference(schema) ? getRef(schema.$ref) : getScalar(schema);
-/**
- * Extract responses / request types from open-api specs
- */
-export const getResReqTypes = (responsesOrRequests) => uniq(responsesOrRequests.map(([_, res]) => {
-    if (!res) {
-        return 'void';
-    }
-    if (isReference(res)) {
-        return getRef(res.$ref);
-    }
-    if (res.content) {
-        for (let contentType of Object.keys(res.content)) {
-            if (contentType.startsWith('application/json') ||
-                contentType.startsWith('application/octet-stream')) {
-                const schema = res.content[contentType].schema;
-                return resolveValue(schema);
-            }
-        }
-        return 'void';
-    }
-    return 'void';
-})).join(' | ');
-/**
- * Return every params in a path
- *
- * @example
- * ```
- * getParamsInPath("/pet/{category}/{name}/");
- * // => ["category", "name"]
- * ```
- */
-export const getParamsInPath = (path) => {
-    let n;
-    const output = [];
-    const templatePathRegex = /\{(\w+)}/g;
-    while ((n = templatePathRegex.exec(path)) !== null) {
-        output.push(n[1]);
-    }
-    return output;
-};
-/**
- * Generate the interface string
- */
-export const generateInterface = (name, schema) => {
-    const scalar = getScalar(schema);
-    return `
-    ${formatDescription(schema.description)}
-    export type ${pascal(name)} = ${scalar}
-  `;
-};
+import { generateQueryHooks } from './generateHooks';
+import { generateImports } from './generateImports';
+import { isReference } from './getResReqTypes';
 /**
  * Propagate every `discriminator.propertyName` mapping to the original ref
  *
  * Note: This method directly mutate the `specs` object.
  */
-export const resolveDiscriminator = (specs) => {
+const resolveDiscriminator = (specs) => {
     if (specs.components && specs.components.schemas) {
         Object.values(specs.components.schemas).forEach((schema) => {
             if (isReference(schema) || !schema.discriminator || !schema.discriminator.mapping) {
@@ -215,759 +23,10 @@ export const resolveDiscriminator = (specs) => {
         });
     }
 };
-/**
- * Extract all types from #/components/schemas
- */
-export const generateSchemasDefinition = (schemas = {}) => {
-    if (isEmpty(schemas)) {
-        return '';
-    }
-    return (Object.entries(schemas)
-        .map(([name, schema]) => !isReference(schema) &&
-        (!schema.type || schema.type === 'object') &&
-        !schema.allOf &&
-        !schema.oneOf &&
-        !isReference(schema) &&
-        !schema.nullable
-        ? generateInterface(name, schema)
-        : `${formatDescription(isReference(schema) ? undefined : schema.description)}export type ${pascal(name)} = ${resolveValue(schema)};`)
-        .join('\n\n') + '\n');
-};
-/**
- * Extract all types from #/components/requestBodies
- */
-export const generateRequestBodiesDefinition = (requestBodies = {}) => {
-    if (isEmpty(requestBodies)) {
-        return '';
-    }
-    return ('\n' +
-        Object.entries(requestBodies)
-            .map(([name, requestBody]) => {
-            const doc = isReference(requestBody) ? '' : formatDescription(requestBody.description);
-            const type = getResReqTypes([['', requestBody]]);
-            const isEmptyInterface = type === '{}';
-            if (isEmptyInterface) {
-                return `export type ${pascal(name)}RequestBody = ${type}`;
-            }
-            else if (type.includes('{') && !type.includes('|') && !type.includes('&')) {
-                return `${doc}export type ${pascal(name)}RequestBody = ${type}`;
-            }
-            else {
-                return `${doc}export type ${pascal(name)}RequestBody = ${type};`;
-            }
-        })
-            .join('\n\n') +
-        '\n');
-};
-/**
- * Extract all types from #/components/responses
- */
-export const generateResponsesDefinition = (responses = {}) => {
-    if (isEmpty(responses)) {
-        return '';
-    }
-    return ('\n' +
-        Object.entries(responses)
-            .map(([name, response]) => {
-            const doc = isReference(response) ? '' : formatDescription(response.description);
-            const type = getResReqTypes([['', response]]);
-            const isEmptyInterface = type === '{}';
-            if (isEmptyInterface) {
-                return `export type RQ${pascal(name)}Response = ${type}`;
-            }
-            else if (type.includes('{') && !type.includes('|') && !type.includes('&')) {
-                return `${doc}export type RQ${pascal(name)}Response = ${type}`;
-            }
-            else {
-                return `${doc}export type RQ${pascal(name)}Response = ${type};`;
-            }
-        })
-            .join('\n\n') +
-        '\n');
-};
-/**
- * Format a description to code documentation.
- */
-export const formatDescription = (description, tabSize = 0) => description
-    ? `/**\n${description
-        .split('\n')
-        .map((i) => `${' '.repeat(tabSize)} *  ${i}`)
-        .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, headerFilters, }) => {
-    const { operationId = route.replace('/', '') } = operation;
-    if (operationId === '*') {
-        throw new Error(`Invalid operationId/Route set for ${verb} ${route}`);
-    }
-    if (operationIds.includes(operationId)) {
-        throw new Error(`"${operationId}" is duplicated in your schema definition!`);
-    }
-    operationIds.push(operationId);
-    route = route.replace(/\{/g, '${').replace('//', '/'); // `/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 isOk = ([statusCode]) => statusCode.toString().startsWith('2');
-    const responseTypes = getResReqTypes(Object.entries(operation.responses).filter(isOk)) || 'void';
-    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 = [], } = groupBy([...(parameters || []), ...(operation.parameters || [])].map((p) => {
-        if (isReference(p)) {
-            return get(schemasComponents, p.$ref.replace('#/components/', '').replace('/', '.'));
-        }
-        else {
-            return p;
-        }
-    }), 'in');
-    const headerParams = header.filter((p) => !headerFilters?.includes(p.name));
-    let enabled = [];
-    // TODO: extract all requestBody or remove useQuery variants
-    let enabledParam = '!!props';
-    [...queryParams, ...pathParams, ...headerParams].forEach((item) => {
-        if (item.required) {
-            enabled.push(`["${item.name}"]`);
-            if (enabledParam && enabledParam !== '!!props') {
-                enabledParam += `&& props['${item.name}'] != null`;
-            }
-            else {
-                enabledParam = `props['${item.name}'] != null`;
-            }
-        }
-    });
-    // `!props${enabled.join('== null && !props')}`;
-    const paramsTypes = paramsInPath
-        .map((p) => {
-        try {
-            const { name, required, schema } = pathParams.find((i) => i.name === p);
-            return `${name}${required ? '' : '?'}: ${resolveValue(schema)}`;
-        }
-        catch (err) {
-            throw new Error(`The path params ${p} can't be found in parameters (${operationId})`);
-        }
-    })
-        .join('; ');
-    const queryParamsType = queryParams
-        .map((p) => {
-        const processedName = IdentifierRegexp.test(p.name) ? p.name : `"${p.name}"`;
-        return `${formatDescription(p.description, 2)}${processedName}${p.required ? '' : '?'}: ${resolveValue(p.schema)}`;
-    })
-        .join(';\n  ');
-    const headerType = headerParams
-        .map((p) => {
-        try {
-            const { name, required, schema } = headerParams.find((i) => i.name === p.name);
-            return `"${name}"${required ? '' : '?'}: ${resolveValue(schema)}`;
-        }
-        catch (err) {
-            throw new Error(`The path params ${p} can't be found in parameters (${operationId})`);
-        }
-    })
-        .join('; ');
-    // Retrieve the type of the param for delete verb
-    const lastParamInTheRouteDefinition = operation.parameters && lastParamInTheRoute
-        ? operation.parameters.find((p) => {
-            if (isReference(p)) {
-                return false;
-            }
-            return p.name === lastParamInTheRoute;
-        }) // Reference is not possible
-        : { schema: { type: 'string' } };
-    if (!lastParamInTheRouteDefinition) {
-        throw new Error(`The path params ${lastParamInTheRoute} can't be found in parameters (${operationId})`);
-    }
-    let genericsTypes = `${needAResponseComponent ? componentName + 'Res' : responseTypes}`;
-    if (verb !== 'get') {
-        genericsTypes = `${needAResponseComponent ? componentName + 'Res' : responseTypes}`;
-    }
-    const description = formatDescription(operation.summary && operation.description
-        ? `${operation.summary}\n\n${operation.description}`
-        : `${operation.summary || ''}${operation.description || ''}`);
-    let output = `\n\n${description}`;
-    const typeOrInterface = `type ${componentName}Res =`;
-    output += `
-  ${needAResponseComponent ? `export ${typeOrInterface} ${responseTypes}` : ''}
-  `;
-    const headerParam = headerType && headerType !== 'void' ? `${headerType};` : '';
-    const queryParam = queryParamsType && queryParamsType !== 'void' ? `${queryParamsType}` : '';
-    const requestBodyComponent = requestBodyTypes && requestBodyTypes !== 'void' ? `${requestBodyTypes}` : '';
-    // QUERIES
-    if (!requestBodyComponent && paramsInPath.length && !queryParam && !headerParam) {
-        output += `
-    type ${componentName}Return = ${genericsTypes}
-    type ${componentName}Variables = {
-      ${paramsTypes}
-    }
-
-    use${componentName}Query.fetch = async (props: ${componentName}Variables ) => {
-      const result = await api.${verb}<${componentName}Return>(\`${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.updateCache = (
-      {params, updater, options}:
-      {params: ${componentName}Variables,
-      updater: Updater<${componentName}Return | undefined, ${componentName}Return>,
-      options?: SetDataOptions | undefined}
-    ) => queryClient.setQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), updater, options);
-    
-    use${componentName}Query.getQueryState = ({params, filters}:{params: ${componentName}Variables, filters?: QueryFilters})=> queryClient.getQueryState<${componentName}Return>(use${componentName}Query.queryKey(params), filters);
-    use${componentName}Query.getQueryData = ({params, filters}:{params: ${componentName}Variables, filters?: QueryFilters})=> queryClient.getQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), filters);
-    
-    use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
-    queryClient.prefetchQuery<${componentName}Return>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
-
-    use${componentName}Query.cancelQueries = (params: ${componentName}Variables) => queryClient.cancelQueries(use${componentName}Query.queryKey(params))
-    use${componentName}Query.invalidate = (params: ${componentName}Variables) =>
-      queryClient.invalidateQueries<${componentName}Return>(use${componentName}Query.queryKey(params));
-
-    type ${componentName}QueryProps<T = ${componentName}Return> = ${componentName}Variables & {
-      options?: UseQueryOptions<${componentName}Return, AxiosError, T, any> 
-    }
-    export function use${componentName}Query<T = ${componentName}Return>({ options = {}, ...props }: ${componentName}QueryProps<T>) { 
-      return useQuery(use${componentName}Query.queryKey(props), async () => use${componentName}Query.fetch(props), 
-      { enabled: ${enabledParam}, ...options }
-      );}
-
-    type ${componentName}MutationProps<T> = {
-      options?: UseMutationOptions<${componentName}Return, AxiosError, ${componentName}Variables, T> 
-    }
-    export function use${componentName}Mutation<T = ${componentName}Return>(props?: ${componentName}MutationProps<T>) { 
-      return useMutation(async (data) => use${componentName}Query.fetch(data),
-    props?.options
-  )};`;
-    }
-    if (!requestBodyComponent && paramsInPath.length && queryParam && !headerParam) {
-        output += `
-    type ${componentName}Return = ${genericsTypes}
-    type ${componentName}Variables = {
-      ${paramsTypes}
-      ${queryParamsType}; 
-    }
-
-    use${componentName}Query.fetch = async (props:${componentName}Variables) => {
-      const {${paramsInPath.join(', ')}, ...queryParams} = props
-      const params = queryString.stringify(queryParams);
-      const result = await api.${verb}<${componentName}Return>(\`${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.updateCache = (
-      {params, updater, options}:
-      {params: ${componentName}Variables,
-      updater: Updater<${componentName}Return | undefined, ${componentName}Return>,
-      options?: SetDataOptions | undefined}
-    ) => queryClient.setQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), updater, options);
-    
-    use${componentName}Query.getQueryState = ({params, filters}:{params: ${componentName}Variables, filters?: QueryFilters})=> queryClient.getQueryState<${componentName}Return>(use${componentName}Query.queryKey(params), filters);
-    use${componentName}Query.getQueryData = ({params, filters}:{params: ${componentName}Variables, filters?: QueryFilters})=> queryClient.getQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), filters);
-    
-    use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
-    queryClient.prefetchQuery<${componentName}Return>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
-
-    use${componentName}Query.cancelQueries = (params: ${componentName}Variables) => queryClient.cancelQueries(use${componentName}Query.queryKey(params))
-    use${componentName}Query.invalidate = (params: ${componentName}Variables) =>
-      queryClient.invalidateQueries<${componentName}Return>(use${componentName}Query.queryKey(params));
-      
-    type ${componentName}QueryProps<T = ${componentName}Return> = ${componentName}Variables & {
-      options?: UseQueryOptions<${componentName}Return, AxiosError, T, any> 
-    }
-    export function use${componentName}Query<T = ${componentName}Return>({ options = {}, ...props }: ${componentName}QueryProps<T>) { 
-    return useQuery(use${componentName}Query.queryKey(props), async () => use${componentName}Query.fetch(props), 
-    { enabled: ${enabledParam}, ...options }
-    );}
-    
-    type ${componentName}MutationProps<T> = {
-      options?: UseMutationOptions<${componentName}Return, AxiosError, ${componentName}Variables, T> 
-    }
-    export function use${componentName}Mutation<T = ${componentName}Return>(props?: ${componentName}MutationProps<T>) { 
-    return useMutation(async (data) => use${componentName}Query.fetch(data),
-    props?.options
-  )};`;
-    }
-    if (!requestBodyComponent && !paramsInPath.length && !queryParam && !headerParam) {
-        output += `
-    type ${componentName}Return = ${genericsTypes}
-    use${componentName}Query.fetch = async () => {
-      const result = await api.${verb}<${componentName}Return>(\`${route}\`);
-      return result.data;
-    }
-    use${componentName}Query.baseKey = (): QueryKey => ["${componentName.toLowerCase()}"];
-    use${componentName}Query.queryKey = (): QueryKey => use${componentName}Query.baseKey()
-
-    use${componentName}Query.updateCache = ({updater, options}:
-    {updater: Updater<${componentName}Return | undefined, ${componentName}Return>,
-      options?: SetDataOptions | undefined}
-    ) => queryClient.setQueryData<${componentName}Return>(use${componentName}Query.queryKey(), updater, options);
-    
-    use${componentName}Query.getQueryState = (props?: {filters?: QueryFilters})=> queryClient.getQueryState<${componentName}Return>(use${componentName}Query.queryKey(), props?.filters);
-    use${componentName}Query.getQueryData = (props?: {filters?: QueryFilters})=> queryClient.getQueryData<${componentName}Return>(use${componentName}Query.queryKey(), props?.filters);
-
-    use${componentName}Query.prefetch = () =>
-    queryClient.prefetchQuery<${componentName}Return>(use${componentName}Query.queryKey(), ()=> use${componentName}Query.fetch());
-
-    use${componentName}Query.cancelQueries = () => queryClient.cancelQueries(use${componentName}Query.queryKey())
-    use${componentName}Query.invalidate = () =>
-      queryClient.invalidateQueries<${componentName}Return>(use${componentName}Query.queryKey());
-
-
-    type ${componentName}QueryProps<T = ${componentName}Return> = {
-      options?: UseQueryOptions<${componentName}Return, AxiosError, T, any> 
-    }
-    export function use${componentName}Query<T = ${componentName}Return>(props?: ${componentName}QueryProps<T>) { 
-      return useQuery(use${componentName}Query.queryKey(), use${componentName}Query.fetch, props?.options
-      );} 
-      
-      type ${componentName}MutationProps<T> = {
-        options?: UseMutationOptions<${componentName}Return, AxiosError, void, T> 
-      }
-      export function use${componentName}Mutation<T = ${componentName}Return>(props?: ${componentName}MutationProps<T>) { 
-      return useMutation(async () => use${componentName}Query.fetch(),
-      props?.options
-    )};`;
-    }
-    if (!requestBodyComponent && !paramsInPath.length && queryParam && !headerParam) {
-        output += `
-
-    type ${componentName}Return = ${genericsTypes}
-    type ${componentName}Variables = { 
-      ${queryParamsType} 
-    }
-
-    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}<${componentName}Return>(\`${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.updateCache = (
-      {params, updater, options}:
-      {params: ${componentName}Variables,
-      updater: Updater<${componentName}Return | undefined, ${componentName}Return>,
-      options?: SetDataOptions | undefined}
-    ) => queryClient.setQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), updater, options);
-    
-    use${componentName}Query.getQueryState = ({params, filters}:{params: ${componentName}Variables, filters?: QueryFilters})=> queryClient.getQueryState<${componentName}Return>(use${componentName}Query.queryKey(params), filters);
-    use${componentName}Query.getQueryData = ({params, filters}:{params: ${componentName}Variables, filters?: QueryFilters})=> queryClient.getQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), filters);
-    
-    use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
-    queryClient.prefetchQuery<${componentName}Return>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
-
-    use${componentName}Query.cancelQueries = (params: ${componentName}Variables) => queryClient.cancelQueries(use${componentName}Query.queryKey(params))
-    use${componentName}Query.invalidate = (params: ${componentName}Variables) =>
-      queryClient.invalidateQueries<${componentName}Return>(use${componentName}Query.queryKey(params));
-
-    export function use${componentName}Query<T = ${componentName}Return>({ options = {}, ...props }: ${componentName}Variables & { options?: UseQueryOptions<${componentName}Return, AxiosError, T, any>}) { 
-    return useQuery(use${componentName}Query.queryKey(props), async () => use${componentName}Query.fetch(props), 
-    { enabled: ${enabledParam}, ...options }
-    );}
-    
-    export function use${componentName}Mutation<T = ${componentName}Return>(props?: { options?: UseMutationOptions<${componentName}Return, AxiosError, ${componentName}Variables, T>}) { 
-      return useMutation(async (data) => use${componentName}Query.fetch(data),
-      props?.options
-    )};
-`;
-    }
-    if (requestBodyComponent && !paramsInPath.length && !queryParam && !headerParam) {
-        output += `
-    type ${componentName}Return = ${genericsTypes}
-    type ${componentName}Variables = ${requestBodyComponent};
-
-    use${componentName}Query.fetch = async (body: ${componentName}Variables) => {
-      const result = await api.${verb}<${componentName}Return>(\`${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];
-
-    use${componentName}Query.updateCache = (
-      {params, updater, options}:
-      {params: ${componentName}Variables,
-      updater: Updater<${componentName}Return | undefined, ${componentName}Return>,
-      options?: SetDataOptions | undefined}
-    ) => queryClient.setQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), updater, options);
-    
-    use${componentName}Query.getQueryState = ({params, filters}:{params: ${componentName}Variables, filters?: QueryFilters})=> queryClient.getQueryState<${componentName}Return>(use${componentName}Query.queryKey(params), filters);
-    use${componentName}Query.getQueryData = ({params, filters}:{params: ${componentName}Variables, filters?: QueryFilters})=> queryClient.getQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), filters);
-    
-    use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
-    queryClient.prefetchQuery<${componentName}Return>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
-
-    use${componentName}Query.cancelQueries = (params: ${componentName}Variables) => queryClient.cancelQueries(use${componentName}Query.queryKey(params))
-    use${componentName}Query.invalidate = (params: ${componentName}Variables) =>
-      queryClient.invalidateQueries<${componentName}Return>(use${componentName}Query.queryKey(params));
-
-    
-    type ${componentName}QueryProps<T = ${componentName}Return> = ${componentName}Variables & {
-      options?: UseQueryOptions<${componentName}Return, AxiosError, T, any> 
-    }
-    export function use${componentName}Query<T = ${componentName}Return>({ 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<${componentName}Return, AxiosError, ${componentName}Variables, T> 
-    }
-    export function use${componentName}Mutation<T = ${componentName}Return>(props?: ${componentName}MutationProps<T>) { 
-      return useMutation(async (body) => use${componentName}Query.fetch(body),
-    props?.options
-  )};`;
-    }
-    if (requestBodyComponent && paramsInPath.length && !queryParam && !headerParam) {
-        output += `
-    type ${componentName}Return = ${genericsTypes}
-    type ${componentName}Variables = {
-      body: ${requestBodyComponent}
-      ${paramsTypes}
-    }
-
-    type ${componentName}QueryProps<T = ${componentName}Return> =  ${componentName}Variables & {
-      options?: UseQueryOptions<${componentName}Return, AxiosError, T, any> 
-    }
-
-    use${componentName}Query.fetch = async (props: ${componentName}Variables) => {
-      const {${paramsInPath.join(', ')}, ...body} = props
-      const result = await api.${verb}<${componentName}Return>(\`${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];
-
-    use${componentName}Query.updateCache = (
-      {params, updater, options}:
-      {params: ${componentName}Variables,
-      updater: Updater<${componentName}Return | undefined, ${componentName}Return>,
-      options?: SetDataOptions | undefined}
-    ) => queryClient.setQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), updater, options);
-    
-    use${componentName}Query.getQueryState = ({params, filters}:{params: ${componentName}Variables, filters?: QueryFilters})=> queryClient.getQueryState<${componentName}Return>(use${componentName}Query.queryKey(params), filters);
-    use${componentName}Query.getQueryData = ({params, filters}:{params: ${componentName}Variables, filters?: QueryFilters})=> queryClient.getQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), filters);
-    
-    use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
-    queryClient.prefetchQuery<${componentName}Return>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
-
-    use${componentName}Query.cancelQueries = (params: ${componentName}Variables) => queryClient.cancelQueries(use${componentName}Query.queryKey(params))
-    use${componentName}Query.invalidate = (params: ${componentName}Variables) =>
-      queryClient.invalidateQueries<${componentName}Return>(use${componentName}Query.queryKey(params));
-
-
-    export function use${componentName}Query<T = ${componentName}Return>({ options = {}, ...props }: ${componentName}QueryProps<T>) { 
-    return useQuery(use${componentName}Query.queryKey(props), async () =>  use${componentName}Query.fetch(props), 
-    { enabled: ${enabledParam}, ...options }
-    );}
-    
-    type ${componentName}MutationProps<T> = {
-      options?: UseMutationOptions<${componentName}Return, AxiosError, ${componentName}Variables, T>
-    }
-    export function use${componentName}Mutation<T = ${componentName}Return>(props?: ${componentName}MutationProps<T>) {
-    return useMutation(async (body) => use${componentName}Query.fetch(body),
-   props?.options
-  )};`;
-    }
-    if (requestBodyComponent && !paramsInPath.length && queryParam && !headerParam) {
-        output += `
-    type ${componentName}Return = ${genericsTypes}
-    type ${componentName}Variables = {
-      body: ${requestBodyComponent} 
-      ${queryParamsType} 
-    }
-
-    type ${componentName}QueryProps<T = ${componentName}Return> = ${componentName}Variables & {
-      options?: UseQueryOptions<${componentName}Return, AxiosError, T, any> 
-    }
-
-    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}<${componentName}Return>(\`${route}?\${params}\`, props.body)
-      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.updateCache = (
-      {params, updater, options}:
-      {params: ${componentName}Variables,
-      updater: Updater<${componentName}Return | undefined, ${componentName}Return>,
-      options?: SetDataOptions | undefined}
-    ) => queryClient.setQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), updater, options);
-    
-    use${componentName}Query.getQueryState = ({params, filters}:{params: ${componentName}Variables, filters?: QueryFilters})=> queryClient.getQueryState<${componentName}Return>(use${componentName}Query.queryKey(params), filters);
-    use${componentName}Query.getQueryData = ({params, filters}:{params: ${componentName}Variables, filters?: QueryFilters})=> queryClient.getQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), filters);
-    
-    use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
-    queryClient.prefetchQuery<${componentName}Return>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
-
-    use${componentName}Query.cancelQueries = (params: ${componentName}Variables) => queryClient.cancelQueries(use${componentName}Query.queryKey(params))
-    use${componentName}Query.invalidate = (params: ${componentName}Variables) =>
-      queryClient.invalidateQueries<${componentName}Return>(use${componentName}Query.queryKey(params));
-
-
-    export function use${componentName}Query<T = ${componentName}Return>({ options = {}, ...props }: ${componentName}QueryProps<T>) { 
-    return useQuery(use${componentName}Query.queryKey(props), async () =>  use${componentName}Query.fetch(props), 
-    { enabled: ${enabledParam}, ...options }
-    );}
-    
-    
-    type ${componentName}MutationProps<T> = {
-      options?: UseMutationOptions<${componentName}Return, AxiosError, ${componentName}Variables, T>
-    }
-    export function use${componentName}Mutation<T = ${componentName}Return>(props?: ${componentName}MutationProps<T>) {
-    return useMutation(async (body) => use${componentName}Query.fetch(body),
-   props?.options
-  )};`;
-    }
-    if (requestBodyComponent && paramsInPath.length && queryParam && !headerParam) {
-        output += `// TODO: NOT SUPPORTED 2`;
-    }
-    if (requestBodyComponent && !paramsInPath.length && queryParam && headerParam) {
-        output += `// TODO: NOT SUPPORTED 3`;
-    }
-    if (requestBodyComponent && paramsInPath.length && queryParam && headerParam) {
-        output += `// TODO: NOT SUPPORTED 4`;
-    }
-    if (!requestBodyComponent && paramsInPath.length && !queryParam && headerParam) {
-        output += `// TODO: NOT SUPPORTED 5`;
-    }
-    if (!requestBodyComponent && paramsInPath.length && queryParam && headerParam) {
-        output += `// TODO: NOT SUPPORTED 6`;
-    }
-    if (!requestBodyComponent && !paramsInPath.length && !queryParam && headerParam) {
-        output += `
-    type ${componentName}Return = ${genericsTypes}
-    type ${componentName}Variables = {
-      ${headerParam}
-    };
-
-    use${componentName}Query.fetch = async (headers: ${componentName}Variables) => {
-      const result = await api.${verb}<${componentName}Return>(\`${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];
-
-    use${componentName}Query.updateCache = (
-      {params, updater, options}:
-      {params: ${componentName}Variables,
-      updater: Updater<${componentName}Return | undefined, ${componentName}Return>,
-      options?: SetDataOptions | undefined}
-    ) => queryClient.setQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), updater, options);
-    
-    use${componentName}Query.getQueryState = ({params, filters}:{params: ${componentName}Variables, filters?: QueryFilters})=> queryClient.getQueryState<${componentName}Return>(use${componentName}Query.queryKey(params), filters);
-    use${componentName}Query.getQueryData = ({params, filters}:{params: ${componentName}Variables, filters?: QueryFilters})=> queryClient.getQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), filters);
-    
-    use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
-    queryClient.prefetchQuery<${componentName}Return>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
-
-    use${componentName}Query.cancelQueries = (params: ${componentName}Variables) => queryClient.cancelQueries(use${componentName}Query.queryKey(params))
-    use${componentName}Query.invalidate = (params: ${componentName}Variables) =>
-      queryClient.invalidateQueries<${componentName}Return>(use${componentName}Query.queryKey(params));
-
-
-    type ${componentName}QueryProps<T = ${componentName}Return> = ${componentName}Variables & {
-      options?: UseQueryOptions<${componentName}Return, AxiosError, T, any> 
-    }
-    export function use${componentName}Query<T = ${componentName}Return>({ options = {}, ...props }: ${componentName}QueryProps<T>) { 
-      return useQuery(use${componentName}Query.queryKey(props), async () => use${componentName}Query.fetch(props), 
-      { enabled: ${enabledParam}, ...options }
-      );}
-
-      type ${componentName}MutationProps<T> = {
-        options?: UseMutationOptions<${componentName}Return, AxiosError, ${componentName}Variables, T> 
-      }
-      export function use${componentName}Mutation<T = ${componentName}Return>(props?: ${componentName}MutationProps<T>) { 
-      return useMutation(async (data) => use${componentName}Query.fetch(data),
-      props?.options
-    )};`;
-    }
-    if (!requestBodyComponent && !paramsInPath.length && queryParam && headerParam) {
-        output += `
-    type ${componentName}Return = ${genericsTypes}
-
-    type ${componentName}Variables = {
-      ${headerParam}
-      ${queryParamsType}; 
-    };
-
-    use${componentName}Query.fetch = async (data: ${componentName}Variables) => {
-      const params = queryString.stringify({
-        ${queryParams.map((p) => `"${p.name}": data["${p.name}"]`).join(',')}
-      });
-      const headers = {
-        ${headerParams.map((p) => `"${p.name}": data["${p.name}"]`).join(',')}
-      }
-      const result = await api.${verb}<${componentName}Return>(\`${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];
-
-    use${componentName}Query.updateCache = (
-      {params, updater, options}:
-      {params: ${componentName}Variables,
-      updater: Updater<${componentName}Return | undefined, ${componentName}Return>,
-      options?: SetDataOptions | undefined}
-    ) => queryClient.setQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), updater, options);
-    
-    use${componentName}Query.getQueryState = ({params, filters}:{params: ${componentName}Variables, filters?: QueryFilters})=> queryClient.getQueryState<${componentName}Return>(use${componentName}Query.queryKey(params), filters);
-    use${componentName}Query.getQueryData = ({params, filters}:{params: ${componentName}Variables, filters?: QueryFilters})=> queryClient.getQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), filters);
-    
-    use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
-      queryClient.prefetchQuery<${componentName}Return>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
-
-    use${componentName}Query.cancelQueries = (params: ${componentName}Variables) => queryClient.cancelQueries(use${componentName}Query.queryKey(params))
-      use${componentName}Query.invalidate = (params: ${componentName}Variables) =>
-      queryClient.invalidateQueries<${componentName}Return>(use${componentName}Query.queryKey(params));
-
-    type ${componentName}QueryProps<T = ${componentName}Return> = ${componentName}Variables & {
-      options?: UseQueryOptions<${componentName}Return, AxiosError, T, any> 
-    }
-    export function use${componentName}Query<T = ${componentName}Return>({ options = {}, ...props }: ${componentName}QueryProps<T>) { 
-    return useQuery(use${componentName}Query.queryKey(props), async () => use${componentName}Query.fetch(props), 
-    {  enabled: ${enabledParam}, ...options }
-    );}
-    
-    type ${componentName}MutationProps<T> = {
-      options?: UseMutationOptions<${componentName}Return, AxiosError, ${componentName}Variables, T> 
-    }
-  
-    export function use${componentName}Mutation<T = ${componentName}Return>(props?: ${componentName}MutationProps<T>) { 
-    return useMutation(async (data) => use${componentName}Query.fetch(data),
-    props?.options
-  )};`;
-    }
-    if (requestBodyComponent && !paramsInPath.length && !queryParam && headerParam) {
-        output += `
-    type ${componentName}Return = ${genericsTypes}
-
-    type ${componentName}Variables = {
-      body: ${requestBodyComponent}
-      ${headerParam}
-    };
-
-    use${componentName}Query.fetch = async (body: ${componentName}Variables) => {
-      const headers = {
-        ${headerParams.map((param) => `"${param.name}": body["${param.name}"]`).join(',')}
-      }
-      const result = await api.${verb}<${componentName}Return>(\`${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];
-
-    use${componentName}Query.updateCache = (
-      {params, updater, options}:
-      {params: ${componentName}Variables,
-      updater: Updater<${componentName}Return | undefined, ${componentName}Return>,
-      options?: SetDataOptions | undefined}
-    ) => queryClient.setQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), updater, options);
-    
-    use${componentName}Query.getQueryState = ({params, filters}:{params: ${componentName}Variables, filters?: QueryFilters})=> queryClient.getQueryState<${componentName}Return>(use${componentName}Query.queryKey(params), filters);
-    use${componentName}Query.getQueryData = ({params, filters}:{params: ${componentName}Variables, filters?: QueryFilters})=> queryClient.getQueryData<${componentName}Return>(use${componentName}Query.queryKey(params), filters);
-    
-    use${componentName}Query.prefetch = (params: ${componentName}Variables) =>
-    queryClient.prefetchQuery<${componentName}Return>(use${componentName}Query.queryKey(params), ()=> use${componentName}Query.fetch(params));
-
-    use${componentName}Query.cancelQueries = (params: ${componentName}Variables) => queryClient.cancelQueries(use${componentName}Query.queryKey(params))
-    use${componentName}Query.invalidate = (params: ${componentName}Variables) =>
-      queryClient.invalidateQueries<${componentName}Return>(use${componentName}Query.queryKey(params));
-
-    type ${componentName}QueryProps<T = ${componentName}Return> = ${componentName}Variables & {
-      options?: UseQueryOptions<${componentName}Return, AxiosError, T, any> 
-    }
-    export function use${componentName}Query<T = ${componentName}Return>({ options = {}, ...props }: ${componentName}QueryProps<T>) { 
-      return useQuery(use${componentName}Query.queryKey(props), async () => use${componentName}Query.fetch(props), 
-      { enabled: ${enabledParam}, ...options }
-      );}
-
-    
-    type ${componentName}MutationProps<T> = {
-      options?: UseMutationOptions<${componentName}Return, AxiosError, ${componentName}Variables, T> 
-    }
-    export function use${componentName}Mutation<T = ${componentName}Return>(props?: ${componentName}MutationProps<T>) { 
-    return useMutation(async (body) => use${componentName}Query.fetch(body),
-    props?.options
-  )};`;
-    }
-    if (requestBodyComponent && paramsInPath.length && !queryParam && headerParam) {
-        output += `// TODO: CODEGEN DOES NOT SUPPORT requestBodyComponent AND paramsInPath AND headerParam`;
-    }
-    return output;
-};
-const generateQueryHooks = (spec, operationIds, headerFilters) => {
-    const { paths, components } = spec;
-    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: spec.basePath + route,
-                    operationIds,
-                    parameters: verbs.parameters,
-                    schemasComponents: components,
-                    headerFilters,
-                });
-            }
-        });
-    });
-    return output;
-};
-/**
- * Main entry of the generator. Generate react-query component from openAPI.
- */
-export const importOpenApi = async ({ data, format, apiDirectory, queryClientDir, headerFilters = [], }) => {
+export const importOpenApi = async ({ specs, apiDirectory, queryClientDir, headerFilters = [], }) => {
     const operationIds = [];
-    let specs = await importSpecs(data, format);
     resolveDiscriminator(specs);
-    let output = '';
-    output = `
-  import {
-    useQuery,
-    useMutation,
-    UseQueryOptions,
-    UseMutationOptions,
-    QueryKey,
-    SetDataOptions,
-    QueryFilters
-  } from '@tanstack/react-query';
-  
-  import queryString from 'query-string';
-  import { AxiosError } from 'axios';
-  import { api } from '${apiDirectory}';
-  import { queryClient } from '${queryClientDir}';
-
-  type Updater<TInput, TOutput> = TOutput | ((input: TInput) => TOutput);
-
-  // SCEHMAS
-  ${generateSchemasDefinition(specs.components?.schemas)}
-
-  // RESPONSES
-  ${generateResponsesDefinition(specs.components?.responses)}
-
-  // REQUEST BODIES
-  ${generateRequestBodiesDefinition(specs.components?.requestBodies)}
-
-  // HOOKS
-  ${generateQueryHooks(specs, operationIds, headerFilters)}
-  `;
-    return output;
+    const imports = generateImports({ apiDirectory, queryClientDir });
+    const hooks = generateQueryHooks(specs, operationIds, headerFilters);
+    return imports + hooks;
 };