@geode/opengeodeweb-front 10.6.2 → 10.6.3-rc.1

package/server/api/extensions/upload.put.js

@@ -1,35 +1,27 @@
 // Node imports
-import { finished, pipeline } from "node:stream/promises"
-import { Readable } from "node:stream"
-import fs from "node:fs"
-import path from "node:path"
+import { finished, pipeline } from "node:stream/promises";
+import { Readable } from "node:stream";
+import fs from "node:fs";
+import path from "node:path";
 
 // Third party imports
-import {
-  createError,
-  defineEventHandler,
-  getRequestHeaders,
-  getRequestWebStream,
-} from "h3"
-import StreamZip from "node-stream-zip"
-import busboy from "busboy"
-import sanitize from "sanitize-filename"
+import { createError, defineEventHandler, getRequestHeaders, getRequestWebStream } from "h3";
+import StreamZip from "node-stream-zip";
+import busboy from "busboy";
+import sanitize from "sanitize-filename";
 
 // Local imports
-import {
-  addExtensionToConf,
-  confFolderPath,
-} from "@geode/opengeodeweb-front/app/utils/config.js"
+import { addExtensionToConf, confFolderPath } from "@geode/opengeodeweb-front/app/utils/config.js";
 
-const CODE_201 = 201
-const FILE_SIZE_LIMIT = 107_374_182 // 100 MB
+const CODE_201 = 201;
+const FILE_SIZE_LIMIT = 107_374_182;
 
 export default defineEventHandler(async (event) => {
-  const projectName = "vease"
-  const writePromises = []
-  const savedFiles = []
+  const projectName = "vease";
+  const writePromises = [];
+  const savedFiles = [];
 
-  const configFolderPath = confFolderPath(projectName)
+  const configFolderPath = confFolderPath(projectName);
 
   const busboyInstance = busboy({
     headers: getRequestHeaders(event),
@@ -37,71 +29,65 @@ export default defineEventHandler(async (event) => {
       fileSize: FILE_SIZE_LIMIT,
       files: 1,
     },
-  })
+  });
 
   busboyInstance.on("file", (fieldname, fileStream, info) => {
     if (fieldname !== "file") {
       // Drain & ignore unwanted fields
-      fileStream.resume()
-      return
+      fileStream.resume();
+      return;
     }
 
-    const safeFilename = sanitize(info.filename)
-    const targetPath = path.join(configFolderPath, safeFilename)
+    const safeFilename = sanitize(info.filename);
+    const targetPath = path.join(configFolderPath, safeFilename);
 
     const writePromise = (async () => {
-      const writeStream = fs.createWriteStream(targetPath)
-      await pipeline(fileStream, writeStream)
-      savedFiles.push(targetPath)
-      console.log("File written:", targetPath)
-    })()
-
-    writePromises.push(writePromise)
-    fileStream.on("limit", () =>
-      busboyInstance.destroy(new Error("File too large")),
-    )
-  })
+      const writeStream = fs.createWriteStream(targetPath);
+      await pipeline(fileStream, writeStream);
+      savedFiles.push(targetPath);
+      console.log("File written:", targetPath);
+    })();
+
+    writePromises.push(writePromise);
+    fileStream.on("limit", () => busboyInstance.destroy(new Error("File too large")));
+  });
 
   busboyInstance.on("field", (name, value) => {
-    console.log(`Field ${name}: ${value}`)
-  })
+    console.log(`Field ${name}: ${value}`);
+  });
 
-  busboyInstance.on("filesLimit", () =>
-    busboyInstance.destroy(new Error("Too many files")),
-  )
-  busboyInstance.on("partsLimit", () =>
-    busboyInstance.destroy(new Error("Too many parts")),
-  )
+  busboyInstance.on("filesLimit", () => busboyInstance.destroy(new Error("Too many files")));
+  busboyInstance.on("partsLimit", () => busboyInstance.destroy(new Error("Too many parts")));
 
-  const webStream = getRequestWebStream(event)
-  Readable.fromWeb(webStream).pipe(busboyInstance)
-  await finished(busboyInstance)
+  const webStream = getRequestWebStream(event);
+  Readable.fromWeb(webStream).pipe(busboyInstance);
+  await finished(busboyInstance);
 
   if (writePromises.length > 0) {
-    await Promise.all(writePromises)
-    console.log("All disk writes completed")
+    await Promise.all(writePromises);
+    console.log("All disk writes completed");
   }
 
   if (savedFiles.length === 0) {
-    throw createError({ statusCode: 400, message: "No file received" })
+    throw createError({ statusCode: 400, message: "No file received" });
   }
 
   await Promise.all(
     savedFiles.map(async (file) => {
-      const StreamZipAsync = StreamZip.async
+      const StreamZipAsync = StreamZip.async;
       const zip = new StreamZipAsync({
         file,
         storeEntries: true,
-      })
-      const metadataJson = await zip.entryData("metadata.json")
-      const metadata = JSON.parse(metadataJson)
-      const { id } = metadata
+      });
+      const metadataJson = await zip.entryData("metadata.json");
+      const metadata = JSON.parse(metadataJson);
+      const { id } = metadata;
       await addExtensionToConf(projectName, {
         extensionID: id,
         extensionPath: file,
-      })
+      });
     }),
-  )
+  );
 
-  return { statusCode: CODE_201 }
-})
+  return { statusCode: CODE_201 };
+});

package/tests/integration/setup.js

@@ -1,40 +1,32 @@
 // Node.js imports
-import { WebSocket } from "ws"
-import path from "node:path"
+import { WebSocket } from "ws";
+import path from "node:path";
 
 // Third party imports
-import { afterAll, beforeAll, expect, vi } from "vitest"
+import { afterAll, beforeAll, expect, vi } from "vitest";
 
 // Local imports
-import {
-  addMicroserviceMetadatas,
-  runBack,
-  runViewer,
-} from "@ogw_front/utils/local/microservices"
-import {
-  createPath,
-  generateProjectFolderPath,
-} from "@ogw_front/utils/local/path"
-import { Status } from "@ogw_front/utils/status"
-import { appMode } from "@ogw_front/utils/local/app_mode"
-import { importFile } from "@ogw_front/utils/file_import_workflow"
-import { setupActivePinia } from "@ogw_tests/utils"
-import { useGeodeStore } from "@ogw_front/stores/geode"
-import { useInfraStore } from "@ogw_front/stores/infra"
-import { useViewerStore } from "@ogw_front/stores/viewer"
+import { addMicroserviceMetadatas, runBack, runViewer } from "@ogw_front/utils/local/microservices";
+import { createPath, generateProjectFolderPath } from "@ogw_front/utils/local/path";
+import { Status } from "@ogw_front/utils/status";
+import { appMode } from "@ogw_front/utils/local/app_mode";
+import { importFile } from "@ogw_front/utils/file_import_workflow";
+import { setupActivePinia } from "@ogw_tests/utils";
+import { useGeodeStore } from "@ogw_front/stores/geode";
+import { useInfraStore } from "@ogw_front/stores/infra";
+import { useViewerStore } from "@ogw_front/stores/viewer";
 
 // Local constants
-const data_folder = path.join("tests", "integration", "data", "uploads")
+const data_folder = path.join("tests", "integration", "data", "uploads");
 
 async function runMicroservices() {
-  const geodeStore = useGeodeStore()
-  const infraStore = useInfraStore()
-  const viewerStore = useViewerStore()
-  infraStore.app_mode = appMode.BROWSER
-  const { COMMAND_BACK, PROJECT, COMMAND_VIEWER, NUXT_ROOT_PATH } =
-    useRuntimeConfig().public
-  const projectFolderPath = generateProjectFolderPath(PROJECT)
-  await createPath(projectFolderPath)
+  const geodeStore = useGeodeStore();
+  const infraStore = useInfraStore();
+  const viewerStore = useViewerStore();
+  infraStore.app_mode = appMode.BROWSER;
+  const { COMMAND_BACK, PROJECT, COMMAND_VIEWER, NUXT_ROOT_PATH } = useRuntimeConfig().public;
+  const projectFolderPath = generateProjectFolderPath(PROJECT);
+  await createPath(projectFolderPath);
 
   const [back_port, viewer_port] = await Promise.all([
     runBack(COMMAND_BACK, NUXT_ROOT_PATH, {
@@ -42,58 +34,56 @@ async function runMicroservices() {
       uploadFolderPath: data_folder,
     }),
     runViewer(COMMAND_VIEWER, NUXT_ROOT_PATH, { projectFolderPath }),
-  ])
+  ]);
 
-  console.log("back_port", back_port)
-  console.log("viewer_port", viewer_port)
+  console.log("back_port", back_port);
+  console.log("viewer_port", viewer_port);
 
   await addMicroserviceMetadatas(projectFolderPath, {
     type: "back",
     name: COMMAND_BACK,
     port: back_port,
-  })
+  });
   await addMicroserviceMetadatas(projectFolderPath, {
     type: "viewer",
     name: COMMAND_VIEWER,
     port: viewer_port,
-  })
+  });
 
-  geodeStore.default_local_port = back_port
-  viewerStore.default_local_port = viewer_port
+  geodeStore.default_local_port = back_port;
+  viewerStore.default_local_port = viewer_port;
 
   return {
     projectFolderPath,
-  }
+  };
 }
 
 async function setupIntegrationTests(file_name, geode_object) {
-  setupActivePinia()
-  const viewerStore = useViewerStore()
-  const { projectFolderPath } = await runMicroservices()
-  await viewerStore.ws_connect()
-  const id = await importFile(file_name, geode_object)
-  expect(viewerStore.status).toBe(Status.CONNECTED)
-  console.log("end of setupIntegrationTests", { id, projectFolderPath })
-  return { id, projectFolderPath }
+  setupActivePinia();
+  const viewerStore = useViewerStore();
+  const { projectFolderPath } = await runMicroservices();
+  await viewerStore.ws_connect();
+  const id = await importFile(file_name, geode_object);
+  expect(viewerStore.status).toBe(Status.CONNECTED);
+  console.log("end of setupIntegrationTests", { id, projectFolderPath });
+  return { id, projectFolderPath };
 }
 
-const mockLockRequest = vi
-  .fn()
-  .mockImplementation(async (name, task) => await task({ name }))
+const mockLockRequest = vi.fn().mockImplementation(async (name, task) => await task({ name }));
 
 vi.stubGlobal("navigator", {
   ...navigator,
   locks: {
     request: mockLockRequest,
   },
-})
+});
 
 beforeAll(() => {
-  globalThis.WebSocket = WebSocket
-})
+  globalThis.WebSocket = WebSocket;
+});
 
 afterAll(() => {
-  delete globalThis.WebSocket
-})
+  delete globalThis.WebSocket;
+});
 
-export { runMicroservices, setupIntegrationTests }
+export { runMicroservices, setupIntegrationTests };

package/tests/integration/stores/data_style/mesh/cells.nuxt.test.js

@@ -1,181 +1,155 @@
 // Third party imports
-import { afterEach, beforeEach, describe, expect, test, vi } from "vitest"
-import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json" with { type: "json" }
+import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
+import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json" with { type: "json" };
 
 // Local imports
-import { Status } from "@ogw_front/utils/status"
-import { cleanupBackend } from "@ogw_front/utils/local/cleanup"
-import { setupIntegrationTests } from "@ogw_tests/integration/setup"
-import { useDataStyleStore } from "@ogw_front/stores/data_style"
-import { useViewerStore } from "@ogw_front/stores/viewer"
+import { Status } from "@ogw_front/utils/status";
+import { cleanupBackend } from "@ogw_front/utils/local/cleanup";
+import { setupIntegrationTests } from "@ogw_tests/integration/setup";
+import { useDataStyleStore } from "@ogw_front/stores/data_style";
+import { useViewerStore } from "@ogw_front/stores/viewer";
 
 // Local constants
-const INTERVAL_TIMEOUT = 20_000
-const mesh_cells_schemas = viewer_schemas.opengeodeweb_viewer.mesh.cells
-const file_name = "test.og_rgd2d"
-const geode_object = "RegularGrid2D"
-const vertex_attribute = { name: "points" }
-const cell_attribute = { name: "RGB_data" }
+const INTERVAL_TIMEOUT = 20_000;
+const mesh_cells_schemas = viewer_schemas.opengeodeweb_viewer.mesh.cells;
+const file_name = "test.og_rgd2d";
+const geode_object = "RegularGrid2D";
+const vertex_attribute = { name: "points" };
+const cell_attribute = { name: "RGB_data" };
 
 let id = "",
-  projectFolderPath = ""
+  projectFolderPath = "";
 
 beforeEach(async () => {
-  ;({ id, projectFolderPath } = await setupIntegrationTests(
-    file_name,
-    geode_object,
-  ))
-}, INTERVAL_TIMEOUT)
+  ({ id, projectFolderPath } = await setupIntegrationTests(file_name, geode_object));
+}, INTERVAL_TIMEOUT);
 
 afterEach(async () => {
-  console.log("afterEach mesh cells kill", projectFolderPath)
-  await cleanupBackend(projectFolderPath)
-})
+  console.log("afterEach mesh cells kill", projectFolderPath);
+  await cleanupBackend(projectFolderPath);
+});
 
-describe("Mesh cells", async () => {
+describe("Mesh cells", () => {
   describe("Cells visibility", () => {
     test("Visibility true", async () => {
-      const dataStyleStore = useDataStyleStore()
-      const viewerStore = useViewerStore()
-      const visibility = true
-      const spy = vi.spyOn(viewerStore, "request")
-      const result = dataStyleStore.setMeshCellsVisibility(id, visibility)
-      expect(result).toBeInstanceOf(Promise)
-      await result
+      const dataStyleStore = useDataStyleStore();
+      const viewerStore = useViewerStore();
+      const visibility = true;
+      const spy = vi.spyOn(viewerStore, "request");
+      const result = dataStyleStore.setMeshCellsVisibility(id, visibility);
+      expect(result).toBeInstanceOf(Promise);
+      await result;
       expect(spy).toHaveBeenCalledWith(
         mesh_cells_schemas.visibility,
         { id, visibility },
         {
           response_function: expect.any(Function),
         },
-      )
-      expect(dataStyleStore.meshCellsVisibility(id)).toBe(visibility)
-      expect(viewerStore.status).toBe(Status.CONNECTED)
-    })
-  })
+      );
+      expect(dataStyleStore.meshCellsVisibility(id)).toBe(visibility);
+      expect(viewerStore.status).toBe(Status.CONNECTED);
+    });
+  });
 
   describe("Cells color", () => {
     test("Color red", async () => {
-      const dataStyleStore = useDataStyleStore()
-      const viewerStore = useViewerStore()
-      const color = { r: 255, g: 0, b: 0 }
-      const spy = vi.spyOn(viewerStore, "request")
-      const result = dataStyleStore.setMeshCellsColor(id, color)
-      expect(result).toBeInstanceOf(Promise)
-      await result
+      const dataStyleStore = useDataStyleStore();
+      const viewerStore = useViewerStore();
+      const color = { r: 255, g: 0, b: 0 };
+      const spy = vi.spyOn(viewerStore, "request");
+      const result = dataStyleStore.setMeshCellsColor(id, color);
+      expect(result).toBeInstanceOf(Promise);
+      await result;
       expect(spy).toHaveBeenCalledWith(
         mesh_cells_schemas.color,
         { id, color },
         {
           response_function: expect.any(Function),
         },
-      )
-      expect(dataStyleStore.meshCellsColor(id)).toStrictEqual(color)
-      expect(viewerStore.status).toBe(Status.CONNECTED)
-    })
-  })
+      );
+      expect(dataStyleStore.meshCellsColor(id)).toStrictEqual(color);
+      expect(viewerStore.status).toBe(Status.CONNECTED);
+    });
+  });
 
   describe("Cells vertex attribute", () => {
     test("Coloring vertex attribute", async () => {
-      const dataStyleStore = useDataStyleStore()
-      const viewerStore = useViewerStore()
-      const spy = vi.spyOn(viewerStore, "request")
-      const result = dataStyleStore.setMeshCellsVertexAttributeName(
-        id,
-        vertex_attribute.name,
-      )
-      expect(result).toBeInstanceOf(Promise)
-      await result
+      const dataStyleStore = useDataStyleStore();
+      const viewerStore = useViewerStore();
+      const spy = vi.spyOn(viewerStore, "request");
+      const result = dataStyleStore.setMeshCellsVertexAttributeName(id, vertex_attribute.name);
+      expect(result).toBeInstanceOf(Promise);
+      await result;
       expect(spy).toHaveBeenCalledWith(
         mesh_cells_schemas.attribute.vertex.name,
         { id, ...vertex_attribute },
         {
           response_function: expect.any(Function),
         },
-      )
-      expect(dataStyleStore.meshCellsVertexAttributeName(id)).toBe(
-        vertex_attribute.name,
-      )
-      expect(viewerStore.status).toBe(Status.CONNECTED)
-    })
-  })
+      );
+      expect(dataStyleStore.meshCellsVertexAttributeName(id)).toBe(vertex_attribute.name);
+      expect(viewerStore.status).toBe(Status.CONNECTED);
+    });
+  });
 
   describe("Cells cell attribute", () => {
     test("Coloring cell attribute", async () => {
-      const dataStyleStore = useDataStyleStore()
-      const viewerStore = useViewerStore()
-      const spy = vi.spyOn(viewerStore, "request")
-      const result = dataStyleStore.setMeshCellsCellAttributeName(
-        id,
-        cell_attribute.name,
-      )
-      expect(result).toBeInstanceOf(Promise)
-      await result
+      const dataStyleStore = useDataStyleStore();
+      const viewerStore = useViewerStore();
+      const spy = vi.spyOn(viewerStore, "request");
+      const result = dataStyleStore.setMeshCellsCellAttributeName(id, cell_attribute.name);
+      expect(result).toBeInstanceOf(Promise);
+      await result;
       expect(spy).toHaveBeenCalledWith(
         mesh_cells_schemas.attribute.cell.name,
         { id, ...cell_attribute },
         {
           response_function: expect.any(Function),
         },
-      )
-      expect(dataStyleStore.meshCellsCellAttributeName(id)).toBe(
-        cell_attribute.name,
-      )
-      expect(viewerStore.status).toBe(Status.CONNECTED)
-    })
-  })
+      );
+      expect(dataStyleStore.meshCellsCellAttributeName(id)).toBe(cell_attribute.name);
+      expect(viewerStore.status).toBe(Status.CONNECTED);
+    });
+  });
 
   describe("Cells active coloring", () => {
     test("test coloring", async () => {
-      const dataStyleStore = useDataStyleStore()
-      const viewerStore = useViewerStore()
+      const dataStyleStore = useDataStyleStore();
+      const viewerStore = useViewerStore();
       const coloringTypes = [
         { name: "color" },
         {
           name: "vertex",
-          function: () =>
-            dataStyleStore.setMeshCellsVertexAttributeName(
-              id,
-              vertex_attribute.name,
-            ),
+          function: () => dataStyleStore.setMeshCellsVertexAttributeName(id, vertex_attribute.name),
         },
         {
           name: "cell",
-          function: () =>
-            dataStyleStore.setMeshCellsCellAttributeName(
-              id,
-              cell_attribute.name,
-            ),
+          function: () => dataStyleStore.setMeshCellsCellAttributeName(id, cell_attribute.name),
         },
-      ]
+      ];
       async function testColoring(coloringType, expectedColoringType) {
         if (coloringType.function) {
-          await coloringType.function()
+          await coloringType.function();
         }
-        const result = dataStyleStore.setMeshCellsActiveColoring(
-          id,
-          coloringType.name,
-        )
-        expect(result).toBeInstanceOf(Promise)
-        await result
-        expect(dataStyleStore.meshCellsActiveColoring(id)).toBe(
-          expectedColoringType,
-        )
-        expect(viewerStore.status).toBe(Status.CONNECTED)
+        const result = dataStyleStore.setMeshCellsActiveColoring(id, coloringType.name);
+        expect(result).toBeInstanceOf(Promise);
+        await result;
+        expect(dataStyleStore.meshCellsActiveColoring(id)).toBe(expectedColoringType);
+        expect(viewerStore.status).toBe(Status.CONNECTED);
       }
 
-      await testColoring(coloringTypes[0], "color")
-      await testColoring(coloringTypes[1], "vertex")
-      await testColoring(coloringTypes[2], "cell")
-    })
-  })
+      await testColoring(coloringTypes[0], "color");
+      await testColoring(coloringTypes[1], "vertex");
+      await testColoring(coloringTypes[2], "cell");
+    });
+  });
 
   test("Cells apply default style", async () => {
-    const dataStyleStore = useDataStyleStore()
-    const viewerStore = useViewerStore()
-    const result = dataStyleStore.applyMeshCellsStyle(id)
-    expect(result).toBeInstanceOf(Promise)
-    await result
-    expect(viewerStore.status).toBe(Status.CONNECTED)
-  })
-})
+    const dataStyleStore = useDataStyleStore();
+    const viewerStore = useViewerStore();
+    const result = dataStyleStore.applyMeshCellsStyle(id);
+    expect(result).toBeInstanceOf(Promise);
+    await result;
+    expect(viewerStore.status).toBe(Status.CONNECTED);
+  });
+});