@geode/opengeodeweb-front 10.35.0 → 10.36.0-rc.2

package/app/stores/app.ts

@@ -8,10 +8,15 @@ import { upload_file } from "@ogw_internal/utils/upload_file.js";
 import { useAppExtensions } from "./app_helpers/extension.js";
 import { useInfraStore } from "@ogw_front/stores/infra";
 
-import type { JsonRpcSchema, RequestHandlers } from "@ogw_shared/utils/types.js";
+import type {
+  JsonRpcSchema,
+  ParamsOf,
+  RequestHandlers,
+  ResponseOf,
+} from "@ogw_shared/utils/types.js";
 import type { StateTree } from "pinia";
 
-import opengeodeweb_front_schemas from "@geode/opengeodeweb-front/opengeodeweb_front_schemas.json" with { type: "json" };
+import opengeodeweb_front_schemas from "@geode/opengeodeweb-front/opengeodeweb_front_typed_schemas.js";
 
 // The `share` defineStore option (used by every store in this codebase) is implemented by a runtime pinia plugin outside this package's type surface; this augmentation only teaches the type checker about the option shape already used at each defineStore call site.
 declare module "pinia" {
@@ -170,29 +175,30 @@ export const useAppStore = defineStore("app", () => {
     return result;
   }
 
-  // `TResult` is asserted, not verified, at the single `return result as TResult` boundary below: the backend response is only checked against `schema` at runtime, so callers' `TResult` is a contract with the schema, not something this function can prove.
+  // The response type comes from the schema's generated `response` type, asserted at the single `as ResponseOf<Schema>` boundary below: the server checks its responses against that schema outside production.
   // oxlint-disable-next-line unicorn/consistent-function-scoping
-  // oxlint-disable-next-line unicorn/consistent-function-scoping
-  async function request<TResult = unknown>(
-    { schema, params }: { schema: JsonRpcSchema; params?: Record<string, unknown> },
-    callbacks: RequestHandlers = {},
-  ): Promise<TResult> {
+  async function request<Schema extends JsonRpcSchema>(
+    { schema, params }: { schema: Schema; params?: ParamsOf<Schema> },
+    callbacks: RequestHandlers<ResponseOf<Schema>> = {},
+  ): Promise<ResponseOf<Schema>> {
+    const rpc_schema: JsonRpcSchema = schema;
     const result = await api_fetch(
       { $id: "app", base_url: base_url.value, start_request, stop_request },
       // The app store is only ever used with HTTP ("front") schemas, which always carry `methods`; the wider JsonRpcSchema param above is kept as-is to match this action's public signature (e.g. relayed from get_version-style callers that only know about the shared, looser schema shape).
       // oxlint-disable-next-line no-unsafe-type-assertion -- narrowing optional `methods` to required is safe here; see comment above.
-      { schema: schema as JsonRpcSchema & { methods: string[] }, params },
+      { schema: rpc_schema as JsonRpcSchema & { methods: string[] }, params: params ?? {} },
       {
         ...callbacks,
         response_function: async (response: unknown) => {
           if (callbacks.response_function) {
-            await callbacks.response_function(response);
+            // oxlint-disable-next-line no-unsafe-type-assertion -- this is the trusted API boundary; see comment above.
+            await callbacks.response_function(response as ResponseOf<Schema>);
           }
         },
       },
     );
     // oxlint-disable-next-line no-unsafe-type-assertion -- this is the trusted API boundary; see comment above.
-    return result as TResult;
+    return result as ResponseOf<Schema>;
   }
 
   const projectFolderPath = ref("");
@@ -204,12 +210,8 @@ export const useAppStore = defineStore("app", () => {
     const result = await request(
       { schema, params },
       {
-        response_function: (response: unknown) => {
-          // oxlint-disable-next-line no-unsafe-type-assertion
-          const { projectFolderPath: newProjectFolderPath } = response as {
-            projectFolderPath: string;
-          };
-          projectFolderPath.value = newProjectFolderPath;
+        response_function: (response) => {
+          projectFolderPath.value = response.projectFolderPath;
         },
       },
     );

package/app/stores/back.ts

@@ -1,15 +1,20 @@
 import { getRestApiPort, getRestApiProtocol, isCloudMode } from "@ogw_front/utils/stores";
 import { Status } from "@ogw_front/utils/status";
 import { api_fetch } from "@ogw_internal/utils/api_fetch";
-import back_schemas from "@geode/opengeodeweb-back/opengeodeweb_back_schemas.json";
+import back_schemas from "@geode/opengeodeweb-back/opengeodeweb_back_typed_schemas.js";
 import { upload_file } from "@ogw_internal/utils/upload_file.js";
 import { useAppStore } from "@ogw_front/stores/app";
 import { useFeedbackStore } from "@ogw_front/stores/feedback";
 import { useInfraStore } from "@ogw_front/stores/infra";
 
-import type { JsonRpcSchema, RequestHandlers } from "@ogw_shared/utils/types.js";
+import type {
+  JsonRpcSchema,
+  ParamsOf,
+  RequestHandlers,
+  ResponseOf,
+} from "@ogw_shared/utils/types.js";
 
-import opengeodeweb_front_schemas from "@geode/opengeodeweb-front/opengeodeweb_front_schemas.json" with { type: "json" };
+import opengeodeweb_front_schemas from "@geode/opengeodeweb-front/opengeodeweb_front_typed_schemas.js";
 
 const MILLISECONDS_IN_SECOND = 1000;
 const DEFAULT_PING_INTERVAL_SECONDS = 10;
@@ -81,7 +86,7 @@ export const useBackStore = defineStore("back", {
     stop_request() {
       this.request_counter -= 1;
     },
-    async launch(args: Record<string, unknown>) {
+    async launch(args: { projectFolderPath: string }) {
       const appStore = useAppStore();
       const { COMMAND_BACK, NUXT_ROOT_PATH } = useRuntimeConfig().public;
       const schema = opengeodeweb_front_schemas.api.local.app.run_back;
@@ -90,15 +95,8 @@ export const useBackStore = defineStore("back", {
       const result = await appStore.request(
         { schema, params },
         {
-          response_function: (response: unknown) => {
-            if (
-              typeof response === "object" &&
-              response !== null &&
-              "port" in response &&
-              (typeof response.port === "string" || typeof response.port === "number")
-            ) {
-              this.default_local_port = String(response.port);
-            }
+          response_function: (response) => {
+            this.default_local_port = String(response.port);
           },
         },
       );
@@ -108,27 +106,35 @@ export const useBackStore = defineStore("back", {
       this.set_ping();
       await Promise.resolve();
     },
-    async request(
-      { schema, params = {} }: { schema: JsonRpcSchema; params?: Record<string, unknown> },
-      callbacks: RequestHandlers = {},
-    ) {
+    async request<Schema extends JsonRpcSchema>(
+      { schema, params }: { schema: Schema; params?: ParamsOf<Schema> },
+      callbacks: RequestHandlers<ResponseOf<Schema>> = {},
+    ): Promise<ResponseOf<Schema>> {
+      const rpc_schema: JsonRpcSchema = schema;
       const result = await api_fetch(
         this,
         // The back store is only ever used with HTTP ("front"/"back") schemas,
         // Which always carry `methods`; the wider JsonRpcSchema param above is
         // Kept as-is to match this action's public signature.
-        // oxlint-disable-next-line typescript/no-unsafe-type-assertion
-        { schema: schema as JsonRpcSchema & { methods: string[] }, params, headers: {} },
+        {
+          // oxlint-disable-next-line typescript/no-unsafe-type-assertion
+          schema: rpc_schema as JsonRpcSchema & { methods: string[] },
+          params: params ?? {},
+          headers: {},
+        },
         {
           ...callbacks,
           response_function: async (response: unknown) => {
             if (callbacks.response_function) {
-              await callbacks.response_function(response);
+              // The back validates its responses against the schema `response` it was generated from.
+              // oxlint-disable-next-line typescript/no-unsafe-type-assertion
+              await callbacks.response_function(response as ResponseOf<Schema>);
             }
           },
         },
       );
-      return result;
+      // oxlint-disable-next-line typescript/no-unsafe-type-assertion
+      return result as ResponseOf<Schema>;
     },
     async upload(file: File, callbacks: RequestHandlers = {}) {
       const schema = back_schemas.opengeodeweb_back.upload_file;

package/app/stores/cloud.ts

@@ -2,7 +2,7 @@ import { clearCloudUrlParam, getCloudUrlParam } from "@ogw_front/utils/cloud";
 import type { RunCloudResponse } from "@geode/cloud-api/types";
 import { Status } from "@ogw_front/utils/status";
 import { api_fetch } from "@ogw_internal/utils/api_fetch";
-import back_schemas from "@geode/opengeodeweb-back/opengeodeweb_back_schemas.json";
+import back_schemas from "@geode/opengeodeweb-back/opengeodeweb_back_typed_schemas.js";
 import cloud_api_schemas from "@geode/cloud-api/cloud_api_schemas.json";
 import { setAppBaseUrl } from "@ogw_shared/scripts";
 import { useAPIStore } from "@ogw_front/stores/api";

package/app/stores/infra.ts

@@ -107,6 +107,6 @@ export interface Microservice {
   $id: string;
   status?: string;
   is_busy?: boolean;
-  launch?: (params: Record<string, unknown>) => Promise<unknown>;
+  launch?: (params: { projectFolderPath: string }) => Promise<unknown>;
   connect: () => Promise<void>;
 }

package/app/stores/viewer.ts

@@ -4,7 +4,7 @@ import "@kitware/vtk.js/Rendering/OpenGL/Profiles/Geometry";
 import type { Vector3 } from "@kitware/vtk.js/types";
 import { connectImageStream } from "@kitware/vtk.js/Rendering/Misc/RemoteView";
 import { initWebSocketClient } from "@ogw_internal/utils/ws_client";
-import opengeodeweb_front_schemas from "@geode/opengeodeweb-front/opengeodeweb_front_schemas.json" with { type: "json" };
+import opengeodeweb_front_schemas from "@geode/opengeodeweb-front/opengeodeweb_front_typed_schemas.js";
 import opengeodeweb_viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json" with { type: "json" };
 
 // Local imports
@@ -150,7 +150,7 @@ export const useViewerStore = defineStore(
         }
       });
     }
-    async function launch(args: Readonly<{ projectFolderPath?: string }> = {}): Promise<unknown> {
+    async function launch(args: Readonly<{ projectFolderPath: string }>): Promise<unknown> {
       const appStore = useAppStore();
       const { COMMAND_VIEWER, NUXT_ROOT_PATH } = useRuntimeConfig().public;
       const schema = opengeodeweb_front_schemas.api.local.app.run_viewer;
@@ -165,10 +165,8 @@ export const useViewerStore = defineStore(
           params,
         },
         {
-          response_function: (response: unknown) => {
-            // oxlint-disable-next-line no-unsafe-type-assertion -- response shape is defined by the run_viewer schema.
-            const { port: viewerPort } = response as { port: string };
-            default_local_port.value = viewerPort;
+          response_function: (response) => {
+            default_local_port.value = String(response.port);
           },
         },
       );

package/app/utils/extension.ts

@@ -7,14 +7,14 @@ import type { RegisterableStore, useAppStore } from "@ogw_front/stores/app";
 import type { Microservice } from "@ogw_front/stores/infra";
 import { consola } from "consola";
 import { isCloudMode } from "@ogw_front/utils/stores";
-import opengeodeweb_front_schemas from "@geode/opengeodeweb-front/opengeodeweb_front_schemas.json" with { type: "json" };
+import opengeodeweb_front_schemas from "@geode/opengeodeweb-front/opengeodeweb_front_typed_schemas.js";
 
 interface ExtensionDescriptor {
   id: string;
   name: string;
   version: string;
   frontendContent: string;
-  port: string;
+  port: number;
 }
 
 interface DownloadExtensionParams {
@@ -48,7 +48,7 @@ async function runExtensions(): Promise<{ extensionsArray: ExtensionDescriptor[]
     projectFolderPath,
     projectName,
   };
-  const result = await appStore.request<{ extensionsArray: ExtensionDescriptor[] }>({
+  const result = await appStore.request({
     schema,
     params,
   });
@@ -92,7 +92,7 @@ async function registerRunningExtensions(): Promise<RegisteredExtension[]> {
         type: "application/javascript",
       });
       const blobUrl = URL.createObjectURL(blob);
-      const extensionModule = await appStore.loadExtension(blobUrl, port);
+      const extensionModule = await appStore.loadExtension(blobUrl, String(port));
       consola.info("[ExtensionManager] Extension loaded:", id);
       const storeFactory = extensionModule.metadata.store;
       const store = storeFactory();

package/app/utils/import_workflow.ts

@@ -1,6 +1,6 @@
 // oxlint-disable promise/prefer-await-to-then
 // Third party imports
-import back_schemas from "@geode/opengeodeweb-back/opengeodeweb_back_schemas.json";
+import back_schemas from "@geode/opengeodeweb-back/opengeodeweb_back_typed_schemas.js";
 import { consola } from "consola";
 
 // Local imports

package/internal/stores/hybrid_viewer/base64.ts

@@ -0,0 +1,6 @@
+// Decodes a base64 string (the back's binary_light_viewable) into raw bytes for vtk.js readers.
+// Uint8Array.fromBase64 would do this natively but is unavailable in Node 22, which runs the tests.
+export function base64ToArrayBuffer(b64: string): ArrayBuffer {
+  // Atob returns a "binary string": one char per byte, so each code point is the byte value.
+  return Uint8Array.from(atob(b64), (char) => char.codePointAt(0) ?? 0).buffer;
+}

package/internal/stores/hybrid_viewer/scene.ts

@@ -1,6 +1,7 @@
 import type { HybridDb, vtkActor as VtkActorInstance } from "./vtk_types";
 import { requireRenderWindow, useHybridViewerCore } from "./core";
 import { ACTOR_COLOR } from "./constants";
+import { base64ToArrayBuffer } from "./base64";
 import { useDataStore } from "@ogw_front/stores/data";
 import { useViewerStore } from "@ogw_front/stores/viewer";
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json";
@@ -25,8 +26,11 @@ const useHybridViewerScene = createSharedComposable(() => {
       return;
     }
     const value = await dataStore.item(id);
+    if (value.binary_light_viewable === undefined) {
+      return;
+    }
     const reader = vtkXMLPolyDataReader();
-    reader.parseAsArrayBuffer(new TextEncoder().encode(value.binary_light_viewable).buffer);
+    reader.parseAsArrayBuffer(base64ToArrayBuffer(value.binary_light_viewable));
     const actor = vtkActor();
     const mapper = vtkMapper();
     // oxlint-disable-next-line no-unsafe-type-assertion -- vtk.js's algorithm interface types getOutputData as `any`; this reader always produces polydata.

package/internal/utils/api_fetch.ts

@@ -1,5 +1,6 @@
 import type { JsonRpcSchema, RequestHandlersWithValidation } from "@ogw_shared/utils/types.js";
 import { endRequestLog, startRequestLog } from "@ogw_front/utils/log";
+import type { ErrorResponse } from "@geode/opengeodeweb-back/opengeodeweb_back_typed_schemas.js";
 import { consola } from "consola";
 import { fetchSchema } from "@ogw_shared/utils/fetch_schema";
 import { useFeedbackStore } from "@ogw_front/stores/feedback";
@@ -15,7 +16,7 @@ interface Microservice {
 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>;
+  params?: object;
   headers?: Record<string, string>;
 }
 
@@ -26,11 +27,9 @@ interface FetchErrorLike {
   stack?: string;
 }
 
-interface FetchErrorResponseLike {
-  status?: number;
-  name?: string;
-  description?: string;
-}
+type FetchErrorResponseLike = { status?: number } & Partial<
+  Pick<ErrorResponse, "name" | "description">
+>;
 
 function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value !== null;
@@ -51,10 +50,12 @@ function toFetchErrorResponseLike(response: unknown): FetchErrorResponseLike {
   if (!isRecord(response)) {
     return {};
   }
+  // Ofetch puts the parsed body (an ErrorResponse for Flask microservices) in `_data`
+  const body = isRecord(response._data) ? response._data : response;
   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,
+    name: typeof body.name === "string" ? body.name : undefined,
+    description: typeof body.description === "string" ? body.description : undefined,
   };
 }