Configuration

The following options can be used in the configuration file.

# Customizing PHP Namespaces

Namespaces of generated PHP classes can be set globally, respectively for entities, enumerations and interfaces (if used with Doctrine Resolve Target Entity Listener option).

Example:

namespaces:
    entity: "App\ECommerce\Entity"
    enum: "App\ECommerce\Enum"
    interface: "App\ECommerce\Model"

Namespaces can also be specified for a specific type. It will take precedence over any globally configured namespace.

Example:

types:
    Thing:
        namespaces:
            class: "App\Common\Entity" # Namespace for the Thing entity (works for enumerations too)
            interface: "App\Schema\Model" # Namespace of the related interface

# Forcing a Field Type (Range)

RDF allows a property to have several types (ranges). However, the generator allows only one type by property. If not configured, it will use the first defined type. The range option is useful to set the type of a given property. It can also be used to force a type (even if not in the RDF vocabulary definition).

Example:

types:
    Brand:
        properties:
            logo: { range: "ImageObject" } # Force the range of the logo property to ImageObject (can also be a URL according to Schema.org)

    PostalAddress:
        properties:
            addressCountry: { range: "Text" } # Force the type to Text instead of Country. It will be converted to the PHP string type.

# Forcing a Field Cardinality

The cardinality of a property is automatically guessed. The cardinality option allows to override the guessed value. Supported cardinalities are:

(0..1): scalar, not required
(0..*): array, not required
(1..1): scalar, required
(1..*): array, required
(*..0)
(*..1)
(*..*)

Cardinalities are enforced by the class generator, the Doctrine ORM generator and the Symfony validation generator.

Example:

types:
    Product:
        properties:
            sku:
                cardinality: "(0..1)"

# Changing the Default Cardinality

When a cardinality has not been guessed, a default cardinality will be used instead.

By default, the cardinality (1..1) is used, but you can change it like this:

relations:
    defaultCardinality: "(1..*)"

# Adding a Custom Attribute or Modifying a Generated Attribute

You can add any custom attribute you want, or you can modify the arguments of any generated attribute, for a property, a class or even a whole vocabulary!

For instance, if you want to change the join table name and add security for a specific relation:

types:
    Organization:
        properties:
            contactPoint:
                attributes:
                    ORM\JoinTable: { name: organization_contactPoint } # Instead of organization_contact_point by default
                    ApiProperty: { security: "is_granted('ROLE_ADMIN')" }

To add a custom attribute, you also need to add it in the uses option:

uses:
    App\Attributes\MyAttribute: ~

types:
    Book:
        attributes:
            - ApiResource: { routePrefix: '/library' } # Add a route prefix for this resource
            - MyAttribute: ~
            # Note the optional usage of a hyphen list: it allows to preserve the order of attributes

# Forcing (or Enabling) a Class Parent

Override the guessed class hierarchy of a given type with this option.

Example:

types:
    ImageObject:
        parent: Thing # Force the parent to be Thing instead of CreativeWork > MediaObject
        properties: ~
    Drug:
        parent: ~ # Enable the class hierarchy for this type

# Forcing a Class to be Abstract

Force a class to be (or to not be) abstract. By default, it will be guessed, depending on the class hierarchy and if the class is used in a relation.

Example:

types:
    Person:
        abstract: true

# Define API Platform Operations

API Platform operations can be added this way:

types:
    Person:
        operations:
            Get: ~
            GetCollection:
                routeName: get_person_collection

# Forcing a Nullable Property

Force a property to be (or to not be) nullable.

By default, this option is null: the cardinality will be used to determine the nullability. If no cardinality is found, it will be true.

Example:

    Person:
        properties:
            name: { nullable: false }

The #[Assert\NotNull] constraint is automatically added.

<?php

/**
 * The name of the item.
 */
#[ORM\Column]
#[Assert\NotNull]
private string $name;

# Forcing a Unique Property

Force a property to be (or to not be) unique.

By default, this option is false.

Example:

    Person:
        properties:
            email: { unique: true }

Output:

<?php
// api/src/Entity/Person.php
namespace App\Entity;

use Doctrine\ORM\Mapping as ORM;
use Symfony\Component\Validator\Constraints as Assert;
use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
use Doctrine\ORM\Mapping as ORM;

/**
 * A person (alive, dead, undead, or fictional).
 *
 * @see https://schema.org/Person
 */
#[ORM\Entity]
#[ApiResource(types: ['https://schema.org/Person'])]
#[UniqueEntity('email')]
class Person
{
    /**
     * Email address.
     *
     * @see https://schema.org/email
     */
    #[ORM\Column]
    #[Assert\Email]
    private string $email;

    // ...
}

# Making a Property Read-Only

A property can be marked read-only with the following configuration:

    Person:
        properties:
            email: { writable: false }

In such case, no mutator method will be generated.

# Making a Property Write-Only

A property can be marked write-only with the following configuration:

    Person:
        properties:
            email: { readable: false }

In this case, no getter method will be generated.

# Forcing an Embeddable Class to be Embedded

Force an embeddable class to be embedded.

Example:

    QuantitativeValue:
        embeddable: true
    Product:
        properties:
            weight: { range: "QuantitativeValue", embedded: true }

Output:

<?php
// api/src/Entity/Product.php
namespace App\Entity;

use ApiPlatform\Metadata\ApiProperty;
use ApiPlatform\Metadata\ApiResource;
use Doctrine\ORM\Mapping as ORM;

/**
 * Any offered product or service.
 *
 * @see https://schema.org/Product Documentation on Schema.org
 */
#[ORM\Entity]
#[ApiResource(types: ['https://schema.org/Product'])]
#[UniqueEntity('gtin13s')]
class Product
{
    /**
     * The weight of the product or person.
     *
     * @see https://schema.org/weight
     */
    #[ORM\Embedded(class: QuantitativeValue::class)]
    #[ApiProperty(iri: 'https://schema.org/weight')]
    private ?QuantitativeValue $weight = null;

    // ...
}

# Skipping Accessor Method Generation

It’s possible to skip the generation of accessor methods. This is particularly useful combined with the visibility: public option.

To skip the generation of accessor methods, use the following config:

accessorMethods: false

# Using Fluent Mutator Methods

If you want to generate fluent mutator methods, like this:

public function setName(?string $name): self
{
    $this->name = $name;

    return $this;
}

Use the following config:

fluentMutatorMethods: true

# Disabling the `id` Generator

By default, the generator adds a property called id not provided by Schema.org. This is useful when generating an entity for use with an ORM or an ODM but not when generating DTOs. This behavior can be disabled with the following setting:

id:
    generate: false

# Generating UUIDs

It’s also possible to let the DBMS generate UUIDs instead of auto-incremented integers:

id:
    generationStrategy: uuid

# User-submitted UUIDs

To manually set a UUID instead of letting the DBMS generate it, use the following config:

id:
    generationStrategy: uuid
    writable: true

# Generating Custom IDs

With this configuration option, an $id property of type string and the corresponding getters and setters will be generated, but the DBMS will not generate anything. The ID must be set manually.

id:
    generationStrategy: none

# Disabling Usage of Doctrine Collections

By default, the generator uses classes provided by the Doctrine Collections library to store collections of entities. This is useful (and required) when using Doctrine ORM or Doctrine MongoDB ODM. This behavior can be disabled (to fall back to standard arrays) with the following setting:

doctrine:
    useCollection: false

# Changing the Field Visibility

Generated fields have a private visibility and are exposed through getters and setters. The default visibility can be changed with the fieldVisibility option.

Example:

fieldVisibility: "protected"

# Generating `Assert\Type` Attributes

It’s possible to automatically generate Symfony validator’s #[Assert\Type] attributes using the following config:

validator:
    assertType: true

# Forcing Doctrine Inheritance Mapping Attribute

The generator is able to handle inheritance in a smart way:

If a class has children and is referenced by a relation, it will generate an inheritance mapping strategy with #[InheritanceType] (configurable, see below), #[DiscriminatorColumn] (#[DiscriminatorField] for ODM) and #[DiscriminatorMap]. The discriminator map will be filled with all possible values.
If a class has children but is not referenced by a relation, it will generate a mapped superclass (#[MappedSuperclass]). If this mapped superclass defines relations and is used by multiple children, the generator will add #[AssociationOverride] attributes to them (see the related Doctrine documentation), thanks to the special DoctrineOrmAssociationOverrideAttributeGenerator.
If a class has no child, an #[Entity] (or #[Document] for ODM) attribute is used.

If this behaviour does not suit you, the inheritance attribute can be forced in the following way:

doctrine:
    inheritanceType: SINGLE_TABLE # Default: JOINED
    inheritanceAttributes:
        CustomInheritanceAttribute: []

# Interfaces and Doctrine Resolve Target Entity Listener

ResolveTargetEntityListener is a feature of Doctrine to keep modules independent. It allows to specify interfaces and abstract classes in relation mappings.

If you set the option useInterface to true, the generator will generate an interface corresponding to each generated entity and will use them in relation mappings.

To let the schema generator generate the mapping file usable with Symfony, add the following to your config file:

doctrine:
    resolveTargetEntityConfigPath: path/to/doctrine.xml

The default mapping file format is XML, but you can change it to YAML with the following option:

doctrine:
    resolveTargetEntityConfigPath: path/to/doctrine.yaml
    resolveTargetEntityConfigType: YAML # Supports XML & YAML

# Doctrine Resolve Target Entity Config Type

By default, the mapping file is in XML. If you want to have a YAML file, add the following:

doctrine:
    resolveTargetEntityConfigPath: path/to/doctrine.yaml
    resolveTargetEntityConfigType: yaml

# Custom Schemas

The generator can use your own schema definitions. They must be written in RDF/XML and follow the format of the Schema.org’s definition. This is useful to document your Schema.org extensions and use them to generate the PHP data model of your application.

Example:

vocabularies:
    - https://github.com/schemaorg/schemaorg/raw/main/data/releases/13.0/schemaorg-current-https.rdf
    - http://example.com/data/myschema.rdf # Additional types

You can also use any other vocabulary. Check the Linked Open Vocabularies to find one fitting your needs.

For instance, to generate a data model from the Video Game Ontology, use the following config file:

vocabularies:
    - http://vocab.linkeddata.es/vgo/GameOntologyv3.owl # The URL of the vocabulary definition

types:
    Session:
        vocabularyNamespace: http://purl.org/net/VideoGameOntology#

  # ...

# All Types, Resolve Types and Exclude

If you use multiple vocabularies, and you need to generate all types for some ones, only generate types when they are used for some others and exclude some types, you can do so with this kind of configuration:

vocabularies:
    # Schema.org classes will only be generated when one of its type is used in the other vocabularies.
    - { uri: 'https://schema.org/version/latest/schemaorg-current-https.rdf', format: null, allTypes: false }
    - http://vocab.linkeddata.es/vgo/GameOntologyv3.owl

allTypes: true # Generate all types by default for vocabularies
resolveTypes: true # Resolve types in other vocabularies

types:
    GameEvent:
        exclude: true # Exclude the GameEvent type

# Checking GoodRelation Compatibility

If the checkIsGoodRelations option is set to true, the generator will emit a warning if an encountered property is not par of the GoodRelations schema.

This is useful when generating e-commerce data models.

# Author PHPDoc

Add a @author PHPDoc annotation to class DocBlock.

Example:

author: "Kévin Dunglas <[email protected]>"

# PHP File Header

Prepend all generated PHP files with a custom comment.

Example:

header: |
    /*
     * This file is part of the Ecommerce package.
     *
     * (c) Kévin Dunglas <[email protected]>
     *
     * For the full copyright and license information, please view the LICENSE
     * file that was distributed with this source code.
     */

# Disabling Generators and Creating Custom Ones

By default, all generators except DoctrineMongoDBAttributeGenerator are enabled. You can specify the list of generators to use with the annotationGenerators and attributeGenerators option.

Example (enabling only the PHPDoc generator):

annotationGenerators:
    - ApiPlatform\SchemaGenerator\AnnotationGenerator\PhpDocAnnotationGenerator
attributeGenerators: []

You can write your own generators by implementing the AnnotationGeneratorInterface or AttributeGeneratorInterface. The AbstractAnnotationGenerator or AbstractAttributeGenerator provides helper methods useful when creating your own generators.

Enabling a custom attribute generator and the PHPDoc generator:

annotationGenerators:
    - ApiPlatform\SchemaGenerator\AnnotationGenerator\PhpDocAnnotationGenerator
attributeGenerators
    - Acme\Generators\MyGenerator

# Full Configuration Reference

openApi:
    file:                 null

# RDF vocabularies
vocabularies:

    # Prototype
    uri:

        # RDF vocabulary to use
        uri:                  ~ # Example: 'https://schema.org/version/latest/schemaorg-current-https.rdf'

        # RDF vocabulary format
        format:               null # Example: rdfxml

        # Generate all types for this vocabulary, even if an explicit configuration exists. If allTypes is enabled globally, it can be disabled for this particular vocabulary
        allTypes:             null

        # Attributes (merged with generated attributes)
        attributes:           []

# Namespace of the vocabulary to import
vocabularyNamespace:  'https://schema.org/' # Example: 'http://www.w3.org/ns/activitystreams#'

# Relations configuration
relations:

    # OWL relation URIs containing cardinality information in the GoodRelations format
    uris:                 # Example: 'https://archive.org/services/purl/goodrelations/v1.owl'

        # Default:
        - https://archive.org/services/purl/goodrelations/v1.owl

    # The default cardinality to use when it cannot be extracted
    defaultCardinality:   (1..1) # One of "(0..1)"; "(0..*)"; "(1..1)"; "(1..*)"; "(*..0)"; "(*..1)"; "(*..*)"

# Debug mode
debug:                false

# Use old API Platform attributes (API Platform < 2.7)
apiPlatformOldAttributes: false

# IDs configuration
id:

    # Automatically add an ID field to entities
    generate:             true

    # The ID generation strategy to use ("none" to not let the database generate IDs).
    generationStrategy:   auto # One of "auto"; "none"; "uuid"; "mongoid"

    # Is the ID writable? Only applicable if "generationStrategy" is "uuid".
    writable:             false

# Generate interfaces and use Doctrine's Resolve Target Entity feature
useInterface:         false

# Emit a warning if a property is not derived from GoodRelations
checkIsGoodRelations: false

# A license or any text to use as header of generated files
header:               null # Example: '// (c) Kévin Dunglas <[email protected]>'

# PHP namespaces
namespaces:

    # The global namespace's prefix
    prefix:               null # Example: App\

    # The namespace of the generated entities
    entity:               App\Entity # Example: App\Entity

    # The namespace of the generated enumerations
    enum:                 App\Enum # Example: App\Enum

    # The namespace of the generated interfaces
    interface:            App\Model # Example: App\Model

# Custom uses (for instance if you use a custom attribute)
uses:

    # Prototype
    name:

        # Name of this use
        name:                 ~ # Example: App\Attributes\MyAttribute

        # The alias to use for this use
        alias:                null

# Doctrine
doctrine:

    # Use Doctrine's ArrayCollection instead of standard arrays
    useCollection:        true

    # The Resolve Target Entity Listener config file path
    resolveTargetEntityConfigPath: null

    # The Resolve Target Entity Listener config file type
    resolveTargetEntityConfigType: XML # One of "XML"; "yaml"

    # Doctrine inheritance attributes (if set, no other attributes are generated)
    inheritanceAttributes: []

    # The inheritance type to use when an entity is referenced by another and has child
    inheritanceType:      JOINED # One of "JOINED"; "SINGLE_TABLE"; "SINGLE_COLLECTION"; "TABLE_PER_CLASS"; "COLLECTION_PER_CLASS"; "NONE"

    # Maximum length of any given database identifier, like tables or column names
    maxIdentifierLength:  63

# Symfony Validator Component
validator:

    # Generate @Assert\Type annotation
    assertType:           false

# The value of the phpDoc's @author annotation
author:               false # Example: 'Kévin Dunglas <[email protected]>'

# Visibility of entities fields
fieldVisibility:      private # One of "private"; "protected"; "public"

# Set this flag to false to not generate getter, setter, adder and remover methods
accessorMethods:      true

# Set this flag to true to generate fluent setter, adder and remover methods
fluentMutatorMethods: false
rangeMapping:

    # Prototype
    name:                 ~

# Generate all types, even if an explicit configuration exists
allTypes:             false

# If a type is present in a vocabulary but not explicitly imported (types) or if the vocabulary is not totally imported (allTypes), it will be generated
resolveTypes:         false

# Types to import from the vocabulary
types:

    # Prototype
    id:

        # Exclude this type, even if "allTypes" is set to true"
        exclude:              false

        # Namespace of the vocabulary of this type (defaults to the global "vocabularyNamespace" entry)
        vocabularyNamespace:  null # Example: 'http://www.w3.org/ns/activitystreams#'

        # Is the class abstract? (null to guess)
        abstract:             null

        # Is the class embeddable?
        embeddable:           false

        # Type namespaces
        namespaces:

            # The namespace for the generated class (override any other defined namespace)
            class:                null

            # The namespace for the generated interface (override any other defined namespace)
            interface:            null

        # Attributes (merged with generated attributes)
        attributes:           []

        # The parent class, set to false for a top level class
        parent:               false

        # If declaring a custom class, this will be the class from which properties type will be guessed
        guessFrom:            Thing

        # Operations for the class
        operations:           []

        # Import all existing properties
        allProperties:        false

        # Properties of this type to use
        properties:

            # Prototype
            id:

                # Exclude this property, even if "allProperties" is set to true"
                exclude:              false

                # The property range
                range:                null # Example: Offer
                cardinality:          unknown # One of "(0..1)"; "(0..*)"; "(1..1)"; "(1..*)"; "(*..0)"; "(*..1)"; "(*..*)"; "unknown"

                # Symfony Serialization Groups
                groups:               []

                # The doctrine mapped by attribute
                mappedBy:             null # Example: partOfSeason

                # The doctrine inversed by attribute
                inversedBy:           null # Example: episodes

                # Is the property readable?
                readable:             true

                # Is the property writable?
                writable:             true

                # Is the property nullable? (if null, cardinality will be used: will be true if no cardinality found)
                nullable:             null

                # Is the property required?
                required:             true

                # The property unique
                unique:               false

                # Is the property embedded?
                embedded:             false

                # Attributes (merged with generated attributes)
                attributes:           []

# Annotation generators to use
annotationGenerators:

    # Default:
    - ApiPlatform\SchemaGenerator\AnnotationGenerator\PhpDocAnnotationGenerator

# Attribute generators to use
attributeGenerators:

    # Defaults:
    - ApiPlatform\SchemaGenerator\AttributeGenerator\DoctrineOrmAttributeGenerator
    - ApiPlatform\SchemaGenerator\AttributeGenerator\DoctrineOrmAssociationOverrideAttributeGenerator
    - ApiPlatform\SchemaGenerator\AttributeGenerator\ApiPlatformCoreAttributeGenerator
    - ApiPlatform\SchemaGenerator\AttributeGenerator\ConstraintAttributeGenerator
    - ApiPlatform\SchemaGenerator\AttributeGenerator\ConfigurationAttributeGenerator

# Directories for custom generator twig templates
generatorTemplates:   []

Configuration

Table of Contents

# Customizing PHP Namespaces

# Forcing a Field Type (Range)

# Forcing a Field Cardinality

# Changing the Default Cardinality

# Adding a Custom Attribute or Modifying a Generated Attribute

# Forcing (or Enabling) a Class Parent

# Forcing a Class to be Abstract

# Define API Platform Operations

# Forcing a Nullable Property

# Forcing a Unique Property

# Making a Property Read-Only

# Making a Property Write-Only

# Forcing an Embeddable Class to be Embedded

# Skipping Accessor Method Generation

# Using Fluent Mutator Methods

# Disabling the id Generator

# Generating UUIDs

# User-submitted UUIDs

# Generating Custom IDs

# Disabling Usage of Doctrine Collections

# Changing the Field Visibility

# Generating Assert\Type Attributes

# Forcing Doctrine Inheritance Mapping Attribute

# Interfaces and Doctrine Resolve Target Entity Listener

# Doctrine Resolve Target Entity Config Type

# Custom Schemas

# All Types, Resolve Types and Exclude

# Checking GoodRelation Compatibility

# Author PHPDoc

# PHP File Header

# Disabling Generators and Creating Custom Ones

# Full Configuration Reference

# Disabling the `id` Generator

# Generating `Assert\Type` Attributes