Seperated Workspace server methods to own class

src-csharp/Vla/Server/Messages/Requests/CreateWorkspaceRequest.cs

@@ -9,4 +9,10 @@ public readonly struct CreateWorkspaceRequest(string name, string path) : ISocke
 
 	[JsonProperty("path")]
 	public string Path { get; init; } = path;
+}
+
+public readonly struct WorkspaceRequest(Abstractions.Workspace workspace) : ISocketRequest
+{
+	[JsonProperty("workspace")]
+	public Abstractions.Workspace Workspace { get; init; } = workspace;
 }

src-csharp/Vla/Server/Methods/Workspaces.cs

@@ -0,0 +1,51 @@
+using System.Collections.Immutable;
+using Somfic.Common;
+using Vla.Server.Messages;
+using Vla.Server.Messages.Requests;
+using Vla.Server.Messages.Response;
+using Vla.Workspace;
+using WatsonWebsocket;
+
+namespace Vla.Server.Methods;
+
+public class Workspaces : IServerMethods
+{
+	private readonly WorkspaceService _workspaces;
+
+	public Workspaces(WorkspaceService workspaces)
+	{
+		_workspaces = workspaces;
+	}
+
+	[Request("workspaces-list-recent")]
+	private async Task<ISocketResponse> OnWorkspacesListRecent(ClientMetadata client)
+	{
+		var workspaces = await _workspaces.ListRecentAsync();
+
+		return workspaces
+			.Map<ISocketResponse, ImmutableArray<Abstractions.Workspace>>(
+				w => new WorkspacesResponse(w),
+				e => new ExceptionResponse(e));
+	}
+
+	[Request("workspace-create")]
+	private async Task<ISocketResponse> OnWorkspaceCreate(ClientMetadata client, CreateWorkspaceRequest request)
+	{
+		var workspace = await _workspaces.CreateOrLoadAsync(request.Name, request.Path);
+
+		return workspace
+			.Map<ISocketResponse, Abstractions.Workspace>(
+				w => new WorkspaceResponse(w),
+				e => new ExceptionResponse(e));
+	}
+
+	[Request("workspace-save")]
+	private async Task OnWorkspaceSave(ClientMetadata client, WorkspaceRequest request)
+	{
+		await _workspaces.SaveAsync(request.Workspace);
+	}
+}
+
+public interface IServerMethods
+{
+}

src-csharp/Vla/Server/RequestAttribute.cs

@@ -0,0 +1,7 @@
+namespace Vla.Server;
+
+[AttributeUsage(AttributeTargets.Method)]
+public class RequestAttribute(string id) : Attribute
+{
+	public string Id { get; } = id;
+}

src-csharp/Vla/Server/ServerService.cs

@@ -81,110 +81,103 @@ public void OnTick(Func<Task> callback)
 
 	private async Task OnIncomingMessage(ClientMetadata client, string message)
 	{
-		var jObject = JObject.Parse(message);
-		var id = jObject["id"]?.Value<string>()?.ToLower() ?? string.Empty;
-
-		if (string.IsNullOrEmpty(id))
+		try
 		{
-			_log.LogWarning("Incoming request did not have an ID, skipping");
-			return;
-		}
+			var jObject = JObject.Parse(message);
+			var id = jObject["id"]?.Value<string>()?.ToLower() ?? string.Empty;
 
-		// TODO: Cache the available methods, since they're constant at runtime
-		var method = GetType()
-			.GetMethods()
-			.Select(x => (method: x, attribute: x.GetCustomAttribute(typeof(RequestAttribute))))
-			.Where(x => x.attribute != null)
-			.Select(x => (x.method, attribute: x.attribute as RequestAttribute))
-			.FirstOrDefault(x => x.attribute!.Id.Equals(id, StringComparison.CurrentCultureIgnoreCase));
+			if (string.IsNullOrEmpty(id))
+			{
+				_log.LogWarning("Incoming request did not have an ID, skipping");
+				return;
+			}
 
-		if (method.method == null)
-		{
-			_log.LogWarning("Could not find a request handler with an implementation for '{Id}, skipping'", id);
-			return;
-		}
+			// TODO: Cache the available methods, since they're constant at runtime
+			var method = GetType()
+				.GetMethods()
+				.Select(x => (method: x, attribute: x.GetCustomAttribute(typeof(RequestAttribute))))
+				.Where(x => x.attribute != null)
+				.Select(x => (x.method, attribute: x.attribute as RequestAttribute))
+				.FirstOrDefault(x => x.attribute!.Id.Equals(id, StringComparison.CurrentCultureIgnoreCase));
 
-		var methodParameters = method.method.GetParameters();
-		var invokingParameters = new dynamic[methodParameters.Length];
+			if (method.method == null)
+			{
+				_log.LogWarning("Could not find a request handler with an implementation for '{Id}, skipping'", id);
+				return;
+			}
 
-		for (var index = 0; index < methodParameters.Length; index++)
-		{
-			var methodParameter = methodParameters[index];
+			var methodParameters = method.method.GetParameters();
+			var invokingParameters = new dynamic[methodParameters.Length];
 
-			if (methodParameter.ParameterType == typeof(ClientMetadata))
-				invokingParameters[index] = client;
+			for (var index = 0; index < methodParameters.Length; index++)
+			{
+				var methodParameter = methodParameters[index];
 
-			if (methodParameter.ParameterType.IsSubclassOf(typeof(ISocketRequest)))
-				try
-				{
-					var request = JsonConvert.DeserializeObject(message, methodParameter.ParameterType);
+				if (methodParameter.ParameterType == typeof(ClientMetadata))
+					invokingParameters[index] = client;
 
-					if (request == null)
+				if (methodParameter.ParameterType.IsSubclassOf(typeof(ISocketRequest)))
+					try
 					{
-						_log.LogWarning("Could not convert request body to type {Type}", methodParameter.ParameterType);
-						return;
-					}
+						var request = JsonConvert.DeserializeObject(message, methodParameter.ParameterType);
 
-					invokingParameters[index] = request;
-				}
-				catch (Exception ex)
-				{
-					_log.LogWarning(ex, "Could not convert request body to type {Type}", methodParameter.ParameterType);
-					return;
-				}
-		}
+						if (request == null)
+						{
+							_log.LogWarning("Could not convert request body to type {Type}",
+								methodParameter.ParameterType);
+							return;
+						}
 
-		// Check if the method is async by checking if the return type is Task or Task<T>
-		if (method.method.ReturnType == typeof(Task))
-		{
-			await (Task)method.method.Invoke(this, invokingParameters)!;
-		}
-		// Check if the method is async and returns an ISocketMessage by checking if the return type is Task<ISocketMessage>, or Task<(type that inherits from ISocketMessage)>
-		else if (method.method.ReturnType.IsGenericType &&
-		         method.method.ReturnType.GetGenericTypeDefinition() == typeof(Task<>) &&
-		         method.method.ReturnType.GetGenericArguments().Length == 1 && method.method.ReturnType
-			         .GetGenericArguments().First().IsAssignableTo(typeof(ISocketMessage)))
-		{
-			var result = await (Task<ISocketMessage>)method.method.Invoke(this, invokingParameters)!;
-			await _server.SendAsync(client, result);
+						invokingParameters[index] = request;
+					}
+					catch (Exception ex)
+					{
+						_log.LogWarning(ex, "Could not convert request body to type {Type}",
+							methodParameter.ParameterType);
+						return;
+					}
+			}
+
+			// If the method returns nothing, just invoke it
+			if (method.method.ReturnType == typeof(Task))
+			{
+				await (Task)method.method.Invoke(this, invokingParameters)!;
+			}
+			else if (method.method.ReturnType == typeof(void))
+			{
+				method.method.Invoke(this, invokingParameters);
+			}
+
+			// If the method returns a type that inherits from ISocketResponse, invoke it and send the result
+			else if (method.method.ReturnType.IsGenericType &&
+			         method.method.ReturnType.GetGenericTypeDefinition() == typeof(Task<>) &&
+			         method.method.ReturnType.GetGenericArguments().Length == 1 && method.method.ReturnType
+				         .GetGenericArguments().First().IsAssignableTo(typeof(ISocketMessage)))
+			{
+				var result = await (Task<ISocketMessage>)method.method.Invoke(this, invokingParameters)!;
+				await _server.SendAsync(client, result);
+			}
+			else if (method.method.ReturnType.IsAssignableTo(typeof(ISocketMessage)))
+			{
+				var result = (ISocketMessage)method.method.Invoke(this, invokingParameters)!;
+				await _server.SendAsync(client, result);
+			}
+			else
+			{
+				_log.LogWarning("Method '{Method}' returned an unexpected type '{Type}', skipping",
+					method.method.Name, method.method.ReturnType);
+			}
 		}
-		// Else, just invoke the method and ignore the result
-		else
+		catch (Exception ex)
 		{
-			method.method.Invoke(this, invokingParameters);
+			_log.LogWarning(ex, "Could not process incoming message");
+			await _server.SendAsync(client, new ExceptionResponse(ex));
 		}
 	}
 
 	private Task OnNewClient(ClientMetadata client)
 	{
 		return Task.CompletedTask;
 	}
-
-	[Request("workspaces-list-recent")]
-	private async Task<ISocketMessage> OnWorkspacesListRecent(ClientMetadata client)
-	{
-		var workspaces = await _workspaces.ListRecentAsync();
-
-		return workspaces
-			.Map<ISocketMessage, ImmutableArray<Abstractions.Workspace>>(
-				w => new WorkspacesResponse(w),
-				e => new ExceptionResponse(e));
-	}
-
-	[Request("workspace-create")]
-	private async Task<ISocketMessage> OnWorkspaceCreate(ClientMetadata client, CreateWorkspaceRequest request)
-	{
-		var workspace = await _workspaces.CreateOrLoadAsync(request.Name, request.Path);
-
-		return workspace
-			.Map<ISocketMessage, Abstractions.Workspace>(
-				w => new WorkspaceResponse(w),
-				e => new ExceptionResponse(e));
-	}
-
-	[AttributeUsage(AttributeTargets.Method)]
-	private class RequestAttribute(string id) : Attribute
-	{
-		public string Id { get; } = id;
-	}
+
 }

src-csharp/Vla/Websocket/WebsocketService.cs

@@ -41,14 +41,16 @@ public async Task StopAsync()
 
 	public async Task BroadcastAsync<TMessage>(TMessage message) where TMessage : ISocketMessage
 	{
+		_log.LogDebug("Starting broadcast of '{Message}'", message);
 		foreach (var client in _server.ListClients()) await SendAsync(client, message);
+		_log.LogDebug("Broadcast of '{Message}' completed", message);
 	}
 
 	public async Task SendAsync<TMessage>(ClientMetadata client, TMessage message) where TMessage : ISocketMessage
 	{
 		var wrappedMessage = new ServerMessage<TMessage>(message);
 		var json = JsonConvert.SerializeObject(wrappedMessage);
-		Console.WriteLine($"> {json}");
+		_log.LogDebug("Sending message to {Guid}: '{Message}'", client.Guid, json);
 		await _server.SendAsync(client.Guid, json);
 	}
 
@@ -60,7 +62,9 @@ private async Task OnClientConnected(ConnectionEventArgs e)
 
 	private async Task OnMessageReceived(MessageReceivedEventArgs e)
 	{
-		await MessageReceived.Set((e.Client, Encoding.UTF8.GetString(e.Data.ToArray())));
+		var message = Encoding.UTF8.GetString(e.Data.ToArray());
+		_log.LogDebug("Message received from {Guid}: '{Message}'", e.Client.Guid, message);
+		await MessageReceived.Set((e.Client, message));
 	}
 
 
@@ -71,8 +75,8 @@ public static implicit operator ServerMessage<TMessage>(TMessage message)
 			return new ServerMessage<TMessage>(message);
 		}
 
-		[JsonProperty("type")]
-		public static string Type => typeof(TMessage).Name.Replace("Message", string.Empty);
+		[JsonProperty("id")]
+		public static string Id => typeof(TMessage).Name.Replace("Message", string.Empty);
 
 		[JsonProperty("data")]
 		public TMessage Data { get; init; } = message;