Remove WOS dependency from wshrpc (#329)

The frontend wshserver.ts had a weird circuitous dependency on wos.ts,
which was unnecessary. This moves the misplaced functions into wshrpc.ts
and updates the generation logic.

cmd/generatets/main-generatets.go

@@ -89,7 +89,7 @@ func generateWshServerFile(tsTypeMap map[reflect.Type]string) error {
 	fmt.Fprintf(fd, "// Copyright 2024, Command Line Inc.\n")
 	fmt.Fprintf(fd, "// SPDX-License-Identifier: Apache-2.0\n\n")
 	fmt.Fprintf(fd, "// generated by cmd/generate/main-generate.go\n\n")
-	fmt.Fprintf(fd, "import * as WOS from \"./wos\";\n\n")
+	fmt.Fprintf(fd, "import { wshServerRpcHelper_call, wshServerRpcHelper_responsestream } from \"./wshrpc\";\n\n")
 	orderedKeys := utilfn.GetOrderedMapKeys(declMap)
 	fmt.Fprintf(fd, "// WshServerCommandToDeclMap\n")
 	fmt.Fprintf(fd, "class WshServerType {\n")

frontend/app/store/wos.ts

@@ -3,7 +3,6 @@
 
 // WaveObjectStore
 
-import { sendRpcCommand } from "@/app/store/wshrpc";
 import { getWebServerEndpoint } from "@/util/endpoints";
 import { fetch } from "@/util/fetchutil";
 import * as jotai from "jotai";
@@ -11,8 +10,6 @@ import * as React from "react";
 import { atoms, globalStore } from "./global";
 import * as services from "./services";
 
-const IsElectron = true;
-
 type WaveObjectDataItemType<T extends WaveObj> = {
     value: T;
     loading: boolean;
@@ -125,53 +122,6 @@ function callBackendService(service: string, method: string, args: any[], noUICo
     return prtn;
 }
 
-function wshServerRpcHelper_responsestream(
-    command: string,
-    data: any,
-    opts: RpcOpts
-): AsyncGenerator<any, void, boolean> {
-    if (opts?.noresponse) {
-        throw new Error("noresponse not supported for responsestream calls");
-    }
-    const msg: RpcMessage = {
-        command: command,
-        data: data,
-        reqid: crypto.randomUUID(),
-    };
-    if (opts?.timeout) {
-        msg.timeout = opts.timeout;
-    }
-    if (opts?.route) {
-        msg.route = opts.route;
-    }
-    const rpcGen = sendRpcCommand(msg);
-    return rpcGen;
-}
-
-function wshServerRpcHelper_call(command: string, data: any, opts: RpcOpts): Promise<any> {
-    const msg: RpcMessage = {
-        command: command,
-        data: data,
-    };
-    if (!opts?.noresponse) {
-        msg.reqid = crypto.randomUUID();
-    }
-    if (opts?.timeout) {
-        msg.timeout = opts.timeout;
-    }
-    if (opts?.route) {
-        msg.route = opts.route;
-    }
-    const rpcGen = sendRpcCommand(msg);
-    if (rpcGen == null) {
-        return null;
-    }
-    const respMsgPromise = rpcGen.next(true); // pass true to force termination of rpc after 1 response (not streaming)
-    return respMsgPromise.then((msg: IteratorResult<any, void>) => {
-        return msg.value;
-    });
-}
-
 const waveObjectValueCache = new Map<string, WaveObjectValue<any>>();
 
 function clearWaveObjectCache() {
@@ -344,6 +294,4 @@ export {
     updateWaveObject,
     updateWaveObjects,
     useWaveObjectValue,
-    wshServerRpcHelper_call,
-    wshServerRpcHelper_responsestream,
 };

frontend/app/store/wshrpc.ts

@@ -12,6 +12,53 @@ type RpcEntry = {
 
 const openRpcs = new Map<string, RpcEntry>();
 
+function wshServerRpcHelper_responsestream(
+    command: string,
+    data: any,
+    opts: RpcOpts
+): AsyncGenerator<any, void, boolean> {
+    if (opts?.noresponse) {
+        throw new Error("noresponse not supported for responsestream calls");
+    }
+    const msg: RpcMessage = {
+        command: command,
+        data: data,
+        reqid: crypto.randomUUID(),
+    };
+    if (opts?.timeout) {
+        msg.timeout = opts.timeout;
+    }
+    if (opts?.route) {
+        msg.route = opts.route;
+    }
+    const rpcGen = sendRpcCommand(msg);
+    return rpcGen;
+}
+
+function wshServerRpcHelper_call(command: string, data: any, opts: RpcOpts): Promise<any> {
+    const msg: RpcMessage = {
+        command: command,
+        data: data,
+    };
+    if (!opts?.noresponse) {
+        msg.reqid = crypto.randomUUID();
+    }
+    if (opts?.timeout) {
+        msg.timeout = opts.timeout;
+    }
+    if (opts?.route) {
+        msg.route = opts.route;
+    }
+    const rpcGen = sendRpcCommand(msg);
+    if (rpcGen == null) {
+        return null;
+    }
+    const respMsgPromise = rpcGen.next(true); // pass true to force termination of rpc after 1 response (not streaming)
+    return respMsgPromise.then((msg: IteratorResult<any, void>) => {
+        return msg.value;
+    });
+}
+
 async function* rpcResponseGenerator(
     command: string,
     reqid: string,
@@ -148,4 +195,10 @@ if (globalThis.window != null) {
     globalThis["consumeGenerator"] = consumeGenerator;
 }
 
-export { handleIncomingRpcMessage, sendRawRpcMessage, sendRpcCommand };
+export {
+    handleIncomingRpcMessage,
+    sendRawRpcMessage,
+    sendRpcCommand,
+    wshServerRpcHelper_call,
+    wshServerRpcHelper_responsestream,
+};

frontend/app/store/wshserver.ts

@@ -3,198 +3,198 @@
 
 // generated by cmd/generate/main-generate.go
 
-import * as WOS from "./wos";
+import { wshServerRpcHelper_call, wshServerRpcHelper_responsestream } from "./wshrpc";
 
 // WshServerCommandToDeclMap
 class WshServerType {
     // command "announce" [call]
     AnnounceCommand(data: string, opts?: RpcOpts): Promise<void> {
-        return WOS.wshServerRpcHelper_call("announce", data, opts);
+        return wshServerRpcHelper_call("announce", data, opts);
     }
 
     // command "authenticate" [call]
     AuthenticateCommand(data: string, opts?: RpcOpts): Promise<CommandAuthenticateRtnData> {
-        return WOS.wshServerRpcHelper_call("authenticate", data, opts);
+        return wshServerRpcHelper_call("authenticate", data, opts);
     }
 
     // command "connconnect" [call]
     ConnConnectCommand(data: string, opts?: RpcOpts): Promise<void> {
-        return WOS.wshServerRpcHelper_call("connconnect", data, opts);
+        return wshServerRpcHelper_call("connconnect", data, opts);
     }
 
     // command "conndisconnect" [call]
     ConnDisconnectCommand(data: string, opts?: RpcOpts): Promise<void> {
-        return WOS.wshServerRpcHelper_call("conndisconnect", data, opts);
+        return wshServerRpcHelper_call("conndisconnect", data, opts);
     }
 
     // command "connensure" [call]
     ConnEnsureCommand(data: string, opts?: RpcOpts): Promise<void> {
-        return WOS.wshServerRpcHelper_call("connensure", data, opts);
+        return wshServerRpcHelper_call("connensure", data, opts);
     }
 
     // command "connreinstallwsh" [call]
     ConnReinstallWshCommand(data: string, opts?: RpcOpts): Promise<void> {
-        return WOS.wshServerRpcHelper_call("connreinstallwsh", data, opts);
+        return wshServerRpcHelper_call("connreinstallwsh", data, opts);
     }
 
     // command "connstatus" [call]
     ConnStatusCommand(opts?: RpcOpts): Promise<ConnStatus[]> {
-        return WOS.wshServerRpcHelper_call("connstatus", null, opts);
+        return wshServerRpcHelper_call("connstatus", null, opts);
     }
 
     // command "controllerinput" [call]
     ControllerInputCommand(data: CommandBlockInputData, opts?: RpcOpts): Promise<void> {
-        return WOS.wshServerRpcHelper_call("controllerinput", data, opts);
+        return wshServerRpcHelper_call("controllerinput", data, opts);
     }
 
     // command "controllerresync" [call]
     ControllerResyncCommand(data: CommandControllerResyncData, opts?: RpcOpts): Promise<void> {
-        return WOS.wshServerRpcHelper_call("controllerresync", data, opts);
+        return wshServerRpcHelper_call("controllerresync", data, opts);
     }
 
     // command "controllerstop" [call]
     ControllerStopCommand(data: string, opts?: RpcOpts): Promise<void> {
-        return WOS.wshServerRpcHelper_call("controllerstop", data, opts);
+        return wshServerRpcHelper_call("controllerstop", data, opts);
     }
 
     // command "createblock" [call]
     CreateBlockCommand(data: CommandCreateBlockData, opts?: RpcOpts): Promise<ORef> {
-        return WOS.wshServerRpcHelper_call("createblock", data, opts);
+        return wshServerRpcHelper_call("createblock", data, opts);
     }
 
     // command "deleteblock" [call]
     DeleteBlockCommand(data: CommandDeleteBlockData, opts?: RpcOpts): Promise<void> {
-        return WOS.wshServerRpcHelper_call("deleteblock", data, opts);
+        return wshServerRpcHelper_call("deleteblock", data, opts);
     }
 
     // command "eventpublish" [call]
     EventPublishCommand(data: WaveEvent, opts?: RpcOpts): Promise<void> {
-        return WOS.wshServerRpcHelper_call("eventpublish", data, opts);
+        return wshServerRpcHelper_call("eventpublish", data, opts);
     }
 
     // command "eventreadhistory" [call]
     EventReadHistoryCommand(data: CommandEventReadHistoryData, opts?: RpcOpts): Promise<WaveEvent[]> {
-        return WOS.wshServerRpcHelper_call("eventreadhistory", data, opts);
+        return wshServerRpcHelper_call("eventreadhistory", data, opts);
     }
 
     // command "eventrecv" [call]
     EventRecvCommand(data: WaveEvent, opts?: RpcOpts): Promise<void> {
-        return WOS.wshServerRpcHelper_call("eventrecv", data, opts);
+        return wshServerRpcHelper_call("eventrecv", data, opts);
     }
 
     // command "eventsub" [call]
     EventSubCommand(data: SubscriptionRequest, opts?: RpcOpts): Promise<void> {
-        return WOS.wshServerRpcHelper_call("eventsub", data, opts);
+        return wshServerRpcHelper_call("eventsub", data, opts);
     }
 
     // command "eventunsub" [call]
     EventUnsubCommand(data: string, opts?: RpcOpts): Promise<void> {
-        return WOS.wshServerRpcHelper_call("eventunsub", data, opts);
+        return wshServerRpcHelper_call("eventunsub", data, opts);
     }
 
     // command "eventunsuball" [call]
     EventUnsubAllCommand(opts?: RpcOpts): Promise<void> {
-        return WOS.wshServerRpcHelper_call("eventunsuball", null, opts);
+        return wshServerRpcHelper_call("eventunsuball", null, opts);
     }
 
     // command "fileappend" [call]
     FileAppendCommand(data: CommandFileData, opts?: RpcOpts): Promise<void> {
-        return WOS.wshServerRpcHelper_call("fileappend", data, opts);
+        return wshServerRpcHelper_call("fileappend", data, opts);
     }
 
     // command "fileappendijson" [call]
     FileAppendIJsonCommand(data: CommandAppendIJsonData, opts?: RpcOpts): Promise<void> {
-        return WOS.wshServerRpcHelper_call("fileappendijson", data, opts);
+        return wshServerRpcHelper_call("fileappendijson", data, opts);
     }
 
     // command "fileread" [call]
     FileReadCommand(data: CommandFileData, opts?: RpcOpts): Promise<string> {
-        return WOS.wshServerRpcHelper_call("fileread", data, opts);
+        return wshServerRpcHelper_call("fileread", data, opts);
     }
 
     // command "filewrite" [call]
     FileWriteCommand(data: CommandFileData, opts?: RpcOpts): Promise<void> {
-        return WOS.wshServerRpcHelper_call("filewrite", data, opts);
+        return wshServerRpcHelper_call("filewrite", data, opts);
     }
 
     // command "getmeta" [call]
     GetMetaCommand(data: CommandGetMetaData, opts?: RpcOpts): Promise<MetaType> {
-        return WOS.wshServerRpcHelper_call("getmeta", data, opts);
+        return wshServerRpcHelper_call("getmeta", data, opts);
     }
 
     // command "message" [call]
     MessageCommand(data: CommandMessageData, opts?: RpcOpts): Promise<void> {
-        return WOS.wshServerRpcHelper_call("message", data, opts);
+        return wshServerRpcHelper_call("message", data, opts);
     }
 
     // command "remotefiledelete" [call]
     RemoteFileDeleteCommand(data: string, opts?: RpcOpts): Promise<void> {
-        return WOS.wshServerRpcHelper_call("remotefiledelete", data, opts);
+        return wshServerRpcHelper_call("remotefiledelete", data, opts);
     }
 
     // command "remotefileinfo" [call]
     RemoteFileInfoCommand(data: string, opts?: RpcOpts): Promise<FileInfo> {
-        return WOS.wshServerRpcHelper_call("remotefileinfo", data, opts);
+        return wshServerRpcHelper_call("remotefileinfo", data, opts);
     }
 
     // command "remotefilejoin" [call]
     RemoteFileJoinCommand(data: string[], opts?: RpcOpts): Promise<FileInfo> {
-        return WOS.wshServerRpcHelper_call("remotefilejoin", data, opts);
+        return wshServerRpcHelper_call("remotefilejoin", data, opts);
     }
 
     // command "remotestreamcpudata" [responsestream]
 	RemoteStreamCpuDataCommand(opts?: RpcOpts): AsyncGenerator<TimeSeriesData, void, boolean> {
-        return WOS.wshServerRpcHelper_responsestream("remotestreamcpudata", null, opts);
+        return wshServerRpcHelper_responsestream("remotestreamcpudata", null, opts);
     }
 
     // command "remotestreamfile" [responsestream]
 	RemoteStreamFileCommand(data: CommandRemoteStreamFileData, opts?: RpcOpts): AsyncGenerator<CommandRemoteStreamFileRtnData, void, boolean> {
-        return WOS.wshServerRpcHelper_responsestream("remotestreamfile", data, opts);
+        return wshServerRpcHelper_responsestream("remotestreamfile", data, opts);
     }
 
     // command "remotewritefile" [call]
     RemoteWriteFileCommand(data: CommandRemoteWriteFileData, opts?: RpcOpts): Promise<void> {
-        return WOS.wshServerRpcHelper_call("remotewritefile", data, opts);
+        return wshServerRpcHelper_call("remotewritefile", data, opts);
     }
 
     // command "resolveids" [call]
     ResolveIdsCommand(data: CommandResolveIdsData, opts?: RpcOpts): Promise<CommandResolveIdsRtnData> {
-        return WOS.wshServerRpcHelper_call("resolveids", data, opts);
+        return wshServerRpcHelper_call("resolveids", data, opts);
     }
 
     // command "setconfig" [call]
     SetConfigCommand(data: SettingsType, opts?: RpcOpts): Promise<void> {
-        return WOS.wshServerRpcHelper_call("setconfig", data, opts);
+        return wshServerRpcHelper_call("setconfig", data, opts);
     }
 
     // command "setmeta" [call]
     SetMetaCommand(data: CommandSetMetaData, opts?: RpcOpts): Promise<void> {
-        return WOS.wshServerRpcHelper_call("setmeta", data, opts);
+        return wshServerRpcHelper_call("setmeta", data, opts);
     }
 
     // command "setview" [call]
     SetViewCommand(data: CommandBlockSetViewData, opts?: RpcOpts): Promise<void> {
-        return WOS.wshServerRpcHelper_call("setview", data, opts);
+        return wshServerRpcHelper_call("setview", data, opts);
     }
 
     // command "streamcpudata" [responsestream]
 	StreamCpuDataCommand(data: CpuDataRequest, opts?: RpcOpts): AsyncGenerator<TimeSeriesData, void, boolean> {
-        return WOS.wshServerRpcHelper_responsestream("streamcpudata", data, opts);
+        return wshServerRpcHelper_responsestream("streamcpudata", data, opts);
     }
 
     // command "streamtest" [responsestream]
 	StreamTestCommand(opts?: RpcOpts): AsyncGenerator<number, void, boolean> {
-        return WOS.wshServerRpcHelper_responsestream("streamtest", null, opts);
+        return wshServerRpcHelper_responsestream("streamtest", null, opts);
     }
 
     // command "streamwaveai" [responsestream]
 	StreamWaveAiCommand(data: OpenAiStreamRequest, opts?: RpcOpts): AsyncGenerator<OpenAIPacketType, void, boolean> {
-        return WOS.wshServerRpcHelper_responsestream("streamwaveai", data, opts);
+        return wshServerRpcHelper_responsestream("streamwaveai", data, opts);
     }
 
     // command "test" [call]
     TestCommand(data: string, opts?: RpcOpts): Promise<void> {
-        return WOS.wshServerRpcHelper_call("test", data, opts);
+        return wshServerRpcHelper_call("test", data, opts);
     }
 
 }

pkg/tsgen/tsgen.go

@@ -436,7 +436,7 @@ func GenerateWshServerMethod_ResponseStream(methodDecl *wshrpc.WshRpcMethodDecl,
 	} else {
 		sb.WriteString(fmt.Sprintf("	%s(opts?: RpcOpts): %s {\n", methodDecl.MethodName, genRespType))
 	}
-	sb.WriteString(fmt.Sprintf("        return WOS.wshServerRpcHelper_responsestream(%q, %s, opts);\n", methodDecl.Command, dataName))
+	sb.WriteString(fmt.Sprintf("        return wshServerRpcHelper_responsestream(%q, %s, opts);\n", methodDecl.Command, dataName))
 	sb.WriteString("    }\n")
 	return sb.String()
 }
@@ -459,7 +459,7 @@ func GenerateWshServerMethod_Call(methodDecl *wshrpc.WshRpcMethodDecl, tsTypesMa
 	} else {
 		sb.WriteString(fmt.Sprintf("    %s(opts?: RpcOpts): %s {\n", methodDecl.MethodName, rtnType))
 	}
-	methodBody := fmt.Sprintf("        return WOS.wshServerRpcHelper_call(%q, %s, opts);\n", methodDecl.Command, dataName)
+	methodBody := fmt.Sprintf("        return wshServerRpcHelper_call(%q, %s, opts);\n", methodDecl.Command, dataName)
 	sb.WriteString(methodBody)
 	sb.WriteString("    }\n")
 	return sb.String()