diff --git a/src/Microsoft.OpenApi/Interfaces/IOpenApiReferenceHolder.cs b/src/Microsoft.OpenApi/Interfaces/IOpenApiReferenceHolder.cs index 9d0c05168..28aeb998d 100644 --- a/src/Microsoft.OpenApi/Interfaces/IOpenApiReferenceHolder.cs +++ b/src/Microsoft.OpenApi/Interfaces/IOpenApiReferenceHolder.cs @@ -7,23 +7,35 @@ namespace Microsoft.OpenApi /// A generic interface for OpenApiReferenceable objects that have a target. /// /// The type of the target being referenced - /// The type of the interface implemented by both the target and the reference type - public interface IOpenApiReferenceHolder : IOpenApiReferenceHolder where T : IOpenApiReferenceable, V + /// The type of the interface implemented by both the target and the reference type + /// The type for the reference holding the additional fields and annotations + public interface IOpenApiReferenceHolder : IOpenApiReferenceHolder where T : IOpenApiReferenceable, U where V : BaseOpenApiReference, new() { /// /// Gets the resolved target object. /// - V? Target { get; } - + U? Target { get; } + /// /// Gets the recursively resolved target object. /// T? RecursiveTarget { get; } - + /// /// Copy the reference as a target element with overrides. /// - V CopyReferenceAsTargetElementWithOverrides(V source); + U CopyReferenceAsTargetElementWithOverrides(U source); + } + /// + /// A generic interface for OpenApiReferenceable objects that have a target. + /// + /// The type for the reference holding the additional fields and annotations + public interface IOpenApiReferenceHolder : IOpenApiReferenceHolder where V : BaseOpenApiReference, new() + { + /// + /// Reference object. + /// + V Reference { get; init; } } /// /// A generic interface for OpenApiReferenceable objects that have a target. @@ -34,10 +46,5 @@ public interface IOpenApiReferenceHolder : IOpenApiSerializable /// Indicates if object is populated with data or is just a reference to the data /// bool UnresolvedReference { get; } - - /// - /// Reference object. - /// - OpenApiReference Reference { get; init; } } } diff --git a/src/Microsoft.OpenApi/Models/OpenApiReference.cs b/src/Microsoft.OpenApi/Models/BaseOpenApiReference.cs similarity index 80% rename from src/Microsoft.OpenApi/Models/OpenApiReference.cs rename to src/Microsoft.OpenApi/Models/BaseOpenApiReference.cs index 4bfb6748b..86377b8b2 100644 --- a/src/Microsoft.OpenApi/Models/OpenApiReference.cs +++ b/src/Microsoft.OpenApi/Models/BaseOpenApiReference.cs @@ -11,21 +11,8 @@ namespace Microsoft.OpenApi /// /// A simple object to allow referencing other components in the specification, internally and externally. /// - public class OpenApiReference : IOpenApiSerializable, IOpenApiDescribedElement, IOpenApiSummarizedElement + public class BaseOpenApiReference : IOpenApiSerializable { - /// - /// A short summary which by default SHOULD override that of the referenced component. - /// If the referenced object-type does not allow a summary field, then this field has no effect. - /// - public string? Summary { get; set; } - - /// - /// A description which by default SHOULD override that of the referenced component. - /// CommonMark syntax MAY be used for rich text representation. - /// If the referenced object-type does not allow a description field, then this field has no effect. - /// - public string? Description { get; set; } - /// /// External resource in the reference. /// It maybe: @@ -143,45 +130,43 @@ public string? ReferenceV2 /// /// Parameterless constructor /// - public OpenApiReference() { } + public BaseOpenApiReference() { } /// - /// Initializes a copy instance of the object + /// Initializes a copy instance of the object /// - public OpenApiReference(OpenApiReference reference) + public BaseOpenApiReference(BaseOpenApiReference reference) { Utils.CheckArgumentNull(reference); - Summary = reference.Summary; - Description = reference.Description; ExternalResource = reference.ExternalResource; Type = reference.Type; Id = reference.Id; HostDocument = reference.HostDocument; } - /// - /// Serialize to Open Api v3.1. - /// - public void SerializeAsV31(IOpenApiWriter writer) + /// + public virtual void SerializeAsV31(IOpenApiWriter writer) { - SerializeInternal(writer, w => - { - // summary and description are in 3.1 but not in 3.0 - w.WriteProperty(OpenApiConstants.Summary, Summary); - w.WriteProperty(OpenApiConstants.Description, Description); - }); + SerializeInternal(writer, SerializeAdditionalV31Properties); } /// - /// Serialize to Open Api v3.0. + /// Serialize additional properties for Open Api v3.1. /// - public void SerializeAsV3(IOpenApiWriter writer) + /// + protected virtual void SerializeAdditionalV31Properties(IOpenApiWriter writer) + { + // noop for the base type + } + + /// + public virtual void SerializeAsV3(IOpenApiWriter writer) { SerializeInternal(writer); } /// - /// Serialize + /// Serialize /// private void SerializeInternal(IOpenApiWriter writer, Action? callback = null) { @@ -206,10 +191,8 @@ private void SerializeInternal(IOpenApiWriter writer, Action? ca writer.WriteEndObject(); } - /// - /// Serialize to Open Api v2.0. - /// - public void SerializeAsV2(IOpenApiWriter writer) + /// + public virtual void SerializeAsV2(IOpenApiWriter writer) { Utils.CheckArgumentNull(writer); @@ -291,23 +274,27 @@ internal void EnsureHostDocumentIsSet(OpenApiDocument currentDocument) Utils.CheckArgumentNull(currentDocument); hostDocument ??= currentDocument; } - private static string? GetPropertyValueFromNode(JsonObject jsonObject, string key) => + /// + /// Gets the property value from a JsonObject node. + /// + /// The object to get the value from + /// The key of the property + /// The property value + protected internal static string? GetPropertyValueFromNode(JsonObject jsonObject, string key) => jsonObject.TryGetPropertyValue(key, out var valueNode) && valueNode is JsonValue valueCast && valueCast.TryGetValue(out var strValue) ? strValue : null; - internal void SetSummaryAndDescriptionFromMapNode(MapNode mapNode) + internal virtual void SetMetadataFromMapNode(MapNode mapNode) { - var (description, summary) = mapNode.JsonNode switch { - JsonObject jsonObject => (GetPropertyValueFromNode(jsonObject, OpenApiConstants.Description), - GetPropertyValueFromNode(jsonObject, OpenApiConstants.Summary)), - _ => (null, null) - }; - if (!string.IsNullOrEmpty(description)) - { - Description = description; - } - if (!string.IsNullOrEmpty(summary)) - { - Summary = summary; - } + if (mapNode.JsonNode is not JsonObject jsonObject) return; + SetAdditional31MetadataFromMapNode(jsonObject); + } + + /// + /// Sets additional metadata from the map node. + /// + /// The object to get the data from + protected virtual void SetAdditional31MetadataFromMapNode(JsonObject jsonObject) + { + // noop for the base type } internal void SetJsonPointerPath(string pointer, string nodeLocation) @@ -319,11 +306,11 @@ internal void SetJsonPointerPath(string pointer, string nodeLocation) } // Absolute reference or anchor (e.g. "#/components/schemas/..." or full URL) - else if ((pointer.Contains('#') || pointer.StartsWith("http", StringComparison.OrdinalIgnoreCase)) + else if ((pointer.Contains('#') || pointer.StartsWith("http", StringComparison.OrdinalIgnoreCase)) && !string.Equals(ReferenceV3, pointer, StringComparison.OrdinalIgnoreCase)) { ReferenceV3 = pointer; - } + } } private static string ResolveRelativePointer(string nodeLocation, string relativeRef) diff --git a/src/Microsoft.OpenApi/Models/JsonSchemaReference.cs b/src/Microsoft.OpenApi/Models/JsonSchemaReference.cs new file mode 100644 index 000000000..1e7f788df --- /dev/null +++ b/src/Microsoft.OpenApi/Models/JsonSchemaReference.cs @@ -0,0 +1,139 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT license. + +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text.Json.Nodes; + +namespace Microsoft.OpenApi; + +/// +/// Schema reference information that includes metadata annotations from JSON Schema 2020-12. +/// This class extends OpenApiReference to provide schema-specific metadata override capabilities. +/// +public class JsonSchemaReference : OpenApiReferenceWithDescription +{ + /// + /// A default value which by default SHOULD override that of the referenced component. + /// If the referenced object-type does not allow a default field, then this field has no effect. + /// + public JsonNode? Default { get; set; } + + /// + /// A title which by default SHOULD override that of the referenced component. + /// If the referenced object-type does not allow a title field, then this field has no effect. + /// + public string? Title { get; set; } + + /// + /// Indicates whether the referenced component is deprecated. + /// If the referenced object-type does not allow a deprecated field, then this field has no effect. + /// + public bool? Deprecated { get; set; } + + /// + /// Indicates whether the referenced component is read-only. + /// If the referenced object-type does not allow a readOnly field, then this field has no effect. + /// + public bool? ReadOnly { get; set; } + + /// + /// Indicates whether the referenced component is write-only. + /// If the referenced object-type does not allow a writeOnly field, then this field has no effect. + /// + public bool? WriteOnly { get; set; } + + /// + /// Example values which by default SHOULD override those of the referenced component. + /// If the referenced object-type does not allow examples, then this field has no effect. + /// + public IList? Examples { get; set; } + + /// + /// Parameterless constructor + /// + public JsonSchemaReference() { } + + /// + /// Initializes a copy instance of the object + /// + public JsonSchemaReference(JsonSchemaReference reference) : base(reference) + { + Utils.CheckArgumentNull(reference); + Default = reference.Default; + Title = reference.Title; + Deprecated = reference.Deprecated; + ReadOnly = reference.ReadOnly; + WriteOnly = reference.WriteOnly; + Examples = reference.Examples; + } + + /// + protected override void SerializeAdditionalV31Properties(IOpenApiWriter writer) + { + if (Type != ReferenceType.Schema) throw new InvalidOperationException( + $"JsonSchemaReference can only be serialized for ReferenceType.Schema, but was {Type}."); + + base.SerializeAdditionalV31Properties(writer); + // Additional schema metadata annotations in 3.1 + writer.WriteOptionalObject(OpenApiConstants.Default, Default, (w, d) => w.WriteAny(d)); + writer.WriteProperty(OpenApiConstants.Title, Title); + if (Deprecated.HasValue) + { + writer.WriteProperty(OpenApiConstants.Deprecated, Deprecated.Value, false); + } + if (ReadOnly.HasValue) + { + writer.WriteProperty(OpenApiConstants.ReadOnly, ReadOnly.Value, false); + } + if (WriteOnly.HasValue) + { + writer.WriteProperty(OpenApiConstants.WriteOnly, WriteOnly.Value, false); + } + if (Examples != null && Examples.Any()) + { + writer.WriteOptionalCollection(OpenApiConstants.Examples, Examples, (w, e) => w.WriteAny(e)); + } + } + + /// + protected override void SetAdditional31MetadataFromMapNode(JsonObject jsonObject) + { + base.SetAdditional31MetadataFromMapNode(jsonObject); + + var title = GetPropertyValueFromNode(jsonObject, OpenApiConstants.Title); + if (!string.IsNullOrEmpty(title)) + { + Title = title; + } + + // Boolean properties + if (jsonObject.TryGetPropertyValue(OpenApiConstants.Deprecated, out var deprecatedNode) && deprecatedNode is JsonValue deprecatedValue && deprecatedValue.TryGetValue(out var deprecated)) + { + Deprecated = deprecated; + } + + if (jsonObject.TryGetPropertyValue(OpenApiConstants.ReadOnly, out var readOnlyNode) && readOnlyNode is JsonValue readOnlyValue && readOnlyValue.TryGetValue(out var readOnly)) + { + ReadOnly = readOnly; + } + + if (jsonObject.TryGetPropertyValue(OpenApiConstants.WriteOnly, out var writeOnlyNode) && writeOnlyNode is JsonValue writeOnlyValue && writeOnlyValue.TryGetValue(out var writeOnly)) + { + WriteOnly = writeOnly; + } + + // Default value + if (jsonObject.TryGetPropertyValue(OpenApiConstants.Default, out var defaultNode)) + { + Default = defaultNode; + } + + // Examples + if (jsonObject.TryGetPropertyValue(OpenApiConstants.Examples, out var examplesNode) && examplesNode is JsonArray examplesArray) + { + Examples = examplesArray.OfType().ToList(); + } + } +} diff --git a/src/Microsoft.OpenApi/Models/OpenApiDocument.cs b/src/Microsoft.OpenApi/Models/OpenApiDocument.cs index 037910085..dcbcde3cb 100644 --- a/src/Microsoft.OpenApi/Models/OpenApiDocument.cs +++ b/src/Microsoft.OpenApi/Models/OpenApiDocument.cs @@ -496,9 +496,9 @@ public void SetReferenceHostDocument() } /// - /// Load the referenced object from a object + /// Load the referenced object from a object /// - internal T? ResolveReferenceTo(OpenApiReference reference) where T : IOpenApiReferenceable + internal T? ResolveReferenceTo(BaseOpenApiReference reference) where T : IOpenApiReferenceable { if (ResolveReference(reference, reference.IsExternal) is T result) @@ -564,9 +564,9 @@ private static string ConvertByteArrayToString(byte[] hash) } /// - /// Load the referenced object from a object + /// Load the referenced object from a object /// - internal IOpenApiReferenceable? ResolveReference(OpenApiReference? reference, bool useExternal) + internal IOpenApiReferenceable? ResolveReference(BaseOpenApiReference? reference, bool useExternal) { if (reference == null) { diff --git a/src/Microsoft.OpenApi/Models/OpenApiReferenceWithDescription.cs b/src/Microsoft.OpenApi/Models/OpenApiReferenceWithDescription.cs new file mode 100644 index 000000000..a6338b761 --- /dev/null +++ b/src/Microsoft.OpenApi/Models/OpenApiReferenceWithDescription.cs @@ -0,0 +1,52 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT license. + +using System.Text.Json.Nodes; + +namespace Microsoft.OpenApi; + +/// +/// OpenApiReferenceWithSummary is a reference to an OpenAPI component that includes a description. +/// +public class OpenApiReferenceWithDescription : BaseOpenApiReference, IOpenApiDescribedElement +{ + /// + /// A description which by default SHOULD override that of the referenced component. + /// CommonMark syntax MAY be used for rich text representation. + /// If the referenced object-type does not allow a description field, then this field has no effect. + /// + public string? Description { get; set; } + + /// + /// Parameterless constructor + /// + public OpenApiReferenceWithDescription() : base() { } + + /// + /// Initializes a copy instance of the object + /// + public OpenApiReferenceWithDescription(OpenApiReferenceWithDescription reference) : base(reference) + { + Utils.CheckArgumentNull(reference); + Description = reference.Description; + } + /// + protected override void SerializeAdditionalV31Properties(IOpenApiWriter writer) + { + base.SerializeAdditionalV31Properties(writer); + // summary and description are in 3.1 but not in 3.0 + writer.WriteProperty(OpenApiConstants.Description, Description); + } + /// + protected override void SetAdditional31MetadataFromMapNode(JsonObject jsonObject) + { + base.SetAdditional31MetadataFromMapNode(jsonObject); + // Description + var description = GetPropertyValueFromNode(jsonObject, OpenApiConstants.Description); + + if (!string.IsNullOrEmpty(description)) + { + Description = description; + } + } +} diff --git a/src/Microsoft.OpenApi/Models/OpenApiReferenceWithDescriptionAndSummary.cs b/src/Microsoft.OpenApi/Models/OpenApiReferenceWithDescriptionAndSummary.cs new file mode 100644 index 000000000..6096fb4c5 --- /dev/null +++ b/src/Microsoft.OpenApi/Models/OpenApiReferenceWithDescriptionAndSummary.cs @@ -0,0 +1,51 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT license. + +using System.Text.Json.Nodes; + +namespace Microsoft.OpenApi; + +/// +/// OpenApiReferenceWithSummary is a reference to an OpenAPI component that includes a summary. +/// +public class OpenApiReferenceWithDescriptionAndSummary : OpenApiReferenceWithDescription, IOpenApiSummarizedElement +{ + /// + /// A short summary which by default SHOULD override that of the referenced component. + /// If the referenced object-type does not allow a summary field, then this field has no effect. + /// + public string? Summary { get; set; } + + /// + /// Parameterless constructor + /// + public OpenApiReferenceWithDescriptionAndSummary() : base() { } + + /// + /// Initializes a copy instance of the object + /// + public OpenApiReferenceWithDescriptionAndSummary(OpenApiReferenceWithDescriptionAndSummary reference) : base(reference) + { + Utils.CheckArgumentNull(reference); + Summary = reference.Summary; + } + /// + protected override void SerializeAdditionalV31Properties(IOpenApiWriter writer) + { + // summary and description are in 3.1 but not in 3.0 + writer.WriteProperty(OpenApiConstants.Summary, Summary); + base.SerializeAdditionalV31Properties(writer); + } + /// + protected override void SetAdditional31MetadataFromMapNode(JsonObject jsonObject) + { + base.SetAdditional31MetadataFromMapNode(jsonObject); + // Summary + var summary = GetPropertyValueFromNode(jsonObject, OpenApiConstants.Summary); + + if (!string.IsNullOrEmpty(summary)) + { + Summary = summary; + } + } +} diff --git a/src/Microsoft.OpenApi/Models/References/BaseOpenApiReferenceHolder.cs b/src/Microsoft.OpenApi/Models/References/BaseOpenApiReferenceHolder.cs index 31f2e4e55..3f90276ff 100644 --- a/src/Microsoft.OpenApi/Models/References/BaseOpenApiReferenceHolder.cs +++ b/src/Microsoft.OpenApi/Models/References/BaseOpenApiReferenceHolder.cs @@ -5,16 +5,17 @@ namespace Microsoft.OpenApi; /// Base class for OpenApiReferenceHolder. /// /// The concrete class implementation type for the model. -/// The interface type for the model. -public abstract class BaseOpenApiReferenceHolder : IOpenApiReferenceHolder where T : class, IOpenApiReferenceable, V where V : IOpenApiReferenceable, IOpenApiSerializable +/// The interface type for the model. +/// The type for the reference holding the additional fields and annotations +public abstract class BaseOpenApiReferenceHolder : IOpenApiReferenceHolder where T : class, IOpenApiReferenceable, U where U : IOpenApiReferenceable, IOpenApiSerializable where V : BaseOpenApiReference, new() { /// - public virtual V? Target + public virtual U? Target { get { if (Reference.HostDocument is null) return default; - return Reference.HostDocument.ResolveReferenceTo(Reference); + return Reference.HostDocument.ResolveReferenceTo(Reference); } } /// @@ -23,21 +24,27 @@ public T? RecursiveTarget get { return Target switch { - BaseOpenApiReferenceHolder recursiveTarget => recursiveTarget.RecursiveTarget, + BaseOpenApiReferenceHolder recursiveTarget => recursiveTarget.RecursiveTarget, T concrete => concrete, _ => null }; } } + /// + /// Copy the reference as a target element with overrides. + /// + /// The source reference to copy + /// The copy of the reference + protected abstract V CopyReference(V sourceReference); /// /// Copy constructor /// /// The parameter reference to copy - protected BaseOpenApiReferenceHolder(BaseOpenApiReferenceHolder source) + protected BaseOpenApiReferenceHolder(BaseOpenApiReferenceHolder source) { Utils.CheckArgumentNull(source); - Reference = new(source.Reference); + Reference = CopyReference(source.Reference); //no need to copy summary and description as if they are not overridden, they will be fetched from the target //if they are, the reference copy will handle it } @@ -58,7 +65,7 @@ protected BaseOpenApiReferenceHolder(string referenceId, OpenApiDocument? hostDo // we're not checking for null hostDocument as it's optional and can be set via additional methods by a walker // this way object initialization of a whole document is supported - Reference = new OpenApiReference() + Reference = new V() { Id = referenceId, HostDocument = hostDocument, @@ -71,13 +78,13 @@ protected BaseOpenApiReferenceHolder(string referenceId, OpenApiDocument? hostDo #if NETSTANDARD2_1_OR_GREATER /// - public required OpenApiReference Reference { get; init; } + public required V Reference { get; init; } #else /// - public OpenApiReference Reference { get; init; } + public V Reference { get; init; } #endif /// - public abstract V CopyReferenceAsTargetElementWithOverrides(V source); + public abstract U CopyReferenceAsTargetElementWithOverrides(U source); /// public virtual void SerializeAsV3(IOpenApiWriter writer) { @@ -125,7 +132,7 @@ public virtual void SerializeAsV2(IOpenApiWriter writer) /// The OpenApiWriter. /// The action to serialize the target object. private protected void SerializeInternal(IOpenApiWriter writer, - Action action) + Action action) { Utils.CheckArgumentNull(writer); if (Target is not null) diff --git a/src/Microsoft.OpenApi/Models/References/OpenApiCallbackReference.cs b/src/Microsoft.OpenApi/Models/References/OpenApiCallbackReference.cs index ebba35087..bdf22eb03 100644 --- a/src/Microsoft.OpenApi/Models/References/OpenApiCallbackReference.cs +++ b/src/Microsoft.OpenApi/Models/References/OpenApiCallbackReference.cs @@ -8,7 +8,7 @@ namespace Microsoft.OpenApi /// /// Callback Object Reference: A reference to a map of possible out-of band callbacks related to the parent operation. /// - public class OpenApiCallbackReference : BaseOpenApiReferenceHolder, IOpenApiCallback + public class OpenApiCallbackReference : BaseOpenApiReferenceHolder, IOpenApiCallback { /// /// Constructor initializing the reference object. @@ -20,16 +20,16 @@ public class OpenApiCallbackReference : BaseOpenApiReferenceHolder - public OpenApiCallbackReference(string referenceId, OpenApiDocument? hostDocument = null, string? externalResource = null):base(referenceId, hostDocument, ReferenceType.Callback, externalResource) + public OpenApiCallbackReference(string referenceId, OpenApiDocument? hostDocument = null, string? externalResource = null) : base(referenceId, hostDocument, ReferenceType.Callback, externalResource) { } /// /// Copy constructor /// /// The reference to copy - private OpenApiCallbackReference(OpenApiCallbackReference callback):base(callback) + private OpenApiCallbackReference(OpenApiCallbackReference callback) : base(callback) { - + } /// @@ -56,5 +56,10 @@ public IOpenApiCallback CreateShallowCopy() { return new OpenApiCallbackReference(this); } + /// + protected override BaseOpenApiReference CopyReference(BaseOpenApiReference sourceReference) + { + return new BaseOpenApiReference(sourceReference); + } } } diff --git a/src/Microsoft.OpenApi/Models/References/OpenApiExampleReference.cs b/src/Microsoft.OpenApi/Models/References/OpenApiExampleReference.cs index b699786f4..a616975bf 100644 --- a/src/Microsoft.OpenApi/Models/References/OpenApiExampleReference.cs +++ b/src/Microsoft.OpenApi/Models/References/OpenApiExampleReference.cs @@ -9,7 +9,7 @@ namespace Microsoft.OpenApi /// /// Example Object Reference. /// - public class OpenApiExampleReference : BaseOpenApiReferenceHolder, IOpenApiExample + public class OpenApiExampleReference : BaseOpenApiReferenceHolder, IOpenApiExample { /// /// Constructor initializing the reference object. @@ -21,14 +21,14 @@ public class OpenApiExampleReference : BaseOpenApiReferenceHolder - public OpenApiExampleReference(string referenceId, OpenApiDocument? hostDocument = null, string? externalResource = null):base(referenceId, hostDocument, ReferenceType.Example, externalResource) + public OpenApiExampleReference(string referenceId, OpenApiDocument? hostDocument = null, string? externalResource = null) : base(referenceId, hostDocument, ReferenceType.Example, externalResource) { } /// /// Copy constructor /// /// The example reference to copy - private OpenApiExampleReference(OpenApiExampleReference example):base(example) + private OpenApiExampleReference(OpenApiExampleReference example) : base(example) { } @@ -73,5 +73,10 @@ public IOpenApiExample CreateShallowCopy() { return new OpenApiExampleReference(this); } + /// + protected override OpenApiReferenceWithDescriptionAndSummary CopyReference(OpenApiReferenceWithDescriptionAndSummary sourceReference) + { + return new OpenApiReferenceWithDescriptionAndSummary(sourceReference); + } } } diff --git a/src/Microsoft.OpenApi/Models/References/OpenApiHeaderReference.cs b/src/Microsoft.OpenApi/Models/References/OpenApiHeaderReference.cs index f610b0c02..838b029d4 100644 --- a/src/Microsoft.OpenApi/Models/References/OpenApiHeaderReference.cs +++ b/src/Microsoft.OpenApi/Models/References/OpenApiHeaderReference.cs @@ -9,7 +9,7 @@ namespace Microsoft.OpenApi /// /// Header Object Reference. /// - public class OpenApiHeaderReference : BaseOpenApiReferenceHolder, IOpenApiHeader + public class OpenApiHeaderReference : BaseOpenApiReferenceHolder, IOpenApiHeader { /// /// Constructor initializing the reference object. @@ -21,7 +21,7 @@ public class OpenApiHeaderReference : BaseOpenApiReferenceHolder - public OpenApiHeaderReference(string referenceId, OpenApiDocument? hostDocument = null, string? externalResource = null):base(referenceId, hostDocument, ReferenceType.Header, externalResource) + public OpenApiHeaderReference(string referenceId, OpenApiDocument? hostDocument = null, string? externalResource = null) : base(referenceId, hostDocument, ReferenceType.Header, externalResource) { } @@ -29,7 +29,7 @@ public OpenApiHeaderReference(string referenceId, OpenApiDocument? hostDocument /// Copy constructor /// /// The object to copy - private OpenApiHeaderReference(OpenApiHeaderReference header):base(header) + private OpenApiHeaderReference(OpenApiHeaderReference header) : base(header) { } @@ -84,5 +84,10 @@ public IOpenApiHeader CreateShallowCopy() { return new OpenApiHeaderReference(this); } + /// + protected override OpenApiReferenceWithDescription CopyReference(OpenApiReferenceWithDescription sourceReference) + { + return new OpenApiReferenceWithDescription(sourceReference); + } } } diff --git a/src/Microsoft.OpenApi/Models/References/OpenApiLinkReference.cs b/src/Microsoft.OpenApi/Models/References/OpenApiLinkReference.cs index 05405c680..a11decf63 100644 --- a/src/Microsoft.OpenApi/Models/References/OpenApiLinkReference.cs +++ b/src/Microsoft.OpenApi/Models/References/OpenApiLinkReference.cs @@ -8,7 +8,7 @@ namespace Microsoft.OpenApi /// /// Link Object Reference. /// - public class OpenApiLinkReference : BaseOpenApiReferenceHolder, IOpenApiLink + public class OpenApiLinkReference : BaseOpenApiReferenceHolder, IOpenApiLink { /// /// Constructor initializing the reference object. @@ -20,14 +20,14 @@ public class OpenApiLinkReference : BaseOpenApiReferenceHolder - public OpenApiLinkReference(string referenceId, OpenApiDocument? hostDocument = null, string? externalResource = null):base(referenceId, hostDocument, ReferenceType.Link, externalResource) + public OpenApiLinkReference(string referenceId, OpenApiDocument? hostDocument = null, string? externalResource = null) : base(referenceId, hostDocument, ReferenceType.Link, externalResource) { } /// /// Copy constructor. /// /// The reference to copy - private OpenApiLinkReference(OpenApiLinkReference reference):base(reference) + private OpenApiLinkReference(OpenApiLinkReference reference) : base(reference) { } @@ -73,5 +73,10 @@ public IOpenApiLink CreateShallowCopy() { return new OpenApiLinkReference(this); } + /// + protected override OpenApiReferenceWithDescription CopyReference(OpenApiReferenceWithDescription sourceReference) + { + return new OpenApiReferenceWithDescription(sourceReference); + } } } diff --git a/src/Microsoft.OpenApi/Models/References/OpenApiParameterReference.cs b/src/Microsoft.OpenApi/Models/References/OpenApiParameterReference.cs index 9912e651b..665669ea2 100644 --- a/src/Microsoft.OpenApi/Models/References/OpenApiParameterReference.cs +++ b/src/Microsoft.OpenApi/Models/References/OpenApiParameterReference.cs @@ -9,7 +9,7 @@ namespace Microsoft.OpenApi /// /// Parameter Object Reference. /// - public class OpenApiParameterReference : BaseOpenApiReferenceHolder, IOpenApiParameter + public class OpenApiParameterReference : BaseOpenApiReferenceHolder, IOpenApiParameter { /// /// Constructor initializing the reference object. @@ -90,5 +90,11 @@ public IOpenApiParameter CreateShallowCopy() { return new OpenApiParameterReference(this); } + + /// + protected override OpenApiReferenceWithDescription CopyReference(OpenApiReferenceWithDescription sourceReference) + { + return new OpenApiReferenceWithDescription(sourceReference); + } } } diff --git a/src/Microsoft.OpenApi/Models/References/OpenApiPathItemReference.cs b/src/Microsoft.OpenApi/Models/References/OpenApiPathItemReference.cs index b440e81a2..291c75308 100644 --- a/src/Microsoft.OpenApi/Models/References/OpenApiPathItemReference.cs +++ b/src/Microsoft.OpenApi/Models/References/OpenApiPathItemReference.cs @@ -9,7 +9,7 @@ namespace Microsoft.OpenApi /// /// Path Item Object Reference: to describe the operations available on a single path. /// - public class OpenApiPathItemReference : BaseOpenApiReferenceHolder, IOpenApiPathItem + public class OpenApiPathItemReference : BaseOpenApiReferenceHolder, IOpenApiPathItem { /// @@ -22,7 +22,7 @@ public class OpenApiPathItemReference : BaseOpenApiReferenceHolder - public OpenApiPathItemReference(string referenceId, OpenApiDocument? hostDocument = null, string? externalResource = null): base(referenceId, hostDocument, ReferenceType.PathItem, externalResource) + public OpenApiPathItemReference(string referenceId, OpenApiDocument? hostDocument = null, string? externalResource = null) : base(referenceId, hostDocument, ReferenceType.PathItem, externalResource) { } @@ -30,9 +30,9 @@ public OpenApiPathItemReference(string referenceId, OpenApiDocument? hostDocumen /// Copy constructor /// /// The reference to copy - private OpenApiPathItemReference(OpenApiPathItemReference pathItem):base(pathItem) + private OpenApiPathItemReference(OpenApiPathItemReference pathItem) : base(pathItem) { - + } /// @@ -78,5 +78,10 @@ public override void SerializeAsV2(IOpenApiWriter writer) { Reference.SerializeAsV2(writer); } + /// + protected override OpenApiReferenceWithDescriptionAndSummary CopyReference(OpenApiReferenceWithDescriptionAndSummary sourceReference) + { + return new OpenApiReferenceWithDescriptionAndSummary(sourceReference); + } } } diff --git a/src/Microsoft.OpenApi/Models/References/OpenApiRequestBodyReference.cs b/src/Microsoft.OpenApi/Models/References/OpenApiRequestBodyReference.cs index dffa8f342..a23d325d7 100644 --- a/src/Microsoft.OpenApi/Models/References/OpenApiRequestBodyReference.cs +++ b/src/Microsoft.OpenApi/Models/References/OpenApiRequestBodyReference.cs @@ -9,7 +9,7 @@ namespace Microsoft.OpenApi /// /// Request Body Object Reference. /// - public class OpenApiRequestBodyReference : BaseOpenApiReferenceHolder, IOpenApiRequestBody + public class OpenApiRequestBodyReference : BaseOpenApiReferenceHolder, IOpenApiRequestBody { /// /// Constructor initializing the reference object. @@ -21,16 +21,16 @@ public class OpenApiRequestBodyReference : BaseOpenApiReferenceHolder - public OpenApiRequestBodyReference(string referenceId, OpenApiDocument? hostDocument = null, string? externalResource = null):base(referenceId, hostDocument, ReferenceType.RequestBody, externalResource) + public OpenApiRequestBodyReference(string referenceId, OpenApiDocument? hostDocument = null, string? externalResource = null) : base(referenceId, hostDocument, ReferenceType.RequestBody, externalResource) { } /// /// Copy constructor /// /// The reference to copy - private OpenApiRequestBodyReference(OpenApiRequestBodyReference openApiRequestBodyReference):base(openApiRequestBodyReference) + private OpenApiRequestBodyReference(OpenApiRequestBodyReference openApiRequestBodyReference) : base(openApiRequestBodyReference) { - + } /// @@ -88,5 +88,10 @@ public IOpenApiRequestBody CreateShallowCopy() { return new OpenApiRequestBodyReference(this); } + /// + protected override OpenApiReferenceWithDescription CopyReference(OpenApiReferenceWithDescription sourceReference) + { + return new OpenApiReferenceWithDescription(sourceReference); + } } } diff --git a/src/Microsoft.OpenApi/Models/References/OpenApiResponseReference.cs b/src/Microsoft.OpenApi/Models/References/OpenApiResponseReference.cs index 78ec42be4..f76ddea15 100644 --- a/src/Microsoft.OpenApi/Models/References/OpenApiResponseReference.cs +++ b/src/Microsoft.OpenApi/Models/References/OpenApiResponseReference.cs @@ -8,7 +8,7 @@ namespace Microsoft.OpenApi /// /// Response Object Reference. /// - public class OpenApiResponseReference : BaseOpenApiReferenceHolder, IOpenApiResponse + public class OpenApiResponseReference : BaseOpenApiReferenceHolder, IOpenApiResponse { /// /// Constructor initializing the reference object. @@ -20,16 +20,16 @@ public class OpenApiResponseReference : BaseOpenApiReferenceHolder - public OpenApiResponseReference(string referenceId, OpenApiDocument? hostDocument = null, string? externalResource = null):base(referenceId, hostDocument, ReferenceType.Response, externalResource) + public OpenApiResponseReference(string referenceId, OpenApiDocument? hostDocument = null, string? externalResource = null) : base(referenceId, hostDocument, ReferenceType.Response, externalResource) { } /// /// Copy constructor /// /// The reference to copy - private OpenApiResponseReference(OpenApiResponseReference openApiResponseReference):base(openApiResponseReference) + private OpenApiResponseReference(OpenApiResponseReference openApiResponseReference) : base(openApiResponseReference) { - + } /// @@ -62,5 +62,10 @@ public IOpenApiResponse CreateShallowCopy() { return new OpenApiResponseReference(this); } + /// + protected override OpenApiReferenceWithDescription CopyReference(OpenApiReferenceWithDescription sourceReference) + { + return new OpenApiReferenceWithDescription(sourceReference); + } } } diff --git a/src/Microsoft.OpenApi/Models/References/OpenApiSchemaReference.cs b/src/Microsoft.OpenApi/Models/References/OpenApiSchemaReference.cs index f28d3f683..bc8d002cd 100644 --- a/src/Microsoft.OpenApi/Models/References/OpenApiSchemaReference.cs +++ b/src/Microsoft.OpenApi/Models/References/OpenApiSchemaReference.cs @@ -10,8 +10,9 @@ namespace Microsoft.OpenApi /// /// Schema reference object /// - public class OpenApiSchemaReference : BaseOpenApiReferenceHolder, IOpenApiSchema + public class OpenApiSchemaReference : BaseOpenApiReferenceHolder, IOpenApiSchema { + /// /// Constructor initializing the reference object. /// @@ -22,14 +23,14 @@ public class OpenApiSchemaReference : BaseOpenApiReferenceHolder - public OpenApiSchemaReference(string referenceId, OpenApiDocument? hostDocument = null, string? externalResource = null):base(referenceId, hostDocument, ReferenceType.Schema, externalResource) + public OpenApiSchemaReference(string referenceId, OpenApiDocument? hostDocument = null, string? externalResource = null) : base(referenceId, hostDocument, ReferenceType.Schema, externalResource) { } /// /// Copy constructor /// /// The schema reference to copy - private OpenApiSchemaReference(OpenApiSchemaReference schema):base(schema) + private OpenApiSchemaReference(OpenApiSchemaReference schema) : base(schema) { } @@ -41,7 +42,11 @@ public string? Description } /// - public string? Title { get => Target?.Title; } + public string? Title + { + get => string.IsNullOrEmpty(Reference.Title) ? Target?.Title : Reference.Title; + set => Reference.Title = value; + } /// public Uri? Schema { get => Target?.Schema; } /// @@ -79,11 +84,23 @@ public string? Description /// public decimal? MultipleOf { get => Target?.MultipleOf; } /// - public JsonNode? Default { get => Target?.Default; } + public JsonNode? Default + { + get => Reference.Default ?? Target?.Default; + set => Reference.Default = value; + } /// - public bool ReadOnly { get => Target?.ReadOnly ?? false; } + public bool ReadOnly + { + get => Reference.ReadOnly ?? Target?.ReadOnly ?? false; + set => Reference.ReadOnly = value; + } /// - public bool WriteOnly { get => Target?.WriteOnly ?? false; } + public bool WriteOnly + { + get => Reference.WriteOnly ?? Target?.WriteOnly ?? false; + set => Reference.WriteOnly = value; + } /// public IList? AllOf { get => Target?.AllOf; } /// @@ -119,7 +136,11 @@ public string? Description /// public JsonNode? Example { get => Target?.Example; } /// - public IList? Examples { get => Target?.Examples; } + public IList? Examples + { + get => Reference.Examples ?? Target?.Examples; + set => Reference.Examples = value; + } /// public IList? Enum { get => Target?.Enum; } /// @@ -127,7 +148,11 @@ public string? Description /// public OpenApiExternalDocs? ExternalDocs { get => Target?.ExternalDocs; } /// - public bool Deprecated { get => Target?.Deprecated ?? false; } + public bool Deprecated + { + get => Reference.Deprecated ?? Target?.Deprecated ?? false; + set => Reference.Deprecated = value; + } /// public OpenApiXml? Xml { get => Target?.Xml; } /// @@ -184,5 +209,10 @@ public IOpenApiSchema CreateShallowCopy() { return new OpenApiSchemaReference(this); } + /// + protected override JsonSchemaReference CopyReference(JsonSchemaReference sourceReference) + { + return new JsonSchemaReference(sourceReference); + } } } diff --git a/src/Microsoft.OpenApi/Models/References/OpenApiSecuritySchemeReference.cs b/src/Microsoft.OpenApi/Models/References/OpenApiSecuritySchemeReference.cs index 52b4f9291..aa83105fa 100644 --- a/src/Microsoft.OpenApi/Models/References/OpenApiSecuritySchemeReference.cs +++ b/src/Microsoft.OpenApi/Models/References/OpenApiSecuritySchemeReference.cs @@ -9,7 +9,7 @@ namespace Microsoft.OpenApi /// /// Security Scheme Object Reference. /// - public class OpenApiSecuritySchemeReference : BaseOpenApiReferenceHolder, IOpenApiSecurityScheme + public class OpenApiSecuritySchemeReference : BaseOpenApiReferenceHolder, IOpenApiSecurityScheme { /// /// Constructor initializing the reference object. @@ -17,16 +17,16 @@ public class OpenApiSecuritySchemeReference : BaseOpenApiReferenceHolderThe reference Id. /// The host OpenAPI document. /// The externally referenced file. - public OpenApiSecuritySchemeReference(string referenceId, OpenApiDocument? hostDocument = null, string? externalResource = null):base(referenceId, hostDocument, ReferenceType.SecurityScheme, externalResource) + public OpenApiSecuritySchemeReference(string referenceId, OpenApiDocument? hostDocument = null, string? externalResource = null) : base(referenceId, hostDocument, ReferenceType.SecurityScheme, externalResource) { } /// /// Copy constructor /// /// The reference to copy - private OpenApiSecuritySchemeReference(OpenApiSecuritySchemeReference openApiSecuritySchemeReference):base(openApiSecuritySchemeReference) + private OpenApiSecuritySchemeReference(OpenApiSecuritySchemeReference openApiSecuritySchemeReference) : base(openApiSecuritySchemeReference) { - + } /// @@ -71,5 +71,10 @@ public IOpenApiSecurityScheme CreateShallowCopy() { return new OpenApiSecuritySchemeReference(this); } + /// + protected override OpenApiReferenceWithDescription CopyReference(OpenApiReferenceWithDescription sourceReference) + { + return new OpenApiReferenceWithDescription(sourceReference); + } } } diff --git a/src/Microsoft.OpenApi/Models/References/OpenApiTagReference.cs b/src/Microsoft.OpenApi/Models/References/OpenApiTagReference.cs index b32e0eff6..92d1d1308 100644 --- a/src/Microsoft.OpenApi/Models/References/OpenApiTagReference.cs +++ b/src/Microsoft.OpenApi/Models/References/OpenApiTagReference.cs @@ -9,7 +9,7 @@ namespace Microsoft.OpenApi /// /// Tag Object Reference /// - public class OpenApiTagReference : BaseOpenApiReferenceHolder, IOpenApiTag + public class OpenApiTagReference : BaseOpenApiReferenceHolder, IOpenApiTag { /// /// Resolved target of the reference. @@ -32,22 +32,22 @@ public override IOpenApiTag? Target /// 1. a absolute/relative file path, for example: ../commons/pet.json /// 2. a Url, for example: http://localhost/pet.json /// - public OpenApiTagReference(string referenceId, OpenApiDocument? hostDocument = null, string? externalResource = null):base(referenceId, hostDocument, ReferenceType.Tag, externalResource) + public OpenApiTagReference(string referenceId, OpenApiDocument? hostDocument = null, string? externalResource = null) : base(referenceId, hostDocument, ReferenceType.Tag, externalResource) { } /// /// Copy constructor /// /// The reference to copy - private OpenApiTagReference(OpenApiTagReference openApiTagReference):base(openApiTagReference) + private OpenApiTagReference(OpenApiTagReference openApiTagReference) : base(openApiTagReference) { - + } /// public string? Description { - get => string.IsNullOrEmpty(Reference.Description) ? Target?.Description : Reference.Description; + get => Target?.Description; } /// @@ -69,5 +69,10 @@ public IOpenApiTag CreateShallowCopy() { return new OpenApiTagReference(this); } + /// + protected override BaseOpenApiReference CopyReference(BaseOpenApiReference sourceReference) + { + return new BaseOpenApiReference(sourceReference); + } } } diff --git a/src/Microsoft.OpenApi/Reader/OpenApiModelFactory.cs b/src/Microsoft.OpenApi/Reader/OpenApiModelFactory.cs index 906187240..d3029193e 100644 --- a/src/Microsoft.OpenApi/Reader/OpenApiModelFactory.cs +++ b/src/Microsoft.OpenApi/Reader/OpenApiModelFactory.cs @@ -264,7 +264,7 @@ private static async Task LoadExternalRefsAsync(OpenApiDocume var streamLoader = new DefaultStreamLoader(settings.HttpClient); var workspace = document?.Workspace ?? new OpenApiWorkspace(); var workspaceLoader = new OpenApiWorkspaceLoader(workspace, settings.CustomExternalLoader ?? streamLoader, settings); - return await workspaceLoader.LoadAsync(new OpenApiReference() { ExternalResource = "/" }, document, format ?? OpenApiConstants.Json, null, token).ConfigureAwait(false); + return await workspaceLoader.LoadAsync(new BaseOpenApiReference() { ExternalResource = "/" }, document, format ?? OpenApiConstants.Json, null, token).ConfigureAwait(false); } private static ReadResult InternalLoad(MemoryStream input, string format, OpenApiReaderSettings settings) diff --git a/src/Microsoft.OpenApi/Reader/Services/OpenApiRemoteReferenceCollector.cs b/src/Microsoft.OpenApi/Reader/Services/OpenApiRemoteReferenceCollector.cs index 75e68c915..a741f9a66 100644 --- a/src/Microsoft.OpenApi/Reader/Services/OpenApiRemoteReferenceCollector.cs +++ b/src/Microsoft.OpenApi/Reader/Services/OpenApiRemoteReferenceCollector.cs @@ -10,12 +10,12 @@ namespace Microsoft.OpenApi.Reader /// internal class OpenApiRemoteReferenceCollector : OpenApiVisitorBase { - private readonly Dictionary _references = new(); + private readonly Dictionary _references = new(); /// /// List of all external references collected from OpenApiDocument /// - public IEnumerable References + public IEnumerable References { get { @@ -26,13 +26,21 @@ public IEnumerable References /// public override void Visit(IOpenApiReferenceHolder referenceHolder) { - AddExternalReferences(referenceHolder.Reference); + var reference = referenceHolder switch + { + IOpenApiReferenceHolder { Reference: OpenApiReferenceWithDescriptionAndSummary withSummary } => withSummary, + IOpenApiReferenceHolder { Reference: OpenApiReferenceWithDescription withDescription } => withDescription, + IOpenApiReferenceHolder { Reference: JsonSchemaReference jsonSchemaReference } => jsonSchemaReference, + IOpenApiReferenceHolder { Reference: BaseOpenApiReference baseReference } => baseReference, + _ => throw new OpenApiException($"Unsupported reference holder type: {referenceHolder.GetType().FullName}") + }; + AddExternalReferences(reference); } /// /// Collect external references /// - private void AddExternalReferences(OpenApiReference? reference) + private void AddExternalReferences(BaseOpenApiReference? reference) { if (reference is {IsExternal: true} && reference.ExternalResource is {} externalResource&& !_references.ContainsKey(externalResource)) diff --git a/src/Microsoft.OpenApi/Reader/Services/OpenApiWorkspaceLoader.cs b/src/Microsoft.OpenApi/Reader/Services/OpenApiWorkspaceLoader.cs index 998424718..e793aa985 100644 --- a/src/Microsoft.OpenApi/Reader/Services/OpenApiWorkspaceLoader.cs +++ b/src/Microsoft.OpenApi/Reader/Services/OpenApiWorkspaceLoader.cs @@ -17,7 +17,7 @@ public OpenApiWorkspaceLoader(OpenApiWorkspace workspace, IStreamLoader loader, _readerSettings = readerSettings; } - internal async Task LoadAsync(OpenApiReference reference, + internal async Task LoadAsync(BaseOpenApiReference reference, OpenApiDocument? document, string? format = null, OpenApiDiagnostic? diagnostic = null, diff --git a/src/Microsoft.OpenApi/Reader/V31/OpenApiCallbackDeserializer.cs b/src/Microsoft.OpenApi/Reader/V31/OpenApiCallbackDeserializer.cs index 0777be16d..c7d72c847 100644 --- a/src/Microsoft.OpenApi/Reader/V31/OpenApiCallbackDeserializer.cs +++ b/src/Microsoft.OpenApi/Reader/V31/OpenApiCallbackDeserializer.cs @@ -22,10 +22,12 @@ public static IOpenApiCallback LoadCallback(ParseNode node, OpenApiDocument host { var mapNode = node.CheckMapNode("callback"); - if (mapNode.GetReferencePointer() is {} pointer) + if (mapNode.GetReferencePointer() is { } pointer) { var reference = GetReferenceIdAndExternalResource(pointer); - return new OpenApiCallbackReference(reference.Item1, hostDocument, reference.Item2); + var callbackReference = new OpenApiCallbackReference(reference.Item1, hostDocument, reference.Item2); + callbackReference.Reference.SetMetadataFromMapNode(mapNode); + return callbackReference; } var domainObject = new OpenApiCallback(); diff --git a/src/Microsoft.OpenApi/Reader/V31/OpenApiExampleDeserializer.cs b/src/Microsoft.OpenApi/Reader/V31/OpenApiExampleDeserializer.cs index 58019984e..2bd891172 100644 --- a/src/Microsoft.OpenApi/Reader/V31/OpenApiExampleDeserializer.cs +++ b/src/Microsoft.OpenApi/Reader/V31/OpenApiExampleDeserializer.cs @@ -51,7 +51,9 @@ public static IOpenApiExample LoadExample(ParseNode node, OpenApiDocument hostDo if (pointer != null) { var reference = GetReferenceIdAndExternalResource(pointer); - return new OpenApiExampleReference(reference.Item1, hostDocument, reference.Item2); + var exampleReference = new OpenApiExampleReference(reference.Item1, hostDocument, reference.Item2); + exampleReference.Reference.SetMetadataFromMapNode(mapNode); + return exampleReference; } var example = new OpenApiExample(); diff --git a/src/Microsoft.OpenApi/Reader/V31/OpenApiHeaderDeserializer.cs b/src/Microsoft.OpenApi/Reader/V31/OpenApiHeaderDeserializer.cs index 7c142f3b6..6ed2fe97f 100644 --- a/src/Microsoft.OpenApi/Reader/V31/OpenApiHeaderDeserializer.cs +++ b/src/Microsoft.OpenApi/Reader/V31/OpenApiHeaderDeserializer.cs @@ -114,7 +114,9 @@ public static IOpenApiHeader LoadHeader(ParseNode node, OpenApiDocument hostDocu if (pointer != null) { var reference = GetReferenceIdAndExternalResource(pointer); - return new OpenApiHeaderReference(reference.Item1, hostDocument, reference.Item2); + var headerReference = new OpenApiHeaderReference(reference.Item1, hostDocument, reference.Item2); + headerReference.Reference.SetMetadataFromMapNode(mapNode); + return headerReference; } var header = new OpenApiHeader(); diff --git a/src/Microsoft.OpenApi/Reader/V31/OpenApiLinkDeserializer.cs b/src/Microsoft.OpenApi/Reader/V31/OpenApiLinkDeserializer.cs index d2d4a37f5..435ee084b 100644 --- a/src/Microsoft.OpenApi/Reader/V31/OpenApiLinkDeserializer.cs +++ b/src/Microsoft.OpenApi/Reader/V31/OpenApiLinkDeserializer.cs @@ -57,7 +57,9 @@ public static IOpenApiLink LoadLink(ParseNode node, OpenApiDocument hostDocument if (pointer != null) { var reference = GetReferenceIdAndExternalResource(pointer); - return new OpenApiLinkReference(reference.Item1, hostDocument, reference.Item2); + var linkReference = new OpenApiLinkReference(reference.Item1, hostDocument, reference.Item2); + linkReference.Reference.SetMetadataFromMapNode(mapNode); + return linkReference; } ParseMap(mapNode, link, _linkFixedFields, _linkPatternFields, hostDocument); diff --git a/src/Microsoft.OpenApi/Reader/V31/OpenApiParameterDeserializer.cs b/src/Microsoft.OpenApi/Reader/V31/OpenApiParameterDeserializer.cs index 6f7a92dd2..0b6686ca1 100644 --- a/src/Microsoft.OpenApi/Reader/V31/OpenApiParameterDeserializer.cs +++ b/src/Microsoft.OpenApi/Reader/V31/OpenApiParameterDeserializer.cs @@ -161,7 +161,9 @@ public static IOpenApiParameter LoadParameter(ParseNode node, OpenApiDocument ho if (pointer != null) { var reference = GetReferenceIdAndExternalResource(pointer); - return new OpenApiParameterReference(reference.Item1, hostDocument, reference.Item2); + var parameterReference = new OpenApiParameterReference(reference.Item1, hostDocument, reference.Item2); + parameterReference.Reference.SetMetadataFromMapNode(mapNode); + return parameterReference; } var parameter = new OpenApiParameter(); diff --git a/src/Microsoft.OpenApi/Reader/V31/OpenApiPathItemDeserializer.cs b/src/Microsoft.OpenApi/Reader/V31/OpenApiPathItemDeserializer.cs index fd38ba334..892c1e8a1 100644 --- a/src/Microsoft.OpenApi/Reader/V31/OpenApiPathItemDeserializer.cs +++ b/src/Microsoft.OpenApi/Reader/V31/OpenApiPathItemDeserializer.cs @@ -55,7 +55,9 @@ public static IOpenApiPathItem LoadPathItem(ParseNode node, OpenApiDocument host if (pointer != null) { var reference = GetReferenceIdAndExternalResource(pointer); - return new OpenApiPathItemReference(reference.Item1, hostDocument, reference.Item2); + var pathItemReference = new OpenApiPathItemReference(reference.Item1, hostDocument, reference.Item2); + pathItemReference.Reference.SetMetadataFromMapNode(mapNode); + return pathItemReference; } var pathItem = new OpenApiPathItem(); diff --git a/src/Microsoft.OpenApi/Reader/V31/OpenApiRequestBodyDeserializer.cs b/src/Microsoft.OpenApi/Reader/V31/OpenApiRequestBodyDeserializer.cs index e02f7f765..de40027db 100644 --- a/src/Microsoft.OpenApi/Reader/V31/OpenApiRequestBodyDeserializer.cs +++ b/src/Microsoft.OpenApi/Reader/V31/OpenApiRequestBodyDeserializer.cs @@ -49,7 +49,9 @@ public static IOpenApiRequestBody LoadRequestBody(ParseNode node, OpenApiDocumen if (pointer != null) { var reference = GetReferenceIdAndExternalResource(pointer); - return new OpenApiRequestBodyReference(reference.Item1, hostDocument, reference.Item2); + var requestBodyReference = new OpenApiRequestBodyReference(reference.Item1, hostDocument, reference.Item2); + requestBodyReference.Reference.SetMetadataFromMapNode(mapNode); + return requestBodyReference; } var requestBody = new OpenApiRequestBody(); diff --git a/src/Microsoft.OpenApi/Reader/V31/OpenApiResponseDeserializer.cs b/src/Microsoft.OpenApi/Reader/V31/OpenApiResponseDeserializer.cs index 314a9d24b..d25603126 100644 --- a/src/Microsoft.OpenApi/Reader/V31/OpenApiResponseDeserializer.cs +++ b/src/Microsoft.OpenApi/Reader/V31/OpenApiResponseDeserializer.cs @@ -50,7 +50,9 @@ public static IOpenApiResponse LoadResponse(ParseNode node, OpenApiDocument host if (pointer != null) { var reference = GetReferenceIdAndExternalResource(pointer); - return new OpenApiResponseReference(reference.Item1, hostDocument, reference.Item2); + var responseReference = new OpenApiResponseReference(reference.Item1, hostDocument, reference.Item2); + responseReference.Reference.SetMetadataFromMapNode(mapNode); + return responseReference; } var response = new OpenApiResponse(); diff --git a/src/Microsoft.OpenApi/Reader/V31/OpenApiSchemaDeserializer.cs b/src/Microsoft.OpenApi/Reader/V31/OpenApiSchemaDeserializer.cs index e7b7f8bec..9d62a681f 100644 --- a/src/Microsoft.OpenApi/Reader/V31/OpenApiSchemaDeserializer.cs +++ b/src/Microsoft.OpenApi/Reader/V31/OpenApiSchemaDeserializer.cs @@ -368,7 +368,7 @@ public static IOpenApiSchema LoadSchema(ParseNode node, OpenApiDocument hostDocu { var reference = GetReferenceIdAndExternalResource(pointer); var result = new OpenApiSchemaReference(reference.Item1, hostDocument, reference.Item2); - result.Reference.SetSummaryAndDescriptionFromMapNode(mapNode); + result.Reference.SetMetadataFromMapNode(mapNode); result.Reference.SetJsonPointerPath(pointer, nodeLocation); return result; } diff --git a/src/Microsoft.OpenApi/Reader/V31/OpenApiSecuritySchemeDeserializer.cs b/src/Microsoft.OpenApi/Reader/V31/OpenApiSecuritySchemeDeserializer.cs index 84836d1ac..b85d82df9 100644 --- a/src/Microsoft.OpenApi/Reader/V31/OpenApiSecuritySchemeDeserializer.cs +++ b/src/Microsoft.OpenApi/Reader/V31/OpenApiSecuritySchemeDeserializer.cs @@ -90,7 +90,9 @@ public static IOpenApiSecurityScheme LoadSecurityScheme(ParseNode node, OpenApiD if (pointer != null) { var reference = GetReferenceIdAndExternalResource(pointer); - return new OpenApiSecuritySchemeReference(reference.Item1, hostDocument, reference.Item2); + var securitySchemeReference = new OpenApiSecuritySchemeReference(reference.Item1, hostDocument, reference.Item2); + securitySchemeReference.Reference.SetMetadataFromMapNode(mapNode); + return securitySchemeReference; } var securityScheme = new OpenApiSecurityScheme(); diff --git a/src/Microsoft.OpenApi/Services/OpenApiReferenceError.cs b/src/Microsoft.OpenApi/Services/OpenApiReferenceError.cs index 6c173206f..e6d0d5b24 100644 --- a/src/Microsoft.OpenApi/Services/OpenApiReferenceError.cs +++ b/src/Microsoft.OpenApi/Services/OpenApiReferenceError.cs @@ -11,7 +11,7 @@ public class OpenApiReferenceError : OpenApiError /// /// The reference that caused the error. /// - public readonly OpenApiReference? Reference; + public readonly BaseOpenApiReference? Reference; /// /// Initializes the class using the message and pointer from the given exception. /// @@ -24,7 +24,7 @@ public OpenApiReferenceError(OpenApiException exception) : base(exception.Pointe /// /// /// - public OpenApiReferenceError(OpenApiReference reference, string message) : base("", message) + public OpenApiReferenceError(BaseOpenApiReference reference, string message) : base("", message) { Reference = reference; } diff --git a/src/Microsoft.OpenApi/Services/OpenApiWalker.cs b/src/Microsoft.OpenApi/Services/OpenApiWalker.cs index e3a5fbead..b00bee4de 100644 --- a/src/Microsoft.OpenApi/Services/OpenApiWalker.cs +++ b/src/Microsoft.OpenApi/Services/OpenApiWalker.cs @@ -1262,8 +1262,7 @@ private void Walk(string context, Action walk) /// private bool ProcessAsReference(IOpenApiReferenceHolder referenceableHolder, bool isComponent = false) { - var isReference = referenceableHolder.Reference != null && - (!isComponent || referenceableHolder.UnresolvedReference); + var isReference = !isComponent || referenceableHolder.UnresolvedReference; if (isReference) { Walk(referenceableHolder); diff --git a/src/Microsoft.OpenApi/Services/ReferenceHostDocumentSetter.cs b/src/Microsoft.OpenApi/Services/ReferenceHostDocumentSetter.cs index a627f0a94..eabb01c4e 100644 --- a/src/Microsoft.OpenApi/Services/ReferenceHostDocumentSetter.cs +++ b/src/Microsoft.OpenApi/Services/ReferenceHostDocumentSetter.cs @@ -18,7 +18,15 @@ public ReferenceHostDocumentSetter(OpenApiDocument currentDocument) /// public override void Visit(IOpenApiReferenceHolder referenceHolder) { - referenceHolder.Reference?.EnsureHostDocumentIsSet(_currentDocument); + var reference = referenceHolder switch + { + IOpenApiReferenceHolder { Reference: OpenApiReferenceWithDescriptionAndSummary withSummary } => withSummary, + IOpenApiReferenceHolder { Reference: OpenApiReferenceWithDescription withDescription } => withDescription, + IOpenApiReferenceHolder { Reference: JsonSchemaReference jsonSchemaReference } => jsonSchemaReference, + IOpenApiReferenceHolder { Reference: BaseOpenApiReference baseReference } => baseReference, + _ => throw new OpenApiException($"Unsupported reference holder type: {referenceHolder.GetType().FullName}") + }; + reference.EnsureHostDocumentIsSet(_currentDocument); } } } diff --git a/src/Microsoft.OpenApi/Writers/OpenApiWriterSettings.cs b/src/Microsoft.OpenApi/Writers/OpenApiWriterSettings.cs index cbd3344b2..502f2d7b4 100644 --- a/src/Microsoft.OpenApi/Writers/OpenApiWriterSettings.cs +++ b/src/Microsoft.OpenApi/Writers/OpenApiWriterSettings.cs @@ -18,7 +18,7 @@ public class OpenApiWriterSettings /// public bool InlineExternalReferences { get; set; } - internal bool ShouldInlineReference(OpenApiReference reference) + internal bool ShouldInlineReference(BaseOpenApiReference reference) { return (reference.IsLocal && InlineLocalReferences) || (reference.IsExternal && InlineExternalReferences); diff --git a/test/Microsoft.OpenApi.Readers.Tests/V31Tests/OpenApiCallbackReferenceDeserializerTests.cs b/test/Microsoft.OpenApi.Readers.Tests/V31Tests/OpenApiCallbackReferenceDeserializerTests.cs new file mode 100644 index 000000000..5aea87294 --- /dev/null +++ b/test/Microsoft.OpenApi.Readers.Tests/V31Tests/OpenApiCallbackReferenceDeserializerTests.cs @@ -0,0 +1,36 @@ +using System.Text.Json.Nodes; +using Microsoft.OpenApi.Reader; +using Microsoft.OpenApi.Reader.V31; +using Xunit; + +namespace Microsoft.OpenApi.Readers.Tests.V31Tests; + +public class OpenApiCallbackReferenceDeserializerTests +{ + [Fact] + public void ShouldDeserializeCallbackReferenceAnnotations() + { + var json = + """ + { + "$ref": "#/components/callbacks/MyCallback" + } + """; + + var hostDocument = new OpenApiDocument(); + hostDocument.AddComponent("MyCallback", new OpenApiCallback + { + // Optionally add a PathItem or similar here if needed + }); + var jsonNode = JsonNode.Parse(json); + var parseNode = ParseNode.Create(new ParsingContext(new()), jsonNode); + + var result = OpenApiV31Deserializer.LoadCallback(parseNode, hostDocument); + + Assert.NotNull(result); + var resultReference = Assert.IsType(result); + + Assert.Equal("MyCallback", resultReference.Reference.Id); + Assert.NotNull(resultReference.Target); + } +} diff --git a/test/Microsoft.OpenApi.Readers.Tests/V31Tests/OpenApiExampleReferenceDeserializerTests.cs b/test/Microsoft.OpenApi.Readers.Tests/V31Tests/OpenApiExampleReferenceDeserializerTests.cs new file mode 100644 index 000000000..cf9f4f47c --- /dev/null +++ b/test/Microsoft.OpenApi.Readers.Tests/V31Tests/OpenApiExampleReferenceDeserializerTests.cs @@ -0,0 +1,41 @@ +using System.Text.Json.Nodes; +using Microsoft.OpenApi.Reader; +using Microsoft.OpenApi.Reader.V31; +using Xunit; + +namespace Microsoft.OpenApi.Readers.Tests.V31Tests; + +public class OpenApiExampleReferenceDeserializerTests +{ + [Fact] + public void ShouldDeserializeExampleReferenceAnnotations() + { + var json = + """ + { + "$ref": "#/components/examples/MyExample", + "description": "This is an example reference", + "summary": "Example Summary reference" + } + """; + + var hostDocument = new OpenApiDocument(); + hostDocument.AddComponent("MyExample", new OpenApiExample + { + Summary = "This is an example", + Description = "This is an example description", + }); + var jsonNode = JsonNode.Parse(json); + var parseNode = ParseNode.Create(new ParsingContext(new()), jsonNode); + + var result = OpenApiV31Deserializer.LoadExample(parseNode, hostDocument); + + Assert.NotNull(result); + var resultReference = Assert.IsType(result); + + Assert.Equal("MyExample", resultReference.Reference.Id); + Assert.Equal("This is an example reference", resultReference.Description); + Assert.Equal("Example Summary reference", resultReference.Summary); + Assert.NotNull(resultReference.Target); + } +} diff --git a/test/Microsoft.OpenApi.Readers.Tests/V31Tests/OpenApiHeaderReferenceDeserializerTests.cs b/test/Microsoft.OpenApi.Readers.Tests/V31Tests/OpenApiHeaderReferenceDeserializerTests.cs new file mode 100644 index 000000000..81ef67a60 --- /dev/null +++ b/test/Microsoft.OpenApi.Readers.Tests/V31Tests/OpenApiHeaderReferenceDeserializerTests.cs @@ -0,0 +1,39 @@ + +using System.Text.Json.Nodes; +using Microsoft.OpenApi.Reader; +using Microsoft.OpenApi.Reader.V31; +using Xunit; + +namespace Microsoft.OpenApi.Readers.Tests.V31Tests; + +public class OpenApiHeaderReferenceDeserializerTests +{ + [Fact] + public void ShouldDeserializeReferenceAnnotations() + { + var json = + """ + { + "$ref": "#/components/headers/MyHeader", + "description": "This is a header reference" + } + """; + + var hostDocument = new OpenApiDocument(); + hostDocument.AddComponent("MyHeader", new OpenApiHeader + { + Description = "This is a header" + }); + var jsonNode = JsonNode.Parse(json); + var parseNode = ParseNode.Create(new ParsingContext(new()), jsonNode); + + var result = OpenApiV31Deserializer.LoadHeader(parseNode, hostDocument); + + Assert.NotNull(result); + var resultReference = Assert.IsType(result); + + Assert.Equal("MyHeader", resultReference.Reference.Id); + Assert.Equal("This is a header reference", resultReference.Description); + Assert.NotNull(resultReference.Target); + } +} diff --git a/test/Microsoft.OpenApi.Readers.Tests/V31Tests/OpenApiLinkReferenceDeserializerTests.cs b/test/Microsoft.OpenApi.Readers.Tests/V31Tests/OpenApiLinkReferenceDeserializerTests.cs new file mode 100644 index 000000000..e6a124a8a --- /dev/null +++ b/test/Microsoft.OpenApi.Readers.Tests/V31Tests/OpenApiLinkReferenceDeserializerTests.cs @@ -0,0 +1,38 @@ +using System.Text.Json.Nodes; +using Microsoft.OpenApi.Reader; +using Microsoft.OpenApi.Reader.V31; +using Xunit; + +namespace Microsoft.OpenApi.Readers.Tests.V31Tests; + +public class OpenApiLinkReferenceDeserializerTests +{ + [Fact] + public void ShouldDeserializeLinkReferenceAnnotations() + { + var json = + """ + { + "$ref": "#/components/links/MyLink", + "description": "This is a link reference" + } + """; + + var hostDocument = new OpenApiDocument(); + hostDocument.AddComponent("MyLink", new OpenApiLink + { + Description = "This is a link description", + }); + var jsonNode = JsonNode.Parse(json); + var parseNode = ParseNode.Create(new ParsingContext(new()), jsonNode); + + var result = OpenApiV31Deserializer.LoadLink(parseNode, hostDocument); + + Assert.NotNull(result); + var resultReference = Assert.IsType(result); + + Assert.Equal("MyLink", resultReference.Reference.Id); + Assert.Equal("This is a link reference", resultReference.Description); + Assert.NotNull(resultReference.Target); + } +} diff --git a/test/Microsoft.OpenApi.Readers.Tests/V31Tests/OpenApiParameterReferenceDeserializerTests.cs b/test/Microsoft.OpenApi.Readers.Tests/V31Tests/OpenApiParameterReferenceDeserializerTests.cs new file mode 100644 index 000000000..d51274076 --- /dev/null +++ b/test/Microsoft.OpenApi.Readers.Tests/V31Tests/OpenApiParameterReferenceDeserializerTests.cs @@ -0,0 +1,40 @@ +using System.Text.Json.Nodes; +using Microsoft.OpenApi.Reader; +using Microsoft.OpenApi.Reader.V31; +using Xunit; + +namespace Microsoft.OpenApi.Readers.Tests.V31Tests; + +public class OpenApiParameterReferenceDeserializerTests +{ + [Fact] + public void ShouldDeserializeParameterReferenceAnnotations() + { + var json = + """ + { + "$ref": "#/components/parameters/MyParameter", + "description": "This is a parameter reference" + } + """; + + var hostDocument = new OpenApiDocument(); + hostDocument.AddComponent("MyParameter", new OpenApiParameter + { + Name = "myParam", + In = ParameterLocation.Query, + Description = "This is a parameter description", + }); + var jsonNode = JsonNode.Parse(json); + var parseNode = ParseNode.Create(new ParsingContext(new()), jsonNode); + + var result = OpenApiV31Deserializer.LoadParameter(parseNode, hostDocument); + + Assert.NotNull(result); + var resultReference = Assert.IsType(result); + + Assert.Equal("MyParameter", resultReference.Reference.Id); + Assert.Equal("This is a parameter reference", resultReference.Description); + Assert.NotNull(resultReference.Target); + } +} diff --git a/test/Microsoft.OpenApi.Readers.Tests/V31Tests/OpenApiPathItemReferenceDeserializerTests.cs b/test/Microsoft.OpenApi.Readers.Tests/V31Tests/OpenApiPathItemReferenceDeserializerTests.cs new file mode 100644 index 000000000..ac7d62d3a --- /dev/null +++ b/test/Microsoft.OpenApi.Readers.Tests/V31Tests/OpenApiPathItemReferenceDeserializerTests.cs @@ -0,0 +1,41 @@ +using System.Text.Json.Nodes; +using Microsoft.OpenApi.Reader; +using Microsoft.OpenApi.Reader.V31; +using Xunit; + +namespace Microsoft.OpenApi.Readers.Tests.V31Tests; + +public class OpenApiPathItemReferenceDeserializerTests +{ + [Fact] + public void ShouldDeserializePathItemReferenceAnnotations() + { + var json = + """ + { + "$ref": "#/components/pathItems/MyPathItem", + "description": "This is a path item reference", + "summary": "PathItem Summary reference" + } + """; + + var hostDocument = new OpenApiDocument(); + hostDocument.AddComponent("MyPathItem", new OpenApiPathItem + { + Summary = "This is a path item", + Description = "This is a path item description", + }); + var jsonNode = JsonNode.Parse(json); + var parseNode = ParseNode.Create(new ParsingContext(new()), jsonNode); + + var result = OpenApiV31Deserializer.LoadPathItem(parseNode, hostDocument); + + Assert.NotNull(result); + var resultReference = Assert.IsType(result); + + Assert.Equal("MyPathItem", resultReference.Reference.Id); + Assert.Equal("This is a path item reference", resultReference.Description); + Assert.Equal("PathItem Summary reference", resultReference.Summary); + Assert.NotNull(resultReference.Target); + } +} diff --git a/test/Microsoft.OpenApi.Readers.Tests/V31Tests/OpenApiRequestBodyReferenceDeserializerTests.cs b/test/Microsoft.OpenApi.Readers.Tests/V31Tests/OpenApiRequestBodyReferenceDeserializerTests.cs new file mode 100644 index 000000000..04ecdc72e --- /dev/null +++ b/test/Microsoft.OpenApi.Readers.Tests/V31Tests/OpenApiRequestBodyReferenceDeserializerTests.cs @@ -0,0 +1,38 @@ +using System.Text.Json.Nodes; +using Microsoft.OpenApi.Reader; +using Microsoft.OpenApi.Reader.V31; +using Xunit; + +namespace Microsoft.OpenApi.Readers.Tests.V31Tests; + +public class OpenApiRequestBodyReferenceDeserializerTests +{ + [Fact] + public void ShouldDeserializeRequestBodyReferenceAnnotations() + { + var json = + """ + { + "$ref": "#/components/requestBodies/MyRequestBody", + "description": "This is a request body reference" + } + """; + + var hostDocument = new OpenApiDocument(); + hostDocument.AddComponent("MyRequestBody", new OpenApiRequestBody + { + Description = "This is a request body description", + }); + var jsonNode = JsonNode.Parse(json); + var parseNode = ParseNode.Create(new ParsingContext(new()), jsonNode); + + var result = OpenApiV31Deserializer.LoadRequestBody(parseNode, hostDocument); + + Assert.NotNull(result); + var resultReference = Assert.IsType(result); + + Assert.Equal("MyRequestBody", resultReference.Reference.Id); + Assert.Equal("This is a request body reference", resultReference.Description); + Assert.NotNull(resultReference.Target); + } +} diff --git a/test/Microsoft.OpenApi.Readers.Tests/V31Tests/OpenApiResponseReferenceDeserializerTests.cs b/test/Microsoft.OpenApi.Readers.Tests/V31Tests/OpenApiResponseReferenceDeserializerTests.cs new file mode 100644 index 000000000..6ca61c7c4 --- /dev/null +++ b/test/Microsoft.OpenApi.Readers.Tests/V31Tests/OpenApiResponseReferenceDeserializerTests.cs @@ -0,0 +1,38 @@ +using System.Text.Json.Nodes; +using Microsoft.OpenApi.Reader; +using Microsoft.OpenApi.Reader.V31; +using Xunit; + +namespace Microsoft.OpenApi.Readers.Tests.V31Tests; + +public class OpenApiResponseReferenceDeserializerTests +{ + [Fact] + public void ShouldDeserializeResponseReferenceAnnotations() + { + var json = + """ + { + "$ref": "#/components/responses/MyResponse", + "description": "This is a response reference" + } + """; + + var hostDocument = new OpenApiDocument(); + hostDocument.AddComponent("MyResponse", new OpenApiResponse + { + Description = "This is a response description", + }); + var jsonNode = JsonNode.Parse(json); + var parseNode = ParseNode.Create(new ParsingContext(new()), jsonNode); + + var result = OpenApiV31Deserializer.LoadResponse(parseNode, hostDocument); + + Assert.NotNull(result); + var resultReference = Assert.IsType(result); + + Assert.Equal("MyResponse", resultReference.Reference.Id); + Assert.Equal("This is a response reference", resultReference.Description); + Assert.NotNull(resultReference.Target); + } +} diff --git a/test/Microsoft.OpenApi.Readers.Tests/V31Tests/OpenApiSchemaReferenceDeserializerTests.cs b/test/Microsoft.OpenApi.Readers.Tests/V31Tests/OpenApiSchemaReferenceDeserializerTests.cs new file mode 100644 index 000000000..13e89df71 --- /dev/null +++ b/test/Microsoft.OpenApi.Readers.Tests/V31Tests/OpenApiSchemaReferenceDeserializerTests.cs @@ -0,0 +1,60 @@ +using System.Collections.Generic; +using System.Text.Json.Nodes; +using Microsoft.OpenApi.Reader; +using Microsoft.OpenApi.Reader.V31; +using Xunit; + +namespace Microsoft.OpenApi.Readers.Tests.V31Tests; + +public class OpenApiSchemaReferenceDeserializerTests +{ + [Fact] + public void ShouldDeserializeSchemaReferenceAnnotations() + { + var json = + """ + { + "$ref": "#/components/schemas/MySchema", + "description": "This is a schema reference", + "default": "foo", + "readOnly": true, + "writeOnly": true, + "deprecated": true, + "title": "This is a schema reference", + "examples": ["example reference value"] + } + """; + + var hostDocument = new OpenApiDocument(); + hostDocument.AddComponent("MySchema", new OpenApiSchema + { + Title = "This is a schema", + Description = "This is a schema description", + Default = "bar", + Type = JsonSchemaType.String, + ReadOnly = false, + WriteOnly = false, + Deprecated = false, + Examples = new List { "example value" }, + }); + var jsonNode = JsonNode.Parse(json); + var parseNode = ParseNode.Create(new ParsingContext(new()), jsonNode); + + var result = OpenApiV31Deserializer.LoadSchema(parseNode, hostDocument); + + Assert.NotNull(result); + var resultReference = Assert.IsType(result); + + Assert.Equal("MySchema", resultReference.Reference.Id); + Assert.Equal("This is a schema reference", resultReference.Description); + Assert.Equal("foo", resultReference.Default?.ToString()); + Assert.True(resultReference.ReadOnly); + Assert.True(resultReference.WriteOnly); + Assert.True(resultReference.Deprecated); + Assert.Equal("This is a schema reference", resultReference.Title); + Assert.NotNull(resultReference.Examples); + Assert.Single(resultReference.Examples); + Assert.Equal("example reference value", resultReference.Examples[0]?.ToString()); + Assert.NotNull(resultReference.Target); + } +} diff --git a/test/Microsoft.OpenApi.Readers.Tests/V31Tests/OpenApiSecuritySchemeReferenceDeserializerTests.cs b/test/Microsoft.OpenApi.Readers.Tests/V31Tests/OpenApiSecuritySchemeReferenceDeserializerTests.cs new file mode 100644 index 000000000..0a09b68be --- /dev/null +++ b/test/Microsoft.OpenApi.Readers.Tests/V31Tests/OpenApiSecuritySchemeReferenceDeserializerTests.cs @@ -0,0 +1,41 @@ +using System.Text.Json.Nodes; +using Microsoft.OpenApi.Reader; +using Microsoft.OpenApi.Reader.V31; +using Xunit; + +namespace Microsoft.OpenApi.Readers.Tests.V31Tests; + +public class OpenApiSecuritySchemeReferenceDeserializerTests +{ + [Fact] + public void ShouldDeserializeSecuritySchemeReferenceAnnotations() + { + var json = + """ + { + "$ref": "#/components/securitySchemes/MyScheme", + "description": "This is a security scheme reference" + } + """; + + var hostDocument = new OpenApiDocument(); + hostDocument.AddComponent("MyScheme", new OpenApiSecurityScheme + { + Type = SecuritySchemeType.ApiKey, + Name = "api_key", + In = ParameterLocation.Header, + Description = "This is a security scheme description", + }); + var jsonNode = JsonNode.Parse(json); + var parseNode = ParseNode.Create(new ParsingContext(new()), jsonNode); + + var result = OpenApiV31Deserializer.LoadSecurityScheme(parseNode, hostDocument); + + Assert.NotNull(result); + var resultReference = Assert.IsType(result); + + Assert.Equal("MyScheme", resultReference.Reference.Id); + Assert.Equal("This is a security scheme reference", resultReference.Description); + Assert.NotNull(resultReference.Target); + } +} diff --git a/test/Microsoft.OpenApi.Readers.Tests/V31Tests/OpenApiTagReferenceDeserializerTests.cs b/test/Microsoft.OpenApi.Readers.Tests/V31Tests/OpenApiTagReferenceDeserializerTests.cs new file mode 100644 index 000000000..8bbac7fd5 --- /dev/null +++ b/test/Microsoft.OpenApi.Readers.Tests/V31Tests/OpenApiTagReferenceDeserializerTests.cs @@ -0,0 +1,47 @@ +using System.Collections.Generic; +using System.Linq; +using System.Text.Json.Nodes; +using Microsoft.OpenApi.Reader; +using Microsoft.OpenApi.Reader.V31; +using Xunit; + +namespace Microsoft.OpenApi.Readers.Tests.V31Tests; + +public class OpenApiTagReferenceDeserializerTests +{ + [Fact] + public void ShouldDeserializeTagReferenceAnnotations() + { + var json = + """ + { + "tags" : [ + "MyTag" + ] + } + """; + + var hostDocument = new OpenApiDocument(); + hostDocument.Tags ??= new HashSet(); + hostDocument.Tags.Add(new OpenApiTag + { + Name = "MyTag", + Description = "This is a tag description", + }); + var jsonNode = JsonNode.Parse(json); + var parseNode = ParseNode.Create(new ParsingContext(new()), jsonNode); + + var result = OpenApiV31Deserializer.LoadOperation(parseNode, hostDocument); + // this diverges from the other unit tests because Tag References are implemented + // through the reference infrastructure for convenience, but the behave quite differently + + Assert.NotNull(result); + Assert.NotNull(result.Tags); + Assert.Single(result.Tags); + var resultReference = Assert.IsType(result.Tags.First()); + + Assert.Equal("MyTag", resultReference.Reference.Id); + Assert.Equal("This is a tag description", resultReference.Description); + Assert.NotNull(resultReference.Target); + } +} diff --git a/test/Microsoft.OpenApi.Tests/Models/OpenApiReferenceTests.cs b/test/Microsoft.OpenApi.Tests/Models/OpenApiReferenceTests.cs index dc6f3a6f5..e2ad1f87c 100644 --- a/test/Microsoft.OpenApi.Tests/Models/OpenApiReferenceTests.cs +++ b/test/Microsoft.OpenApi.Tests/Models/OpenApiReferenceTests.cs @@ -20,7 +20,7 @@ public void SettingInternalReferenceForComponentsStyleReferenceShouldSucceed( string id) { // Arrange & Act - var reference = new OpenApiReference + var reference = new BaseOpenApiReference { Type = type, Id = id @@ -46,7 +46,7 @@ public void SettingInternalReferenceForComponentsStyleReferenceShouldSucceed( public void SettingExternalReferenceV3ShouldSucceed(string expected, string externalResource, string id, ReferenceType type) { // Arrange & Act - var reference = new OpenApiReference + var reference = new BaseOpenApiReference { ExternalResource = externalResource, Type = type, @@ -70,7 +70,7 @@ public void SettingExternalReferenceV3ShouldSucceed(string expected, string exte public void SettingExternalReferenceV2ShouldSucceed(string expected, string externalResource, string id, ReferenceType type) { // Arrange & Act - var reference = new OpenApiReference + var reference = new BaseOpenApiReference { ExternalResource = externalResource, Type = type, @@ -88,7 +88,7 @@ public void SettingExternalReferenceV2ShouldSucceed(string expected, string exte public async Task SerializeSchemaReferenceAsJsonV3Works() { // Arrange - var reference = new OpenApiReference { Type = ReferenceType.Schema, Id = "Pet" }; + var reference = new BaseOpenApiReference { Type = ReferenceType.Schema, Id = "Pet" }; var expected = """ { @@ -112,7 +112,7 @@ public async Task SerializeSchemaReferenceAsJsonV3Works() public async Task SerializeHttpSchemaReferenceAsJsonV31Works(string id, string referenceV3) { // Arrange - var reference = new OpenApiReference { Type = ReferenceType.Schema, Id = id }; + var reference = new BaseOpenApiReference { Type = ReferenceType.Schema, Id = id }; var expected = $$""" { @@ -133,7 +133,7 @@ public async Task SerializeHttpSchemaReferenceAsJsonV31Works(string id, string r public async Task SerializeSchemaReferenceAsYamlV3Works() { // Arrange - var reference = new OpenApiReference + var reference = new BaseOpenApiReference { Type = ReferenceType.Schema, Id = "Pet" @@ -152,7 +152,7 @@ public async Task SerializeSchemaReferenceAsYamlV3Works() public async Task SerializeSchemaReferenceAsJsonV2Works() { // Arrange - var reference = new OpenApiReference + var reference = new BaseOpenApiReference { Type = ReferenceType.Schema, Id = "Pet" @@ -176,7 +176,7 @@ public async Task SerializeSchemaReferenceAsJsonV2Works() public async Task SerializeSchemaReferenceAsYamlV2Works() { // Arrange - var reference = new OpenApiReference + var reference = new BaseOpenApiReference { Type = ReferenceType.Schema, Id = "Pet" @@ -194,7 +194,7 @@ public async Task SerializeSchemaReferenceAsYamlV2Works() public async Task SerializeExternalReferenceAsJsonV2Works() { // Arrange - var reference = new OpenApiReference + var reference = new BaseOpenApiReference { ExternalResource = "main.json", Type = ReferenceType.Schema, @@ -221,7 +221,7 @@ public async Task SerializeExternalReferenceAsJsonV2Works() public async Task SerializeExternalReferenceAsYamlV2Works() { // Arrange - var reference = new OpenApiReference + var reference = new BaseOpenApiReference { ExternalResource = "main.json", Type = ReferenceType.Schema, @@ -240,7 +240,7 @@ public async Task SerializeExternalReferenceAsYamlV2Works() public async Task SerializeExternalReferenceAsJsonV3Works() { // Arrange - var reference = new OpenApiReference { ExternalResource = "main.json", Type = ReferenceType.Schema, Id = "Pets" }; + var reference = new BaseOpenApiReference { ExternalResource = "main.json", Type = ReferenceType.Schema, Id = "Pets" }; var expected = """ @@ -262,7 +262,7 @@ public async Task SerializeExternalReferenceAsJsonV3Works() public async Task SerializeExternalReferenceAsYamlV3Works() { // Arrange - var reference = new OpenApiReference { ExternalResource = "main.json", Type = ReferenceType.Schema, Id = "Pets" }; + var reference = new BaseOpenApiReference { ExternalResource = "main.json", Type = ReferenceType.Schema, Id = "Pets" }; var expected = @"$ref: main.json#/components/schemas/Pets"; // Act diff --git a/test/Microsoft.OpenApi.Tests/Models/References/OpenApiSchemaReferenceTests.SerializeSchemaReferenceAsV31JsonWorks_produceTerseOutput=False.verified.txt b/test/Microsoft.OpenApi.Tests/Models/References/OpenApiSchemaReferenceTests.SerializeSchemaReferenceAsV31JsonWorks_produceTerseOutput=False.verified.txt new file mode 100644 index 000000000..3d7372e1b --- /dev/null +++ b/test/Microsoft.OpenApi.Tests/Models/References/OpenApiSchemaReferenceTests.SerializeSchemaReferenceAsV31JsonWorks_produceTerseOutput=False.verified.txt @@ -0,0 +1,11 @@ +{ + "description": "Reference Description", + "default": "reference default", + "title": "Reference Title", + "deprecated": true, + "readOnly": true, + "examples": [ + "reference example" + ], + "$ref": "#/components/schemas/Pet" +} \ No newline at end of file diff --git a/test/Microsoft.OpenApi.Tests/Models/References/OpenApiSchemaReferenceTests.SerializeSchemaReferenceAsV31JsonWorks_produceTerseOutput=True.verified.txt b/test/Microsoft.OpenApi.Tests/Models/References/OpenApiSchemaReferenceTests.SerializeSchemaReferenceAsV31JsonWorks_produceTerseOutput=True.verified.txt new file mode 100644 index 000000000..2a7cc8e44 --- /dev/null +++ b/test/Microsoft.OpenApi.Tests/Models/References/OpenApiSchemaReferenceTests.SerializeSchemaReferenceAsV31JsonWorks_produceTerseOutput=True.verified.txt @@ -0,0 +1 @@ +{"description":"Reference Description","default":"reference default","title":"Reference Title","deprecated":true,"readOnly":true,"examples":["reference example"],"$ref":"#/components/schemas/Pet"} \ No newline at end of file diff --git a/test/Microsoft.OpenApi.Tests/Models/References/OpenApiSchemaReferenceTests.SerializeSchemaReferenceAsV3JsonWorks_produceTerseOutput=False.verified.txt b/test/Microsoft.OpenApi.Tests/Models/References/OpenApiSchemaReferenceTests.SerializeSchemaReferenceAsV3JsonWorks_produceTerseOutput=False.verified.txt new file mode 100644 index 000000000..be99f20ed --- /dev/null +++ b/test/Microsoft.OpenApi.Tests/Models/References/OpenApiSchemaReferenceTests.SerializeSchemaReferenceAsV3JsonWorks_produceTerseOutput=False.verified.txt @@ -0,0 +1,3 @@ +{ + "$ref": "#/components/schemas/Pet" +} \ No newline at end of file diff --git a/test/Microsoft.OpenApi.Tests/Models/References/OpenApiSchemaReferenceTests.SerializeSchemaReferenceAsV3JsonWorks_produceTerseOutput=True.verified.txt b/test/Microsoft.OpenApi.Tests/Models/References/OpenApiSchemaReferenceTests.SerializeSchemaReferenceAsV3JsonWorks_produceTerseOutput=True.verified.txt new file mode 100644 index 000000000..5838142cd --- /dev/null +++ b/test/Microsoft.OpenApi.Tests/Models/References/OpenApiSchemaReferenceTests.SerializeSchemaReferenceAsV3JsonWorks_produceTerseOutput=True.verified.txt @@ -0,0 +1 @@ +{"$ref":"#/components/schemas/Pet"} \ No newline at end of file diff --git a/test/Microsoft.OpenApi.Tests/Models/References/OpenApiSchemaReferenceTests.cs b/test/Microsoft.OpenApi.Tests/Models/References/OpenApiSchemaReferenceTests.cs new file mode 100644 index 000000000..57ccae0cb --- /dev/null +++ b/test/Microsoft.OpenApi.Tests/Models/References/OpenApiSchemaReferenceTests.cs @@ -0,0 +1,260 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT license. + +using System.Collections.Generic; +using System.Globalization; +using System.IO; +using System.Linq; +using System.Net.Http; +using System.Text.Json.Nodes; +using System.Threading.Tasks; +using VerifyXunit; +using Xunit; + +namespace Microsoft.OpenApi.Tests.Models.References +{ + [Collection("DefaultSettings")] + public class OpenApiSchemaReferenceTests + { + [Fact] + public void SchemaReferenceWithAnnotationsShouldWork() + { + // Arrange + var workingDocument = new OpenApiDocument() + { + Components = new OpenApiComponents(), + }; + const string referenceId = "targetSchema"; + var targetSchema = new OpenApiSchema() + { + Type = JsonSchemaType.Object, + Title = "Target Title", + Description = "Target Description", + ReadOnly = false, + WriteOnly = false, + Deprecated = false, + Default = JsonValue.Create("target default"), + Examples = new List { JsonValue.Create("target example") }, + Properties = new Dictionary() + { + ["prop1"] = new OpenApiSchema() + { + Type = JsonSchemaType.String + } + } + }; + workingDocument.Components.Schemas = new Dictionary() + { + [referenceId] = targetSchema + }; + workingDocument.Workspace.RegisterComponents(workingDocument); + + // Act + var schemaReference = new OpenApiSchemaReference(referenceId, workingDocument) + { + Title = "Override Title", + Description = "Override Description", + ReadOnly = true, + WriteOnly = true, + Deprecated = true, + Default = JsonValue.Create("override default"), + Examples = new List { JsonValue.Create("override example") }, + }; + + // Assert + Assert.Equal("Override Title", schemaReference.Title); + Assert.Equal("Override Description", schemaReference.Description); + Assert.True(schemaReference.ReadOnly); + Assert.True(schemaReference.WriteOnly); + Assert.True(schemaReference.Deprecated); + Assert.Equal("override default", schemaReference.Default?.GetValue()); + Assert.Single(schemaReference.Examples); + Assert.Equal("override example", schemaReference.Examples.First()?.GetValue()); + } + + [Fact] + public void SchemaReferenceWithoutAnnotationsShouldFallbackToTarget() + { + // Arrange + var workingDocument = new OpenApiDocument() + { + Components = new OpenApiComponents(), + }; + const string referenceId = "targetSchema"; + var targetSchema = new OpenApiSchema() + { + Type = JsonSchemaType.Object, + Title = "Target Title", + Description = "Target Description", + ReadOnly = true, + WriteOnly = false, + Deprecated = true, + Default = JsonValue.Create("target default"), + Examples = new List { JsonValue.Create("target example") }, + Properties = new Dictionary() + { + ["prop1"] = new OpenApiSchema() + { + Type = JsonSchemaType.String + } + } + }; + workingDocument.Components.Schemas = new Dictionary() + { + [referenceId] = targetSchema + }; + workingDocument.Workspace.RegisterComponents(workingDocument); + + // Act + var schemaReference = new OpenApiSchemaReference(referenceId, workingDocument); + + // Assert - should fallback to target values + Assert.Equal("Target Title", schemaReference.Title); + Assert.Equal("Target Description", schemaReference.Description); + Assert.True(schemaReference.ReadOnly); + Assert.False(schemaReference.WriteOnly); + Assert.True(schemaReference.Deprecated); + Assert.Equal("target default", schemaReference.Default?.GetValue()); + Assert.Single(schemaReference.Examples); + Assert.Equal("target example", schemaReference.Examples.First()?.GetValue()); + } + + [Theory] + [InlineData(true)] + [InlineData(false)] + public async Task SerializeSchemaReferenceAsV31JsonWorks(bool produceTerseOutput) + { + // Arrange + var reference = new OpenApiSchemaReference("Pet", null) + { + Title = "Reference Title", + Description = "Reference Description", + ReadOnly = true, + WriteOnly = false, + Deprecated = true, + Default = JsonValue.Create("reference default"), + Examples = new List { JsonValue.Create("reference example") } + }; + + var outputStringWriter = new StringWriter(CultureInfo.InvariantCulture); + var writer = new OpenApiJsonWriter(outputStringWriter, new OpenApiJsonWriterSettings { Terse = produceTerseOutput }); + + // Act + reference.SerializeAsV31(writer); + await writer.FlushAsync(); + + // Assert + await Verifier.Verify(outputStringWriter).UseParameters(produceTerseOutput); + } + + [Theory] + [InlineData(true)] + [InlineData(false)] + public async Task SerializeSchemaReferenceAsV3JsonWorks(bool produceTerseOutput) + { + // Arrange + var reference = new OpenApiSchemaReference("Pet", null) + { + Title = "Reference Title", + Description = "Reference Description", + ReadOnly = true, + WriteOnly = false, + Deprecated = true, + Default = JsonValue.Create("reference default"), + Examples = new List { JsonValue.Create("reference example") } + }; + + var outputStringWriter = new StringWriter(CultureInfo.InvariantCulture); + var writer = new OpenApiJsonWriter(outputStringWriter, new OpenApiJsonWriterSettings { Terse = produceTerseOutput }); + + // Act + reference.SerializeAsV3(writer); + await writer.FlushAsync(); + + // Assert + await Verifier.Verify(outputStringWriter).UseParameters(produceTerseOutput); + } + + [Fact] + public void ParseSchemaReferenceWithAnnotationsWorks() + { + // Arrange + var jsonContent = @"{ + ""openapi"": ""3.1.0"", + ""info"": { + ""title"": ""Test API"", + ""version"": ""1.0.0"" + }, + ""paths"": { + ""/test"": { + ""get"": { + ""responses"": { + ""200"": { + ""description"": ""OK"", + ""content"": { + ""application/json"": { + ""schema"": { + ""$ref"": ""#/components/schemas/Pet"", + ""title"": ""Pet Response Schema"", + ""description"": ""A pet object returned from the API"", + ""summary"": ""Pet Response"", + ""deprecated"": true, + ""readOnly"": true, + ""writeOnly"": false, + ""default"": {""name"": ""default pet""}, + ""examples"": [{""name"": ""example pet""}] + } + } + } + } + } + } + } + }, + ""components"": { + ""schemas"": { + ""Pet"": { + ""type"": ""object"", + ""title"": ""Original Pet Title"", + ""description"": ""Original Pet Description"", + ""properties"": { + ""name"": { + ""type"": ""string"" + } + } + } + } + } +}"; + + // Act + var readResult = OpenApiDocument.Parse(jsonContent, "json"); + var document = readResult.Document; + + // Assert + Assert.NotNull(document); + Assert.Empty(readResult.Diagnostic.Errors); + + var schema = document.Paths["/test"].Operations[HttpMethod.Get] + .Responses["200"].Content["application/json"].Schema; + + Assert.IsType(schema); + var schemaRef = (OpenApiSchemaReference)schema; + + // Test that reference annotations override target values + Assert.Equal("Pet Response Schema", schemaRef.Title); + Assert.Equal("A pet object returned from the API", schemaRef.Description); + Assert.True(schemaRef.Deprecated); + Assert.True(schemaRef.ReadOnly); + Assert.False(schemaRef.WriteOnly); + Assert.NotNull(schemaRef.Default); + Assert.Single(schemaRef.Examples); + + // Test that target schema still has original values + var targetSchema = schemaRef.Target; + Assert.NotNull(targetSchema); + Assert.Equal("Original Pet Title", targetSchema.Title); + Assert.Equal("Original Pet Description", targetSchema.Description); + } + } +} diff --git a/test/Microsoft.OpenApi.Tests/PublicApi/PublicApi.approved.txt b/test/Microsoft.OpenApi.Tests/PublicApi/PublicApi.approved.txt index 19248ec7b..89dda519e 100644 --- a/test/Microsoft.OpenApi.Tests/PublicApi/PublicApi.approved.txt +++ b/test/Microsoft.OpenApi.Tests/PublicApi/PublicApi.approved.txt @@ -5,17 +5,39 @@ [assembly: System.Runtime.Versioning.TargetFramework(".NETCoreApp,Version=v8.0", FrameworkDisplayName=".NET 8.0")] namespace Microsoft.OpenApi { - public abstract class BaseOpenApiReferenceHolder : Microsoft.OpenApi.IOpenApiElement, Microsoft.OpenApi.IOpenApiReferenceHolder, Microsoft.OpenApi.IOpenApiReferenceHolder, Microsoft.OpenApi.IOpenApiSerializable - where T : class, Microsoft.OpenApi.IOpenApiReferenceable, V - where V : Microsoft.OpenApi.IOpenApiReferenceable, Microsoft.OpenApi.IOpenApiSerializable + public class BaseOpenApiReference : Microsoft.OpenApi.IOpenApiElement, Microsoft.OpenApi.IOpenApiSerializable { - protected BaseOpenApiReferenceHolder(Microsoft.OpenApi.BaseOpenApiReferenceHolder source) { } + public BaseOpenApiReference() { } + public BaseOpenApiReference(Microsoft.OpenApi.BaseOpenApiReference reference) { } + public string? ExternalResource { get; init; } + public Microsoft.OpenApi.OpenApiDocument? HostDocument { get; init; } + public string? Id { get; init; } + public bool IsExternal { get; } + public bool IsFragment { get; init; } + public bool IsLocal { get; } + public string? ReferenceV2 { get; } + public string? ReferenceV3 { get; } + public Microsoft.OpenApi.ReferenceType Type { get; init; } + protected virtual void SerializeAdditionalV31Properties(Microsoft.OpenApi.IOpenApiWriter writer) { } + public virtual void SerializeAsV2(Microsoft.OpenApi.IOpenApiWriter writer) { } + public virtual void SerializeAsV3(Microsoft.OpenApi.IOpenApiWriter writer) { } + public virtual void SerializeAsV31(Microsoft.OpenApi.IOpenApiWriter writer) { } + protected virtual void SetAdditional31MetadataFromMapNode(System.Text.Json.Nodes.JsonObject jsonObject) { } + protected static string? GetPropertyValueFromNode(System.Text.Json.Nodes.JsonObject jsonObject, string key) { } + } + public abstract class BaseOpenApiReferenceHolder : Microsoft.OpenApi.IOpenApiElement, Microsoft.OpenApi.IOpenApiReferenceHolder, Microsoft.OpenApi.IOpenApiReferenceHolder, Microsoft.OpenApi.IOpenApiReferenceHolder, Microsoft.OpenApi.IOpenApiSerializable + where T : class, Microsoft.OpenApi.IOpenApiReferenceable, U + where U : Microsoft.OpenApi.IOpenApiReferenceable, Microsoft.OpenApi.IOpenApiSerializable + where V : Microsoft.OpenApi.BaseOpenApiReference, new () + { + protected BaseOpenApiReferenceHolder(Microsoft.OpenApi.BaseOpenApiReferenceHolder source) { } protected BaseOpenApiReferenceHolder(string referenceId, Microsoft.OpenApi.OpenApiDocument? hostDocument, Microsoft.OpenApi.ReferenceType referenceType, string? externalResource) { } public T RecursiveTarget { get; } - public Microsoft.OpenApi.OpenApiReference Reference { get; init; } - public virtual V Target { get; } + public V Reference { get; init; } + public virtual U Target { get; } public bool UnresolvedReference { get; } - public abstract V CopyReferenceAsTargetElementWithOverrides(V source); + protected abstract V CopyReference(V sourceReference); + public abstract U CopyReferenceAsTargetElementWithOverrides(U source); public virtual void SerializeAsV2(Microsoft.OpenApi.IOpenApiWriter writer) { } public virtual void SerializeAsV3(Microsoft.OpenApi.IOpenApiWriter writer) { } public virtual void SerializeAsV31(Microsoft.OpenApi.IOpenApiWriter writer) { } @@ -161,15 +183,20 @@ namespace Microsoft.OpenApi } public interface IOpenApiReferenceHolder : Microsoft.OpenApi.IOpenApiElement, Microsoft.OpenApi.IOpenApiSerializable { - Microsoft.OpenApi.OpenApiReference Reference { get; init; } bool UnresolvedReference { get; } } - public interface IOpenApiReferenceHolder : Microsoft.OpenApi.IOpenApiElement, Microsoft.OpenApi.IOpenApiReferenceHolder, Microsoft.OpenApi.IOpenApiSerializable - where out T : Microsoft.OpenApi.IOpenApiReferenceable, V + public interface IOpenApiReferenceHolder : Microsoft.OpenApi.IOpenApiElement, Microsoft.OpenApi.IOpenApiReferenceHolder, Microsoft.OpenApi.IOpenApiSerializable + where V : Microsoft.OpenApi.BaseOpenApiReference, new () + { + V Reference { get; init; } + } + public interface IOpenApiReferenceHolder : Microsoft.OpenApi.IOpenApiElement, Microsoft.OpenApi.IOpenApiReferenceHolder, Microsoft.OpenApi.IOpenApiReferenceHolder, Microsoft.OpenApi.IOpenApiSerializable + where out T : Microsoft.OpenApi.IOpenApiReferenceable, U + where V : Microsoft.OpenApi.BaseOpenApiReference, new () { T RecursiveTarget { get; } - V Target { get; } - V CopyReferenceAsTargetElementWithOverrides(V source); + U Target { get; } + U CopyReferenceAsTargetElementWithOverrides(U source); } public interface IOpenApiReferenceable : Microsoft.OpenApi.IOpenApiElement, Microsoft.OpenApi.IOpenApiSerializable { } public interface IOpenApiRequestBody : Microsoft.OpenApi.IOpenApiDescribedElement, Microsoft.OpenApi.IOpenApiElement, Microsoft.OpenApi.IOpenApiReadOnlyExtensible, Microsoft.OpenApi.IOpenApiReferenceable, Microsoft.OpenApi.IOpenApiSerializable, Microsoft.OpenApi.IShallowCopyable @@ -305,6 +332,19 @@ namespace Microsoft.OpenApi public string[] Tokens { get; } public override string ToString() { } } + public class JsonSchemaReference : Microsoft.OpenApi.OpenApiReferenceWithDescription + { + public JsonSchemaReference() { } + public JsonSchemaReference(Microsoft.OpenApi.JsonSchemaReference reference) { } + public System.Text.Json.Nodes.JsonNode? Default { get; set; } + public bool? Deprecated { get; set; } + public System.Collections.Generic.IList? Examples { get; set; } + public bool? ReadOnly { get; set; } + public string? Title { get; set; } + public bool? WriteOnly { get; set; } + protected override void SerializeAdditionalV31Properties(Microsoft.OpenApi.IOpenApiWriter writer) { } + protected override void SetAdditional31MetadataFromMapNode(System.Text.Json.Nodes.JsonObject jsonObject) { } + } [System.Flags] public enum JsonSchemaType { @@ -346,11 +386,12 @@ namespace Microsoft.OpenApi public virtual void SerializeAsV3(Microsoft.OpenApi.IOpenApiWriter writer) { } public virtual void SerializeAsV31(Microsoft.OpenApi.IOpenApiWriter writer) { } } - public class OpenApiCallbackReference : Microsoft.OpenApi.BaseOpenApiReferenceHolder, Microsoft.OpenApi.IOpenApiCallback, Microsoft.OpenApi.IOpenApiElement, Microsoft.OpenApi.IOpenApiReadOnlyExtensible, Microsoft.OpenApi.IOpenApiReferenceable, Microsoft.OpenApi.IOpenApiSerializable, Microsoft.OpenApi.IShallowCopyable + public class OpenApiCallbackReference : Microsoft.OpenApi.BaseOpenApiReferenceHolder, Microsoft.OpenApi.IOpenApiCallback, Microsoft.OpenApi.IOpenApiElement, Microsoft.OpenApi.IOpenApiReadOnlyExtensible, Microsoft.OpenApi.IOpenApiReferenceable, Microsoft.OpenApi.IOpenApiSerializable, Microsoft.OpenApi.IShallowCopyable { public OpenApiCallbackReference(string referenceId, Microsoft.OpenApi.OpenApiDocument? hostDocument = null, string? externalResource = null) { } public System.Collections.Generic.IDictionary? Extensions { get; } public System.Collections.Generic.Dictionary? PathItems { get; } + protected override Microsoft.OpenApi.BaseOpenApiReference CopyReference(Microsoft.OpenApi.BaseOpenApiReference sourceReference) { } public override Microsoft.OpenApi.IOpenApiCallback CopyReferenceAsTargetElementWithOverrides(Microsoft.OpenApi.IOpenApiCallback source) { } public Microsoft.OpenApi.IOpenApiCallback CreateShallowCopy() { } public override void SerializeAsV2(Microsoft.OpenApi.IOpenApiWriter writer) { } @@ -640,7 +681,7 @@ namespace Microsoft.OpenApi public virtual void SerializeAsV3(Microsoft.OpenApi.IOpenApiWriter writer) { } public virtual void SerializeAsV31(Microsoft.OpenApi.IOpenApiWriter writer) { } } - public class OpenApiExampleReference : Microsoft.OpenApi.BaseOpenApiReferenceHolder, Microsoft.OpenApi.IOpenApiDescribedElement, Microsoft.OpenApi.IOpenApiElement, Microsoft.OpenApi.IOpenApiExample, Microsoft.OpenApi.IOpenApiReadOnlyExtensible, Microsoft.OpenApi.IOpenApiReferenceable, Microsoft.OpenApi.IOpenApiSerializable, Microsoft.OpenApi.IOpenApiSummarizedElement, Microsoft.OpenApi.IShallowCopyable + public class OpenApiExampleReference : Microsoft.OpenApi.BaseOpenApiReferenceHolder, Microsoft.OpenApi.IOpenApiDescribedElement, Microsoft.OpenApi.IOpenApiElement, Microsoft.OpenApi.IOpenApiExample, Microsoft.OpenApi.IOpenApiReadOnlyExtensible, Microsoft.OpenApi.IOpenApiReferenceable, Microsoft.OpenApi.IOpenApiSerializable, Microsoft.OpenApi.IOpenApiSummarizedElement, Microsoft.OpenApi.IShallowCopyable { public OpenApiExampleReference(string referenceId, Microsoft.OpenApi.OpenApiDocument? hostDocument = null, string? externalResource = null) { } public string? Description { get; set; } @@ -648,6 +689,7 @@ namespace Microsoft.OpenApi public string? ExternalValue { get; } public string? Summary { get; set; } public System.Text.Json.Nodes.JsonNode? Value { get; } + protected override Microsoft.OpenApi.OpenApiReferenceWithDescriptionAndSummary CopyReference(Microsoft.OpenApi.OpenApiReferenceWithDescriptionAndSummary sourceReference) { } public override Microsoft.OpenApi.IOpenApiExample CopyReferenceAsTargetElementWithOverrides(Microsoft.OpenApi.IOpenApiExample source) { } public Microsoft.OpenApi.IOpenApiExample CreateShallowCopy() { } public override void SerializeAsV2(Microsoft.OpenApi.IOpenApiWriter writer) { } @@ -721,7 +763,7 @@ namespace Microsoft.OpenApi public virtual void SerializeAsV3(Microsoft.OpenApi.IOpenApiWriter writer) { } public virtual void SerializeAsV31(Microsoft.OpenApi.IOpenApiWriter writer) { } } - public class OpenApiHeaderReference : Microsoft.OpenApi.BaseOpenApiReferenceHolder, Microsoft.OpenApi.IOpenApiDescribedElement, Microsoft.OpenApi.IOpenApiElement, Microsoft.OpenApi.IOpenApiHeader, Microsoft.OpenApi.IOpenApiReadOnlyExtensible, Microsoft.OpenApi.IOpenApiReferenceable, Microsoft.OpenApi.IOpenApiSerializable, Microsoft.OpenApi.IShallowCopyable + public class OpenApiHeaderReference : Microsoft.OpenApi.BaseOpenApiReferenceHolder, Microsoft.OpenApi.IOpenApiDescribedElement, Microsoft.OpenApi.IOpenApiElement, Microsoft.OpenApi.IOpenApiHeader, Microsoft.OpenApi.IOpenApiReadOnlyExtensible, Microsoft.OpenApi.IOpenApiReferenceable, Microsoft.OpenApi.IOpenApiSerializable, Microsoft.OpenApi.IShallowCopyable { public OpenApiHeaderReference(string referenceId, Microsoft.OpenApi.OpenApiDocument? hostDocument = null, string? externalResource = null) { } public bool AllowEmptyValue { get; } @@ -736,6 +778,7 @@ namespace Microsoft.OpenApi public bool Required { get; } public Microsoft.OpenApi.IOpenApiSchema? Schema { get; } public Microsoft.OpenApi.ParameterStyle? Style { get; } + protected override Microsoft.OpenApi.OpenApiReferenceWithDescription CopyReference(Microsoft.OpenApi.OpenApiReferenceWithDescription sourceReference) { } public override Microsoft.OpenApi.IOpenApiHeader CopyReferenceAsTargetElementWithOverrides(Microsoft.OpenApi.IOpenApiHeader source) { } public Microsoft.OpenApi.IOpenApiHeader CreateShallowCopy() { } } @@ -814,7 +857,7 @@ namespace Microsoft.OpenApi public virtual void SerializeAsV3(Microsoft.OpenApi.IOpenApiWriter writer) { } public virtual void SerializeAsV31(Microsoft.OpenApi.IOpenApiWriter writer) { } } - public class OpenApiLinkReference : Microsoft.OpenApi.BaseOpenApiReferenceHolder, Microsoft.OpenApi.IOpenApiDescribedElement, Microsoft.OpenApi.IOpenApiElement, Microsoft.OpenApi.IOpenApiLink, Microsoft.OpenApi.IOpenApiReadOnlyExtensible, Microsoft.OpenApi.IOpenApiReferenceable, Microsoft.OpenApi.IOpenApiSerializable, Microsoft.OpenApi.IShallowCopyable + public class OpenApiLinkReference : Microsoft.OpenApi.BaseOpenApiReferenceHolder, Microsoft.OpenApi.IOpenApiDescribedElement, Microsoft.OpenApi.IOpenApiElement, Microsoft.OpenApi.IOpenApiLink, Microsoft.OpenApi.IOpenApiReadOnlyExtensible, Microsoft.OpenApi.IOpenApiReferenceable, Microsoft.OpenApi.IOpenApiSerializable, Microsoft.OpenApi.IShallowCopyable { public OpenApiLinkReference(string referenceId, Microsoft.OpenApi.OpenApiDocument? hostDocument = null, string? externalResource = null) { } public string? Description { get; set; } @@ -824,6 +867,7 @@ namespace Microsoft.OpenApi public System.Collections.Generic.IDictionary? Parameters { get; } public Microsoft.OpenApi.RuntimeExpressionAnyWrapper? RequestBody { get; } public Microsoft.OpenApi.OpenApiServer? Server { get; } + protected override Microsoft.OpenApi.OpenApiReferenceWithDescription CopyReference(Microsoft.OpenApi.OpenApiReferenceWithDescription sourceReference) { } public override Microsoft.OpenApi.IOpenApiLink CopyReferenceAsTargetElementWithOverrides(Microsoft.OpenApi.IOpenApiLink source) { } public Microsoft.OpenApi.IOpenApiLink CreateShallowCopy() { } public override void SerializeAsV2(Microsoft.OpenApi.IOpenApiWriter writer) { } @@ -924,7 +968,7 @@ namespace Microsoft.OpenApi public virtual void SerializeAsV3(Microsoft.OpenApi.IOpenApiWriter writer) { } public virtual void SerializeAsV31(Microsoft.OpenApi.IOpenApiWriter writer) { } } - public class OpenApiParameterReference : Microsoft.OpenApi.BaseOpenApiReferenceHolder, Microsoft.OpenApi.IOpenApiDescribedElement, Microsoft.OpenApi.IOpenApiElement, Microsoft.OpenApi.IOpenApiParameter, Microsoft.OpenApi.IOpenApiReadOnlyExtensible, Microsoft.OpenApi.IOpenApiReferenceable, Microsoft.OpenApi.IOpenApiSerializable, Microsoft.OpenApi.IShallowCopyable + public class OpenApiParameterReference : Microsoft.OpenApi.BaseOpenApiReferenceHolder, Microsoft.OpenApi.IOpenApiDescribedElement, Microsoft.OpenApi.IOpenApiElement, Microsoft.OpenApi.IOpenApiParameter, Microsoft.OpenApi.IOpenApiReadOnlyExtensible, Microsoft.OpenApi.IOpenApiReferenceable, Microsoft.OpenApi.IOpenApiSerializable, Microsoft.OpenApi.IShallowCopyable { public OpenApiParameterReference(string referenceId, Microsoft.OpenApi.OpenApiDocument? hostDocument = null, string? externalResource = null) { } public bool AllowEmptyValue { get; } @@ -941,6 +985,7 @@ namespace Microsoft.OpenApi public bool Required { get; } public Microsoft.OpenApi.IOpenApiSchema? Schema { get; } public Microsoft.OpenApi.ParameterStyle? Style { get; } + protected override Microsoft.OpenApi.OpenApiReferenceWithDescription CopyReference(Microsoft.OpenApi.OpenApiReferenceWithDescription sourceReference) { } public override Microsoft.OpenApi.IOpenApiParameter CopyReferenceAsTargetElementWithOverrides(Microsoft.OpenApi.IOpenApiParameter source) { } public Microsoft.OpenApi.IOpenApiParameter CreateShallowCopy() { } } @@ -966,7 +1011,7 @@ namespace Microsoft.OpenApi public virtual void SerializeAsV3(Microsoft.OpenApi.IOpenApiWriter writer) { } public virtual void SerializeAsV31(Microsoft.OpenApi.IOpenApiWriter writer) { } } - public class OpenApiPathItemReference : Microsoft.OpenApi.BaseOpenApiReferenceHolder, Microsoft.OpenApi.IOpenApiDescribedElement, Microsoft.OpenApi.IOpenApiElement, Microsoft.OpenApi.IOpenApiPathItem, Microsoft.OpenApi.IOpenApiReadOnlyExtensible, Microsoft.OpenApi.IOpenApiReferenceable, Microsoft.OpenApi.IOpenApiSerializable, Microsoft.OpenApi.IOpenApiSummarizedElement, Microsoft.OpenApi.IShallowCopyable + public class OpenApiPathItemReference : Microsoft.OpenApi.BaseOpenApiReferenceHolder, Microsoft.OpenApi.IOpenApiDescribedElement, Microsoft.OpenApi.IOpenApiElement, Microsoft.OpenApi.IOpenApiPathItem, Microsoft.OpenApi.IOpenApiReadOnlyExtensible, Microsoft.OpenApi.IOpenApiReferenceable, Microsoft.OpenApi.IOpenApiSerializable, Microsoft.OpenApi.IOpenApiSummarizedElement, Microsoft.OpenApi.IShallowCopyable { public OpenApiPathItemReference(string referenceId, Microsoft.OpenApi.OpenApiDocument? hostDocument = null, string? externalResource = null) { } public string? Description { get; set; } @@ -975,6 +1020,7 @@ namespace Microsoft.OpenApi public System.Collections.Generic.IList? Parameters { get; } public System.Collections.Generic.IList? Servers { get; } public string? Summary { get; set; } + protected override Microsoft.OpenApi.OpenApiReferenceWithDescriptionAndSummary CopyReference(Microsoft.OpenApi.OpenApiReferenceWithDescriptionAndSummary sourceReference) { } public override Microsoft.OpenApi.IOpenApiPathItem CopyReferenceAsTargetElementWithOverrides(Microsoft.OpenApi.IOpenApiPathItem source) { } public Microsoft.OpenApi.IOpenApiPathItem CreateShallowCopy() { } public override void SerializeAsV2(Microsoft.OpenApi.IOpenApiWriter writer) { } @@ -998,30 +1044,27 @@ namespace Microsoft.OpenApi public OpenApiReaderException(string message, Microsoft.OpenApi.Reader.ParsingContext context) { } public OpenApiReaderException(string message, System.Exception innerException) { } } - public class OpenApiReference : Microsoft.OpenApi.IOpenApiDescribedElement, Microsoft.OpenApi.IOpenApiElement, Microsoft.OpenApi.IOpenApiSerializable, Microsoft.OpenApi.IOpenApiSummarizedElement + public class OpenApiReferenceError : Microsoft.OpenApi.OpenApiError + { + public readonly Microsoft.OpenApi.BaseOpenApiReference? Reference; + public OpenApiReferenceError(Microsoft.OpenApi.OpenApiException exception) { } + public OpenApiReferenceError(Microsoft.OpenApi.BaseOpenApiReference reference, string message) { } + } + public class OpenApiReferenceWithDescription : Microsoft.OpenApi.BaseOpenApiReference, Microsoft.OpenApi.IOpenApiDescribedElement, Microsoft.OpenApi.IOpenApiElement { - public OpenApiReference() { } - public OpenApiReference(Microsoft.OpenApi.OpenApiReference reference) { } + public OpenApiReferenceWithDescription() { } + public OpenApiReferenceWithDescription(Microsoft.OpenApi.OpenApiReferenceWithDescription reference) { } public string? Description { get; set; } - public string? ExternalResource { get; init; } - public Microsoft.OpenApi.OpenApiDocument? HostDocument { get; init; } - public string? Id { get; init; } - public bool IsExternal { get; } - public bool IsFragment { get; init; } - public bool IsLocal { get; } - public string? ReferenceV2 { get; } - public string? ReferenceV3 { get; } - public string? Summary { get; set; } - public Microsoft.OpenApi.ReferenceType Type { get; init; } - public void SerializeAsV2(Microsoft.OpenApi.IOpenApiWriter writer) { } - public void SerializeAsV3(Microsoft.OpenApi.IOpenApiWriter writer) { } - public void SerializeAsV31(Microsoft.OpenApi.IOpenApiWriter writer) { } + protected override void SerializeAdditionalV31Properties(Microsoft.OpenApi.IOpenApiWriter writer) { } + protected override void SetAdditional31MetadataFromMapNode(System.Text.Json.Nodes.JsonObject jsonObject) { } } - public class OpenApiReferenceError : Microsoft.OpenApi.OpenApiError + public class OpenApiReferenceWithDescriptionAndSummary : Microsoft.OpenApi.OpenApiReferenceWithDescription, Microsoft.OpenApi.IOpenApiElement, Microsoft.OpenApi.IOpenApiSummarizedElement { - public readonly Microsoft.OpenApi.OpenApiReference? Reference; - public OpenApiReferenceError(Microsoft.OpenApi.OpenApiException exception) { } - public OpenApiReferenceError(Microsoft.OpenApi.OpenApiReference reference, string message) { } + public OpenApiReferenceWithDescriptionAndSummary() { } + public OpenApiReferenceWithDescriptionAndSummary(Microsoft.OpenApi.OpenApiReferenceWithDescriptionAndSummary reference) { } + public string? Summary { get; set; } + protected override void SerializeAdditionalV31Properties(Microsoft.OpenApi.IOpenApiWriter writer) { } + protected override void SetAdditional31MetadataFromMapNode(System.Text.Json.Nodes.JsonObject jsonObject) { } } public static class OpenApiReferenceableExtensions { @@ -1041,7 +1084,7 @@ namespace Microsoft.OpenApi public virtual void SerializeAsV3(Microsoft.OpenApi.IOpenApiWriter writer) { } public virtual void SerializeAsV31(Microsoft.OpenApi.IOpenApiWriter writer) { } } - public class OpenApiRequestBodyReference : Microsoft.OpenApi.BaseOpenApiReferenceHolder, Microsoft.OpenApi.IOpenApiDescribedElement, Microsoft.OpenApi.IOpenApiElement, Microsoft.OpenApi.IOpenApiReadOnlyExtensible, Microsoft.OpenApi.IOpenApiReferenceable, Microsoft.OpenApi.IOpenApiRequestBody, Microsoft.OpenApi.IOpenApiSerializable, Microsoft.OpenApi.IShallowCopyable + public class OpenApiRequestBodyReference : Microsoft.OpenApi.BaseOpenApiReferenceHolder, Microsoft.OpenApi.IOpenApiDescribedElement, Microsoft.OpenApi.IOpenApiElement, Microsoft.OpenApi.IOpenApiReadOnlyExtensible, Microsoft.OpenApi.IOpenApiReferenceable, Microsoft.OpenApi.IOpenApiRequestBody, Microsoft.OpenApi.IOpenApiSerializable, Microsoft.OpenApi.IShallowCopyable { public OpenApiRequestBodyReference(string referenceId, Microsoft.OpenApi.OpenApiDocument? hostDocument = null, string? externalResource = null) { } public System.Collections.Generic.IDictionary? Content { get; } @@ -1050,6 +1093,7 @@ namespace Microsoft.OpenApi public bool Required { get; } public Microsoft.OpenApi.IOpenApiParameter? ConvertToBodyParameter(Microsoft.OpenApi.IOpenApiWriter writer) { } public System.Collections.Generic.IEnumerable? ConvertToFormDataParameters(Microsoft.OpenApi.IOpenApiWriter writer) { } + protected override Microsoft.OpenApi.OpenApiReferenceWithDescription CopyReference(Microsoft.OpenApi.OpenApiReferenceWithDescription sourceReference) { } public override Microsoft.OpenApi.IOpenApiRequestBody CopyReferenceAsTargetElementWithOverrides(Microsoft.OpenApi.IOpenApiRequestBody source) { } public Microsoft.OpenApi.IOpenApiRequestBody CreateShallowCopy() { } public override void SerializeAsV2(Microsoft.OpenApi.IOpenApiWriter writer) { } @@ -1067,7 +1111,7 @@ namespace Microsoft.OpenApi public virtual void SerializeAsV3(Microsoft.OpenApi.IOpenApiWriter writer) { } public virtual void SerializeAsV31(Microsoft.OpenApi.IOpenApiWriter writer) { } } - public class OpenApiResponseReference : Microsoft.OpenApi.BaseOpenApiReferenceHolder, Microsoft.OpenApi.IOpenApiDescribedElement, Microsoft.OpenApi.IOpenApiElement, Microsoft.OpenApi.IOpenApiReadOnlyExtensible, Microsoft.OpenApi.IOpenApiReferenceable, Microsoft.OpenApi.IOpenApiResponse, Microsoft.OpenApi.IOpenApiSerializable, Microsoft.OpenApi.IShallowCopyable + public class OpenApiResponseReference : Microsoft.OpenApi.BaseOpenApiReferenceHolder, Microsoft.OpenApi.IOpenApiDescribedElement, Microsoft.OpenApi.IOpenApiElement, Microsoft.OpenApi.IOpenApiReadOnlyExtensible, Microsoft.OpenApi.IOpenApiReferenceable, Microsoft.OpenApi.IOpenApiResponse, Microsoft.OpenApi.IOpenApiSerializable, Microsoft.OpenApi.IShallowCopyable { public OpenApiResponseReference(string referenceId, Microsoft.OpenApi.OpenApiDocument? hostDocument = null, string? externalResource = null) { } public System.Collections.Generic.IDictionary? Content { get; } @@ -1075,6 +1119,7 @@ namespace Microsoft.OpenApi public System.Collections.Generic.IDictionary? Extensions { get; } public System.Collections.Generic.IDictionary? Headers { get; } public System.Collections.Generic.IDictionary? Links { get; } + protected override Microsoft.OpenApi.OpenApiReferenceWithDescription CopyReference(Microsoft.OpenApi.OpenApiReferenceWithDescription sourceReference) { } public override Microsoft.OpenApi.IOpenApiResponse CopyReferenceAsTargetElementWithOverrides(Microsoft.OpenApi.IOpenApiResponse source) { } public Microsoft.OpenApi.IOpenApiResponse CreateShallowCopy() { } } @@ -1157,7 +1202,7 @@ namespace Microsoft.OpenApi public virtual void SerializeAsV3(Microsoft.OpenApi.IOpenApiWriter writer) { } public virtual void SerializeAsV31(Microsoft.OpenApi.IOpenApiWriter writer) { } } - public class OpenApiSchemaReference : Microsoft.OpenApi.BaseOpenApiReferenceHolder, Microsoft.OpenApi.IOpenApiDescribedElement, Microsoft.OpenApi.IOpenApiElement, Microsoft.OpenApi.IOpenApiReadOnlyExtensible, Microsoft.OpenApi.IOpenApiReferenceable, Microsoft.OpenApi.IOpenApiSchema, Microsoft.OpenApi.IOpenApiSerializable, Microsoft.OpenApi.IShallowCopyable + public class OpenApiSchemaReference : Microsoft.OpenApi.BaseOpenApiReferenceHolder, Microsoft.OpenApi.IOpenApiDescribedElement, Microsoft.OpenApi.IOpenApiElement, Microsoft.OpenApi.IOpenApiReadOnlyExtensible, Microsoft.OpenApi.IOpenApiReferenceable, Microsoft.OpenApi.IOpenApiSchema, Microsoft.OpenApi.IOpenApiSerializable, Microsoft.OpenApi.IShallowCopyable { public OpenApiSchemaReference(string referenceId, Microsoft.OpenApi.OpenApiDocument? hostDocument = null, string? externalResource = null) { } public Microsoft.OpenApi.IOpenApiSchema? AdditionalProperties { get; } @@ -1166,17 +1211,17 @@ namespace Microsoft.OpenApi public System.Collections.Generic.IList? AnyOf { get; } public string? Comment { get; } public string? Const { get; } - public System.Text.Json.Nodes.JsonNode? Default { get; } + public System.Text.Json.Nodes.JsonNode? Default { get; set; } public System.Collections.Generic.IDictionary? Definitions { get; } public System.Collections.Generic.IDictionary>? DependentRequired { get; } - public bool Deprecated { get; } + public bool Deprecated { get; set; } public string? Description { get; set; } public Microsoft.OpenApi.OpenApiDiscriminator? Discriminator { get; } public string? DynamicAnchor { get; } public string? DynamicRef { get; } public System.Collections.Generic.IList? Enum { get; } public System.Text.Json.Nodes.JsonNode? Example { get; } - public System.Collections.Generic.IList? Examples { get; } + public System.Collections.Generic.IList? Examples { get; set; } public string? ExclusiveMaximum { get; } public string? ExclusiveMinimum { get; } public System.Collections.Generic.IDictionary? Extensions { get; } @@ -1198,17 +1243,18 @@ namespace Microsoft.OpenApi public string? Pattern { get; } public System.Collections.Generic.IDictionary? PatternProperties { get; } public System.Collections.Generic.IDictionary? Properties { get; } - public bool ReadOnly { get; } + public bool ReadOnly { get; set; } public System.Collections.Generic.ISet? Required { get; } public System.Uri? Schema { get; } - public string? Title { get; } + public string? Title { get; set; } public Microsoft.OpenApi.JsonSchemaType? Type { get; } public bool UnevaluatedProperties { get; } public bool? UniqueItems { get; } public System.Collections.Generic.IDictionary? UnrecognizedKeywords { get; } public System.Collections.Generic.IDictionary? Vocabulary { get; } - public bool WriteOnly { get; } + public bool WriteOnly { get; set; } public Microsoft.OpenApi.OpenApiXml? Xml { get; } + protected override Microsoft.OpenApi.JsonSchemaReference CopyReference(Microsoft.OpenApi.JsonSchemaReference sourceReference) { } public override Microsoft.OpenApi.IOpenApiSchema CopyReferenceAsTargetElementWithOverrides(Microsoft.OpenApi.IOpenApiSchema source) { } public Microsoft.OpenApi.IOpenApiSchema CreateShallowCopy() { } public override void SerializeAsV2(Microsoft.OpenApi.IOpenApiWriter writer) { } @@ -1246,7 +1292,7 @@ namespace Microsoft.OpenApi public virtual void SerializeAsV3(Microsoft.OpenApi.IOpenApiWriter writer) { } public virtual void SerializeAsV31(Microsoft.OpenApi.IOpenApiWriter writer) { } } - public class OpenApiSecuritySchemeReference : Microsoft.OpenApi.BaseOpenApiReferenceHolder, Microsoft.OpenApi.IOpenApiDescribedElement, Microsoft.OpenApi.IOpenApiElement, Microsoft.OpenApi.IOpenApiReadOnlyExtensible, Microsoft.OpenApi.IOpenApiReferenceable, Microsoft.OpenApi.IOpenApiSecurityScheme, Microsoft.OpenApi.IOpenApiSerializable, Microsoft.OpenApi.IShallowCopyable + public class OpenApiSecuritySchemeReference : Microsoft.OpenApi.BaseOpenApiReferenceHolder, Microsoft.OpenApi.IOpenApiDescribedElement, Microsoft.OpenApi.IOpenApiElement, Microsoft.OpenApi.IOpenApiReadOnlyExtensible, Microsoft.OpenApi.IOpenApiReferenceable, Microsoft.OpenApi.IOpenApiSecurityScheme, Microsoft.OpenApi.IOpenApiSerializable, Microsoft.OpenApi.IShallowCopyable { public OpenApiSecuritySchemeReference(string referenceId, Microsoft.OpenApi.OpenApiDocument? hostDocument = null, string? externalResource = null) { } public string? BearerFormat { get; } @@ -1258,6 +1304,7 @@ namespace Microsoft.OpenApi public System.Uri? OpenIdConnectUrl { get; } public string? Scheme { get; } public Microsoft.OpenApi.SecuritySchemeType? Type { get; } + protected override Microsoft.OpenApi.OpenApiReferenceWithDescription CopyReference(Microsoft.OpenApi.OpenApiReferenceWithDescription sourceReference) { } public override Microsoft.OpenApi.IOpenApiSecurityScheme CopyReferenceAsTargetElementWithOverrides(Microsoft.OpenApi.IOpenApiSecurityScheme source) { } public Microsoft.OpenApi.IOpenApiSecurityScheme CreateShallowCopy() { } } @@ -1331,7 +1378,7 @@ namespace Microsoft.OpenApi public virtual void SerializeAsV3(Microsoft.OpenApi.IOpenApiWriter writer) { } public virtual void SerializeAsV31(Microsoft.OpenApi.IOpenApiWriter writer) { } } - public class OpenApiTagReference : Microsoft.OpenApi.BaseOpenApiReferenceHolder, Microsoft.OpenApi.IOpenApiElement, Microsoft.OpenApi.IOpenApiReadOnlyDescribedElement, Microsoft.OpenApi.IOpenApiReadOnlyExtensible, Microsoft.OpenApi.IOpenApiReferenceable, Microsoft.OpenApi.IOpenApiSerializable, Microsoft.OpenApi.IOpenApiTag, Microsoft.OpenApi.IShallowCopyable + public class OpenApiTagReference : Microsoft.OpenApi.BaseOpenApiReferenceHolder, Microsoft.OpenApi.IOpenApiElement, Microsoft.OpenApi.IOpenApiReadOnlyDescribedElement, Microsoft.OpenApi.IOpenApiReadOnlyExtensible, Microsoft.OpenApi.IOpenApiReferenceable, Microsoft.OpenApi.IOpenApiSerializable, Microsoft.OpenApi.IOpenApiTag, Microsoft.OpenApi.IShallowCopyable { public OpenApiTagReference(string referenceId, Microsoft.OpenApi.OpenApiDocument? hostDocument = null, string? externalResource = null) { } public string? Description { get; } @@ -1339,6 +1386,7 @@ namespace Microsoft.OpenApi public Microsoft.OpenApi.OpenApiExternalDocs? ExternalDocs { get; } public string? Name { get; } public override Microsoft.OpenApi.IOpenApiTag? Target { get; } + protected override Microsoft.OpenApi.BaseOpenApiReference CopyReference(Microsoft.OpenApi.BaseOpenApiReference sourceReference) { } public override Microsoft.OpenApi.IOpenApiTag CopyReferenceAsTargetElementWithOverrides(Microsoft.OpenApi.IOpenApiTag source) { } public Microsoft.OpenApi.IOpenApiTag CreateShallowCopy() { } }