[Core] Provide Schema Loaders for supporting different Formats

[alexander-schranz]

The Schema is currently created via PHP but maybe like in doctrine it make sense to create a Schema via other Formats like XML, YAML, JSON?

Current PHP Schema:

<?php

use Schranz\Search\SEAL\Schema\Field;
use Schranz\Search\SEAL\Schema\Index;
use Schranz\Search\SEAL\Schema\Schema;

return new Schema([
    'news' => new Index('news', [
        'id' => new Field\IdentifierField('id'),
        'title' => new Field\TextField('title'),
        'header' => new Field\TypedField('header', 'type', [
            'image' => [
                'media' => new Field\IntegerField('media'),
            ],
            'video' => [
                'media' => new Field\TextField('media', searchable: false),
            ],
        ]),
        'article' => new Field\TextField('article'),
        'blocks' => new Field\TypedField('blocks', 'type', [
            'text' => [
                'title' => new Field\TextField('title'),
                'description' => new Field\TextField('description'),
                'media' => new Field\IntegerField('media', multiple: true),
            ],
            'embed' => [
                'title' => new Field\TextField('title'),
                'media' => new Field\TextField('media', searchable: false),
            ],
        ], multiple: true),
        'footer' => new Field\ObjectField('footer', [
            'title' => new Field\TextField('title'),
        ]),
        'created' => new Field\DateTimeField('created'),
        'commentsCount' => new Field\IntegerField('commentsCount'),
        'rating' => new Field\FloatField('rating', sortable: true),
        'comments' => new Field\ObjectField('comments', [
            'email' => new Field\TextField('email', searchable: false),
            'text' => new Field\TextField('text'),
        ], multiple: true),
        'tags' => new Field\TextField('tags', multiple: true, filterable: true),
        'categoryIds' => new Field\IntegerField('categoryIds', multiple: true, filterable: true),
   ]),
]);

Which other formats should be supported:

• YAML?
• JSON?
• XML?

Is the Core responsible for this formats or should the Core not care about additional Formats and Example the Symfony Bundle could us Symfony configuration tree instead, which out of the box supports Yaml, Xml, PHP Array, PHP Builder configuration.

But that would mean the definition would be framework specific, so own Schema Loaders which are not Framework specific maybe would make sense.

Maybe also other formats as the current PHP representation are not required?

In doctrine DBAL is also not responsible for this formats the ORM provide something so maybe the SEAL CORE should also not handle different formats or Schema Loaders, and maybe a future ODM would handle that, but that is another Ticket #81.

What also should be keep in mind does providing different formats improve a better developer experience or even hurt it as some answers to stackoverflow, github discussions, ... are written in just one format and not in another.

[alexander-schranz]

This is what a JSON Format would look like:

{
    "name": "news",
    "fields": {
         "id": {
              "type": "id"
         },
         "title": {
              "type": "text"
         },
         "header": {
              "type": "typed",
              "typeField": "type",
              "types": {
                   "image": {
                        "media": {
                            "type": "integer"
                        }
                   },
                   "video": {
                        "media": {
                            "type": "string",
                            "searchable": false
                        }
                   },
              }
         },
         "article": {
              "type": "text"
         },
         "blocks": {
              "type": "typed",
              "typeField": "type",
              "types": {
                   "text": {
                        "title": {
                            "type": "text"
                        },
                        "description": {
                            "type": "text"
                        },
                        "media": {
                            "type": "integer",
                            "multiple": true
                        }
                   },
                   "embed": {
                        "title": {
                            "type": "text"
                        }
                        "embed": {
                            "type": "text",
                            "searchable": false
                        }
                   }
              }
         },
         "footer": {
              "type": "object",
              "fields": {
                   "title": {
                        "type": "text"
                   }
              }
         },
         "created": {
              "type": "date"
         },
         "rating": {
              "type": "integer",
              "sortable": true
         },
         "commentsCount": {
              "type": "integer"
         },
         "comments": {
              "type": "object",
              "fields": {
                   "email": {
                        "type": "text",
                        "searchable": false
                   },
                   "text": {
                        "type": "text"
                   },
              }
         },
         "tags": {
              "type": "text",
              "multiple": true
         },
         "categoryIds": {
              "type": "integer",
              "multiple": true,
              "filterable": true
         }
    }
}

[alexander-schranz]

This is what a XML Format would look like:

<index name="news">
     <id name="id" />
     <text name="title" />
     <typed name="header" type-field="type">
         <type name="image">
              <integer name="media" />
         </type>
         <type name="video">
              <text name="media" />
         </type>
     </typed>
     <text name="article" />
     <typed name="blocks" type-field="type">
         <type name="image">
              <text name="title" />
              <text name="description" />
              <integer name="media" multiple="true" />
         </type>
         <type name="embed">
              <text name="title" />
              <text name="media" searchable="false" />
         </type>
     </typed>
     <object name="footer">
          <text name="title" />
     </object>
     <integer name="commentsCount" />
     <integer name="rating" sortable="true" />
     <object name="comments" multiple="true">
          <text name="email" searchable="false" />
          <text name="text" />
     </object>
     <text name="tags" multiple="true" filterable="true" />
     <integer name="categoryIds" multiple="true" filterable="true" />
</index>

[alexander-schranz]

The PHP classes could also in future be used as attributes for the ODM #81 implementation:

<?php

use Schranz\Search\SEAL\Schema\Field;
use Schranz\Search\SEAL\Schema\Index;

#[Index(name: 'page')]
class Page {
    #[Field\IdentifierField('id')]
    private string $id;
    
    #[Field\TextField('title')]
    private string $title;
    
    #[Field\TypedField('header', 'type', [
        'image' => [
            'media' => new Field\IntegerField('media'),
        ],
        'video' => [
            'media' => new Field\TextField('media', searchable: false),
        ],
    ])]
    private array $header;
    
    // ...
}