WBert WBert
Login Start free
Feature

Entities

Back to home
Entities

Model the application structure once, then let the backend drive the client faster.

Entities are the logical model between the database and the client application. They describe fields, labels, editing behavior, relations and indexes, so screens and APIs can evolve from backend metadata instead of being hardcoded repeatedly in the client.

Client models Editing fields Relations Indexes API metadata
Entity Customer Type Fields, labels, rules and relations
DB Database Tables and columns
API API layer Definitions and responses
UI Client app Forms, grids and lookups
⚙ Backend logic Processes and generation

A backend model for client-side structures

Instead of duplicating the same model rules inside every client screen, WBert lets the backend describe how an object is displayed, edited and connected. The client can read this structure and reduce repeated configuration work.

  • Define columns and display labels once.
  • Choose which fields are editable by the client.
  • Expose entity definitions through the structure API.
Entities Define client-side application models, columns and editing fields.
NameConnectorTable/View
Customer Typemaincustomer_type
Details--
Master--

Edit the structure without touching the client first

The entity editor stores columns, editing fields, relations and indexes as metadata. This keeps the structure flexible while the application evolves, especially during early product validation and client UI changes.

  • Generate metadata from existing tables or define it manually.
  • Select editing fields from the entity columns.
  • Keep database binding optional when the model is only logical.
Edit entity Entity definitions are metadata for the client.
ColumnsEditing FieldsRelationsIndexes
FieldNameHeaderTextDataType
created_atCreated AtString
descriptionDescriptionString

Relations connect entities to other entities

Relations describe how one entity points to another. The backend can use them for lookup metadata, API responses, future table generation and client-side forms that need to show readable values instead of raw identifiers.

  • Connect a source field to a target entity and target field.
  • Choose a display field for readable client labels.
  • Mark relations that should create database foreign keys later.
Order customer_id
Customer id → name
The API can keep the id, while the client displays the name.

Ready for APIs and client applications

The structure API can return entity definitions to the client, while administrators continue to refine fields, relations and indexes in the backend. This reduces client-side rebuilds and keeps business structure under platform control.

  • Use structure.GetEntities to discover available models.
  • Use structure.GetEntityDefinition to read fields, relations and indexes.
  • Connect metadata to future UI builders, forms, grids and lookup components.
Application Structure structure.GetEntities structure.GetEntityDefinition structure.ResetEntityCache 
{
  entity: "Customer Type",
  columns: ["id", "description"],
  editingFields: ["description"],
  relations: [],
  indexes: ["description"]
}

A structure that keeps evolving with the backend.

Entities are not just a database wrapper. They are a configurable backend contract for client applications, APIs and business tools. As the application grows, the structure can evolve from the platform instead of being scattered across client code.