Merge 162ebf6 into 2e2a70b

docs/interpretation_of_JSON_Schema_draft_7.md

@@ -16,6 +16,7 @@ The order of transformation:
 - [allOf](#allOf-sub-schemas)
 - `const` overwrite already interpreted `enums`.
 - `items` are determined as is, where more then 1 item are merged.
+- `additionalProperties` are determined as is, where duplicate additionalProperties for the model are merged together. If the schema does not define additionalProperties it defaults to `true` schema.
 - [oneOf/anyOf/then/else](#Processing-sub-schemas)
 
 ## allOf sub schemas

src/interpreter/InterpretAdditionalProperties.ts

@@ -0,0 +1,19 @@
+import { CommonModel } from 'models';
+import { Schema } from 'models/Schema';
+import { Interpreter } from './Interpreter';
+import { isModelObject } from './Utils';
+
+/**
+ * Interpreter function for JSON Schema draft 7 additionalProperties keyword.
+ * 
+ * @param schema
+ * @param model
+ * @param interpreter
+ */
+export default function interpretAdditionalProperties(schema: Schema | boolean, model: CommonModel, interpreter : Interpreter) {
+  if (typeof schema === 'boolean' || !isModelObject(model)) return;
+  const newModels = interpreter.interpret(schema.additionalProperties || true);
+  if (newModels.length > 0) {
+    model.addAdditionalProperty(newModels[0], schema);
+  }
+}

src/interpreter/Interpreter.ts

@@ -4,8 +4,9 @@ import { interpretName, isModelObject } from './Utils';
 import interpretProperties from './InterpretProperties';
 import interpretAllOf from './InterpretAllOf';
 import interpretConst from './InterpretConst';
-import { Logger } from '../utils';
+import interpretAdditionalProperties from './InterpretAdditionalProperties';
 import interpretItems from './InterpretItems';
+import { Logger } from '../utils';
 
 export class Interpreter {
   static defaultOptions: SimplificationOptions = {
@@ -80,6 +81,7 @@ export class Interpreter {
 
       model.required = schema.required || model.required;
 
+      interpretAdditionalProperties(schema, model, this);
       interpretItems(schema, model, this);
       interpretProperties(schema, model, this);
       interpretAllOf(schema, model, this);

src/models/CommonModel.ts

@@ -117,6 +117,22 @@ export class CommonModel extends CommonSchema<CommonModel> {
     }
   }
 
+  /**
+   * Adds additionalProperty to the model.
+   * If another model already are added the two are merged.
+   * 
+   * @param additionalPropertiesModel 
+   * @param schema 
+   */
+  addAdditionalProperty(additionalPropertiesModel: CommonModel, schema: Schema) {
+    if (this.additionalProperties !== undefined) {
+      Logger.warn('While trying to add additionalProperties to model, but it is already present, merging models together', additionalPropertiesModel, schema, this);
+      this.additionalProperties = CommonModel.mergeCommonModels(this.additionalProperties, additionalPropertiesModel, schema);
+    } else {
+      this.additionalProperties = additionalPropertiesModel;
+    }
+  }
+
   /**
    * Adds another model this model should extend.
    * 

test/interpreter/Intepreter.spec.ts

@@ -4,6 +4,7 @@ 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 interpretAdditionalProperties from '../../src/interpreter/InterpretAdditionalProperties';
 import { CommonModel, Schema } from '../../src/models';
 
 let mockedIsModelObjectReturn = false;
@@ -19,6 +20,7 @@ jest.mock('../../src/interpreter/InterpretProperties');
 jest.mock('../../src/interpreter/InterpretConst');
 jest.mock('../../src/interpreter/InterpretAllOf');
 jest.mock('../../src/interpreter/InterpretItems');
+jest.mock('../../src/interpreter/InterpretAdditionalProperties');
 CommonModel.mergeCommonModels = jest.fn();
 /**
  * Some of these test are purely theoretical and have little if any merit 
@@ -184,6 +186,12 @@ describe('Interpreter', function() {
     interpreter.interpret(schema);
     expect(interpretItems).toHaveBeenNthCalledWith(1, schema, expect.anything(), expect.anything());
   });
+  test('should always try to interpret additionalProperties', function() {
+    const schema = {};
+    const interpreter = new Interpreter();
+    interpreter.interpret(schema);
+    expect(interpretAdditionalProperties).toHaveBeenNthCalledWith(1, schema, expect.anything(), expect.anything());
+  });
 
   test('should support primitive roots', function() {
     const schema = { 'type': 'string' };

test/interpreter/InterpretAdditionalProperties.spec.ts

@@ -0,0 +1,61 @@
+/* eslint-disable no-undef */
+import { CommonModel } from '../../src/models/CommonModel';
+import { Interpreter } from '../../src/interpreter/Interpreter';
+import interpretAdditionalProperties from '../../src/interpreter/InterpretAdditionalProperties';
+
+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 additionalProperties', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockedReturnModels = [new CommonModel()];
+  });
+  afterAll(() => {
+    jest.restoreAllMocks();
+  });
+  test('should try and interpret additionalProperties schema', () => {
+    const schema: any = { additionalProperties: { type: 'string' } };
+    const model = new CommonModel();
+    model.type = "object";
+    const interpreter = new Interpreter();
+    interpretAdditionalProperties(schema, model, interpreter);
+    expect(interpreter.interpret).toHaveBeenNthCalledWith(1, { type: 'string' });
+    expect(model.addAdditionalProperty).toHaveBeenNthCalledWith(1, mockedReturnModels[0], schema);
+  });
+  test('should ignore model if interpreter cannot interpret additionalProperty schema', () => {
+    const schema: any = { };
+    const model = new CommonModel();
+    model.type = "object";
+    const interpreter = new Interpreter();
+    mockedReturnModels.pop();
+    interpretAdditionalProperties(schema, model, interpreter);
+    expect(model.addAdditionalProperty).not.toHaveBeenCalled();
+  });
+  test('should only work if model is object type', () => {
+    const schema: any = { };
+    const model = new CommonModel();
+    model.type = "string";
+    const interpreter = new Interpreter();
+    interpretAdditionalProperties(schema, model, interpreter);
+    expect(interpreter.interpret).not.toHaveBeenCalled();
+    expect(model.addAdditionalProperty).not.toHaveBeenCalled();
+  });
+  test('should default to true', () => {
+    const schema: any = { };
+    const model = new CommonModel();
+    model.type = "object";
+    const interpreter = new Interpreter();
+    interpretAdditionalProperties(schema, model, interpreter);
+    expect(interpreter.interpret).toHaveBeenNthCalledWith(1, true);
+    expect(model.addAdditionalProperty).toHaveBeenNthCalledWith(1, mockedReturnModels[0], schema);
+  });
+});

test/models/CommonModel.spec.ts

@@ -606,6 +606,32 @@ describe('CommonModel', function() {
     });
   });
 
+
+  describe('addAdditionalProperty', function() {
+    beforeAll(() => {
+      jest.spyOn(CommonModel, "mergeCommonModels");
+    });
+    afterEach(() => {
+      jest.clearAllMocks();
+    });
+    test('should add additionalProperties to model', function() {
+      const additionalPropertiesModel = new CommonModel();
+      additionalPropertiesModel.$id = "test"; 
+      const model = new CommonModel(); 
+      model.addAdditionalProperty(additionalPropertiesModel, {});
+      expect(model.additionalProperties).toEqual(additionalPropertiesModel);
+      expect(CommonModel.mergeCommonModels).not.toHaveBeenCalled();
+    });
+    test('should merge additionalProperties together', function() {
+      const additionalPropertiesModel = new CommonModel();
+      additionalPropertiesModel.$id = "test"; 
+      const model = new CommonModel(); 
+      model.addAdditionalProperty(additionalPropertiesModel, {});
+      model.addAdditionalProperty(additionalPropertiesModel, {});
+      expect(model.additionalProperties).toEqual(additionalPropertiesModel);
+      expect(CommonModel.mergeCommonModels).toHaveBeenNthCalledWith(1, additionalPropertiesModel, additionalPropertiesModel, {});
+    });
+  });
   describe('addTypes', function() {
     test('should add multiple types', function() {
       const model = new CommonModel();