741 lines
30 KiB
Go
741 lines
30 KiB
Go
package apigen
|
|
|
|
import (
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"go/format"
|
|
"os"
|
|
"path/filepath"
|
|
"runtime/debug"
|
|
"sort"
|
|
"strconv"
|
|
"strings"
|
|
|
|
"git.yuntuo.hk/k2safe/go-omni/cmd/go-omni/scaffold"
|
|
"golang.org/x/mod/modfile"
|
|
"golang.org/x/mod/module"
|
|
"golang.org/x/mod/semver"
|
|
)
|
|
|
|
const frameworkModule = "git.yuntuo.hk/k2safe/go-omni"
|
|
|
|
// Runtime-only releases need not raise the managed template compatibility floor.
|
|
const minimumVersion = "v0.22.0-preview"
|
|
const currentVersion = "v0.22.0-preview"
|
|
const generatedHeader = "// Code generated by go-omni api. DO NOT EDIT.\n"
|
|
|
|
type Options struct {
|
|
generation GeneratorConfig
|
|
lockHeld bool
|
|
documentCatalogs map[string][]byte
|
|
Database, Storage string
|
|
API, Dir, Module, FrameworkDir, FrameworkVersion, LogOutput, LogFormat string
|
|
Check bool
|
|
DryRun bool
|
|
}
|
|
type FileChange struct {
|
|
Path string
|
|
Action string
|
|
}
|
|
type Output struct {
|
|
Generated, Created, Preserved, Removed []string
|
|
Changes []FileChange
|
|
Diagnostics []Diagnostic
|
|
}
|
|
|
|
// Generate creates or safely updates one contract-driven project. It renders
|
|
// and validates every output before applying an ownership-checked transaction.
|
|
func Generate(o Options) (Output, error) {
|
|
if o.Check && o.DryRun {
|
|
return Output{}, errors.New("--check and --dry-run cannot be combined")
|
|
}
|
|
if o.API == "" || o.Dir == "" {
|
|
return Output{}, errors.New("--api and --dir are required")
|
|
}
|
|
spec, err := parseWithCatalogs(o.API, o.documentCatalogs)
|
|
if err != nil {
|
|
return Output{}, err
|
|
}
|
|
compiled, err := Compile(spec)
|
|
if err != nil {
|
|
return Output{}, err
|
|
}
|
|
return generate(o, compiled, false)
|
|
}
|
|
|
|
const starterAPI = "syntax = \"v1\"\n\ninfo (\n title: \"Greeting API\"\n version: \"1.0.0\"\n)\n\ntype GreetReq {\n Name string `path:\"name\" binding:\"required,max=80\"`\n}\ntype GreetResp {\n Message string `json:\"message\"`\n}\n\n@server (\n group: greet\n prefix: /api\n)\nservice greet-api {\n @doc \"Greet a visitor\"\n @handler greet\n get /greet/:name (GreetReq) returns (GreetResp)\n}\n"
|
|
|
|
// New creates a runnable greeting project, including its editable API file.
|
|
func New(o Options) (Output, error) {
|
|
if o.API != "" || o.Check || o.DryRun {
|
|
return Output{}, errors.New("api new does not accept --api, --check or --dry-run")
|
|
}
|
|
if o.Dir == "" {
|
|
return Output{}, errors.New("project directory required")
|
|
}
|
|
if entries, err := os.ReadDir(o.Dir); err == nil && len(entries) > 0 {
|
|
return Output{}, errors.New("api new requires an empty directory")
|
|
} else if err != nil && !errors.Is(err, os.ErrNotExist) {
|
|
return Output{}, err
|
|
}
|
|
tokens, err := lex("service.api", starterAPI)
|
|
if err != nil {
|
|
return Output{}, err
|
|
}
|
|
spec := &Spec{Version: "1.0.0", Entry: "service.api", Sources: map[string][]byte{"service.api": []byte(starterAPI)}}
|
|
p := parser{tokens: tokens, spec: spec}
|
|
if err = p.parse(); err != nil {
|
|
return Output{}, err
|
|
}
|
|
c, err := Compile(spec)
|
|
if err != nil {
|
|
return Output{}, err
|
|
}
|
|
return generate(o, c, true)
|
|
}
|
|
|
|
func generate(o Options, c *Compiled, starter bool) (Output, error) {
|
|
directory, err := filepath.Abs(o.Dir)
|
|
if err != nil {
|
|
return Output{}, err
|
|
}
|
|
o.Dir = directory
|
|
genConfig, hasGenConfig, err := readGeneratorConfig(directory)
|
|
if err != nil {
|
|
return Output{}, err
|
|
}
|
|
o.generation = genConfig
|
|
if err = checkRuntimeExtension(directory); err != nil {
|
|
return Output{}, err
|
|
}
|
|
if err = checkConfigLoadExtension(directory); err != nil {
|
|
return Output{}, err
|
|
}
|
|
for _, r := range c.Spec.Routes {
|
|
if !r.Manual {
|
|
path := filepath.Join(directory, "internal/handler", r.Group, lower(r.Handler)+"Manual.go")
|
|
if _, err := os.Lstat(path); err == nil {
|
|
return Output{}, fmt.Errorf("manual handler %s exists; migrate and remove it explicitly before switching to automatic generation", path)
|
|
} else if !errors.Is(err, os.ErrNotExist) {
|
|
return Output{}, err
|
|
}
|
|
}
|
|
}
|
|
if err := resolveProfile(&o); err != nil {
|
|
return Output{}, err
|
|
}
|
|
seeds := map[string][]byte{}
|
|
requiredVersion := ""
|
|
moduleData, readErr := os.ReadFile(filepath.Join(directory, "go.mod"))
|
|
if readErr == nil {
|
|
mf, err := modfile.Parse("go.mod", moduleData, nil)
|
|
if err != nil || mf.Module == nil {
|
|
return Output{}, errors.New("invalid project go.mod")
|
|
}
|
|
if o.Module != "" && o.Module != mf.Module.Mod.Path {
|
|
return Output{}, errors.New("--module differs from existing go.mod")
|
|
}
|
|
o.Module = mf.Module.Mod.Path
|
|
found := false
|
|
for _, r := range mf.Require {
|
|
if r.Mod.Path == frameworkModule {
|
|
found = true
|
|
requiredVersion = r.Mod.Version
|
|
if o.FrameworkVersion != "" && o.FrameworkVersion != r.Mod.Version {
|
|
return Output{}, errors.New("existing framework version differs; update go.mod explicitly")
|
|
}
|
|
}
|
|
}
|
|
if !found {
|
|
return Output{}, errors.New("existing go.mod must require go-omni")
|
|
}
|
|
if semver.Compare(requiredVersion, minimumVersion) < 0 {
|
|
localCurrent := false
|
|
for _, r := range mf.Replace {
|
|
if r.Old.Path == frameworkModule && r.New.Version == "" {
|
|
path := r.New.Path
|
|
if !filepath.IsAbs(path) {
|
|
path = filepath.Join(directory, path)
|
|
}
|
|
if source, err := os.ReadFile(filepath.Join(path, "config", "references.go")); err == nil && strings.Contains(string(source), "func WithLookupEnv(") {
|
|
localCurrent = true
|
|
}
|
|
}
|
|
}
|
|
if !localCurrent {
|
|
return Output{}, fmt.Errorf("existing framework dependency predates the generated configuration helpers; use %s or a current local replacement", minimumVersion)
|
|
}
|
|
}
|
|
if o.FrameworkDir != "" {
|
|
matched := false
|
|
for _, r := range mf.Replace {
|
|
if r.Old.Path == frameworkModule && r.New.Version == "" {
|
|
replacement := r.New.Path
|
|
if !filepath.IsAbs(replacement) {
|
|
replacement = filepath.Join(directory, replacement)
|
|
}
|
|
matched = canonical(replacement) == canonical(o.FrameworkDir)
|
|
}
|
|
}
|
|
if !matched {
|
|
return Output{}, errors.New("existing framework replacement differs; update go.mod explicitly")
|
|
}
|
|
}
|
|
} else if !errors.Is(readErr, os.ErrNotExist) {
|
|
return Output{}, readErr
|
|
} else {
|
|
if o.Module == "" {
|
|
o.Module = filepath.Base(directory)
|
|
}
|
|
data, err := moduleFile(o)
|
|
if err != nil {
|
|
return Output{}, err
|
|
}
|
|
seeds["go.mod"] = data
|
|
}
|
|
if err = module.CheckImportPath(o.Module); err != nil {
|
|
return Output{}, err
|
|
}
|
|
generated, base, err := renderProject(o, c, starter)
|
|
if err != nil {
|
|
return Output{}, err
|
|
}
|
|
for name, data := range base {
|
|
seeds[name] = data
|
|
}
|
|
if !hasGenConfig {
|
|
raw, _ := json.MarshalIndent(genConfig, "", " ")
|
|
seeds[generatorConfigFile] = append(raw, '\n')
|
|
}
|
|
// The API source remains developer-owned. A relocated project regenerates
|
|
// from its own api/ tree, including all imports.
|
|
entry := "api/" + c.Spec.Entry
|
|
for name, data := range c.Spec.Sources {
|
|
if !strings.HasPrefix(name, "@") {
|
|
seeds["api/"+name] = data
|
|
}
|
|
}
|
|
if len(c.Spec.SharedRoots) > 0 {
|
|
raw, e := sharedSeeds(c.Spec, directory)
|
|
if e != nil {
|
|
return Output{}, e
|
|
}
|
|
seeds["api/"+importsFile] = raw
|
|
}
|
|
if o.API != "" {
|
|
source, _ := filepath.Abs(o.API)
|
|
sourceReal, _ := filepath.EvalSymlinks(source)
|
|
targetReal := canonical(directory)
|
|
rel, e := filepath.Rel(targetReal, sourceReal)
|
|
if e == nil && rel != ".." && !strings.HasPrefix(rel, ".."+string(filepath.Separator)) {
|
|
entry = filepath.ToSlash(rel)
|
|
delete(seeds, "api/"+importsFile)
|
|
for name := range c.Spec.Sources {
|
|
delete(seeds, "api/"+name)
|
|
}
|
|
}
|
|
}
|
|
// Source collisions must never leave a copied contract different from the
|
|
// generated code. On updates, use the developer-owned API in the project.
|
|
for name, data := range seeds {
|
|
if strings.HasSuffix(name, ".api") || filepath.Base(name) == catalogDocumentFile || filepath.Base(name) == importsFile {
|
|
current, e := os.ReadFile(filepath.Join(directory, filepath.FromSlash(name)))
|
|
if e == nil && string(current) != string(data) {
|
|
return Output{}, fmt.Errorf("%s already differs; regenerate from that project API instead", name)
|
|
}
|
|
}
|
|
}
|
|
seeds["README.md"] = []byte(projectREADME(o.Module, entry) + infrastructureREADME(o))
|
|
for _, files := range []map[string][]byte{generated, seeds} {
|
|
for name, data := range files {
|
|
if strings.HasSuffix(name, ".go") {
|
|
data, err = format.Source(data)
|
|
if err != nil {
|
|
return Output{}, fmt.Errorf("format %s: %w", name, err)
|
|
}
|
|
files[name] = data
|
|
}
|
|
}
|
|
}
|
|
currentConfig, stillExists, err := readGeneratorConfig(directory)
|
|
if err != nil {
|
|
return Output{}, err
|
|
}
|
|
beforeConfig, _ := json.Marshal(genConfig)
|
|
afterConfig, _ := json.Marshal(currentConfig)
|
|
if hasGenConfig != stillExists || genConfig.inputDigest != currentConfig.inputDigest || string(beforeConfig) != string(afterConfig) {
|
|
return Output{}, errors.New("generation configuration changed during generation; retry")
|
|
}
|
|
out, err := apply(directory, o.Module, entry, generated, seeds, o.Check, o.DryRun, o.profile(), snapshotContract(c.Spec), o.lockHeld)
|
|
expectedVersion := currentVersion
|
|
if info, ok := debug.ReadBuildInfo(); ok && info.Main.Path == frameworkModule && info.Main.Sum != "" && semver.IsValid(info.Main.Version) {
|
|
expectedVersion = info.Main.Version
|
|
}
|
|
if requiredVersion != "" && requiredVersion != expectedVersion {
|
|
out.Diagnostics = append(out.Diagnostics, Diagnostic{Severity: "review", Code: "frameworkVersion", Path: "go.mod", Before: requiredVersion, After: expectedVersion, Message: "project dependency differs from this CLI version; use matching CLI/framework versions, or verify the explicit local replacement"})
|
|
sortDiagnostics(out.Diagnostics)
|
|
}
|
|
return out, err
|
|
}
|
|
|
|
func moduleFile(o Options) ([]byte, error) {
|
|
if err := module.CheckImportPath(o.Module); err != nil {
|
|
return nil, err
|
|
}
|
|
root := o.FrameworkDir
|
|
version := o.FrameworkVersion
|
|
if root == "" && version == "" {
|
|
wd, _ := os.Getwd()
|
|
for wd != "" {
|
|
data, err := os.ReadFile(filepath.Join(wd, "go.mod"))
|
|
if err == nil {
|
|
mf, e := modfile.Parse("go.mod", data, nil)
|
|
if e == nil && mf.Module != nil && mf.Module.Mod.Path == frameworkModule {
|
|
root = wd
|
|
}
|
|
break
|
|
}
|
|
parent := filepath.Dir(wd)
|
|
if parent == wd {
|
|
break
|
|
}
|
|
wd = parent
|
|
}
|
|
}
|
|
if version == "" {
|
|
if info, ok := debug.ReadBuildInfo(); ok && info.Main.Path == frameworkModule && info.Main.Sum != "" {
|
|
version = info.Main.Version
|
|
} else {
|
|
version = currentVersion
|
|
}
|
|
}
|
|
if !semver.IsValid(version) || semver.Major(version) != "v0" && semver.Major(version) != "v1" {
|
|
return nil, errors.New("invalid framework version")
|
|
}
|
|
if root == "" && semver.Compare(version, minimumVersion) < 0 {
|
|
return nil, fmt.Errorf("API generation needs %s or newer; use --framework-dir for unpublished source", minimumVersion)
|
|
}
|
|
text := "module " + o.Module + "\n\ngo 1.22.0\n\nrequire " + frameworkModule + " " + version + "\n"
|
|
if root != "" {
|
|
root = canonical(root)
|
|
data, err := os.ReadFile(filepath.Join(root, "go.mod"))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
mf, err := modfile.Parse("go.mod", data, nil)
|
|
if err != nil || mf.Module == nil || mf.Module.Mod.Path != frameworkModule {
|
|
return nil, errors.New("--framework-dir must contain go-omni")
|
|
}
|
|
if _, err = os.Stat(filepath.Join(root, "contract", "contract.go")); err != nil {
|
|
return nil, errors.New("local framework lacks API contract support")
|
|
}
|
|
relative, err := filepath.Rel(canonical(o.Dir), root)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
text += "\nreplace " + frameworkModule + " => " + strconv.Quote(filepath.ToSlash(relative)) + "\n"
|
|
}
|
|
return []byte(text), nil
|
|
}
|
|
func canonical(path string) string {
|
|
path, _ = filepath.Abs(path)
|
|
candidate := path
|
|
var tail []string
|
|
for {
|
|
if resolved, err := filepath.EvalSymlinks(candidate); err == nil {
|
|
for i := len(tail) - 1; i >= 0; i-- {
|
|
resolved = filepath.Join(resolved, tail[i])
|
|
}
|
|
return resolved
|
|
}
|
|
parent := filepath.Dir(candidate)
|
|
if parent == candidate {
|
|
return path
|
|
}
|
|
tail = append(tail, filepath.Base(candidate))
|
|
candidate = parent
|
|
}
|
|
}
|
|
|
|
func renderProject(o Options, c *Compiled, starter bool) (map[string][]byte, map[string][]byte, error) {
|
|
generated, seeds := map[string][]byte{}, map[string][]byte{}
|
|
put := func(files map[string][]byte, name, content string) { files[name] = []byte(content) }
|
|
if len(c.Spec.Errors) > 0 {
|
|
content := "package apierrors\nimport(\"encoding/json\"; omnierrors " + strconv.Quote(frameworkModule+"/errors") + ")\n"
|
|
content += fmt.Sprintf("func Catalog()omnierrors.Catalog{var c omnierrors.Catalog;if err:=json.Unmarshal([]byte(%q),&c);err!=nil{panic(err)};return c}\nvar errorRegistry=omnierrors.MustRegistry(Catalog())\n", errorCatalogJSON(c.Spec, nil))
|
|
for _, e := range c.Spec.Errors {
|
|
var args, values []string
|
|
for _, p := range e.Params {
|
|
name := p.Name
|
|
switch name {
|
|
case "string", "any", "omnierrors", "errorRegistry", "int", "int32", "int64", "float64", "bool":
|
|
name = "_" + name
|
|
}
|
|
args = append(args, name+" "+p.Type)
|
|
values = append(values, strconv.Quote(p.Name)+":"+name)
|
|
}
|
|
ref := fmt.Sprintf("omnierrors.ByCode(Code%s)", e.Name)
|
|
if len(args) > 0 {
|
|
ref += ".WithParams(map[string]any{" + strings.Join(values, ",") + "})"
|
|
}
|
|
content += fmt.Sprintf("const Code%s=%q\n// %s returns a fresh, resolved error declared in the API contract.\nfunc %s(%s)*omnierrors.APIError{return errorRegistry.Resolve(%s)}\n", e.Name, e.Code, e.Name, e.Name, strings.Join(args, ","), ref)
|
|
}
|
|
put(generated, "internal/apierrors/errorsGen.go", generatedHeader+content)
|
|
}
|
|
|
|
types := "package types\n\n"
|
|
needsUpload := false
|
|
for _, b := range c.Bindings {
|
|
needsUpload = needsUpload || b.HasMultipart()
|
|
}
|
|
if needsUpload {
|
|
types += fmt.Sprintf("import %q\n", frameworkModule+"/contract")
|
|
}
|
|
if len(c.Spec.Scalars) > 0 {
|
|
types += "import("
|
|
for i, d := range c.Spec.Scalars {
|
|
types += fmt.Sprintf("scalar%d %q;", i, d.GoImport)
|
|
}
|
|
types += ")\n"
|
|
registry := fmt.Sprintf("package types\nimport %q\nfunc ContractScalars()[]contract.Scalar{return []contract.Scalar{", frameworkModule+"/contract")
|
|
for i, d := range c.Spec.Scalars {
|
|
types += fmt.Sprintf("type %s = scalar%d.%s\n", d.Name, i, d.GoType)
|
|
registry += fmt.Sprintf("contract.ScalarOf[%s](%q,%q,%t),", d.Name, d.JSONInput, d.JSONOutput, d.Text)
|
|
}
|
|
registry += "}}\n"
|
|
put(generated, "internal/types/scalarsGen.go", generatedHeader+registry)
|
|
}
|
|
if needsUpload {
|
|
types += "type File = contract.File\n"
|
|
}
|
|
bySource := map[string]string{}
|
|
for _, t := range c.Spec.Types {
|
|
name := dtoFile(t.Position)
|
|
if bySource[name] == "" {
|
|
bySource[name] = "package types\n\n"
|
|
}
|
|
text := "type " + t.Name + " struct {\n"
|
|
for _, f := range t.Fields {
|
|
if f.Description != "" {
|
|
for _, line := range strings.Split(f.Description, "\n") {
|
|
text += "// " + line + "\n"
|
|
}
|
|
}
|
|
text += fmt.Sprintf("%s %s `%s`\n", f.Name, f.Type, fieldTag(f))
|
|
}
|
|
bySource[name] += text + "}\n"
|
|
}
|
|
for name, text := range bySource {
|
|
put(generated, "internal/types/"+name, generatedHeader+text)
|
|
}
|
|
put(generated, "internal/types/typesGen.go", generatedHeader+types)
|
|
put(generated, "docs/openapi.json", string(c.Document)+"\n")
|
|
put(generated, "internal/handler/openapiGen.go", generatedHeader+fmt.Sprintf("package handler\nimport (\"net/http\"; %q)\nconst OpenAPIDocument = %q\nfunc OpenAPI(c *httpx.Context) error { return c.WriteResponse(200,http.Header{\"Content-Type\": {\"application/json; charset=utf-8\"}},[]byte(OpenAPIDocument)) }\n", frameworkModule+"/httpx", string(c.Document)+"\n"))
|
|
policySource := fmt.Sprintf("package handler\nimport(\"encoding/json\";\"strings\";%q; omnierrors %q)\nvar responseTemplates=map[string]response.Encoder{\"\":response.Default(),\n", frameworkModule+"/response", frameworkModule+"/errors")
|
|
for _, definition := range c.Spec.Responses {
|
|
data, err := json.Marshal(definition.Config)
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
policySource += fmt.Sprintf("%q: newResponseTemplate(%q),\n", definition.Name, string(data))
|
|
}
|
|
policySource += "}\nfunc newResponseTemplate(raw string)*response.Formatter{var cfg response.Config;decoder:=json.NewDecoder(strings.NewReader(raw));decoder.UseNumber();if err:=decoder.Decode(&cfg);err!=nil{panic(err)};return response.MustNew(cfg)}\n"
|
|
policySource += "func responseEncoder(name string,raw bool,catalogJSON string)response.Encoder{encoder:=responseTemplates[name];if encoder==nil{panic(\"unknown response template\")};var catalog omnierrors.Catalog;if err:=json.Unmarshal([]byte(catalogJSON),&catalog);err!=nil{panic(err)};if len(catalog.Definitions)>0{encoder=response.MustWithErrors(catalog,encoder)};if raw{encoder=response.RawJSON(encoder)};return encoder}\n"
|
|
put(generated, "internal/handler/responseGen.go", generatedHeader+policySource)
|
|
imports := fmt.Sprintf("import (\"fmt\"; %q; %q; %q;", frameworkModule+"/httpx", frameworkModule+"/openapi", o.Module+"/internal/svc")
|
|
routes := "func RegisterRoutes(router openapi.Registrar, deps *svc.ServiceContext) error {\n if router==nil || deps==nil {return fmt.Errorf(\"router and dependencies required\")}\n"
|
|
if len(c.Spec.Scalars) > 0 {
|
|
imports += fmt.Sprintf("%q;%q;", frameworkModule+"/contract", o.Module+"/internal/types")
|
|
routes += "if err:=contract.ValidateScalars(types.ContractScalars()...);err!=nil{return err}\n"
|
|
}
|
|
middlewareSet := map[string]bool{}
|
|
for _, r := range c.Spec.Routes {
|
|
for _, m := range r.Middleware {
|
|
middlewareSet[m] = true
|
|
}
|
|
}
|
|
var middlewareNames []string
|
|
for m := range middlewareSet {
|
|
middlewareNames = append(middlewareNames, m)
|
|
}
|
|
sort.Strings(middlewareNames)
|
|
for _, m := range middlewareNames {
|
|
routes += fmt.Sprintf("if deps.Middlewares[%q]==nil {return fmt.Errorf(%q)}\n", m, "missing middleware "+m)
|
|
}
|
|
for i, group := range c.Groups {
|
|
imports += fmt.Sprintf("h%d %q; s%d %q;", i, o.Module+"/internal/handler/"+group, i, o.Module+"/internal/logic/"+group)
|
|
routes += fmt.Sprintf("h%d := h%d.New(s%d.New(deps),deps)\n", i, i, i)
|
|
groupRoutes := []Route{}
|
|
for _, r := range c.Spec.Routes {
|
|
if r.Group == group {
|
|
groupRoutes = append(groupRoutes, r)
|
|
}
|
|
}
|
|
packageName := filepath.Base(group)
|
|
text := "package " + packageName + "\nimport(\"context\"; \"fmt\";"
|
|
needsTypes, needsBinder, hasAutomatic := false, false, false
|
|
for _, r := range groupRoutes {
|
|
if r.Manual {
|
|
continue
|
|
}
|
|
hasAutomatic = true
|
|
needsTypes = needsTypes || r.Request != "" || responseNeedsTypes(r.Response)
|
|
needsBinder = needsBinder || !r.CustomBinding
|
|
}
|
|
text += fmt.Sprintf("%q;%q;", frameworkModule+"/httpx", o.Module+"/internal/svc")
|
|
if needsTypes {
|
|
text += fmt.Sprintf("%q;", o.Module+"/internal/types")
|
|
}
|
|
if needsBinder {
|
|
text += fmt.Sprintf("%q;", frameworkModule+"/contract")
|
|
}
|
|
text += ")\n"
|
|
text += "type Logic interface {\n"
|
|
for _, r := range groupRoutes {
|
|
if !r.Manual {
|
|
text += signature(r) + "\n"
|
|
}
|
|
}
|
|
text += "}\ntype Handler struct {logic Logic;deps *svc.ServiceContext}\nfunc New(s Logic,deps ...*svc.ServiceContext)*Handler {h:=&Handler{logic:s};if len(deps)>0{h.deps=deps[0]};return h}\n"
|
|
for _, r := range groupRoutes {
|
|
name := upper(r.Handler)
|
|
// The response policy and body reader cap are installed before App middleware.
|
|
if r.MaxBodyBytes > 0 {
|
|
routes += fmt.Sprintf("httpx.HandleWithBodyLimit(router,%q,%q,%d,responseEncoder(%q,%t,%q),h%d.%s", strings.ToUpper(r.Method), r.Path, r.MaxBodyBytes, responseName(r), r.ResponseFormat == "raw", errorCatalogJSON(c.Spec, append([]string{}, r.Errors...)), i, name)
|
|
} else {
|
|
routes += fmt.Sprintf("httpx.HandleWithResponse(router,%q,%q,responseEncoder(%q,%t,%q),h%d.%s", strings.ToUpper(r.Method), r.Path, responseName(r), r.ResponseFormat == "raw", errorCatalogJSON(c.Spec, append([]string{}, r.Errors...)), i, name)
|
|
}
|
|
for _, m := range r.Middleware {
|
|
routes += fmt.Sprintf(",deps.Middlewares[%q]", m)
|
|
}
|
|
routes += ")\n"
|
|
if r.Manual {
|
|
put(seeds, "internal/handler/"+group+"/"+lower(r.Handler)+"Manual.go", fmt.Sprintf("package %s\nimport(%q;apierrors %q)\n// %s owns raw/multipart binding and response output. h.deps holds project dependencies.\n// This file is preserved on regeneration.\nfunc(h *Handler)%s(c *httpx.Context)error{return apierrors.New(501,\"NOT_IMPLEMENTED\",\"manual handler is not implemented\")}\n", packageName, frameworkModule+"/httpx", frameworkModule+"/errors", name, name))
|
|
continue
|
|
}
|
|
if !r.CustomBinding {
|
|
scalarArgs := ""
|
|
if len(c.Spec.Scalars) > 0 {
|
|
scalarArgs = "types.ContractScalars()..."
|
|
}
|
|
requestType := "struct{}"
|
|
if r.Request != "" {
|
|
requestType = "types." + r.Request
|
|
} else {
|
|
scalarArgs = ""
|
|
}
|
|
text += fmt.Sprintf("var %sRequest = contract.MustNew[%s](%s)\n", lower(r.Handler), requestType, scalarArgs)
|
|
}
|
|
text += fmt.Sprintf("func(h *Handler) %s(c *httpx.Context)error {\n", name)
|
|
call := "c.Context()"
|
|
if r.Request != "" {
|
|
if r.CustomBinding {
|
|
text += fmt.Sprintf("var req types.%s\nif err:=h.bind%s(c,&req);err!=nil{return err}\n", r.Request, name)
|
|
put(seeds, "internal/handler/"+group+"/"+lower(r.Handler)+"Bind.go", fmt.Sprintf("package %s\nimport(%q;%q;apierrors %q)\n// bind%s is project-owned; repeated generation preserves it.\nfunc(h *Handler)bind%s(c *httpx.Context,req *types.%s)error{return apierrors.New(501,\"BINDING_NOT_IMPLEMENTED\",\"custom binding is not implemented\")}\n", packageName, frameworkModule+"/httpx", o.Module+"/internal/types", frameworkModule+"/errors", name, name, r.Request))
|
|
} else if r.BoundMultipart {
|
|
text += fmt.Sprintf("var req types.%s\ncleanup,err:=%sRequest.BindMultipart(c.Request(),httpx.RouteParams(c.Context()),&req,contract.MultipartOptions{MaxBodyBytes:%d,MaxParts:%d,MaxFieldBytes:%d,MaxFileBytes:%d,Policy:%s});if err!=nil{return err};defer cleanup()\n", r.Request, lower(r.Handler), r.MaxBodyBytes, r.MaxParts, r.MaxFieldBytes, r.MaxFileBytes, policyLiteral(r.RequestPolicy))
|
|
} else {
|
|
limit := ""
|
|
if r.MaxBodyBytes > 0 {
|
|
limit = fmt.Sprintf(",%d", r.MaxBodyBytes)
|
|
}
|
|
policy := r.RequestPolicy
|
|
if r.BodyMode == "raw" || r.BodyMode == "multipart" {
|
|
policy.Body = "auto"
|
|
}
|
|
text += fmt.Sprintf("var req types.%s\nif err:=%sRequest.BindWithPolicy(c.Request(),httpx.RouteParams(c.Context()),&req,%s%s);err!=nil{return err}\n", r.Request, lower(r.Handler), policyLiteral(policy), limit)
|
|
}
|
|
call += ", &req"
|
|
} else {
|
|
limit := ""
|
|
if r.MaxBodyBytes > 0 {
|
|
limit = fmt.Sprintf(",%d", r.MaxBodyBytes)
|
|
}
|
|
policy := r.RequestPolicy
|
|
if r.BodyMode == "raw" || r.BodyMode == "multipart" {
|
|
policy.Body = "auto"
|
|
}
|
|
text += fmt.Sprintf("if err:=%sRequest.BindWithPolicy(c.Request(),httpx.RouteParams(c.Context()),&struct{}{},%s%s);err!=nil{return err}\n", lower(r.Handler), policyLiteral(policy), limit)
|
|
}
|
|
streamingBody := streamsBody(r)
|
|
if streamingBody {
|
|
text += fmt.Sprintf("body,err:=httpx.NewBody(c.Request(),%q);if err!=nil{return err}\n", r.BodyMode)
|
|
call += ",body"
|
|
}
|
|
if r.Produces != "" {
|
|
text += fmt.Sprintf("resp,err:=h.logic.%s(%s);if err!=nil{if resp!=nil{_ = resp.Close()};return err}\n", name, call)
|
|
if streamingBody {
|
|
text += "if err:=body.Complete();err!=nil{if resp!=nil{_ =resp.Close()};return err}\n"
|
|
}
|
|
text += fmt.Sprintf("return c.WriteStream(%d,%q,resp)\n}\n", r.Status, r.Produces)
|
|
} else if responseGoType(r.Response) != "" {
|
|
text += fmt.Sprintf("resp,err:=h.logic.%s(%s);if err!=nil{return err};\n", name, call)
|
|
kind, _ := responseShape(r.Response)
|
|
if kind == "object" {
|
|
text += fmt.Sprintf("if resp==nil{return fmt.Errorf(%q)}\n", name+" returned a nil response")
|
|
}
|
|
if kind == "array" {
|
|
text += "if resp==nil{resp=make(" + responseGoType(r.Response) + ",0)}\n"
|
|
}
|
|
if streamingBody {
|
|
text += "if err:=body.Complete();err!=nil{return err}\n"
|
|
}
|
|
method := map[int]string{200: "OK", 201: "Created", 202: "Accepted"}[r.Status]
|
|
text += "return c." + method + "(resp)\n}\n"
|
|
} else {
|
|
text += fmt.Sprintf("if err:=h.logic.%s(%s);err!=nil{return err};", name, call)
|
|
if streamingBody {
|
|
text += "if err:=body.Complete();err!=nil{return err};"
|
|
}
|
|
if r.Response == "null" {
|
|
method := map[int]string{200: "OK", 201: "Created", 202: "Accepted"}[r.Status]
|
|
text += "return c." + method + "(nil)\n}\n"
|
|
} else {
|
|
text += "return c.NoContent()\n}\n"
|
|
}
|
|
}
|
|
service := fmt.Sprintf("package %s\nimport(\"context\"; apierrors %q;", packageName, frameworkModule+"/errors")
|
|
if r.Request != "" || responseNeedsTypes(r.Response) {
|
|
service += fmt.Sprintf("%q;", o.Module+"/internal/types")
|
|
}
|
|
if streamingBody || r.Produces != "" {
|
|
service += fmt.Sprintf("%q;", frameworkModule+"/httpx")
|
|
}
|
|
service += ")\n"
|
|
service += "// " + name + " implements the business operation. This file is never overwritten.\nfunc(s *Logic) " + signature(r) + " {\n"
|
|
if starter && r.Handler == "greet" {
|
|
service = strings.Replace(service, "apierrors "+strconv.Quote(frameworkModule+"/errors")+";", "\"fmt\";", 1)
|
|
service += "s.deps.Logger.InfoContext(ctx,\"greet.called\")\nreturn &types.GreetResp{Message:fmt.Sprintf(\"Hello %s\",req.Name)},nil\n}"
|
|
} else {
|
|
service += "// TODO: implement business behavior and use s.deps for dependencies.\n"
|
|
if responseGoType(r.Response) != "" || r.Produces != "" {
|
|
service += "return nil, "
|
|
} else {
|
|
service += "return "
|
|
}
|
|
service += "apierrors.New(501,\"NOT_IMPLEMENTED\",\"operation is not implemented\")\n}"
|
|
}
|
|
put(seeds, "internal/logic/"+group+"/"+lower(r.Handler)+".go", service)
|
|
}
|
|
if !hasAutomatic {
|
|
text = strings.Replace(text, strconv.Quote(frameworkModule+"/httpx")+";", "", 1)
|
|
text = strings.Replace(text, "\"context\";", "", 1)
|
|
}
|
|
if !hasResponse(groupRoutes) {
|
|
text = strings.Replace(text, "\"fmt\";", "", 1)
|
|
}
|
|
put(generated, "internal/handler/"+group+"/handlersGen.go", generatedHeader+text)
|
|
put(seeds, "internal/logic/"+group+"/logic.go", fmt.Sprintf("package %s\nimport %q\ntype Logic struct {deps *svc.ServiceContext}\nfunc New(deps *svc.ServiceContext)*Logic{return &Logic{deps:deps}}\n", packageName, o.Module+"/internal/svc"))
|
|
if o.generation.Repository == "group" {
|
|
put(seeds, "internal/repository/"+group+"/repository.go", "// Package "+packageName+" owns persistence contracts for this business group.\n// Define repository interfaces and implementations here; HTTP DTOs do not\n// determine a database schema. This file is never overwritten.\npackage "+packageName+"\n")
|
|
}
|
|
}
|
|
put(generated, "internal/handler/routesGen.go", generatedHeader+"package handler\n"+imports+")\n"+routes+"return nil\n}\n")
|
|
registry := "package middleware\nimport " + strconv.Quote(frameworkModule+"/httpx") + "\nfunc Defaults()map[string]httpx.Middleware{return map[string]httpx.Middleware{\n"
|
|
for _, m := range middlewareNames {
|
|
registry += fmt.Sprintf("%q:%s,\n", m, upper(m))
|
|
put(seeds, "internal/middleware/"+lower(m)+".go", fmt.Sprintf("package middleware\nimport(%q; apierrors %q)\n// %s is a developer-owned hook. Implement it before enabling this route.\nfunc %s(next httpx.Handler)httpx.Handler{return func(c *httpx.Context)error {return apierrors.New(501,\"MIDDLEWARE_NOT_IMPLEMENTED\",\"middleware is not implemented\")}}\n", frameworkModule+"/httpx", frameworkModule+"/errors", upper(m), upper(m)))
|
|
}
|
|
put(generated, "internal/middleware/registryGen.go", generatedHeader+registry+"}}\n")
|
|
if o.generation.Middleware == "factories" {
|
|
renderMiddlewareFactories(middlewareNames, generated, seeds)
|
|
}
|
|
for name, source := range baseTemplates {
|
|
content := strings.ReplaceAll(source, "MODULE", o.Module)
|
|
content = strings.ReplaceAll(content, "LOGFORMAT", o.LogFormat)
|
|
content = strings.ReplaceAll(content, "LOGOUTPUT", o.LogOutput)
|
|
if name == "etc/config.yaml" && o.LogOutput == "file" {
|
|
content = strings.Replace(content, "output: file", "output: stderr\n file: ./var/log/server.log\n rotation:\n enabled: true\n maxSizeMb: 100\n maxBackups: 10\n maxAgeDays: 7\n compress: true", 1)
|
|
}
|
|
if name == "main.go" {
|
|
put(generated, name, generatedHeader+content)
|
|
} else {
|
|
put(seeds, name, content)
|
|
}
|
|
}
|
|
|
|
infra, err := scaffold.APIInfrastructure(o.Module, o.Database, o.Storage, o.LogOutput, o.LogFormat)
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
for name, data := range infra {
|
|
if o.generation.Middleware == "factories" && name == "internal/svc/runtimeGen.go" {
|
|
formatted, err := format.Source(data)
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
source := string(formatted)
|
|
source = strings.Replace(source, "Middlewares: middleware.Defaults(),", "", 1)
|
|
source = strings.Replace(source, "return c, nil", "if len(c.Middlewares) != 0 { return nil, errors.New(\"factory middleware is registered automatically; remove manual Middlewares assignments from Init\") }\nc.Middlewares, err = middleware.New(c)\nif err != nil { return nil, err }\nreturn c, nil", 1)
|
|
data = []byte(source)
|
|
}
|
|
if strings.HasSuffix(name, "Gen.go") {
|
|
generated[name] = append([]byte(generatedHeader), data...)
|
|
} else {
|
|
seeds[name] = data
|
|
}
|
|
}
|
|
if o.Storage == "local" {
|
|
for _, r := range c.Spec.Routes {
|
|
if r.Path == "/storage/object" {
|
|
return nil, nil, errors.New("/storage/object is reserved by local storage")
|
|
}
|
|
}
|
|
}
|
|
put(generated, "internal/handler/appGen.go", generatedHeader+appSource(o, c.Spec))
|
|
|
|
return generated, seeds, nil
|
|
}
|
|
func hasResponse(routes []Route) bool {
|
|
for _, r := range routes {
|
|
if kind, _ := responseShape(r.Response); r.Response != "" && kind == "object" && !r.Manual && r.Produces == "" {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
func signature(r Route) string {
|
|
s := upper(r.Handler) + "(ctx context.Context"
|
|
if r.Request != "" {
|
|
s += ",req *types." + r.Request
|
|
}
|
|
if streamsBody(r) {
|
|
s += ",body *httpx.Body"
|
|
}
|
|
s += ") "
|
|
if r.Produces != "" {
|
|
return s + "(*httpx.Stream,error)"
|
|
}
|
|
if result := responseGoType(r.Response); result != "" {
|
|
s += "(" + result + ",error)"
|
|
} else {
|
|
s += "error"
|
|
}
|
|
return s
|
|
}
|
|
|
|
func streamsBody(r Route) bool {
|
|
return r.BodyMode == "raw" || (r.BodyMode == "multipart" && !r.BoundMultipart)
|
|
}
|
|
|
|
func dtoFile(position string) string {
|
|
source := position
|
|
for i := 0; i < 2; i++ {
|
|
if idx := strings.LastIndex(source, ":"); idx >= 0 {
|
|
source = source[:idx]
|
|
}
|
|
}
|
|
stem := strings.TrimSuffix(filepath.Base(source), ".api")
|
|
var b strings.Builder
|
|
for _, r := range stem {
|
|
if r >= 'a' && r <= 'z' || r >= 'A' && r <= 'Z' || r >= '0' && r <= '9' {
|
|
b.WriteRune(r)
|
|
}
|
|
}
|
|
if b.Len() == 0 {
|
|
b.WriteString("contract")
|
|
}
|
|
return "dto" + upper(b.String()) + digest([]byte(source))[:12] + "Gen.go"
|
|
}
|