mirror of
https://github.com/LukeHagar/libopenapi.git
synced 2025-12-07 20:47:45 +00:00
336 lines
11 KiB
Go
336 lines
11 KiB
Go
// Copyright 2022 Princess B33f Heavy Industries / Dave Shanley
|
|
// SPDX-License-Identifier: MIT
|
|
|
|
// Package model
|
|
//
|
|
// What-changed models are unified across OpenAPI and Swagger. Everything is kept flat for simplicity, so please
|
|
// excuse the size of the package. There is a lot of data to crunch!
|
|
//
|
|
// Every model in here is either universal (works across both versions of OpenAPI) or is bound to a specific version
|
|
// of OpenAPI. There is only a single model however - so version specific objects are marked accordingly.
|
|
package model
|
|
|
|
import (
|
|
"reflect"
|
|
|
|
"github.com/pb33f/libopenapi/datamodel/low"
|
|
"github.com/pb33f/libopenapi/datamodel/low/base"
|
|
v2 "github.com/pb33f/libopenapi/datamodel/low/v2"
|
|
v3 "github.com/pb33f/libopenapi/datamodel/low/v3"
|
|
)
|
|
|
|
// DocumentChanges represents all the changes made to an OpenAPI document.
|
|
type DocumentChanges struct {
|
|
*PropertyChanges
|
|
InfoChanges *InfoChanges `json:"info,omitempty" yaml:"info,omitempty"`
|
|
PathsChanges *PathsChanges `json:"paths,omitempty" yaml:"paths,omitempty"`
|
|
TagChanges []*TagChanges `json:"tags,omitempty" yaml:"tags,omitempty"`
|
|
ExternalDocChanges *ExternalDocChanges `json:"externalDoc,omitempty" yaml:"externalDoc,omitempty"`
|
|
WebhookChanges map[string]*PathItemChanges `json:"webhooks,omitempty" yaml:"webhooks,omitempty"`
|
|
ServerChanges []*ServerChanges `json:"servers,omitempty" yaml:"servers,omitempty"`
|
|
SecurityRequirementChanges []*SecurityRequirementChanges `json:"securityRequirements,omitempty" yaml:"securityRequirements,omitempty"`
|
|
ComponentsChanges *ComponentsChanges `json:"components,omitempty" yaml:"components,omitempty"`
|
|
ExtensionChanges *ExtensionChanges `json:"extensions,omitempty" yaml:"extensions,omitempty"`
|
|
}
|
|
|
|
// TotalChanges returns a total count of all changes made in the Document
|
|
func (d *DocumentChanges) TotalChanges() int {
|
|
if d == nil {
|
|
return 0
|
|
}
|
|
|
|
c := d.PropertyChanges.TotalChanges()
|
|
if d.InfoChanges != nil {
|
|
c += d.InfoChanges.TotalChanges()
|
|
}
|
|
if d.PathsChanges != nil {
|
|
c += d.PathsChanges.TotalChanges()
|
|
}
|
|
for k := range d.TagChanges {
|
|
c += d.TagChanges[k].TotalChanges()
|
|
}
|
|
if d.ExternalDocChanges != nil {
|
|
c += d.ExternalDocChanges.TotalChanges()
|
|
}
|
|
for k := range d.WebhookChanges {
|
|
c += d.WebhookChanges[k].TotalChanges()
|
|
}
|
|
for k := range d.ServerChanges {
|
|
c += d.ServerChanges[k].TotalChanges()
|
|
}
|
|
for k := range d.SecurityRequirementChanges {
|
|
c += d.SecurityRequirementChanges[k].TotalChanges()
|
|
}
|
|
if d.ComponentsChanges != nil {
|
|
c += d.ComponentsChanges.TotalChanges()
|
|
}
|
|
if d.ExtensionChanges != nil {
|
|
c += d.ExtensionChanges.TotalChanges()
|
|
}
|
|
return c
|
|
}
|
|
|
|
// GetAllChanges returns a slice of all changes made between Document objects
|
|
func (d *DocumentChanges) GetAllChanges() []*Change {
|
|
if d == nil {
|
|
return nil
|
|
}
|
|
|
|
var changes []*Change
|
|
changes = append(changes, d.Changes...)
|
|
if d.InfoChanges != nil {
|
|
changes = append(changes, d.InfoChanges.GetAllChanges()...)
|
|
}
|
|
if d.PathsChanges != nil {
|
|
changes = append(changes, d.PathsChanges.GetAllChanges()...)
|
|
}
|
|
for k := range d.TagChanges {
|
|
changes = append(changes, d.TagChanges[k].GetAllChanges()...)
|
|
}
|
|
if d.ExternalDocChanges != nil {
|
|
changes = append(changes, d.ExternalDocChanges.GetAllChanges()...)
|
|
}
|
|
for k := range d.WebhookChanges {
|
|
changes = append(changes, d.WebhookChanges[k].GetAllChanges()...)
|
|
}
|
|
for k := range d.ServerChanges {
|
|
changes = append(changes, d.ServerChanges[k].GetAllChanges()...)
|
|
}
|
|
for k := range d.SecurityRequirementChanges {
|
|
changes = append(changes, d.SecurityRequirementChanges[k].GetAllChanges()...)
|
|
}
|
|
if d.ComponentsChanges != nil {
|
|
changes = append(changes, d.ComponentsChanges.GetAllChanges()...)
|
|
}
|
|
if d.ExtensionChanges != nil {
|
|
changes = append(changes, d.ExtensionChanges.GetAllChanges()...)
|
|
}
|
|
return changes
|
|
}
|
|
|
|
// TotalBreakingChanges returns a total count of all breaking changes made in the Document
|
|
func (d *DocumentChanges) TotalBreakingChanges() int {
|
|
if d == nil {
|
|
return 0
|
|
}
|
|
|
|
c := d.PropertyChanges.TotalBreakingChanges()
|
|
if d.InfoChanges != nil {
|
|
c += d.InfoChanges.TotalBreakingChanges()
|
|
}
|
|
if d.PathsChanges != nil {
|
|
c += d.PathsChanges.TotalBreakingChanges()
|
|
}
|
|
for k := range d.TagChanges {
|
|
c += d.TagChanges[k].TotalBreakingChanges()
|
|
}
|
|
if d.ExternalDocChanges != nil {
|
|
c += d.ExternalDocChanges.TotalBreakingChanges()
|
|
}
|
|
for k := range d.WebhookChanges {
|
|
c += d.WebhookChanges[k].TotalBreakingChanges()
|
|
}
|
|
for k := range d.ServerChanges {
|
|
c += d.ServerChanges[k].TotalBreakingChanges()
|
|
}
|
|
for k := range d.SecurityRequirementChanges {
|
|
c += d.SecurityRequirementChanges[k].TotalBreakingChanges()
|
|
}
|
|
if d.ComponentsChanges != nil {
|
|
c += d.ComponentsChanges.TotalBreakingChanges()
|
|
}
|
|
return c
|
|
}
|
|
|
|
// CompareDocuments will compare any two OpenAPI documents (either Swagger or OpenAPI) and return a pointer to
|
|
// DocumentChanges that outlines everything that was found to have changed.
|
|
func CompareDocuments(l, r any) *DocumentChanges {
|
|
var changes []*Change
|
|
var props []*PropertyCheck
|
|
|
|
dc := new(DocumentChanges)
|
|
|
|
if reflect.TypeOf(&v2.Swagger{}) == reflect.TypeOf(l) && reflect.TypeOf(&v2.Swagger{}) == reflect.TypeOf(r) {
|
|
lDoc := l.(*v2.Swagger)
|
|
rDoc := r.(*v2.Swagger)
|
|
|
|
// version
|
|
addPropertyCheck(&props, lDoc.Swagger.ValueNode, rDoc.Swagger.ValueNode,
|
|
lDoc.Swagger.Value, rDoc.Swagger.Value, &changes, v3.SwaggerLabel, true)
|
|
|
|
// host
|
|
addPropertyCheck(&props, lDoc.Host.ValueNode, rDoc.Host.ValueNode,
|
|
lDoc.Host.Value, rDoc.Host.Value, &changes, v3.HostLabel, true)
|
|
|
|
// base path
|
|
addPropertyCheck(&props, lDoc.BasePath.ValueNode, rDoc.BasePath.ValueNode,
|
|
lDoc.BasePath.Value, rDoc.BasePath.Value, &changes, v3.BasePathLabel, true)
|
|
|
|
// schemes
|
|
if len(lDoc.Schemes.Value) > 0 || len(rDoc.Schemes.Value) > 0 {
|
|
ExtractStringValueSliceChanges(lDoc.Schemes.Value, rDoc.Schemes.Value,
|
|
&changes, v3.SchemesLabel, true)
|
|
}
|
|
// consumes
|
|
if len(lDoc.Consumes.Value) > 0 || len(rDoc.Consumes.Value) > 0 {
|
|
ExtractStringValueSliceChanges(lDoc.Consumes.Value, rDoc.Consumes.Value,
|
|
&changes, v3.ConsumesLabel, true)
|
|
}
|
|
// produces
|
|
if len(lDoc.Produces.Value) > 0 || len(rDoc.Produces.Value) > 0 {
|
|
ExtractStringValueSliceChanges(lDoc.Produces.Value, rDoc.Produces.Value,
|
|
&changes, v3.ProducesLabel, true)
|
|
}
|
|
|
|
// tags
|
|
dc.TagChanges = CompareTags(lDoc.Tags.Value, rDoc.Tags.Value)
|
|
|
|
// paths
|
|
if !lDoc.Paths.IsEmpty() || !rDoc.Paths.IsEmpty() {
|
|
dc.PathsChanges = ComparePaths(lDoc.Paths.Value, rDoc.Paths.Value)
|
|
}
|
|
|
|
// external docs
|
|
compareDocumentExternalDocs(lDoc, rDoc, dc, &changes)
|
|
|
|
// info
|
|
compareDocumentInfo(&lDoc.Info, &rDoc.Info, dc, &changes)
|
|
|
|
// security
|
|
if !lDoc.Security.IsEmpty() || !rDoc.Security.IsEmpty() {
|
|
checkSecurity(lDoc.Security, rDoc.Security, &changes, dc)
|
|
}
|
|
|
|
// components / definitions
|
|
// swagger (damn you) decided to put all this stuff at the document root, rather than cleanly
|
|
// placing it under a parent, like they did with OpenAPI. This means picking through each definition
|
|
// creating a new set of changes and then morphing them into a single changes object.
|
|
cc := new(ComponentsChanges)
|
|
cc.PropertyChanges = new(PropertyChanges)
|
|
if n := CompareComponents(lDoc.Definitions.Value, rDoc.Definitions.Value); n != nil {
|
|
cc.SchemaChanges = n.SchemaChanges
|
|
}
|
|
if n := CompareComponents(lDoc.SecurityDefinitions.Value, rDoc.SecurityDefinitions.Value); n != nil {
|
|
cc.SecuritySchemeChanges = n.SecuritySchemeChanges
|
|
}
|
|
if n := CompareComponents(lDoc.Parameters.Value, rDoc.Parameters.Value); n != nil {
|
|
cc.PropertyChanges.Changes = append(cc.PropertyChanges.Changes, n.Changes...)
|
|
}
|
|
if n := CompareComponents(lDoc.Responses.Value, rDoc.Responses.Value); n != nil {
|
|
cc.Changes = append(cc.Changes, n.Changes...)
|
|
}
|
|
dc.ExtensionChanges = CompareExtensions(lDoc.Extensions, rDoc.Extensions)
|
|
if cc.TotalChanges() > 0 {
|
|
dc.ComponentsChanges = cc
|
|
}
|
|
}
|
|
|
|
if reflect.TypeOf(&v3.Document{}) == reflect.TypeOf(l) && reflect.TypeOf(&v3.Document{}) == reflect.TypeOf(r) {
|
|
lDoc := l.(*v3.Document)
|
|
rDoc := r.(*v3.Document)
|
|
|
|
// version
|
|
addPropertyCheck(&props, lDoc.Version.ValueNode, rDoc.Version.ValueNode,
|
|
lDoc.Version.Value, rDoc.Version.Value, &changes, v3.OpenAPILabel, true)
|
|
|
|
// schema dialect
|
|
addPropertyCheck(&props, lDoc.JsonSchemaDialect.ValueNode, rDoc.JsonSchemaDialect.ValueNode,
|
|
lDoc.JsonSchemaDialect.Value, rDoc.JsonSchemaDialect.Value, &changes, v3.JSONSchemaDialectLabel, true)
|
|
|
|
// tags
|
|
dc.TagChanges = CompareTags(lDoc.Tags.Value, rDoc.Tags.Value)
|
|
|
|
// paths
|
|
if !lDoc.Paths.IsEmpty() || !rDoc.Paths.IsEmpty() {
|
|
dc.PathsChanges = ComparePaths(lDoc.Paths.Value, rDoc.Paths.Value)
|
|
}
|
|
|
|
// external docs
|
|
compareDocumentExternalDocs(lDoc, rDoc, dc, &changes)
|
|
|
|
// info
|
|
compareDocumentInfo(&lDoc.Info, &rDoc.Info, dc, &changes)
|
|
|
|
// security
|
|
if !lDoc.Security.IsEmpty() || !rDoc.Security.IsEmpty() {
|
|
checkSecurity(lDoc.Security, rDoc.Security, &changes, dc)
|
|
}
|
|
|
|
// compare components.
|
|
if !lDoc.Components.IsEmpty() && !rDoc.Components.IsEmpty() {
|
|
if n := CompareComponents(lDoc.Components.Value, rDoc.Components.Value); n != nil {
|
|
dc.ComponentsChanges = n
|
|
}
|
|
}
|
|
if !lDoc.Components.IsEmpty() && rDoc.Components.IsEmpty() {
|
|
CreateChange(&changes, PropertyRemoved, v3.ComponentsLabel,
|
|
lDoc.Components.ValueNode, nil, true, lDoc.Components.Value, nil)
|
|
}
|
|
if lDoc.Components.IsEmpty() && !rDoc.Components.IsEmpty() {
|
|
CreateChange(&changes, PropertyAdded, v3.ComponentsLabel,
|
|
rDoc.Components.ValueNode, nil, false, nil, lDoc.Components.Value)
|
|
}
|
|
|
|
// compare servers
|
|
if n := checkServers(lDoc.Servers, rDoc.Servers); n != nil {
|
|
dc.ServerChanges = n
|
|
}
|
|
|
|
// compare webhooks
|
|
dc.WebhookChanges = CheckMapForChanges(lDoc.Webhooks.Value, rDoc.Webhooks.Value, &changes,
|
|
v3.WebhooksLabel, ComparePathItemsV3)
|
|
|
|
// extensions
|
|
dc.ExtensionChanges = CompareExtensions(lDoc.Extensions, rDoc.Extensions)
|
|
}
|
|
|
|
CheckProperties(props)
|
|
dc.PropertyChanges = NewPropertyChanges(changes)
|
|
if dc.TotalChanges() <= 0 {
|
|
return nil
|
|
}
|
|
return dc
|
|
}
|
|
|
|
func compareDocumentExternalDocs(l, r low.HasExternalDocs, dc *DocumentChanges, changes *[]*Change) {
|
|
// external docs
|
|
if !l.GetExternalDocs().IsEmpty() && !r.GetExternalDocs().IsEmpty() {
|
|
lExtDoc := l.GetExternalDocs().Value.(*base.ExternalDoc)
|
|
rExtDoc := r.GetExternalDocs().Value.(*base.ExternalDoc)
|
|
if !low.AreEqual(lExtDoc, rExtDoc) {
|
|
dc.ExternalDocChanges = CompareExternalDocs(lExtDoc, rExtDoc)
|
|
}
|
|
}
|
|
if l.GetExternalDocs().IsEmpty() && !r.GetExternalDocs().IsEmpty() {
|
|
CreateChange(changes, PropertyAdded, v3.ExternalDocsLabel,
|
|
nil, r.GetExternalDocs().ValueNode, false, nil,
|
|
r.GetExternalDocs().Value)
|
|
}
|
|
if !l.GetExternalDocs().IsEmpty() && r.GetExternalDocs().IsEmpty() {
|
|
CreateChange(changes, PropertyRemoved, v3.ExternalDocsLabel,
|
|
l.GetExternalDocs().ValueNode, nil, false, l.GetExternalDocs().Value,
|
|
nil)
|
|
}
|
|
}
|
|
|
|
func compareDocumentInfo(l, r *low.NodeReference[*base.Info], dc *DocumentChanges, changes *[]*Change) {
|
|
// info
|
|
if !l.IsEmpty() && !r.IsEmpty() {
|
|
lInfo := l.Value
|
|
rInfo := r.Value
|
|
if !low.AreEqual(lInfo, rInfo) {
|
|
dc.InfoChanges = CompareInfo(lInfo, rInfo)
|
|
}
|
|
}
|
|
if l.IsEmpty() && !r.IsEmpty() {
|
|
CreateChange(changes, PropertyAdded, v3.InfoLabel,
|
|
nil, r.ValueNode, false, nil,
|
|
r.Value)
|
|
}
|
|
if !l.IsEmpty() && r.IsEmpty() {
|
|
CreateChange(changes, PropertyRemoved, v3.InfoLabel,
|
|
l.ValueNode, nil, false, l.Value,
|
|
nil)
|
|
}
|
|
}
|