@geode/opengeodeweb-front 10.34.0-rc.12 → 10.34.0-rc.13

package/server/utils/ws_client.ts

@@ -34,11 +34,11 @@ function rawDataToString(raw: WebSocket.RawData): string {
 }
 
 interface ServerWsRpcClient {
-  call: (rpc: string, params?: Readonly<Record<string, unknown>>) => Promise<unknown>;
+  call: (rpc: string, params?: Record<string, unknown>) => Promise<unknown>;
   close: () => void;
   getConnection: () => {
     getSession: () => {
-      call: (rpc: string, params: readonly [Readonly<Record<string, unknown>>]) => Promise<unknown>;
+      call: (rpc: string, params: readonly [Record<string, unknown>]) => Promise<unknown>;
     };
   };
   isOpen: () => boolean;
@@ -100,7 +100,7 @@ function createServerWsRpcClient(baseUrl: string): ServerWsRpcClient {
       }
     });
 
-    socket.on("error", (error: Readonly<Error>) => {
+    socket.on("error", (error: Error) => {
       onErrorCallback?.(error);
       reject(error);
     });
@@ -114,10 +114,7 @@ function createServerWsRpcClient(baseUrl: string): ServerWsRpcClient {
     });
   });
 
-  async function call(
-    rpc: string,
-    params: Readonly<Record<string, unknown>> = {},
-  ): Promise<unknown> {
+  async function call(rpc: string, params: Record<string, unknown> = {}): Promise<unknown> {
     await ready;
     const id = uuidv4();
     //oxlint-disable-next-line promise/avoid-new
@@ -142,8 +139,7 @@ function createServerWsRpcClient(baseUrl: string): ServerWsRpcClient {
   function getConnection(): ReturnType<ServerWsRpcClient["getConnection"]> {
     return {
       getSession: () => ({
-        call: (rpc: string, [params]: readonly [Readonly<Record<string, unknown>>]) =>
-          call(rpc, params),
+        call: (rpc: string, [params]: readonly [Record<string, unknown>]) => call(rpc, params),
       }),
     };
   }

package/shared/utils/call_raw.ts

@@ -6,34 +6,27 @@ import pTimeout from "p-timeout";
 import type { RequestHandlers } from "./types.js";
 
 interface RpcSession {
-  readonly call: (
-    rpc: string,
-    params: readonly [Readonly<Record<string, unknown>>],
-  ) => Promise<unknown>;
+  readonly call: (rpc: string, params: readonly [Record<string, unknown>]) => Promise<unknown>;
 }
 interface RpcConnection {
   readonly getSession: () => RpcSession;
 }
 interface RpcClient {
-  readonly call: (rpc: string, params: Readonly<Record<string, unknown>>) => Promise<unknown>;
+  readonly call: (rpc: string, params: Record<string, unknown>) => Promise<unknown>;
   readonly getConnection: () => RpcConnection;
 }
 
 interface CallClientOptions {
   rpc: string;
-  params?: Readonly<Record<string, unknown>>;
-  client: Readonly<RpcClient>;
+  params?: Record<string, unknown>;
+  client: RpcClient;
 }
 
 interface CallRawOptions extends CallClientOptions {
   timeout?: number;
 }
 
-async function callClient({
-  rpc,
-  params = {},
-  client,
-}: Readonly<CallClientOptions>): Promise<unknown> {
+async function callClient({ rpc, params = {}, client }: CallClientOptions): Promise<unknown> {
   if (globalThis.window !== undefined) {
     const response = await client.getConnection().getSession().call(rpc, [params]);
     return response;
@@ -43,12 +36,8 @@ async function callClient({
 }
 
 async function callRaw(
-  { rpc, params = {}, client, timeout }: Readonly<CallRawOptions>,
-  {
-    request_error_function,
-    response_function,
-    response_error_function,
-  }: Readonly<RequestHandlers> = {},
+  { rpc, params = {}, client, timeout }: CallRawOptions,
+  { request_error_function, response_function, response_error_function }: RequestHandlers = {},
 ): Promise<unknown> {
   async function performCall(): Promise<unknown> {
     try {

package/shared/utils/call_schema.ts

@@ -8,20 +8,20 @@ import { validateSchema } from "./validate_schema.js";
 const ERROR_400 = 400;
 
 interface CallSchemaOptions {
-  schema: Readonly<JsonRpcSchema>;
-  params?: Readonly<Record<string, unknown>>;
-  client: Readonly<RpcClient>;
+  schema: JsonRpcSchema;
+  params?: Record<string, unknown>;
+  client: RpcClient;
   timeout?: number;
 }
 
 async function callSchema(
-  { schema, params = {}, client, timeout }: Readonly<CallSchemaOptions>,
+  { schema, params = {}, client, timeout }: CallSchemaOptions,
   {
     request_error_function,
     response_function,
     response_error_function,
     validation_error_function,
-  }: Readonly<RequestHandlersWithValidation> = {},
+  }: RequestHandlersWithValidation = {},
 ): Promise<unknown> {
   const { valid, error: schema_error } = validateSchema(schema, params);
 

package/shared/utils/fetch_raw.ts

@@ -12,14 +12,14 @@ interface FetchRawOptions {
   method?: string;
   params?: unknown;
   baseURL?: string;
-  headers?: Readonly<Record<string, string>>;
+  headers?: Record<string, string>;
   max_retry?: number;
   timeout?: number;
   expectEvent?: boolean;
 }
 
 function resolveHeaders(
-  headers: Readonly<Record<string, string>>,
+  headers: Record<string, string>,
   expectEvent: boolean,
 ): Record<string, string> {
   const resolvedHeaders: Record<string, string> = { ...headers };
@@ -39,7 +39,7 @@ interface PerformFetchOptions extends RequestHandlers {
   method?: string;
   params?: unknown;
   baseURL?: string;
-  headers: Readonly<Record<string, string>>;
+  headers: Record<string, string>;
   max_retry?: number;
 }
 
@@ -53,29 +53,33 @@ async function performFetch({
   request_error_function,
   response_function,
   response_error_function,
-}: Readonly<PerformFetchOptions>): Promise<unknown> {
+}: PerformFetchOptions): Promise<unknown> {
   const fetchResult = await $fetch<unknown>(route, {
     baseURL,
     method,
     headers,
     ...(hasBody(params) ? { body: params } : {}),
     ...(max_retry === undefined ? {} : { retry: max_retry }),
-    onRequestError({ error }: Readonly<{ error: unknown }>) {
+    async onRequestError({ error }: { error: unknown }) {
       if (request_error_function) {
-        request_error_function(error);
+        await request_error_function(error);
       }
     },
-    onResponse({
+    async onResponse({
       response,
       // oxlint-disable-next-line eslint/id-length -- mirrors the real ofetch/vitest API field name (`ok`/`fn`)
-    }: Readonly<{ response: Readonly<{ ok: boolean; _data?: unknown }> }>) {
+    }: {
+      response: { ok: boolean; _data?: unknown };
+    }) {
       if (response.ok && response_function) {
-        response_function(response._data);
+        // 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);
       }
     },
-    onResponseError({ response }: Readonly<{ response: unknown }>) {
+    async onResponseError({ response }: { response: unknown }) {
       if (response_error_function) {
-        response_error_function(response);
+        await response_error_function(response);
       }
     },
   });
@@ -92,14 +96,10 @@ async function fetchRaw(
     max_retry,
     timeout,
     expectEvent = false,
-  }: Readonly<FetchRawOptions>,
-  {
-    request_error_function,
-    response_function,
-    response_error_function,
-  }: Readonly<RequestHandlers> = {},
+  }: FetchRawOptions,
+  { request_error_function, response_function, response_error_function }: RequestHandlers = {},
 ): Promise<unknown> {
-  const fetchOptions: Readonly<PerformFetchOptions> = {
+  const fetchOptions: PerformFetchOptions = {
     route,
     method,
     params,

package/shared/utils/fetch_schema.ts

@@ -6,29 +6,22 @@ import { validateSchema } from "./validate_schema.js";
 const ERROR_400 = 400;
 
 interface FetchSchemaOptions {
-  schema: Readonly<JsonRpcSchema & { methods: readonly string[] }>;
+  schema: JsonRpcSchema & { methods: readonly string[] };
   params?: unknown;
   baseURL?: string;
-  headers?: Readonly<Record<string, string>>;
+  headers?: Record<string, string>;
   timeout?: number;
   expectEvent?: boolean;
 }
 
 async function fetchSchema(
-  {
-    schema,
-    params = {},
-    baseURL,
-    headers,
-    timeout,
-    expectEvent = false,
-  }: Readonly<FetchSchemaOptions>,
+  { schema, params = {}, baseURL, headers, timeout, expectEvent = false }: FetchSchemaOptions,
   {
     request_error_function,
     response_function,
     response_error_function,
     validation_error_function,
-  }: Readonly<RequestHandlersWithValidation> = {},
+  }: RequestHandlersWithValidation = {},
 ): Promise<unknown> {
   const { valid, error: schema_error } = validateSchema(schema, params);
 

package/shared/utils/response_handlers/load.ts

@@ -2,7 +2,7 @@ interface AllowedObject {
   readonly is_loadable: number;
   readonly object_priority?: number;
 }
-type AllowedObjectMap = Readonly<Record<string, AllowedObject>>;
+type AllowedObjectMap = Record<string, AllowedObject>;
 
 function getFileExtension(filename: string): string {
   return filename.slice(filename.lastIndexOf(".") + 1);

package/shared/utils/types.ts

@@ -14,14 +14,14 @@ interface ValidationError {
 }
 
 interface RequestHandlers {
-  readonly 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.
   readonly response_function?: (response: unknown) => unknown;
-  readonly response_error_function?: (response: unknown) => void;
+  readonly response_error_function?: (response: unknown) => void | Promise<void>;
 }
 
 interface RequestHandlersWithValidation extends RequestHandlers {
-  readonly validation_error_function?: (error: Readonly<ValidationError>) => void;
+  readonly validation_error_function?: (error: ValidationError) => void;
 }
 
 export type { JsonRpcSchema, RequestHandlers, RequestHandlersWithValidation, ValidationError };

package/shared/utils/validate_schema.ts

@@ -2,10 +2,7 @@ import Ajv from "ajv";
 
 import type { JsonRpcSchema } from "./types.js";
 
-function validateSchema(
-  schema: Readonly<JsonRpcSchema>,
-  body: unknown,
-): { valid: boolean; error: string } {
+function validateSchema(schema: JsonRpcSchema, body: unknown): { valid: boolean; error: string } {
   const ajv = new Ajv();
   const list_keywords = ["methods", "route", "max_retry", "rpc"];
   for (const keyword of list_keywords) {