feat: support booleanish schemas & represent additional{Items,Properties}

jest.config.js

@@ -1,6 +1,7 @@
 module.exports = {
   rootDir: process.cwd(),
   testEnvironment: 'node',
+  roots: ['<rootDir>/src'],
   setupFilesAfterEnv: ['./setupTests.ts'],
   testMatch: ['<rootDir>/src/**/__tests__/*.(ts|js)?(x)'],
   transform: {

src/__tests__/__fixtures__/arrays/additional-empty.json

@@ -0,0 +1,4 @@
+{
+  "type": "array",
+  "additionalItems": {}
+}

src/__tests__/__fixtures__/arrays/additional-false.json

@@ -0,0 +1,4 @@
+{
+  "type": "array",
+  "additionalItems": false
+}

src/__tests__/__fixtures__/arrays/additional-schema.json

@@ -0,0 +1,11 @@
+{
+  "type": "array",
+  "additionalItems": {
+    "type": "object",
+    "properties": {
+      "baz": {
+        "type": "number"
+      }
+    }
+  }
+}

src/__tests__/__fixtures__/arrays/additional-true.json

@@ -0,0 +1,4 @@
+{
+  "type": "array",
+  "additionalItems": true
+}

src/__tests__/__fixtures__/arrays/with-multiple-arrayish-items.json

@@ -17,10 +17,7 @@
           "type": "string"
         }
       },
-      "required": [
-        "code",
-        "msg"
-      ]
+      "required": ["code", "msg"]
     }
   ]
 }

src/__tests__/__fixtures__/arrays/with-single-arrayish-items.json

@@ -14,10 +14,7 @@
           "type": "string"
         }
       },
-      "required": [
-        "code",
-        "msg"
-      ]
+      "required": ["code", "msg"]
     }
   ]
 }

src/__tests__/__fixtures__/objects/additional-empty.json

@@ -0,0 +1,4 @@
+{
+  "type": "object",
+  "additionalProperties": {}
+}

src/__tests__/__fixtures__/objects/additional-false.json

@@ -0,0 +1,4 @@
+{
+  "type": "object",
+  "additionalProperties": false
+}

src/__tests__/__fixtures__/objects/additional-schema.json

@@ -0,0 +1,11 @@
+{
+  "type": "object",
+  "additionalProperties": {
+    "type": "object",
+    "properties": {
+      "baz": {
+        "type": "number"
+      }
+    }
+  }
+}

src/__tests__/__fixtures__/objects/additional-true.json

@@ -0,0 +1,4 @@
+{
+  "type": "object",
+  "additionalProperties": true
+}

src/__tests__/__snapshots__/tree.spec.ts.snap

@@ -296,6 +296,61 @@ exports[`SchemaTree output compound keywords given oneOf combiner placed next to
 "
 `;
 
+exports[`SchemaTree output should generate valid tree for arrays/additional-empty.json 1`] = `
+"└─ #
+   ├─ types
+   │  └─ 0: array
+   ├─ primaryType: array
+   └─ children
+      └─ 0
+         └─ #/additionalItems
+"
+`;
+
+exports[`SchemaTree output should generate valid tree for arrays/additional-false.json 1`] = `
+"└─ #
+   ├─ types
+   │  └─ 0: array
+   ├─ primaryType: array
+   └─ children
+      └─ 0
+         └─ #/additionalItems
+            └─ value: false
+"
+`;
+
+exports[`SchemaTree output should generate valid tree for arrays/additional-schema.json 1`] = `
+"└─ #
+   ├─ types
+   │  └─ 0: array
+   ├─ primaryType: array
+   └─ children
+      └─ 0
+         └─ #/additionalItems
+            ├─ types
+            │  └─ 0: object
+            ├─ primaryType: object
+            └─ children
+               └─ 0
+                  └─ #/additionalItems/properties/baz
+                     ├─ types
+                     │  └─ 0: number
+                     └─ primaryType: number
+"
+`;
+
+exports[`SchemaTree output should generate valid tree for arrays/additional-true.json 1`] = `
+"└─ #
+   ├─ types
+   │  └─ 0: array
+   ├─ primaryType: array
+   └─ children
+      └─ 0
+         └─ #/additionalItems
+            └─ value: true
+"
+`;
+
 exports[`SchemaTree output should generate valid tree for arrays/of-allofs.json 1`] = `
 "└─ #
    ├─ types
@@ -823,7 +878,16 @@ exports[`SchemaTree output should generate valid tree for combiners/allOfs/neste
       │  └─ #/properties/order
       │     ├─ types
       │     │  └─ 0: object
-      │     └─ primaryType: object
+      │     ├─ primaryType: object
+      │     └─ children
+      │        └─ 0
+      │           └─ #/properties/order/additionalProperties
+      │              ├─ types
+      │              │  └─ 0: string
+      │              ├─ primaryType: string
+      │              └─ enum
+      │                 ├─ 0: ASC
+      │                 └─ 1: DESC
       └─ 7
          └─ #/properties/nextToken
             ├─ types
@@ -1246,6 +1310,61 @@ exports[`SchemaTree output should generate valid tree for formats-schema.json 1`
 "
 `;
 
+exports[`SchemaTree output should generate valid tree for objects/additional-empty.json 1`] = `
+"└─ #
+   ├─ types
+   │  └─ 0: object
+   ├─ primaryType: object
+   └─ children
+      └─ 0
+         └─ #/additionalProperties
+"
+`;
+
+exports[`SchemaTree output should generate valid tree for objects/additional-false.json 1`] = `
+"└─ #
+   ├─ types
+   │  └─ 0: object
+   ├─ primaryType: object
+   └─ children
+      └─ 0
+         └─ #/additionalProperties
+            └─ value: false
+"
+`;
+
+exports[`SchemaTree output should generate valid tree for objects/additional-schema.json 1`] = `
+"└─ #
+   ├─ types
+   │  └─ 0: object
+   ├─ primaryType: object
+   └─ children
+      └─ 0
+         └─ #/additionalProperties
+            ├─ types
+            │  └─ 0: object
+            ├─ primaryType: object
+            └─ children
+               └─ 0
+                  └─ #/additionalProperties/properties/baz
+                     ├─ types
+                     │  └─ 0: number
+                     └─ primaryType: number
+"
+`;
+
+exports[`SchemaTree output should generate valid tree for objects/additional-true.json 1`] = `
+"└─ #
+   ├─ types
+   │  └─ 0: object
+   ├─ primaryType: object
+   └─ children
+      └─ 0
+         └─ #/additionalProperties
+            └─ value: true
+"
+`;
+
 exports[`SchemaTree output should generate valid tree for references/base.json 1`] = `
 "└─ #
    ├─ types

src/__tests__/tree.spec.ts

@@ -907,6 +907,34 @@ describe('SchemaTree', () => {
         tree.root.children[0].children[1].annotations.description,
       ).toEqual('_Everyone_ ~hates~ loves caves');
     });
+
+    it('should render true/false schemas', () => {
+      const schema = {
+        type: 'object',
+        properties: {
+          bear: true,
+          cave: false,
+        },
+      };
+
+      const tree = new SchemaTree(schema);
+      tree.populate();
+
+      expect(printTree(schema)).toMatchInlineSnapshot(`
+        "└─ #
+           ├─ types
+           │  └─ 0: object
+           ├─ primaryType: object
+           └─ children
+              ├─ 0
+              │  └─ #/properties/bear
+              │     └─ value: true
+              └─ 1
+                 └─ #/properties/cave
+                    └─ value: false
+        "
+      `);
+    });
   });
 
   describe('position', () => {

src/__tests__/utils/printTree.ts

@@ -2,8 +2,9 @@ import { pathToPointer } from '@stoplight/json';
 import type { Dictionary } from '@stoplight/types';
 import * as treeify from 'treeify';
 
-import { isMirroredNode, isReferenceNode, isRegularNode } from '../../guards';
+import { isBooleanishNode, isMirroredNode, isReferenceNode, isRegularNode, isRootNode } from '../../guards';
 import type { MirroredSchemaNode, ReferenceNode, RegularNode, SchemaNode } from '../../nodes';
+import type { BooleanishNode } from '../../nodes/BooleanishNode';
 import type { SchemaTreeOptions } from '../../tree';
 import { SchemaTree } from '../../tree';
 import type { SchemaFragment } from '../../types';
@@ -41,22 +42,30 @@ function printReferenceNode(node: ReferenceNode) {
   };
 }
 
+function printBooleanishNode(node: BooleanishNode) {
+  return {
+    value: node.fragment,
+  };
+}
+
 function printMirrorNode(node: MirroredSchemaNode): any {
   return {
     mirrors: pathToPointer(node.mirroredNode.path as string[]),
   };
 }
 
 function printNode(node: SchemaNode) {
-  return isMirroredNode(node)
-    ? printMirrorNode(node)
-    : isRegularNode(node)
-    ? printRegularNode(node)
-    : isReferenceNode(node)
-    ? printReferenceNode(node)
-    : {
-        kind: 'unknown node',
-      };
+  if (isMirroredNode(node)) {
+    return printMirrorNode(node);
+  } else if (isRegularNode(node)) {
+    return printRegularNode(node);
+  } else if (isReferenceNode(node)) {
+    return printReferenceNode(node);
+  } else if (isBooleanishNode(node)) {
+    return printBooleanishNode(node);
+  } else if (isRootNode(node)) {
+    return {};
+  }
 }
 
 function prepareTree(node: SchemaNode) {

src/accessors/getValidations.ts

@@ -12,8 +12,8 @@ const VALIDATION_TYPES: Partial<Dictionary<(keyof SchemaFragment)[], SchemaNodeK
   get integer() {
     return this.number;
   },
-  object: ['additionalProperties', 'minProperties', 'maxProperties'],
-  array: ['additionalItems', 'minItems', 'maxItems', 'uniqueItems'],
+  object: ['minProperties', 'maxProperties'],
+  array: ['minItems', 'maxItems', 'uniqueItems'],
 };
 
 function getTypeValidations(types: SchemaNodeKind[]): (keyof SchemaFragment)[] | null {

src/guards/nodes.ts

@@ -7,6 +7,7 @@ import {
   RootNode,
   SchemaNode,
 } from '../nodes';
+import type { BooleanishNode } from '../nodes/BooleanishNode';
 
 export function isSchemaNode(node: unknown): node is SchemaNode {
   const name = Object.getPrototypeOf(node).constructor.name;
@@ -34,3 +35,7 @@ export function isMirroredNode(node: SchemaNode): node is MirroredSchemaNode {
 export function isReferenceNode(node: SchemaNode): node is ReferenceNode {
   return 'external' in node && 'value' in node;
 }
+
+export function isBooleanishNode(node: SchemaNode): node is BooleanishNode {
+  return typeof node.fragment === 'boolean';
+}

src/nodes/BaseNode.ts

@@ -1,4 +1,3 @@
-import type { SchemaFragment } from '../types';
 import type { MirroredRegularNode } from './mirrored';
 import type { RegularNode } from './RegularNode';
 import type { RootNode } from './RootNode';
@@ -35,7 +34,7 @@ export abstract class BaseNode {
     return this.pos === this.parentChildren.length - 1;
   }
 
-  protected constructor(public readonly fragment: SchemaFragment) {
+  protected constructor() {
     this.id = String(SEED++);
     this.subpath = [];
   }

src/nodes/BooleanishNode.ts

@@ -0,0 +1,7 @@
+import { BaseNode } from './BaseNode';
+
+export class BooleanishNode extends BaseNode {
+  constructor(public readonly fragment: boolean) {
+    super();
+  }
+}

src/nodes/ReferenceNode.ts

@@ -7,8 +7,8 @@ import { BaseNode } from './BaseNode';
 export class ReferenceNode extends BaseNode {
   public readonly value: string | null;
 
-  constructor(fragment: SchemaFragment, public readonly error: string | null) {
-    super(fragment);
+  constructor(public readonly fragment: SchemaFragment, public readonly error: string | null) {
+    super();
 
     this.value = unwrapStringOrNull(fragment.$ref);
   }

src/nodes/RegularNode.ts

@@ -10,6 +10,7 @@ import { isDeprecated } from '../accessors/isDeprecated';
 import { unwrapArrayOrNull, unwrapStringOrNull } from '../accessors/unwrap';
 import type { SchemaFragment } from '../types';
 import { BaseNode } from './BaseNode';
+import type { BooleanishNode } from './BooleanishNode';
 import type { ReferenceNode } from './ReferenceNode';
 import { MirroredSchemaNode, SchemaAnnotations, SchemaCombinerName, SchemaNodeKind } from './types';
 
@@ -25,14 +26,14 @@ export class RegularNode extends BaseNode {
   public readonly title: string | null;
   public readonly deprecated: boolean;
 
-  public children: (RegularNode | ReferenceNode | MirroredSchemaNode)[] | null | undefined;
+  public children: (RegularNode | BooleanishNode | ReferenceNode | MirroredSchemaNode)[] | null | undefined;
 
   public readonly annotations: Readonly<Partial<Dictionary<unknown, SchemaAnnotations>>>;
   public readonly validations: Readonly<Dictionary<unknown>>;
   public readonly originalFragment: SchemaFragment;
 
   constructor(public readonly fragment: SchemaFragment, context?: { originalFragment?: SchemaFragment }) {
-    super(fragment);
+    super();
 
     this.$id = unwrapStringOrNull('id' in fragment ? fragment.id : fragment.$id);
     this.types = getTypes(fragment);