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

package/shared/utils/call_raw.ts

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

package/shared/utils/call_schema.ts

@@ -1,12 +1,8 @@
-// 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
 // Third party imports
 
 // Local imports
-import { callRaw } from "./call_raw.js";
-// oxlint-disable-next-line eslint/no-duplicate-imports
-import type { RpcClient } 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;
@@ -18,7 +14,7 @@ interface CallSchemaOptions {
   timeout?: number;
 }
 
-function callSchema(
+async function callSchema(
   { schema, params = {}, client, timeout }: CallSchemaOptions,
   {
     request_error_function,
@@ -26,7 +22,7 @@ function callSchema(
     response_error_function,
     validation_error_function,
   }: RequestHandlersWithValidation = {},
-) {
+): Promise<unknown> {
   const { valid, error: schema_error } = validateSchema(schema, params);
 
   if (!valid) {
@@ -39,7 +35,7 @@ function callSchema(
     throw new Error(`${schema.$id}: ${schema_error}`);
   }
 
-  return callRaw(
+  const result = await callRaw(
     {
       rpc: schema.$id,
       params,
@@ -52,6 +48,7 @@ function callSchema(
       response_error_function,
     },
   );
+  return result;
 }
 
 export { callSchema };

package/shared/utils/fetch_raw.ts

@@ -1,13 +1,11 @@
-// 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
 // Third party imports
 import { $fetch } from "ofetch";
 import _ from "lodash";
 import pTimeout from "p-timeout";
 
 // Local imports
-import { hasBody } from "./file.js";
 import type { RequestHandlers } from "./types.js";
+import { hasBody } from "./file.js";
 
 interface FetchRawOptions {
   route: string;
@@ -20,7 +18,75 @@ interface FetchRawOptions {
   expectEvent?: boolean;
 }
 
-function fetchRaw(
+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,
@@ -32,54 +98,28 @@ function fetchRaw(
     expectEvent = false,
   }: FetchRawOptions,
   { request_error_function, response_function, response_error_function }: RequestHandlers = {},
-) {
-  if (expectEvent) {
-    const value = "text/event-stream";
-    if (_.isEmpty(headers)) {
-      headers["Accept"] = value;
-    } else {
-      headers["Accept"] = `${headers["Accept"]}, ${value}`;
-    }
-  }
-
-  const request_options: Record<string, unknown> = { method, headers };
-  if (hasBody(params)) {
-    request_options.body = params;
-  }
-  if (max_retry) {
-    request_options.max_retry = max_retry;
-  }
-
-  function doFetch() {
-    return $fetch(route, {
-      baseURL,
-      ...request_options,
-      onRequestError({ error }: { error: unknown }) {
-        if (request_error_function) {
-          request_error_function(error);
-        }
-      },
-      // oxlint-disable-next-line eslint/id-length -- mirrors the real ofetch/vitest API field name (`ok`/`fn`)
-      onResponse({ response }: { response: { ok: boolean; _data: unknown } }) {
-        if (response.ok && response_function) {
-          response_function(response._data);
-        }
-      },
-      onResponseError({ response }: { response: unknown }) {
-        if (response_error_function) {
-          response_error_function(response);
-        }
-      },
-    } as Parameters<typeof $fetch>[1]);
-  }
+): 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 && timeout > 0) {
-    return pTimeout(doFetch(), {
+  if (timeout !== undefined && timeout > 0) {
+    const result = await pTimeout(performFetch(fetchOptions), {
       milliseconds: timeout,
       message: `${route}: Timed out after ${timeout}ms`,
     });
+    return result;
   }
-  return doFetch();
+  const result = await performFetch(fetchOptions);
+  return result;
 }
 
 export { fetchRaw };

package/shared/utils/fetch_schema.ts

@@ -1,16 +1,12 @@
-// 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
-// Third party imports
-
 // Local imports
-import { fetchRaw } from "./fetch_raw.js";
 import type { JsonRpcSchema, RequestHandlersWithValidation } from "./types.js";
+import { fetchRaw } from "./fetch_raw.js";
 import { validateSchema } from "./validate_schema.js";
 
 const ERROR_400 = 400;
 
 interface FetchSchemaOptions {
-  schema: JsonRpcSchema & { methods: string[] };
+  schema: JsonRpcSchema & { methods: readonly string[] };
   params?: unknown;
   baseURL?: string;
   headers?: Record<string, string>;
@@ -18,7 +14,7 @@ interface FetchSchemaOptions {
   expectEvent?: boolean;
 }
 
-function fetchSchema(
+async function fetchSchema(
   { schema, params = {}, baseURL, headers, timeout, expectEvent = false }: FetchSchemaOptions,
   {
     request_error_function,
@@ -26,7 +22,7 @@ function fetchSchema(
     response_error_function,
     validation_error_function,
   }: RequestHandlersWithValidation = {},
-) {
+): Promise<unknown> {
   const { valid, error: schema_error } = validateSchema(schema, params);
 
   if (!valid) {
@@ -39,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"),
@@ -56,6 +52,7 @@ function fetchSchema(
       response_error_function,
     },
   );
+  return result;
 }
 
 export { fetchSchema };

package/shared/utils/file.ts

@@ -1,5 +1,11 @@
 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)) {
@@ -7,10 +13,10 @@ function assertFile(file: unknown): asserts file is File {
   }
 }
 
-function hasBody(params: unknown): boolean {
+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, hasBody };
+export { assertFile, BYTES_PER_KIBIBYTE, CHUNK_SIZE_BYTES, hasBody };

package/shared/utils/response_handlers/load.ts

@@ -1,6 +1,6 @@
 interface AllowedObject {
-  is_loadable: number;
-  object_priority?: number;
+  readonly is_loadable: number;
+  readonly object_priority?: number;
 }
 type AllowedObjectMap = Record<string, AllowedObject>;
 
@@ -21,8 +21,13 @@ function selectGeodeObject(objectMap: AllowedObjectMap): string | undefined {
   if (objectKeys.length === 0) {
     return undefined;
   }
-  if (objectKeys.length === 1 && getObject(objectMap, objectKeys[0]!).is_loadable > 0) {
-    return objectKeys[0];
+  const [firstKey] = objectKeys;
+  if (
+    objectKeys.length === 1 &&
+    firstKey !== undefined &&
+    getObject(objectMap, firstKey).is_loadable > 0
+  ) {
+    return firstKey;
   }
 
   const highestLoadScore = Math.max(
@@ -52,7 +57,7 @@ function selectGeodeObject(objectMap: AllowedObjectMap): string | undefined {
   return undefined;
 }
 
-function intersectAllowedObjects(allowedObjectsList: AllowedObjectMap[]): {
+function intersectAllowedObjects(allowedObjectsList: readonly AllowedObjectMap[]): {
   commonKeys: string[];
   allKeys: string[];
   mergedAllowedObjects: AllowedObjectMap;
@@ -60,23 +65,33 @@ function intersectAllowedObjects(allowedObjectsList: AllowedObjectMap[]): {
   const allKeys = [...new Set(allowedObjectsList.flatMap((object) => Object.keys(object)))];
   const commonKeys = allKeys.filter((key) => allowedObjectsList.every((object) => key in object));
 
-  const mergedAllowedObjects: AllowedObjectMap = {};
-  for (const key of commonKeys) {
+  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);
 
-    mergedAllowedObjects[key] = { is_loadable: Math.min(...loadScores) };
     if (priorities.length > 0) {
-      mergedAllowedObjects[key].object_priority = Math.max(...priorities);
+      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: string[], allowedObjectsList: AllowedObjectMap[]) {
+function resolveAllowedObjects(
+  filenames: readonly string[],
+  allowedObjectsList: readonly AllowedObjectMap[],
+): {
+  mergedAllowedObjects: AllowedObjectMap;
+  multipleFilesNoCommon: boolean;
+  selectedGeodeObject: string | undefined;
+} {
   const { commonKeys, allKeys, mergedAllowedObjects } = intersectAllowedObjects(allowedObjectsList);
 
   const multipleFilesNoCommon =

package/shared/utils/types.ts

@@ -1,10 +1,10 @@
 // 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 {
-  $id: string;
-  methods?: string[];
-  rpc?: string;
-  max_retry?: number;
-  [key: string]: unknown;
+  readonly $id: string;
+  readonly methods?: readonly string[];
+  readonly rpc?: string;
+  readonly max_retry?: number;
+  readonly [key: string]: unknown;
 }
 
 interface ValidationError {
@@ -14,14 +14,14 @@ interface ValidationError {
 }
 
 interface RequestHandlers {
-  request_error_function?: (error: unknown) => void;
+  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.
-  response_function?: (response: unknown) => unknown;
-  response_error_function?: (response: unknown) => void;
+  readonly response_function?: (response: unknown) => unknown;
+  readonly response_error_function?: (response: unknown) => void | Promise<void>;
 }
 
 interface RequestHandlersWithValidation extends RequestHandlers {
-  validation_error_function?: (error: ValidationError) => void;
+  readonly validation_error_function?: (error: ValidationError) => void;
 }
 
 export type { JsonRpcSchema, RequestHandlers, RequestHandlersWithValidation, ValidationError };

package/shared/utils/validate_schema.ts

@@ -8,7 +8,7 @@ function validateSchema(schema: JsonRpcSchema, body: unknown): { valid: boolean;
   for (const keyword of list_keywords) {
     ajv.addKeyword(keyword);
   }
-  const valid = Boolean(ajv.validate(schema, body));
+  const valid = ajv.validate(schema, body);
   return { valid, error: ajv.errorsText() };
 }