@saltcorn/server 0.9.4-beta.19 → 0.9.4-beta.20

package/package.json

@@ -1,19 +1,19 @@
 {
   "name": "@saltcorn/server",
-  "version": "0.9.4-beta.19",
+  "version": "0.9.4-beta.20",
   "description": "Server app for Saltcorn, open-source no-code platform",
   "homepage": "https://saltcorn.com",
   "main": "index.js",
   "license": "MIT",
   "dependencies": {
     "@aws-sdk/client-s3": "^3.451.0",
-    "@saltcorn/base-plugin": "0.9.4-beta.19",
-    "@saltcorn/builder": "0.9.4-beta.19",
-    "@saltcorn/data": "0.9.4-beta.19",
-    "@saltcorn/admin-models": "0.9.4-beta.19",
-    "@saltcorn/filemanager": "0.9.4-beta.19",
-    "@saltcorn/markup": "0.9.4-beta.19",
-    "@saltcorn/sbadmin2": "0.9.4-beta.19",
+    "@saltcorn/base-plugin": "0.9.4-beta.20",
+    "@saltcorn/builder": "0.9.4-beta.20",
+    "@saltcorn/data": "0.9.4-beta.20",
+    "@saltcorn/admin-models": "0.9.4-beta.20",
+    "@saltcorn/filemanager": "0.9.4-beta.20",
+    "@saltcorn/markup": "0.9.4-beta.20",
+    "@saltcorn/sbadmin2": "0.9.4-beta.20",
     "@socket.io/cluster-adapter": "^0.2.1",
     "@socket.io/sticky": "^1.0.1",
     "adm-zip": "0.5.10",

package/public/saltcorn-common.js

@@ -1189,6 +1189,13 @@ async function common_done(res, viewname, isWeb = true) {
         const input = form.find(
           `input[name=${k}], textarea[name=${k}], select[name=${k}]`
         );
+        if (k === "id" && input.length === 0) {
+          //TODO table.pk_name instead of id
+          form.append(
+            `<input type="hidden" name="id" value="${res.set_fields[k]}">`
+          );
+          return;
+        }
         if (input.attr("type") === "checkbox")
           input.prop("checked", res.set_fields[k]);
         else input.val(res.set_fields[k]);

package/public/saltcorn.js

@@ -252,6 +252,21 @@ function ajax_done(res, viewname) {
   common_done(res, viewname);
 }
 
+function spin_action_link(e) {
+  const $e = $(e);
+  const width = $e.width();
+  $e.attr("data-innerhtml-prespin", $e.html());
+  $e.html('<i class="fas fa-spinner fa-spin"></i>').width(width);
+}
+
+function reset_spinners() {
+  $("[data-innerhtml-prespin]").each(function () {
+    $e = $(this);
+    $e.html($e.attr("data-innerhtml-prespin"));
+    $e.removeAttr("data-innerhtml-prespin");
+  });
+}
+
 function view_post(viewname, route, data, onDone, sendState) {
   const query = sendState
     ? `?${new URL(get_current_state_url()).searchParams.toString()}`
@@ -271,9 +286,11 @@ function view_post(viewname, route, data, onDone, sendState) {
     .done(function (res) {
       if (onDone) onDone(res);
       ajax_done(res, viewname);
+      reset_spinners();
     })
     .fail(function (res) {
       notifyAlert({ type: "danger", text: res.responseText });
+      reset_spinners();
     });
 }
 let logged_errors = [];

package/routes/fields.js

@@ -1180,9 +1180,24 @@ router.post(
       type,
       join_field,
       join_fieldview,
+      agg_outcome_type,
+      agg_fieldview,
+      agg_field,
       _columndef,
     } = req.body;
     const table = Table.findOne({ name: tableName });
+    if (agg_outcome_type && agg_fieldview) {
+      const type = getState().types[agg_outcome_type];
+      const fv = type?.fieldviews?.[agg_fieldview];
+      if (!fv?.configFields) {
+        res.send(req.query?.accept == "json" ? "[]" : "");
+        return;
+      }
+      const field = table.getField(agg_field);
+      const cfgfields = await applyAsync(fv.configFields, field || { table });
+      res.json(cfgfields);
+      return;
+    }
     if (typeof type !== "string") {
       try {
         type = JSON.parse(_columndef).type;
@@ -1193,19 +1208,19 @@ router.post(
     const fieldName = type == "Field" ? field_name : join_field;
     const fv_name = type == "Field" ? fieldview : join_fieldview;
     if (!fieldName) {
-      res.send("");
+      res.send(req.query?.accept == "json" ? "[]" : "");
       return;
     }
 
     const field = table.getField(fieldName);
     if (!field) {
-      res.send("");
+      res.send(req.query?.accept == "json" ? "[]" : "");
       return;
     }
     const fieldViewConfigForms = await calcfldViewConfig([field], false, 0);
     const formFields = fieldViewConfigForms[field.name][fv_name];
     if (!formFields) {
-      res.send("");
+      res.send(req.query?.accept == "json" ? "[]" : "");
       return;
     }
     formFields.forEach((ff) => {

package/routes/pageedit.js

@@ -186,7 +186,7 @@ const pageBuilderData = async (req, context) => {
   for (const view of views) {
     fixed_state_fields[view.name] = [];
     const table = Table.findOne(view.table_id || view.exttable_name);
-
+    if (table) view.table_name = table.name;
     const fs = await view.get_state_fields();
     for (const frec of fs) {
       const f = new Field(frec);
@@ -219,9 +219,10 @@ const pageBuilderData = async (req, context) => {
       }
     }
   }
+
   //console.log(fixed_state_fields.ListTasks);
   return {
-    views,
+    views: views.map((v) => v.select_option),
     images,
     pages,
     page_groups,

package/routes/tables.js

@@ -832,6 +832,7 @@ router.get(
       }
       viewCard = {
         type: "card",
+        id: "table-views",
         title: req.__("Views of this table"),
         contents:
           viewCardContents +
@@ -1173,6 +1174,32 @@ router.post(
       res.redirect(`/table`);
       return;
     }
+    const views = await View.find(
+      t.id ? { table_id: t.id } : { exttable_name: t.name }
+    );
+    if (views.length) {
+      req.flash(
+        "error",
+        `${text(t.name)} has views. Delete these first: <a href="/table/${
+          t.name
+        }#table-views">Views for ${text(t.name)}</a>`
+      );
+      res.redirect(`/table`);
+      return;
+    }
+    if (t.id) {
+      const triggers = await Trigger.find({ table_id: t.id });
+      if (triggers.length) {
+        req.flash(
+          "error",
+          `${text(
+            t.name
+          )} has triggers. Delete these first: <a href="/actions">Trigger list</a>`
+        );
+        res.redirect(`/table`);
+        return;
+      }
+    }
     try {
       await t.delete();
       req.flash("success", req.__(`Table %s deleted`, t.name));

package/serve.js

@@ -394,21 +394,29 @@ const setupSocket = (subdomainOffset, ...servers) => {
     io.attach(server);
   }
 
-  //io.use(wrap(setTenant));
-  io.use(wrap(getSessionStore()));
-  io.use(wrap(passport.initialize()));
-  io.use(wrap(passport.authenticate(["jwt", "session"])));
+  const passportInit = passport.initialize();
+  const sessionStore = getSessionStore();
+  const setupNamespace = (namespace) => {
+    //io.of(namespace).use(wrap(setTenant));
+    io.of(namespace).use(wrap(sessionStore));
+    io.of(namespace).use(wrap(passportInit));
+    io.of(namespace).use(wrap(passport.authenticate(["jwt", "session"])));
+  };
+  setupNamespace("/");
+  setupNamespace("/datastream");
   if (process.send && !cluster.isMaster) io.adapter(createAdapter());
   getState().setRoomEmitter((tenant, viewname, room_id, msg) => {
-    io.to(`${tenant}_${viewname}_${room_id}`).emit("message", msg);
+    io.of("/").to(`${tenant}_${viewname}_${room_id}`).emit("message", msg);
   });
 
   getState().setLogEmitter((tenant, level, msg) => {
     const time = new Date().valueOf();
-    io.to(`_logs_${tenant}_`).emit("log_msg", { text: msg, time, level });
+    io.of("/")
+      .to(`_logs_${tenant}_`)
+      .emit("log_msg", { text: msg, time, level });
   });
 
-  io.on("connection", (socket) => {
+  io.of("/").on("connection", (socket) => {
     socket.on("join_room", ([viewname, room_id]) => {
       const ten = get_tenant_from_req(socket.request) || "public";
       const f = () => {
@@ -466,4 +474,116 @@ const setupSocket = (subdomainOffset, ...servers) => {
       else f();
     });
   });
+
+  io.of("/datastream").on("connection", (socket) => {
+    let dataStream = null;
+    let dataTarget = null;
+    socket.on(
+      "open_data_stream",
+      async ([viewName, id, fieldName, fieldView, targetOpts], callback) => {
+        const tenant =
+          get_tenant_from_req(socket.request, subdomainOffset) || "public";
+        const f = async () => {
+          try {
+            const user = socket.request.user;
+            const view = View.findOne({ name: viewName });
+            if (view.viewtemplateObj.authorizeDataStream) {
+              const authorized = await view.viewtemplateObj.authorizeDataStream(
+                view,
+                id,
+                fieldName,
+                user,
+                targetOpts
+              );
+              if (!authorized) throw new Error("Not authorized");
+            }
+            const { stream, target } = await view.openDataStream(
+              id,
+              fieldName,
+              fieldView,
+              user,
+              targetOpts
+            );
+            dataStream = stream;
+            dataTarget = target;
+            getState().log(
+              5,
+              `opened data stram to: ${JSON.stringify(dataTarget)}`
+            );
+            callback({ status: "ok", target });
+          } catch (err) {
+            getState().log(
+              1,
+              `Socket open_data_stream: ${err.message || "unknown error"}`
+            );
+            callback({ status: "error", msg: err.message || "unknown error" });
+          }
+        };
+        if (tenant && tenant !== "public") db.runWithTenant(tenant, f);
+        else f();
+      }
+    );
+    socket.on("write_to_stream", async (data, callback) => {
+      if (!dataStream) {
+        getState().log(1, "Socket write_to_stream: No stream available");
+        callback({ status: "error", msg: "No stream available" });
+      } else
+        dataStream.write(data, (err) => {
+          if (err) {
+            getState().log(1, "Socket write_to_stream: No stream available");
+            callback({ status: "error", msg: err.message || "unknown error" });
+          } else callback({ status: "ok" });
+        });
+    });
+
+    socket.on("close_data_stream", async (callback) => {
+      if (!dataStream) {
+        getState().log(1, "Socket close_data_stream: No stream available");
+        callback({ status: "error", msg: "No stream available" });
+      } else {
+        dataStream.close((err) => {
+          if (err) {
+            getState().log(
+              1,
+              `Socket close_data_stream: ${err.message || "unknown error"}`
+            );
+            callback({ status: "error", msg: err.message || "unknown error" });
+          } else {
+            getState().log(
+              5,
+              `closed data stram of: ${JSON.stringify(dataTarget)}`
+            );
+            callback({ status: "ok" });
+            dataStream = null;
+          }
+        });
+      }
+    });
+
+    socket.on("disconnect", async () => {
+      const tenant =
+        get_tenant_from_req(socket.request, subdomainOffset) || "public";
+      const f = async () => {
+        if (dataStream)
+          dataStream.close((err) => {
+            if (err) {
+              getState().log(
+                1,
+                `Socket disconnect close_data_stream: ${
+                  err.message || "unknown error"
+                }`
+              );
+            } else {
+              getState().log(
+                5,
+                `closed data stram of: ${JSON.stringify(dataTarget)}`
+              );
+              dataStream = null;
+            }
+          });
+      };
+      if (tenant && tenant !== "public") db.runWithTenant(tenant, f);
+      else f();
+    });
+  });
 };

package/tests/table.test.js

@@ -254,11 +254,7 @@ Gordon Kane, 218`;
       await request(app)
         .get("/table/")
         .set("Cookie", loginCookie)
-        .expect(
-          toInclude(
-            "cannot drop table books because other objects depend on it"
-          )
-        );
+        .expect(toInclude("has views. Delete these first"));
   });
 });
 describe("deletion to table with row ownership", () => {