Skip to main content

Welcome to TeaQL

TeaQL is a generated business API platform for AI-native software. It turns a domain model into type-safe, human-readable APIs that can be used by application developers and AI coding tools without asking them to guess SQL, table relationships, DTO shapes, or runtime policy.

TeaQL has two current centers of gravity:

  • Java-proven productivity for enterprise systems, Spring Boot services, rich domain models, and maintainable business queries.
  • Rust-powered runtime work for MySQL, PostgreSQL, SQLite, embedded SQLite, in-memory tests, edge deployments, and agent memory.

The short version:

Generated Business APIs. Java-proven. Rust-powered. Multi-database ready.

The Philosophy Behind TeaQL: Uncompromising Design Meets AI​

TeaQL is not a solo endeavor or a weekend workshop project. It is the culmination of collective expertise—a comprehensive ecosystem systematically architected by a dedicated group of top-tier engineers with extensive enterprise experience.

Our core motto is simple: "Never compromise on design."

Long before a single line of implementation was written, our team spent countless hours meticulously crafting, debating, and finalizing extensive architectural blueprints and design documents online. Because of our strict adherence to this uncompromising standard, our initial progress was deliberately slow. We refused to accumulate technical debt or settle for "good enough" just to launch faster.

Then came the era of Agentic AI.

With our robust, battle-tested designs already in place, AI became the ultimate catalyst. The AI didn't design the system; rather, it helped us rapidly execute and realize the vast library of design documents we had already perfected. What used to be a bottleneck of manual implementation has now skyrocketed in velocity. AI coding tools gave our top-tier engineering collective the execution speed necessary to match our rigorous design vision—without ever having to compromise.

Choose Your Path​

I want to try TeaQL in 5 minutes​

Start from a starter model, then inspect the generated query APIs.

I want to understand the architecture​

Learn why TeaQL is more than an ORM and how the generated API, runtime context, repositories, and providers fit together.

I want to use TeaQL with AI coding tools​

Use generated business APIs as a stable layer between LLM-generated application code and your database/runtime implementation.

I want to run TeaQL Rust with MySQL, PostgreSQL, or SQLite​

Use the Rust runtime provider model to choose SQLx PostgreSQL, SQLx MySQL, SQLx SQLite, rusqlite SQLite, or MemoryRepository.

Core Ideas​

TeaQL keeps business API design separate from storage execution:

Domain Model
  -> TeaQL Generator
  -> Generated Q API
  -> Runtime Provider
  -> MySQL / PostgreSQL / SQLite / Memory / Edge / Agent

The same domain model can generate APIs that read like business intent:

User userOrderInfo = Q.users()
    .comment("Query users").purpose("Load data").filterWithId(userId)
    .countOrder()
    .facetByOrderStatus("statusWithCount", Q.orderStatus().countOrders())
    .selectOrderList(
        Q.ordersWithId()
            .selectOrderId()
            .selectDate()
            .offset(0, 10)
            .selectLineItemList(Q.lineItemsWithId().selectImageURL().limit(3))
            .countLineItems()
    )
    .execute(context);

One business page can be expressed as one fluent API instead of scattered SQL, XML, DTO mapping, and manual stitching.