Concepts

Abstraction Layer

Building enterprise applications usually requires translating ideas between four different worlds: database schemas (SQL), backend code (Java/C#), API contracts (JSON/GraphQL), and frontend code (React/Vue).

Kodall unifies the entire application building process into a single framework.
Data, automations, queries, APIs and user interfaces all operate as one integrated model by integrating all the abstractions below.

Entities

In Kodall, business objects are called Entities.
You can create them in a declarative manner, from the Development Module.

Entities are first class citizens across the entire platform.

The moment an Entity is published, the platform automatically propagates its properties, relationships, and security policies across the full stack, generating the underlying security, database schema, query structures, logic engine, REST APIs, and UI views in real time.

By integrating Entities at the Platform Layer, Kodall handles schema generation and relational graphing out of the box. You can model deeply nested relationships (1:1, 1:N, N:1, N:N, P:C) without writing manual DDL scripts, maintaining ORM mapping files, or handling foreign key setups.

Workflow

Processing business rules, calculations, and state changes, is done through Workflow: our native, strongly-typed programming language.

In Kodall, Workflow solves a fundamental problem: it’s the missing link between business logic and clean execution. It lets you manipulate entities natively, addressing the exact Entity names, properties and relationships you’ve previously defined.

Workflow syntax is similar to C-style languages (Java, C#, JavaScript), so most developers pick it up instantly without learning exotic paradigms. Most importantly, Workflow logic executes safely inside the sandboxed Development Module, meaning it can manipulate business objects without touching or compromising core platform operations.

workflow InventoryService;

method createIn(idDocument as int, idProduct as int, quantity as decimal, description as string) {
    var i = CREATE inventory;
    i.id_document = idDocument;
    i.id_product = idProduct;
    i.quantity = quantity;
    i.description = description;
    PUT i;
}

➔ Reference: Lesson 3: Inventory Management

Fetch Query Language

Fetch is our dedicated query language engineered for speed and performance. Operating directly against the Entity graph, Fetch retrieves deeply nested data structures in a single, unified operation.

Fetch allows developers to request exactly what the application needs (such as Customer → Orders → Order Items) in a clean statement without impacting performance.

FETCH    ::= 'FETCH' entityName '(' property ( ',' property )* ')' linkedEntities* ( 'FILTER' filter )? orderBy? ( 'LIMIT' int ( ',' int )? )?

Example 1

FETCH product (key, name, price, bar_code) FILTER AND (${nameArg})

➔ Reference: Lesson 1: The Products

Example 2

FETCH purchase_invoice (key GROUP BY, number, date) {
    supplier TO id_supplier (name AS supplierName GROUP BY) FILTER AND (${supplier_key}),
    purchase_invoice_item TO id_purchase_invoice (SUM(amount) AS invoice_amount)
}
FILTER AND (${invoice_number},${invoice_date_from},${invoice_date_to})

➔ Reference: Lesson 2: The Invoices

UI Abstraction

The frontend in Kodall contains no hardcoded forms, static grids, or embedded API queries. It operates as a dynamic presentation abstraction driven directly by Entity definitions and Workflow states.

Rather than writing custom HTML/CSS or managing state hooks, you model your layouts using the master-detail pattern by declaring Search Views and Edit Views.

The final view is where all record mechanics converge

Entities: Supplies the complete property schema, nested child entity grids, data constraints, and field-level control mappings (e.g., text, dates, dropdowns).

Workflow Engine: Binds directly to Entity Actions and form submission triggers, executing custom business rules, validations, and state changes.

Security: Enforces record ownership (User, Business Unit, Organization) and granular Sharing ACLs (View, Edit, Delete) dynamically at the UI boundary.

Search View: Serves as the operational target, returning the user to the master dataset grid while automatically refreshing updated records.

Customization Sets

Customization Sets represent Kodall's core delivery abstraction. Configured directly within the Development Module, a Customization Set packages Entity metadata definitions, properties, and relationships into modular, version controlled change units that can be published, updated, or rolled back across environment lifecycles.

A Customization Set organizes application changes across three structural layers:

Entities: Defines the scope of business objects contained in the change package.

Properties: Declares the attributes for each entity, including property names, data types, mandatory flags, and default values.

Relationships: Configures explicit associations between entities, such as 1:N and N:1 or parent:child.

Lifecycle & Versioning

Customization Sets enforce strict deployment and schema stability rules:

Publishing: Staged changes (new entities, properties, or relationships) remain isolated in the Development Module until published. Once published, the platform engine automatically updates the underlying environment.

Immutability & History: Published customization sets become immutable. Modifying or removing active schema elements requires unpublishing an existing version via the History tab or applying new, non-destructive additive updates.

Architectural Integration

Entities & Relational Graph: Serves as the packaging mechanism that transports Entity schemas, property metadata, and graph constraints into the runtime environment.

Platform Engine Isolation: Ensures schema migrations execute safely inside Kodall's core runtime without touching the underlying engine binaries or risking database drift.

Modular Upgrades: Enables application extensions, custom fields, and module additions to be built, shipped, and versioned independently without breaking base platform installations.