main.go.tmpl

{{- define "main" -}}

{{- /* Options with default values. */ -}}
{{- $opts := dict -}}
{{- set $opts "pkg" (default .Opts.pkg "proto") -}}
{{- set $opts "client" (ternary (in .Opts.client "" "true") true false) -}}
{{- set $opts "server" (ternary (in .Opts.server "" "true") true false) -}}
{{- set $opts "types" (ternary (eq (default .Opts.types "true") "false") false true) -}}
{{- set $opts "json" (default .Opts.json "stdlib") -}}
{{- set $opts "importTypesFrom" (default .Opts.importTypesFrom "" ) -}}
{{- set $opts "fixEmptyArrays" (ternary (in .Opts.fixEmptyArrays "" "true") true false) -}}
{{- set $opts "errorStackTrace" (ternary (in .Opts.errorStackTrace "" "true") true false) -}}
{{- set $opts "webrpcHeader" (ternary (eq (default .Opts.webrpcHeader "true") "false") false true) -}}

{{- $typePrefix := (last (split "/" $opts.importTypesFrom)) -}}
{{- if ne $typePrefix "" -}}
  {{- $typePrefix = (printf "%s." $typePrefix) -}}
{{- end -}}

{{- set $opts "" false -}}
{{- range $_, $service := .Services -}}
	{{- range $_, $method := $service.Methods -}}
		{{ if eq $method.StreamOutput true -}}
			{{- set $opts "streaming" true -}}
		{{- end -}}
	{{- end -}}
{{- end }}

{{- /* Print help on -help. */ -}}
{{- if exists .Opts "help" -}}
  {{- template "help" $opts -}}
  {{- exit 0 -}}
{{- end -}}

{{- /* Print help on unsupported option. */ -}}
{{- range $k, $v := .Opts }}
  {{- if not (exists $opts $k) -}}
    {{- stderrPrintf "-%v=%q is not supported target option\n\nUsage:\n" $k $v -}}
    {{- template "help" $opts -}}
    {{- exit 1 -}}
  {{- end -}}
{{- end -}}

{{- if ne .WebrpcVersion "v1" -}}
  {{- stderrPrintf "%s generator error: unsupported webrpc version %s\n" .WebrpcTarget .WebrpcVersion -}}
  {{- exit 1 -}}
{{- end -}}

{{- if not (minVersion .WebrpcGenVersion "v0.9.0") -}}
  {{- stderrPrintf "%s generator error: unsupported webrpc-gen version %s, please update\n" .WebrpcTarget .WebrpcGenVersion -}}
  {{- exit 1 -}}
{{- end -}}

{{- /* Map webrpc core types to Go. */ -}}
{{- $typeMap := dict -}}
{{- set $typeMap "null" "struct{}" -}}
{{- set $typeMap "any" "interface{}" -}}
{{- set $typeMap "byte" "byte" -}}
{{- set $typeMap "bool" "bool" -}}
{{- set $typeMap "uint" "uint" -}}
{{- set $typeMap "uint8" "uint8" -}}
{{- set $typeMap "uint16" "uint16" -}}
{{- set $typeMap "uint32" "uint32" -}}
{{- set $typeMap "uint64" "uint64" -}}
{{- set $typeMap "int" "int" -}}
{{- set $typeMap "int8" "int8" -}}
{{- set $typeMap "int16" "int16" -}}
{{- set $typeMap "int32" "int32" -}}
{{- set $typeMap "int64" "int64" -}}
{{- set $typeMap "float32" "float32" -}}
{{- set $typeMap "float64" "float64" -}}
{{- set $typeMap "string" "string" -}}
{{- set $typeMap "timestamp" "time.Time" -}}

// {{.SchemaName}} {{.SchemaVersion}} {{.SchemaHash}}
// --
// Code generated by webrpc-gen@{{.WebrpcGenVersion}} with {{.WebrpcTarget}} generator. DO NOT EDIT.
//
// {{.WebrpcGenCommand}}
package {{get $opts "pkg"}}

{{template "imports" dict "Types" .Types "Opts" $opts }}

const WebrpcHeader = "Webrpc"

const WebrpcHeaderValue = "{{ .WebrpcHeader }}"

// WebRPC description and code-gen version
func WebRPCVersion() string {
	return "{{.WebrpcVersion}}"
}

// Schema version of your RIDL schema
func WebRPCSchemaVersion() string {
	return "{{.SchemaVersion}}"
}

// Schema hash generated from your RIDL schema
func WebRPCSchemaHash() string {
	return "{{.SchemaHash}}"
}

type WebrpcGenVersions struct {
    WebrpcGenVersion string
    CodeGenName string
    CodeGenVersion string
    SchemaName string
    SchemaVersion string
}

func VersionFromHeader(h http.Header) (*WebrpcGenVersions, error) {
    if h.Get(WebrpcHeader) == "" {
        return nil, fmt.Errorf("header is empty or missing")
    }

    versions, err := parseWebrpcGenVersions(h.Get(WebrpcHeader))
    if err != nil {
        return nil, fmt.Errorf("webrpc header is invalid: %w", err)
    }

    return versions, nil
}

func parseWebrpcGenVersions(header string) (*WebrpcGenVersions, error) {
    versions := strings.Split(header, ";")
    if len(versions) < 3 {
        return nil, fmt.Errorf("expected at least 3 parts while parsing webrpc header: %v", header)
    }

    _, webrpcGenVersion, ok := strings.Cut(versions[0], "@")
    if !ok {
        return nil, fmt.Errorf("webrpc gen version could not be parsed from: %s", versions[0])
    }

    tmplTarget, tmplVersion, ok := strings.Cut(versions[1], "@")
    if !ok {
        return nil, fmt.Errorf("tmplTarget and tmplVersion could not be parsed from: %s", versions[1])
    }

    schemaName, schemaVersion, ok := strings.Cut(versions[2], "@")
    if !ok {
        return nil, fmt.Errorf("schema name and schema version could not be parsed from: %s", versions[2])
    }

    return &WebrpcGenVersions{
        WebrpcGenVersion: webrpcGenVersion,
        CodeGenName: tmplTarget,
        CodeGenVersion: tmplVersion,
        SchemaName: schemaName,
        SchemaVersion: schemaVersion,
    }, nil
}

{{- printf "\n" -}}

{{- if eq $opts.importTypesFrom "" }}
{{ template "types" dict "Services" .Services "Types" .Types "TypeMap" $typeMap "TypePrefix" $typePrefix "Opts" $opts }}
{{ end -}}

{{- if $opts.server }}
{{ template "server" dict "Services" .Services "TypeMap" $typeMap "TypePrefix" $typePrefix "Opts" $opts }}
{{ end -}}

{{ if $opts.client }}
{{ template "client" dict "Services" .Services "TypeMap" $typeMap "Opts" $opts "TypePrefix" $typePrefix }}
{{ end -}}

{{ template "helpers" dict "Opts" $opts }}

{{ template "errors" dict "WebrpcErrors" .WebrpcErrors "SchemaErrors" .Errors "Opts" $opts "TypePrefix" $typePrefix }}

{{- end }}