Add authorization middleware, id_resolver (#12)

* Add authorization middleware, id_resolver

**What**

- Renamed `http/middleware` -> `http/middlewares`
- Added `http/middlewares/authorization`
- Added `db/id_resolver`

Author: rdner

.circleci/config.yml

@@ -3,6 +3,11 @@ jobs:
   build:
     docker:
       - image: circleci/golang:1.12
+      - image: circleci/postgres:alpine
+        environment:
+          POSTGRES_PASSWORD: localdev
+          POSTGRES_USER: contiamo_test
+          POSTGRES_DB: postgres
     environment:
       GO111MODULE: "on"
     steps: # steps that comprise the `build` job
@@ -20,9 +25,19 @@ jobs:
       - run:
           name: Verify formatting
           command: make fmt lint
+      - run:
+          name: Waiting for Postgres to be ready
+          command: |
+            for i in `seq 1 10`;
+            do
+              nc -z localhost 5432 && echo Success && exit 0
+              echo -n .
+              sleep 1
+            done
+            echo Failed waiting for Postgres && exit 1
       - run:
           name: Run unit tests
-          command: make test
+          command: make .test-ci
       - save_cache: # Store cache in the /go/pkg directory
           key: go-mod-cache
           paths:

Makefile

@@ -31,6 +31,28 @@ setup-env:
 	$(shell go mod download)
 	$(shell curl -sfL https://raw.githubusercontent.com/golangci/golangci-lint/master/install.sh| sh -s v1.20.0)
 
+.PHONY: .run-test-db
+.run-test-db: ## start the test db
+	@echo "+ setup test db"
+	@docker run --rm -d --name go-base-postgres \
+	-p 0.0.0.0:5432:5432 \
+	-e POSTGRES_PASSWORD=$$(cat pkg/db/test/password) \
+	-e POSTGRES_USER=contiamo_test \
+	-e POSTGRES_DB=postgres \
+	postgres:alpine -c fsync=off -c full_page_writes=off -c synchronous_commit=off &>/dev/null
+	@bash -c "export PGPASSWORD=$$(cat pkg/db/test/password); until psql -q -Ucontiamo_test -l -h localhost &>/dev/null; do echo -n .; sleep 1; done"
+	@echo ""
+	@echo "+ test db started"
+
+.PHONY: .stop-test-db
+.stop-test-db:  ## teardown the test db
+	@echo "+ teardown test db"
+	@docker rm -v -f go-base-postgres &>/dev/null
+
+.PHONY: .test-ci
+.test-ci:
+	go test -cover ./...
+
 .PHONY: changelog
 changelog: ## Print git hitstory based changelog
 	@git --no-pager log --no-merges --pretty=format:"%h : %s (by %an)" $(shell git describe --tags --abbrev=0)...HEAD
@@ -54,8 +76,10 @@ staticcheck: ## Verifies `staticcheck` passes
 
 .PHONY: test
 test: ## Runs the go tests
+	@$(MAKE) .run-test-db
 	@echo "+ $@"
-	@go test -cover ./...
+	-@$(MAKE) .test-ci
+	@$(MAKE) .stop-test-db
 
 .PHONY: lint
 lint: setup-env ## Verifies `golangci-lint` passes

go.mod

@@ -5,16 +5,19 @@ require (
 	github.com/asaskevich/govalidator v0.0.0-20190424111038-f61b66f89f4a // indirect
 	github.com/bakins/net-http-recover v0.0.0-20141007104922-6cba69d01459
 	github.com/cenkalti/backoff v2.2.1+incompatible
-	github.com/codahale/hdrhistogram v0.0.0-20161010025455-3a0bb77429bd // indirect
+	github.com/contiamo/goserver v0.5.0
+	github.com/contiamo/jwt v0.2.2
 	github.com/dgrijalva/jwt-go v3.2.0+incompatible
 	github.com/go-chi/chi v4.0.2+incompatible
 	github.com/go-ozzo/ozzo-validation v3.6.0+incompatible
+	github.com/go-sql-driver/mysql v1.4.1 // indirect
 	github.com/golang/protobuf v1.3.2
 	github.com/google/uuid v1.1.1
 	github.com/gorilla/websocket v1.4.0
 	github.com/konsorten/go-windows-terminal-sequences v1.0.2 // indirect
 	github.com/kr/pretty v0.1.0 // indirect
 	github.com/lib/pq v1.1.1
+	github.com/mattn/go-sqlite3 v1.11.0 // indirect
 	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
 	github.com/modern-go/reflect2 v1.0.1 // indirect
 	github.com/opentracing/opentracing-go v1.1.0
@@ -25,15 +28,13 @@ require (
 	github.com/satori/go.uuid v1.2.0
 	github.com/sirupsen/logrus v1.4.2
 	github.com/stretchr/testify v1.3.0
-	github.com/uber-go/atomic v1.4.0 // indirect
 	github.com/uber/jaeger-client-go v2.16.0+incompatible
 	github.com/uber/jaeger-lib v2.0.0+incompatible // indirect
 	github.com/urfave/negroni v1.0.0
-	go.uber.org/atomic v1.4.0 // indirect
 	golang.org/x/lint v0.0.0-20190409202823-959b441ac422
 	golang.org/x/tools v0.0.0-20190606124116-d0a3d012864b // indirect
 	google.golang.org/appengine v1.4.0 // indirect
 	google.golang.org/genproto v0.0.0-20190716160619-c506a9f90610 // indirect
-	google.golang.org/grpc v1.22.0
+	google.golang.org/grpc v1.22.0 // indirect
 	gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 // indirect
 )

go.sum

@@ -68,26 +68,26 @@ func (cfg *Database) GetConnectionString() (connStr string, err error) {
 	connStr = "sslmode=disable "
 
 	if cfg.Host != "" {
-		connStr += fmt.Sprintf("host=%v ", cfg.Host)
+		connStr += fmt.Sprintf("host=%s ", cfg.Host)
 	}
 
 	if cfg.Port != 0 {
 		connStr += fmt.Sprintf("port=%d ", cfg.Port)
 	}
 
 	if cfg.Name != "" {
-		connStr += fmt.Sprintf("dbname=%v ", cfg.Name)
+		connStr += fmt.Sprintf("dbname=%s ", cfg.Name)
 	}
 	if cfg.Username != "" {
-		connStr += fmt.Sprintf("user=%v ", cfg.Username)
+		connStr += fmt.Sprintf("user=%s ", cfg.Username)
 	}
 	if cfg.PasswordPath != "" {
 		pw, err := cfg.GetPassword()
 		if err != nil {
 			return "", err
 		}
 		if pw != "" {
-			connStr += fmt.Sprintf("password=%v ", pw)
+			connStr += fmt.Sprintf("password=%s ", pw)
 		}
 	}
 

pkg/config/database.go

@@ -0,0 +1,109 @@
+package managers
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"strings"
+
+	squirrel "github.com/Masterminds/squirrel"
+	dserrors "github.com/contiamo/go-base/pkg/errors"
+	uuid "github.com/satori/go.uuid"
+)
+
+// IDResolver makes possible to access database records by their IDs or unique values
+type IDResolver interface {
+	// Resolve returns an ID of the given record identified by the value which can be either
+	// an UUID or a unique string value of the given secondary column.
+	// where is a map of where statements to their list of arguments
+	Resolve(ctx context.Context, sql squirrel.StatementBuilderType, value string, filter squirrel.Sqlizer) (string, error)
+	// Sqlizer returns a Sqlizer interface that contains where statements for a given
+	// filter and the ID column, so you can immediately use it with
+	// the where of the select builder
+	Sqlizer(ctx context.Context, sql squirrel.StatementBuilderType, value string, filter squirrel.Sqlizer) (squirrel.Sqlizer, error)
+}
+
+type idResolver struct {
+	table,
+	idColumn,
+	secondaryColumn string
+}
+
+func (r *idResolver) Sqlizer(ctx context.Context, sql squirrel.StatementBuilderType, value string, filter squirrel.Sqlizer) (squirrel.Sqlizer, error) {
+	id, err := r.Resolve(ctx, sql, value, filter)
+	if err != nil {
+		return nil, err
+	}
+
+	idPred := squirrel.Eq{
+		r.idColumn: id,
+	}
+	if filter == nil {
+		return idPred, nil
+	}
+	return squirrel.And{
+		filter,
+		idPred,
+	}, nil
+}
+
+func (r *idResolver) Resolve(ctx context.Context, sql squirrel.StatementBuilderType, value string, filter squirrel.Sqlizer) (string, error) {
+	if value == "" {
+		return value, dserrors.ValidationErrors{
+			"id": errors.New("the id parameter can't be empty"),
+		}.Filter()
+	}
+
+	uuidVal, err := uuid.FromString(strings.TrimSpace(value))
+	if err == nil {
+		return uuidVal.String(), nil
+	}
+
+	rows, err := sql.
+		Select(r.idColumn).
+		From(r.table).
+		Where(filter).
+		Where(squirrel.Eq{r.secondaryColumn: value}).
+		Limit(2).
+		QueryContext(ctx)
+
+	if err != nil {
+		return "", err
+	}
+
+	defer rows.Close()
+
+	// no results at all
+	if !rows.Next() {
+		return "", dserrors.ErrNotFound
+	}
+	var id string
+	err = rows.Scan(&id)
+	if err != nil {
+		return id, err
+	}
+	// non-unique result
+	if rows.Next() {
+		return "", fmt.Errorf(
+			"id for `%s = %s` can't be resolved in `%s` due to non-unique results",
+			r.secondaryColumn,
+			value,
+			r.table,
+		)
+	}
+
+	return id, err
+}
+
+// NewIDResolver creates a new name->id resolver for a table, for example
+// var (
+// 	CollectionIDResolver = NewIDResolver("collections", "collection_id", "name")
+// 	TableIDResolver = NewIDResolver("tables", "table_id", "name")
+// )
+func NewIDResolver(table, idColumn, secondaryColumn string) IDResolver {
+	return &idResolver{
+		table:           table,
+		idColumn:        idColumn,
+		secondaryColumn: secondaryColumn,
+	}
+}

pkg/data/managers/id_resolver.go

@@ -0,0 +1,143 @@
+package managers
+
+import (
+	"context"
+	"database/sql"
+	"io/ioutil"
+	"testing"
+	"time"
+
+	squirrel "github.com/Masterminds/squirrel"
+	dbtest "github.com/contiamo/go-base/pkg/db/test"
+	uuid "github.com/satori/go.uuid"
+	"github.com/sirupsen/logrus"
+	"github.com/stretchr/testify/require"
+)
+
+func init() {
+	logrus.SetOutput(ioutil.Discard)
+}
+
+func Test_Sqlizer(t *testing.T) {
+	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+	defer cancel()
+	_, db := dbtest.GetDatabase(t, nil)
+	defer db.Close()
+
+	r := NewIDResolver("test", "id", "name")
+	manager := NewBaseManager(db, "id_resolver_test")
+	builder := manager.GetQueryBuilder()
+	id := uuid.NewV4().String()
+	where, err := r.Sqlizer(ctx, builder, id, squirrel.Eq{
+		"some": "cool",
+	})
+	require.NoError(t, err)
+	sql, _, err := where.ToSql()
+	require.NoError(t, err)
+	require.Equal(t, "(some = ? AND id = ?)", sql)
+}
+
+func Test_Resolve(t *testing.T) {
+	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+	defer cancel()
+
+	_, db := dbtest.GetDatabase(t, func(ctx context.Context, db *sql.DB) error {
+		_, err := db.ExecContext(ctx, `CREATE TABLE test(
+		id UUID PRIMARY KEY,
+    parent_id UUID,
+		name text,
+		UNIQUE(name, parent_id)
+	);`)
+		return err
+	})
+	defer db.Close()
+
+	secIDs := []uuid.UUID{
+		uuid.NewV4(),
+		uuid.NewV4(),
+	}
+	ids := []uuid.UUID{
+		uuid.NewV4(),
+		uuid.NewV4(),
+		uuid.NewV4(),
+	}
+
+	_, err := db.ExecContext(ctx, `INSERT INTO test (id, parent_id, name) VALUES ($1,$2, 'unique')`, ids[0], secIDs[0])
+	require.NoError(t, err)
+	_, err = db.ExecContext(ctx, `INSERT INTO test (id, parent_id, name) VALUES ($1,$2, 'regular')`, ids[1], secIDs[0])
+	require.NoError(t, err)
+	_, err = db.ExecContext(ctx, `INSERT INTO test (id, parent_id, name) VALUES ($1,$2, 'regular')`, ids[2], secIDs[1])
+	require.NoError(t, err)
+
+	r := NewIDResolver("test", "id", "name")
+
+	cases := []struct {
+		name,
+		value,
+		expectedID string
+		where  squirrel.Sqlizer
+		expErr bool
+	}{
+		{
+			name:       "Resolves UUID into ID",
+			value:      ids[0].String(),
+			expectedID: ids[0].String(),
+			where:      nil,
+		},
+		{
+			name:       "Resolves a unique name into ID",
+			value:      "unique",
+			expectedID: ids[0].String(),
+			where:      nil,
+		},
+		{
+			name:       "Resolves a non-unique name into ID for different parent IDs",
+			value:      "regular",
+			expectedID: ids[1].String(),
+			where: squirrel.Eq{
+				"parent_id": secIDs[0],
+			},
+		},
+		{
+			name:       "Resolves a second non-unique name into ID",
+			value:      "regular",
+			expectedID: ids[2].String(),
+			where: squirrel.Eq{
+				"parent_id": secIDs[1],
+			},
+		},
+		{
+			name:       "Triggers error when resolve a non-existent name",
+			value:      "wrong",
+			expectedID: "",
+			where: squirrel.Eq{
+				"parent_id": secIDs[0],
+			},
+			expErr: true,
+		},
+		{
+			name:       "Triggers error when there are more than one result",
+			value:      "regular",
+			expectedID: "",
+			expErr:     true,
+		},
+		{
+			name:   "Triggers validation error when the value is empty",
+			expErr: true,
+		},
+	}
+
+	for _, tc := range cases {
+		manager := NewBaseManager(db, "id_resolver_test")
+		builder := manager.GetQueryBuilder()
+		t.Run(tc.name, func(t *testing.T) {
+			id, err := r.Resolve(ctx, builder, tc.value, tc.where)
+			if tc.expErr {
+				require.Error(t, err)
+				return
+			}
+			require.NoError(t, err)
+			require.Equal(t, tc.expectedID, id)
+		})
+	}
+}