fix: filter out invalid properties/items

Author: P0lip

src/tree/utils/__tests__/walk.spec.ts

@@ -0,0 +1,100 @@
+import { SchemaKind } from '../../../types';
+import { walk } from '../walk';
+
+describe('Schema Walker', () => {
+  describe('when type equals array', () => {
+    test.each(['[circular]', 2, null])('given invalid items, should normalize them %s', items => {
+      const schema = {
+        type: SchemaKind.Array,
+        items,
+      };
+      const { value: node } = walk(schema as any).next();
+
+      expect(node).toStrictEqual({
+        fragment: schema,
+        node: {
+          id: expect.any(String),
+          type: SchemaKind.Array,
+          annotations: {},
+          enum: void 0,
+          validations: {},
+          additionalItems: void 0,
+          items: void 0,
+        },
+      });
+    });
+
+    test.each([{ type: 'string' }, [{ type: 'number' }]])(
+      'given valid items, should leave them untouched %s',
+      items => {
+        const schema = {
+          type: SchemaKind.Array,
+          items,
+        };
+        const { value: node } = walk(schema as any).next();
+
+        expect(node).toStrictEqual({
+          fragment: schema,
+          node: {
+            id: expect.any(String),
+            type: SchemaKind.Array,
+            annotations: {},
+            enum: void 0,
+            validations: {},
+            additionalItems: void 0,
+            items,
+          },
+        });
+      },
+    );
+  });
+
+  describe('when type equals object', () => {
+    test.each(['[circular]', 2, null, [{}]])('given invalid properties, should normalize them %s', properties => {
+      const schema = {
+        type: SchemaKind.Object,
+        properties,
+      };
+      const { value: node } = walk(schema as any).next();
+
+      expect(node).toStrictEqual({
+        fragment: schema,
+        node: {
+          id: expect.any(String),
+          type: SchemaKind.Object,
+          annotations: {},
+          enum: void 0,
+          validations: {},
+          additionalProperties: void 0,
+          patternProperties: void 0,
+          properties: void 0,
+        },
+      });
+    });
+
+    test.each([{}, { foo: { type: 'string' } }])(
+      'given valid properties, should leave them untouched %s',
+      properties => {
+        const schema = {
+          type: SchemaKind.Object,
+          properties,
+        };
+        const { value: node } = walk(schema as any).next();
+
+        expect(node).toStrictEqual({
+          fragment: schema,
+          node: {
+            id: expect.any(String),
+            type: SchemaKind.Object,
+            annotations: {},
+            enum: void 0,
+            validations: {},
+            additionalProperties: void 0,
+            patternProperties: void 0,
+            properties,
+          },
+        });
+      },
+    );
+  });
+});

src/tree/utils/walk.ts

@@ -1,4 +1,6 @@
+import { Optional } from '@stoplight/types';
 import { JSONSchema4 } from 'json-schema';
+import { isObject as _isObject } from 'lodash';
 import { IArrayNode, IBaseNode, ICombinerNode, IObjectNode, SchemaKind, SchemaNode } from '../../types';
 import { flattenTypes } from '../../utils/flattenTypes';
 import { generateId } from '../../utils/generateId';
@@ -12,13 +14,17 @@ import { normalizeRequired } from '../../utils/normalizeRequired';
 function assignNodeSpecificFields(base: IBaseNode, node: JSONSchema4) {
   switch (getPrimaryType(node)) {
     case SchemaKind.Array:
-      (base as IArrayNode).items = node.items;
-      (base as IArrayNode).additionalItems = node.additionalItems;
+      (base as IArrayNode).items = unwrapItemsOrUndefined(node.items);
+      (base as IArrayNode).additionalItems =
+        typeof node.additionalItems === 'boolean' ? node.additionalItems : unwrapItemsOrUndefined(node.additionalItems);
       break;
     case SchemaKind.Object:
-      (base as IObjectNode).properties = node.properties;
-      (base as IObjectNode).patternProperties = node.patternProperties;
-      (base as IObjectNode).additionalProperties = node.additionalProperties;
+      (base as IObjectNode).properties = unwrapPropertiesOrUndefined(node.properties);
+      (base as IObjectNode).patternProperties = unwrapPropertiesOrUndefined(node.patternProperties);
+      (base as IObjectNode).additionalProperties =
+        typeof node.additionalProperties === 'boolean'
+          ? node.additionalProperties
+          : unwrapPropertiesOrUndefined(node.additionalProperties);
       break;
   }
 }
@@ -100,3 +106,11 @@ export function* walk(schema: JSONSchema4[] | JSONSchema4): IterableIterator<Wal
     }
   }
 }
+
+function unwrapItemsOrUndefined<T = unknown>(value: T): Optional<T> {
+  return _isObject(value) ? value : void 0;
+}
+
+function unwrapPropertiesOrUndefined<T = unknown>(value: T): Optional<T> {
+  return _isObject(value) && !Array.isArray(value) ? value : void 0;
+}

src/utils/guards.ts

@@ -10,6 +10,6 @@ export const isArrayNodeWithItems = (
 export const isRefNode = (node: SchemaNode): node is IRefNode => '$ref' in node;
 
 export const hasRefItems = (node: SchemaNode): node is Omit<IArrayNode, 'items'> & { items: Omit<IRefNode, 'id'> } =>
-  'items' in node && !!node.items && '$ref' in node.items;
+  isArrayNodeWithItems(node) && '$ref' in node.items;
 
 export const isCombinerNode = (node: SchemaNode): node is ICombinerNode => 'combiner' in node;