Function generateRpc

scripts/codegen/csharp.ts:2537–2587

(schemaPath?: string, sessionEventsSchema?: JSONSchema7)

}

export async function generateRpc(schemaPath?: string, sessionEventsSchema?: JSONSchema7): Promise<void> {
    console.log("C#: generating RPC types...");
    const resolvedPath = schemaPath ?? (await getApiSchemaPath());
    let schema = fixNullableRequiredRefsInApiSchema(cloneSchemaForCodegen((await loadSchemaJson(resolvedPath)) as ApiSchema));
    if (sessionEventsSchema) {
        const sharedDefinitions = findSharedSchemaDefinitions(
            schema as unknown as Record<string, unknown>,
            sessionEventsSchema as unknown as Record<string, unknown>
        );
        const reachableDefinitions = collectReachableDefinitionNames(sessionEventsSchema as unknown as Record<string, unknown>);
        for (const name of [...sharedDefinitions]) {
            if (!reachableDefinitions.has(name)) {
                sharedDefinitions.delete(name);
            }
        }
        schema = rewriteSharedDefinitionReferences(schema, sharedDefinitions, "session-events.schema.json");
    }
    const externalJsonSerializableRefs = new Map<string, Set<string>>();
    const externalValueTypes = new Set<string>();
    if (sessionEventsSchema) {
        const sessionEventsCode = generateSessionEventsCode(sessionEventsSchema);
        const externalRefs = collectExternalSchemaRefNames(schema);
        const sessionEventRefs = externalRefs.get("session-events.schema.json");
        if (sessionEventRefs && sessionEventRefs.size > 0) {
            const reachableDefinitions = collectReachableDefinitionNames(
                sessionEventsSchema as unknown as Record<string, unknown>,
                sessionEventRefs
            );
            const emittedDefinitions = new Set<string>();
            for (const name of reachableDefinitions) {
                const typeName = typeToClassName(name);
                const declarationPattern = new RegExp(`\\bpublic\\s+(?:(?:sealed|abstract|partial|readonly)\\s+)*(?:class|struct)\\s+${typeName}\\b`);
                if (declarationPattern.test(sessionEventsCode)) {
                    emittedDefinitions.add(name);
                }
                const valueTypeDeclarationPattern = new RegExp(`\\bpublic\\s+(?:(?:readonly)\\s+)?struct\\s+${typeName}\\b`);
                if (valueTypeDeclarationPattern.test(sessionEventsCode)) {
                    externalValueTypes.add(name);
                }
            }
            externalJsonSerializableRefs.set(
                "session-events.schema.json",
                emittedDefinitions
            );
        }
    }
    const code = generateRpcCode(schema, externalJsonSerializableRefs, externalValueTypes);
    const outPath = await writeGeneratedFile("dotnet/src/Generated/Rpc.cs", code);
    console.log(`  ✓ ${outPath}`);
    await formatCSharpFile(outPath);
}

// ══════════════════════════════════════════════════════════════════════════════
// MAIN