@geode/opengeodeweb-front 10.34.0-rc.8 → 10.34.0

package/internal/stores/hybrid_viewer/viewport.ts

@@ -1,51 +1,52 @@
-// Not auto-fixable (eslint's sort-imports core rule has no autofixer) and this file's import order doesn't match its syntax-kind-then-alphabetical requirement - left as-is rather than manually reordered across the codebase for a purely cosmetic rule.
-// oxlint-disable eslint/sort-imports
-import type { Ref } from "vue";
+import type { Vector3, ViewStreamLike } from "./vtk_types";
+import { centerCameraOnPosition, useHybridViewerCamera } from "./camera";
 import { Status } from "@ogw_front/utils/status";
 import { WHEEL_TIME_OUT_MS } from "./constants";
-import { centerCameraOnPosition } from "./camera";
-import { useHybridViewerStore } from "@ogw_front/stores/hybrid_viewer";
+import { useHybridViewerCore } from "./core";
+import { useHybridViewerHighlight } from "./highlight";
 import { useViewerStore } from "@ogw_front/stores/viewer";
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json";
-import type { HybridViewerStorePublic, Vector3 } from "./vtk_types";
 
 type ContainerRef = Ref<{ $el: HTMLElement } | undefined>;
 
-// The image stream object returned by vtk.js's ImageStream.createViewStream(); vtk.js's own vtkViewStream type declares `onImageReady` with a zero-arg callback, which doesn't match how it's actually invoked at runtime (with the decoded image), so this describes the shape as it's actually used here.
-interface ViewStreamLike {
-  setSize: (width: number, height: number) => void;
-  onImageReady: (callback: (event: { image: unknown }) => void) => void;
+interface HybridViewerViewport {
+  setContainer: (container: ContainerRef | undefined) => void;
+  resize: (width: number, height: number) => Promise<void>;
+  viewStream: Ref<ViewStreamLike | undefined>;
 }
 
-async function performResize(width: number, height: number): Promise<void> {
-  const hybridViewerStore = useHybridViewerStore();
-  const { genericRenderWindow, remoteRender } =
-    hybridViewerStore as unknown as HybridViewerStorePublic;
-  const { status, viewStream } = storeToRefs(hybridViewerStore) as unknown as {
-    status: Ref<string>;
-    viewStream: Ref<{ setSize: (width: number, height: number) => void } | undefined>;
-  };
+async function resize(width: number, height: number): Promise<void> {
+  const { genericRenderWindow, remoteRender, status, viewStream } = useHybridViewerCore();
   const viewerStore = useViewerStore();
   if (viewerStore.status !== Status.CONNECTED || status.value !== Status.CREATED) {
     return;
   }
-  const webGLRenderWindow = genericRenderWindow.value!.getApiSpecificRenderWindow();
-  const canvas = webGLRenderWindow.getCanvas();
+  const renderWindow = genericRenderWindow.value;
+  if (!renderWindow) {
+    return;
+  }
+  // oxlint-disable-next-line no-unsafe-assignment -- vtk.js has no types for getApiSpecificRenderWindow(); narrowed below.
+  const webGLRenderWindow = renderWindow.getApiSpecificRenderWindow();
+  // oxlint-disable-next-line no-unsafe-type-assertion -- trusted vtk.js OpenGL render window API boundary.
+  const openGLRenderWindow = webGLRenderWindow as unknown as {
+    getCanvas: () => HTMLCanvasElement;
+    setSize: (width: number, height: number) => void;
+  };
+  const canvas = openGLRenderWindow.getCanvas();
   canvas.width = width;
   canvas.height = height;
   await nextTick();
-  webGLRenderWindow.setSize(width, height);
+  openGLRenderWindow.setSize(width, height);
   if (viewStream.value) {
     viewStream.value.setSize(width, height);
   }
-  const renderWindow = genericRenderWindow.value!.getRenderWindow();
-  renderWindow.render();
+  renderWindow.getRenderWindow().render();
   await remoteRender();
 }
 
 function performClickPicking(event: MouseEvent, containerElement: HTMLElement): void {
-  const { genericRenderWindow, syncRemoteCamera } =
-    useHybridViewerStore() as unknown as HybridViewerStorePublic;
+  const { genericRenderWindow } = useHybridViewerCore();
+  const { syncRemoteCamera } = useHybridViewerCamera();
   const viewerStore = useViewerStore();
   const rect = containerElement.getBoundingClientRect();
   const schema = viewer_schemas.opengeodeweb_viewer.viewer.get_point_position;
@@ -53,53 +54,58 @@ function performClickPicking(event: MouseEvent, containerElement: HTMLElement):
     x: Math.round(event.clientX - rect.left),
     y: Math.round(rect.height - (event.clientY - rect.top)),
   };
-  viewerStore.request(
+  void viewerStore.request(
     {
       schema,
       params,
     },
     {
       response_function: (response: unknown) => {
+        // oxlint-disable-next-line no-unsafe-type-assertion -- response shape is defined by the get_point_position schema.
         const { x, y, z } = response as { x: number; y: number; z: number };
         const pickedPos: Vector3 = [x, y, z];
-        if (pickedPos.some((val) => val !== 0)) {
-          const renderer = genericRenderWindow.value!.getRenderer();
-          const camera = renderer.getActiveCamera();
-          centerCameraOnPosition(camera, pickedPos);
-          const renderWindow = genericRenderWindow.value!.getRenderWindow();
-          renderWindow.render();
-          syncRemoteCamera();
+        if (!genericRenderWindow.value || !pickedPos.some((val) => val !== 0)) {
+          return;
         }
+        const renderer = genericRenderWindow.value.getRenderer();
+        const camera = renderer.getActiveCamera();
+        centerCameraOnPosition(camera, pickedPos);
+        genericRenderWindow.value.getRenderWindow().render();
+        syncRemoteCamera();
       },
     },
   );
 }
 
-function performSetContainer(container: ContainerRef | undefined): void {
+function setContainer(container: ContainerRef | undefined): void {
   if (!container || !container.value) {
     return;
   }
-  const hybridViewerStore = useHybridViewerStore();
-  const { genericRenderWindow, syncRemoteCamera, hoverHighlight } =
-    hybridViewerStore as unknown as HybridViewerStorePublic;
-  const { is_picking, is_moving } = storeToRefs(hybridViewerStore) as unknown as {
-    is_picking: Ref<boolean>;
-    is_moving: Ref<boolean>;
+  const containerElement = container.value.$el;
+  const { genericRenderWindow, is_picking, is_moving } = useHybridViewerCore();
+  const { syncRemoteCamera } = useHybridViewerCamera();
+  const { hoverHighlight } = useHybridViewerHighlight();
+  if (!genericRenderWindow.value) {
+    return;
+  }
+  genericRenderWindow.value.setContainer(containerElement);
+  // oxlint-disable-next-line no-unsafe-assignment -- vtk.js has no types for getApiSpecificRenderWindow(); narrowed below.
+  const webGLRenderWindow = genericRenderWindow.value.getApiSpecificRenderWindow();
+  // oxlint-disable-next-line no-unsafe-type-assertion -- trusted vtk.js OpenGL render window API boundary.
+  const openGLRenderWindow = webGLRenderWindow as unknown as {
+    setUseBackgroundImage: (value: boolean) => void;
+    getReferenceByName: (name: string) => { style: CSSStyleDeclaration } | undefined;
   };
-  genericRenderWindow.value!.setContainer(container.value.$el);
-  const webGLRenderWindow = genericRenderWindow.value!.getApiSpecificRenderWindow();
-  webGLRenderWindow.setUseBackgroundImage(true);
-  const imageStyle = webGLRenderWindow.getReferenceByName("bgImage")?.style as
-    | CSSStyleDeclaration
-    | undefined;
+  openGLRenderWindow.setUseBackgroundImage(true);
+  const imageStyle = openGLRenderWindow.getReferenceByName("bgImage")?.style;
   Object.assign(imageStyle ?? {}, {
     transition: "opacity 0.1s ease-in",
     zIndex: 1,
   });
-  performResize(container.value.$el.offsetWidth, container.value.$el.offsetHeight);
+  void resize(containerElement.offsetWidth, containerElement.offsetHeight);
   let has_dragged = false;
   useMousePressed({
-    target: container as never,
+    target: containerElement,
     onPressed: (event: MouseEvent | TouchEvent | DragEvent) => {
       if (!(event instanceof MouseEvent)) {
         return;
@@ -108,7 +114,7 @@ function performSetContainer(container: ContainerRef | undefined): void {
         return;
       }
       if (event.button === 0 && is_picking.value) {
-        performClickPicking(event, container.value!.$el);
+        performClickPicking(event, containerElement);
         is_picking.value = false;
         return;
       }
@@ -118,25 +124,31 @@ function performSetContainer(container: ContainerRef | undefined): void {
     },
     onReleased: () => {
       is_moving.value = false;
-      if (has_dragged) {
-        const renderer = genericRenderWindow.value!.getRenderer();
+      if (has_dragged && genericRenderWindow.value) {
+        const renderer = genericRenderWindow.value.getRenderer();
         renderer.resetCameraClippingRange();
         syncRemoteCamera();
       }
       has_dragged = false;
     },
   });
-  useEventListener(container as never, "mousemove", (event: MouseEvent) => {
+  useEventListener(containerElement, "mousemove", (event: MouseEvent) => {
     if (is_moving.value) {
       has_dragged = true;
       if (imageStyle) {
         imageStyle.opacity = "0";
       }
     }
-    hoverHighlight(event);
+    void (async (): Promise<void> => {
+      try {
+        await hoverHighlight(event);
+      } catch {
+        // Ignore hover highlight failures
+      }
+    })();
   });
   let wheelEventEndTimeout: ReturnType<typeof setTimeout> | undefined = undefined;
-  useEventListener(container as never, "wheel", () => {
+  useEventListener(containerElement, "wheel", () => {
     is_moving.value = true;
     if (imageStyle) {
       imageStyle.opacity = "0";
@@ -144,25 +156,22 @@ function performSetContainer(container: ContainerRef | undefined): void {
     clearTimeout(wheelEventEndTimeout);
     wheelEventEndTimeout = setTimeout(() => {
       is_moving.value = false;
-      const renderer = genericRenderWindow.value!.getRenderer();
+      if (!genericRenderWindow.value) {
+        return;
+      }
+      const renderer = genericRenderWindow.value.getRenderer();
       renderer.resetCameraClippingRange();
       syncRemoteCamera();
     }, WHEEL_TIME_OUT_MS);
   });
 }
-function useHybridViewerViewport() {
-  const viewStream = ref<ViewStreamLike | undefined>(undefined);
-  function setContainer(container: ContainerRef | undefined): void {
-    performSetContainer(container);
-  }
-  async function resize(width: number, height: number): Promise<void> {
-    await performResize(width, height);
-  }
+function useHybridViewerViewport(): HybridViewerViewport {
+  const { viewStream } = useHybridViewerCore();
   return {
     setContainer,
     resize,
     viewStream,
   };
 }
-export { performClickPicking, performResize, performSetContainer, useHybridViewerViewport };
-export type { ViewStreamLike };
+export { performClickPicking, useHybridViewerViewport };
+export type { ViewStreamLike } from "./vtk_types";

package/internal/stores/hybrid_viewer/vtk_types.ts

@@ -1,14 +1,5 @@
-// Not auto-fixable (eslint's sort-imports core rule has no autofixer) and this file's import order doesn't match its syntax-kind-then-alphabetical requirement - left as-is rather than manually reordered across the codebase for a purely cosmetic rule.
-// This file's imported vtk.js types are also used locally (CameraOptions, HybridDbEntry, HybridViewerStorePublic reference them directly), not just re-exported, so they can't become pure `export ... from "...";` re-exports without losing the local binding these interfaces need.
-// oxlint-disable eslint/sort-imports, unicorn/prefer-export-from
-// Re-exports of vtk.js's own (real, shipped) TypeScript types for the objects the hybrid viewer store composables interact with, plus the handful of shapes that are specific to this codebase (CameraOptions' snake_case wire format, the local hybridDb map, hover highlight data, ...).
-import type { vtkCamera } from "@kitware/vtk.js/Rendering/Core/Camera";
-import type { vtkRenderer } from "@kitware/vtk.js/Rendering/Core/Renderer";
-import type { vtkRenderWindow } from "@kitware/vtk.js/Rendering/Core/RenderWindow";
-import type { vtkGenericRenderWindow } from "@kitware/vtk.js/Rendering/Misc/GenericRenderWindow";
-import type { vtkOpenGLRenderWindow } from "@kitware/vtk.js/Rendering/OpenGL/RenderWindow";
-import type vtkActor from "@kitware/vtk.js/Rendering/Core/Actor";
 import type { Vector3 } from "@kitware/vtk.js/types";
+import type vtkActor from "@kitware/vtk.js/Rendering/Core/Actor";
 
 // The camera state as exchanged with the viewer microservice (snake_case field names, plain arrays) - distinct from vtk.js's own vtkCamera object.
 interface CameraOptions {
@@ -44,31 +35,24 @@ interface HoverData {
   attributes: Record<string, unknown>;
 }
 
-// The parent Pinia store (app/stores/hybrid_viewer.ts) assembles these composables via `...spread` and is converted/typed separately from this directory, so its exact inferred return type isn't reliable to build on here. This describes just the slice of its returned (already-unwrapped) state and actions that the composables in this folder read or call directly (i.e. not through `storeToRefs`, which callers type separately at each destructuring site).
-interface HybridViewerStorePublic {
-  genericRenderWindow: { value: vtkGenericRenderWindow | undefined };
-  hybridDb: HybridDb;
-  camera_options: Record<string, unknown>;
-  remoteRender: () => Promise<void> | void;
-  clearHoverHighlight: () => void;
-  syncRemoteCamera: () => void;
-  hoverHighlight: (event: MouseEvent) => void;
-  setZScaling: (value: number) => Promise<void>;
-  setCamera: (options: CameraOptions) => void;
+// The image stream object returned by vtk.js's ImageStream.createViewStream(); vtk.js's own vtkViewStream type declares `onImageReady` with a zero-arg callback, which doesn't match how it's actually invoked at runtime (with the decoded image), so this describes the shape as it's actually used here.
+interface ViewStreamLike {
+  setSize: (width: number, height: number) => void;
+  onImageReady: (callback: (event: { image: unknown }) => void) => void;
 }
 
+export type { Vector3 } from "@kitware/vtk.js/types";
+export type { default as vtkActor } from "@kitware/vtk.js/Rendering/Core/Actor";
+export type { vtkCamera } from "@kitware/vtk.js/Rendering/Core/Camera";
+export type { vtkGenericRenderWindow } from "@kitware/vtk.js/Rendering/Misc/GenericRenderWindow";
+export type { vtkOpenGLRenderWindow } from "@kitware/vtk.js/Rendering/OpenGL/RenderWindow";
+export type { vtkRenderWindow } from "@kitware/vtk.js/Rendering/Core/RenderWindow";
+export type { vtkRenderer } from "@kitware/vtk.js/Rendering/Core/Renderer";
 export type {
-  vtkCamera,
-  vtkRenderer,
-  vtkRenderWindow,
-  vtkGenericRenderWindow,
-  vtkOpenGLRenderWindow,
-  vtkActor,
-  Vector3,
   CameraOptions,
   HybridDbEntry,
   HybridDb,
   HoverComponentInfo,
   HoverData,
-  HybridViewerStorePublic,
+  ViewStreamLike,
 };

package/internal/utils/api_fetch.ts

@@ -1,9 +1,7 @@
-// Not auto-fixable (eslint's sort-imports core rule has no autofixer) and this file's import order doesn't match its syntax-kind-then-alphabetical requirement - left as-is rather than manually reordered across the codebase for a purely cosmetic rule.
-// oxlint-disable eslint/sort-imports
+import type { JsonRpcSchema, RequestHandlersWithValidation } from "@ogw_shared/utils/types.js";
 import { endRequestLog, startRequestLog } from "@ogw_front/utils/log";
 import { fetchSchema } from "@ogw_shared/utils/fetch_schema";
 import { useFeedbackStore } from "@ogw_front/stores/feedback";
-import type { JsonRpcSchema, RequestHandlersWithValidation } from "@ogw_shared/utils/types.js";
 
 // The microservice-backed Pinia stores (back/app/...) all expose this shape; only the slice actually used here needs to be declared.
 interface Microservice {
@@ -33,7 +31,34 @@ interface FetchErrorResponseLike {
   description?: string;
 }
 
-function api_fetch(
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}
+
+function toFetchErrorLike(error: unknown): FetchErrorLike {
+  if (!isRecord(error)) {
+    return {};
+  }
+  return {
+    code: typeof error.code === "number" ? error.code : undefined,
+    message: typeof error.message === "string" ? error.message : undefined,
+    stack: typeof error.stack === "string" ? error.stack : undefined,
+  };
+}
+
+function toFetchErrorResponseLike(response: unknown): FetchErrorResponseLike {
+  if (!isRecord(response)) {
+    return {};
+  }
+  return {
+    status: typeof response.status === "number" ? response.status : undefined,
+    name: typeof response.name === "string" ? response.name : undefined,
+    description: typeof response.description === "string" ? response.description : undefined,
+  };
+}
+
+// oxlint-disable-next-line max-lines-per-function
+async function api_fetch(
   microservice: Microservice,
   { schema, params = {}, headers = {} }: ApiFetchParams,
   {
@@ -41,14 +66,15 @@ function api_fetch(
     response_function,
     response_error_function,
     timeout,
-  }: RequestHandlersWithValidation & { timeout?: number } = {},
-) {
+    skip_feedback_error,
+  }: RequestHandlersWithValidation & { timeout?: number; skip_feedback_error?: boolean } = {},
+): Promise<unknown> {
   console.log("[API] Fetching", microservice.base_url);
   const feedbackStore = useFeedbackStore();
   microservice.start_request();
 
   const requestStartingTime = startRequestLog(microservice, schema);
-  return fetchSchema(
+  const result = await fetchSchema(
     {
       schema,
       params,
@@ -59,15 +85,17 @@ function api_fetch(
     {
       request_error_function(error: unknown) {
         microservice.stop_request();
-        const typedError = error as FetchErrorLike;
-        feedbackStore.add_error(
-          typedError.code ?? 0,
-          schema.$id,
-          typedError.message ?? "",
-          typedError.stack ?? "",
-        );
+        const typedError = toFetchErrorLike(error);
+        if (skip_feedback_error !== true) {
+          feedbackStore.add_error(
+            typedError.code ?? 0,
+            schema.$id,
+            typedError.message ?? "",
+            typedError.stack ?? "",
+          );
+        }
         if (request_error_function) {
-          request_error_function(error);
+          void request_error_function(error);
         }
       },
       response_function(data: unknown) {
@@ -79,15 +107,17 @@ function api_fetch(
       },
       response_error_function(response: unknown) {
         microservice.stop_request();
-        const typedResponse = response as FetchErrorResponseLike;
-        feedbackStore.add_error(
-          typedResponse.status ?? 0,
-          schema.$id,
-          typedResponse.name ?? "",
-          typedResponse.description ?? "",
-        );
+        const typedResponse = toFetchErrorResponseLike(response);
+        if (skip_feedback_error !== true) {
+          feedbackStore.add_error(
+            typedResponse.status ?? 0,
+            schema.$id,
+            typedResponse.name ?? "",
+            typedResponse.description ?? "",
+          );
+        }
         if (response_error_function) {
-          response_error_function(response);
+          void response_error_function(response);
         }
       },
       validation_error_function({ code, name, error }) {
@@ -96,6 +126,7 @@ function api_fetch(
       },
     },
   );
+  return result;
 }
 
 export { api_fetch };

package/internal/utils/upload_file.ts

@@ -1,16 +1,15 @@
-// Not auto-fixable (eslint's sort-imports core rule has no autofixer) and this file's import order doesn't match its syntax-kind-then-alphabetical requirement - left as-is rather than manually reordered across the codebase for a purely cosmetic rule.
-// oxlint-disable eslint/sort-imports
-import { fetchRaw } from "@ogw_shared/utils/fetch_raw.js";
-import { useFeedbackStore } from "@ogw_front/stores/feedback.js";
 import type { JsonRpcSchema, RequestHandlers } from "@ogw_shared/utils/types.js";
+import { CHUNK_SIZE_BYTES } from "@ogw_shared/utils/file.js";
 import type { Microservice } from "./api_fetch.js";
+import { fetchRaw } from "@ogw_shared/utils/fetch_raw.js";
+import { useFeedbackStore } from "@ogw_front/stores/feedback.js";
 
 interface UploadFileParams {
   // Always forwarded to fetchRaw via schema.methods, which is only ever set on
   // HTTP-flavored ("front"/"back") schemas.
   schema: JsonRpcSchema & { methods: string[] };
   file: File;
-  params?: Record<string, string | Blob>;
+  params?: Record<string, string>;
 }
 
 // Loosely-typed shapes for the dynamic error/response values reported by fetchRaw.
@@ -26,69 +25,91 @@ interface FetchErrorResponseLike {
   description?: string;
 }
 
-function upload_file(
+function isFetchErrorLike(value: unknown): value is FetchErrorLike {
+  return typeof value === "object" && value !== null;
+}
+
+function isFetchErrorResponseLike(value: unknown): value is FetchErrorResponseLike {
+  return typeof value === "object" && value !== null;
+}
+
+async function upload_file(
   microservice: Microservice,
   { schema, file, params = {} }: UploadFileParams,
   { request_error_function, response_function, response_error_function }: RequestHandlers = {},
-) {
+): Promise<unknown> {
   console.log("[UPLOAD_FILE] Uploading file", { schema, file });
   const feedbackStore = useFeedbackStore();
 
   if (!(file instanceof File)) {
-    return Promise.reject(new Error("file must be an instance of File"));
+    throw new Error("file must be an instance of File");
   }
 
-  const body = new FormData();
-  for (const [key, value] of Object.entries(params)) {
-    body.append(key, value);
+  const route = schema.$id;
+  const method = schema.methods.find((candidate) => candidate !== "OPTIONS");
+  const totalChunks = Math.max(1, Math.ceil(file.size / CHUNK_SIZE_BYTES));
+
+  function onRequestError(error: unknown): void {
+    microservice.stop_request();
+    const typedError = isFetchErrorLike(error) ? error : {};
+    feedbackStore.add_error(
+      typedError.code ?? 0,
+      route,
+      typedError.message ?? "",
+      typedError.stack ?? "",
+    );
+    if (request_error_function) {
+      void request_error_function(error);
+    }
+  }
+
+  function onResponseError(response: unknown): void {
+    microservice.stop_request();
+    const typedResponse = isFetchErrorResponseLike(response) ? response : {};
+    feedbackStore.add_error(
+      typedResponse.status ?? 0,
+      route,
+      typedResponse.name ?? "",
+      typedResponse.description ?? "",
+    );
+    if (response_error_function) {
+      void response_error_function(response);
+    }
   }
-  body.append("file", file);
 
   microservice.start_request();
-  const route = schema.$id;
 
-  return fetchRaw(
-    {
-      route,
-      method: schema.methods.find((method) => method !== "OPTIONS"),
-      params: body,
-      baseURL: microservice.base_url,
-    },
-    {
-      request_error_function(error: unknown) {
-        microservice.stop_request();
-        const typedError = error as FetchErrorLike;
-        feedbackStore.add_error(
-          typedError.code ?? 0,
-          route,
-          typedError.message ?? "",
-          typedError.stack ?? "",
-        );
-        if (request_error_function) {
-          request_error_function(error);
-        }
-      },
-      response_function(data: unknown) {
-        microservice.stop_request();
-        if (response_function) {
-          response_function(data);
-        }
+  let result: unknown = undefined;
+  for (let chunkIndex = 0; chunkIndex < totalChunks; chunkIndex += 1) {
+    const start = chunkIndex * CHUNK_SIZE_BYTES;
+    const chunk = file.slice(start, start + CHUNK_SIZE_BYTES);
+    const query = new URLSearchParams({
+      ...params,
+      filename: file.name,
+      chunk_index: String(chunkIndex),
+      total_chunks: String(totalChunks),
+    });
+
+    // oxlint-disable-next-line no-await-in-loop -- chunks must be sent in order; the server appends each one to the file as it arrives.
+    result = await fetchRaw(
+      {
+        route: `${route}?${query.toString()}`,
+        method,
+        params: chunk,
+        baseURL: microservice.base_url,
       },
-      response_error_function(response: unknown) {
-        microservice.stop_request();
-        const typedResponse = response as FetchErrorResponseLike;
-        feedbackStore.add_error(
-          typedResponse.status ?? 0,
-          route,
-          typedResponse.name ?? "",
-          typedResponse.description ?? "",
-        );
-        if (response_error_function) {
-          response_error_function(response);
-        }
+      {
+        request_error_function: onRequestError,
+        response_error_function: onResponseError,
       },
-    },
-  );
+    );
+  }
+
+  microservice.stop_request();
+  if (response_function) {
+    response_function(result);
+  }
+  return result;
 }
 
 export { upload_file };