feat: add switch to use put as default update verb

src/Microsoft.OpenApi.OData.Reader/OpenApiConvertSettings.cs

@@ -19,7 +19,7 @@
     /// <summary>
     /// Gets/sets the service root.
     /// </summary>
     public Uri ServiceRoot { get; set; } = new Uri("http://localhost");
 
     /// <summary>
     /// Get/set the metadata version.
@@ -337,6 +337,15 @@
     /// </summary>
     public int ComposableFunctionsExpansionDepth { get; set; } = 1;
 
+    /// <summary>
+    /// Gets/sets a value indicating whether to use HTTP PUT method for update operations by default
+    /// instead of PATCH when no UpdateRestrictions annotation is present in the CSDL.
+    /// If false (default), PATCH will be used for updates.
+    /// If true, PUT will be used for updates.
+    /// This setting is ignored when UpdateRestrictions annotations are present in the CSDL.
+    /// </summary>
+    public bool UseHttpPutForUpdate { get; set; } = false;
+
     internal OpenApiConvertSettings Clone()
     {
         var newSettings = new OpenApiConvertSettings
@@ -392,7 +401,8 @@
             SemVerVersion = this.SemVerVersion,
             EnableAliasForOperationSegments = this.EnableAliasForOperationSegments,
             UseStringArrayForQueryOptionsSchema = this.UseStringArrayForQueryOptionsSchema,
-            ComposableFunctionsExpansionDepth = this.ComposableFunctionsExpansionDepth
+            ComposableFunctionsExpansionDepth = this.ComposableFunctionsExpansionDepth,
+            UseHttpPutForUpdate = this.UseHttpPutForUpdate
         };
 
         return newSettings;

src/Microsoft.OpenApi.OData.Reader/PathItem/ComplexPropertyItemHandler.cs

@@ -99,7 +99,16 @@
             }
             else
             {
-                AddOperation(item, HttpMethod.Patch);
+                // When no explicit update method is specified in UpdateRestrictions,
+                // use the UseHttpPutForUpdate setting to determine the default method
+                if (Context?.Settings?.UseHttpPutForUpdate == true)
+                {
+                    AddOperation(item, HttpMethod.Put);
+                }
+                else
+                {
+                    AddOperation(item, HttpMethod.Patch);
+                }
             }
         }
     }

src/Microsoft.OpenApi.OData.Reader/PathItem/EntityPathItemHandler.cs

@@ -28,7 +28,7 @@
         protected override ODataPathKind HandleKind => ODataPathKind.Entity;
 
         /// <inheritdoc/>
         protected override void SetOperations(OpenApiPathItem item)
         {
             var readRestrictions = string.IsNullOrEmpty(TargetPath) ? null : Context?.Model.GetRecord<ReadRestrictionsType>(TargetPath, CapabilitiesConstants.ReadRestrictions);
 
@@ -67,7 +67,16 @@
                 }
                 else
                 {
-                    AddOperation(item, HttpMethod.Patch);
+                    // When no explicit update method is specified in UpdateRestrictions,
+                    // use the UseHttpPutForUpdate setting to determine the default method
+                    if (Context?.Settings?.UseHttpPutForUpdate == true)
+                    {
+                        AddOperation(item, HttpMethod.Put);
+                    }
+                    else
+                    {
+                        AddOperation(item, HttpMethod.Patch);
+                    }
                 }
             }
 

src/Microsoft.OpenApi.OData.Reader/PathItem/NavigationPropertyPathItemHandler.cs

@@ -58,7 +58,7 @@
         private IEdmEntityType? _navPropEntityType;
 
         /// <inheritdoc/>
         protected override void SetOperations(OpenApiPathItem item)
         {
             IEdmVocabularyAnnotatable? target = NavigationSource switch {
                 IEdmEntitySet es => es,
@@ -175,7 +175,7 @@
             AddDeleteOperation(item, restriction);
         }
 
         private void AddGetOperation(OpenApiPathItem item, NavigationPropertyRestriction? restriction)
         {
             var navPropReadRestriction = string.IsNullOrEmpty(TargetPath) ? null : Context?.Model.GetRecord<ReadRestrictionsType>(TargetPath, CapabilitiesConstants.ReadRestrictions);
             navPropReadRestriction?.MergePropertiesIfNull(restriction?.ReadRestrictions);
@@ -198,7 +198,7 @@
 
             if (NavigationProperty.TargetMultiplicity() == EdmMultiplicity.Many)
             {
                 // TODO: $ref also supports Get ?
                 if (LastSegmentIsKeySegment)
                 {
                     if ((navPropReadRestriction?.ReadByKeyRestrictions?.IsReadable ?? true) &&
@@ -255,7 +255,7 @@
                 AddOperation(item, HttpMethod.Delete);
             }
             else if (navPropDeleteRestriction?.Deletable ?? false)
             {
                 // Add delete operation for non-contained nav. props only if explicitly set to true via annotation
                 // Note: Use Deletable and NOT IsDeletable
                 AddOperation(item, HttpMethod.Delete);
@@ -279,7 +279,16 @@
                 }
                 else
                 {
-                    AddOperation(item, HttpMethod.Patch);
+                    // When no explicit update method is specified in UpdateRestrictions,
+                    // use the UseHttpPutForUpdate setting to determine the default method
+                    if (Context?.Settings?.UseHttpPutForUpdate == true)
+                    {
+                        AddOperation(item, HttpMethod.Put);
+                    }
+                    else
+                    {
+                        AddOperation(item, HttpMethod.Patch);
+                    }
                 }
             }
 
@@ -300,7 +309,7 @@
         }
 
         /// <inheritdoc/>
         protected override void SetExtensions(OpenApiPathItem item)
         {
             if (Context is null || !Context.Settings.ShowMsDosGroupPath)
             {
@@ -324,7 +333,7 @@
 
                 var npSegment = path.LastSegment is ODataNavigationPropertySegment npS ? 
                                 npS :
                                 path.Segments[path.Count - 2] is ODataNavigationPropertySegment npSegmentFallback ?
                                 npSegmentFallback :
                                 null;
 				if (NavigationProperty != npSegment?.NavigationProperty)

src/Microsoft.OpenApi.OData.Reader/PublicAPI.Unshipped.txt

@@ -221,6 +221,8 @@ Microsoft.OpenApi.OData.OpenApiConvertSettings.UseStringArrayForQueryOptionsSche
 Microsoft.OpenApi.OData.OpenApiConvertSettings.UseStringArrayForQueryOptionsSchema.set -> void
 Microsoft.OpenApi.OData.OpenApiConvertSettings.UseSuccessStatusCodeRange.get -> bool
 Microsoft.OpenApi.OData.OpenApiConvertSettings.UseSuccessStatusCodeRange.set -> void
+Microsoft.OpenApi.OData.OpenApiConvertSettings.UseHttpPutForUpdate.get -> bool
+Microsoft.OpenApi.OData.OpenApiConvertSettings.UseHttpPutForUpdate.set -> void
 Microsoft.OpenApi.OData.OpenApiConvertSettings.VerifyEdmModel.get -> bool
 Microsoft.OpenApi.OData.OpenApiConvertSettings.VerifyEdmModel.set -> void
 Microsoft.OpenApi.OData.Vocabulary.Core.LinkRelKey

src/OoasUtil/ComLineProcessor.cs

@@ -99,6 +99,11 @@ public ComLineProcessor(string[] args)
         /// </summary>
         public bool? RequireDerivedTypesConstraint { get; private set; }
 
+        /// <summary>
+        /// Use HTTP PUT method for update operations by default instead of PATCH.
+        /// </summary>
+        public bool? UseHttpPutForUpdate { get; private set; }
+
         /// <summary>
         /// Process the arguments.
         /// </summary>
@@ -227,6 +232,14 @@ public bool Process()
                             }
                             break;
 
+                        case "--useputforupdate":
+                        case "-put":
+                            if (!ProcessUseHttpPutForUpdate(true))
+                            {
+                                return false;
+                            }
+                            break;
+
                         default:
                             PrintUsage();
                             return false;
@@ -285,6 +298,11 @@ public bool Process()
                 DisableSchemaExamples = false;
             }
 
+            if (UseHttpPutForUpdate == null)
+            {
+                UseHttpPutForUpdate = false;
+            }
+
             _continue = ValidateArguments();
             return _continue;
         }
@@ -419,6 +437,19 @@ private bool ProcessDisableSchemaExamples(bool disableSchemaExamples)
             return true;
         }
 
+        private bool ProcessUseHttpPutForUpdate(bool useHttpPutForUpdate)
+        {
+            if (UseHttpPutForUpdate != null)
+            {
+                Console.WriteLine("[Error:] Multiple [--useputforupdate|-put] are not allowed.\n");
+                PrintUsage();
+                return false;
+            }
+
+            UseHttpPutForUpdate = useHttpPutForUpdate;
+            return true;
+        }
+
         private bool ProcessTarget(int version)
         {
             if (Version != null)
@@ -484,6 +515,7 @@ public static void PrintUsage()
             sb.Append("  --enablepagination|-p\t\t\tSet the output to expose pagination for collections.\n");
             sb.Append("  --enableunqualifiedcall|-u\t\t\tSet the output to use unqualified calls for bound operations.\n");
             sb.Append("  --disableschemaexamples|-x\t\t\tDisable examples in the schema.\n");
+            sb.Append("  --useputforupdate|-put\t\t\tUse HTTP PUT method for update operations instead of PATCH by default.\n");
             sb.Append("  --json|-j\t\t\tSet the output format as JSON.\n");
             sb.Append("  --yaml|-y\t\t\tSet the output format as YAML.\n");
             sb.Append("  --specversion|-s IntVersion\tSet the OpenApi Specification version of the output. Only 2 or 3 are supported.\n");

src/OoasUtil/Program.cs

@@ -14,7 +14,7 @@
     {
         static async System.Threading.Tasks.Task<int> Main(string[] args)
         {
             // args = new[] { "--json", "--input", @"E:\work\OneApiDesign\test\TripService.OData.xml", "-o", @"E:\work\OneApiDesign\test1\Trip.json" };
             // args = new[] { "--yaml", "-i", @"E:\work\OneApiDesign\test\TripService.OData.xml", "-o", @"E:\work\OneApiDesign\test1\Trip.yaml" };
             // args = new[] { "--yaml", "--input", @"http://services.odata.org/TrippinRESTierService", "-o", @"E:\work\OneApiDesign\test1\TripUrl.yaml" };
             // args = new[] { "--json", "-i", @"http://services.odata.org/TrippinRESTierService", "-o", @"E:\work\OneApiDesign\test1\TripUrl.json" };
@@ -42,6 +42,7 @@
                 EnableUnqualifiedCall = processor.EnableUnqualifiedCall.Value,
                 ShowSchemaExamples = !processor.DisableSchemaExamples.Value,
                 OpenApiSpecVersion = processor.Version.Value,
+                UseHttpPutForUpdate = processor.UseHttpPutForUpdate.Value,
             };
 
             if (processor.IsLocalFile)

test/Microsoft.OpenAPI.OData.Reader.Tests/PathItem/ComplexPropertyPathItemHandlerTests.cs

@@ -263,4 +263,101 @@ public void CreatesComplexPropertyPathsBasedOnTargetPathAnnotations(string reada
             Assert.True(pathItem.Operations.ContainsKey(HttpMethod.Get));
         }
     }
+
+	[Theory]
+	[InlineData(false, 2)]
+	[InlineData(true, 2)]
+	public void CreatesComplexPropertyPathItemUsesHttpPutForUpdateWhenSettingIsEnabled(bool useHttpPutForUpdate, int operationCount)
+	{
+		// Arrange
+		var annotation = @"
+<Annotation Term=""Org.OData.Capabilities.V1.UpdateRestrictions"">
+  <Record>
+	<PropertyValue Property=""Updatable"" Bool=""true"" />
+  </Record>
+</Annotation>
+<Annotation Term=""Org.OData.Capabilities.V1.ReadRestrictions"">
+  <Record>
+	<PropertyValue Property=""Readable"" Bool=""true"" />
+  </Record>
+</Annotation>";
+		var target = @"""NS.Customer/BillingAddress""";
+		var model = EntitySetPathItemHandlerTests.GetEdmModel(annotation: annotation, target: target);
+		var convertSettings = new OpenApiConvertSettings
+		{
+			UseHttpPutForUpdate = useHttpPutForUpdate
+		};
+		var context = new ODataContext(model, convertSettings);
+		var entitySet = model.EntityContainer.FindEntitySet("Customers");
+		Assert.NotNull(entitySet); // guard
+		var entityType = entitySet.EntityType;
+		var property = entityType.FindProperty("BillingAddress");
+		Assert.NotNull(property); // guard
+		var path = new ODataPath(new ODataNavigationSourceSegment(entitySet), new ODataKeySegment(entityType), new ODataComplexPropertySegment(property as IEdmStructuralProperty));
+		Assert.Equal(ODataPathKind.ComplexProperty, path.Kind); // guard
+
+		// Act
+		var pathItem = _pathItemHandler.CreatePathItem(context, path);
+
+		// Assert
+		Assert.NotNull(pathItem);
+		Assert.Equal(operationCount, pathItem.Operations?.Count ?? 0);
+
+		Assert.True(pathItem.Operations.ContainsKey(HttpMethod.Get));
+		if (useHttpPutForUpdate)
+		{
+			Assert.True(pathItem.Operations.ContainsKey(HttpMethod.Put));
+			Assert.False(pathItem.Operations.ContainsKey(HttpMethod.Patch));
+		}
+		else
+		{
+			Assert.True(pathItem.Operations.ContainsKey(HttpMethod.Patch));
+			Assert.False(pathItem.Operations.ContainsKey(HttpMethod.Put));
+		}
+	}
+
+	[Fact]
+	public void CreateComplexPropertyPathItemPrefersUpdateMethodAnnotationOverUseHttpPutForUpdateSetting()
+	{
+		// Arrange - annotation specifies PUT explicitly, setting is disabled (default PATCH)
+		var annotation = @"
+<Annotation Term=""Org.OData.Capabilities.V1.UpdateRestrictions"">
+  <Record>
+    <PropertyValue Property=""UpdateMethod"">
+      <EnumMember>Org.OData.Capabilities.V1.HttpMethod/PUT</EnumMember>
+    </PropertyValue>
+	<PropertyValue Property=""Updatable"" Bool=""true"" />
+  </Record>
+</Annotation>
+<Annotation Term=""Org.OData.Capabilities.V1.ReadRestrictions"">
+  <Record>
+	<PropertyValue Property=""Readable"" Bool=""true"" />
+  </Record>
+</Annotation>";
+		var target = @"""NS.Customer/BillingAddress""";
+		var model = EntitySetPathItemHandlerTests.GetEdmModel(annotation: annotation, target: target);
+		var convertSettings = new OpenApiConvertSettings
+		{
+			UseHttpPutForUpdate = false // Setting says use PATCH (default)
+		};
+		var context = new ODataContext(model, convertSettings);
+		var entitySet = model.EntityContainer.FindEntitySet("Customers");
+		Assert.NotNull(entitySet); // guard
+		var entityType = entitySet.EntityType;
+		var property = entityType.FindProperty("BillingAddress");
+		Assert.NotNull(property); // guard
+		var path = new ODataPath(new ODataNavigationSourceSegment(entitySet), new ODataKeySegment(entityType), new ODataComplexPropertySegment(property as IEdmStructuralProperty));
+		Assert.Equal(ODataPathKind.ComplexProperty, path.Kind); // guard
+
+		// Act
+		var pathItem = _pathItemHandler.CreatePathItem(context, path);
+
+		// Assert
+		Assert.NotNull(pathItem);
+		Assert.Equal(2, pathItem.Operations?.Count ?? 0);
+		Assert.True(pathItem.Operations.ContainsKey(HttpMethod.Get));
+		// Should use PUT from annotation, not PATCH from setting
+		Assert.True(pathItem.Operations.ContainsKey(HttpMethod.Put));
+		Assert.False(pathItem.Operations.ContainsKey(HttpMethod.Patch));
+	}
 }

test/Microsoft.OpenAPI.OData.Reader.Tests/PathItem/EntityPathItemHandlerTests.cs

@@ -232,6 +232,67 @@ public void CreateEntityPathItemWorksForUpdateMethodRestrictionsCapabilities(boo
             VerifyPathItemOperations(annotation, expected);
         }
 
+        [Theory]
+        [InlineData(false, new string[] { "get", "patch", "delete" })]
+        [InlineData(true, new string[] { "get", "put", "delete" })]
+        public void CreateEntityPathItemUsesHttpPutForUpdateWhenSettingIsEnabled(bool useHttpPutForUpdate, string[] expected)
+        {
+            // Arrange
+            IEdmModel model = EntitySetPathItemHandlerTests.GetEdmModel(annotation: "");
+            OpenApiConvertSettings settings = new OpenApiConvertSettings
+            {
+                UseHttpPutForUpdate = useHttpPutForUpdate
+            };
+            ODataContext context = new ODataContext(model, settings);
+            IEdmEntitySet entitySet = model.EntityContainer.FindEntitySet("Customers");
+            Assert.NotNull(entitySet); // guard
+            ODataPath path = new ODataPath(new ODataNavigationSourceSegment(entitySet), new ODataKeySegment(entitySet.EntityType));
+
+            // Act
+            var pathItem = _pathItemHandler.CreatePathItem(context, path);
+
+            // Assert
+            Assert.NotNull(pathItem);
+
+            Assert.NotNull(pathItem.Operations);
+            Assert.NotEmpty(pathItem.Operations);
+            Assert.Equal(expected, pathItem.Operations.Select(e => e.Key.ToString().ToLowerInvariant()));
+        }
+
+        [Fact]
+        public void CreateEntityPathItemPrefersUpdateMethodAnnotationOverUseHttpPutForUpdateSetting()
+        {
+            // Arrange - annotation specifies PUT explicitly, setting is disabled (default PATCH)
+            string annotation = @"
+<Annotation Term=""Org.OData.Capabilities.V1.UpdateRestrictions"">
+  <Record>
+    <PropertyValue Property=""UpdateMethod"">
+      <EnumMember>Org.OData.Capabilities.V1.HttpMethod/PUT</EnumMember>
+    </PropertyValue>
+  </Record>
+</Annotation>";
+
+            IEdmModel model = EntitySetPathItemHandlerTests.GetEdmModel(annotation);
+            OpenApiConvertSettings settings = new OpenApiConvertSettings
+            {
+                UseHttpPutForUpdate = false // Setting says use PATCH (default)
+            };
+            ODataContext context = new ODataContext(model, settings);
+            IEdmEntitySet entitySet = model.EntityContainer.FindEntitySet("Customers");
+            Assert.NotNull(entitySet); // guard
+            ODataPath path = new ODataPath(new ODataNavigationSourceSegment(entitySet), new ODataKeySegment(entitySet.EntityType));
+
+            // Act
+            var pathItem = _pathItemHandler.CreatePathItem(context, path);
+
+            // Assert
+            Assert.NotNull(pathItem);
+            Assert.NotNull(pathItem.Operations);
+            Assert.NotEmpty(pathItem.Operations);
+            // Should use PUT from annotation, not PATCH from setting
+            Assert.Equal(new string[] { "get", "put", "delete" }, pathItem.Operations.Select(e => e.Key.ToString().ToLowerInvariant()));
+        }
+
         private void VerifyPathItemOperations(string annotation, string[] expected)
         {
             // Arrange