fluxpro-engine 0.1.5

A feature-gated workflow and process engine
Documentation
use super::Session;
use crate::editor::settings::{duration_parts, duration_value};
use leptos::prelude::*;
use serde_json::{Value, json};

#[derive(Clone, Copy)]
pub(super) struct Field {
    pub draft: RwSignal<Value>,
    path: StoredValue<String>,
}
impl Field {
    pub fn root(draft: RwSignal<Value>) -> Self {
        Self {
            draft,
            path: StoredValue::new(String::new()),
        }
    }
    pub fn child(self, key: impl ToString) -> Self {
        Self {
            draft: self.draft,
            path: StoredValue::new(format!(
                "{}/{}",
                self.path.get_value(),
                key.to_string().replace('~', "~0").replace('/', "~1")
            )),
        }
    }
    pub fn get(self) -> Value {
        self.draft.with(|v| {
            v.pointer(&self.path.get_value())
                .cloned()
                .unwrap_or(Value::Null)
        })
    }
    pub fn text(self) -> String {
        match self.get() {
            Value::String(v) => v,
            Value::Null => String::new(),
            v => v.to_string(),
        }
    }
    pub fn set(self, value: Value) {
        self.draft.update(|v| {
            set_path(v, &self.path.get_value(), value);
        });
    }
}
fn set_path(root: &mut Value, path: &str, value: Value) {
    if path.is_empty() {
        *root = value;
        return;
    }
    let (parent, key) = path.rsplit_once('/').unwrap();
    let key = key.replace("~1", "/").replace("~0", "~");
    if root.pointer(parent).is_none_or(Value::is_null) {
        set_path(root, parent, json!({}));
    }
    if let Some(target) = root.pointer_mut(parent) {
        match target {
            Value::Array(items) => {
                if let Ok(i) = key.parse::<usize>() {
                    if let Some(item) = items.get_mut(i) {
                        *item = value;
                    }
                }
            }
            _ => target[&key] = value,
        }
    }
}

#[component]
pub(super) fn TextField(
    field: Field,
    label: &'static str,
    #[prop(default = "text")] kind: &'static str,
    #[prop(default = false)] optional: bool,
) -> impl IntoView {
    view! { <label class="fp-field">{label}<input type=kind step="any" prop:value=move || field.text() on:input=move |ev| {
        let value = event_target_value(&ev);
        field.set(if optional && value.is_empty() { Value::Null } else if kind == "number" { serde_json::from_str::<Value>(&value).ok().filter(Value::is_number).unwrap_or(json!(value)) } else { json!(value) });
    }/></label> }
}
#[component]
pub(super) fn Notes(field: Field, label: &'static str) -> impl IntoView {
    view! { <label class="fp-field">{label}<textarea rows="3" prop:value=move || field.text() on:input=move |ev| field.set(json!(event_target_value(&ev)))></textarea></label> }
}
#[component]
pub(super) fn Check(field: Field, label: &'static str) -> impl IntoView {
    view! { <label class="fp-check"><input type="checkbox" prop:checked=move || field.get().as_bool().unwrap_or(false) on:change=move |ev| field.set(json!(event_target_checked(&ev)))/>{label}</label> }
}
#[component]
pub(super) fn Select(
    field: Field,
    label: &'static str,
    options: Signal<Vec<String>>,
    #[prop(default = true)] optional: bool,
) -> impl IntoView {
    // Retain unresolved imported references so opening a form never drops them.
    let choices = Memo::new(move |_| {
        let mut values = options.get();
        let current = field.text();
        if !current.is_empty() && !values.contains(&current) {
            values.insert(0, current);
        }
        values
    });
    view! { <label class="fp-field">{label}<select prop:value=move || field.text() on:change=move |ev| { let value=event_target_value(&ev); field.set(if value.is_empty() {Value::Null} else {json!(value)}); }>
        <option value="">{if optional { "None" } else { "Choose…" }}</option>
        {move || choices.get().into_iter().map(|id| view! { <option value=id.clone()>{id.clone()}</option> }).collect_view()}
    </select></label> }
}
pub(super) fn fixed(values: &[&str]) -> Signal<Vec<String>> {
    Signal::stored(values.iter().map(|s| s.to_string()).collect())
}
pub(super) fn catalog(session: Session, kind: &'static str) -> Signal<Vec<String>> {
    Signal::derive(move || {
        session.state.with(|s| match kind {
            "forms" => s
                .document
                .definition
                .forms
                .iter()
                .map(|f| f.id.to_string())
                .collect(),
            "signals" => s
                .document
                .definition
                .signals
                .iter()
                .map(|f| f.name().to_owned())
                .collect(),
            "stages" => s
                .document
                .definition
                .stages
                .iter()
                .map(|f| f.id().to_string())
                .collect(),
            "topics" => s
                .document
                .definition
                .escalations
                .iter()
                .map(|f| f.topic.to_string())
                .collect(),
            _ => s
                .document
                .definition
                .nodes
                .iter()
                .filter(|n| !n.is_start())
                .map(|n| n.id().to_string())
                .collect(),
        })
    })
}
#[component]
pub(super) fn Toggle(field: Field, label: &'static str, initial: Value) -> impl IntoView {
    let initial = StoredValue::new(initial);
    view! { <label class="fp-check"><input type="checkbox" prop:checked=move || !field.get().is_null() on:change=move |ev| field.set(if event_target_checked(&ev) { initial.get_value() } else { Value::Null })/>{label}</label> }
}
#[component]
pub(super) fn DurationField(field: Field, label: &'static str) -> impl IntoView {
    let initial_value = untrack(move || field.text());
    let initial = duration_parts(&initial_value);
    let amount = RwSignal::new(initial.0);
    let unit = RwSignal::new(initial.1);
    let written = RwSignal::new(initial_value);
    Effect::new(move |_| {
        let current = field.text();
        if current != written.get_untracked() {
            let parts = duration_parts(&current);
            amount.set(parts.0);
            unit.set(parts.1);
            written.set(current);
        }
    });
    let write = move || {
        let value = duration_value(&amount.get_untracked(), &unit.get_untracked());
        written.set(value.clone());
        field.set(json!(value));
    };
    view! { <div class="fp-duration"><label class="fp-field">{label}<input prop:value=move || amount.get() on:input=move |ev| { amount.set(event_target_value(&ev)); write(); }/></label>
        <label class="fp-field">"Unit"<select aria-label=format!("{label} unit") prop:value=move || unit.get() on:change=move |ev| {
            let next=event_target_value(&ev);
            if next == "custom" { amount.set(field.text()); } else if unit.get_untracked() == "custom" { amount.set("1".into()); }
            unit.set(next); write();
        }><option value="seconds">"Seconds"</option><option value="minutes">"Minutes"</option><option value="hours">"Hours"</option><option value="days">"Days"</option><option value="weeks">"Weeks"</option><option value="custom">"ISO duration"</option></select></label></div>
    }
}
#[component]
pub(super) fn DateField(field: Field, label: &'static str) -> impl IntoView {
    view! { <label class="fp-field">{label}<input type="datetime-local" step="any" prop:value=move || {
        chrono::DateTime::parse_from_rfc3339(&field.text()).map(|v| v.with_timezone(&chrono::Utc).format("%Y-%m-%dT%H:%M:%S%.f").to_string()).unwrap_or_else(|_| field.text().trim_end_matches('Z').to_owned())
    } on:input=move |ev| { let value=event_target_value(&ev); field.set(if value.is_empty() { Value::Null } else { json!(format!("{}Z", if value.len()==16 {format!("{value}:00")} else {value})) }); }/></label> }
}

#[component]
pub(super) fn HandlerField(field: Field, label: &'static str, session: Session) -> impl IntoView {
    let list_id = format!("fp-handlers-{}", field.path.get_value().replace('/', "-"));
    let options = move || {
        session.state.with(|s| {
            let root = serde_json::to_value(&s.document.definition).unwrap_or_default();
            let mut values = root["nodes"]
                .as_array()
                .into_iter()
                .flatten()
                .filter_map(|n| n["handler"].as_str().map(str::to_owned))
                .collect::<Vec<_>>();
            if let Some(hooks) = root["special_handlers"].as_object() {
                for hook in hooks.values() {
                    if let Some(id) = hook.as_str().or_else(|| hook["handler"].as_str()) {
                        values.push(id.into());
                    }
                }
            }
            values.sort();
            values.dedup();
            values
        })
    };
    view! { <label class="fp-field">{label}<input list=list_id.clone() prop:value=move || field.text() on:input=move |ev| field.set(json!(event_target_value(&ev)))/></label>
    <datalist id=list_id>{move || options().into_iter().map(|id| view!{ <option value=id/> }).collect_view()}</datalist> }
}
/// Recursive editor for ordinary JSON and the engine's typed ContextValue wrappers.
#[component]
pub(super) fn ValueEditor(
    field: Field,
    #[prop(default = false)] typed: bool,
    session: Session,
) -> impl IntoView {
    let kind = Memo::new(move |_| value_kind(&field.get(), typed));
    let options = if typed {
        fixed(&[
            "string", "id_field", "number", "float", "date", "datetime", "boolean", "array",
            "object",
        ])
    } else {
        fixed(&["string", "number", "boolean", "array", "object", "null"])
    };
    view! { <div class="fp-value-editor">
        <label class="fp-field">"Value type"<select prop:value=move || kind.get() on:change=move |ev| {
            let k=event_target_value(&ev); let value=default_value(&k);
            field.set(if typed {json!({k:value})} else {value});
        }>{move || options.get().into_iter().map(|k| view!{<option value=k.clone()>{k.clone()}</option>}).collect_view()}</select></label>
        {move || {
            let k=kind.get(); let payload=if typed {field.child(&k)} else {field};
            match k.as_str() {
                "object" => view!{<ObjectEditor field=payload typed=false session=session/>}.into_any(),
                "array" => view!{<ArrayEditor field=payload typed=typed session=session/>}.into_any(),
                "boolean" => view!{<Check field=payload label="Enabled"/>}.into_any(),
                "datetime" => view!{<DateField field=payload label="Date and time (UTC)"/>}.into_any(),
                "date" => view!{<TextField field=payload label="Date" kind="date"/>}.into_any(),
                "number" | "float" => view!{<TextField field=payload label="Number" kind="number"/>}.into_any(),
                "null" => view!{<p>"Empty value"</p>}.into_any(),
                _ => view!{<TextField field=payload label="Value"/>}.into_any(),
            }
        }}
    </div> }
}
fn value_kind(value: &Value, typed: bool) -> String {
    if typed {
        return value
            .as_object()
            .and_then(|v| v.keys().next())
            .cloned()
            .unwrap_or("string".into());
    }
    match value {
        Value::Object(_) => "object",
        Value::Array(_) => "array",
        Value::Bool(_) => "boolean",
        Value::Number(_) => "number",
        Value::Null => "null",
        _ => "string",
    }
    .into()
}
fn default_value(kind: &str) -> Value {
    match kind {
        "object" => json!({}),
        "array" => json!([]),
        "boolean" => json!(false),
        "number" => json!(0),
        "float" => json!(0.0),
        "null" => Value::Null,
        "date" => json!("2026-01-01"),
        "datetime" => json!("2026-01-01T00:00:00Z"),
        _ => json!(""),
    }
}
#[component]
pub(super) fn ObjectEditor(
    field: Field,
    #[prop(default = true)] typed: bool,
    session: Session,
) -> impl IntoView {
    let key = RwSignal::new(String::new());
    let error = RwSignal::new(String::new());
    view! { <div class="fp-object-editor">
        <For each={move || field.get().as_object().map(|v| v.keys().cloned().collect::<Vec<_>>()).unwrap_or_default()} key=|key|key.clone() children=move |name| {
            let name=StoredValue::new(name); let value=field.child(name.get_value()); let rename=RwSignal::new(name.get_value());
            view! { <div class="fp-setting-card"><div class="fp-inline"><input aria-label="Field name" prop:value=move || rename.get() on:input=move |ev| rename.set(event_target_value(&ev))/>
                <button type="button" on:click=move |_| { let new=rename.get_untracked(); let mut object=field.get(); if new.is_empty() || (new != name.get_value() && object.get(&new).is_some()) {error.set("Use a nonempty, unique field name.".into());return;} if let Some(o)=object.as_object_mut() {if let Some(v)=o.remove(&name.get_value()) {o.insert(new,v);}} field.set(object); error.set(String::new()); }>"Rename"</button>
                <button type="button" aria-label=move || format!("Remove field {}",name.get_value()) on:click=move |_| {let mut object=field.get(); if let Some(o)=object.as_object_mut(){o.remove(&name.get_value());} field.set(object);}>"×"</button></div>
                <Show when=move || typed && name.get_value()=="topic" && value.get().get("id_field").is_some() && field.draft.with(|v|v["handler"]=="create_support_ticket") fallback=move || view!{<ValueEditor field=value typed=typed session=session/>}>
                    <Select field=value.child("id_field") label="Escalation topic" options=catalog(session,"topics") optional=false/>
                </Show>
            </div> }
        }/>
        <div class="fp-inline"><input aria-label=if typed {"New argument name"} else {"New field name"} placeholder="Field name" prop:value=move ||key.get() on:input=move |ev|key.set(event_target_value(&ev))/><button type="button" on:click=move |_| {
            let name=key.get_untracked(); let mut object=field.get(); if name.is_empty() || object.get(&name).is_some(){error.set("Use a nonempty, unique field name.".into());return;}
            object[&name]=if typed{json!({"string":""})}else{json!("")}; field.set(object);key.set(String::new());error.set(String::new());
        }>"Add field"</button></div><p role="status">{move ||error.get()}</p>
    </div> }
}
#[component]
fn ArrayEditor(field: Field, typed: bool, session: Session) -> impl IntoView {
    view! { <div><For each={move || (0..field.get().as_array().map_or(0,Vec::len)).collect::<Vec<_>>()} key=|i|*i children=move |i| view!{
        <div class="fp-setting-card"><ValueEditor field=field.child(i) typed=typed session=session/><button type="button" on:click=move |_| {let mut v=field.get();if let Some(a)=v.as_array_mut(){a.remove(i);}field.set(v);}>"Remove item"</button></div>
    }/><button type="button" on:click=move |_| {let mut v=field.get();if let Some(a)=v.as_array_mut(){a.push(if typed{json!({"string":""})}else{json!("")});}field.set(v);}>"Add item"</button></div> }
}

#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    fn structured_fields_edit_nested_objects_arrays_and_escaped_keys() {
        let mut value = json!({"args":{"a/b~c":{"array":[{"object":{"flag":false}}]}}});
        set_path(&mut value, "/args/a~1b~0c/array/0/object/flag", json!(true));
        set_path(&mut value, "/metadata/owner", json!("team"));
        assert_eq!(value["args"]["a/b~c"]["array"][0]["object"]["flag"], true);
        assert_eq!(value["metadata"]["owner"], "team");
    }
}