MatcherBasedModule.php

Go to the documentation of this file.

<?php
 
namespace MediaWiki\Rest\Module;
 
use InvalidArgumentException;
use MediaWiki\Rest\PathTemplateMatcher\PathMatcher;
 
abstract class MatcherBasedModule extends Module {
 
    private ?array $matchers = [];
 
    private bool $matchersInitialized = false;
 
    public function getCacheData(): array {
        $cacheData = [];
 
        foreach ( $this->getMatchers() as $method => $matcher ) {
            $cacheData[$method] = $matcher->getCacheData();
        }
 
        $cacheData[self::CACHE_CONFIG_HASH_KEY] = $this->getConfigHash();
        return $cacheData;
    }
 
    public function initFromCacheData( array $cacheData ): bool {
        if ( $cacheData[self::CACHE_CONFIG_HASH_KEY] !== $this->getConfigHash() ) {
            return false;
        }
 
        unset( $cacheData[self::CACHE_CONFIG_HASH_KEY] );
        $this->matchers = [];
 
        foreach ( $cacheData as $method => $data ) {
            $this->matchers[$method] = PathMatcher::newFromCache( $data );
        }
 
        $this->matchersInitialized = true;
        return true;
    }
 
    abstract protected function getConfigHash(): string;
 
    protected function getMatchers() {
        if ( !$this->matchersInitialized ) {
            $this->initRoutes();
            $this->matchersInitialized = true;
        }
 
        return $this->matchers;
    }
 
    abstract protected function initRoutes(): void;
 
    protected function addRoute( $method, string $path, array $info ) {
        $methods = (array)$method;
 
        // Make sure the matched path is known.
        if ( !isset( $info['spec'] ) ) {
            throw new InvalidArgumentException( 'Missing key in $info: "spec"' );
        }
 
        $info['path'] = $path;
 
        foreach ( $methods as $method ) {
            $method = strtoupper( $method );
 
            if ( !isset( $this->matchers[$method] ) ) {
                $this->matchers[$method] = new PathMatcher;
            }
 
            $this->matchers[$method]->add( $path, $info );
        }
    }
 
    public function findHandlerMatch(
        string $path,
        string $requestMethod
    ): array {
        $requestMethod = strtoupper( $requestMethod );
 
        $matchers = $this->getMatchers();
        $matcher = $matchers[$requestMethod] ?? null;
        $match = $matcher ? $matcher->match( $path ) : null;
 
        if ( !$match ) {
            // Return allowed methods, to support CORS and 405 responses.
            return [
                'found' => false,
                'methods' => $this->getAllowedMethods( $path ),
            ];
        } else {
            $info = $match['userData'];
            $info['found'] = true;
            $info['method'] = $requestMethod;
            $info['params'] = $match['params'] ?? [];
 
            return $info;
        }
    }
 
    public function getAllowedMethods( string $relPath ): array {
        $allowed = [];
        foreach ( $this->getMatchers() as $allowedMethod => $allowedMatcher ) {
            if ( $allowedMatcher->match( $relPath ) ) {
                $allowed[] = $allowedMethod;
            }
        }
 
        return array_unique(
            in_array( 'GET', $allowed ) ? array_merge( [ 'HEAD' ], $allowed ) : $allowed
        );
    }
 
}