react-query-lightbase-codegen 0.5.0 → 1.0.2

package/README.md

@@ -1 +1,77 @@
+# React Query Code Generation
 
+Generate fully typed react query hooks from OpenAPI specifications.
+
+- GET requests will automatically generate `useQuery` hooks together with helper functions
+  - getQueryState
+  - getQueryData
+  - prefetch
+  - cancelQueries
+  - invalidate
+  - refetchStale
+
+- Override default generation forcing query, mutation or infiniteQuery output
+
+## Installation
+
+You can install react-query-lightbase-codegen with NPM or Yarn.
+
+Using NPM:
+
+```bash
+$ npm i -D react-query-lightbase-codegen 
+```
+
+Using Yarn:
+
+```
+$ yarn add -D react-query-lightbase-codegen
+```
+
+## Configuration
+
+create a generateQueries.mjs file in project root folder
+
+```javascript
+// generateQueries.mjs
+import { importSpecs } from 'react-query-lightbase-codegen';
+
+importSpecs({
+  // folder location of the openapi/swagger documents (yaml or JSON)
+  sourceDirectory: './specs',
+  // export folder for hooks and schema code generated files
+  exportDirectory: './src/generated',
+  // api client - as named export labelled 'api'
+  apiDirectory: './src/api',
+  // React query client directory - names export 'queryClient'
+  queryClientDir: './src/api',
+});
+```
+
+## Code generation
+
+To generate the code generated scheme and react query hooks run the above script
+
+```bash
+node scripts/generateQueries.mjs && prettier --check ./src/generated/*.tsx --write
+```
+
+## Configuration Options
+
+```javascript
+// generateQueries.mjs
+import { importSpecs } from 'react-query-lightbase-codegen';
+
+importSpecs({
+  ...
+  // Filter out any headers from individual queries (these might be applied globally in the axios instance)
+  headerFilters: ['X-Session-Token'],
+  overrides: {
+    // operationId listed in the openApi spec
+    findPetsByStatus: {
+      // Override the default query code generation type ('query' | 'mutation' | 'infiniteQuery')
+      type: 'query',
+    },
+  },
+});
+```

package/package.json

@@ -1,19 +1,43 @@
 {
   "name": "react-query-lightbase-codegen",
-  "version": "0.5.0",
+  "description": "Fully typed react query code generation tool based on openApi specifications",
+  "version": "1.0.2",
   "license": "MIT",
   "type": "module",
-  "exports": "./src/index.js",
+  "exports": "./dist/index.js",
   "files": [
     "lib/"
   ],
+  "keywords": [
+    "rest",
+    "client",
+    "swagger",
+    "open-api",
+    "fetch",
+    "data fetching",
+    "code-generation",
+    "react",
+    "react-query",
+    "axios",
+    "vue-query",
+    "tanstack"
+  ],
+  "author": {
+    "name": "Oliver Winter",
+    "email": "owinter86@gmail.com"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/owinter86/react-query-codegen"
+  },
   "engines": {
     "node": ">=14.16"
   },
   "scripts": {
     "lint": "eslint . --ext .js,.jsx,.ts,.tsx",
-    "tsc": "tsc -p tsconfig.json && tsc -p tsconfig-cjs.json",
-    "test": "yarn tsc && node test/script.mjs && prettier --check ./test/generated/**/*.tsx --write && eslint ./test/generated/**/*.tsx --fix"
+    "tsc": "tsc -p tsconfig.json",
+    "test": "yarn tsc && node test/script.mjs && prettier --check ./test/generated/**/*.tsx --write && eslint ./test/generated/**/*.tsx --fix",
+    "prepare": "husky install"
   },
   "dependencies": {
     "axios": "0.27.2",
@@ -28,7 +52,13 @@
   "devDependencies": {
     "@babel/core": "7.18.10",
     "@babel/eslint-parser": "7.17.0",
+    "@commitlint/cli": "^17.0.3",
+    "@commitlint/config-conventional": "^17.0.3",
     "@react-native-community/eslint-config": "3.1.0",
+    "@semantic-release/changelog": "^6.0.1",
+    "@semantic-release/git": "^10.0.1",
+    "@semantic-release/github": "^8.0.5",
+    "@semantic-release/npm": "^9.0.1",
     "@tanstack/react-query": "4.0.10",
     "@types/js-yaml": "4.0.5",
     "@types/lodash": "4.14.182",
@@ -38,8 +68,10 @@
     "@types/yamljs": "0.2.31",
     "eslint": "8.21.0",
     "eslint-plugin-prettier": "4.2.1",
+    "husky": "^8.0.1",
     "prettier": "2.7.1",
     "react": "17.0.2",
+    "semantic-release": "^19.0.3",
     "typescript": "4.7.4"
   }
 }

package/lib/cjs/convertSwaggerFile.js

@@ -1,32 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertSwaggerFile = void 0;
-const swagger2openapi_1 = __importDefault(require("swagger2openapi"));
-const js_yaml_1 = __importDefault(require("js-yaml"));
-/**
- * Import and parse the openapi spec from a yaml/json
- */
-const convertSwaggerFile = (data, extension) => {
-    const schema = extension === 'yaml' ? js_yaml_1.default.load(data) : JSON.parse(data);
-    return new Promise((resolve, reject) => {
-        if (!schema.openapi || !schema.openapi.startsWith('3.')) {
-            swagger2openapi_1.default.convertObj(schema, {}, (err, convertedObj) => {
-                if (err) {
-                    reject(err);
-                }
-                else {
-                    // @ts-ignore
-                    convertedObj.openapi.basePath = convertedObj.original.basePath;
-                    resolve(convertedObj.openapi);
-                }
-            });
-        }
-        else {
-            resolve(schema);
-        }
-    });
-};
-exports.convertSwaggerFile = convertSwaggerFile;

package/lib/cjs/generateHooks.js

@@ -1,401 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createHook = void 0;
-const lodash_1 = __importDefault(require("lodash"));
-const { get, groupBy } = lodash_1.default;
-const utils_js_1 = require("./utils.js");
-const case_1 = __importDefault(require("case"));
-const chalk_1 = __importDefault(require("chalk"));
-const { pascal, camel } = case_1.default;
-const IdentifierRegexp = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
-/**
- * Return every params in a path
- */
-const getParamsInPath = (path) => {
-    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
- */
-const createHook = ({ operation, verb, route, operationIds, parameters, schemasComponents, headerFilters, overrides, }) => {
-    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 = null;
-    const componentName = pascal(operationId);
-    const isOk = ([statusCode]) => statusCode.toString().startsWith('2');
-    const responseTypes = (0, utils_js_1.getResReqTypes)(Object.entries(operation.responses).filter(isOk)) || 'void';
-    const requestBodyTypes = (0, utils_js_1.getResReqTypes)([['body', operation.requestBody]]);
-    let imports = [responseTypes];
-    let queryImports = [];
-    const paramsInPath = getParamsInPath(route).filter((param) => !(verb === 'delete' && param === lastParamInTheRoute));
-    const { query: queryParams = [], path: pathParams = [], header = [], } = groupBy([...(parameters || []), ...(operation.parameters || [])].map((p) => {
-        if ((0, utils_js_1.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 = '!!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 ? '' : '?'}: ${(0, utils_js_1.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 `${(0, utils_js_1.formatDescription)(p.description)}
-      ${processedName}${p.required ? '' : '?'}: ${(0, utils_js_1.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 ? '' : '?'}: ${(0, utils_js_1.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 ((0, utils_js_1.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})`);
-    }
-    const defaultDescription = `type: ${verb}\noperationId: ${operationId}\nurl: ${route}`;
-    const description = (0, utils_js_1.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) => {
-        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];
-            return Object.keys(scheme.properties)
-                .map((item) => `["${item}"]: props["${item}"]`)
-                .join(',');
-        }
-    };
-    const fetchName = camel(componentName);
-    const createQueryHooks = (emptyParams) => {
-        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 }) => `
-    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_1.default.blue(`⚙️  [${operationId}] has been changed to a useQuery hook`));
-            queryImports.push('query');
-            return createQuery();
-        }
-        if (override?.type === 'mutation') {
-            queryImports.push('mutation');
-            console.log(chalk_1.default.blue(`⚙️  [${operationId}] has been changed to a useMutation hook`));
-            return createMutation();
-        }
-        if (override?.type === 'infiniteQuery') {
-            console.log(chalk_1.default.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 };
-};
-exports.createHook = createHook;

package/lib/cjs/generateImports.js

@@ -1,31 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateImports = void 0;
-const generateImports = ({ schemaName, apiDirectory, queryClientDir, schemaImports, queryImports, }) => {
-    const importTypes = schemaImports.join(',');
-    let imports = [];
-    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);  
-  `;
-};
-exports.generateImports = generateImports;

package/lib/cjs/generateRequestBodiesDefinition.js

@@ -1,36 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateRequestBodiesDefinition = void 0;
-const case_1 = require("case");
-const isEmpty_1 = __importDefault(require("lodash/isEmpty"));
-const getResReqTypes_1 = require("./getResReqTypes");
-/**
- * Extract all types from #/components/requestBodies
- */
-const generateRequestBodiesDefinition = (requestBodies = {}) => {
-    if ((0, isEmpty_1.default)(requestBodies)) {
-        return '';
-    }
-    return ('\n // REQUEST BODIES \n' +
-        Object.entries(requestBodies)
-            .map(([name, requestBody]) => {
-            const doc = (0, getResReqTypes_1.getDocs)(requestBody);
-            const type = (0, getResReqTypes_1.getResReqTypes)([['', requestBody]]);
-            const isEmptyInterface = type === '{}';
-            if (isEmptyInterface) {
-                return `export type ${(0, case_1.pascal)(name)}RequestBody = ${type}`;
-            }
-            else if (type.includes('{') && !type.includes('|') && !type.includes('&')) {
-                return `${doc}export type ${(0, case_1.pascal)(name)}RequestBody = ${type}`;
-            }
-            else {
-                return `${doc}export type ${(0, case_1.pascal)(name)}RequestBody = ${type};`;
-            }
-        })
-            .join('\n\n') +
-        '\n');
-};
-exports.generateRequestBodiesDefinition = generateRequestBodiesDefinition;