swagger-typescript-api 13.0.9 → 13.0.10

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

@@ -1,156 +0,0 @@
-import _ from "lodash";
-import { SCHEMA_TYPES } from "../../constants.js";
-import { MonoSchemaParser } from "../mono-schema-parser.js";
-import { EnumKeyResolver } from "../util/enum-key-resolver.js";
-
-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?.$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]);
-  };
-}
-
-export { EnumSchemaParser };

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

@@ -1,103 +0,0 @@
-import _ from "lodash";
-import { SCHEMA_TYPES } from "../../constants.js";
-import { MonoSchemaParser } from "../mono-schema-parser.js";
-
-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;
-  };
-}
-
-export { ObjectSchemaParser };

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

@@ -1,61 +0,0 @@
-import _ from "lodash";
-import { SCHEMA_TYPES } from "../../constants.js";
-import { MonoSchemaParser } from "../mono-schema-parser.js";
-
-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),
-    };
-  }
-}
-
-export { PrimitiveSchemaParser };

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

@@ -1,26 +0,0 @@
-import _ from "lodash";
-import { MonoSchemaParser } from "../mono-schema-parser.js";
-
-// 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);
-  }
-}
-
-export { AllOfSchemaParser };

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

@@ -1,27 +0,0 @@
-import _ from "lodash";
-import { MonoSchemaParser } from "../mono-schema-parser.js";
-
-// T1 | T2
-class AnyOfSchemaParser extends MonoSchemaParser {
-  parse() {
-    const ignoreTypes = [this.config.Ts.Keyword.Any];
-    const combined = _.map(this.schema.anyOf, (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.UnionType(filtered);
-
-    return this.schemaUtils.safeAddNullToType(this.schema, type);
-  }
-}
-
-export { AnyOfSchemaParser };

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

@@ -1,9 +0,0 @@
-import { MonoSchemaParser } from "../mono-schema-parser.js";
-
-class NotSchemaParser extends MonoSchemaParser {
-  parse() {
-    return this.config.Ts.Keyword.Any;
-  }
-}
-
-export { NotSchemaParser };

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

@@ -1,27 +0,0 @@
-import _ from "lodash";
-import { MonoSchemaParser } from "../mono-schema-parser.js";
-
-// T1 | T2
-class OneOfSchemaParser extends MonoSchemaParser {
-  parse() {
-    const ignoreTypes = [this.config.Ts.Keyword.Any];
-    const combined = _.map(this.schema.oneOf, (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.UnionType(filtered);
-
-    return this.schemaUtils.safeAddNullToType(this.schema, type);
-  }
-}
-
-export { OneOfSchemaParser };

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

@@ -1,46 +0,0 @@
-class MonoSchemaParser {
-  schema;
-  typeName;
-  schemaPath;
-
-  /** @type {Logger} */
-  logger;
-  /** @type {SchemaParser} */
-  schemaParser;
-  /** @type {SchemaParserFabric} */
-  schemaParserFabric;
-  /** @type {TypeNameFormatter} */
-  typeNameFormatter;
-  /** @type {SchemaComponentsMap} */
-  schemaComponentsMap;
-  /** @type {SchemaUtils} */
-  schemaUtils;
-  /** @type {CodeGenConfig} */
-  config;
-  /** @type {SchemaFormatters} */
-  schemaFormatters;
-
-  constructor(schemaParser, schema, typeName = null, schemaPath = []) {
-    this.schemaParser = schemaParser;
-    this.schemaParserFabric = schemaParser.schemaParserFabric;
-    this.logger = schemaParser.logger;
-    this.schema = schema;
-    this.typeName = typeName;
-    this.typeNameFormatter = schemaParser.typeNameFormatter;
-    this.schemaPath = schemaPath;
-    this.schemaComponentsMap = this.schemaParser.schemaComponentsMap;
-    this.schemaUtils = this.schemaParser.schemaUtils;
-    this.config = this.schemaParser.config;
-    this.schemaFormatters = this.schemaParser.schemaFormatters;
-  }
-
-  parse() {
-    throw new Error("not implemented");
-  }
-
-  buildTypeNameFromPath = () => {
-    return this.schemaUtils.buildTypeNameFromPath(this.schemaPath);
-  };
-}
-
-export { MonoSchemaParser };

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

@@ -1,164 +0,0 @@
-import _ from "lodash";
-import { SCHEMA_TYPES } from "../constants.js";
-
-class SchemaFormatters {
-  /** @type {CodeGenConfig} */
-  config;
-  /** @type {Logger} */
-  logger;
-  /** @type {TemplatesWorker} */
-  templatesWorker;
-  /** @type {SchemaUtils} */
-  schemaUtils;
-
-  /**
-   * @param schemaParser {SchemaParser | SchemaParserFabric}
-   */
-  constructor(schemaParser) {
-    this.config = schemaParser.config;
-    this.logger = schemaParser.logger;
-    this.schemaUtils = schemaParser.schemaUtils;
-    this.templatesWorker = schemaParser.templatesWorker;
-  }
-
-  base = {
-    [SCHEMA_TYPES.ENUM]: (parsedSchema) => {
-      if (this.config.generateUnionEnums) {
-        return {
-          ...parsedSchema,
-          $content: parsedSchema.content,
-          content: this.config.Ts.UnionType(
-            _.map(parsedSchema.content, ({ value }) => value),
-          ),
-        };
-      }
-
-      return {
-        ...parsedSchema,
-        $content: parsedSchema.content,
-        content: this.config.Ts.EnumFieldsWrapper(parsedSchema.content),
-      };
-    },
-    [SCHEMA_TYPES.OBJECT]: (parsedSchema) => {
-      if (parsedSchema.nullable)
-        return this.inline[SCHEMA_TYPES.OBJECT](parsedSchema);
-      return {
-        ...parsedSchema,
-        $content: parsedSchema.content,
-        content: this.formatObjectContent(parsedSchema.content),
-      };
-    },
-    [SCHEMA_TYPES.PRIMITIVE]: (parsedSchema) => {
-      return {
-        ...parsedSchema,
-        $content: parsedSchema.content,
-      };
-    },
-  };
-  inline = {
-    [SCHEMA_TYPES.ENUM]: (parsedSchema) => {
-      return {
-        ...parsedSchema,
-        content: parsedSchema.$ref
-          ? parsedSchema.typeName
-          : this.config.Ts.UnionType(
-              _.compact([
-                ..._.map(parsedSchema.content, ({ value }) => `${value}`),
-                parsedSchema.nullable && this.config.Ts.Keyword.Null,
-              ]),
-            ) || this.config.Ts.Keyword.Any,
-      };
-    },
-    [SCHEMA_TYPES.OBJECT]: (parsedSchema) => {
-      if (_.isString(parsedSchema.content)) {
-        return {
-          ...parsedSchema,
-          typeIdentifier: this.config.Ts.Keyword.Type,
-          content: this.schemaUtils.safeAddNullToType(parsedSchema.content),
-        };
-      }
-
-      return {
-        ...parsedSchema,
-        typeIdentifier: this.config.Ts.Keyword.Type,
-        content: this.schemaUtils.safeAddNullToType(
-          parsedSchema,
-          parsedSchema.content.length
-            ? this.config.Ts.ObjectWrapper(
-                this.formatObjectContent(parsedSchema.content),
-              )
-            : this.config.Ts.RecordType(
-                this.config.Ts.Keyword.String,
-                this.config.Ts.Keyword.Any,
-              ),
-        ),
-      };
-    },
-  };
-
-  /**
-   * @param parsedSchema {Record<string, any>}
-   * @param formatType {"base" | "inline"}
-   */
-  formatSchema = (parsedSchema, formatType = "base") => {
-    const schemaType =
-      _.get(parsedSchema, ["schemaType"]) ||
-      _.get(parsedSchema, ["$parsed", "schemaType"]);
-    const formatterFn = _.get(this, [formatType, schemaType]);
-    return formatterFn?.(parsedSchema) || parsedSchema;
-  };
-
-  formatDescription = (description, inline) => {
-    if (!description) return "";
-
-    let prettified = description;
-
-    prettified = _.replace(prettified, /\*\//g, "*/");
-
-    const hasMultipleLines = _.includes(prettified, "\n");
-
-    if (!hasMultipleLines) return prettified;
-
-    if (inline) {
-      return _(prettified)
-        .split(/\n/g)
-        .map((part) => _.trim(part))
-        .compact()
-        .join(" ")
-        .valueOf();
-    }
-
-    return _.replace(prettified, /\n$/g, "");
-  };
-
-  formatObjectContent = (content) => {
-    const fields = [];
-
-    for (const part of content) {
-      const extraSpace = "  ";
-      const result = `${extraSpace}${part.field},\n`;
-
-      const renderedJsDoc = this.templatesWorker.renderTemplate(
-        this.config.templatesToRender.dataContractJsDoc,
-        {
-          data: part,
-        },
-      );
-
-      const routeNameFromTemplate = renderedJsDoc
-        .split("\n")
-        .map((c) => `${extraSpace}${c}`)
-        .join("\n");
-
-      if (routeNameFromTemplate) {
-        fields.push(`${routeNameFromTemplate}${result}`);
-      } else {
-        fields.push(`${result}`);
-      }
-    }
-
-    return fields.join("");
-  };
-}
-
-export { SchemaFormatters };