@yuneta/gobj-ui 7.25.19 → 7.25.21

package/src/c_yui_treedb_graph.js

@@ -1312,6 +1312,42 @@ function close_json_viewer(gobj)
     }
 }
 
+/************************************************************
+ *  A drill (or the whole document) that will get no answer from the
+ *  backend is answered HERE, or its stub shows "loading" for the life
+ *  of the viewer: C_YUI_JSON ignores every click on a pending path.
+ *  `answer` is {i18n: <key>} or {error: <text>}.
+ ************************************************************/
+function answer_print_tranger_refused(gobj, path, answer)
+{
+    let jv = gobj.priv.json_gobj;
+    if(!jv || !is_gobj(jv) || gobj_is_destroying(jv)) {
+        return;     /*  no viewer to answer: the refusal is already logged  */
+    }
+    if(path) {
+        gobj_send_event(jv, "EV_SUBTREE_ERROR",
+            Object.assign({path: path}, answer), gobj);
+    } else {
+        yui_shell_show_error(yui_shell_of(gobj),
+            answer.i18n || answer.error, {t: t});
+    }
+}
+
+/************************************************************
+ *  The text of a transport's refusal: gobj_command() answers a string,
+ *  a command response or a number.
+ ************************************************************/
+function refusal_text(ret)
+{
+    if(typeof ret === "string" && ret) {
+        return ret;
+    }
+    if(ret && typeof ret === "object" && typeof ret.comment === "string" && ret.comment) {
+        return ret.comment;
+    }
+    return "print-tranger failed";
+}
+
 /************************************************************
  *  Fetch the treedb's raw tranger (or one subtree when `path` is set) as
  *  bounded, drillable JSON. Collapsed at 100 so a huge tranger stays a
@@ -1322,11 +1358,13 @@ function request_print_tranger(gobj, path)
     let priv = gobj.priv;
     if(!priv.gobj_remote_yuno) {
         log_error(`${gobj_short_name(gobj)}: No gobj_remote_yuno defined`);
-        let jv = priv.json_gobj;
-        if(path && jv && is_gobj(jv) && !gobj_is_destroying(jv)) {
-            gobj_send_event(jv, "EV_SUBTREE_ERROR",
-                {path: path, error: t("no session")}, gobj);
-        }
+        answer_print_tranger_refused(gobj, path, {i18n: "no session"});
+        return;
+    }
+    if(!is_connected(gobj)) {
+        log_warning(`${gobj_short_name(gobj)}: print-tranger '${path || ""}' ` +
+            `not asked: no session`);
+        answer_print_tranger_refused(gobj, path, {i18n: "no session"});
         return;
     }
     let ret = gobj_command(priv.gobj_remote_yuno, "print-tranger",
@@ -1342,6 +1380,7 @@ function request_print_tranger(gobj, path)
         }, gobj);
     if(ret) {
         log_error(ret);
+        answer_print_tranger_refused(gobj, path, {error: refusal_text(ret)});
     }
 }
 
@@ -1498,7 +1537,7 @@ function treedb_create_node(gobj, treedb_name, topic_name, record, options)
 /************************************************************
  *  Command to remote service
  ************************************************************/
-function treedb_update_node(gobj, treedb_name, topic_name, record, options)
+function treedb_update_node(gobj, treedb_name, topic_name, record, options, graphs_load)
 {
     let priv = gobj.priv;
 
@@ -1525,6 +1564,11 @@ function treedb_update_node(gobj, treedb_name, topic_name, record, options)
      *  arranges, so that topic has to travel here.  */
     if(topic_name === "__graphs__") {
         kw.__md_command__.graph_topic = graph_topic_of(record);
+        /*  And the engine's LOAD it was sent from: a refusal answered
+         *  after a reload is not about the arrangement shown now.  */
+        if(graphs_load !== undefined) {
+            kw.__md_command__.graphs_load = graphs_load;
+        }
     }
 
     let ret = gobj_command(priv.gobj_remote_yuno,
@@ -2162,7 +2206,8 @@ function ac_mt_command_answer(gobj, event, kw, src)
             if(result < 0 && command === "update-node") {
                 graphs_write_refused(gobj,
                     kw_get_str(gobj, kw_command, "topic_name", "", 0),
-                    kw_get_str(gobj, kw_command, "graph_topic", "", 0));
+                    kw_get_str(gobj, kw_command, "graph_topic", "", 0),
+                    kw_command ? kw_command.graphs_load : undefined);
             }
             if(result >= 0 &&
                 kw_get_str(gobj, kw_command, "topic_name", "", 0) !== "__graphs__") {
@@ -2533,9 +2578,10 @@ function ac_update_node(gobj, event, kw, src)
     let topic_name = kw.topic_name;
     let record = kw.record;
     let options = kw.options || {};
+    let graphs_load = kw.graphs_load;
 
     if(refuse_if_readonly(gobj, event)) {
-        graphs_write_refused(gobj, topic_name, graph_topic_of(record));
+        graphs_write_refused(gobj, topic_name, graph_topic_of(record), graphs_load);
         return -1;
     }
 
@@ -2545,7 +2591,7 @@ function ac_update_node(gobj, event, kw, src)
     if(topic_name === "__graphs__" && !is_connected(gobj)) {
         log_warning(`${gobj_short_name(gobj)}: no session, the arrangement ` +
             `was not sent`);
-        graphs_write_refused(gobj, topic_name, graph_topic_of(record));
+        graphs_write_refused(gobj, topic_name, graph_topic_of(record), graphs_load);
         return -1;
     }
 
@@ -2554,10 +2600,11 @@ function ac_update_node(gobj, event, kw, src)
         treedb_name,
         topic_name,
         record,
-        options
+        options,
+        graphs_load
     );
     if(ret < 0) {
-        graphs_write_refused(gobj, topic_name, graph_topic_of(record));
+        graphs_write_refused(gobj, topic_name, graph_topic_of(record), graphs_load);
     }
     return ret;
 }
@@ -2578,9 +2625,11 @@ function graph_topic_of(record)
  *  (C_G6_NODES_TREE) took it for granted when it left -- nothing
  *  answers it when it lands -- so it is told, and its next Save
  *  writes the topic again. Other topics are the operator's data:
- *  the answer's error says what happened to them.
+ *  the answer's error says what happened to them. `graphs_load` is
+ *  the engine's load the write was sent from, handed back so it can
+ *  tell a refusal of an earlier load from one of the current.
  ************************************************************/
-function graphs_write_refused(gobj, topic_name, topic)
+function graphs_write_refused(gobj, topic_name, topic, graphs_load)
 {
     let priv = gobj.priv;
 
@@ -2594,7 +2643,11 @@ function graphs_write_refused(gobj, topic_name, topic)
     if(!priv.gobj_nodes_tree) {
         return;     /*  no engine: nothing believes it was saved  */
     }
-    gobj_send_event(priv.gobj_nodes_tree, "EV_GRAPHS_WRITE_REFUSED", {topic: topic}, gobj);
+    let kw = {topic: topic};
+    if(graphs_load !== undefined) {
+        kw.graphs_load = graphs_load;
+    }
+    gobj_send_event(priv.gobj_nodes_tree, "EV_GRAPHS_WRITE_REFUSED", kw, gobj);
 }
 
 /********************************************

package/src/c_yui_treedb_topic_with_form.js

@@ -3711,8 +3711,9 @@ function ac_expand_path(gobj, event, kw, src)
     let path = (kw && kw.path) || "";
 
     gobj_send_event(src, "EV_SUBTREE_ERROR", {
-        path:  path,
-        error: t("this part cannot be loaded here")
+        path:      path,
+        i18n:      "this part cannot be loaded here",
+        by_design: true
     }, gobj);
     return 0;
 }

package/src/c_yui_treedb_topics.js

@@ -1943,6 +1943,42 @@ function request_schema_file(gobj)
     }
 }
 
+/************************************************************
+ *  A drill (or the whole document) that will get no answer from the
+ *  backend is answered HERE, or its stub shows "loading" for the life
+ *  of the viewer: C_YUI_JSON ignores every click on a pending path.
+ *  `answer` is {i18n: <key>} or {error: <text>}.
+ ************************************************************/
+function answer_print_tranger_refused(gobj, path, answer)
+{
+    let jv = gobj.priv.json_gobj;
+    if(!jv || !is_gobj(jv) || gobj_is_destroying(jv)) {
+        return;     /*  no viewer to answer: the refusal is already logged  */
+    }
+    if(path) {
+        gobj_send_event(jv, "EV_SUBTREE_ERROR",
+            Object.assign({path: path}, answer), gobj);
+    } else {
+        yui_shell_show_error(yui_shell_of(gobj),
+            answer.i18n || answer.error, {t: t});
+    }
+}
+
+/************************************************************
+ *  The text of a transport's refusal: gobj_command() answers a string,
+ *  a command response or a number.
+ ************************************************************/
+function refusal_text(ret)
+{
+    if(typeof ret === "string" && ret) {
+        return ret;
+    }
+    if(ret && typeof ret === "object" && typeof ret.comment === "string" && ret.comment) {
+        return ret.comment;
+    }
+    return "print-tranger failed";
+}
+
 /************************************************************
  *  The whole tranger, for the raw-json viewer.
  ************************************************************/
@@ -1952,11 +1988,13 @@ function request_print_tranger(gobj, path)
     let remote = gobj_read_pointer_attr(gobj, "gobj_remote_yuno");
     if(!remote) {
         log_error(`${gobj_short_name(gobj)}: No gobj_remote_yuno defined`);
-        let jv = priv.json_gobj;
-        if(path && jv && is_gobj(jv) && !gobj_is_destroying(jv)) {
-            gobj_send_event(jv, "EV_SUBTREE_ERROR",
-                {path: path, error: t("no session")}, gobj);
-        }
+        answer_print_tranger_refused(gobj, path, {i18n: "no session"});
+        return;
+    }
+    if(!is_connected(gobj)) {
+        log_warning(`${gobj_short_name(gobj)}: print-tranger '${path || ""}' ` +
+            `not asked: no session`);
+        answer_print_tranger_refused(gobj, path, {i18n: "no session"});
         return;
     }
     let ret = gobj_command(remote, "print-tranger",
@@ -1972,6 +2010,7 @@ function request_print_tranger(gobj, path)
         }, gobj);
     if(ret) {
         log_error(ret);
+        answer_print_tranger_refused(gobj, path, {error: refusal_text(ret)});
     }
 }
 

package/src/form_json_expand.wiring.test.js

@@ -43,10 +43,12 @@ const {
     SDATA_END, gclass_create,
     gobj_start_up, gobj_create_yuno, gobj_create, gobj_create_service,
     gobj_start, gobj_send_event, gobj_current_state,
+    gobj_create_pure_child, gobj_read_attr,
     set_log_callback,
 } = await import("@yuneta/gobj-js");
 const {register_c_yui_shell} = await import("./c_yui_shell.js");
 const {register_c_yui_json} = await import("./c_yui_json.js");
+const {t} = await import("i18next");
 const {register_c_yui_treedb_topic_with_form} = await import("./c_yui_treedb_topic_with_form.js");
 
 const logged = [];
@@ -86,6 +88,11 @@ function errors()
     return logged.filter((l) => l.level === "error").map((l) => l.msg);
 }
 
+function warnings()
+{
+    return logged.filter((l) => l.level === "warning").map((l) => l.msg);
+}
+
 describe("a viewer of the form asks to load a truncated part", () => {
 
     test("the form answers that it cannot, and the stub stops loading", () => {
@@ -112,10 +119,86 @@ describe("a viewer of the form asks to load a truncated part", () => {
         gobj_send_event(viewer, "EV_EXPAND_COLLAPSED", {path: "cols`name", size: 40}, viewer);
 
         expect(viewer.priv.pending.has("cols`name")).toBe(false);
-        expect(viewer.priv.errors.get("cols`name")).toBe("this part cannot be loaded here");
-        /*  The viewer logs what it could not load; nothing else is.  */
+        /*  The KEY travels, not its translation: the stub draws t(key)
+         *  with data-i18n, so it changes language with the app.  */
+        expect(viewer.priv.errors.get("cols`name")).toEqual(
+            {error: "this part cannot be loaded here", is_key: true});
+        /*  A host saying it cannot, by design, is a WARNING: an ERROR
+         *  on every click broke the clean-console check of a deploy and
+         *  reached the backend through the remote log.  */
+        expect(errors()).toEqual([]);
+        expect(warnings()).toEqual([
+            "C_YUI_JSON: subtree not loaded at 'cols`name': this part cannot be loaded here"
+        ]);
+
+    });
+});
+
+describe("the stub of a subtree that was not loaded", () => {
+
+    /*  A host answering with a KEY that it cannot, by design.  */
+    function make_viewer(name, answer)
+    {
+        gclass_create(`C_TEST_JSON_HOST_${name}`, [["EV_EXPAND_PATH", 0]], [
+            ["ST_IDLE", [["EV_EXPAND_PATH", function(gobj, event, kw, src) {
+                gobj_send_event(src, "EV_SUBTREE_ERROR",
+                    Object.assign({path: kw.path}, answer), gobj);
+                return 0;
+            }, null]]]
+        ], {}, 0, [SDATA_END()], {}, 0, 0, 0, 0);
+        const host = gobj_create(`${name}_host`, `C_TEST_JSON_HOST_${name}`, {}, yuno);
+        gobj_start(host);
+        const viewer = gobj_create_pure_child(`${name}_jv`, "C_YUI_JSON", {
+            json_data: {a: {__collapsed__: {size: 3, path: "a"}}}
+        }, host);
+        gobj_start(viewer);
+        return viewer;
+    }
+
+    function stub_error(viewer)
+    {
+        return gobj_read_attr(viewer, "$container").querySelector(".JSON_STUB_ERR");
+    }
+
+    test("a key is drawn translated, carries data-i18n, and follows the language", async () => {
+        const i18next = (await import("i18next")).default;
+        i18next.addResource("es", "translation",
+            "this part cannot be loaded here", "esta parte no se puede cargar aqui");
+
+        const viewer = make_viewer("s1",
+            {i18n: "this part cannot be loaded here", by_design: true});
+        logged.length = 0;
+        gobj_send_event(viewer, "EV_EXPAND_COLLAPSED", {path: "a", size: 3}, viewer);
+
+        let el = stub_error(viewer);
+        expect(el).toBeTruthy();
+        expect(el.getAttribute("data-i18n")).toBe("this part cannot be loaded here");
+        expect(el.textContent).toBe("this part cannot be loaded here");
+        expect(errors()).toEqual([]);
+        expect(warnings()).toEqual([
+            "C_YUI_JSON: subtree not loaded at 'a': this part cannot be loaded here"
+        ]);
+
+        await i18next.changeLanguage("es");
+        try {
+            gobj_send_event(viewer, "EV_LANGUAGE_CHANGED", {}, viewer);
+            expect(stub_error(viewer).textContent).toBe("esta parte no se puede cargar aqui");
+            expect(t("this part cannot be loaded here")).toBe("esta parte no se puede cargar aqui");
+        } finally {
+            await i18next.changeLanguage("en");
+        }
+    });
+
+    test("a failure in free text is drawn as it came, and is an ERROR", () => {
+        const viewer = make_viewer("s2", {error: "print-tranger failed"});
+        logged.length = 0;
+        gobj_send_event(viewer, "EV_EXPAND_COLLAPSED", {path: "a", size: 3}, viewer);
+
+        let el = stub_error(viewer);
+        expect(el.getAttribute("data-i18n")).toBe(null);
+        expect(el.textContent).toBe("print-tranger failed");
         expect(errors()).toEqual([
-            "C_YUI_JSON: subtree load failed at 'cols`name': this part cannot be loaded here"
+            "C_YUI_JSON: subtree load failed at 'a': print-tranger failed"
         ]);
     });
 });

package/src/g6_graphs_write_owed.wiring.test.js

@@ -235,3 +235,80 @@ describe("a refused __graphs__ write keeps the Save lit", () => {
         expect(errors()).toEqual([]);
     });
 });
+
+/*  A refusal is about the LOAD its write was sent from. Before gobj-ui
+ *  7.25.20 it carried only the topic: Save, then Refresh, then the
+ *  refusal landed and was applied to the FRESH load -- the Save lit
+ *  over nothing changed, and pressing it wrote a record identical to
+ *  what the backend holds.  */
+describe("a refusal of an earlier load is not applied to the current one", () => {
+
+    test("the write carries its load, and a refusal of it counts", () => {
+        const g = build("edition");
+        g.tree.priv._graph_properties.users.nodes.u1.x = 99;
+        gobj_send_event(g.tree, "EV_SAVE_GRAPH", {}, g.tree);
+        const [write] = published.filter((p) => p.event === "EV_UPDATE_NODE");
+        expect(typeof write.kw.graphs_load).toBe("number");
+
+        gobj_send_event(g.tree, "EV_GRAPHS_WRITE_REFUSED",
+            {topic: "users", graphs_load: write.kw.graphs_load}, g.tree);
+        expect(g.lit()).toBe(true);
+        expect(g.tree.priv._saved_graph_properties.users).toBe(undefined);
+        expect(errors()).toEqual([]);
+    });
+
+    test("Save, reload, then the refusal: ignored, and said", () => {
+        const g = build("edition");
+        g.tree.priv._graph_properties.users.nodes.u1.x = 99;
+        gobj_send_event(g.tree, "EV_SAVE_GRAPH", {}, g.tree);
+        const [write] = published.filter((p) => p.event === "EV_UPDATE_NODE");
+
+        gobj_send_event(g.tree, "EV_CLEAR_DATA", {}, g.tree);
+        /*  The reload brings what the backend holds.  */
+        g.tree.priv._graph_properties = {users: {nodes: {u1: {x: 10, y: 20}}}};
+        g.tree.priv._saved_graph_properties = {users: {nodes: {u1: {x: 10, y: 20}}}};
+        gobj_send_event(g.tree, "EV_SET_OPERATION_MODE", {operation_mode: "edition"}, g.tree);
+        logged.length = 0;
+
+        gobj_send_event(g.tree, "EV_GRAPHS_WRITE_REFUSED",
+            {topic: "users", graphs_load: write.kw.graphs_load}, g.tree);
+        expect(g.lit()).toBe(false);
+        expect(g.tree.priv._saved_graph_properties.users).toEqual({nodes: {u1: {x: 10, y: 20}}});
+        expect(logged.map((l) => [l.level, l.msg.replace(/^\S+: /, "")])).toEqual([
+            ["warning", "a refused write of the arrangement of 'users' belongs to an earlier load: ignored"]
+        ]);
+    });
+});
+
+/*  The FIRST record of a topic's arrangement arrives as a CREATE echo
+ *  (from this browser or another). Before gobj-ui 7.25.20 it rebuilt
+ *  every topic's saved copy from the live objects the view edits in
+ *  place, so an unsaved change of ANOTHER topic counted as saved and
+ *  the next Save did not write it.  */
+describe("a __graphs__ create echo moves only its own topic", () => {
+
+    test("an unsaved change of another topic stays unsaved", () => {
+        const g = build("edition");
+        g.tree.priv.descs = {};
+        g.tree.priv.__graphs__ = [
+            {id: "users", topic: "users", active: true,
+                properties: g.tree.priv._graph_properties.users}
+        ];
+        /*  Edited in place, not saved.  */
+        g.tree.priv._graph_properties.users.nodes.u1.x = 77;
+
+        gobj_send_event(g.tree, "EV_NODE_CREATED", {
+            topic_name: "__graphs__",
+            node: {id: "roles", topic: "roles", active: true,
+                properties: {nodes: {r1: {x: 1, y: 2}}}}
+        }, g.tree);
+
+        expect(g.tree.priv._saved_graph_properties.users).toEqual({nodes: {u1: {x: 10, y: 20}}});
+        expect(g.tree.priv._saved_graph_properties.roles).toEqual({nodes: {r1: {x: 1, y: 2}}});
+
+        gobj_send_event(g.tree, "EV_SAVE_GRAPH", {}, g.tree);
+        const writes = published.filter((p) => p.event === "EV_UPDATE_NODE");
+        expect(writes.map((w) => w.kw.record.id)).toEqual(["users"]);
+        expect(errors()).toEqual([]);
+    });
+});

package/src/schema_editor_transport.wiring.test.js

@@ -37,7 +37,7 @@ const {
     gobj_start_up, gobj_create_yuno, gobj_create, gobj_create_service,
     gobj_start, gobj_send_event, gobj_read_attr,
     gobj_change_state, gobj_current_state,
-    set_log_callback,
+    set_log_callback, log_error,
 } = await import("@yuneta/gobj-js");
 const {register_c_yui_schema_editor} = await import("./c_yui_schema_editor.js");
 
@@ -56,13 +56,33 @@ const RECORDS = {
     ],
 };
 
-/*  A transport out of session refuses in the RETURN, as C_IEVENT_CLI and
- *  the routing adapters do: a request that did not leave is not waited for.  */
+/*  A transport out of session refuses in the RETURN, as the routing
+ *  adapters do (gui_agent's C_AGENT_TREEDB_LINK): a request that did not
+ *  leave is not waited for. `refuse_on_the_way` makes it refuse IN
+ *  session too, as a transport that cannot send.  */
+let refuse_on_the_way = false;
+
 function remote_command_parser(gobj, command, kw, src)
 {
     if(gobj_current_state(gobj) !== "ST_SESSION") {
         return `${command}: not in session`;
     }
+    if(refuse_on_the_way) {
+        return `${command}: cannot send`;
+    }
+    commands.push({command, kw, src});
+    return null;
+}
+
+/*  A DIRECT C_IEVENT_CLI, as its mt_command does it: out of session it
+ *  logs "Not in session" and answers NULL -- the same answer as a request
+ *  that left. The README allows `gobj_remote_yuno` to be one.  */
+function ievent_cli_command_parser(gobj, command, kw, src)
+{
+    if(gobj_current_state(gobj) !== "ST_SESSION") {
+        log_error(`Not in session`);
+        return null;
+    }
     commands.push({command, kw, src});
     return null;
 }
@@ -93,6 +113,13 @@ beforeAll(() => {
         {mt_command_parser: remote_command_parser},
         0, [SDATA_END()], {}, 0, 0, 0, 0
     );
+    gclass_create(
+        "C_TEST_IEVENT_CLI",
+        [],
+        [["ST_DISCONNECTED", []], ["ST_SESSION", []]],
+        {mt_command_parser: ievent_cli_command_parser},
+        0, [SDATA_END()], {}, 0, 0, 0, 0
+    );
     register_c_yui_schema_editor();
     yuno = gobj_create_yuno("transport_yuno", "C_TEST_HOST", {});
     gobj_start(yuno);
@@ -102,6 +129,7 @@ beforeEach(() => {
     logged.length = 0;
     commands.length = 0;
     shown.length = 0;
+    refuse_on_the_way = false;
 });
 
 function take(command)
@@ -148,9 +176,10 @@ function reconnect(editor, remote, host)
     gobj_send_event(editor, "EV_TRANSPORT_STATE", {connected: true}, host);
 }
 
-function build(name, loaded)
+function build(name, loaded, remote_gclass)
 {
-    const remote = gobj_create_service(`${name}_remote`, "C_TEST_REMOTE", {}, yuno);
+    const remote = gobj_create_service(`${name}_remote`,
+        remote_gclass || "C_TEST_REMOTE", {}, yuno);
     gobj_change_state(remote, "ST_SESSION");
     const host = gobj_create(`${name}_host`, "C_TEST_EDITOR_HOST", {}, yuno);
     const editor = gobj_create(`${name}_editor`, "C_YUI_SCHEMA_EDITOR", {
@@ -455,3 +484,58 @@ describe("a write answered after it was given up", () => {
         expect(errors()).toEqual([]);
     });
 });
+
+/*  Before gobj-ui 7.25.20 a write never asked whether the transport was
+ *  in session. A direct C_IEVENT_CLI answers null out of session, which
+ *  remote_command() took for "sent": the editor sat in ST_SAVING, busy
+ *  and inert, until another drop.  */
+describe("a write with the transport out of session", () => {
+
+    test("a direct C_IEVENT_CLI: the write ends, said, and the next session reads again", () => {
+        const {editor, remote, host} = build("x1", true, "C_TEST_IEVENT_CLI");
+        /*  Gone, and the host's edge has not arrived yet.  */
+        gobj_change_state(remote, "ST_DISCONNECTED");
+
+        gobj_send_event(editor, "EV_SAVE_COLUMN", {
+            creating: true, topic: "users", values: {value: "name", type: "string"}
+        }, host);
+        expect(gobj_current_state(editor)).toBe("ST_COLUMNS");
+        expect(is_busy(editor)).toBe(false);
+        expect(take("update-node")).toEqual([]);
+        expect(shown).toEqual(["cannot reach the treedb"]);
+        expect(errors()).toEqual([]);
+        expect(warnings()).toEqual([
+            "C_YUI_SCHEMA_EDITOR^x1_editor: no session, 'update-node' of 'cols' was not sent"
+        ]);
+
+        gobj_send_event(editor, "EV_TRANSPORT_STATE", {connected: false}, host);
+        reconnect(editor, remote, host);
+        expect(answer_the_load(editor, remote)).toBe(3);
+        expect(gobj_current_state(editor)).toBe("ST_COLUMNS");
+        expect(errors()).toEqual([]);
+    });
+
+    /*  The toast is handed the KEY (yui_shell_show_error translates it
+     *  and keeps it for a change of language). This path passed
+     *  t("cannot reach the treedb"), a text that cannot re-translate.  */
+    test("a transport that refuses in session: the toast gets the key", async () => {
+        const i18next = (await import("i18next")).default;
+        if(!i18next.isInitialized) {
+            await i18next.init({lng: "en", resources: {}});
+        }
+        i18next.addResource(i18next.language || "en", "translation",
+            "cannot reach the treedb", "TRANSLATED: cannot reach the treedb");
+        try {
+            const {editor, remote, host} = build("x2", true);
+            refuse_on_the_way = true;
+            gobj_send_event(editor, "EV_SAVE_COLUMN", {
+                creating: true, topic: "users", values: {value: "name", type: "string"}
+            }, host);
+            expect(gobj_current_state(editor)).toBe("ST_COLUMNS");
+            expect(shown).toEqual(["cannot reach the treedb"]);
+            expect(errors()).toEqual(["update-node: cannot send"]);
+        } finally {
+            i18next.removeResourceBundle(i18next.language || "en", "translation");
+        }
+    });
+});

package/src/treedb_graph_writes.wiring.test.js

@@ -156,15 +156,20 @@ function build(name)
     return {remote, host, engine};
 }
 
-/*  What the engine publishes on a Save of one topic's arrangement.  */
-function save_arrangement(engine, topic)
+/*  What the engine publishes on a Save of one topic's arrangement,
+ *  from its load number `graphs_load`.  */
+function save_arrangement(engine, topic, graphs_load)
 {
-    gobj_publish_event(engine, "EV_UPDATE_NODE", {
+    let kw = {
         treedb_name: "treedb_test",
         topic_name: "__graphs__",
         record: {id: topic, topic: topic, active: true, properties: {nodes: {}}},
         options: {list_dict: true, autolink: false, create: true}
-    });
+    };
+    if(graphs_load !== undefined) {
+        kw.graphs_load = graphs_load;
+    }
+    gobj_publish_event(engine, "EV_UPDATE_NODE", kw);
 }
 
 /*  The answer as the real transports build it: the command frame
@@ -188,6 +193,11 @@ function refused()
     return told.filter((t) => t.event === "EV_GRAPHS_WRITE_REFUSED").map((t) => t.kw.topic);
 }
 
+function refused_kw()
+{
+    return told.filter((t) => t.event === "EV_GRAPHS_WRITE_REFUSED").map((t) => t.kw);
+}
+
 describe("a __graphs__ write that does not land is said to the engine", () => {
 
     test("refused by the backend", () => {
@@ -222,6 +232,30 @@ describe("a __graphs__ write that does not land is said to the engine", () => {
         expect(refused()).toEqual(["binaries"]);
     });
 
+    /*  Before gobj-ui 7.25.20 the refusal carried only the topic, and
+     *  the engine applied one answered after a reload to the fresh
+     *  load. The engine's load number now travels in __md_command__
+     *  and comes back with the refusal, on every path.  */
+    test("the engine's load comes back with the refusal, on every path", () => {
+        const {remote, host, engine} = build("g6");
+        save_arrangement(engine, "yunos", 7);
+        expect(commands[0].kw.__md_command__.graphs_load).toBe(7);
+        answer(host, remote, commands[0], -1, "not authorized");
+
+        refuse_on_the_way = true;
+        save_arrangement(engine, "binaries", 7);
+        refuse_on_the_way = false;
+
+        gobj_change_state(remote, "ST_DISCONNECTED");
+        save_arrangement(engine, "realms", 8);
+
+        expect(refused_kw()).toEqual([
+            {topic: "yunos", graphs_load: 7},
+            {topic: "binaries", graphs_load: 7},
+            {topic: "realms", graphs_load: 8}
+        ]);
+    });
+
     test("a refused write of another topic says nothing to the engine", () => {
         const {remote, host, engine} = build("g5");
         gobj_send_event(host, "EV_UPDATE_NODE", {