types.go.tmpl

{{define "types"}}
{{- $typeMap := .TypeMap -}}
{{- $typePrefix := .TypePrefix -}}
{{- $types := .Types -}}
{{- $services := .Services -}}
{{- $opts := .Opts -}}

//
// Common types
//
{{ range $_, $type := $types -}}

{{- if eq $type.Kind "enum" }}
	{{- if eq $type.Type.Expr "string" }}
{{template "enum_string" dict "Name" $type.Name "Type" $type.Type "TypePrefix" $typePrefix "Fields" $type.Fields "Opts" $opts}}
	{{- else }}
{{template "enum" dict "Name" $type.Name "Type" $type.Type "TypePrefix" $typePrefix "Fields" $type.Fields "Opts" $opts}}
	{{- end -}}
{{ end -}}

{{- if and (eq $type.Kind "struct") $opts.types }}
{{- if gt (len $type.Comments) 0 }}
	{{- range $_, $comment := $type.Comments }}
		// {{ replaceAll $comment "\"" "'" }}
	{{- end }}
{{- end }}
{{template "struct" dict "Name" $type.Name "TypeMap" $typeMap "TypePrefix" $typePrefix "Fields" $type.Fields}}
{{ end -}}

{{- end }}

var methods = map[string]method{
	{{- range $_, $service := $services -}}
	{{- range $_, $method := $service.Methods }}
	"/rpc/{{$service.Name}}/{{$method.Name}}": {
		Name: "{{$method.Name}}",
		Service: "{{$service.Name}}",
		Annotations: map[string]string{ {{- range $_, $annotation := $method.Annotations -}}"{{$annotation.AnnotationType}}": "{{$annotation.Value}}", {{- end -}} },
	},
	{{- end -}}
    {{ end }}
}

func WebrpcMethods() map[string]method {
	res := make(map[string]method, len(methods))
	for k, v := range methods {
		res[k] = v
	}

	return res
}

var WebRPCServices = map[string][]string{
{{- range $_, $service := $services}}
	"{{$service.Name}}": {
		{{- range $_, $method := $service.Methods}}
		"{{$method.Name}}",
		{{- end}}
	},
{{- end}}
}

//
// Server types
//

{{ range $_, $service := $services -}}
{{ if $opts.types -}}
type {{$service.Name}} interface {
	{{- range $_, $method := $service.Methods}}
	{{- if gt (len $method.Comments) 0 -}}
		{{- range $_, $comment := $method.Comments }}
			// {{ replaceAll $comment "\"" "'" }}
		{{- end }}
	{{- end }}
	{{- $deprecated := index $method.Annotations "deprecated" -}}
	{{- if $deprecated }}
	// Deprecated:
	{{- end }}
	{{ if eq $method.StreamOutput true -}}
	{{$method.Name}}(ctx context.Context{{range $_, $input := $method.Inputs}}, {{$input.Name}} {{template "field" dict "Name" $input.Name "Type" $input.Type "TypeMap" $typeMap "TypePrefix" $typePrefix "Optional" $input.Optional "TypeMeta" $input.Meta}}{{end}}, stream {{$method.Name}}StreamWriter) error
	{{- else -}}
	{{$method.Name}}(ctx context.Context{{range $_, $input := $method.Inputs}}, {{$input.Name}} {{template "field" dict "Name" $input.Name "Type" $input.Type "TypeMap" $typeMap "TypePrefix" $typePrefix "Optional" $input.Optional "TypeMeta" $input.Meta}}{{end}}) {{if len .Outputs}}({{end}}{{range $i, $output := .Outputs}}{{template "field" dict "Name" $output.Name "Type" $output.Type "TypeMap" $typeMap "TypePrefix" $typePrefix "Optional" $output.Optional "TypeMeta" $output.Meta}}{{if lt $i (len $method.Outputs)}}, {{end}}{{end}}error{{if len $method.Outputs}}){{end}}
	{{- end -}}

	{{- end}}
}
{{- end }}

{{- range $_, $method := $service.Methods }}
{{ if eq $method.StreamOutput true -}}
type {{$method.Name}}StreamWriter interface {
	Write({{range $i, $output := $method.Outputs}}{{if gt $i 0}}, {{end}}{{$output.Name}} {{template "field" dict "Name" $output.Name "Type" $output.Type "Optional" $output.Optional "TypeMap" $typeMap "TypePrefix" $typePrefix "TypeMeta" $output.Meta}}{{end}}) error
}
{{ end }}
{{- end }}

{{- range $_, $method := $service.Methods}}
{{- if eq $method.StreamOutput true }}
type {{firstLetterToLower $method.Name}}StreamWriter struct {
	streamWriter
}

func (w *{{firstLetterToLower $method.Name}}StreamWriter) Write({{range $i, $output := $method.Outputs}}{{if gt $i 0}}, {{end}}{{$output.Name}} {{template "field" dict "Name" $output.Name "Type" $output.Type "Optional" $output.Optional "TypeMap" $typeMap "TypePrefix" $typePrefix "TypeMeta" $output.Meta}}{{end}}) error {
	out := struct {
	{{- range $i, $output := $method.Outputs}}
		Ret{{$i}} {{template "field" dict "Name" $output.Name "Type" $output.Type "Optional" $output.Optional "TypeMap" $typeMap "TypePrefix" $typePrefix "TypeMeta" $output.Meta "JsonTags" true}}
	{{- end}}
	}{
	{{- range $i, $output := $method.Outputs}}
		Ret{{$i}}: {{$output.Name}},
	{{- end}}
	}

	return w.streamWriter.write(out)
}

{{ end }}
{{- end }}
{{- end }}

{{- if $opts.streaming -}}

type streamWriter struct {
	mu sync.Mutex // Guards concurrent writes to w.
	w  http.ResponseWriter
	f  http.Flusher
	e  *json.Encoder

	sendError func(w http.ResponseWriter, r *http.Request, rpcErr WebRPCError)
}

const StreamKeepAliveInterval = 10*time.Second

func (w *streamWriter) keepAlive(ctx context.Context) {
	for {
		select {
		case <-time.After(StreamKeepAliveInterval):
			err := w.ping()
			if err != nil {
				return
			}
		case <-ctx.Done():
			return
		}
	}
}

func (w *streamWriter) ping() error {
	defer w.f.Flush()

	w.mu.Lock()
	defer w.mu.Unlock()

	_, err := w.w.Write([]byte("\n"))
	return err
}

func (w *streamWriter) write(respPayload interface{}) error {
	defer w.f.Flush()

	w.mu.Lock()
	defer w.mu.Unlock()

	return w.e.Encode(respPayload)
}
{{- end }}

//
// Client types
//

{{ if and $services $opts.types -}}
{{ range $_, $service := $services -}}
type {{$service.Name}}Client interface {
	{{- range $_, $method := $service.Methods}}
	{{- if gt (len $method.Comments) 0 }}
		{{- range $_, $comment := $method.Comments }}
			// {{ replaceAll $comment "\"" "'" }}
		{{- end }}
	{{- end }}
	{{- $deprecated := index $method.Annotations "deprecated" -}}
	{{- if $deprecated }}
	// Deprecated:
	{{- end }}
	{{ if eq $method.StreamOutput true -}}
	{{$method.Name}}(ctx context.Context{{range $_, $input := $method.Inputs}}, {{$input.Name}} {{template "field" dict "Name" $input.Name "Type" $input.Type "TypeMap" $typeMap "TypePrefix" $typePrefix "Optional" $input.Optional "TypeMeta" $input.Meta}}{{end}}) ({{$method.Name}}StreamReader, error)
	{{- else -}}
	{{$method.Name}}(ctx context.Context{{range $_, $input := $method.Inputs}}, {{$input.Name}} {{template "field" dict "Name" $input.Name "Type" $input.Type "TypeMap" $typeMap "TypePrefix" $typePrefix "Optional" $input.Optional "TypeMeta" $input.Meta}}{{end}}) {{if len .Outputs}}({{end}}{{range $i, $output := .Outputs}}{{template "field" dict "Name" $output.Name "Type" $output.Type "TypeMap" $typeMap "TypePrefix" $typePrefix "Optional" $output.Optional "TypeMeta" $output.Meta}}{{if lt $i (len $method.Outputs)}}, {{end}}{{end}}error{{if len $method.Outputs}}){{end}}
	{{- end -}}

	{{- end}}
}

{{- range $_, $method := $service.Methods }}
{{ if eq $method.StreamOutput true -}}
type {{$method.Name}}StreamReader interface {
	Read() ({{range $i, $output := $method.Outputs}}{{if gt $i 0}}, {{end}}{{$output.Name}} {{template "field" dict "Name" $output.Name "Type" $output.Type "Optional" $output.Optional "TypeMap" $typeMap "TypePrefix" $typePrefix "TypeMeta" $output.Meta}}{{end}}, err error)
}
{{ end }}
{{- end }}

{{- end -}}
{{- end -}}

{{- end -}}