@yuneta/gobj-ui 7.25.12 → 7.25.13

package/README.md

@@ -819,6 +819,26 @@ A write is known by its topic AND its serial (`<topic>^<form_write>`): each
 topic's form counts its serials from 1, and keyed by the serial alone two
 forms saving at once shared one entry.
 
+**A write cut by the drop is not a refusal** (7.25.13). A refused write
+reads its topic again at once, so a cell edited in place goes back to what the
+store has. A write that fails while the transport is NOT in session is the
+drop: a routing adapter (gui_agent's `C_AGENT_TREEDB_LINK`) settles what it
+had in flight when its session closes. The topic cannot be read then — the
+transport refuses the read (*"cannot route 'nodes' -- not in session"*) — so
+the view logs a warning and owes the read. Writes in flight on the
+disconnect edge are owed the same way. The first edge that finds the
+transport in session again pays it: each owed topic whose table is open is
+read once. An `EV_CONNECTION_STATE` "up" that comes before the view's own
+transport is in session leaves the read owed. A form is answered once, also
+when the edge answered it before the failure arrived.
+
+```js
+// Session up: a cell edit goes out as update-node.
+// Session drops; the adapter answers it {result: -1}   -> no read, a warning
+// EV_TRANSPORT_STATE {connected: true}, transport in session
+//                                                      -> `nodes` of that topic, once
+```
+
 **The pkey2 of an update goes back as the record had it** (7.25.5). It names
 the instance the write is for, and a `time` pkey2 that crossed the form's
 `datetime-local` came back without its seconds — another instance, or none.

package/dist/gobj-ui.cjs.js

@@ -23160,11 +23160,17 @@ function track_form_write(in_flight, form_write, topic_name) {
 	};
 }
 /************************************************************
-*  A write was answered, one way or the other
+*  A write was answered, one way or the other. True when it was
+*  still in flight: false when something else answered it already
+*  (the transport closing, abandon_form_writes), so its form must
+*  not be answered twice.
 ************************************************************/
 function settle_form_write(in_flight, form_write, topic_name) {
-	if (!in_flight || !form_write) return;
-	delete in_flight[form_write_key(topic_name, form_write)];
+	if (!in_flight || !form_write) return false;
+	const key = form_write_key(topic_name, form_write);
+	if (!Object.prototype.hasOwnProperty.call(in_flight, key)) return false;
+	delete in_flight[key];
+	return true;
 }
 /************************************************************
 *  Nothing in flight can be answered any more: take them all,
@@ -23751,6 +23757,7 @@ var __gclass__$6 = null;
 ***************************************************************/
 function mt_create$6(gobj) {
 	gobj.priv.form_writes = {};
+	gobj.priv.reload_on_session = {};
 	gobj.priv.conn_shell = null;
 	build_ui$6(gobj);
 	let subscriber = (0, _yuneta_gobj_js.gobj_read_pointer_attr)(gobj, "subscriber");
@@ -25181,9 +25188,15 @@ function ac_mt_command_answer$2(gobj, event, kw, src) {
 			yui_shell_show_error(yui_shell_of(gobj), comment, { t: i18next.t });
 			if (command === "update-node" || command === "create-node") {
 				let failed_topic = (0, _yuneta_gobj_js.kw_get_str)(gobj, kw_command, "topic_name", "", 0);
-				if (failed_topic) (0, _yuneta_gobj_js.gobj_send_event)(gobj, "EV_REFRESH_TOPIC", { topic_name: failed_topic }, gobj);
-				settle_form_write(gobj.priv.form_writes, (0, _yuneta_gobj_js.kw_get_int)(gobj, kw_command, "form_write", 0, 0), failed_topic);
-				answer_form_write(gobj, get_gobj_formtable(gobj, failed_topic), (0, _yuneta_gobj_js.kw_get_int)(gobj, kw_command, "form_write", 0, 0), false);
+				let form_write = (0, _yuneta_gobj_js.kw_get_int)(gobj, kw_command, "form_write", 0, 0);
+				if (failed_topic) {
+					if (is_connected$1(gobj)) (0, _yuneta_gobj_js.gobj_send_event)(gobj, "EV_REFRESH_TOPIC", { topic_name: failed_topic }, gobj);
+					else {
+						(0, _yuneta_gobj_js.log_warning)(`${(0, _yuneta_gobj_js.gobj_short_name)(gobj)}: the write of '${failed_topic}' was cut by the drop: the topic is read again when the session is back`);
+						gobj.priv.reload_on_session[failed_topic] = true;
+					}
+				}
+				if (settle_form_write(gobj.priv.form_writes, form_write, failed_topic)) answer_form_write(gobj, get_gobj_formtable(gobj, failed_topic), form_write, false);
 			}
 		}
 		return 0;
@@ -25383,11 +25396,31 @@ function ac_transport_state$2(gobj, event, kw, src) {
 	refresh_toolbar_buttons(gobj, connected);
 	if (!connected) abandon_form_writes(gobj.priv.form_writes).forEach((w) => {
 		(0, _yuneta_gobj_js.log_warning)(`${(0, _yuneta_gobj_js.gobj_short_name)(gobj)}: transport closed, the write ${w.form_write} of '${w.topic_name}' is lost`);
+		if (w.topic_name) gobj.priv.reload_on_session[w.topic_name] = true;
 		answer_form_write(gobj, get_gobj_formtable(gobj, w.topic_name), w.form_write, false);
 	});
+	else reload_owed_topics(gobj);
 	return 0;
 }
 /************************************************************
+*  The session is back: read again the topics a drop left
+*  unknown. Only when the TRANSPORT says so too -- the app's
+*  connection (EV_CONNECTION_STATE) can report "up" before the
+*  transport of this view is in session, and a read asked then is
+*  refused. What is owed stays owed until an edge finds the
+*  transport in session; each topic is read once.
+************************************************************/
+function reload_owed_topics(gobj) {
+	let priv = gobj.priv;
+	if (!is_connected$1(gobj)) return;
+	let topics = Object.keys(priv.reload_on_session);
+	priv.reload_on_session = {};
+	topics.forEach((topic_name) => {
+		if (!get_gobj_formtable(gobj, topic_name)) return;
+		(0, _yuneta_gobj_js.gobj_send_event)(gobj, "EV_REFRESH_TOPIC", { topic_name }, gobj);
+	});
+}
+/************************************************************
 *   Parent (routing) inform us that we go hidden
 ************************************************************/
 function ac_hide$4(gobj, event, kw, src) {

package/dist/gobj-ui.es.js

@@ -23155,11 +23155,17 @@ function track_form_write(in_flight, form_write, topic_name) {
 	};
 }
 /************************************************************
-*  A write was answered, one way or the other
+*  A write was answered, one way or the other. True when it was
+*  still in flight: false when something else answered it already
+*  (the transport closing, abandon_form_writes), so its form must
+*  not be answered twice.
 ************************************************************/
 function settle_form_write(in_flight, form_write, topic_name) {
-	if (!in_flight || !form_write) return;
-	delete in_flight[form_write_key(topic_name, form_write)];
+	if (!in_flight || !form_write) return false;
+	const key = form_write_key(topic_name, form_write);
+	if (!Object.prototype.hasOwnProperty.call(in_flight, key)) return false;
+	delete in_flight[key];
+	return true;
 }
 /************************************************************
 *  Nothing in flight can be answered any more: take them all,
@@ -23746,6 +23752,7 @@ var __gclass__$6 = null;
 ***************************************************************/
 function mt_create$6(gobj) {
 	gobj.priv.form_writes = {};
+	gobj.priv.reload_on_session = {};
 	gobj.priv.conn_shell = null;
 	build_ui$6(gobj);
 	let subscriber = gobj_read_pointer_attr(gobj, "subscriber");
@@ -25176,9 +25183,15 @@ function ac_mt_command_answer$2(gobj, event, kw, src) {
 			yui_shell_show_error(yui_shell_of(gobj), comment, { t });
 			if (command === "update-node" || command === "create-node") {
 				let failed_topic = kw_get_str(gobj, kw_command, "topic_name", "", 0);
-				if (failed_topic) gobj_send_event(gobj, "EV_REFRESH_TOPIC", { topic_name: failed_topic }, gobj);
-				settle_form_write(gobj.priv.form_writes, kw_get_int(gobj, kw_command, "form_write", 0, 0), failed_topic);
-				answer_form_write(gobj, get_gobj_formtable(gobj, failed_topic), kw_get_int(gobj, kw_command, "form_write", 0, 0), false);
+				let form_write = kw_get_int(gobj, kw_command, "form_write", 0, 0);
+				if (failed_topic) {
+					if (is_connected$1(gobj)) gobj_send_event(gobj, "EV_REFRESH_TOPIC", { topic_name: failed_topic }, gobj);
+					else {
+						log_warning(`${gobj_short_name(gobj)}: the write of '${failed_topic}' was cut by the drop: the topic is read again when the session is back`);
+						gobj.priv.reload_on_session[failed_topic] = true;
+					}
+				}
+				if (settle_form_write(gobj.priv.form_writes, form_write, failed_topic)) answer_form_write(gobj, get_gobj_formtable(gobj, failed_topic), form_write, false);
 			}
 		}
 		return 0;
@@ -25378,11 +25391,31 @@ function ac_transport_state$2(gobj, event, kw, src) {
 	refresh_toolbar_buttons(gobj, connected);
 	if (!connected) abandon_form_writes(gobj.priv.form_writes).forEach((w) => {
 		log_warning(`${gobj_short_name(gobj)}: transport closed, the write ${w.form_write} of '${w.topic_name}' is lost`);
+		if (w.topic_name) gobj.priv.reload_on_session[w.topic_name] = true;
 		answer_form_write(gobj, get_gobj_formtable(gobj, w.topic_name), w.form_write, false);
 	});
+	else reload_owed_topics(gobj);
 	return 0;
 }
 /************************************************************
+*  The session is back: read again the topics a drop left
+*  unknown. Only when the TRANSPORT says so too -- the app's
+*  connection (EV_CONNECTION_STATE) can report "up" before the
+*  transport of this view is in session, and a read asked then is
+*  refused. What is owed stays owed until an edge finds the
+*  transport in session; each topic is read once.
+************************************************************/
+function reload_owed_topics(gobj) {
+	let priv = gobj.priv;
+	if (!is_connected$1(gobj)) return;
+	let topics = Object.keys(priv.reload_on_session);
+	priv.reload_on_session = {};
+	topics.forEach((topic_name) => {
+		if (!get_gobj_formtable(gobj, topic_name)) return;
+		gobj_send_event(gobj, "EV_REFRESH_TOPIC", { topic_name }, gobj);
+	});
+}
+/************************************************************
 *   Parent (routing) inform us that we go hidden
 ************************************************************/
 function ac_hide$4(gobj, event, kw, src) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yuneta/gobj-ui",
-  "version": "7.25.12",
+  "version": "7.25.13",
   "type": "module",
   "main": "dist/gobj-ui.cjs.js",
   "module": "dist/gobj-ui.es.js",

package/src/c_yui_treedb_topics.js

@@ -160,6 +160,10 @@ function mt_create(gobj)
      *  and serial (form_writes_in_flight): answered refused when the
      *  transport closes under them.  */
     gobj.priv.form_writes = {};
+    /*  The topics a write cut by a DROP left unknown: the table may show
+     *  what was typed and the store what it had. Read again when the
+     *  session is back (reload_owed_topics), never out of session.  */
+    gobj.priv.reload_on_session = {};
     gobj.priv.conn_shell = null;    /*  the shell whose EV_CONNECTION_STATE we hear  */
 
     build_ui(gobj);
@@ -2092,18 +2096,34 @@ function ac_mt_command_answer(gobj, event, kw, src)
              *  topic back to what the treedb actually has. */
             if(command === "update-node" || command === "create-node") {
                 let failed_topic = kw_get_str(gobj, kw_command, "topic_name", "", 0);
+                let form_write = kw_get_int(gobj, kw_command, "form_write", 0, 0);
                 if(failed_topic) {
-                    gobj_send_event(gobj, "EV_REFRESH_TOPIC",
-                        {topic_name: failed_topic}, gobj);
+                    if(is_connected(gobj)) {
+                        gobj_send_event(gobj, "EV_REFRESH_TOPIC",
+                            {topic_name: failed_topic}, gobj);
+                    } else {
+                        /*  A failure out of session is the DROP, not a
+                         *  refusal: a routing adapter settles what it had
+                         *  in flight when its session closes. The topic
+                         *  cannot be read now -- asked, the transport
+                         *  refuses it ("cannot route 'nodes' -- not in
+                         *  session"). The reconnect reads it.  */
+                        log_warning(`${gobj_short_name(gobj)}: the write of ` +
+                            `'${failed_topic}' was cut by the drop: the topic is ` +
+                            `read again when the session is back`);
+                        gobj.priv.reload_on_session[failed_topic] = true;
+                    }
+                }
+                /*  Answered once: the transport closing may have answered
+                 *  this form already (ac_transport_state).  */
+                if(settle_form_write(gobj.priv.form_writes, form_write, failed_topic)) {
+                    answer_form_write(
+                        gobj,
+                        get_gobj_formtable(gobj, failed_topic),
+                        form_write,
+                        false
+                    );
                 }
-                settle_form_write(gobj.priv.form_writes,
-                    kw_get_int(gobj, kw_command, "form_write", 0, 0), failed_topic);
-                answer_form_write(
-                    gobj,
-                    get_gobj_formtable(gobj, failed_topic),
-                    kw_get_int(gobj, kw_command, "form_write", 0, 0),
-                    false
-                );
             }
         }
         return 0;
@@ -2462,6 +2482,11 @@ function ac_transport_state(gobj, event, kw, src)
     if(!connected) {
         abandon_form_writes(gobj.priv.form_writes).forEach((w) => {
             log_warning(`${gobj_short_name(gobj)}: transport closed, the write ${w.form_write} of '${w.topic_name}' is lost`);
+            /*  Whether it reached the store is unknown: read it again
+             *  when the session is back.  */
+            if(w.topic_name) {
+                gobj.priv.reload_on_session[w.topic_name] = true;
+            }
             answer_form_write(
                 gobj,
                 get_gobj_formtable(gobj, w.topic_name),
@@ -2469,10 +2494,36 @@ function ac_transport_state(gobj, event, kw, src)
                 false
             );
         });
+    } else {
+        reload_owed_topics(gobj);
     }
     return 0;
 }
 
+/************************************************************
+ *  The session is back: read again the topics a drop left
+ *  unknown. Only when the TRANSPORT says so too -- the app's
+ *  connection (EV_CONNECTION_STATE) can report "up" before the
+ *  transport of this view is in session, and a read asked then is
+ *  refused. What is owed stays owed until an edge finds the
+ *  transport in session; each topic is read once.
+ ************************************************************/
+function reload_owed_topics(gobj)
+{
+    let priv = gobj.priv;
+    if(!is_connected(gobj)) {
+        return;
+    }
+    let topics = Object.keys(priv.reload_on_session);
+    priv.reload_on_session = {};
+    topics.forEach((topic_name) => {
+        if(!get_gobj_formtable(gobj, topic_name)) {
+            return;     /*  its table is closed: opening it reads it  */
+        }
+        gobj_send_event(gobj, "EV_REFRESH_TOPIC", {topic_name: topic_name}, gobj);
+    });
+}
+
 /************************************************************
  *   Parent (routing) inform us that we go hidden
  ************************************************************/

package/src/form_writes_in_flight.js

@@ -44,14 +44,22 @@ function track_form_write(in_flight, form_write, topic_name)
 }
 
 /************************************************************
- *  A write was answered, one way or the other
+ *  A write was answered, one way or the other. True when it was
+ *  still in flight: false when something else answered it already
+ *  (the transport closing, abandon_form_writes), so its form must
+ *  not be answered twice.
  ************************************************************/
 function settle_form_write(in_flight, form_write, topic_name)
 {
     if(!in_flight || !form_write) {
-        return;
+        return false;
+    }
+    const key = form_write_key(topic_name, form_write);
+    if(!Object.prototype.hasOwnProperty.call(in_flight, key)) {
+        return false;
     }
-    delete in_flight[form_write_key(topic_name, form_write)];
+    delete in_flight[key];
+    return true;
 }
 
 /************************************************************

package/src/treedb_topics_transport.wiring.test.js

@@ -22,7 +22,7 @@ const {
     gclass_create,
     gobj_start_up, gobj_create_yuno, gobj_create, gobj_create_service,
     gobj_start, gobj_send_event,
-    gobj_change_state,
+    gobj_change_state, gobj_current_state,
     set_log_callback,
 } = gobj_js;
 const {register_c_yui_shell, yui_shell_set_connection_state} = await import("./c_yui_shell.js");
@@ -34,11 +34,16 @@ const commands = [];        /*  what the fake transport was asked  */
 
 /*
  *  The transport: answers nothing, like a C_IEVENT_CLI whose socket is
- *  about to drop. Its state is what `is_connected()` reads.
+ *  about to drop. Its state is what `is_connected()` reads. Out of
+ *  session it refuses what it is asked, as gui_agent's routing adapter
+ *  (C_AGENT_TREEDB_LINK) does.
  */
 function remote_command_parser(gobj, command, kw, src)
 {
     commands.push({command, kw});
+    if(gobj_current_state(gobj) !== "ST_SESSION") {
+        return `cannot route '${command}' -- not in session`;
+    }
     return null;
 }
 
@@ -78,7 +83,11 @@ beforeAll(() => {
         ]]],
         {},
         0,
-        [SDATA(data_type_t.DTP_STRING, "topic_name", 0, "", "topic"), SDATA_END()],
+        [
+            SDATA(data_type_t.DTP_STRING, "topic_name", 0, "", "topic"),
+            SDATA(data_type_t.DTP_BOOLEAN, "with_remote_paging", 0, false, "pulls its pages"),
+            SDATA_END()
+        ],
         {}, 0, 0, 0, 0
     );
     /*  The host of the view: it hears what a CHILD view publishes.  */
@@ -226,3 +235,107 @@ describe("a Save in flight when the backend drops (M8)", () => {
         ]);
     });
 });
+
+/*
+ *  The answer the routing adapter gives a write it had in flight when
+ *  its session closed: a failure, settled by the adapter itself.
+ */
+function failed_write(topic_name, form_write)
+{
+    const md = {topic_name: topic_name, treedb_name: "treedb_test", record: {id: "x"}};
+    if(form_write) {
+        md.form_write = form_write;
+    }
+    return {result: -1, comment: "the session closed", data: null, __md_iev__: {
+        command_stack: [{command: "update-node", kw: md}]
+    }};
+}
+
+function nodes_asked()
+{
+    return commands.filter((c) => c.command === "nodes").map((c) => c.kw.topic_name);
+}
+
+describe("a write cut by the drop does not reload out of session", () => {
+
+    test("the failure lands before the edge: no reload now, one on the reconnect", () => {
+        const {shell, topics} = build("t6");
+        yui_shell_set_connection_state(shell, true);
+
+        /*  A cell edited in place: it looks saved until the topic is read again.  */
+        gobj_send_event(topics, "EV_UPDATE_FIELD",
+            {topic_name: "users", id: "x", field: "name", value: "typed"}, topics);
+        expect(commands.filter((c) => c.command === "update-node").length).toBe(1);
+
+        /*  The adapter leaves ST_SESSION and settles what it had in flight.  */
+        gobj_change_state(remote, "ST_DISCONNECTED");
+        gobj_send_event(topics, "EV_MT_COMMAND_ANSWER", failed_write("users", 0), remote);
+
+        expect(nodes_asked()).toEqual([]);
+        expect(errors().filter((m) => m.includes("not in session"))).toEqual([]);
+
+        gobj_send_event(topics, "EV_TRANSPORT_STATE", {connected: false}, topics);
+        expect(nodes_asked()).toEqual([]);
+
+        /*  The reconnect reloads what the drop left unknown -- once, though
+         *  two edges report it.  */
+        gobj_change_state(remote, "ST_SESSION");
+        gobj_send_event(topics, "EV_TRANSPORT_STATE", {connected: true}, topics);
+        yui_shell_set_connection_state(shell, false);
+        yui_shell_set_connection_state(shell, true);
+        expect(nodes_asked()).toEqual(["users"]);
+        expect(errors()).toEqual([]);
+    });
+
+    test("the edge lands first: the form is answered once, the reload waits", () => {
+        const {shell, topics, forms} = build("t7");
+        yui_shell_set_connection_state(shell, true);
+        save(topics, forms.users, 1);
+
+        gobj_change_state(remote, "ST_DISCONNECTED");
+        yui_shell_set_connection_state(shell, false);
+        gobj_send_event(topics, "EV_MT_COMMAND_ANSWER", failed_write("users", 1), remote);
+
+        expect(answers).toEqual([
+            {topic: "users", event: "EV_WRITE_REFUSED", form_write: 1},
+        ]);
+        expect(nodes_asked()).toEqual([]);
+
+        gobj_change_state(remote, "ST_SESSION");
+        yui_shell_set_connection_state(shell, true);
+        expect(nodes_asked()).toEqual(["users"]);
+        expect(errors()).toEqual([]);
+    });
+
+    test("an edge that says 'up' before the transport is: the reload still waits", () => {
+        const {shell, topics} = build("t8");
+        yui_shell_set_connection_state(shell, true);
+        gobj_send_event(topics, "EV_UPDATE_FIELD",
+            {topic_name: "roles", id: "x", field: "name", value: "typed"}, topics);
+        gobj_change_state(remote, "ST_DISCONNECTED");
+        gobj_send_event(topics, "EV_MT_COMMAND_ANSWER", failed_write("roles", 0), remote);
+        yui_shell_set_connection_state(shell, false);
+
+        /*  The app's connection is back, the view's transport is not yet.  */
+        yui_shell_set_connection_state(shell, true);
+        expect(nodes_asked()).toEqual([]);
+
+        gobj_change_state(remote, "ST_SESSION");
+        gobj_send_event(topics, "EV_TRANSPORT_STATE", {connected: true}, topics);
+        expect(nodes_asked()).toEqual(["roles"]);
+        expect(errors().filter((m) => m.includes("not in session"))).toEqual([]);
+    });
+
+    test("a write refused IN session reloads its topic at once, and only then", () => {
+        const {shell, topics} = build("t9");
+        yui_shell_set_connection_state(shell, true);
+        gobj_send_event(topics, "EV_UPDATE_FIELD",
+            {topic_name: "users", id: "x", field: "name", value: "typed"}, topics);
+        gobj_send_event(topics, "EV_MT_COMMAND_ANSWER", failed_write("users", 0), remote);
+        expect(nodes_asked()).toEqual(["users"]);
+
+        gobj_send_event(topics, "EV_TRANSPORT_STATE", {connected: false}, topics);
+        gobj_send_event(topics, "EV_TRANSPORT_STATE", {connected: true}, topics);
+        expect(nodes_asked()).toEqual(["users"]);
+    });
+});