Api Platform generate non-required fields for id (and others)

OpenAPI specification doesn't consider readOnly fields as required by default, even if they're non-nullable in your PHP entity. Your id field is marked as readOnly: true in the schema but isn't included in the required array, which is why the TypeScript generator treats it as optional.

You could try several thing here:

1. Custom OpenAPI Decorator

Create a custom decorator to modify the OpenAPI schema generation:

// src/OpenApi/RequiredReadOnlyDecorator.php
namespace App\OpenApi;

use ApiPlatform\OpenApi\Factory\OpenApiFactoryInterface;
use ApiPlatform\OpenApi\OpenApi;
use ApiPlatform\OpenApi\Model;

final class RequiredReadOnlyDecorator implements OpenApiFactoryInterface
{
    public function __construct(
        private OpenApiFactoryInterface $decorated
    ) {}

    public function __invoke(array $context = []): OpenApi
    {
        $openApi = $this->decorated->__invoke($context);
        $schemas = $openApi->getComponents()->getSchemas();

        foreach ($schemas as $key => $schema) {
            $schemaArray = $schema->getArrayCopy();
            
            // Add readOnly fields to required array
            if (isset($schemaArray['properties'])) {
                $required = $schemaArray['required'] ?? [];
                
                foreach ($schemaArray['properties'] as $propName => $propSchema) {
                    // Add id fields and other critical readOnly fields to required
                    if (isset($propSchema['readOnly']) && $propSchema['readOnly'] === true) {
                        if ($propName === 'id' || $propName === '@id' || $propName === 'createdAt') {
                            if (!in_array($propName, $required)) {
                                $required[] = $propName;
                            }
                        }
                    }
                }
                
                if (!empty($required)) {
                    $schemaArray['required'] = array_values(array_unique($required));
                    $schemas[$key] = new \ArrayObject($schemaArray);
                }
            }
        }

        return $openApi;
    }
}

Register it in your services:

# config/services.yaml
services:
    App\OpenApi\RequiredReadOnlyDecorator:
        decorates: 'api_platform.openapi.factory'
        arguments: ['@.inner']

2. Use OpenAPI Property Attributes

Add OpenAPI schema attributes directly to your entity properties:

use ApiPlatform\Metadata\ApiProperty;

class UserMeasurement
{
    #[ORM\Id]
    #[ORM\Column(type: "uuid", unique: true)]
    #[ORM\GeneratedValue(strategy: "CUSTOM")]
    #[ORM\CustomIdGenerator(class: UuidGenerator::class)]
    #[Groups(groups: ['UserMeasurement:read'])]
    #[ApiProperty(
        openapiContext: ['required' => true],
        schema: ['type' => 'string', 'format' => 'uuid'],
        required: true
    )]
    protected UuidInterface $id;

    // ... rest of your properties
}

3. Custom Normalizer Approach

Create a custom normalizer to ensure these fields are always marked as required:

// src/Serializer/RequiredFieldsNormalizer.php
namespace App\Serializer;

use Symfony\Component\Serializer\Normalizer\NormalizerInterface;
use Symfony\Component\Serializer\Normalizer\DenormalizerInterface;
use ApiPlatform\Api\IriConverterInterface;

class RequiredFieldsNormalizer implements NormalizerInterface
{
    public function __construct(
        private NormalizerInterface $decorated,
        private IriConverterInterface $iriConverter
    ) {}

    public function normalize($object, string $format = null, array $context = []): array
    {
        $data = $this->decorated->normalize($object, $format, $context);
        
        // Ensure id fields are always present
        if (is_array($data) && method_exists($object, 'getId')) {
            $data['id'] = $data['id'] ?? $object->getId()->toString();
        }
        
        return $data;
    }

    public function supportsNormalization($data, string $format = null, array $context = []): bool
    {
        return $this->decorated->supportsNormalization($data, $format, $context);
    }
}

4. RTK Query Codegen Configuration

If you prefer to handle this on the TypeScript generation side, use the hooks configuration in your codegen config:

// rtk-query-codegen.config.ts
module.exports = {
  schemaFile: './openapi.json',
  apiFile: './src/api/baseApi.ts',
  hooks: {
    queries: {
      overrideResultType: (resultType, { operationDefinition }) => {
        // Force certain fields to be required
        if (resultType.includes('UserMeasurement')) {
          return resultType
            .replace('id?:', 'id:')
            .replace('"@id"?:', '"@id":')
            .replace('createdAt?:', 'createdAt:');
        }
        return resultType;
      }
    }
  }
};

5. Post-processing Script

Create a script to post-process the generated TypeScript files:

// scripts/fix-required-fields.ts
import * as fs from 'fs';
import * as path from 'path';

const generatedDir = './src/api/generated';
const files = fs.readdirSync(generatedDir);

const fieldsToMakeRequired = ['id', '@id', 'createdAt', 'createdBy'];

files.forEach(file => {
  if (file.endsWith('.ts')) {
    let content = fs.readFileSync(path.join(generatedDir, file), 'utf8');
    
    fieldsToMakeRequired.forEach(field => {
      const pattern = new RegExp(`"${field}"\\?:`, 'g');
      content = content.replace(pattern, `"${field}":`);
    });
    
    fs.writeFileSync(path.join(generatedDir, file), content);
  }
});

Obviously option 1 is the cleanest approach.