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

package/app/utils/local/microservices.js

@@ -10,8 +10,8 @@ import pTimeout from "p-timeout";
 
 // Local imports
 import { commandExistsSync, waitForReady } from "./scripts.js";
-import { executableName, executablePath } from "./path.js";
 import { microservicesMetadatasPath, projectMicroservices } from "./cleanup.js";
+import { executablePath } from "./path.js";
 
 const DEFAULT_TIMEOUT_SECONDS = 60;
 const MILLISECONDS_PER_SECOND = 1000;
@@ -24,8 +24,8 @@ function getAvailablePort() {
 }
 
 async function runScript(
-  execName,
   execPath,
+  execName,
   args,
   expectedResponse,
   timeoutSeconds = DEFAULT_TIMEOUT_SECONDS,
@@ -34,7 +34,7 @@ async function runScript(
   if (commandExistsSync(execName)) {
     command = execName;
   } else {
-    command = path.join(executablePath(execPath), executableName(execName));
+    command = path.join(executablePath(execPath, execName));
   }
   console.log("runScript", command, args);
 
@@ -82,8 +82,8 @@ async function runBack(execName, execPath, args = {}) {
   if (process.env.NODE_ENV === "development" || !process.env.NODE_ENV) {
     backArgs.push("--debug");
   }
-  console.log("runBack", execName, execPath, backArgs);
-  await runScript(execName, execPath, backArgs, "Serving Flask app");
+  console.log("runBack", execPath, execName, backArgs);
+  await runScript(execPath, execName, backArgs, "Serving Flask app");
   return port;
 }
 
@@ -98,8 +98,8 @@ async function runViewer(execName, execPath, args = {}) {
     `--data_folder_path ${projectFolderPath}`,
     `--timeout ${0}`,
   ];
-  console.log("runViewer", execName, execPath, viewerArgs);
-  await runScript(execName, execPath, viewerArgs, "Starting factory");
+  console.log("runViewer", execPath, execName, viewerArgs);
+  await runScript(execPath, execName, viewerArgs, "Starting factory");
   return port;
 }
 

package/app/utils/local/path.js

@@ -2,6 +2,7 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import { setTimeout } from "node:timers/promises";
 
 // Third party imports
 import { v4 as uuidv4 } from "uuid";
@@ -9,22 +10,31 @@ import { v4 as uuidv4 } from "uuid";
 // Local imports
 import { appMode } from "./app_mode.js";
 
-function executablePath(microservicePath) {
+function executablePath(execPath, execName) {
   const resourcesPath = process.env.RESOURCES_PATH;
   const mode = process.env.MODE;
   const nodeEnv = process.env.NODE_ENV;
-  console.log("[executablePath]", { microservicePath, mode, nodeEnv, resourcesPath });
+  console.log("[executablePath]", { execPath, execName, mode, nodeEnv, resourcesPath });
   if (mode === appMode.DESKTOP && nodeEnv === "production") {
-    return resourcesPath;
+    const execPathInResources = path.join(resourcesPath, executableName(execName));
+    if (fs.existsSync(execPathInResources)) {
+      console.log(`[executablePath] Found executable in resources path: ${execPathInResources}`);
+      return execPathInResources;
+    }
   }
-  return microservicePath;
+  const localExecPath = path.join(execPath, executableName(execName));
+  if (fs.existsSync(localExecPath)) {
+    console.log(`[executablePath] Found executable in local path: ${localExecPath}`);
+    return localExecPath;
+  }
+  throw new Error(`Executable not found: ${execName}`);
 }
 
-function executableName(name) {
+function executableName(execName) {
   if (process.platform === "win32") {
-    return `${name}.exe`;
+    return `${execName}.exe`;
   }
-  return name;
+  return execName;
 }
 
 function createPath(dirPath) {
@@ -39,17 +49,62 @@ function generateProjectFolderPath(projectName) {
   return path.join(os.tmpdir(), projectName.replaceAll("/", "_"), uuidv4());
 }
 
-function extensionFrontendPath(unzippedExtensionPath, frontendFile, rootPath, extensionId) {
-  if (process.env.NODE_ENV === "production") {
-    return path.join(unzippedExtensionPath, frontendFile);
+async function lookForLocalExtensionDistPath(rootPath, extentionRepoName, frontendFile) {
+  const localExtensionPath = path.join(rootPath, "..", extentionRepoName);
+  const localExtensionDistPath = path.join(localExtensionPath, "dist");
+
+  if (!fs.existsSync(localExtensionDistPath)) {
+    return;
+  }
+  console.log(
+    `[extensionFrontendPath] Found existing folder: ${localExtensionDistPath}, deleting it...`,
+  );
+  fs.rmSync(localExtensionDistPath, { recursive: true, force: true });
+  const now = new Date();
+  fs.utimesSync(path.join(localExtensionPath, "package.json"), now, now);
+
+  const rebuiltFilePath = path.join(localExtensionDistPath, frontendFile);
+  const MAX_DELETE_FOLDER_RETRIES = 10;
+  const MILLISECONDS_PER_RETRY = 1000;
+
+  for (let i = 0; i <= MAX_DELETE_FOLDER_RETRIES; i += 1) {
+    if (fs.existsSync(rebuiltFilePath)) {
+      console.log(`Found rebuilt file: ${rebuiltFilePath}`);
+      return rebuiltFilePath;
+    }
+    console.log(`Waiting for rebuild... attempt ${i}/${MAX_DELETE_FOLDER_RETRIES}`);
+    // oxlint-disable-next-line no-await-in-loop
+    await setTimeout(MILLISECONDS_PER_RETRY);
   }
+
+  throw new Error(`Failed to find local extension dist path: ${rebuiltFilePath}`);
+}
+async function extensionFrontendPath(unzippedExtensionPath, frontendFile, rootPath, extensionId) {
+  console.log("[extensionFrontendPath]", {
+    unzippedExtensionPath,
+    frontendFile,
+    rootPath,
+    extensionId,
+  });
   const extentionRepoName = extensionId
     .split("-")
     .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
     .join("-");
-  const localExtensionPath = path.join(rootPath, "..", extentionRepoName, "dist", frontendFile);
-  console.log("runExtensions", { localExtensionPath });
-  return localExtensionPath;
+
+  const localFilePath = await lookForLocalExtensionDistPath(
+    rootPath,
+    extentionRepoName,
+    frontendFile,
+  );
+  if (localFilePath) {
+    return localFilePath;
+  }
+
+  const unzippedfrontendFilePath = path.join(unzippedExtensionPath, frontendFile);
+  if (fs.existsSync(unzippedfrontendFilePath)) {
+    return unzippedfrontendFilePath;
+  }
+  throw new Error(`Failed to find ${unzippedfrontendFilePath}`);
 }
 
 export {

package/internal/stores/data_style/mesh/cells/cell.js

@@ -9,6 +9,7 @@ import { useViewerStore } from "@ogw_front/stores/viewer";
 // Local constants
 const meshCellsCellAttributeSchemas = viewer_schemas.opengeodeweb_viewer.mesh.cells.attribute.cell;
 
+// oxlint-disable-next-line max-lines-per-function
 export function useMeshCellsCellAttributeStyle() {
   const viewerStore = useViewerStore();
   const meshCellsCommonStyle = useMeshCellsCommonStyle();
@@ -42,9 +43,13 @@ export function useMeshCellsCellAttributeStyle() {
   }
 
   function setMeshCellsCellAttributeName(id, name) {
+    const schema = meshCellsCellAttributeSchemas.name;
+    const params = { id, name };
     return viewerStore.request(
-      meshCellsCellAttributeSchemas.name,
-      { id, name },
+      {
+        schema,
+        params,
+      },
       {
         response_function: () => meshCellsCommonStyle.mutateMeshCellsCellStyle(id, { name }),
       },
@@ -62,9 +67,13 @@ export function useMeshCellsCellAttributeStyle() {
     const name = meshCellsCellAttributeName(id);
     const points = getRGBPointsFromPreset(meshCellsCellAttributeColorMap(id));
     if (points.length > 0 && minimum !== undefined && maximum !== undefined) {
+      const schema = meshCellsCellAttributeSchemas.color_map;
+      const params = { id, points, minimum, maximum };
       return viewerStore.request(
-        meshCellsCellAttributeSchemas.color_map,
-        { id, points, minimum, maximum },
+        {
+          schema,
+          params,
+        },
         {
           response_function: () =>
             setMeshCellsCellAttributeStoredConfig(id, name, { minimum, maximum }),
@@ -87,9 +96,13 @@ export function useMeshCellsCellAttributeStyle() {
     const points = getRGBPointsFromPreset(colorMap);
     const { minimum, maximum } = storedConfig;
     if (points.length > 0 && minimum !== undefined && maximum !== undefined) {
+      const schema = meshCellsCellAttributeSchemas.color_map;
+      const params = { id, points, minimum, maximum };
       return viewerStore.request(
-        meshCellsCellAttributeSchemas.color_map,
-        { id, points, minimum, maximum },
+        {
+          schema,
+          params,
+        },
         {
           response_function: () => setMeshCellsCellAttributeStoredConfig(id, name, { colorMap }),
         },

package/internal/stores/data_style/mesh/cells/color.js

@@ -6,7 +6,7 @@ import { useMeshCellsCommonStyle } from "./common";
 import { useViewerStore } from "@ogw_front/stores/viewer";
 
 // Local constants
-const meshCellsColorSchemas = viewer_schemas.opengeodeweb_viewer.mesh.cells.color;
+const schema = viewer_schemas.opengeodeweb_viewer.mesh.cells.color;
 
 export function useMeshCellsColorStyle() {
   const viewerStore = useViewerStore();
@@ -16,9 +16,12 @@ export function useMeshCellsColorStyle() {
     return meshCellsCommonStyle.meshCellsColoring(id).color;
   }
   function setMeshCellsColor(id, color) {
+    const params = { id, color };
     return viewerStore.request(
-      meshCellsColorSchemas,
-      { id, color },
+      {
+        schema,
+        params,
+      },
       {
         response_function: () =>
           meshCellsCommonStyle.mutateMeshCellsColoring(id, {

package/internal/stores/data_style/mesh/cells/textures.js

@@ -6,7 +6,7 @@ import { useMeshCellsCommonStyle } from "./common";
 import { useViewerStore } from "@ogw_front/stores/viewer";
 
 // Local constants
-const meshCellsTexturesSchemas = viewer_schemas.opengeodeweb_viewer.mesh.cells.apply_textures;
+const schema = viewer_schemas.opengeodeweb_viewer.mesh.cells.apply_textures;
 
 export function useMeshCellsTexturesStyle() {
   const viewerStore = useViewerStore();
@@ -16,9 +16,12 @@ export function useMeshCellsTexturesStyle() {
     return meshCellsCommonStyle.meshCellsColoring(id).textures;
   }
   function setMeshCellsTextures(id, textures) {
+    const params = { id, textures };
     return viewerStore.request(
-      meshCellsTexturesSchemas,
-      { id, textures },
+      {
+        schema,
+        params,
+      },
       {
         response_function: () =>
           meshCellsCommonStyle.mutateMeshCellsStyle(id, {

package/internal/stores/data_style/mesh/cells/vertex.js

@@ -10,6 +10,7 @@ import { useViewerStore } from "@ogw_front/stores/viewer";
 const meshCellsVertexAttributeSchemas =
   viewer_schemas.opengeodeweb_viewer.mesh.cells.attribute.vertex;
 
+// oxlint-disable-next-line max-lines-per-function
 export function useMeshCellsVertexAttributeStyle() {
   const viewerStore = useViewerStore();
   const meshCellsCommonStyle = useMeshCellsCommonStyle();
@@ -51,9 +52,10 @@ export function useMeshCellsVertexAttributeStyle() {
   }
 
   function setMeshCellsVertexAttributeName(id, name) {
+    const schema = meshCellsVertexAttributeSchemas.name;
+    const params = { id, name };
     return viewerStore.request(
-      meshCellsVertexAttributeSchemas.name,
-      { id, name },
+      { schema, params },
       {
         response_function: () => {
           const updates = { name };
@@ -84,9 +86,10 @@ export function useMeshCellsVertexAttributeStyle() {
     const name = meshCellsVertexAttributeName(id);
     const points = getRGBPointsFromPreset(meshCellsVertexAttributeColorMap(id));
     if (points.length > 0 && minimum !== undefined && maximum !== undefined) {
+      const schema = meshCellsVertexAttributeSchemas.color_map;
+      const params = { id, points, minimum, maximum };
       return viewerStore.request(
-        meshCellsVertexAttributeSchemas.color_map,
-        { id, points, minimum, maximum },
+        { schema, params },
         {
           response_function: () =>
             setMeshCellsVertexAttributeStoredConfig(id, name, { minimum, maximum }),
@@ -112,9 +115,10 @@ export function useMeshCellsVertexAttributeStyle() {
     const points = getRGBPointsFromPreset(colorMap);
     const { minimum, maximum } = storedConfig;
     if (points.length > 0 && minimum !== undefined && maximum !== undefined) {
+      const schema = meshCellsVertexAttributeSchemas.color_map;
+      const params = { id, points, minimum, maximum };
       return viewerStore.request(
-        meshCellsVertexAttributeSchemas.color_map,
-        { id, points, minimum, maximum },
+        { schema, params },
         {
           response_function: () => setMeshCellsVertexAttributeStoredConfig(id, name, { colorMap }),
         },

package/internal/stores/data_style/mesh/cells/visibility.js

@@ -6,7 +6,7 @@ import { useMeshCellsCommonStyle } from "./common";
 import { useViewerStore } from "@ogw_front/stores/viewer";
 
 // Local constants
-const meshCellsVisibilitySchema = viewer_schemas.opengeodeweb_viewer.mesh.cells.visibility;
+const schema = viewer_schemas.opengeodeweb_viewer.mesh.cells.visibility;
 
 export function useMeshCellsVisibilityStyle() {
   const viewerStore = useViewerStore();
@@ -16,9 +16,12 @@ export function useMeshCellsVisibilityStyle() {
     return meshCellsCommonStyle.meshCellsStyle(id).visibility;
   }
   function setMeshCellsVisibility(id, visibility) {
+    const params = { id, visibility };
     return viewerStore.request(
-      meshCellsVisibilitySchema,
-      { id, visibility },
+      {
+        schema,
+        params,
+      },
       {
         response_function: () => meshCellsCommonStyle.mutateMeshCellsStyle(id, { visibility }),
       },

package/internal/stores/data_style/mesh/edges/color.js

@@ -6,7 +6,7 @@ import { useMeshEdgesCommonStyle } from "./common";
 import { useViewerStore } from "@ogw_front/stores/viewer";
 
 // Local constants
-const meshEdgesColorSchemas = viewer_schemas.opengeodeweb_viewer.mesh.edges.color;
+const schema = viewer_schemas.opengeodeweb_viewer.mesh.edges.color;
 
 export function useMeshEdgesColorStyle() {
   const viewerStore = useViewerStore();
@@ -16,9 +16,12 @@ export function useMeshEdgesColorStyle() {
     return meshEdgesCommonStyle.meshEdgesColoring(id).color;
   }
   function setMeshEdgesColor(id, color) {
+    const params = { id, color };
     return viewerStore.request(
-      meshEdgesColorSchemas,
-      { id, color },
+      {
+        schema,
+        params,
+      },
       {
         response_function: () =>
           meshEdgesCommonStyle.mutateMeshEdgesColoring(id, {

package/internal/stores/data_style/mesh/edges/edge.js

@@ -9,6 +9,7 @@ import { useViewerStore } from "@ogw_front/stores/viewer";
 // Local constants
 const meshEdgesEdgeAttributeSchemas = viewer_schemas.opengeodeweb_viewer.mesh.edges.attribute.edge;
 
+// oxlint-disable-next-line max-lines-per-function
 export function useMeshEdgesEdgeAttributeStyle() {
   const viewerStore = useViewerStore();
   const meshEdgesCommonStyle = useMeshEdgesCommonStyle();
@@ -54,9 +55,13 @@ export function useMeshEdgesEdgeAttributeStyle() {
   }
 
   function setMeshEdgesEdgeAttributeName(id, name) {
+    const schema = meshEdgesEdgeAttributeSchemas.name;
+    const params = { id, name };
     return viewerStore.request(
-      meshEdgesEdgeAttributeSchemas.name,
-      { id, name },
+      {
+        schema,
+        params,
+      },
       {
         response_function: () => {
           const updates = { name };
@@ -87,9 +92,10 @@ export function useMeshEdgesEdgeAttributeStyle() {
     const name = meshEdgesEdgeAttributeName(id);
     const points = getRGBPointsFromPreset(meshEdgesEdgeAttributeColorMap(id));
     if (points.length > 0 && minimum !== undefined && maximum !== undefined) {
+      const schema = meshEdgesEdgeAttributeSchemas.color_map;
+      const params = { id, points, minimum, maximum };
       return viewerStore.request(
-        meshEdgesEdgeAttributeSchemas.color_map,
-        { id, points, minimum, maximum },
+        { schema, params },
         {
           response_function: () =>
             setMeshEdgesEdgeAttributeStoredConfig(id, name, { minimum, maximum }),
@@ -115,9 +121,10 @@ export function useMeshEdgesEdgeAttributeStyle() {
     const points = getRGBPointsFromPreset(colorMap);
     const { minimum, maximum } = storedConfig;
     if (points.length > 0 && minimum !== undefined && maximum !== undefined) {
+      const schema = meshEdgesEdgeAttributeSchemas.color_map;
+      const params = { id, points, minimum, maximum };
       return viewerStore.request(
-        meshEdgesEdgeAttributeSchemas.color_map,
-        { id, points, minimum, maximum },
+        { schema, params },
         {
           response_function: () => setMeshEdgesEdgeAttributeStoredConfig(id, name, { colorMap }),
         },

package/internal/stores/data_style/mesh/edges/vertex.js

@@ -9,6 +9,7 @@ import { useViewerStore } from "@ogw_front/stores/viewer";
 const meshEdgesVertexAttributeSchemas =
   viewer_schemas.opengeodeweb_viewer.mesh.edges.attribute.vertex;
 
+// oxlint-disable-next-line max-lines-per-function
 export function useMeshEdgesVertexAttributeStyle() {
   const viewerStore = useViewerStore();
   const meshEdgesCommonStyle = useMeshEdgesCommonStyle();
@@ -53,9 +54,10 @@ export function useMeshEdgesVertexAttributeStyle() {
     return meshEdgesVertexAttribute(id).name;
   }
   function setMeshEdgesVertexAttributeName(id, name) {
+    const schema = meshEdgesVertexAttributeSchemas.name;
+    const params = { id, name };
     return viewerStore.request(
-      meshEdgesVertexAttributeSchemas.name,
-      { id, name },
+      { schema, params },
       {
         response_function: () => {
           const updates = { name };
@@ -85,9 +87,10 @@ export function useMeshEdgesVertexAttributeStyle() {
     const name = meshEdgesVertexAttributeName(id);
     const points = getRGBPointsFromPreset(meshEdgesVertexAttributeColorMap(id));
     if (points.length > 0 && minimum !== undefined && maximum !== undefined) {
+      const schema = meshEdgesVertexAttributeSchemas.color_map;
+      const params = { id, points, minimum, maximum };
       return viewerStore.request(
-        meshEdgesVertexAttributeSchemas.color_map,
-        { id, points, minimum, maximum },
+        { schema, params },
         {
           response_function: () =>
             setMeshEdgesVertexAttributeStoredConfig(id, name, { minimum, maximum }),
@@ -112,9 +115,10 @@ export function useMeshEdgesVertexAttributeStyle() {
     const points = getRGBPointsFromPreset(colorMap);
     const { minimum, maximum } = storedConfig;
     if (points.length > 0 && minimum !== undefined && maximum !== undefined) {
+      const schema = meshEdgesVertexAttributeSchemas.color_map;
+      const params = { id, points, minimum, maximum };
       return viewerStore.request(
-        meshEdgesVertexAttributeSchemas.color_map,
-        { id, points, minimum, maximum },
+        { schema, params },
         {
           response_function: () => setMeshEdgesVertexAttributeStoredConfig(id, name, { colorMap }),
         },

package/internal/stores/data_style/mesh/edges/visibility.js

@@ -5,7 +5,7 @@ import { useMeshEdgesCommonStyle } from "./common";
 import { useViewerStore } from "@ogw_front/stores/viewer";
 
 // Local constants
-const meshEdgesVisibilitySchema = viewer_schemas.opengeodeweb_viewer.mesh.edges.visibility;
+const schema = viewer_schemas.opengeodeweb_viewer.mesh.edges.visibility;
 
 export function useMeshEdgesVisibilityStyle() {
   const viewerStore = useViewerStore();
@@ -15,9 +15,12 @@ export function useMeshEdgesVisibilityStyle() {
     return meshEdgesCommonStyle.meshEdgesStyle(id).visibility;
   }
   function setMeshEdgesVisibility(id, visibility) {
+    const params = { id, visibility };
     return viewerStore.request(
-      meshEdgesVisibilitySchema,
-      { id, visibility },
+      {
+        schema,
+        params,
+      },
       {
         response_function: () => meshEdgesCommonStyle.mutateMeshEdgesStyle(id, { visibility }),
       },

package/internal/stores/data_style/mesh/edges/width.js

@@ -5,7 +5,7 @@ import { useMeshEdgesCommonStyle } from "./common";
 import { useViewerStore } from "@ogw_front/stores/viewer";
 
 // Local constants
-const meshEdgesWidthSchemas = viewer_schemas.opengeodeweb_viewer.mesh.edges.width;
+const schema = viewer_schemas.opengeodeweb_viewer.mesh.edges.width;
 
 export function useMeshEdgesWidthStyle() {
   const viewerStore = useViewerStore();
@@ -15,9 +15,12 @@ export function useMeshEdgesWidthStyle() {
     return meshEdgesCommonStyle.meshEdgesStyle(id).width;
   }
   function setMeshEdgesWidth(id, width) {
+    const params = { id, width };
     return viewerStore.request(
-      meshEdgesWidthSchemas,
-      { id, width },
+      {
+        schema,
+        params,
+      },
       {
         response_function: () => meshEdgesCommonStyle.mutateMeshEdgesStyle(id, { width }),
       },

package/internal/stores/data_style/mesh/index.js

@@ -29,9 +29,13 @@ export function useMeshStyle() {
     return dataStyleState.getStyle(id).visibility;
   }
   function setMeshVisibility(id, visibility) {
+    const schema = meshSchemas.visibility;
+    const params = { id, visibility };
     return viewerStore.request(
-      meshSchemas.visibility,
-      { id, visibility },
+      {
+        schema,
+        params,
+      },
       {
         response_function: async () => {
           await hybridViewerStore.setVisibility(id, visibility);
@@ -46,9 +50,13 @@ export function useMeshStyle() {
   }
 
   function setMeshColor(id, color) {
+    const schema = meshSchemas.color;
+    const params = { id, color };
     return viewerStore.request(
-      meshSchemas.color,
-      { id, color },
+      {
+        schema,
+        params,
+      },
       {
         response_function: () => dataStyleState.mutateStyle(id, { color }),
       },

package/internal/stores/data_style/mesh/points/color.js

@@ -6,7 +6,7 @@ import { useMeshPointsCommonStyle } from "./common";
 import { useViewerStore } from "@ogw_front/stores/viewer";
 
 // Local constants
-const meshPointsColorSchemas = viewer_schemas.opengeodeweb_viewer.mesh.points.color;
+const schema = viewer_schemas.opengeodeweb_viewer.mesh.points.color;
 
 export function useMeshPointsColorStyle() {
   const viewerStore = useViewerStore();
@@ -16,9 +16,12 @@ export function useMeshPointsColorStyle() {
     return meshPointsCommonStyle.meshPointsColoring(id).color;
   }
   function setMeshPointsColor(id, color) {
+    const params = { id, color };
     return viewerStore.request(
-      meshPointsColorSchemas,
-      { id, color },
+      {
+        schema,
+        params,
+      },
       {
         response_function: () =>
           meshPointsCommonStyle.mutateMeshPointsColoring(id, {

package/internal/stores/data_style/mesh/points/size.js

@@ -6,7 +6,7 @@ import { useMeshPointsCommonStyle } from "./common";
 import { useViewerStore } from "@ogw_front/stores/viewer";
 
 // Local constants
-const meshPointsSizeSchemas = viewer_schemas.opengeodeweb_viewer.mesh.points.size;
+const schema = viewer_schemas.opengeodeweb_viewer.mesh.points.size;
 
 export function useMeshPointsSizeStyle() {
   const viewerStore = useViewerStore();
@@ -16,9 +16,12 @@ export function useMeshPointsSizeStyle() {
     return meshPointsCommonStyle.meshPointsStyle(id).size;
   }
   function setMeshPointsSize(id, size) {
+    const params = { id, size };
     return viewerStore.request(
-      meshPointsSizeSchemas,
-      { id, size },
+      {
+        schema,
+        params,
+      },
       {
         response_function: () => meshPointsCommonStyle.mutateMeshPointsStyle(id, { size }),
       },

package/internal/stores/data_style/mesh/points/vertex.js

@@ -10,6 +10,7 @@ import { useViewerStore } from "@ogw_front/stores/viewer";
 const meshPointsVertexAttributeSchemas =
   viewer_schemas.opengeodeweb_viewer.mesh.points.attribute.vertex;
 
+// oxlint-disable-next-line max-lines-per-function
 function useMeshPointsVertexAttributeConfig() {
   const meshPointsCommonStyle = useMeshPointsCommonStyle();
 
@@ -74,14 +75,16 @@ function useMeshPointsVertexAttributeConfig() {
   };
 }
 
+// oxlint-disable-next-line max-lines-per-function
 function useMeshPointsVertexAttributeActions() {
   const viewerStore = useViewerStore();
   const config = useMeshPointsVertexAttributeConfig();
 
   function setMeshPointsVertexAttributeName(id, name) {
+    const schema = meshPointsVertexAttributeSchemas.name;
+    const params = { id, name };
     return viewerStore.request(
-      meshPointsVertexAttributeSchemas.name,
-      { id, name },
+      { schema, params },
       {
         response_function: () => {
           const updates = { name };
@@ -105,9 +108,10 @@ function useMeshPointsVertexAttributeActions() {
     const name = config.meshPointsVertexAttributeName(id);
     const points = getRGBPointsFromPreset(config.meshPointsVertexAttributeColorMap(id));
     if (points.length > 0 && minimum !== undefined && maximum !== undefined) {
+      const schema = meshPointsVertexAttributeSchemas.color_map;
+      const params = { id, points, minimum, maximum };
       return viewerStore.request(
-        meshPointsVertexAttributeSchemas.color_map,
-        { id, points, minimum, maximum },
+        { schema, params },
         {
           response_function: () =>
             config.setMeshPointsVertexAttributeStoredConfig(id, name, { minimum, maximum }),
@@ -126,9 +130,10 @@ function useMeshPointsVertexAttributeActions() {
     const points = getRGBPointsFromPreset(colorMap);
     const { minimum, maximum } = storedConfig;
     if (points.length > 0 && minimum !== undefined && maximum !== undefined) {
+      const schema = meshPointsVertexAttributeSchemas.color_map;
+      const params = { id, points, minimum, maximum };
       return viewerStore.request(
-        meshPointsVertexAttributeSchemas.color_map,
-        { id, points, minimum, maximum },
+        { schema, params },
         {
           response_function: () =>
             config.setMeshPointsVertexAttributeStoredConfig(id, name, { colorMap }),

package/internal/stores/data_style/mesh/points/visibility.js

@@ -6,7 +6,7 @@ import { useMeshPointsCommonStyle } from "./common";
 import { useViewerStore } from "@ogw_front/stores/viewer";
 
 // Local constants
-const meshPointsVisibilitySchema = viewer_schemas.opengeodeweb_viewer.mesh.points.visibility;
+const schema = viewer_schemas.opengeodeweb_viewer.mesh.points.visibility;
 
 export function useMeshPointsVisibilityStyle() {
   const viewerStore = useViewerStore();
@@ -16,9 +16,12 @@ export function useMeshPointsVisibilityStyle() {
     return meshPointsCommonStyle.meshPointsStyle(id).visibility;
   }
   function setMeshPointsVisibility(id, visibility) {
+    const params = { id, visibility };
     return viewerStore.request(
-      meshPointsVisibilitySchema,
-      { id, visibility },
+      {
+        schema,
+        params,
+      },
       {
         response_function: () => meshPointsCommonStyle.mutateMeshPointsStyle(id, { visibility }),
       },