react-query-lightbase-codegen 1.0.2 → 1.0.3

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "react-query-lightbase-codegen",
   "description": "Fully typed react query code generation tool based on openApi specifications",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "license": "MIT",
   "type": "module",
   "exports": "./dist/index.js",
   "files": [
-    "lib/"
+    "src",
+    "dist"
   ],
   "keywords": [
     "rest",

package/src/convertSwaggerFile.ts

@@ -0,0 +1,25 @@
+import { OpenAPIObject } from 'openapi3-ts';
+import swagger2openapi from 'swagger2openapi';
+import yaml from 'js-yaml';
+
+/**
+ * Import and parse the openapi spec from a yaml/json
+ */
+export const convertSwaggerFile = (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 {
+          // @ts-ignore
+          convertedObj.openapi.basePath = convertedObj.original.basePath;
+          resolve(convertedObj.openapi);
+        }
+      });
+    } else {
+      resolve(schema);
+    }
+  });
+};

package/src/generateHooks.ts

@@ -0,0 +1,490 @@
+import lodash from 'lodash';
+const { get, groupBy } = lodash;
+import {
+  ComponentsObject,
+  OperationObject,
+  ParameterObject,
+  ReferenceObject,
+  ResponseObject,
+  SchemaObject,
+} from 'openapi3-ts';
+import { formatDescription, getResReqTypes, isReference, resolveValue } from './utils.js';
+import pasCase from 'case';
+import chalk from 'chalk';
+
+const { pascal, camel } = pasCase;
+
+const IdentifierRegexp = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
+
+/**
+ * Return every params in a path
+ */
+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 a react-query component from openapi operation specs
+ */
+export const createHook = ({
+  operation,
+  verb,
+  route,
+  operationIds,
+  parameters,
+  schemasComponents,
+  headerFilters,
+  overrides,
+}: {
+  operation: OperationObject;
+  verb: string;
+  route: string;
+  operationIds: string[];
+  parameters: (ReferenceObject | ParameterObject)[] | undefined;
+  schemasComponents?: ComponentsObject;
+  headerFilters?: string[];
+  overrides?: Record<
+    string,
+    { type: 'query' } | { type: 'mutation' } | { type: 'infiniteQuery'; infiniteQueryParm: string }
+  >;
+}) => {
+  const { operationId = route.replace('/', '') } = operation;
+  if (operationId === '*') {
+    throw new Error(`Invalid operationId/Route set for ${verb} ${route}`);
+  }
+  if (operationIds.includes(operationId)) {
+    return { implementation: '', imports: [], queryImports: [] };
+  }
+  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: string | null = null;
+
+  const componentName = pascal(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!]]);
+
+  let imports = [responseTypes];
+  let queryImports = [] as Array<'mutation' | 'query' | 'infiniteQuery'>;
+
+  const paramsInPath = getParamsInPath(route).filter(
+    (param) => !(verb === 'delete' && param === lastParamInTheRoute)
+  );
+
+  const {
+    query: queryParams = [],
+    path: pathParams = [],
+    header = [],
+  } = groupBy(
+    [...(parameters || []), ...(operation.parameters || [])].map<ParameterObject>((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 = [] as any;
+
+  // TODO: extract all requestBody or remove useQuery variants
+  let enabledParam = '!!params';
+  [...queryParams, ...pathParams, ...headerParams].forEach((item) => {
+    if (item.required) {
+      enabled.push(`["${item.name}"]`);
+      if (enabledParam && enabledParam !== '!!params') {
+        enabledParam += `&& params['${item.name}'] != null`;
+      } else {
+        enabledParam = `params['${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)}
+      ${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;
+        }) 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 (${operationId})`);
+  }
+
+  const defaultDescription = `type: ${verb}\noperationId: ${operationId}\nurl: ${route}`;
+
+  const description = formatDescription(
+    operation.summary && operation.description
+      ? `${defaultDescription}\n\n${operation.summary}\n\n${operation.description}`
+      : `${defaultDescription}`
+  );
+
+  let output = `\n\n${description}`;
+
+  const headerParam = headerType && headerType !== 'void' ? `${headerType};` : '';
+  const queryParam = queryParamsType && queryParamsType !== 'void' ? `${queryParamsType}` : '';
+  const requestBodyComponent = requestBodyTypes && requestBodyTypes !== 'void' ? `${requestBodyTypes}` : '';
+
+  if (requestBodyComponent) {
+    imports.push(requestBodyComponent);
+  }
+
+  const isUpdateRequest = ['post', 'patch', 'put'].includes(verb);
+
+  const generateProps = (props: ParameterObject[]) => {
+    return props.map((item) => `["${item.name}"]: props["${item.name}"]`).join(',');
+  };
+
+  const generateBodyProps = () => {
+    const definitionKey = Object.keys(schemasComponents?.schemas || {}).find(
+      (key) => pascal(key) === requestBodyComponent
+    );
+    if (definitionKey) {
+      const scheme = schemasComponents?.schemas?.[definitionKey] as SchemaObject;
+      return Object.keys(scheme.properties as SchemaObject)
+        .map((item: string) => `["${item}"]: props["${item}"]`)
+        .join(',');
+    }
+  };
+
+  const fetchName = camel(componentName);
+
+  const createQueryHooks = (emptyParams?: boolean) => {
+    const params = emptyParams ? '' : `params: ${componentName}Params,`;
+    const key = emptyParams ? '' : `params`;
+    const mutationParams = emptyParams ? 'void' : `${componentName}Params`;
+    const queryParamType = emptyParams ? '' : `${componentName}Params &`;
+    const filterParams = emptyParams
+      ? '{ filters }: { filters?: QueryFilters }'
+      : `{ params, filters }: { params: ${componentName}Params, filters?: QueryFilters }`;
+    const cacheParams = emptyParams
+      ? `{updater, options}: {updater: Updater<${responseTypes} | undefined, ${responseTypes} | undefined>, options?: SetDataOptions | undefined}`
+      : `{params, updater, options}: {params: ${componentName}Params, updater: Updater<${responseTypes} | undefined, ${responseTypes} | undefined>, options?: SetDataOptions | undefined}`;
+    const queryKey = emptyParams
+      ? `use${componentName}Query.baseKey()`
+      : `[...use${componentName}Query.baseKey(), params]`;
+
+    const createQuery = () => `
+    type ${componentName}QueryProps<T = ${responseTypes}> = ${queryParamType} {
+      options?: UseQueryOptions<${responseTypes}, AxiosError, T, any> 
+    }
+    export function use${componentName}Query<T = ${responseTypes}>({ options = {}, ...params }: ${componentName}QueryProps<T>) { 
+      return useQuery(use${componentName}Query.queryKey(${key}), async () => ${fetchName}(${key}), { enabled: ${enabledParam}, ...options });
+    }
+
+    use${componentName}Query.baseKey = (): QueryKey => ["${componentName.toLowerCase()}"];
+  
+    use${componentName}Query.queryKey = (${params}): QueryKey => ${queryKey};
+  
+    use${componentName}Query.updateCache = (${cacheParams}) => queryClient.setQueryData<${responseTypes}>(use${componentName}Query.queryKey(${key}), updater, options);
+    
+    use${componentName}Query.getQueryState = (${filterParams})=> queryClient.getQueryState<${responseTypes}>(use${componentName}Query.queryKey(${key}), filters);
+    
+    use${componentName}Query.getQueryData = (${filterParams})=> queryClient.getQueryData<${responseTypes}>(use${componentName}Query.queryKey(${key}), filters);
+    
+    use${componentName}Query.prefetch = (${params}) => queryClient.prefetchQuery<${responseTypes}>(use${componentName}Query.queryKey(${key}), ()=> ${fetchName}(${key}));
+  
+    use${componentName}Query.cancelQueries = (${params}) => queryClient.cancelQueries(use${componentName}Query.queryKey(${key}))
+  
+    use${componentName}Query.invalidate = (${params}) => queryClient.invalidateQueries<${responseTypes}>(use${componentName}Query.queryKey(${key}));
+  
+    use${componentName}Query.refetchStale = (${params}) => queryClient.refetchQueries<${responseTypes}>(use${componentName}Query.queryKey(${key}), { stale: true });
+  `;
+
+    const getInfiniteQuery = ({ pageParam }: { pageParam: string }) => `
+    type ${componentName}QueryProps<T = ${responseTypes}> = ${queryParamType} {
+      options: UseInfiniteQueryOptions<${responseTypes}, AxiosError, T, any> 
+    }
+    export function use${componentName}Query<T = ${responseTypes}>({ options = {}, ...params }: ${componentName}QueryProps<T>) { 
+      return useInfiniteQuery(use${componentName}Query.queryKey(${key}), async ({ pageParam = 0 }) => ${fetchName}({${pageParam}: pageParam, ...params}), { enabled: ${enabledParam}, ...options });
+    }
+
+    use${componentName}Query.baseKey = (): QueryKey => ["${componentName.toLowerCase()}"];
+  
+    use${componentName}Query.queryKey = (${params}): QueryKey => ${queryKey};
+  
+  `;
+
+    const createMutation = () => `
+    type ${componentName}MutationProps<T> = {
+      options?: UseMutationOptions<${responseTypes}, AxiosError, ${mutationParams}, T> 
+    }
+    export function use${componentName}Mutation<T = ${responseTypes}>(props?: ${componentName}MutationProps<T>) { 
+      return useMutation(async (${key}) => ${fetchName}(${key}), props?.options)
+    };
+    `;
+
+    const override = overrides?.[operationId];
+    if (override?.type === 'query') {
+      console.log(chalk.blue(`⚙️  [${operationId}] has been changed to a useQuery hook`));
+      queryImports.push('query');
+      return createQuery();
+    }
+
+    if (override?.type === 'mutation') {
+      queryImports.push('mutation');
+      console.log(chalk.blue(`⚙️  [${operationId}] has been changed to a useMutation hook`));
+      return createMutation();
+    }
+
+    if (override?.type === 'infiniteQuery') {
+      console.log(chalk.blue(`⚙️  [${operationId}] has been changed to a useInfiniteQuery hook`));
+      queryImports.push('infiniteQuery');
+      return getInfiniteQuery({ pageParam: override.infiniteQueryParm });
+    }
+
+    if (verb === 'get') {
+      queryImports.push('query');
+      return createQuery();
+    }
+
+    queryImports.push('mutation');
+    return createMutation();
+  };
+
+  output += createQueryHooks(!requestBodyComponent && !paramsInPath.length && !queryParam && !headerParam);
+
+  if (!requestBodyComponent && !paramsInPath.length && !queryParam && !headerParam) {
+    output += `
+    const ${fetchName} = async () => {
+      const result = await api.${verb}<${responseTypes}>(\`${route}\`);
+      return result.data;
+    }
+    `;
+  }
+
+  if (!requestBodyComponent && paramsInPath.length && queryParam && !headerParam) {
+    const config = isUpdateRequest ? 'body,{params}' : '{params}';
+    output += `
+    type ${componentName}Params = {
+      ${paramsTypes}
+      ${queryParamsType}; 
+    }
+
+     const ${fetchName} = async (props:${componentName}Params) => {
+      const {${paramsInPath.join(', ')}, ...params} = props
+      const result = await api.${verb}<${responseTypes}>(\`${route}\`, ${config})
+      return result.data;
+    }`;
+  }
+
+  if (!requestBodyComponent && paramsInPath.length && !queryParam && !headerParam) {
+    output += `
+    type ${componentName}Params = {
+      ${paramsTypes}
+    }
+
+    const ${fetchName} = async (props: ${componentName}Params ) => {
+      const result = await api.${verb}<${responseTypes}>(\`${route.replace(/\{/g, '{props.')}\`);
+      return result.data;
+    }
+    `;
+  }
+
+  if (!requestBodyComponent && !paramsInPath.length && queryParam && !headerParam) {
+    const config = isUpdateRequest ? 'null,{params}' : '{params}';
+    output += `
+    type ${componentName}Params = { 
+      ${queryParamsType} 
+    }
+
+    const ${fetchName} = async (params: ${componentName}Params) => {
+      const result = await api.${verb}<${responseTypes}>(\`${route}\`, ${config})
+      return result.data;
+    }
+    `;
+  }
+  if (!requestBodyComponent && !paramsInPath.length && queryParam && headerParam) {
+    const config = isUpdateRequest ? 'null,{headers, params: queryParams}' : '{headers, params: queryParams}';
+    output += `
+      type ${componentName}Params = {
+        ${headerParam}
+        ${queryParamsType}
+      }
+      const ${fetchName} = async (props: ${componentName}Params) => {
+        const headers = {${generateProps(header)}}
+        const queryParams = {${generateProps(queryParams)}}
+        const result = await api.${verb}<${responseTypes}>(\`${route}\`, ${config})
+        return result.data
+      }`;
+  }
+  if (!requestBodyComponent && !paramsInPath.length && !queryParam && headerParam) {
+    const config = isUpdateRequest ? 'null,{headers}' : '{headers}';
+    output += `
+      type ${componentName}Params = {
+        ${headerParam}
+      };
+  
+      const ${fetchName} = async (headers: ${componentName}Params) => {
+        const result = await api.${verb}<${responseTypes}>(\`${route}\`, ${config});
+        return result.data;
+      }
+      `;
+  }
+
+  if (requestBodyComponent && !paramsInPath.length && !queryParam && !headerParam) {
+    output += `
+    type ${componentName}Params = ${requestBodyComponent}
+
+    const ${fetchName} = async (body: ${componentName}Params) => {
+      const result = await api.${verb}<${responseTypes}>(\`${route}\`, body)
+      return result.data
+    } 
+      `;
+  }
+
+  if (requestBodyComponent && !paramsInPath.length && queryParam && !headerParam) {
+    const config = isUpdateRequest ? 'null,{headers, params: queryParams}' : '{headers, params: queryParams}';
+    const queryParamsProps = queryParams.map((item) => `["${item.name}"]: props["${item.name}"]`);
+    output += `
+    type ${componentName}Params = ${requestBodyComponent}  & {
+      ${queryParamsType}
+    }
+
+    type ${componentName}QueryProps<T = ${responseTypes}> = ${componentName}Params & {
+      const body =  {${generateBodyProps()}}
+      const params =  {${generateProps(queryParams)}}
+      options?: UseQueryOptions<${responseTypes}, AxiosError, T, any> 
+    }
+
+     const ${fetchName} = async ({body, params}: ${componentName}Params) => {   
+      const queryParams = {${queryParamsProps.join(',')}}
+      const result = await api.${verb}<${responseTypes}>(\`${route}\`, ${config})
+      return result.data
+    }
+    `;
+  }
+
+  if (requestBodyComponent && !paramsInPath.length && !queryParam && headerParam) {
+    output += `
+    type ${componentName}Params =  ${requestBodyComponent} & {
+      ${headerParam}
+    };
+
+    const ${fetchName} = async (props: ${componentName}Params) => {
+      const headers = {${generateProps(header)}}
+      const body =  {${generateBodyProps()}}
+      const result = await api.${verb}<${responseTypes}>(\`${route}\`, body, {headers})
+      return result.data
+    }
+    `;
+  }
+
+  if (requestBodyComponent && !paramsInPath.length && queryParam && headerParam) {
+    output += `
+    type ${componentName}Params = ${requestBodyComponent} & {
+      ${headerParam}
+      ${paramsTypes}
+    };
+
+    const ${fetchName} = async (props: ${componentName}Params) => {
+      const body =  {${generateBodyProps()}}
+      const headers = {${generateProps(header)}}
+      const params =  {${generateProps(queryParams)}}
+      const result = await api.${verb}<${responseTypes}>(\`${route}\`, body, {headers, params})
+      return result.data
+    }
+    `;
+  }
+
+  if (requestBodyComponent && paramsInPath.length && !queryParam && !headerParam) {
+    output += `
+    type ${componentName}Params = ${requestBodyComponent} & {
+      ${headerParam}
+      ${paramsTypes}
+    };
+
+    const ${fetchName} = async (props: ${componentName}Params) => {
+      const body =  {${generateBodyProps()}}
+      const result = await api.${verb}<${responseTypes}>(\`${route.replace(/\{/g, '{props.')}\`, body)
+      return result.data
+    }
+    `;
+  }
+
+  if (requestBodyComponent && paramsInPath.length && queryParam && !headerParam) {
+    output += `// TODO: NOT SUPPORTED requestBodyComponent && paramsInPath && queryParam)`;
+  }
+
+  if (requestBodyComponent && paramsInPath.length && queryParam && headerParam) {
+    output += `// TODO: NOT SUPPORTED requestBodyComponent && paramsInPath && queryParam && headerParam)`;
+  }
+
+  if (!requestBodyComponent && paramsInPath.length && !queryParam && headerParam) {
+    const config = isUpdateRequest ? 'null,{headers}' : '{headers}';
+    output += `
+    type ${componentName}Params = {
+      ${headerParam}
+      ${paramsTypes}
+    };
+
+    const ${fetchName} = async (props: ${componentName}Params) => {
+      const headers = {${generateProps(header)}}
+      const result = await api.${verb}<${responseTypes}>(\`${route.replace(/\{/g, '{props.')}\`, ${config})
+      return result.data
+    }
+    `;
+  }
+
+  if (!requestBodyComponent && paramsInPath.length && queryParam && headerParam) {
+    output += `// TODO: NOT SUPPORTED (paramsInPath && queryParam && headerParam)`;
+  }
+
+  if (requestBodyComponent && paramsInPath.length && !queryParam && headerParam) {
+    output += `// TODO: NOT SUPPORTED (requestBodyComponent && paramsInPath && headerParam)`;
+  }
+
+  return { implementation: output, imports, queryImports };
+};

package/src/generateImports.ts

@@ -0,0 +1,41 @@
+export const generateImports = ({
+  schemaName,
+  apiDirectory,
+  queryClientDir,
+  schemaImports,
+  queryImports,
+}: {
+  apiDirectory: string;
+  queryClientDir: string;
+  schemaName: string;
+  schemaImports: string[];
+  queryImports: ('query' | 'mutation' | 'infiniteQuery')[];
+}) => {
+  const importTypes = schemaImports.join(',');
+  let imports = [] as string[];
+  if (queryImports.includes('query')) {
+    imports = [...imports, 'useQuery', 'UseQueryOptions', 'QueryKey', 'SetDataOptions', 'QueryFilters'];
+  }
+  if (queryImports.includes('infiniteQuery')) {
+    imports = [...imports, 'useInfiniteQuery', 'UseInfiniteQueryOptions', 'QueryKey'];
+  }
+  if (queryImports.includes('mutation')) {
+    imports = [...imports, 'UseMutationOptions', 'useMutation'];
+  }
+
+  const importString = [...new Set(imports)].join(',');
+
+  return `
+  import {
+    ${importString}
+  } from '@tanstack/react-query';
+  
+  import { AxiosError } from 'axios';
+  import { api } from '${apiDirectory}';
+  import { queryClient } from '${queryClientDir}';
+
+  import {${importTypes}} from './${schemaName}'
+
+  type Updater<TInput, TOutput> = TOutput | ((input: TInput) => TOutput);  
+  `;
+};

package/src/generateSchemas.ts

@@ -0,0 +1,114 @@
+import pasCase from 'case';
+import lodash from 'lodash';
+const { isEmpty } = lodash;
+const { pascal } = pasCase;
+import { ComponentsObject, OpenAPIObject, SchemaObject } from 'openapi3-ts';
+import { formatDescription, getScalar, isReference, resolveValue } from './utils.js';
+
+import { getDocs, getResReqTypes } from './utils.js';
+
+/**
+ * Generate the interface string
+ */
+const generateInterface = (name: string, schema: SchemaObject) => {
+  const scalar = getScalar(schema);
+  return `${formatDescription(schema.description)}
+       export type ${pascal(name)} = ${scalar}
+     `;
+};
+
+/**
+ * Extract all types from #/components/schemas
+ */
+const generateSchemasDefinition = (schemas: ComponentsObject['schemas'] = {}) => {
+  if (isEmpty(schemas)) {
+    return '';
+  }
+
+  return (
+    '\n // SCEHMAS \n' +
+    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
+ */
+const generateRequestBodiesDefinition = (requestBodies: ComponentsObject['requestBodies'] = {}) => {
+  if (isEmpty(requestBodies)) {
+    return '';
+  }
+
+  return (
+    '\n // REQUEST BODIES \n' +
+    Object.entries(requestBodies)
+      .map(([name, requestBody]) => {
+        const doc = getDocs(requestBody);
+        const type = getResReqTypes([['', requestBody]]);
+        const isEmptyInterface = type === '{}';
+        if (isEmptyInterface) {
+          return `${doc}\nexport type ${pascal(name)}RequestBody = ${type}`;
+        } else if (type.includes('{') && !type.includes('|') && !type.includes('&')) {
+          return `${doc}\nexport type ${pascal(name)}RequestBody = ${type}`;
+        } else {
+          return `${doc}\nexport type ${pascal(name)}RequestBody = ${type};`;
+        }
+      })
+      .join('\n\n') +
+    '\n'
+  );
+};
+
+/**
+ * Extract all types from #/components/responses
+ */
+const generateResponsesDefinition = (responses: ComponentsObject['responses'] = {}) => {
+  if (isEmpty(responses)) {
+    return '';
+  }
+
+  return (
+    '\n // RESPONSES \n' +
+    Object.entries(responses)
+      .map(([name, response]) => {
+        const doc = getDocs(response);
+        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'
+  );
+};
+
+/**
+ * Extract all types from #/components/schemas
+ */
+export const generateSchemas = ({ spec }: { spec: OpenAPIObject }) => {
+  const schemaOutput =
+    generateRequestBodiesDefinition(spec.components?.requestBodies) +
+    generateResponsesDefinition(spec.components?.responses) +
+    generateSchemasDefinition(spec.components?.schemas);
+
+  return schemaOutput;
+};

package/src/importSpecs.ts

@@ -0,0 +1,110 @@
+import chalk from 'chalk';
+import { readFileSync, writeFileSync, readdir, mkdirSync } from 'fs';
+import { OperationObject, PathItemObject } from 'openapi3-ts';
+import { join, parse } from 'path';
+import { convertSwaggerFile } from './convertSwaggerFile.js';
+import { createHook } from './generateHooks.js';
+import { generateImports } from './generateImports.js';
+import { generateSchemas } from './generateSchemas.js';
+
+export function importSpecs({
+  sourceDirectory,
+  exportDirectory,
+  apiDirectory,
+  queryClientDir,
+  headerFilters,
+  overrides,
+}: {
+  sourceDirectory: string;
+  exportDirectory: string;
+  apiDirectory: string;
+  queryClientDir: string;
+  headerFilters?: string[];
+  overrides?: Record<
+    string,
+    { type: 'query' } | { type: 'mutation' } | { type: 'infiniteQuery'; infiniteQueryParm: string }
+  >;
+}) {
+  readdir(sourceDirectory, function (err, filenames) {
+    if (err) {
+      console.log(err);
+      throw err;
+    }
+    filenames.map(async (filename) => {
+      try {
+        const data = readFileSync(join(process.cwd(), sourceDirectory + '/' + filename), 'utf-8');
+        const { ext } = parse(sourceDirectory + '/' + filename);
+        const format = ['.yaml', '.yml'].includes(ext.toLowerCase()) ? 'yaml' : 'json';
+        let spec = await convertSwaggerFile(data, format);
+
+        const schemaName = `useQueries${filename.split('.')[0]}.schema`;
+        const hooksName = `useQueries${filename.split('.')[0]}`;
+        const name = filename.split('.')[0];
+        mkdirSync(join(process.cwd(), `${exportDirectory}/${name}`), { recursive: true });
+
+        const operationIds: string[] = [];
+
+        let hooks = '';
+        let schemaImportsArray = [] as string[];
+        let collectedQueryImports = [] as ('query' | 'mutation' | 'infiniteQuery')[];
+        Object.entries(spec.paths).forEach(([route, verbs]: [string, PathItemObject]) => {
+          Object.entries(verbs).forEach(([verb, operation]: [string, OperationObject]) => {
+            if (['get', 'post', 'patch', 'put', 'delete'].includes(verb) && !operation.deprecated) {
+              const { implementation, imports, queryImports } = createHook({
+                operation,
+                verb,
+                route: (spec.basePath || '') + route,
+                operationIds,
+                parameters: verbs.parameters,
+                schemasComponents: spec.components,
+                headerFilters,
+                overrides,
+              });
+
+              hooks += implementation;
+              imports.forEach((element) => {
+                const formattedImport = element.replace('[]', '');
+                if (
+                  !schemaImportsArray.includes(formattedImport) &&
+                  element !== 'void' &&
+                  element !== 'string' &&
+                  !element.includes('{')
+                ) {
+                  schemaImportsArray.push(formattedImport);
+                }
+              });
+              queryImports.forEach((element) => {
+                if (!schemaImportsArray.includes(element)) {
+                  collectedQueryImports.push(element);
+                }
+              });
+            }
+          });
+        });
+
+        const imports = generateImports({
+          apiDirectory,
+          queryClientDir,
+          schemaName,
+          schemaImports: schemaImportsArray,
+          queryImports: collectedQueryImports,
+        });
+
+        writeFileSync(join(process.cwd(), `${exportDirectory}/${name}/${hooksName}.tsx`), imports + hooks);
+
+        const schemas = generateSchemas({ spec });
+        writeFileSync(join(process.cwd(), `${exportDirectory}/${name}/${schemaName}.tsx`), schemas);
+
+        console.log(
+          chalk.green(`🎉 [${filename}] Your OpenAPI spec has been converted into react query hooks`)
+        );
+      } catch (error) {
+        if ((error as any).code === 'EISDIR') {
+          console.log(chalk.red('nested folder structure not supported'));
+          return;
+        }
+        console.log(chalk.red(`[${filename}]:`), chalk.red(error));
+      }
+    });
+  });
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+import { convertSwaggerFile } from './convertSwaggerFile.js';
+import { importSpecs } from './importSpecs.js';
+export { importSpecs, convertSwaggerFile };

package/src/utils.ts

@@ -0,0 +1,190 @@
+import lodash from 'lodash';
+const { uniq, isEmpty } = lodash;
+import pasCase from 'case';
+
+const { pascal } = pasCase;
+
+import { ReferenceObject, RequestBodyObject, ResponseObject, SchemaObject } from 'openapi3-ts';
+
+export const getDocs = (data: ReferenceObject | { description?: string }) =>
+  isReference(data) ? '' : formatDescription(data.description);
+/**
+ * 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
+ */
+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
+ */
+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
+ */
+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}';
+  }
+
+  const IdentifierRegexp = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
+  // 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 = getDocs(prop);
+        const isRequired = (item.required || []).includes(key);
+        const processedKey = IdentifierRegexp.test(key) ? key : `"${key}"`;
+        return `${doc}\n${processedKey}${isRequired ? '' : '?'}: ${resolveValue(prop)};`;
+      })
+      .join('');
+  }
+
+  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);
+
+/**
+ * Format a description to code documentation.
+ */
+export const formatDescription = (description?: string) => {
+  if (!description) {
+    return '';
+  }
+  return `\n/**\n${description
+    .split('\n')
+    .map((i) => `*  ${i}`)
+    .join('\n')}\n */`;
+};
+
+/**
+ * Extract responses / request types from open-api specs
+ */
+export const getResReqTypes = (
+  responsesOrRequests: Array<[string, ResponseObject | ReferenceObject | RequestBodyObject]>
+) => {
+  return uniq(
+    responsesOrRequests.map(([_, res]) => {
+      if (!res) {
+        return;
+      }
+
+      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;
+      }
+
+      return;
+    })
+  ).join(' | ');
+};