Merge 49348fb into 92185d7

docs/interpretation_of_JSON_Schema_draft_7.md

@@ -15,6 +15,7 @@ The order of transformation:
 - `properties` are determined as is, where duplicate properties for the model are merged.
 - [allOf](#allOf-sub-schemas)
 - `const` overwrite already interpreted `enums`.
+- `items` are determined as is, where more then 1 item are merged.
 - [oneOf/anyOf/then/else](#Processing-sub-schemas)
 
 ## allOf sub schemas

src/interpreter/InterpretItems.ts

@@ -0,0 +1,38 @@
+
+import { CommonModel } from '../models/CommonModel';
+import { Schema } from '../models/Schema';
+import { Interpreter } from './Interpreter';
+
+/**
+ * Interpreter function for JSON Schema draft 7 items keyword.
+ * 
+ * @param schema 
+ * @param model 
+ * @param interpreter 
+ */
+export default function interpretItems(schema: Schema | boolean, model: CommonModel, interpreter : Interpreter) {
+  if (typeof schema === 'boolean' || schema.items === undefined) return;
+  model.addTypes('array');
+  interpretArrayItems(schema, schema.items, model, interpreter);
+}
+
+/**
+ * Internal function to process all item schemas
+ *  
+ * @param rootSchema 
+ * @param itemSchemas 
+ * @param model 
+ * @param interpreter 
+ */
+function interpretArrayItems(rootSchema: Schema, itemSchemas: (Schema | boolean)[] | (Schema | boolean), model: CommonModel, interpreter : Interpreter) {
+  if (Array.isArray(itemSchemas)) {
+    for (const itemSchema of itemSchemas) {
+      interpretArrayItems(rootSchema, itemSchema, model, interpreter);
+    }
+  } else {
+    const itemModels = interpreter.interpret(itemSchemas);
+    if (itemModels.length > 0) {
+      model.addItem(itemModels[0], rootSchema);
+    }
+  }
+}

src/interpreter/Interpreter.ts

@@ -5,6 +5,7 @@ import interpretProperties from './InterpretProperties';
 import interpretAllOf from './InterpretAllOf';
 import interpretConst from './InterpretConst';
 import { Logger } from '../utils';
+import interpretItems from './InterpretItems';
 
 export class Interpreter {
   static defaultOptions: SimplificationOptions = {
@@ -78,7 +79,8 @@ export class Interpreter {
       }
 
       model.required = schema.required || model.required;
-
+
+      interpretItems(schema, model, this);
       interpretProperties(schema, model, this);
       interpretAllOf(schema, model, this);
       interpretConst(schema, model);

src/models/CommonModel.ts

@@ -82,6 +82,23 @@ export class CommonModel extends CommonSchema<CommonModel> {
     return this.required.includes(propertyName);
   }
 
+  /**
+   * Adds an item to the model.
+   * 
+   * If items already exist the two are merged.
+   * 
+   * @param itemModel 
+   * @param schema schema to the corresponding property model
+   */
+  addItem(itemModel: CommonModel, schema: Schema) {
+    if (this.items !== undefined) {
+      Logger.warn(`While trying to add item to model ${this.$id}, duplicate items found. Merging models together to form a unified item model.`, itemModel, schema, this);
+      this.items = CommonModel.mergeCommonModels(this.items as CommonModel, itemModel, schema);
+    } else {
+      this.items = itemModel;
+    }
+  }
+
   /**
    * Adds a property to the model.
    * If the property already exist the two are merged.

test/interpreter/Intepreter.spec.ts

@@ -3,6 +3,7 @@ import {isModelObject, interpretName} from '../../src/interpreter/Utils';
 import interpretProperties from '../../src/interpreter/InterpretProperties';
 import interpretConst from '../../src/interpreter/InterpretConst';
 import interpretAllOf from '../../src/interpreter/InterpretAllOf';
+import interpretItems from '../../src/interpreter/InterpretItems';
 import { CommonModel, Schema } from '../../src/models';
 
 let mockedIsModelObjectReturn = false;
@@ -17,6 +18,7 @@ jest.mock('../../src/interpreter/Utils', () => {
 jest.mock('../../src/interpreter/InterpretProperties');
 jest.mock('../../src/interpreter/InterpretConst');
 jest.mock('../../src/interpreter/InterpretAllOf');
+jest.mock('../../src/interpreter/InterpretItems');
 CommonModel.mergeCommonModels = jest.fn();
 /**
  * Some of these test are purely theoretical and have little if any merit 
@@ -176,6 +178,12 @@ describe('Interpreter', function() {
     interpreter.interpret(schema);
     expect(interpretAllOf).toHaveBeenNthCalledWith(1, schema, expect.anything(), expect.anything());
   });
+  test('should always try to interpret items', function() {
+    const schema = {};
+    const interpreter = new Interpreter();
+    interpreter.interpret(schema);
+    expect(interpretItems).toHaveBeenNthCalledWith(1, schema, expect.anything(), expect.anything());
+  });
 
   test('should support primitive roots', function() {
     const schema = { 'type': 'string' };

test/interpreter/InterpretItems.spec.ts

@@ -0,0 +1,86 @@
+/* eslint-disable no-undef */
+import { CommonModel } from '../../src/models/CommonModel';
+import { Interpreter } from '../../src/interpreter/Interpreter';
+import interpretItems from '../../src/interpreter/InterpretItems';
+let mockedReturnModels = [new CommonModel()];
+jest.mock('../../src/interpreter/Interpreter', () => {
+  return {
+    Interpreter: jest.fn().mockImplementation(() => {
+      return {
+        interpret: jest.fn().mockReturnValue(mockedReturnModels)
+      };
+    })
+  };
+});
+jest.mock('../../src/models/CommonModel');
+describe('Interpretation of', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockedReturnModels = [new CommonModel()];
+  });
+  afterAll(() => {
+    jest.restoreAllMocks();
+  })
+  test('should not do anything if schema does not contain items', function() {
+    const schema = {};
+    const model = new CommonModel();
+    const interpreter = new Interpreter();
+    interpretItems(schema, model, interpreter);
+    expect(model.type).toBeUndefined();
+    expect(model.addItem).not.toHaveBeenCalled();
+  });
+  test('should not do anything if schema is boolean', function() {
+    const schema = true;
+    const model = new CommonModel();
+    const interpreter = new Interpreter();
+    interpretItems(schema, model, interpreter);
+    expect(model.type).toBeUndefined();
+    expect(model.addItem).not.toHaveBeenCalled();
+    expect(JSON.stringify(model)).toEqual(JSON.stringify(new CommonModel()));
+  });
+
+  test('should ignore model if interpreter cannot interpret property schema', () => {
+    const schema: any = { items: { type: 'string' } };
+    const model = new CommonModel();
+    const interpreter = new Interpreter();
+    mockedReturnModels.pop();
+    interpretItems(schema, model, interpreter);
+    expect(model.type).toBeUndefined();
+    expect(model.addItem).not.toHaveBeenCalled();
+  });
+  describe('single item schemas', () => {
+    test('should set items', () => {
+      const schema: any = { items: { type: 'string' } };
+      const model = new CommonModel();
+      const interpreter = new Interpreter();
+      interpretItems(schema, model, interpreter);
+      expect(interpreter.interpret).toHaveBeenNthCalledWith(1, { type: 'string' });
+      expect(model.addItem).toHaveBeenNthCalledWith(1, mockedReturnModels[0], schema);
+    });
+    test('should infer type of model', () => {
+      const schema: any = { items: { type: 'string' } };
+      const model = new CommonModel();
+      const interpreter = new Interpreter();
+      interpretItems(schema, model, interpreter);
+      expect(model.addTypes).toHaveBeenNthCalledWith(1, 'array');
+    });
+  });
+  describe('multiple item schemas', () => {
+    test('should set items', () => {
+      const schema: any = { items: [{ type: 'string' }, { type: 'number' }] };
+      const model = new CommonModel();
+      const interpreter = new Interpreter();
+      interpretItems(schema, model, interpreter);
+      expect(interpreter.interpret).toHaveBeenNthCalledWith(1, { type: 'string' });
+      expect(interpreter.interpret).toHaveBeenNthCalledWith(2, { type: 'number' });
+      expect(model.addItem).toHaveBeenNthCalledWith(1, mockedReturnModels[0], schema);
+    });
+    test('should infer type of model', () => {
+      const schema: any = { items: [{ type: 'string' }, { type: 'number' }] };
+      const model = new CommonModel();
+      const interpreter = new Interpreter();
+      interpretItems(schema, model, interpreter);
+      expect(model.addTypes).toHaveBeenNthCalledWith(1, 'array');
+    });
+  });
+});

test/models/CommonModel.spec.ts

@@ -495,6 +495,32 @@ describe('CommonModel', function() {
     });
   });
 
+  describe('addItem', function() {
+    beforeAll(() => {
+      jest.spyOn(CommonModel, "mergeCommonModels");
+    });
+    afterEach(() => {
+      jest.clearAllMocks();
+    });
+    test('should add items to model', function() {
+      const itemModel = new CommonModel();
+      itemModel.$id = "test"; 
+      const model = new CommonModel(); 
+      model.addItem(itemModel, {});
+      expect(model.items).toEqual(itemModel);
+      expect(CommonModel.mergeCommonModels).not.toHaveBeenCalled();
+    });
+    test('should merge items together', function() {
+      const itemModel = new CommonModel();
+      itemModel.$id = "test"; 
+      const model = new CommonModel();
+      model.items = itemModel;
+      model.addItem(itemModel, {});
+      model.addItem(itemModel, {});
+      expect(model.items).toEqual(itemModel);
+      expect(CommonModel.mergeCommonModels).toHaveBeenNthCalledWith(1, itemModel, itemModel, {});
+    });
+  });
   describe('addProperty', function() {
     beforeAll(() => {
       jest.spyOn(CommonModel, "mergeCommonModels");