Update codegenerators to handle RPC methods returning primitives

Author: SteveSandersonMS

dotnet/src/Generated/Rpc.cs

@@ -17,6 +17,7 @@ import {
     getRpcSchemaTypeName,
     getSessionEventsSchemaPath,
     isNodeFullyExperimental,
+    isObjectSchema,
     isRpcMethod,
     REPO_ROOT,
     writeGeneratedFile,
@@ -596,6 +597,7 @@ export async function generateSessionEvents(schemaPath?: string): Promise<void>
 // ══════════════════════════════════════════════════════════════════════════════
 
 let emittedRpcClasses = new Set<string>();
+let emittedRpcEnumResultTypes = new Set<string>();
 let experimentalRpcTypes = new Set<string>();
 let rpcKnownTypes = new Map<string, string>();
 let rpcEnumOutput: string[] = [];
@@ -718,6 +720,21 @@ function emitRpcClass(className: string, schema: JSONSchema7, visibility: "publi
     return lines.join("\n");
 }
 
+/**
+ * Emit the type for a non-object RPC result schema (e.g., a bare enum).
+ * Returns the C# type name to use in method signatures. For enums, ensures the enum
+ * is created via getOrCreateEnum. For other primitives, returns the mapped C# type.
+ */
+function emitNonObjectResultType(typeName: string, schema: JSONSchema7, classes: string[]): string {
+    if (schema.enum && Array.isArray(schema.enum)) {
+        const enumName = getOrCreateEnum("", typeName, schema.enum as string[], rpcEnumOutput, schema.description, typeName);
+        emittedRpcEnumResultTypes.add(enumName);
+        return enumName;
+    }
+    // For other non-object types, use the basic type mapping
+    return schemaTypeToCSharp(schema, true, rpcKnownTypes);
+}
+
 /**
  * Emit ServerRpc as an instance class (like SessionRpc but without sessionId).
  */
@@ -803,12 +820,16 @@ function emitServerInstanceMethod(
     groupExperimental: boolean
 ): void {
     const methodName = toPascalCase(name);
-    const resultClassName = resultTypeName(method);
+    let resultClassName = resultTypeName(method);
     if (method.stability === "experimental") {
         experimentalRpcTypes.add(resultClassName);
     }
-    const resultClass = emitRpcClass(resultClassName, method.result, "public", classes);
-    if (resultClass) classes.push(resultClass);
+    if (isObjectSchema(method.result)) {
+        const resultClass = emitRpcClass(resultClassName, method.result, "public", classes);
+        if (resultClass) classes.push(resultClass);
+    } else if (method.result) {
+        resultClassName = emitNonObjectResultType(resultClassName, method.result, classes);
+    }
 
     const paramEntries = method.params?.properties ? Object.entries(method.params.properties) : [];
     const requiredSet = new Set(method.params?.required || []);
@@ -890,12 +911,16 @@ function emitSessionRpcClasses(node: Record<string, unknown>, classes: string[])
 
 function emitSessionMethod(key: string, method: RpcMethod, lines: string[], classes: string[], indent: string, groupExperimental: boolean): void {
     const methodName = toPascalCase(key);
-    const resultClassName = resultTypeName(method);
+    let resultClassName = resultTypeName(method);
     if (method.stability === "experimental") {
         experimentalRpcTypes.add(resultClassName);
     }
-    const resultClass = emitRpcClass(resultClassName, method.result, "public", classes);
-    if (resultClass) classes.push(resultClass);
+    if (isObjectSchema(method.result)) {
+        const resultClass = emitRpcClass(resultClassName, method.result, "public", classes);
+        if (resultClass) classes.push(resultClass);
+    } else if (method.result) {
+        resultClassName = emitNonObjectResultType(resultClassName, method.result, classes);
+    }
 
     const paramEntries = (method.params?.properties ? Object.entries(method.params.properties) : []).filter(([k]) => k !== "sessionId");
     const requiredSet = new Set(method.params?.required || []);
@@ -982,8 +1007,12 @@ function emitClientSessionApiRegistration(clientSchema: Record<string, unknown>,
     for (const { methods } of groups) {
         for (const method of methods) {
             if (method.result) {
-                const resultClass = emitRpcClass(resultTypeName(method), method.result, "public", classes);
-                if (resultClass) classes.push(resultClass);
+                if (isObjectSchema(method.result)) {
+                    const resultClass = emitRpcClass(resultTypeName(method), method.result, "public", classes);
+                    if (resultClass) classes.push(resultClass);
+                } else {
+                    emitNonObjectResultType(resultTypeName(method), method.result, classes);
+                }
             }
 
             if (method.params?.properties && Object.keys(method.params.properties).length > 0) {
@@ -1079,6 +1108,7 @@ function emitClientSessionApiRegistration(clientSchema: Record<string, unknown>,
 
 function generateRpcCode(schema: ApiSchema): string {
     emittedRpcClasses.clear();
+    emittedRpcEnumResultTypes.clear();
     experimentalRpcTypes.clear();
     rpcKnownTypes.clear();
     rpcEnumOutput = [];
@@ -1122,7 +1152,7 @@ internal static class Diagnostics
     if (clientSessionParts.length > 0) lines.push(...clientSessionParts, "");
 
     // Add JsonSerializerContext for AOT/trimming support
-    const typeNames = [...emittedRpcClasses].sort();
+    const typeNames = [...emittedRpcClasses, ...emittedRpcEnumResultTypes].sort();
     if (typeNames.length > 0) {
         lines.push(`[JsonSourceGenerationOptions(`);
         lines.push(`    JsonSerializerDefaults.Web,`);

go/rpc/generated_rpc.go

@@ -918,9 +918,9 @@ async function generateRpc(schemaPath?: string): Promise<void> {
 
     // Extract actual type names generated by quicktype (may differ from toPascalCase)
     const actualTypeNames = new Map<string, string>();
-    const structRe = /^type\s+(\w+)\s+struct\b/gm;
+    const typeRe = /^type\s+(\w+)\s+/gm;
     let sm;
-    while ((sm = structRe.exec(qtCode)) !== null) {
+    while ((sm = typeRe.exec(qtCode)) !== null) {
         actualTypeNames.set(sm[1].toLowerCase(), sm[1]);
     }
     const resolveType = (name: string): string => actualTypeNames.get(name.toLowerCase()) ?? name;