gos builderをいい感じに定義したい

type String struct {
	MinLength int64  `json:"minlength,omitempty"`
	MaxLength int64  `json:"maxlength,omitempty"`
	Pattern   string `json:"pattern,omitempty"`
}

package main

import (
	"encoding/json"
	"os"

	"github.com/podhmo/gos/builder"
)

func main() {
	b := builder.New()

	Name := b.String().MinLength(1).As("Name")

	b.Object(
		b.Field("name", b.String()).Doc("name of person"),
		b.Field("age", b.Integer().Format("int32")),
		b.Field("nickname", b.Reference(Name)).Required(false),
		b.Field("father", b.ReferenceByName("Person")).Required(false),
		b.Field("friends", b.Array(b.ReferenceByName("Person"))).Required(false),
	).As("Person").Doc("person object")

	b.Object(
		b.Field("title", b.String()),
		b.Field("tests", b.Map(b.Integer()).
			PatternProperties(`\-score$`, b.Integer().Doc("score (0~100)")).
			PatternProperties(`\-grade$`, b.String().Doc("grade (A,B,C,D,E,F)"))),
	).As("TestScore")

	doc, err := builder.ToSchema(b)
	if err != nil {
		panic(err)
	}
	enc := json.NewEncoder(os.Stdout)
	enc.SetIndent("", "  ")
	if err := enc.Encode(doc); err != nil {
		panic(err)
	}
}

type Map struct {
	PatternProperties map[string]TypeBuilder `json:"-,omitempty"`
}

type TypeBuilder interface {
	typevalue() *Type
	WriteType(io.Writer) error
	ToSchema(b *Builder) *orderedmap.OrderedMap
}

	// simple
	genum.Define(b.Enum[int]("OneTwo",
		b.Value(1).Name("One"),
		b.Value(2).Name("Two"),
	))

b := genum.NewBuilder()

// simple
genum.Define(b.IntEnum("OneTwo",
	b.Value(1).Name("One"),
	b.Value(2).Name("Two"),
))

// complex
genum.Define(b.StringEnum("RGBColor",
	b.Value("R").Name("Red").Doc("red color"),
	b.Value("G").Name("Green").Doc("red color"),
	b.Value("B").Name("Blue").Doc("red color"),
)).Default("R").Doc("rgb")

getFoo := b.Action(
	b.Input(
		b.Path("id", b.Int()),
	),
	b.Output(
		Foo,
	),
)

router.Get("/foo/{id}") // application/jsonのcontent-typeは自動で補完？

postFoo := prototype.Post("/foo",
	b.Action(
		b.Input(
			b.Body("body", Foo),
		),
		b.Output(NoContent).Status(200),
	),
)

Foo := DefineType("Foo", b.Object(...))


postFoo := prototype.DefineAction("/foo",
	b.Action(
		b.Input(
			b.Body("body", Foo),
		),
		b.Output(NoContent).Status(200),
	),
).Method("POST").OperationID("postFoo").Doc("create foo")

# 全体のroutingを俯瞰できる
r.get("/foo", foo.List, operation_id="list_foo")
r.post("/foo", foo.Create, operation_id="create_foo")

b.Action(
	b.Input(
		b.Field("id", b.String()),
	).Doc("input description"),
	b.Output(
		b.String(),
	).Doc("output description"),
).Doc("action description")

r := prototype.NewRouter(b)
r.Group("person", func(r *prototype.Grouped) {
	createPerson := b.Action("createPerson",
		b.Input(b.Param("name", b.String())),
		b.Output(Person),
	).Doc("create person")

	r.Method("POST", "/person", createPerson)
})

r := prototype.NewRouter(b)
r.Group("person", func(r *prototype.Grouped){
  r.Method("POST", "/person", actions.CreatePerson)
})

product type :: action{input, output}, input{params}, output{return}

cmd := seed.NewCommand(os.Args[1:])
options := cmd.Config

// define
b := seed.NewBuilder(options.PkgName)
b.Metadata.GeneratedBy = "github.com/podhmo/gos/gopenapi/tools"
b.NeedReference()

Type := b.BuildTarget("Type",
	b.Field("Format", seed.Symbol("string")).Tag(`json:"format"`),
)
b.InterfaceMethods("writeTyper // see: ./to_string.go")

Bool := b.Type("Bool").
	NeedBuilder().Underlying("boolean")
Int := b.Type("Int",
	b.Field("Maximum", seed.Symbol("int64")).Tag(`json:"maximum,omitempty"`),
	b.Field("Minimum", seed.Symbol("int64")).Tag(`json:"minimum,omitempty"`),
).NeedBuilder().Underlying("intger")
String := b.Type("String",
	b.Field("Pattern", seed.Symbol("string")).Tag(`json:"pattern,omitempty"`),
	b.Field("MaxLength", seed.Symbol("int64")).Tag(`json:"maxlength,omitempty"`),
	b.Field("MinLength", seed.Symbol("int64")).Tag(`json:"minlength,omitempty"`),
).NeedBuilder().Underlying("string")

Array := b.Type("Array", b.TypeVar("Items", seed.Symbol("TypeBuilder")),
	b.Field("MaxItems", seed.Symbol("int64")).Tag(`json:"maxitems,omitempty"`),
	b.Field("MinItems", seed.Symbol("int64")).Tag(`json:"minitems,omitempty"`),
).NeedBuilder().Underlying("array")
Map := b.Type("Map", b.TypeVar("Items", seed.Symbol("TypeBuilder")),
	b.Field("Pattern", seed.Symbol("string")).Tag(`json:"pattern,omitempty"`),
).NeedBuilder().Underlying("map")

Field := b.Type("Field",
	b.Field("Name", seed.Symbol("string")).Tag(`json:"-"`),
	b.Field("Typ", seed.Symbol("TypeBuilder")).Tag(`json:"-"`),
	b.Field("Description", seed.Symbol("string")).Tag(`json:"description,omitempty"`),
	b.Field("Required", seed.Symbol("bool")).Tag(`json:"-"`),
).Constructor(
	b.Arg("Name", seed.Symbol("string")),
	b.Arg("Typ", seed.Symbol("TypeBuilder")),
).NeedBuilder().Underlying("field") //?

Object := b.Type("Object",
	b.Field("Fields", seed.Symbol("[]*FieldType")).Tag(`json:"-"`),
	b.Field("Strict", seed.Symbol("bool")).Tag(`json:"-"`),
).Constructor(
	b.Arg("Fields", seed.Symbol("*FieldType")).Variadic(),
).NeedBuilder().Underlying("object")

fmt.Fprintln(os.Stderr, Type, Bool, Int, String, Array, Map, Field, Object)
// fmt.Fprintln(os.Stderr, Param, ActionInput, ActionOutput, Action)

// emit
return cmd.Do(b)

// Type is factory method for Type builder.
func (b *Builder) Type(name string, typeVarOrFieldList ...typeAttr) *Type {
	tvars := make([]*TypeVarMetadata, 0, len(typeVarOrFieldList))
	fields := make([]*FieldMetadata, 0, len(typeVarOrFieldList))
	for _, tattr := range typeVarOrFieldList {
		switch t := tattr.(type) {
		case *TypeVar:
			tvars = append(tvars, t.metadata)
		case *Field:
			fields = append(fields, t.metadata)
		default:
			panic(fmt.Sprintf("unexpected type: %T", tattr))
		}
	}

	t := &Type{
		typeBuilder: &typeBuilder[*Type]{metadata: &TypeMetadata{
			Name:       Symbol(name),
			Underlying: name,
			TVars:      tvars,
			Fields:     fields,
			Used:       map[string]bool{},
		}},
	}
	t.ret = t
	b.metadata.Types = append(b.metadata.Types, t.metadata)
	return t
}

TypeVar := DefineType("TypeVar", Type(...)).NeedBuilder()
Field := DefineType("Field", Type(...)).NeedBuilder()

TypeVarOrField := Union(TypeVar, Field) 

Type(
  Field("Fields", "[]*Field"),
  Field("TypeVars", "[]*TypeVar"),
).Constructor(
  Arg("TypeVarsAndFields", "TypeVarOrField").Variadic(),
)

package main

import "fmt"

func main() {
	var Ob struct {
		X int
		y int
	}
	Ob.X, Ob.y = 10, 20
	fmt.Println(Ob)
}

// union
TypeVar := DefineType("TypeVar", Type(...)).NeedBuilder()
Field := DefineType("Field", Type(...)).NeedBuilder()

TypeVarOrField := Union(TypeVar, Field) 

// builder
Object := DefineType("Object", Type(
	Field("Fields", "[]*Field"),
	Field("TypeVars", "[]*TypeVar"),
).Constructor(
	Arg("tattrs", "TypeVarOrField").Variadic().
		AssignFields("Fields", "TypeVars").
		Transform(func(v string) string {
			return fmt.Sprintf(`toSlice2(v TypeVarOrField) (*Field, *TypeVar) { return ... })`)
		}),
))

func (b *Builder) Input(args ...inputArg) *Input {
	var body *Body
	var params []*Param
	for _, a := range args {
		switch a := a.(type) {
		case *Body:
			body = a
		case *Param:
			params = append(params, a)
		}
	}
	t := &Input{
		InputBuilder: &InputBuilder[*Input]{
			_Type: &_Type[*Input]{rootbuilder: b, metadata: &TypeMetadata{Name: "", underlying: "Input"}},
			metadata: &InputMetadata{
				Body: body, Params: params,
			},
		},
	}
	t.ret = t
	return t
}


// inputArg is the one of pseudo sum types (union).
type inputArg interface {
	inputarg()
}

func (t *Param) inputarg() {}

func (t *Body) inputarg() {}

type TypeBuilder interface {
	GetTypeMetadata() *TypeMetadata
	writeType(io.Writer) error // see: ./to_string.go
	toSchemer                  // see: ./to_schema.go
}

type Type interface {
  TypeBuilder
  typ()

func Definitions() (Definitions struct { Person *openapigen.Object}) {
  Definitions.Person = openapigen.Define("Person", b.Object(...))
  return
}

// with pagination
func Pagination(b *openapigen.Builder, typ openapigen.Type) *openapigen.Object {
	return b.Object(
		b.Field("totalCount", b.Int()),
		b.Field("hasMore", b.Bool()),
		b.Field("cursor", b.String()),
		b.Field("data", typ).Doc("response data of api"),
	).Doc("totalCount, hasMore, cursor fields are metadata for pagination")
}

	ListTask := b.Action("ListTask",
		b.Input(b.Param("sort", b.String().Enum([]string{"createdAt", "-createdAt"})).AsQuery()),
		b.Output(Pagination(b, b.Array(Task))),
	).Doc("paginated list task")

  "paths": {
    "/tasks": {
      "get": {
        "operationId": "ListTask",
        "description": "paginated list task",
        "parameters": [
          {
            "name": "sort",
            "in": "query",
            "required": true,
            "schema": {
              "type": "string",
              "enum": [
                "createdAt",
                "-createdAt"
              ]
            }
          }
        ],
        "responses": {
          "200": {
            "description": "totalCount, hasMore, cursor fields are metadata for pagination",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "description": "totalCount, hasMore, cursor fields are metadata for pagination",
                  "properties": {
                    "totalCount": {
                      "type": "integer"
                    },
                    "hasMore": {
                      "type": "boolean"
                    },
                    "cursor": {
                      "type": "string"
                    },
                    "data": {
                      "type": "array",
                      "items": {
                        "$ref": "#/components/schemas/Task"
                      },
                      "description": "response data of api"
                    }
                  },
                  "required": [
                    "totalCount",
                    "hasMore",
                    "cursor",
                    "data"
                  ],
                  "additionalProperties": false
                }
              }
            }
          },
          "default": {
            "description": "default error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          }
        },
        "tags": [
          "task"
        ]
      }
    },