swagger-typescript-api 9.2.0 → 10.0.0

package/src/index.js

@@ -21,6 +21,7 @@ const { generateOutputFiles } = require("./output");
 const formatFileContent = require("./formatFileContent");
 const { logger } = require("./logger");
 const { ComponentTypeNameResolver } = require("./utils/resolveName");
+const { getPrettierOptions } = require("./prettierOptions");
 
 module.exports = {
   constants: constants,
@@ -39,14 +40,19 @@ module.exports = {
     generateClient = config.generateClient,
     httpClientType = config.httpClientType,
     generateUnionEnums = config.generateUnionEnums,
+    addReadonly = config.addReadonly,
     moduleNameIndex = config.moduleNameIndex,
     moduleNameFirstTag = config.moduleNameFirstTag,
     extractRequestParams = config.extractRequestParams,
     extractRequestBody = config.extractRequestBody,
+    extractResponseBody = config.extractResponseBody,
+    extractResponseError = config.extractResponseError,
     defaultResponseType = config.defaultResponseType,
     unwrapResponseData = config.unwrapResponseData,
+    disableThrowOnError = config.disableThrowOnError,
+    sortTypes = config.sortTypes,
     singleHttpClient = config.singleHttpClient,
-    prettier: prettierOptions = constants.PRETTIER_OPTIONS,
+    prettier: prettierOptions = getPrettierOptions(),
     hooks: rawHooks,
     extraTemplates,
     enumNamesAsValues,
@@ -56,6 +62,9 @@ module.exports = {
     silent = config.silent,
     typePrefix = config.typePrefix,
     typeSuffix = config.typeSuffix,
+    patch = config.patch,
+    authorizationToken,
+    apiClassName = config.apiClassName,
   }) =>
     new Promise((resolve, reject) => {
       addToConfig({
@@ -66,12 +75,15 @@ module.exports = {
         generateResponses,
         templates,
         generateUnionEnums,
+        addReadonly,
         moduleNameIndex,
         moduleNameFirstTag,
         prettierOptions,
         modular,
         extractRequestParams,
         extractRequestBody,
+        extractResponseBody,
+        extractResponseError,
         hooks: _.merge(config.hooks, rawHooks || {}),
         enumNamesAsValues,
         disableStrictSSL,
@@ -79,16 +91,20 @@ module.exports = {
         cleanOutput,
         defaultResponseType,
         unwrapResponseData,
+        disableThrowOnError,
+        sortTypes,
         singleHttpClient,
         constants,
         silent,
         toJS: translateToJavaScript,
         typePrefix,
         typeSuffix,
+        patch,
+        apiClassName,
       });
       (spec
-        ? convertSwaggerObject(spec)
-        : getSwaggerObject(input, url, disableStrictSSL, disableProxy)
+        ? convertSwaggerObject(spec, { patch })
+        : getSwaggerObject(input, url, disableStrictSSL, disableProxy, authorizationToken, { patch })
       )
         .then(({ usageSchema, originalSchema }) => {
           const templatePaths = getTemplatePaths(config);
@@ -113,9 +129,7 @@ module.exports = {
 
           const componentsMap = createComponentsMap(components);
 
-          const componentSchemasNames = filterComponentsMap(componentsMap, "schemas").map(
-            (c) => c.typeName,
-          );
+          const componentSchemasNames = filterComponentsMap(componentsMap, "schemas").map((c) => c.typeName);
 
           addToConfig({
             componentTypeNameResolver: new ComponentTypeNameResolver(componentSchemasNames),
@@ -138,11 +152,44 @@ module.exports = {
           const hasFormDataRoutes = routes.some((route) => route.hasFormDataParams);
 
           const usageComponentSchemas = filterComponentsMap(componentsMap, "schemas");
+          const sortByProperty = (o1, o2, propertyName) => {
+            if (o1[propertyName] > o2[propertyName]) {
+              return 1;
+            }
+            if (o1[propertyName] < o2[propertyName]) {
+              return -1;
+            }
+            return 0;
+          };
+          const sortByTypeName = (o1, o2) => sortByProperty(o1, o2, "typeName");
+
+          const sortByName = (o1, o2) => sortByProperty(o1, o2, "name");
+
+          const sortSchemas = (schemas) => {
+            if (config.sortTypes) {
+              return schemas.sort(sortByTypeName).map((schema) => {
+                if (schema.rawTypeData?.properties) {
+                  return {
+                    ...schema,
+                    rawTypeData: {
+                      ...schema.rawTypeData,
+                      $parsed: {
+                        ...schema.rawTypeData["$parsed"],
+                        content: schema.rawTypeData["$parsed"].content.sort(sortByName),
+                      },
+                    },
+                  };
+                }
+                return schema;
+              });
+            }
+            return schemas;
+          };
 
           const rawConfiguration = {
             apiConfig: createApiConfig(usageSchema),
             config,
-            modelTypes: _.map(usageComponentSchemas, prepareModelType),
+            modelTypes: _.map(sortSchemas(usageComponentSchemas), prepareModelType),
             rawModelTypes: usageComponentSchemas,
             hasFormDataRoutes,
             hasSecurityRoutes,

package/src/prettierOptions.js

@@ -0,0 +1,23 @@
+const { cosmiconfigSync } = require("cosmiconfig");
+const constants = require("./constants");
+
+/**
+ * Get prettier options from user's project or return the default one
+ * @return {import('prettier').Options} Prettier options
+ */
+function getPrettierOptions() {
+  const prettier = cosmiconfigSync("prettier").search();
+
+  if (prettier) {
+    return {
+      ...prettier.config,
+      parser: "typescript",
+    };
+  }
+
+  return constants.PRETTIER_OPTIONS;
+}
+
+module.exports = {
+  getPrettierOptions,
+};

package/src/routeNames.js

@@ -13,19 +13,15 @@ const getRouteName = (routeInfo) => {
     config,
   });
 
-  const routeName =
-    config.hooks.onFormatRouteName(routeInfo, routeNameFromTemplate) || routeNameFromTemplate;
+  const routeName = config.hooks.onFormatRouteName(routeInfo, routeNameFromTemplate) || routeNameFromTemplate;
 
   const duplicateIdentifier = `${moduleName}|${routeName}`;
 
   if (routeNameDuplicatesMap.has(duplicateIdentifier)) {
-    routeNameDuplicatesMap.set(
-      duplicateIdentifier,
-      routeNameDuplicatesMap.get(duplicateIdentifier) + 1,
-    );
+    routeNameDuplicatesMap.set(duplicateIdentifier, routeNameDuplicatesMap.get(duplicateIdentifier) + 1);
 
     logger.warn(
-      `Module "${moduleName}" already have method "${routeName}()"`,
+      `Module "${moduleName}" already has method "${routeName}()"`,
       `\nThis method has been renamed to "${
         routeName + routeNameDuplicatesMap.get(duplicateIdentifier)
       }()" to solve conflict names.`,

package/src/routes.js

@@ -1,12 +1,5 @@
 const _ = require("lodash");
-const {
-  types,
-  parseSchema,
-  getType,
-  getRefType,
-  getInlineParseContent,
-  checkAndAddNull,
-} = require("./schema");
+const { types, parseSchema, getType, getRefType, getInlineParseContent, checkAndAddNull } = require("./schema");
 const { formatModelName } = require("./modelNames");
 const {
   DEFAULT_BODY_ARG_NAME,
@@ -19,7 +12,7 @@ const {
 } = require("./constants");
 const { formatDescription, classNameCase } = require("./common");
 const { config } = require("./config");
-const { nanoid } = require("nanoid");
+const { generateId } = require("./utils/id");
 const { getRouteName } = require("./routeNames");
 const { createComponent } = require("./components");
 const { logger } = require("./logger");
@@ -47,26 +40,15 @@ const getSchemaFromRequestType = (requestInfo) => {
   return null;
 };
 
-const getTypeFromRequestInfo = ({
-  requestInfo,
-  parsedSchemas,
-  operationId,
-  defaultType,
-  typeName,
-}) => {
+const getTypeFromRequestInfo = ({ requestInfo, parsedSchemas, operationId, defaultType, typeName }) => {
   // TODO: make more flexible pick schema without content type
   const schema = getSchemaFromRequestType(requestInfo);
   const refTypeInfo = getRefType(requestInfo);
 
   if (schema) {
     const content = getInlineParseContent(schema, typeName);
-    const foundedSchemaByName = _.find(
-      parsedSchemas,
-      (parsedSchema) => formatModelName(parsedSchema.name) === content,
-    );
-    const foundSchemaByContent = _.find(parsedSchemas, (parsedSchema) =>
-      _.isEqual(parsedSchema.content, content),
-    );
+    const foundedSchemaByName = _.find(parsedSchemas, (parsedSchema) => formatModelName(parsedSchema.name) === content);
+    const foundSchemaByContent = _.find(parsedSchemas, (parsedSchema) => _.isEqual(parsedSchema.content, content));
 
     const foundSchema = foundedSchemaByName || foundSchemaByContent;
 
@@ -88,10 +70,7 @@ const getTypeFromRequestInfo = ({
         return formatModelName(refTypeInfo.typeName);
       case "responses":
       case "requestBodies":
-        return getInlineParseContent(
-          getSchemaFromRequestType(refTypeInfo.rawTypeData),
-          refTypeInfo.typeName || null,
-        );
+        return getInlineParseContent(getSchemaFromRequestType(refTypeInfo.rawTypeData), refTypeInfo.typeName || null);
       default:
         return getInlineParseContent(refTypeInfo.rawTypeData, refTypeInfo.typeName || null);
     }
@@ -344,9 +323,7 @@ const createRequestParamsSchema = ({
   if (fixedSchema) return fixedSchema;
 
   if (extractRequestParams) {
-    const typeName = config.componentTypeNameResolver.resolve([
-      classNameCase(`${routeName.usage} Params`),
-    ]);
+    const typeName = config.componentTypeNameResolver.resolve([classNameCase(`${routeName.usage} Params`)]);
 
     return createComponent("schemas", typeName, { ...schema });
   }
@@ -358,9 +335,7 @@ const getContentTypes = (requestInfo, extraContentTypes) =>
   _.uniq(
     _.compact([
       ...(extraContentTypes || []),
-      ..._.flatten(
-        _.map(requestInfo, (requestInfoData) => requestInfoData && _.keys(requestInfoData.content)),
-      ),
+      ..._.flatten(_.map(requestInfo, (requestInfoData) => requestInfoData && _.keys(requestInfoData.content))),
     ]),
   );
 
@@ -400,10 +375,7 @@ const getRequestBodyInfo = (routeInfo, routeParams, parsedSchemas, routeName) =>
   let schema = null;
   let type = null;
 
-  const contentTypes = getContentTypes(
-    [requestBody],
-    [...(consumes || []), routeInfo["x-contentType"]],
-  );
+  const contentTypes = getContentTypes([requestBody], [...(consumes || []), routeInfo["x-contentType"]]);
   let contentKind = getContentKind(contentTypes);
 
   let typeName = null;
@@ -454,8 +426,7 @@ const getRequestBodyInfo = (routeInfo, routeParams, parsedSchemas, routeName) =>
     contentKind,
     schema,
     type,
-    required:
-      requestBody && (typeof requestBody.required === "undefined" || !!requestBody.required),
+    required: requestBody && (typeof requestBody.required === "undefined" || !!requestBody.required),
   };
 };
 
@@ -472,9 +443,7 @@ const getResponseBodyInfo = (routeInfo, routeParams, parsedSchemas) => {
   });
 
   const successResponse = responseInfos.find((response) => response.isSuccess);
-  const errorResponses = responseInfos.filter(
-    (response) => !response.isSuccess && response.type !== TS_KEYWORDS.ANY,
-  );
+  const errorResponses = responseInfos.filter((response) => !response.isSuccess && response.type !== TS_KEYWORDS.ANY);
 
   const handleResponseHeaders = (src) => {
     if (!src) {
@@ -507,24 +476,16 @@ const getResponseBodyInfo = (routeInfo, routeParams, parsedSchemas) => {
         responseInfos
           .map(
             (response) => `{
-      data: ${response.type}, status: ${response.status}, statusCode: ${
-              response.status
-            }, statusText: "${response.description}", ${handleResponseHeaders(
-              response.headers,
-            )} config: {} }`,
+      data: ${response.type}, status: ${response.status}, statusCode: ${response.status}, statusText: "${
+              response.description
+            }", ${handleResponseHeaders(response.headers)} config: {} }`,
           )
           .join(" | ") || TS_KEYWORDS.ANY,
     },
   };
 };
 
-const parseRoutes = ({
-  usageSchema,
-  parsedSchemas,
-  moduleNameIndex,
-  moduleNameFirstTag,
-  extractRequestParams,
-}) => {
+const parseRoutes = ({ usageSchema, parsedSchemas, moduleNameIndex, moduleNameFirstTag, extractRequestParams }) => {
   const { paths, security: globalSecurity } = usageSchema;
   const pathsEntries = _.entries(paths);
 
@@ -553,16 +514,13 @@ const parseRoutes = ({
           } = routeInfo;
           const { route, pathParams } = parseRoute(rawRoute);
 
-          const routeId = nanoid(12);
+          const routeId = generateId();
           const firstTag = tags && tags.length > 0 ? tags[0] : null;
           const moduleName =
             moduleNameFirstTag && firstTag
               ? _.camelCase(firstTag)
               : _.camelCase(_.compact(_.split(route, "/"))[moduleNameIndex]);
-          const hasSecurity = !!(
-            (globalSecurity && globalSecurity.length) ||
-            (security && security.length)
-          );
+          const hasSecurity = !!((globalSecurity && globalSecurity.length) || (security && security.length));
 
           const routeParams = getRouteParams(routeInfo, pathParams);
 
@@ -599,12 +557,7 @@ const parseRoutes = ({
 
           const routeName = getRouteName(rawRouteInfo);
 
-          const requestBodyInfo = getRequestBodyInfo(
-            routeInfo,
-            routeParams,
-            parsedSchemas,
-            routeName,
-          );
+          const requestBodyInfo = getRequestBodyInfo(routeInfo, routeParams, parsedSchemas, routeName);
 
           const requestParamsSchema = createRequestParamsSchema({
             queryParams: routeParams.query,
@@ -614,13 +567,12 @@ const parseRoutes = ({
             routeName,
           });
 
-          const queryType = routeParams.query.length
-            ? getInlineParseContent(queryObjectSchema)
-            : null;
+          extractResponseBodyIfItNeeded(routeInfo, responseBodyInfo, routeParams, rawRouteInfo, routeName);
+          extractResponseErrorIfItNeeded(routeInfo, responseBodyInfo, routeParams, rawRouteInfo, routeName);
+
+          const queryType = routeParams.query.length ? getInlineParseContent(queryObjectSchema) : null;
           const pathType = routeParams.path.length ? getInlineParseContent(pathObjectSchema) : null;
-          const headersType = routeParams.header.length
-            ? getInlineParseContent(headersObjectSchema)
-            : null;
+          const headersType = routeParams.header.length ? getInlineParseContent(headersObjectSchema) : null;
 
           const nameResolver = new SpecificArgNameResolver(pathArgsNames);
 
@@ -634,10 +586,7 @@ const parseRoutes = ({
               : void 0,
             body: requestBodyInfo.type
               ? {
-                  name: nameResolver.resolve([
-                    requestBodyInfo.paramName,
-                    ...RESERVED_BODY_ARG_NAMES,
-                  ]),
+                  name: nameResolver.resolve([requestBodyInfo.paramName, ...RESERVED_BODY_ARG_NAMES]),
                   optional: !requestBodyInfo.required,
                   type: requestBodyInfo.type,
                 }
@@ -764,10 +713,7 @@ const groupRoutes = (routes) => {
             if (
               packRoutes.length > 1 &&
               usageName !== originalName &&
-              !_.some(
-                packRoutes,
-                ({ routeName, id }) => id !== route.id && originalName === routeName.original,
-              )
+              !_.some(packRoutes, ({ routeName, id }) => id !== route.id && originalName === routeName.original)
             ) {
               return {
                 ...route,
@@ -788,6 +734,72 @@ const groupRoutes = (routes) => {
   );
 };
 
+const extractResponseBodyIfItNeeded = (routeInfo, responseBodyInfo, routeParams, rawRouteInfo, routeName) => {
+  if (
+    config.extractResponseBody &&
+    responseBodyInfo.responses.length &&
+    responseBodyInfo.success &&
+    responseBodyInfo.success.schema
+  ) {
+    const typeName = config.componentTypeNameResolver.resolve([
+      classNameCase(`${routeName.usage} Data`),
+      classNameCase(`${routeName.usage} Result`),
+      classNameCase(`${routeName.usage} Output`),
+    ]);
+
+    const idx = responseBodyInfo.responses.indexOf(responseBodyInfo.success.schema);
+
+    let successResponse = responseBodyInfo.success;
+
+    if (successResponse.schema && !successResponse.schema.$ref) {
+      const schema = getSchemaFromRequestType(successResponse.schema);
+      successResponse.schema = createComponent("schemas", typeName, { ...schema });
+      successResponse.type = getInlineParseContent(successResponse.schema);
+
+      if (idx > -1) {
+        responseBodyInfo.responses[idx] = successResponse.schema;
+      }
+    }
+  }
+};
+
+const extractResponseErrorIfItNeeded = (routeInfo, responseBodyInfo, routeParams, rawRouteInfo, routeName) => {
+  if (
+    config.extractResponseError &&
+    responseBodyInfo.responses.length &&
+    responseBodyInfo.error.schemas &&
+    responseBodyInfo.error.schemas.length
+  ) {
+    const typeName = config.componentTypeNameResolver.resolve([
+      classNameCase(`${routeName.usage} Error`),
+      classNameCase(`${routeName.usage} Fail`),
+      classNameCase(`${routeName.usage} Fails`),
+      classNameCase(`${routeName.usage} ErrorData`),
+      classNameCase(`${routeName.usage} HttpError`),
+      classNameCase(`${routeName.usage} BadResponse`),
+    ]);
+
+    const errorSchemas = responseBodyInfo.error.schemas.map(getSchemaFromRequestType).filter(Boolean);
+
+    if (!errorSchemas.length) return;
+
+    const schema = parseSchema({
+      oneOf: errorSchemas,
+      title: errorSchemas
+        .map((schema) => schema.title)
+        .filter(Boolean)
+        .join(" "),
+      description: errorSchemas
+        .map((schema) => schema.description)
+        .filter(Boolean)
+        .join("\n"),
+    });
+    const component = createComponent("schemas", typeName, { ...schema });
+    responseBodyInfo.error.schemas = [component];
+    responseBodyInfo.error.type = formatModelName(component.typeName);
+  }
+};
+
 module.exports = {
   parseRoutes,
   groupRoutes,

package/src/schema.js

@@ -63,12 +63,7 @@ const getTypeAlias = (rawSchema) => {
 };
 
 const getEnumNames = (schema) => {
-  return (
-    schema["x-enumNames"] ||
-    schema["xEnumNames"] ||
-    schema["x-enumnames"] ||
-    schema["x-enum-varnames"]
-  );
+  return schema["x-enumNames"] || schema["xEnumNames"] || schema["x-enumnames"] || schema["x-enum-varnames"];
 };
 
 const getInternalSchemaType = (schema) => {
@@ -137,29 +132,36 @@ const getObjectTypeContent = (schema) => {
     const nullable = !!(rawTypeData.nullable || property.nullable);
     const fieldName = isValidName(name) ? name : `"${name}"`;
     const fieldValue = getInlineParseContent(property);
+    const readOnly = property.readOnly;
 
     return {
       $$raw: property,
+      title: property.title,
       description: _.compact([
         property.description ||
           _.compact(_.map(property[getComplexType(property)], "description"))[0] ||
           rawTypeData.description ||
           _.compact(_.map(rawTypeData[getComplexType(rawTypeData)], "description"))[0] ||
           "",
+        !_.isUndefined(property.deprecated) && `@deprecated`,
         !_.isUndefined(property.format) && `@format ${property.format}`,
         !_.isUndefined(property.minimum) && `@min ${property.minimum}`,
         !_.isUndefined(property.maximum) && `@max ${property.maximum}`,
         !_.isUndefined(property.pattern) && `@pattern ${property.pattern}`,
         !_.isUndefined(property.example) &&
-          `@example ${
-            _.isObject(property.example) ? JSON.stringify(property.example) : property.example
-          }`,
+          `@example ${_.isObject(property.example) ? JSON.stringify(property.example) : property.example}`,
       ]).join("\n"),
       isRequired: required,
       isNullable: nullable,
       name: fieldName,
       value: fieldValue,
-      field: _.compact([fieldName, !required && "?", ": ", fieldValue]).join(""),
+      field: _.compact([
+        readOnly && config.addReadonly && "readonly ",
+        fieldName,
+        !required && "?",
+        ": ",
+        fieldValue,
+      ]).join(""),
     };
   });
 
@@ -178,39 +180,73 @@ const getObjectTypeContent = (schema) => {
 const complexTypeGetter = (schema) => getInlineParseContent(schema);
 const filterContents = (contents, types) => _.filter(contents, (type) => !_.includes(types, type));
 
+const makeAddRequiredToChildSchema = (parentSchema) => (childSchema) => {
+  let required = childSchema.required || [];
+  let properties = childSchema.properties || {};
+
+  // Inherit all the required fields from the parent schema that are defined
+  // either on the parent schema or on the child schema
+  // TODO: any that are defined at grandparents or higher are ignored
+  required = required.concat(
+    (parentSchema.required || []).filter(
+      (key) =>
+        !required.includes(key) && (_.keys(properties).includes(key) || _.keys(parentSchema.properties).includes(key)),
+    ),
+  );
+
+  // Identify properties that are required in the child schema, but
+  // defined only in the parent schema (TODO: this only works one level deep)
+  const parentPropertiesRequiredByChild = required.filter(
+    (key) => !_.keys(childSchema.properties).includes(key) && _.keys(parentSchema.properties).includes(key),
+  );
+
+  // Add such properties to the child so that they can be overriden and made required
+  properties = {
+    ...properties,
+    ...parentPropertiesRequiredByChild.reduce(
+      (additionalProperties, key) => ({
+        ...additionalProperties,
+        [key]: (parentSchema.properties || {})[key],
+      }),
+      {},
+    ),
+  };
+
+  return _.merge(
+    {
+      required: required,
+      properties: properties,
+    },
+    childSchema,
+  );
+};
+
 const complexSchemaParsers = {
   [SCHEMA_TYPES.COMPLEX_ONE_OF]: (schema) => {
     // T1 | T2
-    const combined = _.map(schema.oneOf, complexTypeGetter);
+    const combined = _.map(_.map(schema.oneOf, makeAddRequiredToChildSchema(schema)), complexTypeGetter);
 
     return checkAndAddNull(schema, filterContents(combined, [TS_KEYWORDS.ANY]).join(" | "));
   },
   [SCHEMA_TYPES.COMPLEX_ALL_OF]: (schema) => {
     // T1 & T2
-    const combined = _.map(schema.allOf, complexTypeGetter);
+    const combined = _.map(_.map(schema.allOf, makeAddRequiredToChildSchema(schema)), complexTypeGetter);
     return checkAndAddNull(
       schema,
-      filterContents(combined, [...JS_EMPTY_TYPES, ...JS_PRIMITIVE_TYPES, TS_KEYWORDS.ANY]).join(
-        " & ",
-      ),
+      filterContents(combined, [...JS_EMPTY_TYPES, ...JS_PRIMITIVE_TYPES, TS_KEYWORDS.ANY]).join(" & "),
     );
   },
   [SCHEMA_TYPES.COMPLEX_ANY_OF]: (schema) => {
     // T1 | T2 | (T1 & T2)
-    const combined = _.map(schema.anyOf, complexTypeGetter);
-    const nonEmptyTypesCombined = filterContents(combined, [
-      ...JS_EMPTY_TYPES,
-      ...JS_PRIMITIVE_TYPES,
-      TS_KEYWORDS.ANY,
-    ]);
+    const combined = _.map(_.map(schema.anyOf, makeAddRequiredToChildSchema(schema)), complexTypeGetter);
+    const nonEmptyTypesCombined = filterContents(combined, [...JS_EMPTY_TYPES, ...JS_PRIMITIVE_TYPES, TS_KEYWORDS.ANY]);
     return checkAndAddNull(
       schema,
-      `${combined.join(" | ")}` +
-        (nonEmptyTypesCombined.length > 1 ? ` | (${nonEmptyTypesCombined.join(" & ")})` : ""),
+      `${combined.join(" | ")}` + (nonEmptyTypesCombined.length > 1 ? ` | (${nonEmptyTypesCombined.join(" & ")})` : ""),
     );
   },
   // TODO
-  [SCHEMA_TYPES.COMPLEX_NOT_OF]: (schema) => {
+  [SCHEMA_TYPES.COMPLEX_NOT]: (schema) => {
     // TODO
     return TS_KEYWORDS.ANY;
   },
@@ -227,8 +263,7 @@ const getComplexType = (schema) => {
 };
 
 const attachParsedRef = (originalSchema, parsedSchema) => {
-  const parsedSchemaAfterHook =
-    config.hooks.onParseSchema(originalSchema, parsedSchema) || parsedSchema;
+  const parsedSchemaAfterHook = config.hooks.onParseSchema(originalSchema, parsedSchema) || parsedSchema;
 
   if (originalSchema) {
     originalSchema.$parsed = parsedSchemaAfterHook;
@@ -263,12 +298,7 @@ const schemaParsers = {
         return {
           key: formattedKey,
           type: keyType,
-          value:
-            enumValue === null
-              ? enumValue
-              : isIntegerOrBooleanEnum
-              ? `${enumValue}`
-              : `"${enumValue}"`,
+          value: enumValue === null ? enumValue : isIntegerOrBooleanEnum ? `${enumValue}` : `"${enumValue}"`,
         };
       });
     } else {
@@ -290,9 +320,7 @@ const schemaParsers = {
       type: SCHEMA_TYPES.ENUM,
       keyType: keyType,
       typeIdentifier:
-        config.generateUnionEnums || (!enumNames && isIntegerOrBooleanEnum)
-          ? TS_KEYWORDS.TYPE
-          : TS_KEYWORDS.ENUM,
+        config.generateUnionEnums || (!enumNames && isIntegerOrBooleanEnum) ? TS_KEYWORDS.TYPE : TS_KEYWORDS.ENUM,
       name: typeName,
       description: formatDescription(schema.description),
       content,
@@ -331,8 +359,7 @@ const schemaParsers = {
       content:
         _.compact([
           complexSchemaContent && `(${complexSchemaContent})`,
-          getInternalSchemaType(simpleSchema) === TS_KEYWORDS.OBJECT &&
-            getInlineParseContent(simpleSchema),
+          getInternalSchemaType(simpleSchema) === TS_KEYWORDS.OBJECT && getInlineParseContent(simpleSchema),
         ]).join(" & ") || TS_KEYWORDS.ANY,
     });
   },
@@ -400,10 +427,7 @@ const parseSchema = (rawSchema, typeName, formattersMap) => {
     parsedSchema = schemaParsers[schemaType](fixedRawSchema, typeName);
   }
 
-  return (
-    (formattersMap && formattersMap[schemaType] && formattersMap[schemaType](parsedSchema)) ||
-    parsedSchema
-  );
+  return (formattersMap && formattersMap[schemaType] && formattersMap[schemaType](parsedSchema)) || parsedSchema;
 };
 
 const parseSchemas = (components) =>
@@ -412,8 +436,7 @@ const parseSchemas = (components) =>
 const getInlineParseContent = (rawTypeData, typeName = null) =>
   parseSchema(rawTypeData, typeName, inlineExtraFormatters).content;
 
-const getParseContent = (rawTypeData, typeName = null) =>
-  parseSchema(rawTypeData, typeName).content;
+const getParseContent = (rawTypeData, typeName = null) => parseSchema(rawTypeData, typeName).content;
 
 module.exports = {
   types,