If you've ever built REST APIs, you know the drill: define your data model, write your database queries, map results to objects, handle serialization, write controllers... and that's before you even get to the business logic!
What if I told you that with Trysil, a Delphi ORM, you can skip most of that boilerplate and go from your data model to a working API in just a few steps?
Let me show you how.
The Problem with Traditional Approaches
When building REST APIs the traditional way, you often end up writing:
- SQL queries (or stored procedures)
- Data mapping code
- Validation logic
- CRUD operations for each entity
- Serialization/deserialization code
It works, but it's repetitive and time-consuming. For each new entity, you're basically copying and pasting the same patterns over and over.
Enter Trysil
Trysil is a Delphi ORM that helps you focus on what matters: your business logic. Once you've defined your entity model, Trysil handles the heavy lifting of persistence, queries, and data mapping.
Let's see how simple it can be with a real example.
Step 1: Define Your Entity Model
First, we define our TCustomer entity class. With Trysil, you simply create a plain Delphi class and decorate it with attributes to map it to your database:
[TTable('Customers')]
TCustomer = class
strict private
[TPrimaryKey]
[TColumn('ID')]
FID: TTPrimaryKey;
[TRequired]
[TMaxLength(100)]
[TColumn('Firstame')]
FFirstname: String;
[TRequired]
[TMaxLength(100)]
[TColumn('Lastname')]
FLastname: String;
[TMaxLength(255)]
[TColumn('Email')]
FEmail: String;
[TVersionColumn]
[TColumn('VersionID')]
FVersionID: TTVersion;
public
property ID: TTPrimaryKey read FID;
property Firstname: String read FFirstname write FFirstname;
property Lastname: String read FLastname write FLastname;
property Email: String read FEmail write FEmail;
property VersionID: TTVersion read FVersionID;
end;
That's it! Notice how clean and readable it is. The attributes tell Trysil everything it needs to know about the database mapping.
Step 2: Create Your API Controller
Now here's where the magic happens. To expose this entity through a REST API, we create a controller. Thanks to Trysil handling all the persistence logic, our controller can be incredibly simple:
[TUri('/customer')]
TCustomerController = class(TReadWriteController<TCustomer>)
end;
Look at that! With just a few lines of code, we have:
- GET to retrieve customers
- POST to create a new customer
- PUT to update existing one
- DELETE to remove a customer
Trysil takes care of:
- Database connections
- SQL generation
- Object-relational mapping
- Transactions
- Error handling
The Result
What you end up with is a clean, maintainable codebase where:
Your entity model is the single source of truth
Controllers are thin and focused on HTTP concerns
No SQL strings scattered throughout your code
Easy to test and extend
This is the beauty of using an ORM like Trysil: you spend less time on plumbing and more time building features that matter to your users.
SOCIAL SHARE CARD GENERATOR