@yuneta/gobj-ui 7.25.5 → 7.25.7

package/src/c_yui_schema_editor.js

@@ -70,6 +70,12 @@
  *      `update-node` / `delete-node` on the treedb service, and it may
  *      be a routing adapter two hops away (the agent console's
  *      C_AGENT_TREEDB_LINK) — this view cannot tell, and must not.
+ *      A DROP of it (the host's EV_TRANSPORT_STATE, or a failure that
+ *      arrives while the transport is out of session) ends the load or
+ *      the write it cut, and the model is asked again when the session
+ *      is back. Every request carries its round (`round` for a load,
+ *      `write` for a write) in `__md_command__`, so an answer of what
+ *      was cut is ignored instead of counted in the next one.
  *
  *          Copyright (c) 2026, ArtGins.
  *          All Rights Reserved.
@@ -108,6 +114,7 @@ import {
     clean_name,
     msg_iev_get_stack,
     kw_get_str,
+    kw_get_int,
     kw_get_dict,
     is_object,
     is_array,
@@ -198,6 +205,7 @@ let PRIVATE_DATA = {
     model:          null,   /*  build_schema_model() of the above  */
     pending:        0,      /*  `nodes` requests still in flight  */
     load_error:     "",
+    load_round:     0,      /*  which load an answer belongs to: echoed as `round`  */
 
     /*  Where the operator is. The url carries it; these mirror it.  */
     treedb_id:      "",
@@ -220,9 +228,14 @@ let PRIVATE_DATA = {
     save_queue:     null,
     save_return:    "",
     save_wrote:     false,
+    write_tag:      0,      /*  which write an answer belongs to: echoed as `write`  */
     connected:      false,
+    reload_on_open: false,  /*  a drop cut a load or a write: ask the model again  */
+    dropped_round:  0,      /*  the load a drop ended: its failures are the drop, said once  */
+    dropped_write:  0,      /*  the same for the write a drop ended  */
+    reload_after_write: false,  /*  a write given up turned out DONE while another was in flight  */
 
-    /*  A position that arrived while a write was in flight  */
+    /*  A position that arrived while a load or a write was in flight  */
     pending_seg:    null,
 
     /*  The import dialog's plan and the two nodes it draws into  */
@@ -458,6 +471,7 @@ function request_model(gobj)
     priv.records = {treedbs: [], topics: [], cols: []};
     priv.load_error = "";
     priv.pending = 0;
+    priv.load_round++;
     gobj_change_state(gobj, "ST_LOADING");
     show_notice(gobj, "loading the schemas");
 
@@ -465,7 +479,7 @@ function request_model(gobj)
         if(remote_command(gobj, "nodes", {
             topic_name: topic_name,
             options:    {list_dict: true}
-        }) === 0) {
+        }, {round: priv.load_round}) === 0) {
             priv.pending++;
         }
     }
@@ -487,7 +501,7 @@ function request_model(gobj)
  *  answer says which topic it is about, since the command is
  *  `nodes` for all three.
  ***************************************************************/
-function remote_command(gobj, command, kw)
+function remote_command(gobj, command, kw, tag)
 {
     let remote = gobj_read_pointer_attr(gobj, "gobj_remote_yuno");
     let treedb_name = gobj_read_str_attr(gobj, "treedb_name");
@@ -512,11 +526,11 @@ function remote_command(gobj, command, kw)
      *  whichever one is under this view — and `record_id` is here and
      *  NOT at the top level because a delete answers with nothing, and a
      *  parameter the treedb does not know has no business travelling.  */
-    full_kw.__md_command__ = {
+    full_kw.__md_command__ = Object.assign({
         purpose:    PURPOSE,
         topic_name: (kw && kw.topic_name) || "",
         record_id:  (kw && kw.record_id) || ""
-    };
+    }, tag || {});
     delete full_kw.record_id;
 
     let ret = gobj_command(remote, command, full_kw, gobj);
@@ -2362,17 +2376,121 @@ function run_next_write(gobj)
     let command = write_command(write.op);
     let options = write_options(write.op);
 
+    priv.write_tag++;
     if(remote_command(gobj, command, {
         topic_name: write.topic_name,
         record:     write.record,
         options:    options,
         record_id:  write.record.id || ""
-    }) < 0) {
+    }, {write: priv.write_tag}) < 0) {
         return end_writes(gobj, t("cannot reach the treedb"));
     }
     return 0;
 }
 
+/***************************************************************
+ *  Does the transport say it is in session? The state the library
+ *  reads off every transport (C_IEVENT_CLI and the routing adapters
+ *  name it the same).
+ ***************************************************************/
+function transport_in_session(gobj)
+{
+    let remote = gobj_read_pointer_attr(gobj, "gobj_remote_yuno");
+
+    return !!remote && gobj_current_state(remote) === "ST_SESSION";
+}
+
+/***************************************************************
+ *  Is this answer of the load in flight, or of the write in
+ *  flight? Each request carries its round in `__md_command__`, and
+ *  one the drop abandoned (or a deadline settled) can still come
+ *  back: counted, it ended the next load with the old data or
+ *  moved the next write's queue.
+ *
+ *  The state is part of the question, and that is only true
+ *  because NOTHING moves the editor out of ST_LOADING or ST_SAVING
+ *  but the end of what is in flight: a position the host sends
+ *  meanwhile waits in `pending_seg` (ac_show()). 7.25.6 let EV_SHOW
+ *  move a RELOAD out of ST_LOADING, and every answer of it was then
+ *  "for a load that is over": the records it had emptied stayed
+ *  empty, and the next write patched them into a model with no
+ *  treedb at all.
+ ***************************************************************/
+function is_current_load(gobj, md)
+{
+    return gobj_current_state(gobj) === "ST_LOADING" &&
+        kw_get_int(gobj, md, "round", 0, 0) === gobj.priv.load_round;
+}
+
+function is_current_write(gobj, md)
+{
+    return gobj_current_state(gobj) === "ST_SAVING" &&
+        kw_get_int(gobj, md, "write", 0, 0) === gobj.priv.write_tag;
+}
+
+/***************************************************************
+ *  The transport dropped under a load or a write: its answers
+ *  will never come. The load goes back to the screen it replaced
+ *  (or to "not connected" when there was none), the write ends
+ *  with the drop said -- whether it landed is unknown -- and both
+ *  mark the model to be asked again when the session is back.
+ *  Bumping the round makes an answer of what was cut stale.
+ ***************************************************************/
+function transport_dropped(gobj)
+{
+    let priv = gobj.priv;
+    let state = gobj_current_state(gobj);
+
+    priv.reload_on_open = true;
+    if(state === "ST_SAVING") {
+        log_warning(`${gobj_short_name(gobj)}: the transport dropped during a write: ` +
+            `the model is read again on the reconnect`);
+        priv.dropped_write = priv.write_tag;
+        priv.write_tag++;
+        return end_writes(gobj, "the connection dropped during the write");
+    }
+    if(state === "ST_LOADING") {
+        /*  Said HERE, once: the transport settles every request the drop
+         *  cut, and those failures are this one event (see
+         *  ac_mt_command_answer()).  */
+        log_warning(`${gobj_short_name(gobj)}: the transport dropped during the load: ` +
+            `the model is read again on the reconnect`);
+        priv.dropped_round = priv.load_round;
+        priv.load_round++;
+        priv.pending = 0;
+        priv.load_error = "";
+        return end_load(gobj);
+    }
+    return 0;
+}
+
+/***************************************************************
+ *  A load is over -- landed, failed or cut -- and the editor goes
+ *  where the operator is: the position the host sent while it was
+ *  in flight (ac_show() kept it), or the one it had. Without a
+ *  model there is no screen to go to: the position is kept for the
+ *  next load, and the editor says why it is empty.
+ ***************************************************************/
+function end_load(gobj)
+{
+    let priv = gobj.priv;
+    let seg = priv.pending_seg;
+
+    priv.pending_seg = null;
+    if(priv.model) {
+        if(seg !== null) {
+            return apply_seg(gobj, seg);
+        }
+        return go(gobj, priv.treedb_id, priv.topic_name, priv.diagram, false);
+    }
+    if(seg !== null) {
+        adopt_seg(gobj, seg);
+    }
+    gobj_change_state(gobj, "ST_IDLE");
+    render(gobj);
+    return 0;
+}
+
 /***************************************************************
  *  The queue is done, or gave up. Either way the model is what
  *  the answers made it, so the screen is redrawn from it and the
@@ -2402,7 +2520,7 @@ function end_writes(gobj, error)
                 });
             }
             priv.save_wrote = false;
-            return 0;
+            return reload_if_owed(gobj);
         }
     }
 
@@ -2417,9 +2535,30 @@ function end_writes(gobj, error)
     priv.save_wrote = false;
     render(gobj);
     publish_check(gobj);
+    reload_if_owed(gobj);
     return error ? -1 : 0;
 }
 
+/***************************************************************
+ *  A write given up earlier turned out DONE while another one was
+ *  in flight (see ac_mt_command_answer()): the model is read again
+ *  now that nothing is.
+ ***************************************************************/
+function reload_if_owed(gobj)
+{
+    let priv = gobj.priv;
+
+    if(!priv.reload_after_write) {
+        return 0;
+    }
+    priv.reload_after_write = false;
+    if(!transport_in_session(gobj)) {
+        priv.reload_on_open = true;
+        return 0;
+    }
+    return request_model(gobj);
+}
+
 /***************************************************************
  *  The record a column form produces.
  *
@@ -2525,9 +2664,13 @@ function go(gobj, treedb_id, topic_name, diagram, mirror)
     priv.topic_name = topic_name || "";
     priv.diagram = !!diagram;
 
+    /*  No model and no load (a load in flight never gets here: ac_show()
+     *  keeps the position for it): nothing to draw, and ST_LOADING would
+     *  claim a load that nobody asked for -- the reconnect skipped the one
+     *  it owed BECAUSE the state said a load was running.  */
     let state = "ST_TREEDBS";
     if(!priv.model) {
-        state = "ST_LOADING";
+        state = "ST_IDLE";
     } else if(priv.model.treedbs.length === 0) {
         state = "ST_EMPTY";
     } else if(priv.treedb_id && priv.diagram) {
@@ -2573,18 +2716,39 @@ function position_seg(gobj)
  *  empty screen: a shared link outlives the schema it points at.
  ***************************************************************/
 function apply_seg(gobj, seg)
+{
+    let pos = seg_position(seg);
+
+    return go(gobj, pos.treedb_id, pos.topic_name, pos.diagram, false);
+}
+
+function seg_position(seg)
 {
     let parts = String(seg || "").split("/").filter(x => x.length > 0);
     let treedb_id = parts[0] || "";
     let tail = parts[1] || "";
 
     if(!treedb_id) {
-        return go(gobj, "", "", false, false);
+        return {treedb_id: "", topic_name: "", diagram: false};
     }
     if(tail === DIAGRAM_SEG) {
-        return go(gobj, treedb_id, "", true, false);
+        return {treedb_id: treedb_id, topic_name: "", diagram: true};
     }
-    return go(gobj, treedb_id, tail, false, false);
+    return {treedb_id: treedb_id, topic_name: tail, diagram: false};
+}
+
+/***************************************************************
+ *  Where the operator is, taken WITHOUT a screen: there is no model
+ *  to draw it on yet, and the load that brings one goes there.
+ ***************************************************************/
+function adopt_seg(gobj, seg)
+{
+    let priv = gobj.priv;
+    let pos = seg_position(seg);
+
+    priv.treedb_id = pos.treedb_id;
+    priv.topic_name = pos.topic_name;
+    priv.diagram = pos.diagram;
 }
 
 
@@ -2627,8 +2791,31 @@ function ac_mt_command_answer(gobj, event, kw, src)
         return 0;       /*  another panel's answer on a shared transport  */
     }
 
+    /*  A failure while the transport is not in session is the DROP, not a
+     *  refusal: a routing adapter settles what it had in flight when its
+     *  session closes, and that can arrive before the host's
+     *  EV_TRANSPORT_STATE. Read as a refusal, the write it ended looked
+     *  refused, and the reconnect did not reload a model it may have
+     *  changed.  */
+    if(result < 0 && !transport_in_session(gobj) &&
+            (gobj_current_state(gobj) === "ST_LOADING" ||
+             gobj_current_state(gobj) === "ST_SAVING")) {
+        if((command === "nodes" && is_current_load(gobj, md)) ||
+                (command !== "nodes" && is_current_write(gobj, md))) {
+            return transport_dropped(gobj);
+        }
+    }
+
     if(command === "nodes") {
         let topic_name = kw_get_str(gobj, md, "topic_name", "", 0);
+        if(!is_current_load(gobj, md)) {
+            if(result < 0 && kw_get_int(gobj, md, "round", 0, 0) === priv.dropped_round) {
+                return 0;   /*  the drop that ended this load failed it: said once, in transport_dropped()  */
+            }
+            log_warning(`${gobj_short_name(gobj)}: 'nodes' of '${topic_name}' answered ` +
+                `for a load that is over: ignored`);
+            return 0;
+        }
         priv.pending--;
         if(result < 0) {
             priv.load_error = comment || t("cannot load the schemas");
@@ -2640,9 +2827,7 @@ function ac_mt_command_answer(gobj, event, kw, src)
         }
         if(priv.load_error) {
             priv.model = null;
-            gobj_change_state(gobj, "ST_IDLE");
-            render(gobj);
-            return 0;
+            return end_load(gobj);
         }
         /*  Records straight from the store: what an undo would name is the
          *  order that was ON SCREEN, and this is the stored one arriving.
@@ -2655,13 +2840,25 @@ function ac_mt_command_answer(gobj, event, kw, src)
          *  against. Taken on the write patches instead, it measured every
          *  version against itself.  */
         start_measuring(gobj);
-        /*  Back to where the operator was: the load may be a refresh, or
-         *  the answer to a deep link that arrived before the model.  */
-        return go(gobj, priv.treedb_id, priv.topic_name, priv.diagram, false);
+        /*  Back to where the operator was, or went while it loaded: the
+         *  load may be a refresh, or the answer to a deep link that
+         *  arrived before the model.  */
+        return end_load(gobj);
     }
 
     if(command === "update-node" || command === "delete-node") {
         let topic_name = kw_get_str(gobj, md, "topic_name", "", 0);
+        if(!is_current_write(gobj, md)) {
+            if(result < 0 && kw_get_int(gobj, md, "write", 0, 0) === priv.dropped_write) {
+                return 0;   /*  the drop that ended this write failed it: said once, in transport_dropped()  */
+            }
+            if(result < 0) {
+                log_warning(`${gobj_short_name(gobj)}: '${command}' of '${topic_name}' answered ` +
+                    `for a write that is over (result ${result}): ignored`);
+                return 0;
+            }
+            return late_write_done(gobj, command, topic_name);
+        }
         if(result < 0) {
             return end_writes(gobj, comment || t("the treedb refused the write"));
         }
@@ -2697,6 +2894,41 @@ function ac_mt_command_answer(gobj, event, kw, src)
     return 0;
 }
 
+/***************************************************************
+ *  A write this view gave up on (a drop, a deadline) answers that
+ *  it was DONE: the store holds a change the model does not show.
+ *  The model is read again -- now, or when what is in flight ends,
+ *  or on the reconnect. A load in flight needs nothing: it was
+ *  asked after the write, on the same transport, and reads it.
+ *
+ *  Only when the answer reaches this view. A routing adapter that
+ *  settled the write on its own deadline (gui_agent's
+ *  C_AGENT_TREEDB_LINK) does not deliver its late answer again --
+ *  the view was answered once, as failed -- and echoes the node
+ *  event instead, which this view does not hear: there, Refresh is
+ *  what reads the store.
+ ***************************************************************/
+function late_write_done(gobj, command, topic_name)
+{
+    let priv = gobj.priv;
+    let state = gobj_current_state(gobj);
+
+    log_warning(`${gobj_short_name(gobj)}: '${command}' of '${topic_name}' was given up, ` +
+        `and it was DONE: the model is read again`);
+    if(state === "ST_LOADING") {
+        return 0;
+    }
+    if(state === "ST_SAVING") {
+        priv.reload_after_write = true;
+        return 0;
+    }
+    if(!transport_in_session(gobj)) {
+        priv.reload_on_open = true;
+        return 0;
+    }
+    return request_model(gobj);
+}
+
 /***************************************************************
  *  Remember which topic this write belongs to, which is what
  *  "its version still has to move" is asked about.
@@ -2723,10 +2955,14 @@ function ac_show(gobj, event, kw, src)
 {
     let priv = gobj.priv;
     let seg = (kw && kw.subpath) || "";
+    let state = gobj_current_state(gobj);
 
-    if(gobj_current_state(gobj) === "ST_SAVING") {
+    /*  Nothing but the end of what is in flight moves the editor out of
+     *  these two (see is_current_load()): the position waits, and the
+     *  last one sent wins.  */
+    if(state === "ST_SAVING" || state === "ST_LOADING") {
         priv.pending_seg = seg;
-        return 0;       /*  applied when the write lands (end_writes)  */
+        return 0;       /*  applied when the write lands (end_writes) or the load (end_load)  */
     }
     return apply_seg(gobj, seg);
 }
@@ -2743,16 +2979,31 @@ function ac_hide(gobj, event, kw, src)
 }
 
 /***************************************************************
- *  The session came up or went down. The model stays either way
- *  — a schema does not change under you — but a first load may
- *  have had no transport to run on.
+ *  The session came up or went down. The model stays -- a schema
+ *  does not change under you -- unless the drop cut a load or a
+ *  write (transport_dropped()): then it is asked again on the way
+ *  back, as it is when a first load had no transport to run on.
+ *
+ *  Nothing else ends a load or a write the drop cut: their answers
+ *  will never come, and waiting in ST_LOADING skipped the reload
+ *  itself (M-1 of the independent review of 7.25.4).
  ***************************************************************/
 function ac_transport_state(gobj, event, kw, src)
 {
     let priv = gobj.priv;
+    let state = gobj_current_state(gobj);
 
     priv.connected = !!(kw && kw.connected);
-    if(priv.connected && !priv.model && gobj_current_state(gobj) !== "ST_LOADING") {
+    if(!priv.connected) {
+        if(state === "ST_LOADING" || state === "ST_SAVING") {
+            return transport_dropped(gobj);
+        }
+        render_toolbar(gobj);
+        return 0;
+    }
+    if((!priv.model || priv.reload_on_open) &&
+            state !== "ST_LOADING" && state !== "ST_SAVING") {
+        priv.reload_on_open = false;
         return request_model(gobj);
     }
     render_toolbar(gobj);