swagger-typescript-api 10.0.2 → 11.0.0--alpha

package/src/index.js

@@ -1,271 +1,20 @@
-#!/usr/bin/env node
-
-// Copyright (c) 2019-present acacode
-// Node module: swagger-typescript-api
-// This file is licensed under the MIT License.
-// License text available at https://opensource.org/licenses/MIT
-// Repository https://github.com/acacode/swagger-typescript-api
-
-const _ = require("lodash");
-const { parseSchemas } = require("./schema");
-const { parseRoutes, groupRoutes } = require("./routes");
-const { createApiConfig } = require("./apiConfig");
-const { prepareModelType } = require("./modelTypes");
-const { getSwaggerObject, fixSwaggerScheme, convertSwaggerObject } = require("./swagger");
-const { createComponentsMap, filterComponentsMap } = require("./components");
-const { createFile, pathIsExist, pathIsDir, createDir, cleanDir } = require("./files");
-const { addToConfig, config } = require("./config");
-const { getTemplates, getTemplatePaths, renderTemplate, getTemplate } = require("./templates");
-const constants = require("./constants");
-const { generateOutputFiles } = require("./output");
-const formatFileContent = require("./formatFileContent");
-const { logger } = require("./logger");
-const { ComponentTypeNameResolver } = require("./utils/resolveName");
-const { getPrettierOptions } = require("./prettierOptions");
-
-module.exports = {
-  constants: constants,
-  generateApi: ({
-    input,
-    output,
-    url,
-    spec,
-    name: fileName,
-    toJS: translateToJavaScript = config.toJS,
-    modular,
-    templates,
-    generateResponses = config.generateResponses,
-    defaultResponseAsSuccess = config.defaultResponseAsSuccess,
-    generateRouteTypes = config.generateRouteTypes,
-    generateClient = config.generateClient,
-    httpClientType = config.httpClientType,
-    generateUnionEnums = config.generateUnionEnums,
-    addReadonly = config.addReadonly,
-    moduleNameIndex = config.moduleNameIndex,
-    moduleNameFirstTag = config.moduleNameFirstTag,
-    extractRequestParams = config.extractRequestParams,
-    extractRequestBody = config.extractRequestBody,
-    extractResponseBody = config.extractResponseBody,
-    extractResponseError = config.extractResponseError,
-    defaultResponseType = config.defaultResponseType,
-    unwrapResponseData = config.unwrapResponseData,
-    disableThrowOnError = config.disableThrowOnError,
-    sortTypes = config.sortTypes,
-    singleHttpClient = config.singleHttpClient,
-    prettier: prettierOptions = getPrettierOptions(),
-    hooks: rawHooks,
-    extraTemplates,
-    enumNamesAsValues,
-    disableStrictSSL = config.disableStrictSSL,
-    disableProxy = config.disableProxy,
-    cleanOutput,
-    silent = config.silent,
-    typePrefix = config.typePrefix,
-    typeSuffix = config.typeSuffix,
-    patch = config.patch,
-    authorizationToken,
-    apiClassName = config.apiClassName,
-    debug = config.debug,
-  }) =>
-    new Promise((resolve, reject) => {
-      addToConfig({
-        defaultResponseAsSuccess,
-        generateRouteTypes,
-        generateClient,
-        httpClientType,
-        generateResponses,
-        templates,
-        generateUnionEnums,
-        addReadonly,
-        moduleNameIndex,
-        moduleNameFirstTag,
-        prettierOptions,
-        modular,
-        extractRequestParams,
-        extractRequestBody,
-        extractResponseBody,
-        extractResponseError,
-        hooks: _.merge(config.hooks, rawHooks || {}),
-        enumNamesAsValues,
-        disableStrictSSL,
-        disableProxy,
-        cleanOutput,
-        defaultResponseType,
-        unwrapResponseData,
-        disableThrowOnError,
-        sortTypes,
-        singleHttpClient,
-        constants,
-        silent,
-        toJS: translateToJavaScript,
-        typePrefix,
-        typeSuffix,
-        patch,
-        apiClassName,
-        debug,
-      });
-      (spec
-        ? convertSwaggerObject(spec, { patch })
-        : getSwaggerObject(input, url, disableStrictSSL, disableProxy, authorizationToken, { patch })
-      )
-        .then(({ usageSchema, originalSchema }) => {
-          const templatePaths = getTemplatePaths(config);
-
-          addToConfig({ templatePaths });
-
-          const templatesToRender = getTemplates(config);
-
-          logger.event("start generating your typescript api");
-
-          fixSwaggerScheme(usageSchema, originalSchema);
-
-          addToConfig({
-            swaggerSchema: usageSchema,
-            originalSchema,
-            templatesToRender,
-          });
-
-          const { components } = usageSchema;
-
-          addToConfig(config.hooks.onInit(config) || config);
-
-          const componentsMap = createComponentsMap(components);
-
-          const componentSchemasNames = filterComponentsMap(componentsMap, "schemas").map((c) => c.typeName);
-
-          addToConfig({
-            componentTypeNameResolver: new ComponentTypeNameResolver(componentSchemasNames),
-          });
-
-          const parsedSchemas = parseSchemas(components);
-
-          config.routeNameDuplicatesMap.clear();
-
-          const routes = parseRoutes({
-            usageSchema,
-            parsedSchemas,
-            moduleNameIndex,
-            moduleNameFirstTag,
-            extractRequestParams,
-          });
-
-          const hasSecurityRoutes = routes.some((route) => route.security);
-          const hasQueryRoutes = routes.some((route) => route.hasQuery);
-          const hasFormDataRoutes = routes.some((route) => route.hasFormDataParams);
-
-          const usageComponentSchemas = filterComponentsMap(componentsMap, "schemas");
-          const sortByProperty = (propertyName) => (o1, o2) => {
-            if (o1[propertyName] > o2[propertyName]) {
-              return 1;
-            }
-            if (o1[propertyName] < o2[propertyName]) {
-              return -1;
-            }
-            return 0;
-          };
-
-          const sortSchemas = (schemas) => {
-            if (config.sortTypes) {
-              return schemas.sort(sortByProperty("typeName")).map((schema) => {
-                if (schema.rawTypeData?.properties) {
-                  return {
-                    ...schema,
-                    rawTypeData: {
-                      ...schema.rawTypeData,
-                      $parsed: schema.rawTypeData["$parsed"] && {
-                        ...schema.rawTypeData["$parsed"],
-                        content: Array.isArray(schema.rawTypeData["$parsed"].content)
-                          ? schema.rawTypeData["$parsed"].content.sort(sortByProperty("name"))
-                          : schema.rawTypeData["$parsed"].content,
-                      },
-                    },
-                  };
-                }
-                return schema;
-              });
-            }
-            return schemas;
-          };
-
-          const rawConfiguration = {
-            apiConfig: createApiConfig(usageSchema),
-            config,
-            modelTypes: _.map(sortSchemas(usageComponentSchemas), prepareModelType),
-            rawModelTypes: usageComponentSchemas,
-            hasFormDataRoutes,
-            hasSecurityRoutes,
-            hasQueryRoutes,
-            generateResponses,
-            routes: groupRoutes(routes),
-            extraTemplates,
-            fileName,
-            translateToJavaScript,
-            utils: {
-              ...require("./render/utils"),
-              ...require("./common"),
-            },
-          };
-
-          const configuration = config.hooks.onPrepareConfig(rawConfiguration) || rawConfiguration;
-
-          if (pathIsExist(output)) {
-            if (cleanOutput) {
-              cleanDir(output);
-            }
-          } else {
-            createDir(output);
-          }
-
-          const files = generateOutputFiles({
-            modular,
-            templatesToRender,
-            configuration,
-          });
-
-          const isDirPath = pathIsDir(output);
-
-          const generatedFiles = files.map((file) => {
-            if (!isDirPath) return file;
-
-            if (translateToJavaScript) {
-              createFile({
-                path: output,
-                fileName: file.name,
-                content: file.content,
-                withPrefix: true,
-              });
-              createFile({
-                path: output,
-                fileName: file.declaration.name,
-                content: file.declaration.content,
-                withPrefix: true,
-              });
-              logger.success(`javascript api file`, file.name, `created in ${output}`);
-            } else {
-              createFile({
-                path: output,
-                fileName: file.name,
-                content: file.content,
-                withPrefix: true,
-              });
-              logger.success(`typescript api file`, file.name, `created in ${output}`);
-            }
-
-            return file;
-          });
-
-          resolve({
-            files: generatedFiles,
-            configuration,
-            getTemplate,
-            renderTemplate,
-            createFile,
-            formatTSContent: formatFileContent,
-          });
-        })
-        .catch((e) => {
-          reject(e);
-          throw new Error("Swagger schema parse error!\r\n " + e);
-        });
-    }),
-};
+#!/usr/bin/env node
+
+// Copyright (c) 2019-present acacode
+// Node module: swagger-typescript-api
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+// Repository https://github.com/acacode/swagger-typescript-api
+
+const _ = require("lodash");
+const constants = require("./constants");
+const { CodeGenProcess } = require("./code-gen-process.js");
+
+module.exports = {
+  constants: constants,
+  generateApi: async (config) => {
+    const codeGenProcess = new CodeGenProcess(config);
+    return await codeGenProcess.start();
+  },
+  generateTemplates: (config) => {},
+};

package/src/schema-components-map.js

@@ -0,0 +1,60 @@
+const _ = require("lodash");
+
+class SchemaComponentsMap {
+  /**
+   * @type {Record<string, SchemaComponent>}
+   */
+  data = {};
+  /**
+   * @type {Configuration}
+   */
+  config;
+
+  constructor(config, schema) {
+    this.config = config;
+    this.processSchema(schema);
+  }
+
+  processSchema(schema) {
+    this.data = {};
+    if (!schema) return;
+    _.each(schema.components, (component, componentName) =>
+      _.each(component, (rawTypeData, typeName) => this.createComponent(componentName, typeName, rawTypeData)),
+    );
+  }
+
+  createComponent(componentName, typeName, rawTypeData) {
+    const $ref = `#/components/${componentName}/${typeName}`;
+
+    const componentSchema = {
+      $ref,
+      typeName,
+      rawTypeData,
+      componentName,
+      /** result from schema parser */
+      typeData: null,
+    };
+
+    const usageComponent = this.config.hooks.onCreateComponent(componentSchema) || componentSchema;
+
+    this.data[$ref] = usageComponent;
+
+    return usageComponent;
+  }
+
+  /**
+   * @param componentName {string}
+   * @returns {SchemaComponent[]}
+   */
+  filter(componentName) {
+    return _.filter(this.data, (v, ref) => _.startsWith(ref, `#/components/${componentName}`));
+  }
+
+  get(ref) {
+    return this.data[ref] || null;
+  }
+}
+
+module.exports = {
+  SchemaComponentsMap,
+};

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

@@ -0,0 +1,145 @@
+const { SCHEMA_TYPES } = require("../constants");
+const _ = require("lodash");
+
+class SchemaFormatters {
+  /**
+   * @type {Configuration}
+   */
+  config;
+  /**
+   * @type {Logger}
+   */
+  logger;
+  /**
+   * @type {SchemaParser}
+   */
+  schemaParser;
+  /**
+   * @type {Templates}
+   */
+  templates;
+
+  constructor(config, logger, schemaParser, templates) {
+    this.config = config;
+    this.logger = logger;
+    this.schemaParser = schemaParser;
+    this.templates = templates;
+  }
+
+  base = {
+    [SCHEMA_TYPES.ENUM]: (parsedSchema) => {
+      const isNumberEnum = _.some(parsedSchema.content, (content) => typeof content.key === "number");
+      const formatAsUnionType = !!(isNumberEnum || this.config.generateUnionEnums);
+
+      if (formatAsUnionType) {
+        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.OBJECT]: (parsedSchema) => {
+      if (_.isString(parsedSchema.content)) {
+        return {
+          ...parsedSchema,
+          typeIdentifier: this.config.Ts.Keyword.Type,
+          content: this.schemaParser.checkAndAddNull(parsedSchema.content),
+        };
+      }
+
+      return {
+        ...parsedSchema,
+        typeIdentifier: this.config.Ts.Keyword.Type,
+        content: this.schemaParser.checkAndAddNull(
+          parsedSchema,
+          parsedSchema.content.length
+            ? this.config.Ts.ObjectWrapper(this.formatObjectContent(parsedSchema.content))
+            : this.config.Ts.RecordType(Ts.Keyword.String, this.config.Ts.Keyword.Any),
+        ),
+      };
+    },
+    [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,
+              ]),
+            ),
+      };
+    },
+  };
+
+  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) => {
+    return _.map(content, (part) => {
+      const extraSpace = "  ";
+      const result = `${extraSpace}${part.field},\n`;
+
+      const renderedJsDoc = this.templates.renderTemplate(this.config.templatesToRender.dataContractJsDoc, {
+        data: part,
+      });
+
+      const routeNameFromTemplate = renderedJsDoc
+        .split("\n")
+        .map((c) => `${extraSpace}${c}`)
+        .join("\n");
+
+      if (routeNameFromTemplate) return `${routeNameFromTemplate}${result}`;
+
+      return `${result}`;
+    }).join("");
+  };
+}
+
+module.exports = {
+  SchemaFormatters,
+};