What does it do? 

Structured data is essential for search engine optimisation nowadays. This extension allows the easy integration of structured data based on the schema.org vocabulary on a TYPO3 website. A good introduction to the topic is provided by Google: Understand how structured data works.

The defined structured data is embedded on a web page in JSON-LD markup and can be checked with the Schema Markup Validator and Google's Rich Results Test. The JSON-LD generated by this extension can also be reviewed in the Admin Panel.

The schema.org vocabulary 

Schema.org is a set of extensible schemas that enables webmasters to embed structured data on their web pages for use by search engines and other applications. The vocabulary is divided into different sections:

• The core section provides all default types and properties, like Person or Organization.
• The pending section is a staging area for work-in-progress terms which have yet to be accepted into the core vocabulary. Pending terms are subject to change and should be used with caution. On the schema.org website they are displayed in a blue colour.
• The auto section provides additional terms related to auto.
• The bib section provides additional terms related to bibliography.
• The health-lifesci section provides additional terms related to health and lifesciences.

The schema.org vocabulary is evolving, several times a year a new version is released. The TYPO3 extensions are updated when relevant changes are made to the according vocabulary. The classes for the type models and view helpers are generated by the schema-generator library.

You can browse through a list of types available in a TYPO3 installation.

Release management 

This extension uses semantic versioning which basically means for you, that

• Bugfix updates (for example, 1.0.0 => 1.0.1) just includes small bug fixes or security relevant stuff without breaking changes.
• Minor updates (for example, 1.0.0 => 1.1.0) includes new features and smaller tasks without breaking changes.
• Major updates (for example, 1.0.0 => 2.0.0) breaking changes which can be refactorings, features or bug fixes.

The changes between the different versions can be found in the changelog.

Adjustment of the web page type 

As an editor you have the possibility to adjust the type of every single web page for the schema markup. The default value is the most generic one: WebPage.

You'll find the field in the page properties under the SEO tab (with installed seo system extension) or under the Metadata tab (if the seo system extension is not installed):

If no value is selected, WebPage is assumed.

Available web page types 

WebPage is the most common web page type, the other types are more specific:

Extension configuration 

To configure the extension, go to Admin Tools > Settings > Extension Configuration and click on the Configure extensions button. Open the schema configuration:

Content Object (cObject) SCHEMA 

The extension provides the cObject SCHEMA. The cObject itself will not display anything. Instead it will add configured types to the global schema output.

A small example:

page = PAGE
page.10 = SCHEMA
page.10 {
   type = WebSite
   properties {
      name.field = seo_title // title
      description.field = description
   }
}

That will add an element of type WebSite to schema. It will consist of the property name as well as description. The name property will be filled from the seo_title field, falling back to the title field.

{
   "@context": "https://schema.org/",
   "@type": "Event",
   "offers": [{
      "@type": "Offer",
      "name": "Ticket 1",
      "price": "80",
      "priceCurrency": "EUR"
   }, {
      "@type": "Offer",
      "name": "Ticket 2",
      "price": "120",
      "priceCurrency": "EUR"
   }]
}

Introduction 

With the help of <schema:type> view helpers you can define schema markup in Fluid templates. This can be helpful if you can't use the API, for example, in third-party extensions.

Each type in the schema.org vocabulary is mapped into an according view helper. The properties of a type are available as view helper arguments. As you will see in the example, you can also nest view helpers into each other.

There are currently over 600 view helpers available.

<schema:type> view helpers 

Let's start with a simple example. It's the same markup about John Smith as in the API reference, so you can compare the differences.

Imagine you describe a person on a plugin's detail page that you want to enrich with structured markup:

<schema:type.person
   -id="https://example.org/#person-42"
   givenName="John"
   familyName="Smith"
   gender="https://schema.org/Male"
>
   <schema:type.event
      -as="performerIn"
      name="Fancy Event"
      image="https://example.org/event.png"
      url="https://example.org/"
      isAccessibleForFree="true"
   >
      <schema:property -as="sameAs" value="https://mastodon.social/@fancy-event"/>
      <schema:property -as="sameAs" value="https://pixelfed.social/@fancy-event"/>
   </schema:type.event>
</schema:type.person>

Every type view helper starts with <schema:type.xxx> where xxx is the lower camel case variant of the schema.org type name.

The according properties (like givenName and familyName) are attributes. You can find a list of all available properties for a specific type on the schema.org page, for example, for the person.

In the example, there are two attributes that begin with a -. They are explained in detail in the chapter Special attributes.

As you can see, the value true (and false accordingly) can be used. They are mapped later to the schema types https://schema.org/True and https://schema.org/False.

Please also recognise the <schema:property> view helper. With this view helper you can pass more than one string value to the according type.

You can also use the default Fluid view helpers:

<schema:type.blogPosting
   -isMainEntityOfWebPage="1"
   headline="{data.title}"
   description="{data.description}"
   datePublished="{f:format.date(format:'Y-m-d', date: data.publishDate)}"
>
   <f:if condition="{data.lastUpdated}">
       <schema:property -as="dateModified" value="{f:format.date(format:'Y-m-d', date: data.lastUpdated)}"/>
   </f:if>
</schema:type.blogPosting>

<schema:multipleType> view helper 

You can also add a multiple type node:

<schema:multipleType
   -id="https://example.org/#my-product-and-service"
   types="Product,Service"
   properties="{
      name: 'My product and service',
      manufacturer: 'Acme Ltd.',
      provider: 'Acme Ltd.'
   }"
/>

In the types argument the types are delimited by commas. Add in the properties argument the name/value pairs of the according properties. Here you can mix the properties from the defined types. The special properties -as, -id and -isMainEntityOfWebPage can also be used as described above.

The example results in the following JSON-LD:

{
   "@context": "https://schema.org/",
   "@type": ["Product", "Service"],
   "@id": "https://example.org/#my-product-and-service",
   "manufacturer": "Acme Ltd.",
   "name": "My product and service",
   "provider": "Acme Ltd."
}

You can also use the PropertyViewHelper to add properties to a multiple type instead the properties argument:

<schema:multipleType
   -id="https://example.org/#my-product-and-service"
   types="Product,Service"
>
   <schema:property -as="name" value="My product and service"/>
   <schema:property -as="manufacturer" value="Acme Ltd."/>
   <schema:property -as="provider" value="Acme Ltd."/>
</schema:multipleType>

<schema:nodeIdentifier> view helper 

Sometimes it is useful to reference a node with just the ID. For this case the <schema:nodeIdentifier> view helper is available:

<f:variable name="identifier1" value="{schema:nodeIdentifier(id: 'https://example.org/#john-smith')}"/>
<f:variable name="identifier2" value="{schema:nodeIdentifier(id: 'https://example.org/#sarah-jane-smith')}"/>
<schema:type.person name="John Smith" -id="{identifier1}" knows="{identifier2}"/>
<schema:type.person name="Sarah Jane Smith" -id="{identifier2}" knows="{identifier1}"/>

This generates the following JSON-LD:

{
   "@context": "https://schema.org/",
   "@graph": [
      {
         "@type": "Person",
         "@id": "https://example.org/#john-smith",
         "name": "John Smith",
         "knows": {
            "@id": "https://example.org/#sarah-jane-smith"
         }
      },
      {
         "@type": "Person",
         "@id": "https://example.org/#sarah-jane-smith",
         "name": "Sarah Jane Smith",
         "knows": {
            "@id": "https://example.org/#john-smith"
         }
      }
   ]
}

The view helper has only one attribute which is required:

<schema:blankNodeIdentifier> view helper 

Sometimes it is not necessary (or possible) to define a globally unique ID with an IRI. For these cases you can use a blank node identifier:

<f:variable name="blankIdentifier1" value="{schema:blankNodeIdentifier()}"/>
<f:variable name="blankIdentifier2" value="{schema:blankNodeIdentifier()}"/>
<schema:type.person name="John Smith" -id="{blankIdentifier1}" knows="{blankIdentifier2}"/>
<schema:type.person name="Sarah Jane Smith" -id="{blankIdentifier2}" knows="{blankIdentifier1}"/>

This generates the following JSON-LD:

{
   "@context": "https://schema.org/",
   "@graph": [
      {
         "@type": "Person",
         "@id": "_:b0",
         "name": "John Smith",
         "knows": {
            "@id": "_:b1"
         }
      },
      {
         "@type": "Person",
         "@id": "_:b1",
         "name": "Sarah Jane Smith",
         "knows": {
            "@id": "_:b0"
         }
      }
   ]
}

The view helper has no arguments.

You can find more information in the Blank node identifier API section.

<schema:property> view helper 

You can only set one string value in the argument of a type view helper, but sometimes it is necessary to add more than one value to it. There comes the property view helper into the game:

<schema:type.corporation
   name="Acme Ltd."
   image="https://example.org/logo.png"
   url="https://example.org/"
>
   <schema:property -as="sameAs" value="https://mastodon.social/@acme"/>
   <schema:property -as="sameAs" value="https://pixelfed.social/@acme"/>
</schema:type.corporation>

You can use as much property view helpers as you like for the same property. If you prefer, you can combine the view helpers as follows:

<schema:type.corporation>
   <schema:property -as="name" value="Acme Ltd."/>
   <schema:property -as="image" value="https://example.org/logo.png"/>
   <schema:property -as="url" value="https://example.org/"/>
   <schema:property -as="sameAs" value="https://mastodon.social/@acme"/>
   <schema:property -as="sameAs" value="https://pixelfed.social/@acme"/>
</schema:type.corporation>

The <schema:property> view helper accepts two argument, both are required.

<schema:breadcrumb> View Helper 

This view helper is described in-depth in the chapter View helper <schema:breadcrumb>.

Using the XML schema (XSD) in your code editor 

It is possible to assist your code editor on suggesting the tag name and the possible attributes:

Just add the schema namespace to the root element of your Fluid template:

<html
    xmlns:f="http://typo3.org/ns/TYPO3/CMS/Fluid/ViewHelpers"
    xmlns:schema="http://typo3.org/ns/Brotkrueml/Schema/ViewHelpers"
    schema:schemaLocation="https://brot.krue.ml/schemas/schema-1.9.0.xsd"
    data-namespace-typo3-fluid="true"
>

The relevant parts are the namespace declaration ( xmlns:schema="http://typo3.org/ns/Brotkrueml/Schema/ViewHelpers") and the schema:schemaLocation attribute which points to the recent XSD definition.

You can also import the XSD file into your favorite IDE after downloading it from the following URL: https://brot.krue.ml/schemas/schema-1.9.0.xsd.

Configuration 

To allow non-admin users to access the schema information in the Admin Panel, you have to configure it in the corresponding user TSconfig:

admPanel {
   enable {
      ext-schema = 1
   }
}

Override translations 

You can override translations in the usual way. Have a look into the according TYPO3 documentation: Custom translations.

However, if you feel that a translation provided by the translation server could be improved, please suggest an alternative on Crowdin.

Introduction 

The structured markup can be generated in two ways:

• using the API
• with view helpers in Fluid templates

Each type in the schema.org vocabulary corresponds to a PHP model that provides the available properties. There is also a view helper for each type that makes it easy to integrate the data into your website via a Fluid template.

Attention should be paid to the following points:

• A web page can be characterised by different schema.org types as outlined in this chapter. The WebPage type is set automatically if the corresponding configuration option is set. But it can always overridden manually with the desired type and properties. The chapter The WebPage type is dedicated to this topic.
• A breadcrumb does not only help the user to recognise the location of a particular page on the website. It is also helpful for search engines to understand the structure of your website. Google honors the website operator for using the breadcrumb schema markup on a page: It will be shown in the search result snippet.
• The main entity of a web page indicates the primary entity. It can be set separately from a WebPage.

Quick dive-in 

The schema.org vocabulary consists of many types, like Person, Organization, Product, and so on. They are written with an upper letter at the beginning of the term.

Each type has several properties which characterise the specific type, like givenName or lastName for a Person. The properties start with a lower letter at the beginning in the vocabulary.

The most generic type is Thing. Each other type inherits the properties from one or more other types, e.g: Corporation is a specific type for Organization and defines a new property. Organization itself is a specific type of Thing and inherits the properties of Thing and defines many more properties characterising this type.

You can retrieve the information about a type or property from the URL https://schema.org/ followed by the term name. (for example, https://schema.org/Person) or the name of the property (for example, https://schema.org/givenName).

<?php

declare(strict_types=1);

namespace MyVendor\MyExtension\Controller;

use Brotkrueml\Schema\Type\TypeFactory;

final class MyController
{
    public function __construct(
        private readonly TypeFactory $typeFactory,
    ) {}

    public function doSomething(): void
    {
        // ...

        $thing = $this->typeFactory->create('Thing');
        $thing->setProperty('name', 'A thing');

        // ...
    }
}

<?php

declare(strict_types=1);

namespace MyVendor\MyExtension\Controller;

use Brotkrueml\Schema\Manager\SchemaManager;
use Brotkrueml\Schema\Type\TypeFactory;

final class MyController
{
    public function __construct(
        private readonly SchemaManager $schemaManager,
        private readonly TypeFactory $typeFactory,
    ) {}

    public function doSomething(): void
    {
        // ...

        $thing = $this->typeFactory->create('Thing');
        $thing->setProperty('name', 'A thing');

        $this->schemaManager->addType($thing);

        // ...
    }
}

<schema:type.thing name="A thing"/>

Introduction 

With the extension's API you can define the structured markup with PHP. For example, create a class which gets an Extbase model as input and defines the markup. Then instantiate the class in an action of your controller.

Each type model class in the PHP namespace \Brotkrueml\Schema\Model\Type inherits from the abstract class \Brotkrueml\Schema\Core\Model\AbstractType which defines methods to set and get the properties of a model.

There are currently over 600 models available.

Starting with examples 

<?php

declare(strict_types=1);

namespace MyVendor\MyExtension\Controller;

use Brotkrueml\Schema\Type\TypeFactory;

final class MyController
{
    public function __construct(
        private readonly TypeFactory $typeFactory,
    ) {}

    public function doSomething(): void
    {
        // ...

        $person = $this->typeFactory->create('Person');

        // ...
    }
}

<?php

declare(strict_types=1);

namespace MyVendor\MyExtension\Controller;

use Brotkrueml\Schema\Model\Enumeration\GenderType;
use Brotkrueml\Schema\Type\TypeFactory;

final class MyController
{
    public function __construct(
        private readonly TypeFactory $typeFactory,
    ) {}

    public function doSomething(): void
    {
        // ...

        $person = $this->typeFactory->create('Person');
        $person
            ->setId('https://example.org/#person-42')
            ->setProperty('givenName', 'John')
            ->setProperty('familyName', 'Smith')
            ->setProperty('gender', GenderType::Male);

        // ...
    }
}

<?php

declare(strict_types=1);

namespace MyVendor\MyExtension\Controller;

use Brotkrueml\Schema\Type\TypeFactory;

final class MyController
{
    public function __construct(
        private readonly TypeFactory $typeFactory,
    ) {}

    public function doSomething(): void
    {
        // ...

        $event = $this->typeFactory->create('Event')
            ->setProperty('name', 'Fancy Event')
            ->setProperty('image', 'https:/example.org/event.png')
            ->setProperty('url', 'https://example.org/')
            ->setProperty('isAccessibleForFree', true)
            ->setProperty('sameAs', 'https://mastodon.social/@fancy-event')
            ->addProperty('sameAs', 'https://pixelfed.social/@fancy-event')
        ;

        // ...
    }
}

<?php

declare(strict_types=1);

namespace MyVendor\MyExtension\Controller;

use Brotkrueml\Schema\Type\TypeFactory;

final class MyController
{
    public function __construct(
        private readonly TypeFactory $typeFactory,
    ) {}

    public function doSomething(): void
    {
        // ...

        $person = $this->typeFactory->create('Person');
        $event = $this->typeFactory->create('Event');

        // ...

        $person->setProperty('performerIn', $event);

        // ...
    }
}

<?php

declare(strict_types=1);

namespace MyVendor\MyExtension\Controller;

use Brotkrueml\Schema\Manager\SchemaManager;
use Brotkrueml\Schema\Type\TypeFactory;

final class MyController
{
    public function __construct(
        private readonly SchemaManager $schemaManager,
        private readonly TypeFactory $typeFactory,
    ) {}

    public function doSomething(): void
    {
        // ...

        $person = $this->typeFactory->create('Person');

        // ...

        $this->schemaManager->addType($person);

        // ...
    }
}

{
   "@context": "https://schema.org/",
   "@type": "Person",
   "@id": "https://example.org/#person-42",
   "givenName": "John",
   "familyName": "Smith",
   "gender": "https://schema.org/Male",
   "performerIn": {
      "@type": "Event",
      "name": "Fancy Event",
      "image": "https://example.org/event.png",
      "url": "https://example.org",
      "isAccessibleForFree": "https://schema.org/True",
      "sameAs": ["https://mastodon.social/@fancy-event", "https://pixelfed.social/@fancy-event"]
   }
}

<?php

declare(strict_types=1);

namespace MyVendor\MyExtension\Controller;

use Brotkrueml\Schema\Manager\SchemaManager;
use Brotkrueml\Schema\Type\TypeFactory;

final class MyController
{
    public function __construct(
        private readonly SchemaManager $schemaManager,
        private readonly TypeFactory $typeFactory,
    ) {}

    public function doSomething(): void
    {
        // ...

        $productAndService = $this->typeFactory->create('Product', 'Service');
        $productAndService
            ->setId('https://example.org/#my-product-and-service')
            ->setProperty('name', 'My product and service')
            ->setProperty('manufacturer', 'Acme Ltd.') // from Product
            ->setProperty('provider', 'Acme Ltd.') // from Service
        ;
        $this->schemaManager->addType($productAndService);

        // ...
    }
}

{
   "@context": "https://schema.org/",
   "@type": ["Product", "Service"],
   "@id": "https://example.org/#my-product-and-service",
   "manufacturer": "Acme Ltd.",
   "name": "My product and service",
   "provider": "Acme Ltd."
}

{
   "@context": "https://schema.org/",
   "@type": "Person",
   "@id": "https://example.org/#john-smith",
   "name": "John Smith",
   "knows": {
      "@type": "Person",
      "name": "Sarah Jane Smith",
      "knows": { "@id": "https://example.org/#john-smith" }
   }
}

<?php

declare(strict_types=1);

namespace MyVendor\MyExtension\Controller;

use Brotkrueml\Schema\Core\Model\NodeIdentifier;
use Brotkrueml\Schema\Manager\SchemaManager;
use Brotkrueml\Schema\Type\TypeFactory;

final class MyController
{
    public function __construct(
        private readonly SchemaManager $schemaManager,
        private readonly TypeFactory $typeFactory,
    ) {}

    public function doSomething(): void
    {
        // ...

        $johnSmithId = new NodeIdentifier('https://example.org/#john-smith');

        $person1 = $this->typeFactory->create('Person');
        $person1->setId($johnSmithId);
        $person1->setProperty('name', 'John Smith');

        $person2 = $this->typeFactory->create('Person');
        $person2->setProperty('name', 'Sarah Jane Smith');
        $person2->setProperty('knows', $johnSmithId);

        $person1->setProperty('knows', $person2);

        $this->schemaManager->addType($person1, $person2);

        // ...
    }
}

<?php

declare(strict_types=1);

namespace MyVendor\MyExtension\Controller;

use Brotkrueml\Schema\Core\Model\BlankNodeIdentifier;
use Brotkrueml\Schema\Manager\SchemaManager;
use Brotkrueml\Schema\Type\TypeFactory;

final class MyController
{
    public function __construct(
        private readonly SchemaManager $schemaManager,
        private readonly TypeFactory $typeFactory,
    ) {}

    public function doSomething(): void
    {
        // ...

        $johnSmithId = new BlankNodeIdentifier();

        $person1 = $this->typeFactory->create('Person');
        $person1->setId($johnSmithId);
        $person1->setProperty('name', 'John Smith');

        $person2 = $this->typeFactory->create('Person');
        $person2->setProperty('name', 'Sarah Jane Smith');
        $person2->setProperty('knows', $johnSmithId);

        $person1->setProperty('knows', $person2);

        $this->schemaManager->addType($person1, $person2);

        // ...
    }
}

{
   "@context": "https://schema.org/",
   "@type": "Person",
   "@id": "_:b0",
   "name": "John Smith",
   "knows": {
      "@type": "Person",
      "name": "Sarah Jane Smith",
      "knows": { "@id": "_:b0" }
   }
}

The model in-depth 

Each type model, like Thing, Person or Event, must implement the interfaces \Brotkrueml\Schema\Core\Model\NodeIdentifierInterface and \Brotkrueml\Schema\Core\Model\TypeInterface. For convenience, a type model can also extend the abstract class \Brotkrueml\Schema\Core\Model\AbstractType which implements every required method.

Each enumeration type, like GenderType, ItemAvailability or OrderStatus, implement the interface \Brotkrueml\Schema\Core\Model\EnumerationInterface.

One interface is available to "mark" a type model class as a "special type". It does not require the implementation of additional methods:

• \Brotkrueml\Schema\Core\Model\WebPageTypeInterface for a web page type.

These interfaces can be useful when you want to extend the vocabulary.

Each type model delivered with this extension extends the AbstractType class.

Schema manager 

The schema manager (class \Brotkrueml\Schema\Manager\SchemaManager) collects the concrete type model objects and prepares them for embedding into the web page.

The class exposes the following methods:

Node identifier 

A node identifier (class \Brotkrueml\Schema\Core\Model\NodeIdentifier) holds the ID for a type or a reference.

On instantiation of a NodeIdentifier the ID is given as a string argument into the constructor.

The class exposes the following method:

Blank node identifier 

A blank node identifier (class \Brotkrueml\Schema\Core\Model\BlankNodeIdentifier) holds the ID for a type or a reference.

On instantiation of a BlankNodeIdentifier the ID is auto-generated and unique within a request.

The class exposes the following method:

Other useful APIs 

Introduction 

The schema.org vocabulary provides enumerations types. An enumeration has one or more members, for example, the GenderType used for the gender property has the members Male and Female.

These enumerations can be used in your code instead of plain strings. This has the advantage of avoiding typos because you can use your IDE's capabilities. Also these members are part of a common vocabulary.

You can find the enums provided by the TYPO3 schema extensions in the Classes/Model/Enumeration/ folder.

Usage in PHP 

Usage in PHP is straightforward, in this example we are using the \Brotkrueml\Schema\Model\Enumeration\GenderType enum in the gender property:

<?php

declare(strict_types=1);

namespace MyVendor\MyExtension\Controller;

use Brotkrueml\Schema\Model\Enumeration\GenderType;
use Brotkrueml\Schema\Type\TypeFactory;

final class MyController
{
    public function __construct(
        private readonly TypeFactory $typeFactory,
    ) {}

    public function doSomething(): void
    {
        // ...

        $person = $this->typeFactory->create('Person');
        $person
            ->setId('https://example.org/#person-42')
            ->setProperty('givenName', 'John')
            ->setProperty('familyName', 'Smith')
            ->setProperty('gender', GenderType::Male);

        // ...
    }
}

This results in the following output:

{
   "@context": "https://schema.org/",
   "@type": "Person",
   "@id": "https://example.org/#person-42",
   "givenName": "John",
   "familyName": "Smith",
   "gender": "https://schema.org/Male",
}

Usage in Fluid templates 

The example in the PHP section above can also be adapted for a Fluid template. We make use of the constant view helper (which is available since Fluid v2.12):

<schema:type.person
   -id="https://example.org/#person-42"
   givenName="John"
   familyName="Smith"
   gender="{f:constant(name: '\Brotkrueml\Schema\Model\Enumeration\GenderType::Male')}"
/>

This results in the following output:

{
   "@context": "https://schema.org/",
   "@type": "Person",
   "@id": "https://example.org/#person-42",
   "givenName": "John",
   "familyName": "Smith",
   "gender": "https://schema.org/Male",
}

Create your own enumeration type 

Not all enumerations defined by schema.org are provided by this extension (or by the section extensions), but only those who have at least one member defined by schema.org. You may find a schema.org enumeration type which references members from the GoodRelations or from other vocabularies. If you need them, you can create a custom enum.

Have a look into Add a new enumeration.

Introduction 

There are several web page types available to characterise the content of a web page. A list of the types can be found in the section Available Web Page Types.

The WebPage type and its descendants (like AboutPage or ImageGallery) can only appear once on a web page – as opposed to the other types.

This extension defines a new field Type of web page in the page properties. Choose the appropriate type for the page and the schema markup is added automatically to the page (if the corresponding configuration setting is activated). If the configuration option is set and the according page has an expiration date set, the according property expires will be set in the markup.

But you have various options to set the web page type on your own. This can be the case, if you want to define the mainEntity property for a blog article or a product.

But now let's look at code.

Using the API 

As you saw in a previous chapter you can use the API to define the schema for a page. The WebPage type is no exception to that. Define a WebPage type for a page via API:

<?php

declare(strict_types=1);

namespace MyVendor\MyExtension\Controller;

use Brotkrueml\Schema\Manager\SchemaManager;
use Brotkrueml\Schema\Type\TypeFactory;

final class MyController
{
    public function __construct(
        private readonly SchemaManager $schemaManager,
        private readonly TypeFactory $typeFactory,
    ) {}

    public function doSomething(): void
    {
        // ...

        $itemPage = $this->typeFactory->create('ItemPage');
        $this->schemaManager->addType($itemPage);

        // ...
    }
}

That is it. But you can add one or more properties to it - let's define a page with a product as primary content:

<?php

declare(strict_types=1);

namespace MyVendor\MyExtension\Controller;

use Brotkrueml\Schema\Manager\SchemaManager;
use Brotkrueml\Schema\Type\TypeFactory;

final class MyController
{
    public function __construct(
        private readonly SchemaManager $schemaManager,
        private readonly TypeFactory $typeFactory,
    ) {}

    public function doSomething(): void
    {
        // ...

        $aggregateRating = $this->typeFactory->create('AggregateRating')
            ->setProperty('ratingValue', '4')
            ->setProperty('reviewCount', '126')
        ;

        $product = $this->typeFactory->create('Product')
            ->setProperties([
                'name' => 'Some fancy product',
                'color' => 'blue',
                'material' => 'wood',
                'image' => 'https://example.org/some-fancy-product.jpg',
                'aggregateRating' => $aggregateRating,
            ])
        ;

        $itemPage = $this->typeFactory->create('ItemPage')
            ->setProperty('mainEntity', $product)
        ;

        $this->schemaManager->addType($itemPage);

        // ...
    }
}

The example is rendered as JSON-LD:

{
   "@context": "https://schema.org/",
   "@type": "ItemPage",
   "mainEntity": {
      "@type": "Product",
      "aggregateRating": {
         "@type": "AggregateRating",
         "ratingValue": "4",
         "reviewCount": "126"
      },
      "color": "blue",
      "image": "https://example.org/some-fancy-product.jpg",
      "material": "wood",
      "name": "Some fancy product"
   }
}

If you define a web page on your own, this overrules the page field value of the specific type of web page.

Using the view helpers 

But imagine you don't have the possibility to add PHP code to an extension (for example, it is a third-party extension). So the view helpers come into the game. Let's implement the same example as above with view helpers:

<schema:type.itemPage>
   <schema:type.product
      -as="mainEntity"
      name="Some fancy product"
      color="blue"
      material="wood"
      image="https://example.org/some-fancy-product.jpg"
   >
      <schema:type.aggregateRating
         -as="aggregateRating"
         ratingValue="4"
         reviewCount="126"
      />
   </schema:type.product>
</schema:type.itemPage>

Remark 

As mentioned above, only one web page type can exist on a page. But what happens if you set more than one web page type? Well, the last call wins the race. So you can define it in your Extbase action and set it in a Fluid template – the template wins.

Introduction 

A breadcrumb is an essential part of a web page. It gives the user an idea of where he is on the web site. He can also navigate to parent pages. But for search engines a breadcrumb is also essential to understand the structure of a web site. Last but not least, the breadcrumb is shown in the search result snippet if structured markup for the breadcrumb is available.

There can also be more than one breadcrumb on a page, Google gives an example in his guidelines for a breadcrumb.

Using the API 

You can define a breadcrumb with the API as you may already guessed. For example, you have defined a breadcrumb somewhere:

$breadcrumb = [
   'Some product category' => 'https://example.org/some-product-category/',
   'Some product subcategory' => 'https://example.org/some-product-subcategory/',
   'Some fancy product' => 'https://example.org/some-fancy-product/',
];

Now you can iterate over the pages:

<?php

declare(strict_types=1);

namespace MyVendor\MyExtension\Controller;

use Brotkrueml\Schema\Manager\SchemaManager;
use Brotkrueml\Schema\Type\TypeFactory;

final class MyController
{
    public function __construct(
        private readonly SchemaManager $schemaManager,
        private readonly TypeFactory $typeFactory,
    ) {}

    public function createBreadcrumb(array $breadcrumb): void
    {
        // ...

        $breadcrumbList = $this->typeFactory->create('BreadcrumbList');
        $counter = 0;
        foreach ($breadcrumb as $name => $url) {
            $counter++;

            $breadcrumbList->addProperty(
                'itemListElement',
                $this->typeFactory->create('ListItem')
                    ->setProperties([
                        'name' => $name,
                        'item' => $url,
                        'position' => $counter,
                    ]),
            );
        }
        $this->schemaManager->addType($breadcrumbList);

        // ...
    }
}

This results in the following schema markup:

{
   "@context": "https://schema.org/",
   "@type": "WebPage",
   "breadcrumb": {
      "@type": "BreadcrumbList",
      "itemListElement": [
         {
            "@type": "ListItem",
            "item": "https://example.org/some-product-category/",
            "name": "Some product category",
            "position": "1"
         },
         {
            "@type": "ListItem",
            "item": "https://example.org/some-product-subcategory/",
            "name": "Some product subcategory",
            "position": "2"
         },
         {
            "@type": "ListItem",
            "item": "https://example.org/some-fancy-product/",
            "name": "Some fancy product",
            "position": "3"
         }
      ]
   }
}

As you can see, the breadcrumb is embedded in a WebPage automatically.

Using the view helpers 

<schema:type.breadcrumbList>
   <f:for each="{breadcrumb}" as="item" iteration="iterator">
      <schema:type.listItem
         -as="itemListElement"
         name="{item.title}"
         item="{item.link}"
         position="{iterator.cycle}"
      />
   </f:for>
</schema:type.breadcrumbList>

<schema:type.itemPage>
   <schema:type.breadcrumbList -as="breadcrumb">
      <f:for each="{breadcrumb}" as="item" iteration="iterator">
         <schema:type.listItem
            -as="itemListElement"
            name="{item.title}"
            item="{item.link}"
            position="{iterator.cycle}"
         />
      </f:for>
   </schema:type.breadcrumbList>
</schema:type.itemPage>

page = PAGE
page {
   # ... some other configuration ...

   10 = FLUIDTEMPLATE
   10 {
      # ... some other configuration ...
      dataProcessing {
         10 = TYPO3\CMS\Frontend\DataProcessing\MenuProcessor
         10 {
             special = rootline
             as = breadcrumb
         }
      }
   }
}

<schema:breadcrumb breadcrumb="{breadcrumb}"/>

<schema:breadcrumb breadcrumb="{breadcrumb}" renderFirstItem="1"/>

$breadcrumb = [
   [
      'title' => 'Home page',
      'link' => '/',
      'data' => [
         'tx_schema_webpagetype' => 'WebPage',
      ],
   ],
   [
      'title' => 'Some product category',
      'link' => '/some-product-category/',
      'data' => [
         'tx_schema_webpagetype' => 'CollectionPage',
      ],
   ],
   [
      'title' => 'Some product subcategory',
      'link' => '/some-product-subcategory/',
      'data' => [
         'tx_schema_webpagetype' => 'CollectionPage',
      ],
   ],
   [
      'title' => 'Some fancy product',
      'link' => '/some-fancy-product/',
      'data' => [
         'tx_schema_webpagetype' => 'ItemPage',
      ],
   ],
];

Introduction 

A WebPage type provides a property mainEntity, which indicates the primary content of a page. Every type is allowed - although some types does not make sense (for example, a breadcrumb cannot be the primary content).

Using the API 

The main entity of a web page can be defined with the API. Let's start with an example that specifies a product as the primary content:

<?php

declare(strict_types=1);

namespace MyVendor\MyExtension\Controller;

use Brotkrueml\Schema\Manager\SchemaManager;
use Brotkrueml\Schema\Type\TypeFactory;

final class MyController
{
    public function __construct(
        private readonly SchemaManager $schemaManager,
        private readonly TypeFactory $typeFactory,
    ) {}

    public function addMainEntity(): void
    {
        // ...

        $aggregateRating = $this->typeFactory->create('AggregateRating')
            ->setProperty('ratingValue', '4')
            ->setProperty('reviewCount', '126');

        $product = $this->typeFactory->create('Product')
            ->setProperties([
                'name' => 'Some fancy product',
                'color' => 'blue',
                'material' => 'wood',
                'image' => 'https://example.org/some-fancy-product.jpg',
                'aggregateRating' => $aggregateRating,
            ]);

        $this->schemaManager->addMainEntityOfWebPage($product);

        // ...
    }
}

The above example is rendered as JSON-LD. Let's assume the WebPage type is set to ItemPage - either in the page properties or via the API or a view helper.

{
   "@context": "https://schema.org/",
   "@type": "ItemPage",
   "mainEntity": {
      "@type": "Product",
      "aggregateRating": {
         "@type": "AggregateRating",
         "ratingValue": "4",
         "reviewCount": "126"
      },
      "color": "blue",
      "image": "https://example.org/some-fancy-product.jpg",
      "material": "wood",
      "name": "Some fancy product"
   }
}

Using the view helpers 

You can define the main entity also in a view helper:

<schema:type.product
   -as="mainEntity"
   -isMainEntityOfWebPage="1"
   name="Some fancy product"
   color="blue"
   material="wood"
   image="https://example.org/some-fancy-product.jpg"
>
   <schema:type.aggregateRating
      -as="aggregateRating"
      ratingValue="4"
      reviewCount="126"
   />
</schema:type.product>

Prioritisation 

Main entities can be prioritised. This is sometimes necessary when different main entities are defined in different places (for example in a controller, a Fluid page template or in a content element).

Let's look at an example: In a page template for a blog post, the main entity is defined as type BlogPosting. There are content elements on the page that display questions and answers for a FAQ. The content element sets the web page type to 'FAQPage' and also defines the questions as the main entities (to display as rich snippets on the search results page). However, Google Search Console shows an error because BlogPosting is not allowed as the main entity of a FAQPage.

$schemaManager->addMainEntityOfWebPage($product, true);

<!-- This is defined in a page template -->
<schema:type.blogPosting
   -isMainEntityOfWebPage="1"
   name="A blog post"
/>

<!-- This is defined in a content element template -->
<schema:type.fAQPage/>
<f:for each="{questions}" as="question">
   <schema:type.question
      -isMainEntityOfWebPage="2"
      name="{question.title}"
   />
</f:for>

{
   "@context": "https://schema.org/",
   "@graph": [{
      "@type": "FAQPage",
      "mainEntity":[{
         "@type": "Question",
         "name": "Question #1"
      }, {
         "@type": "Question",
         "name": "Question #2"
      }]
   }, {
      "@type": "BlogPosting",
      "name": "A blog post"
   }]
}

Introduction 

You can enhance the functionality in the schema extension with PSR-14 event listeners. An event listener receives an event that provides methods for retrieving and setting dedicated properties.

Render additional types 

The event allows to add markup in cases where no controller is available, for example, if you want to enrich a page with structured data depending on the doktype of a page.

The event \Brotkrueml\Schema\Event\RenderAdditionalTypesEvent provides the following methods:

getRequest(): \Psr\Http\Message\ServerRequestInterface

Returns the PSR-7 request object.

addType(TypeInterface ...$type): void

Add one or more type models.

addMainEntityOfWebPage(TypeInterface $mainEntity): void

Add a main entity.

<?php

declare(strict_types=1);

namespace MyVendor\MyExtension\EventListener;

use Brotkrueml\Schema\Event\RenderAdditionalTypesEvent;
use Brotkrueml\Schema\Type\TypeFactory;
use TYPO3\CMS\Core\Attribute\AsEventListener;
use TYPO3\CMS\Frontend\Page\PageInformation;

#[AsEventListener(
    identifier: 'my-extension/add-markup-to-article-pages',
)]
final readonly class AddMarkupToArticlePages
{
    public function __construct(
        private TypeFactory $typeFactory,
    ) {}

    public function __invoke(RenderAdditionalTypesEvent $event): void
    {
        // The "frontend.page.information" attribute is available since TYPO3 v13.
        // Use the "frontend.controller" attribute (TSFE) in older TYPO3 versions
        // to retrieve the page record.
        /** @var PageInformation $pageInformation */
        $pageInformation = $event->getRequest()->getAttribute('frontend.page.information');
        $page = $pageInformation->getPageRecord();
        if ($page['doktype'] !== 12345) {
            return;
        }

        // Only for doktype 12345
        $article = $this->typeFactory->create('Article');
        $article->setProperty('name', $page['title']);
        // ... and set some other properties

        $event->addType($article);
    }
}

Introduction 

The TYPO3 schema extension ships type models and view helpers with their properties from the core section of the schema.org definitions. However, there are several extensions, like Health and lifesciences or Autos. There are also pending types and properties available that enable schema.org to introduce terms on an experimental basis.

The embedding of these vocabulary extensions goes beyond the scope of this TYPO3 extension, as it will considerably increase the number of terms – while most of them are not used by the majority of users.

For your convenience there are separate extensions to extend the vocabulary available with the terms of the different sections. But if you only want to add only a few terms you are encouraged to add them on your own, especially pending terms.

Pending terms are experimental, after a certain time a term will be incorporated into the core section or dropped. This depends on the usage, adoption and discussions. To maintain backward-compatibility and to not break any pages, pending types are also not supplied by this extension.

But the vocabulary delivered with this extension can be extended according to your needs. This chapter describes the necessary steps to register additional properties to existing types or to introduce new types on your website.

Register additional properties 

Sometimes it may be necessary to use properties that are not standardised or pending, or to add property annotations. Therefore the schema extension provides a way to extend types.

These additional properties are not only available in the API but also as arguments in the view helpers.

To add one or more properties to a type, create a new class, for example in EXT:my_extension/Classes/Schema/AdditionalProperties/ and implement the \Brotkrueml\Schema\Core\AdditionalPropertiesInterface. The interface requires two methods:

Here is an example for such an implementation:

<?php

declare(strict_types=1);

namespace MyVendor\MyExtension\Schema\AdditionalProperties;

use Brotkrueml\Schema\Core\AdditionalPropertiesInterface;

final class Car implements AdditionalPropertiesInterface
{
    public function getType(): string
    {
        return 'Car';
    }

    public function getAdditionalProperties(): array
    {
        return [
            'accelerationTime',
            'emissionsCO2',
            'fuelCapacity',
            'seatingCapacity',
            'speed',
        ];
    }
}

For each type create a new PHP class.

Adding types 

You can add additional types for use in the API or as a WebPage type. As an example, in March 2020, schema.org introduces a new VirtualLocation type related to the corona crisis, which was quickly adopted by Google. The type can be used as location in the Event type. So let's start with this example.

1. Create the type model class

   The model class for a type defines the available properties. The model class for the VirtualLocation type may look like the following:

   EXT:my_extension/Classes/Schema/Type/VirtualLocation.php

   <?php
   
   declare(strict_types=1);
   
   namespace MyVendor\MyExtension\Schema\Type;
   
   use Brotkrueml\Schema\Attributes\Type;
   use Brotkrueml\Schema\Core\Model\AbstractType;
   
   #[Type('VirtualLocation')]
   final class VirtualLocation extends AbstractType
   {
       protected static array $propertyNames = [
           'additionalType',
           'alternateName',
           'description',
           'disambiguatingDescription',
           'identifier',
           'image',
           'mainEntityOfPage',
           'name',
           'potentialAction',
           'sameAs',
           'subjectOf',
           'url',
       ];
   }
   

   Copied!

   In the example, the class is stored in Classes/Schema/Type of your extension, but you can choose any namespace. It has to extend from \Brotkrueml\Schema\Core\Model\AbstractType. The class must have the \Brotkrueml\Schema\Attributes\Type attribute assigned. It has one mandatory parameter: the type name. The protected static property $propertyNames contains the available schema.org properties.

   Now you can use the VirtualLocation in your PHP code:

   EXT:my_extension/Classes/Controller/MyController.php

   <?php
   
   declare(strict_types=1);
   
   namespace MyVendor\MyExtension\Controller;
   
   use Brotkrueml\Schema\Manager\SchemaManager;
   use Brotkrueml\Schema\Type\TypeFactory;
   
   final class MyController
   {
       public function __construct(
           private readonly SchemaManager $schemaManager,
           private readonly TypeFactory $typeFactory,
       ) {}
   
       public function createVirtualLocation(): void
       {
           // ...
   
           $location = $this->typeFactory->create('VirtualLocation');
           $location->setProperty('url', 'https://example.com/my-webinar-12345/register');
           $this->schemaManager->addType($location);
   
           // ...
       }
   }
   

   Copied!

   Note

   With the \Brotkrueml\Schema\Attributes\Type attribute the class is recognised as a type model class. All types are collected on DI compile time: When you add/change/remove a class, you have to flush the cache via Admin Tools > Maintenance or the flush:cache command on CLI.

2. Create the view helper (optional)

   If you have the need for a view helper with that type, you can create one:

   EXT:my_extension/Classes/ViewHelpers/Schema/Type/VirtualLocationViewHelper.php

   <?php
   
   declare(strict_types=1);
   
   namespace MyVendor\MyExtension\ViewHelpers\Schema\Type;
   
   use Brotkrueml\Schema\Core\ViewHelpers\AbstractTypeViewHelper;
   
   final class VirtualLocationViewHelper extends AbstractTypeViewHelper
   {
       protected string $type = 'VirtualLocation';
   }
   

   Copied!

   Changed in version 3.0

   The name of the type must be defined with the $type property.

   To use the schema namespace in Fluid templates also with your custom view helpers add the following snippet to the ext_localconf.php file of your extension:

   EXT:my_extension/ext_localconf.php

   $GLOBALS['TYPO3_CONF_VARS']['SYS']['fluid']['namespaces']['schema'][]
      = 'MyVendor\\MyExtension\\ViewHelpers\\Schema';

   Copied!

   This way you don't have to think about which namespace to use. And if the pending type is moved to the core section you have no need to touch your Fluid templates. Of course, feel free to use another namespace.

Add a new WebPage type 

If you are responsible for a medical website, the chances are high that you need the MedicalWebPage web page type, which is part of the Health schema.org extension.

Register this web page type so that it is available in the web page type list in the page properties. Simply follow the steps in the Adding types section.

Mark your class as a WebPage type with the interface \Brotkrueml\Schema\Core\Model\WebPageTypeInterface:

<?php

declare(strict_types=1);

namespace MyVendor\MyExtension\Schema\Type;

use Brotkrueml\Schema\Attributes\Type;
use Brotkrueml\Schema\Core\Model\AbstractType;
use Brotkrueml\Schema\Core\Model\WebPageTypeInterface;

#[Type('MedicalWebPage')]
final class MedicalWebPage extends AbstractType implements WebPageTypeInterface
{
    protected static array $propertyNames = [
        // ... the properties ...
    ];
}

The new web page type can now be selected in the page properties:

Add a new enumeration 

schema.org provides the ability to use enumerations as values for certain properties. The TYPO3 schema extensions provide the enumerations defined by schema.org. However, there are some enumerations where schema.org refers to other vocabularies. These enumerations are not provided by the TYPO3 schema extensions. An example is BusinessEntityType, which suggests using the GoodRelations terms. If you want to use them, you can define and use your own enumeration to provide a defined set of of possible values satisfiying your needs (instead of plain strings):

<?php

declare(strict_types=1);

namespace MyVendor\MyExtension\Schema\Enumeration;

use Brotkrueml\Schema\Core\Model\EnumerationInterface;

enum BusinessEntityType implements EnumerationInterface
{
    case Business;
    case Enduser;
    case PublicInstitution;
    case Reseller;

    public function canonical(): string
    {
        return 'http://purl.org/goodrelations/v1#' . $this->name;
    }
}

All enumeration types must implement the interface Brotkrueml\Schema\Core\Model\EnumerationInterface, which requires a canonical() method. Depending on the case, it returns the string to use in the JSON-LD output.

Now you can make use of this enum in PHP, for example:

// use MyVendor\MyExtension\Schema\Enumeration\BusinessEntityType;

$demand = $this->typeFactory->create('Demand');
$demand->setProperty('eligibleCustomerType', BusinessEntityType::Enduser);

or in Fluid:

<schema:type.demand
   eligibleCustomerType="{f:constant(
      name: \MyVendor\MyExtension\Schema\Enumeration\BusinessEntityType::Enduser
   )}"
/>

which results in:

{
   "@type": "Demand",
   "eligibleCustomerType": "http://purl.org/goodrelations/v1#Enduser"
}

Another use case might be to create your own extended GenderType enum instead using the enum from this extension:

<?php

declare(strict_types=1);

namespace MyVendor\MyExtension\Schema\Enumeration;

use Brotkrueml\Schema\Core\Model\EnumerationInterface;

enum GenderType implements EnumerationInterface
{
    case Androgyne;
    case Bigender;
    case Binary;
    case Cis;
    case DemiBoy;
    case DemiGirl;
    case Eunuch;
    case Female;
    case Genderless;
    case Intersex;
    case Male;
    case Multigender;
    case Neither;
    case Polygender;
    case Queer;
    case Transgender;

    public function canonical(): string
    {
        return match ($this) {
            self::DemiBoy => 'Demi-boy',
            self::DemiGirl => 'Demi-girl',
            self::Female, self::Male => 'https://schema.org/' . $this->name,
            default => $this->name,
        };
    }
}

Introduction 

The available schema.org types (like Person, Organization or BlogPosting) are extended with ongoing versions of the schema.org standard. The vocabulary can also be extended independently or by installing additional vocabulary sections.

An overview of the available types can be found in the System > Configuration module.

Types overview 

To open the types overview, navigate to the System > Configuration module. In the upper menu bar, select Schema: Types.

There are two groups available:

• All types: The available types are listed alphabetically.
• Web page types: The available web page types used in the page properties.

You can quickly look up the available types using the search box.

Introduced in version 3 

Introduced in version 1 

Unreleased 

[4.1.1] - 2025-12-02 

4.1.0 - 2025-11-25 

4.0.1 - 2025-09-10 

4.0.0 - 2025-09-09 

3.14.2 - 2025-09-10 

3.14.1 - 2025-09-06 

3.14.0 - 2025-08-30 

3.13.2 - 2025-07-22 

3.13.1 - 2025-07-18 

3.13.0 - 2025-05-17 

3.12.2 - 2025-05-03 

3.12.1 - 2025-04-25 

3.12.0 - 2025-04-14 

3.11.1 - 2025-04-10 

3.11.0 - 2025-04-01 

3.10.1 - 2025-03-16 

3.10.0 - 2025-03-12 

3.9.1 - 2025-01-28 

3.9.0 - 2025-01-13 

3.8.0 - 2024-11-22 

3.7.1 - 2024-10-22 

3.7.0 - 2024-09-19 

3.6.1 - 2024-08-18 

3.6.0 - 2024-07-23 

3.5.0 - 2024-05-20 

3.4.1 - 2024-05-03 

3.4.0 - 2024-02-16 

3.3.0 - 2024-02-04 

3.2.0 - 2024-01-30 

3.1.0 - 2024-01-10 

3.0.0 - 2023-10-23 

2.11.0 - 2023-10-19 

2.10.0 - 2023-07-21 

2.9.1 - 2023-06-06 

2.9.0 - 2023-06-02 

2.8.0 - 2023-05-22 

2.7.2 - 2023-04-26 

2.7.1 - 2023-02-24 

2.7.0 - 2023-02-14 

2.6.4 - 2023-01-05 

2.6.3 - 2022-12-09 

2.6.2 - 2022-11-15 

2.6.1 - 2022-10-28 

2.6.0 - 2022-10-04 

2.5.2 - 2022-09-02 

2.5.1 - 2022-06-13 

2.5.0 - 2022-05-18 

2.4.0 - 2022-03-28 

2.3.0 - 2022-02-28 

2.2.2 - 2022-01-02 

2.2.1 - 2021-11-20 

2.2.0 - 2021-11-17 

2.1.0 - 2021-10-19 

2.0.2 - 2021-09-15 

2.0.1 - 2021-08-09 

2.0.0 - 2021-08-01 

1.13.2 - 2022-10-28 

1.13.1 - 2022-06-13 

1.13.0 - 2022-03-28 

1.12.1 - 2021-08-09 

1.12.0 - 2021-07-07 

1.11.1 - 2021-04-06 

1.11.0 - 2021-03-10 

1.10.0 - 2020-12-28 

1.9.0 - 2020-09-08 

1.8.0 - 2020-07-08 

1.7.2 - 2020-06-14 

1.7.1 - 2020-05-26 

1.7.0 - 2020-04-22 

1.6.0 - 2020-03-09 

1.5.2 - 2020-02-09 

1.5.1 - 2020-01-30 

1.5.0 - 2020-01-22 

1.4.2 - 2019-12-13 

1.4.1 - 2019-12-01 

1.4.0 - 2019-11-23 

1.3.1 - 2019-11-04 

1.3.0 - 2019-09-28 

1.2.0 - 2019-09-03 

1.1.0 - 2019-07-27 

1.0.0 - 2019-07-11 

First stable release

0.9.0 - 2019-07-10 

0.8.1 - 2019-07-09 

0.8.0 - 2019-07-09 

0.7.0 - 2019-07-08 

0.6.0 - 2019-07-04 

0.5.0 - 2019-07-03 

0.4.0 - 2019-06-30 

0.3.0 - 2019-06-29 

0.2.0 - 2019-06-28 

0.1.0 - 2019-06-25 

Initial release

From version 3.x to version 4.0 

In version 4.0, the compatibility with TYPO3 v11 LTS and TYPO3 v12 LTS has been removed.

  use Brotkrueml\Schema\Model\Type\Event;
+ use Brotkrueml\Schema\Type\TypeFactory;

  final class MyController
  {
+     public function __construct(
+         private readonly TypeFactory $typeFactory,
+     ) {}

      public function doSomething(): void
      {
          // ...

-         $event = new Event();
+         $event = $this->typeFactory->create('Event');

          // ...
      }
  }

From version 2.x to version 3.0 

In version 3.0, the compatibility with TYPO3 v10 LTS was removed. Also PHP 8.1 or higher is necessary.

+ use Brotkrueml\Schema\Attributes\Type;

+ #[Type('MyCustomType')]
  final class MyCustomType extends AbstractType
  {
-     protected static $propertyNames = [
+     protected static array $propertyNames = [
         // ... the properties ...
      ]
  }

  final class MyCustomTypeViewHelper extends AbstractTypeViewHelper
  {
+     protected string $type = 'MyCustomType';
  }

 <?php

 declare(strict_types=1);

 namespace MyVendor\MyExtension\Controller;

 use Brotkrueml\Schema\Type\TypeFactory;

 final class MyController
 {
+    public function __construct(
+        private readonly TypeFactory $typeFactory,
+    ) {}

     public function doSomething(): void
     {
         // ...

-        $person = TypeFactory::createType('Person');
+        $person = $this->typeFactory->create('Person');

         // ...
     }
 }

From version 1.x to version 2.0 

In version 2.0, the compatibility with TYPO3 v9 LTS was removed. Also PHP 7.4 or higher is necessary.

$signalSlotDispatcher = \TYPO3\CMS\Core\Utility\GeneralUtility::makeInstance(
   TYPO3\CMS\Extbase\SignalSlot\Dispatcher::class
);
$signalSlotDispatcher->connect(
   \Brotkrueml\Schema\Core\Model\AbstractType::class,
   'registerAdditionalTypeProperties',
   \MyVendor\MyExtension\EventListener\AdditionalPropertiesForPerson::class,
   '__invoke'
);

services:
   # Place here the default dependency injection configuration

   MyVendor\MyExtension\EventListener\AdditionalPropertiesForPerson:
      tags:
         - name: event.listener
           identifier: 'myAdditionalPropertiesForPerson'