Cache (cache)

import { Diom } from "diom";
import { Temporal } from "temporal-polyfill-lite";
 
const client = new Diom("AUTH_TOKEN");
await client.cache.set(
    "my-cache-key",
    new TextEncoder().encode("cached value"),
    { ttl: Temporal.Duration.from({ seconds: 10 }) },
);

from datetime import timedelta
from diom import Diom
from diom.models import CacheSetIn
 
client = Diom("AUTH_TOKEN")
client.cache.set(
    "my-cache-key",
    b"cached value",
    CacheSetIn(ttl_ms=timedelta(seconds=10)),
)

use diom::{DiomClient, models::CacheSetIn};
use std::time::Duration;
 
let client = DiomClient::new("AUTH_TOKEN".to_string(), None);
client.cache().set(
    "my-cache-key".to_string(),
    b"cached value".to_vec(),
    CacheSetIn::new(Duration::from_secs(10))
)
.await?;

import diom "diom.com/go/diom"
 
client, _ := diom.New("AUTH_TOKEN", nil)
client.Cache().Set(ctx, "my-cache-key", []byte("cached value"), diom.CacheSetIn{
    Ttl: diom.DurationMs(10_000),
})

import com.svix.diom.Diom;
import com.svix.diom.models.CacheSetIn;
import java.time.Duration;
 
Diom diom = new Diom("AUTH_TOKEN");
diom.cache().set("my-cache-key", "cached value".getBytes(),
    new CacheSetIn().ttl(Duration.ofSeconds(10)));

export DIOM_AUTH_TOKEN='AUTH_TOKEN'
diom cache set 'my-cache-key' 'cached value' '{"ttl_ms": 10000}'

const out = await client.cache.get("my-key", {});
if (out.value) {
    console.log("Got:", new TextDecoder().decode(out.value));
} else {
    console.log("Key not found");
}

from diom.models import CacheGetIn
 
out = client.cache.get("my-key", CacheGetIn())
if out.value:
    print(f"Got: {out.value.decode()}")
else:
    print("Key not found")

let out = client.cache()
    .get(
        "my-key".to_string(),
        CacheGetIn::new()
    )
    .await?;
 
match out.value {
    Some(bytes) => println!("Got: {}", String::from_utf8_lossy(&bytes)),
    None => println!("Key not found"),
}

out, err := client.Cache().Get(ctx, "my-key", diom.CacheGetIn{})
if err != nil {
    log.Fatal(err)
}
if out.Value != nil {
    fmt.Printf("Got: %s\n", string(out.Value))
} else {
    fmt.Println("Key not found")
}

CacheGetOut out = diom.cache().get("my-key");
if (out.getValue() != null) {
    System.out.println("Got: " + new String(out.getValue()));
} else {
    System.out.println("Key not found");
}

diom cache get 'my-key'

await client.cache.delete("my-key", {});

from diom.models import CacheDeleteIn
 
client.cache.delete("my-key", CacheDeleteIn())

client.cache().delete(
    "my-key".to_string(),
    CacheDeleteIn::new()
)
.await?;

client.Cache().Delete(ctx, "my-key", diom.CacheDeleteIn{})

diom.cache().delete("my-key");

diom cache delete 'my-key'