fix: remove unnecessary creation of rules/instances

Signed-off-by: Fredrik Nordlander <fredrik.nordlander@digg.se>

Author: fredriknordlander

src/cli-mode.ts

@@ -21,6 +21,7 @@ import { parseApiSpecInput,detectSpecFormatPreference, ParseResult} from './util
 import { SpecParseError } from './util/RapLPSpecParseError.js';
 import * as path from 'node:path';
 import { RuleExecutionContext } from './util/RuleExecutionContext.js';
+import { parseRuleCategories,resolveRuleCategories } from './rulesets/util/ruleModules.js';
 
 declare var AggregateError: {
   prototype: AggregateError;
@@ -44,7 +45,9 @@ export async function execCLI<T extends CliArgs>(argv: T) {
   try {
     // Parse command-line arguments using yargs
     const apiSpecFileName = (argv.file as string) || '';
-    const ruleCategories = argv.categories ? (argv.categories as string).split(',') : undefined;
+    //const ruleCategories = argv.categories ? (argv.categories as string).split(',') : undefined;
+    const ruleCategories = parseRuleCategories(argv.categories as string | undefined);
+    const resolvedCategories = resolveRuleCategories(ruleCategories);
     const logErrorFilePath = argv.logError as string | undefined;
     const logDiagnosticFilePath = argv.logDiagnostic as string | undefined;
     const strict = argv.strict as boolean ?? false;
@@ -128,7 +131,7 @@ export async function execCLI<T extends CliArgs>(argv: T) {
 
     try {
       // Import and create rule instances in RAP-LP
-      const enabledRulesAndCategorys = await importAndCreateRuleInstances(context,ruleCategories);
+      const enabledRulesAndCategorys = await importAndCreateRuleInstances(context,resolvedCategories);
       // Load API specification into a Document object
       const parser: IParser<any> = (parseResult.format === 'json' ? Parsers.Json : Parsers.Yaml) as unknown as IParser<any>;
       apiSpecDocument = new SpectralDocument(parseResult.raw, parser, apiSpecFileName);

src/routes/urlValidation.ts

@@ -11,6 +11,7 @@ import { importAndCreateRuleInstances } from '../util/ruleUtil.js';
 import { ERROR_TYPE, RapLPBaseApiError } from '../util/RapLPBaseApiErrorHandling.js';
 import { loadUrlValidationConfiguration } from '../util/urlValidationConfig.js';
 import { RuleExecutionContext } from '../util/RuleExecutionContext.js';
+import { parseRuleCategories,resolveRuleCategories } from '../rulesets/util/ruleModules.js';
 
 export const registerUrlValidationRoutes = (app: Express, urlValidationConfigFile?: string) => {
   const config = loadUrlValidationConfiguration(urlValidationConfigFile);
@@ -34,10 +35,12 @@ export const registerUrlValidationRoutes = (app: Express, urlValidationConfigFil
       const yamlContentString = await response.text();
 
       validateYamlInput(yamlContentString);
+      
+      const apiSpecDocument = new Document(yamlContentString, Parsers.Yaml, 'payload.yaml');
+      const ruleCategories = parseRuleCategories(dto.categories);
+      const resolvedCategories = resolveRuleCategories(ruleCategories);
 
-      const apiSpecDocument = new Document(yamlContentString, Parsers.Yaml, '');
-
-      const rules = await importAndCreateRuleInstances(context, dto.categories);
+      const rules = await importAndCreateRuleInstances(context, resolvedCategories);
 
       const result = await processApiSpec(context,rules, apiSpecDocument);
       res.send(result);

src/routes/validate.ts

@@ -20,6 +20,8 @@ import { ERROR_TYPE, RapLPBaseApiError } from '../util/RapLPBaseApiErrorHandling
 import type { IParser } from '@stoplight/spectral-parsers';
 import { stringify } from 'node:querystring';
 import { RuleExecutionContext } from '../util/RuleExecutionContext.js';
+import { parseRuleCategories,resolveRuleCategories,RULE_REGISTRY} from '../rulesets/util/ruleModules.js';
+
 
 
 
@@ -28,16 +30,24 @@ export const registerValidationRoutes = (app: Express) => {
   app.post('/api/v1/validation/validate', async (req, res, next) => {
     try {
       const context = new RuleExecutionContext();
+      
+      const body: SpecValidationRequestDto = req.body;
+      const strict = body.strict ?? true;
+      const categories = body.categories ?? [];
+
       const yamlContent: YamlContentDto = req.body;
 
-      let yamlContentString: string;
-      yamlContentString = decodeBase64String(yamlContent.yaml);
+      //let yamlContentString: string;
+      //yamlContentString = decodeBase64String(yamlContent.yaml);
+      const raw = decodeBase64String(body.spec);
 
-      validateYamlInput(yamlContentString);
+      validateYamlInput(raw); // Do we need this ?
 
-      const apiSpecDocument = new Document(yamlContentString, Parsers.Yaml, '');
+      const apiSpecDocument = new Document(raw, Parsers.Yaml, 'payload.yaml');
+      const ruleCategories = parseRuleCategories(categories);
+      const resolvedCategories = resolveRuleCategories(ruleCategories);
 
-      const rules = await importAndCreateRuleInstances(context, yamlContent.categories);
+      const rules = await importAndCreateRuleInstances(context, resolvedCategories);
 
       const result = await processApiSpec(context,rules, apiSpecDocument);
       res.send(result);
@@ -47,7 +57,7 @@ export const registerValidationRoutes = (app: Express) => {
   });
 
   app.get('/api/v1/validation/rules', (req, res) => {
-    res.send(validationRules);
+    res.send(RULE_REGISTRY);
   });
 
   app.get('/api/v1/api-info', async (req, res, next) => {
@@ -144,8 +154,12 @@ export const registerValidationRoutes = (app: Express) => {
 
       // 5. No strict-errors → run raplp ruleengine
       const parser: IParser<any> = (parseResult.format === 'json' ? Parsers.Json : Parsers.Yaml) as unknown as IParser<any>;
-       const apiSpecDocument = new Document(parseResult.raw, parser, 'payload.yaml'); // In-memory-file to calculate correct positions when parsing
-      const rules = await importAndCreateRuleInstances(context, categories);
+      const apiSpecDocument = new Document(parseResult.raw, parser, 'payload.yaml'); // In-memory-file to calculate correct positions when parsing
+
+      const ruleCategories = parseRuleCategories(categories);
+      const resolvedCategories = resolveRuleCategories(ruleCategories);
+
+      const rules = await importAndCreateRuleInstances(context, resolvedCategories);
       const result = await processApiSpec(context, rules, apiSpecDocument);
 
       const hasRuleViolations = result.result.some(

src/rulesets/util/ruleModules.ts

@@ -0,0 +1,60 @@
+// SPDX-FileCopyrightText: 2025 Digg - Agency for Digital Government
+//
+// SPDX-License-Identifier: EUPL-1.2
+
+export const RULE_REGISTRY = [
+  { rule: 'UfnRules', description: 'URL Format och namngivning' },
+  { rule: 'SakRules', description: 'Säkerhet' },
+  { rule: 'VerRules', description: 'Versionshantering' },
+  { rule: 'FnsRules', description: 'Filtrering, paginering och sökparametrar' },
+  { rule: 'ArqRules', description: 'API Request' },
+  { rule: 'DokRules', description: 'Dokumentation' },
+  { rule: 'AmeRules', description: 'API Message' },
+  { rule: 'ForRules', description: 'Förutsättningar' },
+  { rule: 'DotRules', description: 'Datum- och tidsformat' },
+  { rule: 'ResRules', description: 'Mognad' },
+  { rule: 'MogRules', description: 'Datum- och tidsformat' },
+  { rule: 'FelRules', description: 'Felhantering' },
+] as const;
+    
+export type RuleModuleName = typeof RULE_REGISTRY[number]['rule'];
+export const RULE_MODULE_NAMES: RuleModuleName[] = 
+    RULE_REGISTRY.map(r => r.rule);
+
+export function parseRuleCategories(
+  input?: string | string[]
+): RuleModuleName[] | undefined {
+
+  if (!input) return undefined;
+
+  const categories =
+    typeof input === "string"
+      ? input.split(",").map(c => c.trim())
+      : input;
+
+  const invalid = categories.filter(
+    c => !RULE_MODULE_NAMES.includes(c as RuleModuleName)
+  );
+
+  if (invalid.length) {
+    throw new Error(`Invalid rule categories: ${invalid.join(", ")}`);
+  }
+
+  return categories as RuleModuleName[];
+}
+export function resolveRuleCategories(
+  categories?: RuleModuleName[]
+): RuleModuleName[] {
+
+  if (!categories || categories.length === 0) {
+    return [...RULE_MODULE_NAMES];
+  }
+
+  const result = [...categories];
+
+  if (!result.includes('ForRules')) {
+    result.push('ForRules');
+  }
+
+  return result;
+}

src/util/ruleUtil.ts

@@ -4,6 +4,7 @@
 
 import { RuleCategoryError } from './RapLPBaseApiErrorHandling.js';
 import { RuleExecutionContext } from './RuleExecutionContext.js';
+import { RuleModuleName } from '../rulesets/util/ruleModules.js';
 
 // ruleUtil.ts
 interface CustomSchema {
@@ -47,7 +48,7 @@ export function getRuleModules() {
  * @returns Promise object with enabled rules in RAP-LP to run
  */
 export async function importAndCreateRuleInstances(
-  context: RuleExecutionContext, ruleCategories?: string[],
+  context: RuleExecutionContext, ruleCategories: RuleModuleName[],
 ): Promise<{ rules: Record<string, any>; instanceCategoryMap: Map<string, any> }> {
   const ruleInstances: Record<string, any> = {}; // store instances of rule classes
   const ruleTypes: any[] = []; // array to store rule classes.