@jsonforms/core 3.0.0-alpha.3 → 3.0.0-beta.2

package/src/util/resolvers.ts

@@ -25,7 +25,8 @@
 
 import isEmpty from 'lodash/isEmpty';
 import get from 'lodash/get';
-import { JsonSchema } from '../models';
+import { JsonSchema, JsonSchema7 } from '../models';
+import { decode } from './path';
 
 /**
  * Map for storing refs and the respective schemas they are pointing to.
@@ -110,80 +111,68 @@ const invalidSegment = (pathSegment: string) =>
 export const resolveSchema = (
   schema: JsonSchema,
   schemaPath: string,
-  rootSchema?: JsonSchema
+  rootSchema: JsonSchema
+): JsonSchema => {
+  const segments = schemaPath?.split('/').map(decode);
+  return resolveSchemaWithSegments(schema, segments, rootSchema);
+};
+
+const resolveSchemaWithSegments = (
+  schema: JsonSchema,
+  pathSegments: string[],
+  rootSchema: JsonSchema
 ): JsonSchema => {
   if (isEmpty(schema)) {
     return undefined;
   }
-  const validPathSegments = schemaPath.split('/');
-  let resultSchema = schema;
-  for (let i = 0; i < validPathSegments.length; i++) {
-    let pathSegment = validPathSegments[i];
-    resultSchema =
-      resultSchema === undefined || resultSchema.$ref === undefined
-        ? resultSchema
-        : resolveSchema(schema, resultSchema.$ref);
-    if (invalidSegment(pathSegment)) {
-      // skip invalid segments
-      continue;
-    }
-    let curSchema = get(resultSchema, pathSegment);
-    if (!curSchema) {
-      // resolving was not successful, check whether the scope omitted an oneOf, allOf or anyOf and resolve anyway
-      const schemas = [].concat(
-        resultSchema?.oneOf ?? [],
-        resultSchema?.allOf ?? [],
-        resultSchema?.anyOf ?? []
-      );
-      for (let item of schemas) {
-        curSchema = resolveSchema(item, validPathSegments.slice(i).join('/'));
-        if (curSchema) {
-          break;
-        }
-      }
-      if (curSchema) {
-        // already resolved rest of the path
-        resultSchema = curSchema;
-        break;
-      }
-    }
-    resultSchema = curSchema;
+
+  if (schema.$ref) {
+    schema = resolveSchema(rootSchema, schema.$ref, rootSchema);
   }
-  // TODO: because schema is already scoped we might end up with refs pointing
-  // outside of the current schema. It would be better if we'd always could deal
-  // with absolute paths here, so that we don't need to keep two different
-  // schemas around
-  if (resultSchema !== undefined && resultSchema.$ref !== undefined) {
-    try {
-      return retrieveResolvableSchema(schema, resultSchema.$ref);
-    } catch (e) {
-      return retrieveResolvableSchema(rootSchema, resultSchema.$ref);
-    }
+
+  if (!pathSegments || pathSegments.length === 0) {
+    return schema;
   }
 
-  return resultSchema;
-};
+  const [segment, ...remainingSegments] = pathSegments;
 
-/**
- * Normalizes the schema and resolves the given ref.
- *
- * @param {JsonSchema} full the JSON schema to resolved the reference against
- * @param {string} reference the reference to be resolved
- * @returns {JsonSchema} the resolved sub-schema
- */
-// disable rule because resolve is mutually recursive
-// tslint:disable:only-arrow-functions
-function retrieveResolvableSchema(
-  full: JsonSchema,
-  reference: string
-): JsonSchema {
-  // tslint:enable:only-arrow-functions
-  const child = resolveSchema(full, reference);
-  const allRefs = findAllRefs(child);
-  const innerSelfReference = allRefs[reference];
-  if (innerSelfReference !== undefined) {
-    innerSelfReference.$ref = '#';
+  if (invalidSegment(segment)) {
+    return resolveSchemaWithSegments(schema, remainingSegments, rootSchema);
   }
 
-  return child;
-}
+  const singleSegmentResolveSchema = get(schema, segment);
+
+  const resolvedSchema = resolveSchemaWithSegments(singleSegmentResolveSchema, remainingSegments, rootSchema);
+  if (resolvedSchema) {
+    return resolvedSchema;
+  }
+
+  if (segment === 'properties' || segment === 'items') {
+    // Let's try to resolve the path, assuming oneOf/allOf/anyOf/then/else was omitted.
+    // We only do this when traversing an object or array as we want to avoid
+    // following a property which is named oneOf, allOf, anyOf, then or else.
+    let alternativeResolveResult = undefined;
+
+    const subSchemas = [].concat(
+      schema.oneOf ?? [],
+      schema.allOf ?? [],
+      schema.anyOf ?? [],
+      (schema as JsonSchema7).then ?? [],
+      (schema as JsonSchema7).else ?? []
+    );
+
+    for (const subSchema of subSchemas) {
+      alternativeResolveResult = resolveSchemaWithSegments(
+        subSchema,
+        [segment, ...remainingSegments],
+        rootSchema
+      );
+      if (alternativeResolveResult) {
+        break;
+      }
+    }
+    return alternativeResolveResult;
+  }
+
+  return undefined;
+}

package/src/util/util.ts

@@ -99,7 +99,7 @@ export const Resolve: {
  schema(
    schema: JsonSchema,
    schemaPath: string,
-   rootSchema?: JsonSchema
+   rootSchema: JsonSchema
  ): JsonSchema;
  data(data: any, path: string): any;
 } = {