feat: support booleanish schemas & additionalProperties

Author: P0lip

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.yaml

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

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

@@ -0,0 +1,2 @@
+type: array
+additionalItems: false

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

@@ -0,0 +1,6 @@
+type: array
+additionalItems:
+  type: object
+  properties:
+    baz:
+      type: number

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

@@ -0,0 +1,2 @@
+type: array
+additionalItems: true

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

@@ -823,7 +823,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 +1255,53 @@ 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
+"
+`;
+
+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
+"
+`;
+
 exports[`SchemaTree output should generate valid tree for references/base.json 1`] = `
 "└─ #
    ├─ types

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/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);

src/nodes/RootNode.ts

@@ -7,7 +7,7 @@ export class RootNode extends BaseNode {
   public readonly children: SchemaNode[];
 
   constructor(public readonly fragment: SchemaFragment) {
-    super(fragment);
+    super();
     this.children = [];
   }
 }

src/nodes/mirrored/MirroredReferenceNode.ts

@@ -1,9 +1,13 @@
+import type { SchemaFragment } from '../../types';
 import { BaseNode } from '../BaseNode';
 import type { ReferenceNode } from '../ReferenceNode';
 
 export class MirroredReferenceNode extends BaseNode implements ReferenceNode {
+  public readonly fragment: SchemaFragment;
+
   constructor(public readonly mirroredNode: ReferenceNode) {
-    super(mirroredNode.fragment);
+    super();
+    this.fragment = mirroredNode.fragment;
   }
 
   get error() {

src/nodes/mirrored/MirroredRegularNode.ts

@@ -1,15 +1,17 @@
 import type { Dictionary } from '@stoplight/types';
 
-import { isRegularNode } from '../../guards';
+import { isReferenceNode, isRegularNode } from '../../guards';
 import type { SchemaFragment } from '../../types';
 import { isNonNullable } from '../../utils';
 import { BaseNode } from '../BaseNode';
+import { BooleanishNode } from '../BooleanishNode';
 import type { ReferenceNode } from '../ReferenceNode';
 import type { RegularNode } from '../RegularNode';
 import type { SchemaAnnotations, SchemaCombinerName, SchemaNodeKind } from '../types';
 import { MirroredReferenceNode } from './MirroredReferenceNode';
 
 export class MirroredRegularNode extends BaseNode implements RegularNode {
+  public readonly fragment: SchemaFragment;
   public readonly $id!: string | null;
   public readonly types!: SchemaNodeKind[] | null;
   public readonly primaryType!: SchemaNodeKind | null;
@@ -28,10 +30,14 @@ export class MirroredRegularNode extends BaseNode implements RegularNode {
   public readonly simple!: boolean;
   public readonly unknown!: boolean;
 
-  private readonly cache: WeakMap<RegularNode | ReferenceNode, MirroredRegularNode | MirroredReferenceNode>;
+  private readonly cache: WeakMap<
+    RegularNode | BooleanishNode | ReferenceNode,
+    MirroredRegularNode | BooleanishNode | MirroredReferenceNode
+  >;
 
   constructor(public readonly mirroredNode: RegularNode, context?: { originalFragment?: SchemaFragment }) {
-    super(mirroredNode.fragment);
+    super();
+    this.fragment = mirroredNode.fragment;
     this.originalFragment = context?.originalFragment ?? mirroredNode.originalFragment;
 
     this.cache = new WeakMap();
@@ -59,9 +65,9 @@ export class MirroredRegularNode extends BaseNode implements RegularNode {
 
   private readonly _this: MirroredRegularNode;
 
-  private _children?: (MirroredRegularNode | MirroredReferenceNode)[];
+  private _children?: (MirroredRegularNode | BooleanishNode | MirroredReferenceNode)[];
 
-  public get children(): (MirroredRegularNode | MirroredReferenceNode)[] | null | undefined {
+  public get children(): (MirroredRegularNode | BooleanishNode | MirroredReferenceNode)[] | null | undefined {
     const referencedChildren = this.mirroredNode.children;
 
     if (!isNonNullable(referencedChildren)) {
@@ -74,7 +80,7 @@ export class MirroredRegularNode extends BaseNode implements RegularNode {
       this._children.length = 0;
     }
 
-    const children: (MirroredRegularNode | MirroredReferenceNode)[] = this._children;
+    const children: (MirroredRegularNode | BooleanishNode | MirroredReferenceNode)[] = this._children;
     for (const child of referencedChildren) {
       // this is to avoid pointing at nested mirroring
       const cached = this.cache.get(child);
@@ -84,7 +90,11 @@ export class MirroredRegularNode extends BaseNode implements RegularNode {
         continue;
       }
 
-      const mirroredChild = isRegularNode(child) ? new MirroredRegularNode(child) : new MirroredReferenceNode(child);
+      const mirroredChild = isRegularNode(child)
+        ? new MirroredRegularNode(child)
+        : isReferenceNode(child)
+        ? new MirroredReferenceNode(child)
+        : new BooleanishNode(child.fragment);
 
       mirroredChild.parent = this._this;
       mirroredChild.subpath = child.subpath;

src/nodes/types.ts

@@ -1,3 +1,4 @@
+import type { BooleanishNode } from './BooleanishNode';
 import type { MirroredReferenceNode } from './mirrored/MirroredReferenceNode';
 import type { MirroredRegularNode } from './mirrored/MirroredRegularNode';
 import type { ReferenceNode } from './ReferenceNode';
@@ -6,7 +7,7 @@ import type { RootNode } from './RootNode';
 
 export type MirroredSchemaNode = MirroredRegularNode | MirroredReferenceNode;
 
-export type SchemaNode = RootNode | RegularNode | ReferenceNode | MirroredSchemaNode;
+export type SchemaNode = RootNode | RegularNode | BooleanishNode | ReferenceNode | MirroredSchemaNode;
 
 export enum SchemaNodeKind {
   Any = 'any',

src/utils/guards.ts

@@ -1,5 +1,7 @@
 import type { Dictionary } from '@stoplight/types';
 
+import type { SchemaFragment } from '../types';
+
 export function isStringOrNumber(value: unknown): value is number | string {
   return typeof value === 'string' || typeof value === 'number';
 }
@@ -23,3 +25,7 @@ export function isObjectLiteral(maybeObj: unknown): maybeObj is Dictionary<unkno
 export function isNonNullable<T = unknown>(maybeNullable: T): maybeNullable is NonNullable<T> {
   return maybeNullable !== void 0 && maybeNullable !== null;
 }
+
+export function isValidSchemaFragment(maybeSchemaFragment: unknown): maybeSchemaFragment is SchemaFragment {
+  return typeof maybeSchemaFragment === 'boolean' || isObjectLiteral(maybeSchemaFragment);
+}

src/walker/types.ts

@@ -13,7 +13,7 @@ export type WalkingOptions = {
 };
 
 export type WalkerSnapshot = {
-  readonly fragment: SchemaFragment;
+  readonly fragment: SchemaFragment | boolean;
   readonly depth: number;
   readonly schemaNode: RegularNode | RootNode;
   readonly path: string[];
@@ -23,7 +23,7 @@ export type WalkerHookAction = 'filter' | 'stepIn';
 export type WalkerHookHandler = (node: SchemaNode) => boolean;
 
 export type WalkerNodeEventHandler = (node: SchemaNode) => void;
-export type WalkerFragmentEventHandler = (node: SchemaFragment) => void;
+export type WalkerFragmentEventHandler = (node: SchemaFragment | boolean) => void;
 export type WalkerErrorEventHandler = (ex: Error) => void;
 
 export type WalkerEmitter = {