react-query-lightbase-codegen 1.1.1 → 1.1.4

package/lib/esm/generateHooks.js

@@ -1,360 +0,0 @@
-import lodash from 'lodash';
-const { get, groupBy, uniq } = lodash;
-import { formatDescription, getResReqTypes, isReference, resolveValue } from './utils.js';
-import pasCase from 'case';
-const { pascal } = pasCase;
-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;
-};
-const createQueryHooks = ({ componentName, responseTypes, enabledParam, emptyParams, }) => {
-    const params = emptyParams ? '' : `params: ${componentName}Params,`;
-    const key = emptyParams ? '' : `params`;
-    const mutationParams = emptyParams ? 'void' : `${componentName}Params`;
-    const queryParams = emptyParams ? '' : `${componentName}Params &`;
-    const filterParams = emptyParams
-        ? '{ filters }: { filters?: QueryFilters }'
-        : `{ params, filters }: { params: ${componentName}Params, filters }`;
-    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 query = `
-  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}), ()=> use${componentName}Query.fetch(${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 });
-
-  type ${componentName}QueryProps<T = ${responseTypes}> = ${queryParams} {
-    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 () => use${componentName}Query.fetch(${key}), { enabled: ${enabledParam}, ...options });
-  }`;
-    const mutation = `
-  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}) => use${componentName}Query.fetch(${key}), props?.options)
-  };`;
-    return query + mutation;
-};
-/**
- * Generate a react-query component from openapi operation specs
- */
-const createHook = ({ 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]]);
-    let imports = [responseTypes];
-    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 = '!!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;
-        }) // Reference is not possible
-        : { schema: { type: 'string' } };
-    if (!lastParamInTheRouteDefinition) {
-        throw new Error(`The path params ${lastParamInTheRoute} can't be found in parameters (${operationId})`);
-    }
-    const description = formatDescription(operation.summary && operation.description
-        ? `${operation.summary}\n\n${operation.description}`
-        : `${operation.summary || ''}${operation.description || ''}`);
-    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);
-    }
-    // QUERIES
-    if (!requestBodyComponent && !paramsInPath.length && !queryParam && !headerParam) {
-        output += `
-    // SECTION-A
-    use${componentName}Query.fetch = async () => {
-      const result = await api.${verb}<${responseTypes}>(\`${route}\`);
-      return result.data;
-    }
-    `;
-        output += createQueryHooks({ componentName, responseTypes, enabledParam, emptyParams: true });
-    }
-    if (!requestBodyComponent && paramsInPath.length && queryParam && !headerParam) {
-        output += `
-    // SECTION-B
-    type ${componentName}Params = {
-      ${paramsTypes}
-      ${queryParamsType}; 
-    }
-
-    use${componentName}Query.fetch = async (props:${componentName}Params) => {
-      const {${paramsInPath.join(', ')}, ...params} = props
-      const result = await api.${verb}<${responseTypes}>(\`${route}\`, {params})
-      return result.data;
-    }`;
-        output += createQueryHooks({ componentName, responseTypes, enabledParam });
-    }
-    if (!requestBodyComponent && paramsInPath.length && !queryParam && !headerParam) {
-        output += `
-    // SECTION-C
-    type ${componentName}Params = {
-      ${paramsTypes}
-    }
-
-    use${componentName}Query.fetch = async (props: ${componentName}Params ) => {
-      const result = await api.${verb}<${responseTypes}>(\`${route.replace(/\{/g, '{props.')}\`);
-      return result.data;
-    }
-    `;
-        output += createQueryHooks({ componentName, responseTypes, enabledParam });
-    }
-    if (!requestBodyComponent && !paramsInPath.length && queryParam && !headerParam) {
-        output += `
-    // SECTION-D
-    type ${componentName}Params = { 
-      ${queryParamsType} 
-    }
-
-    use${componentName}Query.fetch = async (props: ${componentName}Params) => {
-      const result = await api.${verb}<${responseTypes}>(\`${route}\`, {params: props})
-      return result.data;
-    }
-    `;
-        output += createQueryHooks({ componentName, responseTypes, enabledParam });
-    }
-    if (requestBodyComponent && !paramsInPath.length && !queryParam && !headerParam) {
-        output += `
-    // SECTION-E
-    type ${componentName}Params = ${requestBodyComponent}
-
-    use${componentName}Query.fetch = async (body: ${componentName}Params) => {
-      const result = await api.${verb}<${responseTypes}>(\`${route}\`, body)
-        return result.data
-      }
-      
-      `;
-        output += createQueryHooks({ componentName, responseTypes, enabledParam });
-    }
-    if (requestBodyComponent && !paramsInPath.length && queryParam && !headerParam) {
-        output += `
-    // SECTION-G
-    // TODO: LOOKS BROKEN
-    type ${componentName}Params = {
-      body: ${requestBodyComponent} 
-      queryParams: ${queryParamsType} 
-    }
-
-    type ${componentName}QueryProps<T = ${responseTypes}> = ${componentName}Params & {
-      options?: UseQueryOptions<${responseTypes}, AxiosError, T, any> 
-    }
-
-    use${componentName}Query.fetch = async ({body, queryParams}: ${componentName}Params) => {   
-      const result = await api.${verb}<${responseTypes}>(\`${route}\`, body, {params: queryParams})
-      return result.data
-    }
-    `;
-        output += createQueryHooks({ componentName, responseTypes, enabledParam });
-    }
-    if (!requestBodyComponent && !paramsInPath.length && !queryParam && headerParam) {
-        output += `
-    // SECTION-H
-    type ${componentName}Params = {
-      ${headerParam}
-    };
-
-    use${componentName}Query.fetch = async (headers: ${componentName}Params) => {
-      const result = await api.${verb}<${responseTypes}>(\`${route}\`, {headers});
-      return result.data;
-    }
-    `;
-        output += createQueryHooks({ componentName, responseTypes, enabledParam });
-    }
-    if (requestBodyComponent && !paramsInPath.length && !queryParam && headerParam) {
-        output += `
-    // SECTION-J
-    type ${componentName}Params = {
-      body: ${requestBodyComponent}
-      headers: {${headerParam}}
-    };
-
-    use${componentName}Query.fetch = async ({headers, body}: ${componentName}Params) => {
-      const result = await api.${verb}<${responseTypes}>(\`${route}\`, body, {headers})
-        return result.data
-      }`;
-        output += createQueryHooks({ componentName, responseTypes, enabledParam });
-    }
-    if (!requestBodyComponent && !paramsInPath.length && queryParam && headerParam) {
-        output += `
-    // SECTION-K
-    type ${componentName}Params = {
-      headers: {${headerParam}}
-      queryParams: {${queryParamsType} }
-    }
-    use${componentName}Query.fetch = async ({headers, queryParams}: ${componentName}Params) => {
-      const result = await api.${verb}<${responseTypes}>(\`${route}\`, body, {headers, params: queryParams})
-        return result.data
-      }`;
-        output += createQueryHooks({ componentName, responseTypes, enabledParam });
-    }
-    if (requestBodyComponent && paramsInPath.length && !queryParam && !headerParam) {
-        output += `// TODO: NOT SUPPORTED requestBodyComponent && paramsInPath)`;
-    }
-    if (requestBodyComponent && paramsInPath.length && queryParam && !headerParam) {
-        output += `// TODO: NOT SUPPORTED requestBodyComponent && paramsInPath && queryParam)`;
-    }
-    if (requestBodyComponent && !paramsInPath.length && queryParam && headerParam) {
-        output += `// TODO: NOT SUPPORTED requestBodyComponent && queryParam && headerParam)`;
-    }
-    if (requestBodyComponent && paramsInPath.length && queryParam && headerParam) {
-        output += `// TODO: NOT SUPPORTED requestBodyComponent && paramsInPath && queryParam && headerParam)`;
-    }
-    if (!requestBodyComponent && paramsInPath.length && !queryParam && headerParam) {
-        output += `// TODO: NOT SUPPORTED (paramsInPath && headerParam)`;
-    }
-    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 };
-};
-export const generateImports = ({ schemaName, apiDirectory, queryClientDir, schemaImports, }) => {
-    const importTypes = schemaImports.join(',');
-    return `
-  import {
-    useQuery,
-    useMutation,
-    UseQueryOptions,
-    UseMutationOptions,
-    QueryKey,
-    SetDataOptions,
-    QueryFilters
-  } 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);  
-  `;
-};
-export const generateQueryHooks = ({ spec, operationIds, headerFilters, }) => {
-    const { paths, components } = spec;
-    let hooks = '';
-    let schemaImports = [];
-    Object.entries(paths).forEach(([route, verbs]) => {
-        Object.entries(verbs).forEach(([verb, operation]) => {
-            if (['get', 'post', 'patch', 'put', 'delete'].includes(verb) && !operation.deprecated) {
-                const { implementation, imports } = createHook({
-                    operation,
-                    verb,
-                    route: spec.basePath + route,
-                    operationIds,
-                    parameters: verbs.parameters,
-                    schemasComponents: components,
-                    headerFilters,
-                });
-                hooks += implementation;
-                imports.forEach((element) => {
-                    schemaImports.push(element.replace('[]', ''));
-                });
-            }
-        });
-    });
-    const schemaImportsFiltered = schemaImports.filter((item) => !!item && item !== 'void' && item !== 'boolean' && item !== 'undefined' && item !== 'string');
-    return { implementation: hooks, schemaImports: uniq(schemaImportsFiltered) };
-};

package/lib/esm/generateImports.js

@@ -1,22 +0,0 @@
-export const generateImports = ({ schemaName, apiDirectory, queryClientDir, schemaImports, }) => {
-    const importTypes = schemaImports.join(',');
-    return `
-  import {
-    useQuery,
-    useMutation,
-    UseQueryOptions,
-    UseMutationOptions,
-    QueryKey,
-    SetDataOptions,
-    QueryFilters
-  } 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/lib/esm/importSpecs.js

@@ -1,39 +0,0 @@
-import chalk from 'chalk';
-import { readFileSync, writeFileSync, readdir, mkdirSync } from 'fs';
-import { join, parse } from 'path';
-import { convertSwaggerFile } from './convertSwaggerFile.js';
-import { generateImports, generateQueryHooks } from './generateHooks.js';
-import { generateSchemas } from './generateSchemas.js';
-export function importSpecs({ sourceDirectory, exportDirectory, apiDirectory, queryClientDir, headerFilters, }) {
-    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';
-                const name = filename.split('.')[0];
-                let spec = await convertSwaggerFile(data, format);
-                const operationIds = [];
-                mkdirSync(join(process.cwd(), `${exportDirectory}/${name}`), { recursive: true });
-                const { implementation, schemaImports } = generateQueryHooks({ spec, operationIds, headerFilters });
-                const schemaName = `useQueries${filename.split('.')[0]}.schema`;
-                const imports = generateImports({ apiDirectory, queryClientDir, schemaName, schemaImports });
-                const hooksName = `useQueries${filename.split('.')[0]}`;
-                writeFileSync(join(process.cwd(), `${exportDirectory}/${name}/${hooksName}.tsx`), imports + implementation);
-                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.code === 'EISDIR') {
-                    return;
-                }
-                console.log(chalk.red(`[${filename}]:`), chalk.red(error));
-            }
-        });
-    });
-}