Not translated yet — showing English.
Schema Object Reference
A schema is built from three kinds of object, and objects are built from fields. Entities hold your game's records, parts are reusable groups of fields inside them, and enums are fixed lists of values. This page is the reference for each of them; Building a Game Schema walks through creating them.
Entities, parts and enums
| Object | What it is | Has its own records | Example |
|---|---|---|---|
| Entity | A standalone object: a table of records your game reads and writes. | Yes, listed in Data | Ships, Pilots, MatchResults |
| Part | A reusable group of fields that only exists inside an entity or another part. | No, its values live in the record that includes it | Stats, Loadout |
| Enum | A fixed list of allowed values for a field. | No | ShipClass: Fighter, Bomber, Scout |
Field kinds
Every field has a kind, which decides what it stores.
| Kind | Stores | Target | Cardinality |
|---|---|---|---|
| Primitive | A value directly, of one of the primitive types. | — | One value |
| Enum reference | One value from an enum. | An enum | One value |
| Relationship → entity | A link to a record of another entity, by its ID. | An entity | 1-to-1 or 1-to-many |
| Inclusion ↳ part | A part's fields, embedded in this record. | A part | 1-to-1 or 1-to-many |
Relationship and inclusion both connect objects, in different ways. A relationship points to a record that exists on its own and can be shared: a pilot points to a ship, and many pilots can point to the same ship. An inclusion embeds a structure that belongs to its parent and has no life of its own: a ship's Stats exist only as part of that ship.
Primitive types
| Type | Stores |
|---|---|
| Text | A short string |
| Long text | A multi-line string |
| Integer | A whole number |
| Number | A floating-point number |
| Decimal | A fixed-precision number |
| Boolean | true or false |
| Date & time | An ISO timestamp |
| Date | A date, YYYY-MM-DD |
| UUID | A unique identifier |
| JSON | A structured object |
| A validated email address | |
| URL | A link |
Field settings
| Setting | Meaning |
|---|---|
| Name | Letters, digits and underscores, starting with a letter, up to 64 characters. Id, CreatedAt and UpdatedAt are reserved. |
| Default | The value a new record gets when none is given. |
| Required | A record can't be saved without a value. |
| Unique | No two records may share a value. |
| Indexed | Speeds up filtering and sorting on this field. |
Entity settings
An entity carries a few settings beyond its fields. They are set in the entity's editor: New ▾ → Entity for a new one, or the pencil next to its name.
| Setting | What it does |
|---|---|
| Singleton entity | The entity holds exactly one record, with no business key of its own; references to it skip the ID. Use it for global configuration such as match rules. In Data it shows as a single form instead of a list. |
| Display field | The field that stands for a record wherever it is referenced: relation cells, the record panel, the record picker. Auto picks one for you. |
| Access control | Who may read and write the entity's records. See Access Control. |
| Owned by player | Each record belongs to one player, stamped by the server when a player creates it. See Player-owned entities. |
| Read access | For a player-owned entity: Owner, each player reads only their own records, or Public, everyone may read every record. |
| On player delete | For a player-owned entity, required: what happens to a player's records when the player is deleted. |
| On player delete | The player's records are |
|---|---|
cascade-delete | Deleted with the player. |
anonymise | Kept, with the owner replaced by a stable anonymous marker. |
restrict | Kept, and the player can't be deleted while any exist. |
Raw fields
By default a record may only hold the fields its entity declares. An entity can instead allow raw fields: records may then carry extra keys the schema doesn't define, for free-form data you don't want to model. Raw fields can't be filtered, sorted or indexed, and are only reachable by reading the record. They are switched on through the API or MCP; the Backoffice has no setting for them.
Raw fields trade structure for flexibility
Declared fields are validated, typed and queryable; raw fields are none of these. Use them for data you only ever read back whole, and model anything you'll want to search on.
Schemas pushed from code
An entity or part can come from your game's code instead of the Backoffice, pushed with the SDK's schema tool. It then carries a CODE label: its structure is read-only in the Backoffice and changes come from code, while its records stay editable in Data. Pushing from code can't take over an object of the same name created in the Backoffice.
Next steps
- Building a Game Schema — create objects and fields, then review and apply the changes
- Working with Game Data — the records of your entities
- Access Control — who may read and write each entity
Last updated on 16 Oct 2026