swagger-typescript-api 10.0.3 → 11.0.0--alpha

package/src/configuration.js

@@ -0,0 +1,425 @@
+const { objectAssign } = require("./util/object-assign");
+const _ = require("lodash");
+const constantsBase = require("./constants.js");
+const packageJson = require("../package.json");
+const { NameResolver, ComponentTypeNameResolver } = require("./util/name-resolver");
+const { cosmiconfigSync } = require("cosmiconfig");
+const CONSTANTS = require("./constants");
+
+const TsKeyword = {
+  Number: "number",
+  String: "string",
+  Boolean: "boolean",
+  Any: "any",
+  Void: "void",
+  Unknown: "unknown",
+  Null: "null",
+  Undefined: "undefined",
+  Object: "object",
+  File: "File",
+  Date: "Date",
+  Type: "type",
+  Enum: "enum",
+  Interface: "interface",
+  Array: "Array",
+  Record: "Record",
+  Intersection: "&",
+  Union: "|",
+};
+
+const TsCodeGenKeyword = {
+  UtilRequiredKeys: "UtilRequiredKeys",
+};
+
+/**
+ * @type {GenerateApiConfiguration["config"]}}
+ */
+class Configuration {
+  version = packageJson.version;
+  /** CLI flag */
+  templates = "../templates/default";
+  /** CLI flag */
+  generateResponses = false;
+  /** CLI flag */
+  defaultResponseAsSuccess = false;
+  /** CLI flag */
+  generateRouteTypes = false;
+  /** CLI flag */
+  generateClient = true;
+  /** CLI flag */
+  generateUnionEnums = false;
+  /** CLI flag */
+  addReadonly = false;
+  enumNamesAsValues = false;
+  /** parsed swagger schema from getSwaggerObject() */
+
+  /** parsed swagger schema ref */
+  swaggerSchema = null;
+  /** original (converted to json) swagger schema ref */
+  originalSchema = null;
+
+  /** { "#/components/schemas/Foo": @TypeInfo, ... } */
+  componentsMap = {};
+  /** flag for catching convertion from swagger 2.0 */
+  convertedFromSwagger2 = false;
+
+  /** url index from paths used for merging into modules */
+  moduleNameIndex = 0;
+
+  /** use the first tag for the module name */
+  moduleNameFirstTag = false;
+  disableStrictSSL = false;
+  disableProxy = false;
+  extractRequestParams = false;
+  extractRequestBody = false;
+  extractResponseBody = false;
+  extractResponseError = false;
+  fileNames = {
+    dataContracts: "data-contracts",
+    routeTypes: "route-types",
+    httpClient: "http-client",
+    outOfModuleApi: "Common",
+  };
+  routeNameDuplicatesMap = new Map();
+  prettierOptions = { ...CONSTANTS.PRETTIER_OPTIONS };
+  hooks = {
+    onCreateComponent: (schema) => schema,
+    onParseSchema: (originalSchema, parsedSchema) => parsedSchema,
+    onCreateRoute: (routeData) => routeData,
+    onInit: (config) => config,
+    onPrepareConfig: (apiConfig) => apiConfig,
+    onCreateRequestParams: (rawType) => {},
+    onCreateRouteName: () => {},
+    onFormatTypeName: (typeName, rawTypeName) => {},
+    onFormatRouteName: (routeInfo, templateRouteName) => {},
+  };
+  defaultResponseType;
+  singleHttpClient = false;
+  httpClientType = CONSTANTS.HTTP_CLIENT.FETCH;
+  unwrapResponseData = false;
+  disableThrowOnError = false;
+  sortTypes = false;
+  templatePaths = {
+    /** `templates/base` */
+    base: "",
+    /** `templates/default` */
+    default: "",
+    /** `templates/modular` */
+    modular: "",
+    /** usage path if `--templates` option is not set */
+    original: "",
+    /** custom path to templates (`--templates`) */
+    custom: "",
+  };
+  /** Record<templateName, templateContent> */
+  templatesToRender = {
+    api: "",
+    dataContracts: "",
+    dataContractJsDoc: "",
+    interfaceDataContract: "",
+    typeDataContract: "",
+    enumDataContract: "",
+    objectFieldJsDoc: "",
+    httpClient: "",
+    routeTypes: "",
+    routeName: "",
+  };
+  toJS = false;
+  silent = false;
+  typePrefix = "";
+  typeSuffix = "";
+  patch = false;
+  componentTypeNameResolver = new ComponentTypeNameResolver([]);
+  /** name of the main exported class */
+  apiClassName = "Api";
+  debug = false;
+  anotherArrayType = false;
+  internalTemplateOptions = {
+    addUtilRequiredKeysType: false,
+  };
+  extraTemplates = [];
+  input = "";
+  modular = false;
+  output = "";
+  url = "";
+  cleanOutput = false;
+  spec = null;
+  fileName = "";
+  authorizationToken = void 0;
+
+  jsPrimitiveTypes = [];
+  jsEmptyTypes = [];
+
+  successResponseStatusRange = [200, 299];
+
+  Ts = {
+    Keyword: _.cloneDeep(TsKeyword),
+    CodeGenKeyword: _.cloneDeep(TsCodeGenKeyword),
+    /**
+     * $A[] or Array<$A>
+     */
+    ArrayType: (content) => {
+      if (this.anotherArrayType) {
+        return this.Ts.TypeWithGeneric(this.Ts.Keyword.Array, [content]);
+      }
+
+      return `${this.Ts.ExpressionGroup(content)}[]`;
+    },
+    /**
+     * "$A"
+     */
+    StringValue: (content) => `"${content}"`,
+    /**
+     * $A
+     */
+    BooleanValue: (content) => `${content}`,
+    /**
+     * $A
+     */
+    NumberValue: (content) => `${content}`,
+    /**
+     * $A
+     */
+    NullValue: (content) => content,
+    /**
+     * $A1 | $A2
+     */
+    UnionType: (contents) => _.join(_.uniq(contents), ` ${this.Ts.Keyword.Union} `),
+    /**
+     * ($A1)
+     */
+    ExpressionGroup: (content) => (content ? `(${content})` : ""),
+    /**
+     * $A1 & $A2
+     */
+    IntersectionType: (contents) => _.join(_.uniq(contents), ` ${this.Ts.Keyword.Intersection} `),
+    /**
+     * Record<$A1, $A2>
+     */
+    RecordType: (key, value) => this.Ts.TypeWithGeneric(this.Ts.Keyword.Record, [key, value]),
+    /**
+     * readonly $key?:$value
+     */
+    TypeField: ({ readonly, key, optional, value }) =>
+      _.compact([readonly && "readonly ", key, optional && "?", ": ", value]).join(""),
+    /**
+     * [key: $A1]: $A2
+     */
+    InterfaceDynamicField: (key, value) => `[key: ${key}]: ${value}`,
+    /**
+     * $A1 = $A2
+     */
+    EnumField: (key, value) => `${key} = ${value}`,
+    /**
+     * $A0.key = $A0.value,
+     * $A1.key = $A1.value,
+     * $AN.key = $AN.value,
+     */
+    EnumFieldsWrapper: (contents) =>
+      _.map(contents, ({ key, value }) => `  ${this.Ts.EnumField(key, value)}`).join(",\n"),
+    /**
+     * {\n $A \n}
+     */
+    ObjectWrapper: (content) => `{\n${content}\n}`,
+    /**
+     * /** $A *\/
+     */
+    MultilineComment: (contents, formatFn) =>
+      [
+        ...(contents.length === 1
+          ? [`/** ${contents[0]} */`]
+          : ["/**", ...contents.map((content) => ` * ${content}`), " */"]),
+      ].map((part) => `${formatFn ? formatFn(part) : part}\n`),
+    /**
+     * $A1<...$A2.join(,)>
+     */
+    TypeWithGeneric: (typeName, genericArgs) => {
+      return `${typeName}${genericArgs.length ? `<${genericArgs.join(",")}>` : ""}`;
+    },
+  };
+
+  /**
+   * swagger schema type -> typescript type
+   * https://json-schema.org/understanding-json-schema/reference/string.html#dates-and-times
+   * @type {Record<string, string | ((schema: any, parser: SchemaParser) => string) | ({ $default: string } & Record<string, string | ((schema: any, parser: SchemaParser) => string)>)>}
+   */
+  primitiveTypes = {
+    integer: () => this.Ts.Keyword.Number,
+    number: () => this.Ts.Keyword.Number,
+    boolean: () => this.Ts.Keyword.Boolean,
+    object: () => this.Ts.Keyword.Object,
+    file: () => this.Ts.Keyword.File,
+    string: {
+      $default: () => this.Ts.Keyword.String,
+
+      /** formats */
+      binary: () => this.Ts.Keyword.File,
+      file: () => this.Ts.Keyword.File,
+      "date-time": () => this.Ts.Keyword.String,
+      time: () => this.Ts.Keyword.String,
+      date: () => this.Ts.Keyword.String,
+      duration: () => this.Ts.Keyword.String,
+      email: () => this.Ts.Keyword.String,
+      "idn-email": () => this.Ts.Keyword.String,
+      "idn-hostname": () => this.Ts.Keyword.String,
+      ipv4: () => this.Ts.Keyword.String,
+      ipv6: () => this.Ts.Keyword.String,
+      uuid: () => this.Ts.Keyword.String,
+      uri: () => this.Ts.Keyword.String,
+      "uri-reference": () => this.Ts.Keyword.String,
+      "uri-template": () => this.Ts.Keyword.String,
+      "json-pointer": () => this.Ts.Keyword.String,
+      "relative-json-pointer": () => this.Ts.Keyword.String,
+      regex: () => this.Ts.Keyword.String,
+    },
+    array: ({ items, ...schemaPart }, parser) => {
+      const content = parser.getInlineParseContent(items);
+      return parser.checkAndAddNull(schemaPart, this.Ts.ArrayType(content));
+    },
+  };
+
+  templateInfos = [
+    { name: "api", fileName: "api" },
+    { name: "dataContracts", fileName: "data-contracts" },
+    { name: "dataContractJsDoc", fileName: "data-contract-jsdoc" },
+    { name: "interfaceDataContract", fileName: "interface-data-contract" },
+    { name: "typeDataContract", fileName: "type-data-contract" },
+    { name: "enumDataContract", fileName: "enum-data-contract" },
+    { name: "objectFieldJsDoc", fileName: "object-field-jsdoc" },
+    { name: "httpClient", fileName: "http-client" },
+    { name: "routeTypes", fileName: "route-types" },
+    { name: "routeName", fileName: "route-name" },
+  ];
+
+  templateExtensions = [".eta", ".ejs"];
+
+  constructor({
+    input,
+    output,
+    url,
+    spec,
+    name: fileName,
+    toJS,
+    modular,
+    templates,
+    generateResponses,
+    defaultResponseAsSuccess,
+    generateRouteTypes,
+    generateClient,
+    httpClientType,
+    generateUnionEnums,
+    addReadonly,
+    moduleNameIndex,
+    moduleNameFirstTag,
+    extractRequestParams,
+    extractRequestBody,
+    extractResponseBody,
+    extractResponseError,
+    defaultResponseType,
+    unwrapResponseData,
+    disableThrowOnError,
+    sortTypes,
+    singleHttpClient,
+    prettier: prettierOptions = getDefaultPrettierOptions(),
+    hooks: rawHooks,
+    extraTemplates,
+    enumNamesAsValues,
+    disableStrictSSL,
+    disableProxy,
+    cleanOutput,
+    silent,
+    typePrefix,
+    typeSuffix,
+    patch,
+    authorizationToken,
+    apiClassName,
+    debug,
+    anotherArrayType,
+    codeGenConstructs,
+    primitiveTypeConstructs,
+    constants,
+    templateInfos,
+  }) {
+    objectAssign(this.Ts, codeGenConstructs);
+    objectAssign(this.primitiveTypes, primitiveTypeConstructs);
+
+    this.defaultResponseType = this.Ts.Keyword.Void;
+
+    this.update({
+      input,
+      output,
+      url,
+      spec,
+      fileName,
+      extraTemplates,
+      defaultResponseAsSuccess,
+      generateRouteTypes,
+      generateClient,
+      httpClientType,
+      generateResponses,
+      templates,
+      generateUnionEnums,
+      addReadonly,
+      moduleNameIndex,
+      moduleNameFirstTag,
+      prettierOptions,
+      modular,
+      extractRequestParams,
+      extractRequestBody,
+      extractResponseBody,
+      extractResponseError,
+      hooks: _.merge(this.hooks, rawHooks || {}),
+      enumNamesAsValues,
+      disableStrictSSL,
+      disableProxy,
+      cleanOutput,
+      defaultResponseType,
+      unwrapResponseData,
+      disableThrowOnError,
+      sortTypes,
+      singleHttpClient,
+      constants: {
+        ...constantsBase,
+        ...constants,
+      },
+      authorizationToken,
+      silent,
+      toJS,
+      typePrefix,
+      typeSuffix,
+      patch,
+      apiClassName,
+      debug,
+      anotherArrayType,
+      templateInfos,
+    });
+
+    this.jsPrimitiveTypes = [this.Ts.Keyword.Number, this.Ts.Keyword.String, this.Ts.Keyword.Boolean];
+    this.jsEmptyTypes = [this.Ts.Keyword.Null, this.Ts.Keyword.Undefined];
+  }
+
+  /**
+   *
+   * @param update {Partial<GenerateApiConfiguration["config"]>}
+   */
+  update = (update) => {
+    objectAssign(this, update);
+  };
+}
+
+const getDefaultPrettierOptions = () => {
+  const prettier = cosmiconfigSync("prettier").search();
+
+  if (prettier) {
+    return {
+      ...prettier.config,
+      parser: "typescript",
+    };
+  }
+
+  return { ...CONSTANTS.PRETTIER_OPTIONS };
+};
+
+module.exports = {
+  Configuration,
+};

package/src/constants.js

@@ -1,29 +1,3 @@
-const TS_KEYWORDS = {
-  NUMBER: "number",
-  STRING: "string",
-  BOOLEAN: "boolean",
-  ANY: "any",
-  VOID: "void",
-  UNKNOWN: "unknown",
-  NULL: "null",
-  UNDEFINED: "undefined",
-  OBJECT: "object",
-  FILE: "File",
-  DATE: "Date",
-  TYPE: "type",
-  ENUM: "enum",
-  INTERFACE: "interface",
-  TYPE_AND_OPERATOR: " & ",
-  TYPE_OR_OPERATOR: " | ",
-};
-
-const TS_EXTERNAL = {
-  RECORD: "Record<string, any>",
-};
-
-const JS_PRIMITIVE_TYPES = [TS_KEYWORDS.NUMBER, TS_KEYWORDS.STRING, TS_KEYWORDS.BOOLEAN];
-const JS_EMPTY_TYPES = [TS_KEYWORDS.NULL, TS_KEYWORDS.UNDEFINED];
-
 const RESERVED_QUERY_ARG_NAMES = ["query", "queryParams", "queryArg"];
 const RESERVED_BODY_ARG_NAMES = ["data", "body", "reqBody"];
 const RESERVED_REQ_PARAMS_ARG_NAMES = ["params", "requestParams", "reqParams", "httpParams"];
@@ -49,13 +23,22 @@ const HTTP_CLIENT = {
   AXIOS: "axios",
 };
 
+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 ##
+ * ---------------------------------------------------------------
+ */
+
+`;
+
 module.exports = {
+  FILE_PREFIX,
   DEFAULT_BODY_ARG_NAME: "data",
-  SUCCESS_RESPONSE_STATUS_RANGE: [200, 300],
-  JS_PRIMITIVE_TYPES,
-  JS_EMPTY_TYPES,
-  TS_KEYWORDS,
-  TS_EXTERNAL,
   SCHEMA_TYPES,
   HTTP_CLIENT,
   RESERVED_QUERY_ARG_NAMES,