@geode/opengeodeweb-front 10.22.0 → 10.22.1-rc.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geode/opengeodeweb-front",
-  "version": "10.22.0",
+  "version": "10.22.1-rc.2",
   "description": "OpenSource Vue/Nuxt/Pinia/Vuetify framework for web applications",
   "homepage": "https://github.com/Geode-solutions/OpenGeodeWeb-Front",
   "bugs": {
@@ -34,8 +34,8 @@
     "build": ""
   },
   "dependencies": {
-    "@geode/opengeodeweb-back": "latest",
-    "@geode/opengeodeweb-viewer": "latest",
+    "@geode/opengeodeweb-back": "next",
+    "@geode/opengeodeweb-viewer": "next",
     "@google-cloud/run": "3.2.0",
     "@kitware/vtk.js": "33.3.0",
     "@mdi/font": "7.4.47",

package/server/api/extensions/run.post.js

@@ -57,12 +57,14 @@ export default defineEventHandler(async (event) => {
           });
         }
 
-        const frontendFilePath = extensionFrontendPath(
-          projectFolderPath,
+        const frontendFilePath = await extensionFrontendPath(
+          unzippedExtensionPath,
           frontendFile,
           path.resolve(),
           id,
         );
+
+        console.log("runExtensions", { frontendFilePath });
         const frontendContent = await fs.promises.readFile(frontendFilePath, "utf8");
 
         const backendExecutablePath = path.join(unzippedExtensionPath, backendExecutable);

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

@@ -40,9 +40,10 @@ describe("mesh cells", () => {
       const result = dataStyleStore.setMeshCellsVisibility(id, visibility);
       expect(result).toBeInstanceOf(Promise);
       await result;
+      const schema = mesh_cells_schemas.visibility;
+      const params = { id, visibility };
       expect(spy).toHaveBeenCalledWith(
-        mesh_cells_schemas.visibility,
-        { id, visibility },
+        { schema, params },
         {
           response_function: expect.any(Function),
         },
@@ -61,9 +62,10 @@ describe("mesh cells", () => {
       const result = dataStyleStore.setMeshCellsColor(id, color);
       expect(result).toBeInstanceOf(Promise);
       await result;
+      const schema = mesh_cells_schemas.color;
+      const params = { id, color };
       expect(spy).toHaveBeenCalledWith(
-        mesh_cells_schemas.color,
-        { id, color },
+        { schema, params },
         {
           response_function: expect.any(Function),
         },
@@ -81,9 +83,10 @@ describe("mesh cells", () => {
       const result = dataStyleStore.setMeshCellsVertexAttributeName(id, vertex_attribute.name);
       expect(result).toBeInstanceOf(Promise);
       await result;
+      const schema = mesh_cells_schemas.attribute.vertex.name;
+      const params = { id, ...vertex_attribute };
       expect(spy).toHaveBeenCalledWith(
-        mesh_cells_schemas.attribute.vertex.name,
-        { id, ...vertex_attribute },
+        { schema, params },
         {
           response_function: expect.any(Function),
         },
@@ -101,9 +104,10 @@ describe("mesh cells", () => {
       const result = dataStyleStore.setMeshCellsCellAttributeName(id, cell_attribute.name);
       expect(result).toBeInstanceOf(Promise);
       await result;
+      const schema = mesh_cells_schemas.attribute.cell.name;
+      const params = { id, ...cell_attribute };
       expect(spy).toHaveBeenCalledWith(
-        mesh_cells_schemas.attribute.cell.name,
-        { id, ...cell_attribute },
+        { schema, params },
         {
           response_function: expect.any(Function),
         },

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

@@ -38,9 +38,10 @@ describe("mesh edges", () => {
       const result = dataStyleStore.setMeshEdgesVisibility(id, visibility);
       expect(result).toBeInstanceOf(Promise);
       await result;
+      const schema = mesh_edges_schemas.visibility;
+      const params = { id, visibility };
       expect(spy).toHaveBeenCalledWith(
-        mesh_edges_schemas.visibility,
-        { id, visibility },
+        { schema, params },
         {
           response_function: expect.any(Function),
         },
@@ -57,9 +58,10 @@ describe("mesh edges", () => {
       const result = dataStyleStore.setMeshEdgesColor(id, color);
       expect(result).toBeInstanceOf(Promise);
       await result;
+      const schema = mesh_edges_schemas.color;
+      const params = { id, color };
       expect(spy).toHaveBeenCalledWith(
-        mesh_edges_schemas.color,
-        { id, color },
+        { schema, params },
         {
           response_function: expect.any(Function),
         },
@@ -74,9 +76,10 @@ describe("mesh edges", () => {
 
       const spy = vi.spyOn(viewerStore, "request");
       await dataStyleStore.setMeshEdgesVertexAttributeName(id, vertex_attribute.name);
+      const schema = mesh_edges_schemas.attribute.vertex.name;
+      const params = { id, ...vertex_attribute };
       expect(spy).toHaveBeenCalledWith(
-        mesh_edges_schemas.attribute.vertex.name,
-        { id, ...vertex_attribute },
+        { schema, params },
         {
           response_function: expect.any(Function),
         },
@@ -91,9 +94,10 @@ describe("mesh edges", () => {
 
       const spy = vi.spyOn(viewerStore, "request");
       await dataStyleStore.setMeshEdgesEdgeAttributeName(id, edge_attribute.name);
+      const schema = mesh_edges_schemas.attribute.edge.name;
+      const params = { id, ...edge_attribute };
       expect(spy).toHaveBeenCalledWith(
-        mesh_edges_schemas.attribute.edge.name,
-        { id, ...edge_attribute },
+        { schema, params },
         {
           response_function: expect.any(Function),
         },

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

@@ -36,9 +36,10 @@ describe("mesh", () => {
       const result = dataStyleStore.setMeshVisibility(id, visibility);
       expect(result).toBeInstanceOf(Promise);
       await result;
+      const schema = mesh_schemas.visibility;
+      const params = { id, visibility };
       expect(spy).toHaveBeenCalledWith(
-        mesh_schemas.visibility,
-        { id, visibility },
+        { schema, params },
         {
           response_function: expect.any(Function),
         },

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

@@ -37,9 +37,10 @@ describe("mesh points", () => {
       const result = dataStyleStore.setMeshPointsVisibility(id, visibility);
       expect(result).toBeInstanceOf(Promise);
       await result;
+      const schema = mesh_points_schemas.visibility;
+      const params = { id, visibility };
       expect(spy).toHaveBeenCalledWith(
-        mesh_points_schemas.visibility,
-        { id, visibility },
+        { schema, params },
         {
           response_function: expect.any(Function),
         },
@@ -58,9 +59,10 @@ describe("mesh points", () => {
       const result = dataStyleStore.setMeshPointsColor(id, color);
       expect(result).toBeInstanceOf(Promise);
       await result;
+      const schema = mesh_points_schemas.color;
+      const params = { id, color };
       expect(spy).toHaveBeenCalledWith(
-        mesh_points_schemas.color,
-        { id, color },
+        { schema, params },
         {
           response_function: expect.any(Function),
         },
@@ -104,9 +106,10 @@ describe("mesh points", () => {
       const result = dataStyleStore.setMeshPointsSize(id, size);
       expect(result).toBeInstanceOf(Promise);
       await result;
+      const schema = mesh_points_schemas.size;
+      const params = { id, size };
       expect(spy).toHaveBeenCalledWith(
-        mesh_points_schemas.size,
-        { id, size },
+        { schema, params },
         {
           response_function: expect.any(Function),
         },
@@ -123,9 +126,10 @@ describe("mesh points", () => {
 
       const spy = vi.spyOn(viewerStore, "request");
       await dataStyleStore.setMeshPointsVertexAttributeName(id, vertex_attribute.name);
+      const schema = mesh_points_schemas.attribute.vertex.name;
+      const params = { id, ...vertex_attribute };
       expect(spy).toHaveBeenCalledWith(
-        mesh_points_schemas.attribute.vertex.name,
-        { id, ...vertex_attribute },
+        { schema, params },
         {
           response_function: expect.any(Function),
         },

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

@@ -38,9 +38,10 @@ describe("mesh polygons", () => {
       const result = dataStyleStore.setMeshPolygonsVisibility(id, visibility);
       expect(result).toBeInstanceOf(Promise);
       await result;
+      const schema = mesh_polygons_schemas.visibility;
+      const params = { id, visibility };
       expect(spy).toHaveBeenCalledWith(
-        mesh_polygons_schemas.visibility,
-        { id, visibility },
+        { schema, params },
         {
           response_function: expect.any(Function),
         },
@@ -59,9 +60,10 @@ describe("mesh polygons", () => {
       const result = dataStyleStore.setMeshPolygonsColor(id, color);
       expect(result).toBeInstanceOf(Promise);
       await result;
+      const schema = mesh_polygons_schemas.color;
+      const params = { id, color };
       expect(spy).toHaveBeenCalledWith(
-        mesh_polygons_schemas.color,
-        { id, color },
+        { schema, params },
         {
           response_function: expect.any(Function),
         },
@@ -79,9 +81,10 @@ describe("mesh polygons", () => {
       const result = dataStyleStore.setMeshPolygonsVertexAttributeName(id, vertex_attribute.name);
       expect(result).toBeInstanceOf(Promise);
       await result;
+      const schema = mesh_polygons_schemas.attribute.vertex.name;
+      const params = { id, ...vertex_attribute };
       expect(spy).toHaveBeenCalledWith(
-        mesh_polygons_schemas.attribute.vertex.name,
-        { id, ...vertex_attribute },
+        { schema, params },
         {
           response_function: expect.any(Function),
         },
@@ -99,9 +102,10 @@ describe("mesh polygons", () => {
       const result = dataStyleStore.setMeshPolygonsPolygonAttributeName(id, polygon_attribute.name);
       expect(result).toBeInstanceOf(Promise);
       await result;
+      const schema = mesh_polygons_schemas.attribute.polygon.name;
+      const params = { id, ...polygon_attribute };
       expect(spy).toHaveBeenCalledWith(
-        mesh_polygons_schemas.attribute.polygon.name,
-        { id, ...polygon_attribute },
+        { schema, params },
         {
           response_function: expect.any(Function),
         },

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

@@ -38,9 +38,10 @@ describe("mesh polyhedra", () => {
       const result = dataStyleStore.setMeshPolyhedraVisibility(id, visibility);
       expect(result).toBeInstanceOf(Promise);
       await result;
+      const schema = mesh_polyhedra_schemas.visibility;
+      const params = { id, visibility };
       expect(spy).toHaveBeenCalledWith(
-        mesh_polyhedra_schemas.visibility,
-        { id, visibility },
+        { schema, params },
         {
           response_function: expect.any(Function),
         },
@@ -57,9 +58,10 @@ describe("mesh polyhedra", () => {
       const result = dataStyleStore.setMeshPolyhedraColor(id, color);
       expect(result).toBeInstanceOf(Promise);
       await result;
+      const schema = mesh_polyhedra_schemas.color;
+      const params = { id, color };
       expect(spy).toHaveBeenCalledWith(
-        mesh_polyhedra_schemas.color,
-        { id, color },
+        { schema, params },
         {
           response_function: expect.any(Function),
         },
@@ -110,9 +112,10 @@ describe("mesh polyhedra", () => {
 
     const spy = vi.spyOn(viewerStore, "request");
     await dataStyleStore.setMeshPolyhedraVertexAttributeName(id, vertex_attribute.name);
+    const schema = mesh_polyhedra_schemas.attribute.vertex.name;
+    const params = { id, ...vertex_attribute };
     expect(spy).toHaveBeenCalledWith(
-      mesh_polyhedra_schemas.attribute.vertex.name,
-      { id, ...vertex_attribute },
+      { schema, params },
       {
         response_function: expect.any(Function),
       },
@@ -127,9 +130,10 @@ describe("mesh polyhedra", () => {
 
     const spy = vi.spyOn(viewerStore, "request");
     await dataStyleStore.setMeshPolyhedraPolyhedronAttributeName(id, polyhedron_attribute.name);
+    const schema = mesh_polyhedra_schemas.attribute.polyhedron.name;
+    const params = { id, ...polyhedron_attribute };
     expect(spy).toHaveBeenCalledWith(
-      mesh_polyhedra_schemas.attribute.polyhedron.name,
-      { id, ...polyhedron_attribute },
+      { schema, params },
       {
         response_function: expect.any(Function),
       },

package/tests/integration/stores/data_style/model/blocks.nuxt.test.js

@@ -50,13 +50,10 @@ describe("model blocks", () => {
       expect(result).toBeInstanceOf(Promise);
       await result;
       await sleep(SLEEP_MS);
+      const schema = model_blocks_schemas.visibility;
+      const params = { id, block_ids: block_viewer_ids, visibility };
       expect(spy).toHaveBeenCalledWith(
-        model_blocks_schemas.visibility,
-        {
-          id,
-          block_ids: block_viewer_ids,
-          visibility,
-        },
+        { schema, params },
         {
           response_function: expect.any(Function),
         },
@@ -79,14 +76,10 @@ describe("model blocks", () => {
       const spy = vi.spyOn(viewerStore, "request");
       await dataStyleStore.setModelBlocksColor(id, block_ids, color);
       await sleep(SLEEP_MS);
+      const schema = model_blocks_schemas.color;
+      const params = { id, block_ids: block_viewer_ids, color, color_mode: "constant" };
       expect(spy).toHaveBeenCalledWith(
-        model_blocks_schemas.color,
-        {
-          id,
-          block_ids: block_viewer_ids,
-          color,
-          color_mode: "constant",
-        },
+        { schema, params },
         {
           response_function: expect.any(Function),
         },

package/tests/integration/stores/data_style/model/corners.nuxt.test.js

@@ -50,13 +50,10 @@ describe("model corners", () => {
       expect(result).toBeInstanceOf(Promise);
       await result;
       await sleep(SLEEP_MS);
+      const schema = model_corners_schemas.visibility;
+      const params = { id, block_ids: corner_viewer_ids, visibility };
       expect(spy).toHaveBeenCalledWith(
-        model_corners_schemas.visibility,
-        {
-          id,
-          block_ids: corner_viewer_ids,
-          visibility,
-        },
+        { schema, params },
         {
           response_function: expect.any(Function),
         },
@@ -82,14 +79,10 @@ describe("model corners", () => {
       expect(result).toBeInstanceOf(Promise);
       await result;
       await sleep(SLEEP_MS);
+      const schema = model_corners_schemas.color;
+      const params = { id, block_ids: corner_viewer_ids, color, color_mode: "constant" };
       expect(spy).toHaveBeenCalledWith(
-        model_corners_schemas.color,
-        {
-          id,
-          block_ids: corner_viewer_ids,
-          color,
-          color_mode: "constant",
-        },
+        { schema, params },
         {
           response_function: expect.any(Function),
         },

package/tests/integration/stores/data_style/model/edges.nuxt.test.js

@@ -46,9 +46,10 @@ describe("model edges", () => {
       expect(result).toBeInstanceOf(Promise);
       await result;
       await sleep(SLEEP_MS);
+      const schema = model_edges_schemas.visibility;
+      const params = { id, visibility };
       expect(spy).toHaveBeenCalledWith(
-        model_edges_schemas.visibility,
-        { id, visibility },
+        { schema, params },
         {
           response_function: expect.any(Function),
         },

package/tests/integration/stores/data_style/model/index.nuxt.test.js

@@ -46,9 +46,10 @@ describe("model", () => {
       expect(result).toBeInstanceOf(Promise);
       await result;
       await sleep(SLEEP_MS);
+      const schema = model_schemas.visibility;
+      const params = { id, visibility };
       expect(spy).toHaveBeenCalledWith(
-        model_schemas.visibility,
-        { id, visibility },
+        { schema, params },
         {
           response_function: expect.any(Function),
         },

package/tests/integration/stores/data_style/model/lines.nuxt.test.js

@@ -51,13 +51,10 @@ describe("model lines", () => {
       expect(result).toBeInstanceOf(Promise);
       await result;
       await sleep(SLEEP_MS);
+      const schema = model_lines_schemas.visibility;
+      const params = { id, block_ids: lines_viewer_ids, visibility };
       expect(spy).toHaveBeenCalledWith(
-        model_lines_schemas.visibility,
-        {
-          id,
-          block_ids: lines_viewer_ids,
-          visibility,
-        },
+        { schema, params },
         {
           response_function: expect.any(Function),
         },
@@ -83,14 +80,10 @@ describe("model lines", () => {
       expect(result).toBeInstanceOf(Promise);
       await result;
       await sleep(SLEEP_MS);
+      const schema = model_lines_schemas.color;
+      const params = { id, block_ids: lines_viewer_ids, color, color_mode: "constant" };
       expect(spy).toHaveBeenCalledWith(
-        model_lines_schemas.color,
-        {
-          id,
-          block_ids: lines_viewer_ids,
-          color,
-          color_mode: "constant",
-        },
+        { schema, params },
         {
           response_function: expect.any(Function),
         },

package/tests/integration/stores/data_style/model/points.nuxt.test.js

@@ -46,9 +46,10 @@ describe("model points", () => {
       expect(result).toBeInstanceOf(Promise);
       await result;
       await sleep(SLEEP_MS);
+      const schema = model_points_schemas.visibility;
+      const params = { id, visibility };
       expect(spy).toHaveBeenCalledWith(
-        model_points_schemas.visibility,
-        { id, visibility },
+        { schema, params },
         {
           response_function: expect.any(Function),
         },
@@ -69,9 +70,10 @@ describe("model points", () => {
       expect(result).toBeInstanceOf(Promise);
       await result;
       await sleep(SLEEP_MS);
+      const schema = model_points_schemas.size;
+      const params = { id, size };
       expect(spy).toHaveBeenCalledWith(
-        model_points_schemas.size,
-        { id, size },
+        { schema, params },
         {
           response_function: expect.any(Function),
         },

package/tests/integration/stores/data_style/model/surfaces.nuxt.test.js

@@ -49,13 +49,10 @@ describe("model surfaces", () => {
       expect(result).toBeInstanceOf(Promise);
       await result;
       await sleep(SLEEP_MS);
+      const schema = model_surfaces_schemas.visibility;
+      const params = { id, block_ids: surface_viewer_ids, visibility };
       expect(spy).toHaveBeenCalledWith(
-        model_surfaces_schemas.visibility,
-        {
-          id,
-          block_ids: surface_viewer_ids,
-          visibility,
-        },
+        { schema, params },
         {
           response_function: expect.any(Function),
         },
@@ -81,14 +78,10 @@ describe("model surfaces", () => {
       expect(result).toBeInstanceOf(Promise);
       await result;
       await sleep(SLEEP_MS);
+      const schema = model_surfaces_schemas.color;
+      const params = { id, block_ids: surface_viewer_ids, color, color_mode: "constant" };
       expect(spy).toHaveBeenCalledWith(
-        model_surfaces_schemas.color,
-        {
-          id,
-          block_ids: surface_viewer_ids,
-          color,
-          color_mode: "constant",
-        },
+        { schema, params },
         {
           response_function: expect.any(Function),
         },

package/tests/integration/stores/viewer.nuxt.test.js

@@ -56,10 +56,9 @@ describe("viewer Store", () => {
           const schema = opengeodeweb_viewer_schemas.opengeodeweb_viewer.viewer.render;
           const viewerStore = useViewerStore();
           const timeout = 1;
-          const params = {};
           expect(() =>
             viewerStore
-              .request(schema, params, {}, timeout)
+              .request({ schema, timeout })
               .rejects.toThrow(`${schema.$id}: Timed out after ${timeout}ms, ${schema} ${params}`),
           ).toBeDefined();
         },

package/tests/unit/components/CrsSelector.nuxt.test.js

@@ -30,7 +30,7 @@ describe("crs selector", () => {
     ];
 
     // Mock backStore.request instead of registerEndpoint
-    backStore.request = vi.fn((schema, params, callbacks) => {
+    backStore.request = vi.fn((request, callbacks) => {
       callbacks.response_function({ crs_list });
       return Promise.resolve({ crs_list });
     });

package/tests/unit/components/Inspector/InspectionButton.nuxt.test.js

@@ -31,7 +31,7 @@ describe("inspector inspection button", () => {
         },
       ],
     };
-    backStore.request = vi.fn((_schema, _params, callbacks) => {
+    backStore.request = vi.fn((request, callbacks) => {
       callbacks?.response_function?.({ inspection_result });
       return Promise.resolve({ inspection_result });
     });

package/tests/unit/components/MissingFilesSelector.nuxt.test.js

@@ -23,7 +23,7 @@ describe("missing files selector", () => {
   backStore.base_url = "/";
 
   test("select file", async () => {
-    backStore.request = vi.fn((schema, params, callbacks) => {
+    backStore.request = vi.fn((request, callbacks) => {
       callbacks?.response_function?.({
         has_missing_files: true,
         mandatory_files: ["fake_file.txt"],

package/tests/unit/composables/api_fetch.nuxt.test.js

@@ -48,14 +48,13 @@ describe("backStore.request()", () => {
       additionalProperties: false,
     };
     const params = { test: "hello" };
-    expect(() => backStore.request(invalid_schema, params)).toThrow("data/test must be number");
+    expect(() => backStore.request({ schema: invalid_schema, params })).toThrow(
+      "data/test must be number",
+    );
   });
 
   test("invalid params", () => {
-    const params = {};
-    expect(() => backStore.request(schema, params)).toThrow(
-      "data must have required property 'test'",
-    );
+    expect(() => backStore.request({ schema })).toThrow("data must have required property 'test'");
   });
 
   test("request with callbacks", async () => {
@@ -70,7 +69,7 @@ describe("backStore.request()", () => {
       method: schema.methods[FIRST_INDEX],
       handler: () => ({ result: "success" }),
     });
-    await backStore.request(schema, params, callbacks);
+    await backStore.request({ schema, params }, callbacks);
     expect(errorCalled).toBe(false);
   });
 });

package/tests/vitest.config.js

@@ -45,7 +45,6 @@ export default defineConfig({
           include: ["tests/integration/**/*.test.js"],
           globals: true,
           environment: "nuxt",
-          fileParallelism: false,
           testTimeout: TIMEOUTS.integration,
           setupFiles: [path.resolve(__dirname, "./setup_indexeddb.js")],
           server: {