#aya

@aya.from(User::table())
|> @aya.Query::filter(u => u.age.gte(18) & u.deleted_at.is_none())
|> @aya.Query::map(u => @aya.sel(u.name))
|> @aya.Query::order_by(u => [u.name.asc()])
|> @aya.Query::limit(20)

SELECT u."name"
  FROM "users" AS u
 WHERE u."age" >= ? AND u."deleted_at" IS NULL
 ORDER BY u."name" ASC
 LIMIT ?
-- parameters: [18, 20]

#What it is

• A query builder, not an ORM. No identity map, no lazy loading, no change tracking. A query is a value; running it is a separate step.
• Typed at the column. Column[T] carries a phantom T, so a Column[Int] will not accept a string and a Column[String] cannot be summed.
• Database-agnostic. aya produces SQL text plus an ordered parameter list. Anything that can run that pair is a driver; SQLite, PostgreSQL and a recording fake ship in src/driver.
• Generated, not reflected. The generator emits ordinary MoonBit source you can read and diff. Nothing is discovered at runtime.
• The schema comes from the same source. aya-kit diffs your entities against the last snapshot and writes the migration — no connection needed.

#Install

moon add Allianaab2m/aya

// moon.pkg
import {
  "Allianaab2m/aya",
  "Allianaab2m/aya/driver/sqlite",
}

#Quickstart

#ayatable(name="users", alias="u")
pub(all) struct User {
  #ayaid
  id : Int
  name : String
  age : Int
  deleted_at : String?
} derive(Debug, Eq)

aya-kit codegen

async fn main {
  @sqlite.with_connection("app.db", driver => {
    let db = @aya.Tx::new(driver)
    let adults = (@aya.from(User::table())
      |> @aya.Query::filter(u => u.age.gte(18))).run(db)
    println(adults.length())
  })
}

#The vocabulary

classDiagram
    class Table~Cols,R~ {
        cols : Cols
        all : Selection~R~
        write : Binding~R~
    }
    class Selection~Out~ {
        exprs : Array~RawExpr~
        read : Row to Out
    }
    class Binding~In~ {
        columns : Array~String~
        write : In to values
    }
    class Query~Cols,A~ {
        cols : Cols
        projection / wheres / group / order
        decode : Row to A
    }
    class Reducer~Out~ {
        aggregates only
    }
    class Column~T~ {
        tbl : String
        name : String
    }
    class Expr~T~ {
        raw : RawExpr
    }
    class Tx~D~ {
        db : D
        depth : Int
    }
    class RawExpr {
        Col / Lit / Bin
        Unary / InList / Agg
    }

    Table --> Selection : all
    Table --> Binding : write
    Table --> Query : from
    Query --> Reducer : reduce / group_by
    Column --> Expr : expr
    Expr --> RawExpr : raw
    Selection --> RawExpr : exprs
    Tx --> Query : run / one / first

#Documentation

#Package layout

src/*.mbt           core library — expressions, projection, query, DML, emission
src/gen/            entity parsing — attributes to IR — and column-handle emission
src/ddl/            IR to snapshot, diff, and DDL
src/kit/            config and migration planning, all of it pure
src/kit/aya-kit/    the CLI (aya-kit)
src/driver/sqlite/  SQLite driver
src/driver/postgres/PostgreSQL driver
src/driver/fake/    recording fake, for testing repositories
src/example/        two worked entities: a plain one and a row-vs-domain one
migrations/         the migrations generated from src/example

#Development

moon check      # type check
moon test       # tests
moon fmt        # format
moon info       # refresh .mbti

#License