2 new files added (#942)

* 2 new files added

* apply formatting changes

* update to use reverse strategy

* add test case

* do not remove content from sub-schema when it is changed to $ref in schema diagram

* apply formatting changes

---------

Co-authored-by: Devesh0129 <Devesh0129@users.noreply.github.com>
Co-authored-by: Felix Neubauer <felix@neuby.de>
Co-authored-by: Logende <Logende@users.noreply.github.com>

Author: Devesh0129

meta_configurator/src/schema/__tests__/cleanupSchemaByType.test.ts

@@ -0,0 +1,88 @@
+import {describe, expect, it, vi} from 'vitest';
+import {type JsonSchemaType} from '../jsonSchemaType';
+import {cleanupSchemaByType} from '@/schema/cleanupSchemaByType.ts';
+
+describe('test cleanupSchemaByType', () => {
+  const schema: any = {
+    required: ['a'],
+    properties: {
+      obj: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          name: {
+            type: 'string',
+          },
+        },
+      },
+      str: {
+        type: 'string',
+        minLength: 5,
+        pattern: '^[a-zA-Z]+$',
+      },
+      num: {
+        type: 'number',
+        minimum: 0,
+        maximum: 100,
+      },
+      arr: {
+        type: 'array',
+        items: {
+          type: 'string',
+        },
+        minItems: 1,
+      },
+    },
+  } as JsonSchemaType;
+
+  it('test changing obj to something else removes the object constraints', () => {
+    // initial object schema should have object-specific constraints
+    const objectSchema = schema.properties.obj;
+    expect(objectSchema).toHaveProperty('additionalProperties');
+    expect(objectSchema).toHaveProperty('properties');
+
+    // update object schema to be a string schema instead
+    objectSchema.type = 'string';
+
+    // run the cleanup function
+    cleanupSchemaByType(objectSchema, 'string');
+
+    // object-specific constraints should be removed
+    expect(objectSchema).not.toHaveProperty('additionalProperties');
+    expect(objectSchema).not.toHaveProperty('properties');
+  });
+
+  it('test changing string to something else removes the string constraints', () => {
+    // initial string schema should have string-specific constraints
+    const stringSchema = schema.properties.str;
+    expect(stringSchema).toHaveProperty('minLength');
+    expect(stringSchema).toHaveProperty('pattern');
+
+    // update string schema to be a number schema instead
+    stringSchema.type = 'number';
+
+    // run the cleanup function
+    cleanupSchemaByType(stringSchema, 'number');
+
+    // string-specific constraints should be removed
+    expect(stringSchema).not.toHaveProperty('minLength');
+    expect(stringSchema).not.toHaveProperty('pattern');
+  });
+
+  it('test changing number to something else removes the number constraints', () => {
+    // initial number schema should have number-specific constraints
+    const numberSchema = schema.properties.num;
+    expect(numberSchema).toHaveProperty('minimum');
+    expect(numberSchema).toHaveProperty('maximum');
+
+    // update number schema to be an array schema instead
+    numberSchema.type = 'array';
+
+    // run the cleanup function
+    cleanupSchemaByType(numberSchema, 'array');
+
+    // number-specific constraints should be removed
+    expect(numberSchema).not.toHaveProperty('minimum');
+    expect(numberSchema).not.toHaveProperty('maximum');
+  });
+});

meta_configurator/src/schema/cleanupSchemaByType.ts

@@ -0,0 +1,13 @@
+import {CONSTRAINED_KEYWORDS} from './supportedJsonSchemaTypeKeywords';
+import type {SchemaPropertyType} from '@/schema/jsonSchemaType.ts';
+
+export function cleanupSchemaByType(schema: Record<string, any>, type: SchemaPropertyType) {
+  Object.keys(schema).forEach(key => {
+    if (key in CONSTRAINED_KEYWORDS) {
+      const supportedTypesForProperty = CONSTRAINED_KEYWORDS[key]!;
+      if (!supportedTypesForProperty.includes(type)) {
+        delete schema[key];
+      }
+    }
+  });
+}

meta_configurator/src/schema/graph-representation/typeUtils.ts

@@ -2,6 +2,7 @@ import type {JsonSchemaObjectType, SchemaPropertyTypes} from '@/schema/jsonSchem
 import {pathToJsonPointer} from '@/utility/pathUtils';
 import {SchemaNodeData} from '@/schema/graph-representation/schemaGraphTypes';
 import type {Path} from '@/utility/path';
+import {cleanupSchemaByType} from '../cleanupSchemaByType';
 
 export type AttributeTypeChoice = {label: string; schema: JsonSchemaObjectType};
 
@@ -111,6 +112,7 @@ export function applyNewType(
 ) {
   if (typeSchema.type !== undefined) {
     currentSchema.type = typeSchema.type;
+    cleanupSchemaByType(currentSchema, typeSchema.type);
     if (typeSchema.type === 'array') {
       if (
         currentSchema.items === undefined ||

meta_configurator/src/schema/supportedJsonSchemaTypeKeywords.ts

@@ -0,0 +1,25 @@
+import type {SchemaPropertyType} from '@/schema/jsonSchemaType.ts';
+
+export const CONSTRAINED_KEYWORDS: Record<string, SchemaPropertyType[]> = {
+  minLength: ['string'],
+  maxLength: ['string'],
+  pattern: ['string'],
+  format: ['string'],
+  minimum: ['number', 'integer'],
+  maximum: ['number', 'integer'],
+  exclusiveMinimum: ['number', 'integer'],
+  exclusiveMaximum: ['number', 'integer'],
+  multipleOf: ['number', 'integer'],
+  properties: ['object'],
+  patternProperties: ['object'],
+  required: ['object'],
+  additionalProperties: ['object'],
+  propertyNames: ['object'],
+  items: ['array'],
+  minItems: ['array'],
+  maxItems: ['array'],
+  uniqueItems: ['array'],
+  contains: ['array'],
+  maxContains: ['array'],
+  minContains: ['array'],
+};