react-query-lightbase-codegen 1.1.0 → 1.1.1

package/lib/cjs/utils.js

@@ -0,0 +1,165 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getResReqTypes = exports.formatDescription = exports.resolveValue = exports.getScalar = exports.isReference = exports.getDocs = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const { uniq, isEmpty } = lodash_1.default;
+const case_1 = __importDefault(require("case"));
+const { pascal } = case_1.default;
+const getDocs = (data) => (0, exports.isReference)(data) ? '' : (0, exports.formatDescription)(data.description);
+exports.getDocs = getDocs;
+/**
+ * Discriminator helper for `ReferenceObject`
+ */
+const isReference = (property) => {
+    return Boolean(property.$ref);
+};
+exports.isReference = isReference;
+/**
+ * Return the typescript equivalent of open-api data type
+ */
+const getScalar = (item) => {
+    const nullable = item.nullable ? ' | null' : '';
+    switch (item.type) {
+        case 'number':
+        case 'integer':
+            return 'number' + nullable;
+        case 'boolean':
+            return 'boolean' + nullable;
+        case 'array':
+            return getArray(item) + nullable;
+        case 'string':
+            return (item.enum ? `"${item.enum.join(`" | "`)}"` : 'string') + nullable;
+        case 'object':
+        default:
+            return getObject(item) + nullable;
+    }
+};
+exports.getScalar = getScalar;
+/**
+ * Return the output type from the $ref
+ */
+const getRef = ($ref) => {
+    if ($ref.startsWith('#/components/schemas')) {
+        return pascal($ref.replace('#/components/schemas/', ''));
+    }
+    else if ($ref.startsWith('#/components/responses')) {
+        return pascal($ref.replace('#/components/responses/', '')) + 'Response';
+    }
+    else if ($ref.startsWith('#/components/parameters')) {
+        return pascal($ref.replace('#/components/parameters/', '')) + 'Parameter';
+    }
+    else if ($ref.startsWith('#/components/requestBodies')) {
+        return pascal($ref.replace('#/components/requestBodies/', '')) + 'RequestBody';
+    }
+    else {
+        throw new Error('This library only resolve $ref that are include into `#/components/*` for now');
+    }
+};
+/**
+ * Return the output type from an array
+ */
+const getArray = (item) => {
+    if (item.items) {
+        if (!(0, exports.isReference)(item.items) && (item.items.oneOf || item.items.allOf || item.items.enum)) {
+            return `(${(0, exports.resolveValue)(item.items)})[]`;
+        }
+        else {
+            return `${(0, exports.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) => {
+    if ((0, exports.isReference)(item)) {
+        return getRef(item.$ref);
+    }
+    if (item.allOf) {
+        return item.allOf.map(exports.resolveValue).join(' & ');
+    }
+    if (item.oneOf) {
+        return item.oneOf.map(exports.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]) => {
+            const doc = (0, exports.getDocs)(prop);
+            const isRequired = (item.required || []).includes(key);
+            const processedKey = IdentifierRegexp.test(key) ? key : `"${key}"`;
+            return `${doc}\n${processedKey}${isRequired ? '' : '?'}: ${(0, exports.resolveValue)(prop)};`;
+        })
+            .join('');
+    }
+    if (item.additionalProperties) {
+        if (item.properties) {
+            output += '\n';
+        }
+        output += `} & { [key: string]: ${item.additionalProperties === true ? 'any' : (0, exports.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.
+ */
+const resolveValue = (schema) => (0, exports.isReference)(schema) ? getRef(schema.$ref) : (0, exports.getScalar)(schema);
+exports.resolveValue = resolveValue;
+/**
+ * Format a description to code documentation.
+ */
+const formatDescription = (description) => {
+    if (!description)
+        return '';
+    return `/**\n${description
+        .split('\n')
+        .map((i) => `*  ${i}`)
+        .join('\n')}\n */`;
+};
+exports.formatDescription = formatDescription;
+/**
+ * Extract responses / request types from open-api specs
+ */
+const getResReqTypes = (responsesOrRequests) => uniq(responsesOrRequests.map(([_, res]) => {
+    if (!res) {
+        return;
+    }
+    if ((0, exports.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 (0, exports.resolveValue)(schema);
+            }
+        }
+        return;
+    }
+    return;
+})).join(' | ');
+exports.getResReqTypes = getResReqTypes;

package/lib/esm/convertSwaggerFile.js

@@ -0,0 +1,25 @@
+import swagger2openapi from 'swagger2openapi';
+import yaml from 'js-yaml';
+/**
+ * Import and parse the openapi spec from a yaml/json
+ */
+export const convertSwaggerFile = (data, extension) => {
+    const schema = extension === 'yaml' ? yaml.load(data) : JSON.parse(data);
+    return new Promise((resolve, reject) => {
+        if (!schema.openapi || !schema.openapi.startsWith('3.')) {
+            swagger2openapi.convertObj(schema, {}, (err, convertedObj) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    // @ts-ignore
+                    convertedObj.openapi.basePath = convertedObj.original.basePath;
+                    resolve(convertedObj.openapi);
+                }
+            });
+        }
+        else {
+            resolve(schema);
+        }
+    });
+};

package/lib/esm/generateHooks.js

@@ -0,0 +1,360 @@
+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

@@ -0,0 +1,22 @@
+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/generateSchemas.js

@@ -0,0 +1,97 @@
+import pasCase from 'case';
+import lodash from 'lodash';
+const { isEmpty } = lodash;
+const { pascal } = pasCase;
+import { formatDescription, getScalar, isReference, resolveValue } from './utils.js';
+import { getDocs, getResReqTypes } from './utils.js';
+/**
+ * Generate the interface string
+ */
+const generateInterface = (name, schema) => {
+    const scalar = getScalar(schema);
+    return `
+       ${formatDescription(schema.description)}
+       export type ${pascal(name)} = ${scalar}
+     `;
+};
+/**
+ * Extract all types from #/components/schemas
+ */
+const generateSchemasDefinition = (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 = {}) => {
+    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}export type ${pascal(name)}RequestBody = ${type}`;
+            }
+            else if (type.includes('{') && !type.includes('|') && !type.includes('&')) {
+                return `${doc}export type ${pascal(name)}RequestBody = ${type}`;
+            }
+            else {
+                return `${doc}export type ${pascal(name)}RequestBody = ${type};`;
+            }
+        })
+            .join('\n\n') +
+        '\n');
+};
+/**
+ * Extract all types from #/components/responses
+ */
+const generateResponsesDefinition = (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 }) => {
+    const schemaOutput = generateSchemasDefinition(spec.components?.schemas) +
+        generateResponsesDefinition(spec.components?.responses) +
+        generateRequestBodiesDefinition(spec.components?.requestBodies);
+    return schemaOutput;
+};