Fixes YousefED#107 by manually merging the objects into one.

Author: domoritz

test/programs/type-intersection/schema.json

@@ -1,43 +1,26 @@
 {
-    "type": "object",
+    "$schema": "http://json-schema.org/draft-04/schema#",
+    "additionalProperties": false,
     "properties": {
         "value": {
-            "allOf": [
-                {
-                    "$ref": "#/definitions/Type1"
-                },
-                {
-                    "$ref": "#/definitions/Type2"
-                }
-            ]
-        }
-    },
-    "required": [
-        "value"
-    ],
-    "definitions": {
-        "Type1": {
-            "type": "object",
+            "additionalProperties": false,
             "properties": {
                 "value1": {
                     "type": "string"
-                }
-            },
-            "required": [
-                "value1"
-            ]
-        },
-        "Type2": {
-            "type": "object",
-            "properties": {
+                },
                 "value2": {
                     "type": "number"
                 }
             },
             "required": [
+                "value1",
                 "value2"
-            ]
+            ],
+            "type": "object"
         }
     },
-    "$schema": "http://json-schema.org/draft-04/schema#"
-}
+    "required": [
+        "value"
+    ],
+    "type": "object"
+}

test/schema.test.ts

@@ -147,7 +147,9 @@ describe("schema", () => {
      */
 
     assertSchema("type-union", "main.ts", "MyObject");
-    assertSchema("type-intersection", "main.ts", "MyObject");
+    assertSchema("type-intersection", "main.ts", "MyObject", {
+        disableExtraProperties: true
+    });
     assertSchema("type-union-tagged", "main.ts", "Shape");
     assertSchema("type-aliases-union-namespace", "main.ts", "MyModel");
 

typescript-json-schema.ts

@@ -77,6 +77,28 @@ export type Definition = {
     typeof?: "function"
 };
 
+function extend(target: any, ..._: any[]) {
+    if (target == null) { // TypeError if undefined or null
+      throw new TypeError("Cannot convert undefined or null to object");
+    }
+
+    const to = Object(target);
+
+    for (var index = 1; index < arguments.length; index++) {
+      const nextSource = arguments[index];
+
+      if (nextSource != null) { // Skip over if undefined or null
+        for (const nextKey in nextSource) {
+          // Avoid bugs when hasOwnProperty is shadowed
+          if (Object.prototype.hasOwnProperty.call(nextSource, nextKey)) {
+            to[nextKey] = nextSource[nextKey];
+          }
+        }
+      }
+    }
+    return to;
+}
+
 export class JsonSchemaGenerator {
     /**
      * JSDoc keywords that should be used to annotate the JSON schema.
@@ -667,10 +689,22 @@ export class JsonSchemaGenerator {
                 if (typ.flags & ts.TypeFlags.Union) {
                     this.getUnionDefinition(typ as ts.UnionType, prop!, tc, unionModifier, definition);
                 } else if (typ.flags & ts.TypeFlags.Intersection) {
-                    definition.allOf = [];
+                    // extend object instead of using allOf because allOf does not work well with additional properties. See #107
+                    if (this.args.disableExtraProperties) {
+                        definition.additionalProperties = false;
+                    }
+
                     const types = (<ts.IntersectionType> typ).types;
                     for (let i = 0; i < types.length; ++i) {
-                        definition.allOf.push(this.getTypeDefinition(types[i], tc));
+                        const other = this.getTypeDefinition(types[i], tc, false);
+                        definition.type = other.type;  // should always be object
+                        definition.properties = extend(definition.properties || {}, other.properties);
+                        if (Object.keys(other.default || {}).length > 0) {
+                            definition.default = extend(definition.default || {}, other.default);
+                        }
+                        if (other.required) {
+                            definition.required = (definition.required || []).concat(other.required);
+                        }
                     }
                 } else if (isRawType) {
                     this.getDefinitionForRootType(typ, tc, reffedType!, definition);