Add applyAnalysisKindConfig

Author: mbg

src/config/db-config.test.ts

@@ -1,5 +1,6 @@
 import test, { ExecutionContext } from "ava";
 
+import { AnalysisKind } from "../analyses";
 import { RepositoryProperties } from "../feature-flags/properties";
 import { BuiltInLanguage, Language } from "../languages";
 import { getRunnerLogger } from "../logging";
@@ -14,6 +15,117 @@ import { ConfigurationError, prettyPrintPack } from "../util";
 
 import * as dbConfig from "./db-config";
 
+function makeUserConfigWithActionExtensions(options?: {
+  analysisConfig?: dbConfig.UserConfig;
+  analysisKinds?: AnalysisKind[];
+  baseConfig?: dbConfig.UserConfig;
+}) {
+  const testConfig = { ...options?.baseConfig };
+
+  const allAnalysisKinds = Object.values(AnalysisKind);
+  const analysisKinds = options?.analysisKinds ?? allAnalysisKinds;
+  for (const analysisKind of analysisKinds) {
+    testConfig[analysisKind] = { ...options?.analysisConfig };
+  }
+
+  return testConfig as dbConfig.UserConfigWithActionExtensions;
+}
+
+test("hasAnalysisKindKey - finds `AnalysisKind` sections", async (t) => {
+  const testConfig = makeUserConfigWithActionExtensions();
+
+  for (const analysisKind of Object.values(AnalysisKind)) {
+    // Check that it finds the `analysisKind`-specific section among multiple.
+    t.true(dbConfig.hasAnalysisKindKey(analysisKind, testConfig));
+    // And for just the `analysisKind`-specific section.
+    t.true(dbConfig.hasAnalysisKindKey(analysisKind, { [analysisKind]: {} }));
+  }
+});
+
+test("hasAnalysisKindKey - returns false if there is no relevant section", async (t) => {
+  const testConfig = makeUserConfigWithActionExtensions();
+
+  for (const analysisKind of Object.values(AnalysisKind)) {
+    // Clone the `testConfig` and remove the `analysisKind`-specific key.
+    const testConfigClone = { ...testConfig };
+    delete testConfigClone[analysisKind];
+
+    // Check that it doesn't find an `analysisKind`-specific section.
+    t.false(dbConfig.hasAnalysisKindKey(analysisKind, testConfigClone));
+  }
+});
+
+test("applyAnalysisKindConfig - applies analysis-specific settings", async (t) => {
+  for (const analysisKind of Object.values(AnalysisKind)) {
+    const testConfig = makeUserConfigWithActionExtensions({
+      analysisKinds: [analysisKind],
+      analysisConfig: {
+        "paths-ignore": [],
+      },
+      baseConfig: {
+        "paths-ignore": ["a", "b", "c"],
+        "threat-models": ["local"],
+      },
+    });
+    const clonedTestConfig = { ...testConfig };
+
+    const result = dbConfig.applyAnalysisKindConfig(analysisKind, testConfig);
+
+    // The `analysisKind`-specific section should have been removed.
+    // `threat-models` should be unchanged from the `baseConfig`.
+    // `paths-ignore` should have been overwritten with the `analysisKind`-specific config.
+    t.deepEqual(result, {
+      "threat-models": ["local"],
+      "paths-ignore": [],
+    });
+
+    // The input `testConfig` should not have changed.
+    t.deepEqual(testConfig, clonedTestConfig);
+  }
+});
+
+test("applyAnalysisKindConfig - removes all `AnalysisKind`-specific keys", async (t) => {
+  for (const analysisKind of Object.values(AnalysisKind)) {
+    const testConfig = makeUserConfigWithActionExtensions({
+      analysisConfig: {
+        "paths-ignore": ["a", "b", "c"],
+      },
+      baseConfig: {},
+    });
+
+    const result = dbConfig.applyAnalysisKindConfig(analysisKind, testConfig);
+
+    // All `AnalysisKind`-specific sections should have been removed.
+    // `paths-ignore` should have been overwritten with the analysis-specific config.
+    t.deepEqual(result, {
+      "paths-ignore": ["a", "b", "c"],
+    });
+  }
+});
+
+test("applyAnalysisKindConfig - returns the `baseConfig` if there is no `analysisKind`-specific key", async (t) => {
+  const baseConfig = {
+    "disable-default-queries": true,
+    "paths-ignore": ["a", "b", "c"],
+    queries: [{ name: "foo", uses: "something" }],
+    packs: { test: ["bar"] },
+    "default-setup": { org: { "model-packs": ["pack"] } },
+  } satisfies dbConfig.UserConfig;
+
+  const testConfig = makeUserConfigWithActionExtensions({
+    analysisKinds: [],
+    baseConfig,
+  });
+
+  const result = dbConfig.applyAnalysisKindConfig(
+    AnalysisKind.CodeScanning,
+    testConfig,
+  );
+
+  // The result should be the same as the `baseConfig`.
+  t.deepEqual(result, baseConfig);
+});
+
 /**
  * Test macro for ensuring the packs block is valid
  */

src/config/db-config.ts

@@ -4,6 +4,7 @@ import * as yaml from "js-yaml";
 import * as jsonschema from "jsonschema";
 import * as semver from "semver";
 
+import { AnalysisKind } from "../analyses";
 import {
   addNoLanguageDiagnostic,
   makeTelemetryDiagnostic,
@@ -77,6 +78,68 @@ export interface UserConfig {
   "default-setup"?: DefaultSetupConfig;
 }
 
+/** Represents a `UserConfig` with CodeQL Action extensions. */
+export type UserConfigWithActionExtensions = {
+  /**
+   * We add a key for each analysis kind that may contain options
+   * specific to that kind of analysis.
+   */
+  [T in keyof typeof AnalysisKind as (typeof AnalysisKind)[T]]?: UserConfig;
+} & UserConfig;
+
+/**
+ * Determines whether `config` contains an `analysisKind`-specific section.
+ *
+ * @param analysisKind The analysis section to check for.
+ * @param config The base `UserConfig` value.
+ */
+export function hasAnalysisKindKey(
+  analysisKind: AnalysisKind,
+  config: UserConfig,
+): config is UserConfigWithActionExtensions {
+  return analysisKind in config && typeof config[analysisKind] === "object";
+}
+
+/**
+ * Clones `config` and removes any `AnalysisKind`-specific sections.
+ */
+export function removeAnalysisKindConfigs(config: UserConfig): UserConfig {
+  // Clone the configuration and remove any `AnalysisKind`-specific sections.
+  const configWithoutScopes = { ...config };
+  for (const kind of Object.values(AnalysisKind)) {
+    delete configWithoutScopes[kind];
+  }
+  return configWithoutScopes;
+}
+
+/**
+ * Applies an `analysisKind`-specific configuration, if any, to the resulting configuration
+ * and removes all `AnalysisKind`-specific configuration sections.
+ *
+ * @param analysisKind The `AnalysisKind` to apply specific configuration options for.
+ * @param config The loaded configuration, possibly including `analysisKind`-specific settings.
+ */
+export function applyAnalysisKindConfig(
+  analysisKind: AnalysisKind,
+  config: UserConfig,
+): UserConfig {
+  // Clone the configuration and remove any `AnalysisKind`-specific sections.
+  const configWithoutScopes = removeAnalysisKindConfigs(config);
+
+  // If there is no `analysisKind`-specific section, return the input configuration
+  // without any `AnalysisKind`-specific sections.
+  if (!hasAnalysisKindKey(analysisKind, config)) {
+    return configWithoutScopes;
+  }
+
+  // Otherwise, extract the `analysisKind`-specific configuration from the input `config`.
+  const analysisKindSpecificConfig = config[analysisKind];
+
+  // Return the base configuration (without any `AnalysisKind`-specific sections) and
+  // override the top-level properties with the `analysisKind`-specific settings.
+  return { ...configWithoutScopes, ...analysisKindSpecificConfig };
+}
+
 /** A subset of the `UserConfig` schema that is used by Default Setup. */
 const DEFAULT_SETUP_CONFIG_SCHEMA = {
   "threat-models": json.optional(json.array(json.string)),