Introduce constructor & property default values with ScalarDefaultProvider

  - Add ScalarDefaultProvider that determines type-appropriate defaults
    for properties (string='', int=0, bool=false, float=0.0, array=[],
    nullable=null)
  - Add withDefaultValues() option to PropertyAssembler (enabled by default),
    replacing the separate PropertyDefaultsAssembler
  - Add withDefaultValues() option to ConstructorAssembler (enabled by default),
    with automatic reordering of parameters so those with defaults come last
  - Add withOptionalValue() option to ConstructorAssembler, forcing all
    parameters to ?Type = null (matching PropertyAssembler behavior)
  - Remove PropertyDefaultsAssembler (functionality folded into PropertyAssembler)

Author: veewee

UPGRADING.md

@@ -131,6 +131,22 @@ If you want to have this mapping in your configuration, you can start out fresh
 ./vendor/bin/soap-client generate:config --config=config/soap-client.php
 ```
 
+## Constructor and property default values
+
+The `ConstructorAssembler` now applies type-appropriate default values to constructor parameters by default. Scalar parameters get their zero-value (`''`, `0`, `false`, `0.0`, `[]`), nullable parameters get `= null`, and parameters with defaults are reordered to the end (PHP requirement). Non-nullable complex type parameters remain without defaults. To restore the previous behavior, use:
+
+```php
+new ConstructorAssembler((new ConstructorAssemblerOptions())->withDefaultValues(false))
+```
+
+The `ConstructorAssembler` also supports a new `withOptionalValue()` option that forces all parameters to `?Type = null`, matching the `PropertyAssembler` behavior.
+
+The `PropertyDefaultsAssembler` has been removed. Its functionality is now built into `PropertyAssembler` via `PropertyAssemblerOptions::create()->withDefaultValues()` (enabled by default). To disable:
+
+```php
+new PropertyAssembler(PropertyAssemblerOptions::create()->withDefaultValues(false))
+```
+
 ## Regenerate classes
 
 After upgrading, regenerate all your classes:

docs/code-generation/assemblers.md

@@ -19,7 +19,6 @@ to generate the code you want to add to the generated SOAP types.
 - [IteratorAssembler](#iteratorassembler)
 - [JsonSerializableAssembler](#jsonserializableassembler)
 - [PropertyAssembler](#propertyassembler)
-- [PropertyDefaultsAssembler](#propertydefaultsassembler)
 - [RequestAssembler](#requestassembler)
 - [ResultAssembler](#resultassembler)
 - [ResultProviderAssembler](#resultproviderassembler)
@@ -121,6 +120,44 @@ new ConstructorAssembler((new ConstructorAssemblerOptions())->withDocBlocks(fals
     }
 ```
 
+Default values are enabled by default. Scalar parameters get type-appropriate defaults (`''`, `0`, `false`, `0.0`, `[]`), nullable parameters get `= null`, and parameters with defaults are reordered to the end (PHP requirement). This can be disabled with `withDefaultValues(false)`.
+
+Example
+```php
+new ConstructorAssembler((new ConstructorAssemblerOptions())->withTypeHints()->withDefaultValues())
+```
+
+```php
+    public function __construct(SomeClass $obj, string $prop1 = '', int $prop2 = 0)
+    {
+        $this->obj = $obj;
+        $this->prop1 = $prop1;
+        $this->prop2 = $prop2;
+    }
+```
+
+To disable default values:
+```php
+new ConstructorAssembler((new ConstructorAssemblerOptions())->withDefaultValues(false))
+```
+
+Optional values can be enabled with `withOptionalValue()`. This forces ALL parameters to be nullable with `= null`, regardless of WSDL metadata. This is useful when you want to construct objects without providing all values upfront.
+
+Example
+```php
+new ConstructorAssembler((new ConstructorAssemblerOptions())->withOptionalValue())
+```
+
+```php
+    public function __construct(?string $prop1 = null, ?SomeClass $prop2 = null)
+    {
+        $this->prop1 = $prop1;
+        $this->prop2 = $prop2;
+    }
+```
+
+`withOptionalValue()` takes precedence over `withDefaultValues()`: when both are enabled, all parameters become `?Type = null`.
+
 ## FluentSetterAssembler
 
 The `FluentSetterAssembler` will add a setter method to the generated class. The method will return the current instance to enable chaining.
@@ -306,30 +343,28 @@ Example output:
     /**
      * @var string
      */
-    private $prop1 = null;
+    private string $prop1 = '';
 ```
 
-You can adjust the visibility of the property by injecting the visibility in the constructor.
+You can adjust the visibility of the property by injecting `PropertyAssemblerOptions` in the constructor.
 
 ```php
-new PropertyAssembler(PropertyGenerator::VISIBILITY_PROTECTED)
+new PropertyAssembler(PropertyAssemblerOptions::create()->withVisibility(PropertyGenerator::VISIBILITY_PROTECTED))
 ```
 
 Please note that the default ruleset has a visibility of private.
 If you want to override this, you will have to override all rules by calling `Phpro\SoapClient\CodeGenerator\Config\Config::setRuleSet`.
 
-## PropertyDefaultsAssembler
-
-This `PropertyDefaultsAssembler` can be used together with the default `PropertyAssembler` and can be used to determine basic default values for specific properties.
-It adds default values for following scalar types: `string`, `int`, `float`, `bool`, `array`, `mixed`.
+Default values are enabled by default via `withDefaultValues()`. Scalar properties get type-appropriate defaults (`''`, `0`, `false`, `0.0`, `[]`), nullable types get `= null`, and non-nullable complex types get no default.
 
-Example output:
+This differs from `withOptionalValue()`:
+- `withOptionalValue()`: forces ALL properties to `?Type = null` regardless of WSDL metadata.
+- `withDefaultValues()`: gives type-appropriate defaults respecting the WSDL schema.
+- When both are enabled, `withOptionalValue()` takes precedence (everything becomes `?Type = null`).
 
+To disable default values:
 ```php
-    /**
-     * @var string
-     */
-    private $prop1 = '';
+new PropertyAssembler(PropertyAssemblerOptions::create()->withDefaultValues(false))
 ```
 
 ## RequestAssembler

src/Phpro/SoapClient/CodeGenerator/Assembler/ConstructorAssembler.php

@@ -6,9 +6,12 @@
 use Laminas\Code\Generator\ParameterGenerator;
 use Phpro\SoapClient\CodeGenerator\Context\ContextInterface;
 use Phpro\SoapClient\CodeGenerator\Context\TypeContext;
+use Phpro\SoapClient\CodeGenerator\Model\Property;
 use Phpro\SoapClient\CodeGenerator\Model\Type;
+use Phpro\SoapClient\CodeGenerator\Provider\ScalarDefaultProvider;
 use Phpro\SoapClient\Exception\AssemblerException;
 use Laminas\Code\Generator\MethodGenerator;
+use Soap\Engine\Metadata\Model\TypeMeta;
 
 /**
  * Class ConstructorAssembler
@@ -67,23 +70,30 @@ public function assemble(ContextInterface $context)
      */
     private function assembleConstructor(Type $type): MethodGenerator
     {
-        $body = [];
         $constructor = (new MethodGenerator('__construct'))
             ->setVisibility(MethodGenerator::VISIBILITY_PUBLIC);
 
         $docblock = (new DocBlockGenerator())
             ->setWordWrap(false)
             ->setShortDescription('Constructor');
 
-        foreach ($type->getProperties() as $property) {
-            $param = (new ParameterGenerator($property->getName()));
-            $body[] = sprintf('$this->%1$s = $%1$s;', $property->getName());
+        $entries = $this->resolveProperties($type->getProperties());
+
+        $body = [];
+        foreach ($entries as $entry) {
+            $property = $entry['property'];
+            $param = new ParameterGenerator($property->getName());
 
             if ($this->options->useTypeHints()) {
                 $param->setType($property->getPhpType());
             }
 
+            if ($entry['hasDefault']) {
+                $param->setDefaultValue($entry['default']);
+            }
+
             $constructor->setParameter($param);
+            $body[] = sprintf('$this->%1$s = $%1$s;', $property->getName());
 
             if ($this->options->useDocBlocks()) {
                 $docblock->setTag([
@@ -101,4 +111,47 @@ private function assembleConstructor(Type $type): MethodGenerator
 
         return $constructor;
     }
+
+    /**
+     * Resolves properties by applying optionalValue nullability, computing default values
+     * via ScalarDefaultProvider, and reordering so that properties without defaults come
+     * first (PHP requirement for parameters with defaults to be trailing).
+     *
+     * @param list<Property> $properties
+     * @return list<array{property: Property, default: mixed, hasDefault: bool}>
+     */
+    private function resolveProperties(array $properties): array
+    {
+        $applyDefaults = ($this->options->useDefaultValues() || $this->options->useOptionalValue())
+            && $this->options->useTypeHints();
+
+        $defaultProvider = new ScalarDefaultProvider();
+        $entries = [];
+
+        foreach ($properties as $property) {
+            if ($this->options->useOptionalValue()) {
+                $property = $property->withMeta(fn(TypeMeta $meta): TypeMeta => $meta->withIsNullable(true));
+            }
+
+            $hasDefault = false;
+            $default = null;
+            if ($applyDefaults) {
+                $result = $defaultProvider($property);
+                if ($result->isSucceeded()) {
+                    $hasDefault = true;
+                    $default = $result->getResult();
+                }
+            }
+
+            $entries[] = ['property' => $property, 'default' => $default, 'hasDefault' => $hasDefault];
+        }
+
+        if ($applyDefaults) {
+            $withoutDefaults = array_filter($entries, static fn (array $e): bool => !$e['hasDefault']);
+            $withDefaults = array_filter($entries, static fn (array $e): bool => $e['hasDefault']);
+            $entries = [...array_values($withoutDefaults), ...array_values($withDefaults)];
+        }
+
+        return $entries;
+    }
 }

src/Phpro/SoapClient/CodeGenerator/Assembler/ConstructorAssemblerOptions.php

@@ -21,6 +21,20 @@ class ConstructorAssemblerOptions
      */
     private $docBlocks = true;
 
+    /**
+     * When enabled, constructor parameters receive type-appropriate default values:
+     * scalars get their zero-value ('', 0, false, 0.0, []), nullable types get null.
+     * Parameters with defaults are reordered to the end (PHP requirement).
+     * Requires type hints to be enabled.
+     */
+    private bool $defaultValues = true;
+
+    /**
+     * When enabled, ALL constructor parameters are forced to be nullable with = null,
+     * regardless of WSDL metadata. Takes precedence over defaultValues.
+     */
+    private bool $optionalValue = false;
+
     /**
      * @return ConstructorAssemblerOptions
      */
@@ -70,4 +84,30 @@ public function useDocBlocks(): bool
     {
         return $this->docBlocks;
     }
+
+    public function withDefaultValues(bool $withDefaultValues = true): ConstructorAssemblerOptions
+    {
+        $new = clone $this;
+        $new->defaultValues = $withDefaultValues;
+
+        return $new;
+    }
+
+    public function useDefaultValues(): bool
+    {
+        return $this->defaultValues;
+    }
+
+    public function withOptionalValue(bool $withOptionalValue = true): ConstructorAssemblerOptions
+    {
+        $new = clone $this;
+        $new->optionalValue = $withOptionalValue;
+
+        return $new;
+    }
+
+    public function useOptionalValue(): bool
+    {
+        return $this->optionalValue;
+    }
 }

src/Phpro/SoapClient/CodeGenerator/Assembler/PropertyAssembler.php

@@ -3,10 +3,12 @@
 namespace Phpro\SoapClient\CodeGenerator\Assembler;
 
 use Laminas\Code\Generator\DocBlockGenerator;
+use Laminas\Code\Generator\PropertyValueGenerator;
 use Laminas\Code\Generator\TypeGenerator;
 use Phpro\SoapClient\CodeGenerator\Context\ContextInterface;
 use Phpro\SoapClient\CodeGenerator\Context\PropertyContext;
 use Phpro\SoapClient\CodeGenerator\LaminasCodeFactory\DocBlockGeneratorFactory;
+use Phpro\SoapClient\CodeGenerator\Provider\ScalarDefaultProvider;
 use Phpro\SoapClient\Exception\AssemblerException;
 use Laminas\Code\Generator\PropertyGenerator;
 use Soap\Engine\Metadata\Model\TypeMeta;
@@ -80,6 +82,19 @@ public function assemble(ContextInterface $context)
                 $propertyGenerator->setType(TypeGenerator::fromTypeString($property->getPhpType()));
             }
 
+            if ($this->options->useDefaultValues()) {
+                $defaultValue = (new ScalarDefaultProvider())($property);
+                if ($defaultValue->isSucceeded()) {
+                    $propertyGenerator
+                        ->setDefaultValue(
+                            $defaultValue->getResult(),
+                            PropertyValueGenerator::TYPE_AUTO,
+                            PropertyValueGenerator::OUTPUT_SINGLE_LINE
+                        )
+                        ->omitDefaultValue(false);
+                }
+            }
+
             $class->addPropertyFromGenerator($propertyGenerator);
         } catch (\Exception $e) {
             throw AssemblerException::fromException($e);

src/Phpro/SoapClient/CodeGenerator/Assembler/PropertyAssemblerOptions.php

@@ -14,8 +14,26 @@ class PropertyAssemblerOptions
     private bool $typeHints = true;
     private bool $docBlocks = true;
     private string $visibility = PropertyGenerator::VISIBILITY_PRIVATE;
+
+    /**
+     * When enabled, ALL properties are forced to be nullable with = null, regardless of WSDL metadata.
+     * This makes every property ?Type = null, which is useful when you want to construct
+     * objects without providing all values upfront.
+     *
+     * Takes precedence over `defaultValues`: when both are enabled, all properties become ?Type = null.
+     */
     private bool $optionalValue = false;
 
+    /**
+     * When enabled, properties receive type-appropriate default values based on WSDL metadata:
+     * scalars get their zero-value ('', 0, false, 0.0, []), nullable types get null,
+     * non-nullable complex types get no default.
+     *
+     * This differs from `optionalValue`: optionalValue forces ALL properties to ?Type = null
+     * regardless of WSDL metadata. When both are enabled, optionalValue takes precedence.
+     */
+    private bool $defaultValues = true;
+
     public static function create(): PropertyAssemblerOptions
     {
         return new self();
@@ -78,4 +96,17 @@ public function useOptionalValue(): bool
     {
         return $this->optionalValue;
     }
+
+    public function withDefaultValues(bool $withDefaultValues = true): self
+    {
+        $new = clone $this;
+        $new->defaultValues = $withDefaultValues;
+
+        return $new;
+    }
+
+    public function useDefaultValues(): bool
+    {
+        return $this->defaultValues;
+    }
 }