0
0
package apigen
import (
"encoding/json"
"errors"
"fmt"
"go/ast"
"go/parser"
"go/token"
"os"
"path"
"path/filepath"
"reflect"
"regexp"
"sort"
"strconv"
"strings"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
commonv1 "github.com/johnandersen777/socialweb-computer-kcp/api/common/v1alpha1"
v1alpha1 "github.com/johnandersen777/socialweb-computer-kcp/api/v1alpha1"
)
const (
TypeObject = "object"
TypeString = "string"
TypeInteger = "integer"
TypeBoolean = "boolean"
TypeArray = "array"
RefObjectMeta = "ObjectMeta"
RefCondition = "Condition"
optionalTag = "optional"
)
type Schema struct {
Type string
Format string
Enum []string
Ref string
Properties []Property
Closed bool
Items *Schema
AdditionalProperties *Schema
PreserveUnknown bool
Default any
Minimum *int64
Maximum *int64
MaxLength *int64
Pattern string
ListType string
ListMapKeys []string
}
type Property struct {
Name string
Required bool
Schema *Schema
}
func (s *Schema) Required() []string {
var out []string
for _, p := range s.Properties {
if p.Required {
out = append(out, p.Name)
}
}
return out
}
type Resource struct {
Kind string
ListKind string
Plural string
Singular string
Revision int
Export string
Schema *Schema
PrinterColumns []v1alpha1.PrinterColumn
Conditions bool
Contracts []string
}
func (r Resource) SchemaName(group, version string) string {
return fmt.Sprintf("%s-%d.%s.%s", version, r.Revision, r.Plural, group)
}
type Model struct {
Dir string
Package string
Group string
Version string
Resources []Resource
Named map[string]*Schema
Order []string
}
var (
conditionType = reflect.TypeFor[metav1.Condition]()
conditionsType = reflect.TypeFor[[]metav1.Condition]()
timeType = reflect.TypeFor[metav1.Time]()
rawJSONType = reflect.TypeFor[json.RawMessage]()
objectMetaType = reflect.TypeFor[metav1.ObjectMeta]()
typeMetaType = reflect.TypeFor[metav1.TypeMeta]()
commonPkgPath = reflect.TypeFor[commonv1.ObjectRef]().PkgPath()
)
func BuildV1alpha1(root string) (*Model, error) {
groups := Groups()
return BuildGroup(root, groups[0])
}
func Build(root string) ([]*Model, error) {
groups := Groups()
models := make([]*Model, 0, len(groups))
for _, g := range groups {
m, err := BuildGroup(root, g)
if err != nil {
return nil, fmt.Errorf("%s: %w", g.Group, err)
}
models = append(models, m)
}
if err := checkContracts(models); err != nil {
return nil, err
}
return models, nil
}
func checkContracts(models []*Model) error {
abstract := map[string]*Schema{}
for _, m := range models {
for _, r := range m.Resources {
abstract[r.Plural] = r.Schema
}
}
var errs []error
for _, m := range models {
for _, r := range m.Resources {
for _, c := range r.Contracts {
root, ok := abstract[c]
if !ok {
errs = append(errs, fmt.Errorf("%s: contract %q names no resource", r.Kind, c))
continue
}
spec := root.property("spec")
if spec == nil || spec.Schema == nil || spec.Schema.property("backendRef") == nil {
errs = append(errs, fmt.Errorf("%s: contract %q is not an abstract kind: it has no spec.backendRef", r.Kind, c))
}
}
}
}
return errors.Join(errs...)
}
func BuildGroup(root string, g Group) (*Model, error) {
enumValues, err := readEnums(filepath.Join(root, filepath.FromSlash(g.Dir)))
if err != nil {
return nil, err
}
b := &builder{
model: &Model{
Dir: g.Dir,
Package: path.Base(g.Package),
Group: g.Group,
Version: g.Version,
Named: map[string]*Schema{},
},
enumValues: enumValues,
pkgPath: g.Package,
types: map[string]reflect.Type{},
}
b.model.Named[RefObjectMeta] = &Schema{Type: TypeObject, Ref: RefObjectMeta}
b.model.Named[RefCondition] = &Schema{Type: TypeObject, Ref: RefCondition, PreserveUnknown: true}
seen := map[string]bool{}
for _, r := range g.Resources {
if seen[r.Kind] {
return nil, fmt.Errorf("%s.APIResources lists %s twice", g.Dir, r.Kind)
}
seen[r.Kind] = true
if r.Revision < 1 {
return nil, fmt.Errorf("%s: Revision must be 1 or more, got %d", r.Kind, r.Revision)
}
root, err := b.root(reflect.TypeOf(r.Object), r.Kind)
if err != nil {
return nil, fmt.Errorf("%s: %w", r.Kind, err)
}
if err := b.checkSpecEndpoints(reflect.TypeOf(r.Object)); err != nil {
b.errs = append(b.errs, fmt.Errorf("%s: %w", r.Kind, err))
}
for _, c := range r.PrinterColumns {
if err := checkColumn(root, c); err != nil {
return nil, fmt.Errorf("%s: printer column %s: %w", r.Kind, c.Name, err)
}
}
b.model.Resources = append(b.model.Resources, Resource{
Kind: r.Kind,
ListKind: r.Kind + "List",
Plural: r.Plural,
Singular: strings.ToLower(r.Kind),
Revision: r.Revision,
Export: r.Export,
Schema: root,
PrinterColumns: r.PrinterColumns,
Conditions: hasStatusConditions(reflect.TypeOf(r.Object)),
Contracts: r.Contracts,
})
}
if err := checkLexicons(root, g.Dir, b.model.Named); err != nil {
b.errs = append(b.errs, err)
}
if err := errors.Join(b.errs...); err != nil {
return nil, err
}
return b.model, nil
}
func hasStatusConditions(t reflect.Type) bool {
status, ok := t.FieldByName("Status")
if !ok || status.Type.Kind() != reflect.Struct {
return false
}
conditions, ok := status.Type.FieldByName("Conditions")
return ok && conditions.Type == conditionsType
}
var columnTypes = map[string]string{
"string": TypeString,
"integer": TypeInteger,
"boolean": TypeBoolean,
"date": TypeString,
}
var conditionColumn = regexp.MustCompile(`^(\.[A-Za-z0-9.]+)\[\?\(@\.type=="[A-Za-z][A-Za-z0-9]*"\)\]\.(status|reason|message)$`)
func columnField(root *Schema, jsonPath, fieldPath string) (*Schema, error) {
s := root
for name := range strings.SplitSeq(fieldPath[1:], ".") {
if s.Ref == RefObjectMeta {
return nil, nil
}
var next *Schema
for _, p := range s.Properties {
if p.Name == name {
next = p.Schema
}
}
if next == nil {
return nil, fmt.Errorf("jsonPath %q names no field %s", jsonPath, name)
}
s = next
}
return s, nil
}
func checkColumn(root *Schema, c v1alpha1.PrinterColumn) error {
want, ok := columnTypes[c.Type]
if !ok {
return fmt.Errorf("type %q is not one of string, integer, boolean, date", c.Type)
}
if !strings.HasPrefix(c.JSONPath, ".") {
return fmt.Errorf("jsonPath %q does not start with a dot", c.JSONPath)
}
if m := conditionColumn.FindStringSubmatch(c.JSONPath); m != nil {
list, err := columnField(root, c.JSONPath, m[1])
if err != nil {
return err
}
if list == nil || list.Type != TypeArray || list.Items == nil || list.Items.Ref != RefCondition {
return fmt.Errorf("jsonPath %q filters %s, which is not a conditions list", c.JSONPath, m[1])
}
if want != TypeString {
return fmt.Errorf("jsonPath %q is a string, the column says %s", c.JSONPath, c.Type)
}
return nil
}
s, err := columnField(root, c.JSONPath, c.JSONPath)
if err != nil || s == nil {
return err
}
if s.Type != want {
return fmt.Errorf("jsonPath %q is a %s, the column says %s", c.JSONPath, s.Type, c.Type)
}
return nil
}
type builder struct {
model *Model
enumValues map[string][]string
pkgPath string
types map[string]reflect.Type
errs []error
reported map[string]bool
}
func (b *builder) name(s *Schema) {
b.model.Named[s.Ref] = s
b.model.Order = append(b.model.Order, s.Ref)
}
func (b *builder) root(t reflect.Type, kind string) (*Schema, error) {
if t.Kind() != reflect.Struct || t.Name() != kind {
return nil, fmt.Errorf("the registered Object is %v, want the struct %s", t, kind)
}
s := &Schema{Type: TypeObject, Ref: kind, Closed: true}
b.name(s)
if err := b.fields(s, t); err != nil {
return nil, err
}
return s, nil
}
func (b *builder) fields(s *Schema, t reflect.Type) error {
for f := range t.Fields() {
switch {
case f.Type == typeMetaType:
s.Properties = append(s.Properties,
Property{Name: "apiVersion", Schema: &Schema{Type: TypeString}},
Property{Name: "kind", Schema: &Schema{Type: TypeString}})
case f.Type == objectMetaType:
s.Properties = append(s.Properties, Property{Name: "metadata", Schema: b.model.Named[RefObjectMeta]})
default:
props, err := b.properties(f)
if err != nil {
return err
}
s.Properties = append(s.Properties, props...)
}
}
return nil
}
func (b *builder) properties(f reflect.StructField) ([]Property, error) {
tag := f.Tag.Get("json")
parts := strings.Split(tag, ",")
name := parts[0]
if name == "-" {
return nil, nil
}
if f.Anonymous && name == "" {
s, err := b.schema(f.Type)
if err != nil {
return nil, fmt.Errorf("field %s: %w", f.Name, err)
}
if s.Type != TypeObject || s.AdditionalProperties != nil || !s.Closed {
return nil, fmt.Errorf("embedded field %s is not a closed object", f.Name)
}
return s.Properties, nil
}
if name == "" {
return nil, fmt.Errorf("field %s carries no json name", f.Name)
}
omitempty := false
for _, o := range parts[1:] {
if o == "omitempty" {
omitempty = true
}
}
opts, err := parseTag(f.Tag.Get("apigen"))
if err != nil {
return nil, fmt.Errorf("field %s: %w", f.Name, err)
}
if f.Type.Kind() == reflect.Pointer && !omitempty {
return nil, fmt.Errorf("field %s is a pointer without omitempty, which writes null", f.Name)
}
s, err := b.schema(f.Type)
if err != nil {
return nil, fmt.Errorf("field %s: %w", f.Name, err)
}
if s, err = opts.apply(s); err != nil {
return nil, fmt.Errorf("field %s: %w", f.Name, err)
}
required := !omitempty && !opts.Optional && opts.Default == nil
return []Property{{Name: name, Required: required, Schema: s}}, nil
}
func (b *builder) schema(t reflect.Type) (*Schema, error) {
if t == conditionType {
return b.model.Named[RefCondition], nil
}
if t == timeType {
return &Schema{Type: TypeString, Format: "date-time"}, nil
}
if t == rawJSONType {
return &Schema{Type: TypeObject, PreserveUnknown: true}, nil
}
if t.Kind() == reflect.Interface {
if t.NumMethod() != 0 {
return nil, fmt.Errorf("interface %v is not empty and has no mapping", t)
}
return &Schema{Type: TypeObject, PreserveUnknown: true}, nil
}
switch t.Kind() {
case reflect.Pointer:
return b.schema(t.Elem())
case reflect.String:
if t.PkgPath() == "" {
return &Schema{Type: TypeString}, nil
}
if t.PkgPath() != b.pkgPath {
return nil, fmt.Errorf("named string type %v is outside %s", t, b.pkgPath)
}
if s, ok := b.model.Named[t.Name()]; ok {
return s, nil
}
values := b.enumValues[t.Name()]
if len(values) == 0 {
return nil, fmt.Errorf("named string type %s declares no constants, so it has no enum", t.Name())
}
s := &Schema{Type: TypeString, Enum: values, Ref: t.Name()}
b.name(s)
return s, nil
case reflect.Bool:
return &Schema{Type: TypeBoolean}, nil
case reflect.Int:
return &Schema{Type: TypeInteger}, nil
case reflect.Int32:
return &Schema{Type: TypeInteger, Format: "int32"}, nil
case reflect.Int64:
return &Schema{Type: TypeInteger, Format: "int64"}, nil
case reflect.Slice:
items, err := b.schema(t.Elem())
if err != nil {
return nil, err
}
return &Schema{Type: TypeArray, Items: items}, nil
case reflect.Map:
if t.Key().Kind() != reflect.String {
return nil, fmt.Errorf("map %v does not have string keys", t)
}
if t.PkgPath() != "" && t.PkgPath() != b.pkgPath {
return nil, fmt.Errorf("named map type %v is outside %s", t, b.pkgPath)
}
if t.Name() != "" {
if s, ok := b.model.Named[t.Name()]; ok {
return s, nil
}
}
item, err := b.schema(t.Elem())
if err != nil {
return nil, err
}
s := &Schema{Type: TypeObject, AdditionalProperties: item}
if t.Name() != "" {
s.Ref = t.Name()
b.name(s)
}
return s, nil
case reflect.Struct:
if t.PkgPath() != b.pkgPath && t.PkgPath() != commonPkgPath {
return nil, fmt.Errorf("struct %v is outside %s and %s and has no mapping", t, b.pkgPath, commonPkgPath)
}
if prior, ok := b.types[t.Name()]; ok && prior != t {
return nil, fmt.Errorf("struct %v and %v share the schema name %s", prior, t, t.Name())
}
b.types[t.Name()] = t
if s, ok := b.model.Named[t.Name()]; ok {
return s, nil
}
if t.PkgPath() == b.pkgPath {
if err := b.checkCasing(t); err != nil {
b.errs = append(b.errs, err)
}
}
s := &Schema{Type: TypeObject, Ref: t.Name(), Closed: true}
b.name(s)
if err := b.fields(s, t); err != nil {
return nil, fmt.Errorf("%s: %w", t.Name(), err)
}
return s, nil
default:
return nil, fmt.Errorf("kind %v of %v has no OpenAPI mapping", t.Kind(), t)
}
}
func readEnums(dir string) (map[string][]string, error) {
entries, err := os.ReadDir(dir)
if err != nil {
return nil, err
}
var files []string
for _, e := range entries {
name := e.Name()
if e.IsDir() || !strings.HasSuffix(name, ".go") || strings.HasSuffix(name, "_test.go") {
continue
}
files = append(files, filepath.Join(dir, name))
}
sort.Strings(files)
fset := token.NewFileSet()
enums := map[string][]string{}
for _, path := range files {
f, err := parser.ParseFile(fset, path, nil, 0)
if err != nil {
return nil, err
}
for _, decl := range f.Decls {
gen, ok := decl.(*ast.GenDecl)
if !ok || gen.Tok != token.CONST {
continue
}
for _, spec := range gen.Specs {
vs := spec.(*ast.ValueSpec)
for i, name := range vs.Names {
if i >= len(vs.Values) || !name.IsExported() {
continue
}
lit, ok := vs.Values[i].(*ast.BasicLit)
if !ok || lit.Kind != token.STRING {
continue
}
value, err := strconv.Unquote(lit.Value)
if err != nil {
return nil, fmt.Errorf("%s: %w", fset.Position(lit.Pos()), err)
}
if ident, ok := vs.Type.(*ast.Ident); ok {
enums[ident.Name] = append(enums[ident.Name], value)
}
}
}
}
}
return enums, nil
}