fix(core): more accurate ruleset error paths

packages/core/src/ruleset/function.ts

@@ -22,10 +22,27 @@ export class RulesetFunctionValidationError extends RulesetValidationError {
     super(
       'invalid-function-options',
       RulesetFunctionValidationError.printMessage(fn, error),
-      error.instancePath.slice(1).split('/'),
+      RulesetFunctionValidationError.getPath(error),
     );
   }
 
+  private static getPath(error: ErrorObject): string[] {
+    const path: string[] = [
+      'functionOptions',
+      ...(error.instancePath === '' ? [] : error.instancePath.slice(1).split('/')),
+    ];
+
+    switch (error.keyword) {
+      case 'additionalProperties': {
+        const additionalProperty = (error as AdditionalPropertiesError).params.additionalProperty;
+        path.push(additionalProperty);
+        break;
+      }
+    }
+
+    return path;
+  }
+
   private static printMessage(fn: string, error: ErrorObject): string {
     switch (error.keyword) {
       case 'type': {
@@ -157,7 +174,7 @@ export function createRulesetFunction<I, O>(
       throw new RulesetValidationError(
         'invalid-function-options',
         `"${fn.name || '<unknown>'}" function does not accept any options`,
-        [],
+        ['functionOptions'],
       );
     } else if (
       'errors' in validateOptions &&
@@ -171,7 +188,7 @@ export function createRulesetFunction<I, O>(
       throw new RulesetValidationError(
         'invalid-function-options',
         `"functionOptions" of "${fn.name || '<unknown>'}" function must be valid`,
-        [],
+        ['functionOptions'],
       );
     }
   };

packages/core/src/ruleset/ruleset.ts

@@ -63,10 +63,10 @@ export class Ruleset {
     if (isPlainObject(maybeDefinition) && 'extends' in maybeDefinition) {
       const { extends: _, ...def } = maybeDefinition;
       // we don't want to validate extends - this is going to happen later on (line 29)
-      assertValidRuleset({ extends: [], ...def });
+      assertValidRuleset({ extends: [], ...def }, 'js');
       definition = maybeDefinition as RulesetDefinition;
     } else {
-      assertValidRuleset(maybeDefinition);
+      assertValidRuleset(maybeDefinition, 'js');
       definition = maybeDefinition;
     }
 

packages/core/src/ruleset/validation/__tests__/validation.test.ts

@@ -773,7 +773,12 @@ describe('JS Ruleset Validation', () => {
         }),
       ).toThrowAggregateError(
         new AggregateError([
-          new RulesetValidationError('undefined-function', 'Function is not defined', ['rules', 'rule', 'then']),
+          new RulesetValidationError('undefined-function', 'Function is not defined', [
+            'rules',
+            'rule',
+            'then',
+            'function',
+          ]),
         ]),
       );
     });

packages/core/src/ruleset/validation/errors.ts

@@ -18,7 +18,7 @@ export type RulesetValidationErrorCode =
   | 'undefined-alias';
 
 interface IRulesetValidationSingleError extends Pick<IDiagnostic, 'message' | 'path'> {
-  code: RulesetValidationErrorCode;
+  readonly code: RulesetValidationErrorCode;
 }
 
 export class RulesetValidationError extends Error implements IRulesetValidationSingleError {

packages/core/src/ruleset/validation/validators/function.ts

@@ -24,7 +24,7 @@ export function validateFunction(
     validator(opts);
   } catch (ex) {
     if (ex instanceof ReferenceError) {
-      return new RulesetValidationError('undefined-function', ex.message, toParsedPath(path));
+      return new RulesetValidationError('undefined-function', ex.message, [...toParsedPath(path), 'function']);
     }
 
     return wrapError(ex, path);

packages/functions/src/__tests__/__helpers__/tester.ts

@@ -6,15 +6,8 @@ import {
   IRuleResult,
   RulesetFunction,
   RulesetFunctionWithValidator,
-  RulesetValidationError,
 } from '@stoplight/spectral-core';
 
-import { isError } from 'lodash';
-
-function isAggregateError(maybeAggregateError: unknown): maybeAggregateError is Error & { errors: unknown[] } {
-  return isError(maybeAggregateError) && maybeAggregateError.constructor.name === 'AggregateError';
-}
-
 export default async function <O = unknown>(
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   fn: RulesetFunction<any, any> | RulesetFunctionWithValidator<any, any>,
@@ -23,31 +16,19 @@ export default async function <O = unknown>(
   rule?: Partial<Omit<RuleDefinition, 'then'>> & { then?: Partial<RuleDefinition['then']> },
 ): Promise<Pick<IRuleResult, 'path' | 'message'>[]> {
   const s = new Spectral();
-  try {
-    s.setRuleset({
-      rules: {
-        'my-rule': {
-          given: '$',
-          ...rule,
-          then: {
-            ...(rule?.then as Ruleset['rules']['then']),
-            function: fn,
-            functionOptions: opts,
-          },
+  s.setRuleset({
+    rules: {
+      'my-rule': {
+        given: '$',
+        ...rule,
+        then: {
+          ...(rule?.then as Ruleset['rules']['then']),
+          function: fn,
+          functionOptions: opts,
         },
       },
-    });
-  } catch (ex) {
-    if (isAggregateError(ex)) {
-      for (const e of ex.errors) {
-        if (e instanceof RulesetValidationError) {
-          e.path.length = 0;
-        }
-      }
-    }
-
-    throw ex;
-  }
+    },
+  });
 
   const results = await s.run(input instanceof Document ? input : JSON.stringify(input));
   return results

packages/functions/src/__tests__/alphabetical.test.ts

@@ -132,17 +132,33 @@ describe('Core Functions / Alphabetical', () => {
       expect(await runAlphabetical([], opts)).toEqual([]);
     });
 
-    it.each<[unknown, string]>([
-      [{ foo: true }, '"alphabetical" function does not support "foo" option'],
+    it.each<[unknown, RulesetValidationError]>([
+      [
+        { foo: true },
+        new RulesetValidationError(
+          'invalid-function-options',
+          '"alphabetical" function does not support "foo" option',
+          ['rules', 'my-rule', 'then', 'functionOptions', 'foo'],
+        ),
+      ],
       [
         2,
-        '"alphabetical" function has invalid options specified. Example valid options: null (no options), { "keyedBy": "my-key" }',
+        new RulesetValidationError(
+          'invalid-function-options',
+          '"alphabetical" function has invalid options specified. Example valid options: null (no options), { "keyedBy": "my-key" }',
+          ['rules', 'my-rule', 'then', 'functionOptions'],
+        ),
+      ],
+      [
+        { keyedBy: 2 },
+        new RulesetValidationError(
+          'invalid-function-options',
+          '"alphabetical" function and its "keyedBy" option accepts only the following types: string',
+          ['rules', 'my-rule', 'then', 'functionOptions', 'keyedBy'],
+        ),
       ],
-      [{ keyedBy: 2 }, '"alphabetical" function and its "keyedBy" option accepts only the following types: string'],
     ])('given invalid %p options, should throw', async (opts, error) => {
-      await expect(runAlphabetical([], opts)).rejects.toThrowAggregateError(
-        new AggregateError([new RulesetValidationError('invalid-function-options', error, [])]),
-      );
+      await expect(runAlphabetical([], opts)).rejects.toThrowAggregateError(new AggregateError([error]));
     });
   });
 });

packages/functions/src/__tests__/casing.test.ts

@@ -381,13 +381,21 @@ describe('Core Functions / Casing', () => {
           new RulesetValidationError(
             'invalid-function-options',
             '"casing" function and its "type" option accept the following values: flat, camel, pascal, kebab, cobol, snake, macro',
-            [],
+            ['rules', 'my-rule', 'then', 'functionOptions', 'type'],
           ),
         ],
       ],
       [
         { type: 'macro', foo: true },
-        [new RulesetValidationError('invalid-function-options', '"casing" function does not support "foo" option', [])],
+        [
+          new RulesetValidationError('invalid-function-options', '"casing" function does not support "foo" option', [
+            'rules',
+            'my-rule',
+            'then',
+            'functionOptions',
+            'foo',
+          ]),
+        ],
       ],
       [
         {
@@ -399,7 +407,7 @@ describe('Core Functions / Casing', () => {
           new RulesetValidationError(
             'invalid-function-options',
             '"casing" function is missing "separator.char" option',
-            [],
+            ['rules', 'my-rule', 'then', 'functionOptions', 'separator'],
           ),
         ],
       ],
@@ -413,7 +421,7 @@ describe('Core Functions / Casing', () => {
           new RulesetValidationError(
             'invalid-function-options',
             '"casing" function is missing "separator.char" option',
-            [],
+            ['rules', 'my-rule', 'then', 'functionOptions', 'separator'],
           ),
         ],
       ],
@@ -423,7 +431,7 @@ describe('Core Functions / Casing', () => {
           new RulesetValidationError(
             'invalid-function-options',
             '"casing" function does not support "separator.foo" option',
-            [],
+            ['rules', 'my-rule', 'then', 'functionOptions', 'separator', 'foo'],
           ),
         ],
       ],
@@ -438,7 +446,7 @@ describe('Core Functions / Casing', () => {
           new RulesetValidationError(
             'invalid-function-options',
             '"casing" function and its "separator.char" option accepts only char, i.e. "I" or "/"',
-            [],
+            ['rules', 'my-rule', 'then', 'functionOptions', 'separator', 'char'],
           ),
         ],
       ],
@@ -453,7 +461,7 @@ describe('Core Functions / Casing', () => {
           new RulesetValidationError(
             'invalid-function-options',
             '"casing" function and its "separator.char" option accepts only char, i.e. "I" or "/"',
-            [],
+            ['rules', 'my-rule', 'then', 'functionOptions', 'separator', 'char'],
           ),
         ],
       ],

packages/functions/src/__tests__/defined.test.ts

@@ -25,7 +25,12 @@ describe('Core Functions / Defined', () => {
     it.each([{}, 2])('given invalid %p options, should throw', async opts => {
       await expect(runDefined([], opts)).rejects.toThrowAggregateError(
         new AggregateError([
-          new RulesetValidationError('invalid-function-options', '"defined" function does not accept any options', []),
+          new RulesetValidationError('invalid-function-options', '"defined" function does not accept any options', [
+            'rules',
+            'my-rule',
+            'then',
+            'functionOptions',
+          ]),
         ]),
       );
     });

packages/functions/src/__tests__/enumeration.test.ts

@@ -44,7 +44,7 @@ describe('Core Functions / Enumeration', () => {
           new RulesetValidationError(
             'invalid-function-options',
             '"enumeration" function does not support "foo" option',
-            [],
+            ['rules', 'my-rule', 'then', 'functionOptions', 'foo'],
           ),
         ],
       ],
@@ -56,7 +56,7 @@ describe('Core Functions / Enumeration', () => {
           new RulesetValidationError(
             'invalid-function-options',
             '"enumeration" and its "values" option support only arrays of primitive values, i.e. ["Berlin", "London", "Paris"]',
-            [],
+            ['rules', 'my-rule', 'then', 'functionOptions', 'values'],
           ),
         ],
       ],
@@ -66,7 +66,7 @@ describe('Core Functions / Enumeration', () => {
           new RulesetValidationError(
             'invalid-function-options',
             '"enumeration" function has invalid options specified. Example valid options: { "values": ["Berlin", "London", "Paris"] }, { "values": [2, 3, 5, 8, 13, 21] }',
-            [],
+            ['rules', 'my-rule', 'then', 'functionOptions'],
           ),
         ],
       ],
@@ -76,7 +76,7 @@ describe('Core Functions / Enumeration', () => {
           new RulesetValidationError(
             'invalid-function-options',
             '"enumeration" function has invalid options specified. Example valid options: { "values": ["Berlin", "London", "Paris"] }, { "values": [2, 3, 5, 8, 13, 21] }',
-            [],
+            ['rules', 'my-rule', 'then', 'functionOptions'],
           ),
         ],
       ],

packages/functions/src/__tests__/falsy.test.ts

@@ -25,7 +25,12 @@ describe('Core Functions / Falsy', () => {
     it.each([{}, 2])('given invalid %p options, should throw', async opts => {
       await expect(runFalsy([], opts)).rejects.toThrowAggregateError(
         new AggregateError([
-          new RulesetValidationError('invalid-function-options', '"falsy" function does not accept any options', []),
+          new RulesetValidationError('invalid-function-options', '"falsy" function does not accept any options', [
+            'rules',
+            'my-rule',
+            'then',
+            'functionOptions',
+          ]),
         ]),
       );
     });

packages/functions/src/__tests__/length.test.ts

@@ -61,7 +61,7 @@ describe('Core Functions / Length', () => {
           new RulesetValidationError(
             'invalid-function-options',
             '"length" function has invalid options specified. Example valid options: { "min": 2 }, { "max": 5 }, { "min": 0, "max": 10 }',
-            [],
+            ['rules', 'my-rule', 'then', 'functionOptions'],
           ),
         ],
       ],
@@ -71,7 +71,7 @@ describe('Core Functions / Length', () => {
           new RulesetValidationError(
             'invalid-function-options',
             '"length" function has invalid options specified. Example valid options: { "min": 2 }, { "max": 5 }, { "min": 0, "max": 10 }',
-            [],
+            ['rules', 'my-rule', 'then', 'functionOptions'],
           ),
         ],
       ],
@@ -80,15 +80,23 @@ describe('Core Functions / Length', () => {
           min: 2,
           foo: true,
         },
-        [new RulesetValidationError('invalid-function-options', '"length" function does not support "foo" option', [])],
+        [
+          new RulesetValidationError('invalid-function-options', '"length" function does not support "foo" option', [
+            'rules',
+            'my-rule',
+            'then',
+            'functionOptions',
+            'foo',
+          ]),
+        ],
       ],
       [
         { min: '2' },
         [
           new RulesetValidationError(
             'invalid-function-options',
-            '"length" function and its "min" option accepts only the following types: number',
-            [],
+            `"length" function and its "min" option accepts only the following types: number`,
+            ['rules', 'my-rule', 'then', 'functionOptions', 'min'],
           ),
         ],
       ],
@@ -99,7 +107,7 @@ describe('Core Functions / Length', () => {
           new RulesetValidationError(
             'invalid-function-options',
             `"length" function and its "max" option accepts only the following types: number`,
-            [],
+            ['rules', 'my-rule', 'then', 'functionOptions', 'max'],
           ),
         ],
       ],
@@ -109,12 +117,12 @@ describe('Core Functions / Length', () => {
           new RulesetValidationError(
             'invalid-function-options',
             `"length" function and its "min" option accepts only the following types: number`,
-            [],
+            ['rules', 'my-rule', 'then', 'functionOptions', 'min'],
           ),
           new RulesetValidationError(
             'invalid-function-options',
             `"length" function and its "max" option accepts only the following types: number`,
-            [],
+            ['rules', 'my-rule', 'then', 'functionOptions', 'max'],
           ),
         ],
       ],