Rich tuples support

README.md

@@ -22,8 +22,7 @@ npm install --save ts-json-schema-generator
     --path 'my/project/**.*.ts' \
     --type 'My.Type.Full.Name' \
     --expose 'export' \
-    --jsDoc 'extended' \
-    --strictTuples
+    --jsDoc 'extended'
 ```
 
 ## Options
@@ -44,9 +43,6 @@ npm install --save ts-json-schema-generator
 
 -u, --unstable
     Do not sort properties.
-
--s, --strictTuples
-    Do not allow additional items on tuples.
 ```
 
 

factory/formatter.ts

@@ -15,8 +15,10 @@ import { LiteralUnionTypeFormatter } from "../src/TypeFormatter/LiteralUnionType
 import { NullTypeFormatter } from "../src/TypeFormatter/NullTypeFormatter";
 import { NumberTypeFormatter } from "../src/TypeFormatter/NumberTypeFormatter";
 import { ObjectTypeFormatter } from "../src/TypeFormatter/ObjectTypeFormatter";
+import { OptionalTypeFormatter } from "../src/TypeFormatter/OptionalTypeFormatter";
 import { PrimitiveUnionTypeFormatter } from "../src/TypeFormatter/PrimitiveUnionTypeFormatter";
 import { ReferenceTypeFormatter } from "../src/TypeFormatter/ReferenceTypeFormatter";
+import { RestTypeFormatter } from "../src/TypeFormatter/RestTypeFormatter";
 import { StringTypeFormatter } from "../src/TypeFormatter/StringTypeFormatter";
 import { TupleTypeFormatter } from "../src/TypeFormatter/TupleTypeFormatter";
 import { UndefinedTypeFormatter } from "../src/TypeFormatter/UndefinedTypeFormatter";
@@ -50,8 +52,11 @@ export function createFormatter(config: Config): TypeFormatter {
         .addTypeFormatter(new PrimitiveUnionTypeFormatter())
         .addTypeFormatter(new LiteralUnionTypeFormatter())
 
+        .addTypeFormatter(new OptionalTypeFormatter(circularReferenceTypeFormatter))
+        .addTypeFormatter(new RestTypeFormatter(circularReferenceTypeFormatter))
+
         .addTypeFormatter(new ArrayTypeFormatter(circularReferenceTypeFormatter))
-        .addTypeFormatter(new TupleTypeFormatter(circularReferenceTypeFormatter, config))
+        .addTypeFormatter(new TupleTypeFormatter(circularReferenceTypeFormatter))
         .addTypeFormatter(new UnionTypeFormatter(circularReferenceTypeFormatter))
         .addTypeFormatter(new IntersectionTypeFormatter(circularReferenceTypeFormatter));
 

factory/parser.ts

@@ -23,7 +23,9 @@ import { NullLiteralNodeParser } from "../src/NodeParser/NullLiteralNodeParser";
 import { NumberLiteralNodeParser } from "../src/NodeParser/NumberLiteralNodeParser";
 import { NumberTypeNodeParser } from "../src/NodeParser/NumberTypeNodeParser";
 import { ObjectTypeNodeParser } from "../src/NodeParser/ObjectTypeNodeParser";
+import { OptionalTypeNodeParser } from "../src/NodeParser/OptionalTypeNodeParser";
 import { ParenthesizedNodeParser } from "../src/NodeParser/ParenthesizedNodeParser";
+import { RestTypeNodeParser } from "../src/NodeParser/RestTypeNodeParser";
 import { StringLiteralNodeParser } from "../src/NodeParser/StringLiteralNodeParser";
 import { StringTypeNodeParser } from "../src/NodeParser/StringTypeNodeParser";
 import { TupleNodeParser } from "../src/NodeParser/TupleNodeParser";
@@ -88,6 +90,8 @@ export function createParser(program: ts.Program, config: Config): NodeParser {
         .addNodeParser(new UnionNodeParser(typeChecker, chainNodeParser))
         .addNodeParser(new IntersectionNodeParser(typeChecker, chainNodeParser))
         .addNodeParser(new TupleNodeParser(typeChecker, chainNodeParser))
+        .addNodeParser(new OptionalTypeNodeParser(chainNodeParser))
+        .addNodeParser(new RestTypeNodeParser(chainNodeParser))
 
         .addNodeParser(new CallExpressionParser(typeChecker, chainNodeParser))
 

package.json

@@ -89,6 +89,7 @@
       "src"
     ],
     "coverageDirectory": "./coverage/",
-    "collectCoverage": false
+    "collectCoverage": false,
+    "testEnvironment": "node"
   }
 }

src/NodeParser/OptionalTypeNodeParser.ts

@@ -0,0 +1,20 @@
+import * as ts from "typescript";
+import { Context, NodeParser } from "../NodeParser";
+import { SubNodeParser } from "../SubNodeParser";
+import { BaseType } from "../Type/BaseType";
+import { OptionalType } from "../Type/OptionalType";
+
+export class OptionalTypeNodeParser implements SubNodeParser {
+    public constructor(
+        private childNodeParser: NodeParser,
+    ) {
+    }
+    public supportsNode(node: ts.OptionalTypeNode): boolean {
+        return node.kind === ts.SyntaxKind.OptionalType;
+    }
+    public createType(node: ts.OptionalTypeNode, context: Context): BaseType {
+        return new OptionalType(
+            this.childNodeParser.createType(node.type, context),
+        );
+    }
+}

src/NodeParser/RestTypeNodeParser.ts

@@ -0,0 +1,21 @@
+import * as ts from "typescript";
+import { Context, NodeParser } from "../NodeParser";
+import { SubNodeParser } from "../SubNodeParser";
+import { ArrayType } from "../Type/ArrayType";
+import { BaseType } from "../Type/BaseType";
+import { RestType } from "../Type/RestType";
+
+export class RestTypeNodeParser implements SubNodeParser {
+    public constructor(
+        private childNodeParser: NodeParser,
+    ) {
+    }
+    public supportsNode(node: ts.RestTypeNode): boolean {
+        return node.kind === ts.SyntaxKind.RestType;
+    }
+    public createType(node: ts.RestTypeNode, context: Context): BaseType {
+        return new RestType(
+            this.childNodeParser.createType(node.type, context) as ArrayType,
+        );
+    }
+}

src/Schema/Definition.ts

@@ -13,9 +13,7 @@ export interface Definition {
     items?: Definition | Definition[];
     minItems?: number;
     maxItems?: number;
-    additionalItems?: {
-        anyOf: Definition[],
-    };
+    additionalItems?: Definition;
     enum?: (RawType | Definition)[];
     default?: RawType | Object;
     additionalProperties?: false | Definition;

src/Type/OptionalType.ts

@@ -0,0 +1,17 @@
+import { BaseType } from "./BaseType";
+
+export class OptionalType extends BaseType {
+    public constructor(
+        private item: BaseType,
+    ) {
+        super();
+    }
+
+    public getId(): string {
+        return this.item.getId() + "?";
+    }
+
+    public getType(): BaseType {
+        return this.item;
+    }
+}

src/Type/RestType.ts

@@ -0,0 +1,18 @@
+import { ArrayType } from "./ArrayType";
+import { BaseType } from "./BaseType";
+
+export class RestType extends BaseType {
+    public constructor(
+        private item: ArrayType,
+    ) {
+        super();
+    }
+
+    public getId(): string {
+        return "..." + this.item.getId();
+    }
+
+    public getType(): ArrayType {
+        return this.item;
+    }
+}

src/TypeFormatter/OptionalTypeFormatter.ts

@@ -0,0 +1,22 @@
+import { Definition } from "../Schema/Definition";
+import { SubTypeFormatter } from "../SubTypeFormatter";
+import { BaseType } from "../Type/BaseType";
+import { OptionalType } from "../Type/OptionalType";
+import { TypeFormatter } from "../TypeFormatter";
+
+export class OptionalTypeFormatter implements SubTypeFormatter {
+    public constructor(
+        private childTypeFormatter: TypeFormatter,
+    ) {
+    }
+
+    public supportsType(type: OptionalType): boolean {
+        return type instanceof OptionalType;
+    }
+    public getDefinition(type: OptionalType): Definition {
+        return this.childTypeFormatter.getDefinition(type.getType());
+    }
+    public getChildren(type: OptionalType): BaseType[] {
+        return this.childTypeFormatter.getChildren(type.getType());
+    }
+}

src/TypeFormatter/RestTypeFormatter.ts

@@ -0,0 +1,22 @@
+import { Definition } from "../Schema/Definition";
+import { SubTypeFormatter } from "../SubTypeFormatter";
+import { BaseType } from "../Type/BaseType";
+import { RestType } from "../Type/RestType";
+import { TypeFormatter } from "../TypeFormatter";
+
+export class RestTypeFormatter implements SubTypeFormatter {
+    public constructor(
+        private childTypeFormatter: TypeFormatter,
+    ) {
+    }
+
+    public supportsType(type: RestType): boolean {
+        return type instanceof RestType;
+    }
+    public getDefinition(type: RestType): Definition {
+        return this.childTypeFormatter.getDefinition(type.getType());
+    }
+    public getChildren(type: RestType): BaseType[] {
+        return this.childTypeFormatter.getChildren(type.getType());
+    }
+}

src/TypeFormatter/TupleTypeFormatter.ts

@@ -1,29 +1,42 @@
-import { Config } from "../Config";
 import { Definition } from "../Schema/Definition";
 import { SubTypeFormatter } from "../SubTypeFormatter";
 import { BaseType } from "../Type/BaseType";
+import { OptionalType } from "../Type/OptionalType";
+import { RestType } from "../Type/RestType";
 import { TupleType } from "../Type/TupleType";
 import { TypeFormatter } from "../TypeFormatter";
 
 export class TupleTypeFormatter implements SubTypeFormatter {
     public constructor(
         private childTypeFormatter: TypeFormatter,
-        private config: Config,
     ) {
     }
 
     public supportsType(type: TupleType): boolean {
         return type instanceof TupleType;
     }
     public getDefinition(type: TupleType): Definition {
-        const tupleDefinitions = type.getTypes().map((item) => this.childTypeFormatter.getDefinition(item));
-        const addAdditionalItems = tupleDefinitions.length > 1 && !this.config.strictTuples;
-        const additionalItems = {additionalItems: {anyOf: tupleDefinitions}};
+        const subTypes = type.getTypes();
+
+        const requiredElements = subTypes.filter(t => !(t instanceof OptionalType) && !(t instanceof RestType));
+        const optionalElements  = subTypes.filter(t => t instanceof OptionalType) as OptionalType[];
+        const restElements = subTypes.filter(t => t instanceof RestType) as RestType[];
+
+        const requiredDefinitions = requiredElements.map((item) => this.childTypeFormatter.getDefinition(item));
+        const optionalDefinitions = optionalElements.map((item) => this.childTypeFormatter.getDefinition(item));
+        const itemsTotal = requiredDefinitions.length + optionalDefinitions.length;
+
+        const restType = restElements.length ? restElements[0].getType().getItem() : undefined;
+        const restDefinition = restType ? this.childTypeFormatter.getDefinition(restType) : undefined;
+
         return {
             type: "array",
-            items: tupleDefinitions,
-            minItems: tupleDefinitions.length,
-            ...(addAdditionalItems ? additionalItems : {maxItems: tupleDefinitions.length}),
+            minItems: requiredDefinitions.length,
+            ...(itemsTotal ? { items: requiredDefinitions.concat(optionalDefinitions) } : {}), // with items
+            ...(!itemsTotal && restDefinition ? { items: restDefinition } : {}), // with only rest param
+            ...(!itemsTotal && !restDefinition ? { maxItems: 0 } : {}), // empty
+            ...(restDefinition && itemsTotal ? { additionalItems: restDefinition } : {}), // with items and rest
+            ...(!restDefinition && itemsTotal ? { maxItems: itemsTotal } : {}), // without rest
         };
     }
     public getChildren(type: TupleType): BaseType[] {

test/config.test.ts

@@ -61,19 +61,4 @@ describe("config", () => {
 
     assertSchema("jsdoc-hide", {type: "MyObject", expose: "export", topRef: true, jsDoc: "extended"});
     assertSchema("jsdoc-inheritance", {type: "MyObject", expose: "export", topRef: true, jsDoc: "extended"});
-
-    assertSchema("strict-tuples-true", {
-        type: "MyObject",
-        expose: "export",
-        topRef: true,
-        jsDoc: "none",
-        strictTuples: true,
-    });
-    assertSchema("strict-tuples-false", {
-        type: "MyObject",
-        expose: "export",
-        topRef: true,
-        jsDoc: "none",
-        strictTuples: false,
-    });
 });

test/valid-data.test.ts

@@ -92,12 +92,17 @@ describe("valid-data", () => {
     assertSchema("type-aliases-object", "MyAlias");
     assertSchema("type-aliases-mixed", "MyObject");
     assertSchema("type-aliases-union", "MyUnion");
-    assertSchema("type-aliases-tuple", "MyTuple");
     assertSchema("type-aliases-anonymous", "MyObject");
     assertSchema("type-aliases-local-namespace", "MyObject");
     assertSchema("type-aliases-recursive-anonymous", "MyAlias");
     assertSchema("type-aliases-recursive-export", "MyObject");
 
+    assertSchema("type-aliases-tuple", "MyTuple");
+    assertSchema("type-aliases-tuple-empty", "MyTuple");
+    assertSchema("type-aliases-tuple-optional-items", "MyTuple");
+    assertSchema("type-aliases-tuple-rest", "MyTuple");
+    assertSchema("type-aliases-tuple-only-rest", "MyTuple");
+
     assertSchema("type-maps", "MyObject");
     assertSchema("type-primitives", "MyObject");
     assertSchema("type-union", "TypeUnion");

test/valid-data/type-aliases-tuple-empty/main.ts

@@ -0,0 +1 @@
+export type MyTuple = [];

test/valid-data/type-aliases-tuple-empty/schema.json

@@ -0,0 +1,11 @@
+{
+    "$ref": "#/definitions/MyTuple",
+    "$schema": "http://json-schema.org/draft-06/schema#",
+    "definitions": {
+      "MyTuple": {
+        "maxItems": 0,
+        "minItems": 0,
+        "type": "array"
+      }
+    }
+  }

test/valid-data/type-aliases-tuple-only-rest/main.ts

@@ -0,0 +1 @@
+export type MyTuple = [...string[]];