feat: update to 1.4.1

CypherPotato · CypherPotato · commit f3d75eef31d4 · 2025-04-02T00:53:54.000-03:00
diff --git a/extensions/Sisk.JsonRPC/Documentation/DocumentationDescriptor.cs b/extensions/Sisk.JsonRPC/Documentation/DocumentationDescriptor.cs
@@ -36,6 +36,6 @@ internal static JsonRpcDocumentation GetDocumentationDescriptor ( JsonRpcHandler
                     .ToArray () ) );
         }
 
-        return new JsonRpcDocumentation ( methods.ToArray (), metadata );
+        return new JsonRpcDocumentation ( methods.OrderBy ( m => m.MethodName ).ToArray (), metadata );
     }
 }
diff --git a/extensions/Sisk.JsonRPC/Documentation/JsonRpcJsonExport.cs b/extensions/Sisk.JsonRPC/Documentation/JsonRpcJsonExport.cs
@@ -44,17 +44,27 @@ public JsonRpcJsonExport ( JsonOptions options ) {
     /// <returns></returns>
     public JsonValue EncodeDocumentation ( JsonRpcDocumentation documentation ) {
         JsonArray arr = JsonOptions.CreateJsonArray ();
+        
+        static string GetTypeName ( Type type ) {
+            if (type.IsGenericType) {
+                string genericDefinition = string.Join ( ", ", type.GetGenericArguments ().Select ( s => s.Name ) );
+                return $"{type.Name}<{genericDefinition}>";
+            }
+            else {
+                return type.Name;
+            }
+        }
 
         foreach (var method in documentation.Methods) {
 
             var item = new {
                 Name = method.MethodName,
                 Description = method.Description,
-                Returns = method.ReturnType.Name,
+                Returns = GetTypeName ( method.ReturnType ),
                 Parameters = method.Parameters
                     .Select ( p => new {
                         Name = p.ParameterName,
-                        TypeName = p.ParameterType.Name,
+                        TypeName = GetTypeName ( p.ParameterType ),
                         Description = p.Description,
                         IsOptional = p.IsOptional
                     } )
diff --git a/extensions/Sisk.JsonRPC/JsonRpcMethodCollection.cs b/extensions/Sisk.JsonRPC/JsonRpcMethodCollection.cs
@@ -25,7 +25,8 @@ public sealed class JsonRpcMethodCollection {
     /// <param name="method">The delegate representing the method to add.</param>
     public void AddMethod ( string name, Delegate method ) {
         lock ((methods as ICollection).SyncRoot) {
-            methods.Add ( name, new RpcDelegate ( method.Method, method.Target ) );
+            var del = MethodScanner.ParseDelegate ( method.Method, method.Target, name );
+            methods.Add ( name, del );
         }
     }
 
@@ -35,10 +36,10 @@ public void AddMethod ( string name, Delegate method ) {
     /// <typeparam name="T">The type from which to scan and add methods.</typeparam>
     /// <param name="target">The target object instance containing the methods.</param>
     /// <param name="prefixTypes">Indicates whether to prefix method names with the type name.</param>
-    public void AddMethodsFromType<[DynamicallyAccessedMembers ( DynamicallyAccessedMemberTypes.PublicMethods )] T> ( T target, bool prefixTypes = false ) where T : notnull {
+    public void AddMethodsFromType<[DynamicallyAccessedMembers ( DynamicallyAccessedMemberTypes.All )] T> ( T target, bool prefixTypes = false ) where T : notnull {
         lock ((methods as ICollection).SyncRoot) {
             foreach (var method in MethodScanner.ScanMethods ( typeof ( T ), prefixTypes, target )) {
-                methods.Add ( method.Item1, method.Item2 );
+                methods.Add ( method.WebMethodName, method );
             }
         }
     }
@@ -49,10 +50,10 @@ public void AddMethod ( string name, Delegate method ) {
     /// <param name="type">The type from which to scan and add methods.</param>
     /// <param name="target">The target object instance containing the methods.</param>
     /// <param name="prefixTypes">Indicates whether to prefix method names with the type name.</param>
-    public void AddMethodsFromType ( [DynamicallyAccessedMembers ( DynamicallyAccessedMemberTypes.PublicMethods )] Type type, object? target, bool prefixTypes ) {
+    public void AddMethodsFromType ( [DynamicallyAccessedMembers ( DynamicallyAccessedMemberTypes.All )] Type type, object? target, bool prefixTypes ) {
         lock ((methods as ICollection).SyncRoot) {
             foreach (var method in MethodScanner.ScanMethods ( type, prefixTypes, target )) {
-                methods.Add ( method.Item1, method.Item2 );
+                methods.Add ( method.WebMethodName, method );
             }
         }
     }
@@ -62,13 +63,13 @@ public void AddMethodsFromType ( [DynamicallyAccessedMembers ( DynamicallyAccess
     /// </summary>
     /// <param name="type">The type from which to scan and add methods.</param>
     /// <param name="target">The target object instance containing the methods.</param>
-    public void AddMethodsFromType ( [DynamicallyAccessedMembers ( DynamicallyAccessedMemberTypes.PublicMethods )] Type type, object? target ) => AddMethodsFromType ( type, target, false );
+    public void AddMethodsFromType ( [DynamicallyAccessedMembers ( DynamicallyAccessedMemberTypes.All )] Type type, object? target ) => AddMethodsFromType ( type, target, false );
 
     /// <summary>
     /// Adds methods from the specified type to the collection without prefixing method names.
     /// </summary>
     /// <param name="type">The type from which to scan and add methods.</param>
-    public void AddMethodsFromType ( [DynamicallyAccessedMembers ( DynamicallyAccessedMemberTypes.PublicMethods )] Type type ) => AddMethodsFromType ( type, null, false );
+    public void AddMethodsFromType ( [DynamicallyAccessedMembers ( DynamicallyAccessedMemberTypes.All )] Type type ) => AddMethodsFromType ( type, null, false );
 
     /// <summary>
     /// Removes a method from the collection by its name.
diff --git a/extensions/Sisk.JsonRPC/JsonRpcResponse.cs b/extensions/Sisk.JsonRPC/JsonRpcResponse.cs
@@ -38,7 +38,12 @@ public sealed class JsonRpcResponse {
     internal JsonRpcResponse ( JsonValue? result, JsonRpcError? error, JsonValue id ) {
         Result = result;
         Error = error;
-        Id = id;
+        if (id.Type == JsonValueType.Undefined) {
+            Id = JsonValue.Null;
+        }
+        else {
+            Id = id;
+        }
     }
 
     /// <summary>
diff --git a/extensions/Sisk.JsonRPC/JsonRpcTransportLayer.cs b/extensions/Sisk.JsonRPC/JsonRpcTransportLayer.cs
@@ -7,7 +7,7 @@
 // File name:   JsonRpcTransportLayer.cs
 // Repository:  https://github.com/sisk-http/core
 
-using System.Diagnostics.CodeAnalysis;
+using System.Reflection;
 using System.Runtime.CompilerServices;
 using System.Text;
 using LightJson;
@@ -116,12 +116,17 @@ HttpResponse ImplTransportPostHttp ( HttpRequest request ) {
             response = HandleRpcRequest ( rpcRequest );
         }
         catch (Exception ex) {
-            response = new JsonRpcResponse ( null,
-                new JsonRpcError ( JsonErrorCode.InternalError, ex.Message, JsonValue.Null ), rpcRequest?.Id ?? "0" );
+            if (_handler._server.ServerConfiguration.ThrowExceptions) {
+                throw;
+            }
+            else {
+                response = new JsonRpcResponse ( null,
+                    new JsonRpcError ( JsonErrorCode.InternalError, ex.Message, JsonValue.Null ), rpcRequest?.Id ?? "0" );
+            }
         }
 
 sendResponse:
-        if (rpcRequest is not null && rpcRequest.Id.IsNull) {
+        if (rpcRequest is not null && rpcRequest.Id.IsNull && response.Error is null) {
             return new HttpResponse () {
                 Status = HttpStatusInformation.Accepted
             };
@@ -134,10 +139,8 @@ HttpResponse ImplTransportPostHttp ( HttpRequest request ) {
         }
     }
 
-    [DynamicDependency ( DynamicallyAccessedMemberTypes.PublicMethods, typeof ( Task<> ) )]
-    [DynamicDependency ( DynamicallyAccessedMemberTypes.PublicMethods, typeof ( TaskAwaiter<> ) )]
-    [SuppressMessage ( "Trimming", "IL2026:Using dynamic types might cause types or members to be removed by trimmer.", Justification = "<Pendente>" )]
-    [SuppressMessage ( "Trimming", "IL2072:Target parameter argument does not satisfy 'DynamicallyAccessedMembersAttribute' in call to target method. The return value of the source method does not have matching annotations.", Justification = "<Pending>" )]
+    [System.Diagnostics.CodeAnalysis.SuppressMessage ( "Trimming",
+        "IL2072:Target parameter argument does not satisfy 'DynamicallyAccessedMembersAttribute' in call to target method. The return value of the source method does not have matching annotations.", Justification = "<Pending>" )]
     JsonRpcResponse HandleRpcRequest ( JsonRpcRequest request ) {
         JsonRpcResponse response;
         try {
@@ -146,7 +149,7 @@ JsonRpcResponse HandleRpcRequest ( JsonRpcRequest request ) {
 
             if (method != null) {
                 var methodInfo = method.Method;
-                var methodParameters = methodInfo.GetParameters ();
+                var methodParameters = method.Parameters;
 
                 object? [] methodInvokationParameters = new object? [ methodParameters.Length ];
 
@@ -168,7 +171,7 @@ JsonRpcResponse HandleRpcRequest ( JsonRpcRequest request ) {
                     }
 
                     for (int i = 0; i < jsonValueList.Count; i++) {
-                        methodInvokationParameters [ i ] = jsonValueList [ i ].MaybeNull ()?.Get ( methodParameters [ i ].ParameterType );
+                        methodInvokationParameters [ i ] = jsonValueList [ i ].MaybeNull ()?.Get ( methodParameters [ i ].ParameterType ) ?? methodParameters [ i ].DefaultValue;
                     }
                 }
                 else {
@@ -194,18 +197,24 @@ JsonRpcResponse HandleRpcRequest ( JsonRpcRequest request ) {
                             return response;
                         }
 
-                        methodInvokationParameters [ i ] = jsonParameter.MaybeNull ()?.Get ( param.ParameterType );
+                        methodInvokationParameters [ i ] = jsonParameter.MaybeNull ()?.Get ( param.ParameterType ) ?? param.DefaultValue;
                     }
                 }
 
                 object? result = methodInfo.Invoke ( method.Target, methodInvokationParameters );
 
-                if (result is Task task) {
-                    result = ((dynamic) task).GetAwaiter ().GetResult ();
+                if (result is not null) {
+                    if (method.ReturnInformation.IsAsyncTask) {
+                        ref Task<object> actionTask = ref Unsafe.As<object, Task<object>> ( ref result );
+                        result = actionTask.GetAwaiter ().GetResult ();
+                    }
+                    else if (method.ReturnInformation.IsAsyncEnumerable) {
+                        ref IAsyncEnumerable<object> asyncEnumerable = ref Unsafe.As<object, IAsyncEnumerable<object>> ( ref result );
+                        result = asyncEnumerable.ToBlockingEnumerable ();
+                    }
                 }
 
                 JsonValue resultEncoded = JsonValue.Serialize ( result, _handler._jsonOptions );
-
                 response = new JsonRpcResponse ( resultEncoded, null, request.Id );
             }
             else {
@@ -216,13 +225,18 @@ JsonRpcResponse HandleRpcRequest ( JsonRpcRequest request ) {
         catch (JsonRpcException jex) {
             response = new JsonRpcResponse ( null, jex.AsRpcError (), request.Id );
         }
-        catch (Exception ex) {
+        catch (Exception erx) {
+            Exception ex = erx;
+            if (erx is TargetInvocationException)
+                ex = ex.InnerException ?? ex;
+
             if (_handler._server.ServerConfiguration.ThrowExceptions) {
                 throw;
             }
             else {
+                _handler._server.ServerConfiguration.ErrorsLogsStream?.WriteException ( erx );
                 response = new JsonRpcResponse ( null,
-               new JsonRpcError ( JsonErrorCode.InternalError, ex.Message, JsonValue.Null ), request?.Id ?? "0" );
+                    new JsonRpcError ( JsonErrorCode.InternalError, ex.Message, JsonValue.Null ), request?.Id ?? "0" );
             }
         }
         return response;
diff --git a/extensions/Sisk.JsonRPC/MethodScanner.cs b/extensions/Sisk.JsonRPC/MethodScanner.cs
@@ -14,7 +14,8 @@
 namespace Sisk.JsonRPC;
 
 internal static class MethodScanner {
-    public static IEnumerable<(string, RpcDelegate)> ScanMethods ( [DynamicallyAccessedMembers ( DynamicallyAccessedMemberTypes.PublicMethods )] Type type, bool prefixTypes, object? target ) {
+    
+    public static IEnumerable<RpcDelegate> ScanMethods ( [DynamicallyAccessedMembers ( DynamicallyAccessedMemberTypes.All )] Type type, bool prefixTypes, object? target ) {
         const BindingFlags Flags = BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static;
 
         var customTypeName = type.GetCustomAttribute<WebNameAttribute> ()?.Name;
@@ -24,14 +25,76 @@ internal static class MethodScanner {
             WebMethodAttribute? methodName = method.GetCustomAttribute<WebMethodAttribute> ();
 
             if (methodName is not null) {
+
                 string typeName = customTypeName ?? type.Name;
                 string name = methodName.Name ?? method.Name;
 
                 if (prefixTypes)
                     name = typeName + "." + name;
 
-                yield return (name, new RpcDelegate ( method, target ));
+                yield return ParseDelegate ( method, target, name );
+            }
+        }
+    }
+
+    public static RpcDelegate ParseDelegate ( MethodInfo method, object? target, string? name = null ) {
+        CheckIfMethodIsEligible ( method );
+
+        name ??= method.Name;
+        var parameters = GetParameters ( method ).ToArray ();
+
+        bool _isAsyncTask = false, _isAsyncEnumerable = false;
+        var retType = method.ReturnType;
+        if (retType.IsValueType) {
+            throw new NotSupportedException ( "Defining web methods which their return type is an value type is not supported. Encapsulate it with ValueResult<T>." );
+        }
+        else if (retType.IsAssignableTo ( typeof ( Task ) )) {
+            _isAsyncTask = true;
+            if (CheckAsyncReturnParameters ( retType, method ) is Exception rex) {
+                throw rex;
+            }
+        }
+        else if (retType.IsGenericType && retType.GetGenericTypeDefinition () == typeof ( IAsyncEnumerable<> )) {
+            _isAsyncEnumerable = true;
+            if (CheckAsyncReturnParameters ( retType, method ) is Exception rex) {
+                throw rex;
+            }
+        }
+
+        var returnInformation = new RpcDelegateMethodReturnInformation ( retType, _isAsyncEnumerable, _isAsyncTask );
+
+        return new RpcDelegate ( name, method, parameters, returnInformation, target );
+    }
+
+    public static IEnumerable<RpcDelegateMethodParameter> GetParameters ( MethodInfo method ) {
+        return method.GetParameters ()
+            .Select ( p => new RpcDelegateMethodParameter ( p.ParameterType, p.Name, p.IsOptional, p.DefaultValue ) );
+    }
+
+    static void CheckIfMethodIsEligible ( MethodInfo method ) {
+        var retType = method.ReturnType;
+        if (retType.IsValueType) {
+            throw new NotSupportedException ( "Defining web methods which their return type is an value type is not supported. Encapsulate it with ValueResult<T>." );
+        }
+        else if (retType.IsAssignableTo ( typeof ( Task ) )) {
+            if (CheckAsyncReturnParameters ( retType, method ) is Exception rex) {
+                throw rex;
+            }
+        }
+        else if (retType.IsGenericType && retType.GetGenericTypeDefinition () == typeof ( IAsyncEnumerable<> )) {
+            if (CheckAsyncReturnParameters ( retType, method ) is Exception rex) {
+                throw rex;
+            }
+        }
+    }
+
+    static Exception? CheckAsyncReturnParameters ( Type asyncOutType, MethodInfo method ) {
+        if (asyncOutType.GenericTypeArguments.Length == 1) {
+            Type genericAssignType = asyncOutType.GenericTypeArguments [ 0 ];
+            if (genericAssignType.IsValueType) {
+                return new NotSupportedException ( "Defining web methods which their return type is an value type is not supported. Encapsulate it with ValueResult<T>." );
             }
         }
+        return null;
     }
 }
diff --git a/extensions/Sisk.JsonRPC/RpcDelegate.cs b/extensions/Sisk.JsonRPC/RpcDelegate.cs
@@ -11,4 +11,6 @@
 
 namespace Sisk.JsonRPC;
 
-internal record class RpcDelegate ( MethodInfo Method, object? Target );
+internal record class RpcDelegate ( string WebMethodName, MethodInfo Method, RpcDelegateMethodParameter [] Parameters, RpcDelegateMethodReturnInformation ReturnInformation, object? Target );
+internal record class RpcDelegateMethodParameter ( Type ParameterType, string? Name, bool IsOptional, object? DefaultValue );
+internal record class RpcDelegateMethodReturnInformation ( Type ReturnType, bool IsAsyncEnumerable, bool IsAsyncTask );
diff --git a/extensions/Sisk.JsonRPC/Sisk.JsonRPC.csproj b/extensions/Sisk.JsonRPC/Sisk.JsonRPC.csproj
@@ -24,9 +24,9 @@
 		<PackageTags>http-server,http,web framework</PackageTags>
 		<RepositoryType>git</RepositoryType>
 
-		<AssemblyVersion>1.3.2</AssemblyVersion>
-		<FileVersion>1.3.2</FileVersion>
-		<Version>1.3.2</Version>
+		<AssemblyVersion>1.4.1</AssemblyVersion>
+		<FileVersion>1.4.1</FileVersion>
+		<Version>1.4.1</Version>
 
 		<NeutralLanguage>en</NeutralLanguage>
 		<PackageLicenseFile>LICENSE.txt</PackageLicenseFile>

Original file line number	Diff line number	Diff line change
`@@ -36,6 +36,6 @@ internal static JsonRpcDocumentation GetDocumentationDescriptor ( JsonRpcHandler`
`36`	`36`	`.ToArray () ) );`
`37`	`37`	`}`
`38`	`38`
`39`		`- return new JsonRpcDocumentation ( methods.ToArray (), metadata );`
	`39`	`+ return new JsonRpcDocumentation ( methods.OrderBy ( m => m.MethodName ).ToArray (), metadata );`
`40`	`40`	`}`
`41`	`41`	`}`