grafana/pkg/plugins/codegen/tmpl/composable_registry.tmpl

package schemas

import (
    "fmt"
    "io"
    "io/fs"
    "os"
    "path/filepath"
    "runtime"
    "testing/fstest"

    "cuelang.org/go/cue"
    "cuelang.org/go/cue/cuecontext"
    "cuelang.org/go/cue/load"
)

var cueImportsPath = filepath.Join("packages", "grafana-schema", "src", "common")
var importPath = "github.com/grafana/grafana/packages/grafana-schema/src/common"

type ComposableKind struct {
    Name string
    Filename string
    CueFile cue.Value
}

func GetComposableKinds() ([]ComposableKind, error) {
    kinds := make([]ComposableKind, 0)
    
    _, caller, _, _ := runtime.Caller(0)
    root := filepath.Join(caller, "../../../..")
    
    {{- range .Schemas }}
    
    {{ .Name }}Cue, err := loadCueFileWithCommon(root, filepath.Join(root, "{{ .FilePath }}"))
    if err != nil {
        return nil, err
    }
    kinds = append(kinds, ComposableKind{
        Name: "{{ .Name }}",
        Filename: "{{ .Filename }}",
        CueFile: {{ .Name }}Cue,
    })
    {{- end }}
    
    return kinds, nil
}

func loadCueFileWithCommon(root string, entrypoint string) (cue.Value, error) {
	commonFS, err := mockCommonFS(root)
	if err != nil {
		fmt.Printf("cannot load common cue files: %s\n", err)
		return cue.Value{}, err
	}

	overlay, err := buildOverlay(commonFS)
	if err != nil {
		fmt.Printf("Cannot build overlay: %s\n", err)
		return cue.Value{}, err
	}

	bis := load.Instances([]string{entrypoint}, &load.Config{
		ModuleRoot: "/",
		Overlay:    overlay,
	})

	values, err := cuecontext.New().BuildInstances(bis)
	if err != nil {
		fmt.Printf("Cannot build instance: %s\n", err)
		return cue.Value{}, err
	}

	return values[0], nil
}

func mockCommonFS(root string) (fs.FS, error) {
    path := filepath.Join(root, cueImportsPath)
	dir, err := os.ReadDir(path)
	if err != nil {
		return nil, fmt.Errorf("cannot open common cue files directory: %s", err)
	}

	prefix := "cue.mod/pkg/" + importPath

	commonFS := fstest.MapFS{}
	for _, d := range dir {
		if d.IsDir() {
			continue
		}

		readPath := filepath.Join(path, d.Name())
		b, err := os.ReadFile(filepath.Clean(readPath))
		if err != nil {
			return nil, err
		}

		commonFS[filepath.Join(prefix, d.Name())] = &fstest.MapFile{Data: b}
	}

	return commonFS, nil
}

// It loads common cue files into the schema to be able to make import works
func buildOverlay(commonFS fs.FS) (map[string]load.Source, error) {
	overlay := make(map[string]load.Source)

	err := fs.WalkDir(commonFS, ".", func(path string, d fs.DirEntry, err error) error {
		if err != nil {
			return err
		}

		if d.IsDir() {
			return nil
		}

		f, err := commonFS.Open(path)
		if err != nil {
			return err
		}
		defer func() { _ = f.Close() }()

		b, err := io.ReadAll(f)
		if err != nil {
			return err
		}

		overlay[filepath.Join("/", path)] = load.FromBytes(b)

		return nil
	})

	return overlay, err
}