Handle keyof parameter ranges

Author: rubensworks

components/context.jsonld

@@ -29,6 +29,9 @@
     "parameters": {
       "@id": "oo:parameter"
     },
+    "memberKeys": {
+      "@id": "oo:memberKey"
+    },
     "genericTypeParameters": {
       "@id": "oo:genericTypeParameter"
     },
@@ -77,6 +80,12 @@
     "ParameterRangeArray": {
       "@id": "oo:ParameterRangeArray"
     },
+    "ParameterRangeRest": {
+      "@id": "oo:ParameterRangeRest"
+    },
+    "ParameterRangeKeyof": {
+      "@id": "oo:ParameterRangeKeyof"
+    },
     "ParameterRangeLiteral": {
       "@id": "oo:ParameterRangeLiteral"
     },

lib/preprocess/parameterproperty/ParameterPropertyHandlerRange.ts

@@ -190,6 +190,20 @@ export class ParameterPropertyHandlerRange implements IParameterPropertyHandler
         return Boolean(value && value.term.equals(paramRange.property.parameterRangeValue.term));
       }
 
+      // Check if the range refers to `keyof ...`
+      if (paramRange.isA('ParameterRangeKeyof')) {
+        const component = paramRange.property.parameterRangeValue;
+        // Simulate a union of the member keys as literal parameter ranges
+        const simulatedUnionRange = this.objectLoader.createCompactedResource({
+          '@type': 'ParameterRangeUnion',
+          parameterRangeElements: component.properties.memberKeys.map(memberKey => ({
+            '@type': 'ParameterRangeLiteral',
+            parameterRangeValue: memberKey,
+          })),
+        });
+        return this.hasParamValueValidType(value, param, simulatedUnionRange, genericsContext);
+      }
+
       // Check if the range refers to a generic type
       if (paramRange.isA('ParameterRangeGenericTypeReference')) {
         return genericsContext.bindGenericTypeToValue(
@@ -263,6 +277,9 @@ export class ParameterPropertyHandlerRange implements IParameterPropertyHandler
     if (paramRange.isA('ParameterRangeRest')) {
       return `...${this.rangeToDisplayString(paramRange.property.parameterRangeValue, genericsContext)}`;
     }
+    if (paramRange.isA('ParameterRangeKeyof')) {
+      return `keyof ${this.rangeToDisplayString(paramRange.property.parameterRangeValue, genericsContext)}`;
+    }
     if (paramRange.isA('ParameterRangeUnion')) {
       return paramRange.properties.parameterRangeElements
         .map(child => this.rangeToDisplayString(child, genericsContext))

test/unit/preprocess/parameterproperty/ParameterPropertyHandlerRange-test.ts

@@ -1306,6 +1306,39 @@ describe('ParameterPropertyHandlerRange', () => {
           // eslint-disable-next-line max-len
         )).toThrow(/^Simultaneous manual generic type passing and generic type inference are not supported yet\./u);
       });
+
+      it('should handle keyof type with valid value', () => {
+        expect(handler.captureType(
+          objectLoader.createCompactedResource('"fieldB"'),
+          objectLoader.createCompactedResource({
+            range: {
+              '@type': 'ParameterRangeKeyof',
+              parameterRangeValue: {
+                '@id': 'ex:SomeType1',
+                memberKeys: [ '"fieldA"', '"fieldB"' ],
+              },
+            },
+          }),
+          genericsContext,
+        )).toBeTruthy();
+      });
+
+      it('should throw on keyof type without valid value', () => {
+        expect(() => handler.captureType(
+          objectLoader.createCompactedResource('"fieldC"'),
+          objectLoader.createCompactedResource({
+            range: {
+              '@type': 'ParameterRangeKeyof',
+              parameterRangeValue: {
+                '@id': 'ex:SomeType1',
+                memberKeys: [ '"fieldA"', '"fieldB"' ],
+              },
+            },
+          }),
+          genericsContext,
+          // eslint-disable-next-line max-len
+        )).toThrow(/^The value "fieldC" for parameter ".*" is not of required range type "keyof ex:SomeType1"/u);
+      });
     });
   });