swagger-typescript-api 13.0.9 → 13.0.11

package/src/constants.js

@@ -1,77 +0,0 @@
-import { createRequire } from "node:module";
-
-const require = createRequire(import.meta.url);
-const packageJson = require("../package.json");
-
-const DEFAULT_BODY_ARG_NAME = "data";
-
-const FILE_PREFIX = `/* eslint-disable */
-/* tslint:disable */
-/*
- * ---------------------------------------------------------------
- * ## THIS FILE WAS GENERATED VIA SWAGGER-TYPESCRIPT-API        ##
- * ##                                                           ##
- * ## AUTHOR: acacode                                           ##
- * ## SOURCE: https://github.com/acacode/swagger-typescript-api ##
- * ---------------------------------------------------------------
- */
-
-`;
-
-const HTTP_CLIENT = {
-  FETCH: "fetch",
-  AXIOS: "axios",
-};
-
-const PRETTIER_OPTIONS = {
-  printWidth: 120,
-  tabWidth: 2,
-  trailingComma: "all",
-  parser: "typescript",
-};
-
-const PROJECT_VERSION = packageJson.version;
-
-const RESERVED_BODY_ARG_NAMES = ["data", "body", "reqBody"];
-
-const RESERVED_HEADER_ARG_NAMES = ["headers", "headersParams"];
-
-const RESERVED_PATH_ARG_NAMES = ["path", "pathParams"];
-
-const RESERVED_QUERY_ARG_NAMES = ["query", "queryParams", "queryArg"];
-
-const RESERVED_REQ_PARAMS_ARG_NAMES = [
-  "params",
-  "requestParams",
-  "reqParams",
-  "httpParams",
-];
-
-const SCHEMA_TYPES = {
-  ARRAY: "array",
-  OBJECT: "object",
-  ENUM: "enum",
-  REF: "$ref",
-  PRIMITIVE: "primitive",
-  COMPLEX: "complex",
-  DISCRIMINATOR: "discriminator",
-  COMPLEX_ONE_OF: "oneOf",
-  COMPLEX_ANY_OF: "anyOf",
-  COMPLEX_ALL_OF: "allOf",
-  COMPLEX_NOT: "not",
-  COMPLEX_UNKNOWN: "__unknown",
-};
-
-export {
-  DEFAULT_BODY_ARG_NAME,
-  FILE_PREFIX,
-  HTTP_CLIENT,
-  PRETTIER_OPTIONS,
-  PROJECT_VERSION,
-  RESERVED_BODY_ARG_NAMES,
-  RESERVED_HEADER_ARG_NAMES,
-  RESERVED_PATH_ARG_NAMES,
-  RESERVED_QUERY_ARG_NAMES,
-  RESERVED_REQ_PARAMS_ARG_NAMES,
-  SCHEMA_TYPES,
-};

package/src/index.js

@@ -1,16 +0,0 @@
-#!/usr/bin/env node
-
-import { CodeGenProcess } from "./code-gen-process.js";
-import { generateTemplates } from "./commands/generate-templates/index.js";
-import * as constants from "./constants.js";
-
-async function generateApi({ name, prettier, ...config }) {
-  const codeGenProcess = new CodeGenProcess({
-    ...config,
-    fileName: name,
-    prettierOptions: prettier,
-  });
-  return await codeGenProcess.start();
-}
-
-export { constants, generateApi, generateTemplates };

package/src/schema-components-map.js

@@ -1,76 +0,0 @@
-import _ from "lodash";
-
-class SchemaComponentsMap {
-  /** @type {SchemaComponent[]} */
-  _data = [];
-  /** @type {CodeGenConfig} */
-  config;
-
-  constructor({ config }) {
-    this.config = config;
-  }
-
-  clear() {
-    this._data = [];
-  }
-
-  createRef = (paths) => {
-    return ["#", ...paths].join("/");
-  };
-
-  parseRef = (ref) => {
-    return ref.split("/");
-  };
-
-  createComponent($ref, rawTypeData) {
-    const parsed = this.parseRef($ref);
-    const typeName = parsed[parsed.length - 1];
-    const componentName = parsed[parsed.length - 2];
-    const componentSchema = {
-      $ref,
-      typeName,
-      rawTypeData,
-      componentName,
-      /** result from schema parser */
-      typeData: null,
-    };
-
-    const usageComponent =
-      this.config.hooks.onCreateComponent(componentSchema) || componentSchema;
-
-    const refIndex = this._data.findIndex((c) => c.$ref === $ref);
-
-    if (refIndex === -1) {
-      this._data.push(usageComponent);
-    } else {
-      this._data[refIndex] = usageComponent;
-    }
-
-    return usageComponent;
-  }
-
-  /**
-   * @returns {SchemaComponent[]}
-   */
-  getComponents() {
-    return this._data;
-  }
-
-  /**
-   * @params {...string[]} componentNames
-   * @returns {SchemaComponent[]}
-   */
-  filter(...componentNames) {
-    return _.filter(this._data, (it) =>
-      componentNames.some((componentName) =>
-        _.startsWith(it.$ref, `#/components/${componentName}`),
-      ),
-    );
-  }
-
-  get($ref) {
-    return this._data.find((c) => c.$ref === $ref) || null;
-  }
-}
-
-export { SchemaComponentsMap };

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

@@ -1,41 +0,0 @@
-import _ from "lodash";
-import { SCHEMA_TYPES } from "../../constants.js";
-import { MonoSchemaParser } from "../mono-schema-parser.js";
-
-class ArraySchemaParser extends MonoSchemaParser {
-  parse() {
-    let contentType;
-    const { type, description, items } = this.schema || {};
-
-    if (_.isArray(items) && type === SCHEMA_TYPES.ARRAY) {
-      const tupleContent = [];
-      for (const item of items) {
-        tupleContent.push(
-          this.schemaParserFabric
-            .createSchemaParser({ schema: item, schemaPath: this.schemaPath })
-            .getInlineParseContent(),
-        );
-      }
-      contentType = this.config.Ts.Tuple(tupleContent);
-    } else {
-      const content = this.schemaParserFabric
-        .createSchemaParser({ schema: items, schemaPath: this.schemaPath })
-        .getInlineParseContent();
-      contentType = this.config.Ts.ArrayType(content);
-    }
-
-    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),
-      content: this.schemaUtils.safeAddNullToType(this.schema, contentType),
-    };
-  }
-}
-
-export { ArraySchemaParser };

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

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

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

@@ -1,305 +0,0 @@
-import _ from "lodash";
-import { SCHEMA_TYPES } from "../../constants.js";
-import { MonoSchemaParser } from "../mono-schema-parser.js";
-
-class DiscriminatorSchemaParser extends MonoSchemaParser {
-  parse() {
-    const ts = this.config.Ts;
-    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 = 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: ts.Keyword.Type,
-      name: this.typeName,
-      description: this.schemaFormatters.formatDescription(
-        this.schema.description,
-      ),
-      content: schemaContent,
-    };
-  }
-
-  createDiscriminatorSchema = ({ skipMappingType, abstractSchemaStruct }) => {
-    const ts = this.config.Ts;
-
-    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) {
-      const rawTypeName = `${abstractSchemaStruct.typeName}_${discriminator.propertyName}`;
-      const generatedTypeName = this.schemaUtils.resolveTypeName(rawTypeName, {
-        suffixes: this.config.extractingOptions.discriminatorMappingSuffix,
-        resolver:
-          this.config.extractingOptions.discriminatorMappingNameResolver,
-      });
-
-      const content = ts.IntersectionType([
-        ts.ObjectWrapper(
-          ts.TypeField({
-            key: ts.StringValue(discriminator.propertyName),
-            value: "Key",
-          }),
-        ),
-        "Type",
-      ]);
-
-      const component = this.schemaParserFabric.createParsedComponent({
-        typeName: generatedTypeName,
-        schema: {
-          type: "object",
-          properties: {},
-          genericArgs: [{ name: "Key" }, { name: "Type" }],
-          internal: true,
-        },
-      });
-
-      component.typeData.content = content;
-
-      mappingTypeName = this.typeNameFormatter.format(component.typeName);
-    }
-
-    /** 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] ||
-        ts.StringValue(mappingKey);
-
-      if (ableToCreateMappingType) {
-        return ts.TypeWithGeneric(mappingTypeName, [mappingUsageKey, content]);
-      } else {
-        return ts.ExpressionGroup(
-          ts.IntersectionType([
-            ts.ObjectWrapper(
-              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 = ts.ExpressionGroup(ts.UnionType(mappingContents));
-
-    return {
-      content,
-    };
-  };
-
-  createMappingPropertySchemaEnumKeys = ({
-    abstractSchemaStruct,
-    discPropertyName,
-  }) => {
-    const ts = this.config.Ts;
-
-    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] = 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 schemaIsAny =
-      this.schemaParserFabric.getInlineParseContent(_.cloneDeep(schema)) ===
-      this.config.Ts.Keyword.Any;
-    const schemaIsEmpty = !_.keys(schema).length;
-
-    if (schemaIsEmpty || schemaIsAny) 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 ts = this.config.Ts;
-    const complexType = this.schemaUtils.getComplexType(this.schema);
-
-    if (complexType === SCHEMA_TYPES.COMPLEX_UNKNOWN) return null;
-
-    return {
-      content: ts.ExpressionGroup(
-        this.schemaParser._complexSchemaParsers[complexType](this.schema),
-      ),
-    };
-  };
-}
-
-export { DiscriminatorSchemaParser };