swagger-typescript-api 12.0.4 → 13.0.0

package/src/schema-parser/base-schema-parsers/complex.js

@@ -0,0 +1,51 @@
+const { MonoSchemaParser } = require('../mono-schema-parser');
+const _ = require('lodash');
+const { SCHEMA_TYPES } = require('../../constants');
+
+class ComplexSchemaParser extends MonoSchemaParser {
+  parse() {
+    const complexType = this.schemaUtils.getComplexType(this.schema);
+    const simpleSchema = _.omit(
+      _.clone(this.schema),
+      _.keys(this.schemaParser._complexSchemaParsers),
+    );
+    const complexSchemaContent = this.schemaParser._complexSchemaParsers[
+      complexType
+    ](this.schema);
+
+    return {
+      ...(_.isObject(this.schema) ? this.schema : {}),
+      $schemaPath: this.schemaPath.slice(),
+      $parsedSchema: true,
+      schemaType: SCHEMA_TYPES.COMPLEX,
+      type: SCHEMA_TYPES.PRIMITIVE,
+      typeIdentifier: this.config.Ts.Keyword.Type,
+      name: this.typeName,
+      description: this.schemaFormatters.formatDescription(
+        this.schema.description ||
+          _.compact(_.map(this.schema[complexType], 'description'))[0] ||
+          '',
+      ),
+      content:
+        this.config.Ts.IntersectionType(
+          _.compact([
+            this.config.Ts.ExpressionGroup(complexSchemaContent),
+            this.schemaUtils.getInternalSchemaType(simpleSchema) ===
+              SCHEMA_TYPES.OBJECT &&
+              this.config.Ts.ExpressionGroup(
+                this.schemaParserFabric
+                  .createSchemaParser({
+                    schema: simpleSchema,
+                    schemaPath: this.schemaPath,
+                  })
+                  .getInlineParseContent(),
+              ),
+          ]),
+        ) || this.config.Ts.Keyword.Any,
+    };
+  }
+}
+
+module.exports = {
+  ComplexSchemaParser,
+};

package/src/schema-parser/base-schema-parsers/discriminator.js

@@ -0,0 +1,301 @@
+const _ = require('lodash');
+const { SCHEMA_TYPES } = require('../../constants');
+const { MonoSchemaParser } = require('../mono-schema-parser');
+
+class DiscriminatorSchemaParser extends MonoSchemaParser {
+  parse() {
+    const { discriminator, ...noDiscriminatorSchema } = this.schema;
+
+    if (!discriminator.mapping) {
+      return this.schemaParserFabric
+        .createSchemaParser({
+          schema: noDiscriminatorSchema,
+          typeName: this.typeName,
+          schemaPath: this.schemaPath,
+        })
+        .parseSchema();
+    }
+
+    // https://github.com/acacode/swagger-typescript-api/issues/456
+    // const skipMappingType = !!noDiscriminatorSchema.oneOf;
+    const skipMappingType = false;
+
+    const abstractSchemaStruct = this.createAbstractSchemaStruct();
+    // const complexSchemaStruct = this.createComplexSchemaStruct();
+    const discriminatorSchemaStruct = this.createDiscriminatorSchema({
+      skipMappingType,
+      abstractSchemaStruct,
+    });
+
+    const schemaContent = this.config.Ts.IntersectionType(
+      [
+        abstractSchemaStruct?.content,
+        discriminatorSchemaStruct?.content,
+      ].filter(Boolean),
+    );
+
+    return {
+      ...(_.isObject(this.schema) ? this.schema : {}),
+      $schemaPath: this.schemaPath.slice(),
+      $parsedSchema: true,
+      schemaType: SCHEMA_TYPES.COMPLEX,
+      type: SCHEMA_TYPES.PRIMITIVE,
+      typeIdentifier: this.config.Ts.Keyword.Type,
+      name: this.typeName,
+      description: this.schemaFormatters.formatDescription(
+        this.schema.description,
+      ),
+      content: schemaContent,
+    };
+  }
+
+  createDiscriminatorSchema = ({ skipMappingType, abstractSchemaStruct }) => {
+    const refPath = this.schemaComponentsMap.createRef([
+      'components',
+      'schemas',
+      this.typeName,
+    ]);
+    const { discriminator } = this.schema;
+    const mappingEntries = _.entries(discriminator.mapping);
+    const ableToCreateMappingType =
+      !skipMappingType &&
+      !!(abstractSchemaStruct?.typeName && mappingEntries.length);
+    const mappingContents = [];
+    let mappingTypeName;
+
+    /** { mapping_key: SchemaEnum.MappingKey, ... } */
+    const mappingPropertySchemaEnumKeysMap =
+      this.createMappingPropertySchemaEnumKeys({
+        abstractSchemaStruct,
+        discPropertyName: discriminator.propertyName,
+      });
+
+    if (ableToCreateMappingType) {
+      mappingTypeName = this.schemaUtils.resolveTypeName(
+        `${abstractSchemaStruct.typeName} ${discriminator.propertyName}`,
+        {
+          suffixes: this.config.extractingOptions.discriminatorMappingSuffix,
+          resolver:
+            this.config.extractingOptions.discriminatorMappingNameResolver,
+        },
+      );
+      this.schemaParserFabric.createSchema({
+        linkedComponent: this.schemaComponentsMap.createComponent(
+          this.schemaComponentsMap.createRef([
+            'components',
+            'schemas',
+            mappingTypeName,
+          ]),
+        ),
+        content: this.config.Ts.IntersectionType([
+          this.config.Ts.ObjectWrapper(
+            this.config.Ts.TypeField({
+              key: discriminator.propertyName,
+              value: 'Key',
+            }),
+          ),
+          'Type',
+        ]),
+        genericArgs: [{ name: 'Key' }, { name: 'Type' }],
+        internal: true,
+      });
+    }
+
+    /** returns (GenericType<"mapping_key", MappingType>) or ({ discriminatorProperty: "mapping_key" } & MappingType) */
+    const createMappingContent = (mappingSchema, mappingKey) => {
+      const content = this.schemaParserFabric
+        .createSchemaParser({
+          schema: mappingSchema,
+          schemaPath: this.schemaPath,
+        })
+        .getInlineParseContent();
+
+      const mappingUsageKey =
+        mappingPropertySchemaEnumKeysMap[mappingKey] ||
+        this.config.Ts.StringValue(mappingKey);
+
+      if (ableToCreateMappingType) {
+        return this.config.Ts.TypeWithGeneric(mappingTypeName, [
+          mappingUsageKey,
+          content,
+        ]);
+      } else {
+        return this.config.Ts.ExpressionGroup(
+          this.config.Ts.IntersectionType([
+            this.config.Ts.ObjectWrapper(
+              this.config.Ts.TypeField({
+                key: discriminator.propertyName,
+                value: mappingUsageKey,
+              }),
+            ),
+            content,
+          ]),
+        );
+      }
+    };
+
+    for (const [mappingKey, schema] of mappingEntries) {
+      const mappingSchema =
+        typeof schema === 'string' ? { $ref: schema } : schema;
+
+      this.mutateMappingDependentSchema({
+        discPropertyName: discriminator.propertyName,
+        abstractSchemaStruct,
+        mappingSchema,
+        refPath,
+        mappingPropertySchemaEnumKeysMap,
+      });
+
+      mappingContents.push(createMappingContent(mappingSchema, mappingKey));
+    }
+
+    if (skipMappingType) return null;
+
+    const content = this.config.Ts.ExpressionGroup(
+      this.config.Ts.UnionType(mappingContents),
+    );
+
+    return {
+      content,
+    };
+  };
+
+  createMappingPropertySchemaEnumKeys = ({
+    abstractSchemaStruct,
+    discPropertyName,
+  }) => {
+    let mappingPropertySchemaEnumKeysMap = {};
+    let mappingPropertySchema = _.get(
+      abstractSchemaStruct?.component?.rawTypeData,
+      ['properties', discPropertyName],
+    );
+    if (this.schemaUtils.isRefSchema(mappingPropertySchema)) {
+      mappingPropertySchema = this.schemaUtils.getSchemaRefType(
+        mappingPropertySchema,
+      );
+    }
+
+    if (
+      mappingPropertySchema?.rawTypeData?.$parsed?.type === SCHEMA_TYPES.ENUM
+    ) {
+      mappingPropertySchemaEnumKeysMap = _.reduce(
+        mappingPropertySchema.rawTypeData.$parsed.enum,
+        (acc, key, index) => {
+          const enumKey =
+            mappingPropertySchema.rawTypeData.$parsed.content[index].key;
+          acc[key] = this.config.Ts.EnumUsageKey(
+            mappingPropertySchema.rawTypeData.$parsed.typeName,
+            enumKey,
+          );
+          return acc;
+        },
+        {},
+      );
+    }
+
+    return mappingPropertySchemaEnumKeysMap;
+  };
+
+  mutateMappingDependentSchema = ({
+    discPropertyName,
+    abstractSchemaStruct,
+    mappingSchema,
+    refPath,
+    mappingPropertySchemaEnumKeysMap,
+  }) => {
+    const complexSchemaKeys = _.keys(this.schemaParser._complexSchemaParsers);
+    // override parent dependencies
+    if (mappingSchema.$ref && abstractSchemaStruct?.component?.$ref) {
+      const mappingRefSchema =
+        this.schemaUtils.getSchemaRefType(mappingSchema)?.rawTypeData;
+      if (mappingRefSchema) {
+        complexSchemaKeys.forEach((schemaKey) => {
+          if (_.isArray(mappingRefSchema[schemaKey])) {
+            mappingRefSchema[schemaKey] = mappingRefSchema[schemaKey].map(
+              (schema) => {
+                if (schema.$ref === refPath) {
+                  return {
+                    ...schema,
+                    $ref: abstractSchemaStruct.component.$ref,
+                  };
+                }
+                if (
+                  this.schemaUtils.getInternalSchemaType(schema) ===
+                  SCHEMA_TYPES.OBJECT
+                ) {
+                  for (const schemaPropertyName in schema.properties) {
+                    const schemaProperty =
+                      schema.properties[schemaPropertyName];
+                    if (
+                      schemaPropertyName === discPropertyName &&
+                      this.schemaUtils.getInternalSchemaType(schemaProperty) ===
+                        SCHEMA_TYPES.ENUM &&
+                      schemaProperty.enum.length === 1 &&
+                      mappingPropertySchemaEnumKeysMap[schemaProperty.enum[0]]
+                    ) {
+                      schema.properties[schemaPropertyName] =
+                        this.schemaParserFabric.createSchema({
+                          content:
+                            mappingPropertySchemaEnumKeysMap[
+                              schemaProperty.enum[0]
+                            ],
+                        });
+                    }
+                  }
+                }
+                return schema;
+              },
+            );
+          }
+        });
+      }
+    }
+  };
+
+  createAbstractSchemaStruct = () => {
+    // eslint-disable-next-line no-unused-vars
+    const { discriminator, ...noDiscriminatorSchema } = this.schema;
+    const complexSchemaKeys = _.keys(this.schemaParser._complexSchemaParsers);
+    const schema = _.omit(_.clone(noDiscriminatorSchema), complexSchemaKeys);
+    const schemaIsEmpty = !_.keys(schema).length;
+
+    if (schemaIsEmpty) return null;
+
+    const typeName = this.schemaUtils.resolveTypeName(this.typeName, {
+      prefixes: this.config.extractingOptions.discriminatorAbstractPrefix,
+      resolver: this.config.extractingOptions.discriminatorAbstractResolver,
+    });
+    const component = this.schemaComponentsMap.createComponent(
+      this.schemaComponentsMap.createRef(['components', 'schemas', typeName]),
+      {
+        ...schema,
+        internal: true,
+      },
+    );
+    const content = this.schemaParserFabric
+      .createSchemaParser({ schema: component, schemaPath: this.schemaPath })
+      .getInlineParseContent();
+
+    return {
+      typeName,
+      component,
+      content,
+    };
+  };
+
+  createComplexSchemaStruct = () => {
+    const complexType = this.schemaUtils.getComplexType(this.schema);
+
+    if (complexType === SCHEMA_TYPES.COMPLEX_UNKNOWN) return null;
+
+    return {
+      content: this.config.Ts.ExpressionGroup(
+        this.schemaParser._complexSchemaParsers[complexType](this.schema),
+      ),
+    };
+  };
+}
+
+module.exports = {
+  DiscriminatorSchemaParser,
+};

package/src/schema-parser/base-schema-parsers/enum.js

@@ -0,0 +1,158 @@
+const { MonoSchemaParser } = require('../mono-schema-parser');
+const _ = require('lodash');
+const { SCHEMA_TYPES } = require('../../constants');
+const { EnumKeyResolver } = require('../util/enum-key-resolver');
+
+class EnumSchemaParser extends MonoSchemaParser {
+  /** @type {EnumKeyResolver} */
+  enumKeyResolver;
+
+  constructor(...args) {
+    super(...args);
+    this.enumKeyResolver = new EnumKeyResolver(this.config, this.logger, []);
+  }
+
+  extractEnum = (pathTypeName) => {
+    const generatedTypeName = this.schemaUtils.resolveTypeName(pathTypeName, {
+      suffixes: this.config.extractingOptions.enumSuffix,
+      resolver: this.config.extractingOptions.enumNameResolver,
+    });
+    const customComponent = this.schemaComponentsMap.createComponent(
+      this.schemaComponentsMap.createRef([
+        'components',
+        'schemas',
+        generatedTypeName,
+      ]),
+      {
+        ...this.schema,
+      },
+    );
+    return this.schemaParserFabric.parseSchema(customComponent);
+  };
+
+  parse() {
+    const pathTypeName = this.buildTypeNameFromPath();
+
+    if (this.config.extractEnums && !this.typeName && pathTypeName != null) {
+      return this.extractEnum(pathTypeName);
+    }
+
+    const refType = this.schemaUtils.getSchemaRefType(this.schema);
+    const $ref = (refType && refType.$ref) || null;
+
+    // fix schema when enum has length 1+ but value is []
+    if (Array.isArray(this.schema.enum)) {
+      this.schema.enum = this.schema.enum.filter((key) => key != null);
+    }
+
+    if (Array.isArray(this.schema.enum) && Array.isArray(this.schema.enum[0])) {
+      return this.schemaParserFabric.parseSchema(
+        {
+          oneOf: this.schema.enum.map((enumNames) => ({
+            type: 'array',
+            items: enumNames.map((enumName) => ({
+              type: 'string',
+              enum: [enumName],
+            })),
+          })),
+        },
+        this.typeName,
+        this.schemaPath,
+      );
+    }
+
+    const keyType = this.schemaUtils.getSchemaType(this.schema);
+    const enumNames = this.schemaUtils.getEnumNames(this.schema);
+    let content = null;
+
+    const formatValue = (value) => {
+      if (value === null) {
+        return this.config.Ts.NullValue(value);
+      }
+      if (
+        _.includes(keyType, this.schemaUtils.getSchemaType({ type: 'number' }))
+      ) {
+        return this.config.Ts.NumberValue(value);
+      }
+      if (
+        _.includes(keyType, this.schemaUtils.getSchemaType({ type: 'boolean' }))
+      ) {
+        return this.config.Ts.BooleanValue(value);
+      }
+
+      return this.config.Ts.StringValue(value);
+    };
+
+    if (_.isArray(enumNames) && _.size(enumNames)) {
+      content = _.map(enumNames, (enumName, index) => {
+        const enumValue = _.get(this.schema.enum, index);
+        const formattedKey = this.formatEnumKey({
+          key: enumName,
+          value: enumValue,
+        });
+
+        if (this.config.enumNamesAsValues || _.isUndefined(enumValue)) {
+          return {
+            key: formattedKey,
+            type: this.config.Ts.Keyword.String,
+            value: this.config.Ts.StringValue(enumName),
+          };
+        }
+
+        return {
+          key: formattedKey,
+          type: keyType,
+          value: formatValue(enumValue),
+        };
+      });
+    } else {
+      content = _.map(this.schema.enum, (value) => {
+        return {
+          key: this.formatEnumKey({ value }),
+          type: keyType,
+          value: formatValue(value),
+        };
+      });
+    }
+
+    return {
+      ...(_.isObject(this.schema) ? this.schema : {}),
+      $ref: $ref,
+      typeName: this.typeName || ($ref && refType.typeName) || null,
+      $parsedSchema: true,
+      schemaType: SCHEMA_TYPES.ENUM,
+      type: SCHEMA_TYPES.ENUM,
+      keyType: keyType,
+      typeIdentifier: this.config.generateUnionEnums
+        ? this.config.Ts.Keyword.Type
+        : this.config.Ts.Keyword.Enum,
+      name: this.typeName,
+      description: this.schemaFormatters.formatDescription(
+        this.schema.description,
+      ),
+      content,
+    };
+  }
+
+  formatEnumKey = ({ key, value }) => {
+    let formatted;
+
+    if (key) {
+      formatted = this.typeNameFormatter.format(key, {
+        type: 'enum-key',
+      });
+    }
+
+    if (!formatted) {
+      formatted = this.typeNameFormatter.format(`${value}`, {
+        type: 'enum-key',
+      });
+    }
+
+    return this.enumKeyResolver.resolve([formatted]);
+  };
+}
+
+module.exports = {
+  EnumSchemaParser,
+};

package/src/schema-parser/base-schema-parsers/object.js

@@ -0,0 +1,105 @@
+const { MonoSchemaParser } = require('../mono-schema-parser');
+const _ = require('lodash');
+const { SCHEMA_TYPES } = require('../../constants');
+
+class ObjectSchemaParser extends MonoSchemaParser {
+  parse() {
+    const contentProperties = this.getObjectSchemaContent(this.schema);
+
+    return {
+      ...(_.isObject(this.schema) ? this.schema : {}),
+      $schemaPath: this.schemaPath.slice(),
+      $parsedSchema: true,
+      schemaType: SCHEMA_TYPES.OBJECT,
+      type: SCHEMA_TYPES.OBJECT,
+      typeIdentifier: this.config.Ts.Keyword.Interface,
+      name: this.typeName,
+      description: this.schemaFormatters.formatDescription(
+        this.schema.description,
+      ),
+      allFieldsAreOptional: !_.some(
+        _.values(contentProperties),
+        (part) => part.isRequired,
+      ),
+      content: contentProperties,
+    };
+  }
+
+  getObjectSchemaContent = (schema) => {
+    const { properties, additionalProperties } = schema || {};
+
+    const propertiesContent = _.map(properties, (property, 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 = this.schemaParserFabric
+        .createSchemaParser({
+          schema: property,
+          schemaPath: [...this.schemaPath, name],
+        })
+        .getInlineParseContent();
+      const readOnly = property.readOnly;
+
+      return {
+        ...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) {
+      propertiesContent.push({
+        $$raw: { additionalProperties },
+        description: '',
+        isRequired: false,
+        field: this.config.Ts.InterfaceDynamicField(
+          this.config.Ts.Keyword.String,
+          this.config.Ts.Keyword.Any,
+        ),
+      });
+    }
+
+    return propertiesContent;
+  };
+}
+
+module.exports = {
+  ObjectSchemaParser,
+};

package/src/schema-parser/base-schema-parsers/primitive.js

@@ -0,0 +1,63 @@
+const { MonoSchemaParser } = require('../mono-schema-parser');
+const _ = require('lodash');
+const { SCHEMA_TYPES } = require('../../constants');
+
+class PrimitiveSchemaParser extends MonoSchemaParser {
+  parse() {
+    let contentType = null;
+    const { additionalProperties, type, description, items } =
+      this.schema || {};
+
+    if (type === this.config.Ts.Keyword.Object && additionalProperties) {
+      const fieldType = _.isObject(additionalProperties)
+        ? this.schemaParserFabric
+            .createSchemaParser({
+              schema: additionalProperties,
+              schemaPath: this.schemaPath,
+            })
+            .getInlineParseContent()
+        : this.config.Ts.Keyword.Any;
+      contentType = this.config.Ts.RecordType(
+        this.config.Ts.Keyword.String,
+        fieldType,
+      );
+    }
+
+    if (_.isArray(type) && type.length) {
+      contentType = this.schemaParser._complexSchemaParsers.oneOf({
+        ...(_.isObject(this.schema) ? this.schema : {}),
+        oneOf: type.map((type) => ({ type })),
+      });
+    }
+
+    if (_.isArray(items) && type === SCHEMA_TYPES.ARRAY) {
+      contentType = this.config.Ts.Tuple(
+        items.map((item) =>
+          this.schemaParserFabric
+            .createSchemaParser({ schema: item, schemaPath: this.schemaPath })
+            .getInlineParseContent(),
+        ),
+      );
+    }
+
+    return {
+      ...(_.isObject(this.schema) ? this.schema : {}),
+      $schemaPath: this.schemaPath.slice(),
+      $parsedSchema: true,
+      schemaType: SCHEMA_TYPES.PRIMITIVE,
+      type: SCHEMA_TYPES.PRIMITIVE,
+      typeIdentifier: this.config.Ts.Keyword.Type,
+      name: this.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.schemaUtils.getSchemaType(this.schema),
+    };
+  }
+}
+
+module.exports = {
+  PrimitiveSchemaParser,
+};

package/src/schema-parser/complex-schema-parsers/all-of.js

@@ -0,0 +1,26 @@
+const { MonoSchemaParser } = require('../mono-schema-parser');
+const _ = require('lodash');
+
+// T1 & T2
+class AllOfSchemaParser extends MonoSchemaParser {
+  parse() {
+    const ignoreTypes = [this.config.Ts.Keyword.Any];
+    const combined = _.map(this.schema.allOf, (childSchema) =>
+      this.schemaParserFabric.getInlineParseContent(
+        this.schemaUtils.makeAddRequiredToChildSchema(this.schema, childSchema),
+        null,
+        this.schemaPath,
+      ),
+    );
+    const filtered = this.schemaUtils.filterSchemaContents(
+      combined,
+      (content) => !ignoreTypes.includes(content),
+    );
+
+    const type = this.config.Ts.IntersectionType(filtered);
+
+    return this.schemaUtils.safeAddNullToType(this.schema, type);
+  }
+}
+
+module.exports = { AllOfSchemaParser };