Bundle OpenAPI references into a single file

// BundleBytesComposed will take a byte slice of an OpenAPI specification and return a composed bundled version of it.
// this is the same as BundleBytes, but it will compose the bundling instead of inline it.
func BundleBytesComposed(bytes []byte, configuration *datamodel.DocumentConfiguration,
	compositionConfig *BundleCompositionConfig) ([]byte, error) {

// BundleCompositionConfig is used to configure the composition of OpenAPI documents when using BundleDocumentComposed.
type BundleCompositionConfig struct {
	Delimiter string // Delimiter is used to separate clashing names. Defaults to `__`.
}

// BundleDocumentComposed will take a v3.Document and return a composed bundled version of it. Composed means
// that every external file will have references lifted out and added to the `components` section of the document.
// Names will be preserved where possible, conflicts will be appended with a number. If the type of the reference cannot
// be determined, it will be added to the `components` section as a `Schema` type, a warning will be logged.
// The document model will be mutated permanently.
//
// Circular references will not be resolved and will be skipped.
func BundleDocumentComposed(model *v3.Document, compositionConfig *BundleCompositionConfig) ([]byte, error) {
	return compose(model, compositionConfig)
}

func BundleBytes(bytes []byte, configuration *datamodel.DocumentConfiguration) ([]byte, error)

func BundleDocument(model *v3.Document) ([]byte, error)

import (
  "bytes"
  "github.com/pb33f/libopenapi"
  "github.com/pb33f/libopenapi/bundler"
  "github.com/pb33f/libopenapi/datamodel"
  "github.com/stretchr/testify/assert"
  "log"
  "log/slog"
  "os"
  "os/exec"
  "path/filepath"
  "runtime"
  "strings"
)

func main() {

  // check out the mother of all exploded specifications
  tmp, _ := os.MkdirTemp("", "openapi")
  cmd := exec.Command("git", "clone", "https://github.com/digitalocean/openapi", tmp)
  defer os.RemoveAll(filepath.Join(tmp, "openapi"))

  err := cmd.Run()
  if err != nil {
      log.Fatalf("cmd.Run() failed with %s\n", err)
  }

  spec, _ := filepath.Abs(filepath.Join(tmp+"/specification", "DigitalOcean-public.v2.yaml"))
  specBytes, _ := os.ReadFile(spec)

  doc, err := libopenapi.NewDocumentWithConfiguration([]byte(specBytes), &datamodel.DocumentConfiguration{
      Logger: slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{
          Level: slog.LevelWarn,
      })),
  }) 
  if err != nil {
      panic(err) 
  }

  v3Doc, errs := doc.BuildV3Model()
  if len(errs) > 0 {
      panic(errs)
  }

  bytes, e := bundler.BundleDocument(&v3Doc.Model)

 //... do something with the bytes
}

// BundleInlineConfig provides configuration options for inline bundling.
type BundleInlineConfig struct {
    // ResolveDiscriminatorExternalRefs when true, copies external schemas referenced
    // by discriminator mappings to the root document's components section.
    // This ensures the bundled output is valid and self-contained.
    ResolveDiscriminatorExternalRefs bool
}

// Bundle raw bytes with configuration
func BundleBytesWithConfig(bytes []byte, configuration *datamodel.DocumentConfiguration,
    bundleConfig *BundleInlineConfig) ([]byte, error)

// Bundle a document with configuration
func BundleDocumentWithConfig(model *v3.Document, bundleConfig *BundleInlineConfig) ([]byte, error)

ResolveDiscriminatorExternalRefs: true

import (
  "github.com/pb33f/libopenapi"
  "github.com/pb33f/libopenapi/bundler"
  "github.com/pb33f/libopenapi/datamodel"
  "log/slog"
  "os"
)

func main() {
  // Read the OpenAPI specification
  specBytes, _ := os.ReadFile("path/to/spec.yaml")

  // Configure document loading
  docConfig := &datamodel.DocumentConfiguration{
      AllowFileReferences:     true,
      Logger: slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{
          Level: slog.LevelWarn,
      })),
  }

  // Create the document
  doc, err := libopenapi.NewDocumentWithConfiguration(specBytes, docConfig)
  if err != nil {
      panic(err)
  }

  v3Doc, errs := doc.BuildV3Model()
  if len(errs) > 0 {
      panic(errs)
  }

  // Configure inline bundling with discriminator resolution
  bundleConfig := &bundler.BundleInlineConfig{
      ResolveDiscriminatorExternalRefs: true,
  }

  // Bundle with configuration
  bundledBytes, err := bundler.BundleDocumentWithConfig(&v3Doc.Model, bundleConfig)
  if err != nil {
      panic(err)
  }

  // Write the bundled specification
  os.WriteFile("bundled-spec.yaml", bundledBytes, 0644)
}

// Bundle bytes with discriminator resolution
bundleConfig := &bundler.BundleInlineConfig{
    ResolveDiscriminatorExternalRefs: true,
}

bundledBytes, err := bundler.BundleBytesWithConfig(specBytes, docConfig, bundleConfig)