xsd2php

If your XSD contains xsd:anyType or xsd:anySimpleType, you must map these to custom handlers in your config.yml using the aliases key. You then implement a class that implements SubscribingHandlerInterface to define how serialization and deserialization should behave for these types.

# config.yml
xsd2php:
  aliases: 
    'http://www.w3.org/2001/XMLSchema':
      anyType: 'MyCustomAnyTypeHandler'
      anySimpleType: 'MyCustomAnySimpleTypeHandler'

use JMS\\Serializer\\Handler\\SubscribingHandlerInterface;
use JMS\\Serializer\\GraphNavigator;

class MyHandler implements SubscribingHandlerInterface
{
    public static function getSubscribingMethods()
    {
        return [
            [
                'direction' => GraphNavigator::DIRECTION_DESERIALIZATION,
                'format' => 'xml',
                'type' => 'MyCustomAnyTypeHandler',
                'method' => 'deserializeAnyType'
            ],
            [
                'direction' => GraphNavigator::DIRECTION_SERIALIZATION,
                'format' => 'xml',
                'type' => 'MyCustomAnyTypeHandler',
                'method' => 'serializeAnyType'
            ]
        ];
    }

    public function serializeAnyType($visitor, $data, array $type, $context)
    {
        // implementation
    }

    public function deserializeAnyType($visitor, $data, array $type)
    {
        // implementation
    }
}

The generated JMS metadata allows you to serialize and deserialize PHP objects using the JMS Serializer. You must register default handlers (like BaseTypesHandler and XmlSchemaDateHandler) and point the builder to your generated metadata directory.

<?php

use JMS\
Serializer\\SerializerBuilder;
use JMS\\Serializer\\Handler\\HandlerRegistryInterface;
use GoetasWebservices\\Xsd\\XsdToPhpRuntime\\Jms\\Handler\\BaseTypesHandler;
use GoetasWebservices\\Xsd\\XsdToPhpRuntime\\Jms\\Handler\\XmlSchemaDateHandler;

$serializerBuilder = SerializerBuilder::create();
$serializerBuilder->addMetadataDir('metadata dir', 'TestNs');
$serializerBuilder->configureHandlers(function (HandlerRegistryInterface $handler) use ($serializerBuilder) {
    $serializerBuilder->addDefaultHandlers();
    $handler->registerSubscribingHandler(new BaseTypesHandler());
    $handler->registerSubscribingHandler(new XmlSchemaDateHandler());
});

$serializer = $serializerBuilder->build();

// Deserialize XML into an object
$object = $serializer->deserialize('<some xml/>', 'TestNs\\MyObject', 'xml');

// Serialize object back to XML
$newXml = $serializer->serialize($object, 'xml');

The YamlValidatorConverter is a specialized converter that extends YamlConverter to transform XSD schema restrictions into Symfony Validation Constraints for use in JMS YAML files.

When generating validation metadata, it maps specific XSD facets to the following Symfony constraints:

• enumeration $\rightarrow$ Choice (with type-casting for int and float)
• length $\rightarrow$ Length (sets both min and max to the same value)
• maxLength $\rightarrow$ Length (sets max)
• minLength $\rightarrow$ Length (sets min)
• pattern $\rightarrow$ Regex (includes automatic translation of Unicode blocks like \p{IsBasicLatin} to PHP-compatible hex ranges)
• maxExclusive $\rightarrow$ LessThan
• maxInclusive $\rightarrow$ LessThanOrEqual
• minExclusive $\rightarrow$ GreaterThan
• minInclusive $\rightarrow$ GreaterThanOrEqual

Additionally, it handles structural constraints:

• Required Elements/Attributes: Maps to NotNull.
• Arrays: Uses Count for min/max occurrences and wraps element constraints in an All constraint to ensure every item in the array satisfies the rules.

The conversion process requires a YAML configuration file to map XML namespaces to PHP namespaces and define output directories.

Important for Linux Users: Use backslashes (\) for PHP namespaces in the configuration (e.g., TestNs\MyApp). On Windows, you may use forward slashes (/) if preferred, but backslashes are the standard for PHP namespaces.

Key configuration sections:

• xsd2php.namespaces (Required): Maps XML namespaces to PHP namespaces.
• xsd2php.destinations_php (Required): Directory for generated PHP classes.
• xsd2php.destinations_jms (Required): Directory for JMS Serializer metadata.
• xsd2php.aliases (Optional): Maps specific XML types to custom PHP classes to bypass metadata generation.
• xsd2php.naming_strategy (Optional): Use short (default) or long to avoid naming conflicts.
• xsd2php.path_generator (Optional): Strategy for file saving (default is psr4).

xsd2php:
  namespaces:
    'http://www.example.org/test/': 'TestNs\MyApp'
  destinations_php: 
    'TestNs\MyApp': soap/src
  destinations_jms:
    'TestNs\MyApp': soap/metadata
  aliases: 
    'http://www.example.org/test/':
      MyCustomXSDType: 'MyCustomMappedPHPType'
  naming_strategy: short
  path_generator: psr4

The PhpConverter class is the primary engine for converting XSD (XML Schema Definition) schemas into PHP class structures. It uses a NamingStrategy to determine how XSD elements and types are named in PHP and requires a mapping of XSD namespaces to PHP namespaces.

To use it, instantiate the converter with a naming strategy and a logger, then call convert() passing an array of Schema objects. The method returns an associative array where keys are the fully qualified class names and values are the corresponding PHPClass objects.

use GoetasWebservices\Xsd\XsdToPhp\Php\PhpConverter;
use GoetasWebservices\Xsd\XsdToPhp\Naming\YourNamingStrategy;

$converter = new PhpConverter(new YourNamingStrategy(), $logger);
$phpClasses = $converter->convert($schemas);

foreach ($phpClasses as $fqcn => $phpClass) {
    // $phpClass is an instance of PHPClass representing the generated structure
}