ApiQuerySiteinfo.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Api;
 
use MediaWiki\HookContainer\HookContainer;
use MediaWiki\Interwiki\InterwikiLookup;
use MediaWiki\Language\Language;
use MediaWiki\Language\LanguageCode;
use MediaWiki\Language\LanguageConverter;
use MediaWiki\Language\LanguageConverterFactory;
use MediaWiki\Language\LanguageFactory;
use MediaWiki\Language\LanguageNameUtils;
use MediaWiki\MainConfigNames;
use MediaWiki\Parser\MagicWordFactory;
use MediaWiki\Parser\ParserFactory;
use MediaWiki\Permissions\GroupPermissionsLookup;
use MediaWiki\Registration\ExtensionRegistry;
use MediaWiki\ResourceLoader\SkinModule;
use MediaWiki\SiteStats\SiteStats;
use MediaWiki\Skin\Skin;
use MediaWiki\Skin\SkinFactory;
use MediaWiki\SpecialPage\SpecialPage;
use MediaWiki\SpecialPage\SpecialPageFactory;
use MediaWiki\Specials\SpecialVersion;
use MediaWiki\Title\NamespaceInfo;
use MediaWiki\Title\Title;
use MediaWiki\Upload\UploadBase;
use MediaWiki\Upload\UploadFromUrl;
use MediaWiki\User\Options\UserOptionsLookup;
use MediaWiki\User\TempUser\TempUserConfig;
use MediaWiki\User\UserGroupManager;
use MediaWiki\User\UserIdentityUtils;
use MediaWiki\User\UserRequirementsConditionChecker;
use MediaWiki\Utils\ExtensionInfo;
use MediaWiki\Utils\GitInfo;
use MediaWiki\Utils\SBOMGenerator;
use MediaWiki\Utils\UrlUtils;
use MediaWiki\WikiMap\WikiMap;
use Wikimedia\ParamValidator\ParamValidator;
use Wikimedia\Rdbms\ILoadBalancer;
use Wikimedia\Rdbms\ReadOnlyMode;
use Wikimedia\Timestamp\TimestampFormat as TS;
 
class ApiQuerySiteinfo extends ApiQueryBase {
 
    public function __construct(
        ApiQuery $query,
        string $moduleName,
        private readonly UserOptionsLookup $userOptionsLookup,
        private readonly UserGroupManager $userGroupManager,
        private readonly HookContainer $hookContainer,
        private readonly LanguageConverterFactory $languageConverterFactory,
        private readonly LanguageFactory $languageFactory,
        private readonly LanguageNameUtils $languageNameUtils,
        private readonly Language $contentLanguage,
        private readonly NamespaceInfo $namespaceInfo,
        private readonly InterwikiLookup $interwikiLookup,
        private readonly ParserFactory $parserFactory,
        private readonly MagicWordFactory $magicWordFactory,
        private readonly SpecialPageFactory $specialPageFactory,
        private readonly SkinFactory $skinFactory,
        private readonly ILoadBalancer $loadBalancer,
        private readonly ReadOnlyMode $readOnlyMode,
        private readonly UrlUtils $urlUtils,
        private readonly TempUserConfig $tempUserConfig,
        private readonly GroupPermissionsLookup $groupPermissionsLookup,
        private readonly SBOMGenerator $sbomGenerator,
        private readonly UserIdentityUtils $userIdentityUtils,
    ) {
        parent::__construct( $query, $moduleName, 'si' );
    }
 
    public function execute() {
        $params = $this->extractRequestParams();
        $done = [];
        foreach ( $params['prop'] as $p ) {
            $fit = match ( $p ) {
                'general' => $this->appendGeneralInfo( $p ),
                'namespaces' => $this->appendNamespaces( $p ),
                'namespacealiases' => $this->appendNamespaceAliases( $p ),
                'specialpagealiases' => $this->appendSpecialPageAliases( $p ),
                'magicwords' => $this->appendMagicWords( $p ),
                'interwikimap' => $this->appendInterwikiMap( $p, $params['filteriw'] ),
                'dbrepllag' => $this->appendDbReplLagInfo( $p, $params['showalldb'] ),
                'statistics' => $this->appendStatistics( $p ),
                'usergroups' => $this->appendUserGroups( $p, $params['numberingroup'] ),
                'autocreatetempuser' => $this->appendAutoCreateTempUser( $p ),
                'clientlibraries' => $this->appendInstalledClientLibraries( $p ),
                'libraries' => $this->appendInstalledLibraries( $p ),
                'extensions' => $this->appendExtensions( $p ),
                'fileextensions' => $this->appendFileExtensions( $p ),
                'rightsinfo' => $this->appendRightsInfo( $p ),
                'restrictions' => $this->appendRestrictions( $p ),
                'languages' => $this->appendLanguages( $p ),
                'languagevariants' => $this->appendLanguageVariants( $p ),
                'skins' => $this->appendSkins( $p ),
                'extensiontags' => $this->appendExtensionTags( $p ),
                'functionhooks' => $this->appendFunctionHooks( $p ),
                'showhooks' => $this->appendSubscribedHooks( $p ),
                'variables' => $this->appendVariables( $p ),
                'doubleunderscores' => $this->appendDoubleUnderscores( $p ),
                'protocols' => $this->appendProtocols( $p ),
                'defaultoptions' => $this->appendDefaultOptions( $p ),
                'uploaddialog' => $this->appendUploadDialog( $p ),
                'autopromote' => $this->appendAutoPromote( $p ),
                'autopromoteonce' => $this->appendAutoPromoteOnce( $p ),
                'copyuploaddomains' => $this->appendCopyUploadDomains( $p ),
                'crosssiteajaxdomains' => $this->appendCrossSiteAJAXdomains( $p ),
                'sbom' => $this->appendSBOM( $p ),
                // @phan-suppress-next-line PhanUseReturnValueOfNever
                default => ApiBase::dieDebug( __METHOD__, "Unknown prop=$p" ) // @codeCoverageIgnore
            };
            if ( !$fit ) {
                // Abuse siprop as a query-continue parameter
                // and set it to all unprocessed props
                $this->setContinueEnumParameter( 'prop', implode( '|',
                    array_diff( $params['prop'], $done ) ) );
                break;
            }
            $done[] = $p;
        }
    }
 
    protected function appendGeneralInfo( string $property ): bool {
        $config = $this->getConfig();
        $mainPage = Title::newMainPage();
        $logo = SkinModule::getAvailableLogos( $config, $this->getLanguage()->getCode() );
 
        $data = [
            'mainpage' => $mainPage->getPrefixedText(),
            'base' => (string)$this->urlUtils->expand( $mainPage->getFullURL(), PROTO_CURRENT ),
            'sitename' => $config->get( MainConfigNames::Sitename ),
            'mainpageisdomainroot' => (bool)$config->get( MainConfigNames::MainPageIsDomainRoot ),
 
            // A logo can either be a relative or an absolute path
            // make sure we always return an absolute path
            'logo' => (string)$this->urlUtils->expand( $logo['1x'], PROTO_RELATIVE ),
 
            'generator' => 'MediaWiki ' . MW_VERSION,
 
            'phpversion' => PHP_VERSION,
            'phpsapi' => PHP_SAPI,
            'dbtype' => $config->get( MainConfigNames::DBtype ),
            'dbversion' => $this->getDB()->getServerVersion(),
        ];
 
        $allowFrom = [ '' ];
        $allowException = true;
        if ( !$config->get( MainConfigNames::AllowExternalImages ) ) {
            $data['imagewhitelistenabled'] =
                (bool)$config->get( MainConfigNames::EnableImageWhitelist );
            $allowFrom = $config->get( MainConfigNames::AllowExternalImagesFrom );
            $allowException = (bool)$allowFrom;
        }
        if ( $allowException ) {
            $data['externalimages'] = (array)$allowFrom;
            ApiResult::setIndexedTagName( $data['externalimages'], 'prefix' );
        }
 
        $data['langconversion'] = !$this->languageConverterFactory->isConversionDisabled();
        $data['linkconversion'] = !$this->languageConverterFactory->isLinkConversionDisabled();
        // For backwards compatibility (soft deprecated since MW 1.36)
        $data['titleconversion'] = $data['linkconversion'];
 
        $contLangConverter = $this->languageConverterFactory->getLanguageConverter( $this->contentLanguage );
        if ( $this->contentLanguage->linkPrefixExtension() ) {
            $linkPrefixCharset = $this->contentLanguage->linkPrefixCharset();
            $data['linkprefixcharset'] = $linkPrefixCharset;
            // For backwards compatibility
            $data['linkprefix'] = "/^((?>.*[^$linkPrefixCharset]|))(.+)$/sDu";
        } else {
            $data['linkprefixcharset'] = '';
            $data['linkprefix'] = '';
        }
 
        $data['linktrail'] = $this->contentLanguage->linkTrail() ?: '';
 
        $data['legaltitlechars'] = Title::legalChars();
        $data['invalidusernamechars'] = $config->get( MainConfigNames::InvalidUsernameCharacters );
        $data['allunicodefixes'] = (bool)$config->get( MainConfigNames::AllUnicodeFixes );
 
        $git = GitInfo::repo()->getHeadSHA1();
        if ( $git ) {
            $data['git-hash'] = $git;
            $data['git-branch'] = GitInfo::repo()->getCurrentBranch();
        }
 
        // 'case-insensitive' option is reserved for future
        $data['case'] =
            $config->get( MainConfigNames::CapitalLinks ) ? 'first-letter' : 'case-sensitive';
        $data['lang'] = $config->get( MainConfigNames::LanguageCode );
 
        $data['fallback'] = [];
        foreach ( $this->contentLanguage->getFallbackLanguages() as $code ) {
            $data['fallback'][] = [ 'code' => $code ];
        }
        ApiResult::setIndexedTagName( $data['fallback'], 'lang' );
 
        if ( $contLangConverter->hasVariants() ) {
            $data['variants'] = [];
            foreach ( $contLangConverter->getVariants() as $code ) {
                $data['variants'][] = [
                    'code' => $code,
                    'name' => $this->contentLanguage->getVariantname( $code ),
                ];
            }
            ApiResult::setIndexedTagName( $data['variants'], 'lang' );
        }
 
        $data['rtl'] = $this->contentLanguage->isRTL();
        $data['fallback8bitEncoding'] = $this->contentLanguage->fallback8bitEncoding();
 
        $data['readonly'] = $this->readOnlyMode->isReadOnly();
        if ( $data['readonly'] ) {
            $data['readonlyreason'] = $this->readOnlyMode->getReason();
        }
        $data['writeapi'] = true; // Deprecated since MW 1.32
 
        $data['maxarticlesize'] = $config->get( MainConfigNames::MaxArticleSize ) * 1024;
 
        $data['timezone'] = $config->get( MainConfigNames::Localtimezone );
        $data['timeoffset'] = (int)( $config->get( MainConfigNames::LocalTZoffset ) );
        $data['articlepath'] = $config->get( MainConfigNames::ArticlePath );
        $data['scriptpath'] = $config->get( MainConfigNames::ScriptPath );
        $data['script'] = $config->get( MainConfigNames::Script );
        $data['variantarticlepath'] = $config->get( MainConfigNames::VariantArticlePath );
        $data[ApiResult::META_BC_BOOLS][] = 'variantarticlepath';
        $data['server'] = $config->get( MainConfigNames::Server );
        $data['servername'] = $config->get( MainConfigNames::ServerName );
        $data['wikiid'] = WikiMap::getCurrentWikiId();
        $data['time'] = wfTimestamp( TS::ISO_8601, time() );
 
        $data['misermode'] = (bool)$config->get( MainConfigNames::MiserMode );
 
        $data['uploadsenabled'] = UploadBase::isEnabled();
        $data['maxuploadsize'] = UploadBase::getMaxUploadSize();
        $data['minuploadchunksize'] = ApiUpload::getMinUploadChunkSize( $config );
 
        $data['galleryoptions'] = $config->get( MainConfigNames::GalleryOptions );
 
        /* T427066: return thumblimits as a compact array, even if it is
         * actually sparse; the thumbsize defaults are adjusted to match in
         * ::appendDefaultOptions() below. */
        $data['thumblimits'] = array_values(
            $config->get( MainConfigNames::ThumbLimits )
        );
        ApiResult::setArrayType( $data['thumblimits'], 'BCassoc' );
        ApiResult::setIndexedTagName( $data['thumblimits'], 'limit' );
        $data['imagelimits'] = [];
        foreach ( $config->get( MainConfigNames::ImageLimits ) as $k => $limit ) {
            $data['imagelimits'][$k] = [ 'width' => $limit[0], 'height' => $limit[1] ];
        }
        ApiResult::setArrayType( $data['imagelimits'], 'BCassoc' );
        ApiResult::setIndexedTagName( $data['imagelimits'], 'limit' );
 
        $favicon = $config->get( MainConfigNames::Favicon );
        if ( $favicon ) {
            // Expand any local path to full URL to improve API usability (T77093).
            $data['favicon'] = (string)$this->urlUtils->expand( $favicon );
        }
 
        $data['centralidlookupprovider'] = $config->get( MainConfigNames::CentralIdLookupProvider );
        $providerIds = array_keys( $config->get( MainConfigNames::CentralIdLookupProviders ) );
        $data['allcentralidlookupproviders'] = $providerIds;
 
        $data['interwikimagic'] = (bool)$config->get( MainConfigNames::InterwikiMagic );
        $data['magiclinks'] = $config->get( MainConfigNames::EnableMagicLinks );
 
        $data['categorycollation'] = $config->get( MainConfigNames::CategoryCollation );
 
        $data['nofollowlinks'] = $config->get( MainConfigNames::NoFollowLinks );
        $data['nofollownsexceptions'] = $config->get( MainConfigNames::NoFollowNsExceptions );
        $data['nofollowdomainexceptions'] = $config->get( MainConfigNames::NoFollowDomainExceptions );
        $data['externallinktarget'] = $config->get( MainConfigNames::ExternalLinkTarget );
 
        $this->getHookRunner()->onAPIQuerySiteInfoGeneralInfo( $this, $data );
 
        return $this->getResult()->addValue( 'query', $property, $data );
    }
 
    protected function appendNamespaces( string $property ): bool {
        $nsProtection = $this->getConfig()->get( MainConfigNames::NamespaceProtection );
 
        $data = [ ApiResult::META_TYPE => 'assoc' ];
        foreach ( $this->contentLanguage->getFormattedNamespaces() as $ns => $title ) {
            $data[$ns] = [
                'id' => (int)$ns,
                'case' => $this->namespaceInfo->isCapitalized( $ns ) ? 'first-letter' : 'case-sensitive',
            ];
            ApiResult::setContentValue( $data[$ns], 'name', $title );
            $canonical = $this->namespaceInfo->getCanonicalName( $ns );
 
            $data[$ns]['subpages'] = $this->namespaceInfo->hasSubpages( $ns );
 
            if ( $canonical ) {
                $data[$ns]['canonical'] = strtr( $canonical, '_', ' ' );
            }
 
            $data[$ns]['content'] = $this->namespaceInfo->isContent( $ns );
            $data[$ns]['nonincludable'] = $this->namespaceInfo->isNonincludable( $ns );
 
            $specificNs = $nsProtection[$ns] ?? '';
            if ( is_array( $specificNs ) ) {
                $specificNs = implode( "|", array_filter( $specificNs ) );
            }
            if ( $specificNs !== '' ) {
                $data[$ns]['namespaceprotection'] = $specificNs;
            }
 
            $contentmodel = $this->namespaceInfo->getNamespaceContentModel( $ns );
            if ( $contentmodel ) {
                $data[$ns]['defaultcontentmodel'] = $contentmodel;
            }
        }
 
        ApiResult::setArrayType( $data, 'assoc' );
        ApiResult::setIndexedTagName( $data, 'ns' );
 
        return $this->getResult()->addValue( 'query', $property, $data );
    }
 
    protected function appendNamespaceAliases( string $property ): bool {
        $aliases = $this->contentLanguage->getNamespaceAliases();
        $namespaces = $this->contentLanguage->getNamespaces();
        $data = [];
        foreach ( $aliases as $title => $ns ) {
            if ( $namespaces[$ns] == $title ) {
                // Don't list duplicates
                continue;
            }
            $item = [ 'id' => (int)$ns ];
            ApiResult::setContentValue( $item, 'alias', strtr( $title, '_', ' ' ) );
            $data[] = $item;
        }
 
        sort( $data );
 
        ApiResult::setIndexedTagName( $data, 'ns' );
 
        return $this->getResult()->addValue( 'query', $property, $data );
    }
 
    protected function appendSpecialPageAliases( string $property ): bool {
        $data = [];
        $aliases = $this->contentLanguage->getSpecialPageAliases();
        foreach ( $this->specialPageFactory->getNames() as $specialpage ) {
            if ( isset( $aliases[$specialpage] ) ) {
                $arr = [ 'realname' => $specialpage, 'aliases' => $aliases[$specialpage] ];
                ApiResult::setIndexedTagName( $arr['aliases'], 'alias' );
                $data[] = $arr;
            }
        }
        ApiResult::setIndexedTagName( $data, 'specialpage' );
 
        return $this->getResult()->addValue( 'query', $property, $data );
    }
 
    protected function appendMagicWords( string $property ): bool {
        $data = [];
        foreach ( $this->contentLanguage->getMagicWords() as $name => $aliases ) {
            $caseSensitive = (bool)array_shift( $aliases );
            $arr = [
                'name' => $name,
                'aliases' => $aliases,
                'case-sensitive' => $caseSensitive,
            ];
            ApiResult::setIndexedTagName( $arr['aliases'], 'alias' );
            $data[] = $arr;
        }
        ApiResult::setIndexedTagName( $data, 'magicword' );
 
        return $this->getResult()->addValue( 'query', $property, $data );
    }
 
    protected function appendInterwikiMap( string $property, ?string $filter ): bool {
        $local = $filter ? $filter === 'local' : null;
 
        $params = $this->extractRequestParams();
        $langCode = $params['inlanguagecode'] ?? '';
        $interwikiMagic = $this->getConfig()->get( MainConfigNames::InterwikiMagic );
 
        if ( $interwikiMagic ) {
            $langNames = $this->languageNameUtils->getLanguageNames( $langCode );
        }
 
        $extraLangPrefixes = $this->getConfig()->get( MainConfigNames::ExtraInterlanguageLinkPrefixes );
        $extraLangCodeMap = $this->getConfig()->get( MainConfigNames::InterlanguageLinkCodeMap );
        $localInterwikis = $this->getConfig()->get( MainConfigNames::LocalInterwikis );
        $data = [];
 
        foreach ( $this->interwikiLookup->getAllPrefixes( $local ) as $row ) {
            $prefix = $row['iw_prefix'];
            $val = [];
            $val['prefix'] = $prefix;
            if ( $row['iw_local'] ?? false ) {
                $val['local'] = true;
            }
            if ( $row['iw_trans'] ?? false ) {
                $val['trans'] = true;
            }
 
            if ( $interwikiMagic && isset( $langNames[$prefix] ) ) {
                $val['language'] = $langNames[$prefix];
                $standard = LanguageCode::replaceDeprecatedCodes( $prefix );
                if ( $standard !== $prefix ) {
                    # Note that even if this code is deprecated, it should
                    # only be remapped if extralanglink (set below) is false.
                    $val['deprecated'] = $standard;
                }
                $val['bcp47'] = LanguageCode::bcp47( $standard );
            }
            if ( in_array( $prefix, $localInterwikis ) ) {
                $val['localinterwiki'] = true;
            }
            if ( $interwikiMagic && in_array( $prefix, $extraLangPrefixes ) ) {
                $val['extralanglink'] = true;
                $val['code'] = $extraLangCodeMap[$prefix] ?? $prefix;
                $val['bcp47'] = LanguageCode::bcp47( $val['code'] );
 
                $linktext = $this->msg( "interlanguage-link-$prefix" );
                if ( !$linktext->isDisabled() ) {
                    $val['linktext'] = $linktext->text();
                }
 
                $sitename = $this->msg( "interlanguage-link-sitename-$prefix" );
                if ( !$sitename->isDisabled() ) {
                    $val['sitename'] = $sitename->text();
                }
            }
 
            $val['url'] = (string)$this->urlUtils->expand( $row['iw_url'], PROTO_CURRENT );
            $val['protorel'] = str_starts_with( $row['iw_url'], '//' );
            if ( ( $row['iw_wikiid'] ?? '' ) !== '' ) {
                $val['wikiid'] = $row['iw_wikiid'];
            }
            if ( ( $row['iw_api'] ?? '' ) !== '' ) {
                $val['api'] = $row['iw_api'];
            }
 
            $data[] = $val;
        }
 
        ApiResult::setIndexedTagName( $data, 'iw' );
 
        return $this->getResult()->addValue( 'query', $property, $data );
    }
 
    protected function appendDbReplLagInfo( string $property, bool $includeAll ): bool {
        $data = [];
        $showHostnames = $this->getConfig()->get( MainConfigNames::ShowHostnames );
        if ( $includeAll ) {
            if ( !$showHostnames ) {
                $this->dieWithError( 'apierror-siteinfo-includealldenied', 'includeAllDenied' );
            }
 
            foreach ( $this->loadBalancer->getLagTimes() as $i => $lag ) {
                $data[] = [
                    'host' => $this->loadBalancer->getServerName( $i ),
                    'lag' => $lag
                ];
            }
        } else {
            [ , $lag, $index ] = $this->loadBalancer->getMaxLag();
            $data[] = [
                'host' => $showHostnames ? $this->loadBalancer->getServerName( $index ) : '',
                'lag' => $lag
            ];
        }
 
        ApiResult::setIndexedTagName( $data, 'db' );
 
        return $this->getResult()->addValue( 'query', $property, $data );
    }
 
    protected function appendStatistics( string $property ): bool {
        $data = [
            'pages' => SiteStats::pages(),
            'articles' => SiteStats::articles(),
            'edits' => SiteStats::edits(),
            'images' => SiteStats::images(),
            'users' => SiteStats::users(),
            'activeusers' => SiteStats::activeUsers(),
            'admins' => SiteStats::numberingroup( 'sysop' ),
            'jobs' => SiteStats::jobs(),
        ];
 
        $this->getHookRunner()->onAPIQuerySiteInfoStatisticsInfo( $data );
 
        return $this->getResult()->addValue( 'query', $property, $data );
    }
 
    protected function appendUserGroups( string $property, bool $numberInGroup ): bool {
        $config = $this->getConfig();
 
        $data = [];
        $result = $this->getResult();
        $allGroups = $this->userGroupManager->listAllGroups();
        $allImplicitGroups = $this->userGroupManager->listAllImplicitGroups();
        foreach ( array_merge( $allImplicitGroups, $allGroups ) as $group ) {
            $arr = [
                'name' => $group,
                'rights' => $this->groupPermissionsLookup->getGrantedPermissions( $group ),
                // TODO: Also expose the list of revoked permissions somehow.
            ];
 
            if ( $numberInGroup ) {
                $autopromote = $config->get( MainConfigNames::Autopromote );
 
                if ( $group == 'user' ) {
                    $arr['number'] = SiteStats::users();
                // '*' and autopromote groups have no size
                } elseif ( $group !== '*' && !isset( $autopromote[$group] ) ) {
                    $arr['number'] = SiteStats::numberingroup( $group );
                }
            }
 
            $groupArr = $this->userGroupManager->getGroupsChangeableByGroup( $group );
 
            foreach ( $groupArr as $type => $groups ) {
                $groups = array_values( array_intersect( $groups, $allGroups ) );
                if ( $groups ) {
                    $arr[$type] = $groups;
                    ApiResult::setArrayType( $arr[$type], 'BCarray' );
                    ApiResult::setIndexedTagName( $arr[$type], 'group' );
                }
            }
 
            ApiResult::setIndexedTagName( $arr['rights'], 'permission' );
            $data[] = $arr;
        }
 
        ApiResult::setIndexedTagName( $data, 'group' );
 
        return $result->addValue( 'query', $property, $data );
    }
 
    protected function appendAutoCreateTempUser( string $property ): bool {
        $data = [ 'enabled' => $this->tempUserConfig->isEnabled() ];
        if ( $this->tempUserConfig->isKnown() ) {
            $data['matchPatterns'] = $this->tempUserConfig->getMatchPatterns();
        }
        return $this->getResult()->addValue( 'query', $property, $data );
    }
 
    protected function appendFileExtensions( string $property ): bool {
        $data = [];
        foreach (
            array_unique( $this->getConfig()->get( MainConfigNames::FileExtensions ) ) as $ext
        ) {
            $data[] = [ 'ext' => $ext ];
        }
        ApiResult::setIndexedTagName( $data, 'fe' );
 
        return $this->getResult()->addValue( 'query', $property, $data );
    }
 
    protected function appendInstalledClientLibraries( string $property ): bool {
        $data = [];
        foreach ( SpecialVersion::parseForeignResources() as $name => $info ) {
            $data[] = [
                // Can't use $name as it is version suffixed (as multiple versions
                // of a library may exist, provided by different skins/extensions)
                'name' => $info['name'],
                'version' => $info['version'],
            ];
        }
        ApiResult::setIndexedTagName( $data, 'library' );
        return $this->getResult()->addValue( 'query', $property, $data );
    }
 
    protected function appendInstalledLibraries( string $property ): bool {
        $credits = SpecialVersion::getCredits(
            ExtensionRegistry::getInstance(),
            $this->getConfig()
        );
        $data = [];
        foreach ( SpecialVersion::parseComposerInstalled( $credits ) as $name => $info ) {
            if ( str_starts_with( $info['type'], 'mediawiki-' ) ) {
                // Skip any extensions or skins since they'll be listed
                // in their proper section
                continue;
            }
            $data[] = [
                'name' => $name,
                'version' => $info['version'],
            ];
        }
        ApiResult::setIndexedTagName( $data, 'library' );
 
        return $this->getResult()->addValue( 'query', $property, $data );
    }
 
    protected function appendExtensions( string $property ): bool {
        $data = [];
        $credits = SpecialVersion::getCredits(
            ExtensionRegistry::getInstance(),
            $this->getConfig()
        );
        foreach ( $credits as $type => $extensions ) {
            foreach ( $extensions as $ext ) {
                $ret = [ 'type' => $type ];
                if ( isset( $ext['name'] ) ) {
                    $ret['name'] = $ext['name'];
                }
                if ( isset( $ext['namemsg'] ) ) {
                    $ret['namemsg'] = $ext['namemsg'];
                }
                if ( isset( $ext['description'] ) ) {
                    $ret['description'] = $ext['description'];
                }
                if ( isset( $ext['descriptionmsg'] ) ) {
                    // Can be a string or [ key, param1, param2, ... ]
                    if ( is_array( $ext['descriptionmsg'] ) ) {
                        $ret['descriptionmsg'] = $ext['descriptionmsg'][0];
                        $ret['descriptionmsgparams'] = array_slice( $ext['descriptionmsg'], 1 );
                        ApiResult::setIndexedTagName( $ret['descriptionmsgparams'], 'param' );
                    } else {
                        $ret['descriptionmsg'] = $ext['descriptionmsg'];
                    }
                }
                if ( isset( $ext['author'] ) ) {
                    $ret['author'] = is_array( $ext['author'] ) ?
                        implode( ', ', $ext['author'] ) : $ext['author'];
                }
                if ( isset( $ext['url'] ) ) {
                    $ret['url'] = $ext['url'];
                }
                if ( isset( $ext['version'] ) ) {
                    $ret['version'] = $ext['version'];
                }
                if ( isset( $ext['path'] ) ) {
                    $extensionPath = dirname( $ext['path'] );
                    $gitInfo = new GitInfo( $extensionPath );
                    $vcsVersion = $gitInfo->getHeadSHA1();
                    if ( $vcsVersion !== false ) {
                        $ret['vcs-system'] = 'git';
                        $ret['vcs-version'] = $vcsVersion;
                        $ret['vcs-url'] = $gitInfo->getHeadViewUrl();
                        $vcsDate = $gitInfo->getHeadCommitDate();
                        if ( $vcsDate !== false ) {
                            $ret['vcs-date'] = wfTimestamp( TS::ISO_8601, $vcsDate );
                        }
                    }
 
                    if ( ExtensionInfo::getLicenseFileNames( $extensionPath ) ) {
                        $ret['license-name'] = $ext['license-name'] ?? '';
                        $ret['license'] = SpecialPage::getTitleFor(
                            'Version',
                            "License/{$ext['name']}"
                        )->getLinkURL();
                    }
 
                    if ( ExtensionInfo::getAuthorsFileName( $extensionPath ) ) {
                        $ret['credits'] = SpecialPage::getTitleFor(
                            'Version',
                            "Credits/{$ext['name']}"
                        )->getLinkURL();
                    }
                }
                $data[] = $ret;
            }
        }
 
        ApiResult::setIndexedTagName( $data, 'ext' );
 
        return $this->getResult()->addValue( 'query', $property, $data );
    }
 
    protected function appendRightsInfo( string $property ): bool {
        $config = $this->getConfig();
        $title = Title::newFromText( $config->get( MainConfigNames::RightsPage ) );
        if ( $title ) {
            $url = $this->urlUtils->expand( $title->getLinkURL(), PROTO_CURRENT );
        } else {
            $url = $config->get( MainConfigNames::RightsUrl );
        }
        $text = $config->get( MainConfigNames::RightsText ) ?? '';
        if ( $text === '' && $title ) {
            $text = $title->getPrefixedText();
        }
 
        $data = [
            'url' => (string)$url,
            'text' => (string)$text,
        ];
 
        return $this->getResult()->addValue( 'query', $property, $data );
    }
 
    protected function appendRestrictions( string $property ): bool {
        $config = $this->getConfig();
        $data = [
            'types' => $config->get( MainConfigNames::RestrictionTypes ),
            'levels' => $config->get( MainConfigNames::RestrictionLevels ),
            'cascadinglevels' => $config->get( MainConfigNames::CascadingRestrictionLevels ),
            'semiprotectedlevels' => $config->get( MainConfigNames::SemiprotectedRestrictionLevels ),
        ];
 
        ApiResult::setArrayType( $data['types'], 'BCarray' );
        ApiResult::setArrayType( $data['levels'], 'BCarray' );
        ApiResult::setArrayType( $data['cascadinglevels'], 'BCarray' );
        ApiResult::setArrayType( $data['semiprotectedlevels'], 'BCarray' );
 
        ApiResult::setIndexedTagName( $data['types'], 'type' );
        ApiResult::setIndexedTagName( $data['levels'], 'level' );
        ApiResult::setIndexedTagName( $data['cascadinglevels'], 'level' );
        ApiResult::setIndexedTagName( $data['semiprotectedlevels'], 'level' );
 
        return $this->getResult()->addValue( 'query', $property, $data );
    }
 
    public function appendLanguages( string $property ): bool {
        $params = $this->extractRequestParams();
        $langCode = $params['inlanguagecode'] ?? '';
        $langNames = $this->languageNameUtils->getLanguageNames( $langCode );
 
        $data = [];
 
        foreach ( $langNames as $code => $name ) {
            $lang = [
                'code' => $code,
                'bcp47' => LanguageCode::bcp47( $code ),
            ];
            ApiResult::setContentValue( $lang, 'name', $name );
            $data[] = $lang;
        }
        ApiResult::setIndexedTagName( $data, 'lang' );
 
        return $this->getResult()->addValue( 'query', $property, $data );
    }
 
    // Export information about which page languages will trigger
    // language conversion. (T153341)
    public function appendLanguageVariants( string $property ): bool {
        $langNames = $this->languageConverterFactory->isConversionDisabled() ? [] :
            LanguageConverter::$languagesWithVariants;
        sort( $langNames );
 
        $data = [];
        foreach ( $langNames as $langCode ) {
            $lang = $this->languageFactory->getLanguage( $langCode );
            $langConverter = $this->languageConverterFactory->getLanguageConverter( $lang );
            if ( !$langConverter->hasVariants() ) {
                // Only languages which have variants should be listed
                continue;
            }
            $data[$langCode] = [];
            ApiResult::setIndexedTagName( $data[$langCode], 'variant' );
            ApiResult::setArrayType( $data[$langCode], 'kvp', 'code' );
 
            $variants = $langConverter->getVariants();
            sort( $variants );
            foreach ( $variants as $v ) {
                $data[$langCode][$v] = [
                    'fallbacks' => (array)$langConverter->getVariantFallbacks( $v ),
                ];
                ApiResult::setIndexedTagName(
                    $data[$langCode][$v]['fallbacks'], 'variant'
                );
            }
        }
        ApiResult::setIndexedTagName( $data, 'lang' );
        ApiResult::setArrayType( $data, 'kvp', 'code' );
 
        return $this->getResult()->addValue( 'query', $property, $data );
    }
 
    public function appendSkins( string $property ): bool {
        $data = [];
        $allowed = $this->skinFactory->getAllowedSkins();
        $default = Skin::normalizeKey( 'default' );
 
        foreach ( $this->skinFactory->getInstalledSkins() as $name => $displayName ) {
            $msg = $this->msg( "skinname-{$name}" );
            $code = $this->getParameter( 'inlanguagecode' );
            if ( $code && $this->languageNameUtils->isValidCode( $code ) ) {
                $msg->inLanguage( $code );
            } else {
                $msg->inContentLanguage();
            }
            if ( $msg->exists() ) {
                $displayName = $msg->text();
            }
            $skin = [ 'code' => $name ];
            ApiResult::setContentValue( $skin, 'name', $displayName );
            if ( !isset( $allowed[$name] ) ) {
                $skin['unusable'] = true;
            }
            if ( $name === $default ) {
                $skin['default'] = true;
            }
            $data[] = $skin;
        }
        ApiResult::setIndexedTagName( $data, 'skin' );
 
        return $this->getResult()->addValue( 'query', $property, $data );
    }
 
    public function appendExtensionTags( string $property ): bool {
        $tags = array_map(
            static fn ( $item ) => "<$item>",
            $this->parserFactory->getMainInstance()->getTags()
        );
        ApiResult::setArrayType( $tags, 'BCarray' );
        ApiResult::setIndexedTagName( $tags, 't' );
 
        return $this->getResult()->addValue( 'query', $property, $tags );
    }
 
    public function appendFunctionHooks( string $property ): bool {
        $hooks = $this->parserFactory->getMainInstance()->getFunctionHooks();
        ApiResult::setArrayType( $hooks, 'BCarray' );
        ApiResult::setIndexedTagName( $hooks, 'h' );
 
        return $this->getResult()->addValue( 'query', $property, $hooks );
    }
 
    public function appendVariables( string $property ): bool {
        $variables = $this->magicWordFactory->getVariableIDs();
        ApiResult::setArrayType( $variables, 'BCarray' );
        ApiResult::setIndexedTagName( $variables, 'v' );
 
        return $this->getResult()->addValue( 'query', $property, $variables );
    }
 
    public function appendDoubleUnderscores( string $property ): bool {
        $ids = $this->magicWordFactory->getDoubleUnderscoreArray()->getNames();
        ApiResult::setArrayType( $ids, 'BCarray' );
        ApiResult::setIndexedTagName( $ids, 'v' );
 
        return $this->getResult()->addValue( 'query', $property, $ids );
    }
 
    public function appendProtocols( string $property ): bool {
        // Make a copy of the global so we don't try to set the _element key of it - T47130
        $protocols = array_values( $this->getConfig()->get( MainConfigNames::UrlProtocols ) );
        ApiResult::setArrayType( $protocols, 'BCarray' );
        ApiResult::setIndexedTagName( $protocols, 'p' );
 
        return $this->getResult()->addValue( 'query', $property, $protocols );
    }
 
    public function appendDefaultOptions( string $property ): bool {
        $options = $this->userOptionsLookup->getDefaultOptions( null );
        $options[ApiResult::META_BC_BOOLS] = array_keys( $options );
        // Adjust thumbsize option, since for API purposes we're returning
        // thumblimits as a non-sparse array. (T427066)
        $options['thumbsize'] = array_search(
            $options['thumbsize'],
            array_keys( $this->getConfig()->get( MainConfigNames::ThumbLimits ) ),
            true
        );
        return $this->getResult()->addValue( 'query', $property, $options );
    }
 
    public function appendUploadDialog( string $property ): bool {
        $config = $this->getConfig()->get( MainConfigNames::UploadDialog );
        return $this->getResult()->addValue( 'query', $property, $config );
    }
 
    private function getAutoPromoteConds(): array {
        $allowedConditions = [];
        foreach ( get_defined_constants() as $constantName => $constantValue ) {
            if ( str_contains( $constantName, 'APCOND_' ) ) {
                $allowedConditions[$constantName] = $constantValue;
            }
        }
        return $allowedConditions;
    }
 
    private function processAutoPromote( array $input, array $allowedConditions ): array {
        $data = [];
        foreach ( $input as $groupName => $conditions ) {
            $row = $this->recAutopromote( $conditions, $allowedConditions );
            if ( !isset( $row[0] ) || is_string( $row ) ) {
                $row = [ $row ];
            }
            $data[$groupName] = $row;
        }
        return $data;
    }
 
    private function appendAutoPromote( string $property ): bool {
        return $this->getResult()->addValue(
            'query',
            $property,
            $this->processAutoPromote(
                $this->getConfig()->get( MainConfigNames::Autopromote ),
                $this->getAutoPromoteConds()
            )
        );
    }
 
    private function appendAutoPromoteOnce( string $property ): bool {
        $allowedConditions = $this->getAutoPromoteConds();
        $data = [];
        foreach ( $this->getConfig()->get( MainConfigNames::AutopromoteOnce ) as $key => $value ) {
            $data[$key] = $this->processAutoPromote( $value, $allowedConditions );
        }
        return $this->getResult()->addValue( 'query', $property, $data );
    }
 
    private function appendCopyUploadDomains( string $property ): bool {
        $allowedHosts = UploadFromUrl::getAllowedHosts();
        ApiResult::setIndexedTagName( $allowedHosts, 'domain' );
        return $this->getResult()->addValue(
            'query',
            $property,
            $allowedHosts
        );
    }
 
    private function appendCrossSiteAJAXdomains( string $property ): bool {
        $allowedDomains = $this->getConfig()->get( MainConfigNames::CrossSiteAJAXdomains );
        ApiResult::setArrayType( $allowedDomains, 'array' );
        ApiResult::setIndexedTagName( $allowedDomains, 'domain' );
        return $this->getResult()->addValue( 'query', $property, $allowedDomains );
    }
 
    protected function appendSBOM( string $property ): bool {
        if ( !$this->userIdentityUtils->isNamed( $this->getUser() ) ) {
            $this->dieWithError( 'apierror-mustbeloggedin-sbom' );
        }
        $data = $this->sbomGenerator->generateCdxSBOM( $this->getContext() );
        return $this->getResult()->addValue( 'query', $property, $data );
    }
 
    private function recAutopromote( $cond, $allowedConditions ) {
        $config = [];
        // First, checks if $cond is an array
        if ( is_array( $cond ) ) {
            // Checks if $cond[0] is a valid operand
            if ( in_array( $cond[0], UserRequirementsConditionChecker::VALID_OPS, true ) ) {
                $config['operand'] = $cond[0];
                // Traversal checks conditions
                foreach ( array_slice( $cond, 1 ) as $value ) {
                    $config[] = $this->recAutopromote( $value, $allowedConditions );
                }
            } elseif ( is_string( $cond[0] ) ) {
                // Returns $cond directly, if $cond[0] is a string
                $config = $cond;
            } else {
                // When $cond is equal to an APCOND_ constant value
                $params = array_slice( $cond, 1 );
                if ( $params === [ null ] ) {
                    // Special casing for these conditions and their default of null,
                    // to replace their values with $wgAutoConfirmCount/$wgAutoConfirmAge as appropriate
                    if ( $cond[0] === APCOND_EDITCOUNT ) {
                        $params = [ $this->getConfig()->get( MainConfigNames::AutoConfirmCount ) ];
                    } elseif ( $cond[0] === APCOND_AGE ) {
                        $params = [ $this->getConfig()->get( MainConfigNames::AutoConfirmAge ) ];
                    }
                }
                $config = [
                    'condname' => array_search( $cond[0], $allowedConditions ),
                    'params' => $params
                ];
                ApiResult::setIndexedTagName( $config, 'params' );
            }
        } elseif ( is_string( $cond ) ) {
            $config = $cond;
        } else {
            // When $cond is equal to an APCOND_ constant value
            $config = [
                'condname' => array_search( $cond, $allowedConditions ),
                'params' => []
            ];
            ApiResult::setIndexedTagName( $config, 'params' );
        }
 
        return $config;
    }
 
    public function appendSubscribedHooks( string $property ): bool {
        $hookNames = $this->hookContainer->getHookNames();
        sort( $hookNames );
 
        $data = [];
        foreach ( $hookNames as $name ) {
            $arr = [
                'name' => $name,
                'subscribers' => $this->hookContainer->getHandlerDescriptions( $name ),
            ];
 
            ApiResult::setArrayType( $arr['subscribers'], 'array' );
            ApiResult::setIndexedTagName( $arr['subscribers'], 's' );
            $data[] = $arr;
        }
 
        ApiResult::setIndexedTagName( $data, 'hook' );
 
        return $this->getResult()->addValue( 'query', $property, $data );
    }
 
    public function getCacheMode( $params ) {
        // Messages for $wgExtraInterlanguageLinkPrefixes depend on user language
        if ( $this->getConfig()->get( MainConfigNames::ExtraInterlanguageLinkPrefixes ) &&
            in_array( 'interwikimap', $params['prop'] ?? [] )
        ) {
            return 'anon-public-user-private';
        }
 
        return 'public';
    }
 
    public function getAllowedParams() {
        return [
            'prop' => [
                ParamValidator::PARAM_DEFAULT => 'general',
                ParamValidator::PARAM_ISMULTI => true,
                ParamValidator::PARAM_TYPE => [
                    'general',
                    'namespaces',
                    'namespacealiases',
                    'specialpagealiases',
                    'magicwords',
                    'interwikimap',
                    'dbrepllag',
                    'statistics',
                    'usergroups',
                    'autocreatetempuser',
                    'clientlibraries',
                    'libraries',
                    'extensions',
                    'fileextensions',
                    'rightsinfo',
                    'restrictions',
                    'languages',
                    'languagevariants',
                    'skins',
                    'extensiontags',
                    'functionhooks',
                    'showhooks',
                    'variables',
                    'doubleunderscores',
                    'protocols',
                    'defaultoptions',
                    'uploaddialog',
                    'autopromote',
                    'autopromoteonce',
                    'copyuploaddomains',
                    'crosssiteajaxdomains',
                    'sbom',
                ],
                ApiBase::PARAM_HELP_MSG_PER_VALUE => [],
            ],
            'filteriw' => [
                ParamValidator::PARAM_TYPE => [
                    'local',
                    '!local',
                ]
            ],
            'showalldb' => false,
            'numberingroup' => false,
            'inlanguagecode' => null,
        ];
    }
 
    protected function getExamplesMessages() {
        return [
            'action=query&meta=siteinfo&siprop=general|namespaces|namespacealiases|statistics'
                => 'apihelp-query+siteinfo-example-simple',
            'action=query&meta=siteinfo&siprop=interwikimap&sifilteriw=local'
                => 'apihelp-query+siteinfo-example-interwiki',
            'action=query&meta=siteinfo&siprop=dbrepllag&sishowalldb='
                => 'apihelp-query+siteinfo-example-replag',
        ];
    }
 
    public function getHelpUrls() {
        return 'https://www.mediawiki.org/wiki/Special:MyLanguage/API:Siteinfo';
    }
}
 
class_alias( ApiQuerySiteinfo::class, 'ApiQuerySiteinfo' );