react-query-lightbase-codegen 0.0.2 → 0.0.3

package/src/scripts/import-open-api.ts

@@ -1,739 +0,0 @@
-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 {
-  ComponentsObject,
-  OpenAPIObject,
-  OperationObject,
-  ParameterObject,
-  PathItemObject,
-  ReferenceObject,
-  RequestBodyObject,
-  ResponseObject,
-  SchemaObject,
-} from 'openapi3-ts';
-
-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: string, extension: 'yaml' | 'json'): Promise<OpenAPIObject> => {
-  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 {
-          resolve(convertedObj.openapi);
-        }
-      });
-    } else {
-      resolve(schema);
-    }
-  });
-};
-
-/**
- * Discriminator helper for `ReferenceObject`
- */
-export const isReference = (property: any): property is ReferenceObject => {
-  return Boolean(property.$ref);
-};
-
-/**
- * Return the typescript equivalent of open-api data type
- */
-export const getScalar = (item: SchemaObject) => {
-  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: ReferenceObject['$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: SchemaObject): string => {
-  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: SchemaObject): string => {
-  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]: [string, ReferenceObject | SchemaObject]) => {
-        const doc = isReference(prop) ? '' : formatDescription(prop.description, 2);
-        const isRequired = (item.required || []).includes(key);
-        const processedKey = IdentifierRegexp.test(key) ? key : `"${key}"`;
-        return `  ${doc}${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: SchemaObject) =>
-  isReference(schema) ? getRef(schema.$ref) : getScalar(schema);
-
-/**
- * Extract responses / request types from open-api specs
- */
-export const getResReqTypes = (
-  responsesOrRequests: Array<[string, ResponseObject | ReferenceObject | RequestBodyObject]>
-) =>
-  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: string) => {
-  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: string, schema: SchemaObject) => {
-  const scalar = getScalar(schema);
-  return `${formatDescription(schema.description)}export interface ${pascal(name)} ${scalar}`;
-};
-
-/**
- * Propagate every `discriminator.propertyName` mapping to the original ref
- *
- * Note: This method directly mutate the `specs` object.
- */
-export const resolveDiscriminator = (specs: OpenAPIObject) => {
-  if (specs.components && specs.components.schemas) {
-    Object.values(specs.components.schemas).forEach((schema) => {
-      if (isReference(schema) || !schema.discriminator || !schema.discriminator.mapping) {
-        return;
-      }
-      const { mapping, propertyName } = schema.discriminator;
-
-      Object.entries(mapping).forEach(([name, ref]) => {
-        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]
-        );
-      });
-    });
-  }
-};
-
-/**
- * Extract all types from #/components/schemas
- */
-export const generateSchemasDefinition = (schemas: ComponentsObject['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: ComponentsObject['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 interface ${pascal(name)}RequestBody ${type}`;
-        } else if (type.includes('{') && !type.includes('|') && !type.includes('&')) {
-          return `${doc}export interface ${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: ComponentsObject['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 interface RQ${pascal(name)}Response ${type}`;
-        } else if (type.includes('{') && !type.includes('|') && !type.includes('&')) {
-          return `${doc}export interface 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?: string, tabSize = 0) =>
-  description
-    ? `/**\n${description
-        .split('\n')
-        .map((i) => `${' '.repeat(tabSize)} * ${i}`)
-        .join('\n')}\n${' '.repeat(tabSize)} */\n${' '.repeat(tabSize)}`
-    : '';
-
-/**
- * Generate a react-query component from openapi operation specs
- */
-export const generateRestfulComponent = (
-  operation: OperationObject,
-  verb: string,
-  route: string,
-  operationIds: string[],
-  parameters: Array<ReferenceObject | ParameterObject> = [],
-  schemasComponents?: ComponentsObject
-) => {
-  if (!operation.operationId) {
-    throw new Error(`Every path must have a operationId - No operationId set for ${verb} ${route}`);
-  }
-  if (operationIds.includes(operation.operationId)) {
-    throw new Error(`"${operation.operationId}" is duplicated in your schema definition!`);
-  }
-  operationIds.push(operation.operationId);
-
-  route = route.replace(/\{/g, '${'); // `/pet/{id}` => `/pet/${id}`
-
-  // Remove the last param of the route if we are in the DELETE case
-  let lastParamInTheRoute: string | null = null;
-
-  const componentName = pascal(operation.operationId!);
-
-  const isOk = ([statusCode]: [string, ResponseObject | ReferenceObject]) =>
-    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 = [] } = groupBy(
-    [...parameters, ...(operation.parameters || [])].map<ParameterObject>((p) => {
-      if (isReference(p)) {
-        return get(schemasComponents, p.$ref.replace('#/components/', '').replace('/', '.'));
-      } else {
-        return p;
-      }
-    }),
-    'in'
-  );
-
-  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 (${operation.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  ');
-
-  // 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;
-        }) as ParameterObject | undefined) // Reference is not possible
-      : { schema: { type: 'string' } };
-
-  if (!lastParamInTheRouteDefinition) {
-    throw new Error(
-      `The path params ${lastParamInTheRoute} can't be found in parameters (${operation.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 queryParam = queryParamsType && queryParamsType !== 'void' ? `${queryParamsType}` : '';
-  const requestBodyComponent = requestBodyTypes && requestBodyTypes !== 'void' ? `${requestBodyTypes}` : '';
-
-  // QUERIES
-  if (!requestBodyComponent && paramsInPath.length && !queryParam) {
-    output += `interface ${componentName}QueryProps<T = ${genericsTypes}> {
-      ${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 result = await api.${verb}<${genericsTypes}>(\`${route.replace(/\{/g, '{props.')}\`);
-      return result.data;
-    }
-    
-    use${componentName}Query.baseKey = (): QueryKey => ["${componentName.toLowerCase()}"];
-
-    use${componentName}Query.queryKey = (params: {${paramsTypes}} ): QueryKey => [...use${componentName}Query.baseKey(), params];
-
-    `;
-
-    output += `interface ${componentName}MutationVariables {
-      ${paramsTypes}
-    }
-    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 ({${paramsInPath.join(', ')}}) => {
-      const result = await api.${verb}<${genericsTypes}>(\`${route}\`) 
-      return result.data
-    },
-    props?.options
-  )};`;
-  }
-
-  if (!requestBodyComponent && paramsInPath.length && queryParam) {
-    output += `interface ${componentName}QueryProps<T = ${genericsTypes}> {
-      ${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);
-      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];
-    
-    `;
-
-    output += `interface ${componentName}MutationVariables {
-      ${paramsTypes}
-      ${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 {${paramsInPath.join(', ')}, ...queryParams} = data
-      const params = queryString.stringify(queryParams);
-      const result = await api.${verb}<${genericsTypes}>(\`${route}?\${params}\`)
-      return result.data
-    },
-    props?.options
-  )};`;
-  }
-
-  if (!requestBodyComponent && !paramsInPath.length && !queryParam) {
-    output += `interface ${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> {
-        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;
-      },
-      props?.options
-    )};`;
-  }
-
-  if (!requestBodyComponent && !paramsInPath.length && queryParam) {
-    output += `interface ${componentName}QueryProps<T = ${genericsTypes}> {
-      ${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.${queryParams.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];
-    
-    `;
-
-    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
-  )};`;
-  }
-
-  if (requestBodyComponent && !paramsInPath.length && !queryParam) {
-    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
-    );}
-
-    use${componentName}Query.fetch = async (body: Omit<${componentName}QueryProps, 'options'>) => {
-      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 = ${requestBodyComponent};
-    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 (body) => { 
-      const result = await api.${verb}<${genericsTypes}>(\`${route}\`, body)
-      return result.data
-    },
-    props?.options
-  )};`;
-  }
-
-  if (requestBodyComponent && paramsInPath.length && !queryParam) {
-    output += `interface ${componentName}QueryProps<T = ${genericsTypes}> extends  ${requestBodyComponent
-      .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 }
-    );}
-
-    // HEHEH
-    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> {
-      options?: UseMutationOptions<${genericsTypes}, AxiosError, ${componentName}MutationVariables, T>
-    }
-    export function use${componentName}Mutation<T = ${genericsTypes}>(props?: ${componentName}MutationProps<T>) {
-    return useMutation(async (body) => use${componentName}Query.fetch(body),
-   props?.options
-  )};`;
-  }
-
-  if (requestBodyComponent && queryParam) {
-    output += `// TODO: CODEGEN DOES NOT SUPPORT QUERYPARAM AND REQUESTBODY`;
-  }
-
-  return output;
-};
-
-/**
- * Main entry of the generator. Generate react-query component from openAPI.
- */
-const importOpenApi = async ({ data, format }: { data: string; format: 'yaml' | 'json' }) => {
-  const operationIds: string[] = [];
-  let specs = await importSpecs(data, format);
-  resolveDiscriminator(specs);
-
-  let output = `
-  import { useQuery, useMutation, UseQueryOptions, UseMutationOptions, QueryKey } from 'react-query';
-  import queryString from 'query-string';
-  import {AxiosError} from 'axios';
-  import { api } from 'api';
-  `;
-
-  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]: [string, PathItemObject]) => {
-    Object.entries(verbs).forEach(([verb, operation]: [string, OperationObject]) => {
-      if (['get', 'post', 'patch', 'put', 'delete'].includes(verb) && !operation.deprecated) {
-        output += generateRestfulComponent(
-          operation,
-          verb,
-          route,
-          operationIds,
-          verbs.parameters,
-          specs.components
-        );
-      }
-    });
-  });
-
-  return output;
-};
-
-export default importOpenApi;