Merge pull request #89 from mutablelogic/v5

Added API Prefixes

Author: djthorpe

README.md

@@ -16,14 +16,26 @@ features and functionality as needed. More documentation soon on how to do that.
 
 ## Running
 
-You can run the server in a docker container or build it from source. To run the latest
-released version as a docker container:
+The binary includes both the *server*-side application and the *client*-side
+command-line tools. Both can be run as docker containers.
+
+To run the latest released version as a docker container:
 
 ```bash
 docker run ghcr.io/mutablelogic/go-server:latest
 ```
 
-This will print out the help message.
+This will print out the help message and provide insight into running both the server application
+and interacting with the server through commands. To run the server, you'll need a PostgreSQL
+database, and you can set the environment variables `PG_HOST`, `PG_DATABASE`, `PG_USER` and `PG_PASS`.
+
+### Bootstrapping the database server and roles
+
+More information about setting up the databses TODO
+
+### Creating a new database
+
+Information about setting up a new database
 
 ## Building
 
@@ -41,10 +53,10 @@ The plugins and the `server` binary will be built in the `build` directory.
 
 You need the following three tools installed to build the server:
 
-- [Go](https://golang.org/doc/install/source) (1.23 or later, not required for docker builds)
-- [Make](https://www.gnu.org/software/make/)
-- [Docker](https://docs.docker.com/get-docker/)
-- [NPM](https://docs.npmjs.com/downloading-and-installing-node-js-and-npm)
+* [Go](https://golang.org/doc/install/source) (1.23 or later, not required for docker builds)
+* [Make](https://www.gnu.org/software/make/)
+* [Docker](https://docs.docker.com/get-docker/)
+* [NPM](https://docs.npmjs.com/downloading-and-installing-node-js-and-npm)
 
 ### Makefile targets
 
@@ -68,15 +80,14 @@ Binaries are placed in the `build` directory.
 You can also affect the build by setting the following environment variables. For example,
 
 ```bash
-GOOS=linux GOARCH=amd64 make
+OS=linux ARCH=amd64 make
 ```
 
 | Variable | Description |
 |----------|-------------|
-| `GOOS` | The target operating system for the build |
-| `GOARCH` | The target architecture for the build |
+| `OS` | The target operating system for the build |
+| `ARCH` | The target architecture for the build |
 | `BUILD_DIR` | The target architecture for the build |
 | `VERBOSE` | Setting this flag will provide verbose output for unit tests |
 | `VERSION` | Explicitly set the version |
 | `DOCKER_REPO` | The docker repository to push to. Defaults to `ghcr.io/mutablelogic/go-server` |
-

cmd/server/main.go

@@ -9,9 +9,13 @@ import (
 	kong "github.com/alecthomas/kong"
 	server "github.com/mutablelogic/go-server"
 	auth "github.com/mutablelogic/go-server/pkg/auth/cmd"
+	auth_schema "github.com/mutablelogic/go-server/pkg/auth/schema"
 	certmanager "github.com/mutablelogic/go-server/pkg/cert/cmd"
+	cert_schema "github.com/mutablelogic/go-server/pkg/cert/schema"
 	pgmanager "github.com/mutablelogic/go-server/pkg/pgmanager/cmd"
+	pgmanager_schema "github.com/mutablelogic/go-server/pkg/pgmanager/schema"
 	pgqueue "github.com/mutablelogic/go-server/pkg/pgqueue/cmd"
+	pgqueue_schema "github.com/mutablelogic/go-server/pkg/pgqueue/schema"
 )
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -51,10 +55,10 @@ func main() {
 		kong.Vars{
 			"HOST":         hostName(),
 			"USER":         userName(),
-			"CERT_PREFIX":  "/cert/v1",
-			"PG_PREFIX":    "/pg/v1",
-			"AUTH_PREFIX":  "/auth/v1",
-			"QUEUE_PREFIX": "/queue/v1",
+			"CERT_PREFIX":  cert_schema.APIPrefix,
+			"PG_PREFIX":    pgmanager_schema.APIPrefix,
+			"AUTH_PREFIX":  auth_schema.APIPrefix,
+			"QUEUE_PREFIX": pgqueue_schema.APIPrefix,
 		},
 	)
 

cmd/server/service.go

@@ -9,7 +9,11 @@ import (
 	// Packages
 	server "github.com/mutablelogic/go-server"
 	helloworld "github.com/mutablelogic/go-server/npm/helloworld"
+	auth_schema "github.com/mutablelogic/go-server/pkg/auth/schema"
+	cert_schema "github.com/mutablelogic/go-server/pkg/cert/schema"
 	httpresponse "github.com/mutablelogic/go-server/pkg/httpresponse"
+	pgmanager_schema "github.com/mutablelogic/go-server/pkg/pgmanager/schema"
+	pgqueue_schema "github.com/mutablelogic/go-server/pkg/pgqueue/schema"
 	provider "github.com/mutablelogic/go-server/pkg/provider"
 	ref "github.com/mutablelogic/go-server/pkg/ref"
 	types "github.com/mutablelogic/go-server/pkg/types"
@@ -104,6 +108,7 @@ func (cmd *ServiceRunCommand) Run(app server.Cmd) error {
 		pgpool := config.(*pg.Config)
 
 		// Set router
+		pgpool.Prefix = pgmanager_schema.APIPrefix
 		if router, ok := provider.Task(ctx, "httprouter.main").(server.HTTPRouter); !ok || router == nil {
 			return httpresponse.ErrInternalError.With("Invalid router")
 		} else {
@@ -128,14 +133,15 @@ func (cmd *ServiceRunCommand) Run(app server.Cmd) error {
 		auth := config.(*auth.Config)
 
 		// Set the router
-		if router, ok := ref.Provider(ctx).Task(ctx, "httprouter").(server.HTTPRouter); !ok || router == nil {
+		auth.Prefix = auth_schema.APIPrefix
+		if router, ok := ref.Provider(ctx).Task(ctx, "httprouter.main").(server.HTTPRouter); !ok || router == nil {
 			return httpresponse.ErrInternalError.With("Invalid router")
 		} else {
 			auth.Router = router
 		}
 
 		// Set the connection pool
-		if pool, ok := ref.Provider(ctx).Task(ctx, "pgpool").(server.PG); !ok || pool == nil {
+		if pool, ok := ref.Provider(ctx).Task(ctx, "pgpool.main").(server.PG); !ok || pool == nil {
 			return httpresponse.ErrInternalError.With("Invalid connection pool")
 		} else {
 			auth.Pool = pool
@@ -148,14 +154,15 @@ func (cmd *ServiceRunCommand) Run(app server.Cmd) error {
 		pgqueue := config.(*pgqueue.Config)
 
 		// Set the router
-		if router, ok := ref.Provider(ctx).Task(ctx, "httprouter").(server.HTTPRouter); !ok || router == nil {
+		pgqueue.Prefix = pgqueue_schema.APIPrefix
+		if router, ok := ref.Provider(ctx).Task(ctx, "httprouter.main").(server.HTTPRouter); !ok || router == nil {
 			return httpresponse.ErrInternalError.With("Invalid router")
 		} else {
 			pgqueue.Router = router
 		}
 
 		// Set the connection pool
-		if pool, ok := ref.Provider(ctx).Task(ctx, "pgpool").(server.PG); !ok || pool == nil {
+		if pool, ok := ref.Provider(ctx).Task(ctx, "pgpool.main").(server.PG); !ok || pool == nil {
 			return httpresponse.ErrInternalError.With("Invalid connection pool")
 		} else {
 			pgqueue.Pool = pool
@@ -167,21 +174,22 @@ func (cmd *ServiceRunCommand) Run(app server.Cmd) error {
 		certmanager := config.(*cert.Config)
 
 		// Set the router
-		if router, ok := ref.Provider(ctx).Task(ctx, "httprouter").(server.HTTPRouter); !ok || router == nil {
+		certmanager.Prefix = cert_schema.APIPrefix
+		if router, ok := ref.Provider(ctx).Task(ctx, "httprouter.main").(server.HTTPRouter); !ok || router == nil {
 			return httpresponse.ErrInternalError.With("Invalid router")
 		} else {
 			certmanager.Router = router
 		}
 
 		// Set the connection pool
-		if pool, ok := ref.Provider(ctx).Task(ctx, "pgpool").(server.PG); !ok || pool == nil {
+		if pool, ok := ref.Provider(ctx).Task(ctx, "pgpool.main").(server.PG); !ok || pool == nil {
 			return httpresponse.ErrInternalError.With("Invalid connection pool")
 		} else {
 			certmanager.Pool = pool
 		}
 
 		// Set the queue
-		if queue, ok := ref.Provider(ctx).Task(ctx, "pgqueue").(server.PGQueue); !ok || queue == nil {
+		if queue, ok := ref.Provider(ctx).Task(ctx, "pgqueue.main").(server.PGQueue); !ok || queue == nil {
 			return httpresponse.ErrInternalError.With("Invalid task queue")
 		} else {
 			certmanager.Queue = queue

pkg/auth/schema/schema.go

@@ -15,6 +15,7 @@ const (
 	RootUserName      = "root"
 	UserListLimit     = 50
 	AuthHashAlgorithm = "sha256"
+	APIPrefix         = "/auth/v1"
 )
 
 const (

pkg/cert/schema/schema.go

@@ -12,6 +12,7 @@ import (
 
 const (
 	SchemaName = "certmanager"
+	APIPrefix  = "/cert/v1"
 )
 
 const (

pkg/pgmanager/schema/globals.go

@@ -11,6 +11,7 @@ import (
 
 const (
 	CatalogSchema = "pg_catalog"
+	APIPrefix     = "/pg/v1"
 )
 
 const (

pkg/pgqueue/schema/schema.go

@@ -15,7 +15,7 @@ const (
 	SchemaName       = "pgqueue"
 	DefaultNamespace = "default"
 	CleanupNamespace = "cleanup"
-	DefaultPrefix    = "/queue/v1"
+	APIPrefix        = "/queue/v1"
 	TopicQueueInsert = "queue_insert"
 	QueueListLimit   = 100
 	TickerListLimit  = 100

pkg/provider/meta/meta.go

@@ -5,14 +5,16 @@ import (
 	"fmt"
 	"io"
 	"net/url"
+	"os"
 	"reflect"
-	"strings"
+	"strconv"
 	"time"
 
 	// Packages
-	"github.com/mutablelogic/go-server"
+	server "github.com/mutablelogic/go-server"
 	httpresponse "github.com/mutablelogic/go-server/pkg/httpresponse"
 	ast "github.com/mutablelogic/go-server/pkg/parser/ast"
+	types "github.com/mutablelogic/go-server/pkg/types"
 )
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -21,7 +23,9 @@ import (
 type Meta struct {
 	Name        string
 	Description string
+	Default     string
 	Type        reflect.Type
+	Index       []int
 	Fields      []*Meta
 }
 
@@ -93,6 +97,9 @@ func (m *Meta) Write(w io.Writer) error {
 			buf.WriteString("  // ")
 			buf.WriteString(field.Description)
 		}
+		if field.Default != "" {
+			buf.WriteString(" (default: " + types.Quote(field.Default) + ")")
+		}
 
 		buf.WriteString("\n")
 	}
@@ -114,16 +121,20 @@ func (m *Meta) Validate(values any) error {
 }
 
 func (m *Meta) New() server.Plugin {
-	return reflect.New(m.Type).Interface().(server.Plugin)
+	obj := reflect.New(m.Type)
+	for _, field := range m.Fields {
+		// Expand field for env
+		setValue(obj.Elem().FieldByIndex(field.Index), os.ExpandEnv(field.Default))
+	}
+	return obj.Interface().(server.Plugin)
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // PRIVATE METHODS
 
 func newMetaField(rf reflect.StructField) (*Meta, error) {
 	meta := new(Meta)
-
-	//fmt.Println("newMetaField", rf.Name, rf.Type)
+	meta.Index = rf.Index
 
 	// Name
 	if name := nameForField(rf, "json", "yaml", "name"); name == "" {
@@ -134,7 +145,16 @@ func newMetaField(rf reflect.StructField) (*Meta, error) {
 	}
 
 	// Description
-	meta.Description = rf.Tag.Get("help")
+	if description, _ := valueForField(rf, "description", "help"); description != "" {
+		meta.Description = description
+	}
+
+	// Env - needs to be an identififer
+	if env, _ := valueForField(rf, "env"); types.IsIdentifier(env) {
+		meta.Default = "${" + env + "}"
+	} else if def, _ := valueForField(rf, "default"); def != "" {
+		meta.Default = def
+	}
 
 	// Type
 	if t := typeName(rf.Type); t == "" {
@@ -152,6 +172,67 @@ var (
 	durationType = reflect.TypeOf(time.Duration(0))
 )
 
+func setValue(rv reflect.Value, str string) error {
+	switch rv.Kind() {
+	case reflect.Bool:
+		// Zero value
+		if str == "" {
+			rv.SetZero()
+		}
+		// Bool
+		if v, err := strconv.ParseBool(str); err != nil {
+			return httpresponse.ErrBadRequest.Withf("invalid value for %s: %q", rv.Type(), str)
+		} else {
+			rv.SetBool(v)
+		}
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		// Zero value
+		if str == "" {
+			rv.SetZero()
+		}
+		// Duration
+		if rv.Type() == durationType {
+			if v, err := time.ParseDuration(str); err != nil {
+				return httpresponse.ErrBadRequest.Withf("invalid value for %s: %q", rv.Type(), str)
+			} else {
+				rv.Set(reflect.ValueOf(v))
+			}
+		}
+		// Int
+		if v, err := strconv.ParseInt(str, 10, 64); err != nil {
+			return httpresponse.ErrBadRequest.Withf("invalid value for %s: %q", rv.Type(), str)
+		} else {
+			rv.SetInt(v)
+		}
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		// Zero value
+		if str == "" {
+			rv.SetZero()
+		}
+		// Uint
+		if v, err := strconv.ParseUint(str, 10, 64); err != nil {
+			return httpresponse.ErrBadRequest.Withf("invalid value for %s: %q", rv.Type(), str)
+		} else {
+			rv.SetUint(v)
+		}
+	case reflect.Float32, reflect.Float64:
+		// Zero value
+		if str == "" {
+			rv.SetZero()
+		}
+		// Float
+		if v, err := strconv.ParseFloat(str, 64); err != nil {
+			return httpresponse.ErrBadRequest.Withf("invalid value for %s: %q", rv.Type(), str)
+		} else {
+			rv.SetFloat(v)
+		}
+	case reflect.String:
+		// String
+		rv.SetString(str)
+	}
+	return httpresponse.ErrBadRequest.Withf("invalid value for %s: %q", rv.Type(), str)
+}
+
 func typeName(rt reflect.Type) string {
 	if rt.Kind() == reflect.Ptr {
 		rt = rt.Elem()
@@ -189,20 +270,26 @@ func typeName(rt reflect.Type) string {
 	return "ref"
 }
 
-func nameForField(rt reflect.StructField, tags ...string) string {
+func valueForField(rf reflect.StructField, tags ...string) (string, bool) {
 	for _, tag := range tags {
-		tag, ok := rt.Tag.Lookup(tag)
+		tag, ok := rf.Tag.Lookup(tag)
 		if !ok {
 			continue
 		}
-		if tag == "-" || tag == "" {
+		if tag == "-" {
 			// Ignore
-			return ""
-		}
-		name := strings.Split(tag, ",")
-		if len(name) > 0 && name[0] != "" {
-			return name[0]
+			return "", true
+		} else {
+			return tag, true
 		}
 	}
+	return "", false
+}
+
+func nameForField(rt reflect.StructField, tags ...string) string {
+	value, exists := valueForField(rt, tags...)
+	if exists {
+		return value
+	}
 	return rt.Name
 }