@yuneta/gobj-ui 5.14.2 → 5.16.0

package/src/c_yui_treedb_topic_with_form.js

@@ -76,6 +76,8 @@ import {yui_tabulator_lang, yui_tabulator_relocalize} from "./yui_tabulator_i18n
 
 import {t} from "i18next";
 
+import {plan_treedb_writes} from "./treedb_write_plan.js";
+
 import "./c_yui_treedb_topic_with_form.css";
 import "./tabulator.css";
 
@@ -97,6 +99,7 @@ SDATA(data_type_t.DTP_STRING,   "topic_name",           0,  null,   "Topic name"
 SDATA(data_type_t.DTP_POINTER,  "desc",                 0,  null,   "Description of topics"),
 
 /*---------------- Edition Mode ----------------*/
+SDATA(data_type_t.DTP_BOOLEAN,  "readonly",             0,  false,  "The topic cannot be written: no edition mode, no new/delete/paste, no in-row icons, and the record form opens without its save toolbar. Set it when the treedb is not the master of its tranger (only the master can write; the yuno refuses otherwise), or when the user lacks the authz"),
 SDATA(data_type_t.DTP_BOOLEAN,  "with_edition_mode",    0,  true,   "Enable EDITION mode showing EDIT Button toolbar"),
 SDATA(data_type_t.DTP_BOOLEAN,  "with_new_button",      0,  true,   "Button toolbar NEW"),
 SDATA(data_type_t.DTP_BOOLEAN,  "with_delete_button",   0,  true,   "Button toolbar DELETE"),
@@ -343,11 +346,16 @@ function build_ui(gobj)
         // TODO pon autorización, solo si está autorizado a modificar los datos!!!
         // TODO deja que estos botones se queden en el top cuando se hace scroll (clip ?)
         let $table_toolbar = [];
-        let with_edition_mode = gobj_read_bool_attr(gobj, "with_edition_mode");
-        let with_new_button = gobj_read_bool_attr(gobj, "with_new_button");
-        let with_delete_button = gobj_read_bool_attr(gobj, "with_delete_button");
+        /*  One plan decides every write affordance (treedb_write_plan.js):
+         *  `readonly` is the STATE of the topic and beats each with_* flag,
+         *  and stating that in five `!readonly &&` expressions is five places
+         *  to forget the sixth.  */
+        let plan = write_plan(gobj);
+        let with_edition_mode = plan.edition_mode;
+        let with_new_button = plan.new_button;
+        let with_delete_button = plan.delete_button;
         let with_copy_button = gobj_read_bool_attr(gobj, "with_copy_button");
-        let with_paste_button = gobj_read_bool_attr(gobj, "with_paste_button");
+        let with_paste_button = plan.paste_button;
 
         let toolbar_id = gobj_read_str_attr(gobj, "toolbar_id");
 
@@ -884,7 +892,7 @@ function create_tabulator(gobj)
         ].join('');
     }
 
-    let with_in_row_edit_icons = gobj_read_bool_attr(gobj, "with_in_row_edit_icons");
+    let with_in_row_edit_icons = write_plan(gobj).in_row_icons;
     if(with_in_row_edit_icons) {
         columns.push({
             field: '_operation',
@@ -1306,6 +1314,7 @@ function open_form_dialog(gobj, mode, record)
                  style: 'display:flex; flex-direction:column; height:100%;'}, []]
     );
 
+    let form_plan = write_plan(gobj);
     let form = gobj_create_pure_child(
         "form_" + clean_name(gobj_name(gobj)),
         "C_YUI_FORM",
@@ -1314,13 +1323,18 @@ function open_form_dialog(gobj, mode, record)
             record:         record,
             fkey_options:   build_fkey_options(gobj),
             form_mode:      mode,
+            /*  A read-only topic still OPENS its form -- looking at a record
+             *  is the point of a replica -- with the cells not editable and
+             *  the write half of the toolbar gone. A null plan leaves the
+             *  form's own default alone.  */
+            ...(form_plan.form_toolbar ? {toolbar: form_plan.form_toolbar} : {}),
             /*  Editing the raw topic record: structured cols
              *  (template / table / coordinates) are raw JSON editors,
              *  not interpreted into sub-widgets (the pre-merge behaviour). */
             render_mode:    "edit",
             pkey:           desc.pkey || "id",
             topic_name:     topic_name,
-            editable:       true,
+            editable:       !form_plan.readonly,
             $parent:        $body
         },
         gobj
@@ -2066,6 +2080,42 @@ function show_dropdown_popup_menu(gobj, x, y, items, callback)
 
 
 
+/***************************************************************
+ *  A read-only topic refuses the write EVENTS too, not only their
+ *  buttons. The buttons are gone, but an event can still arrive: a
+ *  keyboard path, a hosted form that outlived the flag, a caller that
+ *  sends EV_SAVE_RECORD itself. Refusing here is what makes `readonly`
+ *  a state of the gclass rather than a way of drawing it -- and it
+ *  fails LOUDLY, because an ignored write is how the backend used to
+ *  behave and what this whole change exists to stop.
+ ***************************************************************/
+function write_plan(gobj)
+{
+    return plan_treedb_writes({
+        readonly:               gobj_read_bool_attr(gobj, "readonly"),
+        with_edition_mode:      gobj_read_bool_attr(gobj, "with_edition_mode"),
+        with_new_button:        gobj_read_bool_attr(gobj, "with_new_button"),
+        with_delete_button:     gobj_read_bool_attr(gobj, "with_delete_button"),
+        with_paste_button:      gobj_read_bool_attr(gobj, "with_paste_button"),
+        with_in_row_edit_icons: gobj_read_bool_attr(gobj, "with_in_row_edit_icons")
+    });
+}
+
+/***************************************************************
+ *  A read-only topic refuses the write EVENTS too, not only their
+ *  buttons.
+ ***************************************************************/
+function refuse_if_readonly(gobj, event)
+{
+    if(!gobj_read_bool_attr(gobj, "readonly")) {
+        return false;
+    }
+    log_error(`${gobj_short_name(gobj)}: ${event} refused, topic ` +
+        `'${gobj_read_str_attr(gobj, "topic_name")}' is READ-ONLY`);
+    return true;
+}
+
+
                     /***************************
                      *      Actions
                      ***************************/
@@ -2192,7 +2242,22 @@ function ac_load_node_updated(gobj, event, kw, src)
     let tabulator = gobj_read_attr(gobj, "tabulator");
     if(tabulator) {
         for(let record of data) {
-            tabulator.updateData([record]);
+            /*
+             *  updateData() REJECTS the promise on a row it cannot find and
+             *  nobody awaits it, so the rejection surfaces as an unhandled
+             *  "Update Error - Unable to find row" that names neither the
+             *  gclass nor the topic. Ask first, like ac_node_deleted does.
+             *
+             *  A table nobody has opened holds NO rows, and a node event for
+             *  it is not news: its rows are read when the topic is shown. A
+             *  row missing from a table that IS loaded is.
+             */
+            if(tabulator.getRow(record.id)) {
+                tabulator.updateData([record]);
+            } else if(tabulator.getDataCount() > 0) {
+                log_error(`${gobj_short_name(gobj)}: updated node is not in ` +
+                    `the loaded table: ${record.id}`);
+            }
         }
     }
 
@@ -2242,6 +2307,9 @@ function ac_node_deleted(gobj, event, kw, src)
  ************************************************************/
 function ac_edition_mode(gobj, event, kw, src)
 {
+    if(refuse_if_readonly(gobj, event)) {
+        return -1;      /*  Error already logged  */
+    }
     let tabulator = gobj_read_attr(gobj, "tabulator");
 
     /*
@@ -2307,6 +2375,9 @@ function ac_edition_mode(gobj, event, kw, src)
  ************************************************************/
 function ac_new_row(gobj, event, kw, src)
 {
+    if(refuse_if_readonly(gobj, event)) {
+        return -1;      /*  Error already logged  */
+    }
     /*
      *  Build default values. TODO no debería estar en desc configuration?
      */
@@ -2352,6 +2423,9 @@ function ac_new_row(gobj, event, kw, src)
  ************************************************************/
 function ac_delete_rows(gobj, event, kw, src)
 {
+    if(refuse_if_readonly(gobj, event)) {
+        return -1;      /*  Error already logged  */
+    }
     let tabulator = gobj_read_attr(gobj, "tabulator");
 
     if(json_size(kw) === 0) {
@@ -2451,6 +2525,9 @@ function ac_copy_rows(gobj, event, kw, src)
  ************************************************************/
 function ac_paste_rows(gobj, event, kw, src)
 {
+    if(refuse_if_readonly(gobj, event)) {
+        return -1;      /*  Error already logged  */
+    }
     /*----------------------------*
      *  Paste rows
      *----------------------------*/
@@ -2478,6 +2555,9 @@ function ac_paste_rows(gobj, event, kw, src)
  ************************************************************/
 function ac_form_save_record(gobj, event, kw, src)
 {
+    if(refuse_if_readonly(gobj, event)) {
+        return -1;      /*  Error already logged  */
+    }
     let mode = gobj_read_str_attr(src, "form_mode");
     gobj_publish_event(
         gobj,

package/src/c_yui_treedb_topics.js

@@ -77,6 +77,7 @@ SDATA(data_type_t.DTP_JSON,     "descs",            0,  null,   "Description of
 SDATA(data_type_t.DTP_BOOLEAN,  "system",           0,  false,  "Manage system topics (true) or user topics (false)"),
 SDATA(data_type_t.DTP_STRING,   "tabs_style",       0,  "is-toggle is-fullwidth", "Bulma tab styling"),
 SDATA(data_type_t.DTP_BOOLEAN,  "with_cards_landing",0, false,  "Land on a grid of topic cards (list->detail): a card opens its table, with the tabs bar + a back-to-grid button. Off = tabs only (legacy)."),
+SDATA(data_type_t.DTP_BOOLEAN,  "readonly",         0,  false,  "The whole treedb is read-only: every topic opens without its write affordances and the write events are refused. Set it when this yuno is not the MASTER of the treedb's tranger -- only the master can write, and the yuno answers 'READ-ONLY' to a write since SDK 7.13.0 (ask `treedb-info`)"),
 SDATA(data_type_t.DTP_JSON,     "card_action_routes",0, null,   "Per-card hash-route templates {info, table, graph} with a {topic} placeholder (host-supplied, route-agnostic). Present ⇒ cards show 3 icon actions; absent ⇒ a single card that opens the table."),
 SDATA(data_type_t.DTP_JSON,     "landing_routes",   0,  null,   "Host-supplied hashes for the two landing sub-views {cards, schema}; the toggle navigates to them so the landing is URL-addressable (ROUTING.md). Absent ⇒ toggle flips in-view only (legacy)."),
 SDATA(data_type_t.DTP_STRING,   "base_route",       0,  "",     "This view's base route (host-supplied); used to declare its sub-routes (topics / info / schema) to the site map (ROUTING.md contributor)."),
@@ -997,6 +998,7 @@ function process_treedb_descs(gobj)
     let descs = gobj_read_attr(gobj, "descs");
     let system = gobj_read_bool_attr(gobj, "system");
     let treedb_name = gobj_read_str_attr(gobj, "treedb_name");
+    let readonly = gobj_read_bool_attr(gobj, "readonly");
     for(const [key, desc] of Object.entries(descs)) {
         if(system) {
         } else {
@@ -1008,10 +1010,13 @@ function process_treedb_descs(gobj)
         let kw_topic_form = {
             subscriber: gobj,  // HACK get all output events
 
-            // TODO set according the authz
-            //with_edit_button: true,
-            with_new_button: true,
-            with_delete_button: true,
+            /*  One flag, not three: a read-only treedb has no writable
+             *  topic. (The old TODO here asked for the authz to decide the
+             *  buttons; the authz is a per-user question the backend answers
+             *  per command, while this is a property of the STORE.)  */
+            readonly: readonly,
+            with_new_button: !readonly,
+            with_delete_button: !readonly,
 
             treedb_name: treedb_name,
             topic_name: key,
@@ -1619,6 +1624,25 @@ function request_print_tranger(gobj, path)
 
 
 
+/***************************************************************
+ *  The last gate before a write leaves for the yuno. The per-topic
+ *  children already hide their write buttons when the treedb is
+ *  read-only, but the record events converge HERE, and this is the
+ *  gclass that owns the treedb: a write that got this far on a replica
+ *  would travel, be refused by the yuno, and come back as a toast --
+ *  after the table had already drawn the row.
+ ***************************************************************/
+function refuse_if_readonly(gobj, event)
+{
+    if(!gobj_read_bool_attr(gobj, "readonly")) {
+        return false;
+    }
+    log_error(`${gobj_short_name(gobj)}: ${event} refused, treedb ` +
+        `'${gobj_read_str_attr(gobj, "treedb_name")}' is READ-ONLY`);
+    return true;
+}
+
+
                     /***************************
                      *      Actions
                      ***************************/
@@ -1731,7 +1755,8 @@ function ac_mt_command_answer(gobj, event, kw, src)
                 treedb_name: kw_get_str(gobj, kw_command, "treedb_name", "", 0),
                 topic_name:  kw_get_str(gobj, kw_command, "topic_name", "", 0),
                 record:      kw_get_dict(gobj, kw_command, "record", {}, 0),
-                created:     (command === "create-node")
+                created:     (command === "create-node"),
+                command:     command
             });
             break;
 
@@ -2051,6 +2076,9 @@ function ac_treedb_node_deleted(gobj, event, kw, src)
  ********************************************/
 function ac_create_record(gobj, event, kw, src)
 {
+    if(refuse_if_readonly(gobj, event)) {
+        return -1;      /*  Error already logged  */
+    }
     let treedb_name = gobj_read_str_attr(gobj, "treedb_name");
     let topic_name = gobj_read_attr(src, "topic_name");
     let record = kw.record;
@@ -2079,6 +2107,9 @@ function ac_create_record(gobj, event, kw, src)
  ********************************************/
 function ac_update_record(gobj, event, kw, src)
 {
+    if(refuse_if_readonly(gobj, event)) {
+        return -1;      /*  Error already logged  */
+    }
     let treedb_name = gobj_read_str_attr(gobj, "treedb_name");
     let topic_name = gobj_read_attr(src, "topic_name");
     let record = kw.record;
@@ -2106,6 +2137,9 @@ function ac_update_record(gobj, event, kw, src)
  ********************************************/
 function ac_delete_record(gobj, event, kw, src)
 {
+    if(refuse_if_readonly(gobj, event)) {
+        return -1;      /*  Error already logged  */
+    }
     let treedb_name = gobj_read_str_attr(gobj, "treedb_name");
     let topic_name = gobj_read_attr(src, "topic_name");
     let record = kw.record;

package/src/treedb_write_plan.js

@@ -0,0 +1,73 @@
+/***********************************************************************
+ *          treedb_write_plan.js
+ *
+ *      Which write affordances a treedb topic offers.
+ *
+ *      Pure, so it can be tested without a DOM: the gclass turns the
+ *      plan into buttons and columns, this decides the plan. Same split
+ *      as form_toolbar_plan.js.
+ *
+ *      The rule it exists to state ONCE: `readonly` is not one more
+ *      button flag, it is the STATE of the topic and it wins over all of
+ *      them. A treedb whose tranger this yuno does not master answers
+ *      every write with "READ-ONLY" (the yuno refuses since SDK 7.13.0),
+ *      so offering the buttons anyway only turns a fact into an error
+ *      message per click. Written as `!readonly && with_x` in five
+ *      places it is five places to forget the sixth.
+ *
+ *          Copyright (c) 2026, ArtGins.
+ *          All Rights Reserved.
+ ***********************************************************************/
+
+/*  What a read-only form keeps: reading a record includes taking it with
+ *  you, so `copy` stays and the write half goes.  */
+const READONLY_FORM_TOOLBAR = ["copy"];
+
+
+/***************************************************************
+ *  plan_treedb_writes(flags) -> plan
+ *
+ *      flags   {readonly, with_edition_mode, with_new_button,
+ *               with_delete_button, with_paste_button,
+ *               with_in_row_edit_icons}
+ *              Every with_* defaults to TRUE when absent, which is
+ *              what the gclass attrs default to: a caller that sets
+ *              nothing gets the toolbar this view always had.
+ *
+ *      plan    the same names without the `with_` prefix, plus
+ *              `form_toolbar`: the list to hand C_YUI_FORM, or null
+ *              to leave the form's own default alone.
+ ***************************************************************/
+function plan_treedb_writes(flags)
+{
+    let f = flags || {};
+    let readonly = !!f.readonly;
+    let want = (name) => {
+        return (f[name] === undefined) ? true : !!f[name];
+    };
+
+    if(readonly) {
+        return {
+            readonly:      true,
+            edition_mode:  false,
+            new_button:    false,
+            delete_button: false,
+            paste_button:  false,
+            in_row_icons:  false,
+            form_toolbar:  READONLY_FORM_TOOLBAR.slice()
+        };
+    }
+
+    return {
+        readonly:      false,
+        edition_mode:  want("with_edition_mode"),
+        new_button:    want("with_new_button"),
+        delete_button: want("with_delete_button"),
+        paste_button:  want("with_paste_button"),
+        in_row_icons:  want("with_in_row_edit_icons"),
+        form_toolbar:  null
+    };
+}
+
+
+export {plan_treedb_writes, READONLY_FORM_TOOLBAR};

package/src/treedb_write_plan.test.js

@@ -0,0 +1,83 @@
+/***********************************************************************
+ *          treedb_write_plan.test.js
+ *
+ *      What a read-only treedb topic must NOT offer, pinned.
+ *
+ *      The point of the file under test is that one flag beats five, so
+ *      these tests are mostly about the ways someone could get a write
+ *      affordance back by accident.
+ ***********************************************************************/
+import { describe, test, expect } from "vitest";
+import { plan_treedb_writes, READONLY_FORM_TOOLBAR } from "./treedb_write_plan.js";
+
+const WRITES = ["edition_mode", "new_button", "delete_button", "paste_button", "in_row_icons"];
+
+
+describe("writable (the default)", () => {
+    test("nothing set is everything on — the toolbar this view always had", () => {
+        const plan = plan_treedb_writes({});
+        for(const k of WRITES) {
+            expect(plan[k]).toBe(true);
+        }
+        expect(plan.readonly).toBe(false);
+    });
+
+    test("an absent flags object behaves the same", () => {
+        expect(plan_treedb_writes(undefined).new_button).toBe(true);
+        expect(plan_treedb_writes(null).delete_button).toBe(true);
+    });
+
+    test("the form keeps its OWN default toolbar (null, not a copy of it)", () => {
+        /*  Repeating the five names here is how the default drifts from
+         *  C_YUI_FORM's; null says "do not touch it".  */
+        expect(plan_treedb_writes({}).form_toolbar).toBe(null);
+    });
+
+    test("a single with_* off turns off only that one", () => {
+        const plan = plan_treedb_writes({with_delete_button: false});
+        expect(plan.delete_button).toBe(false);
+        expect(plan.new_button).toBe(true);
+        expect(plan.edition_mode).toBe(true);
+    });
+});
+
+
+describe("readonly beats every with_*", () => {
+    test("all write affordances off, even when each is explicitly asked for", () => {
+        const plan = plan_treedb_writes({
+            readonly:               true,
+            with_edition_mode:      true,
+            with_new_button:        true,
+            with_delete_button:     true,
+            with_paste_button:      true,
+            with_in_row_edit_icons: true
+        });
+        for(const k of WRITES) {
+            expect(plan[k]).toBe(false);
+        }
+    });
+
+    test("the form opens with copy only — reading includes taking the record", () => {
+        expect(plan_treedb_writes({readonly: true}).form_toolbar).toEqual(["copy"]);
+    });
+
+    test("the plan hands out a COPY of the toolbar, so a caller cannot mutate the constant", () => {
+        const plan = plan_treedb_writes({readonly: true});
+        plan.form_toolbar.push("save");
+        expect(READONLY_FORM_TOOLBAR).toEqual(["copy"]);
+        expect(plan_treedb_writes({readonly: true}).form_toolbar).toEqual(["copy"]);
+    });
+
+    test("readonly is reported, so the gclass can refuse the EVENTS too", () => {
+        /*  Hiding the buttons is not the same as refusing the write: an
+         *  event can still arrive from a keyboard path or a stale form.  */
+        expect(plan_treedb_writes({readonly: true}).readonly).toBe(true);
+    });
+
+    test("only a truthy readonly counts — a missing flag is writable", () => {
+        expect(plan_treedb_writes({readonly: false}).new_button).toBe(true);
+        expect(plan_treedb_writes({readonly: 0}).new_button).toBe(true);
+        expect(plan_treedb_writes({readonly: undefined}).new_button).toBe(true);
+        expect(plan_treedb_writes({readonly: "yes"}).new_button).toBe(false);
+    });
+});