@yuneta/gobj-ui 7.25.13 → 7.25.14

package/README.md

@@ -819,24 +819,29 @@ 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.
+**A drop is followed by a read of every open table** (7.25.13, 7.25.14). 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, not a refusal: 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 waits.
+
+A drop also hides the node events published while it lasts: another writer's
+create, update or delete reaches no table. So the disconnect edge marks the
+view, and the first edge that finds the transport in session again reads
+EVERY open table once — as the schema editor reloads its model on the
+reconnect. An `EV_CONNECTION_STATE` "up" that comes before the view's own
+transport is in session does not read; the read waits for an edge that finds
+the transport in session. An "up" with no drop before it reads nothing. 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
+// Session up, tables `users` and `roles` open.
+// Session drops                       -> writes in flight answered refused
+// (another writer creates a user; its EV_TREEDB_NODE_CREATED is lost)
 // EV_TRANSPORT_STATE {connected: true}, transport in session
-//                                                      -> `nodes` of that topic, once
+//                                     -> `nodes` of users and of roles, once each
 ```
 
 **The pkey2 of an update goes back as the record had it** (7.25.5). It names

package/dist/gobj-ui.cjs.js

@@ -23757,7 +23757,7 @@ var __gclass__$6 = null;
 ***************************************************************/
 function mt_create$6(gobj) {
 	gobj.priv.form_writes = {};
-	gobj.priv.reload_on_session = {};
+	gobj.priv.reread_on_session = false;
 	gobj.priv.conn_shell = null;
 	build_ui$6(gobj);
 	let subscriber = (0, _yuneta_gobj_js.gobj_read_pointer_attr)(gobj, "subscriber");
@@ -25193,7 +25193,7 @@ function ac_mt_command_answer$2(gobj, event, kw, src) {
 					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;
+						gobj.priv.reread_on_session = 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);
@@ -25394,30 +25394,34 @@ function ac_back_to_topics(gobj, event, kw, src) {
 function ac_transport_state$2(gobj, event, kw, src) {
 	let connected = !!(kw && kw.connected);
 	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);
+	if (!connected) {
+		gobj.priv.reread_on_session = true;
+		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`);
+			answer_form_write(gobj, get_gobj_formtable(gobj, w.topic_name), w.form_write, false);
+		});
+	} else reread_open_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.
+*  The session is back after a drop: read every open table again,
+*  as the schema editor reloads its model. A drop cuts the writes
+*  in flight AND the node events published meanwhile, so any
+*  table may be stale, not only the one a cut write left.
+*
+*  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. The
+*  read waits for an edge that finds the transport in session, and
+*  is done once, though both edges report the same "up".
 ************************************************************/
-function reload_owed_topics(gobj) {
+function reread_open_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);
+	if (!priv.reread_on_session || !is_connected$1(gobj)) return;
+	priv.reread_on_session = false;
+	(0, _yuneta_gobj_js.gobj_match_children)(gobj, { __gclass_name__: "C_YUI_TREEDB_TOPIC_WITH_FORM" }).forEach((form) => {
+		let topic_name = (0, _yuneta_gobj_js.gobj_read_attr)(form, "topic_name");
+		if (topic_name) (0, _yuneta_gobj_js.gobj_send_event)(gobj, "EV_REFRESH_TOPIC", { topic_name }, gobj);
 	});
 }
 /************************************************************

package/dist/gobj-ui.es.js

@@ -23752,7 +23752,7 @@ var __gclass__$6 = null;
 ***************************************************************/
 function mt_create$6(gobj) {
 	gobj.priv.form_writes = {};
-	gobj.priv.reload_on_session = {};
+	gobj.priv.reread_on_session = false;
 	gobj.priv.conn_shell = null;
 	build_ui$6(gobj);
 	let subscriber = gobj_read_pointer_attr(gobj, "subscriber");
@@ -25188,7 +25188,7 @@ function ac_mt_command_answer$2(gobj, event, kw, src) {
 					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;
+						gobj.priv.reread_on_session = 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);
@@ -25389,30 +25389,34 @@ function ac_back_to_topics(gobj, event, kw, src) {
 function ac_transport_state$2(gobj, event, kw, src) {
 	let connected = !!(kw && kw.connected);
 	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);
+	if (!connected) {
+		gobj.priv.reread_on_session = true;
+		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`);
+			answer_form_write(gobj, get_gobj_formtable(gobj, w.topic_name), w.form_write, false);
+		});
+	} else reread_open_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.
+*  The session is back after a drop: read every open table again,
+*  as the schema editor reloads its model. A drop cuts the writes
+*  in flight AND the node events published meanwhile, so any
+*  table may be stale, not only the one a cut write left.
+*
+*  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. The
+*  read waits for an edge that finds the transport in session, and
+*  is done once, though both edges report the same "up".
 ************************************************************/
-function reload_owed_topics(gobj) {
+function reread_open_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);
+	if (!priv.reread_on_session || !is_connected$1(gobj)) return;
+	priv.reread_on_session = false;
+	gobj_match_children(gobj, { __gclass_name__: "C_YUI_TREEDB_TOPIC_WITH_FORM" }).forEach((form) => {
+		let topic_name = gobj_read_attr(form, "topic_name");
+		if (topic_name) gobj_send_event(gobj, "EV_REFRESH_TOPIC", { topic_name }, gobj);
 	});
 }
 /************************************************************

package/package.json

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

package/src/c_yui_treedb_topics.js

@@ -160,10 +160,11 @@ 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 = {};
+    /*  The session dropped since the tables were read: every open table
+     *  may be stale (a write the drop cut, node events published while
+     *  nobody heard them). Read again when the session is back
+     *  (reread_open_topics), never out of session.  */
+    gobj.priv.reread_on_session = false;
     gobj.priv.conn_shell = null;    /*  the shell whose EV_CONNECTION_STATE we hear  */
 
     build_ui(gobj);
@@ -2111,7 +2112,7 @@ function ac_mt_command_answer(gobj, event, kw, src)
                         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;
+                        gobj.priv.reread_on_session = true;
                     }
                 }
                 /*  Answered once: the transport closing may have answered
@@ -2480,13 +2481,12 @@ function ac_transport_state(gobj, event, kw, src)
      *  was typed, and the person saves again when the session is back.
      */
     if(!connected) {
+        /*  What happens in the store while the session is down reaches
+         *  no table: its node events are published to nobody. Every open
+         *  table is read again when the session is back.  */
+        gobj.priv.reread_on_session = true;
         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),
@@ -2495,32 +2495,37 @@ function ac_transport_state(gobj, event, kw, src)
             );
         });
     } else {
-        reload_owed_topics(gobj);
+        reread_open_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.
+ *  The session is back after a drop: read every open table again,
+ *  as the schema editor reloads its model. A drop cuts the writes
+ *  in flight AND the node events published meanwhile, so any
+ *  table may be stale, not only the one a cut write left.
+ *
+ *  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. The
+ *  read waits for an edge that finds the transport in session, and
+ *  is done once, though both edges report the same "up".
  ************************************************************/
-function reload_owed_topics(gobj)
+function reread_open_topics(gobj)
 {
     let priv = gobj.priv;
-    if(!is_connected(gobj)) {
+    if(!priv.reread_on_session || !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  */
+    priv.reread_on_session = false;
+    gobj_match_children(gobj, {
+        __gclass_name__: "C_YUI_TREEDB_TOPIC_WITH_FORM"
+    }).forEach((form) => {
+        let topic_name = gobj_read_attr(form, "topic_name");
+        if(topic_name) {
+            gobj_send_event(gobj, "EV_REFRESH_TOPIC", {topic_name: topic_name}, gobj);
         }
-        gobj_send_event(gobj, "EV_REFRESH_TOPIC", {topic_name: topic_name}, gobj);
     });
 }
 

package/src/treedb_topics_transport.wiring.test.js

@@ -30,6 +30,7 @@ const {register_c_yui_treedb_topics} = await import("./c_yui_treedb_topics.js");
 
 const logged = [];
 const answers = [];         /*  what the fake forms were told  */
+const loaded = [];          /*  the rows each fake form was loaded with  */
 const commands = [];        /*  what the fake transport was asked  */
 
 /*
@@ -57,6 +58,12 @@ function ac_form_answer(gobj, event, kw, src)
     return 0;
 }
 
+function ac_form_load(gobj, event, kw, src)
+{
+    loaded.push({topic: gobj.priv_topic, rows: kw});
+    return 0;
+}
+
 let yuno = null;
 let remote = null;
 
@@ -76,10 +83,11 @@ beforeAll(() => {
     );
     gclass_create(
         "C_YUI_TREEDB_TOPIC_WITH_FORM",
-        [["EV_WRITE_DONE", 0], ["EV_WRITE_REFUSED", 0]],
+        [["EV_WRITE_DONE", 0], ["EV_WRITE_REFUSED", 0], ["EV_LOAD_NODES", 0]],
         [["ST_IDLE", [
             ["EV_WRITE_DONE",    ac_form_answer, null],
-            ["EV_WRITE_REFUSED", ac_form_answer, null]
+            ["EV_WRITE_REFUSED", ac_form_answer, null],
+            ["EV_LOAD_NODES",    ac_form_load,   null]
         ]]],
         {},
         0,
@@ -115,6 +123,7 @@ beforeEach(() => {
     logged.length = 0;
     answers.length = 0;
     commands.length = 0;
+    loaded.length = 0;
 });
 
 function build(name)
@@ -136,7 +145,9 @@ function build(name)
 
     const forms = {};
     for(const topic of ["users", "roles"]) {
-        forms[topic] = gobj_create(`${name}_form_${topic}`, "C_YUI_TREEDB_TOPIC_WITH_FORM",
+        /*  Named as the view names its forms: the answer of a `nodes`
+         *  finds its table by that name.  */
+        forms[topic] = gobj_create(`${name}_topics?${topic}`, "C_YUI_TREEDB_TOPIC_WITH_FORM",
             {topic_name: topic}, topics);
         forms[topic].priv_topic = topic;
     }
@@ -277,13 +288,12 @@ describe("a write cut by the drop does not reload out of session", () => {
         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.  */
+        /*  The reconnect reads every open table -- 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(nodes_asked().sort()).toEqual(["roles", "users"]);
         expect(errors()).toEqual([]);
     });
 
@@ -303,7 +313,7 @@ describe("a write cut by the drop does not reload out of session", () => {
 
         gobj_change_state(remote, "ST_SESSION");
         yui_shell_set_connection_state(shell, true);
-        expect(nodes_asked()).toEqual(["users"]);
+        expect(nodes_asked().sort()).toEqual(["roles", "users"]);
         expect(errors()).toEqual([]);
     });
 
@@ -322,20 +332,78 @@ describe("a write cut by the drop does not reload out of session", () => {
 
         gobj_change_state(remote, "ST_SESSION");
         gobj_send_event(topics, "EV_TRANSPORT_STATE", {connected: true}, topics);
-        expect(nodes_asked()).toEqual(["roles"]);
+        expect(nodes_asked().sort()).toEqual(["roles", "users"]);
         expect(errors().filter((m) => m.includes("not in session"))).toEqual([]);
     });
 
-    test("a write refused IN session reloads its topic at once, and only then", () => {
+    test("a write refused IN session reloads its topic at once", () => {
         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"]);
+    });
+});
 
+/*
+ *  The answer of a `nodes`, the way C_IEVENT_CLI delivers it.
+ */
+function nodes_answer_of(topic_name, rows)
+{
+    return {result: 0, comment: "", data: rows, __md_iev__: {
+        command_stack: [{command: "nodes", kw: {topic_name: topic_name}}]
+    }};
+}
+
+describe("what the drop hid is read again on the reconnect", () => {
+
+    test("a node created during the drop is in its table after the reconnect", () => {
+        const {shell, topics} = build("t10");
+        yui_shell_set_connection_state(shell, true);
+
+        /*  No write in flight: the session just drops. While it is down,
+         *  another writer creates a user; its EV_TREEDB_NODE_CREATED is
+         *  published to nobody.  */
+        gobj_change_state(remote, "ST_DISCONNECTED");
         gobj_send_event(topics, "EV_TRANSPORT_STATE", {connected: false}, topics);
+        yui_shell_set_connection_state(shell, false);
+        expect(nodes_asked()).toEqual([]);
+
+        gobj_change_state(remote, "ST_SESSION");
         gobj_send_event(topics, "EV_TRANSPORT_STATE", {connected: true}, topics);
-        expect(nodes_asked()).toEqual(["users"]);
+        yui_shell_set_connection_state(shell, true);
+
+        /*  Every open table is read once, though two edges said "up".  */
+        expect(nodes_asked().sort()).toEqual(["roles", "users"]);
+
+        gobj_send_event(topics, "EV_MT_COMMAND_ANSWER",
+            nodes_answer_of("users", [{id: "x"}, {id: "created_during_the_drop"}]), remote);
+        expect(loaded).toEqual([
+            {topic: "users", rows: [{id: "x"}, {id: "created_during_the_drop"}]}
+        ]);
+        expect(errors()).toEqual([]);
+    });
+
+    test("an 'up' with no drop before it reads nothing", () => {
+        const {shell, topics} = build("t11");
+        yui_shell_set_connection_state(shell, true);
+        gobj_send_event(topics, "EV_TRANSPORT_STATE", {connected: true}, topics);
+        expect(nodes_asked()).toEqual([]);
+    });
+
+    test("an edge that says 'up' before the transport is in session waits", () => {
+        const {shell, topics} = build("t12");
+        yui_shell_set_connection_state(shell, true);
+        gobj_change_state(remote, "ST_DISCONNECTED");
+        yui_shell_set_connection_state(shell, false);
+
+        yui_shell_set_connection_state(shell, true);
+        expect(nodes_asked()).toEqual([]);
+        expect(errors().filter((m) => m.includes("not in session"))).toEqual([]);
+
+        gobj_change_state(remote, "ST_SESSION");
+        gobj_send_event(topics, "EV_TRANSPORT_STATE", {connected: true}, topics);
+        expect(nodes_asked().sort()).toEqual(["roles", "users"]);
     });
 });