DEV Community

David Lastrucci
David Lastrucci

Posted on

Trysil - API REST made simple

#trysil #delphi #orm

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;
Enter fullscreen mode Exit fullscreen mode

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;
Enter fullscreen mode Exit fullscreen mode

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.

Top comments (0)