review: Rely on schema instead of data, remove string/number prop usage

- remove usage of any number or string property as fallback
- choose type, kind default prop based on combinator schema with const entry instead of presence in the data object
- Adapt tests
- remove usage of id as a default prop

Author: lucas-koehler

MIGRATION.md

@@ -10,14 +10,12 @@ Thus, custom renderers using either method might have behavior changes.
 This rework is part of an ongoing effort to remove mandatory usage of AJV from JSON Forms.
 
 Before this change, AJV was used to validate the current data against all schemas of the combinator.
-This was replaced by using a heuristic which tries to match the schema via an identification property
-against a `const` entry in the schema.
+This was replaced by a heuristic which tries to match the schema via an identification property against a `const` entry in the schema.
 
 The identification property is determined as follows in descending order of priority:
 
 1. The schema contains a new custom property `x-jsf-type-property` next to the combinator to define the identification property.
-2. The data has any of these properties: `type`, `kind`, `id`. They are considered in the listed order.
-3. The data has any string or number property. The first encountered one is used.
+2. At least one of the combinator schemas has this property with a const declaration: `type`, `kind`. They are considered in the listed order.
 
 If no combinator schema can be matched, fallback to the first one as before this update.
 
@@ -72,7 +70,9 @@ const dataWithUser = {
 
 #### Example 2: Use a default identification property
 
-In this example we use the `kind` property as the identification property. Like in the custom property case, subschemas are matched via a `const` definition in the identification property's schema. However, we do not need to explicitly specify `kind` being used.
+In this example we use the `kind` property as the identification property.
+Like in the custom property case, subschemas are matched via a `const` definition in the identification property's schema.
+However, we do not need to explicitly specify `kind` being used.
 The `default` keyword can be used to tell JSON Forms to automatically initialize the property.
 
 ```ts

packages/core/src/mappers/combinators.ts

@@ -40,7 +40,7 @@ export type CombinatorKeyword = 'anyOf' | 'oneOf' | 'allOf';
 export const COMBINATOR_TYPE_PROPERTY = 'x-jsf-type-property';
 
 /** Default properties that are used to identify combinator schemas. */
-export const COMBINATOR_IDENTIFICATION_PROPERTIES = ['type', 'kind', 'id'];
+export const COMBINATOR_IDENTIFICATION_PROPERTIES = ['type', 'kind'];
 
 export const createCombinatorRenderInfos = (
   combinatorSubSchemas: JsonSchema[],
@@ -75,22 +75,41 @@ export const createCombinatorRenderInfos = (
   });
 
 /**
- * Returns the identification property of the given data object.
+ * Returns the index of the schema in the given combinator keyword that matches the identification property of the given data object.
+ * The heuristic only works for data objects with a corresponding schema. If the data is a primitive value or an array, the heuristic does not work.
+ *
  * The following heuristics are applied:
  * If the schema defines a `x-jsf-type-property`, it is used as the identification property.
- * Otherwise, the first of the following data properties is used:
+ * Otherwise, the first of the following properties is used if it exists in at least one combinator schema and has a `const` entry:
  * - `type`
  * - `kind`
- * - `id`
  *
- * If none of the above properties are present, the first string or number property of the data object is used.
+ * If the index cannot be determined, `-1` is returned.
+ *
+ * @returns the index of the fitting schema or `-1` if no fitting schema was found
  */
-export const getCombinatorIdentificationProp = (
+export const getCombinatorIndexOfFittingSchema = (
   data: any,
-  schema: JsonSchema
-): string | undefined => {
+  keyword: CombinatorKeyword,
+  schema: JsonSchema,
+  rootSchema: JsonSchema
+): number => {
   if (typeof data !== 'object' || data === null) {
-    return undefined;
+    return -1;
+  }
+
+  // Resolve all schemas in the combinator.
+  const resolvedCombinatorSchemas = [];
+  for (let i = 0; i < schema[keyword]?.length; i++) {
+    let resolvedSchema = schema[keyword][i];
+    if (resolvedSchema.$ref) {
+      resolvedSchema = Resolve.schema(
+        rootSchema,
+        resolvedSchema.$ref,
+        rootSchema
+      );
+    }
+    resolvedCombinatorSchemas.push(resolvedSchema);
   }
 
   // Determine the identification property
@@ -101,58 +120,25 @@ export const getCombinatorIdentificationProp = (
   ) {
     idProperty = schema[COMBINATOR_TYPE_PROPERTY];
   } else {
-    // Use the first default identification property that is present in the data object
-    for (const prop of COMBINATOR_IDENTIFICATION_PROPERTIES) {
-      if (Object.prototype.hasOwnProperty.call(data, prop)) {
-        idProperty = prop;
-        break;
-      }
-    }
-  }
-
-  // If no identification property was found, use the first string or number property
-  // of the data object
-  if (idProperty === undefined) {
-    for (const key of Object.keys(data)) {
-      if (typeof data[key] === 'string' || typeof data[key] === 'number') {
-        idProperty = key;
-        break;
+    // Use the first default identification property that has a const entry in at least one of the schemas
+    for (const potentialIdProp of COMBINATOR_IDENTIFICATION_PROPERTIES) {
+      for (const resolvedSchema of resolvedCombinatorSchemas) {
+        if (resolvedSchema.properties?.[potentialIdProp]?.const !== undefined) {
+          idProperty = potentialIdProp;
+          break;
+        }
       }
     }
   }
 
-  return idProperty;
-};
-
-/**
- * Returns the index of the schema in the given combinator keyword that matches the identification property of the given data object.
- * The heuristic only works for data objects with a corresponding schema. If the data is a primitive value or an array, the heuristic does not work.
- *
- * If the index cannot be determined, `-1` is returned.
- *
- * @returns the index of the fitting schema or `-1` if no fitting schema was found
- */
-export const getCombinatorIndexOfFittingSchema = (
-  data: any,
-  keyword: CombinatorKeyword,
-  schema: JsonSchema,
-  rootSchema: JsonSchema
-): number => {
   let indexOfFittingSchema = -1;
-  const idProperty = getCombinatorIdentificationProp(data, schema);
   if (idProperty === undefined) {
     return indexOfFittingSchema;
   }
 
-  for (let i = 0; i < schema[keyword]?.length; i++) {
-    let resolvedSchema = schema[keyword][i];
-    if (resolvedSchema.$ref) {
-      resolvedSchema = Resolve.schema(
-        rootSchema,
-        resolvedSchema.$ref,
-        rootSchema
-      );
-    }
+  // Check if the data matches the identification property of one of the resolved schemas
+  for (let i = 0; i < resolvedCombinatorSchemas.length; i++) {
+    const resolvedSchema = resolvedCombinatorSchemas[i];
 
     // Match the identification property against a constant value in resolvedSchema
     const maybeConstIdValue = resolvedSchema.properties?.[idProperty]?.const;
@@ -162,9 +148,6 @@ export const getCombinatorIndexOfFittingSchema = (
       data[idProperty] === maybeConstIdValue
     ) {
       indexOfFittingSchema = i;
-      console.debug(
-        `Data matches the resolved schema for property ${idProperty}`
-      );
       break;
     }
   }