Kotlin SDK Reference

import com.onyx.cloud.api.onyx

val db = onyx.init<Any>()

val account = Account(id = "acct_1", name = "Checking", balance = 1250.0)
db.save(account)

val fetched: Account? = db.findById("acct_1")

db.save(account.copy(balance = 1400.0))

db.delete("Account", "acct_1")

val txns = listOf(
  Transaction(id = "txn_batch_1", accountId = "acct_batch", amount = 1.99, currency = "USD"),
  Transaction(id = "txn_batch_2", accountId = "acct_batch", amount = 12.5, currency = "USD"),
  Transaction(id = "txn_batch_3", accountId = "acct_batch", amount = 45.0, currency = "USD"),
  Transaction(id = "txn_batch_4", accountId = "acct_batch", amount = 7.25, currency = "USD"),
)

db.save(Transaction::class, txns)

import com.onyx.cloud.api.*

val results = db.from<Transaction>()
  .where("status" eq "posted")
  .and("amount" gt 100.0)
  .and("createdAt" gte "2025-01-01")
  .and(contains("merchant", "aws"))
  .orderBy(desc("createdAt"))
  .limit(25)
  .list<Transaction>()

val rows = db.select("id", "accountId", "amount", "createdAt")
  .from<Transaction>()
  .list<Map<String, Any>>()

import com.onyx.cloud.api.eq

val tx: Transaction? = db.from<Transaction>()
  .where("id" eq "txn_123")
  .firstOrNull()

val txOne: Transaction? = db.from<Transaction>()
  .where("id" eq "txn_123")
  .one()

import com.onyx.cloud.api.*

val accounts = db.from<Account>()
  .where(
    within(
      "id",
      db.select("accountId")
        .from<Transaction>()
        .where(gt("amount", 1000.0))
    )
  )
  .list<Account>()

import com.onyx.cloud.api.eq

val updatedCount = db.from<Transaction>()
  .where("status" eq "pending")
  .and("amount" gt 100.0)
  .setUpdates("status" to "posted")
  .update()

import com.onyx.cloud.api.eq

val deleted = db.from<Transaction>()
  .where("status" eq "archived")
  .delete()

import com.onyx.cloud.api.eq

val grouped = db.select("merchant", "currency")
  .from<Transaction>()
  .where("status" eq "posted")
  .groupBy("merchant", "currency")
  .list<Map<String, Any>>()

import com.onyx.cloud.api.*

val totals = db.select(sum("amount"), "merchant")
  .from<Transaction>()
  .where("status" eq "posted")
  .list<Map<String, Any>>()

import com.onyx.cloud.api.eq

val events = mutableListOf<Transaction>()
val subscription = db.from<Transaction>()
  .where("status" eq "posted")
  .onItem<Transaction> { events.add(it) }
  .onItemAdded<Transaction> { events.add(it) }
  .onItemUpdated<Transaction> { events.add(it) }
  .onItemDeleted<Transaction> { events.add(it) }
  .stream<Transaction>(includeQueryResults = true, keepAlive = true)

// later
subscription.cancelAndJoin()

import com.onyx.cloud.api.asc

val page1 = db.from<Transaction>()
  .orderBy(asc("createdAt"))
  .limit(50)
  .page<Transaction>()

val next = page1.nextPage
if (next != null) {
  val page2 = db.from<Transaction>()
    .orderBy(asc("createdAt"))
    .page<Transaction>(nextPage = next)
}

// JVM example using the Java 11+ HTTP client.
import java.net.URI
import java.net.URLEncoder
import java.net.http.HttpClient
import java.net.http.HttpRequest
import java.net.http.HttpResponse
import java.nio.charset.StandardCharsets.UTF_8
import java.time.Duration

fun main() {
    fun env(name: String) = requireNotNull(System.getenv(name)) { "Set " + name }
    fun path(value: String) = URLEncoder.encode(value, UTF_8).replace("+", "%20")
    val baseUrl = (System.getenv("ONYX_DATABASE_BASE_URL") ?: "https://api.onyx.dev").trimEnd('/')
    val endpoint = baseUrl + "/data/" + path(env("ONYX_DATABASE_ID")) +
        "/model-builder/published-model/" + path("churn-model") + "/predict"
    val client = HttpClient.newHttpClient()

    fun predictRequest(body: String, suffix: String = ""): String {
        val request = HttpRequest.newBuilder(URI.create(endpoint + suffix))
            .timeout(Duration.ofSeconds(60))
            .header("Content-Type", "application/json")
            .header("x-onyx-key", env("ONYX_DATABASE_API_KEY"))
            .header("x-onyx-secret", env("ONYX_DATABASE_API_SECRET"))
            .POST(HttpRequest.BodyPublishers.ofString(body))
            .build()
        val response = client.send(request, HttpResponse.BodyHandlers.ofString())
        check(response.statusCode() in 200..299) {
            "Prediction failed: " + response.statusCode()
        }
        return response.body()
    }

    val result = predictRequest("""{
      "inputs": [
        {"accountAgeDays": 420, "usageScore": 0.87},
        {"accountAgeDays": 90, "usageScore": 0.42}
      ]
    }""")
    println(result)

    val scriptResult = predictRequest("""{
      "scriptId": "score-active-customers",
      "scriptParameters": {"segment": "enterprise", "limit": "50"}
    }""", "/script")
    println(scriptResult)
}

val current = db.getSchema() ?: emptyMap<String, Any>()
val next = current.toMutableMap().apply {
  // modify entities/attributes here
  put("revisionDescription", "Describe your change")
}

val diff = db.diffSchema(next)
val validation = db.validateSchema(next)
if (validation.valid == true) {
  db.updateSchema(next, publish = true)
}