improved format for query params in JSON + more typesafe URL parsing

includes:
- validated integers via URL params
- optional/required URL params (now empty string is distinct from unset)
- not accepting unrecognized URL params

Author: joonas-fi

codegen/codegentemplates/uiroutes.go

@@ -8,7 +8,7 @@ import (
 )
 
 func RegisterUiRoutes(routes *mux.Router, uiHandler http.HandlerFunc) { {{range .Module.UiRoutes}}
-	routes.HandleFunc("{{.PathWithoutQuery}}", uiHandler){{end}}
+	routes.HandleFunc("{{.Path}}", uiHandler){{end}}
 }
 `
 
@@ -23,31 +23,53 @@ export interface RouteHandlers { {{range .Module.UiRoutes}}
 }
 
 {{range .Module.UiRoutes}}
-{{if .HasOpts}}export interface {{.TsOptsName}} { {{range .PathAndQueryOpts}}
-	{{.}}: string;{{end}}
+{{if .HasOpts}}export interface {{.TsOptsName}} { {{range .PathPlaceholders}}
+	{{.}}: string;{{end}}{{range .QueryParams}}
+	{{.Key}}{{if .Type.Nullable}}?{{end}}: {{if eq .Type.NameRaw "integer"}}number{{else}}string{{end}};{{end}}
 }{{end}}
 
 // {{.Path}}
 export function {{.Id}}Url({{if .HasOpts}}opts: {{.TsOptsName}}{{end}}): string {
-	const query: queryParams = {}
-{{range .QueryPlaceholders}}
-	if (opts.{{.}}) {
-		query.{{.}} = opts.{{.}};
-	} {{end}}
+	const query: queryParams = {};
+{{range .QueryParams}}
+{{if .Type.Nullable}}	if (opts.{{.Key}} !== undefined) {
+	{{end}}	query.{{.Key}} = opts.{{.Key}}{{if eq .Type.NameRaw "integer"}}.toString(){{end}};{{if .Type.Nullable}}
+	}{{end}}
+{{end}}
  
 	return makeQueryParams(` + "`{{.TsPath}}`" + `, query);
 }
 
-// @ts-ignore
 export function {{.Id}}Match(path: string, query: queryParams): {{if .HasOpts}}{{.TsOptsName}}{{else}}{}{{end}} | null {
 	const matches = {{.PathReJavaScript}}.exec(path);
 	if (matches == null) {
 		return null;
 	}
 
+{{range .QueryParams}}{{if eq .Type.NameRaw "string"}}
+	const {{.Key}}Par = query.{{.Key}};{{else}}
+	let {{.Key}}Par: number | undefined;
+	if (query{{.Key}} !== undefined) {
+		// parseInt() accepts garbage after the number, and "+" accepts empty string
+		if (query.{{.Key}} === '') {
+			throw new Error("Invalid URL param: '{{.Key}}'; expecting integer, got empty string")
+		}
+		const parsed = +query.{{.Key}};
+		if (isNaN(parsed)) {
+			throw new Error("Invalid URL param: '{{.Key}}'; expecting integer")
+		}
+		{{.Key}}Par = parsed;
+	}{{end}}{{if not .Type.Nullable}}
+	if ({{.Key}}Par === undefined) {
+		throw new Error("Required URL param '{{.Key}}' missing");
+	} {{end}}
+{{end}}
+
+	assertNoUnrecognizedKeys(Object.keys(query), [{{range .QueryParams}}'{{.Key}}', {{end}}]);
+
 	return { {{range $idx, $key := .PathPlaceholders}}
-		{{$key}}: matches[{{add $idx 1}}],{{end}}{{range .QueryPlaceholders}}
-		{{.}}: query.{{.}} || '',{{end}}
+		{{$key}}: matches[{{add $idx 1}}],{{end}}{{range .QueryParams}}
+		{{.Key}}: {{.Key}}Par,{{end}}
 	};
 }
 
@@ -85,4 +107,11 @@ export function hasRouteFor(url: string): boolean {
 	return false;
 }
 
+function assertNoUnrecognizedKeys(gotKeys: string[], allowedKeys: string[]) {
+	const unrecognizedKeys = gotKeys.filter(key => allowedKeys.indexOf(key) === -1);
+	if (unrecognizedKeys.length > 0) {
+		throw new Error("Unrecognized keys in URL params: "+unrecognizedKeys.join(', '));
+	}
+}
+
 `

codegen/uiroutes.go

@@ -1,13 +1,16 @@
 package codegen
 
 import (
-	"net/url"
 	"strings"
 )
 
 type uiRouteSpec struct {
-	Id   string `json:"id"`
-	Path string `json:"path"`
+	Id          string `json:"id"`
+	Path        string `json:"path"`
+	QueryParams []struct {
+		Key  string      `json:"key"`
+		Type DatatypeDef `json:"type"`
+	} `json:"query_params"`
 }
 
 // need to uppercase b/c tslint complains about pascal case
@@ -16,74 +19,31 @@ func (u *uiRouteSpec) TsOptsName() string {
 }
 
 func (u *uiRouteSpec) HasOpts() bool {
-	return len(u.PathAndQueryOpts()) > 0
-}
-
-// "/accounts/{id}?token={token}" => ["id", "token"]
-func (u *uiRouteSpec) PathAndQueryOpts() []string {
-	return u.placeholders(u.Path)
+	return (len(u.PathPlaceholders()) + len(u.QueryParams)) > 0
 }
 
 // "/accounts/{id}?token={token}" => ["id"]
 func (u *uiRouteSpec) PathPlaceholders() []string {
-	return u.placeholders(u.PathWithoutQuery())
-}
-
-// "/accounts/{id}?token={token}" => ["token"]
-func (u *uiRouteSpec) QueryPlaceholders() []string {
-	return u.placeholders(u.Query())
-}
-
-func (u *uiRouteSpec) placeholders(pathOrQuery string) []string {
-	placeholders := []string{}
-	for _, match := range routePlaceholderParseRe.FindAllStringSubmatch(pathOrQuery, -1) {
-		placeholders = append(placeholders, match[1])
+	keys := []string{}
+	for _, match := range routePlaceholderParseRe.FindAllStringSubmatch(u.Path, -1) {
+		keys = append(keys, match[1])
 	}
 
-	return placeholders
+	return keys
 }
 
 func (u *uiRouteSpec) PathReJavaScript() string {
 	// "/account/{account}/import_otp_token" => "/account/([^/]+)/import_otp_token"
-	reString := routePlaceholderParseRe.ReplaceAllStringFunc(u.PathWithoutQuery(), func(_ string) string {
+	reString := routePlaceholderParseRe.ReplaceAllStringFunc(u.Path, func(_ string) string {
 		return "([^/]+)"
 	})
 
 	// "/^\/account\/([^\/]+)\/import_otp_token$/"
 	return "/^" + strings.ReplaceAll(reString, "/", `\/`) + "$/"
 }
 
-func (u *uiRouteSpec) PathWithoutQuery() string {
-	// FIXME: trick to make it work with hashes
-	if strings.HasPrefix(u.Path, "#") {
-		parsedUrl, err := url.Parse(u.Path[1:])
-		if err != nil {
-			panic(err)
-		}
-
-		return "#" + parsedUrl.Path
-	} else {
-		parsedUrl, err := url.Parse(u.Path)
-		if err != nil {
-			panic(err)
-		}
-
-		return parsedUrl.Path
-	}
-}
-
-func (u *uiRouteSpec) Query() string {
-	// FIXME: trick to make it work with hashes
-	parsedUrl, err := url.Parse(strings.TrimPrefix(u.Path, "#"))
-	if err != nil {
-		panic(err)
-	}
-
-	return parsedUrl.RawQuery
-}
-
 func (u *uiRouteSpec) TsPath() string {
-	return routePlaceholderParseRe.ReplaceAllStringFunc(u.PathWithoutQuery(), func(match string) string {
+	return routePlaceholderParseRe.ReplaceAllStringFunc(u.Path, func(match string) string {
 		// "{id}" => "id"
 		placeholder := removeBraces(match)