@red-hat-developer-hub/e2e-test-utils 1.1.10

package/dist/utils/merge-yamls.js

@@ -0,0 +1,96 @@
+import fs from "fs-extra";
+import yaml from "js-yaml";
+import mergeWith from "lodash.mergewith";
+/**
+ * Merges two arrays of objects by a specific key.
+ * Objects with matching keys are deeply merged, new objects are appended.
+ */
+function mergeArraysByKey(target, source, key, mergeOptions) {
+    const result = [...target];
+    for (const srcItem of source) {
+        if (typeof srcItem === "object" && srcItem !== null && key in srcItem) {
+            const srcKeyValue = srcItem[key];
+            const existingIndex = result.findIndex((item) => typeof item === "object" &&
+                item !== null &&
+                item[key] === srcKeyValue);
+            if (existingIndex !== -1) {
+                // Merge existing object with source object
+                result[existingIndex] = deepMerge(result[existingIndex], srcItem, mergeOptions);
+            }
+            else {
+                // Append new object
+                result.push(srcItem);
+            }
+        }
+        else {
+            // Non-object or missing key, append as-is
+            result.push(srcItem);
+        }
+    }
+    return result;
+}
+/**
+ * Deeply merges two YAML-compatible objects.
+ * Array handling is controlled by the arrayMergeStrategy option.
+ */
+export function deepMerge(target, source, options = {}) {
+    const strategy = options.arrayMergeStrategy ?? "replace";
+    return mergeWith({ ...target }, source, (objValue, srcValue) => {
+        if (Array.isArray(objValue) && Array.isArray(srcValue)) {
+            if (strategy === "replace") {
+                return srcValue;
+            }
+            else if (strategy === "concat") {
+                return [...objValue, ...srcValue];
+            }
+            else if (typeof strategy === "object" && "byKey" in strategy) {
+                return mergeArraysByKey(objValue, srcValue, strategy.byKey, options);
+            }
+        }
+    });
+}
+/**
+ * Merge multiple YAML files into one object.
+ *
+ * @param paths List of YAML file paths (base first, overlays last)
+ * @param options Optional merge options (e.g., arrayMergeStrategy)
+ * @returns Merged YAML object
+ */
+export async function mergeYamlFiles(paths, options = {}) {
+    let merged = {};
+    for (const path of paths) {
+        const content = await fs.readFile(path, "utf8");
+        const parsed = (yaml.load(content) || {});
+        merged = deepMerge(merged, parsed, options);
+    }
+    return merged;
+}
+/**
+ * Merge multiple YAML files if they exist.
+ *
+ * @param paths List of YAML file paths
+ * @param options Optional merge options (e.g., arrayMergeStrategy)
+ * @returns Merged YAML object
+ */
+export async function mergeYamlFilesIfExists(paths, options = {}) {
+    return await mergeYamlFiles(paths.filter((path) => {
+        const exists = fs.existsSync(path);
+        if (!exists)
+            console.log(`YAML file ${path} does not exist`);
+        return exists;
+    }), options);
+}
+/**
+ * Merge multiple YAML files and write the result to an output file.
+ *
+ * @param inputPaths List of input YAML files
+ * @param outputPath Output YAML file path
+ * @param dumpOptions Optional dump formatting
+ * @param mergeOptions Optional merge options (e.g., arrayMergeStrategy)
+ */
+export async function mergeYamlFilesToFile(inputPaths, outputPath, dumpOptions = { lineWidth: -1 }, mergeOptions = {}) {
+    const merged = await mergeYamlFiles(inputPaths, mergeOptions);
+    const yamlString = yaml.dump(merged, dumpOptions);
+    await fs.outputFile(outputPath, yamlString);
+    console.log(`Merged ${inputPaths.length} YAML files into ${outputPath}`);
+}

package/dist/utils/plugin-metadata.d.ts

@@ -0,0 +1,116 @@
+/**
+ * Represents parsed plugin metadata from a Package CRD file.
+ */
+export interface PluginMetadata {
+    /** The dynamic artifact path (e.g., ./dynamic-plugins/dist/plugin-name) */
+    packagePath: string;
+    /** The plugin configuration from appConfigExamples[0].content */
+    pluginConfig: Record<string, unknown>;
+    /** The package name (e.g., @backstage-community/plugin-tech-radar) */
+    packageName: string;
+    /** Source metadata file path */
+    sourceFile: string;
+}
+/**
+ * Checks if plugin metadata handling should be enabled.
+ * This controls both auto-generation and injection of plugin metadata.
+ *
+ * Default: ENABLED (for local dev and PR builds)
+ * Disabled when:
+ * - RHDH_SKIP_PLUGIN_METADATA_INJECTION is set, OR
+ * - JOB_NAME contains "periodic-" (nightly/periodic builds)
+ */
+export declare function shouldInjectPluginMetadata(): boolean;
+/**
+ * Extracts the plugin name from a package path or OCI reference.
+ *
+ * Handles various formats:
+ * - Local path: ./dynamic-plugins/dist/backstage-community-plugin-tech-radar
+ * - OCI with integrity: oci://quay.io/rhdh/plugin@sha256:...!backstage-community-plugin-tech-radar
+ * - OCI without integrity: oci://quay.io/rhdh/backstage-community-plugin-tech-radar:tag
+ *
+ * @param packageRef The package reference string
+ * @returns The extracted plugin name
+ */
+export declare function extractPluginName(packageRef: string): string;
+/**
+ * Default metadata directory path relative to the e2e-tests directory.
+ * Follows the same pattern as user config paths (e.g., tests/config/dynamic-plugins.yaml).
+ */
+export declare const DEFAULT_METADATA_PATH = "../metadata";
+/**
+ * Gets the metadata directory path.
+ * Uses the provided path or falls back to DEFAULT_METADATA_PATH.
+ *
+ * @param metadataPath Optional custom path to metadata directory
+ * @returns The metadata directory path, or null if it doesn't exist
+ */
+export declare function getMetadataDirectory(metadataPath?: string): string | null;
+/**
+ * Parses a single metadata YAML file and extracts plugin configuration.
+ *
+ * @param filePath Path to the metadata YAML file
+ * @returns PluginMetadata if valid, null otherwise
+ */
+export declare function parseMetadataFile(filePath: string): Promise<PluginMetadata>;
+/**
+ * Parses all metadata files in a directory and builds a map of plugin name to config.
+ * The plugin name is extracted from the dynamicArtifact path for flexible matching.
+ *
+ * @param metadataDir Path to the metadata directory
+ * @returns Map of plugin name to plugin configuration
+ */
+export declare function parseAllMetadataFiles(metadataDir: string): Promise<Map<string, PluginMetadata>>;
+/**
+ * Plugin entry in dynamic-plugins.yaml
+ */
+export interface PluginEntry {
+    package: string;
+    disabled?: boolean;
+    pluginConfig?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+/**
+ * Dynamic plugins configuration structure
+ */
+export interface DynamicPluginsConfig {
+    plugins?: PluginEntry[];
+    includes?: string[];
+    [key: string]: unknown;
+}
+/**
+ * Injects plugin configurations from metadata into a dynamic plugins config.
+ * Metadata config serves as the base, user-provided pluginConfig overrides it.
+ *
+ * Matching is done by extracting the plugin name from both the package reference
+ * and the metadata's dynamicArtifact, allowing flexible matching across different
+ * package formats (local paths, OCI references, etc.).
+ *
+ * @param dynamicPluginsConfig The dynamic plugins configuration to augment
+ * @param metadataMap Map of plugin names to plugin metadata
+ * @returns The augmented configuration with injected pluginConfigs
+ */
+export declare function injectMetadataConfig(dynamicPluginsConfig: DynamicPluginsConfig, metadataMap: Map<string, PluginMetadata>): DynamicPluginsConfig;
+/**
+ * Generates a complete dynamic-plugins configuration from metadata files.
+ * Iterates through all metadata files and creates plugin entries with:
+ * - package: the dynamicArtifact path
+ * - disabled: false (enabled by default)
+ * - pluginConfig: from appConfigExamples[0].content
+ *
+ * @param metadataPath Optional custom path to metadata directory (default: ../metadata)
+ * @returns Complete dynamic plugins configuration
+ * @throws Error if metadata directory not found or no valid metadata files
+ */
+export declare function generateDynamicPluginsConfigFromMetadata(metadataPath?: string): Promise<DynamicPluginsConfig>;
+/**
+ * Main function to load and inject plugin metadata for PR builds.
+ * For non-PR builds (nightly), returns the config unchanged.
+ *
+ * @param dynamicPluginsConfig The dynamic plugins configuration
+ * @param metadataPath Optional custom path to metadata directory (default: ../metadata)
+ * @returns Augmented configuration with metadata (for PR) or unchanged (for nightly)
+ * @throws Error if PR build but no metadata directory found
+ */
+export declare function loadAndInjectPluginMetadata(dynamicPluginsConfig: DynamicPluginsConfig, metadataPath?: string): Promise<DynamicPluginsConfig>;
+//# sourceMappingURL=plugin-metadata.d.ts.map

package/dist/utils/plugin-metadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-metadata.d.ts","sourceRoot":"","sources":["../../src/utils/plugin-metadata.ts"],"names":[],"mappings":"AA8HA;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,2EAA2E;IAC3E,WAAW,EAAE,MAAM,CAAC;IACpB,iEAAiE;IACjE,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACtC,sEAAsE;IACtE,WAAW,EAAE,MAAM,CAAC;IACpB,gCAAgC;IAChC,UAAU,EAAE,MAAM,CAAC;CACpB;AAgBD;;;;;;;;GAQG;AACH,wBAAgB,0BAA0B,IAAI,OAAO,CAmBpD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAQ5D;AAED;;;GAGG;AACH,eAAO,MAAM,qBAAqB,gBAAgB,CAAC;AAEnD;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,YAAY,GAAE,MAA8B,GAC3C,MAAM,GAAG,IAAI,CAUf;AAED;;;;;GAKG;AACH,wBAAsB,iBAAiB,CACrC,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,cAAc,CAAC,CA0BzB;AAED;;;;;;GAMG;AACH,wBAAsB,qBAAqB,CACzC,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC,CAwBtC;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACvC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,OAAO,CAAC,EAAE,WAAW,EAAE,CAAC;IACxB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AA4CD;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAClC,oBAAoB,EAAE,oBAAoB,EAC1C,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,GACvC,oBAAoB,CAsCtB;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,wCAAwC,CAC5D,YAAY,GAAE,MAA8B,GAC3C,OAAO,CAAC,oBAAoB,CAAC,CAsD/B;AAED;;;;;;;;GAQG;AACH,wBAAsB,2BAA2B,CAC/C,oBAAoB,EAAE,oBAAoB,EAC1C,YAAY,GAAE,MAA8B,GAC3C,OAAO,CAAC,oBAAoB,CAAC,CAuC/B"}

package/dist/utils/plugin-metadata.js

@@ -0,0 +1,330 @@
+import fs from "fs-extra";
+import path from "path";
+import yaml from "js-yaml";
+import { glob } from "zx";
+import { deepMerge } from "./merge-yamls.js";
+const OCI_REGISTRY_PREFIX = "oci://ghcr.io/redhat-developer/rhdh-plugin-export-overlays";
+/**
+ * Fetches plugin versions from source repo and builds OCI URL map.
+ * Only called when GIT_PR_NUMBER is set.
+ */
+async function getOCIUrlsForPR(workspacePath, prNumber) {
+    const ociUrls = new Map();
+    const sourceJsonPath = path.join(workspacePath, "source.json");
+    const pluginsListPath = path.join(workspacePath, "plugins-list.yaml");
+    if (!fs.existsSync(sourceJsonPath)) {
+        throw new Error(`[PluginMetadata] PR build requires source.json but not found at: ${sourceJsonPath}`);
+    }
+    if (!fs.existsSync(pluginsListPath)) {
+        throw new Error(`[PluginMetadata] PR build requires plugins-list.yaml but not found at: ${pluginsListPath}`);
+    }
+    const sourceJson = JSON.parse(await fs.readFile(sourceJsonPath, "utf-8"));
+    const { repo, "repo-ref": ref, "repo-flat": repoFlat } = sourceJson;
+    if (!repo) {
+        throw new Error(`[PluginMetadata] source.json is missing required 'repo' field: ${sourceJsonPath}`);
+    }
+    if (!ref) {
+        throw new Error(`[PluginMetadata] source.json is missing required 'repo-ref' field: ${sourceJsonPath}`);
+    }
+    // Parse owner/repo from URL
+    const match = repo.match(/github\.com\/(.+?)(?:\.git)?$/);
+    if (!match) {
+        throw new Error(`[PluginMetadata] Failed to parse GitHub repo from source.json: ${repo}`);
+    }
+    const ownerRepo = match[1];
+    // Parse plugins-list.yaml as YAML and extract keys (plugin paths)
+    const pluginsListContent = await fs.readFile(pluginsListPath, "utf-8");
+    const pluginsListData = yaml.load(pluginsListContent);
+    if (!pluginsListData || typeof pluginsListData !== "object") {
+        throw new Error(`[PluginMetadata] plugins-list.yaml is empty or invalid: ${pluginsListPath}`);
+    }
+    const pluginPaths = Object.keys(pluginsListData);
+    const workspaceName = path.basename(workspacePath);
+    console.log(`[PluginMetadata] Fetching versions for ${pluginPaths.length} plugins from source...`);
+    for (const pluginPath of pluginPaths) {
+        const pkgJsonPath = repoFlat
+            ? `${pluginPath}/package.json`
+            : `workspaces/${workspaceName}/${pluginPath}/package.json`;
+        const rawUrl = `https://raw.githubusercontent.com/${ownerRepo}/${ref}/${pkgJsonPath}`;
+        const res = await fetch(rawUrl);
+        if (!res.ok) {
+            throw new Error(`[PluginMetadata] Failed to fetch package.json for ${pluginPath}: ${res.status} ${res.statusText}\n` +
+                `  URL: ${rawUrl}`);
+        }
+        const pkgJson = (await res.json());
+        if (!pkgJson.name) {
+            throw new Error(`[PluginMetadata] package.json is missing 'name' field for ${pluginPath}\n` +
+                `  URL: ${rawUrl}`);
+        }
+        if (!pkgJson.version) {
+            throw new Error(`[PluginMetadata] package.json is missing 'version' field for ${pluginPath}\n` +
+                `  URL: ${rawUrl}`);
+        }
+        const { name, version } = pkgJson;
+        // @backstage-community/plugin-tech-radar -> backstage-community-plugin-tech-radar
+        const displayName = name.replace(/^@/, "").replace(/\//g, "-");
+        // TODO(RHDHBUGS-2530): Remove !alias suffix once Konflux builds include
+        // io.backstage.dynamic-packages annotation. The suffix is a workaround
+        // because install-dynamic-plugins.py can't auto-detect plugin path without it.
+        const ociUrl = `${OCI_REGISTRY_PREFIX}/${displayName}:pr_${prNumber}__${version}!${displayName}`;
+        ociUrls.set(displayName, ociUrl);
+        console.log(`[PluginMetadata] ${displayName} -> ${ociUrl}`);
+    }
+    return ociUrls;
+}
+/**
+ * Checks if plugin metadata handling should be enabled.
+ * This controls both auto-generation and injection of plugin metadata.
+ *
+ * Default: ENABLED (for local dev and PR builds)
+ * Disabled when:
+ * - RHDH_SKIP_PLUGIN_METADATA_INJECTION is set, OR
+ * - JOB_NAME contains "periodic-" (nightly/periodic builds)
+ */
+export function shouldInjectPluginMetadata() {
+    // Explicit opt-out
+    if (process.env.RHDH_SKIP_PLUGIN_METADATA_INJECTION) {
+        console.log("[PluginMetadata] Metadata handling disabled (RHDH_SKIP_PLUGIN_METADATA_INJECTION is set)");
+        return false;
+    }
+    // Periodic/nightly job
+    const jobName = process.env.JOB_NAME || "";
+    if (jobName.includes("periodic-")) {
+        console.log("[PluginMetadata] Metadata handling disabled (periodic job detected)");
+        return false;
+    }
+    return true;
+}
+/**
+ * Extracts the plugin name from a package path or OCI reference.
+ *
+ * Handles various formats:
+ * - Local path: ./dynamic-plugins/dist/backstage-community-plugin-tech-radar
+ * - OCI with integrity: oci://quay.io/rhdh/plugin@sha256:...!backstage-community-plugin-tech-radar
+ * - OCI without integrity: oci://quay.io/rhdh/backstage-community-plugin-tech-radar:tag
+ *
+ * @param packageRef The package reference string
+ * @returns The extracted plugin name
+ */
+export function extractPluginName(packageRef) {
+    // Strip ! suffix if present (e.g., oci://...@sha256:...!alias)
+    const ref = packageRef.includes("!") ? packageRef.split("!")[0] : packageRef;
+    // Regex to extract plugin name from various formats:
+    // Captures the last path segment (chars except / : @) before any :tag or @digest
+    const match = ref.match(/\/([^/:@]+)(?:[:@].*)?$/);
+    return match?.[1] || packageRef;
+}
+/**
+ * Default metadata directory path relative to the e2e-tests directory.
+ * Follows the same pattern as user config paths (e.g., tests/config/dynamic-plugins.yaml).
+ */
+export const DEFAULT_METADATA_PATH = "../metadata";
+/**
+ * Gets the metadata directory path.
+ * Uses the provided path or falls back to DEFAULT_METADATA_PATH.
+ *
+ * @param metadataPath Optional custom path to metadata directory
+ * @returns The metadata directory path, or null if it doesn't exist
+ */
+export function getMetadataDirectory(metadataPath = DEFAULT_METADATA_PATH) {
+    const resolvedPath = path.resolve(metadataPath);
+    if (fs.existsSync(resolvedPath) && fs.statSync(resolvedPath).isDirectory()) {
+        console.log(`[PluginMetadata] Using metadata directory: ${resolvedPath}`);
+        return resolvedPath;
+    }
+    console.log(`[PluginMetadata] Metadata directory not found: ${resolvedPath}`);
+    return null;
+}
+/**
+ * Parses a single metadata YAML file and extracts plugin configuration.
+ *
+ * @param filePath Path to the metadata YAML file
+ * @returns PluginMetadata if valid, null otherwise
+ */
+export async function parseMetadataFile(filePath) {
+    const content = await fs.readFile(filePath, "utf8");
+    const parsed = yaml.load(content);
+    const packagePath = parsed?.spec?.dynamicArtifact;
+    const packageName = parsed?.spec?.packageName;
+    const pluginConfig = parsed?.spec?.appConfigExamples?.[0]?.content;
+    if (!packagePath) {
+        throw new Error(`[PluginMetadata] Missing required field spec.dynamicArtifact in ${filePath}`);
+    }
+    if (!packageName) {
+        throw new Error(`[PluginMetadata] Missing required field spec.packageName in ${filePath}`);
+    }
+    return {
+        packagePath,
+        pluginConfig: pluginConfig || {},
+        packageName,
+        sourceFile: filePath,
+    };
+}
+/**
+ * Parses all metadata files in a directory and builds a map of plugin name to config.
+ * The plugin name is extracted from the dynamicArtifact path for flexible matching.
+ *
+ * @param metadataDir Path to the metadata directory
+ * @returns Map of plugin name to plugin configuration
+ */
+export async function parseAllMetadataFiles(metadataDir) {
+    const pattern = path.join(metadataDir, "*.yaml");
+    const files = await glob(pattern);
+    console.log(`[PluginMetadata] Found ${files.length} metadata files in ${metadataDir}`);
+    const metadataMap = new Map();
+    for (const file of files) {
+        const metadata = await parseMetadataFile(file);
+        const pluginName = extractPluginName(metadata.packagePath);
+        metadataMap.set(pluginName, metadata);
+        console.log(`[PluginMetadata] Mapped plugin: ${pluginName} <- ${metadata.packagePath}`);
+    }
+    console.log(`[PluginMetadata] Successfully parsed ${metadataMap.size} plugin metadata entries`);
+    return metadataMap;
+}
+/**
+ * Replaces local package paths with OCI URLs for plugins that have matching metadata.
+ * Only applies to plugins with metadata (workspace plugins). Plugins without metadata
+ * (e.g., keycloak, bulk-import from auth defaults) keep their original paths.
+ *
+ * @param plugins The plugin entries to process
+ * @param metadataMap Map of plugin names to plugin metadata
+ * @param metadataPath Path to the metadata directory (used to resolve workspace root)
+ * @returns Plugin entries with OCI URLs replaced where applicable
+ */
+async function replaceWithOCIUrls(plugins, metadataMap, metadataPath) {
+    const prNumber = process.env.GIT_PR_NUMBER;
+    if (!prNumber) {
+        return plugins;
+    }
+    console.log(`[PluginMetadata] PR build detected (PR #${prNumber}), fetching OCI URLs...`);
+    const workspacePath = path.resolve(metadataPath, "..");
+    const ociUrls = await getOCIUrlsForPR(workspacePath, prNumber);
+    return plugins.map((plugin) => {
+        const pluginName = extractPluginName(plugin.package);
+        const metadata = metadataMap.get(pluginName);
+        if (!metadata?.packageName)
+            return plugin;
+        const displayName = metadata.packageName
+            .replace(/^@/, "")
+            .replace(/\//g, "-");
+        const ociUrl = ociUrls.get(displayName);
+        if (!ociUrl)
+            return plugin;
+        console.log(`[PluginMetadata] Replacing ${plugin.package} with ${ociUrl}`);
+        return { ...plugin, package: ociUrl };
+    });
+}
+/**
+ * Injects plugin configurations from metadata into a dynamic plugins config.
+ * Metadata config serves as the base, user-provided pluginConfig overrides it.
+ *
+ * Matching is done by extracting the plugin name from both the package reference
+ * and the metadata's dynamicArtifact, allowing flexible matching across different
+ * package formats (local paths, OCI references, etc.).
+ *
+ * @param dynamicPluginsConfig The dynamic plugins configuration to augment
+ * @param metadataMap Map of plugin names to plugin metadata
+ * @returns The augmented configuration with injected pluginConfigs
+ */
+export function injectMetadataConfig(dynamicPluginsConfig, metadataMap) {
+    if (!dynamicPluginsConfig.plugins) {
+        return dynamicPluginsConfig;
+    }
+    const augmentedPlugins = dynamicPluginsConfig.plugins.map((plugin) => {
+        // Extract plugin name from package reference for flexible matching
+        const pluginName = extractPluginName(plugin.package);
+        const metadata = metadataMap.get(pluginName);
+        if (!metadata) {
+            // No metadata found for this plugin, keep as-is
+            console.log(`[PluginMetadata] No metadata found for: ${pluginName} (from ${plugin.package})`);
+            return plugin;
+        }
+        console.log(`[PluginMetadata] Injecting config for: ${pluginName} (from ${plugin.package})`);
+        // Merge: metadata config (base) + user config (override)
+        const mergedPluginConfig = deepMerge(metadata.pluginConfig, plugin.pluginConfig || {});
+        return {
+            ...plugin,
+            pluginConfig: mergedPluginConfig,
+        };
+    });
+    return {
+        ...dynamicPluginsConfig,
+        plugins: augmentedPlugins,
+    };
+}
+/**
+ * Generates a complete dynamic-plugins configuration from metadata files.
+ * Iterates through all metadata files and creates plugin entries with:
+ * - package: the dynamicArtifact path
+ * - disabled: false (enabled by default)
+ * - pluginConfig: from appConfigExamples[0].content
+ *
+ * @param metadataPath Optional custom path to metadata directory (default: ../metadata)
+ * @returns Complete dynamic plugins configuration
+ * @throws Error if metadata directory not found or no valid metadata files
+ */
+export async function generateDynamicPluginsConfigFromMetadata(metadataPath = DEFAULT_METADATA_PATH) {
+    // Skip if metadata handling is disabled
+    if (!shouldInjectPluginMetadata()) {
+        console.log("[PluginMetadata] Returning empty config (metadata handling disabled)");
+        return { plugins: [] };
+    }
+    console.log("[PluginMetadata] No dynamic-plugins config provided, generating from metadata...");
+    // Get metadata directory
+    const metadataDir = getMetadataDirectory(metadataPath);
+    if (!metadataDir) {
+        throw new Error(`[PluginMetadata] Cannot generate dynamic-plugins config: metadata directory not found at: ${path.resolve(metadataPath)}`);
+    }
+    // Parse all metadata files
+    const metadataMap = await parseAllMetadataFiles(metadataDir);
+    if (metadataMap.size === 0) {
+        throw new Error(`[PluginMetadata] Cannot generate dynamic-plugins config: no valid metadata files found in ${metadataDir}`);
+    }
+    // Build plugin entries from metadata
+    let plugins = [];
+    for (const [pluginName, metadata] of metadataMap) {
+        console.log(`[PluginMetadata] Adding plugin: ${pluginName} (${metadata.packagePath})`);
+        plugins.push({
+            package: metadata.packagePath,
+            disabled: false,
+            pluginConfig: metadata.pluginConfig,
+        });
+    }
+    // Replace local paths with OCI URLs for PR builds
+    plugins = await replaceWithOCIUrls(plugins, metadataMap, metadataPath);
+    console.log(`[PluginMetadata] Generated dynamic-plugins config with ${plugins.length} plugins`);
+    return { plugins };
+}
+/**
+ * Main function to load and inject plugin metadata for PR builds.
+ * For non-PR builds (nightly), returns the config unchanged.
+ *
+ * @param dynamicPluginsConfig The dynamic plugins configuration
+ * @param metadataPath Optional custom path to metadata directory (default: ../metadata)
+ * @returns Augmented configuration with metadata (for PR) or unchanged (for nightly)
+ * @throws Error if PR build but no metadata directory found
+ */
+export async function loadAndInjectPluginMetadata(dynamicPluginsConfig, metadataPath = DEFAULT_METADATA_PATH) {
+    // Skip metadata injection if disabled
+    if (!shouldInjectPluginMetadata()) {
+        return dynamicPluginsConfig;
+    }
+    console.log("[PluginMetadata] Loading plugin metadata...");
+    // Get metadata directory
+    const metadataDir = getMetadataDirectory(metadataPath);
+    if (!metadataDir) {
+        throw new Error(`[PluginMetadata] PR build requires metadata directory but not found at: ${path.resolve(metadataPath)}`);
+    }
+    // Parse all metadata files
+    const metadataMap = await parseAllMetadataFiles(metadataDir);
+    if (metadataMap.size === 0) {
+        throw new Error(`[PluginMetadata] PR build requires plugin metadata but no valid metadata files found in ${metadataDir}`);
+    }
+    // Inject metadata configs into the dynamic plugins config
+    const result = injectMetadataConfig(dynamicPluginsConfig, metadataMap);
+    // Replace local paths with OCI URLs for PR builds
+    if (result.plugins) {
+        result.plugins = await replaceWithOCIUrls(result.plugins, metadataMap, metadataPath);
+    }
+    return result;
+}

package/package.json

@@ -0,0 +1,108 @@
+{
+  "name": "@red-hat-developer-hub/e2e-test-utils",
+  "version": "1.1.10",
+  "description": "Test utilities for RHDH E2E tests",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/redhat-developer/rhdh-e2e-test-utils.git",
+    "directory": "."
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    "./eslint": {
+      "types": "./dist/eslint/base.config.d.ts",
+      "default": "./dist/eslint/base.config.js"
+    },
+    "./test": {
+      "types": "./dist/playwright/fixtures/test.d.ts",
+      "default": "./dist/playwright/fixtures/test.js"
+    },
+    "./playwright-config": {
+      "types": "./dist/playwright/base-config.d.ts",
+      "default": "./dist/playwright/base-config.js"
+    },
+    "./tsconfig": "./tsconfig.base.json",
+    "./rhdh": {
+      "types": "./dist/deployment/rhdh/index.d.ts",
+      "default": "./dist/deployment/rhdh/index.js"
+    },
+    "./utils": {
+      "types": "./dist/utils/index.d.ts",
+      "default": "./dist/utils/index.js"
+    },
+    "./helpers": {
+      "types": "./dist/playwright/helpers/index.d.ts",
+      "default": "./dist/playwright/helpers/index.js"
+    },
+    "./pages": {
+      "types": "./dist/playwright/pages/index.d.ts",
+      "default": "./dist/playwright/pages/index.js"
+    },
+    "./keycloak": {
+      "types": "./dist/deployment/keycloak/index.d.ts",
+      "default": "./dist/deployment/keycloak/index.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "tsconfig.base.json"
+  ],
+  "scripts": {
+    "build": "yarn clean && tsc -p tsconfig.build.json && cp -r src/deployment/rhdh/config dist/deployment/rhdh/ && cp -r src/deployment/keycloak/config dist/deployment/keycloak/",
+    "check": "yarn typecheck && yarn lint:check && yarn prettier:check",
+    "clean": "rm -rf dist",
+    "lint:check": "eslint . --ignore-pattern dist --ignore-pattern README.md --ignore-pattern docs",
+    "lint:fix": "eslint . --fix --ignore-pattern dist --ignore-pattern README.md --ignore-pattern docs",
+    "prepublishOnly": "yarn build",
+    "prettier:check": "prettier --check . '!dist' '!README.md' '!docs' '!.github/workflows/deploy-docs.yml'",
+    "prettier:fix": "prettier --write . '!dist' '!README.md' '!docs' '!.github/workflows/deploy-docs.yml'",
+    "typecheck": "tsc --noEmit"
+  },
+  "keywords": [
+    "e2e",
+    "playwright",
+    "rhdh",
+    "test-utils"
+  ],
+  "engines": {
+    "node": ">=22",
+    "yarn": ">=3"
+  },
+  "peerDependencies": {
+    "@playwright/test": "^1.57.0"
+  },
+  "devDependencies": {
+    "@backstage/catalog-model": "1.7.5",
+    "@playwright/test": "^1.57.0",
+    "@types/fs-extra": "^11.0.4",
+    "@types/js-yaml": "^4.0.9",
+    "@types/lodash.clonedeepwith": "^4.5.9",
+    "@types/lodash.mergewith": "^4.6.9",
+    "@types/node": "^24.10.1"
+  },
+  "dependencies": {
+    "@axe-core/playwright": "^4.11.0",
+    "@eslint/js": "^9.39.1",
+    "@keycloak/keycloak-admin-client": "^26.0.0",
+    "@kubernetes/client-node": "^1.4.0",
+    "eslint": "^9.39.1",
+    "eslint-plugin-check-file": "^3.3.1",
+    "eslint-plugin-playwright": "^2.4.0",
+    "fs-extra": "^11.3.2",
+    "js-yaml": "^4.1.1",
+    "lodash.clonedeepwith": "^4.5.0",
+    "lodash.mergewith": "^4.6.2",
+    "otplib": "12.0.1",
+    "prettier": "^3.7.4",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.48.1",
+    "zx": "^8.8.5"
+  },
+  "packageManager": "yarn@3.8.7"
+}

package/tsconfig.base.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "lib": ["ES2022"],
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "noEmit": true,
+    "types": ["node"]
+  },
+  "exclude": ["node_modules", "test-results", "playwright-report"]
+}