renovate/lib/modules/manager/helm-values/extract.ts

import { isObject } from '@sindresorhus/is';
import { logger } from '../../../logger/index.ts';
import { parseYaml } from '../../../util/yaml.ts';
import { id as dockerVersioning } from '../../versioning/docker/index.ts';
import { getDep } from '../dockerfile/extract.ts';
import type {
  ExtractConfig,
  PackageDependency,
  PackageFileContent,
} from '../types.ts';
import type { HelmDockerImageDependency } from './types.ts';
import {
  getHelmValuesSiblingVersion,
  matchesHelmValuesDockerHeuristic,
  matchesHelmValuesInlineImage,
} from './util.ts';

function getHelmDep(
  registry: string,
  repository: string,
  tag: string,
  registryAliases: Record<string, string> | undefined,
): PackageDependency<never> {
  const dep = getDep(`${registry}${repository}:${tag}`, {
    specifyReplaceString: false,
    registryAliases,
  });
  dep.replaceString = tag;
  dep.versioning = dockerVersioning;
  dep.autoReplaceStringTemplate =
    '{{newValue}}{{#if newDigest}}@{{newDigest}}{{/if}}';
  return dep;
}

/**
 * Recursively find all supported dependencies in the yaml object.
 *
 * @param parsedContent
 */
export function findDependencies<T = never>(
  parsedContent: Record<string, unknown> | HelmDockerImageDependency,
  registryAliases: Record<string, string> | undefined,
): PackageDependency<T>[] {
  return findDependenciesInternal<T>(parsedContent, [], registryAliases);
}
export function findDependenciesInternal<T = never>(
  parsedContent: Record<string, unknown> | HelmDockerImageDependency,
  packageDependencies: PackageDependency<T>[],
  registryAliases: Record<string, string> | undefined,
): PackageDependency<T>[] {
  if (!isObject(parsedContent)) {
    return packageDependencies;
  }

  Object.entries(parsedContent).forEach(([key, value]) => {
    if (matchesHelmValuesDockerHeuristic(key, value)) {
      const currentItem = value;

      let registry = currentItem.registry;
      registry = registry ? `${registry}/` : '';
      const repository = String(currentItem.repository);
      const tag = `${currentItem.tag ?? currentItem.version}`;
      packageDependencies.push(
        getHelmDep(registry, repository, tag, registryAliases),
      );
    } else if (matchesHelmValuesInlineImage(key, value)) {
      const dep = getDep(value, { registryAliases });
      // An inline reference without an embedded version can be completed by a
      // sibling `tag`/`version` key: `cli: { image: ..., tag: v1.0.0 }`
      if (!dep.currentValue && !dep.currentDigest) {
        const siblingVersion = getHelmValuesSiblingVersion(parsedContent);
        if (siblingVersion) {
          packageDependencies.push(
            getHelmDep('', value, siblingVersion, registryAliases),
          );
        } else {
          packageDependencies.push(dep);
        }
      } else {
        packageDependencies.push(dep);
      }
    } else {
      findDependenciesInternal(
        value as Record<string, unknown>,
        packageDependencies,
        registryAliases,
      );
    }
  });
  return packageDependencies;
}

export function extractPackageFile(
  content: string,
  packageFile: string,
  config: ExtractConfig,
): PackageFileContent | null {
  let parsedContent: Record<string, unknown>[] | HelmDockerImageDependency[];
  try {
    // a parser that allows extracting line numbers would be preferable, with
    // the current approach we need to match anything we find again during the update
    // TODO: fix me (#9610)
    parsedContent = parseYaml(content) as any;
  } catch (err) {
    logger.debug({ err, packageFile }, 'Failed to parse helm-values YAML');
    return null;
  }
  try {
    const deps: PackageDependency[] = [];

    for (const con of parsedContent) {
      deps.push(...findDependencies(con, config.registryAliases));
    }

    if (deps.length) {
      return { deps };
    }
  } catch (err) /* istanbul ignore next */ {
    logger.debug(
      { err, packageFile },
      'Error parsing helm-values parsed content',
    );
  }
  return null;
}