swagger-typescript-api 10.0.0 → 10.0.2

package/src/templates.js

@@ -1,132 +1,155 @@
-const _ = require("lodash");
-const Eta = require("eta");
-const { getFileContent, pathIsExist } = require("./files");
-const { config } = require("./config");
-const { resolve } = require("path");
-const { logger } = require("./logger");
-
-/**
- * name - project template name,
- * fileName - template file name,
- */
-const TEMPLATE_INFOS = [
-  { name: "api", fileName: "api.eta" },
-  { name: "dataContracts", fileName: "data-contracts.eta" },
-  { name: "httpClient", fileName: "http-client.eta" },
-  { name: "routeTypes", fileName: "route-types.eta" },
-  { name: "routeName", fileName: "route-name.eta" },
-];
-
-const getTemplatePaths = ({ templates, modular }) => {
-  const baseTemplatesPath = resolve(__dirname, "../templates/base");
-  const defaultTemplatesPath = resolve(__dirname, "../templates/default");
-  const modularTemplatesPath = resolve(__dirname, "../templates/modular");
-  const originalTemplatesPath = modular ? modularTemplatesPath : defaultTemplatesPath;
-  const customTemplatesPath = templates ? resolve(process.cwd(), templates) : originalTemplatesPath;
-
-  return {
-    /** `templates/base` */
-    base: baseTemplatesPath,
-    /** `templates/default` */
-    default: defaultTemplatesPath,
-    /** `templates/modular` */
-    modular: modularTemplatesPath,
-    /** usage path if `--templates` option is not set */
-    original: originalTemplatesPath,
-    /** custom path to templates (`--templates`) */
-    custom: customTemplatesPath,
-  };
-};
-
-const getTemplate = ({ fileName, name, path }) => {
-  const { templatePaths } = config;
-
-  if (path) {
-    return getFileContent(path);
-  }
-
-  if (!fileName) return "";
-
-  const customFullPath = resolve(templatePaths.custom, "./", fileName);
-  let fileContent = pathIsExist(customFullPath) && getFileContent(customFullPath);
-
-  if (!fileContent) {
-    const baseFullPath = resolve(templatePaths.base, "./", fileName);
-    const originalFullPath = resolve(templatePaths.original, "./", fileName);
-
-    if (pathIsExist(baseFullPath)) {
-      fileContent = getFileContent(baseFullPath);
-    } else {
-      logger.warn(
-        `${_.lowerCase(name)} template not found in ${customFullPath}`,
-        `\nCode generator will use the default template`,
-      );
-    }
-
-    if (pathIsExist(originalFullPath)) {
-      fileContent = getFileContent(originalFullPath);
-    }
-  }
-
-  return fileContent;
-};
-
-const getTemplates = ({ templatePaths }) => {
-  logger.log(`try to read templates from directory "${templatePaths.custom}"`);
-
-  const templatesMap = _.reduce(
-    TEMPLATE_INFOS,
-    (acc, { fileName, name }) => ({
-      ...acc,
-      [name]: getTemplate({ fileName, name }),
-    }),
-    {},
-  );
-
-  return templatesMap;
-};
-
-const getTemplateContent = (path) => {
-  let fixedPath = _.endsWith(path, ".eta") ? path : `${path}.eta`;
-
-  _.keys(config.templatePaths).forEach((key) => {
-    if (_.startsWith(fixedPath, `@${key}`)) {
-      fixedPath = resolve(_.replace(fixedPath, `@${key}`, config.templatePaths[key]));
-    }
-  });
-
-  if (pathIsExist(fixedPath)) {
-    return getFileContent(fixedPath);
-  }
-
-  const customPath = resolve(config.templatePaths.custom, fixedPath);
-
-  if (pathIsExist(customPath)) {
-    return getFileContent(customPath);
-  }
-
-  const originalPath = resolve(config.templatePaths.original, fixedPath);
-
-  if (pathIsExist(originalPath)) {
-    return getFileContent(originalPath);
-  }
-
-  return "";
-};
-
-const renderTemplate = (template, configuration, options) => {
-  if (!template) return "";
-
-  return Eta.render(template, configuration, {
-    async: false,
-    ...(options || {}),
-    includeFile: (path, payload) => renderTemplate(getTemplateContent(path), payload),
-  });
-};
-
-module.exports = {
-  getTemplate,
-  getTemplates,
-  getTemplatePaths,
-  renderTemplate,
-};
+const _ = require("lodash");
+const Eta = require("eta");
+const { getFileContent, pathIsExist } = require("./files");
+const { config } = require("./config");
+const { resolve } = require("path");
+const { logger } = require("./logger");
+
+const TEMPLATE_EXTENSIONS = [".eta", ".ejs"];
+
+/**
+ * name - project template name,
+ * fileName - template file name,
+ */
+const TEMPLATE_INFOS = [
+  { 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" },
+];
+
+const getTemplatePaths = ({ templates, modular }) => {
+  const baseTemplatesPath = resolve(__dirname, "../templates/base");
+  const defaultTemplatesPath = resolve(__dirname, "../templates/default");
+  const modularTemplatesPath = resolve(__dirname, "../templates/modular");
+  const originalTemplatesPath = modular ? modularTemplatesPath : defaultTemplatesPath;
+  const customTemplatesPath = templates ? resolve(process.cwd(), templates) : originalTemplatesPath;
+
+  return {
+    /** `templates/base` */
+    base: baseTemplatesPath,
+    /** `templates/default` */
+    default: defaultTemplatesPath,
+    /** `templates/modular` */
+    modular: modularTemplatesPath,
+    /** usage path if `--templates` option is not set */
+    original: originalTemplatesPath,
+    /** custom path to templates (`--templates`) */
+    custom: customTemplatesPath,
+  };
+};
+
+const cropExtension = (path) =>
+  TEMPLATE_EXTENSIONS.reduce((path, ext) => (_.endsWith(path, ext) ? path.replace(ext, "") : path), path);
+
+const getTemplateFullPath = (path, fileName) => {
+  const raw = resolve(path, "./", cropExtension(fileName));
+  const pathVariants = TEMPLATE_EXTENSIONS.map((extension) => `${raw}${extension}`);
+
+  return pathVariants.find((variant) => !!pathIsExist(variant));
+};
+
+const getTemplate = ({ fileName, name, path }) => {
+  const { templatePaths } = config;
+
+  if (path) {
+    return getFileContent(path);
+  }
+
+  if (!fileName) return "";
+
+  const customFullPath = getTemplateFullPath(templatePaths.custom, fileName);
+  let fileContent = customFullPath && getFileContent(customFullPath);
+
+  if (!fileContent) {
+    const baseFullPath = getTemplateFullPath(templatePaths.base, fileName);
+
+    if (baseFullPath) {
+      fileContent = getFileContent(baseFullPath);
+    } else {
+      logger.warn(
+        `${_.lowerCase(name)} template not found in ${customFullPath}`,
+        `\nCode generator will use the default template`,
+      );
+    }
+
+    const originalFullPath = getTemplateFullPath(templatePaths.original, fileName);
+
+    if (originalFullPath) {
+      fileContent = getFileContent(originalFullPath);
+    }
+  }
+
+  return fileContent;
+};
+
+const getTemplates = ({ templatePaths }) => {
+  logger.log(`try to read templates from directory "${templatePaths.custom}"`);
+
+  const templatesMap = _.reduce(
+    TEMPLATE_INFOS,
+    (acc, { fileName, name }) => ({
+      ...acc,
+      [name]: getTemplate({ fileName, name }),
+    }),
+    {},
+  );
+
+  return templatesMap;
+};
+
+const getTemplateContent = (path) => {
+  const foundTemplatePathKey = _.keys(config.templatePaths).find((key) => _.startsWith(path, `@${key}`));
+
+  const findPathWithExt = (path) => {
+    const raw = cropExtension(path);
+    const pathVariants = TEMPLATE_EXTENSIONS.map((extension) => `${raw}${extension}`);
+    return pathVariants.find((variant) => pathIsExist(variant));
+  };
+
+  const rawPath = resolve(_.replace(path, `@${foundTemplatePathKey}`, config.templatePaths[foundTemplatePathKey]));
+  const fixedPath = findPathWithExt(rawPath);
+
+  if (fixedPath) {
+    return getFileContent(fixedPath);
+  }
+
+  const customPath = findPathWithExt(resolve(config.templatePaths.custom, path));
+
+  if (customPath) {
+    return getFileContent(customPath);
+  }
+
+  const originalPath = findPathWithExt(resolve(config.templatePaths.original, path));
+
+  if (originalPath) {
+    return getFileContent(originalPath);
+  }
+
+  return "";
+};
+
+const renderTemplate = (template, configuration, options) => {
+  if (!template) return "";
+
+  return Eta.render(template, configuration, {
+    async: false,
+    ...(options || {}),
+    includeFile: (path, payload, options) => {
+      return renderTemplate(getTemplateContent(path), payload, options);
+    },
+  });
+};
+
+module.exports = {
+  getTemplate,
+  getTemplates,
+  getTemplatePaths,
+  renderTemplate,
+};

package/src/translators/JavaScript.js

@@ -1,60 +1,60 @@
-const ts = require("typescript");
-
-function translate(fileName, content, options) {
-  const output = {};
-  const host = ts.createCompilerHost(options, true);
-  const fileNames = [fileName];
-  const originalSourceFileGet = host.getSourceFile.bind(host);
-  host.getSourceFile = (sourceFileName, languageVersion, onError, shouldCreateNewSourceFile) => {
-    if (sourceFileName !== fileName)
-      return originalSourceFileGet(
-        sourceFileName,
-        languageVersion,
-        onError,
-        shouldCreateNewSourceFile,
-      );
-
-    return ts.createSourceFile(
-      sourceFileName,
-      content,
-      languageVersion,
-      true,
-      ts.ScriptKind.External,
-    );
-  };
-
-  host.writeFile = (fileName, contents) => {
-    output[fileName] = contents;
-  };
-
-  ts.createProgram(fileNames, options, host).emit();
-
-  return output;
-}
-
-module.exports = {
-  translate: (fileName, sourceTypeScript) => {
-    const translated = translate(fileName, sourceTypeScript, {
-      module: "ESNext",
-      noImplicitReturns: true,
-      alwaysStrict: true,
-      target: ts.ScriptTarget.ESNext,
-      declaration: true,
-      noImplicitAny: false,
-      sourceMap: false,
-      removeComments: false,
-      disableSizeLimit: true,
-      esModuleInterop: true,
-      emitDecoratorMetadata: true,
-      skipLibCheck: true,
-    });
-
-    const sourceFileName = fileName.replace(ts.Extension.Ts, ts.Extension.Js);
-    const declarationFileName = fileName.replace(ts.Extension.Ts, ts.Extension.Dts);
-
-    return {
-      sourceContent: translated[sourceFileName],
-      declarationContent: translated[declarationFileName],
-    };
-  },
-};
+const ts = require("typescript");
+
+function translate(fileName, content, options) {
+  const output = {};
+  const host = ts.createCompilerHost(options, true);
+  const fileNames = [fileName];
+  const originalSourceFileGet = host.getSourceFile.bind(host);
+  host.getSourceFile = (sourceFileName, languageVersion, onError, shouldCreateNewSourceFile) => {
+    if (sourceFileName !== fileName)
+      return originalSourceFileGet(
+        sourceFileName,
+        languageVersion,
+        onError,
+        shouldCreateNewSourceFile,
+      );
+
+    return ts.createSourceFile(
+      sourceFileName,
+      content,
+      languageVersion,
+      true,
+      ts.ScriptKind.External,
+    );
+  };
+
+  host.writeFile = (fileName, contents) => {
+    output[fileName] = contents;
+  };
+
+  ts.createProgram(fileNames, options, host).emit();
+
+  return output;
+}
+
+module.exports = {
+  translate: (fileName, sourceTypeScript) => {
+    const translated = translate(fileName, sourceTypeScript, {
+      module: "ESNext",
+      noImplicitReturns: true,
+      alwaysStrict: true,
+      target: ts.ScriptTarget.ESNext,
+      declaration: true,
+      noImplicitAny: false,
+      sourceMap: false,
+      removeComments: false,
+      disableSizeLimit: true,
+      esModuleInterop: true,
+      emitDecoratorMetadata: true,
+      skipLibCheck: true,
+    });
+
+    const sourceFileName = fileName.replace(ts.Extension.Ts, ts.Extension.Js);
+    const declarationFileName = fileName.replace(ts.Extension.Ts, ts.Extension.Dts);
+
+    return {
+      sourceContent: translated[sourceFileName],
+      declarationContent: translated[declarationFileName],
+    };
+  },
+};

package/src/typeFormatters.js

@@ -1,75 +1,121 @@
-const _ = require("lodash");
-const { config } = require("./config");
-const { TS_KEYWORDS, SCHEMA_TYPES } = require("./constants");
-
-const formatters = {
-  [SCHEMA_TYPES.ENUM]: (content) => {
-    const isNumberEnum = _.some(content, (content) => typeof content.key === "number");
-    const formatAsUnionType = !!(isNumberEnum || config.generateUnionEnums);
-
-    if (formatAsUnionType) {
-      return _.map(content, ({ value }) => value).join(" | ");
-    }
-
-    return _.map(content, ({ key, value }) => `  ${key} = ${value}`).join(",\n");
-  },
-  [SCHEMA_TYPES.OBJECT]: (content) =>
-    _.map(content, (part) => {
-      const extraSpace = "  ";
-      const result = `${extraSpace}${part.field};\n`;
-
-      const comments = _.uniq(_.compact([part.title, part.description]).reduce(
-        (acc, comment) => [...acc, ...comment.split(/\n/g)],
-        [],
-      ));
-
-      const commonText = comments.length
-        ? [
-            "",
-            ...(comments.length === 1
-              ? [`/** ${comments[0]} */`]
-              : ["/**", ...comments.map((commentPart) => ` * ${commentPart}`), " */"]),
-          ]
-            .map((part) => `${extraSpace}${part}\n`)
-            .join("")
-        : "";
-
-      return `${commonText}${result}`;
-    }).join(""),
-  [SCHEMA_TYPES.PRIMITIVE]: (content) => {
-    return content;
-  },
-};
-
-/** transform content of parsed schema to string or compact size */
-const inlineExtraFormatters = {
-  [SCHEMA_TYPES.OBJECT]: (parsedSchema) => {
-    return {
-      ...parsedSchema,
-      typeIdentifier: TS_KEYWORDS.TYPE,
-      content: _.isString(parsedSchema.content)
-        ? parsedSchema.content
-        : parsedSchema.content.length
-        ? `{ ${parsedSchema.content.map((part) => part.field).join(", ")} }`
-        : TS_KEYWORDS.OBJECT,
-    };
-  },
-  [SCHEMA_TYPES.ENUM]: (parsedSchema) => {
-    return {
-      ...parsedSchema,
-      content: parsedSchema.$ref
-        ? parsedSchema.typeName
-        : _.uniq(
-            _.compact([
-              ..._.map(parsedSchema.content, ({ value }) => `${value}`),
-              parsedSchema.nullable && TS_KEYWORDS.NULL,
-            ]),
-          ).join(" | "),
-    };
-  },
-};
-
-module.exports = {
-  formatters,
-  inlineExtraFormatters,
-};
+const _ = require("lodash");
+const { config } = require("./config");
+const { TS_KEYWORDS, SCHEMA_TYPES, TS_EXTERNAL } = require("./constants");
+
+const checkAndAddNull = (schema, value) => {
+  const { nullable, type } = schema || {};
+  return (nullable || !!_.get(schema, "x-nullable") || type === TS_KEYWORDS.NULL) &&
+    _.isString(value) &&
+    !value.includes(` ${TS_KEYWORDS.NULL}`) &&
+    !value.includes(`${TS_KEYWORDS.NULL} `)
+    ? `${value} | ${TS_KEYWORDS.NULL}`
+    : value;
+};
+
+const formatters = {
+  [SCHEMA_TYPES.ENUM]: (parsedSchema) => {
+    const isNumberEnum = _.some(parsedSchema.content, (content) => typeof content.key === "number");
+    const formatAsUnionType = !!(isNumberEnum || config.generateUnionEnums);
+
+    if (formatAsUnionType) {
+      return {
+        ...parsedSchema,
+        $content: parsedSchema.content,
+        content: _.map(parsedSchema.content, ({ value }) => value).join(" | "),
+      };
+    }
+
+    return {
+      ...parsedSchema,
+      $content: parsedSchema.content,
+      content: _.map(parsedSchema.content, ({ key, value }) => `  ${key} = ${value}`).join(",\n"),
+    };
+  },
+  [SCHEMA_TYPES.OBJECT]: (parsedSchema) => {
+    if (parsedSchema.nullable) return inlineExtraFormatters[SCHEMA_TYPES.OBJECT](parsedSchema);
+    return {
+      ...parsedSchema,
+      $content: parsedSchema.content,
+      content: formatObjectContent(parsedSchema.content),
+    };
+  },
+  [SCHEMA_TYPES.PRIMITIVE]: (parsedSchema) => {
+    return {
+      ...parsedSchema,
+      $content: parsedSchema.content,
+    };
+  },
+};
+
+/** transform content of parsed schema to string or compact size */
+const inlineExtraFormatters = {
+  [SCHEMA_TYPES.OBJECT]: (parsedSchema) => {
+    if (_.isString(parsedSchema.content)) {
+      return {
+        ...parsedSchema,
+        typeIdentifier: TS_KEYWORDS.TYPE,
+        content: checkAndAddNull(parsedSchema.content),
+      };
+    }
+
+    return {
+      ...parsedSchema,
+      typeIdentifier: TS_KEYWORDS.TYPE,
+      content: checkAndAddNull(
+        parsedSchema,
+        parsedSchema.content.length ? `{\n${formatObjectContent(parsedSchema.content)}\n}` : TS_EXTERNAL.RECORD,
+      ),
+    };
+  },
+  [SCHEMA_TYPES.ENUM]: (parsedSchema) => {
+    return {
+      ...parsedSchema,
+      content: parsedSchema.$ref
+        ? parsedSchema.typeName
+        : _.uniq(
+            _.compact([
+              ..._.map(parsedSchema.content, ({ value }) => `${value}`),
+              parsedSchema.nullable && TS_KEYWORDS.NULL,
+            ]),
+          ).join(" | "),
+    };
+  },
+};
+
+const formatObjectContent = (content) => {
+  return _.map(content, (part) => {
+    const extraSpace = "  ";
+    const result = `${extraSpace}${part.field},\n`;
+
+    const comments = _.uniq(
+      _.compact([
+        part.title,
+        part.description,
+        part.deprecated && ` * @deprecated`,
+        !_.isUndefined(part.format) && `@format ${part.format}`,
+        !_.isUndefined(part.minimum) && `@min ${part.minimum}`,
+        !_.isUndefined(part.maximum) && `@max ${part.maximum}`,
+        !_.isUndefined(part.pattern) && `@pattern ${part.pattern}`,
+        !_.isUndefined(part.example) &&
+          `@example ${_.isObject(part.example) ? JSON.stringify(part.example) : part.example}`,
+      ]).reduce((acc, comment) => [...acc, ...comment.split(/\n/g)], []),
+    );
+
+    const commonText = comments.length
+      ? [
+          ...(comments.length === 1
+            ? [`/** ${comments[0]} */`]
+            : ["/**", ...comments.map((commentPart) => ` * ${commentPart}`), " */"]),
+        ]
+          .map((part) => `${extraSpace}${part}\n`)
+          .join("")
+      : "";
+
+    return `${commonText}${result}`;
+  }).join("");
+};
+
+module.exports = {
+  formatters,
+  inlineExtraFormatters,
+};

package/src/utils/id.js

@@ -1,9 +1,9 @@
-const { customAlphabet } = require("nanoid");
-
-const ALPHABET = "abcdefghijklmnopqrstuvwxyz0123456789";
-
-const generateId = customAlphabet(ALPHABET, 12);
-
-module.exports = {
-  generateId,
-};
+const { customAlphabet } = require("nanoid");
+
+const ALPHABET = "abcdefghijklmnopqrstuvwxyz0123456789";
+
+const generateId = customAlphabet(ALPHABET, 12);
+
+module.exports = {
+  generateId,
+};

package/src/utils/random.js

@@ -1,14 +1,14 @@
-const getRandomFloat = (min = 0, max = 1) => {
-  return Math.random() * (max - min) + min;
-};
-
-const getRandomInt = (min = 0, max = 1) => {
-  if (min === max) return min;
-
-  return Math.round(getRandomFloat(min, max));
-};
-
-module.exports = {
-  getRandomFloat,
-  getRandomInt,
-};
+const getRandomFloat = (min = 0, max = 1) => {
+  return Math.random() * (max - min) + min;
+};
+
+const getRandomInt = (min = 0, max = 1) => {
+  if (min === max) return min;
+
+  return Math.round(getRandomFloat(min, max));
+};
+
+module.exports = {
+  getRandomFloat,
+  getRandomInt,
+};