feat(composer): filter releases using php constraint

lib/modules/datasource/index.ts

@@ -10,6 +10,7 @@ import { regEx } from '../../util/regex';
 import { trimTrailingSlash } from '../../util/url';
 import * as allVersioning from '../versioning';
 import datasources from './api';
+import { GithubTagsDatasource } from './github-tags';
 import { addMetaData } from './metadata';
 import { setNpmrc } from './npm';
 import { resolveRegistryUrl } from './npm/npmrc';
@@ -415,6 +416,60 @@ export async function getPkgReleases(
             version.matches(constraintValue, releaseConstraint)
         );
       });
+    } else {
+      if (constraintName === 'php') {
+        const composerVersioning = allVersioning.get('composer');
+        if (composerVersioning.isValid(constraintValue)) {
+          const lookupConfig: GetPkgReleasesConfig = {
+            datasource: GithubTagsDatasource.id,
+            depName: 'php/php-src',
+            extractVersion: '^php-(?<version>\\S+)',
+          };
+          const phpVersions = (
+            await getPkgReleases(lookupConfig)
+          )?.releases.map((release) => release.version);
+          if (!phpVersions) {
+            logger.warn('Could not fetch php releases for compatibility check');
+            return null;
+          }
+          const matchingVersions = phpVersions.filter((version) =>
+            composerVersioning.matches(version, constraintValue)
+          );
+          logger.debug(
+            `Found ${matchingVersions.length} matching php versions`
+          );
+          if (matchingVersions.length) {
+            const originalReleaseCount = res.releases.length;
+            res.releases = res.releases.filter((release) => {
+              const constraint = release.constraints?.[constraintName];
+              if (!is.nonEmptyArray(constraint)) {
+                // A release with no constraints is OK
+                return true;
+              }
+              return constraint.some(
+                // If any of the release's constraints match, then it's OK
+                (releaseConstraint) => {
+                  const releaseMatchingVersions = phpVersions.filter(
+                    (version) =>
+                      composerVersioning.matches(version, releaseConstraint)
+                  );
+
+                  const isMatch = matchingVersions.every((version) =>
+                    releaseMatchingVersions.includes(version)
+                  );
+                  return isMatch;
+                }
+              );
+            });
+            const filteredReleaseCount = res.releases.length;
+            logger.debug(
+              `${filteredReleaseCount} of ${originalReleaseCount} releases have matching constraints`
+            );
+          }
+        } else {
+          logger.warn({ constraintValue }, 'Invalid php constraint');
+        }
+      }
     }
   }
   // Strip constraints from releases result

lib/modules/datasource/packagist/index.ts

@@ -133,10 +133,16 @@ export class PackagistDatasource extends Datasource {
       if (release.source?.url) {
         dep.sourceUrl = release.source.url;
       }
+      const constraints: Record<string, string[]> = {};
+      if (release.require?.php) {
+        constraints.php = [release.require.php];
+      }
+
       return {
         version: parsedVersion.replace(regEx(/^v/), ''),
         gitRef: parsedVersion,
         releaseTimestamp: release.time,
+        constraints,
       };
     });
     return dep;

lib/modules/datasource/packagist/schema.spec.ts

@@ -24,6 +24,7 @@ describe('modules/datasource/packagist/schema', () => {
         homepage: null,
         source: null,
         time: null,
+        require: null,
       };
 
       expect(ComposerRelease.parse({ version: '1.2.3' })).toEqual(
@@ -66,7 +67,13 @@ describe('modules/datasource/packagist/schema', () => {
       expect(ComposerReleaseArray.parse([1, 2, 3])).toEqual([]);
       expect(ComposerReleaseArray.parse(['foobar'])).toEqual([]);
       expect(ComposerReleaseArray.parse([{ version: '1.2.3' }])).toEqual([
-        { version: '1.2.3', homepage: null, source: null, time: null },
+        {
+          version: '1.2.3',
+          homepage: null,
+          source: null,
+          time: null,
+          require: null,
+        },
       ]);
     });
   });
@@ -85,7 +92,13 @@ describe('modules/datasource/packagist/schema', () => {
           },
         })
       ).toEqual([
-        { version: '1.2.3', homepage: null, source: null, time: null },
+        {
+          version: '1.2.3',
+          homepage: null,
+          source: null,
+          time: null,
+          require: null,
+        },
       ]);
     });
   });

lib/modules/datasource/packagist/schema.ts

@@ -14,6 +14,7 @@ export const ComposerRelease = z.object({
     .transform((x) => x.url)
     .nullable()
     .catch(null),
+  require: z.object({ php: z.string() }).nullable().catch(null),
   time: z.string().nullable().catch(null),
 });
 
@@ -59,6 +60,7 @@ export function parsePackagesResponses(
 
   for (const packagesResponse of packagesResponses) {
     const releaseArray = parsePackagesResponse(packageName, packagesResponse);
+    let phpConstraint: string | undefined;
     for (const composerRelease of releaseArray) {
       const version = composerRelease.version.replace(/^v/, '');
       const gitRef = composerRelease.version;
@@ -69,6 +71,12 @@ export function parsePackagesResponses(
         dep.releaseTimestamp = composerRelease.time;
       }
 
+      phpConstraint ??= composerRelease.require?.php;
+
+      if (phpConstraint) {
+        dep.constraints = { php: [phpConstraint] };
+      }
+
       releases.push(dep);
 
       if (!maxVersion || versioning.isGreaterThan(version, maxVersion)) {