@saltcorn/server 0.9.4-beta.9 → 0.9.5-beta.0

package/serve.js

@@ -112,6 +112,10 @@ const initMaster = async ({ disableMigrate }, useClusterAdaptor = true) => {
     const tenants = await getAllTenants();
     await init_multi_tenant(loadAllPlugins, disableMigrate, tenants);
   }
+  eachTenant(async () => {
+    const state = getState();
+    if (state) await state.setConfig("joined_log_socket_ids", []);
+  });
   if (useClusterAdaptor) setupPrimary();
 };
 
@@ -283,7 +287,7 @@ module.exports =
           })
           .ready((glx) => {
             const httpsServer = glx.httpsServer();
-            setupSocket(httpsServer);
+            setupSocket(appargs?.subdomainOffset, httpsServer);
             httpsServer.setTimeout(timeout * 1000);
             process.on("message", workerDispatchMsg);
             glx.serveApp(app);
@@ -350,7 +354,7 @@ const nonGreenlockWorkerSetup = async (appargs, port) => {
     // todo timeout to config
     httpServer.setTimeout(timeout * 1000);
     httpsServer.setTimeout(timeout * 1000);
-    setupSocket(httpServer, httpsServer);
+    setupSocket(appargs?.subdomainOffset, httpServer, httpsServer);
     httpServer.listen(port, () => {
       console.log("HTTP Server running on port 80");
     });
@@ -363,7 +367,7 @@ const nonGreenlockWorkerSetup = async (appargs, port) => {
     // server with http only
     const http = require("http");
     const httpServer = http.createServer(app);
-    setupSocket(httpServer);
+    setupSocket(appargs?.subdomainOffset, httpServer);
 
     // todo timeout to config
     // todo refer in doc to httpserver doc
@@ -380,7 +384,7 @@ const nonGreenlockWorkerSetup = async (appargs, port) => {
  *
  * @param  {...*} servers
  */
-const setupSocket = (...servers) => {
+const setupSocket = (subdomainOffset, ...servers) => {
   // https://socket.io/docs/v4/middlewares/
   const wrap = (middleware) => (socket, next) =>
     middleware(socket.request, {}, next);
@@ -390,15 +394,29 @@ const setupSocket = (...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);
   });
-  io.on("connection", (socket) => {
+
+  getState().setLogEmitter((tenant, level, msg) => {
+    const time = new Date().valueOf();
+    io.of("/")
+      .to(`_logs_${tenant}_`)
+      .emit("log_msg", { text: msg, time, level });
+  });
+
+  io.of("/").on("connection", (socket) => {
     socket.on("join_room", ([viewname, room_id]) => {
       const ten = get_tenant_from_req(socket.request) || "public";
       const f = () => {
@@ -418,5 +436,154 @@ const setupSocket = (...servers) => {
       if (ten && ten !== "public") db.runWithTenant(ten, f);
       else f();
     });
+
+    socket.on("join_log_room", async (callback) => {
+      const tenant =
+        get_tenant_from_req(socket.request, subdomainOffset) || "public";
+      const f = async () => {
+        try {
+          const user = socket.request.user;
+          if (!user || user.role_id !== 1) throw new Error("Not authorized");
+          else {
+            socket.join(`_logs_${tenant}_`);
+            const socketIds = await getState().getConfig(
+              "joined_log_socket_ids"
+            );
+            socketIds.push(socket.id);
+            await getState().setConfig("joined_log_socket_ids", [...socketIds]);
+            callback({ status: "ok" });
+          }
+        } catch (err) {
+          getState().log(1, `Socket join_logs stream: ${err.stack}`);
+          callback({ status: "error", msg: err.message || "unknown error" });
+        }
+      };
+      if (tenant && tenant !== "public") db.runWithTenant(tenant, f);
+      else await f();
+    });
+
+    socket.on("disconnect", async () => {
+      const tenant =
+        get_tenant_from_req(socket.request, subdomainOffset) || "public";
+      const f = async () => {
+        const socketIds = await getState().getConfig("joined_log_socket_ids");
+        const newSocketIds = socketIds.filter((id) => id !== socket.id);
+        await getState().setConfig("joined_log_socket_ids", newSocketIds);
+      };
+      if (tenant && tenant !== "public") db.runWithTenant(tenant, f);
+      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/admin.test.js

@@ -382,13 +382,13 @@ describe("actions", () => {
       .send("table_id=2")
       .send("name=mynewaction")
       .send("when_trigger=Insert")
-      .expect(toRedirect("/actions/configure/1"));
+      .expect(toRedirect("/actions/configure/3"));
   });
   it("show edit", async () => {
     const app = await getApp({ disableCsrf: true });
     const loginCookie = await getAdminLoginCookie();
     await request(app)
-      .get("/actions/edit/1")
+      .get("/actions/edit/3")
       .set("Cookie", loginCookie)
       .expect(toInclude("Edit trigger"))
       .expect(toInclude("run_js_code"));
@@ -397,7 +397,7 @@ describe("actions", () => {
     const app = await getApp({ disableCsrf: true });
     const loginCookie = await getAdminLoginCookie();
     await request(app)
-      .get("/actions/configure/1")
+      .get("/actions/configure/3")
       .set("Cookie", loginCookie)
       .expect(toInclude("Configure trigger"))
       .expect(toInclude("Code"));
@@ -406,7 +406,7 @@ describe("actions", () => {
     const app = await getApp({ disableCsrf: true });
     const loginCookie = await getAdminLoginCookie();
     await request(app)
-      .post("/actions/configure/1")
+      .post("/actions/configure/3")
       .set("Cookie", loginCookie)
       .send("code=console.log(12345678)")
       .expect(toRedirect("/actions/"));
@@ -415,7 +415,7 @@ describe("actions", () => {
     const app = await getApp({ disableCsrf: true });
     const loginCookie = await getAdminLoginCookie();
     await request(app)
-      .get("/actions/testrun/1")
+      .get("/actions/testrun/3")
       .set("Cookie", loginCookie)
       .expect(toInclude("12345678"));
   });
@@ -423,7 +423,7 @@ describe("actions", () => {
     const app = await getApp({ disableCsrf: true });
     const loginCookie = await getAdminLoginCookie();
     await request(app)
-      .post("/actions/configure/1")
+      .post("/actions/configure/3")
       .set("Cookie", loginCookie)
       .send("code=1")
       .expect(toRedirect("/actions/"));
@@ -432,7 +432,7 @@ describe("actions", () => {
     const app = await getApp({ disableCsrf: true });
     const loginCookie = await getAdminLoginCookie();
     await request(app)
-      .get("/actions/testrun/1")
+      .get("/actions/testrun/2")
       .set("Cookie", loginCookie)
       .expect(toRedirect("/actions/"));
   });
@@ -446,9 +446,9 @@ describe("actions", () => {
       .send("action=run_js_code")
       .send("when_trigger=API+call")
       .send("min_role=1")
-      .expect(toRedirect("/actions/configure/2"));
+      .expect(toRedirect("/actions/configure/4"));
     await request(app)
-      .post("/actions/configure/2")
+      .post("/actions/configure/4")
       .set("Cookie", loginCookie)
       .send("code=return 27")
       .expect(toRedirect("/actions/"));
@@ -463,7 +463,7 @@ describe("actions", () => {
     const app = await getApp({ disableCsrf: true });
     const loginCookie = await getAdminLoginCookie();
     await request(app)
-      .post("/actions/delete/1")
+      .post("/actions/delete/3")
       .set("Cookie", loginCookie)
       .expect(toRedirect("/actions/"));
   });
@@ -555,7 +555,7 @@ describe("diagram", () => {
 });
 
 /**
- * Diagram tests
+ * Tags tests
  */
 describe("tags", () => {
   itShouldRedirectUnauthToLogin("/tag");
@@ -604,6 +604,12 @@ describe("tags", () => {
       .expect(toRedirect("/tag"));
   });
 });
+
+describe("server logs viewer", () => {
+  itShouldRedirectUnauthToLogin("/admin/dev/logs_viewer");
+  itShouldIncludeTextForAdmin("/admin/dev/logs_viewer", "Server logs");
+});
+
 /**
  * Clear all tests
  */

package/tests/api.test.js

@@ -161,6 +161,33 @@ describe("API read", () => {
         succeedJsonWith((rows) => rows.length == 2 && +rows[0]._versions === 0)
       );
   });
+  it("should get distinct authors for public", async () => {
+    const app = await getApp({ disableCsrf: true });
+    await request(app)
+      .get("/api/books/distinct/author")
+      .expect(
+        succeedJsonWith((vals) => {
+          return vals.length == 2 && vals.includes("Herman Melville");
+        })
+      );
+  });
+  it("should not allow public access to distinct patients", async () => {
+    const app = await getApp({ disableCsrf: true });
+    await request(app).get("/api/patients/distinct/name").expect(notAuthorized);
+  });
+  it("should allow staff access to distinct patients", async () => {
+    const loginCookie = await getStaffLoginCookie();
+
+    const app = await getApp({ disableCsrf: true });
+    await request(app)
+      .get("/api/patients/distinct/name")
+      .set("Cookie", loginCookie)
+      .expect(
+        succeedJsonWith(
+          (rows) => rows.length == 2 && rows.includes("Kirk Douglas")
+        )
+      );
+  });
 });
 describe("API post", () => {
   it("should post books", async () => {

package/tests/fields.test.js

@@ -8,6 +8,7 @@ const {
   getAdminLoginCookie,
   itShouldRedirectUnauthToLogin,
   toInclude,
+  toBeTrue,
   toNotInclude,
   toRedirect,
   resetToFixtures,
@@ -364,9 +365,12 @@ describe("Field Endpoints", () => {
     await request(app)
       .post("/field/show-calculated/books/pagesp1/show")
       .set("Cookie", loginCookie)
-      .expect((r) => +r.body > 2);
+      .send({
+        id: 1,
+      })
+      .expect(toBeTrue((r) => +r.text > 500 && +r.text < 1500));
   });
-  it("should show calculated with single joinfield", async () => {
+  it("should show calculated field with single joinfield", async () => {
     const loginCookie = await getAdminLoginCookie();
     const table = Table.findOne({ name: "patients" });
     await Field.create({
@@ -382,9 +386,12 @@ describe("Field Endpoints", () => {
     await request(app)
       .post("/field/show-calculated/patients/pagesp1/show")
       .set("Cookie", loginCookie)
-      .expect((r) => +r.body > 2);
+      .send({
+        id: 1,
+      })
+      .expect(toBeTrue((r) => +r.text > 2));
   });
-  it("should show calculated with double joinfield", async () => {
+  it("should show calculated field with double joinfield", async () => {
     const loginCookie = await getAdminLoginCookie();
     const table = Table.findOne({ name: "readings" });
     await Field.create({
@@ -400,7 +407,127 @@ describe("Field Endpoints", () => {
     await request(app)
       .post("/field/show-calculated/readings/pagesp1/show")
       .set("Cookie", loginCookie)
-      .expect((r) => +r.body > 2);
+      .send({
+        id: 1,
+      })
+      .expect(toBeTrue((r) => +r.text > 2));
+  });
+  it("should show-calculated on join field value", async () => {
+    const loginCookie = await getAdminLoginCookie();
+
+    const app = await getApp({ disableCsrf: true });
+
+    await request(app)
+      .post("/field/show-calculated/books/publisher.name/as_text")
+      .set("Cookie", loginCookie)
+      .send({
+        publisher: 1,
+      })
+      .expect(toBeTrue((r) => r.text === "AK Press"));
+  });
+  it("should show-calculated on join field value", async () => {
+    const loginCookie = await getAdminLoginCookie();
+
+    const app = await getApp({ disableCsrf: true });
+
+    await request(app)
+      .post("/field/show-calculated/books/publisher.name/code")
+      .set("Cookie", loginCookie)
+      .send({
+        publisher: 1,
+      })
+      .expect(toBeTrue((r) => r.text === "<pre><code>AK Press</code></pre>"));
+  });
+  it("should show-calculated on join field value", async () => {
+    const loginCookie = await getAdminLoginCookie();
+
+    const app = await getApp({ disableCsrf: true });
+
+    await request(app)
+      .post("/field/show-calculated/books/publisher.name/code")
+      .set("Cookie", loginCookie)
+      .send({
+        publisher: 1,
+      })
+      .expect(toBeTrue((r) => r.text === "<pre><code>AK Press</code></pre>"));
+  });
+  it("should show-calculated on join field value", async () => {
+    const loginCookie = await getAdminLoginCookie();
+
+    const app = await getApp({ disableCsrf: true });
+
+    await request(app)
+      .post(
+        "/field/show-calculated/books/publisher.name/show_with_html?code=pub%3A%7B%7Bit.toLowerCase()%7D%7D"
+      )
+      .set("Cookie", loginCookie)
+      .send({
+        publisher: 1,
+      })
+      .expect(toBeTrue((r) => r.text === "pub:ak press"));
+  });
+  it("should show-calculated on double-join field value", async () => {
+    const loginCookie = await getAdminLoginCookie();
+
+    const app = await getApp({ disableCsrf: true });
+
+    await request(app)
+      .post("/field/show-calculated/patients/favbook.publisher.name/as_text")
+      .set("Cookie", loginCookie)
+      .send({
+        favbook: 2,
+      })
+      .expect(toBeTrue((r) => r.text === "AK Press"));
+  });
+  it("should not show unauth show-calculated on double-join field value", async () => {
+    const app = await getApp({ disableCsrf: true });
+
+    await request(app)
+      .post("/field/show-calculated/patients/favbook.publisher.name/as_text")
+
+      .send({
+        favbook: 2,
+      })
+      .expect(401);
+  });
+  it("should preview field", async () => {
+    const loginCookie = await getAdminLoginCookie();
+
+    const app = await getApp({ disableCsrf: true });
+
+    await request(app)
+      .post("/field/preview/books/author/code")
+      .set("Cookie", loginCookie)
+      .send({})
+      .expect(
+        toBeTrue((r) => r.text === "<pre><code>Herman Melville</code></pre>")
+      );
+  });
+  it("should preview joinfield", async () => {
+    const loginCookie = await getAdminLoginCookie();
+
+    const app = await getApp({ disableCsrf: true });
+
+    await request(app)
+      .post("/field/preview/books/publisher.name/code")
+      .set("Cookie", loginCookie)
+      .send({})
+      .expect(toBeTrue((r) => r.text === "<pre><code>AK Press</code></pre>"));
+  });
+  it("should preview joinfield with cfg", async () => {
+    const loginCookie = await getAdminLoginCookie();
+
+    const app = await getApp({ disableCsrf: true });
+
+    await request(app)
+      .post("/field/preview/books/publisher.name/show_with_html")
+      .set("Cookie", loginCookie)
+      .send({
+        configuration: {
+          code: "pub:{{it.toLowerCase()}}",
+        },
+      })
+      .expect(toBeTrue((r) => r.text === "pub:ak press"));
   });
 });
 

package/tests/help.test.js

@@ -0,0 +1,37 @@
+const request = require("supertest");
+const getApp = require("../app");
+const {
+  toRedirect,
+  getAdminLoginCookie,
+  getStaffLoginCookie,
+  itShouldRedirectUnauthToLogin,
+  toInclude,
+  toNotInclude,
+  resetToFixtures,
+  succeedJsonWith,
+} = require("../auth/testhelp");
+const db = require("@saltcorn/data/db");
+const View = require("@saltcorn/data/models/view");
+const Table = require("@saltcorn/data/models/table");
+
+beforeAll(async () => {
+  await resetToFixtures();
+});
+afterAll(db.close);
+
+jest.setTimeout(30000);
+
+describe("Help topics", () => {
+  itShouldRedirectUnauthToLogin("/admin/help/View%20patterns");
+
+  it("should show view patterns help", async () => {
+    const loginCookie = await getAdminLoginCookie();
+
+    const app = await getApp({ disableCsrf: true });
+    await request(app)
+      .get("/admin/help/View patterns")
+      .set("Cookie", loginCookie)
+      .expect(toInclude("<title>Help: View patterns</title>"))
+      .expect(toInclude("The view pattern is a fundamental concept"));
+  });
+});

package/tests/page_group.test.js

@@ -73,6 +73,7 @@ describe("edit Page groups", () => {
       name: nameAfterUpdate,
       description: null,
       min_role: 100,
+      random_allocation: false,
     });
   });
 

package/tests/plugins.test.js

@@ -280,19 +280,7 @@ describe("Pack clash detection", () => {
       .set("Cookie", loginCookie)
       .expect(toRedirect("/"));
   });
-  it("should install issues", async () => {
-    const loginCookie = await getAdminLoginCookie();
 
-    const app = await getApp({ disableCsrf: true });
-    await request(app)
-      .post("/packs/install-named/Blog")
-      .set("Cookie", loginCookie)
-      .expect(toRedirect("/plugins"));
-    await request(app)
-      .get("/plugins")
-      .set("Cookie", loginCookie)
-      .expect(toInclude("Tables already exist: comments"));
-  });
   it("should reset again", async () => {
     await resetToFixtures();
   });

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", () => {

package/tests/view.test.js

@@ -37,6 +37,18 @@ describe("view list endpoint", () => {
 describe("nonexisting view", () => {
   itShouldRedirectUnauthToLogin("/view/patlist", "/");
 });
+describe("preview view", () => {
+  it("should show previewview to auth", async () => {
+    const loginCookie = await getAdminLoginCookie();
+
+    const app = await getApp({ disableCsrf: true });
+    await request(app)
+      .post("/view/authorlist/preview")
+      .set("Cookie", loginCookie)
+      .expect(toInclude("Tolstoy"))
+      .expect(toNotInclude(">728<"));
+  });
+});
 describe("view patients list endpoint", () => {
   itShouldRedirectUnauthToLogin("/view/patientlist");