@geode/opengeodeweb-front 10.34.0-rc.2 → 10.34.0-rc.21

package/internal/utils/api_fetch.ts

@@ -0,0 +1,133 @@
+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";
+
+// The microservice-backed Pinia stores (back/app/...) all expose this shape; only the slice actually used here needs to be declared.
+interface Microservice {
+  $id: string;
+  base_url: string;
+  start_request: () => void;
+  stop_request: () => void;
+}
+
+interface ApiFetchParams {
+  // This function always forwards this schema to fetchSchema, which requires the HTTP-flavored `methods` array (as opposed to the websocket `rpc` field).
+  schema: JsonRpcSchema & { methods: string[] };
+  params?: Record<string, unknown>;
+  headers?: Record<string, string>;
+}
+
+// Loosely-typed shapes for the dynamic error/response values reported by fetchSchema.
+interface FetchErrorLike {
+  code?: number;
+  message?: string;
+  stack?: string;
+}
+
+interface FetchErrorResponseLike {
+  status?: number;
+  name?: string;
+  description?: string;
+}
+
+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,
+  {
+    request_error_function,
+    response_function,
+    response_error_function,
+    timeout,
+    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);
+  const result = await fetchSchema(
+    {
+      schema,
+      params,
+      baseURL: microservice.base_url,
+      headers,
+      timeout,
+    },
+    {
+      request_error_function(error: unknown) {
+        microservice.stop_request();
+        const typedError = toFetchErrorLike(error);
+        if (!skip_feedback_error) {
+          feedbackStore.add_error(
+            typedError.code ?? 0,
+            schema.$id,
+            typedError.message ?? "",
+            typedError.stack ?? "",
+          );
+        }
+        if (request_error_function) {
+          request_error_function(error);
+        }
+      },
+      response_function(data: unknown) {
+        endRequestLog(microservice, schema, requestStartingTime);
+        microservice.stop_request();
+        if (response_function) {
+          response_function(data);
+        }
+      },
+      response_error_function(response: unknown) {
+        microservice.stop_request();
+        const typedResponse = toFetchErrorResponseLike(response);
+        if (!skip_feedback_error) {
+          feedbackStore.add_error(
+            typedResponse.status ?? 0,
+            schema.$id,
+            typedResponse.name ?? "",
+            typedResponse.description ?? "",
+          );
+        }
+        if (response_error_function) {
+          response_error_function(response);
+        }
+      },
+      validation_error_function({ code, name, error }) {
+        microservice.stop_request();
+        feedbackStore.add_error(code, schema.$id, name, error ?? "");
+      },
+    },
+  );
+  return result;
+}
+
+export { api_fetch };
+export type { Microservice };

package/internal/utils/upload_file.ts

@@ -0,0 +1,115 @@
+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>;
+}
+
+// Loosely-typed shapes for the dynamic error/response values reported by fetchRaw.
+interface FetchErrorLike {
+  code?: number;
+  message?: string;
+  stack?: string;
+}
+
+interface FetchErrorResponseLike {
+  status?: number;
+  name?: string;
+  description?: string;
+}
+
+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)) {
+    throw new Error("file must be an instance of File");
+  }
+
+  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) {
+      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) {
+      response_error_function(response);
+    }
+  }
+
+  microservice.start_request();
+
+  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,
+      },
+      {
+        request_error_function: onRequestError,
+        response_error_function: onResponseError,
+      },
+    );
+  }
+
+  microservice.stop_request();
+  if (response_function) {
+    response_function(result);
+  }
+  return result;
+}
+
+export { upload_file };

package/internal/utils/viewer_call.ts

@@ -0,0 +1,99 @@
+import type { JsonRpcSchema, RequestHandlersWithValidation } from "@ogw_shared/utils/types.js";
+import { endRequestLog, startRequestLog } from "@ogw_front/utils/log";
+import type { Microservice } from "./api_fetch.js";
+import type { RpcClient } from "@ogw_shared/utils/call_raw.js";
+import { callSchema } from "@ogw_shared/utils/call_schema";
+import { useFeedbackStore } from "@ogw_front/stores/feedback";
+
+interface ViewerMicroservice extends Microservice {
+  client: RpcClient;
+}
+
+interface ViewerCallParams {
+  schema: JsonRpcSchema;
+  params?: Record<string, unknown>;
+  timeout?: number;
+}
+
+// Loosely-typed shape for the dynamic error/response values reported by callSchema.
+interface RpcErrorLike {
+  code?: number;
+  message?: string;
+}
+
+function toRpcErrorLike(value: unknown): RpcErrorLike {
+  if (typeof value !== "object" || value === null) {
+    return {};
+  }
+  return {
+    code: "code" in value && typeof value.code === "number" ? value.code : undefined,
+    message: "message" in value && typeof value.message === "string" ? value.message : undefined,
+  };
+}
+
+async function viewer_call(
+  microservice: ViewerMicroservice,
+  { schema, params = {}, timeout }: ViewerCallParams,
+  {
+    request_error_function,
+    response_function,
+    response_error_function,
+  }: RequestHandlersWithValidation = {},
+): Promise<unknown> {
+  const feedbackStore = useFeedbackStore();
+  const { client } = microservice;
+  microservice.start_request();
+
+  const requestStartingTime = startRequestLog(microservice, schema);
+  const result = await callSchema(
+    {
+      schema,
+      params,
+      client,
+      timeout,
+    },
+    {
+      request_error_function(error: unknown) {
+        microservice.stop_request();
+        const typedError = toRpcErrorLike(error);
+        feedbackStore.add_error(
+          typedError.code ?? 0,
+          schema.$id,
+          typedError.message ?? "",
+          typedError.message ?? "",
+        );
+        if (request_error_function) {
+          request_error_function(error);
+        }
+      },
+      response_function(data: unknown) {
+        endRequestLog(microservice, schema, requestStartingTime);
+        microservice.stop_request();
+        if (response_function) {
+          response_function(data);
+        }
+      },
+      response_error_function(response: unknown) {
+        microservice.stop_request();
+        const typedResponse = toRpcErrorLike(response);
+        feedbackStore.add_error(
+          typedResponse.code ?? 0,
+          schema.$id,
+          typedResponse.message ?? "",
+          typedResponse.message ?? "",
+        );
+        if (response_error_function) {
+          response_error_function(response);
+        }
+      },
+      validation_error_function({ code, name, error }) {
+        microservice.stop_request();
+        feedbackStore.add_error(code, schema.$id, name, error ?? "");
+      },
+    },
+  );
+  return result;
+}
+
+export { viewer_call };
+export type { ViewerMicroservice };

package/internal/utils/ws_client.ts

@@ -0,0 +1,54 @@
+// Third party imports
+import vtkWSLinkClient, {
+  type vtkWSLinkClient as VtkWSLinkClient,
+  newInstance,
+} from "@kitware/vtk.js/IO/Core/WSLinkClient";
+import SmartConnect from "wslink/src/SmartConnect";
+
+interface WsClientCallbacks {
+  onConnectionClose?: () => void;
+}
+
+// Wslink's connection event shape is untyped upstream; this describes the fields we read.
+interface WsConnectionEvent {
+  response?: { error?: string };
+}
+
+function isVtkWSLinkClient(value: unknown): value is VtkWSLinkClient {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    "connect" in value &&
+    "onConnectionError" in value &&
+    "onConnectionClose" in value
+  );
+}
+
+async function initWebSocketClient(
+  baseUrl: string,
+  initialClient: unknown = {},
+  { onConnectionClose }: WsClientCallbacks = {},
+): Promise<VtkWSLinkClient> {
+  vtkWSLinkClient.setSmartConnectClass(SmartConnect);
+  const client = isVtkWSLinkClient(initialClient) ? initialClient : newInstance();
+
+  client.onConnectionError((httpReq: WsConnectionEvent) => {
+    const message = httpReq.response?.error ?? "Connection error";
+    console.error(message);
+  });
+  client.onConnectionClose((httpReq: WsConnectionEvent) => {
+    const message = httpReq.response?.error ?? "Connection close";
+    onConnectionClose?.();
+    console.error(message);
+  });
+
+  client.beginBusy();
+  await client.connect({
+    application: "Viewer",
+    sessionURL: baseUrl,
+  });
+
+  return client;
+}
+
+export { initWebSocketClient };

package/nuxt.config.ts

@@ -0,0 +1,168 @@
+// Node imports
+import fs from "node:fs";
+import path from "node:path";
+
+// Third party imports
+import { defineNuxtConfig } from "nuxt/config";
+
+// Local imports
+import package_json from "./package.json";
+
+const __dirname = import.meta.dirname;
+
+// Oxlint's type-aware linter auto-discovers each file's nearest tsconfig.json
+// By walking up directories, and any "extends" on that discovered file makes
+// Its whole type-aware resolution collapse: every symbol coming through the
+// Aliases normally only defined in .nuxt/tsconfig.json (@ogw_shared, etc.,
+// But also Nuxt's own #app/#imports/defineStore auto-imports) becomes an
+// `error` type, even though tsc/vue-tsc resolve the exact same "extends"
+// Chain correctly (oxc-project/oxc#22345). The only fix is for the root
+// Tsconfig.json to be fully self-contained: no "extends", with its own copy
+// Of .nuxt/tsconfig.json's compilerOptions.paths (re-relativized here, since
+// They're written relative to .nuxt/) and a deliberately project-wide
+// "include" (unlike .nuxt/tsconfig.json's own include, which only covers
+// Nuxt's conventional folders and would otherwise silently drop internal/,
+// Tests/, etc. from the program). Regenerated on every Nuxt prepare so it
+// Can never drift from what Nuxt actually resolves.
+function remap_path_to_root(target: string, build_dir: string): string {
+  const relative = path
+    .relative(__dirname, path.resolve(build_dir, target))
+    .split(path.sep)
+    .join("/");
+  return relative.startsWith("./") || relative.startsWith("../") ? relative : `./${relative}`;
+}
+
+// Nuxt requires this file's config object as the default export; the shared org lint config's no-default-export override only lists *.config.js, not *.config.ts, since this file predates the TypeScript migration.
+// oxlint-disable-next-line import/no-default-export
+export default defineNuxtConfig({
+  runtimeConfig: {
+    public: {
+      COMMAND_BACK: "opengeodeweb-back",
+      COMMAND_VIEWER: "opengeodeweb-viewer",
+      NUXT_ROOT_PATH: __dirname,
+      MODE: process.env.MODE ?? "CLOUD",
+      PROJECT: package_json.name,
+    },
+  },
+
+  modules: [
+    "vuetify-nuxt-module",
+    ["@pinia/nuxt", { autoImports: ["defineStore", "storeToRefs"] }],
+    "@vueuse/nuxt",
+  ],
+  imports: {
+    scan: false,
+  },
+
+  ssr: false,
+
+  alias: {
+    "@ogw_front": path.resolve(__dirname, "app"),
+    "@ogw_internal": path.resolve(__dirname, "internal"),
+    "@ogw_tests": path.resolve(__dirname, "tests"),
+    "@ogw_shared": path.resolve(__dirname, "shared"),
+    "@ogw_server": path.resolve(__dirname, "server"),
+  },
+
+  // ** Global CSS
+  css: ["vuetify/lib/styles/main.sass", path.resolve(__dirname, "app/assets/css/main.css")],
+
+  // ** Build configuration
+  build: {
+    transpile: ["vuetify"],
+  },
+
+  vuetify: {
+    moduleOptions: {
+      prefixComposables: true,
+      enableRules: false,
+      rulesConfiguration: {
+        fromLabs: false,
+      },
+    },
+    vuetifyOptions: {
+      defaults: {
+        VTooltip: {
+          openDelay: 500,
+        },
+      },
+    },
+  },
+
+  vue: {
+    compilerOptions: {
+      isCustomElement: (tag: string) => ["md-linedivider"].includes(tag),
+    },
+  },
+
+  vite: {
+    optimizeDeps: {
+      include: [
+        "@kitware/vtk.js",
+        "@kitware/vtk.js/Common/Core/Math",
+        "@kitware/vtk.js/IO/Core/WSLinkClient",
+        "@kitware/vtk.js/IO/XML/XMLPolyDataReader",
+        "@kitware/vtk.js/Rendering/Core/Actor",
+        "@kitware/vtk.js/Rendering/Core/AnnotatedCubeActor",
+        "@kitware/vtk.js/Rendering/Core/ColorTransferFunction",
+        "@kitware/vtk.js/Rendering/Core/Mapper",
+        "@kitware/vtk.js/Rendering/Misc/GenericRenderWindow",
+        "@kitware/vtk.js/Rendering/Misc/RemoteView",
+        "@kitware/vtk.js/Rendering/OpenGL/Profiles/Geometry",
+        "@kitware/vtk.js/Widgets/Core/WidgetManager",
+        "@kitware/vtk.js/Widgets/Widgets3D/ImplicitPlaneWidget",
+        "@vue/devtools-core",
+        "@vue/devtools-kit",
+        "ajv",
+        "broadcast-channel",
+        "dexie",
+        "globalthis",
+        "h3",
+        "js-file-download",
+        "lodash",
+        "lodash/merge",
+        "p-timeout",
+        "seedrandom",
+        "spark-md5",
+        "uuid",
+        "wslink",
+        "wslink/src/SmartConnect",
+        "xmlbuilder2",
+      ],
+    },
+  },
+  typescript: {
+    tsConfig: {
+      compilerOptions: {
+        types: ["node", "ws", "busboy"],
+      },
+    },
+  },
+
+  hooks: {
+    "prepare:types": ({ tsConfig }) => {
+      const paths = tsConfig.compilerOptions?.paths;
+      if (!paths) {
+        return;
+      }
+      const build_dir = path.resolve(__dirname, ".nuxt");
+      const root_paths = Object.fromEntries(
+        Object.entries(paths).map(([alias, targets]) => [
+          alias,
+          targets.map((target) => remap_path_to_root(target, build_dir)),
+        ]),
+      );
+      fs.writeFileSync(
+        path.resolve(__dirname, "tsconfig.json"),
+        `${JSON.stringify(
+          {
+            compilerOptions: { ...tsConfig.compilerOptions, paths: root_paths },
+            include: ["**/*", "./.nuxt/nuxt.d.ts"],
+          },
+          undefined,
+          2,
+        )}\n`,
+      );
+    },
+  },
+});

package/opengeodeweb_front_schemas.json

@@ -183,8 +183,8 @@
           "additionalProperties": false
         },
         "get_is_app_ready": {
-          "$id": "api/microservice/app/api/microservice/app/get_is_app_ready",
-          "route": "/api/microservice/app/get_is_app_ready",
+          "$id": "api/microservice/app/get_is_app_ready",
+          "route": "/get_is_app_ready",
           "methods": ["GET"],
           "type": "object",
           "properties": {},