feat(JsonSchemaGenerator): Added buildGenerator function to expose the loaded JsonSchemaGenerator

Author: Zak Henry

test/programs/array-and-description/main.ts

@@ -1,6 +1,6 @@
 export interface MyObject {
   /**
-   * A name 
+   * A name
    */
   name?: string;
   description?: string;

test/programs/comments-override/main.ts

@@ -1,5 +1,5 @@
 
-/** 
+/**
  * Type-level description
  * @additionalProperties true
  */

test/programs/comments/main.ts

@@ -12,7 +12,7 @@ type Vector3D = number[];
  * Description of MyObject, a top level object,
  * which also has a comment that spans
  * multiple lines
- * 
+ *
  * @additionalProperties false
  * @unsupportedAnnotationThatShouldBeIgnored
  */

test/schema.test.ts

@@ -10,7 +10,7 @@ const ajv = new Ajv();
 const base = "test/programs/";
 
 export function assertSchema(group: string, name: string, type: string, settings: any = {}, compilerOptions?: CompilerOptions) {
-    it(group + " should create correct schema", function() {
+    it(group + " should create correct schema", () => {
         const defaults = TJS.getDefaultArgs();
         defaults.generateRequired = true;
 
@@ -34,7 +34,19 @@ export function assertSchema(group: string, name: string, type: string, settings
     });
 }
 
-describe("schema", function () {
+describe("interfaces", () => {
+    it("should return an instance of JsonSchemaGenerator", () => {
+
+        const defaults = TJS.getDefaultArgs();
+        const program = TJS.getProgramFromFiles([resolve(base + "array-and-description/main.ts")]);
+        const generator = TJS.buildGenerator(program, defaults);
+
+        assert.instanceOf(generator, TJS.JsonSchemaGenerator);
+        assert.doesNotThrow(() => generator.getSchemaForSymbol("MyObject"));
+    });
+});
+
+describe("schema", () => {
     assertSchema("array-and-description", "main.ts", "MyObject");
     assertSchema("class-single", "main.ts", "MyObject");
 

typescript-json-schema.ts

@@ -74,13 +74,15 @@ export class JsonSchemaGenerator {
     };
 
     private allSymbols: { [name: string]: ts.Type };
+    private userSymbols: { [name: string]: ts.Type };
     private inheritingTypes: { [baseName: string]: string[] };
     private tc: ts.TypeChecker;
 
     private reffedDefinitions: { [key: string]: Definition } = {};
 
-    constructor(allSymbols: { [name: string]: ts.Type }, inheritingTypes: { [baseName: string]: string[] }, tc: ts.TypeChecker, private args = getDefaultArgs()) {
+    constructor(allSymbols: { [name: string]: ts.Type }, userSymbols: { [name: string]: ts.Type }, inheritingTypes: { [baseName: string]: string[] }, tc: ts.TypeChecker, private args = getDefaultArgs()) {
         this.allSymbols = allSymbols;
+        this.userSymbols = userSymbols;
         this.inheritingTypes = inheritingTypes;
         this.tc = tc;
     }
@@ -674,6 +676,10 @@ export class JsonSchemaGenerator {
         }
         return root;
     }
+
+    public getUserSymbols(): { [name: string]: ts.Type } {
+        return this.userSymbols;
+    }
 }
 
 export function getProgramFromFiles(files: string[], compilerOptions: ts.CompilerOptions = {}): ts.Program {
@@ -689,7 +695,7 @@ export function getProgramFromFiles(files: string[], compilerOptions: ts.Compile
     return ts.createProgram(files, options);
 }
 
-export function generateSchema(program: ts.Program, fullTypeName: string, args = getDefaultArgs()) {
+export function buildGenerator(program: ts.Program, args = getDefaultArgs()): JsonSchemaGenerator {
     const typeChecker = program.getTypeChecker();
 
     var diagnostics = ts.getPreEmitDiagnostics(program);
@@ -704,10 +710,10 @@ export function generateSchema(program: ts.Program, fullTypeName: string, args =
             function inspect(node: ts.Node, tc: ts.TypeChecker) {
 
                 if (node.kind === ts.SyntaxKind.ClassDeclaration
-                    || node.kind === ts.SyntaxKind.InterfaceDeclaration
-                    || node.kind === ts.SyntaxKind.EnumDeclaration
-                    || node.kind === ts.SyntaxKind.TypeAliasDeclaration
-                    ) {
+                  || node.kind === ts.SyntaxKind.InterfaceDeclaration
+                  || node.kind === ts.SyntaxKind.EnumDeclaration
+                  || node.kind === ts.SyntaxKind.TypeAliasDeclaration
+                ) {
                     const symbol: ts.Symbol = (<any>node).symbol;
                     let fullName = tc.getFullyQualifiedName(symbol);
 
@@ -742,27 +748,33 @@ export function generateSchema(program: ts.Program, fullTypeName: string, args =
             inspect(sourceFile, typeChecker);
         });
 
-        const generator = new JsonSchemaGenerator(allSymbols, inheritingTypes, typeChecker, args);
-        let definition: Definition;
-        if (fullTypeName === "*") { // All types in file(s)
-            definition = generator.getSchemaForSymbols(userSymbols);
-        } else { // Use specific type as root object
-            definition = generator.getSchemaForSymbol(fullTypeName);
-        }
-        return definition;
+        return new JsonSchemaGenerator(allSymbols, userSymbols, inheritingTypes, typeChecker, args);
     } else {
         diagnostics.forEach((diagnostic) => {
             let message = ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
             if(diagnostic.file) {
-            let { line, character } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
-            console.warn(`${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}`);
+                let { line, character } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
+                console.warn(`${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}`);
             } else {
                 console.warn(message);
             }
         });
     }
 }
 
+export function generateSchema(program: ts.Program, fullTypeName: string, args = getDefaultArgs()) {
+
+    const generator = buildGenerator(program, args);
+
+    let definition: Definition;
+    if (fullTypeName === "*") { // All types in file(s)
+        definition = generator.getSchemaForSymbols(generator.getUserSymbols());
+    } else { // Use specific type as root object
+        definition = generator.getSchemaForSymbol(fullTypeName);
+    }
+    return definition;
+}
+
 export function programFromConfig(configFileName: string) {
     // basically a copy of https://github.com/Microsoft/TypeScript/blob/3663d400270ccae8b69cbeeded8ffdc8fa12d7ad/src/compiler/tsc.ts -> parseConfigFile
     const result = ts.parseConfigFileTextToJson(configFileName, ts.sys.readFile(configFileName));