@sjcrh/proteinpaint-server 2.99.0 → 2.99.1-1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sjcrh/proteinpaint-server",
-  "version": "2.99.0",
+  "version": "2.99.1-1",
   "type": "module",
   "description": "a genomics visualization tool for exploring a cohort's genotype and phenotype data",
   "main": "src/app.js",
@@ -61,16 +61,20 @@
     "@sjcrh/augen": "2.87.0",
     "@sjcrh/proteinpaint-rust": "2.99.0",
     "@sjcrh/proteinpaint-shared": "2.99.0",
-    "@sjcrh/proteinpaint-types": "2.99.0",
+    "@sjcrh/proteinpaint-types": "2.99.1-1",
+    "@types/express": "^5.0.0",
+    "@types/express-session": "^1.18.1",
     "better-sqlite3": "^9.4.1",
     "body-parser": "^1.15.2",
     "canvas": "~2.11.2",
     "compression": "^1.6.2",
+    "connect-redis": "^6.1.3",
     "cookie-parser": "^1.4.5",
     "d3": "^7.6.1",
     "deep-object-diff": "^1.1.0",
     "express": "^4.17.1",
     "express-basic-auth": "^1.1.5",
+    "express-session": "^1.18.1",
     "got": "^14.2.0",
     "image-size": "^0.5.5",
     "jsonwebtoken": "^9.0.0",
@@ -81,6 +85,7 @@
     "minimatch": "^3.1.2",
     "node-fetch": "^2.6.1",
     "partjson": "^0.58.2",
+    "redis": "^4.7.0",
     "tiny-async-pool": "^1.2.0",
     "tough-cookie": "^4.1.4"
   },

package/routes/clearwsisession.js

@@ -0,0 +1,51 @@
+import { clearWSImagesSessionsPayload } from "@sjcrh/proteinpaint-types/routes/clearwsisessions.js";
+import SessionManager from "#src/wsisessions/SessionManager.js";
+import ky from "ky";
+import serverconfig from "#src/serverconfig.js";
+const api = {
+  endpoint: "clearwsisession",
+  methods: {
+    delete: {
+      ...clearWSImagesSessionsPayload,
+      init
+    }
+  }
+};
+function init() {
+  return async (req, res) => {
+    try {
+      if (serverconfig.redis) {
+        const sessionsString = req.query.sessions;
+        const sessionsArray = JSON.parse(sessionsString);
+        const sessions = new Map(sessionsArray);
+        const sessionManager = SessionManager.getInstance(serverconfig.redis.url);
+        for (const [key, value] of sessions.entries()) {
+          const sessionData = await sessionManager.getSession(key);
+          if (sessionData) {
+            const userSessionIds = sessionData.userSessionIds;
+            if (!userSessionIds.some((sessionId) => sessionId === value)) {
+              break;
+            }
+            const newSessions = userSessionIds.filter((sessionId) => sessionId !== value);
+            if (newSessions.length === 0) {
+              await ky.put(`${serverconfig.tileServerURL}/tileserver/reset/${sessionData.imageSessionId}`);
+              await sessionManager.deleteSession(key);
+            } else {
+              sessionData.userSessionIds = newSessions;
+              await sessionManager.setSession(key, sessionData);
+            }
+          }
+        }
+        res.send({ message: "Sessions cleared" });
+      } else {
+        res.status(404).send("Redis not configured");
+      }
+    } catch (e) {
+      console.log(e);
+      res.status(404).send("Error clearing sessions");
+    }
+  };
+}
+export {
+  api
+};

package/routes/img.js

@@ -0,0 +1,46 @@
+import { imgPayload } from "#types/checkers";
+import path from "path";
+import fs from "fs";
+import * as utils from "../src/utils.js";
+import imagesize from "image-size";
+const api = {
+  endpoint: "img",
+  methods: {
+    get: {
+      ...imgPayload,
+      init
+    },
+    post: {
+      ...imgPayload,
+      init
+    }
+  }
+};
+function init() {
+  return async (req, res) => {
+    try {
+      sendImage(req, res);
+    } catch (e) {
+      res.send({ status: "error", error: e.message || e });
+    }
+  };
+}
+async function sendImage(req, res) {
+  const [e, file] = utils.fileurl(req, true);
+  try {
+    if (e)
+      throw "invalid image file";
+    const data = await fs.promises.readFile(file);
+    const ext = path.extname(file).substring(1);
+    const image = {
+      src: `data:image/${ext};base64,${Buffer.from(data).toString("base64")}`,
+      size: imagesize(file)
+    };
+    res.send({ ...image });
+  } catch (e2) {
+    res.send({ error: e2.message || e2 });
+  }
+}
+export {
+  api
+};

package/routes/samplewsimages.js

@@ -23,6 +23,17 @@ function init({ genomes }) {
       if (!ds)
         throw "invalid dataset name";
       const sampleId = query.sample_id;
+      if (ds.queries.WSImages.sources) {
+        const images2 = [];
+        if (ds.queries.WSImages.sources) {
+          images2.push({
+            filename: sampleId + "_fsspec.json",
+            metadata: ""
+          });
+        }
+        res.send({ sampleWSImages: images2 });
+        return;
+      }
       const images = await ds.queries.WSImages.getWSImages({ sampleId });
       res.send({ sampleWSImages: images });
     } catch (e) {

package/routes/termdb.config.js

@@ -219,6 +219,7 @@ function addNonDictionaryQueries(c, ds, genome) {
         sampleColumns: q.singleCell.samples.sampleColumns,
         experimentColumns: q.singleCell.samples.experimentColumns
       },
+      images: q.singleCell.images,
       data: {
         sameLegend: q.singleCell.data.sameLegend,
         refName: q.singleCell.data.refName,

package/routes/termdb.singlecellSamples.js

@@ -76,6 +76,17 @@ async function validate_query_singleCell(ds, genome) {
   if (q.DEgenes) {
     validate_query_singleCell_DEgenes(ds);
   }
+  if (q.images) {
+    validateImages(q.images);
+  }
+}
+function validateImages(images) {
+  if (!images.folder)
+    throw "images.folder missing";
+  if (!images.label)
+    images.label = "Images";
+  if (!images.fileName)
+    throw "images.fileName missing";
 }
 async function validateSamplesNative(S, D, ds) {
   const samples = /* @__PURE__ */ new Map();

package/routes/tileserver.js

@@ -19,7 +19,7 @@ function init() {
     try {
       const { sampleId, TileGroup, z, x, y } = req.params;
       const url = `${serverconfig.tileServerURL}/tileserver/layer/slide/${sampleId}/zoomify/${TileGroup}/${z}-${x}-${y}@1x.jpg`;
-      const response = await ky.get(url);
+      const response = await ky.get(url, { timeout: 12e4 });
       const buffer = await response.arrayBuffer();
       res.status(response.status).send(Buffer.from(buffer));
     } catch (error) {

package/routes/wsimages.js

@@ -5,6 +5,8 @@ import serverconfig from "#src/serverconfig.js";
 import { CookieJar } from "tough-cookie";
 import { promisify } from "util";
 import { wsImagesPayload } from "#types/checkers";
+import SessionManager, { SessionData } from "../src/wsisessions/SessionManager.ts";
+import crypto from "crypto";
 const routePath = "wsimages";
 const api = {
   endpoint: `${routePath}`,
@@ -25,93 +27,116 @@ function init({ genomes }) {
       const query = req.query;
       const g = genomes[query.genome];
       if (!g)
-        throw "invalid genome name";
+        throw new Error("Invalid genome name");
       const ds = g.datasets[query.dslabel];
       if (!ds)
-        throw "invalid dataset name";
+        throw new Error("Invalid dataset name");
       const sampleId = query.sampleId;
       if (!sampleId)
-        throw "invalid sampleId";
+        throw new Error("Invalid sampleId");
       const wsimage = query.wsimage;
       if (!wsimage)
-        throw "invalid wsimage";
+        throw new Error("Invalid wsimage");
       const cookieJar = new CookieJar();
       const setCookie = promisify(cookieJar.setCookie.bind(cookieJar));
       const getCookieString = promisify(cookieJar.getCookieString.bind(cookieJar));
-      await ky.get(`${serverconfig.tileServerURL}/tileserver/session_id`, {
-        hooks: {
-          beforeRequest: [
-            async (request) => {
-              const cookie = await getCookieString(request.url);
-              request.headers.set("Cookie", cookie);
-            }
-          ],
-          afterResponse: [
-            async (request, options, response) => {
-              const setCookieHeader = response.headers.get("set-cookie");
-              if (setCookieHeader) {
-                await setCookie(setCookieHeader, request.url);
-              }
-            }
-          ]
-        }
-      });
-      const cookieString = await getCookieString(`${serverconfig.tileServerURL}/tileserver/session_id`);
-      const sessionId = cookieString.match(/session_id=([^;]*)/)?.[1];
-      const sampleWsiTileServer = path.join(
-        `${serverconfig.tileServerMount}/${ds.queries.WSImages.imageBySampleFolder}/${sampleId}`,
-        wsimage
-      );
-      const data = qs.stringify({ slide_path: sampleWsiTileServer });
-      await ky.put(`${serverconfig.tileServerURL}/tileserver/slide`, {
-        body: data,
-        headers: {
-          "Content-Type": "application/x-www-form-urlencoded",
-          Cookie: `session_id=${sessionId}`
-          // Include the session_id in the headers
-        },
-        hooks: {
-          beforeRequest: [
-            async (request) => {
-              const cookie = await getCookieString(request.url);
-              request.headers.set("Cookie", cookie);
-            }
-          ],
-          afterResponse: [
-            async (request, options, response) => {
-              const setCookieHeader = response.headers.get("set-cookie");
-              if (setCookieHeader) {
-                await setCookie(setCookieHeader, request.url);
-              }
-            }
-          ]
-        }
-      });
-      const getWsiImageResponse = await ky.get(`${serverconfig.tileServerURL}/tileserver/slide`, {
-        hooks: {
-          beforeRequest: [
-            async (request) => {
-              const cookie = await getCookieString(request.url);
-              request.headers.set("Cookie", cookie);
-            }
-          ]
-        }
-      }).json();
+      let sessionManager;
+      let sessionData;
+      let userSessionId = void 0;
+      if (serverconfig.redis) {
+        sessionManager = SessionManager.getInstance(serverconfig.redis.url);
+        userSessionId = crypto.createHash("sha256").update(crypto.randomBytes(32).toString("hex")).digest("hex");
+        sessionData = await sessionManager.getSession(wsimage);
+      }
+      const sessionId = sessionData ? sessionData.imageSessionId : await getSessionId(cookieJar, getCookieString, setCookie, wsimage, ds, sampleId);
+      if (serverconfig.redis && sessionManager) {
+        await manageUserSession(sessionManager, sessionData, wsimage, userSessionId, sessionId);
+      }
+      const getWsiImageResponse = await getWsiImageDimensions(sessionId, getCookieString);
       const payload = {
         status: "ok",
-        sessionId,
+        wsiSessionId: sessionId,
+        browserImageInstanceId: serverconfig.redis ? userSessionId : void 0,
         slide_dimensions: getWsiImageResponse.slide_dimensions
       };
       res.status(200).json(payload);
     } catch (e) {
-      console.log(e);
-      res.send({
+      console.error(e);
+      res.status(500).send({
         status: "error",
-        error: e.error || e
+        error: e.message || e
       });
     }
   };
 }
+async function getSessionId(cookieJar, getCookieString, setCookie, wsimage, ds, sampleId) {
+  await ky.get(`${serverconfig.tileServerURL}/tileserver/session_id`, {
+    timeout: 5e4,
+    hooks: getHooks(cookieJar, getCookieString, setCookie)
+  });
+  const cookieString = await getCookieString(`${serverconfig.tileServerURL}/tileserver/session_id`);
+  const sessionId = cookieString.match(/session_id=([^;]*)/)?.[1];
+  if (!sessionId)
+    throw new Error("session_id not found");
+  const sampleWsiTileServer = path.join(
+    `${serverconfig.tileServerMount}/${ds.queries.WSImages.imageBySampleFolder}/${sampleId}`,
+    wsimage
+  );
+  const data = qs.stringify({ slide_path: sampleWsiTileServer });
+  await ky.put(`${serverconfig.tileServerURL}/tileserver/slide`, {
+    body: data,
+    timeout: 5e4,
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded",
+      Cookie: `session_id=${sessionId}`
+    },
+    hooks: getHooks(cookieJar, getCookieString, setCookie)
+  });
+  return sessionId;
+}
+async function manageUserSession(sessionManager, sessionData, wsimage, userId, sessionId) {
+  if (!sessionData) {
+    await sessionManager.setSession(wsimage, new SessionData(sessionId, [userId]));
+  } else if (!sessionData.userSessionIds || !sessionData.userSessionIds.includes(userId)) {
+    sessionData.userSessionIds = sessionData.userSessionIds || [];
+    sessionData.userSessionIds.push(userId);
+    await sessionManager.setSession(wsimage, sessionData);
+  }
+}
+async function getWsiImageDimensions(sessionId, getCookieString) {
+  return await ky.get(`${serverconfig.tileServerURL}/tileserver/slide`, {
+    timeout: 12e4,
+    hooks: {
+      beforeRequest: [
+        async (request) => {
+          let cookie = await getCookieString(request.url);
+          if (!cookie) {
+            cookie = `session_id=${sessionId}`;
+          }
+          request.headers.set("Cookie", cookie);
+        }
+      ]
+    }
+  }).json();
+}
+function getHooks(cookieJar, getCookieString, setCookie) {
+  return {
+    beforeRequest: [
+      async (request) => {
+        const cookie = await getCookieString(request.url);
+        request.headers.set("Cookie", cookie);
+      }
+    ],
+    afterResponse: [
+      async (request, options, response) => {
+        const setCookieHeader = response.headers.get("set-cookie");
+        if (setCookieHeader) {
+          await setCookie(setCookieHeader, request.url);
+        }
+      }
+    ]
+  };
+}
 export {
   api
 };