feat: simplify patternProperties (#153)

Co-authored-by: Maciej Urbańczyk <urbanczyk.maciej.95@gmail.com>

Author: jonaslagoni

src/models/CommonModel.ts

@@ -35,6 +35,12 @@ export class CommonModel extends CommonSchema<CommonModel> {
     }
     return newCommonModel;
   }
+  /**
+   * Merge two common model properties together 
+   * @param mergeTo 
+   * @param mergeFrom 
+   * @param originalSchema 
+   */
   private static mergeProperties(mergeTo: CommonModel, mergeFrom: CommonModel, originalSchema: Schema) {
     const mergeToProperties = mergeTo.properties;
     const mergeFromProperties = mergeFrom.properties;
@@ -52,6 +58,46 @@ export class CommonModel extends CommonSchema<CommonModel> {
       }
     }
   }
+  /**
+   * Merge two common model additional properties together 
+   * @param mergeTo 
+   * @param mergeFrom 
+   * @param originalSchema 
+   */
+  private static mergeAdditionalProperties(mergeTo: CommonModel, mergeFrom: CommonModel, originalSchema: Schema) {
+    const mergeToAdditionalProperties = mergeTo.additionalProperties;
+    const mergeFromAdditionalProperties = mergeFrom.additionalProperties;
+    if (mergeFromAdditionalProperties !== undefined) {
+      if (mergeToAdditionalProperties === undefined) {
+        mergeTo.additionalProperties = mergeFromAdditionalProperties;
+      } else {
+        mergeTo.additionalProperties = CommonModel.mergeCommonModels(mergeToAdditionalProperties, mergeFromAdditionalProperties, originalSchema);
+      }
+    }
+  }
+  /**
+   * Merge two common model pattern properties together 
+   * @param mergeTo 
+   * @param mergeFrom 
+   * @param originalSchema 
+   */
+  private static mergePatternProperties(mergeTo: CommonModel, mergeFrom: CommonModel, originalSchema: Schema) {
+    const mergeToPatternProperties = mergeTo.patternProperties;
+    const mergeFromPatternProperties = mergeFrom.patternProperties;
+    if (mergeFromPatternProperties !== undefined) {
+      if (mergeToPatternProperties === undefined) {
+        mergeTo.patternProperties = mergeFromPatternProperties;
+      } else {
+        for (const [pattern, patternModel] of Object.entries(mergeFromPatternProperties)) {
+          if (mergeToPatternProperties[`${pattern}`] !== undefined) {
+            mergeToPatternProperties[`${pattern}`] = CommonModel.mergeCommonModels(mergeToPatternProperties[`${pattern}`], patternModel, originalSchema);
+          } else {
+            mergeToPatternProperties[`${pattern}`] = patternModel;
+          }
+        }
+      }
+    }
+  }
 
   /**
    * Merge items together so only one CommonModel remains.
@@ -128,6 +174,8 @@ export class CommonModel extends CommonSchema<CommonModel> {
   static mergeCommonModels(mergeTo: CommonModel | undefined, mergeFrom: CommonModel, originalSchema: Schema): CommonModel {
     if (mergeTo === undefined) return mergeFrom;
 
+    CommonModel.mergeAdditionalProperties(mergeTo, mergeFrom, originalSchema);
+    CommonModel.mergePatternProperties(mergeTo, mergeFrom, originalSchema);
     CommonModel.mergeProperties(mergeTo, mergeFrom, originalSchema);
     CommonModel.mergeItems(mergeTo, mergeFrom, originalSchema);
     CommonModel.mergeTypes(mergeTo, mergeFrom);
@@ -162,8 +210,7 @@ export class CommonModel extends CommonSchema<CommonModel> {
   getFromSchema<K extends keyof Schema>(key: K) {
     let schema = this.originalSchema || {};
     if (typeof schema === 'boolean') schema = {};
-    // eslint-disable-next-line security/detect-object-injection
-    return schema[key];
+    return schema[`${key}`];
   }
 
   /**

src/models/CommonSchema.ts

@@ -7,7 +7,8 @@ export class CommonSchema<T> {
     enum?: any[];
     items?: T | T[];
     properties?: { [key: string]: T; };
-    additionalProperties?: boolean | T;
+    additionalProperties?: T;
+    patternProperties?: { [key: string]: T; };
     $ref?: string;
     required?: string[];
 
@@ -36,9 +37,17 @@ export class CommonSchema<T> {
         schema.properties = properties;
       }
       if (typeof schema.additionalProperties === 'object' && 
-            schema.additionalProperties !== null) {
+            schema.additionalProperties !== undefined) {
         schema.additionalProperties = transformationSchemaCallback(schema.additionalProperties, seenSchemas);
       }
+      if (typeof schema.patternProperties === 'object' && 
+            schema.patternProperties !== undefined) {
+        const patternProperties : {[key: string]: T | boolean} = {};
+        Object.entries(schema.patternProperties).forEach(([pattern, patternSchema]) => {
+          patternProperties[`${pattern}`] = transformationSchemaCallback(patternSchema, seenSchemas);
+        });
+        schema.patternProperties = patternProperties;
+      }
       return schema;
     }
 }

src/models/Schema.ts

@@ -30,7 +30,6 @@ export class Schema extends CommonSchema<Schema | boolean> {
     const?: any;
     dependencies?: { [key: string]: Schema | boolean | string[]; };
     propertyNames?: Schema | boolean;
-    patternProperties?: { [key: string]: Schema | boolean; };
     if?: Schema | boolean;
     then?: Schema | boolean;
     else?: Schema | boolean;
@@ -101,14 +100,6 @@ export class Schema extends CommonSchema<Schema | boolean> {
       if (schema.propertyNames !== undefined) {
         schema.propertyNames = Schema.toSchema(schema.propertyNames, seenSchemas);
       }
-
-      if (schema.patternProperties !== undefined) {
-        const patternProperties: { [key: string]: Schema | boolean } = {};
-        Object.entries(schema.patternProperties).forEach(([propertyName, property]) => {
-          patternProperties[`${propertyName}`] = Schema.toSchema(property, seenSchemas);
-        });
-        schema.patternProperties = patternProperties;
-      }
 
       if (schema.if !== undefined) {
         schema.if = Schema.toSchema(schema.if, seenSchemas);

src/simplification/Simplifier.ts

@@ -7,6 +7,7 @@ import simplifyRequired from './SimplifyRequired';
 import simplifyTypes from './SimplifyTypes';
 import { SimplificationOptions } from '../models/SimplificationOptions';
 import simplifyAdditionalProperties from './SimplifyAdditionalProperties';
+import simplifyPatternProperties from './SimplifyPatternProperties';
 import { isModelObject } from './Utils';
 import simplifyName from './SimplifyName';
 
@@ -86,6 +87,11 @@ export class Simplifier {
       model.properties = simplifiedProperties;
     }
 
+    const simplifiedPatternProperties = simplifyPatternProperties(schema, this);
+    if (simplifiedPatternProperties !== undefined) {
+      model.patternProperties = simplifiedPatternProperties;
+    }
+
     const simplifiedAdditionalProperties = simplifyAdditionalProperties(schema, this, model);
     if (simplifiedAdditionalProperties !== undefined) {
       model.additionalProperties = simplifiedAdditionalProperties;
@@ -142,7 +148,13 @@ export class Simplifier {
     }
     if (model.additionalProperties) {
       const existingAdditionalProperties = model.additionalProperties;
-      model.additionalProperties = this.splitModels(existingAdditionalProperties as CommonModel);
+      model.additionalProperties = this.splitModels(existingAdditionalProperties);
+    }
+    if (model.patternProperties) {
+      const existingPatternProperties = model.patternProperties;
+      for (const [pattern, patternModel] of Object.entries(existingPatternProperties)) {
+        model.patternProperties[`${pattern}`] = this.splitModels(patternModel);
+      }
     }
   }
 }

src/simplification/SimplifyAdditionalProperties.ts

@@ -5,7 +5,7 @@ import { isModelObject } from './Utils';
 type Output = CommonModel | undefined;
 
 /**
- * Find out which common models we should extend
+ * Simplifier function for finding the simplified version of additional properties
  * 
  * @param schema to find extends of
  */

src/simplification/SimplifyPatternProperties.ts

@@ -0,0 +1,80 @@
+import { CommonModel } from '../models';
+import { Schema } from '../models/Schema';
+import { Simplifier } from './Simplifier';
+type Output = Record<string, CommonModel> | undefined;
+
+/**
+ * Find out which common models we should extend
+ * 
+ * @param schema to find extends of
+ */
+export default function simplifyPatternProperties(schema: Schema | boolean, simplifier : Simplifier, seenSchemas: Map<any, Output> = new Map()) : Output {
+  if (typeof schema !== 'boolean') {
+    if (seenSchemas.has(schema)) return seenSchemas.get(schema);
+    const output: Output = {};
+    seenSchemas.set(schema, output);
+  
+    for (const [pattern, patternSchema] of Object.entries(schema.patternProperties || {})) {
+      const newModels = simplifier.simplify(patternSchema);
+      if (newModels.length > 0) {
+        addToPatterns(pattern, newModels[0], schema, output);
+      }
+    }
+
+    //If we encounter combination schemas ensure we recursively find the properties
+    if (simplifier.options.allowInheritance !== true) {
+      //Only merge allOf schemas if we don't allow inheritance
+      combineSchemas(schema.allOf, output, simplifier, seenSchemas, schema);
+    }
+    combineSchemas(schema.oneOf, output, simplifier, seenSchemas, schema);
+    combineSchemas(schema.anyOf, output, simplifier, seenSchemas, schema);
+
+    //If we encounter combination schemas ensure we recursively find the properties
+    combineSchemas(schema.then, output, simplifier, seenSchemas, schema);
+    combineSchemas(schema.else, output, simplifier, seenSchemas, schema);
+
+    return Object.keys(output).length ? output : undefined;
+  }
+  return undefined;
+}
+/**
+ * Adds a pattern to the model
+ * 
+ * @param pattern for the model
+ * @param patternModel the corresponding model for the pattern
+ * @param schema for the model
+ * @param currentModel the current output
+ */
+function addToPatterns(pattern: string, patternModel: CommonModel, schema: Schema, currentModel: Output) {
+  if (currentModel === undefined) return;
+  //If the pattern already exist, merge the two
+  if (currentModel[`${pattern}`] !== undefined) {
+    currentModel[`${pattern}`] = CommonModel.mergeCommonModels(currentModel[`${pattern}`], patternModel, schema);
+  } else {
+    currentModel[`${pattern}`] = patternModel;
+  }
+}
+/**
+ * Go through schema(s) and combine the simplified properties together.
+ * 
+ * @param schema to go through
+ * @param currentModel the current output
+ * @param simplifier to use
+ * @param seenSchemas which we already have outputs for
+ * @param rootSchema we are combining schemas for
+ */
+function combineSchemas(schema: (Schema | boolean) | (Schema | boolean)[] | undefined, currentModel: Output, simplifier : Simplifier, seenSchemas: Map<any, Output>, rootSchema : Schema) {
+  if (typeof schema !== 'object') return;
+  if (Array.isArray(schema)) {
+    schema.forEach((combinationSchema) => {
+      combineSchemas(combinationSchema, currentModel, simplifier, seenSchemas, rootSchema);
+    });
+  } else {
+    const patternProperties = simplifyPatternProperties(schema, simplifier, seenSchemas);
+    if (patternProperties !== undefined) {
+      for (const [pattern, patternSchema] of Object.entries(patternProperties)) {
+        addToPatterns(pattern, patternSchema, rootSchema, currentModel);
+      }
+    }
+  }
+}

src/simplification/SimplifyProperties.ts

@@ -36,7 +36,7 @@ export default function simplifyProperties(schema: Schema | boolean, simplifier
     combineSchemas(schema.then, output, simplifier, seenSchemas, schema);
     combineSchemas(schema.else, output, simplifier, seenSchemas, schema);
 
-    return !Object.keys(output).length ? undefined : output;
+    return Object.keys(output).length ? output : undefined;
   }
   return undefined;
 }
@@ -46,7 +46,7 @@ export default function simplifyProperties(schema: Schema | boolean, simplifier
  * 
  * @param propName name of the property
  * @param propModel the corresponding model
- * @param schema the schema for the model
+ * @param schema for the model
  * @param currentModel the current output
  */
 function addToProperty(propName: string, propModel: CommonModel, schema: Schema, currentModel: Output) {
@@ -64,9 +64,9 @@ function addToProperty(propName: string, propModel: CommonModel, schema: Schema,
  * 
  * @param schema to go through
  * @param currentModel the current output
- * @param simplifier the simplifier to use
- * @param seenSchemas schemas which we already have outputs for
- * @param rootSchema the root schema we are combining schemas for
+ * @param simplifier to use
+ * @param seenSchemas which we already have outputs for
+ * @param rootSchema we are combining schemas for
  */
 function combineSchemas(schema: (Schema | boolean) | (Schema | boolean)[] | undefined, currentModel: Output, simplifier : Simplifier, seenSchemas: Map<any, Output>, rootSchema : Schema) {
   if (typeof schema !== 'object') return;

test/models/CommonModel.spec.ts

@@ -97,13 +97,6 @@ describe('CommonModel', function() {
       const d = CommonModel.toCommonModel(doc);
       expect(d.additionalProperties).toEqual(undefined);
     });
-    
-    test('should return undefined when null', function() {
-      const doc: any = { additionalProperties: null };
-      const d = CommonModel.toCommonModel(doc);
-      expect(d.additionalProperties).not.toBeUndefined();
-      expect(d.additionalProperties).toEqual(doc.additionalProperties);
-    });
   });
 
   describe('$ref', function() {
@@ -423,8 +416,69 @@ describe('CommonModel', function() {
         expect(doc1.properties).toBeUndefined();
       });
     });
-  });
+    describe('additionalProperties', function() {
+      test('should be merged when only right side is defined', function() {
+        const doc: Schema = { };
+        let doc1 = CommonModel.toCommonModel(doc);
+        let doc2 = CommonModel.toCommonModel(doc);
+        doc2.additionalProperties = CommonModel.toCommonModel({type: "string"});
+        doc1 = CommonModel.mergeCommonModels(doc1, doc2, doc);
+        expect(doc1.additionalProperties).toEqual(doc2.additionalProperties);
+      });
+      test('should be merged together when both sides are defined', function() {
+        const doc: Schema = { };
+        let doc1 = CommonModel.toCommonModel(doc);
+        let doc2 = CommonModel.toCommonModel(doc);
+        doc2.additionalProperties = CommonModel.toCommonModel({type: "string"});
+        doc1.additionalProperties = CommonModel.toCommonModel({type: "number"});
+        doc1 = CommonModel.mergeCommonModels(doc1, doc2, doc);
+        expect(doc1.additionalProperties).toEqual({type: ["number", "string"], originalSchema: {}});
+      });
+      test('should not change if nothing is defined', function() {
+        const doc: Schema = { };
+        let doc1 = CommonModel.toCommonModel(doc);
+        let doc2 = CommonModel.toCommonModel(doc);
+        doc1 = CommonModel.mergeCommonModels(doc1, doc2, doc);
+        expect(doc1.patternProperties).toBeUndefined();
+      });
+    });
 
+    describe('patternProperties', function() {
+      test('should be merged when only right side is defined', function() {
+        const doc: Schema = { };
+        let doc1 = CommonModel.toCommonModel(doc);
+        let doc2 = CommonModel.toCommonModel(doc);
+        doc2.patternProperties = {"pattern1": CommonModel.toCommonModel({type: "string"})};
+        doc1 = CommonModel.mergeCommonModels(doc1, doc2, doc);
+        expect(doc1.patternProperties).toEqual(doc2.patternProperties);
+      });
+      test('should be merged when both sides are defined', function() {
+        const doc: Schema = { };
+        let doc1 = CommonModel.toCommonModel(doc);
+        let doc2 = CommonModel.toCommonModel(doc);
+        doc2.patternProperties = {"pattern1": CommonModel.toCommonModel({type: "string"})};
+        doc1.patternProperties = {"pattern2": CommonModel.toCommonModel({type: "number"})};
+        doc1 = CommonModel.mergeCommonModels(doc1, doc2, doc);
+        expect(doc1.patternProperties).toEqual({"pattern1": {type: "string"}, "pattern2": {type: "number"}});
+      });
+      test('should be merged together when both sides are defined', function() {
+        const doc: Schema = { };
+        let doc1 = CommonModel.toCommonModel(doc);
+        let doc2 = CommonModel.toCommonModel(doc);
+        doc2.patternProperties = {"pattern1": CommonModel.toCommonModel({type: "string"})};
+        doc1.patternProperties = {"pattern1": CommonModel.toCommonModel({type: "number"})};
+        doc1 = CommonModel.mergeCommonModels(doc1, doc2, doc);
+        expect(doc1.patternProperties).toEqual({"pattern1": {type: ["number", "string"], originalSchema: {}}});
+      });
+      test('should not change if nothing is defined', function() {
+        const doc: Schema = { };
+        let doc1 = CommonModel.toCommonModel(doc);
+        let doc2 = CommonModel.toCommonModel(doc);
+        doc1 = CommonModel.mergeCommonModels(doc1, doc2, doc);
+        expect(doc1.patternProperties).toBeUndefined();
+      });
+    });
+  });
   describe('helpers', function() {
     describe('getFromSchema', function() {
       test('should work', function() {

test/models/Schema.spec.ts

@@ -313,13 +313,6 @@ describe('Schema', function() {
       expect(typeof d).toEqual("object");
       expect(d.additionalProperties).toEqual(undefined);
     });
-    
-    test('should return undefined when null', function() {
-      const doc: any = { additionalProperties: null };
-      const d = Schema.toSchema(doc) as Schema;
-      expect(typeof d).toEqual("object");
-      expect(d.additionalProperties).toEqual(null);
-    });
   });
 
   describe('additionalItems', function() {