Merge pull request #37 from oproto/main

Merge main back into develop

Author: dguisinger

.kiro/specs/dictionary-schema-support/tasks.md

@@ -6,87 +6,87 @@ This implementation adds proper dictionary type handling to the Oproto.Lambda.Op
 
 ## Tasks
 
-- [ ] 1. Implement dictionary type detection
-  - [ ] 1.1 Add `IsDictionaryType` method to `OpenApiSpecGenerator_Types.cs`
+- [x] 1. Implement dictionary type detection
+  - [x] 1.1 Add `IsDictionaryType` method to `OpenApiSpecGenerator_Types.cs`
     - Implement detection for `Dictionary<K,V>`, `IDictionary<K,V>`, `IReadOnlyDictionary<K,V>`
     - Extract key and value type symbols from type arguments
     - Check for interface implementation for custom dictionary types
     - _Requirements: 1.1, 1.2, 1.3, 1.4, 1.5_
 
-- [ ] 2. Implement dictionary schema generation
-  - [ ] 2.1 Add `TryCreateDictionarySchema` method to `OpenApiSpecGenerator_Schema.cs`
+- [x] 2. Implement dictionary schema generation
+  - [x] 2.1 Add `TryCreateDictionarySchema` method to `OpenApiSpecGenerator_Schema.cs`
     - Create schema with `type: "object"` and `additionalProperties`
     - Recursively call `CreateSchema` for the value type
     - Apply `[OpenApiSchema]` attributes (Description, Example) to dictionary schema
     - _Requirements: 2.1, 2.2, 2.3, 2.4, 2.5, 3.1, 3.2, 3.3, 6.1, 6.2_
 
-  - [ ] 2.2 Integrate dictionary detection into `CreateSchema` pipeline
+  - [x] 2.2 Integrate dictionary detection into `CreateSchema` pipeline
     - Add `TryCreateDictionarySchema` call after `TryCreateCollectionSchema` and before complex type handling
     - Ensure dictionaries don't fall through to `CreateComplexTypeSchema`
     - _Requirements: 5.1, 5.2, 5.3_
 
-  - [ ] 2.3 Handle nullable dictionary types
+  - [x] 2.3 Handle nullable dictionary types
     - Ensure nullable dictionaries (`Dictionary<K,V>?`) produce `nullable: true` in schema
     - Handle nullable reference type annotations on dictionary properties
     - _Requirements: 4.1, 4.2_
 
-- [ ] 3. Checkpoint - Verify implementation compiles
+- [x] 3. Checkpoint - Verify implementation compiles
   - Run `dotnet build` on the source generator project
   - Ensure no compiler warnings or errors
   - Ensure all tests pass, ask the user if questions arise
 
-- [ ] 4. Add unit tests for dictionary schema generation
-  - [ ] 4.1 Add basic dictionary type tests to `OpenApiGeneratorTests.cs`
+- [x] 4. Add unit tests for dictionary schema generation
+  - [x] 4.1 Add basic dictionary type tests to `OpenApiGeneratorTests.cs`
     - Test `Dictionary<string, string>` produces correct schema
     - Test `Dictionary<string, int>` produces integer additionalProperties
     - Test `Dictionary<string, bool>` produces boolean additionalProperties
     - Test `Dictionary<string, decimal>` produces number additionalProperties
     - Test `Dictionary<string, DateTime>` produces string with date-time format
     - _Requirements: 2.1, 2.2, 2.3, 2.4, 2.5_
 
-  - [ ] 4.2 Add complex value type tests
+  - [x] 4.2 Add complex value type tests
     - Test `Dictionary<string, ComplexType>` produces $ref in additionalProperties
     - Test `Dictionary<string, List<string>>` produces nested array schema
     - Test `Dictionary<string, Dictionary<string, int>>` produces nested dictionary schema
     - _Requirements: 3.1, 3.2, 3.3_
 
-  - [ ] 4.3 Add nullable dictionary tests
+  - [x] 4.3 Add nullable dictionary tests
     - Test nullable dictionary property produces `nullable: true`
     - Test `Dictionary<string, T>?` produces `nullable: true`
     - _Requirements: 4.1, 4.2_
 
-  - [ ] 4.4 Add dictionary interface tests
+  - [x] 4.4 Add dictionary interface tests
     - Test `IDictionary<string, T>` is detected as dictionary
     - Test `IReadOnlyDictionary<string, T>` is detected as dictionary
     - _Requirements: 1.2, 1.3_
 
-  - [ ] 4.5 Add attribute support tests
+  - [x] 4.5 Add attribute support tests
     - Test `[OpenApiSchema(Description = "...")]` applies to dictionary schema
     - Test `[OpenApiSchema(Example = "...")]` applies to dictionary schema
     - _Requirements: 6.1, 6.2_
 
-- [ ] 5. Add property-based tests for dictionary handling
-  - [ ] 5.1 Write property test for dictionary type detection
+- [x] 5. Add property-based tests for dictionary handling
+  - [x] 5.1 Write property test for dictionary type detection
     - **Property 1: Dictionary Type Detection**
     - **Validates: Requirements 1.1, 1.2, 1.3, 1.4, 1.5**
 
-  - [ ] 5.2 Write property test for dictionary schema structure
+  - [x] 5.2 Write property test for dictionary schema structure
     - **Property 2: Dictionary Schema Structure**
     - **Validates: Requirements 5.2**
 
-  - [ ] 5.3 Write property test for simple value type mapping
+  - [x] 5.3 Write property test for simple value type mapping
     - **Property 3: Simple Value Type Schema**
     - **Validates: Requirements 2.1, 2.2, 2.3, 2.4, 2.5**
 
-  - [ ] 5.4 Write property test for complex value type references
+  - [x] 5.4 Write property test for complex value type references
     - **Property 4: Complex Value Type Reference**
     - **Validates: Requirements 3.1**
 
-  - [ ] 5.5 Write property test for nullable dictionary handling
+  - [x] 5.5 Write property test for nullable dictionary handling
     - **Property 5: Nullable Dictionary Handling**
     - **Validates: Requirements 4.1, 4.2**
 
-- [ ] 6. Final checkpoint - Ensure all tests pass
+- [x] 6. Final checkpoint - Ensure all tests pass
   - Run full test suite with `dotnet test`
   - Verify no regressions in existing functionality
   - Ensure all tests pass, ask the user if questions arise

Oproto.Lambda.OpenApi.Build/ExtractOpenApiSpecTask.cs

@@ -248,22 +248,55 @@ private string TryExtractViaReflection()
             var assemblyDir = Path.GetDirectoryName(AssemblyPath);
             Log.LogMessage(MessageImportance.High, $"Trying reflection extraction from: {assemblyDir}");
 
-            // Collect all DLLs in the output directory for the resolver
-            var assemblyPaths = new List<string> { AssemblyPath };
+            // Collect assemblies for the resolver, avoiding duplicates that cause
+            // "assembly has already been loaded" errors in MetadataLoadContext.
+            // This can happen when:
+            // 1. Same assembly exists in multiple directories (output + runtime)
+            // 2. Different SDK version (e.g., .NET 10) builds a different target (e.g., .NET 8)
+            var assemblyPathsByName = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+            
+            // Add the target assembly first
+            assemblyPathsByName[Path.GetFileName(AssemblyPath)] = AssemblyPath;
+            
+            // Add assemblies from output directory - these should match the target framework
             if (assemblyDir != null)
             {
-                assemblyPaths.AddRange(Directory.GetFiles(assemblyDir, "*.dll"));
+                foreach (var dll in Directory.GetFiles(assemblyDir, "*.dll"))
+                {
+                    var fileName = Path.GetFileName(dll);
+                    if (!assemblyPathsByName.ContainsKey(fileName))
+                    {
+                        assemblyPathsByName[fileName] = dll;
+                    }
+                }
             }
 
-            // Add core library path
-            var coreAssemblyPath = typeof(object).Assembly.Location;
-            var coreDir = Path.GetDirectoryName(coreAssemblyPath);
-            if (coreDir != null)
+            // Try to find the target framework's reference assemblies from the SDK packs
+            // This is more reliable than using the running runtime when SDK version differs from target
+            var referenceAssembliesAdded = TryAddReferenceAssemblies(assemblyPathsByName);
+            
+            // Only fall back to running runtime assemblies if we couldn't find reference assemblies
+            // and the output directory doesn't have core assemblies (e.g., System.Private.CoreLib)
+            if (!referenceAssembliesAdded && !assemblyPathsByName.ContainsKey("System.Private.CoreLib.dll"))
             {
-                assemblyPaths.AddRange(Directory.GetFiles(coreDir, "*.dll"));
+                var coreAssemblyPath = typeof(object).Assembly.Location;
+                var coreDir = Path.GetDirectoryName(coreAssemblyPath);
+                if (coreDir != null)
+                {
+                    Log.LogMessage(MessageImportance.Low, 
+                        $"Adding runtime assemblies from: {coreDir}");
+                    foreach (var dll in Directory.GetFiles(coreDir, "*.dll"))
+                    {
+                        var fileName = Path.GetFileName(dll);
+                        if (!assemblyPathsByName.ContainsKey(fileName))
+                        {
+                            assemblyPathsByName[fileName] = dll;
+                        }
+                    }
+                }
             }
 
-            var resolver = new PathAssemblyResolver(assemblyPaths.Distinct());
+            var resolver = new PathAssemblyResolver(assemblyPathsByName.Values);
             using var mlc = new MetadataLoadContext(resolver);
 
             var assembly = mlc.LoadFromAssemblyPath(AssemblyPath);
@@ -301,4 +334,77 @@ private string TryExtractViaReflection()
             return null;
         }
     }
+
+    /// <summary>
+    /// Attempts to add reference assemblies from the .NET SDK packs directory.
+    /// This ensures we use assemblies matching the target framework, not the running SDK.
+    /// </summary>
+    private bool TryAddReferenceAssemblies(Dictionary<string, string> assemblyPathsByName)
+    {
+        try
+        {
+            // Try to determine target framework from the assembly path (e.g., bin/Debug/net8.0/)
+            var assemblyDir = Path.GetDirectoryName(AssemblyPath);
+            if (assemblyDir == null) return false;
+
+            var tfmDir = Path.GetFileName(assemblyDir); // e.g., "net8.0"
+            if (string.IsNullOrEmpty(tfmDir) || !tfmDir.StartsWith("net")) return false;
+
+            // Look for reference assemblies in the SDK packs directory
+            // Typical path: ~/.dotnet/packs/Microsoft.NETCore.App.Ref/{version}/ref/{tfm}/
+            var dotnetRoot = Environment.GetEnvironmentVariable("DOTNET_ROOT");
+            if (string.IsNullOrEmpty(dotnetRoot))
+            {
+                // Try common locations
+                var home = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);
+                var possibleRoots = new[]
+                {
+                    Path.Combine(home, ".dotnet"),
+                    "/usr/share/dotnet",
+                    "/usr/local/share/dotnet",
+                    @"C:\Program Files\dotnet"
+                };
+                dotnetRoot = possibleRoots.FirstOrDefault(Directory.Exists);
+            }
+
+            if (string.IsNullOrEmpty(dotnetRoot) || !Directory.Exists(dotnetRoot)) return false;
+
+            var packsDir = Path.Combine(dotnetRoot, "packs", "Microsoft.NETCore.App.Ref");
+            if (!Directory.Exists(packsDir)) return false;
+
+            // Find the appropriate version directory
+            var versionDirs = Directory.GetDirectories(packsDir)
+                .Select(d => new { Path = d, Name = Path.GetFileName(d) })
+                .Where(d => d.Name.StartsWith(tfmDir.Replace("net", ""))) // e.g., "8.0" for "net8.0"
+                .OrderByDescending(d => d.Name)
+                .ToList();
+
+            foreach (var versionDir in versionDirs)
+            {
+                var refDir = Path.Combine(versionDir.Path, "ref", tfmDir);
+                if (Directory.Exists(refDir))
+                {
+                    Log.LogMessage(MessageImportance.Low, 
+                        $"Adding reference assemblies from: {refDir}");
+                    foreach (var dll in Directory.GetFiles(refDir, "*.dll"))
+                    {
+                        var fileName = Path.GetFileName(dll);
+                        if (!assemblyPathsByName.ContainsKey(fileName))
+                        {
+                            assemblyPathsByName[fileName] = dll;
+                        }
+                    }
+                    return true;
+                }
+            }
+
+            return false;
+        }
+        catch (Exception ex)
+        {
+            Log.LogMessage(MessageImportance.Low, 
+                $"Could not locate reference assemblies: {ex.Message}");
+            return false;
+        }
+    }
 }

Oproto.Lambda.OpenApi.Examples/Oproto.Lambda.OpenApi.Examples.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net8.0</TargetFramework>
+    <TargetFrameworks>net8.0;net10.0</TargetFrameworks>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
     <GenerateRuntimeConfigurationFiles>true</GenerateRuntimeConfigurationFiles>
@@ -42,7 +42,8 @@
   <UsingTask TaskName="Oproto.Lambda.OpenApi.Build.ExtractOpenApiSpecTask"
              AssemblyFile="..\Oproto.Lambda.OpenApi.Build\bin\$(Configuration)\netstandard2.0\Oproto.Lambda.OpenApi.Build.dll"/>
 
-  <Target Name="GenerateOpenApi" AfterTargets="Build">
+  <!-- Only run OpenAPI generation during inner builds (when TargetFramework is set) -->
+  <Target Name="GenerateOpenApi" AfterTargets="Build" Condition="'$(TargetFramework)' != ''">
     <Message Text="Starting OpenAPI Generation" Importance="high"/>
     <ExtractOpenApiSpecTask
       AssemblyPath="$(TargetDir)$(TargetFileName)"

Oproto.Lambda.OpenApi.Merge.Cdk/Oproto.Lambda.OpenApi.Merge.Cdk.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net8.0</TargetFramework>
+    <TargetFrameworks>net8.0;net10.0</TargetFrameworks>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
     <LangVersion>12</LangVersion>

Oproto.Lambda.OpenApi.Merge.Lambda.Tests/Oproto.Lambda.OpenApi.Merge.Lambda.Tests.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net8.0</TargetFramework>
+    <TargetFrameworks>net8.0;net10.0</TargetFrameworks>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
     <LangVersion>12</LangVersion>

Oproto.Lambda.OpenApi.Merge.Lambda/Oproto.Lambda.OpenApi.Merge.Lambda.csproj

@@ -1,6 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
+    <!-- Lambda runtime target - set to net10.0 for .NET 10 Lambda runtime -->
     <TargetFramework>net8.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>

Oproto.Lambda.OpenApi.Merge.Tests/Oproto.Lambda.OpenApi.Merge.Tests.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net8.0</TargetFramework>
+    <TargetFrameworks>net8.0;net10.0</TargetFrameworks>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
     <LangVersion>12</LangVersion>

Oproto.Lambda.OpenApi.Merge.Tool/Oproto.Lambda.OpenApi.Merge.Tool.csproj

@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net8.0</TargetFramework>
+    <TargetFrameworks>net8.0;net10.0</TargetFrameworks>
     <LangVersion>12</LangVersion>
     <Nullable>enable</Nullable>
     <ImplicitUsings>enable</ImplicitUsings>

Oproto.Lambda.OpenApi.Merge/Oproto.Lambda.OpenApi.Merge.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>netstandard2.0</TargetFramework>
+    <TargetFrameworks>netstandard2.0;net8.0;net10.0</TargetFrameworks>
     <LangVersion>12</LangVersion>
     <Nullable>enable</Nullable>
     <GeneratePackageOnBuild>true</GeneratePackageOnBuild>

Oproto.Lambda.OpenApi.SourceGenerator/OpenApiSpecGenerator.cs

@@ -1762,7 +1762,8 @@ private OpenApiSchema CreateComplexTypeSchema(ITypeSymbol typeSymbol)
                         a.AttributeClass?.Name is "OpenApiIgnore" or "OpenApiIgnoreAttribute"))
                     continue;
 
-                var propertySchema = CreateSchema(member.Type);
+                // Pass the member symbol to CreateSchema so nullable annotations can be detected
+                var propertySchema = CreateSchema(member.Type, member);
                 if (propertySchema != null)
                 {
                     // Get attributes from both the current property and its base if it's an override