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

package/server/utils/ws_client.ts

@@ -0,0 +1,165 @@
+// Third party imports
+import { WebSocket } from "ws";
+import { v4 as uuidv4 } from "uuid";
+
+// Local imports
+
+const HELLO_ID = "system:hello";
+const HELLO_SECRET = "wslink-secret";
+
+interface PendingCall {
+  resolve: (value: unknown) => void;
+  reject: (reason?: unknown) => void;
+}
+
+interface WsRpcMessage {
+  id?: string;
+  error?: { message?: string };
+  result?: unknown;
+}
+
+function isWsRpcMessage(value: unknown): value is WsRpcMessage {
+  return typeof value === "object" && value !== null;
+}
+
+// oxlint-disable-next-line prefer-readonly-parameter-types
+function rawDataToString(raw: WebSocket.RawData): string {
+  if (Buffer.isBuffer(raw)) {
+    return raw.toString();
+  }
+  if (Array.isArray(raw)) {
+    return Buffer.concat(raw).toString();
+  }
+  return Buffer.from(raw).toString();
+}
+
+interface ServerWsRpcClient {
+  call: (rpc: string, params?: Record<string, unknown>) => Promise<unknown>;
+  close: () => void;
+  getConnection: () => {
+    getSession: () => {
+      call: (rpc: string, params: readonly [Record<string, unknown>]) => Promise<unknown>;
+    };
+  };
+  isOpen: () => boolean;
+  onConnectionClose: (callback: () => void) => void;
+  onConnectionError: (callback: (error: unknown) => void) => void;
+  ready: Promise<void>;
+}
+
+//oxlint-disable-next-line max-lines-per-function
+function createServerWsRpcClient(baseUrl: string): ServerWsRpcClient {
+  const socket = new WebSocket(baseUrl);
+  const pending = new Map<string, PendingCall>();
+  let onCloseCallback: (() => void) | undefined = undefined;
+  let onErrorCallback: ((error: unknown) => void) | undefined = undefined;
+
+  //oxlint-disable-next-line promise/avoid-new max-lines-per-function
+  const ready = new Promise<void>((resolve, reject) => {
+    socket.on("open", () => {
+      socket.send(
+        JSON.stringify({
+          id: HELLO_ID,
+          method: "wslink.hello",
+          args: [{ secret: HELLO_SECRET }],
+        }),
+      );
+    });
+
+    // oxlint-disable-next-line prefer-readonly-parameter-types
+    socket.on("message", (raw: WebSocket.RawData) => {
+      let message: WsRpcMessage | undefined = undefined;
+      try {
+        const parsed: unknown = JSON.parse(rawDataToString(raw));
+        if (!isWsRpcMessage(parsed)) {
+          return;
+        }
+        message = parsed;
+      } catch {
+        return;
+      }
+
+      if (message.id === HELLO_ID) {
+        resolve();
+        return;
+      }
+
+      if (typeof message.id === "string" && message.id.startsWith("publish:")) {
+        return;
+      }
+
+      const entry = message.id === undefined ? undefined : pending.get(message.id);
+      if (!entry || message.id === undefined) {
+        return;
+      }
+      pending.delete(message.id);
+      if (message.error) {
+        entry.reject(new Error(message.error.message ?? "wslink RPC error"));
+      } else {
+        entry.resolve(message.result);
+      }
+    });
+
+    socket.on("error", (error: Error) => {
+      onErrorCallback?.(error);
+      reject(error);
+    });
+
+    socket.on("close", () => {
+      onCloseCallback?.();
+      for (const { reject: rejectPending } of pending.values()) {
+        rejectPending(new Error("WebSocket closed"));
+      }
+      pending.clear();
+    });
+  });
+
+  async function call(rpc: string, params: Record<string, unknown> = {}): Promise<unknown> {
+    await ready;
+    const id = uuidv4();
+    //oxlint-disable-next-line promise/avoid-new
+    return new Promise((resolve, reject) => {
+      pending.set(id, { resolve, reject });
+      socket.send(
+        JSON.stringify({
+          wslink: "1.0",
+          id,
+          method: rpc,
+          args: [params],
+          kwargs: { stream: true },
+        }),
+      );
+    });
+  }
+
+  function close(): void {
+    socket.close();
+  }
+
+  function getConnection(): ReturnType<ServerWsRpcClient["getConnection"]> {
+    return {
+      getSession: () => ({
+        call: (rpc: string, [params]: readonly [Record<string, unknown>]) => call(rpc, params),
+      }),
+    };
+  }
+
+  function isOpen(): boolean {
+    return socket.readyState === WebSocket.OPEN;
+  }
+
+  //oxlint-disable-next-line promise/prefer-await-to-callbacks
+  function onConnectionClose(callback: () => void): void {
+    onCloseCallback = callback;
+  }
+
+  //oxlint-disable-next-line promise/prefer-await-to-callbacks
+  function onConnectionError(callback: (error: unknown) => void): void {
+    onErrorCallback = callback;
+  }
+
+  return { call, close, getConnection, isOpen, onConnectionClose, onConnectionError, ready };
+}
+
+export { createServerWsRpcClient };
+export type { ServerWsRpcClient };

package/shared/{scripts.js → scripts.ts}

@@ -7,38 +7,43 @@ import { fetchSchema } from "./utils/fetch_schema.js";
 
 import opengeodeweb_front_schemas from "@geode/opengeodeweb-front/opengeodeweb_front_schemas.json" with { type: "json" };
 
-function setAppBaseUrl(appBaseUrl) {
+async function setAppBaseUrl(appBaseUrl: string): Promise<unknown> {
   console.log("[API] setAppBaseUrl", appBaseUrl);
   const schema = opengeodeweb_front_schemas.api.microservice.app.set_app_base_url;
   const params = { baseUrl: appBaseUrl };
-  return fetchSchema({ schema, params, baseURL: appBaseUrl });
+  const result = await fetchSchema({ schema, params, baseURL: appBaseUrl });
+  return result;
 }
 
-function setBackBaseUrl(appBaseUrl, backBaseUrl) {
+async function setBackBaseUrl(appBaseUrl: string, backBaseUrl: string): Promise<unknown> {
   console.log("[API] setBackBaseUrl", appBaseUrl, backBaseUrl);
   const schema = opengeodeweb_front_schemas.api.microservice.app.set_back_base_url;
   const params = { baseUrl: backBaseUrl };
-  return fetchSchema({ schema, params, baseURL: appBaseUrl });
+  const result = await fetchSchema({ schema, params, baseURL: appBaseUrl });
+  return result;
 }
 
-function setViewerBaseUrl(appBaseUrl, viewerBaseUrl) {
+async function setViewerBaseUrl(appBaseUrl: string, viewerBaseUrl: string): Promise<unknown> {
   console.log("[API] setViewerBaseUrl", appBaseUrl, viewerBaseUrl);
   const schema = opengeodeweb_front_schemas.api.microservice.app.set_viewer_base_url;
   const params = { baseUrl: viewerBaseUrl };
-  return fetchSchema({ schema, params, baseURL: appBaseUrl });
+  const result = await fetchSchema({ schema, params, baseURL: appBaseUrl });
+  return result;
 }
 
-function setIsAppReady(appBaseUrl, isReady) {
+async function setIsAppReady(appBaseUrl: string, isReady: boolean): Promise<unknown> {
   console.log("[API] setIsAppReady", isReady);
   const schema = opengeodeweb_front_schemas.api.microservice.app.set_is_app_ready;
   const params = { isReady };
-  return fetchSchema({ schema, params, baseURL: appBaseUrl });
+  const result = await fetchSchema({ schema, params, baseURL: appBaseUrl });
+  return result;
 }
 
-function getIsAppReady(appBaseUrl) {
+async function getIsAppReady(appBaseUrl: string): Promise<unknown> {
   console.log("[API] getIsAppReady");
   const schema = opengeodeweb_front_schemas.api.microservice.app.get_is_app_ready;
-  return fetchSchema({ schema, baseURL: appBaseUrl });
+  const result = await fetchSchema({ schema, baseURL: appBaseUrl });
+  return result;
 }
 
 export { getIsAppReady, setAppBaseUrl, setBackBaseUrl, setIsAppReady, setViewerBaseUrl };

package/shared/utils/call_raw.ts

@@ -0,0 +1,73 @@
+// Third party imports
+import _ from "lodash";
+import pTimeout from "p-timeout";
+
+// Local imports
+import type { RequestHandlers } from "./types.js";
+
+interface RpcSession {
+  readonly call: (rpc: string, params: readonly [Record<string, unknown>]) => Promise<unknown>;
+}
+interface RpcConnection {
+  readonly getSession: () => RpcSession;
+}
+interface RpcClient {
+  readonly call: (rpc: string, params: Record<string, unknown>) => Promise<unknown>;
+  readonly getConnection: () => RpcConnection;
+}
+
+interface CallClientOptions {
+  rpc: string;
+  params?: Record<string, unknown>;
+  client: RpcClient;
+}
+
+interface CallRawOptions extends CallClientOptions {
+  timeout?: number;
+}
+
+async function callClient({ rpc, params = {}, client }: CallClientOptions): Promise<unknown> {
+  if (globalThis.window !== undefined) {
+    const response = await client.getConnection().getSession().call(rpc, [params]);
+    return response;
+  }
+  const response = await client.call(rpc, params);
+  return response;
+}
+
+async function callRaw(
+  { rpc, params = {}, client, timeout }: CallRawOptions,
+  { request_error_function, response_function, response_error_function }: RequestHandlers = {},
+): Promise<unknown> {
+  async function performCall(): Promise<unknown> {
+    try {
+      const response = await callClient({ rpc, params, client });
+      if (response_function) {
+        await response_function(response);
+      }
+      return response;
+    } catch (error) {
+      if (request_error_function) {
+        request_error_function(error);
+      }
+      if (response_error_function) {
+        response_error_function(error);
+      }
+      throw error;
+    }
+  }
+
+  if (timeout !== undefined && timeout > 0) {
+    const result = await pTimeout(performCall(), {
+      milliseconds: timeout,
+      message: `${rpc}: Timed out after ${timeout}ms`,
+    });
+    return result;
+  }
+
+  const result = await performCall();
+  return result;
+}
+
+export { callRaw };
+export type { RpcClient };

package/shared/utils/{call_schema.js → call_schema.ts}

@@ -1,20 +1,28 @@
 // Third party imports
 
 // Local imports
-import { callRaw } from "./call_raw.js";
+import type { JsonRpcSchema, RequestHandlersWithValidation } from "./types.js";
+import { type RpcClient, callRaw } from "./call_raw.js";
 import { validateSchema } from "./validate_schema.js";
 
 const ERROR_400 = 400;
 
-function callSchema(
-  { schema, params = {}, client, timeout },
+interface CallSchemaOptions {
+  schema: JsonRpcSchema;
+  params?: Record<string, unknown>;
+  client: RpcClient;
+  timeout?: number;
+}
+
+async function callSchema(
+  { schema, params = {}, client, timeout }: CallSchemaOptions,
   {
     request_error_function,
     response_function,
     response_error_function,
     validation_error_function,
-  } = {},
-) {
+  }: RequestHandlersWithValidation = {},
+): Promise<unknown> {
   const { valid, error: schema_error } = validateSchema(schema, params);
 
   if (!valid) {
@@ -27,7 +35,7 @@ function callSchema(
     throw new Error(`${schema.$id}: ${schema_error}`);
   }
 
-  return callRaw(
+  const result = await callRaw(
     {
       rpc: schema.$id,
       params,
@@ -40,6 +48,7 @@ function callSchema(
       response_error_function,
     },
   );
+  return result;
 }
 
 export { callSchema };

package/shared/utils/fetch_raw.ts

@@ -0,0 +1,125 @@
+// Third party imports
+import { $fetch } from "ofetch";
+import _ from "lodash";
+import pTimeout from "p-timeout";
+
+// Local imports
+import type { RequestHandlers } from "./types.js";
+import { hasBody } from "./file.js";
+
+interface FetchRawOptions {
+  route: string;
+  method?: string;
+  params?: unknown;
+  baseURL?: string;
+  headers?: Record<string, string>;
+  max_retry?: number;
+  timeout?: number;
+  expectEvent?: boolean;
+}
+
+function resolveHeaders(
+  headers: Record<string, string>,
+  expectEvent: boolean,
+): Record<string, string> {
+  const resolvedHeaders: Record<string, string> = { ...headers };
+  if (expectEvent) {
+    const value = "text/event-stream";
+    if (_.isEmpty(resolvedHeaders)) {
+      resolvedHeaders.Accept = value;
+    } else {
+      resolvedHeaders.Accept = `${resolvedHeaders.Accept}, ${value}`;
+    }
+  }
+  return resolvedHeaders;
+}
+
+interface PerformFetchOptions extends RequestHandlers {
+  route: string;
+  method?: string;
+  params?: unknown;
+  baseURL?: string;
+  headers: Record<string, string>;
+  max_retry?: number;
+}
+
+async function performFetch({
+  route,
+  method,
+  params,
+  baseURL,
+  headers,
+  max_retry,
+  request_error_function,
+  response_function,
+  response_error_function,
+}: PerformFetchOptions): Promise<unknown> {
+  const fetchResult = await $fetch<unknown>(route, {
+    baseURL,
+    method,
+    headers,
+    ...(hasBody(params) ? { body: params } : {}),
+    ...(max_retry === undefined ? {} : { retry: max_retry }),
+    async onRequestError({ error }: { error: unknown }) {
+      if (request_error_function) {
+        await request_error_function(error);
+      }
+    },
+    async onResponse({
+      response,
+    }: {
+      // oxlint-disable-next-line eslint/id-length -- mirrors the real ofetch/vitest API field name (`ok`/`fn`)
+      response: { ok: boolean; _data?: unknown };
+    }) {
+      if (response.ok && response_function) {
+        // Ofetch awaits whatever this hook returns; without awaiting here, callers relying on
+        // An async response_function (e.g. store patches) race the resolution of this $fetch call.
+        await response_function(response._data);
+      }
+    },
+    async onResponseError({ response }: { response: unknown }) {
+      if (response_error_function) {
+        await response_error_function(response);
+      }
+    },
+  });
+  return fetchResult;
+}
+
+async function fetchRaw(
+  {
+    route,
+    method,
+    params = {},
+    baseURL,
+    headers = {},
+    max_retry,
+    timeout,
+    expectEvent = false,
+  }: FetchRawOptions,
+  { request_error_function, response_function, response_error_function }: RequestHandlers = {},
+): Promise<unknown> {
+  const fetchOptions: PerformFetchOptions = {
+    route,
+    method,
+    params,
+    baseURL,
+    headers: resolveHeaders(headers, expectEvent),
+    max_retry,
+    request_error_function,
+    response_function,
+    response_error_function,
+  };
+
+  if (timeout !== undefined && timeout > 0) {
+    const result = await pTimeout(performFetch(fetchOptions), {
+      milliseconds: timeout,
+      message: `${route}: Timed out after ${timeout}ms`,
+    });
+    return result;
+  }
+  const result = await performFetch(fetchOptions);
+  return result;
+}
+
+export { fetchRaw };

package/shared/utils/{fetch_schema.js → fetch_schema.ts}

@@ -1,20 +1,28 @@
-// Third party imports
-
 // Local imports
+import type { JsonRpcSchema, RequestHandlersWithValidation } from "./types.js";
 import { fetchRaw } from "./fetch_raw.js";
 import { validateSchema } from "./validate_schema.js";
 
 const ERROR_400 = 400;
 
-function fetchSchema(
-  { schema, params = {}, baseURL, headers, timeout, expectEvent = false },
+interface FetchSchemaOptions {
+  schema: JsonRpcSchema & { methods: readonly string[] };
+  params?: unknown;
+  baseURL?: string;
+  headers?: Record<string, string>;
+  timeout?: number;
+  expectEvent?: boolean;
+}
+
+async function fetchSchema(
+  { schema, params = {}, baseURL, headers, timeout, expectEvent = false }: FetchSchemaOptions,
   {
     request_error_function,
     response_function,
     response_error_function,
     validation_error_function,
-  } = {},
-) {
+  }: RequestHandlersWithValidation = {},
+): Promise<unknown> {
   const { valid, error: schema_error } = validateSchema(schema, params);
 
   if (!valid) {
@@ -27,7 +35,7 @@ function fetchSchema(
     throw new Error(`${schema.$id}: ${schema_error}`);
   }
 
-  return fetchRaw(
+  const result = await fetchRaw(
     {
       route: schema.$id,
       method: schema.methods.find((method) => method !== "OPTIONS"),
@@ -44,6 +52,7 @@ function fetchSchema(
       response_error_function,
     },
   );
+  return result;
 }
 
 export { fetchSchema };

package/shared/utils/file.ts

@@ -0,0 +1,22 @@
+import _ from "lodash";
+
+const BYTES_PER_KIBIBYTE = 1024;
+const KIBIBYTES_PER_MEBIBYTE = 1024;
+const CHUNK_SIZE_MEBIBYTES = 8;
+// Cloud hosting in front of the upload routes (Cloud Run/Firebase Hosting) enforces a hard ~32MB request body limit that no amount of server-side streaming can bypass, so uploads are always split into chunks comfortably under that cap. The single source of truth here keeps every uploader (OpenGeodeWeb-Front, Vease) and the routes that assemble the chunks in agreement.
+const CHUNK_SIZE_BYTES = CHUNK_SIZE_MEBIBYTES * KIBIBYTES_PER_MEBIBYTE * BYTES_PER_KIBIBYTE;
+
+function assertFile(file: unknown): asserts file is File {
+  console.log("[ASSERT_FILE] Asserting file", { file });
+  if (!(file instanceof File)) {
+    throw new Error("file must be an instance of File");
+  }
+}
+
+function hasBody(params: unknown): params is Blob | FormData | Record<string, unknown> {
+  if (params instanceof FormData || params instanceof Blob) {
+    return true;
+  }
+  return !_.isEmpty(params);
+}
+export { assertFile, BYTES_PER_KIBIBYTE, CHUNK_SIZE_BYTES, hasBody };

package/shared/utils/{parse_boolean.js → parse_boolean.ts}

@@ -1,7 +1,7 @@
 const TRUTHY_VALUES = new Set([true, 1, "1", "true", "yes"]);
 const FALSY_VALUES = new Set([false, 0, "0", "false", "no"]);
 
-function parseBoolean(value) {
+function parseBoolean(value: string | number | boolean): boolean {
   const normalized = typeof value === "string" ? value.trim().toLowerCase() : value;
 
   if (TRUTHY_VALUES.has(normalized)) {

package/shared/utils/response_handlers/load.ts

@@ -0,0 +1,109 @@
+interface AllowedObject {
+  readonly is_loadable: number;
+  readonly object_priority?: number;
+}
+type AllowedObjectMap = Record<string, AllowedObject>;
+
+function getFileExtension(filename: string): string {
+  return filename.slice(filename.lastIndexOf(".") + 1);
+}
+
+function getObject(objectMap: AllowedObjectMap, key: string): AllowedObject {
+  const object = objectMap[key];
+  if (!object) {
+    throw new Error(`Unknown geode object key: ${key}`);
+  }
+  return object;
+}
+
+function selectGeodeObject(objectMap: AllowedObjectMap): string | undefined {
+  const objectKeys = Object.keys(objectMap);
+  if (objectKeys.length === 0) {
+    return undefined;
+  }
+  const [firstKey] = objectKeys;
+  if (
+    objectKeys.length === 1 &&
+    firstKey !== undefined &&
+    getObject(objectMap, firstKey).is_loadable > 0
+  ) {
+    return firstKey;
+  }
+
+  const highestLoadScore = Math.max(
+    ...objectKeys.map((key) => getObject(objectMap, key).is_loadable),
+  );
+  if (highestLoadScore <= 0) {
+    return undefined;
+  }
+
+  const bestScoreObjects = objectKeys.filter(
+    (key) => getObject(objectMap, key).is_loadable === highestLoadScore,
+  );
+  if (bestScoreObjects.length === 1) {
+    return bestScoreObjects[0];
+  }
+
+  const highestPriority = Math.max(
+    ...bestScoreObjects.map((key) => getObject(objectMap, key).object_priority ?? -Infinity),
+  );
+  const bestPriorityObjects = bestScoreObjects.filter(
+    (key) => getObject(objectMap, key).object_priority === highestPriority,
+  );
+  if (highestPriority !== -Infinity && bestPriorityObjects.length === 1) {
+    return bestPriorityObjects[0];
+  }
+
+  return undefined;
+}
+
+function intersectAllowedObjects(allowedObjectsList: readonly AllowedObjectMap[]): {
+  commonKeys: string[];
+  allKeys: string[];
+  mergedAllowedObjects: AllowedObjectMap;
+} {
+  const allKeys = [...new Set(allowedObjectsList.flatMap((object) => Object.keys(object)))];
+  const commonKeys = allKeys.filter((key) => allowedObjectsList.every((object) => key in object));
+
+  const mergedEntries = commonKeys.map((key): [string, AllowedObject] => {
+    const loadScores = allowedObjectsList.map((object) => getObject(object, key).is_loadable);
+    const priorities = allowedObjectsList
+      .map((object) => getObject(object, key).object_priority)
+      .filter((priority): priority is number => priority !== undefined);
+
+    if (priorities.length > 0) {
+      return [
+        key,
+        { is_loadable: Math.min(...loadScores), object_priority: Math.max(...priorities) },
+      ];
+    }
+    return [key, { is_loadable: Math.min(...loadScores) }];
+  });
+  const mergedAllowedObjects: AllowedObjectMap = Object.fromEntries(mergedEntries);
+
+  return { commonKeys, allKeys, mergedAllowedObjects };
+}
+
+function resolveAllowedObjects(
+  filenames: readonly string[],
+  allowedObjectsList: readonly AllowedObjectMap[],
+): {
+  mergedAllowedObjects: AllowedObjectMap;
+  multipleFilesNoCommon: boolean;
+  selectedGeodeObject: string | undefined;
+} {
+  const { commonKeys, allKeys, mergedAllowedObjects } = intersectAllowedObjects(allowedObjectsList);
+
+  const multipleFilesNoCommon =
+    filenames.length > 1 && allKeys.length > 0 && commonKeys.length === 0;
+
+  const selectedGeodeObject = selectGeodeObject(mergedAllowedObjects);
+
+  return {
+    mergedAllowedObjects,
+    multipleFilesNoCommon,
+    selectedGeodeObject,
+  };
+}
+
+export { resolveAllowedObjects, getFileExtension };

package/shared/utils/types.ts

@@ -0,0 +1,27 @@
+// Covers both flavors of schema used across this codebase: HTTP ("front") schemas carry a `methods` array, websocket RPC ("viewer"/"back") schemas carry `rpc` instead. Neither field is required here since call sites that need one specifically (e.g. fetchSchema needing `methods`) narrow it themselves.
+interface JsonRpcSchema {
+  readonly $id: string;
+  readonly methods?: readonly string[];
+  readonly rpc?: string;
+  readonly max_retry?: number;
+  readonly [key: string]: unknown;
+}
+
+interface ValidationError {
+  code: number;
+  name: string;
+  error: string | null | undefined;
+}
+
+interface RequestHandlers {
+  readonly request_error_function?: (error: unknown) => void | Promise<void>;
+  // Return value is intentionally untyped: callers commonly return the Promise of a downstream call (e.g. a Dexie `.put()`, which resolves to a primary key) that this code chains/awaits but never inspects the resolved value of.
+  readonly response_function?: (response: unknown) => unknown;
+  readonly response_error_function?: (response: unknown) => void | Promise<void>;
+}
+
+interface RequestHandlersWithValidation extends RequestHandlers {
+  readonly validation_error_function?: (error: ValidationError) => void;
+}
+
+export type { JsonRpcSchema, RequestHandlers, RequestHandlersWithValidation, ValidationError };