JsonSchemaTrait.php

Go to the documentation of this file.

<?php
 
namespace MediaWiki\Settings\Source;
 
use InvalidArgumentException;
 
trait JsonSchemaTrait {
 
    private static function jsonToPhpDoc( $jsonSchemaType ) {
        static $phpTypes = [
            'array' => 'array',
            'object' => 'array', // could be optional
            'number' => 'float',
            'double' => 'float', // for good measure
            'boolean' => 'bool',
            'integer' => 'int',
        ];
 
        if ( $jsonSchemaType === null ) {
            throw new InvalidArgumentException( 'The type name cannot be null! Use "null" instead.' );
        }
 
        $nullable = false;
        if ( is_array( $jsonSchemaType ) ) {
            $nullIndex = array_search( 'null', $jsonSchemaType );
            if ( $nullIndex !== false ) {
                $nullable = true;
                unset( $jsonSchemaType[$nullIndex] );
            }
 
            $jsonSchemaType = array_map( [ self::class, 'jsonToPhpDoc' ], $jsonSchemaType );
            $type = implode( '|', $jsonSchemaType );
        } else {
            $type = $phpTypes[ strtolower( $jsonSchemaType ) ] ?? $jsonSchemaType;
        }
 
        if ( $nullable ) {
            $type = "?$type";
        }
 
        return $type;
    }
 
    private static function phpDocToJson( $phpDocType ) {
        static $jsonTypes = [
            'list' => 'array',
            'dict' => 'object',
            'map' => 'object',
            'stdclass' => 'object',
            'int' => 'integer',
            'float' => 'number',
            'bool' => 'boolean',
            'false' => 'boolean',
        ];
 
        if ( $phpDocType === null ) {
            throw new InvalidArgumentException( 'The type name cannot be null! Use "null" instead.' );
        }
 
        if ( is_array( $phpDocType ) ) {
            $types = $phpDocType;
        } else {
            $types = explode( '|', trim( $phpDocType ) );
        }
 
        $nullable = false;
        foreach ( $types as $i => $t ) {
            if ( str_starts_with( $t, '?' ) ) {
                $nullable = true;
                $t = substr( $t, 1 );
            }
 
            $types[$i] = $jsonTypes[ strtolower( $t ) ] ?? $t;
        }
 
        if ( $nullable ) {
            $types[] = 'null';
        }
 
        $types = array_unique( $types );
 
        if ( count( $types ) === 1 ) {
            return reset( $types );
        }
 
        return $types;
    }
 
    private static function normalizeJsonSchema(
        array $schema,
        array &$defs,
        string $source,
        string $propertyName
    ): array {
        if ( isset( $schema['type'] ) ) {
            // Support PHP Doc style types, for convenience.
            $schema['type'] = self::phpDocToJson( $schema['type'] );
        }
 
        if ( isset( $schema['additionalProperties'] ) && is_array( $schema['additionalProperties'] ) ) {
            $schema['additionalProperties'] =
                self::normalizeJsonSchema( $schema['additionalProperties'], $defs, $source, $propertyName );
        }
 
        if ( isset( $schema['items'] ) && is_array( $schema['items'] ) ) {
            $schema['items'] = self::normalizeJsonSchema( $schema['items'], $defs, $source, $propertyName );
        }
 
        if ( isset( $schema['properties'] ) && is_array( $schema['properties'] ) ) {
            foreach ( $schema['properties'] as $name => $propSchema ) {
                $schema['properties'][$name] = self::normalizeJsonSchema( $propSchema, $defs, $source, $propertyName );
            }
        }
 
        // Definitions need to be collected before normalizing the reference because
        // JsonSchemaReferenceResolver expects the $ref to be an array with:
        // [ "class" => "Some\\Class", "field" => "someField" ]
        JsonSchemaReferenceResolver::getDefinitions( $schema, $defs, $source, $propertyName );
 
        if ( isset( $schema['$ref'] ) ) {
            $schema['$ref'] = JsonSchemaReferenceResolver::normalizeRef( $schema['$ref'] );
        }
 
        return $schema;
    }
 
    private static function getDefaultFromJsonSchema( array $schema ) {
        $default = $schema['default'] ?? null;
 
        foreach ( $schema['properties'] ?? [] as $name => $sch ) {
            $def = self::getDefaultFromJsonSchema( $sch );
 
            $default[$name] = $def;
        }
 
        return $default;
    }
 
}