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

package/server/utils/cleanup.ts

@@ -53,7 +53,7 @@ function isErrorWithMessage(error: unknown): error is { message: string } {
   );
 }
 
-async function killHttpMicroservice(microservice: Readonly<Microservice>): Promise<void> {
+async function killHttpMicroservice(microservice: Microservice): Promise<void> {
   console.log("killHttpMicroservice", {
     ...microservice,
   });
@@ -77,7 +77,7 @@ async function killHttpMicroservice(microservice: Readonly<Microservice>): Promi
   });
 }
 
-async function killWebsocketMicroservice(microservice: Readonly<Microservice>): Promise<void> {
+async function killWebsocketMicroservice(microservice: Microservice): Promise<void> {
   console.log("killWebsocketMicroservice", {
     ...microservice,
   });
@@ -124,7 +124,7 @@ async function killWebsocketMicroservice(microservice: Readonly<Microservice>):
         console.log(successMessage);
         resolve();
       });
-      socket.on("error", (error: Readonly<Error>) => {
+      socket.on("error", (error: Error) => {
         console.error("WebSocket error:", error);
         socket.close();
         resolve();
@@ -137,7 +137,7 @@ async function killWebsocketMicroservice(microservice: Readonly<Microservice>):
   });
 }
 
-async function killMicroservice(microservice: Readonly<Microservice>): Promise<void> {
+async function killMicroservice(microservice: Microservice): Promise<void> {
   if (microservice.type === "back") {
     await killHttpMicroservice(microservice);
   } else if (microservice.type === "viewer") {
@@ -148,9 +148,7 @@ async function killMicroservice(microservice: Readonly<Microservice>): Promise<v
   }
 }
 
-async function killMicroservices(
-  microservices: readonly Readonly<Microservice>[],
-): Promise<Readonly<Microservice>[]> {
+async function killMicroservices(microservices: readonly Microservice[]): Promise<Microservice[]> {
   console.log("killMicroservices", {
     microservices,
   });
@@ -203,7 +201,7 @@ async function cleanupBackend(projectFolderPath: string): Promise<void> {
 }
 
 function getMicroserviceByName(
-  microservices: readonly Readonly<Microservice>[],
+  microservices: readonly Microservice[],
   name: string,
 ): Microservice | undefined {
   const found = microservices.find((microservice) => microservice.name === name);

package/server/utils/microservices.ts

@@ -21,7 +21,7 @@ interface RunArgs {
 const MILLISECONDS_PER_SECOND = 1000;
 const DEFAULT_TIMEOUT_SECONDS = 45;
 const MAX_PORT_RETRIES = 1;
-const DEFAULT_RUN_ARGS: Readonly<RunArgs> = { projectFolderPath: "" };
+const DEFAULT_RUN_ARGS: RunArgs = { projectFolderPath: "" };
 
 async function runScript(
   execPath: string,
@@ -61,7 +61,7 @@ function isPortInUseError(error: unknown): boolean {
   return /EADDRINUSE|address already in use|port already in use/iu.test(String(error));
 }
 
-function backArgs(args: Readonly<RunArgs>, port: number): string[] {
+function backArgs(args: RunArgs, port: number): string[] {
   const { projectFolderPath } = args;
   if (!projectFolderPath) {
     throw new Error("projectFolderPath is required");
@@ -91,7 +91,7 @@ function backArgs(args: Readonly<RunArgs>, port: number): string[] {
 async function runBack(
   execName: string,
   execPath: string,
-  args: Readonly<RunArgs> = DEFAULT_RUN_ARGS,
+  args: RunArgs = DEFAULT_RUN_ARGS,
   attempts = 0,
 ): Promise<number> {
   let port: number | undefined = undefined;
@@ -118,7 +118,7 @@ async function runBack(
 async function runViewer(
   execName: string,
   execPath: string,
-  args: Readonly<RunArgs> = DEFAULT_RUN_ARGS,
+  args: RunArgs = DEFAULT_RUN_ARGS,
   attempts = 0,
 ): Promise<number> {
   const { projectFolderPath } = args;
@@ -157,7 +157,7 @@ async function runExtension(
   extensionId: string,
   execName: string,
   execPath: string,
-  args: Readonly<RunArgs> = DEFAULT_RUN_ARGS,
+  args: RunArgs = DEFAULT_RUN_ARGS,
   attempts = 0,
 ): Promise<number> {
   let port: number | undefined = undefined;
@@ -182,10 +182,7 @@ async function runExtension(
   }
   throw new Error(`runExtension failed to run ${extensionId}`);
 }
-function addMicroserviceMetadatas(
-  projectFolderPath: string,
-  serviceObj: Readonly<Microservice>,
-): void {
+function addMicroserviceMetadatas(projectFolderPath: string, serviceObj: Microservice): void {
   const microservices = projectMicroservices(projectFolderPath);
   let enriched: Microservice = { ...serviceObj };
   if (serviceObj.type === "back") {

package/server/utils/scripts.ts

@@ -46,7 +46,7 @@ interface NamedChildProcess extends child_process.ChildProcessByStdio<null, Read
 async function waitForReady(
   child: NamedChildProcess,
   expectedResponse: string,
-  signal?: Readonly<AbortSignal>,
+  signal?: AbortSignal,
 ): Promise<NamedChildProcess> {
   // oxlint-disable-next-line promise/avoid-new
   return new Promise((resolve, reject) => {
@@ -74,7 +74,7 @@ async function waitForReady(
     }
     let onLine: ((line: string) => void) | undefined = undefined;
     let onErrLine: ((line: string) => void) | undefined = undefined;
-    let onError: ((err: Readonly<Error>) => void) | undefined = undefined;
+    let onError: ((err: Error) => void) | undefined = undefined;
     let onClose: ((code: number | null) => void) | undefined = undefined;
     let onAbort: (() => void) | undefined = undefined;
 

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) {