add support for a types array

factory/parser.ts

@@ -62,6 +62,7 @@ import { SatisfiesNodeParser } from "../src/NodeParser/SatisfiesNodeParser.js";
 import { PromiseNodeParser } from "../src/NodeParser/PromiseNodeParser.js";
 import { SpreadElementNodeParser } from "../src/NodeParser/SpreadElementNodeParser.js";
 import { IdentifierNodeParser } from "../src/NodeParser/IdentifierNodeParser.js";
+import { castArray } from "../src/Utils/castArray.js";
 
 export type ParserAugmentor = (parser: MutableParser) => void;
 
@@ -73,7 +74,10 @@ export function createParser(program: ts.Program, config: CompletedConfig, augme
         return new ExposeNodeParser(typeChecker, nodeParser, config.expose, config.jsDoc);
     }
     function withTopRef(nodeParser: NodeParser): NodeParser {
-        return new TopRefNodeParser(chainNodeParser, config.type, config.topRef);
+        const typeArr = castArray(config.type);
+        // If we have multiple types, don't set a top-level $ref.
+        const topRefFullName = typeArr && typeArr.length === 1 ? typeArr[0] : undefined;
+        return new TopRefNodeParser(chainNodeParser, topRefFullName, config.topRef);
     }
     function withJsDoc(nodeParser: SubNodeParser): SubNodeParser {
         const extraTags = new Set(config.extraTags);

src/Config.ts

@@ -9,9 +9,10 @@ export interface Config {
 
     /**
      * Name of the type/interface to generate schema for.
+     * Can specify more than once to generate multiple schemas.
      * Use "*" to generate schemas for all exported types.
      */
-    type?: string;
+    type?: string | string[];
 
     /**
      * Minify the output JSON schema (no whitespace).

src/SchemaGenerator.ts

@@ -10,6 +10,7 @@ import type { TypeFormatter } from "./TypeFormatter.js";
 import type { StringMap } from "./Utils/StringMap.js";
 import { hasJsDocTag } from "./Utils/hasJsDocTag.js";
 import { removeUnreachable } from "./Utils/removeUnreachable.js";
+import { castArray } from "./Utils/castArray.js";
 import { symbolAtNode } from "./Utils/symbolAtNode.js";
 
 export class SchemaGenerator {
@@ -20,8 +21,8 @@ export class SchemaGenerator {
         protected readonly config?: Config,
     ) {}
 
-    public createSchema(fullName?: string): Schema {
-        const rootNodes = this.getRootNodes(fullName);
+    public createSchema(fullNames?: string | string[]): Schema {
+        const rootNodes = this.getRootNodes(castArray(fullNames));
         return this.createSchemaFromNodes(rootNodes);
     }
 
@@ -60,9 +61,11 @@ export class SchemaGenerator {
         };
     }
 
-    protected getRootNodes(fullName: string | undefined): ts.Node[] {
-        if (fullName && fullName !== "*") {
-            return [this.findNamedNode(fullName)];
+    protected getRootNodes(fullNames: string[] | undefined): ts.Node[] {
+        // ["*"] means generate everything.
+        const generateAll = !fullNames || (fullNames && fullNames.length === 1 && fullNames[0] === "*");
+        if (!generateAll) {
+            return fullNames.map((name) => this.findNamedNode(name));
         }
 
         const rootFileNames = this.program.getRootFileNames();

src/Utils/castArray.ts

@@ -0,0 +1,7 @@
+export function castArray<T>(input: undefined | T | T[]): undefined | T[] {
+    if (input === undefined) {
+        return undefined;
+    }
+
+    return Array.isArray(input) ? input : [input];
+}

test/config.test.ts

@@ -20,13 +20,14 @@ import { EnumType } from "../src/Type/EnumType.js";
 import { FunctionType } from "../src/Type/FunctionType.js";
 import { StringType } from "../src/Type/StringType.js";
 import type { TypeFormatter } from "../src/TypeFormatter.js";
+import { castArray } from "../src/Utils/castArray.js";
 import { uniqueArray } from "../src/Utils/uniqueArray.js";
 
 const basePath = "test/config";
 
 function assertSchema(
     name: string,
-    userConfig: Config & { type: string },
+    userConfig: Config & { type: string | string[] },
     tsconfig?: boolean,
     formatterAugmentor?: FormatterAugmentor,
     parserAugmentor?: ParserAugmentor,
@@ -51,7 +52,7 @@ function assertSchema(
             config,
         );
 
-        const schema = generator.createSchema(config.type);
+        const schema = generator.createSchema(castArray(config.type));
         const schemaFile = resolve(`${basePath}/${name}/schema.json`);
 
         if (process.env.UPDATE_SCHEMA) {
@@ -390,6 +391,20 @@ describe("config", () => {
         }),
     );
 
+    it(
+        "multiple-types",
+        assertSchema("multiple-types", {
+            type: ["MyObject1", "MyObject2"],
+        }),
+    );
+
+    it(
+        "multiple-types-all",
+        assertSchema("multiple-types-all", {
+            type: ["MyObject1", "MyObject2", "Object1Prop", "Object2Prop"],
+        }),
+    );
+
     it(
         "mapped-intersection",
         assertSchema("mapped-intersection", {

test/config/multiple-types-all/main.ts

@@ -0,0 +1,30 @@
+type NonExportedType = {
+    misc: number;
+};
+
+export type ExportedType = {
+    val: string;
+    val2: NonExportedType;
+};
+
+export interface ExportedInterface {
+    val: string;
+}
+
+export type Object1Prop = {
+    name: string;
+};
+
+export type Object2Prop = {
+    description: string;
+};
+
+export type MyObject1 = {
+    id: number;
+    bar: Object1Prop;
+};
+
+export type MyObject2 = {
+    idStr: string;
+    baz: Object2Prop;
+};

test/config/multiple-types-all/schema.json

@@ -0,0 +1,61 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "definitions": {
+    "MyObject1": {
+      "properties": {
+        "id": {
+          "type": "number"
+        },
+        "bar": {
+          "$ref": "#/definitions/Object1Prop"
+        }
+      },
+      "required": [
+        "id",
+        "bar"
+      ],
+      "type": "object",
+      "additionalProperties": false
+    },
+    "MyObject2": {
+      "properties": {
+        "idStr": {
+          "type": "string"
+        },
+        "baz": {
+          "$ref": "#/definitions/Object2Prop"
+        }
+      },
+      "required": [
+        "idStr",
+        "baz"
+      ],
+      "type": "object",
+      "additionalProperties": false
+    },
+    "Object1Prop": {
+      "properties": {
+        "name": {
+          "type": "string"
+        }
+      },
+      "required": [
+        "name"
+      ],
+      "type": "object",
+      "additionalProperties": false
+    },
+    "Object2Prop": {
+      "properties": {
+        "description": {
+          "type": "string"
+        }
+      },
+      "required": [
+        "description"
+      ],
+      "type": "object",
+      "additionalProperties": false
+    }
+  }
+}

test/config/multiple-types/main.ts

@@ -0,0 +1,31 @@
+type NonExportedType = {
+    misc: number;
+};
+
+export type ExportedType = {
+    val: string;
+    val2: NonExportedType;
+};
+
+export interface ExportedInterface {
+    val: string;
+}
+
+// Exported, so we include it as a root node
+export type Object1Prop = {
+    name: string;
+};
+
+type Object2Prop = {
+    description: string;
+};
+
+export type MyObject1 = {
+    id: number;
+    bar: Object1Prop;
+};
+
+export type MyObject2 = {
+    idStr: string;
+    baz: Object2Prop;
+};

test/config/multiple-types/schema.json

@@ -0,0 +1,58 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "definitions": {
+    "MyObject1": {
+      "properties": {
+        "id": {
+          "type": "number"
+        },
+        "bar": {
+          "$ref": "#/definitions/Object1Prop"
+        }
+      },
+      "required": [
+        "id",
+        "bar"
+      ],
+      "type": "object",
+      "additionalProperties": false
+    },
+    "MyObject2": {
+      "properties": {
+        "idStr": {
+          "type": "string"
+        },
+        "baz": {
+          "properties": {
+            "description": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "description"
+          ],
+          "type": "object",
+          "additionalProperties": false
+        }
+      },
+      "required": [
+        "idStr",
+        "baz"
+      ],
+      "type": "object",
+      "additionalProperties": false
+    },
+    "Object1Prop": {
+      "properties": {
+        "name": {
+          "type": "string"
+        }
+      },
+      "required": [
+        "name"
+      ],
+      "type": "object",
+      "additionalProperties": false
+    }
+  }
+}

ts-json-schema-generator.ts

@@ -8,10 +8,20 @@ import type { Config } from "./src/Config.js";
 import { BaseError } from "./src/Error/BaseError.js";
 
 import pkg from "./package.json";
+import { castArray } from "./src/Utils/castArray.js";
 
 const args = new Command()
     .option("-p, --path <path>", "Source file path")
-    .option("-t, --type <name>", "Type name")
+    .option(
+        "-t, --type <name>",
+        "Type name (can be passed multiple times)",
+        (value: string, previous: string[] | undefined) => {
+            if (previous) {
+                return previous.concat(value);
+            }
+            return [value];
+        },
+    )
     .option("-i, --id <name>", "$id for generated schema")
     .option("-f, --tsconfig <path>", "Custom tsconfig.json path")
     .addOption(
@@ -84,7 +94,7 @@ const config: Config = {
 };
 
 try {
-    const schema = createGenerator(config).createSchema(args.type);
+    const schema = createGenerator(config).createSchema(castArray(args.type));
 
     const stringify = config.sortProps ? stableStringify : JSON.stringify;
     // need as string since TS can't figure out that the string | undefined case doesn't happen