swagger-typescript-api 12.0.1 → 13.0.0-experimental-1

package/src/schema-parser/schema-parser.js

@@ -1,25 +1,23 @@
-const { SCHEMA_TYPES } = require("../constants.js");
-const _ = require("lodash");
 const { SchemaFormatters } = require("./schema-formatters");
-const { internalCase } = require("../util/internal-case");
 const { SchemaUtils } = require("./schema-utils");
+const { SCHEMA_TYPES } = require("../constants");
+const _ = require("lodash");
+const { internalCase } = require("../util/internal-case");
 const { camelCase } = require("lodash");
-const { pascalCase } = require("../util/pascal-case");
 
 class SchemaParser {
   /**
    * @type {CodeGenConfig}
    */
   config;
-
   /**
    * @type {SchemaComponentsMap}
    */
   schemaComponentsMap;
   /**
-   * @type {TypeName}
+   * @type {TypeNameFormatter}
    */
-  typeName;
+  typeNameFormatter;
   /**
    * @type {SchemaFormatters}
    */
@@ -30,22 +28,43 @@ class SchemaParser {
    */
   schemaUtils;
 
-  $processingSchemaPath = [];
+  schemaPath = [];
 
-  constructor(config, logger, templates, schemaComponentsMap, typeName) {
+  typeName;
+  schema;
+
+  constructor(
+    config,
+    schemaComponentsMap,
+    typeNameFormatter,
+    schemaFormatters,
+    schemaUtils,
+    schema,
+    typeName = null,
+    schemaPath = [],
+  ) {
     this.config = config;
     this.schemaComponentsMap = schemaComponentsMap;
+    this.typeNameFormatter = typeNameFormatter;
+    this.schemaFormatters = schemaFormatters;
+    this.schemaUtils = schemaUtils;
+    this.schema = schema;
     this.typeName = typeName;
-    this.schemaFormatters = new SchemaFormatters(config, logger, this, templates);
-    this.schemaUtils = new SchemaUtils(config, schemaComponentsMap);
+    this.schemaPath = schemaPath;
   }
 
-  complexSchemaParsers = {
+  _complexSchemaParsers = {
     // T1 | T2
-    [SCHEMA_TYPES.COMPLEX_ONE_OF]: (schema) => {
+    [SCHEMA_TYPES.COMPLEX_ONE_OF]: async (schema) => {
       const ignoreTypes = [this.config.Ts.Keyword.Any];
-      const combined = _.map(schema.oneOf, (childSchema) =>
-        this.getInlineParseContent(this.schemaUtils.makeAddRequiredToChildSchema(schema, childSchema)),
+      const combined = await Promise.all(
+        _.map(schema.oneOf, (childSchema) =>
+          this.createParser(
+            this.schemaUtils.makeAddRequiredToChildSchema(schema, childSchema),
+            undefined,
+            this.schemaPath,
+          ).getInlineContent(),
+        ),
       );
       const filtered = this.schemaUtils.filterSchemaContents(combined, (content) => !ignoreTypes.includes(content));
 
@@ -54,10 +73,16 @@ class SchemaParser {
       return this.schemaUtils.safeAddNullToType(schema, type);
     },
     // T1 & T2
-    [SCHEMA_TYPES.COMPLEX_ALL_OF]: (schema) => {
+    [SCHEMA_TYPES.COMPLEX_ALL_OF]: async (schema) => {
       const ignoreTypes = [...this.config.jsPrimitiveTypes, this.config.Ts.Keyword.Any];
-      const combined = _.map(schema.allOf, (childSchema) =>
-        this.getInlineParseContent(this.schemaUtils.makeAddRequiredToChildSchema(schema, childSchema)),
+      const combined = await Promise.all(
+        _.map(schema.allOf, (childSchema) =>
+          this.createParser(
+            this.schemaUtils.makeAddRequiredToChildSchema(schema, childSchema),
+            undefined,
+            this.schemaPath,
+          ).getInlineContent(),
+        ),
       );
       const filtered = this.schemaUtils.filterSchemaContents(combined, (content) => !ignoreTypes.includes(content));
 
@@ -66,10 +91,16 @@ class SchemaParser {
       return this.schemaUtils.safeAddNullToType(schema, type);
     },
     // T1 | T2 | (T1 & T2)
-    [SCHEMA_TYPES.COMPLEX_ANY_OF]: (schema) => {
+    [SCHEMA_TYPES.COMPLEX_ANY_OF]: async (schema) => {
       const ignoreTypes = [...this.config.jsPrimitiveTypes, this.config.Ts.Keyword.Any];
-      const combined = _.map(schema.anyOf, (childSchema) =>
-        this.getInlineParseContent(this.schemaUtils.makeAddRequiredToChildSchema(schema, childSchema)),
+      const combined = await Promise.all(
+        _.map(schema.anyOf, (childSchema) =>
+          this.createParser(
+            this.schemaUtils.makeAddRequiredToChildSchema(schema, childSchema),
+            undefined,
+            this.schemaPath,
+          ).getInlineContent(),
+        ),
       );
       const filtered = this.schemaUtils.filterSchemaContents(combined, (content) => !ignoreTypes.includes(content));
 
@@ -88,20 +119,20 @@ class SchemaParser {
       return this.config.Ts.Keyword.Any;
     },
   };
-
-  baseSchemaParsers = {
-    [SCHEMA_TYPES.ENUM]: (schema, typeName) => {
+  _baseSchemaParsers = {
+    [SCHEMA_TYPES.ENUM]: async (schema, typeName) => {
       if (this.config.extractEnums && !typeName) {
         const generatedTypeName = this.config.componentTypeNameResolver.resolve([this.buildTypeNameFromPath()]);
         const schemaComponent = this.schemaComponentsMap.createComponent("schemas", generatedTypeName, { ...schema });
-        return this.parseSchema(schemaComponent, generatedTypeName);
+        const parser = this.createParser(schemaComponent, generatedTypeName);
+        return await parser.parse();
       }
 
       const refType = this.schemaUtils.getSchemaRefType(schema);
       const $ref = (refType && refType.$ref) || null;
 
       if (Array.isArray(schema.enum) && Array.isArray(schema.enum[0])) {
-        return this.parseSchema(
+        return await this.createParser(
           {
             oneOf: schema.enum.map((enumNames) => ({
               type: "array",
@@ -109,21 +140,22 @@ class SchemaParser {
             })),
           },
           typeName,
-        );
+          this.schemaPath,
+        ).parse();
       }
 
-      const keyType = this.getSchemaType(schema);
+      const keyType = await this.schemaUtils.getSchemaType(schema);
       const enumNames = this.schemaUtils.getEnumNames(schema);
       let content = null;
 
-      const formatValue = (value) => {
+      const formatValue = async (value) => {
         if (value === null) {
           return this.config.Ts.NullValue(value);
         }
-        if (keyType === this.getSchemaType({ type: "number" })) {
+        if (keyType === (await this.schemaUtils.getSchemaType({ type: "number" }))) {
           return this.config.Ts.NumberValue(value);
         }
-        if (keyType === this.getSchemaType({ type: "boolean" })) {
+        if (keyType === (await this.schemaUtils.getSchemaType({ type: "boolean" }))) {
           return this.config.Ts.BooleanValue(value);
         }
 
@@ -131,41 +163,45 @@ class SchemaParser {
       };
 
       if (_.isArray(enumNames) && _.size(enumNames)) {
-        content = _.map(enumNames, (enumName, index) => {
-          const enumValue = _.get(schema.enum, index);
-          const formattedKey =
-            (enumName &&
-              this.typeName.format(enumName, {
+        content = await Promise.all(
+          _.map(enumNames, async (enumName, index) => {
+            const enumValue = _.get(schema.enum, index);
+            const formattedKey =
+              (enumName &&
+                this.typeNameFormatter.format(enumName, {
+                  type: "enum-key",
+                })) ||
+              this.typeNameFormatter.format(`${enumValue}`, {
                 type: "enum-key",
-              })) ||
-            this.typeName.format(`${enumValue}`, {
-              type: "enum-key",
-            });
+              });
+
+            if (this.config.enumNamesAsValues || _.isUndefined(enumValue)) {
+              return {
+                key: formattedKey,
+                type: this.config.Ts.Keyword.String,
+                value: this.config.Ts.StringValue(enumName),
+              };
+            }
 
-          if (this.config.enumNamesAsValues || _.isUndefined(enumValue)) {
             return {
               key: formattedKey,
-              type: this.config.Ts.Keyword.String,
-              value: this.config.Ts.StringValue(enumName),
+              type: keyType,
+              value: await formatValue(enumValue),
             };
-          }
-
-          return {
-            key: formattedKey,
-            type: keyType,
-            value: formatValue(enumValue),
-          };
-        });
+          }),
+        );
       } else {
-        content = _.map(schema.enum, (key) => {
-          return {
-            key: this.typeName.format(`${key}`, {
-              type: "enum-key",
-            }),
-            type: keyType,
-            value: formatValue(key),
-          };
-        });
+        content = await Promise.all(
+          _.map(schema.enum, async (key) => {
+            return {
+              key: this.typeNameFormatter.format(`${key}`, {
+                type: "enum-key",
+              }),
+              type: keyType,
+              value: await formatValue(key),
+            };
+          }),
+        );
       }
 
       return {
@@ -182,8 +218,54 @@ class SchemaParser {
         content,
       };
     },
-    [SCHEMA_TYPES.OBJECT]: (schema, typeName) => {
-      const contentProperties = this.getObjectSchemaContent(schema);
+    [SCHEMA_TYPES.OBJECT]: async (schema, typeName) => {
+      const { properties, additionalProperties } = schema || {};
+      const contentProperties = [];
+
+      const propertyEntries = _.entries(properties);
+
+      for await (const [name, property] of propertyEntries) {
+        this.schemaPath.push(name);
+        const required = this.schemaUtils.isPropertyRequired(name, property, schema);
+        const rawTypeData = _.get(this.schemaUtils.getSchemaRefType(property), "rawTypeData", {});
+        const nullable = !!(rawTypeData.nullable || property.nullable);
+        const fieldName = this.typeNameFormatter.isValidName(name) ? name : this.config.Ts.StringValue(name);
+        const fieldValue = await this.createParser(property, null, this.schemaPath).getInlineContent();
+        const readOnly = property.readOnly;
+
+        this.schemaPath.pop();
+
+        contentProperties.push({
+          ...property,
+          $$raw: property,
+          title: property.title,
+          description:
+            property.description ||
+            _.compact(_.map(property[this.schemaUtils.getComplexType(property)], "description"))[0] ||
+            rawTypeData.description ||
+            _.compact(_.map(rawTypeData[this.schemaUtils.getComplexType(rawTypeData)], "description"))[0] ||
+            "",
+          isRequired: required,
+          isNullable: nullable,
+          name: fieldName,
+          value: fieldValue,
+          field: this.config.Ts.TypeField({
+            readonly: readOnly && this.config.addReadonly,
+            optional: !required,
+            key: fieldName,
+            value: fieldValue,
+          }),
+        });
+      }
+
+      if (additionalProperties) {
+        contentProperties.push({
+          $$raw: { additionalProperties },
+          description: "",
+          isRequired: false,
+          field: this.config.Ts.InterfaceDynamicField(this.config.Ts.Keyword.String, this.config.Ts.Keyword.Any),
+        });
+      }
 
       return {
         ...(_.isObject(schema) ? schema : {}),
@@ -197,10 +279,10 @@ class SchemaParser {
         content: contentProperties,
       };
     },
-    [SCHEMA_TYPES.COMPLEX]: (schema, typeName) => {
-      const complexType = this.getComplexType(schema);
-      const simpleSchema = _.omit(_.clone(schema), _.keys(this.complexSchemaParsers));
-      const complexSchemaContent = this.complexSchemaParsers[complexType](schema);
+    [SCHEMA_TYPES.COMPLEX]: async (schema, typeName) => {
+      const complexType = this.schemaUtils.getComplexType(schema);
+      const simpleSchema = _.omit(_.clone(schema), _.keys(this._complexSchemaParsers));
+      const complexSchemaContent = await this._complexSchemaParsers[complexType](schema);
 
       return {
         ...(_.isObject(schema) ? schema : {}),
@@ -216,32 +298,61 @@ class SchemaParser {
           this.config.Ts.IntersectionType(
             _.compact([
               this.config.Ts.ExpressionGroup(complexSchemaContent),
-              this.getInternalSchemaType(simpleSchema) === SCHEMA_TYPES.OBJECT &&
-                this.config.Ts.ExpressionGroup(this.getInlineParseContent(simpleSchema)),
+              this.schemaUtils.getInternalSchemaType(simpleSchema) === SCHEMA_TYPES.OBJECT &&
+                this.config.Ts.ExpressionGroup(
+                  await this.createParser(simpleSchema, null, this.schemaPath).getInlineContent(),
+                ),
             ]),
           ) || this.config.Ts.Keyword.Any,
       };
     },
-    [SCHEMA_TYPES.PRIMITIVE]: (schema, typeName) => {
+    [SCHEMA_TYPES.ARRAY]: async (schema, typeName) => {
+      let contentType;
+      const { type, description, items } = schema || {};
+
+      if (_.isArray(items) && type === SCHEMA_TYPES.ARRAY) {
+        const tupleContent = await Promise.all(
+          items.map((item) => this.createParser(item, null, this.schemaPath).getInlineContent()),
+        );
+        contentType = this.config.Ts.Tuple(tupleContent);
+      } else {
+        const content = await this.createParser(items, null, this.schemaPath).getInlineContent();
+        contentType = this.config.Ts.ArrayType(content);
+      }
+
+      return {
+        ...(_.isObject(schema) ? schema : {}),
+        $parsedSchema: true,
+        schemaType: SCHEMA_TYPES.PRIMITIVE,
+        type: SCHEMA_TYPES.PRIMITIVE,
+        typeIdentifier: this.config.Ts.Keyword.Type,
+        name: typeName,
+        description: this.schemaFormatters.formatDescription(description),
+        content: this.schemaUtils.safeAddNullToType(schema, contentType),
+      };
+    },
+    [SCHEMA_TYPES.PRIMITIVE]: async (schema, typeName) => {
       let contentType = null;
       const { additionalProperties, type, description, items } = schema || {};
 
       if (type === this.config.Ts.Keyword.Object && additionalProperties) {
         const fieldType = _.isObject(additionalProperties)
-          ? this.getInlineParseContent(additionalProperties)
+          ? await this.createParser(additionalProperties, null, this.schemaPath).getInlineContent()
           : this.config.Ts.Keyword.Any;
         contentType = this.config.Ts.RecordType(this.config.Ts.Keyword.String, fieldType);
       }
 
       if (_.isArray(type) && type.length) {
-        contentType = this.complexSchemaParsers.oneOf({
+        contentType = await this._complexSchemaParsers.oneOf({
           ...(_.isObject(schema) ? schema : {}),
           oneOf: type.map((type) => ({ type })),
         });
       }
 
       if (_.isArray(items) && type === SCHEMA_TYPES.ARRAY) {
-        contentType = this.config.Ts.Tuple(items.map((item) => this.getInlineParseContent(item)));
+        contentType = this.config.Ts.Tuple(
+          await Promise.all(items.map((item) => this.createParser(item, null, this.schemaPath).getInlineContent())),
+        );
       }
 
       return {
@@ -253,110 +364,18 @@ class SchemaParser {
         name: typeName,
         description: this.schemaFormatters.formatDescription(description),
         // TODO: probably it should be refactored. `type === 'null'` is not flexible
-        content: type === this.config.Ts.Keyword.Null ? type : contentType || this.getSchemaType(schema),
+        content:
+          type === this.config.Ts.Keyword.Null ? type : contentType || (await this.schemaUtils.getSchemaType(schema)),
       };
     },
   };
 
-  getInternalSchemaType = (schema) => {
-    if (!_.isEmpty(schema.enum) || !_.isEmpty(this.schemaUtils.getEnumNames(schema))) return SCHEMA_TYPES.ENUM;
-    if (schema.allOf || schema.oneOf || schema.anyOf || schema.not) return SCHEMA_TYPES.COMPLEX;
-    if (!_.isEmpty(schema.properties)) return SCHEMA_TYPES.OBJECT;
-
-    return SCHEMA_TYPES.PRIMITIVE;
-  };
-
-  getSchemaType = (schema) => {
-    if (!schema) return this.config.Ts.Keyword.Any;
-
-    const refTypeInfo = this.schemaUtils.getSchemaRefType(schema);
-
-    if (refTypeInfo) {
-      return this.schemaUtils.checkAndAddRequiredKeys(
-        schema,
-        this.schemaUtils.safeAddNullToType(schema, this.typeName.format(refTypeInfo.typeName)),
-      );
-    }
-
-    const primitiveType = this.schemaUtils.getSchemaPrimitiveType(schema);
-
-    if (primitiveType == null) return this.config.Ts.Keyword.Any;
-
-    let resultType;
-
-    const typeAlias =
-      _.get(this.config.primitiveTypes, [primitiveType, schema.format]) ||
-      _.get(this.config.primitiveTypes, [primitiveType, "$default"]) ||
-      this.config.primitiveTypes[primitiveType];
-
-    if (_.isFunction(typeAlias)) {
-      resultType = typeAlias(schema, this);
-    } else {
-      resultType = typeAlias || primitiveType;
-    }
-
-    if (!resultType) return this.config.Ts.Keyword.Any;
-
-    return this.schemaUtils.checkAndAddRequiredKeys(schema, this.schemaUtils.safeAddNullToType(schema, resultType));
-  };
-
-  getObjectSchemaContent = (schema) => {
-    const { properties, additionalProperties } = schema || {};
-
-    const propertiesContent = _.map(properties, (property, name) => {
-      this.$processingSchemaPath.push(name);
-      const required = this.schemaUtils.isPropertyRequired(name, property, schema);
-      const rawTypeData = _.get(this.schemaUtils.getSchemaRefType(property), "rawTypeData", {});
-      const nullable = !!(rawTypeData.nullable || property.nullable);
-      const fieldName = this.typeName.isValidName(name) ? name : this.config.Ts.StringValue(name);
-      const fieldValue = this.getInlineParseContent(property);
-      const readOnly = property.readOnly;
-
-      this.$processingSchemaPath.pop();
-
-      return {
-        ...property,
-        $$raw: property,
-        title: property.title,
-        description:
-          property.description ||
-          _.compact(_.map(property[this.getComplexType(property)], "description"))[0] ||
-          rawTypeData.description ||
-          _.compact(_.map(rawTypeData[this.getComplexType(rawTypeData)], "description"))[0] ||
-          "",
-        isRequired: required,
-        isNullable: nullable,
-        name: fieldName,
-        value: fieldValue,
-        field: this.config.Ts.TypeField({
-          readonly: readOnly && this.config.addReadonly,
-          optional: !required,
-          key: fieldName,
-          value: fieldValue,
-        }),
-      };
-    });
-
-    if (additionalProperties) {
-      propertiesContent.push({
-        $$raw: { additionalProperties },
-        description: "",
-        isRequired: false,
-        field: this.config.Ts.InterfaceDynamicField(this.config.Ts.Keyword.String, this.config.Ts.Keyword.Any),
-      });
-    }
-
-    return propertiesContent;
-  };
+  buildTypeNameFromPath = () => {
+    const schemaPath = _.uniq(_.compact(this.schemaPath));
 
-  getComplexType = (schema) => {
-    if (schema.oneOf) return SCHEMA_TYPES.COMPLEX_ONE_OF;
-    if (schema.allOf) return SCHEMA_TYPES.COMPLEX_ALL_OF;
-    if (schema.anyOf) return SCHEMA_TYPES.COMPLEX_ANY_OF;
-    // TODO :(
-    if (schema.not) return SCHEMA_TYPES.COMPLEX_NOT;
+    if (!schemaPath || !schemaPath[0]) return null;
 
-    return SCHEMA_TYPES.COMPLEX_UNKNOWN;
+    return internalCase(camelCase(`${schemaPath[0]}_${schemaPath[schemaPath.length - 1]}`));
   };
 
   /**
@@ -364,59 +383,110 @@ class SchemaParser {
    * @param schema {any}
    * @param typeName {null | string}
    * @param formatter {"inline" | "base"}
-   * @return {Record<string, any>}
+   * @return {Promise<Record<string, any>>}
    */
-  parseSchema = (schema, typeName = null) => {
-    if (!schema) return this.baseSchemaParsers[SCHEMA_TYPES.PRIMITIVE](null, typeName);
+  parse = async () => {
+    if (!this.schema) return await this._baseSchemaParsers[SCHEMA_TYPES.PRIMITIVE](null, this.typeName);
 
     let schemaType = null;
     let parsedSchema = null;
 
-    if (typeof schema === "string") {
-      return schema;
+    if (typeof this.schema === "string") {
+      return this.schema;
     }
 
-    if (!schema.$parsed) {
-      if (!typeName && this.schemaUtils.isRefSchema(schema)) {
-        typeName = this.getSchemaType(schema);
+    if (!this.schema.$parsed) {
+      if (!this.typeName && this.schemaUtils.isRefSchema(this.schema)) {
+        this.typeName = await this.schemaUtils.getSchemaType(this.schema);
       }
 
-      if (schema.items && !Array.isArray(schema.items) && !schema.type) {
-        schema.type = SCHEMA_TYPES.ARRAY;
+      if (this.schema.items && !Array.isArray(this.schema.items) && !this.schema.type) {
+        this.schema.type = SCHEMA_TYPES.ARRAY;
       }
-      schemaType = this.getInternalSchemaType(schema);
+      schemaType = this.schemaUtils.getInternalSchemaType(this.schema);
 
-      this.$processingSchemaPath.push(typeName);
+      this.schemaPath.push(this.typeName);
 
-      _.merge(schema, this.config.hooks.onPreParseSchema(schema, typeName, schemaType));
-      parsedSchema = this.baseSchemaParsers[schemaType](schema, typeName);
-      schema.$parsed = this.config.hooks.onParseSchema(schema, parsedSchema) || parsedSchema;
+      _.merge(this.schema, this.config.hooks.onPreParseSchema(this.schema, this.typeName, schemaType));
+      parsedSchema = await this._baseSchemaParsers[schemaType](this.schema, this.typeName);
+      this.schema.$parsed = this.config.hooks.onParseSchema(this.schema, parsedSchema) || parsedSchema;
     }
 
-    this.$processingSchemaPath.pop();
+    this.schemaPath.pop();
 
-    return schema.$parsed;
+    return this.schema.$parsed;
   };
 
-  getInlineParseContent = (rawTypeData, typeName) => {
-    const parsedSchema = this.parseSchema(rawTypeData, typeName);
-    const formattedSchema = this.schemaFormatters.formatSchema(parsedSchema, "inline");
-    return formattedSchema.content;
+  /**
+   * @param cfg {{ formatType?: "base" | "inline", schemaType?: string } }
+   * @return {Promise<Record<string, any>>}
+   */
+  format = async (cfg) => {
+    const parsedSchema = await this.parse();
+    return await this.schemaFormatters.formatSchema(parsedSchema, cfg);
   };
 
-  getParseContent = (rawTypeData, typeName) => {
-    const parsedSchema = this.parseSchema(rawTypeData, typeName);
-    const formattedSchema = this.schemaFormatters.formatSchema(parsedSchema, "base");
-    return formattedSchema.content;
+  getInlineContent = async () => {
+    const schema = await this.format({ formatType: "inline" });
+    return schema.content;
   };
 
-  buildTypeNameFromPath = () => {
-    const schemaPath = _.uniq(_.compact(this.$processingSchemaPath));
-
-    if (!schemaPath || !schemaPath[0]) return null;
+  getContent = async () => {
+    const schema = await this.format({ formatType: "base" });
+    return schema.content;
+  };
 
-    return internalCase(camelCase(`${schemaPath[0]}_${schemaPath[schemaPath.length - 1]}`));
+  /**
+   * @param {Record<string, any>} [schema]
+   * @param {string | null | undefined} [typeName]
+   * @param {string[] | undefined} [schemaPath]
+   * @return {SchemaParser}
+   */
+  createParser = (schema, typeName, schemaPath) => {
+    return new SchemaParser(
+      this.config,
+      this.schemaComponentsMap,
+      this.typeNameFormatter,
+      this.schemaFormatters,
+      this.schemaUtils,
+      schema,
+      typeName,
+      schemaPath,
+    );
   };
+
+  /**
+   * @param config {CodeGenConfig}
+   * @param schemaComponentsMap {SchemaComponentsMap}
+   * @param typeNameFormatter {TypeNameFormatter}
+   * @param schemaFormatters {SchemaFormatters}
+   * @param schemaUtils {SchemaUtils}
+   * @param {Record<string, any>} [schema]
+   * @param {string | null | undefined} [typeName]
+   * @param {string[] | undefined} [schemaPath]
+   * @return {SchemaParser}
+   */
+  static create(
+    config,
+    schemaComponentsMap,
+    typeNameFormatter,
+    schemaFormatters,
+    schemaUtils,
+    schema,
+    typeName,
+    schemaPath,
+  ) {
+    return new SchemaParser(
+      config,
+      schemaComponentsMap,
+      typeNameFormatter,
+      schemaFormatters,
+      schemaUtils,
+      schema,
+      typeName,
+      schemaPath,
+    );
+  }
 }
 
 module.exports = {