Files
solidcraft/crates/engine/src/schema/mod.rs
T
lillith 375d750096 Drawing: edit sheet sketches through shared commands (#7082)
Add an explicitly owned sheet entry, typed create/edit/inspect/cancel commands,
and reuse the existing rectangle/line/point implementations through the W38.0
store and R2 atomic solver boundary. Preserve source parameters and model active
state; restore the sheet entry through drawing undo/redo and checkpoints.

Eight new command tests pass. Across the selected original and new engine groups:
479 unique passed, zero failed, two pre-existing ignored. Native engine check,
strict Clippy and wasm pass. Source-hashed CI-profile artifact reused for all
runtime checks. Full repository and native/browser UI acceptance remain pending;
this is a command subset, not all sketch tools or complete W38a.

No kernel, format, dependency, shared catalog or CI changes. The pending locale
delta needs main's existing #6448 loader on the drawings receiver. Original Cam
store tests and commits retained; no competing store or parent claim.
2026-10-27 17:15:39 +01:00

66 lines
3.4 KiB
Rust

//! Typed parameter contracts for commands.
//!
//! A converted command declares a [`Contract`]: a Rust type its parameters must deserialize
//! into, from which the input JSON Schema is generated. The contract is checked *in front of*
//! the unchanged handler, which still reads the raw parameters, so a command's behaviour does
//! not change unless the session's [`ParamCheck`] level asks for warnings or refusals.
//!
//! - **Off** (the default): nothing is parsed or checked; the handler runs as before.
//! - **Warn**: the handler runs; a successful object result gains `param_warnings`.
//! - **Strict**: a call with an unknown key or a parameter of the wrong shape is refused, and
//! nothing runs.
//!
//! Unknown keys are the top-level keys a call sends that the contract's schema does not list.
//! Keys the engine reads around a command count too: `frames::to_local` reads `body` for
//! commands with picks (extrude's `face`), which the extrude contract declares; it otherwise
//! rewrites only keys a call already has. `live` is read only for commands with `.live(…)`, and
//! `timeline.redefine` adds only `convention` and `participants`, which the contracts declare.
//!
//! The shared field types in [`types`] decide acceptance by calling the same helpers the
//! handlers use (`params::vec3`, `params::expr`, `Operation::parse`, `features::profiles`…), so
//! "the contract accepts it" means "the handler's own reader accepts it". Where the handler is
//! more lenient (a value of the wrong type read as if the key were absent), the contract is the
//! stricter of the two; that difference is what warn and strict surface.
//!
//! Contracts live in one module per command file: `features.rs` for `cmd/features.rs`,
//! `inspect.rs` for `cmd/inspect.rs`, and so on, each with its own tests (`features_tests.rs`),
//! so conversions of different command files touch different files (apart from a new
//! module's line below).
//!
//! To convert a command: declare its parameters type in the module for its command file (and
//! its reply type, for an output schema), creating the module if it is the file's first
//! contract, from the shared types in [`types`] (the keys every feature takes come from
//! [`FeatureCommon`], which `solid.box` and `solid.extrude` predate); give its `CommandSpec`
//! `checked!(…)`, `.contract(…)` and `.output(…)` as `solid.extrude` does; and add it to that
//! module's `schemas_and_the_key_check_agree` and, for messages it already gives,
//! `strict_keeps_todays_errors`. Then run the whole test suite with the audit recorder (see
//! `record.rs`): a call that succeeds today but breaks the contract is either a form the
//! contract is missing or a caller's mistake.
mod check;
#[cfg_attr(target_arch = "wasm32", path = "record_wasm.rs")]
mod record;
mod types;
#[cfg(test)]
mod tests;
// The contracts, by command file.
pub mod drawing_sketch;
pub mod features;
pub mod inspect;
pub use check::{Contract, Issue, ParamCheck, TypedContract, input_schema_for, output_schema_for, run_checked};
pub use types::*;
/// A command's `run` that checks the call against `$contract` before running `$handler`
/// (see [`run_checked`]). Expands to a non-capturing closure, which coerces to the registry's
/// `Run` function pointer.
#[macro_export]
#[doc(hidden)]
macro_rules! checked {
($id:literal, $contract:path, $handler:path) => {
|s: &mut $crate::Session, p: &serde_json::Value| $crate::schema::run_checked(s, p, $id, &$contract, $handler)
};
}