support tsconfig.json

Author: alekbarszczewski

README.MD

@@ -8,7 +8,7 @@ This is a tool to generate swagger files from a [typescript-rest](https://github
 
 **Table of Contents** 
 
-- [Swagger for Typescript-Rest](#)
+- [Swagger for Typescript-rest](#swagger-for-typescript-rest)
   - [Installation](#installation)
   - [Usage](#usage)
     - [Swagger Decorators](#swagger-decorators)
@@ -17,6 +17,7 @@ This is a tool to generate swagger files from a [typescript-rest](https://github
       - [@Tags](#tags)
       - [@Security](#security)
       - [@Produces](#produces)
+      - [@IsInt, @IsLong, @IsFloat, @IsDouble](#isint-islong-isfloat-isdouble)
     - [SwaggerConfig.json](#swaggerconfigjson)
 
 ## Installation
@@ -29,6 +30,8 @@ npm install typescript-rest-swagger -g
 
 ```bash
 swaggerGen -c ./swaggerConfig.json
+swaggerGen -c ./swaggerConfig.json -t # load {cwd}/tsconfig.json
+swaggerGen -c ./swaggerConfig.json -p ./tsconfig.json # load custom tsconfig.json
 ```
 
 Where the [swaggerConfig.json](#swaggerconfigjson) file, contains settings about the swagger generation. For example:
@@ -42,6 +45,21 @@ Where the [swaggerConfig.json](#swaggerconfigjson) file, contains settings about
 }
 ```
 
+Where the [tsconfig.json](https://www.typescriptlang.org/docs/handbook/tsconfig-json.html) file contains compilerOptions. For example:
+
+```json
+{
+    "compilerOptions": {
+        "baseUrl": ".",
+        "paths": {
+            "@/*": ["src/*"]
+        }
+    }
+}
+```
+
+For example above options are required for `swaggerGen` to understand relative imports like `import something from '@/something'`.
+
 ### Swagger Decorators
 
 The documentation will be generated consulting all [typescript-rest](https://github.com/thiagobustamante/typescript-rest) decorators present on your code.

src/cli.ts

@@ -1,6 +1,8 @@
 #!/usr/bin/env node
 'use strict';
 
+import { isAbsolute, join } from 'path';
+import * as ts from 'typescript';
 import { ArgumentParser } from 'argparse';
 import { Config, SwaggerConfig } from './config';
 import { MetadataGenerator } from './metadata/metadataGenerator';
@@ -27,11 +29,29 @@ parser.addArgument(
     }
 );
 
+parser.addArgument(
+    ['-t', '--tsconfig'],
+    {
+        action: 'storeTrue',
+        defaultValue: false,
+        help: 'Load tsconfig.json file',
+    }
+);
+
+parser.addArgument(
+    ['-p', '--tsconfig_path'],
+    {
+        help: 'The tsconfig file (tsconfig.json) path. Default to {cwd}/tsconfig.json.',
+    }
+);
+
 const parameters = parser.parseArgs();
 const config = getConfig(parameters.config);
+const compilerOptions = getCompilerOptions(parameters.tsconfig, parameters.tsconfig_path);
 
 const swaggerConfig = validateSwaggerConfig(config.swagger);
-const metadata = new MetadataGenerator(swaggerConfig.entryFile).generate();
+
+const metadata = new MetadataGenerator(swaggerConfig.entryFile, compilerOptions).generate();
 new SpecGenerator(metadata, swaggerConfig).generate(swaggerConfig.outputDirectory, swaggerConfig.yaml)
     .then(() => {
         console.info ('Generation completed.');
@@ -74,3 +94,40 @@ function validateSwaggerConfig(conf: SwaggerConfig): SwaggerConfig {
 
     return conf;
 }
+
+function getCompilerOptions(loadTsconfig: boolean, tsconfigPath?: string | null): ts.CompilerOptions {
+    if (!loadTsconfig && tsconfigPath) {
+        loadTsconfig = true;
+    }
+    if (!loadTsconfig) {
+        return {};
+    }
+    const cwd = process.cwd();
+    const defaultTsconfigPath = join(cwd, 'tsconfig.json');
+    tsconfigPath = tsconfigPath
+        ? getAbsolutePath(tsconfigPath, cwd)
+        : defaultTsconfigPath;
+    try {
+        const tsConfig = require(tsconfigPath);
+        if (!tsConfig) {
+            throw new Error('Invalid tsconfig');
+        }
+        return tsConfig.compilerOptions || {};
+    } catch (err) {
+        if (err.code === 'MODULE_NOT_FOUND') {
+            throw Error(`No tsconfig file found at '${tsconfigPath}'`);
+        } else if (err.name === 'SyntaxError') {
+            throw Error(`Invalid JSON syntax in tsconfig at '${tsconfigPath}': ${err.message}`);
+        } else {
+            throw Error(`Unhandled error encountered loading tsconfig '${tsconfigPath}': ${err.message}`);
+        }
+    }
+}
+
+function getAbsolutePath(path: string, basePath: string): string {
+    if (isAbsolute(path)) {
+        return path;
+    } else {
+        return join(basePath, path);
+    }
+}

src/metadata/metadataGenerator.ts

@@ -9,8 +9,8 @@ export class MetadataGenerator {
     private referenceTypes: { [typeName: string]: ReferenceType } = {};
     private circularDependencyResolvers = new Array<(referenceTypes: { [typeName: string]: ReferenceType }) => void>();
 
-    constructor(entryFile: string) {
-        this.program = ts.createProgram([entryFile], {});
+    constructor(entryFile: string, compilerOptions: ts.CompilerOptions) {
+        this.program = ts.createProgram([entryFile], compilerOptions);
         this.typeChecker = this.program.getTypeChecker();
         MetadataGenerator.current = this;
     }

test/data/TestInterface.ts

@@ -0,0 +1,4 @@
+export interface TestInterface {
+  a: string;
+  b: number;
+}

test/data/apis.ts

@@ -10,6 +10,7 @@ import {
 } from 'typescript-rest';
 
 import * as swagger from '../../src/decorators';
+import { TestInterface } from '@/TestInterface'; // to test compilerOptions.paths
 
 interface Address {
     street: string;
@@ -91,6 +92,12 @@ export class MyService {
     ) {
         return;
     }
+
+    @POST
+    @Path('test-compiler-options')
+    async testCompilerOptions(payload: TestInterface): Promise<TestInterface> {
+        return { a: 'string', b: 123 };
+    }
 }
 
 class BaseService {

test/unit/definitions.spec.ts

@@ -9,7 +9,13 @@ const expect = chai.expect;
 const jsonata = require('jsonata');
 
 describe('Definition generation', () => {
-  const metadata = new MetadataGenerator('./test/data/apis.ts').generate();
+  const compilerOptions = {
+    baseUrl: '.',
+    paths: {
+      '@/*': ['test/data/*'],
+    },
+  };
+  const metadata = new MetadataGenerator('./test/data/apis.ts', compilerOptions).generate();
   const spec = new SpecGenerator(metadata, getDefaultOptions()).getSpec();
 
   describe('MyService', () => {
@@ -204,6 +210,24 @@ describe('Definition generation', () => {
       // tslint:disable-next-line:no-unused-expression
       expect(expression.evaluate(spec)).to.not.exist;
     });
+
+    it('should support compilerOptions', () => {
+      let expression = jsonata('definitions.TestInterface');
+      expect(expression.evaluate(spec)).to.eql({
+        description: '',
+        properties: {
+          a: { type: 'string', description: '' },
+          b: { type: 'number', format: 'double', description: '' }
+        },
+        required: [ 'a', 'b' ],
+        type: 'object',
+      });
+      expect(spec.paths).to.have.property('/mypath/test-compiler-options');
+      expression = jsonata('paths."/mypath/test-compiler-options".post.responses."200".schema');
+      expect(expression.evaluate(spec)).to.eql({ $ref: '#/definitions/TestInterface' });
+      expression = jsonata('paths."/mypath/test-compiler-options".post.parameters[0].schema');
+      expect(expression.evaluate(spec)).to.eql({ $ref: '#/definitions/TestInterface' });
+    });
   });
 
   describe('PrimitiveEndpoint', () => {