added domain events, fix IQueryalbeProvider abstraction, added support for sagas and RabbitMQ

2025-12-20 15:13:05 -05:00
parent 4051800934
commit 9b9e2cbdbe
57 changed files with 4951 additions and 91 deletions
@@ -17,11 +17,8 @@ internal static class ProtoFileTypeMapper
        var fullTypeName = typeSymbol.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat);
        var typeName = typeSymbol.Name;

-        // Nullable types - unwrap
-        if (typeSymbol.NullableAnnotation == NullableAnnotation.Annotated && typeSymbol is INamedTypeSymbol namedType && namedType.TypeArguments.Length > 0)
-        {
-            return MapType(namedType.TypeArguments[0], out needsImport, out importPath);
-        }
+        // Note: NullableAnnotation.Annotated is for reference type nullability (List<T>?, string?, etc.)
+        // We don't unwrap these - just use the underlying type. Nullable<T> value types are handled later.

        // Basic types
        switch (typeName)
@@ -75,17 +72,31 @@ internal static class ProtoFileTypeMapper
            return "string";
        }

-        if (fullTypeName.Contains("System.Decimal"))
+        if (fullTypeName.Contains("System.Decimal") || typeName == "Decimal" || fullTypeName == "decimal")
        {
            // Decimal serialized as string (no native decimal in proto)
            return "string";
        }

+        // Handle Nullable<T> value types (e.g., int?, decimal?, enum?)
+        if (typeSymbol is INamedTypeSymbol nullableType &&
+            nullableType.OriginalDefinition.SpecialType == SpecialType.System_Nullable_T &&
+            nullableType.TypeArguments.Length == 1)
+        {
+            // Unwrap the nullable and map the inner type
+            return MapType(nullableType.TypeArguments[0], out needsImport, out importPath);
+        }
+
        // Collections
        if (typeSymbol is INamedTypeSymbol collectionType)
        {
-            // List, IEnumerable, Array, etc.
-            if (collectionType.TypeArguments.Length == 1)
+            // List, IEnumerable, Array, ICollection etc. (but not Nullable<T>)
+            var typeName2 = collectionType.Name;
+            if (collectionType.TypeArguments.Length == 1 &&
+                (typeName2.Contains("List") || typeName2.Contains("Collection") ||
+                 typeName2.Contains("Enumerable") || typeName2.Contains("Array") ||
+                 typeName2.Contains("Set") || typeName2.Contains("IList") ||
+                 typeName2.Contains("ICollection") || typeName2.Contains("IEnumerable")))
            {
                var elementType = collectionType.TypeArguments[0];
                var protoElementType = MapType(elementType, out needsImport, out importPath);
@@ -188,4 +199,56 @@ internal static class ProtoFileTypeMapper

        return false;
    }
+
+    /// <summary>
+    /// Gets the element type from a collection type, or returns the type itself if not a collection.
+    /// Also unwraps Nullable types.
+    /// </summary>
+    public static ITypeSymbol GetElementOrUnderlyingType(ITypeSymbol typeSymbol)
+    {
+        // Unwrap Nullable<T>
+        if (typeSymbol is INamedTypeSymbol nullableType &&
+            nullableType.OriginalDefinition.SpecialType == SpecialType.System_Nullable_T &&
+            nullableType.TypeArguments.Length == 1)
+        {
+            return GetElementOrUnderlyingType(nullableType.TypeArguments[0]);
+        }
+
+        // Extract element type from collections
+        if (typeSymbol is INamedTypeSymbol collectionType && collectionType.TypeArguments.Length == 1)
+        {
+            var typeName = collectionType.Name;
+            if (typeName.Contains("List") || typeName.Contains("Collection") ||
+                typeName.Contains("Enumerable") || typeName.Contains("Array") ||
+                typeName.Contains("Set") || typeName.Contains("IList") ||
+                typeName.Contains("ICollection") || typeName.Contains("IEnumerable"))
+            {
+                return GetElementOrUnderlyingType(collectionType.TypeArguments[0]);
+            }
+        }
+
+        return typeSymbol;
+    }
+
+    /// <summary>
+    /// Checks if the type is an enum (including nullable enums)
+    /// </summary>
+    public static bool IsEnumType(ITypeSymbol typeSymbol)
+    {
+        var underlying = GetElementOrUnderlyingType(typeSymbol);
+        return underlying.TypeKind == TypeKind.Enum;
+    }
+
+    /// <summary>
+    /// Gets the enum type symbol if this is an enum or nullable enum, otherwise null
+    /// </summary>
+    public static INamedTypeSymbol? GetEnumType(ITypeSymbol typeSymbol)
+    {
+        var underlying = GetElementOrUnderlyingType(typeSymbol);
+        if (underlying.TypeKind == TypeKind.Enum && underlying is INamedTypeSymbol enumType)
+        {
+            return enumType;
+        }
+        return null;
+    }
 }