use std::collections::{BTreeMap, HashMap};
use jmap_scene_types::SceneObjectComparator;
use jmap_scene_types::{IDENTITY_ORIENTATION, SceneObject, SceneRegion};
use jmap_types::{Id, JmapError, PatchObject};
use serde_json::{Map, Value, json};
use crate::SceneBackend;
use crate::asset::GLTF_BINARY;
use crate::helpers::{
SetAccumulators, check_region_filter, default_sort, enforce_max_objects_in_set,
extract_account_id, fetch_one, finalize_set_response, finite3, forbidden, handle_get_visible,
invalid, is_visible, normalized_quaternion, not_found, orientation_ok, reject_unsupported_sort,
};
use crate::helpers::{parents_first, resolve_refs};
use jmap_server::{
HandlerOutput, SetError, SetErrorType, apply_patch_object, backend_set_error_value,
now_utc_string, reject_read_only_patch, reject_server_set, server_fail_from_backend,
server_fail_value_from_backend,
};
const PHYSICS_MODES: &[&str] = &["static", "dynamic", "kinematic", "none"];
const MAX_DEPTH: usize = 16;
pub async fn handle_scene_object_get<B: SceneBackend>(
backend: &B,
caller: &B::CallerCtx,
args: Value,
) -> Result<HandlerOutput, JmapError> {
handle_get_visible::<SceneObject, B>(backend, caller, args).await
}
pub async fn handle_scene_object_changes<B: SceneBackend>(
backend: &B,
caller: &B::CallerCtx,
args: Value,
) -> Result<HandlerOutput, JmapError> {
jmap_server::handle_changes::<SceneObject, B>(backend, caller, args, &[]).await
}
pub async fn handle_scene_object_query<B: SceneBackend>(
backend: &B,
caller: &B::CallerCtx,
args: Value,
) -> Result<HandlerOutput, JmapError> {
jmap_server::handle_query::<SceneObject, B>(backend, caller, prepare_query(args)?).await
}
pub async fn handle_scene_object_query_changes<B: SceneBackend>(
backend: &B,
caller: &B::CallerCtx,
args: Value,
) -> Result<HandlerOutput, JmapError> {
jmap_server::handle_query_changes::<SceneObject, 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": true }]),
);
}
reject_unsupported_sort::<SceneObjectComparator>(args.get("sort"))?;
match args.get("filter") {
None | Some(Value::Null) => {
Err(JmapError::invalid_arguments("filter.regionId is required"))
}
Some(filter) => check_filter(filter),
}?;
Ok(args)
}
fn check_filter(filter: &Value) -> Result<(), JmapError> {
check_region_filter(filter, &|c| match c.get("physicsMode") {
Some(m) if !m.as_str().is_some_and(|m| PHYSICS_MODES.contains(&m)) => {
Err(JmapError::invalid_arguments(format!(
"filter physicsMode must be \"static\", \"dynamic\", \"kinematic\" or \"none\"; got {m}"
)))
}
_ => Ok(()),
})
}
const OBJECT_ID_PROPERTIES: &[&str] = &["regionId", "parentId"];
pub async fn handle_scene_object_set<B: SceneBackend>(
backend: &B,
caller: &B::CallerCtx,
created_ids: &BTreeMap<Id, Id>,
args: Value,
) -> Result<HandlerOutput, JmapError> {
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::<SceneObject>(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;
let mut created_ids = created_ids.clone();
if let Some(Value::Object(create_map)) = args.remove("create") {
for (create_id, mut obj) in parents_first(create_map, "parentId") {
if let Err(err) = resolve_refs(&mut obj, OBJECT_ID_PROPERTIES, &created_ids) {
acc.not_created
.insert(create_id, serde_json::Value::from(&*err));
continue;
}
match create_scene_object(backend, caller, &account_id, &create_id, obj).await {
Ok(created) => {
mutated = true;
if let Some(id) = created.get("id").and_then(Value::as_str) {
created_ids.insert(Id::from(create_id.as_str()), Id::from(id));
}
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, mut 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;
}
};
if let Err(err) = resolve_refs(&mut patch, OBJECT_ID_PROPERTIES, &created_ids) {
acc.not_updated
.insert(id_str, serde_json::Value::from(&*err));
continue;
}
match update_scene_object(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_scene_object(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, SceneObject>(backend, caller, &account_id, old_state, mutated, acc)
.await
}
fn malformed(m: &Map<String, Value>) -> Vec<&'static str> {
let mut bad = Vec::new();
let mut check = |key: &'static str, ok: bool| {
if !ok {
bad.push(key);
}
};
let optional = |key: &str, ok: fn(&Value) -> bool| m.get(key).is_none_or(ok);
check("regionId", m.get("regionId").is_some_and(Value::is_string));
check("position", m.get("position").is_some_and(finite3));
check("orientation", optional("orientation", orientation_ok));
check("scale", optional("scale", finite3));
check(
"physicsMode",
optional("physicsMode", |v| {
v.as_str().is_some_and(|p| PHYSICS_MODES.contains(&p))
}),
);
for key in ["parentId", "name", "visualRef", "visualType", "assetUri"] {
check(key, optional(key, |v| v.is_null() || v.is_string()));
}
for key in ["interactable", "visible"] {
check(key, optional(key, Value::is_boolean));
}
check(
"worldState",
optional("worldState", |v| v.is_null() || v.is_object()),
);
let present = |key: &str| m.get(key).is_some_and(|v| !v.is_null());
if present("visualRef") != present("visualType") {
bad.extend(["visualRef", "visualType"]);
}
bad
}
async fn check_visual_type<B: SceneBackend>(
backend: &B,
caller: &B::CallerCtx,
account_id: &Id,
visual_type: &str,
) -> Result<(), Value> {
let cap = backend
.scene_capability(caller, account_id)
.await
.map_err(|e| server_fail_value_from_backend(&e))?;
if visual_type == GLTF_BINARY || cap.supported_visual_types.iter().any(|t| t == visual_type) {
Ok(())
} else {
Err(invalid(
&["visualType"],
"visualType is not in supportedVisualTypes",
))
}
}
async fn check_visual_ref<B: SceneBackend>(
backend: &B,
caller: &B::CallerCtx,
account_id: &Id,
visual_ref: &str,
) -> Result<(), Value> {
backend
.blob_size(
caller,
account_id,
&Id::new_validated(visual_ref).map_err(|e| invalid(&["visualRef"], &e.to_string()))?,
)
.await
.map_err(|e| server_fail_value_from_backend(&e))?
.map(|_| ())
.ok_or_else(|| {
invalid(
&["visualRef"],
"visualRef does not reference an uploaded blob",
)
})
}
async fn check_parent<B: SceneBackend>(
backend: &B,
caller: &B::CallerCtx,
account_id: &Id,
region_id: &Id,
self_id: Option<&Id>,
parent_id: &Id,
height: usize,
) -> Result<(), Value> {
let mut depth = 0;
let mut next = Some(parent_id.clone());
while let Some(id) = next {
if self_id == Some(&id) {
return Err(invalid(
&["parentId"],
"parentId would make the object its own ancestor",
));
}
depth += 1;
if depth + height > MAX_DEPTH {
return Err(invalid(
&["parentId"],
"parentId would make the scene graph deeper than 16 levels",
));
}
let Some(ancestor): Option<SceneObject> =
fetch_one(backend, caller, account_id, &id).await?
else {
if depth == 1 {
return Err(invalid(
&["parentId"],
"parentId does not reference an existing SceneObject",
));
}
break;
};
if ancestor.region_id != *region_id {
return Err(invalid(
&["parentId"],
"parentId references a SceneObject in a different region",
));
}
next = ancestor.parent_id;
}
Ok(())
}
async fn subtree_height<B: SceneBackend>(
backend: &B,
caller: &B::CallerCtx,
account_id: &Id,
id: &Id,
) -> Result<usize, Value> {
let (all, _) = backend
.get_objects::<SceneObject>(caller, account_id, None, None)
.await
.map_err(|e| server_fail_value_from_backend(&e))?;
let mut children: HashMap<&Id, Vec<&Id>> = HashMap::new();
for o in &all {
if let Some(p) = &o.parent_id {
children.entry(p).or_default().push(&o.id);
}
}
let mut level = vec![id];
let mut height = 0;
while !level.is_empty() && height <= MAX_DEPTH {
height += 1;
level = level
.iter()
.filter_map(|p| children.get(p))
.flatten()
.copied()
.collect();
}
Ok(height)
}
fn refuse_malformed(mut bad: Vec<&'static str>) -> Result<(), Value> {
if bad.is_empty() {
return Ok(());
}
bad.sort_unstable();
bad.dedup();
Err(invalid(
&bad,
"regionId and position are required, position and scale finite, orientation a unit \
quaternion, physicsMode static, dynamic, kinematic or none, visualRef and visualType \
together",
))
}
async fn create_scene_object<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 SceneObject create must be a JSON object"));
};
let cap = backend
.scene_capability(caller, account_id)
.await
.map_err(|e| server_fail_value_from_backend(&e))?;
if !cap.may_create_object {
return Err(forbidden("mayCreateObject is false"));
}
if let Some(e) = reject_server_set::<SceneObject>(&m) {
return Err(serde_json::Value::from(
&e.with_description("these properties are set by the server"),
));
}
refuse_malformed(malformed(&m))?;
if let Some(t) = m.get("visualType").and_then(Value::as_str) {
check_visual_type(backend, caller, account_id, t).await?;
}
let region_id = Id::new_validated(m["regionId"].as_str().unwrap_or_default())
.map_err(|e| invalid(&["regionId"], &e.to_string()))?;
let inaccessible = || invalid(&["regionId"], "regionId is not an accessible SceneRegion");
fetch_one::<SceneRegion, B>(backend, caller, account_id, ®ion_id)
.await?
.ok_or_else(inaccessible)?;
if !backend
.may_access_region(caller, account_id, ®ion_id)
.await
.map_err(|e| server_fail_value_from_backend(&e))?
{
return Err(inaccessible());
}
if let Some(r) = m.get("visualRef").and_then(Value::as_str) {
check_visual_ref(backend, caller, account_id, r).await?;
}
if let Some(p) = m.get("parentId").and_then(Value::as_str) {
check_parent(
backend,
caller,
account_id,
®ion_id,
None,
&Id::new_validated(p).map_err(|e| invalid(&["parentId"], &e.to_string()))?,
1,
)
.await?;
}
let mut echo_orientation = !m.contains_key("orientation");
m.entry("orientation")
.or_insert_with(|| json!(IDENTITY_ORIENTATION));
if let Some(q) = normalized_quaternion(&m, "orientation") {
m.insert("orientation".to_owned(), q);
echo_orientation = true;
}
let now = now_utc_string();
m.insert("id".to_owned(), json!(jmap_server::CREATE_ID_PLACEHOLDER));
m.insert("ownerId".to_owned(), Value::Null);
m.insert("createdAt".to_owned(), json!(now));
m.insert("updatedAt".to_owned(), json!(now));
let mut object: SceneObject = serde_json::from_value(Value::Object(m))
.map_err(|e| invalid(&[], &format!("invalid SceneObject: {e}")))?;
let (id, stored) = backend
.create_object(caller, account_id, create_id, move |id: &Id| {
object.id = id.clone();
object
})
.await
.map_err(backend_set_error_value)?;
let mut created = json!({
"id": id,
"ownerId": stored.owner_id,
"createdAt": stored.created_at,
"updatedAt": stored.updated_at,
});
if echo_orientation {
created["orientation"] = json!(stored.orientation);
}
Ok(created)
}
async fn fetch_modifiable<B: SceneBackend>(
backend: &B,
caller: &B::CallerCtx,
account_id: &Id,
id: &Id,
) -> Result<SceneObject, Value> {
let object: SceneObject = fetch_one(backend, caller, account_id, id)
.await?
.ok_or_else(not_found)?;
if !is_visible(backend, caller, account_id, &object)
.await
.map_err(|e| server_fail_value_from_backend(&e))?
{
return Err(not_found());
}
if backend
.may_modify_object(caller, account_id, &object)
.await
.map_err(|e| server_fail_value_from_backend(&e))?
{
Ok(object)
} else {
Err(forbidden(
"Caller is not the object owner, region owner, or an administrator.",
))
}
}
async fn update_scene_object<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 object = fetch_modifiable(backend, caller, account_id, id).await?;
let top = |k: &str| k.split('/').next().unwrap_or(k).to_owned();
let patched: Vec<String> = patch.as_map().keys().map(|k| top(k)).collect();
let Value::Object(mut result) = jmap_server::serialize_value(&object)
.map_err(|e| jmap_server::server_fail_value_from_backend(&e))?
else {
unreachable!("a SceneObject serializes as a JSON object")
};
if let Some(e) = reject_read_only_patch::<SceneObject>(patch.as_map(), Some(&result)) {
return Err(serde_json::Value::from(&e.with_description(
"these properties are set by the server or immutable",
)));
}
apply_patch_object(&mut result, patch.as_map()).map_err(|e| {
serde_json::Value::from(
&SetError::new(SetErrorType::InvalidPatch).with_description(e.to_string()),
)
})?;
refuse_malformed(malformed(&result))?;
let touched = |k: &str| patched.iter().any(|p| p == k);
if touched("visualType")
&& let Some(t) = result.get("visualType").and_then(Value::as_str)
{
check_visual_type(backend, caller, account_id, t).await?;
}
if touched("visualRef")
&& let Some(r) = result.get("visualRef").and_then(Value::as_str)
{
check_visual_ref(backend, caller, account_id, r).await?;
}
if touched("parentId")
&& let Some(p) = result.get("parentId").and_then(Value::as_str)
{
let height = subtree_height(backend, caller, account_id, id).await?;
check_parent(
backend,
caller,
account_id,
&object.region_id,
Some(id),
&Id::new_validated(p).map_err(|e| invalid(&["parentId"], &e.to_string()))?,
height,
)
.await?;
}
let now = now_utc_string();
let mut echo = Map::new();
echo.insert("updatedAt".to_owned(), json!(now));
let map = patch.as_map_mut();
if touched("orientation")
&& let Some(q) = normalized_quaternion(&result, "orientation")
{
map.retain(|k, _| top(k) != "orientation");
map.insert("orientation".to_owned(), q.clone());
echo.insert("orientation".to_owned(), q);
}
map.insert("updatedAt".to_owned(), json!(now));
match backend
.update_object::<SceneObject>(caller, account_id, id, patch)
.await
.map_err(backend_set_error_value)?
{
Some(object) => Ok(jmap_server::serialize_value(object)
.map_err(|e| jmap_server::server_fail_value_from_backend(&e))?),
None => Ok(Value::Object(echo)),
}
}
async fn destroy_scene_object<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::<SceneObject>(caller, account_id, id)
.await
.map_err(backend_set_error_value)
}