feat(core): support end-user extensions in the rule definitions

Author: pavelkornev

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

@@ -315,6 +315,30 @@ describe('Ruleset', () => {
 `);
   });
 
+  it('should respect extensions', async () => {
+    const ruleset = {
+      rules: {
+        'foo-rule': {
+          given: '$',
+          then: {
+            function() {
+              return;
+            },
+          },
+          extensions: {
+            foo: 'bar',
+          },
+        },
+      },
+    };
+
+    const rulesetInstance = new Ruleset(ruleset);
+
+    expect(rulesetInstance.rules['foo-rule'].extensions).toEqual({
+      foo: 'bar',
+    });
+  });
+
   it('should include parserOptions', async () => {
     const { parserOptions } = await loadRuleset(import('./__fixtures__/parser-options-ruleset'));
 

packages/core/src/ruleset/meta/rule.schema.json

@@ -77,6 +77,9 @@
         "enum": ["style", "validation"],
         "type": "string",
         "errorMessage": "allowed types are \"style\" and \"validation\""
+      },
+      "extensions": {
+        "type": "object"
       }
     },
     "required": ["given", "then"],

packages/core/src/ruleset/rule.ts

@@ -24,9 +24,10 @@ export interface IRule {
   documentationUrl: string | null;
   then: IRuleThen[];
   given: string[];
+  extensions: Record<string, unknown> | null;
 }
 
-type RuleJson = Omit<IRule, 'then'> & {
+type RuleJson = Omit<IRule, 'then' | 'extensions'> & {
   name: string;
   then: (Pick<IRuleThen, 'field'> & { function: string; functionOptions?: string })[];
   owner: number;
@@ -43,6 +44,7 @@ export class Rule implements IRule {
   #enabled: boolean;
   public recommended: boolean;
   public documentationUrl: string | null;
+  public extensions: Record<string, unknown> | null;
   #then!: IRuleThen[];
   #given!: string[];
 
@@ -61,6 +63,7 @@ export class Rule implements IRule {
     this.formats = 'formats' in definition ? new Formats(definition.formats) : null;
     this.then = definition.then;
     this.given = definition.given;
+    this.extensions = definition.extensions ?? null;
   }
 
   public overrides?: { rulesetSource: string; definition: Map<string, Map<string, DiagnosticSeverity | -1>> };

packages/core/src/ruleset/types.ts

@@ -42,6 +42,9 @@ export type RuleDefinition = {
   resolved?: boolean;
 
   then: IRuleThen | IRuleThen[];
+
+  // User extensions/metadata point
+  extensions?: Record<string, unknown>;
 };
 
 export interface IRuleThen {