use jmap_scene_types::SceneAssetComparator;
use jmap_scene_types::{SceneAsset, SceneCapability};
use jmap_types::{Id, JmapError, PatchObject};
use serde_json::{Map, Value, json};
use crate::SceneBackend;
use crate::helpers::{
SetAccumulators, default_sort, enforce_max_objects_in_set, extract_account_id, fetch_one,
finalize_set_response, forbidden, invalid, not_found, over_quota, reject_unsupported_sort,
};
use jmap_server::{
HandlerOutput, SetError, SetErrorType, backend_set_error_value, now_utc_string,
reject_server_set, server_fail_from_backend, server_fail_value_from_backend,
strip_read_only_patch,
};
pub const GLTF_BINARY: &str = "model/gltf-binary";
const OPTIONAL_STRINGS: &[&str] = &["name", "assetUri", "sha256"];
async fn ensure_scene_asset_supported<B: SceneBackend>(
backend: &B,
caller: &B::CallerCtx,
args: &Value,
) -> Result<(), JmapError> {
let Some(account_id) = args
.get("accountId")
.and_then(Value::as_str)
.and_then(|s| Id::new_validated(s).ok())
else {
return Ok(());
};
let exists = backend
.account_exists(caller, &account_id)
.await
.map_err(|e| server_fail_from_backend(&e))?;
if !exists {
return Ok(());
}
let cap = backend
.scene_capability(caller, &account_id)
.await
.map_err(|e| server_fail_from_backend(&e))?;
if !cap.supports_scene_asset {
return Err(JmapError::unknown_method());
}
Ok(())
}
pub async fn handle_scene_asset_get<B: SceneBackend>(
backend: &B,
caller: &B::CallerCtx,
args: Value,
) -> Result<HandlerOutput, JmapError> {
ensure_scene_asset_supported(backend, caller, &args).await?;
jmap_server::handle_get::<SceneAsset, B>(backend, caller, args).await
}
pub async fn handle_scene_asset_changes<B: SceneBackend>(
backend: &B,
caller: &B::CallerCtx,
args: Value,
) -> Result<HandlerOutput, JmapError> {
ensure_scene_asset_supported(backend, caller, &args).await?;
jmap_server::handle_changes::<SceneAsset, B>(backend, caller, args, &[]).await
}
pub async fn handle_scene_asset_query<B: SceneBackend>(
backend: &B,
caller: &B::CallerCtx,
args: Value,
) -> Result<HandlerOutput, JmapError> {
ensure_scene_asset_supported(backend, caller, &args).await?;
jmap_server::handle_query::<SceneAsset, B>(backend, caller, prepare_query(args)?).await
}
pub async fn handle_scene_asset_query_changes<B: SceneBackend>(
backend: &B,
caller: &B::CallerCtx,
args: Value,
) -> Result<HandlerOutput, JmapError> {
ensure_scene_asset_supported(backend, caller, &args).await?;
jmap_server::handle_query_changes::<SceneAsset, B>(backend, caller, prepare_query(args)?).await
}
fn prepare_query(mut args: Value) -> Result<Value, JmapError> {
if let Value::Object(map) = &mut args {
default_sort(
map,
json!([{ "property": "createdAt", "isAscending": false }]),
);
}
reject_unsupported_sort::<SceneAssetComparator>(args.get("sort"))?;
Ok(args)
}
pub async fn handle_scene_asset_set<B: SceneBackend>(
backend: &B,
caller: &B::CallerCtx,
args: Value,
) -> Result<HandlerOutput, JmapError> {
ensure_scene_asset_supported(backend, caller, &args).await?;
let (account_id, mut args) = extract_account_id(args)?;
if !backend
.account_exists(caller, &account_id)
.await
.map_err(|e| server_fail_from_backend(&e))?
{
return Err(JmapError::account_not_found());
}
enforce_max_objects_in_set(&args, backend.max_objects_in_set(caller, &account_id))?;
let old_state = backend
.get_state::<SceneAsset>(caller, &account_id)
.await
.map_err(|e| server_fail_from_backend(&e))?;
if let Some(if_in_state) = args.get("ifInState").and_then(Value::as_str)
&& if_in_state != old_state.as_ref()
{
return Err(JmapError::state_mismatch());
}
let mut acc = SetAccumulators::default();
let mut mutated = false;
if let Some(Value::Object(create_map)) = args.remove("create") {
for (create_id, obj) in create_map {
match create_asset(backend, caller, &account_id, &create_id, obj).await {
Ok(created) => {
mutated = true;
acc.created.insert(create_id, created);
}
Err(e) => {
acc.not_created.insert(create_id, e);
}
}
}
}
if let Some(Value::Object(update_map)) = args.remove("update") {
for (id_str, patch) in update_map {
let id = match jmap_server::parse_wire_id(&id_str, "id") {
Ok(id) => id,
Err(err) => {
acc.not_updated
.insert(id_str, serde_json::Value::from(&*err));
continue;
}
};
match update_asset(backend, caller, &account_id, &id, patch).await {
Ok(echo) => {
mutated = true;
acc.updated.insert(id_str, echo);
}
Err(e) => {
acc.not_updated.insert(id_str, e);
}
}
}
}
if let Some(Value::Array(destroy_arr)) = args.remove("destroy") {
let ids: Vec<&str> = destroy_arr
.iter()
.map(|v| v.as_str().ok_or(v))
.collect::<Result<_, _>>()
.map_err(|bad| {
JmapError::invalid_arguments(format!(
"destroy: every element must be a string Id; got {}",
jmap_server::json_type_name(bad)
))
})?;
for id_str in ids {
let id = match jmap_server::parse_wire_id(id_str, "id") {
Ok(id) => id,
Err(err) => {
acc.not_destroyed
.insert(id_str.to_owned(), serde_json::Value::from(&*err));
continue;
}
};
match destroy_asset(backend, caller, &account_id, &id).await {
Ok(()) => {
mutated = true;
acc.destroyed.push(Value::String(id_str.to_owned()));
}
Err(e) => {
acc.not_destroyed.insert(id_str.to_owned(), e);
}
}
}
}
finalize_set_response::<B, SceneAsset>(backend, caller, &account_id, old_state, mutated, acc)
.await
}
fn media_type_supported(cap: &SceneCapability, media_type: &str) -> bool {
let listed = |t: &str| t.eq_ignore_ascii_case(media_type);
let audio_or_image = media_type.split_once('/').is_some_and(|(top, sub)| {
!sub.is_empty() && (top.eq_ignore_ascii_case("audio") || top.eq_ignore_ascii_case("image"))
});
listed(GLTF_BINARY) || cap.supported_visual_types.iter().any(|t| listed(t)) || audio_or_image
}
fn is_lowercase_sha256(s: &str) -> bool {
s.len() == 64 && s.bytes().all(|b| matches!(b, b'0'..=b'9' | b'a'..=b'f'))
}
fn malformed<'a>(m: &'a Map<String, Value>, cap: &SceneCapability) -> Vec<&'a str> {
let mut bad = Vec::new();
if let Some((key, v)) = m.get_key_value("mediaType")
&& !v.as_str().is_some_and(|t| media_type_supported(cap, t))
{
bad.push(key.as_str());
}
for (key, v) in m
.iter()
.filter(|(k, _)| OPTIONAL_STRINGS.contains(&k.as_str()))
{
let ok = match v {
Value::Null => true,
Value::String(s) => key != "sha256" || is_lowercase_sha256(s),
_ => false,
};
if !ok {
bad.push(key.as_str());
}
}
bad
}
async fn capability<B: SceneBackend>(
backend: &B,
caller: &B::CallerCtx,
account_id: &Id,
) -> Result<SceneCapability, Value> {
backend
.scene_capability(caller, account_id)
.await
.map_err(|e| server_fail_value_from_backend(&e))
}
async fn create_asset<B: SceneBackend>(
backend: &B,
caller: &B::CallerCtx,
account_id: &Id,
create_id: &str,
obj: Value,
) -> Result<Value, Value> {
let Value::Object(mut m) = obj else {
return Err(invalid(&[], "a SceneAsset create must be a JSON object"));
};
if let Some(e) = reject_server_set::<SceneAsset>(&m) {
return Err(serde_json::Value::from(
&e.with_description("these properties are set by the server"),
));
}
let cap = capability(backend, caller, account_id).await?;
let mut bad = malformed(&m, &cap);
if !m.contains_key("mediaType") {
bad.push("mediaType");
}
let blob_id = m
.get("blobId")
.and_then(Value::as_str)
.and_then(|s| Id::new_validated(s).ok());
if blob_id.is_none() {
bad.push("blobId");
}
let Some(blob_id) = blob_id.filter(|_| bad.is_empty()) else {
bad.sort_unstable();
return Err(invalid(
&bad,
"blobId and mediaType are required; mediaType must be supported; \
name, assetUri and sha256 must be strings or null, sha256 lowercase hex",
));
};
let size = backend
.blob_size(caller, account_id, &blob_id)
.await
.map_err(|e| server_fail_value_from_backend(&e))?
.ok_or_else(|| invalid(&["blobId"], "blobId does not reference an uploaded blob"))?;
if cap.max_asset_size_bytes.is_some_and(|max| size > max) {
return Err(over_quota("the asset exceeds maxAssetSizeBytes"));
}
let owner_id = backend
.caller_user_id(caller, account_id)
.await
.map_err(|e| server_fail_value_from_backend(&e))?;
for key in OPTIONAL_STRINGS {
m.entry(*key).or_insert(Value::Null);
}
m.insert("id".to_owned(), json!(jmap_server::CREATE_ID_PLACEHOLDER));
m.insert("accountId".to_owned(), json!(account_id));
m.insert("ownerId".to_owned(), json!(owner_id));
m.insert("size".to_owned(), json!(size));
m.insert("createdAt".to_owned(), json!(now_utc_string()));
let mut asset: SceneAsset = serde_json::from_value(Value::Object(m))
.map_err(|e| invalid(&[], &format!("invalid SceneAsset: {e}")))?;
let (id, stored) = backend
.create_object(caller, account_id, create_id, move |id: &Id| {
asset.id = id.clone();
asset
})
.await
.map_err(backend_set_error_value)?;
Ok(json!({
"id": id,
"accountId": stored.account_id,
"ownerId": stored.owner_id,
"size": stored.size,
"createdAt": stored.created_at,
}))
}
async fn fetch_modifiable<B: SceneBackend>(
backend: &B,
caller: &B::CallerCtx,
account_id: &Id,
id: &Id,
) -> Result<SceneAsset, Value> {
let asset: SceneAsset = fetch_one(backend, caller, account_id, id)
.await?
.ok_or_else(not_found)?;
if !backend
.may_modify_asset(caller, account_id, &asset)
.await
.map_err(|e| server_fail_value_from_backend(&e))?
{
return Err(forbidden(
"only the asset owner or an admin may modify this asset",
));
}
Ok(asset)
}
async fn update_asset<B: SceneBackend>(
backend: &B,
caller: &B::CallerCtx,
account_id: &Id,
id: &Id,
patch: Value,
) -> Result<Value, Value> {
let mut patch: PatchObject = serde_json::from_value(patch).map_err(|e| {
serde_json::Value::from(
&SetError::new(SetErrorType::InvalidPatch).with_description(e.to_string()),
)
})?;
let asset = fetch_modifiable(backend, caller, account_id, id).await?;
let Value::Object(stored) = jmap_server::serialize_value(&asset)
.map_err(|e| jmap_server::server_fail_value_from_backend(&e))?
else {
unreachable!("a SceneAsset serializes as a JSON object")
};
strip_read_only_patch::<SceneAsset>(patch.as_map_mut(), Some(&stored)).map_err(|e| {
serde_json::Value::from(&(*e).with_description("these properties cannot be changed"))
})?;
if patch.as_map().is_empty() {
return Ok(Value::Null);
}
let cap = capability(backend, caller, account_id).await?;
let bad = malformed(patch.as_map(), &cap);
if !bad.is_empty() {
return Err(invalid(
&bad,
"name, assetUri and sha256 must be strings or null, sha256 lowercase hex",
));
}
match backend
.update_object::<SceneAsset>(caller, account_id, id, patch)
.await
.map_err(backend_set_error_value)?
{
Some(asset) => Ok(jmap_server::serialize_value(asset)
.map_err(|e| jmap_server::server_fail_value_from_backend(&e))?),
None => Ok(Value::Null),
}
}
async fn destroy_asset<B: SceneBackend>(
backend: &B,
caller: &B::CallerCtx,
account_id: &Id,
id: &Id,
) -> Result<(), Value> {
fetch_modifiable(backend, caller, account_id, id).await?;
backend
.destroy_object::<SceneAsset>(caller, account_id, id)
.await
.map_err(backend_set_error_value)
}