mirror of
https://github.com/renovatebot/renovate.git
synced 2026-11-01 10:09:50 +00:00
Sebastian Poxhofer
4b4d14ec00
* feat(manager): pass extracted constraints to updateArtifacts `extractedConstraints` were collected during extraction but only ever read by `fetch.ts` for the lookup. At artifact time every manager had to derive the same tool constraints a second time, and when the updated package file no longer carried the constraint there was nothing to fall back to. `generateBranchConfig()` now merges the `extractedConstraints` of all upgrades of a branch onto the branch config, which reaches `updateArtifacts()` through `patchConfigForArtifactsUpdate()`. `UpdateArtifactsConfig` declares the field and documents what it contains. The new `resolveToolConstraint()` helper implements the ladder once: user `constraints` > an optional artifact-time derivation > the extracted value. The derivation is ranked above the extracted value on purpose: it reads the package files as the branch changed them, so poetry (python is an updatable dependency there), composer, pipenv (`pipenv` can be a dev package) and pep621 (`requires-python` is an updatable dependency) would otherwise regress to a stale constraint. pipenv, pep621 uv/pdm, poetry and composer are migrated to the helper and keep their derivation. Behaviour change: these managers now use the extract-time constraint as a last resort instead of running unconstrained, for example on lock file maintenance where pipenv deletes `Pipfile.lock` before deriving. `execute-post-upgrade-commands.ts` is unaffected: it reads `upgrade.constraints` per upgrade, and the extracted values are kept in a separate field rather than folded into `constraints`, so post-upgrade task tool constraints still come from user config only. Not migrated, because their constraints are never extracted, so the fallback would be dead code: bundler (`ruby`/`bundler`), pixi (`pixi`), pep621 uv (`required-version`) and npm's node ladder, whose last step already reads `package.json` engines. * refactor(manager): resolve tool constraints through resolveToolConstraint() Every manager now obtains the constraint of a tool it runs through `resolveToolConstraint()` instead of reading `config.constraints` itself, so the precedence "user config, then a value derived from the updated files, then the constraints collected during extraction" applies everywhere. The helper treats an empty string as not set at every step and accepts the `PostUpdateConfig` shape, whose `constraints` may be `null`. Behaviour changes that go beyond the new fallback to extracted constraints: - `mix` applies its hardcoded erlang default only after the extracted constraint, so an erlang version collected at extraction can win over it. - `kustomize` decides `HELM_EXPERIMENTAL_OCI` from the fully resolved helm constraint; `generateHelmEnvs()` takes that value instead of the config. - `npm` (yarn): an upgrade of yarn without a new value now consults the user constraint before deriving one from package.json or the lock file. - The "Using <tool> constraint from config" debug lines in bundler, composer, copier and pip-compile are gone, as the helper is the only reader of the config now. Helpers that read the config synchronously became async: bundler `getBundlerConstraint()`, copier `getPythonVersionConstraint()` and `getCopierVersionConstraint()`, pip-compile `get*VersionConstraint()` and `getToolVersionConstraint()`, gomod `deriveGoToolchainConstraints()` and `getUpdateImportPathCmds()`, mise `getMiseLockToolConstraints()`. composer `getPhpConstraint()` is removed. Each converted manager has a test showing the extracted constraint reaching the executed tool, and, where a derive callback exists, that the derived value still wins over it. * refactor(linters): add prefer-resolve-tool-constraint rule Reports member reads and destructuring of `constraints` and `extractedConstraints` from a manager config in `lib/modules/manager/**`, so that tool constraints are resolved through `resolveToolConstraint()` in `lib/modules/manager/util.ts` only. Writes and the same properties on package files, which extraction has to populate, are not reported. The helper itself and spec files are exempt in `.oxlintrc.json`. * refactor(manager): inline thin resolveToolConstraint wrappers Drop copier/utils.ts and the pip-compile getPipToolsVersionConstraint / getUvVersionConstraint helpers, which only forwarded to resolveToolConstraint(). Callers now call it directly. * docs(development): note lock file maintenance in tool constraints section * refactor(manager): address review on tool constraint resolution composer only runs extractConstraints() when a user constraint is missing, via Lazy. UpdateArtifactsConfig no longer re-declares constraints and extractedConstraints, which ToolConstraintsConfig already provides.
100 lines
2.7 KiB
TypeScript
100 lines
2.7 KiB
TypeScript
import semver from 'semver';
|
|
import upath from 'upath';
|
|
import { logger } from '../../../../logger/index.ts';
|
|
import type { ToolConstraint } from '../../../../util/exec/types.ts';
|
|
import { readLocalFile } from '../../../../util/fs/index.ts';
|
|
import { newlineRegex, regEx } from '../../../../util/regex.ts';
|
|
import type { PostUpdateConfig, Upgrade } from '../../types.ts';
|
|
import { resolveToolConstraint } from '../../util.ts';
|
|
import type { LazyPackageJson } from './types.ts';
|
|
|
|
async function getNodeFile(filename: string): Promise<string | null> {
|
|
try {
|
|
// TODO #22198
|
|
const constraint = (await readLocalFile(filename, 'utf8'))!
|
|
.split(newlineRegex)[0]
|
|
.replace(regEx(/^v/), '');
|
|
if (semver.validRange(constraint)) {
|
|
logger.debug(`Using node constraint "${constraint}" from ${filename}`);
|
|
return constraint;
|
|
}
|
|
} catch {
|
|
// do nothing
|
|
}
|
|
return null;
|
|
}
|
|
|
|
async function getPackageJsonConstraint(
|
|
pkg: LazyPackageJson,
|
|
): Promise<string | null> {
|
|
const pkgJson = await pkg.getValue();
|
|
if (pkgJson.volta?.node) {
|
|
const constraint = pkgJson.volta.node;
|
|
// v8 ignore else -- TODO: add test #40625
|
|
if (semver.validRange(constraint)) {
|
|
logger.debug(
|
|
`Using node constraint "${constraint}" from package.json volta`,
|
|
);
|
|
return constraint;
|
|
}
|
|
}
|
|
if (pkgJson.engines?.node) {
|
|
const constraint = pkgJson.engines.node;
|
|
// v8 ignore else -- TODO: add test #40625
|
|
if (semver.validRange(constraint)) {
|
|
logger.debug(
|
|
`Using node constraint "${constraint}" from package.json engines`,
|
|
);
|
|
return constraint;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
// export only for testing
|
|
export async function getNodeConstraint(
|
|
config: Partial<PostUpdateConfig>,
|
|
upgrades: Upgrade[],
|
|
lockFileDir: string,
|
|
pkg: LazyPackageJson,
|
|
): Promise<string | null> {
|
|
const constraint =
|
|
getNodeUpdate(upgrades) ??
|
|
(await resolveToolConstraint(
|
|
config,
|
|
'node',
|
|
async () =>
|
|
(await getNodeFile(upath.join(lockFileDir, '.nvmrc'))) ??
|
|
(await getNodeFile(upath.join(lockFileDir, '.node-version'))) ??
|
|
(await getPackageJsonConstraint(pkg)),
|
|
)) ??
|
|
null;
|
|
if (!constraint) {
|
|
logger.debug('No node constraint found - using latest');
|
|
}
|
|
return constraint;
|
|
}
|
|
|
|
export function getNodeUpdate(upgrades: Upgrade[]): string | undefined {
|
|
return upgrades.find((u) => u.depName === 'node')?.newValue;
|
|
}
|
|
|
|
export async function getNodeToolConstraint(
|
|
config: Partial<PostUpdateConfig>,
|
|
upgrades: Upgrade[],
|
|
lockFileDir: string,
|
|
pkg: LazyPackageJson,
|
|
): Promise<ToolConstraint> {
|
|
const constraint = await getNodeConstraint(
|
|
config,
|
|
upgrades,
|
|
lockFileDir,
|
|
pkg,
|
|
);
|
|
|
|
return {
|
|
toolName: 'node',
|
|
constraint,
|
|
};
|
|
}
|