Switch to go-swagger for client lib and checks for IRON_TOKEN (#406)

* wip - for review, using go-swagger client and checking for IRON_TOKEN and passing as auth header.

* wip - auth header

* add golang builder

* finish client builder

* change gh username

* fix git command

* update readme and small fixes

* some improvements

* using go-swagger

* fn new client

* revert swagger

* make fn routes and apps work with new client (go-swagger)

* some fixes in fn apps

* update functions_go

fn/routes.go

@@ -1,6 +1,7 @@
 package main
 
 import (
+	"context"
 	"encoding/json"
 	"errors"
 	"fmt"
@@ -13,17 +14,20 @@ import (
 	"text/tabwriter"
 	"time"
 
-	functions "github.com/iron-io/functions_go"
+	fnclient "github.com/iron-io/functions_go/client"
+	apiroutes "github.com/iron-io/functions_go/client/routes"
+	"github.com/iron-io/functions_go/models"
 	"github.com/jmoiron/jsonq"
 	"github.com/urfave/cli"
 )
 
 type routesCmd struct {
-	*functions.RoutesApi
+	client *fnclient.Functions
 }
 
 func routes() cli.Command {
-	r := routesCmd{RoutesApi: functions.NewRoutesApi()}
+
+	r := routesCmd{client: apiClient()}
 
 	return cli.Command{
 		Name:      "routes",
@@ -167,7 +171,7 @@ func routes() cli.Command {
 }
 
 func call() cli.Command {
-	r := routesCmd{RoutesApi: functions.NewRoutesApi()}
+	r := routesCmd{client: apiClient()}
 
 	return cli.Command{
 		Name:      "call",
@@ -183,35 +187,33 @@ func (a *routesCmd) list(c *cli.Context) error {
 		return errors.New("error: routes listing takes one argument, an app name")
 	}
 
-	if err := resetBasePath(a.Configuration); err != nil {
-		return fmt.Errorf("error setting endpoint: %v", err)
-	}
-
 	appName := c.Args().Get(0)
-	wrapper, _, err := a.AppsAppRoutesGet(appName)
-	if err != nil {
-		return fmt.Errorf("error getting routes: %v", err)
-	}
 
-	if msg := wrapper.Error_.Message; msg != "" {
-		return errors.New(msg)
-	}
+	resp, err := a.client.Routes.GetAppsAppRoutes(&apiroutes.GetAppsAppRoutesParams{
+		Context: context.Background(),
+		App:     appName,
+	})
 
-	baseURL, err := url.Parse(a.Configuration.BasePath)
 	if err != nil {
-		return fmt.Errorf("error parsing base path: %v", err)
+		switch err.(type) {
+		case *apiroutes.GetAppsAppRoutesNotFound:
+			return fmt.Errorf("error: %v", err.(*apiroutes.GetAppsAppRoutesNotFound).Payload.Error.Message)
+		case *apiroutes.GetAppsAppRoutesDefault:
+			return fmt.Errorf("unexpected error: %v", err.(*apiroutes.GetAppsAppRoutesDefault).Payload.Error.Message)
+		}
+		return fmt.Errorf("unexpected error: %v", err)
 	}
 
 	w := tabwriter.NewWriter(os.Stdout, 0, 8, 0, '\t', 0)
 	fmt.Fprint(w, "path", "\t", "image", "\t", "endpoint", "\n")
-	for _, route := range wrapper.Routes {
+	for _, route := range resp.Payload.Routes {
 		u, err := url.Parse("../")
 		u.Path = path.Join(u.Path, "r", appName, route.Path)
 		if err != nil {
 			return fmt.Errorf("error parsing functions route path: %v", err)
 		}
 
-		fmt.Fprint(w, route.Path, "\t", route.Image, "\t", baseURL.ResolveReference(u).String(), "\n")
+		fmt.Fprint(w, route.Path, "\t", route.Image, "\n")
 	}
 	w.Flush()
 
@@ -223,23 +225,17 @@ func (a *routesCmd) call(c *cli.Context) error {
 		return errors.New("error: routes listing takes three arguments: an app name and a route")
 	}
 
-	if err := resetBasePath(a.Configuration); err != nil {
-		return fmt.Errorf("error setting endpoint: %v", err)
-	}
-
 	appName := c.Args().Get(0)
 	route := c.Args().Get(1)
 
-	baseURL, err := url.Parse(a.Configuration.BasePath)
-	if err != nil {
-		return fmt.Errorf("error parsing base path: %v", err)
+	u := url.URL{
+		Scheme: "http",
+		Host:   host(),
 	}
-
-	u, err := url.Parse("../")
 	u.Path = path.Join(u.Path, "r", appName, route)
 	content := stdin()
 
-	return callfn(baseURL.ResolveReference(u).String(), content, os.Stdout, c.StringSlice("e"))
+	return callfn(u.String(), content, os.Stdout, c.StringSlice("e"))
 }
 
 func callfn(u string, content io.Reader, output io.Writer, env []string) error {
@@ -281,10 +277,6 @@ func (a *routesCmd) create(c *cli.Context) error {
 		return errors.New("error: routes creation takes at least one argument: an app name")
 	}
 
-	if err := resetBasePath(a.Configuration); err != nil {
-		return fmt.Errorf("error setting endpoint: %v", err)
-	}
-
 	appName := c.Args().Get(0)
 	route := c.Args().Get(1)
 	image := c.Args().Get(2)
@@ -298,9 +290,8 @@ func (a *routesCmd) create(c *cli.Context) error {
 		if err != nil {
 			if _, ok := err.(*notFoundError); ok {
 				return errors.New("error: image name is missing or no function file found")
-			} else {
-				return err
 			}
+			return err
 		}
 		image = ff.FullName()
 		if ff.Format != nil {
@@ -334,29 +325,39 @@ func (a *routesCmd) create(c *cli.Context) error {
 		timeout = t
 	}
 
-	body := functions.RouteWrapper{
-		Route: functions.Route{
+	to := int64(timeout.Seconds())
+	body := &models.RouteWrapper{
+		Route: &models.Route{
 			Path:           route,
 			Image:          image,
 			Memory:         c.Int64("memory"),
-			Type_:          c.String("type"),
+			Type:           c.String("type"),
 			Config:         extractEnvConfig(c.StringSlice("config")),
 			Format:         format,
 			MaxConcurrency: int32(maxC),
-			Timeout:        int32(timeout.Seconds()),
+			Timeout:        &to,
 		},
 	}
 
-	wrapper, _, err := a.AppsAppRoutesPost(appName, body)
+	resp, err := a.client.Routes.PostAppsAppRoutes(&apiroutes.PostAppsAppRoutesParams{
+		Context: context.Background(),
+		App:     appName,
+		Body:    body,
+	})
+
 	if err != nil {
-		return fmt.Errorf("error creating route: %v", err)
+		switch err.(type) {
+		case *apiroutes.PostAppsAppRoutesBadRequest:
+			return fmt.Errorf("error: %v", err.(*apiroutes.PostAppsAppRoutesBadRequest).Payload.Error.Message)
+		case *apiroutes.PostAppsAppRoutesConflict:
+			return fmt.Errorf("error: %v", err.(*apiroutes.PostAppsAppRoutesConflict).Payload.Error.Message)
+		case *apiroutes.PostAppsAppRoutesDefault:
+			return fmt.Errorf("unexpected error: %v", err.(*apiroutes.PostAppsAppRoutesDefault).Payload.Error.Message)
+		}
+		return fmt.Errorf("unexpected error: %v", err)
 	}
 
-	if msg := wrapper.Error_.Message; msg != "" {
-		return errors.New(msg)
-	}
-
-	fmt.Println(wrapper.Route.Path, "created with", wrapper.Route.Image)
+	fmt.Println(resp.Payload.Route.Path, "created with", resp.Payload.Route.Image)
 	return nil
 }
 
@@ -365,64 +366,119 @@ func (a *routesCmd) delete(c *cli.Context) error {
 		return errors.New("error: routes listing takes three arguments: an app name and a path")
 	}
 
-	if err := resetBasePath(a.Configuration); err != nil {
-		return fmt.Errorf("error setting endpoint: %v", err)
-	}
-
 	appName := c.Args().Get(0)
 	route := c.Args().Get(1)
 
-	resp, err := a.AppsAppRoutesRouteDelete(appName, route)
+	_, err := a.client.Routes.DeleteAppsAppRoutesRoute(&apiroutes.DeleteAppsAppRoutesRouteParams{
+		Context: context.Background(),
+		App:     appName,
+		Route:   route,
+	})
 	if err != nil {
-		return fmt.Errorf("error deleting route: %v", err)
-	}
-
-	if resp.StatusCode >= http.StatusBadRequest {
-		return fmt.Errorf("route not found: %s", route)
+		switch err.(type) {
+		case *apiroutes.DeleteAppsAppRoutesRouteNotFound:
+			return fmt.Errorf("error: %v", err.(*apiroutes.DeleteAppsAppRoutesRouteNotFound).Payload.Error.Message)
+		case *apiroutes.DeleteAppsAppRoutesRouteDefault:
+			return fmt.Errorf("unexpected error: %v", err.(*apiroutes.DeleteAppsAppRoutesRouteDefault).Payload.Error.Message)
+		}
+		return fmt.Errorf("unexpected error: %v", err)
 	}
 
 	fmt.Println(route, "deleted")
 	return nil
 }
 
-func (a *routesCmd) update(c *cli.Context) error {
-	if c.Args().Get(0) == "" {
-		return errors.New("error: routes creation takes at least one argument: an app name")
-	}
+// _, err = a.client.Routes.PatchAppsAppRoutesRoute(&apiroutes.PatchAppsAppRoutesRouteParams{
+// 	Context: context.Background(),
+// 	App:     appName,
+// 	Route:   route,
+// 	Body:    resp.Payload,
+// })
 
-	if err := resetBasePath(a.Configuration); err != nil {
-		return fmt.Errorf("error setting endpoint: %v", err)
+// if err != nil {
+// 	switch err.(type) {
+// 	case *apiroutes.PatchAppsAppRoutesRouteBadRequest:
+// 		return fmt.Errorf("error: %v", err.(*apiroutes.PatchAppsAppRoutesRouteBadRequest).Payload.Error.Message)
+// 	case *apiroutes.PatchAppsAppRoutesRouteNotFound:
+// 		return fmt.Errorf("error: %v", err.(*apiroutes.PatchAppsAppRoutesRouteNotFound).Payload.Error.Message)
+// 	case *apiroutes.PatchAppsAppRoutesRouteDefault:
+// 		return fmt.Errorf("unexpected error: %v", err.(*apiroutes.PatchAppsAppRoutesRouteDefault).Payload.Error.Message)
+// 	}
+// 	return fmt.Errorf("unexpected error: %v", err)
+// }
+
+func (a *routesCmd) update(c *cli.Context) error {
+	if c.Args().Get(0) == "" || c.Args().Get(1) == "" {
+		return errors.New("error: route configuration description takes two arguments: an app name and a route")
 	}
 
 	appName := c.Args().Get(0)
 	route := c.Args().Get(1)
 
-	if route == "" {
-		return errors.New("error: route path is missing")
-	}
-
-	headers := map[string][]string{}
-	for _, header := range c.StringSlice("headers") {
-		parts := strings.Split(header, "=")
-		headers[parts[0]] = strings.Split(parts[1], ";")
-	}
-
-	patchRoute := &functions.Route{
-		Image:          c.String("image"),
-		Memory:         c.Int64("memory"),
-		Type_:          c.String("type"),
-		Config:         extractEnvConfig(c.StringSlice("config")),
-		Headers:        headers,
-		Format:         c.String("format"),
-		MaxConcurrency: int32(c.Int64("max-concurrency")),
-		Timeout:        int32(c.Int64("timeout")),
-	}
-
-	err := a.patchRoute(appName, route, patchRoute)
+	resp, err := a.client.Routes.GetAppsAppRoutesRoute(&apiroutes.GetAppsAppRoutesRouteParams{
+		Context: context.Background(),
+		App:     appName,
+		Route:   route,
+	})
 	if err != nil {
-		return err
+		switch err.(type) {
+		case *apiroutes.GetAppsAppRoutesRouteNotFound:
+			return fmt.Errorf("error: %v", err.(*apiroutes.GetAppsAppRoutesRouteNotFound).Payload.Error.Message)
+		case *apiroutes.GetAppsAppRoutesRouteDefault:
+			return fmt.Errorf("unexpected error: %v", err.(*apiroutes.GetAppsAppRoutesRouteDefault).Payload.Error.Message)
+		}
+		return fmt.Errorf("unexpected error: %v", err)
 	}
 
+	config := resp.Payload.Route.Config
+	if len(config) == 0 {
+		return errors.New("this route has no configurations")
+	}
+
+	if c.Bool("json") {
+		if err := json.NewEncoder(os.Stdout).Encode(config); err != nil {
+			fmt.Fprintln(os.Stderr, err)
+			os.Exit(1)
+		}
+	} else if c.Bool("shell") {
+		for k, v := range config {
+			fmt.Print("export ", k, "=", v, "\n")
+		}
+	} else {
+		fmt.Println(appName, resp.Payload.Route.Path, "configuration:")
+		w := tabwriter.NewWriter(os.Stdout, 0, 8, 1, ' ', 0)
+		for k, v := range config {
+			fmt.Fprint(w, k, ":\t", v, "\n")
+		}
+		w.Flush()
+	}
+
+	// 	if route == "" {
+	// 		return errors.New("error: route path is missing")
+	// 	}
+
+	// 	headers := map[string][]string{}
+	// 	for _, header := range c.StringSlice("headers") {
+	// 		parts := strings.Split(header, "=")
+	// 		headers[parts[0]] = strings.Split(parts[1], ";")
+	// 	}
+
+	// 	patchRoute := &functions.Route{
+	// 		Image:          c.String("image"),
+	// 		Memory:         c.Int64("memory"),
+	// 		Type_:          c.String("type"),
+	// 		Config:         extractEnvConfig(c.StringSlice("config")),
+	// 		Headers:        headers,
+	// 		Format:         c.String("format"),
+	// 		MaxConcurrency: int32(c.Int64("max-concurrency")),
+	// 		Timeout:        int32(c.Int64("timeout")),
+	// 	}
+
+	// 	err := a.patchRoute(appName, route, patchRoute)
+	// 	if err != nil {
+	// 		return err
+	// 	}
+
 	fmt.Println(appName, route, "updated")
 	return nil
 }
@@ -432,27 +488,69 @@ func (a *routesCmd) configSet(c *cli.Context) error {
 		return errors.New("error: route configuration setting takes four arguments: an app name, a route, a key and a value")
 	}
 
-	if err := resetBasePath(a.Configuration); err != nil {
-		return fmt.Errorf("error setting endpoint: %v", err)
-	}
-
 	appName := c.Args().Get(0)
 	route := c.Args().Get(1)
 	key := c.Args().Get(2)
 	value := c.Args().Get(3)
 
-	patchRoute := functions.Route{
-		Config: make(map[string]string),
-	}
+	resp, err := a.client.Routes.GetAppsAppRoutesRoute(&apiroutes.GetAppsAppRoutesRouteParams{
+		Context: context.Background(),
+		App:     appName,
+		Route:   route,
+	})
 
-	patchRoute.Config[key] = value
-
-	err := a.patchRoute(appName, route, &patchRoute)
 	if err != nil {
-		return err
+		switch err.(type) {
+		case *apiroutes.GetAppsAppRoutesRouteNotFound:
+			return fmt.Errorf("error: %v", err.(*apiroutes.GetAppsAppRoutesRouteNotFound).Payload.Error.Message)
+		case *apiroutes.GetAppsAppRoutesRouteDefault:
+			return fmt.Errorf("unexpected error: %v", err.(*apiroutes.GetAppsAppRoutesRouteDefault).Payload.Error.Message)
+		}
+		return fmt.Errorf("unexpected error: %v", err)
 	}
 
-	fmt.Println(appName, route, "updated", key, "with", value)
+	config := resp.Payload.Route.Config
+
+	if config == nil {
+		config = make(map[string]string)
+	}
+
+	config[key] = value
+	resp.Payload.Route.Config = config
+
+	_, err = a.client.Routes.PatchAppsAppRoutesRoute(&apiroutes.PatchAppsAppRoutesRouteParams{
+		Context: context.Background(),
+		App:     appName,
+		Route:   route,
+		Body:    resp.Payload,
+	})
+
+	if err != nil {
+		switch err.(type) {
+		case *apiroutes.PatchAppsAppRoutesRouteBadRequest:
+			return fmt.Errorf("error: %v", err.(*apiroutes.PatchAppsAppRoutesRouteBadRequest).Payload.Error.Message)
+		case *apiroutes.PatchAppsAppRoutesRouteNotFound:
+			return fmt.Errorf("error: %v", err.(*apiroutes.PatchAppsAppRoutesRouteNotFound).Payload.Error.Message)
+		case *apiroutes.PatchAppsAppRoutesRouteDefault:
+			return fmt.Errorf("unexpected error: %v", err.(*apiroutes.PatchAppsAppRoutesRouteDefault).Payload.Error.Message)
+		}
+		return fmt.Errorf("unexpected error: %v", err)
+	}
+
+	fmt.Println(appName, resp.Payload.Route.Path, "updated", key, "with", value)
+
+	// patchRoute := functions.Route{
+	// 	Config: make(map[string]string),
+	// }
+
+	// patchRoute.Config[key] = value
+
+	// err := a.patchRoute(appName, route, &patchRoute)
+	// if err != nil {
+	// 	return err
+	// }
+
+	// fmt.Println(appName, route, "updated", key, "with", value)
 	return nil
 }
 
@@ -461,84 +559,40 @@ func (a *routesCmd) configUnset(c *cli.Context) error {
 		return errors.New("error: route configuration setting takes four arguments: an app name, a route and a key")
 	}
 
-	if err := resetBasePath(a.Configuration); err != nil {
-		return fmt.Errorf("error setting endpoint: %v", err)
-	}
-
 	appName := c.Args().Get(0)
 	route := c.Args().Get(1)
 	key := c.Args().Get(2)
 
-	patchRoute := functions.Route{
-		Config: make(map[string]string),
-	}
+	resp, err := a.client.Routes.GetAppsAppRoutesRoute(&apiroutes.GetAppsAppRoutesRouteParams{
+		Context: context.Background(),
+		App:     appName,
+		Route:   route,
+	})
 
-	patchRoute.Config["-"+key] = ""
-
-	err := a.patchRoute(appName, route, &patchRoute)
 	if err != nil {
-		return err
+		switch err.(type) {
+		case *apiroutes.GetAppsAppRoutesRouteNotFound:
+			return fmt.Errorf("error: %v", err.(*apiroutes.GetAppsAppRoutesRouteNotFound).Payload.Error.Message)
+		case *apiroutes.GetAppsAppRoutesRouteDefault:
+			return fmt.Errorf("unexpected error: %v", err.(*apiroutes.GetAppsAppRoutesRouteDefault).Payload.Error.Message)
+		}
+		return fmt.Errorf("unexpected error: %v", err)
 	}
 
-	fmt.Println(appName, route, "removed", key)
-	return nil
-}
+	config := resp.Payload.Route.Config
 
-func (a *routesCmd) patchRoute(appName, routePath string, r *functions.Route) error {
-	wrapper, _, err := a.AppsAppRoutesRouteGet(appName, routePath)
-	if err != nil {
-		return fmt.Errorf("error loading route: %v", err)
+	if config == nil {
+		config = make(map[string]string)
 	}
 
-	if msg := wrapper.Error_.Message; msg != "" {
-		return errors.New(msg)
+	if _, ok := config[key]; !ok {
+		return fmt.Errorf("configuration key %s not found", key)
 	}
 
-	wrapper.Route.Path = ""
-	if r != nil {
-		if r.Config != nil {
-			for k, v := range r.Config {
-				if string(k[0]) == "-" {
-					delete(r.Config, string(k[1:]))
-					continue
-				}
-				wrapper.Route.Config[k] = v
-			}
-		}
-		if r.Headers != nil {
-			for k, v := range r.Headers {
-				if v[0] == "" {
-					delete(r.Headers, k)
-					continue
-				}
-				wrapper.Route.Headers[k] = v
-			}
-		}
-		if r.Image != "" {
-			wrapper.Route.Image = r.Image
-		}
-		if r.Format != "" {
-			wrapper.Route.Format = r.Format
-		}
-		if r.MaxConcurrency > 0 {
-			wrapper.Route.MaxConcurrency = r.MaxConcurrency
-		}
-		if r.Memory > 0 {
-			wrapper.Route.Memory = r.Memory
-		}
-		if r.Timeout > 0 {
-			wrapper.Route.Timeout = r.Timeout
-		}
-	}
-
-	if wrapper, _, err = a.AppsAppRoutesRoutePatch(appName, routePath, *wrapper); err != nil {
-		return fmt.Errorf("error updating route: %v", err)
-	}
-
-	if msg := wrapper.Error_.Message; msg != "" {
-		return errors.New(msg)
-	}
+	delete(config, key)
+	resp.Payload.Route.Config = config
 
+	fmt.Println(appName, resp.Payload.Route.Path, "removed", key)
 	return nil
 }
 
@@ -547,38 +601,35 @@ func (a *routesCmd) inspect(c *cli.Context) error {
 		return errors.New("error: routes listing takes three arguments: an app name and a path")
 	}
 
-	if err := resetBasePath(a.Configuration); err != nil {
-		return fmt.Errorf("error setting endpoint: %v", err)
-	}
-
 	appName := c.Args().Get(0)
 	route := c.Args().Get(1)
 	prop := c.Args().Get(2)
 
-	wrapper, resp, err := a.AppsAppRoutesRouteGet(appName, route)
-	if err != nil {
-		return fmt.Errorf("error retrieving route: %v", err)
-	}
+	resp, err := a.client.Routes.GetAppsAppRoutesRoute(&apiroutes.GetAppsAppRoutesRouteParams{
+		Context: context.Background(),
+		App:     appName,
+		Route:   route,
+	})
 
-	if msg := wrapper.Error_.Message; msg != "" {
-		return errors.New(msg)
+	if err != nil {
+		switch err.(type) {
+		case *apiroutes.GetAppsAppRoutesRouteNotFound:
+			return fmt.Errorf("error: %v", err.(*apiroutes.GetAppsAppRoutesRouteNotFound).Payload.Error.Message)
+		case *apiroutes.GetAppsAppRoutesRouteDefault:
+			return fmt.Errorf("unexpected error: %v", err.(*apiroutes.GetAppsAppRoutesRouteDefault).Payload.Error.Message)
+		}
+		return fmt.Errorf("unexpected error: %v", err)
 	}
 
 	enc := json.NewEncoder(os.Stdout)
 	enc.SetIndent("", "\t")
 
 	if prop == "" {
-		enc.Encode(wrapper.Route)
+		enc.Encode(resp.Payload.Route)
 		return nil
 	}
 
-	var inspect struct{ Route map[string]interface{} }
-	err = json.Unmarshal(resp.Payload, &inspect)
-	if err != nil {
-		return fmt.Errorf("error inspect route: %v", err)
-	}
-
-	jq := jsonq.NewQuery(inspect.Route)
+	jq := jsonq.NewQuery(resp.Payload.Route)
 	field, err := jq.Interface(strings.Split(prop, ".")...)
 	if err != nil {
 		return errors.New("failed to inspect the property")