Data & Enterprise

Data Layer

Zornux has a built-in ORM — no external library, no SQL strings. You declare a database, map your classes to tables, and read and write with plain-English statements. Queries are parameterized and injection-safe by construction.

Declaring a database

A database … end block names a provider and maps one or more classes to tables with table T from Class:

class User
    has id
    has name as text
    has email as text required     # NOT NULL
    has balance as money           # exact minor units, lossless
end

database AppDb
    provider memory
    table Users from User
end

Save, find, delete

save item into Table inserts a new item (assigning a fresh id) or updates an existing one, matched by its id. find queries; delete removes.

create alice from User
alice.name = "Alice"
alice.email = "alice@example.com"
save alice into AppDb.Users

# Read every row, or the first match of a condition.
show "Users: " + text(length(find all from AppDb.Users))
create found = find one from AppDb.Users where email is "alice@example.com"
show "Found: " + found.name

# Update: change a field and save the same item again.
found.name = "Alice Jr."
save found into AppDb.Users

# Delete.
delete found from AppDb.Users

Rich queries

A where clause is a tree of comparisons joined by and / or. The is … operators reuse the language's own comparison words, so a query reads like any other condition:

find all from Db.People where age is greater than 18
find all from Db.People where city is "London" and age is greater than 30
find all from Db.People where name starts with "A" or name ends with "z"

Ordering & pagination

Sort with sorted by field [descending] (more keys with then by, a stable sort), and page with skip N (offset) and first N (limit):

find all from Db.People sorted by age descending
find all from Db.People sorted by city then by age
find all from Db.People sorted by created descending skip 20 first 10

Aggregates & existence

Ask a question instead of fetching rows: find count, find any, and the numeric aggregates sum / average / minimum / maximum of field from:

find count from Db.People where city is "London"
find any from Db.People where age is greater than 100
sum of age from Db.People
average of age from Db.People where city is "London"

Relationships — has one / has many

A class declares a relationship with has one / has many Target by column — it maps to no column. Load it with find … with, which batch-loads related rows one query per level (WHERE … IN (…)), so there is no N+1. SQL joins are intentionally not exposed.

class Customer
    has id
    has email as text required
    has many Order by customer_id
end

class Order
    has id
    has customer_id as whole
    has total as money
end

# Load customers and their orders in one extra query — not one per row.
create rows = find all from Shop.Customers with orders

Transactions

A transaction is all-or-nothing: it commits when its body finishes cleanly and rolls the whole batch back if a recoverable error occurs — the same catch error recovery as error handling.

transaction on Bank
    save ada into Bank.Accounts
    save grace into Bank.Accounts
    show item_at([], 3)        # fails — the whole batch rolls back
catch error
    show "rolled back (" + error.code + ")"
end

Injection-safe by design

Untrusted input can't flow straight into a query. A value from read_text or a web request is UntrustedText until you sanitize or validate it — passing raw untrusted text to the database raises ZX2411. Queries are parameterized under the hood, so there is no string-concatenation attack surface.

Schema migrations

As classes change, the database has to keep up. Zornux uses a hybrid model: the automatic diff adds any new tables and columns the classes declare, while migration … end blocks handle the rest — renames and removals — ordered and recorded so each runs once. The diff never removes anything, so a deploy can't lose data by surprise.

migration CreateProducts
    create table Products from Product
end

migration AddSku
    add field sku to Products
end

migrate Store      # apply pending migrations, then the additive diff
rollback Store     # reverse the most recently applied migration

Async in components

In a real backend, data access lives in a repository whose methods are async functions — a service calls them with wait for:

repository UserRepository
    async function all
        give back find all from AppDb.Users
    end
end

Diagnostics are ZX2400–ZX2499. Next: layering services and injection on top — Application Layer.