@yuneta/gobj-ui 7.25.3 → 7.25.5

package/src/host_drafts.test.js

@@ -1,5 +1,5 @@
 import {describe, it, expect} from "vitest";
-import {mark_host_drafts, drafts_of_saved_answer} from "./host_drafts.js";
+import {host_draft_ids, mark_host_drafts, drafts_of_saved_answer} from "./host_drafts.js";
 
 const model = {
     treedbs: [
@@ -60,3 +60,26 @@ describe("drafts_of_saved_answer", () => {
         expect(drafts_of_saved_answer(null)).toEqual({});
     });
 });
+
+describe("host_draft_ids", () => {
+
+    it("resolves the host's names on the model, as topic ids", () => {
+        expect(host_draft_ids(model, {treedb_a: ["users"], treedb_b: ["users"]}))
+            .toEqual({"treedb_a^users": true, "treedb_b^users": true});
+    });
+
+    it("is a fresh map every time: what the host stopped naming is gone (M1)", () => {
+        /*  mark_host_drafts() only ADDS, and the editor fed it the same map
+         *  every time: a topic the host named before the Save stayed a
+         *  draft after it.  */
+        const before = host_draft_ids(model, {treedb_a: ["users", "roles"]});
+        const after = host_draft_ids(model, {treedb_a: []});
+        expect(before).toEqual({"treedb_a^users": true, "treedb_a^roles": true});
+        expect(after).toEqual({});
+    });
+
+    it("no model, no drafts: empty", () => {
+        expect(host_draft_ids(null, {treedb_a: ["users"]})).toEqual({});
+        expect(host_draft_ids(model, null)).toEqual({});
+    });
+});

package/src/schema_editor_drafts.wiring.test.js

@@ -0,0 +1,176 @@
+/***********************************************************************
+ *          schema_editor_drafts.wiring.test.js
+ *
+ *      EV_DRAFTS driven through a real C_YUI_SCHEMA_EDITOR on a document
+ *      double. The helper was right and tested; the ACTION folded the
+ *      host's marks into the session's, so a topic the host named before
+ *      a Save stayed a draft after it (M1 of the 2026-09-23 review).
+ *
+ *          Copyright (c) 2026, ArtGins.
+ *          All Rights Reserved.
+ ***********************************************************************/
+import {describe, test, expect, beforeAll, beforeEach} from "vitest";
+import {install_dom_double} from "../test/dom_double.js";
+
+install_dom_double();
+
+const {
+    SDATA_END,
+    gclass_create,
+    gobj_start_up, gobj_create_yuno, gobj_create, gobj_create_service,
+    gobj_start, gobj_send_event, gobj_read_attr,
+    gobj_change_state,
+    set_log_callback,
+} = await import("@yuneta/gobj-js");
+const {register_c_yui_schema_editor, topic_is_draft} = await import("./c_yui_schema_editor.js");
+
+const logged = [];
+const commands = [];
+
+/*  The yuno's system schema: one treedb, two topics.  */
+const RECORDS = {
+    treedbs: [{id: "db", schema_version: 4}],
+    topics: [
+        {id: "db.users", value: "users", order: 1, pkey: "id", topic_version: 2,
+         treedbs: ["treedbs^db^topics"]},
+        {id: "db.roles", value: "roles", order: 2, pkey: "id", topic_version: 1,
+         treedbs: ["treedbs^db^topics"]},
+    ],
+    cols: [
+        {id: "db.users.id", value: "id", order: 1, type: "string",
+         flag: ["persistent", "required"], topics: ["topics^db.users^cols"]},
+        {id: "db.roles.id", value: "id", order: 1, type: "string",
+         flag: ["persistent", "required"], topics: ["topics^db.roles^cols"]},
+    ],
+};
+
+function remote_command_parser(gobj, command, kw, src)
+{
+    commands.push({command, kw, src});
+    return null;
+}
+
+let yuno = null;
+
+beforeAll(() => {
+    gobj_start_up(null, null, null, null, null, null, null);
+    set_log_callback((level, msg) => {
+        logged.push({level: String(level), msg: String(msg)});
+    });
+    gclass_create("C_TEST_HOST", [], [["ST_IDLE", []]], {}, 0, [SDATA_END()], {}, 0, 0, 0, 0);
+    gclass_create(
+        "C_TEST_EDITOR_HOST",
+        [["EV_POSITION_CHANGED", 0], ["EV_RECORD_WRITTEN", 0], ["EV_SCHEMA_CHECKED", 0]],
+        [["ST_IDLE", [
+            ["EV_POSITION_CHANGED", () => 0, null],
+            ["EV_RECORD_WRITTEN",   () => 0, null],
+            ["EV_SCHEMA_CHECKED",   () => 0, null]
+        ]]],
+        {}, 0, [SDATA_END()], {}, 0, 0, 0, 0
+    );
+    gclass_create(
+        "C_TEST_REMOTE",
+        [],
+        [["ST_SESSION", []]],
+        {mt_command_parser: remote_command_parser},
+        0, [SDATA_END()], {}, 0, 0, 0, 0
+    );
+    register_c_yui_schema_editor();
+    yuno = gobj_create_yuno("drafts_yuno", "C_TEST_HOST", {});
+    gobj_start(yuno);
+});
+
+beforeEach(() => {
+    logged.length = 0;
+    commands.length = 0;
+});
+
+/*  Answer every `nodes` the editor asked, the way a transport does: the
+ *  request's frame on top of the command_stack.  */
+function answer_the_load(editor, remote)
+{
+    const asked = commands.filter((c) => c.command === "nodes");
+    commands.length = 0;
+    for(const c of asked) {
+        gobj_send_event(editor, "EV_MT_COMMAND_ANSWER", {
+            result: 0,
+            data: RECORDS[c.kw.topic_name],
+            __md_iev__: {command_stack: [{command: "nodes", kw: c.kw}]}
+        }, remote);
+    }
+    return asked.length;
+}
+
+function build(name)
+{
+    const remote = gobj_create_service(`${name}_remote`, "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", {
+        gobj_remote_yuno: remote,
+        treedb_name: "treedb_system_schema",
+        base_route: "/schemas"
+    }, host);
+    gobj_start(editor);
+    expect(answer_the_load(editor, remote)).toBe(3);
+    gobj_send_event(editor, "EV_SHOW", {subpath: "db"}, host);
+    return {editor, remote, host};
+}
+
+function drafts_on_screen(editor)
+{
+    const $c = gobj_read_attr(editor, "$container");
+    return $c.querySelectorAll(".SCHEMA_TOPIC_VERSION .is-warning").length;
+}
+
+function is_draft(editor, topic_id)
+{
+    return topic_is_draft(editor.priv, {id: topic_id});
+}
+
+describe("EV_DRAFTS: the host is the truth", () => {
+
+    test("the host names a topic: it is a draft, on screen too", () => {
+        const {editor, host} = build("d1");
+        gobj_send_event(editor, "EV_DRAFTS", {drafts: {db: ["users"]}}, host);
+        expect(is_draft(editor, "db.users")).toBe(true);
+        expect(is_draft(editor, "db.roles")).toBe(false);
+        expect(drafts_on_screen(editor)).toBe(1);
+    });
+
+    test("the host names none any more (a Save): the mark goes (M1)", () => {
+        /*  It only ever ADDED: after the Save the editor still said
+         *  "unsaved schema changes".  */
+        const {editor, host} = build("d2");
+        gobj_send_event(editor, "EV_DRAFTS", {drafts: {db: ["users", "roles"]}}, host);
+        expect(drafts_on_screen(editor)).toBe(2);
+
+        gobj_send_event(editor, "EV_DRAFTS", {drafts: {db: []}}, host);
+        expect(is_draft(editor, "db.users")).toBe(false);
+        expect(is_draft(editor, "db.roles")).toBe(false);
+        expect(drafts_on_screen(editor)).toBe(0);
+    });
+
+    test("a reload keeps what the host said last, and only that", () => {
+        const {editor, remote, host} = build("d3");
+        gobj_send_event(editor, "EV_DRAFTS", {drafts: {db: ["roles"]}}, host);
+        gobj_send_event(editor, "EV_REFRESH", {}, host);
+        expect(answer_the_load(editor, remote)).toBe(3);
+        expect(is_draft(editor, "db.roles")).toBe(true);
+        expect(is_draft(editor, "db.users")).toBe(false);
+    });
+
+    test("what this session wrote is not cleared by the host's answer", () => {
+        const {editor, host} = build("d4");
+        editor.priv.written["db.users"] = true;     /*  a write of this session  */
+        gobj_send_event(editor, "EV_DRAFTS", {drafts: {}}, host);
+        expect(is_draft(editor, "db.users")).toBe(true);
+    });
+
+    test("no error logged on the way", () => {
+        const {editor, host} = build("d5");
+        gobj_send_event(editor, "EV_DRAFTS", {drafts: {db: ["users"]}}, host);
+        gobj_send_event(editor, "EV_DRAFTS", {drafts: {}}, host);
+        expect(logged.filter((l) => l.level === "error").map((l) => l.msg)).toEqual([]);
+    });
+});

package/src/schema_version_bump.test.js

@@ -19,17 +19,22 @@ const TOPIC = {id: "device_groups", topic_version: 5};
 
 describe("topic_is_draft", () => {
     it("says nothing about a topic this session never wrote", () => {
-        expect(topic_is_draft({}, TOPIC)).toBe(false);
+        expect(topic_is_draft({written: {}, host_ids: {}}, TOPIC)).toBe(false);
     });
 
     it("a written topic is a draft, whatever its version says", () => {
-        expect(topic_is_draft({device_groups: true}, TOPIC)).toBe(true);
-        expect(topic_is_draft({device_groups: true}, {id: "device_groups", topic_version: 6}))
-            .toBe(true);
+        expect(topic_is_draft({written: {device_groups: true}}, TOPIC)).toBe(true);
+        expect(topic_is_draft({written: {device_groups: true}},
+            {id: "device_groups", topic_version: 6})).toBe(true);
+    });
+
+    it("a topic the host names is a draft too (EV_DRAFTS)", () => {
+        expect(topic_is_draft({written: {}, host_ids: {device_groups: true}}, TOPIC)).toBe(true);
     });
 
     it("answers false rather than throwing on a missing half", () => {
         expect(topic_is_draft(null, TOPIC)).toBe(false);
-        expect(topic_is_draft({device_groups: true}, null)).toBe(false);
+        expect(topic_is_draft({written: {device_groups: true}}, null)).toBe(false);
+        expect(topic_is_draft({}, TOPIC)).toBe(false);
     });
 });

package/src/treedb_topics_transport.wiring.test.js

@@ -0,0 +1,228 @@
+/***********************************************************************
+ *          treedb_topics_transport.wiring.test.js
+ *
+ *      The WIRING of a form's write and the backend going away, driven
+ *      through the real gclasses (C_YUI_SHELL, C_YUI_TREEDB_TOPICS) on a
+ *      document double. The helper (form_writes_in_flight.js) was tested
+ *      and right; what failed was that two hosts never called the action
+ *      that uses it (M8 of the 2026-09-23 review), which no helper test
+ *      can see.
+ *
+ *          Copyright (c) 2026, ArtGins.
+ *          All Rights Reserved.
+ ***********************************************************************/
+import {describe, test, expect, beforeAll, beforeEach} from "vitest";
+import {install_dom_double} from "../test/dom_double.js";
+
+install_dom_double();
+
+const gobj_js = await import("@yuneta/gobj-js");
+const {
+    SDATA, SDATA_END, data_type_t, event_flag_t,
+    gclass_create,
+    gobj_start_up, gobj_create_yuno, gobj_create, gobj_create_service,
+    gobj_start, gobj_send_event,
+    gobj_change_state,
+    set_log_callback,
+} = gobj_js;
+const {register_c_yui_shell, yui_shell_set_connection_state} = await import("./c_yui_shell.js");
+const {register_c_yui_treedb_topics} = await import("./c_yui_treedb_topics.js");
+
+const logged = [];
+const answers = [];         /*  what the fake forms were told  */
+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.
+ */
+function remote_command_parser(gobj, command, kw, src)
+{
+    commands.push({command, kw});
+    return null;
+}
+
+/*
+ *  A topic form, as C_YUI_TREEDB_TOPICS finds it (by gclass name and
+ *  `topic_name`) to answer its write.
+ */
+function ac_form_answer(gobj, event, kw, src)
+{
+    answers.push({topic: gobj.priv_topic, event, form_write: kw.form_write});
+    return 0;
+}
+
+let yuno = null;
+let remote = null;
+
+beforeAll(() => {
+    gobj_start_up(null, null, null, null, null, null, null);
+    set_log_callback((level, msg) => {
+        logged.push({level: String(level), msg: String(msg)});
+    });
+
+    gclass_create("C_TEST_HOST", [], [["ST_IDLE", []]], {}, 0, [SDATA_END()], {}, 0, 0, 0, 0);
+    gclass_create(
+        "C_TEST_REMOTE",
+        [],
+        [["ST_SESSION", []], ["ST_DISCONNECTED", []]],
+        {mt_command_parser: remote_command_parser},
+        0, [SDATA_END()], {}, 0, 0, 0, 0
+    );
+    gclass_create(
+        "C_YUI_TREEDB_TOPIC_WITH_FORM",
+        [["EV_WRITE_DONE", 0], ["EV_WRITE_REFUSED", 0]],
+        [["ST_IDLE", [
+            ["EV_WRITE_DONE",    ac_form_answer, null],
+            ["EV_WRITE_REFUSED", ac_form_answer, null]
+        ]]],
+        {},
+        0,
+        [SDATA(data_type_t.DTP_STRING, "topic_name", 0, "", "topic"), SDATA_END()],
+        {}, 0, 0, 0, 0
+    );
+    /*  The host of the view: it hears what a CHILD view publishes.  */
+    gclass_create(
+        "C_TEST_VIEW_HOST",
+        [["EV_RECORD_WRITTEN", 0], ["EV_TOPIC_SELECTED", 0]],
+        [["ST_IDLE", [
+            ["EV_RECORD_WRITTEN", () => 0, null],
+            ["EV_TOPIC_SELECTED", () => 0, null]
+        ]]],
+        {}, 0, [SDATA_END()], {}, 0, 0, 0, 0
+    );
+    /*  An app that subscribes to EVERY event of its shell and declares
+     *  none of the new ones: wattyzer's and yunovatios' shape.  */
+    gclass_create("C_TEST_APP", [], [["ST_IDLE", []]], {}, 0, [SDATA_END()], {}, 0, 0, 0, 0);
+
+    register_c_yui_shell();
+    register_c_yui_treedb_topics();
+
+    yuno = gobj_create_yuno("wiring_yuno", "C_TEST_HOST", {});
+    gobj_start(yuno);
+});
+
+beforeEach(() => {
+    logged.length = 0;
+    answers.length = 0;
+    commands.length = 0;
+});
+
+function build(name)
+{
+    const app = gobj_create(`${name}_app`, "C_TEST_APP", {}, yuno);
+    gobj_start(app);
+    const shell = gobj_create(`${name}_shell`, "C_YUI_SHELL", {config: {shell: {}}, default_route: "/home", subscriber: app}, app);
+    gobj_start(shell);
+
+    remote = gobj_create_service(`${name}_remote`, "C_TEST_REMOTE", {}, yuno);
+    gobj_change_state(remote, "ST_SESSION");
+
+    const host = gobj_create(`${name}_host`, "C_TEST_VIEW_HOST", {}, yuno);
+    const topics = gobj_create_service(`${name}_topics`, "C_YUI_TREEDB_TOPICS", {
+        treedb_name: "treedb_test",
+        gobj_remote_yuno: remote
+    }, host);
+    gobj_start(topics);
+
+    const forms = {};
+    for(const topic of ["users", "roles"]) {
+        forms[topic] = gobj_create(`${name}_form_${topic}`, "C_YUI_TREEDB_TOPIC_WITH_FORM",
+            {topic_name: topic}, topics);
+        forms[topic].priv_topic = topic;
+    }
+    /*  What the start of a shell with no routes says is the fixture's,
+     *  not the behaviour under test: the check starts here.  */
+    logged.length = 0;
+    return {app, shell, topics, forms};
+}
+
+function save(topics, form, form_write)
+{
+    gobj_send_event(topics, "EV_UPDATE_RECORD",
+        {record: {id: "x"}, form_write: form_write}, form);
+}
+
+/*  EVERY error the run logged: the check a deployed page gets too.  */
+function errors()
+{
+    return logged.filter((l) => l.level === "error").map((l) => l.msg);
+}
+
+describe("a Save in flight when the backend drops (M8)", () => {
+
+    test("the shell's connection edge answers every form, with no host forwarding", () => {
+        const {shell, topics, forms} = build("t1");
+        yui_shell_set_connection_state(shell, true);
+
+        /*  Two forms, each at ITS serial 1: two writes, not one.  */
+        save(topics, forms.users, 1);
+        save(topics, forms.roles, 1);
+        expect(commands.filter((c) => c.command === "update-node").length).toBe(2);
+        expect(answers).toEqual([]);
+
+        yui_shell_set_connection_state(shell, false);
+
+        expect(answers).toEqual([
+            {topic: "users", event: "EV_WRITE_REFUSED", form_write: 1},
+            {topic: "roles", event: "EV_WRITE_REFUSED", form_write: 1},
+        ]);
+        expect(errors()).toEqual([]);
+    });
+
+    test("a host that also forwards EV_TRANSPORT_STATE: each write answered once", () => {
+        const {shell, topics, forms} = build("t2");
+        yui_shell_set_connection_state(shell, true);
+        save(topics, forms.users, 1);
+
+        gobj_send_event(topics, "EV_TRANSPORT_STATE", {connected: false}, topics);
+        yui_shell_set_connection_state(shell, false);
+
+        expect(answers).toEqual([
+            {topic: "users", event: "EV_WRITE_REFUSED", form_write: 1},
+        ]);
+    });
+
+    test("only an EDGE is published: a repeated 'down' answers nothing twice", () => {
+        const {shell, topics, forms} = build("t3");
+        yui_shell_set_connection_state(shell, true);
+        save(topics, forms.users, 1);
+        yui_shell_set_connection_state(shell, false);
+        yui_shell_set_connection_state(shell, false);
+        expect(answers.length).toBe(1);
+    });
+
+    test("an app subscribed to every shell event is not sent the new one", () => {
+        /*  C_TEST_APP declares no event at all: were EV_CONNECTION_STATE
+         *  published to it, the FSM would log "Event NOT DEFINED".  */
+        const {shell} = build("t4");
+        yui_shell_set_connection_state(shell, true);
+        yui_shell_set_connection_state(shell, false);
+        expect(errors()).toEqual([]);
+    });
+
+    test("an answer from the backend settles its own form only", () => {
+        const {shell, topics, forms} = build("t5");
+        yui_shell_set_connection_state(shell, true);
+        save(topics, forms.users, 1);
+        save(topics, forms.roles, 1);
+
+        /*  The answer of the users write, the way C_IEVENT_CLI delivers it:
+         *  the request's frame on top of the command_stack.  */
+        const ok = {result: 0, comment: "", data: [{id: "x"}], __md_iev__: {
+            command_stack: [{command: "update-node", kw: {
+                topic_name: "users", treedb_name: "treedb_test", form_write: 1, record: {id: "x"}
+            }}]
+        }};
+        gobj_send_event(topics, "EV_MT_COMMAND_ANSWER", ok, remote);
+        expect(answers).toEqual([
+            {topic: "users", event: "EV_WRITE_DONE", form_write: 1},
+        ]);
+
+        yui_shell_set_connection_state(shell, false);
+        expect(answers).toEqual([
+            {topic: "users", event: "EV_WRITE_DONE", form_write: 1},
+            {topic: "roles", event: "EV_WRITE_REFUSED", form_write: 1},
+        ]);
+    });
+});

package/src/treedb_write_plan.js

@@ -116,4 +116,35 @@ function col_goes_back_to_treedb(desc, col)
     return topic_pkey2s(d).includes(col.id);
 }
 
-export {plan_treedb_writes, READONLY_FORM_TOOLBAR, col_goes_back_to_treedb};
+/************************************************************
+ *  The INSTANCE an update of `record` is for: its pkey2 values, as the
+ *  record held them when the form was opened, {pkey2: value}.
+ *
+ *  They go back as they WERE, never as the form's widget hands them: a
+ *  `time` pkey2 is an epoch rendered in a `datetime-local`, and a value
+ *  that crossed the widget (seconds dropped, a local wall time read
+ *  back, an hour the autumn change names twice) names ANOTHER instance
+ *  -- or none, and C_NODE falls back to the primary. The pkey2 is an
+ *  address, not a field of the edit.
+ ************************************************************/
+function instance_keys_of(record, desc)
+{
+    const keys = {};
+    if(!record || typeof record !== "object") {
+        return keys;
+    }
+    for(const k of topic_pkey2s(desc || {})) {
+        if(Object.prototype.hasOwnProperty.call(record, k) &&
+                record[k] !== undefined && record[k] !== null) {
+            keys[k] = record[k];
+        }
+    }
+    return keys;
+}
+
+export {
+    plan_treedb_writes,
+    READONLY_FORM_TOOLBAR,
+    col_goes_back_to_treedb,
+    instance_keys_of,
+};

package/src/treedb_write_plan.test.js

@@ -9,7 +9,8 @@
  ***********************************************************************/
 import { describe, test, expect } from "vitest";
 import {
-    plan_treedb_writes, READONLY_FORM_TOOLBAR, col_goes_back_to_treedb
+    plan_treedb_writes, READONLY_FORM_TOOLBAR, col_goes_back_to_treedb,
+    instance_keys_of
 } from "./treedb_write_plan.js";
 
 const WRITES = ["edition_mode", "new_button", "delete_button", "paste_button", "in_row_icons"];
@@ -133,3 +134,23 @@ describe("what goes back to treedb from a form", () => {
         expect(col_goes_back_to_treedb(null, COL.yuno_release)).toBe(false);
     });
 });
+
+describe("the instance an update is for", () => {
+    test("the pkey2 values as the record held them", () => {
+        expect(instance_keys_of({id: "a", yuno_release: "1.2.3", yuno_name: "x"}, YUNOS_DESC))
+            .toEqual({yuno_release: "1.2.3"});
+    });
+
+    test("a time pkey2 keeps its seconds: the ORIGINAL epoch, not the widget's", () => {
+        /*  A datetime-local that dropped the seconds, or read a local wall
+         *  time back, named another instance of the node.  */
+        const desc = {pkey: "id", pkey2s: ["tm"]};
+        expect(instance_keys_of({id: "a", tm: 1790000059}, desc)).toEqual({tm: 1790000059});
+    });
+
+    test("a record without the pkey2, or no pkey2s at all: nothing", () => {
+        expect(instance_keys_of({id: "a"}, YUNOS_DESC)).toEqual({});
+        expect(instance_keys_of({id: "a", yuno_release: "1"}, {pkey: "id"})).toEqual({});
+        expect(instance_keys_of(null, YUNOS_DESC)).toEqual({});
+    });
+});