Look up anything in an OpenAPI specification

import (
    "fmt"
    "github.com/pb33f/libopenapi"
    "io/ioutil"
)

func main() {
    // load an OpenAPI 3 specification from bytes
    petstore, _ := ioutil.ReadFile("petstorev3.json")

    // create a new document from specification bytes,
    // ignore the errors for the sake of brevity
    doc, _ := libopenapi.NewDocument(petstore)

    // because we know this is a v3 spec, we can build a ready to go
    // model from it - also ignore the errors.
    v3Model, _ := doc.BuildV3Model()

    // extract the index from the model.
    index := v3Model.Index
    
    // print the number of paths and schemas in the document
    fmt.Printf("There are %d paths and %d schemas in the document\n",
        len(index.GetAllPaths()), len(index.GetAllSchemas()))
}

// Digital Ocean needs a baseURL to be set, so we can resolve relative references.
baseURL, _ := url.Parse("https://raw.githubusercontent.com/digitalocean/openapi/main/specification")

config := index.SpecIndexConfig{
    AllowRemoteLookup: true, // must be set or the rolodex will complain
    BaseURL: baseURL,
}

config := index.SpecIndexConfig{
    AllowFileLookup: true, // must be set or the rolodex will complain
    BasePath: "../some/location/on/disk",
}

// read the Digital Ocean OpenAPI Specification from Github.
func read() []byte {
  res, err := http.Get("https://raw.githubusercontent.com/digitalocean" +
      "/openapi/main/specification/DigitalOcean-public.v2.yaml")
  if err != nil {
      panic(err)
  }
  defer res.Body.Close()
  data, err := io.ReadAll(res.Body)
  if err != nil {
      panic(err) 
  } 
  return data
}

// Index the digital ocean OpenAPI specification
func digitalOcean() {

  // create a root node to unmarshal the spec into.
  var rootNode yaml.Node
  _ = yaml.Unmarshal(read(), &rootNode)

  // create a new config that allows remote lookups.
  indexConfig := index.CreateOpenAPIIndexConfig()

  // we're going to check for circular references later, so we don't want to do it now.
  indexConfig.AvoidCircularReferenceCheck = true

  // create a custom logger (optional)
  indexConfig.Logger = slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{
      Level: slog.LevelError,
  }))

  // define the base URL for the remote filesystem.
  location := "https://raw.githubusercontent.com/digitalocean/openapi/main/specification"
  baseURL, _ := url.Parse(location)

  // set the base URL for the remote filesystem in the config.
  indexConfig.BaseURL = baseURL

  // create a new rolodex
  rolodex := index.NewRolodex(indexConfig)

  // set the rolodex root node to the root node of the spec. 
  rolodex.SetRootNode(&rootNode)

  // create a new remote fs and set the config for indexing.
  remoteFS, _ := index.NewRemoteFSWithConfig(indexConfig)

  // add remote filesystem
  rolodex.AddRemoteFS(location, remoteFS)

  // index the rolodex
  indexedErr := rolodex.IndexTheRolodex() 
  if indexedErr != nil {
      panic(indexedErr) 
  }

  // get all the files!
  files := remoteFS.GetFiles()
  fileLen := len(files)

  // check for circular references across the entire document.
  rolodex.CheckForCircularReferences()

  fmt.Printf("%d files found and %d errors reported. There were %d circular references found.\n",
      fileLen, len(remoteFS.GetErrors()), len(rolodex.GetCaughtErrors()))

  // extrtact the resolver from the root index.
  resolver := rolodex.GetRootIndex().GetResolver()

  // print out some interesting information discovered when visiting all the references.
  fmt.Printf("%d references visited\n", resolver.GetReferenceVisited())
  fmt.Printf("%d journeys taken\n", resolver.GetJourneysTaken())
  fmt.Printf("%d index visits\n", resolver.GetIndexesVisited())
  fmt.Printf("%d relatives seen\n", resolver.GetRelativesSeen())
}