refactor(10.2-01): nest framework packages under modules
- Move remaining beach packages and embedded admin assets\n- Rewrite framework, example, build, and gate paths
This commit is contained in:
74
modules/backpack/app.go
Normal file
74
modules/backpack/app.go
Normal file
@@ -0,0 +1,74 @@
|
||||
package backpack
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"sync"
|
||||
|
||||
"git.golem15.com/golem15/summercms/modules/compass"
|
||||
"git.golem15.com/golem15/summercms/modules/festival"
|
||||
)
|
||||
|
||||
// App is the per-instance application container. It must not import party.
|
||||
type App struct {
|
||||
Config *compass.Config
|
||||
Services *Registry
|
||||
Events *festival.Bus
|
||||
|
||||
mu sync.RWMutex
|
||||
plugins map[string]struct{}
|
||||
}
|
||||
|
||||
// New returns an App that owns cfg.
|
||||
func New(cfg *compass.Config) *App {
|
||||
return &App{
|
||||
Config: cfg,
|
||||
Services: NewRegistry(),
|
||||
Events: festival.New(),
|
||||
plugins: make(map[string]struct{}),
|
||||
}
|
||||
}
|
||||
|
||||
// SetPlugins records the complete activated plugin set. HasPlugin uses this
|
||||
// list, including plugins that have not yet Booted.
|
||||
func (a *App) SetPlugins(ids []string) {
|
||||
if a == nil {
|
||||
return
|
||||
}
|
||||
next := make(map[string]struct{}, len(ids))
|
||||
for _, id := range ids {
|
||||
if id != "" {
|
||||
next[id] = struct{}{}
|
||||
}
|
||||
}
|
||||
a.mu.Lock()
|
||||
a.plugins = next
|
||||
a.mu.Unlock()
|
||||
}
|
||||
|
||||
// HasPlugin reports whether id is in the complete registered set.
|
||||
func (a *App) HasPlugin(id string) bool {
|
||||
if a == nil {
|
||||
return false
|
||||
}
|
||||
a.mu.RLock()
|
||||
defer a.mu.RUnlock()
|
||||
_, ok := a.plugins[id]
|
||||
return ok
|
||||
}
|
||||
|
||||
// Publish stores an app-scoped service under T.
|
||||
func (a *App) Publish[T any](value T) error {
|
||||
if a == nil || a.Services == nil {
|
||||
return fmt.Errorf("backpack: app has no service registry")
|
||||
}
|
||||
return a.Services.Publish(value)
|
||||
}
|
||||
|
||||
// Lookup returns the app-scoped service published under T.
|
||||
func (a *App) Lookup[T any]() (T, bool) {
|
||||
var zero T
|
||||
if a == nil || a.Services == nil {
|
||||
return zero, false
|
||||
}
|
||||
return a.Services.Lookup[T]()
|
||||
}
|
||||
50
modules/backpack/app_test.go
Normal file
50
modules/backpack/app_test.go
Normal file
@@ -0,0 +1,50 @@
|
||||
package backpack
|
||||
|
||||
import (
|
||||
"go/parser"
|
||||
"go/token"
|
||||
"os"
|
||||
"strconv"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"git.golem15.com/golem15/summercms/modules/compass"
|
||||
)
|
||||
|
||||
func TestEventBusesAreAppScoped(t *testing.T) {
|
||||
a := New(&compass.Config{})
|
||||
b := New(&compass.Config{})
|
||||
if a.Events == nil || b.Events == nil {
|
||||
t.Fatal("App must own an event bus")
|
||||
}
|
||||
if a.Events == b.Events {
|
||||
t.Fatal("apps must not share a bus")
|
||||
}
|
||||
}
|
||||
|
||||
func TestDoesNotImportParty(t *testing.T) {
|
||||
entries, err := os.ReadDir(".")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
fset := token.NewFileSet()
|
||||
for _, entry := range entries {
|
||||
name := entry.Name()
|
||||
if entry.IsDir() || !strings.HasSuffix(name, ".go") || strings.HasSuffix(name, "_test.go") {
|
||||
continue
|
||||
}
|
||||
file, err := parser.ParseFile(fset, name, nil, parser.ImportsOnly)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
for _, spec := range file.Imports {
|
||||
path, err := strconv.Unquote(spec.Path.Value)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if path == "git.golem15.com/golem15/summercms/modules/party" {
|
||||
t.Fatalf("%s imports party", name)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
60
modules/backpack/services.go
Normal file
60
modules/backpack/services.go
Normal file
@@ -0,0 +1,60 @@
|
||||
package backpack
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"reflect"
|
||||
"sync"
|
||||
)
|
||||
|
||||
// Registry is an app-scoped typed service catalog. It has no process-global state.
|
||||
type Registry struct {
|
||||
mu sync.RWMutex
|
||||
m map[reflect.Type]any
|
||||
}
|
||||
|
||||
// NewRegistry returns an empty service registry.
|
||||
func NewRegistry() *Registry {
|
||||
return &Registry{m: make(map[reflect.Type]any)}
|
||||
}
|
||||
|
||||
// Publish stores value under the concrete type argument T. Publishing the
|
||||
// same T twice is an error.
|
||||
func (r *Registry) Publish[T any](value T) error {
|
||||
if r == nil {
|
||||
return fmt.Errorf("backpack: registry is nil")
|
||||
}
|
||||
if any(value) == nil {
|
||||
return fmt.Errorf("backpack: publish nil service")
|
||||
}
|
||||
key := reflect.TypeFor[T]()
|
||||
r.mu.Lock()
|
||||
defer r.mu.Unlock()
|
||||
if r.m == nil {
|
||||
r.m = make(map[reflect.Type]any)
|
||||
}
|
||||
if _, exists := r.m[key]; exists {
|
||||
return fmt.Errorf("backpack: duplicate provider for %s", key)
|
||||
}
|
||||
r.m[key] = value
|
||||
return nil
|
||||
}
|
||||
|
||||
// Lookup returns the service published under T, or (zero, false).
|
||||
func (r *Registry) Lookup[T any]() (T, bool) {
|
||||
var zero T
|
||||
if r == nil {
|
||||
return zero, false
|
||||
}
|
||||
key := reflect.TypeFor[T]()
|
||||
r.mu.RLock()
|
||||
defer r.mu.RUnlock()
|
||||
v, ok := r.m[key]
|
||||
if !ok {
|
||||
return zero, false
|
||||
}
|
||||
got, ok := v.(T)
|
||||
if !ok {
|
||||
return zero, false
|
||||
}
|
||||
return got, true
|
||||
}
|
||||
161
modules/backpack/services_test.go
Normal file
161
modules/backpack/services_test.go
Normal file
@@ -0,0 +1,161 @@
|
||||
package backpack
|
||||
|
||||
import (
|
||||
"sync"
|
||||
"testing"
|
||||
|
||||
"git.golem15.com/golem15/summercms/modules/compass"
|
||||
"git.golem15.com/golem15/summercms/modules/pact"
|
||||
)
|
||||
|
||||
type ping interface {
|
||||
Ping() string
|
||||
}
|
||||
|
||||
type pingImpl struct{ s string }
|
||||
|
||||
func (p pingImpl) Ping() string { return p.s }
|
||||
|
||||
func TestPublishLookup(t *testing.T) {
|
||||
app := New(&compass.Config{})
|
||||
if err := app.Publish[ping](pingImpl{s: "pong"}); err != nil {
|
||||
t.Fatalf("Publish: %v", err)
|
||||
}
|
||||
got, ok := app.Lookup[ping]()
|
||||
if !ok {
|
||||
t.Fatal("Lookup returned false")
|
||||
}
|
||||
if got.Ping() != "pong" {
|
||||
t.Fatalf("Ping = %q, want pong", got.Ping())
|
||||
}
|
||||
}
|
||||
|
||||
func TestLookupAbsentInterface(t *testing.T) {
|
||||
app := New(&compass.Config{})
|
||||
got, ok := app.Lookup[ping]()
|
||||
if ok {
|
||||
t.Fatalf("Lookup = (%v, true), want false", got)
|
||||
}
|
||||
if got != nil {
|
||||
t.Fatalf("absent lookup value = %v, want nil", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestPublishDuplicateRejected(t *testing.T) {
|
||||
app := New(&compass.Config{})
|
||||
if err := app.Publish[ping](pingImpl{s: "a"}); err != nil {
|
||||
t.Fatalf("Publish: %v", err)
|
||||
}
|
||||
if err := app.Publish[ping](pingImpl{s: "b"}); err == nil {
|
||||
t.Fatal("expected duplicate publish error")
|
||||
}
|
||||
}
|
||||
|
||||
func TestServiceRegistriesAreAppScoped(t *testing.T) {
|
||||
a := New(&compass.Config{})
|
||||
b := New(&compass.Config{})
|
||||
if err := a.Publish[ping](pingImpl{s: "a"}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, ok := b.Lookup[ping](); ok {
|
||||
t.Fatal("app B should not see app A's service")
|
||||
}
|
||||
}
|
||||
|
||||
func TestHasPluginUsesCompleteSet(t *testing.T) {
|
||||
app := New(&compass.Config{})
|
||||
app.SetPlugins([]string{"golem15.hello", "golem15.optional"})
|
||||
if !app.HasPlugin("golem15.optional") {
|
||||
t.Fatal("HasPlugin(golem15.optional) = false")
|
||||
}
|
||||
if app.HasPlugin("golem15.missing") {
|
||||
t.Fatal("HasPlugin(golem15.missing) = true")
|
||||
}
|
||||
}
|
||||
|
||||
func TestTwoAppsIsolateHasPluginAndServices(t *testing.T) {
|
||||
a := New(&compass.Config{})
|
||||
b := New(&compass.Config{})
|
||||
a.SetPlugins([]string{"golem15.optional"})
|
||||
b.SetPlugins([]string{"golem15.hello"})
|
||||
if err := a.Publish[pact.OptionalMessage](msgService{s: "from-a"}); err != nil {
|
||||
t.Fatalf("Publish A: %v", err)
|
||||
}
|
||||
|
||||
if !a.HasPlugin("golem15.optional") {
|
||||
t.Fatal("app A should see optional")
|
||||
}
|
||||
if a.HasPlugin("golem15.hello") {
|
||||
t.Fatal("app A should not see hello")
|
||||
}
|
||||
if !b.HasPlugin("golem15.hello") {
|
||||
t.Fatal("app B should see hello")
|
||||
}
|
||||
if b.HasPlugin("golem15.optional") {
|
||||
t.Fatal("app B should not see optional")
|
||||
}
|
||||
|
||||
got, ok := a.Lookup[pact.OptionalMessage]()
|
||||
if !ok || got.Message() != "from-a" {
|
||||
t.Fatalf("app A lookup = (%v, %v)", got, ok)
|
||||
}
|
||||
if _, ok := b.Lookup[pact.OptionalMessage](); ok {
|
||||
t.Fatal("app B must not see app A's OptionalMessage")
|
||||
}
|
||||
}
|
||||
|
||||
func TestPublishNilRejectedAndLookupStaysAbsent(t *testing.T) {
|
||||
app := New(&compass.Config{})
|
||||
var nilPing ping
|
||||
if err := app.Publish[ping](nilPing); err == nil {
|
||||
t.Fatal("expected nil publish error")
|
||||
}
|
||||
if _, ok := app.Lookup[ping](); ok {
|
||||
t.Fatal("nil publish must not store a value")
|
||||
}
|
||||
}
|
||||
|
||||
func TestDuplicatePublishKeepsFirstValue(t *testing.T) {
|
||||
app := New(&compass.Config{})
|
||||
if err := app.Publish[ping](pingImpl{s: "first"}); err != nil {
|
||||
t.Fatalf("Publish: %v", err)
|
||||
}
|
||||
if err := app.Publish[ping](pingImpl{s: "second"}); err == nil {
|
||||
t.Fatal("expected duplicate error")
|
||||
}
|
||||
got, ok := app.Lookup[ping]()
|
||||
if !ok || got.Ping() != "first" {
|
||||
t.Fatalf("Lookup = (%v, %v), want first", got, ok)
|
||||
}
|
||||
}
|
||||
|
||||
func TestConcurrentLookupAndHasPlugin(t *testing.T) {
|
||||
app := New(&compass.Config{})
|
||||
app.SetPlugins([]string{"golem15.hello"})
|
||||
if err := app.Publish[ping](pingImpl{s: "pong"}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
var wg sync.WaitGroup
|
||||
for i := 0; i < 16; i++ {
|
||||
wg.Add(1)
|
||||
go func() {
|
||||
defer wg.Done()
|
||||
for j := 0; j < 80; j++ {
|
||||
got, ok := app.Lookup[ping]()
|
||||
if !ok || got.Ping() != "pong" {
|
||||
t.Errorf("Lookup = (%v, %v)", got, ok)
|
||||
return
|
||||
}
|
||||
if !app.HasPlugin("golem15.hello") || app.HasPlugin("golem15.missing") {
|
||||
t.Error("HasPlugin concurrent mismatch")
|
||||
return
|
||||
}
|
||||
}
|
||||
}()
|
||||
}
|
||||
wg.Wait()
|
||||
}
|
||||
|
||||
type msgService struct{ s string }
|
||||
|
||||
func (m msgService) Message() string { return m.s }
|
||||
167
modules/boardwalk/boardwalk.go
Normal file
167
modules/boardwalk/boardwalk.go
Normal file
@@ -0,0 +1,167 @@
|
||||
// Package boardwalk serves the embedded admin SPA build (D-01, D-02).
|
||||
//
|
||||
// The committed dist/ is path-agnostic: Vite builds it with a relative base
|
||||
// and index.html carries the __SUMMER_ADMIN_BASE__ token. Handler rewrites
|
||||
// index.html once for the configured backend.uri, serves hashed assets with
|
||||
// long-lived caching, falls back to index.html for client-side routes and
|
||||
// hands every unmatched api/ path back to the caller so API misses stay JSON.
|
||||
package boardwalk
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"embed"
|
||||
"errors"
|
||||
"fmt"
|
||||
"html"
|
||||
"io/fs"
|
||||
"mime"
|
||||
"net/http"
|
||||
"path"
|
||||
"strings"
|
||||
"time"
|
||||
)
|
||||
|
||||
//go:embed all:dist
|
||||
var distFS embed.FS
|
||||
|
||||
// BaseToken is replaced in dist/index.html by the configured admin prefix.
|
||||
const BaseToken = "__SUMMER_ADMIN_BASE__"
|
||||
|
||||
// contentSecurityPolicy keeps the admin out of frames and allows scripts
|
||||
// only from its own origin; the build contains no inline script.
|
||||
const contentSecurityPolicy = "frame-ancestors 'none'; base-uri 'none'; object-src 'none'; script-src 'self'"
|
||||
|
||||
var contentTypes = map[string]string{
|
||||
".js": "text/javascript; charset=utf-8",
|
||||
".mjs": "text/javascript; charset=utf-8",
|
||||
".css": "text/css; charset=utf-8",
|
||||
".html": "text/html; charset=utf-8",
|
||||
".woff2": "font/woff2",
|
||||
".woff": "font/woff",
|
||||
".svg": "image/svg+xml",
|
||||
".json": "application/json",
|
||||
}
|
||||
|
||||
// Dist returns the embedded build tree rooted at dist/.
|
||||
func Dist() (fs.FS, error) {
|
||||
return fs.Sub(distFS, "dist")
|
||||
}
|
||||
|
||||
// Handler serves the embedded SPA under prefix (for example /backend).
|
||||
// notFoundAPI answers any request whose path under the prefix is api or
|
||||
// starts with api/; it must write the admin API's JSON 404 envelope.
|
||||
func Handler(prefix string, notFoundAPI http.Handler) (http.Handler, error) {
|
||||
root, err := Dist()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return newHandler(root, prefix, notFoundAPI)
|
||||
}
|
||||
|
||||
func newHandler(root fs.FS, prefix string, notFoundAPI http.Handler) (http.Handler, error) {
|
||||
if notFoundAPI == nil {
|
||||
return nil, errors.New("boardwalk: notFoundAPI handler is nil")
|
||||
}
|
||||
prefix = strings.TrimRight(prefix, "/")
|
||||
if !strings.HasPrefix(prefix, "/") {
|
||||
return nil, fmt.Errorf("boardwalk: prefix %q must start with /", prefix)
|
||||
}
|
||||
raw, err := fs.ReadFile(root, "index.html")
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("boardwalk: dist/index.html: %w", err)
|
||||
}
|
||||
index, err := RewriteIndex(raw, prefix)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return &handler{root: root, prefix: prefix, index: index, notFoundAPI: notFoundAPI}, nil
|
||||
}
|
||||
|
||||
// RewriteIndex points relative asset URLs at prefix and injects the prefix
|
||||
// into the summer-admin-base meta. It fails when the token is absent, which
|
||||
// catches a stale or hand-edited dist at boot.
|
||||
func RewriteIndex(raw []byte, prefix string) ([]byte, error) {
|
||||
if !bytes.Contains(raw, []byte(BaseToken)) {
|
||||
return nil, errors.New("boardwalk: dist/index.html has no " + BaseToken + " token; rebuild the admin SPA")
|
||||
}
|
||||
escaped := html.EscapeString(prefix)
|
||||
out := bytes.ReplaceAll(raw, []byte(`="./`), []byte(`="`+escaped+`/`))
|
||||
out = bytes.ReplaceAll(out, []byte(BaseToken), []byte(escaped))
|
||||
return out, nil
|
||||
}
|
||||
|
||||
type handler struct {
|
||||
root fs.FS
|
||||
prefix string
|
||||
index []byte
|
||||
notFoundAPI http.Handler
|
||||
}
|
||||
|
||||
func (h *handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
|
||||
setSecurityHeaders(w.Header())
|
||||
rel := strings.TrimPrefix(r.URL.Path, h.prefix)
|
||||
rel = strings.TrimPrefix(rel, "/")
|
||||
if rel == "api" || strings.HasPrefix(rel, "api/") {
|
||||
h.notFoundAPI.ServeHTTP(w, r)
|
||||
return
|
||||
}
|
||||
name := strings.TrimPrefix(path.Clean("/"+rel), "/")
|
||||
if name == "" || name == "index.html" {
|
||||
h.serveIndex(w, r)
|
||||
return
|
||||
}
|
||||
if info, err := fs.Stat(h.root, name); err == nil {
|
||||
if info.Mode().IsRegular() {
|
||||
h.serveFile(w, r, name)
|
||||
return
|
||||
}
|
||||
// A directory is never listed; it is treated as a client route.
|
||||
h.serveIndex(w, r)
|
||||
return
|
||||
}
|
||||
if path.Ext(name) != "" {
|
||||
http.NotFound(w, r)
|
||||
return
|
||||
}
|
||||
h.serveIndex(w, r)
|
||||
}
|
||||
|
||||
func (h *handler) serveIndex(w http.ResponseWriter, r *http.Request) {
|
||||
w.Header().Set("Content-Type", "text/html; charset=utf-8")
|
||||
w.Header().Set("Cache-Control", "no-store")
|
||||
http.ServeContent(w, r, "index.html", time.Time{}, bytes.NewReader(h.index))
|
||||
}
|
||||
|
||||
func (h *handler) serveFile(w http.ResponseWriter, r *http.Request, name string) {
|
||||
body, err := fs.ReadFile(h.root, name)
|
||||
if err != nil {
|
||||
http.NotFound(w, r)
|
||||
return
|
||||
}
|
||||
w.Header().Set("Content-Type", contentType(name))
|
||||
if strings.HasPrefix(name, "assets/") {
|
||||
w.Header().Set("Cache-Control", "public, max-age=31536000, immutable")
|
||||
} else {
|
||||
w.Header().Set("Cache-Control", "no-cache")
|
||||
}
|
||||
http.ServeContent(w, r, path.Base(name), time.Time{}, bytes.NewReader(body))
|
||||
}
|
||||
|
||||
func contentType(name string) string {
|
||||
ext := strings.ToLower(path.Ext(name))
|
||||
if ct, ok := contentTypes[ext]; ok {
|
||||
return ct
|
||||
}
|
||||
if ct := mime.TypeByExtension(ext); ct != "" {
|
||||
return ct
|
||||
}
|
||||
return "application/octet-stream"
|
||||
}
|
||||
|
||||
func setSecurityHeaders(h http.Header) {
|
||||
h.Set("X-Content-Type-Options", "nosniff")
|
||||
h.Set("Referrer-Policy", "same-origin")
|
||||
h.Set("X-Frame-Options", "DENY")
|
||||
h.Set("Content-Security-Policy", contentSecurityPolicy)
|
||||
h.Set("X-Robots-Tag", "noindex, nofollow")
|
||||
}
|
||||
455
modules/boardwalk/boardwalk_test.go
Normal file
455
modules/boardwalk/boardwalk_test.go
Normal file
@@ -0,0 +1,455 @@
|
||||
package boardwalk
|
||||
|
||||
import (
|
||||
"io/fs"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"path"
|
||||
"regexp"
|
||||
"strings"
|
||||
"testing"
|
||||
"testing/fstest"
|
||||
)
|
||||
|
||||
const testPrefix = "/acme-admin"
|
||||
|
||||
var (
|
||||
assetRef = regexp.MustCompile(`(?:src|href)="([^"]+)"`)
|
||||
scriptTag = regexp.MustCompile(`<script\b[^>]*>`)
|
||||
)
|
||||
|
||||
type apiSpy struct{ calls int }
|
||||
|
||||
func (s *apiSpy) ServeHTTP(w http.ResponseWriter, _ *http.Request) {
|
||||
s.calls++
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
w.WriteHeader(http.StatusNotFound)
|
||||
_, _ = w.Write([]byte(`{"error":{"code":"not_found","message":"Not found","details":{}}}`))
|
||||
}
|
||||
|
||||
func newTestHandler(t *testing.T) (http.Handler, *apiSpy) {
|
||||
t.Helper()
|
||||
spy := &apiSpy{}
|
||||
h, err := Handler(testPrefix, spy)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return h, spy
|
||||
}
|
||||
|
||||
func get(h http.Handler, target string) *httptest.ResponseRecorder {
|
||||
rec := httptest.NewRecorder()
|
||||
h.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, target, nil))
|
||||
return rec
|
||||
}
|
||||
|
||||
func TestIndexRewrite(t *testing.T) {
|
||||
h, _ := newTestHandler(t)
|
||||
for _, target := range []string{testPrefix, testPrefix + "/", testPrefix + "/index.html"} {
|
||||
rec := get(h, target)
|
||||
body := rec.Body.String()
|
||||
if rec.Code != http.StatusOK {
|
||||
t.Fatalf("%s status=%d", target, rec.Code)
|
||||
}
|
||||
if !strings.Contains(body, `<meta name="summer-admin-base" content="`+testPrefix+`"`) {
|
||||
t.Fatalf("%s index has no injected base: %s", target, body)
|
||||
}
|
||||
if strings.Contains(body, BaseToken) || strings.Contains(body, `="./`) {
|
||||
t.Fatalf("%s index was not rewritten: %s", target, body)
|
||||
}
|
||||
if !strings.Contains(body, `src="`+testPrefix+`/assets/`) {
|
||||
t.Fatalf("%s index script is not under the prefix: %s", target, body)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestRewriteIndexRequiresToken(t *testing.T) {
|
||||
if _, err := RewriteIndex([]byte(`<html><script src="./assets/a.js"></script></html>`), testPrefix); err == nil {
|
||||
t.Fatal("index without the base token was accepted")
|
||||
}
|
||||
root := fstest.MapFS{"index.html": &fstest.MapFile{Data: []byte("<html></html>")}}
|
||||
if _, err := newHandler(root, testPrefix, &apiSpy{}); err == nil || !strings.Contains(err.Error(), BaseToken) {
|
||||
t.Fatalf("stale dist accepted: %v", err)
|
||||
}
|
||||
if _, err := newHandler(fstest.MapFS{}, testPrefix, &apiSpy{}); err == nil {
|
||||
t.Fatal("dist without index.html accepted")
|
||||
}
|
||||
if _, err := Handler(testPrefix, nil); err == nil {
|
||||
t.Fatal("nil API not-found handler accepted")
|
||||
}
|
||||
if _, err := Handler("acme-admin", &apiSpy{}); err == nil {
|
||||
t.Fatal("prefix without a leading slash accepted")
|
||||
}
|
||||
}
|
||||
|
||||
func TestRewriteIndexEscapesPrefix(t *testing.T) {
|
||||
out, err := RewriteIndex([]byte(`<meta content="`+BaseToken+`"><script src="./a.js"></script>`), `/a"b`)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if strings.Contains(string(out), `"/a"b`) || !strings.Contains(string(out), `/a"b`) {
|
||||
t.Fatalf("prefix not escaped: %s", out)
|
||||
}
|
||||
}
|
||||
|
||||
func TestEveryReferencedAssetIsEmbedded(t *testing.T) {
|
||||
root, err := Dist()
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
raw, err := fs.ReadFile(root, "index.html")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
index, err := RewriteIndex(raw, testPrefix)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
refs := assetRef.FindAllStringSubmatch(string(index), -1)
|
||||
if len(refs) == 0 {
|
||||
t.Fatal("index references no assets")
|
||||
}
|
||||
h, _ := newTestHandler(t)
|
||||
for _, ref := range refs {
|
||||
target := ref[1]
|
||||
if !strings.HasPrefix(target, testPrefix+"/") {
|
||||
t.Fatalf("reference %q is not under the prefix", target)
|
||||
}
|
||||
name := strings.TrimPrefix(target, testPrefix+"/")
|
||||
if _, err := fs.Stat(root, name); err != nil {
|
||||
t.Fatalf("index references %s, missing from the embedded dist: %v", name, err)
|
||||
}
|
||||
if rec := get(h, target); rec.Code != http.StatusOK {
|
||||
t.Fatalf("GET %s status=%d", target, rec.Code)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestNoInlineScript(t *testing.T) {
|
||||
root, err := Dist()
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
raw, err := fs.ReadFile(root, "index.html")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
tags := scriptTag.FindAllString(string(raw), -1)
|
||||
if len(tags) == 0 {
|
||||
t.Fatal("index has no module script")
|
||||
}
|
||||
for _, tag := range tags {
|
||||
if !strings.Contains(tag, " src=") {
|
||||
t.Fatalf("inline script in index.html: %s", tag)
|
||||
}
|
||||
}
|
||||
if strings.Contains(strings.ToLower(string(raw)), "javascript:") {
|
||||
t.Fatal("index.html contains a javascript: URL")
|
||||
}
|
||||
}
|
||||
|
||||
func TestAPIPathsAreDelegated(t *testing.T) {
|
||||
h, spy := newTestHandler(t)
|
||||
for _, target := range []string{testPrefix + "/api", testPrefix + "/api/", testPrefix + "/api/v1/nope", testPrefix + "/api/v1/auth/login"} {
|
||||
before := spy.calls
|
||||
rec := get(h, target)
|
||||
if spy.calls != before+1 || rec.Code != http.StatusNotFound || strings.Contains(rec.Body.String(), "<html") {
|
||||
t.Fatalf("%s was not delegated: status=%d body=%s", target, rec.Code, rec.Body.String())
|
||||
}
|
||||
}
|
||||
before := spy.calls
|
||||
if rec := get(h, testPrefix+"/apiary"); rec.Code != http.StatusOK || spy.calls != before {
|
||||
t.Fatalf("/apiary is a client route, status=%d", rec.Code)
|
||||
}
|
||||
}
|
||||
|
||||
func TestMissingFileWithExtensionIs404(t *testing.T) {
|
||||
h, _ := newTestHandler(t)
|
||||
for _, target := range []string{testPrefix + "/assets/missing.js", testPrefix + "/favicon.ico", testPrefix + "/golem/missing.css"} {
|
||||
rec := get(h, target)
|
||||
if rec.Code != http.StatusNotFound || strings.Contains(rec.Body.String(), "summer-admin-base") {
|
||||
t.Fatalf("%s status=%d body=%s", target, rec.Code, rec.Body.String())
|
||||
}
|
||||
}
|
||||
for _, target := range []string{testPrefix + "/acme/demo/widgets", testPrefix + "/acme/demo/widgets/12", testPrefix + "/login"} {
|
||||
rec := get(h, target)
|
||||
if rec.Code != http.StatusOK || !strings.Contains(rec.Body.String(), "summer-admin-base") {
|
||||
t.Fatalf("client route %s status=%d", target, rec.Code)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestTraversalIsCleaned(t *testing.T) {
|
||||
root := fstest.MapFS{
|
||||
"index.html": &fstest.MapFile{Data: []byte(`<meta content="` + BaseToken + `">`)},
|
||||
"assets/app.js": &fstest.MapFile{Data: []byte("console.log(1)")},
|
||||
}
|
||||
h, err := newHandler(root, testPrefix, &apiSpy{})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
for _, target := range []string{
|
||||
testPrefix + "/../../../go.mod",
|
||||
testPrefix + "/assets/../../boardwalk.go",
|
||||
testPrefix + "/%2e%2e/%2e%2e/etc/passwd.txt",
|
||||
} {
|
||||
req := httptest.NewRequest(http.MethodGet, "/", nil)
|
||||
req.URL.Path = target
|
||||
rec := httptest.NewRecorder()
|
||||
h.ServeHTTP(rec, req)
|
||||
if rec.Code != http.StatusNotFound || strings.Contains(rec.Body.String(), "module ") || strings.Contains(rec.Body.String(), "package ") {
|
||||
t.Fatalf("%s status=%d body=%s", target, rec.Code, rec.Body.String())
|
||||
}
|
||||
}
|
||||
req := httptest.NewRequest(http.MethodGet, "/", nil)
|
||||
req.URL.Path = testPrefix + "/assets/../index.html"
|
||||
rec := httptest.NewRecorder()
|
||||
h.ServeHTTP(rec, req)
|
||||
if rec.Code != http.StatusOK || strings.Contains(rec.Body.String(), BaseToken) {
|
||||
t.Fatalf("cleaned index path served the raw index: %d %s", rec.Code, rec.Body.String())
|
||||
}
|
||||
}
|
||||
|
||||
func TestDirectoryIsNeverListed(t *testing.T) {
|
||||
h, _ := newTestHandler(t)
|
||||
root, err := Dist()
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
entries, err := fs.ReadDir(root, "assets")
|
||||
if err != nil || len(entries) == 0 {
|
||||
t.Fatalf("embedded assets: %v", err)
|
||||
}
|
||||
for _, target := range []string{testPrefix + "/assets", testPrefix + "/assets/"} {
|
||||
rec := get(h, target)
|
||||
body := rec.Body.String()
|
||||
if strings.Contains(body, entries[0].Name()) || !strings.Contains(body, "summer-admin-base") {
|
||||
t.Fatalf("%s listed the directory or skipped the shell: %s", target, body)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestContentTypesAndCaching(t *testing.T) {
|
||||
h, _ := newTestHandler(t)
|
||||
root, err := Dist()
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
want := map[string]string{
|
||||
".js": "text/javascript; charset=utf-8",
|
||||
".css": "text/css; charset=utf-8",
|
||||
".woff2": "font/woff2",
|
||||
".woff": "font/woff",
|
||||
}
|
||||
seen := map[string]bool{}
|
||||
err = fs.WalkDir(root, "assets", func(name string, d fs.DirEntry, err error) error {
|
||||
if err != nil || d.IsDir() {
|
||||
return err
|
||||
}
|
||||
ext := path.Ext(name)
|
||||
ct, ok := want[ext]
|
||||
if !ok || seen[ext] {
|
||||
return nil
|
||||
}
|
||||
seen[ext] = true
|
||||
rec := get(h, testPrefix+"/"+name)
|
||||
if rec.Code != http.StatusOK || rec.Header().Get("Content-Type") != ct {
|
||||
t.Fatalf("%s status=%d type=%q, want %q", name, rec.Code, rec.Header().Get("Content-Type"), ct)
|
||||
}
|
||||
if cc := rec.Header().Get("Cache-Control"); cc != "public, max-age=31536000, immutable" {
|
||||
t.Fatalf("%s Cache-Control=%q", name, cc)
|
||||
}
|
||||
return nil
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
for ext := range want {
|
||||
if !seen[ext] {
|
||||
t.Fatalf("embedded dist has no %s asset", ext)
|
||||
}
|
||||
}
|
||||
index := get(h, testPrefix)
|
||||
if index.Header().Get("Cache-Control") != "no-store" || !strings.HasPrefix(index.Header().Get("Content-Type"), "text/html") {
|
||||
t.Fatalf("index headers = %v", index.Header())
|
||||
}
|
||||
if got := contentType("x.svg"); got != "image/svg+xml" {
|
||||
t.Fatalf("svg type %q", got)
|
||||
}
|
||||
if got := contentType("x.json"); got != "application/json" {
|
||||
t.Fatalf("json type %q", got)
|
||||
}
|
||||
if got := contentType("x.unknown-ext"); got != "application/octet-stream" {
|
||||
t.Fatalf("unknown type %q", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSecurityHeadersOnEveryResponse(t *testing.T) {
|
||||
h, _ := newTestHandler(t)
|
||||
root, err := Dist()
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
entries, err := fs.ReadDir(root, "assets")
|
||||
if err != nil || len(entries) == 0 {
|
||||
t.Fatalf("embedded assets: %v", err)
|
||||
}
|
||||
for _, target := range []string{
|
||||
testPrefix,
|
||||
testPrefix + "/acme/demo/widgets",
|
||||
testPrefix + "/assets/" + entries[0].Name(),
|
||||
testPrefix + "/missing.js",
|
||||
testPrefix + "/api/v1/nope",
|
||||
} {
|
||||
rec := get(h, target)
|
||||
for header, want := range map[string]string{
|
||||
"X-Content-Type-Options": "nosniff",
|
||||
"Referrer-Policy": "same-origin",
|
||||
"X-Frame-Options": "DENY",
|
||||
"Content-Security-Policy": "frame-ancestors 'none'; base-uri 'none'; object-src 'none'; script-src 'self'",
|
||||
"X-Robots-Tag": "noindex, nofollow",
|
||||
} {
|
||||
if got := rec.Header().Get(header); got != want {
|
||||
t.Fatalf("%s %s=%q, want %q", target, header, got, want)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// TestPhase10BoardwalkServing covers the remaining serving branches: HEAD,
|
||||
// query strings, encoded traversal, the index requested by name, a nested
|
||||
// prefix, deep client routes, MIME fallback for unknown extensions and the
|
||||
// constructor's error paths.
|
||||
func TestPhase10BoardwalkServing(t *testing.T) {
|
||||
h, spy := newTestHandler(t)
|
||||
|
||||
t.Run("HEAD answers headers without a body", func(t *testing.T) {
|
||||
for _, target := range []string{testPrefix, testPrefix + "/acme/demo/widgets"} {
|
||||
rec := httptest.NewRecorder()
|
||||
h.ServeHTTP(rec, httptest.NewRequest(http.MethodHead, target, nil))
|
||||
if rec.Code != http.StatusOK || rec.Body.Len() != 0 || !strings.HasPrefix(rec.Header().Get("Content-Type"), "text/html") {
|
||||
t.Fatalf("HEAD %s: status=%d len=%d type=%q", target, rec.Code, rec.Body.Len(), rec.Header().Get("Content-Type"))
|
||||
}
|
||||
if rec.Header().Get("Content-Length") == "" || rec.Header().Get("X-Frame-Options") != "DENY" {
|
||||
t.Fatalf("HEAD %s headers = %v", target, rec.Header())
|
||||
}
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("query strings do not change what is served", func(t *testing.T) {
|
||||
root, err := Dist()
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
entries, err := fs.ReadDir(root, "assets")
|
||||
if err != nil || len(entries) == 0 {
|
||||
t.Fatalf("assets: %v", err)
|
||||
}
|
||||
asset := get(h, testPrefix+"/assets/"+entries[0].Name()+"?v=2")
|
||||
if asset.Code != http.StatusOK || asset.Header().Get("Cache-Control") != "public, max-age=31536000, immutable" {
|
||||
t.Fatalf("asset with query: status=%d headers=%v", asset.Code, asset.Header())
|
||||
}
|
||||
route := get(h, testPrefix+"/acme/demo/widgets?search=blue&page=2")
|
||||
if route.Code != http.StatusOK || !strings.Contains(route.Body.String(), "summer-admin-base") {
|
||||
t.Fatalf("client route with query: status=%d", route.Code)
|
||||
}
|
||||
before := spy.calls
|
||||
if rec := get(h, testPrefix+"/api/v1/nope?x=1"); rec.Code != http.StatusNotFound || spy.calls != before+1 {
|
||||
t.Fatalf("api with query not delegated: %d", rec.Code)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("encoded traversal never escapes the build", func(t *testing.T) {
|
||||
for _, target := range []string{
|
||||
testPrefix + "/%2e%2e/%2e%2e/go.mod",
|
||||
testPrefix + "/assets/..%2f..%2fboardwalk.go",
|
||||
testPrefix + "/%2E%2E%2F%2E%2E%2Fgo.sum",
|
||||
} {
|
||||
rec := get(h, target)
|
||||
body := rec.Body.String()
|
||||
if rec.Code != http.StatusNotFound || strings.Contains(body, "module ") || strings.Contains(body, "package boardwalk") {
|
||||
t.Fatalf("%s status=%d body=%.80s", target, rec.Code, body)
|
||||
}
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("index.html by name is the rewritten index", func(t *testing.T) {
|
||||
byName := get(h, testPrefix+"/index.html")
|
||||
root := get(h, testPrefix+"/")
|
||||
if byName.Code != http.StatusOK || byName.Body.String() != root.Body.String() {
|
||||
t.Fatalf("index.html differs from the root index")
|
||||
}
|
||||
if strings.Contains(byName.Body.String(), BaseToken) || byName.Header().Get("Cache-Control") != "no-store" {
|
||||
t.Fatalf("index.html served raw or cacheable: %v", byName.Header())
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("nested prefix with a trailing slash", func(t *testing.T) {
|
||||
nested, err := Handler("/ops/admin/", &apiSpy{})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
rec := get(nested, "/ops/admin/acme/demo/widgets/12")
|
||||
body := rec.Body.String()
|
||||
if rec.Code != http.StatusOK || !strings.Contains(body, `content="/ops/admin"`) || !strings.Contains(body, `src="/ops/admin/assets/`) {
|
||||
t.Fatalf("nested prefix index: %d %s", rec.Code, body)
|
||||
}
|
||||
if rec := get(nested, "/ops/admin/api/v1/x"); rec.Code != http.StatusNotFound || strings.Contains(rec.Body.String(), "<html") {
|
||||
t.Fatalf("nested prefix api not delegated: %d", rec.Code)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("deep extensionless paths are client routes", func(t *testing.T) {
|
||||
for _, target := range []string{testPrefix + "/a/b/c/d/e/f", testPrefix + "/settings/mail", testPrefix + "/assets"} {
|
||||
rec := get(h, target)
|
||||
if rec.Code != http.StatusOK || !strings.Contains(rec.Body.String(), "summer-admin-base") {
|
||||
t.Fatalf("%s status=%d", target, rec.Code)
|
||||
}
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("unknown extensions fall back to the mime table, then octet-stream", func(t *testing.T) {
|
||||
root := fstest.MapFS{
|
||||
"index.html": &fstest.MapFile{Data: []byte(`<meta content="` + BaseToken + `">`)},
|
||||
"robots.txt": &fstest.MapFile{Data: []byte("User-agent: *\n")},
|
||||
"assets/logo.png": &fstest.MapFile{Data: []byte("\x89PNG")},
|
||||
"assets/blob.zzzext": &fstest.MapFile{Data: []byte("x")},
|
||||
}
|
||||
mapped, err := newHandler(root, testPrefix, &apiSpy{})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
for target, want := range map[string]string{
|
||||
"/robots.txt": "text/plain; charset=utf-8",
|
||||
"/assets/logo.png": "image/png",
|
||||
"/assets/blob.zzzext": "application/octet-stream",
|
||||
} {
|
||||
rec := get(mapped, testPrefix+target)
|
||||
if rec.Code != http.StatusOK || rec.Header().Get("Content-Type") != want {
|
||||
t.Fatalf("%s type=%q, want %q", target, rec.Header().Get("Content-Type"), want)
|
||||
}
|
||||
}
|
||||
if cc := get(mapped, testPrefix+"/robots.txt").Header().Get("Cache-Control"); cc != "no-cache" {
|
||||
t.Fatalf("non-asset file Cache-Control=%q, want no-cache", cc)
|
||||
}
|
||||
if got := contentType("UPPER.JS"); got != "text/javascript; charset=utf-8" {
|
||||
t.Fatalf("extension case: %q", got)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("constructor rejects a nil API handler, a relative prefix and a build without index", func(t *testing.T) {
|
||||
if _, err := Handler(testPrefix, nil); err == nil {
|
||||
t.Fatal("nil notFoundAPI accepted")
|
||||
}
|
||||
if _, err := Handler("backend", &apiSpy{}); err == nil {
|
||||
t.Fatal("relative prefix accepted")
|
||||
}
|
||||
if _, err := newHandler(fstest.MapFS{}, testPrefix, &apiSpy{}); err == nil || !strings.Contains(err.Error(), "index.html") {
|
||||
t.Fatalf("missing index: %v", err)
|
||||
}
|
||||
stale := fstest.MapFS{"index.html": &fstest.MapFile{Data: []byte("<html></html>")}}
|
||||
if _, err := newHandler(stale, testPrefix, &apiSpy{}); err == nil || !strings.Contains(err.Error(), BaseToken) {
|
||||
t.Fatalf("stale index: %v", err)
|
||||
}
|
||||
})
|
||||
}
|
||||
BIN
modules/boardwalk/dist/assets/dm-mono-latin-400-normal--0xN8mdc.woff
vendored
Normal file
BIN
modules/boardwalk/dist/assets/dm-mono-latin-400-normal--0xN8mdc.woff
vendored
Normal file
Binary file not shown.
BIN
modules/boardwalk/dist/assets/dm-mono-latin-400-normal-4GdczIuU.woff2
vendored
Normal file
BIN
modules/boardwalk/dist/assets/dm-mono-latin-400-normal-4GdczIuU.woff2
vendored
Normal file
Binary file not shown.
BIN
modules/boardwalk/dist/assets/dm-mono-latin-500-normal-CN8Miw6E.woff
vendored
Normal file
BIN
modules/boardwalk/dist/assets/dm-mono-latin-500-normal-CN8Miw6E.woff
vendored
Normal file
Binary file not shown.
BIN
modules/boardwalk/dist/assets/dm-mono-latin-500-normal-DRMDZjhP.woff2
vendored
Normal file
BIN
modules/boardwalk/dist/assets/dm-mono-latin-500-normal-DRMDZjhP.woff2
vendored
Normal file
Binary file not shown.
BIN
modules/boardwalk/dist/assets/dm-mono-latin-ext-400-normal-1aZr6b2b.woff
vendored
Normal file
BIN
modules/boardwalk/dist/assets/dm-mono-latin-ext-400-normal-1aZr6b2b.woff
vendored
Normal file
Binary file not shown.
BIN
modules/boardwalk/dist/assets/dm-mono-latin-ext-400-normal-C2zvOubV.woff2
vendored
Normal file
BIN
modules/boardwalk/dist/assets/dm-mono-latin-ext-400-normal-C2zvOubV.woff2
vendored
Normal file
Binary file not shown.
BIN
modules/boardwalk/dist/assets/dm-mono-latin-ext-500-normal-BtRyHRi6.woff2
vendored
Normal file
BIN
modules/boardwalk/dist/assets/dm-mono-latin-ext-500-normal-BtRyHRi6.woff2
vendored
Normal file
Binary file not shown.
BIN
modules/boardwalk/dist/assets/dm-mono-latin-ext-500-normal-Dw3M13d8.woff
vendored
Normal file
BIN
modules/boardwalk/dist/assets/dm-mono-latin-ext-500-normal-Dw3M13d8.woff
vendored
Normal file
Binary file not shown.
BIN
modules/boardwalk/dist/assets/dm-sans-latin-400-normal-BwCSEQnW.woff
vendored
Normal file
BIN
modules/boardwalk/dist/assets/dm-sans-latin-400-normal-BwCSEQnW.woff
vendored
Normal file
Binary file not shown.
BIN
modules/boardwalk/dist/assets/dm-sans-latin-400-normal-CW0RaeGs.woff2
vendored
Normal file
BIN
modules/boardwalk/dist/assets/dm-sans-latin-400-normal-CW0RaeGs.woff2
vendored
Normal file
Binary file not shown.
BIN
modules/boardwalk/dist/assets/dm-sans-latin-500-normal-B9HHJjqV.woff2
vendored
Normal file
BIN
modules/boardwalk/dist/assets/dm-sans-latin-500-normal-B9HHJjqV.woff2
vendored
Normal file
Binary file not shown.
BIN
modules/boardwalk/dist/assets/dm-sans-latin-500-normal-Dr3UlScf.woff
vendored
Normal file
BIN
modules/boardwalk/dist/assets/dm-sans-latin-500-normal-Dr3UlScf.woff
vendored
Normal file
Binary file not shown.
BIN
modules/boardwalk/dist/assets/dm-sans-latin-600-normal-Aqo67rzb.woff2
vendored
Normal file
BIN
modules/boardwalk/dist/assets/dm-sans-latin-600-normal-Aqo67rzb.woff2
vendored
Normal file
Binary file not shown.
BIN
modules/boardwalk/dist/assets/dm-sans-latin-600-normal-BmdmIIQ2.woff
vendored
Normal file
BIN
modules/boardwalk/dist/assets/dm-sans-latin-600-normal-BmdmIIQ2.woff
vendored
Normal file
Binary file not shown.
BIN
modules/boardwalk/dist/assets/dm-sans-latin-700-normal-CUSSCpQX.woff
vendored
Normal file
BIN
modules/boardwalk/dist/assets/dm-sans-latin-700-normal-CUSSCpQX.woff
vendored
Normal file
Binary file not shown.
BIN
modules/boardwalk/dist/assets/dm-sans-latin-700-normal-DvUfVpUG.woff2
vendored
Normal file
BIN
modules/boardwalk/dist/assets/dm-sans-latin-700-normal-DvUfVpUG.woff2
vendored
Normal file
Binary file not shown.
BIN
modules/boardwalk/dist/assets/dm-sans-latin-ext-400-normal-BjWJ59Pq.woff
vendored
Normal file
BIN
modules/boardwalk/dist/assets/dm-sans-latin-ext-400-normal-BjWJ59Pq.woff
vendored
Normal file
Binary file not shown.
BIN
modules/boardwalk/dist/assets/dm-sans-latin-ext-400-normal-BtiwyxMk.woff2
vendored
Normal file
BIN
modules/boardwalk/dist/assets/dm-sans-latin-ext-400-normal-BtiwyxMk.woff2
vendored
Normal file
Binary file not shown.
BIN
modules/boardwalk/dist/assets/dm-sans-latin-ext-500-normal-BJfUCQsA.woff2
vendored
Normal file
BIN
modules/boardwalk/dist/assets/dm-sans-latin-ext-500-normal-BJfUCQsA.woff2
vendored
Normal file
Binary file not shown.
BIN
modules/boardwalk/dist/assets/dm-sans-latin-ext-500-normal-DR84L5F-.woff
vendored
Normal file
BIN
modules/boardwalk/dist/assets/dm-sans-latin-ext-500-normal-DR84L5F-.woff
vendored
Normal file
Binary file not shown.
BIN
modules/boardwalk/dist/assets/dm-sans-latin-ext-600-normal-4vooXBpG.woff2
vendored
Normal file
BIN
modules/boardwalk/dist/assets/dm-sans-latin-ext-600-normal-4vooXBpG.woff2
vendored
Normal file
Binary file not shown.
BIN
modules/boardwalk/dist/assets/dm-sans-latin-ext-600-normal-DRtaDpgU.woff
vendored
Normal file
BIN
modules/boardwalk/dist/assets/dm-sans-latin-ext-600-normal-DRtaDpgU.woff
vendored
Normal file
Binary file not shown.
BIN
modules/boardwalk/dist/assets/dm-sans-latin-ext-700-normal-BLI3TTWz.woff
vendored
Normal file
BIN
modules/boardwalk/dist/assets/dm-sans-latin-ext-700-normal-BLI3TTWz.woff
vendored
Normal file
Binary file not shown.
BIN
modules/boardwalk/dist/assets/dm-sans-latin-ext-700-normal-CJIcxD6K.woff2
vendored
Normal file
BIN
modules/boardwalk/dist/assets/dm-sans-latin-ext-700-normal-CJIcxD6K.woff2
vendored
Normal file
Binary file not shown.
3
modules/boardwalk/dist/assets/index-BAlwlQ8W.js
vendored
Normal file
3
modules/boardwalk/dist/assets/index-BAlwlQ8W.js
vendored
Normal file
File diff suppressed because one or more lines are too long
1
modules/boardwalk/dist/assets/index-CLf0gZ3D.css
vendored
Normal file
1
modules/boardwalk/dist/assets/index-CLf0gZ3D.css
vendored
Normal file
File diff suppressed because one or more lines are too long
15
modules/boardwalk/dist/index.html
vendored
Normal file
15
modules/boardwalk/dist/index.html
vendored
Normal file
@@ -0,0 +1,15 @@
|
||||
<!doctype html>
|
||||
<html lang="pl">
|
||||
<head>
|
||||
<meta charset="UTF-8" />
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
|
||||
<meta name="robots" content="noindex, nofollow" />
|
||||
<meta name="summer-admin-base" content="__SUMMER_ADMIN_BASE__" />
|
||||
<title>SummerCMS</title>
|
||||
<script type="module" crossorigin src="./assets/index-BAlwlQ8W.js"></script>
|
||||
<link rel="stylesheet" crossorigin href="./assets/index-CLf0gZ3D.css">
|
||||
</head>
|
||||
<body>
|
||||
<div id="app"></div>
|
||||
</body>
|
||||
</html>
|
||||
145
modules/bonfire/command.go
Normal file
145
modules/bonfire/command.go
Normal file
@@ -0,0 +1,145 @@
|
||||
package bonfire
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"strings"
|
||||
|
||||
"github.com/spf13/cobra"
|
||||
)
|
||||
|
||||
// ErrCommandName is returned when a plugin command is missing namespace:verb.
|
||||
var ErrCommandName = errors.New("bonfire: plugin command name must be namespace:verb")
|
||||
|
||||
// Command is a console command value collected from plugins or the tool.
|
||||
type Command struct {
|
||||
Name string
|
||||
Description string
|
||||
Flags []Flag
|
||||
Args []Arg
|
||||
Run func(ctx context.Context, in Input, out Output) error
|
||||
}
|
||||
|
||||
// Flag describes a string flag passed to a command.
|
||||
type Flag struct {
|
||||
Name string
|
||||
Shorthand string
|
||||
Description string
|
||||
Default string
|
||||
// Bare allows --flag without a value; cobra stores "true".
|
||||
Bare bool
|
||||
// Repeatable registers this flag as an ordered, multi-occurrence
|
||||
// string flag (Cobra StringSlice) instead of a scalar string flag
|
||||
// (08-CONTEXT.md D-19; 08-PATTERNS.md "bonfire repeatable-flag gap").
|
||||
// Repeated `--name=a --name=b` preserves insertion order and is read
|
||||
// back through Input.Flags, never Input.Flag. Existing scalar/bare
|
||||
// flags are unaffected: Repeatable defaults to false.
|
||||
Repeatable bool
|
||||
}
|
||||
|
||||
// Arg describes a positional argument.
|
||||
type Arg struct {
|
||||
Name string
|
||||
Description string
|
||||
Required bool
|
||||
}
|
||||
|
||||
// Input is the parsed argument and flag view handed to Command.Run.
|
||||
type Input interface {
|
||||
Args() []string
|
||||
Argument(name string) (string, bool)
|
||||
Flag(name string) (string, bool)
|
||||
// Flags returns the ordered, repeated values of a Repeatable flag
|
||||
// (D-19). It returns nil for a scalar/bare flag or an unset repeatable
|
||||
// flag; callers must use Flag for scalar flags.
|
||||
Flags(name string) []string
|
||||
}
|
||||
|
||||
type cobraInput struct {
|
||||
cmd *cobra.Command
|
||||
spec Command
|
||||
args []string
|
||||
}
|
||||
|
||||
func (in cobraInput) Args() []string { return in.args }
|
||||
|
||||
func (in cobraInput) Argument(name string) (string, bool) {
|
||||
for i, arg := range in.spec.Args {
|
||||
if arg.Name == name {
|
||||
if i < len(in.args) {
|
||||
return in.args[i], true
|
||||
}
|
||||
return "", false
|
||||
}
|
||||
}
|
||||
return "", false
|
||||
}
|
||||
|
||||
// Flags returns the ordered values of a Repeatable (Cobra StringSlice)
|
||||
// flag. It returns nil if the flag was never registered as repeatable
|
||||
// (wrong pflag type) or the command has no flag set (08-CONTEXT.md D-19).
|
||||
func (in cobraInput) Flags(name string) []string {
|
||||
if in.cmd == nil || in.cmd.Flags() == nil {
|
||||
return nil
|
||||
}
|
||||
vals, err := in.cmd.Flags().GetStringSlice(name)
|
||||
if err != nil {
|
||||
return nil
|
||||
}
|
||||
return vals
|
||||
}
|
||||
|
||||
func (in cobraInput) Flag(name string) (string, bool) {
|
||||
if in.cmd == nil || in.cmd.Flags() == nil {
|
||||
return "", false
|
||||
}
|
||||
if !in.cmd.Flags().Changed(name) {
|
||||
val, err := in.cmd.Flags().GetString(name)
|
||||
if err != nil || val == "" {
|
||||
return "", false
|
||||
}
|
||||
return val, true
|
||||
}
|
||||
val, err := in.cmd.Flags().GetString(name)
|
||||
if err != nil {
|
||||
return "", false
|
||||
}
|
||||
return val, true
|
||||
}
|
||||
|
||||
func validCommandName(name string) bool {
|
||||
switch name {
|
||||
case "build", "dev", "serve", "migrate":
|
||||
return true
|
||||
}
|
||||
ns, verb, ok := strings.Cut(name, ":")
|
||||
return ok && ns != "" && verb != "" && !strings.Contains(verb, " ")
|
||||
}
|
||||
|
||||
func commandUsage(c Command) string {
|
||||
parts := []string{c.Name}
|
||||
for _, a := range c.Args {
|
||||
if a.Required {
|
||||
parts = append(parts, "<"+a.Name+">")
|
||||
} else {
|
||||
parts = append(parts, "["+a.Name+"]")
|
||||
}
|
||||
}
|
||||
return strings.Join(parts, " ")
|
||||
}
|
||||
|
||||
func positionalArgs(args []Arg) cobra.PositionalArgs {
|
||||
required := 0
|
||||
for _, a := range args {
|
||||
if a.Required {
|
||||
required++
|
||||
}
|
||||
}
|
||||
if required == 0 {
|
||||
return cobra.ArbitraryArgs
|
||||
}
|
||||
if required == len(args) {
|
||||
return cobra.ExactArgs(required)
|
||||
}
|
||||
return cobra.MinimumNArgs(required)
|
||||
}
|
||||
14
modules/bonfire/command_test.go
Normal file
14
modules/bonfire/command_test.go
Normal file
@@ -0,0 +1,14 @@
|
||||
package bonfire
|
||||
|
||||
import (
|
||||
"io"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestValidBareRuntimeCommandNames(t *testing.T) {
|
||||
for _, name := range []string{"serve", "migrate", "migrate:rollback", "migrate:status", "build", "dev"} {
|
||||
if _, err := NewRoot("app", []Command{{Name: name}}, io.Discard); err != nil {
|
||||
t.Fatalf("%s: %v", name, err)
|
||||
}
|
||||
}
|
||||
}
|
||||
170
modules/bonfire/output.go
Normal file
170
modules/bonfire/output.go
Normal file
@@ -0,0 +1,170 @@
|
||||
package bonfire
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"io"
|
||||
"os"
|
||||
|
||||
"golang.org/x/term"
|
||||
)
|
||||
|
||||
const (
|
||||
ansiReset = "\x1b[0m"
|
||||
ansiRed = "\x1b[31m"
|
||||
ansiGreen = "\x1b[32m"
|
||||
ansiYellow = "\x1b[33m"
|
||||
ansiCyan = "\x1b[36m"
|
||||
ansiDim = "\x1b[90m"
|
||||
|
||||
symCheck = "✓"
|
||||
symCross = "✗"
|
||||
symWarn = "⚠"
|
||||
symInfo = "ℹ"
|
||||
symArrow = "→"
|
||||
symPrompt = "?"
|
||||
)
|
||||
|
||||
// Output is the injected console used by commands. Tests supply streams.
|
||||
type Output interface {
|
||||
io.Writer
|
||||
Println(a ...any)
|
||||
Printf(format string, a ...any)
|
||||
Info(message string)
|
||||
Success(message string)
|
||||
Error(message string)
|
||||
Warning(message string)
|
||||
Table(headers []string, rows [][]string)
|
||||
Spinner(message string, fn func() error) error
|
||||
Progress(total int, fn func(Progress) error) error
|
||||
Ask(question, def string) (string, error)
|
||||
Confirm(question string, def bool) (bool, error)
|
||||
Choice(question string, choices []string, def int) (string, error)
|
||||
Secret(question string) (string, error)
|
||||
}
|
||||
|
||||
// Progress is a single progress bar advanced from a command.
|
||||
type Progress interface {
|
||||
Advance(step int)
|
||||
}
|
||||
|
||||
type console struct {
|
||||
in io.Reader
|
||||
out io.Writer
|
||||
err io.Writer
|
||||
lookup func(string) string
|
||||
tty bool
|
||||
interactive bool
|
||||
color bool
|
||||
}
|
||||
|
||||
// NewOutput builds Output from injected streams and the process color policy.
|
||||
func NewOutput(in io.Reader, out, errW io.Writer) Output {
|
||||
return newConsole(in, out, errW, os.Getenv, nil, nil)
|
||||
}
|
||||
|
||||
func newConsole(in io.Reader, out, errW io.Writer, lookup func(string) string, tty, interactive *bool) *console {
|
||||
if in == nil {
|
||||
in = os.Stdin
|
||||
}
|
||||
if out == nil {
|
||||
out = os.Stdout
|
||||
}
|
||||
if errW == nil {
|
||||
errW = out
|
||||
}
|
||||
if lookup == nil {
|
||||
lookup = os.Getenv
|
||||
}
|
||||
c := &console{in: in, out: out, err: errW, lookup: lookup}
|
||||
if tty != nil {
|
||||
c.tty = *tty
|
||||
} else {
|
||||
c.tty = isTerminal(out)
|
||||
}
|
||||
if interactive != nil {
|
||||
c.interactive = *interactive
|
||||
} else {
|
||||
c.interactive = isTerminal(in) && c.tty
|
||||
}
|
||||
c.color = supportsColor(lookup, c.tty)
|
||||
return c
|
||||
}
|
||||
|
||||
func supportsColor(lookup func(string) string, tty bool) bool {
|
||||
if lookup == nil {
|
||||
lookup = os.Getenv
|
||||
}
|
||||
if lookup("NO_COLOR") != "" || lookup("TERM") == "dumb" {
|
||||
return false
|
||||
}
|
||||
if lookup("FORCE_COLOR") != "" {
|
||||
return true
|
||||
}
|
||||
return tty
|
||||
}
|
||||
|
||||
func isTerminal(rw any) bool {
|
||||
type fd interface{ Fd() uintptr }
|
||||
f, ok := rw.(fd)
|
||||
if !ok {
|
||||
return false
|
||||
}
|
||||
return term.IsTerminal(int(f.Fd()))
|
||||
}
|
||||
|
||||
func (c *console) Write(p []byte) (int, error) {
|
||||
if c.out == nil {
|
||||
return 0, io.ErrClosedPipe
|
||||
}
|
||||
return c.out.Write(p)
|
||||
}
|
||||
|
||||
func (c *console) Println(a ...any) {
|
||||
if c.out == nil {
|
||||
return
|
||||
}
|
||||
fmt.Fprintln(c.out, a...)
|
||||
}
|
||||
|
||||
func (c *console) Printf(format string, a ...any) {
|
||||
if c.out == nil {
|
||||
return
|
||||
}
|
||||
fmt.Fprintf(c.out, format, a...)
|
||||
}
|
||||
|
||||
func (c *console) Info(message string) {
|
||||
c.Println(c.style(ansiCyan, symInfo) + " " + message)
|
||||
}
|
||||
|
||||
func (c *console) Success(message string) {
|
||||
c.Println(c.style(ansiGreen, symCheck) + " " + message)
|
||||
}
|
||||
|
||||
func (c *console) Error(message string) {
|
||||
w := c.err
|
||||
if w == nil {
|
||||
w = c.out
|
||||
}
|
||||
if w == nil {
|
||||
return
|
||||
}
|
||||
fmt.Fprintln(w, c.style(ansiRed, symCross)+" "+message)
|
||||
}
|
||||
|
||||
func (c *console) Warning(message string) {
|
||||
c.Println(c.style(ansiYellow, symWarn) + " " + message)
|
||||
}
|
||||
|
||||
func (c *console) style(code, s string) string {
|
||||
if !c.color {
|
||||
return s
|
||||
}
|
||||
return code + s + ansiReset
|
||||
}
|
||||
|
||||
func (c *console) dim(s string) string {
|
||||
return c.style(ansiDim, s)
|
||||
}
|
||||
|
||||
func boolPtr(v bool) *bool { return &v }
|
||||
389
modules/bonfire/output_test.go
Normal file
389
modules/bonfire/output_test.go
Normal file
@@ -0,0 +1,389 @@
|
||||
package bonfire
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"errors"
|
||||
"slices"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestNonTTYSpinner(t *testing.T) {
|
||||
var buf bytes.Buffer
|
||||
out := NewOutput(strings.NewReader(""), &buf, &buf)
|
||||
if err := out.Spinner("building", func() error { return nil }); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if got := buf.String(); got != "[...] building\n" {
|
||||
t.Fatalf("spinner = %q", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestNonTTYProgress(t *testing.T) {
|
||||
var buf bytes.Buffer
|
||||
out := NewOutput(strings.NewReader(""), &buf, &buf)
|
||||
if err := out.Progress(10, func(p Progress) error {
|
||||
for i := 0; i < 10; i++ {
|
||||
p.Advance(1)
|
||||
}
|
||||
return nil
|
||||
}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
got := buf.String()
|
||||
for _, want := range []string{"[1/10] 10%", "[5/10] 50%", "[10/10] 100%"} {
|
||||
if !strings.Contains(got, want) {
|
||||
t.Fatalf("missing %q in %q", want, got)
|
||||
}
|
||||
}
|
||||
if strings.Contains(got, "\x1b[") {
|
||||
t.Fatalf("non-tty progress has ansi: %q", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestNonTTYTable(t *testing.T) {
|
||||
var buf bytes.Buffer
|
||||
out := NewOutput(strings.NewReader(""), &buf, &buf)
|
||||
out.Table([]string{"plugin", "status"}, [][]string{{"golem15.blog", "active"}})
|
||||
got := buf.String()
|
||||
if got != "plugin\tstatus\ngolem15.blog\tactive\n" {
|
||||
t.Fatalf("table = %q", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestColorPolicy(t *testing.T) {
|
||||
t.Run("NO_COLOR", func(t *testing.T) {
|
||||
var buf bytes.Buffer
|
||||
out := newConsole(strings.NewReader(""), &buf, &buf, func(k string) string {
|
||||
if k == "NO_COLOR" {
|
||||
return "1"
|
||||
}
|
||||
if k == "FORCE_COLOR" {
|
||||
return "1"
|
||||
}
|
||||
return ""
|
||||
}, boolPtr(true), boolPtr(true))
|
||||
out.Success("ok")
|
||||
if strings.Contains(buf.String(), "\x1b[") {
|
||||
t.Fatalf("NO_COLOR leaked ansi: %q", buf.String())
|
||||
}
|
||||
})
|
||||
t.Run("TERM=dumb", func(t *testing.T) {
|
||||
var buf bytes.Buffer
|
||||
out := newConsole(strings.NewReader(""), &buf, &buf, func(k string) string {
|
||||
if k == "TERM" {
|
||||
return "dumb"
|
||||
}
|
||||
if k == "FORCE_COLOR" {
|
||||
return "1"
|
||||
}
|
||||
return ""
|
||||
}, boolPtr(true), boolPtr(true))
|
||||
out.Info("hi")
|
||||
if strings.Contains(buf.String(), "\x1b[") {
|
||||
t.Fatalf("TERM=dumb leaked ansi: %q", buf.String())
|
||||
}
|
||||
})
|
||||
t.Run("FORCE_COLOR", func(t *testing.T) {
|
||||
var buf bytes.Buffer
|
||||
out := newConsole(strings.NewReader(""), &buf, &buf, func(k string) string {
|
||||
if k == "FORCE_COLOR" {
|
||||
return "1"
|
||||
}
|
||||
return ""
|
||||
}, boolPtr(false), boolPtr(false))
|
||||
out.Success("ok")
|
||||
if !strings.Contains(buf.String(), "\x1b[") {
|
||||
t.Fatalf("FORCE_COLOR did not enable ansi: %q", buf.String())
|
||||
}
|
||||
})
|
||||
t.Run("default non-tty", func(t *testing.T) {
|
||||
var buf bytes.Buffer
|
||||
out := NewOutput(strings.NewReader(""), &buf, &buf)
|
||||
out.Success("ok")
|
||||
if strings.Contains(buf.String(), "\x1b[") {
|
||||
t.Fatalf("non-tty default has ansi: %q", buf.String())
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func TestPluginCommandRequiresColon(t *testing.T) {
|
||||
var buf bytes.Buffer
|
||||
_, err := NewRoot("app", []Command{{Name: "hello", Description: "bad"}}, &buf)
|
||||
if err == nil || !errors.Is(err, ErrCommandName) {
|
||||
t.Fatalf("want ErrCommandName, got %v", err)
|
||||
}
|
||||
if !strings.Contains(err.Error(), "hello") {
|
||||
t.Fatalf("error should name the command: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestKernelAndNamespacedCommands(t *testing.T) {
|
||||
var buf bytes.Buffer
|
||||
root, err := NewRoot("summer", []Command{
|
||||
{Name: "build", Description: "Build the app"},
|
||||
{Name: "dev", Description: "Watch and rebuild"},
|
||||
{Name: "make:plugin", Description: "Scaffold a plugin from a vendor.plugin id"},
|
||||
{Name: "greeter:hello", Description: "Say hello"},
|
||||
}, &buf)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
root.SetArgs([]string{"make:plugin", "--help"})
|
||||
if err := root.Execute(); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if !strings.Contains(buf.String(), "vendor.plugin") && !strings.Contains(buf.String(), "make:plugin") {
|
||||
t.Fatalf("help = %q", buf.String())
|
||||
}
|
||||
}
|
||||
|
||||
func TestFlagAndArgumentParsing(t *testing.T) {
|
||||
var buf bytes.Buffer
|
||||
var gotArgs []string
|
||||
var gotTarget, gotMode, gotUnset string
|
||||
var gotTargetOK, gotModeOK, gotUnsetOK bool
|
||||
root, err := NewRootIO("app", []Command{{
|
||||
Name: "demo:run",
|
||||
Description: "Run a demo",
|
||||
Args: []Arg{
|
||||
{Name: "target", Description: "who", Required: true},
|
||||
{Name: "extra", Description: "optional"},
|
||||
},
|
||||
Flags: []Flag{
|
||||
{Name: "mode", Shorthand: "m", Default: "slow", Description: "speed"},
|
||||
{Name: "unused", Default: "", Description: "empty default"},
|
||||
},
|
||||
Run: func(ctx context.Context, in Input, out Output) error {
|
||||
gotArgs = append([]string(nil), in.Args()...)
|
||||
gotTarget, gotTargetOK = in.Argument("target")
|
||||
gotMode, gotModeOK = in.Flag("mode")
|
||||
gotUnset, gotUnsetOK = in.Flag("unused")
|
||||
out.Println("ran " + gotTarget)
|
||||
return nil
|
||||
},
|
||||
}}, strings.NewReader(""), &buf, &buf)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
root.SetArgs([]string{"demo:run", "-m", "fast", "world"})
|
||||
if err := root.Execute(); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if !strings.Contains(buf.String(), "ran world") {
|
||||
t.Fatalf("captured output = %q", buf.String())
|
||||
}
|
||||
if strings.Join(gotArgs, ",") != "world" {
|
||||
t.Fatalf("Args = %v", gotArgs)
|
||||
}
|
||||
if !gotTargetOK || gotTarget != "world" {
|
||||
t.Fatalf("Argument(target) = (%q, %v)", gotTarget, gotTargetOK)
|
||||
}
|
||||
if !gotModeOK || gotMode != "fast" {
|
||||
t.Fatalf("Flag(mode) = (%q, %v)", gotMode, gotModeOK)
|
||||
}
|
||||
if gotUnsetOK || gotUnset != "" {
|
||||
t.Fatalf("unset flag = (%q, %v)", gotUnset, gotUnsetOK)
|
||||
}
|
||||
}
|
||||
|
||||
func TestInjectedOutputCapture(t *testing.T) {
|
||||
var stdout, stderr bytes.Buffer
|
||||
out := NewOutput(strings.NewReader(""), &stdout, &stderr)
|
||||
out.Info("heads up")
|
||||
out.Success("done")
|
||||
out.Warning("careful")
|
||||
out.Error("boom")
|
||||
out.Printf("plain %s\n", "line")
|
||||
if !strings.Contains(stdout.String(), "heads up") || !strings.Contains(stdout.String(), "done") || !strings.Contains(stdout.String(), "careful") {
|
||||
t.Fatalf("stdout = %q", stdout.String())
|
||||
}
|
||||
if !strings.Contains(stdout.String(), "plain line") {
|
||||
t.Fatalf("Printf missing from stdout: %q", stdout.String())
|
||||
}
|
||||
if !strings.Contains(stderr.String(), "boom") {
|
||||
t.Fatalf("Error should go to stderr, got %q", stderr.String())
|
||||
}
|
||||
if strings.Contains(stdout.String(), "boom") {
|
||||
t.Fatalf("Error leaked to stdout: %q", stdout.String())
|
||||
}
|
||||
if strings.Contains(stdout.String()+stderr.String(), "\x1b[") {
|
||||
t.Fatalf("non-tty messages have ansi: stdout=%q stderr=%q", stdout.String(), stderr.String())
|
||||
}
|
||||
}
|
||||
|
||||
func TestNonTTYSpinnerError(t *testing.T) {
|
||||
var buf bytes.Buffer
|
||||
out := NewOutput(strings.NewReader(""), &buf, &buf)
|
||||
err := out.Spinner("building", func() error { return errors.New("compile failed") })
|
||||
if err == nil || err.Error() != "compile failed" {
|
||||
t.Fatalf("spinner err = %v", err)
|
||||
}
|
||||
if got := buf.String(); got != "[...] building\n" {
|
||||
t.Fatalf("spinner = %q", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestNonTTYProgressSkipsIntraDecile(t *testing.T) {
|
||||
var buf bytes.Buffer
|
||||
out := NewOutput(strings.NewReader(""), &buf, &buf)
|
||||
if err := out.Progress(20, func(p Progress) error {
|
||||
p.Advance(1) // 5%
|
||||
p.Advance(1) // 10%
|
||||
p.Advance(1) // 15%
|
||||
return nil
|
||||
}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
got := buf.String()
|
||||
if !strings.Contains(got, "[2/20] 10%") {
|
||||
t.Fatalf("missing 10%% step in %q", got)
|
||||
}
|
||||
if strings.Contains(got, "[1/20]") || strings.Contains(got, "[3/20]") {
|
||||
t.Fatalf("intra-decile progress leaked: %q", got)
|
||||
}
|
||||
}
|
||||
|
||||
// TestPhase8RedBonfireFlags is the Phase 8 Wave 7 RED anchor (08-07-PLAN.md
|
||||
// Task 1, D-19). bonfire.Flag/Input are scalar-only today
|
||||
// (08-PATTERNS.md "bonfire repeatable-flag gap"): a Repeatable flag
|
||||
// registered through Command.Flags must preserve every repeated
|
||||
// `--name=value` occurrence in order via Input.Flags, while an ordinary
|
||||
// scalar flag declared alongside it keeps working through Input.Flag
|
||||
// unmodified. It fails with the PHASE8_RED:bonfire-flags sentinel while
|
||||
// Repeatable is not yet wired into Cobra registration;
|
||||
// scripts/check-phase8-red.sh verifies this failure is fail-closed.
|
||||
func TestPhase8RedBonfireFlags(t *testing.T) {
|
||||
var buf bytes.Buffer
|
||||
var gotRedirect, gotScope []string
|
||||
var gotMode string
|
||||
var gotModeOK bool
|
||||
root, err := NewRootIO("app", []Command{{
|
||||
Name: "demo:repeat",
|
||||
Description: "Demo repeatable flags",
|
||||
Flags: []Flag{
|
||||
{Name: "redirect-uri", Repeatable: true, Description: "repeatable redirect URI"},
|
||||
{Name: "scope", Repeatable: true, Description: "repeatable scope"},
|
||||
{Name: "mode", Default: "slow", Description: "scalar, unaffected by D-19"},
|
||||
},
|
||||
Run: func(ctx context.Context, in Input, out Output) error {
|
||||
gotRedirect = in.Flags("redirect-uri")
|
||||
gotScope = in.Flags("scope")
|
||||
gotMode, gotModeOK = in.Flag("mode")
|
||||
return nil
|
||||
},
|
||||
}}, strings.NewReader(""), &buf, &buf)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
root.SetArgs([]string{
|
||||
"demo:repeat",
|
||||
"--redirect-uri=https://a.example/callback",
|
||||
"--redirect-uri=https://b.example/callback",
|
||||
"--scope=read",
|
||||
"--mode=fast",
|
||||
})
|
||||
if err := root.Execute(); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
wantRedirect := []string{"https://a.example/callback", "https://b.example/callback"}
|
||||
if !slices.Equal(gotRedirect, wantRedirect) {
|
||||
t.Fatalf("PHASE8_RED:bonfire-flags: repeated --redirect-uri via Input.Flags = %v, want %v in insertion order", gotRedirect, wantRedirect)
|
||||
}
|
||||
if !slices.Equal(gotScope, []string{"read"}) {
|
||||
t.Fatalf("PHASE8_RED:bonfire-flags: repeated --scope via Input.Flags = %v, want [read]", gotScope)
|
||||
}
|
||||
if !gotModeOK || gotMode != "fast" {
|
||||
t.Fatalf("PHASE8_RED:bonfire-flags: existing scalar --mode via Input.Flag = (%q, %v), want (\"fast\", true) unaffected by Repeatable", gotMode, gotModeOK)
|
||||
}
|
||||
}
|
||||
|
||||
// TestRepeatableFlagUnsetReturnsEmpty proves an unset Repeatable flag comes
|
||||
// back as an empty/nil slice, not an error or a panic (D-19 GREEN
|
||||
// companion to TestPhase8RedBonfireFlags).
|
||||
func TestRepeatableFlagUnsetReturnsEmpty(t *testing.T) {
|
||||
var buf bytes.Buffer
|
||||
var got []string
|
||||
root, err := NewRootIO("app", []Command{{
|
||||
Name: "demo:unset",
|
||||
Flags: []Flag{
|
||||
{Name: "scope", Repeatable: true},
|
||||
},
|
||||
Run: func(ctx context.Context, in Input, out Output) error {
|
||||
got = in.Flags("scope")
|
||||
return nil
|
||||
},
|
||||
}}, strings.NewReader(""), &buf, &buf)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
root.SetArgs([]string{"demo:unset"})
|
||||
if err := root.Execute(); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if len(got) != 0 {
|
||||
t.Fatalf("unset repeatable flag = %v, want empty", got)
|
||||
}
|
||||
}
|
||||
|
||||
// TestRepeatableFlagCoexistsWithBareAndScalar proves a Repeatable flag,
|
||||
// a Bare flag and a scalar flag on the same command parse independently
|
||||
// (D-19 acceptance criteria: existing scalar/bare callers stay unaffected).
|
||||
func TestRepeatableFlagCoexistsWithBareAndScalar(t *testing.T) {
|
||||
var buf bytes.Buffer
|
||||
var gotRedirect []string
|
||||
var gotList, gotListOK bool
|
||||
var gotName string
|
||||
root, err := NewRootIO("app", []Command{{
|
||||
Name: "demo:mixed",
|
||||
Flags: []Flag{
|
||||
{Name: "redirect-uri", Repeatable: true},
|
||||
{Name: "list", Bare: true},
|
||||
{Name: "name", Default: ""},
|
||||
},
|
||||
Run: func(ctx context.Context, in Input, out Output) error {
|
||||
gotRedirect = in.Flags("redirect-uri")
|
||||
listVal, ok := in.Flag("list")
|
||||
gotList, gotListOK = listVal == "true", ok
|
||||
gotName, _ = in.Flag("name")
|
||||
return nil
|
||||
},
|
||||
}}, strings.NewReader(""), &buf, &buf)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
root.SetArgs([]string{"demo:mixed", "--redirect-uri=https://x.example", "--list", "--name=Catalog"})
|
||||
if err := root.Execute(); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if !slices.Equal(gotRedirect, []string{"https://x.example"}) {
|
||||
t.Fatalf("redirect-uri = %v", gotRedirect)
|
||||
}
|
||||
if !gotListOK || !gotList {
|
||||
t.Fatalf("list = (%v, %v), want (true, true)", gotList, gotListOK)
|
||||
}
|
||||
if gotName != "Catalog" {
|
||||
t.Fatalf("name = %q", gotName)
|
||||
}
|
||||
}
|
||||
|
||||
func TestHelpUsesSharedAdapter(t *testing.T) {
|
||||
var buf bytes.Buffer
|
||||
root, err := NewRoot("hello", []Command{{
|
||||
Name: "greeter:hello",
|
||||
Description: "Print the configured application name",
|
||||
}}, &buf)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
root.SetArgs([]string{"greeter:hello", "--help"})
|
||||
if err := root.Execute(); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
got := buf.String()
|
||||
if !strings.Contains(got, "greeter:hello") || !strings.Contains(got, "Print the configured application name") {
|
||||
t.Fatalf("help = %q", got)
|
||||
}
|
||||
}
|
||||
133
modules/bonfire/prompts.go
Normal file
133
modules/bonfire/prompts.go
Normal file
@@ -0,0 +1,133 @@
|
||||
package bonfire
|
||||
|
||||
import (
|
||||
"bufio"
|
||||
"fmt"
|
||||
"io"
|
||||
"os"
|
||||
"strconv"
|
||||
"strings"
|
||||
|
||||
"golang.org/x/term"
|
||||
)
|
||||
|
||||
func (c *console) Ask(question, def string) (string, error) {
|
||||
c.writeQuestion(question, def)
|
||||
line, err := c.readLine()
|
||||
if err != nil {
|
||||
if err == io.EOF {
|
||||
return def, nil
|
||||
}
|
||||
return "", err
|
||||
}
|
||||
if line == "" {
|
||||
return def, nil
|
||||
}
|
||||
return line, nil
|
||||
}
|
||||
|
||||
func (c *console) Confirm(question string, def bool) (bool, error) {
|
||||
if !c.interactive {
|
||||
return def, nil
|
||||
}
|
||||
hint := "y/N"
|
||||
if def {
|
||||
hint = "Y/n"
|
||||
}
|
||||
line, err := c.Ask(question+" ["+hint+"]", "")
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
if line == "" {
|
||||
return def, nil
|
||||
}
|
||||
switch strings.ToLower(line) {
|
||||
case "y", "yes":
|
||||
return true, nil
|
||||
case "n", "no":
|
||||
return false, nil
|
||||
default:
|
||||
return def, nil
|
||||
}
|
||||
}
|
||||
|
||||
func (c *console) Choice(question string, choices []string, def int) (string, error) {
|
||||
if len(choices) == 0 {
|
||||
return "", fmt.Errorf("bonfire: choice has no options")
|
||||
}
|
||||
if def < 0 || def >= len(choices) {
|
||||
def = 0
|
||||
}
|
||||
c.Println(c.style(ansiCyan, symPrompt) + " " + question)
|
||||
for i, choice := range choices {
|
||||
mark := " "
|
||||
if i == def {
|
||||
mark = "*"
|
||||
}
|
||||
c.Printf(" %s %d) %s\n", mark, i+1, choice)
|
||||
}
|
||||
line, err := c.readLine()
|
||||
if err != nil {
|
||||
if err == io.EOF {
|
||||
return choices[def], nil
|
||||
}
|
||||
return "", err
|
||||
}
|
||||
if line == "" {
|
||||
return choices[def], nil
|
||||
}
|
||||
n, convErr := strconv.Atoi(line)
|
||||
if convErr != nil || n < 1 || n > len(choices) {
|
||||
return choices[def], nil
|
||||
}
|
||||
return choices[n-1], nil
|
||||
}
|
||||
|
||||
// Secret reads a hidden password on a TTY via term.ReadPassword.
|
||||
// When stdin is not a terminal it reads a plain line and never logs the value.
|
||||
func (c *console) Secret(question string) (string, error) {
|
||||
c.writeQuestion(question, "")
|
||||
if f, ok := c.in.(*os.File); ok && term.IsTerminal(int(f.Fd())) {
|
||||
b, err := term.ReadPassword(int(f.Fd()))
|
||||
c.Println()
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
return string(b), nil
|
||||
}
|
||||
line, err := c.readLine()
|
||||
if err != nil {
|
||||
if err == io.EOF {
|
||||
return "", nil
|
||||
}
|
||||
return "", err
|
||||
}
|
||||
return line, nil
|
||||
}
|
||||
|
||||
func (c *console) writeQuestion(question, def string) {
|
||||
suffix := ""
|
||||
if def != "" {
|
||||
suffix = " " + c.dim("("+def+")")
|
||||
}
|
||||
c.Printf("%s %s%s %s ", c.style(ansiCyan, symPrompt), question, suffix, symArrow)
|
||||
}
|
||||
|
||||
func (c *console) readLine() (string, error) {
|
||||
if c.in == nil {
|
||||
return "", io.EOF
|
||||
}
|
||||
reader, ok := c.in.(*bufio.Reader)
|
||||
if !ok {
|
||||
reader = bufio.NewReader(c.in)
|
||||
}
|
||||
line, err := reader.ReadString('\n')
|
||||
line = strings.TrimRight(line, "\r\n")
|
||||
if err != nil && err != io.EOF {
|
||||
return "", err
|
||||
}
|
||||
if err == io.EOF && line == "" {
|
||||
return "", io.EOF
|
||||
}
|
||||
return strings.TrimSpace(line), nil
|
||||
}
|
||||
146
modules/bonfire/prompts_test.go
Normal file
146
modules/bonfire/prompts_test.go
Normal file
@@ -0,0 +1,146 @@
|
||||
package bonfire
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"errors"
|
||||
"io"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestConfirmUsesDefaultWhenNonTTY(t *testing.T) {
|
||||
var buf bytes.Buffer
|
||||
out := NewOutput(strings.NewReader("n\n"), &buf, &buf)
|
||||
got, err := out.Confirm("continue?", true)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if !got {
|
||||
t.Fatal("non-tty confirm should use default true without reading stdin")
|
||||
}
|
||||
if buf.Len() != 0 {
|
||||
t.Fatalf("confirm wrote %q", buf.String())
|
||||
}
|
||||
}
|
||||
|
||||
func TestAskReadsStdinLine(t *testing.T) {
|
||||
var buf bytes.Buffer
|
||||
out := NewOutput(strings.NewReader("alice\n"), &buf, &buf)
|
||||
got, err := out.Ask("name", "bob")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if got != "alice" {
|
||||
t.Fatalf("ask = %q", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAskEOFUsesDefault(t *testing.T) {
|
||||
var buf bytes.Buffer
|
||||
out := NewOutput(strings.NewReader(""), &buf, &buf)
|
||||
got, err := out.Ask("name", "bob")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if got != "bob" {
|
||||
t.Fatalf("ask eof = %q", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestChoiceReadsStdinLine(t *testing.T) {
|
||||
var buf bytes.Buffer
|
||||
out := NewOutput(strings.NewReader("2\n"), &buf, &buf)
|
||||
got, err := out.Choice("pick", []string{"a", "b", "c"}, 0)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if got != "b" {
|
||||
t.Fatalf("choice = %q", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSecretReadsPlainStdinLine(t *testing.T) {
|
||||
var buf bytes.Buffer
|
||||
out := NewOutput(strings.NewReader("s3cret\n"), &buf, &buf)
|
||||
got, err := out.Secret("token")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if got != "s3cret" {
|
||||
t.Fatalf("secret = %q", got)
|
||||
}
|
||||
if strings.Contains(buf.String(), "s3cret") {
|
||||
t.Fatal("secret value was written to output")
|
||||
}
|
||||
}
|
||||
|
||||
func TestChoiceEOFUsesDefault(t *testing.T) {
|
||||
var buf bytes.Buffer
|
||||
out := NewOutput(strings.NewReader(""), &buf, &buf)
|
||||
got, err := out.Choice("pick", []string{"a", "b", "c"}, 2)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if got != "c" {
|
||||
t.Fatalf("choice eof = %q", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestChoiceEmptyOptionsError(t *testing.T) {
|
||||
var buf bytes.Buffer
|
||||
out := NewOutput(strings.NewReader("1\n"), &buf, &buf)
|
||||
_, err := out.Choice("pick", nil, 0)
|
||||
if err == nil {
|
||||
t.Fatal("expected empty choice error")
|
||||
}
|
||||
}
|
||||
|
||||
func TestSecretNotLeakedOnCommandError(t *testing.T) {
|
||||
var stdout, stderr bytes.Buffer
|
||||
root, err := NewRootIO("app", []Command{{
|
||||
Name: "auth:login",
|
||||
Description: "login",
|
||||
Run: func(ctx context.Context, in Input, out Output) error {
|
||||
secret, err := out.Secret("token")
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if secret == "" {
|
||||
return errors.New("empty token")
|
||||
}
|
||||
out.Error("login failed")
|
||||
return errors.New("login failed")
|
||||
},
|
||||
}}, strings.NewReader("s3cret\n"), &stdout, &stderr)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
root.SetArgs([]string{"auth:login"})
|
||||
runErr := root.Execute()
|
||||
if runErr == nil {
|
||||
t.Fatal("expected command error")
|
||||
}
|
||||
combined := stdout.String() + stderr.String() + runErr.Error()
|
||||
if strings.Contains(combined, "s3cret") {
|
||||
t.Fatalf("secret leaked into streams: stdout=%q stderr=%q err=%v", stdout.String(), stderr.String(), runErr)
|
||||
}
|
||||
}
|
||||
|
||||
func TestClosedStdinDoesNotHang(t *testing.T) {
|
||||
var buf bytes.Buffer
|
||||
out := NewOutput(io.NopCloser(strings.NewReader("")), &buf, &buf)
|
||||
if _, err := out.Ask("name", "def"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
ok, err := out.Confirm("ok?", false)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if ok {
|
||||
t.Fatal("confirm default false")
|
||||
}
|
||||
if _, err := out.Secret("pw"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
94
modules/bonfire/root.go
Normal file
94
modules/bonfire/root.go
Normal file
@@ -0,0 +1,94 @@
|
||||
package bonfire
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"io"
|
||||
"os"
|
||||
|
||||
"github.com/spf13/cobra"
|
||||
)
|
||||
|
||||
// NewRoot builds the shared cobra root used by the summer tool and app binaries.
|
||||
// It accepts command values rather than a party registry to avoid an import cycle.
|
||||
func NewRoot(name string, commands []Command, out io.Writer) (*cobra.Command, error) {
|
||||
return NewRootIO(name, commands, os.Stdin, out, out)
|
||||
}
|
||||
|
||||
// NewRootIO is NewRoot with injected stdin/stdout/stderr for tests.
|
||||
func NewRootIO(name string, commands []Command, in io.Reader, out, errW io.Writer) (*cobra.Command, error) {
|
||||
if out == nil {
|
||||
out = os.Stdout
|
||||
}
|
||||
if errW == nil {
|
||||
errW = out
|
||||
}
|
||||
if in == nil {
|
||||
in = os.Stdin
|
||||
}
|
||||
output := NewOutput(in, out, errW)
|
||||
root := &cobra.Command{
|
||||
Use: name,
|
||||
SilenceUsage: true,
|
||||
SilenceErrors: true,
|
||||
CompletionOptions: cobra.CompletionOptions{
|
||||
DisableDefaultCmd: true,
|
||||
},
|
||||
}
|
||||
root.SetIn(in)
|
||||
root.SetOut(out)
|
||||
root.SetErr(errW)
|
||||
for _, command := range commands {
|
||||
cmd, err := wrap(command, output)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
root.AddCommand(cmd)
|
||||
}
|
||||
return root, nil
|
||||
}
|
||||
|
||||
func wrap(c Command, out Output) (*cobra.Command, error) {
|
||||
if !validCommandName(c.Name) {
|
||||
return nil, fmt.Errorf("%w: %q", ErrCommandName, c.Name)
|
||||
}
|
||||
cmd := &cobra.Command{
|
||||
Use: commandUsage(c),
|
||||
Short: c.Description,
|
||||
Args: positionalArgs(c.Args),
|
||||
RunE: func(cmd *cobra.Command, args []string) error {
|
||||
if c.Run == nil {
|
||||
return nil
|
||||
}
|
||||
return c.Run(cmd.Context(), cobraInput{cmd: cmd, spec: c, args: args}, out)
|
||||
},
|
||||
}
|
||||
for _, flag := range c.Flags {
|
||||
if flag.Repeatable {
|
||||
// D-19: an ordered, multi-occurrence string flag (Cobra
|
||||
// StringSlice), read back through Input.Flags. Default is a
|
||||
// single-element slice only when non-empty, matching the
|
||||
// scalar path's zero-value convention.
|
||||
var def []string
|
||||
if flag.Default != "" {
|
||||
def = []string{flag.Default}
|
||||
}
|
||||
if flag.Shorthand != "" {
|
||||
cmd.Flags().StringSliceP(flag.Name, flag.Shorthand, def, flag.Description)
|
||||
} else {
|
||||
cmd.Flags().StringSlice(flag.Name, def, flag.Description)
|
||||
}
|
||||
continue
|
||||
}
|
||||
if flag.Shorthand != "" {
|
||||
cmd.Flags().StringP(flag.Name, flag.Shorthand, flag.Default, flag.Description)
|
||||
} else {
|
||||
cmd.Flags().String(flag.Name, flag.Default, flag.Description)
|
||||
}
|
||||
if flag.Bare {
|
||||
if f := cmd.Flags().Lookup(flag.Name); f != nil {
|
||||
f.NoOptDefVal = "true"
|
||||
}
|
||||
}
|
||||
}
|
||||
return cmd, nil
|
||||
}
|
||||
210
modules/bonfire/widgets.go
Normal file
210
modules/bonfire/widgets.go
Normal file
@@ -0,0 +1,210 @@
|
||||
package bonfire
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"strings"
|
||||
"sync"
|
||||
"time"
|
||||
"unicode/utf8"
|
||||
)
|
||||
|
||||
var spinnerFrames = []rune{'⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'}
|
||||
|
||||
const (
|
||||
boxTopLeft = "┌"
|
||||
boxTopRight = "┐"
|
||||
boxBottomLeft = "└"
|
||||
boxBottomRight = "┘"
|
||||
boxHorizontal = "─"
|
||||
boxVertical = "│"
|
||||
boxTeeRight = "├"
|
||||
boxTeeLeft = "┤"
|
||||
boxTeeDown = "┬"
|
||||
boxTeeUp = "┴"
|
||||
boxCross = "┼"
|
||||
)
|
||||
|
||||
func (c *console) Spinner(message string, fn func() error) error {
|
||||
if fn == nil {
|
||||
fn = func() error { return nil }
|
||||
}
|
||||
if !c.tty {
|
||||
c.Printf("[...] %s\n", message)
|
||||
return fn()
|
||||
}
|
||||
|
||||
done := make(chan struct{})
|
||||
var wg sync.WaitGroup
|
||||
wg.Add(1)
|
||||
go func() {
|
||||
defer wg.Done()
|
||||
i := 0
|
||||
ticker := time.NewTicker(80 * time.Millisecond)
|
||||
defer ticker.Stop()
|
||||
c.Printf("\r%s %s", c.style(ansiCyan, string(spinnerFrames[0])), message)
|
||||
for {
|
||||
select {
|
||||
case <-done:
|
||||
return
|
||||
case <-ticker.C:
|
||||
i++
|
||||
frame := spinnerFrames[i%len(spinnerFrames)]
|
||||
c.Printf("\r%s %s", c.style(ansiCyan, string(frame)), message)
|
||||
}
|
||||
}
|
||||
}()
|
||||
|
||||
err := fn()
|
||||
close(done)
|
||||
wg.Wait()
|
||||
if err != nil {
|
||||
c.Printf("\r%s %s\n", c.style(ansiRed, symCross), message)
|
||||
return err
|
||||
}
|
||||
c.Printf("\r%s %s\n", c.style(ansiGreen, symCheck), message)
|
||||
return nil
|
||||
}
|
||||
|
||||
func (c *console) Progress(total int, fn func(Progress) error) error {
|
||||
if total < 1 {
|
||||
total = 1
|
||||
}
|
||||
bar := &progressBar{c: c, total: total, lastPct: -1}
|
||||
if fn == nil {
|
||||
return nil
|
||||
}
|
||||
err := fn(bar)
|
||||
if c.tty && bar.current >= bar.total {
|
||||
c.Println()
|
||||
}
|
||||
return err
|
||||
}
|
||||
|
||||
type progressBar struct {
|
||||
c *console
|
||||
total int
|
||||
current int
|
||||
lastPct int
|
||||
}
|
||||
|
||||
func (p *progressBar) Advance(step int) {
|
||||
if step < 1 {
|
||||
step = 1
|
||||
}
|
||||
p.current += step
|
||||
if p.current > p.total {
|
||||
p.current = p.total
|
||||
}
|
||||
pct := 0
|
||||
if p.total > 0 {
|
||||
pct = p.current * 100 / p.total
|
||||
}
|
||||
if p.c.tty {
|
||||
p.renderTTY(pct)
|
||||
return
|
||||
}
|
||||
if p.lastPct >= 0 && pct/10 == p.lastPct/10 && pct != 100 {
|
||||
return
|
||||
}
|
||||
if pct == 0 && p.lastPct < 0 {
|
||||
p.lastPct = 0
|
||||
return
|
||||
}
|
||||
if pct%10 == 0 || pct == 100 {
|
||||
p.c.Printf("[%d/%d] %d%%\n", p.current, p.total, pct)
|
||||
p.lastPct = pct
|
||||
}
|
||||
}
|
||||
|
||||
func (p *progressBar) renderTTY(pct int) {
|
||||
width := 40
|
||||
filled := 0
|
||||
if p.total > 0 {
|
||||
filled = p.current * width / p.total
|
||||
}
|
||||
if filled > width {
|
||||
filled = width
|
||||
}
|
||||
bar := strings.Repeat("█", filled) + strings.Repeat(" ", width-filled)
|
||||
color := progressColor(pct)
|
||||
p.c.Printf("\r %s %5.1f%% %d/%d", p.c.style(color, bar), float64(pct), p.current, p.total)
|
||||
}
|
||||
|
||||
func progressColor(pct int) string {
|
||||
switch {
|
||||
case pct >= 100:
|
||||
return "\x1b[38;5;34m"
|
||||
case pct >= 50:
|
||||
return "\x1b[38;5;36m"
|
||||
default:
|
||||
return "\x1b[38;5;37m"
|
||||
}
|
||||
}
|
||||
|
||||
func (c *console) Table(headers []string, rows [][]string) {
|
||||
if !c.tty {
|
||||
c.Println(strings.Join(headers, "\t"))
|
||||
for _, row := range rows {
|
||||
c.Println(strings.Join(padRow(row, len(headers)), "\t"))
|
||||
}
|
||||
return
|
||||
}
|
||||
cols := len(headers)
|
||||
all := make([][]string, 0, 1+len(rows))
|
||||
all = append(all, headers)
|
||||
for _, row := range rows {
|
||||
all = append(all, padRow(row, cols))
|
||||
}
|
||||
widths := make([]int, cols)
|
||||
for _, row := range all {
|
||||
for i, cell := range row {
|
||||
if n := utf8.RuneCountInString(cell); n > widths[i] {
|
||||
widths[i] = n
|
||||
}
|
||||
}
|
||||
}
|
||||
c.Println(boxLine(widths, boxTopLeft, boxTeeDown, boxTopRight))
|
||||
c.Println(boxRow(headers, widths, true, c))
|
||||
c.Println(boxLine(widths, boxTeeRight, boxCross, boxTeeLeft))
|
||||
for _, row := range rows {
|
||||
c.Println(boxRow(padRow(row, cols), widths, false, c))
|
||||
}
|
||||
c.Println(boxLine(widths, boxBottomLeft, boxTeeUp, boxBottomRight))
|
||||
}
|
||||
|
||||
func padRow(row []string, n int) []string {
|
||||
out := make([]string, n)
|
||||
for i := 0; i < n; i++ {
|
||||
if i < len(row) {
|
||||
out[i] = row[i]
|
||||
}
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
func boxLine(widths []int, left, mid, right string) string {
|
||||
var b strings.Builder
|
||||
b.WriteString(left)
|
||||
for i, w := range widths {
|
||||
if i > 0 {
|
||||
b.WriteString(mid)
|
||||
}
|
||||
b.WriteString(strings.Repeat(boxHorizontal, w+2))
|
||||
}
|
||||
b.WriteString(right)
|
||||
return b.String()
|
||||
}
|
||||
|
||||
func boxRow(cells []string, widths []int, header bool, c *console) string {
|
||||
var b strings.Builder
|
||||
b.WriteString(boxVertical)
|
||||
for i, cell := range cells {
|
||||
pad := widths[i] - utf8.RuneCountInString(cell)
|
||||
text := cell
|
||||
if header {
|
||||
text = c.style("\x1b[1m", cell)
|
||||
}
|
||||
fmt.Fprintf(&b, " %s%s %s", text, strings.Repeat(" ", pad), boxVertical)
|
||||
}
|
||||
return b.String()
|
||||
}
|
||||
42
modules/bouncer/audience_test.go
Normal file
42
modules/bouncer/audience_test.go
Normal file
@@ -0,0 +1,42 @@
|
||||
package bouncer
|
||||
|
||||
import (
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
func TestAudienceCrossover(t *testing.T) {
|
||||
const secret = "same-secret-for-both-guards"
|
||||
users := memUsers{byID: map[uint]*Principal{1: {ID: 1}}}
|
||||
userTok, _, err := MintAudience(secret, "1", "https://app.test/login", time.Hour, AudienceUser)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
backendTok, _, err := MintAudience(secret, "1", "https://app.test/_admin/api/v1/auth/login", time.Hour, AudienceBackend)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
frontend := NewJWTGuard(secret, users, nil)
|
||||
backend := NewBackendJWTGuard(secret, users, nil, nil)
|
||||
|
||||
if principal, err := backend.Authenticate(withBearer(backendTok)); err != nil || principal == nil || principal.ID != 1 {
|
||||
t.Fatalf("backend guard rejected its own audience: %v", err)
|
||||
}
|
||||
if principal, err := frontend.Authenticate(withBearer(userTok)); err != nil || principal == nil || principal.ID != 1 {
|
||||
t.Fatalf("frontend guard rejected its own audience: %v", err)
|
||||
}
|
||||
if principal, err := backend.Authenticate(withBearer(userTok)); err == nil || principal != nil {
|
||||
t.Fatal("backend guard accepted a frontend-audience token signed with the same secret")
|
||||
}
|
||||
if principal, err := frontend.Authenticate(withBearer(backendTok)); err == nil || principal != nil {
|
||||
t.Fatal("frontend guard accepted a backend-audience token signed with the same secret")
|
||||
}
|
||||
}
|
||||
|
||||
func withBearer(token string) *http.Request {
|
||||
req := httptest.NewRequest(http.MethodGet, "/", nil)
|
||||
req.Header.Set("Authorization", "Bearer "+token)
|
||||
return req
|
||||
}
|
||||
171
modules/bouncer/backend_guard_test.go
Normal file
171
modules/bouncer/backend_guard_test.go
Normal file
@@ -0,0 +1,171 @@
|
||||
package bouncer
|
||||
|
||||
import (
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
// TestPhase09GuardIsolation is the phase gate for token crossover. Each
|
||||
// subtest fails closed when a frontend and backend credential can be used
|
||||
// on the other guard, including same-secret audience checks, distinct
|
||||
// secrets, refresh, blacklist, and password-reset cutoff.
|
||||
func TestPhase09GuardIsolation(t *testing.T) {
|
||||
const (
|
||||
userSecret = "frontend-secret"
|
||||
backendSecret = "backend-secret"
|
||||
sharedSecret = "same-secret-for-both-guards"
|
||||
issuer = "https://app.test"
|
||||
)
|
||||
frontendUsers := memUsers{byID: map[uint]*Principal{1: {ID: 1}}}
|
||||
backendUsers := memUsers{byID: map[uint]*Principal{2: {ID: 2, Backend: true}}}
|
||||
|
||||
userTok, _, err := MintAudience(sharedSecret, "1", issuer, time.Hour, AudienceUser)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
backendTok, _, err := MintAudience(sharedSecret, "2", issuer, time.Hour, AudienceBackend)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
frontend := NewJWTGuard(sharedSecret, frontendUsers, nil)
|
||||
backend := NewBackendJWTGuard(sharedSecret, backendUsers, nil, nil)
|
||||
|
||||
t.Run("own audience", func(t *testing.T) {
|
||||
principal, err := frontend.Authenticate(withBearer(userTok))
|
||||
if err != nil || principal == nil || principal.ID != 1 {
|
||||
t.Fatalf("frontend guard rejected its own token: %v %+v", err, principal)
|
||||
}
|
||||
principal, err = backend.Authenticate(withBearer(backendTok))
|
||||
if err != nil || principal == nil || principal.ID != 2 || !principal.Backend {
|
||||
t.Fatalf("backend guard rejected its own token: %v %+v", err, principal)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("audience crossover same secret", func(t *testing.T) {
|
||||
if principal, err := backend.Authenticate(withBearer(userTok)); err == nil || principal != nil {
|
||||
t.Fatal("backend guard accepted a frontend-audience token signed with the same secret")
|
||||
}
|
||||
if principal, err := frontend.Authenticate(withBearer(backendTok)); err == nil || principal != nil {
|
||||
t.Fatal("frontend guard accepted a backend-audience token signed with the same secret")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("distinct secrets and registries", func(t *testing.T) {
|
||||
userOnly, _, err := MintAudience(userSecret, "1", issuer, time.Hour, AudienceUser)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
adminOnly, _, err := MintAudience(backendSecret, "2", issuer, time.Hour, AudienceBackend)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
front := NewJWTGuard(userSecret, frontendUsers, nil)
|
||||
back := NewBackendJWTGuard(backendSecret, backendUsers, nil, nil)
|
||||
if principal, err := back.Authenticate(withBearer(userOnly)); err == nil || principal != nil {
|
||||
t.Fatal("backend guard accepted a frontend token signed with the frontend secret")
|
||||
}
|
||||
if principal, err := front.Authenticate(withBearer(adminOnly)); err == nil || principal != nil {
|
||||
t.Fatal("frontend guard accepted a backend token signed with the backend secret")
|
||||
}
|
||||
if principal, err := back.Authenticate(withBearer(adminOnly)); err != nil || principal == nil || principal.ID != 2 {
|
||||
t.Fatalf("backend registry principal = %+v err=%v", principal, err)
|
||||
}
|
||||
if principal, err := back.Authenticate(withBearer(mustMint(t, backendSecret, "1", AudienceBackend))); err == nil || principal != nil {
|
||||
t.Fatal("backend guard resolved a subject from the frontend user registry")
|
||||
}
|
||||
reg := NewRegistry()
|
||||
if err := reg.Register("golem15.user", "jwt", front); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := reg.Register("summercms.cabana", "backend", back); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
mw, err := reg.Middleware("backend")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
rec := httptest.NewRecorder()
|
||||
mw(http.HandlerFunc(func(http.ResponseWriter, *http.Request) {
|
||||
t.Fatal("backend middleware ran the handler for a frontend token")
|
||||
})).ServeHTTP(rec, withBearer(userOnly))
|
||||
if rec.Code != http.StatusUnauthorized {
|
||||
t.Fatalf("crossover status=%d body=%s", rec.Code, rec.Body.String())
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("malformed and wrong audience", func(t *testing.T) {
|
||||
if _, err := backend.Authenticate(withBearer("not-a-jwt")); err == nil {
|
||||
t.Fatal("malformed token was accepted")
|
||||
}
|
||||
other, _, err := MintAudience(sharedSecret, "2", issuer, time.Hour, "frontend")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if principal, err := backend.Authenticate(withBearer(other)); err == nil || principal != nil {
|
||||
t.Fatal("backend guard accepted an unexpected audience")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("blacklist and reset cutoff", func(t *testing.T) {
|
||||
bl := NewMemoryBlacklist()
|
||||
revoked, jti, err := MintAudience(backendSecret, "2", issuer, time.Hour, AudienceBackend)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := bl.Add(t.Context(), jti, time.Now().Add(time.Hour), time.Now().Add(-time.Second)); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
guard := NewBackendJWTGuard(backendSecret, backendUsers, bl, nil)
|
||||
if principal, err := guard.Authenticate(withBearer(revoked)); err == nil || principal != nil {
|
||||
t.Fatal("blacklisted backend token was accepted")
|
||||
}
|
||||
if _, err := RefreshAudience(backendSecret, revoked, AudienceBackend, 2*time.Hour, bl, time.Minute, issuer); err == nil {
|
||||
t.Fatal("blacklisted backend token was refreshed")
|
||||
}
|
||||
cutoff := memUsers{byID: map[uint]*Principal{2: {
|
||||
ID: 2, Backend: true, TokensValidAfter: time.Now().Add(time.Minute),
|
||||
}}}
|
||||
stale, _, err := MintAudience(backendSecret, "2", issuer, time.Hour, AudienceBackend)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if principal, err := NewBackendJWTGuard(backendSecret, cutoff, nil, nil).Authenticate(withBearer(stale)); err == nil || principal != nil {
|
||||
t.Fatal("token issued before the password-reset cutoff was accepted")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("refresh does not cross audiences", func(t *testing.T) {
|
||||
access, _, err := MintAudience(userSecret, "1", issuer, time.Hour, AudienceUser)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
admin, _, err := MintAudience(backendSecret, "2", issuer, time.Hour, AudienceBackend)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, err := RefreshAudience(userSecret, access, AudienceBackend, 2*time.Hour, nil, time.Minute, issuer); err == nil {
|
||||
t.Fatal("frontend token refreshed into the backend audience")
|
||||
}
|
||||
if _, err := RefreshAudience(backendSecret, admin, AudienceUser, 2*time.Hour, nil, time.Minute, issuer); err == nil {
|
||||
t.Fatal("backend token refreshed into the frontend audience")
|
||||
}
|
||||
if _, err := RefreshAudience(userSecret, admin, AudienceBackend, 2*time.Hour, nil, time.Minute, issuer); err == nil {
|
||||
t.Fatal("backend token refreshed with the frontend secret")
|
||||
}
|
||||
next, err := RefreshAudience(backendSecret, admin, AudienceBackend, 2*time.Hour, nil, time.Minute, issuer)
|
||||
if err != nil || next == "" {
|
||||
t.Fatalf("backend refresh failed: %v", err)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func mustMint(t *testing.T, secret, sub, audience string) string {
|
||||
t.Helper()
|
||||
token, _, err := MintAudience(secret, sub, "https://app.test", time.Hour, audience)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return token
|
||||
}
|
||||
126
modules/bouncer/blacklist.go
Normal file
126
modules/bouncer/blacklist.go
Normal file
@@ -0,0 +1,126 @@
|
||||
package bouncer
|
||||
|
||||
import (
|
||||
"context"
|
||||
"database/sql"
|
||||
"errors"
|
||||
"fmt"
|
||||
"regexp"
|
||||
"sync"
|
||||
"time"
|
||||
)
|
||||
|
||||
// BlacklistStore records revoked jti values. IsBlacklisted is true only once
|
||||
// validUntil has been reached, so a grace window can keep a just-rotated
|
||||
// token usable. Sweep drops rows whose storage expiry has passed.
|
||||
type BlacklistStore interface {
|
||||
Add(ctx context.Context, jti string, expiresAt, validUntil time.Time) error
|
||||
IsBlacklisted(ctx context.Context, jti string) (bool, error)
|
||||
Sweep(ctx context.Context, now time.Time) error
|
||||
}
|
||||
|
||||
type blEntry struct {
|
||||
expiresAt time.Time
|
||||
validUntil time.Time
|
||||
}
|
||||
|
||||
// MemoryBlacklist is an in-process store for tests. Expired rows are dropped
|
||||
// on read, matching surf.MemoryStore.
|
||||
type MemoryBlacklist struct {
|
||||
mu sync.Mutex
|
||||
entries map[string]blEntry
|
||||
}
|
||||
|
||||
// NewMemoryBlacklist returns an empty in-process blacklist.
|
||||
func NewMemoryBlacklist() *MemoryBlacklist {
|
||||
return &MemoryBlacklist{entries: make(map[string]blEntry)}
|
||||
}
|
||||
|
||||
func (m *MemoryBlacklist) Add(_ context.Context, jti string, expiresAt, validUntil time.Time) error {
|
||||
m.mu.Lock()
|
||||
defer m.mu.Unlock()
|
||||
m.entries[jti] = blEntry{expiresAt: expiresAt, validUntil: validUntil}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (m *MemoryBlacklist) IsBlacklisted(_ context.Context, jti string) (bool, error) {
|
||||
m.mu.Lock()
|
||||
defer m.mu.Unlock()
|
||||
e, ok := m.entries[jti]
|
||||
if !ok {
|
||||
return false, nil
|
||||
}
|
||||
now := time.Now()
|
||||
if now.After(e.expiresAt) {
|
||||
delete(m.entries, jti)
|
||||
return false, nil
|
||||
}
|
||||
return !now.Before(e.validUntil), nil
|
||||
}
|
||||
|
||||
func (m *MemoryBlacklist) Sweep(_ context.Context, now time.Time) error {
|
||||
m.mu.Lock()
|
||||
defer m.mu.Unlock()
|
||||
for k, e := range m.entries {
|
||||
if e.expiresAt.Before(now) {
|
||||
delete(m.entries, k)
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
var blacklistIdent = regexp.MustCompile(`^[a-zA-Z_][a-zA-Z0-9_]*$`)
|
||||
|
||||
// PostgresBlacklist stores revoked jti rows in a caller-supplied table.
|
||||
// The table name is a plugin constant, still checked so it cannot be interpolated raw.
|
||||
type PostgresBlacklist struct {
|
||||
db *sql.DB
|
||||
table string
|
||||
}
|
||||
|
||||
// NewPostgresBlacklist binds db to table. table must be a plain SQL identifier.
|
||||
func NewPostgresBlacklist(db *sql.DB, table string) *PostgresBlacklist {
|
||||
return &PostgresBlacklist{db: db, table: table}
|
||||
}
|
||||
|
||||
func (p *PostgresBlacklist) checkTable() error {
|
||||
if p == nil || !blacklistIdent.MatchString(p.table) {
|
||||
return fmt.Errorf("bouncer: blacklist table %q is not a safe identifier", p.table)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (p *PostgresBlacklist) Add(ctx context.Context, jti string, expiresAt, validUntil time.Time) error {
|
||||
if err := p.checkTable(); err != nil {
|
||||
return err
|
||||
}
|
||||
q := fmt.Sprintf(`INSERT INTO %s (jti, expires_at, valid_until) VALUES ($1, $2, $3)
|
||||
ON CONFLICT (jti) DO UPDATE SET expires_at = EXCLUDED.expires_at, valid_until = EXCLUDED.valid_until`, p.table)
|
||||
_, err := p.db.ExecContext(ctx, q, jti, expiresAt, validUntil)
|
||||
return err
|
||||
}
|
||||
|
||||
func (p *PostgresBlacklist) IsBlacklisted(ctx context.Context, jti string) (bool, error) {
|
||||
if err := p.checkTable(); err != nil {
|
||||
return false, err
|
||||
}
|
||||
q := fmt.Sprintf(`SELECT valid_until FROM %s WHERE jti = $1`, p.table)
|
||||
var validUntil time.Time
|
||||
err := p.db.QueryRowContext(ctx, q, jti).Scan(&validUntil)
|
||||
if errors.Is(err, sql.ErrNoRows) {
|
||||
return false, nil
|
||||
}
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
return !time.Now().Before(validUntil), nil
|
||||
}
|
||||
|
||||
func (p *PostgresBlacklist) Sweep(ctx context.Context, now time.Time) error {
|
||||
if err := p.checkTable(); err != nil {
|
||||
return err
|
||||
}
|
||||
q := fmt.Sprintf(`DELETE FROM %s WHERE expires_at < $1`, p.table)
|
||||
_, err := p.db.ExecContext(ctx, q, now)
|
||||
return err
|
||||
}
|
||||
61
modules/bouncer/blacklist_test.go
Normal file
61
modules/bouncer/blacklist_test.go
Normal file
@@ -0,0 +1,61 @@
|
||||
package bouncer
|
||||
|
||||
import (
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
func TestBlacklistGraceWindow(t *testing.T) {
|
||||
bl := NewMemoryBlacklist()
|
||||
now := time.Now()
|
||||
if err := bl.Add(t.Context(), "jti", now.Add(time.Hour), now.Add(time.Minute)); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
blocked, err := bl.IsBlacklisted(t.Context(), "jti")
|
||||
if err != nil || blocked {
|
||||
t.Fatalf("before validUntil: blocked=%t err=%v", blocked, err)
|
||||
}
|
||||
if err := bl.Add(t.Context(), "due", now.Add(time.Hour), now.Add(-time.Second)); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
blocked, err = bl.IsBlacklisted(t.Context(), "due")
|
||||
if err != nil || !blocked {
|
||||
t.Fatalf("after validUntil: blocked=%t err=%v", blocked, err)
|
||||
}
|
||||
if err := bl.Add(t.Context(), "now", now.Add(time.Hour), time.Now()); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
blocked, err = bl.IsBlacklisted(t.Context(), "now")
|
||||
if err != nil || !blocked {
|
||||
t.Fatalf("at validUntil: blocked=%t err=%v", blocked, err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestBlacklistSweep(t *testing.T) {
|
||||
bl := NewMemoryBlacklist()
|
||||
now := time.Now()
|
||||
if err := bl.Add(t.Context(), "gone", now.Add(-time.Minute), now.Add(-time.Minute)); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := bl.Add(t.Context(), "stay", now.Add(time.Hour), now.Add(-time.Second)); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := bl.Sweep(t.Context(), now); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
gone, err := bl.IsBlacklisted(t.Context(), "gone")
|
||||
if err != nil || gone {
|
||||
t.Fatalf("swept row still present: %t %v", gone, err)
|
||||
}
|
||||
stay, err := bl.IsBlacklisted(t.Context(), "stay")
|
||||
if err != nil || !stay {
|
||||
t.Fatalf("live row = %t %v", stay, err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestPostgresBlacklistRejectsUnsafeTable(t *testing.T) {
|
||||
bl := NewPostgresBlacklist(nil, "user_jwt;drop")
|
||||
if err := bl.Add(t.Context(), "j", time.Now(), time.Now()); err == nil {
|
||||
t.Fatal("want identifier error")
|
||||
}
|
||||
}
|
||||
61
modules/bouncer/context.go
Normal file
61
modules/bouncer/context.go
Normal file
@@ -0,0 +1,61 @@
|
||||
package bouncer
|
||||
|
||||
import (
|
||||
"context"
|
||||
"time"
|
||||
)
|
||||
|
||||
type userKey struct{}
|
||||
|
||||
// Principal is the authenticated identity stored on the request context.
|
||||
// PreferredLocale empty means no override. TokensValidAfter zero means no cutoff.
|
||||
// IsSuperuser and PermissionGrants are set only for backend-admin principals.
|
||||
// A grant ending in ".*" matches permission codes by prefix.
|
||||
type Principal struct {
|
||||
ID uint
|
||||
MustChangePassword bool
|
||||
PreferredLocale string
|
||||
TokensValidAfter time.Time
|
||||
Backend bool `json:"-"`
|
||||
IsSuperuser bool `json:"-"`
|
||||
PermissionGrants map[string]bool `json:"-"`
|
||||
}
|
||||
|
||||
// WithUser stores the verified principal on ctx.
|
||||
func WithUser(ctx context.Context, user *Principal) context.Context {
|
||||
if ctx == nil {
|
||||
ctx = context.Background()
|
||||
}
|
||||
return context.WithValue(ctx, userKey{}, user)
|
||||
}
|
||||
|
||||
// User returns the verified principal from ctx.
|
||||
func User(ctx context.Context) (*Principal, bool) {
|
||||
if ctx == nil {
|
||||
return nil, false
|
||||
}
|
||||
u, ok := ctx.Value(userKey{}).(*Principal)
|
||||
return u, ok && u != nil
|
||||
}
|
||||
|
||||
type credentialKey struct{}
|
||||
|
||||
// WithCredential stores the resolved credential (e.g. *ApiToken) on ctx.
|
||||
func WithCredential(ctx context.Context, cred any) context.Context {
|
||||
if ctx == nil {
|
||||
ctx = context.Background()
|
||||
}
|
||||
return context.WithValue(ctx, credentialKey{}, cred)
|
||||
}
|
||||
|
||||
// Credential returns the resolved credential from ctx.
|
||||
func Credential(ctx context.Context) (any, bool) {
|
||||
if ctx == nil {
|
||||
return nil, false
|
||||
}
|
||||
c := ctx.Value(credentialKey{})
|
||||
if c == nil {
|
||||
return nil, false
|
||||
}
|
||||
return c, true
|
||||
}
|
||||
32
modules/bouncer/context_test.go
Normal file
32
modules/bouncer/context_test.go
Normal file
@@ -0,0 +1,32 @@
|
||||
package bouncer
|
||||
|
||||
import (
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
func TestPrincipalLocaleAndCutoff(t *testing.T) {
|
||||
when := time.Unix(1_700_000_000, 0)
|
||||
p := Principal{PreferredLocale: "pl", TokensValidAfter: when}
|
||||
if p.PreferredLocale != "pl" || !p.TokensValidAfter.Equal(when) {
|
||||
t.Fatalf("%+v", p)
|
||||
}
|
||||
}
|
||||
|
||||
func TestContextCredentialRoundTrip(t *testing.T) {
|
||||
if _, ok := Credential(t.Context()); ok {
|
||||
t.Fatal("empty context must have no credential")
|
||||
}
|
||||
if _, ok := Credential(nil); ok {
|
||||
t.Fatal("nil context must have no credential")
|
||||
}
|
||||
token := &struct{ Name string }{Name: "parity"}
|
||||
got, ok := Credential(WithCredential(t.Context(), token))
|
||||
if !ok || got != token {
|
||||
t.Fatalf("got %#v ok=%t", got, ok)
|
||||
}
|
||||
got, ok = Credential(WithCredential(nil, token))
|
||||
if !ok || got != token {
|
||||
t.Fatalf("nil ctx got %#v ok=%t", got, ok)
|
||||
}
|
||||
}
|
||||
132
modules/bouncer/cookie_guard_test.go
Normal file
132
modules/bouncer/cookie_guard_test.go
Normal file
@@ -0,0 +1,132 @@
|
||||
package bouncer
|
||||
|
||||
import (
|
||||
"context"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
// TestPhase10CookieGuard covers the backend guard's summer_admin cookie
|
||||
// transport (D-19): the cookie is read only when no Bearer header is sent,
|
||||
// Bearer wins when both are present, an empty cookie is unauthenticated, and
|
||||
// the cookie carries no weaker token than the header (audience, blacklist).
|
||||
func TestPhase10CookieGuard(t *testing.T) {
|
||||
const (
|
||||
cookie = "summer_admin"
|
||||
issuer = "https://app.test/backend"
|
||||
)
|
||||
users := memUsers{byID: map[uint]*Principal{
|
||||
2: {ID: 2, Backend: true},
|
||||
3: {ID: 3, Backend: true},
|
||||
}}
|
||||
withCookie := func(value string) *http.Request {
|
||||
r := httptest.NewRequest(http.MethodGet, "/backend/api/v1/auth/me", nil)
|
||||
r.AddCookie(&http.Cookie{Name: cookie, Value: value})
|
||||
return r
|
||||
}
|
||||
mint := func(sub, audience string) (string, string) {
|
||||
t.Helper()
|
||||
tok, jti, err := MintAudience(secret, sub, issuer, time.Hour, audience)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return tok, jti
|
||||
}
|
||||
guard := NewBackendJWTGuard(secret, users, nil, nil, cookie)
|
||||
|
||||
t.Run("cookie without bearer", func(t *testing.T) {
|
||||
tok, _ := mint("2", AudienceBackend)
|
||||
principal, err := guard.Authenticate(withCookie(tok))
|
||||
if err != nil || principal == nil || principal.ID != 2 {
|
||||
t.Fatalf("cookie token rejected: %v %+v", err, principal)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("cookie value is trimmed", func(t *testing.T) {
|
||||
tok, _ := mint("2", AudienceBackend)
|
||||
r := httptest.NewRequest(http.MethodGet, "/", nil)
|
||||
r.Header.Set("Cookie", cookie+"= "+tok+" ")
|
||||
if principal, err := guard.Authenticate(r); err != nil || principal == nil {
|
||||
t.Fatalf("padded cookie rejected: %v", err)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("bearer wins over cookie", func(t *testing.T) {
|
||||
bearerTok, _ := mint("3", AudienceBackend)
|
||||
cookieTok, _ := mint("2", AudienceBackend)
|
||||
r := withCookie(cookieTok)
|
||||
r.Header.Set("Authorization", "Bearer "+bearerTok)
|
||||
principal, err := guard.Authenticate(r)
|
||||
if err != nil || principal == nil || principal.ID != 3 {
|
||||
t.Fatalf("bearer did not win: %v %+v", err, principal)
|
||||
}
|
||||
// A bad Bearer is not rescued by a good cookie.
|
||||
bad := withCookie(cookieTok)
|
||||
bad.Header.Set("Authorization", "Bearer not-a-token")
|
||||
if principal, err := guard.Authenticate(bad); err == nil || principal != nil {
|
||||
t.Fatal("an invalid bearer fell back to the cookie")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("empty or missing cookie is unauthenticated", func(t *testing.T) {
|
||||
for name, r := range map[string]*http.Request{
|
||||
"empty": withCookie(""),
|
||||
"blank": withCookie(" "),
|
||||
"missing": httptest.NewRequest(http.MethodGet, "/", nil),
|
||||
} {
|
||||
principal, err := guard.Authenticate(r)
|
||||
if err == nil || principal != nil || err.Error() != msgTokenNotProvided {
|
||||
t.Fatalf("%s cookie: principal=%+v err=%v, want %q", name, principal, err, msgTokenNotProvided)
|
||||
}
|
||||
}
|
||||
other := httptest.NewRequest(http.MethodGet, "/", nil)
|
||||
tok, _ := mint("2", AudienceBackend)
|
||||
other.AddCookie(&http.Cookie{Name: "summer_other", Value: tok})
|
||||
if _, err := guard.Authenticate(other); err == nil {
|
||||
t.Fatal("a token under another cookie name was accepted")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("frontend audience in the cookie is rejected", func(t *testing.T) {
|
||||
tok, _ := mint("2", AudienceUser)
|
||||
if principal, err := guard.Authenticate(withCookie(tok)); err == nil || principal != nil {
|
||||
t.Fatal("backend guard accepted a frontend-audience cookie")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("blacklisted jti in the cookie is rejected", func(t *testing.T) {
|
||||
bl := NewMemoryBlacklist()
|
||||
blocking := NewBackendJWTGuard(secret, users, bl, nil, cookie)
|
||||
tok, jti := mint("2", AudienceBackend)
|
||||
if _, err := blocking.Authenticate(withCookie(tok)); err != nil {
|
||||
t.Fatalf("fresh cookie rejected: %v", err)
|
||||
}
|
||||
if err := bl.Add(context.Background(), jti, time.Now().Add(time.Hour), time.Now().Add(-time.Second)); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
principal, err := blocking.Authenticate(withCookie(tok))
|
||||
if err == nil || principal != nil || err.Error() != msgBadSignature {
|
||||
t.Fatalf("blacklisted cookie: principal=%+v err=%v", principal, err)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("bearer-only guard ignores the cookie", func(t *testing.T) {
|
||||
tok, _ := mint("2", AudienceBackend)
|
||||
bearerOnly := NewBackendJWTGuard(secret, users, nil, nil)
|
||||
if principal, err := bearerOnly.Authenticate(withCookie(tok)); err == nil || principal != nil {
|
||||
t.Fatal("a guard without cookie names read the cookie")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("second cookie name is tried after an empty first", func(t *testing.T) {
|
||||
tok, _ := mint("2", AudienceBackend)
|
||||
two := NewBackendJWTGuard(secret, users, nil, nil, "legacy_admin", cookie)
|
||||
r := withCookie(tok)
|
||||
r.AddCookie(&http.Cookie{Name: "legacy_admin", Value: ""})
|
||||
if principal, err := two.Authenticate(r); err != nil || principal == nil {
|
||||
t.Fatalf("second cookie name not tried: %v", err)
|
||||
}
|
||||
})
|
||||
}
|
||||
25
modules/bouncer/guard.go
Normal file
25
modules/bouncer/guard.go
Normal file
@@ -0,0 +1,25 @@
|
||||
package bouncer
|
||||
|
||||
import "net/http"
|
||||
|
||||
// Guard resolves the caller's Principal for r, or an error describing why not.
|
||||
type Guard interface {
|
||||
Authenticate(r *http.Request) (*Principal, error)
|
||||
}
|
||||
|
||||
// CredentialGuard resolves the Principal AND its underlying credential (e.g.
|
||||
// *models.ApiToken) in one pass -- a DB-backed guard must never verify twice
|
||||
// per request (RESEARCH.md Pitfall 5: last_used_at must stamp once).
|
||||
type CredentialGuard interface {
|
||||
AuthenticateCredential(r *http.Request) (*Principal, any, error)
|
||||
}
|
||||
|
||||
// UnauthorizedWriter lets a guard write its own failure response. jwtGuard
|
||||
// implements this (reusing write401's {"error":true,"message":...} shape).
|
||||
// TokenGuard does NOT implement it: PHP's TokenScope, not ApiTokenGuard, owns
|
||||
// the {"error":"Invalid token"} 401 body (D-08) -- Registry.Middleware must
|
||||
// pass an unauthenticated request through untouched when a guard has no
|
||||
// UnauthorizedWriter, leaving denial to downstream middleware.
|
||||
type UnauthorizedWriter interface {
|
||||
WriteUnauthorized(w http.ResponseWriter, err error)
|
||||
}
|
||||
371
modules/bouncer/jwt.go
Normal file
371
modules/bouncer/jwt.go
Normal file
@@ -0,0 +1,371 @@
|
||||
package bouncer
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"math"
|
||||
"net/http"
|
||||
"strconv"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"github.com/golang-jwt/jwt/v5"
|
||||
)
|
||||
|
||||
const (
|
||||
msgTokenNotProvided = "Token not provided"
|
||||
msgTokenExpired = "Token has expired"
|
||||
msgUserNotFound = "User not found"
|
||||
msgBadSignature = "Token Signature could not be verified."
|
||||
msgMalformed = "Wrong number of segments"
|
||||
msgRequiredClaims = "JWT payload does not contain the required claims"
|
||||
)
|
||||
|
||||
// UserProvider loads a persisted user by JWT subject.
|
||||
type UserProvider interface {
|
||||
FindByID(ctx context.Context, id uint) (*Principal, error)
|
||||
}
|
||||
|
||||
// Middleware validates a pinned HS256 bearer token and loads the user.
|
||||
func Middleware(secret string, users UserProvider) func(http.Handler) http.Handler {
|
||||
return func(next http.Handler) http.Handler {
|
||||
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
raw, err := bearerToken(r)
|
||||
if err != nil {
|
||||
write401(w, err.Error())
|
||||
return
|
||||
}
|
||||
sub, err := Verify(raw, secret)
|
||||
if err != nil {
|
||||
write401(w, err.Error())
|
||||
return
|
||||
}
|
||||
id, err := strconv.ParseUint(sub, 10, 64)
|
||||
if err != nil || id == 0 {
|
||||
write401(w, msgUserNotFound)
|
||||
return
|
||||
}
|
||||
if users == nil {
|
||||
write401(w, msgUserNotFound)
|
||||
return
|
||||
}
|
||||
user, err := users.FindByID(r.Context(), uint(id))
|
||||
if err != nil {
|
||||
write401(w, "Authentication error")
|
||||
return
|
||||
}
|
||||
if user == nil {
|
||||
write401(w, msgUserNotFound)
|
||||
return
|
||||
}
|
||||
next.ServeHTTP(w, r.WithContext(WithUser(r.Context(), user)))
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
type jwtGuard struct {
|
||||
secret string
|
||||
users UserProvider
|
||||
bl BlacklistStore
|
||||
cookieNames []string
|
||||
audience string
|
||||
requireAudience bool
|
||||
writeFn func(http.ResponseWriter, error)
|
||||
}
|
||||
|
||||
var (
|
||||
_ Guard = (*jwtGuard)(nil)
|
||||
_ UnauthorizedWriter = (*jwtGuard)(nil)
|
||||
)
|
||||
|
||||
// NewJWTGuard adapts bearer/cookie extraction, VerifyClaims, and users.FindByID
|
||||
// into a Guard + UnauthorizedWriter. bl may be nil. An empty cookieNames list
|
||||
// is Bearer-only; otherwise each name is tried, in order, after the Authorization header.
|
||||
func NewJWTGuard(secret string, users UserProvider, bl BlacklistStore, cookieNames ...string) Guard {
|
||||
return &jwtGuard{secret: secret, users: users, bl: bl, cookieNames: cookieNames}
|
||||
}
|
||||
|
||||
// NewBackendJWTGuard requires AudienceBackend. write may replace the
|
||||
// PHP-shaped 401 body; nil keeps write401. With no cookieNames it is
|
||||
// Bearer-only; otherwise each cookie is tried, in order, after the
|
||||
// Authorization header, so a Bearer token still wins when both are sent.
|
||||
func NewBackendJWTGuard(secret string, users UserProvider, bl BlacklistStore, write func(http.ResponseWriter, error), cookieNames ...string) Guard {
|
||||
return &jwtGuard{
|
||||
secret: secret,
|
||||
users: users,
|
||||
bl: bl,
|
||||
cookieNames: cookieNames,
|
||||
audience: AudienceBackend,
|
||||
requireAudience: true,
|
||||
writeFn: write,
|
||||
}
|
||||
}
|
||||
|
||||
func (g *jwtGuard) Authenticate(r *http.Request) (*Principal, error) {
|
||||
raw, err := extractToken(r, g.cookieNames)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
var sub, jti string
|
||||
var iat time.Time
|
||||
if g.requireAudience {
|
||||
sub, iat, _, jti, err = VerifyClaimsAudience(raw, g.secret, g.audience)
|
||||
} else {
|
||||
sub, iat, _, jti, err = VerifyClaims(raw, g.secret)
|
||||
}
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
user, err := subjectPrincipal(r.Context(), g.users, sub)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if g.bl != nil {
|
||||
blocked, err := g.bl.IsBlacklisted(r.Context(), jti)
|
||||
if err != nil {
|
||||
return nil, errors.New("Authentication error")
|
||||
}
|
||||
if blocked {
|
||||
return nil, errors.New(msgBadSignature)
|
||||
}
|
||||
}
|
||||
if issuedBeforeCutoff(user, iat) {
|
||||
return nil, ErrSubjectRejected
|
||||
}
|
||||
return user, nil
|
||||
}
|
||||
|
||||
// ErrSubjectRejected reports that a token's subject is not a loadable user
|
||||
// (a non-numeric or zero sub, a nil provider, or a provider that returned no
|
||||
// principal for a missing, deleted or not-activated user), or that the token
|
||||
// was issued before Principal.TokensValidAfter. Its message is "User not found".
|
||||
var ErrSubjectRejected = errors.New(msgUserNotFound)
|
||||
|
||||
// errAuthentication reports a provider failure while loading the subject.
|
||||
var errAuthentication = errors.New("Authentication error")
|
||||
|
||||
// subjectPrincipal loads the token subject through users, shared by the JWT
|
||||
// guard and RefreshAudienceFor. A provider error is errAuthentication; every
|
||||
// other refusal is ErrSubjectRejected.
|
||||
func subjectPrincipal(ctx context.Context, users UserProvider, sub string) (*Principal, error) {
|
||||
id, err := strconv.ParseUint(sub, 10, 64)
|
||||
if err != nil || id == 0 {
|
||||
return nil, ErrSubjectRejected
|
||||
}
|
||||
if users == nil {
|
||||
return nil, ErrSubjectRejected
|
||||
}
|
||||
user, err := users.FindByID(ctx, uint(id))
|
||||
if err != nil {
|
||||
return nil, errAuthentication
|
||||
}
|
||||
if user == nil {
|
||||
return nil, ErrSubjectRejected
|
||||
}
|
||||
return user, nil
|
||||
}
|
||||
|
||||
// issuedBeforeCutoff reports whether iat predates the user's
|
||||
// tokens_valid_after cutoff (set by a password reset). A zero cutoff never cuts.
|
||||
func issuedBeforeCutoff(user *Principal, iat time.Time) bool {
|
||||
return !user.TokensValidAfter.IsZero() && iat.Before(user.TokensValidAfter)
|
||||
}
|
||||
|
||||
func (g *jwtGuard) WriteUnauthorized(w http.ResponseWriter, err error) {
|
||||
if g.writeFn != nil {
|
||||
g.writeFn(w, err)
|
||||
return
|
||||
}
|
||||
write401(w, err.Error())
|
||||
}
|
||||
|
||||
// Verify parses a token with HS256 pinned and a required exp and sub.
|
||||
// A missing audience is accepted for PHP-issued frontend tokens. An explicit
|
||||
// audience must be AudienceUser, so a backend token cannot pass this guard.
|
||||
func Verify(tokenString, secret string) (string, error) {
|
||||
sub, _, _, _, err := verifyClaims(tokenString, secret, "")
|
||||
return sub, err
|
||||
}
|
||||
|
||||
// VerifyClaims parses a token the same way Verify does and also returns iat, exp, and jti.
|
||||
// A missing audience stays valid so PHP-issued frontend tokens keep working.
|
||||
func VerifyClaims(tokenString, secret string) (sub string, iat, exp time.Time, jti string, err error) {
|
||||
return verifyClaims(tokenString, secret, "")
|
||||
}
|
||||
|
||||
// VerifyClaimsAudience is VerifyClaims plus a required audience claim.
|
||||
func VerifyClaimsAudience(tokenString, secret, audience string) (sub string, iat, exp time.Time, jti string, err error) {
|
||||
if strings.TrimSpace(audience) == "" {
|
||||
return "", time.Time{}, time.Time{}, "", fmt.Errorf("bouncer: jwt audience is empty")
|
||||
}
|
||||
return verifyClaims(tokenString, secret, audience)
|
||||
}
|
||||
|
||||
func verifyClaims(tokenString, secret, audience string) (sub string, iat, exp time.Time, jti string, err error) {
|
||||
if strings.TrimSpace(secret) == "" {
|
||||
return "", time.Time{}, time.Time{}, "", fmt.Errorf("bouncer: jwt secret is empty")
|
||||
}
|
||||
parser := jwt.NewParser(jwt.WithValidMethods([]string{"HS256"}), jwt.WithExpirationRequired())
|
||||
claims := jwt.MapClaims{}
|
||||
_, err = parser.ParseWithClaims(tokenString, claims, func(t *jwt.Token) (any, error) {
|
||||
return []byte(secret), nil
|
||||
})
|
||||
if err != nil {
|
||||
return "", time.Time{}, time.Time{}, "", mapJWTError(err)
|
||||
}
|
||||
if !frontendAudienceOK(claims, audience) {
|
||||
return "", time.Time{}, time.Time{}, "", errors.New(msgBadSignature)
|
||||
}
|
||||
sub = subject(claims)
|
||||
if sub == "" {
|
||||
return "", time.Time{}, time.Time{}, "", errors.New(msgRequiredClaims)
|
||||
}
|
||||
iat, _ = claimTime(claims, "iat")
|
||||
exp, _ = claimTime(claims, "exp")
|
||||
jti, _ = claims["jti"].(string)
|
||||
return sub, iat, exp, jti, nil
|
||||
}
|
||||
|
||||
// frontendAudienceOK accepts a missing audience when expected is empty
|
||||
// (legacy frontend tokens) and otherwise requires expected.
|
||||
func frontendAudienceOK(claims jwt.MapClaims, expected string) bool {
|
||||
auds := claimAudiences(claims)
|
||||
if expected == "" {
|
||||
return len(auds) == 0 || audienceMatches(claims, AudienceUser)
|
||||
}
|
||||
return audienceMatches(claims, expected)
|
||||
}
|
||||
|
||||
func audienceMatches(claims jwt.MapClaims, expected string) bool {
|
||||
for _, aud := range claimAudiences(claims) {
|
||||
if aud == expected {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func claimAudiences(claims jwt.MapClaims) []string {
|
||||
switch v := claims["aud"].(type) {
|
||||
case string:
|
||||
if strings.TrimSpace(v) == "" {
|
||||
return nil
|
||||
}
|
||||
return []string{v}
|
||||
case []string:
|
||||
return v
|
||||
case []any:
|
||||
out := make([]string, 0, len(v))
|
||||
for _, item := range v {
|
||||
s, ok := item.(string)
|
||||
if ok && s != "" {
|
||||
out = append(out, s)
|
||||
}
|
||||
}
|
||||
return out
|
||||
default:
|
||||
return nil
|
||||
}
|
||||
}
|
||||
|
||||
func extractToken(r *http.Request, cookieNames []string) (string, error) {
|
||||
raw, err := bearerToken(r)
|
||||
if err == nil {
|
||||
return raw, nil
|
||||
}
|
||||
if len(cookieNames) == 0 {
|
||||
return "", err
|
||||
}
|
||||
for _, name := range cookieNames {
|
||||
c, cerr := r.Cookie(name)
|
||||
if cerr != nil {
|
||||
continue
|
||||
}
|
||||
v := strings.TrimSpace(c.Value)
|
||||
if v != "" {
|
||||
return v, nil
|
||||
}
|
||||
}
|
||||
return "", errors.New(msgTokenNotProvided)
|
||||
}
|
||||
|
||||
func claimTime(claims jwt.MapClaims, key string) (time.Time, bool) {
|
||||
switch v := claims[key].(type) {
|
||||
case float64:
|
||||
if math.IsNaN(v) || math.IsInf(v, 0) {
|
||||
return time.Time{}, false
|
||||
}
|
||||
return time.Unix(int64(v), 0), true
|
||||
case json.Number:
|
||||
n, err := v.Int64()
|
||||
if err != nil {
|
||||
return time.Time{}, false
|
||||
}
|
||||
return time.Unix(n, 0), true
|
||||
case int64:
|
||||
return time.Unix(v, 0), true
|
||||
default:
|
||||
return time.Time{}, false
|
||||
}
|
||||
}
|
||||
|
||||
func bearerToken(r *http.Request) (string, error) {
|
||||
h := strings.TrimSpace(r.Header.Get("Authorization"))
|
||||
if h == "" {
|
||||
return "", errors.New(msgTokenNotProvided)
|
||||
}
|
||||
token, ok := strings.CutPrefix(h, "Bearer ")
|
||||
token = strings.TrimSpace(token)
|
||||
if !ok || token == "" {
|
||||
return "", errors.New(msgTokenNotProvided)
|
||||
}
|
||||
return token, nil
|
||||
}
|
||||
|
||||
func subject(claims jwt.MapClaims) string {
|
||||
switch v := claims["sub"].(type) {
|
||||
case string:
|
||||
return strings.TrimSpace(v)
|
||||
case float64:
|
||||
if math.IsNaN(v) || math.IsInf(v, 0) || v <= 0 || v != math.Trunc(v) || v > 9007199254740992 {
|
||||
return ""
|
||||
}
|
||||
return strconv.FormatInt(int64(v), 10)
|
||||
case json.Number:
|
||||
n, err := strconv.ParseInt(strings.TrimSpace(v.String()), 10, 64)
|
||||
if err != nil || n <= 0 {
|
||||
return ""
|
||||
}
|
||||
return strconv.FormatInt(n, 10)
|
||||
default:
|
||||
return ""
|
||||
}
|
||||
}
|
||||
|
||||
func mapJWTError(err error) error {
|
||||
switch {
|
||||
case errors.Is(err, jwt.ErrTokenExpired):
|
||||
return errors.New(msgTokenExpired)
|
||||
case errors.Is(err, jwt.ErrTokenSignatureInvalid), errors.Is(err, jwt.ErrTokenUnverifiable):
|
||||
return errors.New(msgBadSignature)
|
||||
case errors.Is(err, jwt.ErrTokenMalformed):
|
||||
return errors.New(msgMalformed)
|
||||
default:
|
||||
msg := err.Error()
|
||||
if strings.Contains(strings.ToLower(msg), "expired") {
|
||||
return errors.New(msgTokenExpired)
|
||||
}
|
||||
if strings.Contains(strings.ToLower(msg), "malformed") || strings.Contains(msg, "segment") {
|
||||
return errors.New(msgMalformed)
|
||||
}
|
||||
return errors.New(msgBadSignature)
|
||||
}
|
||||
}
|
||||
|
||||
func write401(w http.ResponseWriter, message string) {
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
w.WriteHeader(http.StatusUnauthorized)
|
||||
_ = json.NewEncoder(w).Encode(map[string]any{"error": true, "message": message})
|
||||
}
|
||||
128
modules/bouncer/jwt_guard_test.go
Normal file
128
modules/bouncer/jwt_guard_test.go
Normal file
@@ -0,0 +1,128 @@
|
||||
package bouncer
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/golang-jwt/jwt/v5"
|
||||
)
|
||||
|
||||
func TestJWTGuardCookieFallback(t *testing.T) {
|
||||
users := memUsers{byID: map[uint]*Principal{1: {ID: 1}}}
|
||||
tok := sign(t, jwt.SigningMethodHS256, jwt.MapClaims{
|
||||
"sub": "1",
|
||||
"jti": "cookie-jti",
|
||||
"exp": time.Now().Add(time.Hour).Unix(),
|
||||
"iat": time.Now().Unix(),
|
||||
}, []byte(secret))
|
||||
g := NewJWTGuard(secret, users, nil, "token", "auth_token")
|
||||
|
||||
req := httptest.NewRequest(http.MethodGet, "/", nil)
|
||||
req.AddCookie(&http.Cookie{Name: "token", Value: tok})
|
||||
p, err := g.Authenticate(req)
|
||||
if err != nil || p == nil || p.ID != 1 {
|
||||
t.Fatalf("token cookie: %+v %v", p, err)
|
||||
}
|
||||
|
||||
req = httptest.NewRequest(http.MethodGet, "/", nil)
|
||||
req.AddCookie(&http.Cookie{Name: "auth_token", Value: tok})
|
||||
p, err = g.Authenticate(req)
|
||||
if err != nil || p == nil || p.ID != 1 {
|
||||
t.Fatalf("auth_token cookie: %+v %v", p, err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestJWTGuardBearerOnlyIgnoresCookies(t *testing.T) {
|
||||
users := memUsers{byID: map[uint]*Principal{1: {ID: 1}}}
|
||||
tok := sign(t, jwt.SigningMethodHS256, jwt.MapClaims{
|
||||
"sub": "1",
|
||||
"exp": time.Now().Add(time.Hour).Unix(),
|
||||
}, []byte(secret))
|
||||
g := NewJWTGuard(secret, users, nil)
|
||||
req := httptest.NewRequest(http.MethodGet, "/", nil)
|
||||
req.AddCookie(&http.Cookie{Name: "token", Value: tok})
|
||||
if _, err := g.Authenticate(req); err == nil || err.Error() != msgTokenNotProvided {
|
||||
t.Fatalf("cookie on bearer-only guard: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestJWTGuardBlacklist(t *testing.T) {
|
||||
users := memUsers{byID: map[uint]*Principal{1: {ID: 1}}}
|
||||
tok := sign(t, jwt.SigningMethodHS256, jwt.MapClaims{
|
||||
"sub": "1",
|
||||
"jti": "revoked",
|
||||
"exp": time.Now().Add(time.Hour).Unix(),
|
||||
"iat": time.Now().Unix(),
|
||||
}, []byte(secret))
|
||||
bl := NewMemoryBlacklist()
|
||||
if err := bl.Add(t.Context(), "revoked", time.Now().Add(time.Hour), time.Now().Add(-time.Second)); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
g := NewJWTGuard(secret, users, bl)
|
||||
req := httptest.NewRequest(http.MethodGet, "/", nil)
|
||||
req.Header.Set("Authorization", "Bearer "+tok)
|
||||
_, err := g.Authenticate(req)
|
||||
if err == nil || err.Error() != msgBadSignature {
|
||||
t.Fatalf("blacklisted: %v", err)
|
||||
}
|
||||
|
||||
reg := NewRegistry()
|
||||
if err := reg.Register("golem15.user", "jwt", g); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
mw, err := reg.Middleware("jwt")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
rec := httptest.NewRecorder()
|
||||
mw(http.HandlerFunc(func(http.ResponseWriter, *http.Request) {
|
||||
t.Fatal("handler ran")
|
||||
})).ServeHTTP(rec, req)
|
||||
if rec.Code != http.StatusUnauthorized {
|
||||
t.Fatalf("status = %d", rec.Code)
|
||||
}
|
||||
var body map[string]any
|
||||
if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if body["error"] != true || body["message"] != msgBadSignature {
|
||||
t.Fatalf("body = %v", body)
|
||||
}
|
||||
}
|
||||
|
||||
func TestJWTGuardTokensValidAfter(t *testing.T) {
|
||||
tok := sign(t, jwt.SigningMethodHS256, jwt.MapClaims{
|
||||
"sub": "1",
|
||||
"jti": "live",
|
||||
"exp": time.Now().Add(time.Hour).Unix(),
|
||||
"iat": time.Now().Add(-time.Minute).Unix(),
|
||||
}, []byte(secret))
|
||||
req := httptest.NewRequest(http.MethodGet, "/", nil)
|
||||
req.Header.Set("Authorization", "Bearer "+tok)
|
||||
|
||||
cutoff := memUsers{byID: map[uint]*Principal{1: {ID: 1, TokensValidAfter: time.Now().Add(time.Minute)}}}
|
||||
if _, err := NewJWTGuard(secret, cutoff, nil).Authenticate(req); err == nil || err.Error() != msgUserNotFound {
|
||||
t.Fatalf("after cutoff: %v", err)
|
||||
}
|
||||
// The helper extraction keeps the guard's message and makes the refusal
|
||||
// matchable, the same sentinel RefreshAudienceFor returns.
|
||||
if _, err := NewJWTGuard(secret, cutoff, nil).Authenticate(req); err == nil || err.Error() != "User not found" || !errors.Is(err, ErrSubjectRejected) {
|
||||
t.Fatalf("cutoff refusal = %v, want \"User not found\" matching ErrSubjectRejected", err)
|
||||
}
|
||||
|
||||
open := memUsers{byID: map[uint]*Principal{1: {ID: 1, TokensValidAfter: time.Now().Add(-time.Hour)}}}
|
||||
p, err := NewJWTGuard(secret, open, nil).Authenticate(req)
|
||||
if err != nil || p == nil || p.ID != 1 {
|
||||
t.Fatalf("before cutoff: %+v %v", p, err)
|
||||
}
|
||||
|
||||
zero := memUsers{byID: map[uint]*Principal{1: {ID: 1}}}
|
||||
p, err = NewJWTGuard(secret, zero, nil).Authenticate(req)
|
||||
if err != nil || p == nil || p.ID != 1 {
|
||||
t.Fatalf("zero cutoff: %+v %v", p, err)
|
||||
}
|
||||
}
|
||||
294
modules/bouncer/jwt_test.go
Normal file
294
modules/bouncer/jwt_test.go
Normal file
@@ -0,0 +1,294 @@
|
||||
package bouncer
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/base64"
|
||||
"encoding/json"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/golang-jwt/jwt/v5"
|
||||
)
|
||||
|
||||
const secret = "test-secret"
|
||||
|
||||
type memUsers struct {
|
||||
byID map[uint]*Principal
|
||||
err error
|
||||
}
|
||||
|
||||
func (m memUsers) FindByID(ctx context.Context, id uint) (*Principal, error) {
|
||||
if m.err != nil {
|
||||
return nil, m.err
|
||||
}
|
||||
return m.byID[id], nil
|
||||
}
|
||||
|
||||
func sign(t *testing.T, method jwt.SigningMethod, claims jwt.MapClaims, key []byte) string {
|
||||
t.Helper()
|
||||
tok := jwt.NewWithClaims(method, claims)
|
||||
s, err := tok.SignedString(key)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return s
|
||||
}
|
||||
|
||||
func TestVerifyRejectsBadTokens(t *testing.T) {
|
||||
valid := sign(t, jwt.SigningMethodHS256, jwt.MapClaims{
|
||||
"sub": "1",
|
||||
"exp": time.Now().Add(time.Hour).Unix(),
|
||||
}, []byte(secret))
|
||||
if sub, err := Verify(valid, secret); err != nil || sub != "1" {
|
||||
t.Fatalf("valid token: %s %v", sub, err)
|
||||
}
|
||||
|
||||
expired := sign(t, jwt.SigningMethodHS256, jwt.MapClaims{
|
||||
"sub": "1",
|
||||
"exp": time.Now().Add(-time.Hour).Unix(),
|
||||
}, []byte(secret))
|
||||
if _, err := Verify(expired, secret); err == nil || err.Error() != msgTokenExpired {
|
||||
t.Fatalf("expired: %v", err)
|
||||
}
|
||||
|
||||
none := sign(t, jwt.SigningMethodHS384, jwt.MapClaims{
|
||||
"sub": "1",
|
||||
"exp": time.Now().Add(time.Hour).Unix(),
|
||||
}, []byte(secret))
|
||||
if _, err := Verify(none, secret); err == nil || err.Error() != msgBadSignature {
|
||||
t.Fatalf("wrong alg: %v", err)
|
||||
}
|
||||
|
||||
badSig := sign(t, jwt.SigningMethodHS256, jwt.MapClaims{
|
||||
"sub": "1",
|
||||
"exp": time.Now().Add(time.Hour).Unix(),
|
||||
}, []byte("other-secret"))
|
||||
if _, err := Verify(badSig, secret); err == nil || err.Error() != msgBadSignature {
|
||||
t.Fatalf("bad sig: %v", err)
|
||||
}
|
||||
|
||||
if _, err := Verify("not-a-jwt", secret); err == nil || err.Error() != msgMalformed {
|
||||
t.Fatalf("malformed: %v", err)
|
||||
}
|
||||
|
||||
missingSub := sign(t, jwt.SigningMethodHS256, jwt.MapClaims{
|
||||
"exp": time.Now().Add(time.Hour).Unix(),
|
||||
}, []byte(secret))
|
||||
if _, err := Verify(missingSub, secret); err == nil || err.Error() != msgRequiredClaims {
|
||||
t.Fatalf("missing sub: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestMiddlewareStatusBodies(t *testing.T) {
|
||||
users := memUsers{byID: map[uint]*Principal{1: {ID: 1}}}
|
||||
h := Middleware(secret, users)(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
w.Header().Set("X-Hit", "1")
|
||||
w.WriteHeader(http.StatusNoContent)
|
||||
}))
|
||||
|
||||
assert401 := func(t *testing.T, req *http.Request, msg string) {
|
||||
t.Helper()
|
||||
rec := httptest.NewRecorder()
|
||||
h.ServeHTTP(rec, req)
|
||||
if rec.Code != http.StatusUnauthorized {
|
||||
t.Fatalf("status = %d body %s", rec.Code, rec.Body.String())
|
||||
}
|
||||
if rec.Header().Get("X-Hit") != "" {
|
||||
t.Fatal("handler ran")
|
||||
}
|
||||
var body map[string]any
|
||||
if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if body["error"] != true || body["message"] != msg {
|
||||
t.Fatalf("body = %v want %s", body, msg)
|
||||
}
|
||||
}
|
||||
|
||||
t.Run("missing", func(t *testing.T) {
|
||||
assert401(t, httptest.NewRequest(http.MethodGet, "/", nil), msgTokenNotProvided)
|
||||
})
|
||||
t.Run("unknown-user", func(t *testing.T) {
|
||||
tok := sign(t, jwt.SigningMethodHS256, jwt.MapClaims{
|
||||
"sub": "99",
|
||||
"exp": time.Now().Add(time.Hour).Unix(),
|
||||
}, []byte(secret))
|
||||
req := httptest.NewRequest(http.MethodGet, "/", nil)
|
||||
req.Header.Set("Authorization", "Bearer "+tok)
|
||||
assert401(t, req, msgUserNotFound)
|
||||
})
|
||||
t.Run("valid", func(t *testing.T) {
|
||||
tok := sign(t, jwt.SigningMethodHS256, jwt.MapClaims{
|
||||
"sub": "1",
|
||||
"exp": time.Now().Add(time.Hour).Unix(),
|
||||
}, []byte(secret))
|
||||
req := httptest.NewRequest(http.MethodGet, "/", nil)
|
||||
req.Header.Set("Authorization", "Bearer "+tok)
|
||||
rec := httptest.NewRecorder()
|
||||
h.ServeHTTP(rec, req)
|
||||
if rec.Code != http.StatusNoContent || rec.Header().Get("X-Hit") != "1" {
|
||||
t.Fatalf("status=%d hit=%s", rec.Code, rec.Header().Get("X-Hit"))
|
||||
}
|
||||
})
|
||||
t.Run("malformed", func(t *testing.T) {
|
||||
req := httptest.NewRequest(http.MethodGet, "/", nil)
|
||||
req.Header.Set("Authorization", "Bearer not-a-jwt")
|
||||
assert401(t, req, msgMalformed)
|
||||
})
|
||||
t.Run("alg-none", func(t *testing.T) {
|
||||
req := httptest.NewRequest(http.MethodGet, "/", nil)
|
||||
req.Header.Set("Authorization", "Bearer "+noneToken(t, jwt.MapClaims{
|
||||
"sub": "1",
|
||||
"exp": time.Now().Add(time.Hour).Unix(),
|
||||
}))
|
||||
assert401(t, req, msgBadSignature)
|
||||
})
|
||||
t.Run("absent-exp", func(t *testing.T) {
|
||||
tok := sign(t, jwt.SigningMethodHS256, jwt.MapClaims{"sub": "1"}, []byte(secret))
|
||||
req := httptest.NewRequest(http.MethodGet, "/", nil)
|
||||
req.Header.Set("Authorization", "Bearer "+tok)
|
||||
assert401(t, req, msgBadSignature)
|
||||
})
|
||||
}
|
||||
|
||||
func TestVerifyRejectsAlgNoneEmptySecretAndAbsentExp(t *testing.T) {
|
||||
valid := sign(t, jwt.SigningMethodHS256, jwt.MapClaims{
|
||||
"sub": "1",
|
||||
"exp": time.Now().Add(time.Hour).Unix(),
|
||||
}, []byte(secret))
|
||||
|
||||
none := noneToken(t, jwt.MapClaims{
|
||||
"sub": "1",
|
||||
"exp": time.Now().Add(time.Hour).Unix(),
|
||||
})
|
||||
if _, err := Verify(none, secret); err == nil || err.Error() != msgBadSignature {
|
||||
t.Fatalf("alg none: %v", err)
|
||||
}
|
||||
|
||||
if _, err := Verify(valid, ""); err == nil || !strings.Contains(err.Error(), "jwt secret is empty") {
|
||||
t.Fatalf("empty secret: %v", err)
|
||||
}
|
||||
if _, err := Verify(valid, " "); err == nil || !strings.Contains(err.Error(), "jwt secret is empty") {
|
||||
t.Fatalf("blank secret: %v", err)
|
||||
}
|
||||
|
||||
noExp := sign(t, jwt.SigningMethodHS256, jwt.MapClaims{"sub": "1"}, []byte(secret))
|
||||
if sub, err := Verify(noExp, secret); err == nil || sub != "" {
|
||||
t.Fatalf("absent exp must fail, got %q %v", sub, err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestVerifyAndMiddlewareOmitTokenAndSecret(t *testing.T) {
|
||||
const leakSecret = "unique-hs256-secret-value-9f3a"
|
||||
tok := sign(t, jwt.SigningMethodHS256, jwt.MapClaims{
|
||||
"sub": "1",
|
||||
"exp": time.Now().Add(time.Hour).Unix(),
|
||||
}, []byte(leakSecret))
|
||||
|
||||
assertClean := func(t *testing.T, msg string) {
|
||||
t.Helper()
|
||||
if strings.Contains(msg, leakSecret) || strings.Contains(msg, tok) {
|
||||
t.Fatalf("leaked secret or token: %s", msg)
|
||||
}
|
||||
}
|
||||
|
||||
if _, err := Verify("not-a-jwt", leakSecret); err == nil {
|
||||
t.Fatal("want malformed")
|
||||
} else {
|
||||
assertClean(t, err.Error())
|
||||
}
|
||||
if _, err := Verify(tok, "other-"+leakSecret); err == nil {
|
||||
t.Fatal("want bad signature")
|
||||
} else {
|
||||
assertClean(t, err.Error())
|
||||
}
|
||||
|
||||
h := Middleware(leakSecret, memUsers{})(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
t.Fatal("handler must not run")
|
||||
}))
|
||||
req := httptest.NewRequest(http.MethodGet, "/", nil)
|
||||
req.Header.Set("Authorization", "Bearer "+tok)
|
||||
rec := httptest.NewRecorder()
|
||||
h.ServeHTTP(rec, req)
|
||||
if rec.Code != http.StatusUnauthorized {
|
||||
t.Fatalf("status = %d", rec.Code)
|
||||
}
|
||||
assertClean(t, rec.Body.String())
|
||||
}
|
||||
|
||||
func TestContextUserRoundTrip(t *testing.T) {
|
||||
if _, ok := User(t.Context()); ok {
|
||||
t.Fatal("empty context must have no user")
|
||||
}
|
||||
p := &Principal{ID: 7, MustChangePassword: true}
|
||||
got, ok := User(WithUser(t.Context(), p))
|
||||
if !ok || got != p || got.ID != 7 || !got.MustChangePassword {
|
||||
t.Fatalf("got %+v ok=%t", got, ok)
|
||||
}
|
||||
}
|
||||
|
||||
func noneToken(t *testing.T, claims jwt.MapClaims) string {
|
||||
t.Helper()
|
||||
payload, err := json.Marshal(claims)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
header := base64.RawURLEncoding.EncodeToString([]byte(`{"alg":"none","typ":"JWT"}`))
|
||||
body := base64.RawURLEncoding.EncodeToString(payload)
|
||||
return header + "." + body + "."
|
||||
}
|
||||
|
||||
func TestVerifyRejectsFractionalSubject(t *testing.T) {
|
||||
exp := time.Now().Add(time.Hour).Unix()
|
||||
tok := sign(t, jwt.SigningMethodHS256, jwt.MapClaims{"sub": 12.5, "exp": exp}, []byte(secret))
|
||||
if sub, err := Verify(tok, secret); err == nil || sub != "" {
|
||||
t.Fatalf("fractional sub accepted: %q %v", sub, err)
|
||||
}
|
||||
tok = sign(t, jwt.SigningMethodHS256, jwt.MapClaims{"sub": 12, "exp": exp}, []byte(secret))
|
||||
if sub, err := Verify(tok, secret); err != nil || sub != "12" {
|
||||
t.Fatalf("whole sub: %q %v", sub, err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestVerifySubjectMatrix(t *testing.T) {
|
||||
exp := time.Now().Add(time.Hour).Unix()
|
||||
cases := []struct {
|
||||
name string
|
||||
sub any
|
||||
want string
|
||||
}{
|
||||
{"fractional", 12.5, ""},
|
||||
{"huge float", 1e300, ""},
|
||||
{"2^60 float", float64(1 << 60), ""},
|
||||
{"negative", -1, ""},
|
||||
{"zero", 0, ""},
|
||||
{"whole number", 12, "12"},
|
||||
{"string", "12", "12"},
|
||||
}
|
||||
for _, tc := range cases {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
tok := sign(t, jwt.SigningMethodHS256, jwt.MapClaims{"sub": tc.sub, "exp": exp}, []byte(secret))
|
||||
sub, err := Verify(tok, secret)
|
||||
if tc.want == "" {
|
||||
if err == nil || sub != "" {
|
||||
t.Fatalf("sub %v accepted: %q", tc.sub, sub)
|
||||
}
|
||||
return
|
||||
}
|
||||
if err != nil || sub != tc.want {
|
||||
t.Fatalf("sub %v: %q %v", tc.sub, sub, err)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestSubjectJSONNumber(t *testing.T) {
|
||||
for in, want := range map[string]string{"1.5": "", "-3": "", "0": "", "12": "12"} {
|
||||
if got := subject(jwt.MapClaims{"sub": json.Number(in)}); got != want {
|
||||
t.Errorf("json.Number(%q) = %q, want %q", in, got, want)
|
||||
}
|
||||
}
|
||||
}
|
||||
78
modules/bouncer/mint.go
Normal file
78
modules/bouncer/mint.go
Normal file
@@ -0,0 +1,78 @@
|
||||
package bouncer
|
||||
|
||||
import (
|
||||
"crypto/rand"
|
||||
"encoding/hex"
|
||||
"fmt"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"github.com/golang-jwt/jwt/v5"
|
||||
)
|
||||
|
||||
// prvHash is sha1("Golem15\User\Models\User"), the lock-subject PHP jwt-auth
|
||||
// stamps on every frontend user token. Backend tokens do not carry it.
|
||||
const prvHash = "a867434cbc213adfbe78a02bed7082a6bd99c883"
|
||||
|
||||
const (
|
||||
// AudienceUser is the frontend jwt-guard audience.
|
||||
AudienceUser = "user"
|
||||
// AudienceBackend is the admin jwt-guard audience.
|
||||
AudienceBackend = "backend"
|
||||
)
|
||||
|
||||
type registeredClaims struct {
|
||||
jwt.RegisteredClaims
|
||||
Prv string `json:"prv,omitempty"`
|
||||
}
|
||||
|
||||
// Mint signs a frontend-audience HS256 token. iss is the minting endpoint URL.
|
||||
// The returned jti is the token's own jti claim.
|
||||
func Mint(secret, sub, issuerURL string, ttl time.Duration) (string, string, error) {
|
||||
return MintAudience(secret, sub, issuerURL, ttl, AudienceUser)
|
||||
}
|
||||
|
||||
// MintAudience signs an HS256 token for audience. Frontend tokens keep the PHP
|
||||
// prv lock-subject; backend tokens omit it.
|
||||
func MintAudience(secret, sub, issuerURL string, ttl time.Duration, audience string) (string, string, error) {
|
||||
if strings.TrimSpace(secret) == "" {
|
||||
return "", "", fmt.Errorf("bouncer: jwt secret is empty")
|
||||
}
|
||||
if strings.TrimSpace(audience) == "" {
|
||||
return "", "", fmt.Errorf("bouncer: jwt audience is empty")
|
||||
}
|
||||
jti, err := newJTI()
|
||||
if err != nil {
|
||||
return "", "", err
|
||||
}
|
||||
now := time.Now()
|
||||
prv := ""
|
||||
if audience == AudienceUser {
|
||||
prv = prvHash
|
||||
}
|
||||
claims := registeredClaims{
|
||||
RegisteredClaims: jwt.RegisteredClaims{
|
||||
Issuer: issuerURL,
|
||||
Subject: sub,
|
||||
Audience: jwt.ClaimStrings{audience},
|
||||
ExpiresAt: jwt.NewNumericDate(now.Add(ttl)),
|
||||
NotBefore: jwt.NewNumericDate(now),
|
||||
IssuedAt: jwt.NewNumericDate(now),
|
||||
ID: jti,
|
||||
},
|
||||
Prv: prv,
|
||||
}
|
||||
signed, err := jwt.NewWithClaims(jwt.SigningMethodHS256, claims).SignedString([]byte(secret))
|
||||
if err != nil {
|
||||
return "", "", err
|
||||
}
|
||||
return signed, jti, nil
|
||||
}
|
||||
|
||||
func newJTI() (string, error) {
|
||||
buf := make([]byte, 16)
|
||||
if _, err := rand.Read(buf); err != nil {
|
||||
return "", err
|
||||
}
|
||||
return hex.EncodeToString(buf), nil
|
||||
}
|
||||
62
modules/bouncer/mint_test.go
Normal file
62
modules/bouncer/mint_test.go
Normal file
@@ -0,0 +1,62 @@
|
||||
package bouncer
|
||||
|
||||
import (
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/golang-jwt/jwt/v5"
|
||||
)
|
||||
|
||||
func TestMintClaims(t *testing.T) {
|
||||
issuer := "https://app.test/_user/api/v1/login"
|
||||
before := time.Now().Add(-2 * time.Second)
|
||||
token, jti, err := Mint(secret, "42", issuer, 60*time.Minute)
|
||||
after := time.Now().Add(2 * time.Second)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if jti == "" {
|
||||
t.Fatal("empty jti")
|
||||
}
|
||||
claims := decodeClaims(t, token, secret)
|
||||
if claims["iss"] != issuer || claims["sub"] != "42" || claims["prv"] != "a867434cbc213adfbe78a02bed7082a6bd99c883" {
|
||||
t.Fatalf("claims = %#v", claims)
|
||||
}
|
||||
if claims["jti"] != jti {
|
||||
t.Fatalf("jti claim %v != returned %s", claims["jti"], jti)
|
||||
}
|
||||
iat := claimUnix(t, claims, "iat")
|
||||
nbf := claimUnix(t, claims, "nbf")
|
||||
exp := claimUnix(t, claims, "exp")
|
||||
if iat.Before(before) || iat.After(after) || nbf.Before(before) || nbf.After(after) {
|
||||
t.Fatalf("iat=%s nbf=%s want near now", iat, nbf)
|
||||
}
|
||||
if exp.Before(iat.Add(59*time.Minute)) || exp.After(iat.Add(61*time.Minute)) {
|
||||
t.Fatalf("exp=%s iat=%s", exp, iat)
|
||||
}
|
||||
sub, err := Verify(token, secret)
|
||||
if err != nil || sub != "42" {
|
||||
t.Fatalf("Verify = %q %v", sub, err)
|
||||
}
|
||||
}
|
||||
|
||||
func decodeClaims(t *testing.T, token, key string) jwt.MapClaims {
|
||||
t.Helper()
|
||||
parser := jwt.NewParser(jwt.WithValidMethods([]string{"HS256"}), jwt.WithoutClaimsValidation())
|
||||
claims := jwt.MapClaims{}
|
||||
if _, err := parser.ParseWithClaims(token, claims, func(*jwt.Token) (any, error) {
|
||||
return []byte(key), nil
|
||||
}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return claims
|
||||
}
|
||||
|
||||
func claimUnix(t *testing.T, claims jwt.MapClaims, key string) time.Time {
|
||||
t.Helper()
|
||||
v, ok := claims[key].(float64)
|
||||
if !ok {
|
||||
t.Fatalf("%s = %#v", key, claims[key])
|
||||
}
|
||||
return time.Unix(int64(v), 0)
|
||||
}
|
||||
27
modules/bouncer/password.go
Normal file
27
modules/bouncer/password.go
Normal file
@@ -0,0 +1,27 @@
|
||||
package bouncer
|
||||
|
||||
import "golang.org/x/crypto/bcrypt"
|
||||
|
||||
// HashPassword returns a bcrypt hash of plain at the given cost.
|
||||
func HashPassword(cost int, plain string) (string, error) {
|
||||
b, err := bcrypt.GenerateFromPassword([]byte(plain), cost)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
return string(b), nil
|
||||
}
|
||||
|
||||
// CheckPassword reports whether plain matches hash. A malformed hash returns false.
|
||||
func CheckPassword(hash, plain string) bool {
|
||||
return bcrypt.CompareHashAndPassword([]byte(hash), []byte(plain)) == nil
|
||||
}
|
||||
|
||||
// NeedsRehash reports whether hash was produced below configuredCost.
|
||||
// A hash bcrypt cannot parse needs a rehash.
|
||||
func NeedsRehash(hash string, configuredCost int) bool {
|
||||
cost, err := bcrypt.Cost([]byte(hash))
|
||||
if err != nil {
|
||||
return true
|
||||
}
|
||||
return cost < configuredCost
|
||||
}
|
||||
46
modules/bouncer/password_test.go
Normal file
46
modules/bouncer/password_test.go
Normal file
@@ -0,0 +1,46 @@
|
||||
package bouncer
|
||||
|
||||
import "testing"
|
||||
|
||||
func TestPasswordHashAndCheck(t *testing.T) {
|
||||
hash, err := HashPassword(10, "secret")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if !CheckPassword(hash, "secret") {
|
||||
t.Fatal("matching password rejected")
|
||||
}
|
||||
if CheckPassword(hash, "wrong") {
|
||||
t.Fatal("wrong password accepted")
|
||||
}
|
||||
if CheckPassword("not-a-hash", "secret") {
|
||||
t.Fatal("malformed hash must not panic or match")
|
||||
}
|
||||
}
|
||||
|
||||
func TestPasswordAcceptsPHPHash(t *testing.T) {
|
||||
// php -r 'echo password_hash("golem15-a1-check", PASSWORD_BCRYPT, ["cost"=>10]);'
|
||||
const phpHash = "$2y$10$vvjEAuqFJXs6lWVy1eo5FuTZZr84LrP8Oz2c6pzAw4f2pk6u2xV5W"
|
||||
if !CheckPassword(phpHash, "golem15-a1-check") {
|
||||
t.Fatal("PHP $2y$ hash rejected")
|
||||
}
|
||||
if CheckPassword(phpHash, "other") {
|
||||
t.Fatal("PHP hash matched the wrong password")
|
||||
}
|
||||
}
|
||||
|
||||
func TestNeedsRehash(t *testing.T) {
|
||||
hash, err := HashPassword(10, "secret")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if !NeedsRehash(hash, 12) {
|
||||
t.Fatal("lower cost must need rehash")
|
||||
}
|
||||
if NeedsRehash(hash, 10) || NeedsRehash(hash, 8) {
|
||||
t.Fatal("equal or higher cost must not need rehash")
|
||||
}
|
||||
if !NeedsRehash("not-a-hash", 10) {
|
||||
t.Fatal("unparseable hash must need rehash")
|
||||
}
|
||||
}
|
||||
115
modules/bouncer/phase07_coverage_test.go
Normal file
115
modules/bouncer/phase07_coverage_test.go
Normal file
@@ -0,0 +1,115 @@
|
||||
package bouncer
|
||||
|
||||
import (
|
||||
"context"
|
||||
"database/sql"
|
||||
"sync"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
_ "github.com/jackc/pgx/v5/stdlib"
|
||||
"github.com/testcontainers/testcontainers-go"
|
||||
"github.com/testcontainers/testcontainers-go/modules/postgres"
|
||||
)
|
||||
|
||||
func TestMintRefreshBlacklistRoundTrip(t *testing.T) {
|
||||
const secret = "summercms-test-only-hs256-secret"
|
||||
bl := NewMemoryBlacklist()
|
||||
token, jti, err := Mint(secret, "7", "http://example.com/_user/api/v1/login", time.Hour)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
sub, err := Verify(token, secret)
|
||||
if err != nil || sub != "7" {
|
||||
t.Fatalf("verify %q %v", sub, err)
|
||||
}
|
||||
next, err := Refresh(secret, token, 2*time.Hour, bl, 0, "http://example.com/_user/api/v1/refresh")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, err := Verify(next, secret); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
blocked, err := bl.IsBlacklisted(context.Background(), jti)
|
||||
if err != nil || !blocked {
|
||||
t.Fatalf("old jti blacklisted=%t err=%v", blocked, err)
|
||||
}
|
||||
if _, err := Refresh(secret, token, 2*time.Hour, bl, 0, "http://example.com/_user/api/v1/refresh"); err == nil {
|
||||
t.Fatal("blacklisted token refreshed")
|
||||
}
|
||||
}
|
||||
|
||||
func TestMemoryBlacklistConcurrent(t *testing.T) {
|
||||
bl := NewMemoryBlacklist()
|
||||
var wg sync.WaitGroup
|
||||
for i := 0; i < 8; i++ {
|
||||
wg.Add(1)
|
||||
go func() {
|
||||
defer wg.Done()
|
||||
now := time.Now()
|
||||
if err := bl.Add(context.Background(), "jti", now.Add(time.Hour), now.Add(-time.Second)); err != nil {
|
||||
t.Error(err)
|
||||
return
|
||||
}
|
||||
if _, err := bl.IsBlacklisted(context.Background(), "jti"); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
}()
|
||||
}
|
||||
wg.Wait()
|
||||
}
|
||||
|
||||
func TestPostgresBlacklistConcurrent(t *testing.T) {
|
||||
if testing.Short() {
|
||||
t.Skip("postgres blacklist concurrency needs testcontainers")
|
||||
}
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
|
||||
defer cancel()
|
||||
ctr, err := postgres.Run(ctx, "postgres:16-alpine",
|
||||
postgres.WithDatabase("bl"),
|
||||
postgres.WithUsername("bl"),
|
||||
postgres.WithPassword("bl"),
|
||||
postgres.BasicWaitStrategies(),
|
||||
testcontainers.WithEnv(map[string]string{
|
||||
"POSTGRES_INITDB_ARGS": "--locale-provider=icu --icu-locale=pl-PL --encoding=UTF8",
|
||||
}),
|
||||
)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
t.Cleanup(func() { _ = ctr.Terminate(context.Background()) })
|
||||
dsn, err := ctr.ConnectionString(ctx, "sslmode=disable")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
db, err := sql.Open("pgx", dsn)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
t.Cleanup(func() { _ = db.Close() })
|
||||
if _, err := db.ExecContext(ctx, `CREATE TABLE jwt_blacklist (
|
||||
jti text PRIMARY KEY,
|
||||
expires_at timestamptz NOT NULL,
|
||||
valid_until timestamptz NOT NULL
|
||||
)`); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
bl := NewPostgresBlacklist(db, "jwt_blacklist")
|
||||
var wg sync.WaitGroup
|
||||
for i := 0; i < 8; i++ {
|
||||
wg.Add(1)
|
||||
go func() {
|
||||
defer wg.Done()
|
||||
now := time.Now()
|
||||
if err := bl.Add(ctx, "shared", now.Add(time.Hour), now.Add(-time.Second)); err != nil {
|
||||
t.Error(err)
|
||||
return
|
||||
}
|
||||
blocked, err := bl.IsBlacklisted(ctx, "shared")
|
||||
if err != nil || !blocked {
|
||||
t.Errorf("blocked=%t err=%v", blocked, err)
|
||||
}
|
||||
}()
|
||||
}
|
||||
wg.Wait()
|
||||
}
|
||||
121
modules/bouncer/refresh.go
Normal file
121
modules/bouncer/refresh.go
Normal file
@@ -0,0 +1,121 @@
|
||||
package bouncer
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"github.com/golang-jwt/jwt/v5"
|
||||
)
|
||||
|
||||
// Refresh issues a new token for a still-refreshable subject. exp is not
|
||||
// required to be in the future; iat must fall inside refreshTTL. The previous
|
||||
// jti is blacklisted with validUntil = now+grace. Storage expiry follows PHP
|
||||
// jwt-auth: the later of the old exp and iat+refreshTTL, plus one minute, so
|
||||
// a logged-out token cannot be refreshed again for the rest of its refresh window.
|
||||
func Refresh(secret, tokenString string, refreshTTL time.Duration, bl BlacklistStore, grace time.Duration, issuerURL string) (string, error) {
|
||||
return refreshAudience(secret, tokenString, AudienceUser, true, refreshTTL, bl, grace, issuerURL, nil)
|
||||
}
|
||||
|
||||
// RefreshAudience reissues a token that already carries audience. Missing aud is rejected.
|
||||
func RefreshAudience(secret, tokenString, audience string, refreshTTL time.Duration, bl BlacklistStore, grace time.Duration, issuerURL string) (string, error) {
|
||||
if strings.TrimSpace(audience) == "" {
|
||||
return "", errors.New("bouncer: jwt audience is empty")
|
||||
}
|
||||
return refreshAudience(secret, tokenString, audience, false, refreshTTL, bl, grace, issuerURL, nil)
|
||||
}
|
||||
|
||||
// RefreshAudienceFor is RefreshAudience plus the JWT guard's subject checks
|
||||
// before minting: the subject is loaded through users, and a missing,
|
||||
// deleted or not-activated user, or a token issued before the user's
|
||||
// TokensValidAfter cutoff, is refused. The lookup runs only after every
|
||||
// token-only check (signature, audience, refresh window, blacklist, exp)
|
||||
// passed, and a refused subject neither mints a token nor blacklists the old
|
||||
// jti. Only subject refusals match errors.Is(err, ErrSubjectRejected); a
|
||||
// provider failure returns a different error.
|
||||
func RefreshAudienceFor(ctx context.Context, users UserProvider, secret, tokenString, audience string, refreshTTL time.Duration, bl BlacklistStore, grace time.Duration, issuerURL string) (string, error) {
|
||||
if strings.TrimSpace(audience) == "" {
|
||||
return "", errors.New("bouncer: jwt audience is empty")
|
||||
}
|
||||
check := func(sub string, iat time.Time) error {
|
||||
user, err := subjectPrincipal(ctx, users, sub)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if issuedBeforeCutoff(user, iat) {
|
||||
return ErrSubjectRejected
|
||||
}
|
||||
return nil
|
||||
}
|
||||
return refreshAudience(secret, tokenString, audience, false, refreshTTL, bl, grace, issuerURL, check)
|
||||
}
|
||||
|
||||
// refreshAudience holds the shared refresh flow. check, when non-nil, runs
|
||||
// after every token-only check and immediately before minting.
|
||||
func refreshAudience(secret, tokenString, audience string, allowMissing bool, refreshTTL time.Duration, bl BlacklistStore, grace time.Duration, issuerURL string, check func(sub string, iat time.Time) error) (string, error) {
|
||||
if strings.TrimSpace(secret) == "" {
|
||||
return "", errors.New("bouncer: jwt secret is empty")
|
||||
}
|
||||
parser := jwt.NewParser(jwt.WithValidMethods([]string{"HS256"}), jwt.WithoutClaimsValidation())
|
||||
claims := jwt.MapClaims{}
|
||||
if _, err := parser.ParseWithClaims(tokenString, claims, func(*jwt.Token) (any, error) {
|
||||
return []byte(secret), nil
|
||||
}); err != nil {
|
||||
return "", mapJWTError(err)
|
||||
}
|
||||
sub := subject(claims)
|
||||
if sub == "" {
|
||||
return "", errors.New(msgRequiredClaims)
|
||||
}
|
||||
auds := claimAudiences(claims)
|
||||
if len(auds) == 0 {
|
||||
if !allowMissing {
|
||||
return "", errors.New(msgBadSignature)
|
||||
}
|
||||
} else if !audienceMatches(claims, audience) {
|
||||
return "", errors.New(msgBadSignature)
|
||||
}
|
||||
iat, ok := claimTime(claims, "iat")
|
||||
if !ok || time.Now().After(iat.Add(refreshTTL)) {
|
||||
return "", errors.New("Token has expired and can no longer be refreshed")
|
||||
}
|
||||
jti, _ := claims["jti"].(string)
|
||||
if bl != nil && jti != "" {
|
||||
blocked, err := bl.IsBlacklisted(context.Background(), jti)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
if blocked {
|
||||
return "", errors.New("The token has been blacklisted")
|
||||
}
|
||||
}
|
||||
exp, expOK := claimTime(claims, "exp")
|
||||
ttl := exp.Sub(iat)
|
||||
if !expOK || ttl <= 0 {
|
||||
return "", errors.New(msgRequiredClaims)
|
||||
}
|
||||
if check != nil {
|
||||
if err := check(sub, iat); err != nil {
|
||||
return "", err
|
||||
}
|
||||
}
|
||||
next, _, err := MintAudience(secret, sub, issuerURL, ttl, audience)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
if bl != nil && jti != "" {
|
||||
// PHP Blacklist::getMinutesUntilExpired keeps the row until the later of
|
||||
// exp and iat+refreshTTL, plus one minute. Using exp alone would drop a
|
||||
// logged-out token whose access exp has passed but whose refresh window
|
||||
// has not, and the next Refresh would succeed.
|
||||
expiresAt := iat.Add(refreshTTL).Add(time.Minute)
|
||||
if until := exp.Add(time.Minute); until.After(expiresAt) {
|
||||
expiresAt = until
|
||||
}
|
||||
if err := bl.Add(context.Background(), jti, expiresAt, time.Now().Add(grace)); err != nil {
|
||||
return "", err
|
||||
}
|
||||
}
|
||||
return next, nil
|
||||
}
|
||||
261
modules/bouncer/refresh_test.go
Normal file
261
modules/bouncer/refresh_test.go
Normal file
@@ -0,0 +1,261 @@
|
||||
package bouncer
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"sync/atomic"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/golang-jwt/jwt/v5"
|
||||
)
|
||||
|
||||
func TestRefreshWithinWindow(t *testing.T) {
|
||||
old := sign(t, jwt.SigningMethodHS256, jwt.MapClaims{
|
||||
"sub": "42",
|
||||
"iss": "https://app.test/_user/api/v1/login",
|
||||
"prv": "a867434cbc213adfbe78a02bed7082a6bd99c883",
|
||||
"jti": "old-jti",
|
||||
"iat": time.Now().Add(-10 * time.Minute).Unix(),
|
||||
"nbf": time.Now().Add(-10 * time.Minute).Unix(),
|
||||
"exp": time.Now().Add(-time.Minute).Unix(),
|
||||
}, []byte(secret))
|
||||
next, err := Refresh(secret, old, time.Hour, NewMemoryBlacklist(), 0, "https://app.test/_user/api/v1/refresh")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
claims := decodeClaims(t, next, secret)
|
||||
if claims["sub"] != "42" || claims["prv"] != "a867434cbc213adfbe78a02bed7082a6bd99c883" {
|
||||
t.Fatalf("claims = %#v", claims)
|
||||
}
|
||||
if claims["iss"] != "https://app.test/_user/api/v1/refresh" {
|
||||
t.Fatalf("iss = %v", claims["iss"])
|
||||
}
|
||||
if claims["jti"] == "old-jti" || claims["jti"] == "" {
|
||||
t.Fatalf("jti = %v", claims["jti"])
|
||||
}
|
||||
iat := claimUnix(t, claims, "iat")
|
||||
if time.Since(iat) > 5*time.Second {
|
||||
t.Fatalf("iat not fresh: %s", iat)
|
||||
}
|
||||
}
|
||||
|
||||
func TestRefreshPastTTL(t *testing.T) {
|
||||
old := sign(t, jwt.SigningMethodHS256, jwt.MapClaims{
|
||||
"sub": "42",
|
||||
"jti": "stale",
|
||||
"iat": time.Now().Add(-2 * time.Hour).Unix(),
|
||||
"exp": time.Now().Add(-time.Hour).Unix(),
|
||||
}, []byte(secret))
|
||||
if _, err := Refresh(secret, old, time.Hour, NewMemoryBlacklist(), 0, "https://app.test/_user/api/v1/refresh"); err == nil {
|
||||
t.Fatal("want error past refresh TTL")
|
||||
}
|
||||
}
|
||||
|
||||
func TestRefreshRejectsBadSignature(t *testing.T) {
|
||||
old := sign(t, jwt.SigningMethodHS256, jwt.MapClaims{
|
||||
"sub": "42",
|
||||
"jti": "x",
|
||||
"iat": time.Now().Unix(),
|
||||
"exp": time.Now().Add(time.Hour).Unix(),
|
||||
}, []byte("other-secret"))
|
||||
if _, err := Refresh(secret, old, time.Hour, nil, 0, "https://app.test/_user/api/v1/refresh"); err == nil {
|
||||
t.Fatal("want signature error")
|
||||
}
|
||||
}
|
||||
|
||||
func TestRefreshBlacklistsOldJTI(t *testing.T) {
|
||||
old := sign(t, jwt.SigningMethodHS256, jwt.MapClaims{
|
||||
"sub": "42",
|
||||
"jti": "rotate-me",
|
||||
"iat": time.Now().Add(-time.Minute).Unix(),
|
||||
"exp": time.Now().Add(-time.Second).Unix(),
|
||||
}, []byte(secret))
|
||||
bl := NewMemoryBlacklist()
|
||||
if _, err := Refresh(secret, old, time.Hour, bl, 0, "https://app.test/_user/api/v1/refresh"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
blocked, err := bl.IsBlacklisted(t.Context(), "rotate-me")
|
||||
if err != nil || !blocked {
|
||||
t.Fatalf("grace 0 blacklisted=%t err=%v", blocked, err)
|
||||
}
|
||||
|
||||
old2 := sign(t, jwt.SigningMethodHS256, jwt.MapClaims{
|
||||
"sub": "42",
|
||||
"jti": "grace-me",
|
||||
"iat": time.Now().Add(-time.Minute).Unix(),
|
||||
"exp": time.Now().Add(-time.Second).Unix(),
|
||||
}, []byte(secret))
|
||||
bl2 := NewMemoryBlacklist()
|
||||
if _, err := Refresh(secret, old2, time.Hour, bl2, time.Hour, "https://app.test/_user/api/v1/refresh"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
blocked, err = bl2.IsBlacklisted(t.Context(), "grace-me")
|
||||
if err != nil || blocked {
|
||||
t.Fatalf("inside grace blacklisted=%t err=%v", blocked, err)
|
||||
}
|
||||
|
||||
forever := sign(t, jwt.SigningMethodHS256, jwt.MapClaims{
|
||||
"sub": "42",
|
||||
"jti": "logged-out",
|
||||
"iat": time.Now().Unix(),
|
||||
"exp": time.Now().Add(time.Hour).Unix(),
|
||||
}, []byte(secret))
|
||||
if err := bl.Add(t.Context(), "logged-out", time.Now().Add(2*time.Hour), time.Now().Add(-time.Second)); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, err := Refresh(secret, forever, time.Hour, bl, 0, "https://app.test/_user/api/v1/refresh"); err == nil {
|
||||
t.Fatal("blacklisted token must not refresh")
|
||||
}
|
||||
}
|
||||
|
||||
// countingUsers wraps a provider and counts FindByID calls, proving which
|
||||
// refusals happen before the subject lookup.
|
||||
type countingUsers struct {
|
||||
inner UserProvider
|
||||
calls *atomic.Int32
|
||||
}
|
||||
|
||||
func (c countingUsers) FindByID(ctx context.Context, id uint) (*Principal, error) {
|
||||
c.calls.Add(1)
|
||||
return c.inner.FindByID(ctx, id)
|
||||
}
|
||||
|
||||
func TestRefreshAudienceForSubject(t *testing.T) {
|
||||
const issuer = "https://app.test/backend/api/v1/auth/refresh"
|
||||
iat := time.Now().Add(-10 * time.Minute).Truncate(time.Second)
|
||||
token := func(t *testing.T, sub, jti, aud string, iat time.Time, key string) string {
|
||||
t.Helper()
|
||||
claims := jwt.MapClaims{
|
||||
"sub": sub,
|
||||
"jti": jti,
|
||||
"iat": iat.Unix(),
|
||||
"nbf": iat.Unix(),
|
||||
"exp": iat.Add(5 * time.Minute).Unix(),
|
||||
}
|
||||
if aud != "" {
|
||||
claims["aud"] = aud
|
||||
}
|
||||
return sign(t, jwt.SigningMethodHS256, claims, []byte(key))
|
||||
}
|
||||
backend := func(t *testing.T, sub, jti string) string {
|
||||
t.Helper()
|
||||
return token(t, sub, jti, AudienceBackend, iat, secret)
|
||||
}
|
||||
users := func(p *Principal) memUsers {
|
||||
return memUsers{byID: map[uint]*Principal{7: p}}
|
||||
}
|
||||
blacklisted := func(t *testing.T, bl BlacklistStore, jti string) bool {
|
||||
t.Helper()
|
||||
blocked, err := bl.IsBlacklisted(context.Background(), jti)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return blocked
|
||||
}
|
||||
|
||||
t.Run("active principal without a cutoff refreshes", func(t *testing.T) {
|
||||
bl := NewMemoryBlacklist()
|
||||
next, err := RefreshAudienceFor(context.Background(), users(&Principal{ID: 7, Backend: true}), secret, backend(t, "7", "active"), AudienceBackend, time.Hour, bl, 0, issuer)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
claims := decodeClaims(t, next, secret)
|
||||
if claims["sub"] != "7" || !audienceMatches(claims, AudienceBackend) {
|
||||
t.Fatalf("claims = %#v", claims)
|
||||
}
|
||||
if !blacklisted(t, bl, "active") {
|
||||
t.Fatal("old jti was not blacklisted after a successful refresh")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("token issued before the cutoff is a subject refusal", func(t *testing.T) {
|
||||
bl := NewMemoryBlacklist()
|
||||
p := &Principal{ID: 7, TokensValidAfter: iat.Add(time.Minute)}
|
||||
next, err := RefreshAudienceFor(context.Background(), users(p), secret, backend(t, "7", "cut"), AudienceBackend, time.Hour, bl, 0, issuer)
|
||||
if !errors.Is(err, ErrSubjectRejected) || next != "" {
|
||||
t.Fatalf("pre-cutoff refresh = %q, %v; want ErrSubjectRejected", next, err)
|
||||
}
|
||||
if err.Error() != msgUserNotFound {
|
||||
t.Fatalf("message = %q", err.Error())
|
||||
}
|
||||
if blacklisted(t, bl, "cut") {
|
||||
t.Fatal("a refused subject blacklisted the old jti")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("token issued after the cutoff refreshes", func(t *testing.T) {
|
||||
p := &Principal{ID: 7, TokensValidAfter: iat.Add(-time.Second)}
|
||||
if _, err := RefreshAudienceFor(context.Background(), users(p), secret, backend(t, "7", "after"), AudienceBackend, time.Hour, NewMemoryBlacklist(), 0, issuer); err != nil {
|
||||
t.Fatalf("post-cutoff refresh: %v", err)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("missing or not-activated principal is a subject refusal", func(t *testing.T) {
|
||||
bl := NewMemoryBlacklist()
|
||||
_, err := RefreshAudienceFor(context.Background(), memUsers{byID: map[uint]*Principal{}}, secret, backend(t, "7", "gone"), AudienceBackend, time.Hour, bl, 0, issuer)
|
||||
if !errors.Is(err, ErrSubjectRejected) {
|
||||
t.Fatalf("missing principal: %v", err)
|
||||
}
|
||||
if blacklisted(t, bl, "gone") {
|
||||
t.Fatal("a refused subject blacklisted the old jti")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("nil provider is a subject refusal", func(t *testing.T) {
|
||||
_, err := RefreshAudienceFor(context.Background(), nil, secret, backend(t, "7", "nil-users"), AudienceBackend, time.Hour, NewMemoryBlacklist(), 0, issuer)
|
||||
if !errors.Is(err, ErrSubjectRejected) {
|
||||
t.Fatalf("nil users: %v", err)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("non-numeric subject is a subject refusal", func(t *testing.T) {
|
||||
_, err := RefreshAudienceFor(context.Background(), users(&Principal{ID: 7}), secret, backend(t, "seven", "nan"), AudienceBackend, time.Hour, NewMemoryBlacklist(), 0, issuer)
|
||||
if !errors.Is(err, ErrSubjectRejected) {
|
||||
t.Fatalf("non-numeric sub: %v", err)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("provider error is not a subject refusal", func(t *testing.T) {
|
||||
bl := NewMemoryBlacklist()
|
||||
_, err := RefreshAudienceFor(context.Background(), memUsers{err: errors.New("db down")}, secret, backend(t, "7", "db-error"), AudienceBackend, time.Hour, bl, 0, issuer)
|
||||
if err == nil || errors.Is(err, ErrSubjectRejected) {
|
||||
t.Fatalf("provider error: %v, want a non-subject error", err)
|
||||
}
|
||||
if blacklisted(t, bl, "db-error") {
|
||||
t.Fatal("a provider error blacklisted the old jti")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("token-only refusals never reach the provider", func(t *testing.T) {
|
||||
preBlocked := NewMemoryBlacklist()
|
||||
if err := preBlocked.Add(context.Background(), "blocked", time.Now().Add(time.Hour), time.Now()); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
cases := map[string]struct {
|
||||
tok string
|
||||
bl BlacklistStore
|
||||
}{
|
||||
"outside the refresh window": {tok: token(t, "7", "stale", AudienceBackend, time.Now().Add(-2*time.Hour), secret), bl: NewMemoryBlacklist()},
|
||||
"frontend audience": {tok: token(t, "7", "front", AudienceUser, iat, secret), bl: NewMemoryBlacklist()},
|
||||
"wrong secret": {tok: token(t, "7", "forged", AudienceBackend, iat, "other-secret"), bl: NewMemoryBlacklist()},
|
||||
"already blacklisted": {tok: backend(t, "7", "blocked"), bl: preBlocked},
|
||||
}
|
||||
for name, tc := range cases {
|
||||
calls := &atomic.Int32{}
|
||||
provider := countingUsers{inner: users(&Principal{ID: 7}), calls: calls}
|
||||
if _, err := RefreshAudienceFor(context.Background(), provider, secret, tc.tok, AudienceBackend, time.Hour, tc.bl, 0, issuer); err == nil {
|
||||
t.Fatalf("%s: refresh succeeded", name)
|
||||
}
|
||||
if n := calls.Load(); n != 0 {
|
||||
t.Fatalf("%s: provider called %d times before the token checks refused", name, n)
|
||||
}
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("empty audience is rejected", func(t *testing.T) {
|
||||
if _, err := RefreshAudienceFor(context.Background(), users(&Principal{ID: 7}), secret, backend(t, "7", "no-aud"), " ", time.Hour, nil, 0, issuer); err == nil {
|
||||
t.Fatal("empty audience accepted")
|
||||
}
|
||||
})
|
||||
}
|
||||
103
modules/bouncer/registry.go
Normal file
103
modules/bouncer/registry.go
Normal file
@@ -0,0 +1,103 @@
|
||||
package bouncer
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"fmt"
|
||||
"net/http"
|
||||
"reflect"
|
||||
)
|
||||
|
||||
type namedGuard struct {
|
||||
pluginID string
|
||||
g any
|
||||
}
|
||||
|
||||
// Registry stores named Guard / CredentialGuard implementations and derives
|
||||
// auth middleware from them.
|
||||
type Registry struct {
|
||||
guards map[string]namedGuard
|
||||
}
|
||||
|
||||
// NewRegistry returns an empty named-guard registry.
|
||||
func NewRegistry() *Registry {
|
||||
return &Registry{guards: make(map[string]namedGuard)}
|
||||
}
|
||||
|
||||
// Register stores g under name. g must implement Guard or CredentialGuard.
|
||||
// Empty name, nil g, a type implementing neither, or a duplicate name all
|
||||
// fail with a "bouncer: ..." error naming pluginID and name.
|
||||
func (reg *Registry) Register(pluginID, name string, g any) error {
|
||||
if reg == nil {
|
||||
return fmt.Errorf("bouncer: registry is nil")
|
||||
}
|
||||
if name == "" || g == nil {
|
||||
return fmt.Errorf("bouncer: plugin %q registered empty guard %q", pluginID, name)
|
||||
}
|
||||
switch rv := reflect.ValueOf(g); rv.Kind() {
|
||||
case reflect.Pointer, reflect.Map, reflect.Slice, reflect.Func, reflect.Chan, reflect.Interface:
|
||||
if rv.IsNil() {
|
||||
return fmt.Errorf("bouncer: plugin %q registered empty guard %q", pluginID, name)
|
||||
}
|
||||
}
|
||||
_, isGuard := g.(Guard)
|
||||
_, isCred := g.(CredentialGuard)
|
||||
if !isGuard && !isCred {
|
||||
return fmt.Errorf("bouncer: plugin %q registered guard %q that implements neither Guard nor CredentialGuard", pluginID, name)
|
||||
}
|
||||
if existing, ok := reg.guards[name]; ok {
|
||||
return fmt.Errorf("bouncer: guard %q already registered by %s", name, existing.pluginID)
|
||||
}
|
||||
if reg.guards == nil {
|
||||
reg.guards = make(map[string]namedGuard)
|
||||
}
|
||||
reg.guards[name] = namedGuard{pluginID: pluginID, g: g}
|
||||
return nil
|
||||
}
|
||||
|
||||
// Middleware derives an http middleware from a registered guard. Unknown
|
||||
// names fail (fail boot, mirrors surf.RegisterMiddleware's contract).
|
||||
// On Authenticate/AuthenticateCredential success: WithUser (+WithCredential
|
||||
// if a credential was returned) then next.ServeHTTP.
|
||||
// On failure: if the guard implements UnauthorizedWriter, it writes the
|
||||
// response and the chain stops; otherwise next.ServeHTTP runs unauthenticated.
|
||||
func (reg *Registry) Middleware(name string) (func(http.Handler) http.Handler, error) {
|
||||
if reg == nil {
|
||||
return nil, fmt.Errorf("bouncer: registry is nil")
|
||||
}
|
||||
ng, ok := reg.guards[name]
|
||||
if !ok {
|
||||
return nil, fmt.Errorf("bouncer: unknown guard %q", name)
|
||||
}
|
||||
return func(next http.Handler) http.Handler {
|
||||
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
principal, cred, err := authenticate(ng.g, r)
|
||||
if err != nil || principal == nil {
|
||||
if wtr, ok := ng.g.(UnauthorizedWriter); ok {
|
||||
if err == nil {
|
||||
err = errors.New("unauthenticated")
|
||||
}
|
||||
wtr.WriteUnauthorized(w, err)
|
||||
return
|
||||
}
|
||||
next.ServeHTTP(w, r)
|
||||
return
|
||||
}
|
||||
ctx := WithUser(r.Context(), principal)
|
||||
if cred != nil {
|
||||
ctx = WithCredential(ctx, cred)
|
||||
}
|
||||
next.ServeHTTP(w, r.WithContext(ctx))
|
||||
})
|
||||
}, nil
|
||||
}
|
||||
|
||||
func authenticate(g any, r *http.Request) (*Principal, any, error) {
|
||||
if cg, ok := g.(CredentialGuard); ok {
|
||||
return cg.AuthenticateCredential(r)
|
||||
}
|
||||
if gd, ok := g.(Guard); ok {
|
||||
p, err := gd.Authenticate(r)
|
||||
return p, nil, err
|
||||
}
|
||||
return nil, nil, fmt.Errorf("bouncer: guard implements neither Guard nor CredentialGuard")
|
||||
}
|
||||
85
modules/bouncer/registry_coverage_test.go
Normal file
85
modules/bouncer/registry_coverage_test.go
Normal file
@@ -0,0 +1,85 @@
|
||||
package bouncer
|
||||
|
||||
import (
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
// Gap (a): Registry.Register of a type implementing neither Guard nor
|
||||
// CredentialGuard is already asserted by TestRegisterNeitherInterfaceNamesPluginAndName.
|
||||
// This file covers the remaining Register fail-loud branches and the
|
||||
// authenticate() default that Register itself makes unreachable through
|
||||
// the public API.
|
||||
|
||||
func TestRegisterNilRegistryAndEmptyGuard(t *testing.T) {
|
||||
var nilReg *Registry
|
||||
if err := nilReg.Register("golem15.demo", "jwt", writerGuard{}); err == nil || !strings.Contains(err.Error(), "nil") {
|
||||
t.Fatalf("nil registry: %v", err)
|
||||
}
|
||||
reg := NewRegistry()
|
||||
if err := reg.Register("golem15.demo", "", writerGuard{}); err == nil || !strings.Contains(err.Error(), "golem15.demo") {
|
||||
t.Fatalf("empty name: %v", err)
|
||||
}
|
||||
if err := reg.Register("golem15.demo", "jwt", nil); err == nil || !strings.Contains(err.Error(), "jwt") {
|
||||
t.Fatalf("nil guard: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAuthenticateDefaultNeitherInterface(t *testing.T) {
|
||||
// Register rejects this type; authenticate's default is only reachable
|
||||
// by calling it directly (same-package coverage of the fail-closed branch).
|
||||
p, cred, err := authenticate(notAGuard{}, httptest.NewRequest(http.MethodGet, "/", nil))
|
||||
if p != nil || cred != nil {
|
||||
t.Fatalf("principal=%v cred=%v", p, cred)
|
||||
}
|
||||
if err == nil || !strings.Contains(err.Error(), "neither Guard nor CredentialGuard") {
|
||||
t.Fatalf("want neither-interface error, got %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestNilRegistryMiddleware(t *testing.T) {
|
||||
var nilReg *Registry
|
||||
if _, err := nilReg.Middleware("jwt"); err == nil || !strings.Contains(err.Error(), "nil") {
|
||||
t.Fatalf("nil registry Middleware: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestGuardAuthenticateSuccessAttachesUser(t *testing.T) {
|
||||
reg := NewRegistry()
|
||||
principal := &Principal{ID: 7}
|
||||
if err := reg.Register("golem15.user", "jwt", writerGuard{principal: principal}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
mw, err := reg.Middleware("jwt")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
h := mw(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
got, ok := User(r.Context())
|
||||
if !ok || got != principal {
|
||||
t.Fatalf("user = %+v ok=%t", got, ok)
|
||||
}
|
||||
if _, ok := Credential(r.Context()); ok {
|
||||
t.Fatal("plain Guard must not attach a credential")
|
||||
}
|
||||
w.WriteHeader(http.StatusNoContent)
|
||||
}))
|
||||
rec := httptest.NewRecorder()
|
||||
h.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/", nil))
|
||||
if rec.Code != http.StatusNoContent {
|
||||
t.Fatalf("status = %d", rec.Code)
|
||||
}
|
||||
}
|
||||
|
||||
func TestWithUserNilContext(t *testing.T) {
|
||||
p := &Principal{ID: 1}
|
||||
got, ok := User(WithUser(nil, p))
|
||||
if !ok || got != p {
|
||||
t.Fatalf("got %+v ok=%t", got, ok)
|
||||
}
|
||||
if _, ok := User(nil); ok {
|
||||
t.Fatal("nil context must have no user")
|
||||
}
|
||||
}
|
||||
291
modules/bouncer/registry_test.go
Normal file
291
modules/bouncer/registry_test.go
Normal file
@@ -0,0 +1,291 @@
|
||||
package bouncer
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/golang-jwt/jwt/v5"
|
||||
)
|
||||
|
||||
type writerGuard struct {
|
||||
principal *Principal
|
||||
err error
|
||||
wrote *bool
|
||||
}
|
||||
|
||||
func (g writerGuard) Authenticate(*http.Request) (*Principal, error) {
|
||||
return g.principal, g.err
|
||||
}
|
||||
|
||||
func (g writerGuard) WriteUnauthorized(w http.ResponseWriter, err error) {
|
||||
if g.wrote != nil {
|
||||
*g.wrote = true
|
||||
}
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
w.WriteHeader(http.StatusUnauthorized)
|
||||
_, _ = w.Write([]byte(`{"from":"writer"}`))
|
||||
}
|
||||
|
||||
type credOnlyGuard struct {
|
||||
principal *Principal
|
||||
cred any
|
||||
err error
|
||||
}
|
||||
|
||||
func (g credOnlyGuard) AuthenticateCredential(*http.Request) (*Principal, any, error) {
|
||||
return g.principal, g.cred, g.err
|
||||
}
|
||||
|
||||
type notAGuard struct{}
|
||||
|
||||
func TestDuplicateGuardNameFailsWithPluginAndName(t *testing.T) {
|
||||
reg := NewRegistry()
|
||||
if err := reg.Register("golem15.user", "jwt", writerGuard{}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
err := reg.Register("golem15.acme", "jwt", writerGuard{})
|
||||
if err == nil || !strings.Contains(err.Error(), "golem15.user") || !strings.Contains(err.Error(), "jwt") {
|
||||
t.Fatalf("want plugin and guard name in error, got %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestUnknownGuardNameFails(t *testing.T) {
|
||||
reg := NewRegistry()
|
||||
_, err := reg.Middleware("jwt")
|
||||
if err == nil || !strings.Contains(err.Error(), "jwt") {
|
||||
t.Fatalf("want guard name in error, got %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestRegisterNeitherInterfaceNamesPluginAndName(t *testing.T) {
|
||||
reg := NewRegistry()
|
||||
err := reg.Register("golem15.demo", "oops", notAGuard{})
|
||||
if err == nil || !strings.Contains(err.Error(), "golem15.demo") || !strings.Contains(err.Error(), "oops") {
|
||||
t.Fatalf("want plugin and guard name in error, got %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestWriterGuardFailureWritesOwnResponse(t *testing.T) {
|
||||
wrote := false
|
||||
reg := NewRegistry()
|
||||
if err := reg.Register("golem15.user", "jwt", writerGuard{
|
||||
err: errors.New("nope"),
|
||||
wrote: &wrote,
|
||||
}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
mw, err := reg.Middleware("jwt")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
called := false
|
||||
h := mw(http.HandlerFunc(func(http.ResponseWriter, *http.Request) {
|
||||
called = true
|
||||
}))
|
||||
rec := httptest.NewRecorder()
|
||||
h.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/", nil))
|
||||
if !wrote {
|
||||
t.Fatal("WriteUnauthorized was not called")
|
||||
}
|
||||
if called {
|
||||
t.Fatal("next ran on guard failure")
|
||||
}
|
||||
if rec.Code != http.StatusUnauthorized || rec.Body.String() != `{"from":"writer"}` {
|
||||
t.Fatalf("status=%d body=%q", rec.Code, rec.Body.String())
|
||||
}
|
||||
}
|
||||
|
||||
func TestCredentialGuardSoftFailAndSuccess(t *testing.T) {
|
||||
reg := NewRegistry()
|
||||
failing := credOnlyGuard{err: errors.New("bad token")}
|
||||
if err := reg.Register("golem15.acme", "inv_token", failing); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
mw, err := reg.Middleware("inv_token")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
t.Run("failure-passes-through", func(t *testing.T) {
|
||||
called := false
|
||||
h := mw(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
called = true
|
||||
if _, ok := User(r.Context()); ok {
|
||||
t.Fatal("principal attached on failure")
|
||||
}
|
||||
if _, ok := Credential(r.Context()); ok {
|
||||
t.Fatal("credential attached on failure")
|
||||
}
|
||||
w.WriteHeader(http.StatusNoContent)
|
||||
}))
|
||||
rec := httptest.NewRecorder()
|
||||
h.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/", nil))
|
||||
if !called {
|
||||
t.Fatal("next did not run on CredentialGuard failure")
|
||||
}
|
||||
if rec.Code != http.StatusNoContent {
|
||||
t.Fatalf("status = %d", rec.Code)
|
||||
}
|
||||
})
|
||||
|
||||
okReg := NewRegistry()
|
||||
token := &struct{ ID uint }{ID: 9}
|
||||
principal := &Principal{ID: 3}
|
||||
if err := okReg.Register("golem15.acme", "inv_token", credOnlyGuard{
|
||||
principal: principal,
|
||||
cred: token,
|
||||
}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
okMW, err := okReg.Middleware("inv_token")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
t.Run("success-attaches-both", func(t *testing.T) {
|
||||
h := okMW(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
got, ok := User(r.Context())
|
||||
if !ok || got != principal {
|
||||
t.Fatalf("user = %+v ok=%t", got, ok)
|
||||
}
|
||||
cred, ok := Credential(r.Context())
|
||||
if !ok || cred != token {
|
||||
t.Fatalf("cred = %#v ok=%t", cred, ok)
|
||||
}
|
||||
w.WriteHeader(http.StatusNoContent)
|
||||
}))
|
||||
rec := httptest.NewRecorder()
|
||||
h.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/", nil))
|
||||
if rec.Code != http.StatusNoContent {
|
||||
t.Fatalf("status = %d", rec.Code)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func TestJWTGuardRegistryMatchesMiddleware(t *testing.T) {
|
||||
users := memUsers{byID: map[uint]*Principal{1: {ID: 1}}}
|
||||
direct := Middleware(secret, users)(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
w.Header().Set("X-Hit", "1")
|
||||
w.WriteHeader(http.StatusNoContent)
|
||||
}))
|
||||
reg := NewRegistry()
|
||||
if err := reg.Register("golem15.user", "jwt", NewJWTGuard(secret, users, nil)); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
viaReg, err := reg.Middleware("jwt")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
hReg := viaReg(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
w.Header().Set("X-Hit", "1")
|
||||
w.WriteHeader(http.StatusNoContent)
|
||||
}))
|
||||
|
||||
expired := sign(t, jwt.SigningMethodHS256, jwt.MapClaims{
|
||||
"sub": "1",
|
||||
"exp": time.Now().Add(-time.Hour).Unix(),
|
||||
}, []byte(secret))
|
||||
badSig := sign(t, jwt.SigningMethodHS256, jwt.MapClaims{
|
||||
"sub": "1",
|
||||
"exp": time.Now().Add(time.Hour).Unix(),
|
||||
}, []byte("other-secret"))
|
||||
unknown := sign(t, jwt.SigningMethodHS256, jwt.MapClaims{
|
||||
"sub": "99",
|
||||
"exp": time.Now().Add(time.Hour).Unix(),
|
||||
}, []byte(secret))
|
||||
|
||||
cases := []struct {
|
||||
name string
|
||||
header string
|
||||
}{
|
||||
{name: "missing"},
|
||||
{name: "expired", header: "Bearer " + expired},
|
||||
{name: "bad-signature", header: "Bearer " + badSig},
|
||||
{name: "unknown-user", header: "Bearer " + unknown},
|
||||
}
|
||||
for _, tc := range cases {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
req1 := httptest.NewRequest(http.MethodGet, "/", nil)
|
||||
req2 := httptest.NewRequest(http.MethodGet, "/", nil)
|
||||
if tc.header != "" {
|
||||
req1.Header.Set("Authorization", tc.header)
|
||||
req2.Header.Set("Authorization", tc.header)
|
||||
}
|
||||
rec1 := httptest.NewRecorder()
|
||||
rec2 := httptest.NewRecorder()
|
||||
direct.ServeHTTP(rec1, req1)
|
||||
hReg.ServeHTTP(rec2, req2)
|
||||
if rec1.Code != rec2.Code {
|
||||
t.Fatalf("status direct=%d registry=%d", rec1.Code, rec2.Code)
|
||||
}
|
||||
if rec1.Body.String() != rec2.Body.String() {
|
||||
t.Fatalf("body direct=%q registry=%q", rec1.Body.String(), rec2.Body.String())
|
||||
}
|
||||
if rec1.Header().Get("Content-Type") != rec2.Header().Get("Content-Type") {
|
||||
t.Fatalf("content-type direct=%q registry=%q", rec1.Header().Get("Content-Type"), rec2.Header().Get("Content-Type"))
|
||||
}
|
||||
if rec1.Header().Get("X-Hit") != "" || rec2.Header().Get("X-Hit") != "" {
|
||||
t.Fatal("handler ran")
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestRegisterRejectsTypedNilGuard(t *testing.T) {
|
||||
var reg Registry
|
||||
var g *credPtrGuard
|
||||
if err := reg.Register("p", "n", g); err == nil {
|
||||
t.Fatal("typed-nil guard accepted")
|
||||
}
|
||||
}
|
||||
|
||||
type credPtrGuard struct{}
|
||||
|
||||
func (*credPtrGuard) Authenticate(*http.Request) (*Principal, error) { return nil, nil }
|
||||
|
||||
type nilFuncGuard func(*http.Request) (*Principal, error)
|
||||
|
||||
func (f nilFuncGuard) Authenticate(r *http.Request) (*Principal, error) { return f(r) }
|
||||
|
||||
type nilMapGuard map[string]string
|
||||
|
||||
func (nilMapGuard) Authenticate(*http.Request) (*Principal, error) { return nil, nil }
|
||||
|
||||
func TestRegisterRejectsTypedNilPointerFuncMapGuards(t *testing.T) {
|
||||
var (
|
||||
ptr *credPtrGuard
|
||||
fn nilFuncGuard
|
||||
mp nilMapGuard
|
||||
)
|
||||
for name, g := range map[string]any{"pointer": ptr, "func": fn, "map": mp} {
|
||||
t.Run(name, func(t *testing.T) {
|
||||
var reg Registry
|
||||
err := reg.Register("golem15.p", "g", g)
|
||||
if err == nil || !strings.Contains(err.Error(), "golem15.p") || !strings.Contains(err.Error(), `"g"`) {
|
||||
t.Fatalf("typed-nil %s guard: err = %v", name, err)
|
||||
}
|
||||
if _, err := reg.Middleware("g"); err == nil {
|
||||
t.Fatal("rejected guard must not be resolvable")
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestRegisterAcceptsValidGuards(t *testing.T) {
|
||||
var reg Registry
|
||||
if err := reg.Register("p", "ptr", &credPtrGuard{}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := reg.Register("p", "fn", nilFuncGuard(func(*http.Request) (*Principal, error) { return nil, nil })); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := reg.Register("p", "map", nilMapGuard{}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := reg.Register("p", "w", writerGuard{}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
533
modules/cabana/admin_openapi.go
Normal file
533
modules/cabana/admin_openapi.go
Normal file
@@ -0,0 +1,533 @@
|
||||
package cabana
|
||||
|
||||
// @title SummerCMS Admin API
|
||||
// @version 1
|
||||
// @description Framework admin API consumed by the embedded admin SPA. Every path is relative to {backend.uri}/api/v1 (for example /backend/api/v1). The SPA authenticates with the HttpOnly summer_admin cookie set by a login that sends X-Requested-With: XMLHttpRequest, and sends that header on every request; CLI clients and tests send the BackendBearer Authorization header instead.
|
||||
// @BasePath /
|
||||
// @securityDefinitions.apikey BackendBearer
|
||||
// @in header
|
||||
// @name Authorization
|
||||
// @description Backend admin bearer token. Send "Bearer {access_token}".
|
||||
|
||||
// Admin API annotations. scripts/check-admin-openapi.sh reads them with swag
|
||||
// to produce admin/openapi/admin.json, the document the SPA's TypeScript types
|
||||
// are generated from (D-15). The functions are not mounted; service.mount in
|
||||
// http.go is the runtime route table, and TestPhase09PermissionMatrix plus
|
||||
// TestPhase09ContractInventory fail if the two lists diverge.
|
||||
|
||||
// ErrorBody is one D-10 error object.
|
||||
type ErrorBody struct {
|
||||
Code string `json:"code"`
|
||||
Message string `json:"message"`
|
||||
Details map[string]any `json:"details"`
|
||||
}
|
||||
|
||||
// ErrorEnvelope is the D-10 error envelope.
|
||||
type ErrorEnvelope struct {
|
||||
Error ErrorBody `json:"error"`
|
||||
}
|
||||
|
||||
// SuccessMeta is the D-10 meta object.
|
||||
type SuccessMeta struct {
|
||||
Locale string `json:"locale,omitempty"`
|
||||
Page int `json:"page,omitempty"`
|
||||
PerPage int `json:"per_page,omitempty"`
|
||||
Total int `json:"total,omitempty"`
|
||||
LastPage int `json:"last_page,omitempty"`
|
||||
}
|
||||
|
||||
// AdminLogoutData is the POST /auth/logout payload.
|
||||
type AdminLogoutData struct {
|
||||
Status string `json:"status"`
|
||||
}
|
||||
|
||||
// AdminLoginData is the admin login and refresh payload. Bearer transport
|
||||
// carries access_token; cookie transport (X-Requested-With: XMLHttpRequest)
|
||||
// carries token_type "cookie" and expires_in, never the token.
|
||||
type AdminLoginData struct {
|
||||
AccessToken string `json:"access_token,omitempty"`
|
||||
TokenType string `json:"token_type"`
|
||||
ExpiresIn int `json:"expires_in,omitempty"`
|
||||
}
|
||||
|
||||
// Envelope is the typed D-10 success envelope.
|
||||
type Envelope[T any] struct {
|
||||
Data T `json:"data"`
|
||||
Meta SuccessMeta `json:"meta"`
|
||||
}
|
||||
|
||||
// ListEnvelope is the typed D-10 paginated envelope (Phase 9 D-11 meta).
|
||||
type ListEnvelope[T any] struct {
|
||||
Data T `json:"data"`
|
||||
Meta ListMeta `json:"meta"`
|
||||
}
|
||||
|
||||
// AdminRecord is one admin record: a string-keyed map read through its
|
||||
// list or form schema (D-16).
|
||||
type AdminRecord map[string]any
|
||||
|
||||
// AdminIDsRequest is the body of the id-list writes: bulk delete, relation
|
||||
// link and relation unlink.
|
||||
type AdminIDsRequest struct {
|
||||
IDs []uint64 `json:"ids"`
|
||||
}
|
||||
|
||||
// AdminLoginRequest is the admin login body. Either login or email
|
||||
// identifies the backend user.
|
||||
type AdminLoginRequest struct {
|
||||
Login string `json:"login,omitempty"`
|
||||
Email string `json:"email,omitempty"`
|
||||
Password string `json:"password"`
|
||||
}
|
||||
|
||||
// AdminRoleSummary is the role attached to an admin profile.
|
||||
type AdminRoleSummary struct {
|
||||
ID uint `json:"id"`
|
||||
Code string `json:"code"`
|
||||
Name string `json:"name"`
|
||||
}
|
||||
|
||||
// AdminProfile is the GET /auth/me payload.
|
||||
type AdminProfile struct {
|
||||
ID uint `json:"id"`
|
||||
Login string `json:"login"`
|
||||
Email string `json:"email"`
|
||||
FirstName string `json:"first_name"`
|
||||
LastName string `json:"last_name"`
|
||||
IsSuperuser bool `json:"is_superuser"`
|
||||
Role *AdminRoleSummary `json:"role,omitempty"`
|
||||
}
|
||||
|
||||
// AdminLogin documents POST /auth/login.
|
||||
//
|
||||
// @Summary Admin login
|
||||
// @Tags admin
|
||||
// @Accept json
|
||||
// @Produce json
|
||||
// @Param body body AdminLoginRequest true "Credentials"
|
||||
// @Param X-Requested-With header string false "XMLHttpRequest selects cookie transport"
|
||||
// @Success 200 {object} Envelope[AdminLoginData]
|
||||
// @Failure 401 {object} ErrorEnvelope
|
||||
// @Router /auth/login [post]
|
||||
func AdminLogin() {}
|
||||
|
||||
// AdminRefresh documents POST /auth/refresh.
|
||||
//
|
||||
// @Summary Refresh an admin token
|
||||
// @Tags admin
|
||||
// @Accept json
|
||||
// @Produce json
|
||||
// @Param X-Requested-With header string false "XMLHttpRequest; required unless a Bearer token is sent"
|
||||
// @Success 200 {object} Envelope[AdminLoginData]
|
||||
// @Failure 403 {object} ErrorEnvelope
|
||||
// @Failure 401 {object} ErrorEnvelope
|
||||
// @Router /auth/refresh [post]
|
||||
func AdminRefresh() {}
|
||||
|
||||
// LangBundle is the public string bundle: full backend::lang key to CLDR
|
||||
// forms (D-20).
|
||||
type LangBundle map[string]MessageForms
|
||||
|
||||
// AdminLang documents GET /lang.
|
||||
//
|
||||
// @Summary Admin UI strings
|
||||
// @Description Every backend::lang key as CLDR plural forms for the Accept-Language locale, over the fallback locale's keys. Public: the login screen loads it before signing in. meta.locale is the locale the bundle resolved to.
|
||||
// @Tags admin
|
||||
// @Produce json
|
||||
// @Success 200 {object} Envelope[LangBundle]
|
||||
// @Router /lang [get]
|
||||
func AdminLang() {}
|
||||
|
||||
// AdminLogout documents POST /auth/logout.
|
||||
//
|
||||
// @Summary Admin logout
|
||||
// @Tags admin
|
||||
// @Produce json
|
||||
// @Security BackendBearer
|
||||
// @Success 200 {object} Envelope[AdminLogoutData]
|
||||
// @Failure 401 {object} ErrorEnvelope
|
||||
// @Failure 403 {object} ErrorEnvelope
|
||||
// @Failure 404 {object} ErrorEnvelope
|
||||
// @Router /auth/logout [post]
|
||||
func AdminLogout() {}
|
||||
|
||||
// AdminMe documents GET /auth/me.
|
||||
//
|
||||
// @Summary Current admin
|
||||
// @Tags admin
|
||||
// @Produce json
|
||||
// @Security BackendBearer
|
||||
// @Success 200 {object} Envelope[AdminProfile]
|
||||
// @Failure 401 {object} ErrorEnvelope
|
||||
// @Failure 403 {object} ErrorEnvelope
|
||||
// @Failure 404 {object} ErrorEnvelope
|
||||
// @Router /auth/me [get]
|
||||
func AdminMe() {}
|
||||
|
||||
// AdminNavigation documents GET /navigation.
|
||||
//
|
||||
// @Summary Admin navigation
|
||||
// @Tags admin
|
||||
// @Produce json
|
||||
// @Security BackendBearer
|
||||
// @Success 200 {object} Envelope[[]NavigationEntry]
|
||||
// @Failure 401 {object} ErrorEnvelope
|
||||
// @Failure 403 {object} ErrorEnvelope
|
||||
// @Failure 404 {object} ErrorEnvelope
|
||||
// @Router /navigation [get]
|
||||
func AdminNavigation() {}
|
||||
|
||||
// AdminSettingsList documents GET /settings.
|
||||
//
|
||||
// @Summary List admin settings
|
||||
// @Tags admin
|
||||
// @Produce json
|
||||
// @Security BackendBearer
|
||||
// @Success 200 {object} Envelope[[]SettingsEntry]
|
||||
// @Failure 401 {object} ErrorEnvelope
|
||||
// @Failure 403 {object} ErrorEnvelope
|
||||
// @Failure 404 {object} ErrorEnvelope
|
||||
// @Router /settings [get]
|
||||
func AdminSettingsList() {}
|
||||
|
||||
// AdminSettingsSchema documents GET /settings/{code}/schema.
|
||||
//
|
||||
// @Summary Admin settings schema
|
||||
// @Tags admin
|
||||
// @Produce json
|
||||
// @Security BackendBearer
|
||||
// @Param code path string true "Settings code"
|
||||
// @Success 200 {object} Envelope[FormView]
|
||||
// @Failure 401 {object} ErrorEnvelope
|
||||
// @Failure 403 {object} ErrorEnvelope
|
||||
// @Failure 404 {object} ErrorEnvelope
|
||||
// @Router /settings/{code}/schema [get]
|
||||
func AdminSettingsSchema() {}
|
||||
|
||||
// AdminSettingsGet documents GET /settings/{code}.
|
||||
//
|
||||
// @Summary Read admin settings
|
||||
// @Tags admin
|
||||
// @Produce json
|
||||
// @Security BackendBearer
|
||||
// @Param code path string true "Settings code"
|
||||
// @Success 200 {object} Envelope[SettingsResult]
|
||||
// @Failure 401 {object} ErrorEnvelope
|
||||
// @Failure 403 {object} ErrorEnvelope
|
||||
// @Failure 404 {object} ErrorEnvelope
|
||||
// @Router /settings/{code} [get]
|
||||
func AdminSettingsGet() {}
|
||||
|
||||
// AdminSettingsPut documents PUT /settings/{code}.
|
||||
//
|
||||
// @Summary Update admin settings
|
||||
// @Tags admin
|
||||
// @Accept json
|
||||
// @Produce json
|
||||
// @Security BackendBearer
|
||||
// @Param code path string true "Settings code"
|
||||
// @Param body body AdminRecord true "Setting values keyed by field name"
|
||||
// @Success 200 {object} Envelope[SettingsResult]
|
||||
// @Failure 401 {object} ErrorEnvelope
|
||||
// @Failure 403 {object} ErrorEnvelope
|
||||
// @Failure 422 {object} ErrorEnvelope
|
||||
// @Failure 404 {object} ErrorEnvelope
|
||||
// @Router /settings/{code} [put]
|
||||
func AdminSettingsPut() {}
|
||||
|
||||
// AdminListSchema documents the list schema route.
|
||||
//
|
||||
// @Summary Admin list schema
|
||||
// @Tags admin
|
||||
// @Produce json
|
||||
// @Security BackendBearer
|
||||
// @Param vendor path string true "Vendor"
|
||||
// @Param plugin path string true "Plugin"
|
||||
// @Param controller path string true "Controller"
|
||||
// @Success 200 {object} Envelope[ListSchema]
|
||||
// @Failure 401 {object} ErrorEnvelope
|
||||
// @Failure 403 {object} ErrorEnvelope
|
||||
// @Failure 404 {object} ErrorEnvelope
|
||||
// @Router /{vendor}/{plugin}/{controller}/schema/list [get]
|
||||
func AdminListSchema() {}
|
||||
|
||||
// AdminFormSchema documents the form schema route.
|
||||
//
|
||||
// @Summary Admin form schema
|
||||
// @Tags admin
|
||||
// @Produce json
|
||||
// @Security BackendBearer
|
||||
// @Param vendor path string true "Vendor"
|
||||
// @Param plugin path string true "Plugin"
|
||||
// @Param controller path string true "Controller"
|
||||
// @Success 200 {object} Envelope[FormView]
|
||||
// @Failure 401 {object} ErrorEnvelope
|
||||
// @Failure 403 {object} ErrorEnvelope
|
||||
// @Failure 404 {object} ErrorEnvelope
|
||||
// @Router /{vendor}/{plugin}/{controller}/schema/form [get]
|
||||
func AdminFormSchema() {}
|
||||
|
||||
// AdminRelationSchema documents the relation schema route.
|
||||
//
|
||||
// @Summary Admin relation schema
|
||||
// @Tags admin
|
||||
// @Produce json
|
||||
// @Security BackendBearer
|
||||
// @Param vendor path string true "Vendor"
|
||||
// @Param plugin path string true "Plugin"
|
||||
// @Param controller path string true "Controller"
|
||||
// @Param name path string true "Relation name"
|
||||
// @Success 200 {object} Envelope[RelationSchema]
|
||||
// @Failure 401 {object} ErrorEnvelope
|
||||
// @Failure 403 {object} ErrorEnvelope
|
||||
// @Failure 404 {object} ErrorEnvelope
|
||||
// @Router /{vendor}/{plugin}/{controller}/schema/relation/{name} [get]
|
||||
func AdminRelationSchema() {}
|
||||
|
||||
// AdminFieldOptions documents the relation field options route (D-17).
|
||||
//
|
||||
// @Summary Relation field options
|
||||
// @Description Choices for a writable `type: relation` field: value is the related id, label its nameFrom column. Read-only and non-relation fields answer 404.
|
||||
// @Tags admin
|
||||
// @Produce json
|
||||
// @Security BackendBearer
|
||||
// @Param vendor path string true "Vendor"
|
||||
// @Param plugin path string true "Plugin"
|
||||
// @Param controller path string true "Controller"
|
||||
// @Param field path string true "Relation field name"
|
||||
// @Param search query string false "Case-insensitive label search"
|
||||
// @Param page query integer false "Page"
|
||||
// @Param per_page query integer false "Options per page (1-100, default 20)"
|
||||
// @Success 200 {object} ListEnvelope[[]RelationOption]
|
||||
// @Failure 401 {object} ErrorEnvelope
|
||||
// @Failure 403 {object} ErrorEnvelope
|
||||
// @Failure 404 {object} ErrorEnvelope
|
||||
// @Failure 422 {object} ErrorEnvelope
|
||||
// @Router /{vendor}/{plugin}/{controller}/fields/{field}/options [get]
|
||||
func AdminFieldOptions() {}
|
||||
|
||||
// AdminFilterOptions documents the model-backed filter options route (D-27).
|
||||
//
|
||||
// @Summary Filter scope options
|
||||
// @Description Choices of a declared scope filter of the controller's list, from the model's FilterOptions. {scope} is the filter name used as filter[<scope>]; labels are localized.
|
||||
// @Tags admin
|
||||
// @Produce json
|
||||
// @Security BackendBearer
|
||||
// @Param vendor path string true "Vendor"
|
||||
// @Param plugin path string true "Plugin"
|
||||
// @Param controller path string true "Controller"
|
||||
// @Param scope path string true "Filter name"
|
||||
// @Success 200 {object} Envelope[[]FilterOption]
|
||||
// @Failure 401 {object} ErrorEnvelope
|
||||
// @Failure 403 {object} ErrorEnvelope
|
||||
// @Failure 404 {object} ErrorEnvelope
|
||||
// @Router /{vendor}/{plugin}/{controller}/filters/{scope}/options [get]
|
||||
func AdminFilterOptions() {}
|
||||
|
||||
// AdminList documents the record list route.
|
||||
//
|
||||
// @Summary List admin records
|
||||
// @Tags admin
|
||||
// @Produce json
|
||||
// @Security BackendBearer
|
||||
// @Param vendor path string true "Vendor"
|
||||
// @Param plugin path string true "Plugin"
|
||||
// @Param controller path string true "Controller"
|
||||
// @Param search query string false "Search term"
|
||||
// @Param sort query string false "Sort column"
|
||||
// @Param dir query string false "Sort direction (asc or desc)"
|
||||
// @Param page query integer false "Page"
|
||||
// @Param per_page query integer false "Records per page"
|
||||
// @Param filter query object false "Filter values keyed by filter name, sent as filter[<name>]=<value>"
|
||||
// @Success 200 {object} ListEnvelope[[]AdminRecord]
|
||||
// @Failure 401 {object} ErrorEnvelope
|
||||
// @Failure 403 {object} ErrorEnvelope
|
||||
// @Failure 422 {object} ErrorEnvelope
|
||||
// @Failure 404 {object} ErrorEnvelope
|
||||
// @Router /{vendor}/{plugin}/{controller} [get]
|
||||
func AdminList() {}
|
||||
|
||||
// AdminCreate documents the record create route.
|
||||
//
|
||||
// @Summary Create an admin record
|
||||
// @Description Relation fields are sent by field name with ids ({"genre": 3, "artists": [4, 9]}); the response carries the same shape plus meta.labels.
|
||||
// @Tags admin
|
||||
// @Accept json
|
||||
// @Produce json
|
||||
// @Security BackendBearer
|
||||
// @Param vendor path string true "Vendor"
|
||||
// @Param plugin path string true "Plugin"
|
||||
// @Param controller path string true "Controller"
|
||||
// @Param body body AdminRecord true "Field values keyed by field name; relation fields carry ids"
|
||||
// @Success 201 {object} RecordEnvelope
|
||||
// @Failure 401 {object} ErrorEnvelope
|
||||
// @Failure 403 {object} ErrorEnvelope
|
||||
// @Failure 422 {object} ErrorEnvelope
|
||||
// @Failure 404 {object} ErrorEnvelope
|
||||
// @Router /{vendor}/{plugin}/{controller} [post]
|
||||
func AdminCreate() {}
|
||||
|
||||
// AdminBulkDelete documents the bulk delete route.
|
||||
//
|
||||
// @Summary Bulk-delete admin records
|
||||
// @Tags admin
|
||||
// @Accept json
|
||||
// @Produce json
|
||||
// @Security BackendBearer
|
||||
// @Param vendor path string true "Vendor"
|
||||
// @Param plugin path string true "Plugin"
|
||||
// @Param controller path string true "Controller"
|
||||
// @Param body body AdminIDsRequest true "Record ids"
|
||||
// @Success 200 {object} Envelope[BulkResult]
|
||||
// @Failure 401 {object} ErrorEnvelope
|
||||
// @Failure 403 {object} ErrorEnvelope
|
||||
// @Failure 422 {object} ErrorEnvelope
|
||||
// @Failure 404 {object} ErrorEnvelope
|
||||
// @Failure 409 {object} ErrorEnvelope
|
||||
// @Router /{vendor}/{plugin}/{controller}/bulk-delete [post]
|
||||
func AdminBulkDelete() {}
|
||||
|
||||
// AdminShow documents the record show route.
|
||||
//
|
||||
// @Summary Show an admin record
|
||||
// @Tags admin
|
||||
// @Produce json
|
||||
// @Security BackendBearer
|
||||
// @Param vendor path string true "Vendor"
|
||||
// @Param plugin path string true "Plugin"
|
||||
// @Param controller path string true "Controller"
|
||||
// @Param id path integer true "Record id"
|
||||
// @Success 200 {object} RecordEnvelope
|
||||
// @Failure 401 {object} ErrorEnvelope
|
||||
// @Failure 403 {object} ErrorEnvelope
|
||||
// @Failure 404 {object} ErrorEnvelope
|
||||
// @Router /{vendor}/{plugin}/{controller}/{id} [get]
|
||||
func AdminShow() {}
|
||||
|
||||
// AdminUpdate documents the record update route.
|
||||
//
|
||||
// @Summary Update an admin record
|
||||
// @Tags admin
|
||||
// @Accept json
|
||||
// @Produce json
|
||||
// @Security BackendBearer
|
||||
// @Param vendor path string true "Vendor"
|
||||
// @Param plugin path string true "Plugin"
|
||||
// @Param controller path string true "Controller"
|
||||
// @Param id path integer true "Record id"
|
||||
// @Param body body AdminRecord true "Field values keyed by field name; relation fields carry ids"
|
||||
// @Success 200 {object} RecordEnvelope
|
||||
// @Failure 401 {object} ErrorEnvelope
|
||||
// @Failure 403 {object} ErrorEnvelope
|
||||
// @Failure 404 {object} ErrorEnvelope
|
||||
// @Failure 422 {object} ErrorEnvelope
|
||||
// @Router /{vendor}/{plugin}/{controller}/{id} [put]
|
||||
func AdminUpdate() {}
|
||||
|
||||
// AdminDelete documents the record delete route.
|
||||
//
|
||||
// @Summary Delete an admin record
|
||||
// @Tags admin
|
||||
// @Produce json
|
||||
// @Security BackendBearer
|
||||
// @Param vendor path string true "Vendor"
|
||||
// @Param plugin path string true "Plugin"
|
||||
// @Param controller path string true "Controller"
|
||||
// @Param id path integer true "Record id"
|
||||
// @Success 200 {object} Envelope[BulkResult]
|
||||
// @Failure 401 {object} ErrorEnvelope
|
||||
// @Failure 403 {object} ErrorEnvelope
|
||||
// @Failure 404 {object} ErrorEnvelope
|
||||
// @Failure 422 {object} ErrorEnvelope
|
||||
// @Router /{vendor}/{plugin}/{controller}/{id} [delete]
|
||||
func AdminDelete() {}
|
||||
|
||||
// AdminRelationLinked documents the linked-relation route.
|
||||
//
|
||||
// @Summary List linked relation records
|
||||
// @Tags admin
|
||||
// @Produce json
|
||||
// @Security BackendBearer
|
||||
// @Param vendor path string true "Vendor"
|
||||
// @Param plugin path string true "Plugin"
|
||||
// @Param controller path string true "Controller"
|
||||
// @Param id path integer true "Owner id"
|
||||
// @Param name path string true "Relation name"
|
||||
// @Param search query string false "Search term over the panel's searchable columns"
|
||||
// @Param sort query string false "Sort column (a sortable panel column)"
|
||||
// @Param dir query string false "Sort direction (asc or desc)"
|
||||
// @Param page query integer false "Page"
|
||||
// @Param per_page query integer false "Records per page (1-100, default 20)"
|
||||
// @Success 200 {object} ListEnvelope[[]AdminRecord]
|
||||
// @Failure 401 {object} ErrorEnvelope
|
||||
// @Failure 403 {object} ErrorEnvelope
|
||||
// @Failure 404 {object} ErrorEnvelope
|
||||
// @Failure 422 {object} ErrorEnvelope
|
||||
// @Router /{vendor}/{plugin}/{controller}/{id}/relations/{name} [get]
|
||||
func AdminRelationLinked() {}
|
||||
|
||||
// AdminRelationCandidates documents the relation candidate route.
|
||||
//
|
||||
// @Summary List relation candidates
|
||||
// @Tags admin
|
||||
// @Produce json
|
||||
// @Security BackendBearer
|
||||
// @Param vendor path string true "Vendor"
|
||||
// @Param plugin path string true "Plugin"
|
||||
// @Param controller path string true "Controller"
|
||||
// @Param id path integer true "Owner id"
|
||||
// @Param name path string true "Relation name"
|
||||
// @Param search query string false "Search term over the panel's searchable columns"
|
||||
// @Param sort query string false "Sort column (a sortable panel column)"
|
||||
// @Param dir query string false "Sort direction (asc or desc)"
|
||||
// @Param page query integer false "Page"
|
||||
// @Param per_page query integer false "Records per page (1-100, default 20)"
|
||||
// @Success 200 {object} ListEnvelope[[]AdminRecord]
|
||||
// @Failure 401 {object} ErrorEnvelope
|
||||
// @Failure 403 {object} ErrorEnvelope
|
||||
// @Failure 404 {object} ErrorEnvelope
|
||||
// @Failure 422 {object} ErrorEnvelope
|
||||
// @Router /{vendor}/{plugin}/{controller}/{id}/relations/{name}/candidates [get]
|
||||
func AdminRelationCandidates() {}
|
||||
|
||||
// AdminRelationLink documents the relation link route.
|
||||
//
|
||||
// @Summary Link relation records
|
||||
// @Tags admin
|
||||
// @Accept json
|
||||
// @Produce json
|
||||
// @Security BackendBearer
|
||||
// @Param vendor path string true "Vendor"
|
||||
// @Param plugin path string true "Plugin"
|
||||
// @Param controller path string true "Controller"
|
||||
// @Param id path integer true "Owner id"
|
||||
// @Param name path string true "Relation name"
|
||||
// @Param body body AdminIDsRequest true "Related record ids"
|
||||
// @Success 200 {object} Envelope[RelationMutationResult]
|
||||
// @Failure 401 {object} ErrorEnvelope
|
||||
// @Failure 403 {object} ErrorEnvelope
|
||||
// @Failure 422 {object} ErrorEnvelope
|
||||
// @Failure 404 {object} ErrorEnvelope
|
||||
// @Router /{vendor}/{plugin}/{controller}/{id}/relations/{name}/link [post]
|
||||
func AdminRelationLink() {}
|
||||
|
||||
// AdminRelationUnlink documents the relation unlink route.
|
||||
//
|
||||
// @Summary Unlink relation records
|
||||
// @Tags admin
|
||||
// @Accept json
|
||||
// @Produce json
|
||||
// @Security BackendBearer
|
||||
// @Param vendor path string true "Vendor"
|
||||
// @Param plugin path string true "Plugin"
|
||||
// @Param controller path string true "Controller"
|
||||
// @Param id path integer true "Owner id"
|
||||
// @Param name path string true "Relation name"
|
||||
// @Param body body AdminIDsRequest true "Related record ids"
|
||||
// @Success 200 {object} Envelope[RelationMutationResult]
|
||||
// @Failure 401 {object} ErrorEnvelope
|
||||
// @Failure 403 {object} ErrorEnvelope
|
||||
// @Failure 422 {object} ErrorEnvelope
|
||||
// @Failure 404 {object} ErrorEnvelope
|
||||
// @Router /{vendor}/{plugin}/{controller}/{id}/relations/{name}/unlink [post]
|
||||
func AdminRelationUnlink() {}
|
||||
7
modules/cabana/admin_paths_test.go
Normal file
7
modules/cabana/admin_paths_test.go
Normal file
@@ -0,0 +1,7 @@
|
||||
package cabana
|
||||
|
||||
// adminAPI composes a full admin API path under the default prefix, so tests
|
||||
// follow the backend.uri scheme (D-03) instead of hardcoding it.
|
||||
func adminAPI(rel string) string {
|
||||
return DefaultAdminPrefix + adminAPIVersion + rel
|
||||
}
|
||||
506
modules/cabana/auth.go
Normal file
506
modules/cabana/auth.go
Normal file
@@ -0,0 +1,506 @@
|
||||
package cabana
|
||||
|
||||
import (
|
||||
"context"
|
||||
"database/sql"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"log/slog"
|
||||
"net"
|
||||
"net/http"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"git.golem15.com/golem15/summercms/modules/backpack"
|
||||
"git.golem15.com/golem15/summercms/modules/bouncer"
|
||||
"gorm.io/gorm"
|
||||
)
|
||||
|
||||
const (
|
||||
// backendJWTBlacklistTable matches the framework migration in lagoon.
|
||||
// It is not the frontend jwt_blacklist table.
|
||||
backendJWTBlacklistTable = "backend_jwt_blacklist"
|
||||
|
||||
msgInvalidCredentials = "Invalid credentials"
|
||||
msgUnauthenticated = "Unauthenticated"
|
||||
msgForbidden = "Forbidden"
|
||||
msgNotFound = "Not found"
|
||||
msgServerError = "Server error"
|
||||
)
|
||||
|
||||
// BackendUsers loads activated backend principals. It never reads frontend users.
|
||||
type BackendUsers struct {
|
||||
DB *gorm.DB
|
||||
Registry *Registry
|
||||
}
|
||||
|
||||
func (p BackendUsers) FindByID(ctx context.Context, id uint) (*bouncer.Principal, error) {
|
||||
if p.DB == nil || id == 0 {
|
||||
return nil, nil
|
||||
}
|
||||
var user BackendUser
|
||||
err := p.DB.WithContext(ctx).Preload("Role").First(&user, id).Error
|
||||
if errors.Is(err, gorm.ErrRecordNotFound) {
|
||||
return nil, nil
|
||||
}
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if !user.IsActivated {
|
||||
return nil, nil
|
||||
}
|
||||
principal := principalFrom(user)
|
||||
for code, allowed := range p.Registry.rolePermissions(user.Role.Code) {
|
||||
if !allowed {
|
||||
continue
|
||||
}
|
||||
if principal.PermissionGrants == nil {
|
||||
principal.PermissionGrants = map[string]bool{}
|
||||
}
|
||||
principal.PermissionGrants[code] = true
|
||||
}
|
||||
return principal, nil
|
||||
}
|
||||
|
||||
func principalFrom(user BackendUser) *bouncer.Principal {
|
||||
principal := &bouncer.Principal{
|
||||
ID: user.ID,
|
||||
Backend: true,
|
||||
IsSuperuser: user.IsSuperuser,
|
||||
PermissionGrants: parseGrants(user.Role.Permissions),
|
||||
}
|
||||
if user.TokensValidAfter != nil {
|
||||
principal.TokensValidAfter = *user.TokensValidAfter
|
||||
}
|
||||
return principal
|
||||
}
|
||||
|
||||
func parseGrants(raw string) map[string]bool {
|
||||
raw = strings.TrimSpace(raw)
|
||||
if raw == "" || raw == "{}" || raw == "null" {
|
||||
return nil
|
||||
}
|
||||
var decoded map[string]any
|
||||
if err := json.Unmarshal([]byte(raw), &decoded); err != nil {
|
||||
return nil
|
||||
}
|
||||
out := make(map[string]bool, len(decoded))
|
||||
for code, value := range decoded {
|
||||
if truthyGrant(value) {
|
||||
out[code] = true
|
||||
}
|
||||
}
|
||||
if len(out) == 0 {
|
||||
return nil
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
func truthyGrant(value any) bool {
|
||||
switch v := value.(type) {
|
||||
case bool:
|
||||
return v
|
||||
case float64:
|
||||
return v == 1
|
||||
case string:
|
||||
return v == "1" || strings.EqualFold(v, "true")
|
||||
case json.Number:
|
||||
return v.String() == "1"
|
||||
default:
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
type loginBody struct {
|
||||
Login string `json:"login"`
|
||||
Email string `json:"email"`
|
||||
Password string `json:"password"`
|
||||
}
|
||||
|
||||
func (s *service) login(w http.ResponseWriter, r *http.Request) {
|
||||
var body loginBody
|
||||
dec := json.NewDecoder(http.MaxBytesReader(w, r.Body, 4096))
|
||||
if err := dec.Decode(&body); err != nil {
|
||||
WriteError(w, http.StatusUnauthorized, "unauthenticated", msgInvalidCredentials)
|
||||
return
|
||||
}
|
||||
identifier := strings.TrimSpace(body.Login)
|
||||
if identifier == "" {
|
||||
identifier = strings.TrimSpace(body.Email)
|
||||
}
|
||||
if identifier == "" || body.Password == "" {
|
||||
WriteError(w, http.StatusUnauthorized, "unauthenticated", msgInvalidCredentials)
|
||||
return
|
||||
}
|
||||
db, err := s.db()
|
||||
if err != nil {
|
||||
WriteError(w, http.StatusInternalServerError, "error", msgServerError)
|
||||
return
|
||||
}
|
||||
user, found, err := findBackendLogin(db.WithContext(r.Context()), identifier)
|
||||
if err != nil {
|
||||
WriteError(w, http.StatusInternalServerError, "error", msgServerError)
|
||||
return
|
||||
}
|
||||
hash := dummyPasswordHash
|
||||
if found && user.Password != "" {
|
||||
hash = user.Password
|
||||
}
|
||||
ok := bouncer.CheckPassword(hash, body.Password)
|
||||
if !found || !ok || !user.IsActivated {
|
||||
id := uint(0)
|
||||
if found {
|
||||
id = user.ID
|
||||
}
|
||||
s.logAuth(r, "failed", id)
|
||||
WriteError(w, http.StatusUnauthorized, "unauthenticated", msgInvalidCredentials)
|
||||
return
|
||||
}
|
||||
now := time.Now().UTC()
|
||||
if err := db.WithContext(r.Context()).Model(&BackendUser{}).Where("id = ?", user.ID).Update("last_login", now).Error; err != nil {
|
||||
WriteError(w, http.StatusInternalServerError, "error", msgServerError)
|
||||
return
|
||||
}
|
||||
if bouncer.NeedsRehash(user.Password, s.bcryptCost) {
|
||||
if next, err := bouncer.HashPassword(s.bcryptCost, body.Password); err == nil {
|
||||
_ = db.WithContext(r.Context()).Model(&BackendUser{}).Where("id = ?", user.ID).Update("password", next).Error
|
||||
}
|
||||
}
|
||||
token, _, err := bouncer.MintAudience(s.secret, uitoa(user.ID), s.issuer, s.ttl, bouncer.AudienceBackend)
|
||||
if err != nil {
|
||||
WriteError(w, http.StatusInternalServerError, "error", msgServerError)
|
||||
return
|
||||
}
|
||||
s.logAuth(r, "success", user.ID)
|
||||
if isAjax(r) {
|
||||
// Cookie transport (D-19): the SPA never sees the token.
|
||||
s.writeSessionCookie(w, token)
|
||||
WriteData(w, http.StatusOK, cookieLoginData(s.ttl), map[string]any{})
|
||||
return
|
||||
}
|
||||
WriteData(w, http.StatusOK, map[string]string{
|
||||
"access_token": token,
|
||||
"token_type": "bearer",
|
||||
}, map[string]any{})
|
||||
}
|
||||
|
||||
// cookieLoginData is the login/refresh body under cookie transport: no token,
|
||||
// only its type and the access lifetime in seconds.
|
||||
func cookieLoginData(ttl time.Duration) AdminLoginData {
|
||||
return AdminLoginData{TokenType: "cookie", ExpiresIn: int(ttl / time.Second)}
|
||||
}
|
||||
|
||||
// writeSessionCookie sets the admin JWT cookie scoped to the admin prefix.
|
||||
// Max-Age is the refresh window, because refresh accepts an expired access
|
||||
// token until iat plus refresh_ttl.
|
||||
func (s *service) writeSessionCookie(w http.ResponseWriter, token string) {
|
||||
http.SetCookie(w, s.sessionCookie(token, int(s.refreshTTL/time.Second)))
|
||||
}
|
||||
|
||||
// expireSessionCookie tells the browser to drop the admin cookie.
|
||||
func (s *service) expireSessionCookie(w http.ResponseWriter) {
|
||||
http.SetCookie(w, s.sessionCookie("", -1))
|
||||
}
|
||||
|
||||
func (s *service) sessionCookie(value string, maxAge int) *http.Cookie {
|
||||
return &http.Cookie{
|
||||
Name: AdminCookieName,
|
||||
Value: value,
|
||||
Path: s.adminPrefix(),
|
||||
MaxAge: maxAge,
|
||||
HttpOnly: true,
|
||||
Secure: !s.insecureCookie,
|
||||
SameSite: http.SameSiteStrictMode,
|
||||
}
|
||||
}
|
||||
|
||||
func (s *service) refresh(w http.ResponseWriter, r *http.Request) {
|
||||
raw, fromCookie := sessionToken(r)
|
||||
if raw == "" {
|
||||
s.logAuth(r, "failed", 0)
|
||||
WriteError(w, http.StatusUnauthorized, "unauthenticated", msgUnauthenticated)
|
||||
return
|
||||
}
|
||||
next, err := bouncer.RefreshAudienceFor(r.Context(), s.users, s.secret, raw, bouncer.AudienceBackend, s.refreshTTL, s.bl, s.grace, s.issuer)
|
||||
if err != nil {
|
||||
// A subject the guard would refuse (deactivated, deleted, or cut off
|
||||
// by tokens_valid_after) ends the browser session. Other failures,
|
||||
// including a provider error, leave the cookie alone.
|
||||
if fromCookie && errors.Is(err, bouncer.ErrSubjectRejected) {
|
||||
s.expireSessionCookie(w)
|
||||
}
|
||||
s.logAuth(r, "failed", 0)
|
||||
WriteError(w, http.StatusUnauthorized, "unauthenticated", msgUnauthenticated)
|
||||
return
|
||||
}
|
||||
s.logAuth(r, "success", 0)
|
||||
if fromCookie {
|
||||
// A cookie-authenticated request never receives a token in its body.
|
||||
s.writeSessionCookie(w, next)
|
||||
WriteData(w, http.StatusOK, cookieLoginData(s.ttl), map[string]any{})
|
||||
return
|
||||
}
|
||||
WriteData(w, http.StatusOK, map[string]string{
|
||||
"access_token": next,
|
||||
"token_type": "bearer",
|
||||
}, map[string]any{})
|
||||
}
|
||||
|
||||
// logout blacklists the presented token's jti and always expires the admin
|
||||
// cookie, so a browser session ends even when only the Bearer was revoked.
|
||||
func (s *service) logout(w http.ResponseWriter, r *http.Request) {
|
||||
raw, _ := sessionToken(r)
|
||||
_, iat, exp, jti, err := bouncer.VerifyClaimsAudience(raw, s.secret, bouncer.AudienceBackend)
|
||||
if err != nil || jti == "" {
|
||||
WriteError(w, http.StatusUnauthorized, "unauthenticated", msgUnauthenticated)
|
||||
return
|
||||
}
|
||||
if s.bl != nil {
|
||||
expiresAt := iat.Add(s.refreshTTL).Add(time.Minute)
|
||||
if until := exp.Add(time.Minute); until.After(expiresAt) {
|
||||
expiresAt = until
|
||||
}
|
||||
if err := s.bl.Add(r.Context(), jti, expiresAt, time.Now()); err != nil {
|
||||
WriteError(w, http.StatusInternalServerError, "error", msgServerError)
|
||||
return
|
||||
}
|
||||
}
|
||||
id := uint(0)
|
||||
if principal, ok := bouncer.User(r.Context()); ok {
|
||||
id = principal.ID
|
||||
}
|
||||
s.logAuth(r, "success", id)
|
||||
s.expireSessionCookie(w)
|
||||
WriteData(w, http.StatusOK, AdminLogoutData{Status: "logged_out"}, map[string]any{})
|
||||
}
|
||||
|
||||
// sessionToken returns the admin JWT the same way the backend guard reads it:
|
||||
// the Authorization Bearer header first, then the summer_admin cookie.
|
||||
func sessionToken(r *http.Request) (token string, fromCookie bool) {
|
||||
if raw := bearerToken(r); raw != "" {
|
||||
return raw, false
|
||||
}
|
||||
if r == nil {
|
||||
return "", false
|
||||
}
|
||||
if c, err := r.Cookie(AdminCookieName); err == nil {
|
||||
if raw := strings.TrimSpace(c.Value); raw != "" {
|
||||
return raw, true
|
||||
}
|
||||
}
|
||||
return "", false
|
||||
}
|
||||
|
||||
func (s *service) me(w http.ResponseWriter, r *http.Request) {
|
||||
principal, ok := bouncer.User(r.Context())
|
||||
if !ok || principal == nil {
|
||||
WriteError(w, http.StatusUnauthorized, "unauthenticated", msgUnauthenticated)
|
||||
return
|
||||
}
|
||||
db, err := s.db()
|
||||
if err != nil {
|
||||
WriteError(w, http.StatusInternalServerError, "error", msgServerError)
|
||||
return
|
||||
}
|
||||
var user BackendUser
|
||||
err = db.WithContext(r.Context()).Preload("Role").First(&user, principal.ID).Error
|
||||
if errors.Is(err, gorm.ErrRecordNotFound) || (err == nil && !user.IsActivated) {
|
||||
WriteError(w, http.StatusUnauthorized, "unauthenticated", msgUnauthenticated)
|
||||
return
|
||||
}
|
||||
if err != nil {
|
||||
WriteError(w, http.StatusInternalServerError, "error", msgServerError)
|
||||
return
|
||||
}
|
||||
WriteData(w, http.StatusOK, profileOf(user), map[string]any{})
|
||||
}
|
||||
|
||||
func profileOf(user BackendUser) AdminProfile {
|
||||
profile := AdminProfile{
|
||||
ID: user.ID,
|
||||
Login: user.Login,
|
||||
Email: user.Email,
|
||||
FirstName: user.FirstName,
|
||||
LastName: user.LastName,
|
||||
IsSuperuser: user.IsSuperuser,
|
||||
}
|
||||
if user.Role.ID != 0 {
|
||||
profile.Role = &AdminRoleSummary{ID: user.Role.ID, Code: user.Role.Code, Name: user.Role.Name}
|
||||
}
|
||||
return profile
|
||||
}
|
||||
|
||||
func bearerToken(r *http.Request) string {
|
||||
if r == nil {
|
||||
return ""
|
||||
}
|
||||
value := strings.TrimSpace(r.Header.Get("Authorization"))
|
||||
token, ok := strings.CutPrefix(value, "Bearer ")
|
||||
if !ok {
|
||||
return ""
|
||||
}
|
||||
return strings.TrimSpace(token)
|
||||
}
|
||||
|
||||
func (s *service) logAuth(r *http.Request, outcome string, adminID uint) {
|
||||
remote := ""
|
||||
method := ""
|
||||
path := ""
|
||||
if r != nil {
|
||||
method = r.Method
|
||||
if r.URL != nil {
|
||||
path = r.URL.Path
|
||||
}
|
||||
remote = r.RemoteAddr
|
||||
if host, _, err := net.SplitHostPort(remote); err == nil {
|
||||
remote = host
|
||||
}
|
||||
}
|
||||
args := []any{"outcome", outcome, "method", method, "path", path, "remote", remote}
|
||||
if adminID != 0 {
|
||||
args = append(args, "admin_id", adminID)
|
||||
}
|
||||
slog.Default().Info("admin.auth", args...)
|
||||
}
|
||||
|
||||
func adminBlacklist(app *backpack.App) bouncer.BlacklistStore {
|
||||
var sqlDB *sql.DB
|
||||
if app != nil {
|
||||
if db, ok := app.Lookup[*sql.DB](); ok {
|
||||
sqlDB = db
|
||||
} else if gdb, ok := app.Lookup[*gorm.DB](); ok && gdb != nil {
|
||||
if db, err := gdb.DB(); err == nil {
|
||||
sqlDB = db
|
||||
}
|
||||
}
|
||||
}
|
||||
if sqlDB == nil {
|
||||
return nil
|
||||
}
|
||||
return bouncer.NewPostgresBlacklist(sqlDB, backendJWTBlacklistTable)
|
||||
}
|
||||
|
||||
func findBackendLogin(db *gorm.DB, identifier string) (BackendUser, bool, error) {
|
||||
email := strings.ToLower(identifier)
|
||||
var user BackendUser
|
||||
err := db.Preload("Role").Where("login = ? OR lower(email) = ?", identifier, email).First(&user).Error
|
||||
if errors.Is(err, gorm.ErrRecordNotFound) {
|
||||
return BackendUser{}, false, nil
|
||||
}
|
||||
if err != nil {
|
||||
return BackendUser{}, false, err
|
||||
}
|
||||
return user, true, nil
|
||||
}
|
||||
|
||||
func (s *service) db() (*gorm.DB, error) {
|
||||
if s == nil || s.app == nil {
|
||||
return nil, errors.New("cabana: database is not configured")
|
||||
}
|
||||
db, ok := s.app.Lookup[*gorm.DB]()
|
||||
if !ok || db == nil {
|
||||
return nil, errors.New("cabana: database is not configured")
|
||||
}
|
||||
return db, nil
|
||||
}
|
||||
|
||||
func adminSecret(app *backpack.App) (string, error) {
|
||||
secret := ""
|
||||
if app != nil && app.Config != nil {
|
||||
secret = strings.TrimSpace(app.Config.String("admin.jwt.secret"))
|
||||
}
|
||||
if secret == "" {
|
||||
return "", errors.New("cabana: admin.jwt.secret is empty (set SUMMER_ADMIN__JWT__SECRET)")
|
||||
}
|
||||
return secret, nil
|
||||
}
|
||||
|
||||
func adminTTL(app *backpack.App) time.Duration {
|
||||
minutes := 60
|
||||
if app != nil && app.Config != nil && app.Config.Int("admin.jwt.ttl") > 0 {
|
||||
minutes = app.Config.Int("admin.jwt.ttl")
|
||||
}
|
||||
return time.Duration(minutes) * time.Minute
|
||||
}
|
||||
|
||||
func adminRefreshTTL(app *backpack.App) time.Duration {
|
||||
minutes := 20160
|
||||
if app != nil && app.Config != nil && app.Config.Int("admin.jwt.refresh_ttl") > 0 {
|
||||
minutes = app.Config.Int("admin.jwt.refresh_ttl")
|
||||
}
|
||||
return time.Duration(minutes) * time.Minute
|
||||
}
|
||||
|
||||
func adminGrace(app *backpack.App) time.Duration {
|
||||
seconds := 0
|
||||
if app != nil && app.Config != nil && app.Config.Has("admin.jwt.blacklist_grace") {
|
||||
seconds = app.Config.Int("admin.jwt.blacklist_grace")
|
||||
}
|
||||
if seconds < 0 {
|
||||
seconds = 0
|
||||
}
|
||||
return time.Duration(seconds) * time.Second
|
||||
}
|
||||
|
||||
func adminBcryptCost(app *backpack.App) int {
|
||||
cost := 10
|
||||
if app != nil && app.Config != nil && app.Config.Int("admin.password.bcrypt_cost") > 0 {
|
||||
cost = app.Config.Int("admin.password.bcrypt_cost")
|
||||
}
|
||||
if cost < 4 || cost > 31 {
|
||||
return 10
|
||||
}
|
||||
return cost
|
||||
}
|
||||
|
||||
func adminLoginWindow(app *backpack.App) (int, int) {
|
||||
maxAttempts, decayMinutes := 5, 1
|
||||
if app != nil && app.Config != nil {
|
||||
if n := app.Config.Int("admin.login.max_attempts"); n > 0 {
|
||||
maxAttempts = n
|
||||
}
|
||||
if n := app.Config.Int("admin.login.decay_minutes"); n > 0 {
|
||||
decayMinutes = n
|
||||
}
|
||||
}
|
||||
return maxAttempts, decayMinutes
|
||||
}
|
||||
|
||||
// adminCookieSecure reads backend.cookie_secure (default true). false drops
|
||||
// the Secure attribute for plain-http development and is refused in the
|
||||
// production environment.
|
||||
func adminCookieSecure(app *backpack.App) (bool, error) {
|
||||
if app == nil || app.Config == nil || !app.Config.Has("backend.cookie_secure") {
|
||||
return true, nil
|
||||
}
|
||||
if app.Config.Bool("backend.cookie_secure") {
|
||||
return true, nil
|
||||
}
|
||||
if strings.EqualFold(strings.TrimSpace(app.Config.Environment()), "production") {
|
||||
return false, errors.New("cabana: backend.cookie_secure: false is not allowed in the production environment")
|
||||
}
|
||||
return false, nil
|
||||
}
|
||||
|
||||
// adminIssuer is app.url plus the admin API login path. JWT verification does
|
||||
// not check iss, so tokens minted under an earlier prefix stay valid until
|
||||
// they expire.
|
||||
func adminIssuer(app *backpack.App, prefix string) string {
|
||||
base := ""
|
||||
if app != nil && app.Config != nil {
|
||||
base = strings.TrimRight(strings.TrimSpace(app.Config.String("app.url")), "/")
|
||||
}
|
||||
if prefix == "" {
|
||||
prefix = DefaultAdminPrefix
|
||||
}
|
||||
return base + prefix + adminAPIVersion + "/auth/login"
|
||||
}
|
||||
|
||||
// dummyPasswordHash keeps a missing-user login on the bcrypt path.
|
||||
var dummyPasswordHash = func() string {
|
||||
hash, err := bouncer.HashPassword(10, "cabana-invalid-credentials")
|
||||
if err != nil {
|
||||
return ""
|
||||
}
|
||||
return hash
|
||||
}()
|
||||
559
modules/cabana/auth_test.go
Normal file
559
modules/cabana/auth_test.go
Normal file
@@ -0,0 +1,559 @@
|
||||
package cabana_test
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"database/sql"
|
||||
"encoding/base64"
|
||||
"encoding/json"
|
||||
"io/fs"
|
||||
"log/slog"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strconv"
|
||||
"strings"
|
||||
"sync"
|
||||
"testing"
|
||||
"testing/fstest"
|
||||
"time"
|
||||
|
||||
"git.golem15.com/golem15/summercms/modules/backpack"
|
||||
"git.golem15.com/golem15/summercms/modules/bouncer"
|
||||
"git.golem15.com/golem15/summercms/modules/cabana"
|
||||
"git.golem15.com/golem15/summercms/modules/compass"
|
||||
"git.golem15.com/golem15/summercms/modules/lagoon"
|
||||
"git.golem15.com/golem15/summercms/modules/pact"
|
||||
"git.golem15.com/golem15/summercms/modules/party"
|
||||
"git.golem15.com/golem15/summercms/modules/surf"
|
||||
_ "github.com/jackc/pgx/v5/stdlib"
|
||||
"github.com/testcontainers/testcontainers-go"
|
||||
"github.com/testcontainers/testcontainers-go/modules/postgres"
|
||||
"gorm.io/gorm"
|
||||
)
|
||||
|
||||
const (
|
||||
adminTestSecret = "summercms-test-only-admin-hs256-secret"
|
||||
adminTestPassword = "lifecycle-secret"
|
||||
)
|
||||
|
||||
func TestAdminAuthLifecycle(t *testing.T) {
|
||||
gdb := adminGorm(t)
|
||||
h := adminHandler(t, gdb, nil)
|
||||
user := insertAdmin(t, gdb, "life", "Life@Example.Test", adminTestPassword, true, false)
|
||||
login := postJSON(t, h, adminAPI("/auth/login"), map[string]string{
|
||||
"login": "life",
|
||||
"password": adminTestPassword,
|
||||
})
|
||||
if login.Code != http.StatusOK {
|
||||
t.Fatalf("login status=%d body=%s", login.Code, login.Body.String())
|
||||
}
|
||||
token := accessToken(t, login.Body.Bytes())
|
||||
if aud := jwtAudience(t, token); aud != "backend" {
|
||||
t.Fatalf("aud=%q", aud)
|
||||
}
|
||||
if strings.Contains(login.Body.String(), adminTestPassword) {
|
||||
t.Fatal("login body contains the password")
|
||||
}
|
||||
var stamped sql.NullTime
|
||||
if err := gdb.Raw(`SELECT last_login FROM backend_users WHERE id = ?`, user.ID).Scan(&stamped).Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if !stamped.Valid {
|
||||
t.Fatal("successful login did not stamp last_login")
|
||||
}
|
||||
byEmail := postJSON(t, h, adminAPI("/auth/login"), map[string]string{
|
||||
"email": "life@example.test",
|
||||
"password": adminTestPassword,
|
||||
})
|
||||
if byEmail.Code != http.StatusOK {
|
||||
t.Fatalf("email login status=%d body=%s", byEmail.Code, byEmail.Body.String())
|
||||
}
|
||||
emailToken := accessToken(t, byEmail.Body.Bytes())
|
||||
me := getAuth(t, h, adminAPI("/auth/me"), emailToken)
|
||||
if me.Code != http.StatusOK {
|
||||
t.Fatalf("me status=%d body=%s", me.Code, me.Body.String())
|
||||
}
|
||||
assertSafeProfile(t, me.Body.Bytes(), user)
|
||||
refreshed := postAuth(t, h, http.MethodPost, adminAPI("/auth/refresh"), emailToken, nil)
|
||||
if refreshed.Code != http.StatusOK {
|
||||
t.Fatalf("refresh status=%d body=%s", refreshed.Code, refreshed.Body.String())
|
||||
}
|
||||
next := accessToken(t, refreshed.Body.Bytes())
|
||||
if next == emailToken {
|
||||
t.Fatal("refresh returned the same token")
|
||||
}
|
||||
if jwtAudience(t, next) != "backend" {
|
||||
t.Fatal("refreshed token lost the backend audience")
|
||||
}
|
||||
oldMe := getAuth(t, h, adminAPI("/auth/me"), emailToken)
|
||||
if oldMe.Code != http.StatusUnauthorized {
|
||||
t.Fatalf("previous token after refresh status=%d body=%s", oldMe.Code, oldMe.Body.String())
|
||||
}
|
||||
var blacklisted int
|
||||
if err := gdb.Raw(`SELECT COUNT(*) FROM backend_jwt_blacklist WHERE jti = ?`, jwtID(t, emailToken)).Scan(&blacklisted).Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if blacklisted != 1 {
|
||||
t.Fatalf("previous jti blacklist rows=%d", blacklisted)
|
||||
}
|
||||
out := postAuth(t, h, http.MethodPost, adminAPI("/auth/logout"), next, nil)
|
||||
if out.Code != http.StatusOK {
|
||||
t.Fatalf("logout status=%d body=%s", out.Code, out.Body.String())
|
||||
}
|
||||
if strings.Contains(out.Body.String(), next) {
|
||||
t.Fatal("logout body contains the token")
|
||||
}
|
||||
after := getAuth(t, h, adminAPI("/auth/me"), next)
|
||||
if after.Code != http.StatusUnauthorized {
|
||||
t.Fatalf("me after logout status=%d", after.Code)
|
||||
}
|
||||
cutoff := time.Now().Add(time.Minute)
|
||||
if err := gdb.Model(&cabana.BackendUser{}).Where("id = ?", user.ID).Update("tokens_valid_after", cutoff).Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
fresh := accessToken(t, postJSON(t, h, adminAPI("/auth/login"), map[string]string{
|
||||
"login": "life", "password": adminTestPassword,
|
||||
}).Body.Bytes())
|
||||
// Login mints after the cutoff, so this token is current. Move the cutoff
|
||||
// past it to prove a stale principal fails closed.
|
||||
if err := gdb.Model(&cabana.BackendUser{}).Where("id = ?", user.ID).Update("tokens_valid_after", time.Now().Add(time.Hour)).Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
stale := getAuth(t, h, adminAPI("/auth/me"), fresh)
|
||||
if stale.Code != http.StatusUnauthorized {
|
||||
t.Fatalf("stale principal status=%d body=%s", stale.Code, stale.Body.String())
|
||||
}
|
||||
}
|
||||
|
||||
func TestAdminInactive(t *testing.T) {
|
||||
gdb := adminGorm(t)
|
||||
h := adminHandler(t, gdb, nil)
|
||||
insertAdmin(t, gdb, "inactive", "inactive@example.test", adminTestPassword, false, false)
|
||||
unknown := postJSON(t, h, adminAPI("/auth/login"), map[string]string{"login": "nobody", "password": adminTestPassword})
|
||||
wrong := postJSON(t, h, adminAPI("/auth/login"), map[string]string{"login": "inactive", "password": "wrong-password"})
|
||||
right := postJSON(t, h, adminAPI("/auth/login"), map[string]string{"login": "inactive", "password": adminTestPassword})
|
||||
assertSameOpaque(t, unknown, wrong, right)
|
||||
var stamped sql.NullTime
|
||||
if err := gdb.Raw(`SELECT last_login FROM backend_users WHERE login = 'inactive'`).Scan(&stamped).Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if stamped.Valid {
|
||||
t.Fatal("inactive login stamped last_login")
|
||||
}
|
||||
}
|
||||
|
||||
func TestAdminDeleted(t *testing.T) {
|
||||
gdb := adminGorm(t)
|
||||
h := adminHandler(t, gdb, nil)
|
||||
insertAdmin(t, gdb, "deleted", "deleted@example.test", adminTestPassword, true, true)
|
||||
unknown := postJSON(t, h, adminAPI("/auth/login"), map[string]string{"login": "nobody-else", "password": adminTestPassword})
|
||||
deleted := postJSON(t, h, adminAPI("/auth/login"), map[string]string{"login": "deleted", "password": adminTestPassword})
|
||||
assertSameOpaque(t, unknown, deleted)
|
||||
if strings.Contains(strings.ToLower(deleted.Body.String()), "delet") {
|
||||
t.Fatalf("deleted login disclosed the account: %s", deleted.Body.String())
|
||||
}
|
||||
}
|
||||
|
||||
func TestAdminBlacklist(t *testing.T) {
|
||||
gdb := adminGorm(t)
|
||||
h := adminHandler(t, gdb, nil)
|
||||
insertAdmin(t, gdb, "revoke", "revoke@example.test", adminTestPassword, true, false)
|
||||
token := accessToken(t, postJSON(t, h, adminAPI("/auth/login"), map[string]string{
|
||||
"login": "revoke", "password": adminTestPassword,
|
||||
}).Body.Bytes())
|
||||
out := postAuth(t, h, http.MethodPost, adminAPI("/auth/logout"), token, nil)
|
||||
if out.Code != http.StatusOK {
|
||||
t.Fatalf("logout status=%d body=%s", out.Code, out.Body.String())
|
||||
}
|
||||
again := postAuth(t, h, http.MethodPost, adminAPI("/auth/refresh"), token, nil)
|
||||
if again.Code != http.StatusUnauthorized {
|
||||
t.Fatalf("refresh after logout status=%d body=%s", again.Code, again.Body.String())
|
||||
}
|
||||
var n int
|
||||
if err := gdb.Raw(`SELECT COUNT(*) FROM backend_jwt_blacklist WHERE jti = ?`, jwtID(t, token)).Scan(&n).Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if n != 1 {
|
||||
t.Fatalf("admin blacklist rows=%d, want the revoked jti in backend_jwt_blacklist", n)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAdminLoginThrottle(t *testing.T) {
|
||||
gdb := adminGorm(t)
|
||||
h := adminHandler(t, gdb, func(cfg *compass.Config) {
|
||||
if err := cfg.Set("admin.login.max_attempts", 2); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := cfg.Set("admin.login.decay_minutes", 1); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
})
|
||||
var last *httptest.ResponseRecorder
|
||||
for i := 0; i < 3; i++ {
|
||||
last = postJSON(t, h, adminAPI("/auth/login"), map[string]string{
|
||||
"login": "throttle-user", "password": adminTestPassword,
|
||||
})
|
||||
}
|
||||
if last.Code != http.StatusTooManyRequests {
|
||||
t.Fatalf("third login status=%d body=%s, want 429 from the fixed-window limiter", last.Code, last.Body.String())
|
||||
}
|
||||
}
|
||||
|
||||
func TestAdminAuthLogging(t *testing.T) {
|
||||
gdb := adminGorm(t)
|
||||
h := adminHandler(t, gdb, nil)
|
||||
user := insertAdmin(t, gdb, "logged", "logged@example.test", adminTestPassword, true, false)
|
||||
var publisherID uint
|
||||
if err := gdb.Raw(`SELECT id FROM backend_user_roles WHERE code = 'publisher'`).Scan(&publisherID).Error; err != nil || publisherID == 0 {
|
||||
t.Fatalf("publisher role: id=%d err=%v", publisherID, err)
|
||||
}
|
||||
if err := gdb.Model(&cabana.BackendUser{}).Where("id = ?", user.ID).Update("role_id", publisherID).Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
var buf bytes.Buffer
|
||||
prev := slog.Default()
|
||||
slog.SetDefault(slog.New(slog.NewJSONHandler(&buf, nil)))
|
||||
t.Cleanup(func() { slog.SetDefault(prev) })
|
||||
|
||||
ok := postJSON(t, h, adminAPI("/auth/login"), map[string]string{"login": "logged", "password": adminTestPassword})
|
||||
token := accessToken(t, ok.Body.Bytes())
|
||||
assertLog(t, &buf, "success", user.ID, adminTestPassword, token)
|
||||
buf.Reset()
|
||||
|
||||
postJSON(t, h, adminAPI("/auth/login"), map[string]string{"login": "logged", "password": "not-the-password"})
|
||||
assertLog(t, &buf, "failed", user.ID, "not-the-password", "")
|
||||
buf.Reset()
|
||||
|
||||
postJSON(t, h, adminAPI("/auth/login"), map[string]string{"login": "missing-logged", "password": "not-the-password"})
|
||||
failedUnknown := buf.String()
|
||||
if !strings.Contains(failedUnknown, `"outcome":"failed"`) {
|
||||
t.Fatalf("unknown login log = %s", failedUnknown)
|
||||
}
|
||||
if strings.Contains(failedUnknown, `"admin_id"`) || strings.Contains(failedUnknown, "not-the-password") {
|
||||
t.Fatalf("unknown login log disclosed an id or password: %s", failedUnknown)
|
||||
}
|
||||
buf.Reset()
|
||||
|
||||
denied := getAuth(t, h, adminAPI("/acme/demo/widgets"), token)
|
||||
if denied.Code != http.StatusForbidden {
|
||||
t.Fatalf("denied status=%d body=%s", denied.Code, denied.Body.String())
|
||||
}
|
||||
assertLog(t, &buf, "denied", user.ID, adminTestPassword, token)
|
||||
}
|
||||
|
||||
func assertLog(t *testing.T, buf *bytes.Buffer, outcome string, id uint, secret, token string) {
|
||||
t.Helper()
|
||||
text := buf.String()
|
||||
if !strings.Contains(text, `"outcome":"`+outcome+`"`) || !strings.Contains(text, `"admin_id":`+itoa(id)) {
|
||||
t.Fatalf("log %q missing outcome %s admin %d", text, outcome, id)
|
||||
}
|
||||
if secret != "" && strings.Contains(text, secret) {
|
||||
t.Fatalf("log contains a credential: %s", text)
|
||||
}
|
||||
if token != "" && strings.Contains(text, token) {
|
||||
t.Fatalf("log contains a bearer token: %s", text)
|
||||
}
|
||||
if strings.Contains(text, "$2a$") || strings.Contains(text, adminTestSecret) {
|
||||
t.Fatalf("log contains a hash or signing secret: %s", text)
|
||||
}
|
||||
}
|
||||
|
||||
func assertSameOpaque(t *testing.T, recs ...*httptest.ResponseRecorder) {
|
||||
t.Helper()
|
||||
if len(recs) == 0 {
|
||||
t.Fatal("no responses")
|
||||
}
|
||||
want := recs[0].Body.String()
|
||||
for _, rec := range recs {
|
||||
if rec.Code != http.StatusUnauthorized || rec.Body.String() != want {
|
||||
t.Fatalf("opaque mismatch %d %s vs %s", rec.Code, rec.Body.String(), want)
|
||||
}
|
||||
var body struct {
|
||||
Error struct {
|
||||
Code string `json:"code"`
|
||||
Message string `json:"message"`
|
||||
} `json:"error"`
|
||||
}
|
||||
if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if body.Error.Code != "unauthenticated" || body.Error.Message == "" {
|
||||
t.Fatalf("error = %+v", body.Error)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func assertSafeProfile(t *testing.T, raw []byte, user cabana.BackendUser) {
|
||||
t.Helper()
|
||||
if strings.Contains(string(raw), adminTestPassword) || strings.Contains(string(raw), "permissions") || strings.Contains(string(raw), "$2") {
|
||||
t.Fatalf("profile leaked sensitive data: %s", raw)
|
||||
}
|
||||
var body struct {
|
||||
Data struct {
|
||||
ID uint `json:"id"`
|
||||
Login string `json:"login"`
|
||||
Email string `json:"email"`
|
||||
FirstName string `json:"first_name"`
|
||||
LastName string `json:"last_name"`
|
||||
IsSuperuser bool `json:"is_superuser"`
|
||||
Role struct {
|
||||
Code string `json:"code"`
|
||||
Name string `json:"name"`
|
||||
} `json:"role"`
|
||||
} `json:"data"`
|
||||
}
|
||||
if err := json.Unmarshal(raw, &body); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if body.Data.ID != user.ID || body.Data.Login != user.Login || body.Data.Email != user.Email || body.Data.FirstName != "Ada" || body.Data.LastName != "Admin" || body.Data.IsSuperuser || body.Data.Role.Code != "developer" || body.Data.Role.Name != "Developer" {
|
||||
t.Fatalf("profile = %+v", body.Data)
|
||||
}
|
||||
}
|
||||
|
||||
var (
|
||||
adminOnce sync.Once
|
||||
adminSQL *sql.DB
|
||||
adminGDB *gorm.DB
|
||||
adminErr error
|
||||
)
|
||||
|
||||
func adminGorm(t *testing.T) *gorm.DB {
|
||||
t.Helper()
|
||||
if testing.Short() {
|
||||
t.Skip("requires testcontainers postgres")
|
||||
}
|
||||
adminOnce.Do(func() {
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
|
||||
defer cancel()
|
||||
ctr, err := postgres.Run(ctx, "postgres:16-alpine",
|
||||
postgres.WithDatabase("cabana"),
|
||||
postgres.WithUsername("cabana"),
|
||||
postgres.WithPassword("cabana"),
|
||||
postgres.BasicWaitStrategies(),
|
||||
testcontainers.WithEnv(map[string]string{
|
||||
"POSTGRES_INITDB_ARGS": "--locale-provider=icu --icu-locale=pl-PL --encoding=UTF8",
|
||||
}),
|
||||
)
|
||||
if err != nil {
|
||||
adminErr = err
|
||||
return
|
||||
}
|
||||
dsn, err := ctr.ConnectionString(ctx, "sslmode=disable")
|
||||
if err != nil {
|
||||
adminErr = err
|
||||
return
|
||||
}
|
||||
db, err := sql.Open("pgx", dsn)
|
||||
if err != nil {
|
||||
adminErr = err
|
||||
return
|
||||
}
|
||||
gdb, err := lagoon.Use(ctx, db)
|
||||
if err != nil {
|
||||
adminErr = err
|
||||
return
|
||||
}
|
||||
if err := lagoon.Migrate(gdb, nil); err != nil {
|
||||
adminErr = err
|
||||
return
|
||||
}
|
||||
adminSQL = db
|
||||
adminGDB = gdb
|
||||
})
|
||||
if adminErr != nil {
|
||||
t.Fatalf("postgres: %v", adminErr)
|
||||
}
|
||||
return adminGDB
|
||||
}
|
||||
|
||||
func adminHandler(t *testing.T, gdb *gorm.DB, mutate func(*compass.Config)) http.Handler {
|
||||
t.Helper()
|
||||
dir := t.TempDir()
|
||||
if err := os.WriteFile(filepath.Join(dir, "app.yaml"), []byte("name: cabana-auth\n"), 0o644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
cfg, err := compass.Open(compass.Options{
|
||||
Dir: dir,
|
||||
Environ: []string{
|
||||
"SUMMER_ENV=development",
|
||||
"SUMMER_ADMIN__JWT__SECRET=" + adminTestSecret,
|
||||
},
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := cfg.Set("http.body_limits.default_bytes", 1048576); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := cfg.Set("http.body_limits.upload_bytes", 1048576); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if mutate != nil {
|
||||
mutate(cfg)
|
||||
}
|
||||
app := backpack.New(cfg)
|
||||
if err := lagoon.Publish(app, adminSQL, gdb); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
h, err := surf.Assemble(app, []party.Plugin{demoPlugin{fsys: demoFS()}})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return h
|
||||
}
|
||||
|
||||
func insertAdmin(t *testing.T, gdb *gorm.DB, login, email, password string, activated, deleted bool) cabana.BackendUser {
|
||||
t.Helper()
|
||||
hash, err := bouncer.HashPassword(10, password)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
var roleID uint
|
||||
if err := gdb.Raw(`SELECT id FROM backend_user_roles WHERE code = 'developer'`).Scan(&roleID).Error; err != nil || roleID == 0 {
|
||||
t.Fatalf("developer role: %v id=%d", err, roleID)
|
||||
}
|
||||
user := cabana.BackendUser{
|
||||
FirstName: "Ada",
|
||||
LastName: "Admin",
|
||||
Login: login,
|
||||
Email: email,
|
||||
Password: hash,
|
||||
IsActivated: activated,
|
||||
RoleID: &roleID,
|
||||
}
|
||||
if err := gdb.Create(&user).Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if deleted {
|
||||
if err := gdb.Delete(&user).Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
return user
|
||||
}
|
||||
|
||||
type demoPlugin struct{ fsys fs.FS }
|
||||
|
||||
func (p demoPlugin) ID() string { return "acme.demo" }
|
||||
func (p demoPlugin) Requires() []string { return nil }
|
||||
func (p demoPlugin) Register(*backpack.App) error { return nil }
|
||||
func (p demoPlugin) Boot(*backpack.App) error { return nil }
|
||||
func (p demoPlugin) AdminControllers() []pact.AdminController {
|
||||
return []pact.AdminController{demoController{}}
|
||||
}
|
||||
func (p demoPlugin) Permissions() []pact.Permission {
|
||||
return []pact.Permission{{Code: "acme.demo.access", Roles: []string{"developer"}}}
|
||||
}
|
||||
func (p demoPlugin) AdminFS() fs.FS { return p.fsys }
|
||||
|
||||
type demoController struct{}
|
||||
|
||||
func (demoController) ID() string { return "acme.demo.widgets" }
|
||||
func (demoController) ModelName() string { return "Widget" }
|
||||
func (demoController) ConfigDir() string { return "controllers/widgets" }
|
||||
func (demoController) RequiredPermissions() []string { return []string{"acme.demo.access"} }
|
||||
|
||||
func demoFS() fs.FS {
|
||||
return fstest.MapFS{
|
||||
"controllers/widgets/config_list.yaml": &fstest.MapFile{Data: []byte("list: ~/plugins/acme/demo/models/widget/columns.yaml\nmodelClass: Widget\nrecordsPerPage: 20\nshowSearch: true\n")},
|
||||
"models/widget/columns.yaml": &fstest.MapFile{Data: []byte("columns:\n name:\n label: Name\n searchable: true\n")},
|
||||
}
|
||||
}
|
||||
|
||||
func postJSON(t *testing.T, h http.Handler, path string, body any) *httptest.ResponseRecorder {
|
||||
t.Helper()
|
||||
raw, err := json.Marshal(body)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return postAuth(t, h, http.MethodPost, path, "", raw)
|
||||
}
|
||||
|
||||
func postAuth(t *testing.T, h http.Handler, method, path, token string, body []byte) *httptest.ResponseRecorder {
|
||||
t.Helper()
|
||||
req := httptest.NewRequest(method, path, bytes.NewReader(body))
|
||||
if body != nil {
|
||||
req.Header.Set("Content-Type", "application/json")
|
||||
}
|
||||
if token != "" {
|
||||
req.Header.Set("Authorization", "Bearer "+token)
|
||||
}
|
||||
rec := httptest.NewRecorder()
|
||||
h.ServeHTTP(rec, req)
|
||||
return rec
|
||||
}
|
||||
|
||||
func getAuth(t *testing.T, h http.Handler, path, token string) *httptest.ResponseRecorder {
|
||||
t.Helper()
|
||||
return postAuth(t, h, http.MethodGet, path, token, nil)
|
||||
}
|
||||
|
||||
func accessToken(t *testing.T, raw []byte) string {
|
||||
t.Helper()
|
||||
var body struct {
|
||||
Data struct {
|
||||
AccessToken string `json:"access_token"`
|
||||
} `json:"data"`
|
||||
}
|
||||
if err := json.Unmarshal(raw, &body); err != nil {
|
||||
t.Fatalf("token json: %v body=%s", err, raw)
|
||||
}
|
||||
if body.Data.AccessToken == "" {
|
||||
t.Fatalf("missing access_token: %s", raw)
|
||||
}
|
||||
return body.Data.AccessToken
|
||||
}
|
||||
|
||||
func jwtAudience(t *testing.T, token string) string {
|
||||
t.Helper()
|
||||
claims := jwtClaims(t, token)
|
||||
switch v := claims["aud"].(type) {
|
||||
case string:
|
||||
return v
|
||||
case []any:
|
||||
if len(v) == 1 {
|
||||
s, _ := v[0].(string)
|
||||
return s
|
||||
}
|
||||
}
|
||||
t.Fatalf("aud=%v", claims["aud"])
|
||||
return ""
|
||||
}
|
||||
|
||||
func jwtID(t *testing.T, token string) string {
|
||||
t.Helper()
|
||||
id, _ := jwtClaims(t, token)["jti"].(string)
|
||||
if id == "" {
|
||||
t.Fatal("token has no jti")
|
||||
}
|
||||
return id
|
||||
}
|
||||
|
||||
func jwtClaims(t *testing.T, token string) map[string]any {
|
||||
t.Helper()
|
||||
parts := strings.Split(token, ".")
|
||||
if len(parts) != 3 {
|
||||
t.Fatalf("token segments=%d", len(parts))
|
||||
}
|
||||
raw, err := base64.RawURLEncoding.DecodeString(parts[1])
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
var claims map[string]any
|
||||
if err := json.Unmarshal(raw, &claims); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return claims
|
||||
}
|
||||
|
||||
func itoa(id uint) string {
|
||||
return strconv.FormatUint(uint64(id), 10)
|
||||
}
|
||||
|
||||
// adminAPI mirrors the internal helper in admin_paths_test.go for this
|
||||
// external test package: a full admin API path under the default prefix.
|
||||
func adminAPI(rel string) string {
|
||||
return cabana.DefaultAdminPrefix + "/api/v1" + rel
|
||||
}
|
||||
250
modules/cabana/bulk_test.go
Normal file
250
modules/cabana/bulk_test.go
Normal file
@@ -0,0 +1,250 @@
|
||||
package cabana
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"fmt"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"sort"
|
||||
"strings"
|
||||
"sync"
|
||||
"testing"
|
||||
|
||||
"git.golem15.com/golem15/summercms/modules/bouncer"
|
||||
"gorm.io/gorm"
|
||||
)
|
||||
|
||||
func TestBulkDeleteEmpty(t *testing.T) {
|
||||
cap := &captureRouter{}
|
||||
(&service{}).mount(cap)
|
||||
key := "POST " + adminAPI("/{vendor}/{plugin}/{controller}/bulk-delete")
|
||||
mw, ok := cap.middleware[key]
|
||||
if !ok || !containsString(mw, "backend") {
|
||||
t.Fatalf("missing %s in %v", key, cap.routes)
|
||||
}
|
||||
_, httpSvc, _, db, hooks := hookFixture(t)
|
||||
hooks.perms = []string{"acme.demo.records"}
|
||||
forbidden := crudBulk(httpSvc, []byte(`{"ids":[1]}`), principalCtx(hooks, &bouncer.Principal{ID: 4}))
|
||||
if forbidden.Code != http.StatusForbidden || hooks.allocs.Load() != 0 || hooks.queries.Load() != 0 {
|
||||
t.Fatalf("forbidden=%d allocs=%d queries=%d body=%s", forbidden.Code, hooks.allocs.Load(), hooks.queries.Load(), forbidden.Body.String())
|
||||
}
|
||||
ctx := principalCtx(hooks, superUser())
|
||||
for _, body := range []string{`{"ids":[]}`, `{}`, `{"ids":null}`} {
|
||||
rec := crudBulk(httpSvc, []byte(body), ctx)
|
||||
if rec.Code != http.StatusUnprocessableEntity || !strings.Contains(rec.Body.String(), `"validation_failed"`) || !strings.Contains(rec.Body.String(), "The ids field is required.") {
|
||||
t.Fatalf("body %s => %d %s", body, rec.Code, rec.Body.String())
|
||||
}
|
||||
}
|
||||
bad := crudBulk(httpSvc, []byte(`{"ids":["nope",1]}`), ctx)
|
||||
if bad.Code != http.StatusUnprocessableEntity || !strings.Contains(bad.Body.String(), `"validation_failed"`) {
|
||||
t.Fatalf("bad ids=%d %s", bad.Code, bad.Body.String())
|
||||
}
|
||||
if n := countCrud(t, db); n != 0 {
|
||||
t.Fatalf("rows=%d", n)
|
||||
}
|
||||
}
|
||||
|
||||
func TestBulkDeleteDuplicates(t *testing.T) {
|
||||
svc, _, cc, db, hooks := hookFixture(t)
|
||||
rows := seedCrud(t, db, 2)
|
||||
var got []uint
|
||||
ctx := idCtx(hooks, &got)
|
||||
res, err := svc.BulkDelete(ctx, cc, BulkDeleteInput{IDs: []any{rows[1].ID, rows[1].ID, rows[0].ID, float64(rows[0].ID)}})
|
||||
if err != nil || res.Deleted != 2 {
|
||||
t.Fatalf("bulk=%+v err=%v", res, err)
|
||||
}
|
||||
if !sameUints(got, []uint{rows[0].ID, rows[1].ID}) {
|
||||
t.Fatalf("hook ids=%v, want each id once in ascending order", got)
|
||||
}
|
||||
if n := countCrud(t, db); n != 0 {
|
||||
t.Fatalf("rows=%d", n)
|
||||
}
|
||||
}
|
||||
|
||||
func TestBulkDeleteOrder(t *testing.T) {
|
||||
svc, _, cc, db, hooks := hookFixture(t)
|
||||
rows := seedCrud(t, db, 3)
|
||||
var got []uint
|
||||
ctx := idCtx(hooks, &got)
|
||||
res, err := svc.BulkDelete(ctx, cc, BulkDeleteInput{IDs: []any{rows[2].ID, rows[0].ID, rows[1].ID}})
|
||||
if err != nil || res.Deleted != 3 {
|
||||
t.Fatalf("bulk=%+v err=%v", res, err)
|
||||
}
|
||||
want := []uint{rows[0].ID, rows[1].ID, rows[2].ID}
|
||||
sort.Slice(want, func(i, j int) bool { return want[i] < want[j] })
|
||||
if !sameUints(got, want) {
|
||||
t.Fatalf("hook ids=%v want %v", got, want)
|
||||
}
|
||||
}
|
||||
|
||||
func TestBulkDeleteIdempotent(t *testing.T) {
|
||||
svc, _, cc, db, hooks := hookFixture(t)
|
||||
rows := seedCrud(t, db, 2)
|
||||
var got []uint
|
||||
ctx := idCtx(hooks, &got)
|
||||
first, err := svc.BulkDelete(ctx, cc, BulkDeleteInput{IDs: idsOf(rows)})
|
||||
if err != nil || first.Deleted != 2 {
|
||||
t.Fatalf("first=%+v err=%v", first, err)
|
||||
}
|
||||
got = nil
|
||||
again, err := svc.BulkDelete(ctx, cc, BulkDeleteInput{IDs: idsOf(rows)})
|
||||
if err != nil || again.Deleted != 0 || len(got) != 0 {
|
||||
t.Fatalf("repeat=%+v err=%v hooks=%v", again, err, got)
|
||||
}
|
||||
hooks.trackScope = true
|
||||
outside := seedCrud(t, db, 1)
|
||||
if err := db.Model(&outside[0]).Update("scope_id", 2).Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
got = nil
|
||||
scoped := context.WithValue(ctx, scopeKey{}, uint(1))
|
||||
res, err := svc.BulkDelete(scoped, cc, BulkDeleteInput{IDs: []any{outside[0].ID}})
|
||||
if err != nil || res.Deleted != 0 || len(got) != 0 {
|
||||
t.Fatalf("out of scope=%+v err=%v hooks=%v", res, err, got)
|
||||
}
|
||||
if n := countCrud(t, db); n != 1 {
|
||||
t.Fatalf("rows=%d, out-of-scope delete changed the table", n)
|
||||
}
|
||||
}
|
||||
|
||||
func TestBulkDeleteRollback(t *testing.T) {
|
||||
svc, httpSvc, cc, db, hooks := hookFixture(t)
|
||||
rows := seedCrud(t, db, 2)
|
||||
var got []uint
|
||||
ctx := idCtx(hooks, &got)
|
||||
if _, err := svc.BulkDelete(ctx, cc, BulkDeleteInput{IDs: []any{rows[0].ID, uint(999999)}}); err == nil || len(got) != 0 || countCrud(t, db) != 2 {
|
||||
t.Fatalf("mixed missing err=%v hooks=%v rows=%d", err, got, countCrud(t, db))
|
||||
}
|
||||
rec := crudBulk(httpSvc, []byte(fmt.Sprintf(`{"ids":[%d,999999]}`, rows[0].ID)), ctx)
|
||||
if rec.Code != http.StatusConflict || strings.Contains(rec.Body.String(), "999999") {
|
||||
t.Fatalf("mixed http=%d %s", rec.Code, rec.Body.String())
|
||||
}
|
||||
if countCrud(t, db) != 2 {
|
||||
t.Fatal("mixed http committed a delete")
|
||||
}
|
||||
|
||||
hooks.trackScope = true
|
||||
if err := db.Model(&rows[1]).Update("scope_id", 2).Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
got = nil
|
||||
scoped := context.WithValue(ctx, scopeKey{}, uint(1))
|
||||
if _, err := svc.BulkDelete(scoped, cc, BulkDeleteInput{IDs: []any{rows[0].ID, rows[1].ID}}); err == nil || len(got) != 0 {
|
||||
t.Fatalf("mixed scope err=%v hooks=%v", err, got)
|
||||
}
|
||||
if loadCrud(t, db, rows[0].Name).ScopeID != 1 || loadCrud(t, db, rows[1].Name).ScopeID != 2 {
|
||||
t.Fatal("mixed scope committed")
|
||||
}
|
||||
|
||||
if err := db.Model(&rows[1]).Update("scope_id", 1).Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
hooks.trackScope = false
|
||||
got = nil
|
||||
failCtx := context.WithValue(ctx, failIDsKey{}, map[uint]bool{rows[1].ID: true})
|
||||
_, err := svc.BulkDelete(failCtx, cc, BulkDeleteInput{IDs: idsOf(rows)})
|
||||
if err == nil || strings.Contains(err.Error(), "secret-hook-boom") || !strings.Contains(err.Error(), "acme.demo.records") {
|
||||
t.Fatalf("hook err=%v", err)
|
||||
}
|
||||
if countCrud(t, db) != 2 {
|
||||
t.Fatal("hook failure committed a partial delete")
|
||||
}
|
||||
out := httptest.NewRecorder()
|
||||
writeCRUDError(out, err)
|
||||
if out.Code != http.StatusInternalServerError || strings.Contains(out.Body.String(), "secret-hook-boom") {
|
||||
t.Fatalf("hook http=%d %s", out.Code, out.Body.String())
|
||||
}
|
||||
|
||||
cancelCtx, cancel := context.WithCancel(ctx)
|
||||
cancelCtx = context.WithValue(cancelCtx, cancelKey{}, cancel)
|
||||
cancelCtx = context.WithValue(cancelCtx, cancelOnKey{}, rows[1].ID)
|
||||
got = nil
|
||||
if _, err := svc.BulkDelete(cancelCtx, cc, BulkDeleteInput{IDs: idsOf(rows)}); err == nil || countCrud(t, db) != 2 {
|
||||
t.Fatalf("cancel err=%v rows=%d", err, countCrud(t, db))
|
||||
}
|
||||
}
|
||||
|
||||
func TestBulkDeleteConcurrent(t *testing.T) {
|
||||
svc, _, cc, db, hooks := hookFixture(t)
|
||||
rows := seedCrud(t, db, 3)
|
||||
var got []uint
|
||||
ctx := context.WithValue(idCtx(hooks, &got), bulkSlowKey{}, true)
|
||||
in := BulkDeleteInput{IDs: idsOf(rows)}
|
||||
var wg sync.WaitGroup
|
||||
start := make(chan struct{})
|
||||
type outcome struct {
|
||||
res BulkResult
|
||||
err error
|
||||
}
|
||||
outs := make([]outcome, 2)
|
||||
for i := 0; i < 2; i++ {
|
||||
wg.Add(1)
|
||||
go func(i int) {
|
||||
defer wg.Done()
|
||||
<-start
|
||||
outs[i].res, outs[i].err = svc.BulkDelete(ctx, cc, in)
|
||||
}(i)
|
||||
}
|
||||
close(start)
|
||||
wg.Wait()
|
||||
sum := 0
|
||||
for i, out := range outs {
|
||||
if out.err != nil || (out.res.Deleted != 0 && out.res.Deleted != 3) {
|
||||
t.Fatalf("worker %d = %+v err=%v", i, out.res, out.err)
|
||||
}
|
||||
sum += out.res.Deleted
|
||||
}
|
||||
if sum != 3 || !sameUints(got, []uint{rows[0].ID, rows[1].ID, rows[2].ID}) || countCrud(t, db) != 0 {
|
||||
t.Fatalf("sum=%d hooks=%v rows=%d", sum, got, countCrud(t, db))
|
||||
}
|
||||
}
|
||||
|
||||
func seedCrud(t *testing.T, db *gorm.DB, n int) []crudRow {
|
||||
t.Helper()
|
||||
rows := make([]crudRow, n)
|
||||
for i := range rows {
|
||||
rows[i] = crudRow{Name: fmt.Sprintf("row-%d", i), ScopeID: 1}
|
||||
}
|
||||
if err := db.Create(&rows).Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return rows
|
||||
}
|
||||
|
||||
func idsOf(rows []crudRow) []any {
|
||||
out := make([]any, len(rows))
|
||||
for i := range rows {
|
||||
out[i] = rows[i].ID
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
func idCtx(hooks *hookController, got *[]uint) context.Context {
|
||||
return context.WithValue(principalCtx(hooks, superUser()), idSinkKey{}, got)
|
||||
}
|
||||
|
||||
func sameUints(got, want []uint) bool {
|
||||
if len(got) != len(want) {
|
||||
return false
|
||||
}
|
||||
for i := range got {
|
||||
if got[i] != want[i] {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
func crudBulk(svc *service, body []byte, ctx context.Context) *httptest.ResponseRecorder {
|
||||
req := httptest.NewRequest(http.MethodPost, "/", bytes.NewReader(body))
|
||||
req.SetPathValue("vendor", "acme")
|
||||
req.SetPathValue("plugin", "demo")
|
||||
req.SetPathValue("controller", "records")
|
||||
if ctx != nil {
|
||||
req = req.WithContext(ctx)
|
||||
}
|
||||
rec := httptest.NewRecorder()
|
||||
svc.bulkDelete(rec, req)
|
||||
return rec
|
||||
}
|
||||
185
modules/cabana/commands.go
Normal file
185
modules/cabana/commands.go
Normal file
@@ -0,0 +1,185 @@
|
||||
package cabana
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"fmt"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"git.golem15.com/golem15/summercms/modules/backpack"
|
||||
"git.golem15.com/golem15/summercms/modules/bonfire"
|
||||
"git.golem15.com/golem15/summercms/modules/bouncer"
|
||||
"git.golem15.com/golem15/summercms/modules/lagoon"
|
||||
"gorm.io/gorm"
|
||||
)
|
||||
|
||||
// RuntimeCommands returns the operator commands for backend administrators.
|
||||
func RuntimeCommands(app *backpack.App) []bonfire.Command {
|
||||
return []bonfire.Command{
|
||||
{
|
||||
Name: "admin:create",
|
||||
Description: "Create an activated backend administrator",
|
||||
Flags: []bonfire.Flag{
|
||||
{Name: "email", Description: "Admin email"},
|
||||
{Name: "password", Description: "Admin password"},
|
||||
{Name: "login", Description: "Login; defaults to the lower-cased email"},
|
||||
{Name: "superuser", Description: "Grant superuser", Bare: true},
|
||||
{Name: "role", Description: "Role code"},
|
||||
},
|
||||
Run: func(ctx context.Context, in bonfire.Input, out bonfire.Output) error {
|
||||
return adminCreate(ctx, app, in, out)
|
||||
},
|
||||
},
|
||||
{
|
||||
Name: "admin:reset-password",
|
||||
Description: "Reset a backend administrator password and revoke existing tokens",
|
||||
Args: []bonfire.Arg{{
|
||||
Name: "identifier",
|
||||
Description: "Login or email",
|
||||
Required: true,
|
||||
}},
|
||||
Flags: []bonfire.Flag{{
|
||||
Name: "password",
|
||||
Description: "New password",
|
||||
}},
|
||||
Run: func(ctx context.Context, in bonfire.Input, out bonfire.Output) error {
|
||||
return adminResetPassword(ctx, app, in, out)
|
||||
},
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
func adminCreate(ctx context.Context, app *backpack.App, in bonfire.Input, out bonfire.Output) error {
|
||||
email := strings.ToLower(strings.TrimSpace(flagValue(in, "email")))
|
||||
password := flagValue(in, "password")
|
||||
if email == "" || !strings.Contains(email, "@") || strings.TrimSpace(password) == "" {
|
||||
return errors.New("cabana: email and password are required")
|
||||
}
|
||||
login := strings.TrimSpace(flagValue(in, "login"))
|
||||
if login == "" {
|
||||
login = email
|
||||
}
|
||||
roleCode := strings.TrimSpace(flagValue(in, "role"))
|
||||
superuser := flagValue(in, "superuser") == "true"
|
||||
return withAdminDB(ctx, app, func(gdb *gorm.DB) error {
|
||||
return gdb.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
|
||||
roleID, err := roleIDByCode(tx, roleCode)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
var existing int64
|
||||
if err := tx.Model(&BackendUser{}).Where("login = ? OR lower(email) = ?", login, email).Count(&existing).Error; err != nil {
|
||||
return err
|
||||
}
|
||||
if existing > 0 {
|
||||
return errors.New("cabana: admin already exists")
|
||||
}
|
||||
hash, err := bouncer.HashPassword(adminBcryptCost(app), password)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
now := time.Now().UTC()
|
||||
user := BackendUser{
|
||||
Login: login,
|
||||
Email: email,
|
||||
Password: hash,
|
||||
IsActivated: true,
|
||||
IsSuperuser: superuser,
|
||||
RoleID: roleID,
|
||||
ActivatedAt: &now,
|
||||
}
|
||||
if err := tx.Create(&user).Error; err != nil {
|
||||
return err
|
||||
}
|
||||
out.Success(fmt.Sprintf("created admin %s <%s>", user.Login, user.Email))
|
||||
return nil
|
||||
})
|
||||
})
|
||||
}
|
||||
|
||||
func adminResetPassword(ctx context.Context, app *backpack.App, in bonfire.Input, out bonfire.Output) error {
|
||||
identifier := ""
|
||||
if value, ok := in.Argument("identifier"); ok {
|
||||
identifier = strings.TrimSpace(value)
|
||||
}
|
||||
if identifier == "" && len(in.Args()) > 0 {
|
||||
identifier = strings.TrimSpace(in.Args()[0])
|
||||
}
|
||||
password := flagValue(in, "password")
|
||||
if identifier == "" || strings.TrimSpace(password) == "" {
|
||||
return errors.New("cabana: identifier and password are required")
|
||||
}
|
||||
return withAdminDB(ctx, app, func(gdb *gorm.DB) error {
|
||||
return gdb.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
|
||||
var users []BackendUser
|
||||
err := tx.Where("login = ? OR lower(email) = ?", identifier, strings.ToLower(identifier)).Find(&users).Error
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if len(users) == 0 {
|
||||
return errors.New("cabana: admin not found")
|
||||
}
|
||||
if len(users) > 1 {
|
||||
return errors.New("cabana: ambiguous admin")
|
||||
}
|
||||
hash, err := bouncer.HashPassword(adminBcryptCost(app), password)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
cutoff := time.Now().UTC().Add(time.Second)
|
||||
if err := tx.Model(&BackendUser{}).Where("id = ?", users[0].ID).Updates(map[string]any{
|
||||
"password": hash,
|
||||
"tokens_valid_after": cutoff,
|
||||
}).Error; err != nil {
|
||||
return err
|
||||
}
|
||||
out.Success(fmt.Sprintf("reset password for %s", users[0].Login))
|
||||
return nil
|
||||
})
|
||||
})
|
||||
}
|
||||
|
||||
func roleIDByCode(tx *gorm.DB, code string) (*uint, error) {
|
||||
if code == "" {
|
||||
return nil, nil
|
||||
}
|
||||
var ids []uint
|
||||
if err := tx.Model(&BackendUserRole{}).Where("code = ?", code).Pluck("id", &ids).Error; err != nil {
|
||||
return nil, err
|
||||
}
|
||||
switch len(ids) {
|
||||
case 0:
|
||||
return nil, fmt.Errorf("cabana: unknown role %q", code)
|
||||
case 1:
|
||||
return &ids[0], nil
|
||||
default:
|
||||
return nil, fmt.Errorf("cabana: ambiguous role %q", code)
|
||||
}
|
||||
}
|
||||
|
||||
func flagValue(in bonfire.Input, name string) string {
|
||||
if in == nil {
|
||||
return ""
|
||||
}
|
||||
value, _ := in.Flag(name)
|
||||
return value
|
||||
}
|
||||
|
||||
func withAdminDB(ctx context.Context, app *backpack.App, fn func(*gorm.DB) error) error {
|
||||
if app == nil {
|
||||
return errors.New("cabana: app is nil")
|
||||
}
|
||||
if gdb, ok := app.Lookup[*gorm.DB](); ok && gdb != nil {
|
||||
return fn(gdb)
|
||||
}
|
||||
sqlDB, gdb, err := lagoon.OpenFromApp(ctx, app)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer sqlDB.Close()
|
||||
if err := lagoon.Publish(app, sqlDB, gdb); err != nil {
|
||||
return err
|
||||
}
|
||||
return fn(gdb)
|
||||
}
|
||||
197
modules/cabana/commands_test.go
Normal file
197
modules/cabana/commands_test.go
Normal file
@@ -0,0 +1,197 @@
|
||||
package cabana_test
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"os"
|
||||
"path/filepath"
|
||||
|
||||
"git.golem15.com/golem15/summercms/modules/backpack"
|
||||
"git.golem15.com/golem15/summercms/modules/bonfire"
|
||||
"git.golem15.com/golem15/summercms/modules/bouncer"
|
||||
"git.golem15.com/golem15/summercms/modules/cabana"
|
||||
"git.golem15.com/golem15/summercms/modules/compass"
|
||||
"git.golem15.com/golem15/summercms/modules/lagoon"
|
||||
"gorm.io/gorm"
|
||||
)
|
||||
|
||||
func TestAdminCreateCommand(t *testing.T) {
|
||||
gdb := adminGorm(t)
|
||||
app := commandApp(t, gdb)
|
||||
create := commandByName(t, cabana.RuntimeCommands(app), "admin:create")
|
||||
var buf bytes.Buffer
|
||||
out := bonfire.NewOutput(nil, &buf, &buf)
|
||||
const password = "correct-horse-battery"
|
||||
if err := create.Run(context.Background(), flagInput{flags: map[string]string{
|
||||
"email": "Ada@Example.Test",
|
||||
"password": password,
|
||||
"role": "developer",
|
||||
"superuser": "true",
|
||||
}}, out); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if strings.Contains(buf.String(), password) || strings.Contains(buf.String(), "$2") || strings.Contains(buf.String(), adminTestSecret) {
|
||||
t.Fatalf("create output leaked a secret: %s", buf.String())
|
||||
}
|
||||
if !strings.Contains(buf.String(), "ada@example.test") {
|
||||
t.Fatalf("create output = %s", buf.String())
|
||||
}
|
||||
var user cabana.BackendUser
|
||||
if err := gdb.Preload("Role").Where("login = ?", "ada@example.test").First(&user).Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if user.Email != "ada@example.test" || !user.IsActivated || !user.IsSuperuser || user.Role.Code != "developer" || user.ActivatedAt == nil {
|
||||
t.Fatalf("created admin = %+v role=%+v", user, user.Role)
|
||||
}
|
||||
if !bouncer.CheckPassword(user.Password, password) {
|
||||
t.Fatal("stored password hash does not match")
|
||||
}
|
||||
buf.Reset()
|
||||
if err := create.Run(context.Background(), flagInput{flags: map[string]string{
|
||||
"email": "editor@example.test",
|
||||
"password": password,
|
||||
"login": "editor",
|
||||
"role": "publisher",
|
||||
}}, out); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
var editor cabana.BackendUser
|
||||
if err := gdb.Where("login = ?", "editor").First(&editor).Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if editor.IsSuperuser || editor.Email != "editor@example.test" {
|
||||
t.Fatalf("editor = %+v", editor)
|
||||
}
|
||||
if err := create.Run(context.Background(), flagInput{flags: map[string]string{
|
||||
"email": "third@example.test", "password": password, "role": "missing-role",
|
||||
}}, out); err == nil || !strings.Contains(err.Error(), "unknown role") {
|
||||
t.Fatalf("unknown role err = %v", err)
|
||||
}
|
||||
if err := gdb.Exec(`INSERT INTO backend_user_roles (name, code, is_system, created_at, updated_at) VALUES ('Editor A', 'shared', FALSE, NOW(), NOW()), ('Editor B', 'shared', FALSE, NOW(), NOW())`).Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
err := create.Run(context.Background(), flagInput{flags: map[string]string{
|
||||
"email": "fourth@example.test", "password": password, "role": "shared",
|
||||
}}, out)
|
||||
if err == nil || !strings.Contains(err.Error(), "ambiguous role") || strings.Contains(err.Error(), password) {
|
||||
t.Fatalf("ambiguous role err = %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAdminResetPasswordCommand(t *testing.T) {
|
||||
gdb := adminGorm(t)
|
||||
app := commandApp(t, gdb)
|
||||
reset := commandByName(t, cabana.RuntimeCommands(app), "admin:reset-password")
|
||||
const original = "original-password-value"
|
||||
const updated = "replacement-password-value"
|
||||
hash, err := bouncer.HashPassword(10, original)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
var roleID uint
|
||||
if err := gdb.Raw(`SELECT id FROM backend_user_roles WHERE code = 'developer'`).Scan(&roleID).Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
user := cabana.BackendUser{Login: "resetme", Email: "resetme@example.test", Password: hash, IsActivated: true, RoleID: &roleID}
|
||||
if err := gdb.Create(&user).Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
token, _, err := bouncer.MintAudience(adminTestSecret, itoa(user.ID), "https://app.test/_admin/api/v1/auth/login", time.Hour, bouncer.AudienceBackend)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
guard := bouncer.NewBackendJWTGuard(adminTestSecret, cabana.BackendUsers{DB: gdb}, nil, nil)
|
||||
req := httptest.NewRequest(http.MethodGet, adminAPI("/auth/me"), nil)
|
||||
req.Header.Set("Authorization", "Bearer "+token)
|
||||
if _, err := guard.Authenticate(req); err != nil {
|
||||
t.Fatalf("token before reset: %v", err)
|
||||
}
|
||||
var buf bytes.Buffer
|
||||
out := bonfire.NewOutput(nil, &buf, &buf)
|
||||
if err := reset.Run(context.Background(), flagInput{
|
||||
args: []string{"ResetMe@Example.Test"},
|
||||
flags: map[string]string{"password": updated},
|
||||
}, out); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if strings.Contains(buf.String(), updated) || strings.Contains(buf.String(), original) || strings.Contains(buf.String(), "$2") || strings.Contains(buf.String(), token) {
|
||||
t.Fatalf("reset output leaked a secret: %s", buf.String())
|
||||
}
|
||||
if !strings.Contains(buf.String(), "resetme") {
|
||||
t.Fatalf("reset output = %s", buf.String())
|
||||
}
|
||||
var fresh cabana.BackendUser
|
||||
if err := gdb.First(&fresh, user.ID).Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if bouncer.CheckPassword(fresh.Password, original) || !bouncer.CheckPassword(fresh.Password, updated) {
|
||||
t.Fatal("password hash was not replaced")
|
||||
}
|
||||
if fresh.TokensValidAfter == nil {
|
||||
t.Fatal("reset did not advance tokens_valid_after")
|
||||
}
|
||||
if _, err := guard.Authenticate(req); err == nil {
|
||||
t.Fatal("token issued before reset still authenticated")
|
||||
}
|
||||
}
|
||||
|
||||
func commandByName(t *testing.T, cmds []bonfire.Command, name string) bonfire.Command {
|
||||
t.Helper()
|
||||
for _, cmd := range cmds {
|
||||
if cmd.Name == name && cmd.Run != nil {
|
||||
return cmd
|
||||
}
|
||||
}
|
||||
t.Fatalf("%s was not registered", name)
|
||||
return bonfire.Command{}
|
||||
}
|
||||
|
||||
func commandApp(t *testing.T, gdb *gorm.DB) *backpack.App {
|
||||
t.Helper()
|
||||
dir := t.TempDir()
|
||||
if err := os.WriteFile(filepath.Join(dir, "app.yaml"), []byte("name: cabana-admin\n"), 0o644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
cfg, err := compass.Open(compass.Options{
|
||||
Dir: dir,
|
||||
Environ: []string{
|
||||
"SUMMER_ENV=development",
|
||||
"SUMMER_ADMIN__JWT__SECRET=" + adminTestSecret,
|
||||
},
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
app := backpack.New(cfg)
|
||||
if err := lagoon.Publish(app, adminSQL, gdb); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return app
|
||||
}
|
||||
|
||||
type flagInput struct {
|
||||
args []string
|
||||
flags map[string]string
|
||||
}
|
||||
|
||||
func (f flagInput) Args() []string { return f.args }
|
||||
|
||||
func (f flagInput) Argument(name string) (string, bool) {
|
||||
if name == "identifier" && len(f.args) > 0 {
|
||||
return f.args[0], true
|
||||
}
|
||||
return "", false
|
||||
}
|
||||
|
||||
func (f flagInput) Flag(name string) (string, bool) {
|
||||
value, ok := f.flags[name]
|
||||
return value, ok && value != ""
|
||||
}
|
||||
|
||||
func (f flagInput) Flags(string) []string { return nil }
|
||||
177
modules/cabana/contracts.go
Normal file
177
modules/cabana/contracts.go
Normal file
@@ -0,0 +1,177 @@
|
||||
package cabana
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"net/http"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"git.golem15.com/golem15/summercms/modules/bouncer"
|
||||
"git.golem15.com/golem15/summercms/modules/pact"
|
||||
"gorm.io/gorm"
|
||||
)
|
||||
|
||||
// BackendUserRole is the Winter backend_user_roles row.
|
||||
type BackendUserRole struct {
|
||||
ID uint `gorm:"column:id;primaryKey"`
|
||||
Name string `gorm:"column:name"`
|
||||
Code string `gorm:"column:code"`
|
||||
Description string `gorm:"column:description"`
|
||||
Permissions string `gorm:"column:permissions"`
|
||||
IsSystem bool `gorm:"column:is_system"`
|
||||
CreatedAt time.Time `gorm:"column:created_at"`
|
||||
UpdatedAt time.Time `gorm:"column:updated_at"`
|
||||
}
|
||||
|
||||
func (BackendUserRole) TableName() string { return "backend_user_roles" }
|
||||
|
||||
// BackendUser is the Winter backend_users row. It is not a frontend user.
|
||||
// Nullable Winter columns are mapped so a copied row round-trips without a
|
||||
// schema transform. TokensValidAfter is the admin reset cutoff, not a Winter column.
|
||||
type BackendUser struct {
|
||||
ID uint `gorm:"column:id;primaryKey"`
|
||||
FirstName string `gorm:"column:first_name"`
|
||||
LastName string `gorm:"column:last_name"`
|
||||
Login string `gorm:"column:login"`
|
||||
Email string `gorm:"column:email"`
|
||||
Password string `gorm:"column:password"`
|
||||
ActivationCode string `gorm:"column:activation_code"`
|
||||
PersistCode string `gorm:"column:persist_code"`
|
||||
ResetPasswordCode string `gorm:"column:reset_password_code"`
|
||||
Permissions string `gorm:"column:permissions"`
|
||||
IsActivated bool `gorm:"column:is_activated"`
|
||||
IsSuperuser bool `gorm:"column:is_superuser"`
|
||||
RoleID *uint `gorm:"column:role_id"`
|
||||
ActivatedAt *time.Time `gorm:"column:activated_at"`
|
||||
LastLogin *time.Time `gorm:"column:last_login"`
|
||||
CreatedAt time.Time `gorm:"column:created_at"`
|
||||
UpdatedAt time.Time `gorm:"column:updated_at"`
|
||||
DeletedAt gorm.DeletedAt `gorm:"column:deleted_at"`
|
||||
TokensValidAfter *time.Time `gorm:"column:tokens_valid_after"`
|
||||
Role BackendUserRole
|
||||
}
|
||||
|
||||
func (BackendUser) TableName() string { return "backend_users" }
|
||||
|
||||
// Option is a dropdown choice shared with later schema plans.
|
||||
type Option = pact.Option
|
||||
|
||||
// WritableField is one schema field bound to a model fill key at activation.
|
||||
// FillKey comes from the model column, not from request JSON.
|
||||
type WritableField struct {
|
||||
Name string
|
||||
FillKey string
|
||||
}
|
||||
|
||||
// CompiledController is one admin controller after YAML compilation.
|
||||
type CompiledController struct {
|
||||
PluginID string
|
||||
Controller pact.AdminController
|
||||
List *ListSchema
|
||||
Form *FormSchema
|
||||
Relations map[string]*CompiledRelation
|
||||
Writable []WritableField
|
||||
// FieldRelations are the form's `type: relation` fields keyed by field name.
|
||||
FieldRelations map[string]*CompiledFieldRelation
|
||||
}
|
||||
|
||||
// Registry is the immutable controller map keyed by controller ID.
|
||||
type Registry struct {
|
||||
byID map[string]*CompiledController
|
||||
permissions map[string]pact.Permission
|
||||
roleGrants map[string]map[string]bool
|
||||
navigation []pact.NavigationItem
|
||||
settings map[string]*CompiledSetting
|
||||
}
|
||||
|
||||
// Get returns the compiled controller for a D-09 id (vendor.plugin.controller).
|
||||
func (r *Registry) Get(id string) (*CompiledController, bool) {
|
||||
if r == nil {
|
||||
return nil, false
|
||||
}
|
||||
cc, ok := r.byID[id]
|
||||
return cc, ok && cc != nil
|
||||
}
|
||||
|
||||
// Setting returns one compiled singleton setting by stable code.
|
||||
func (r *Registry) Setting(code string) (*CompiledSetting, bool) {
|
||||
if r == nil {
|
||||
return nil, false
|
||||
}
|
||||
setting, ok := r.settings[code]
|
||||
return setting, ok && setting != nil
|
||||
}
|
||||
|
||||
// Allows reports whether principal satisfies every required permission code.
|
||||
// A nil principal fails. Superusers pass. An empty requirement list allows
|
||||
// any authenticated principal. Grants ending in ".*" match by prefix.
|
||||
func Allows(principal *bouncer.Principal, required []string) bool {
|
||||
if principal == nil {
|
||||
return false
|
||||
}
|
||||
if principal.IsSuperuser || len(required) == 0 {
|
||||
return true
|
||||
}
|
||||
for _, code := range required {
|
||||
if !granted(principal.PermissionGrants, code) {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
func granted(grants map[string]bool, code string) bool {
|
||||
if grants[code] {
|
||||
return true
|
||||
}
|
||||
for key, on := range grants {
|
||||
if !on || !strings.HasSuffix(key, ".*") {
|
||||
continue
|
||||
}
|
||||
prefix := strings.TrimSuffix(key, "*")
|
||||
if strings.HasPrefix(code, prefix) {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func requiredOf(ctl pact.AdminController) []string {
|
||||
if p, ok := ctl.(pact.AdminPermissioned); ok && p != nil {
|
||||
return p.RequiredPermissions()
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// WriteData writes a D-10 success envelope.
|
||||
func WriteData(w http.ResponseWriter, status int, data, meta any) {
|
||||
if meta == nil {
|
||||
meta = map[string]any{}
|
||||
}
|
||||
writeJSON(w, status, map[string]any{"data": data, "meta": meta})
|
||||
}
|
||||
|
||||
// WriteError writes a D-10 error envelope. details is always an object.
|
||||
func WriteError(w http.ResponseWriter, status int, code, message string) {
|
||||
WriteErrorDetails(w, status, code, message, nil)
|
||||
}
|
||||
|
||||
// WriteErrorDetails writes a D-10 error envelope with field messages.
|
||||
func WriteErrorDetails(w http.ResponseWriter, status int, code, message string, details map[string]any) {
|
||||
if details == nil {
|
||||
details = map[string]any{}
|
||||
}
|
||||
writeJSON(w, status, map[string]any{
|
||||
"error": map[string]any{
|
||||
"code": code,
|
||||
"message": message,
|
||||
"details": details,
|
||||
},
|
||||
})
|
||||
}
|
||||
|
||||
func writeJSON(w http.ResponseWriter, status int, body any) {
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
w.WriteHeader(status)
|
||||
_ = json.NewEncoder(w).Encode(body)
|
||||
}
|
||||
932
modules/cabana/crud.go
Normal file
932
modules/cabana/crud.go
Normal file
@@ -0,0 +1,932 @@
|
||||
package cabana
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"math"
|
||||
"net/http"
|
||||
"reflect"
|
||||
"sort"
|
||||
"strconv"
|
||||
"strings"
|
||||
|
||||
"git.golem15.com/golem15/summercms/modules/lagoon"
|
||||
"git.golem15.com/golem15/summercms/modules/pact"
|
||||
"gorm.io/gorm"
|
||||
"gorm.io/gorm/clause"
|
||||
)
|
||||
|
||||
// CRUDService runs schema-projected record and bulk operations.
|
||||
type CRUDService struct {
|
||||
DB *gorm.DB
|
||||
}
|
||||
|
||||
// RecordInput is a decoded JSON object. Keys are untrusted.
|
||||
type RecordInput struct {
|
||||
Body map[string]any
|
||||
}
|
||||
|
||||
// BulkDeleteInput is the bulk-delete body.
|
||||
type BulkDeleteInput struct {
|
||||
IDs []any `json:"ids"`
|
||||
}
|
||||
|
||||
// BulkResult is the deleted-count payload.
|
||||
type BulkResult struct {
|
||||
Deleted int `json:"deleted"`
|
||||
}
|
||||
|
||||
// ValidationError is a D-10 validation_failed failure.
|
||||
type ValidationError struct {
|
||||
Details map[string]any
|
||||
}
|
||||
|
||||
func (e *ValidationError) Error() string { return "validation_failed" }
|
||||
|
||||
// CapabilityError is a fail-closed Fill/Validate failure with controller context.
|
||||
type CapabilityError struct {
|
||||
ControllerID string
|
||||
}
|
||||
|
||||
func (e *CapabilityError) Error() string {
|
||||
if e == nil {
|
||||
return "cabana: missing Fill/Validate capability"
|
||||
}
|
||||
return "cabana: controller " + e.ControllerID + ": missing Fill/Validate capability"
|
||||
}
|
||||
|
||||
type recordNotFound struct{}
|
||||
|
||||
func (recordNotFound) Error() string { return "cabana: not found" }
|
||||
|
||||
type hasRules interface {
|
||||
Rules() map[string]string
|
||||
}
|
||||
|
||||
// ProjectWritableFields copies only activation-bound writable keys.
|
||||
// Unknown keys, case variants, nested objects, and protected columns are dropped.
|
||||
func ProjectWritableFields(cc *CompiledController, body map[string]any) map[string]any {
|
||||
out := map[string]any{}
|
||||
if cc == nil || body == nil {
|
||||
return out
|
||||
}
|
||||
allowed := map[string]string{}
|
||||
for _, field := range cc.Writable {
|
||||
if field.FillKey == "" || protectedFillKey(field.Name) || protectedFillKey(field.FillKey) {
|
||||
continue
|
||||
}
|
||||
allowed[field.Name] = field.FillKey
|
||||
}
|
||||
for key, val := range body {
|
||||
fillKey, ok := allowed[key]
|
||||
if !ok || nestedValue(val) {
|
||||
continue
|
||||
}
|
||||
out[fillKey] = val
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
// BindWritableFields records schema field names onto model column fill keys.
|
||||
// Protected columns are omitted. A scalar field with no column fails activation.
|
||||
func BindWritableFields(cc *CompiledController) error {
|
||||
if cc == nil || cc.Form == nil {
|
||||
return nil
|
||||
}
|
||||
id := ""
|
||||
if cc.Controller != nil {
|
||||
id = cc.Controller.ID()
|
||||
}
|
||||
src, ok := cc.Controller.(pact.AdminRecordSource)
|
||||
if !ok || src == nil || src.NewRecord() == nil {
|
||||
return nil
|
||||
}
|
||||
cols := modelColumns(src.NewRecord())
|
||||
bindings := make([]WritableField, 0, len(cc.Form.Fields))
|
||||
for _, field := range cc.Form.Fields {
|
||||
if !scalarFormField(field.Type) || protectedFillKey(field.Name) {
|
||||
continue
|
||||
}
|
||||
if _, known := cols[field.Name]; !known {
|
||||
return errors.New("cabana: controller " + id + ": field " + field.Name + " is not a model column")
|
||||
}
|
||||
bindings = append(bindings, WritableField{Name: field.Name, FillKey: field.Name})
|
||||
}
|
||||
cc.Writable = bindings
|
||||
return nil
|
||||
}
|
||||
|
||||
// Create persists a projected record after Fill and Validate.
|
||||
func (s CRUDService) Create(ctx context.Context, cc *CompiledController, in RecordInput) (map[string]any, error) {
|
||||
res, err := s.save(ctx, cc, nil, in, false)
|
||||
return res.Data, err
|
||||
}
|
||||
|
||||
// Update persists a projected change after Fill and Validate.
|
||||
func (s CRUDService) Update(ctx context.Context, cc *CompiledController, id any, in RecordInput) (map[string]any, error) {
|
||||
res, err := s.save(ctx, cc, id, in, true)
|
||||
return res.Data, err
|
||||
}
|
||||
|
||||
// CreateRecord is Create plus the relation labels of the saved record (D-18).
|
||||
func (s CRUDService) CreateRecord(ctx context.Context, cc *CompiledController, in RecordInput) (RecordResult, error) {
|
||||
return s.save(ctx, cc, nil, in, false)
|
||||
}
|
||||
|
||||
// UpdateRecord is Update plus the relation labels of the saved record (D-18).
|
||||
func (s CRUDService) UpdateRecord(ctx context.Context, cc *CompiledController, id any, in RecordInput) (RecordResult, error) {
|
||||
return s.save(ctx, cc, id, in, true)
|
||||
}
|
||||
|
||||
// Delete removes one scoped record. A missing or out-of-scope id is a successful no-op.
|
||||
func (s CRUDService) Delete(ctx context.Context, cc *CompiledController, id any) (BulkResult, error) {
|
||||
if s.DB == nil {
|
||||
return BulkResult{}, errors.New("cabana: database is not configured")
|
||||
}
|
||||
if ctx == nil {
|
||||
ctx = context.Background()
|
||||
}
|
||||
if _, err := newWritableModel(cc); err != nil {
|
||||
return BulkResult{}, err
|
||||
}
|
||||
var result BulkResult
|
||||
err := s.DB.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
|
||||
tx = tx.WithContext(ctx)
|
||||
target, err := newWritableModel(cc)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
pk, err := coercePK(target, id)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if err := loadRecord(ctx, tx, cc, target, pk); err != nil {
|
||||
var missing recordNotFound
|
||||
if errors.As(err, &missing) {
|
||||
result.Deleted = 0
|
||||
return nil
|
||||
}
|
||||
return err
|
||||
}
|
||||
if err := deleteRecord(ctx, tx, cc, target); err != nil {
|
||||
return err
|
||||
}
|
||||
result.Deleted = 1
|
||||
return nil
|
||||
})
|
||||
if err != nil {
|
||||
return BulkResult{}, err
|
||||
}
|
||||
return result, nil
|
||||
}
|
||||
|
||||
// BulkDelete removes a normalized id set in one transaction.
|
||||
// An empty selection is validation_failed. A wholly absent selection is a
|
||||
// successful no-op. A mixed present/absent selection conflicts and rolls back.
|
||||
func (s CRUDService) BulkDelete(ctx context.Context, cc *CompiledController, in BulkDeleteInput) (BulkResult, error) {
|
||||
if s.DB == nil {
|
||||
return BulkResult{}, errors.New("cabana: database is not configured")
|
||||
}
|
||||
if ctx == nil {
|
||||
ctx = context.Background()
|
||||
}
|
||||
ids, err := normalizeIDs(in.IDs)
|
||||
if err != nil {
|
||||
return BulkResult{}, err
|
||||
}
|
||||
if _, err := newWritableModel(cc); err != nil {
|
||||
return BulkResult{}, err
|
||||
}
|
||||
var result BulkResult
|
||||
err = s.DB.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
|
||||
tx = tx.WithContext(ctx)
|
||||
if err := ctx.Err(); err != nil {
|
||||
return lifecycleFailure(cc, err)
|
||||
}
|
||||
proto, err := newWritableModel(cc)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
rows, err := lockScoped(ctx, tx, cc, proto, ids)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if len(rows) == 0 {
|
||||
result.Deleted = 0
|
||||
return nil
|
||||
}
|
||||
if len(rows) != len(ids) {
|
||||
return partialSelection{}
|
||||
}
|
||||
for _, row := range rows {
|
||||
if err := ctx.Err(); err != nil {
|
||||
return lifecycleFailure(cc, err)
|
||||
}
|
||||
if err := deleteRecord(ctx, tx, cc, row); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
result.Deleted = len(rows)
|
||||
return nil
|
||||
})
|
||||
if err != nil {
|
||||
return BulkResult{}, err
|
||||
}
|
||||
return result, nil
|
||||
}
|
||||
|
||||
// Show loads one scoped record. Missing and out-of-scope ids are identical.
|
||||
func (s CRUDService) Show(ctx context.Context, cc *CompiledController, id any) (map[string]any, error) {
|
||||
res, err := s.ShowRecord(ctx, cc, id)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return res.Data, nil
|
||||
}
|
||||
|
||||
// ShowRecord is Show plus the relation labels of the record (D-18).
|
||||
func (s CRUDService) ShowRecord(ctx context.Context, cc *CompiledController, id any) (RecordResult, error) {
|
||||
if s.DB == nil {
|
||||
return RecordResult{}, errors.New("cabana: database is not configured")
|
||||
}
|
||||
if ctx == nil {
|
||||
ctx = context.Background()
|
||||
}
|
||||
var result RecordResult
|
||||
err := s.DB.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
|
||||
tx = tx.WithContext(ctx)
|
||||
target, err := newWritableModel(cc)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
pk, err := coercePK(target, id)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if err := loadRecord(ctx, tx, cc, target, pk); err != nil {
|
||||
return err
|
||||
}
|
||||
result, err = projectFullRecord(ctx, tx, cc, target)
|
||||
return err
|
||||
})
|
||||
if err != nil {
|
||||
return RecordResult{}, err
|
||||
}
|
||||
return result, nil
|
||||
}
|
||||
|
||||
// projectFullRecord is the D-18 record shape: scalar writable fields, relation
|
||||
// values keyed by field name, and their labels.
|
||||
func projectFullRecord(ctx context.Context, tx *gorm.DB, cc *CompiledController, model any) (RecordResult, error) {
|
||||
data := projectRecord(cc, model)
|
||||
meta, err := projectRelationFields(ctx, tx, cc, model, data)
|
||||
if err != nil {
|
||||
return RecordResult{}, err
|
||||
}
|
||||
return RecordResult{Data: data, Meta: meta}, nil
|
||||
}
|
||||
|
||||
func (s CRUDService) save(ctx context.Context, cc *CompiledController, id any, in RecordInput, update bool) (RecordResult, error) {
|
||||
if s.DB == nil {
|
||||
return RecordResult{}, errors.New("cabana: database is not configured")
|
||||
}
|
||||
if ctx == nil {
|
||||
ctx = context.Background()
|
||||
}
|
||||
if _, err := newWritableModel(cc); err != nil {
|
||||
return RecordResult{}, err
|
||||
}
|
||||
op := "create"
|
||||
if update {
|
||||
op = "update"
|
||||
}
|
||||
// Writable relation keys are lifted before scalar projection (which drops
|
||||
// every nested value); only keys present in the body are applied.
|
||||
relations, err := liftRelationValues(cc, in.Body, op)
|
||||
if err != nil {
|
||||
return RecordResult{}, err
|
||||
}
|
||||
var result RecordResult
|
||||
err = s.DB.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
|
||||
tx = tx.WithContext(ctx)
|
||||
target, err := newWritableModel(cc)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if update {
|
||||
pk, err := coercePK(target, id)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if err := loadRecord(ctx, tx, cc, target, pk); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
projected := projectOperation(cc, in.Body, op)
|
||||
if err := lagoon.Fill(target, fillAllowed(cc, target, op), projected, false); err != nil {
|
||||
return &CapabilityError{ControllerID: controllerID(cc)}
|
||||
}
|
||||
if hook, ok := target.(lagoon.HasBeforeValidate); ok && hook != nil {
|
||||
if err := hook.BeforeValidate(tx); err != nil {
|
||||
return &CapabilityError{ControllerID: controllerID(cc)}
|
||||
}
|
||||
}
|
||||
rules := mergedRules(cc, target)
|
||||
msgs, err := lagoon.Validate(ctx, tx, target, rules, valuesForRules(target, rules), nil)
|
||||
if err != nil {
|
||||
return &CapabilityError{ControllerID: controllerID(cc)}
|
||||
}
|
||||
if len(msgs) > 0 {
|
||||
return &ValidationError{Details: validationDetails(msgs)}
|
||||
}
|
||||
if update {
|
||||
err = formBeforeUpdate(ctx, cc, target)
|
||||
} else {
|
||||
err = formBeforeCreate(ctx, cc, target)
|
||||
}
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
// D-18: submitted ids pass the same scoped query as the options
|
||||
// endpoint; belongsTo keys land before the row write, pivot rows after.
|
||||
if err := checkRelationScope(ctx, tx, cc, relations); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := assignBelongsTo(cc, target, relations); err != nil {
|
||||
return err
|
||||
}
|
||||
if update {
|
||||
err = tx.Save(target).Error
|
||||
} else {
|
||||
err = tx.Create(target).Error
|
||||
}
|
||||
if err != nil {
|
||||
return lifecycleFailure(cc, err)
|
||||
}
|
||||
if err := syncBelongsToMany(ctx, tx, cc, target, relations); err != nil {
|
||||
return err
|
||||
}
|
||||
if update {
|
||||
err = formAfterUpdate(ctx, cc, target)
|
||||
} else {
|
||||
err = formAfterCreate(ctx, cc, target)
|
||||
}
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
result, err = projectFullRecord(ctx, tx, cc, target)
|
||||
return err
|
||||
})
|
||||
if err != nil {
|
||||
return RecordResult{}, err
|
||||
}
|
||||
return result, nil
|
||||
}
|
||||
|
||||
func writeCRUDError(w http.ResponseWriter, err error) {
|
||||
var ve *ValidationError
|
||||
if errors.As(err, &ve) {
|
||||
WriteErrorDetails(w, http.StatusUnprocessableEntity, "validation_failed", "Validation failed", ve.Details)
|
||||
return
|
||||
}
|
||||
var missing recordNotFound
|
||||
if errors.As(err, &missing) {
|
||||
WriteError(w, http.StatusNotFound, "not_found", msgNotFound)
|
||||
return
|
||||
}
|
||||
var partial partialSelection
|
||||
if errors.As(err, &partial) {
|
||||
WriteError(w, http.StatusConflict, "conflict", "Conflict")
|
||||
return
|
||||
}
|
||||
WriteError(w, http.StatusInternalServerError, "error", msgServerError)
|
||||
}
|
||||
|
||||
func newWritableModel(cc *CompiledController) (any, error) {
|
||||
id := controllerID(cc)
|
||||
if cc == nil || cc.Controller == nil {
|
||||
return nil, &CapabilityError{ControllerID: id}
|
||||
}
|
||||
src, ok := cc.Controller.(pact.AdminRecordSource)
|
||||
if !ok || src == nil {
|
||||
return nil, &CapabilityError{ControllerID: id}
|
||||
}
|
||||
model := src.NewRecord()
|
||||
if model == nil {
|
||||
return nil, &CapabilityError{ControllerID: id}
|
||||
}
|
||||
if _, ok := model.(lagoon.HasFillable); !ok {
|
||||
return nil, &CapabilityError{ControllerID: id}
|
||||
}
|
||||
if _, ok := model.(hasRules); !ok {
|
||||
return nil, &CapabilityError{ControllerID: id}
|
||||
}
|
||||
return model, nil
|
||||
}
|
||||
|
||||
func controllerID(cc *CompiledController) string {
|
||||
if cc == nil || cc.Controller == nil {
|
||||
return ""
|
||||
}
|
||||
return cc.Controller.ID()
|
||||
}
|
||||
|
||||
func loadRecord(ctx context.Context, tx *gorm.DB, cc *CompiledController, dest any, pk any) error {
|
||||
col := primaryColumn(dest)
|
||||
q := tx.WithContext(ctx)
|
||||
if cc != nil {
|
||||
if ext, ok := cc.Controller.(pact.FormExtendQuery); ok && ext != nil {
|
||||
if next := ext.FormExtendQuery(ctx, q); next != nil {
|
||||
q = next
|
||||
}
|
||||
}
|
||||
}
|
||||
err := q.Clauses(clause.Locking{Strength: "UPDATE"}).
|
||||
Where(clause.Eq{Column: clause.Column{Name: col}, Value: pk}).
|
||||
Take(dest).Error
|
||||
if errors.Is(err, gorm.ErrRecordNotFound) {
|
||||
return recordNotFound{}
|
||||
}
|
||||
if err != nil {
|
||||
return lifecycleFailure(cc, err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
type lifecycleError struct {
|
||||
ControllerID string
|
||||
}
|
||||
|
||||
func (e *lifecycleError) Error() string {
|
||||
if e == nil {
|
||||
return "cabana: lifecycle failed"
|
||||
}
|
||||
return "cabana: controller " + e.ControllerID + " failed"
|
||||
}
|
||||
|
||||
func lifecycleFailure(cc *CompiledController, err error) error {
|
||||
if err == nil {
|
||||
return nil
|
||||
}
|
||||
var missing recordNotFound
|
||||
if errors.As(err, &missing) {
|
||||
return err
|
||||
}
|
||||
var invalid *ValidationError
|
||||
if errors.As(err, &invalid) {
|
||||
return err
|
||||
}
|
||||
var closed *CapabilityError
|
||||
if errors.As(err, &closed) {
|
||||
return err
|
||||
}
|
||||
var partial partialSelection
|
||||
if errors.As(err, &partial) {
|
||||
return err
|
||||
}
|
||||
var life *lifecycleError
|
||||
if errors.As(err, &life) {
|
||||
return err
|
||||
}
|
||||
return &lifecycleError{ControllerID: controllerID(cc)}
|
||||
}
|
||||
|
||||
type partialSelection struct{}
|
||||
|
||||
func (partialSelection) Error() string { return "cabana: partial selection" }
|
||||
|
||||
func normalizeIDs(raw []any) ([]uint, error) {
|
||||
if len(raw) == 0 {
|
||||
return nil, &ValidationError{Details: map[string]any{"ids": []string{"The ids field is required."}}}
|
||||
}
|
||||
seen := map[uint]struct{}{}
|
||||
ids := make([]uint, 0, len(raw))
|
||||
for _, item := range raw {
|
||||
n, err := asUint(item)
|
||||
if err != nil {
|
||||
return nil, &ValidationError{Details: map[string]any{"ids": []string{"The ids field must be a list of integers."}}}
|
||||
}
|
||||
if _, ok := seen[n]; ok {
|
||||
continue
|
||||
}
|
||||
seen[n] = struct{}{}
|
||||
ids = append(ids, n)
|
||||
}
|
||||
sort.Slice(ids, func(i, j int) bool { return ids[i] < ids[j] })
|
||||
return ids, nil
|
||||
}
|
||||
|
||||
func lockScoped(ctx context.Context, tx *gorm.DB, cc *CompiledController, proto any, ids []uint) ([]any, error) {
|
||||
mt := reflect.TypeOf(proto)
|
||||
if mt == nil || mt.Kind() != reflect.Pointer || mt.Elem().Kind() != reflect.Struct {
|
||||
return nil, &CapabilityError{ControllerID: controllerID(cc)}
|
||||
}
|
||||
holder := reflect.New(reflect.SliceOf(mt.Elem()))
|
||||
q := tx.WithContext(ctx).Model(proto)
|
||||
if cc != nil {
|
||||
if ext, ok := cc.Controller.(pact.ListExtendQuery); ok && ext != nil {
|
||||
if next := ext.ListExtendQuery(ctx, q); next != nil {
|
||||
q = next
|
||||
}
|
||||
}
|
||||
}
|
||||
col := primaryColumn(proto)
|
||||
vals := make([]any, len(ids))
|
||||
for i, id := range ids {
|
||||
vals[i] = castPK(proto, id)
|
||||
}
|
||||
err := q.Clauses(clause.Locking{Strength: "UPDATE"}).
|
||||
Where(clause.IN{Column: clause.Column{Name: col}, Values: vals}).
|
||||
Order(clause.OrderByColumn{Column: clause.Column{Name: col}, Desc: false}).
|
||||
Find(holder.Interface()).Error
|
||||
if err != nil {
|
||||
return nil, lifecycleFailure(cc, err)
|
||||
}
|
||||
values := holder.Elem()
|
||||
out := make([]any, values.Len())
|
||||
for i := 0; i < values.Len(); i++ {
|
||||
out[i] = values.Index(i).Addr().Interface()
|
||||
}
|
||||
sort.SliceStable(out, func(i, j int) bool { return pkUint(out[i]) < pkUint(out[j]) })
|
||||
return out, nil
|
||||
}
|
||||
|
||||
func pkUint(model any) uint {
|
||||
v := reflect.ValueOf(model)
|
||||
for v.Kind() == reflect.Pointer {
|
||||
if v.IsNil() {
|
||||
return 0
|
||||
}
|
||||
v = v.Elem()
|
||||
}
|
||||
field := fieldByColumn(v, primaryColumn(model))
|
||||
if !field.IsValid() || !field.CanInterface() {
|
||||
return 0
|
||||
}
|
||||
n, err := asUint(field.Interface())
|
||||
if err != nil {
|
||||
return 0
|
||||
}
|
||||
return n
|
||||
}
|
||||
|
||||
func formBeforeCreate(ctx context.Context, cc *CompiledController, model any) error {
|
||||
hook, ok := cc.Controller.(pact.FormBeforeCreate)
|
||||
if !ok || hook == nil {
|
||||
return nil
|
||||
}
|
||||
return lifecycleFailure(cc, hook.FormBeforeCreate(ctx, model))
|
||||
}
|
||||
|
||||
func formAfterCreate(ctx context.Context, cc *CompiledController, model any) error {
|
||||
hook, ok := cc.Controller.(pact.FormAfterCreate)
|
||||
if !ok || hook == nil {
|
||||
return nil
|
||||
}
|
||||
return lifecycleFailure(cc, hook.FormAfterCreate(ctx, model))
|
||||
}
|
||||
|
||||
func formBeforeUpdate(ctx context.Context, cc *CompiledController, model any) error {
|
||||
hook, ok := cc.Controller.(pact.FormBeforeUpdate)
|
||||
if !ok || hook == nil {
|
||||
return nil
|
||||
}
|
||||
return lifecycleFailure(cc, hook.FormBeforeUpdate(ctx, model))
|
||||
}
|
||||
|
||||
func formAfterUpdate(ctx context.Context, cc *CompiledController, model any) error {
|
||||
hook, ok := cc.Controller.(pact.FormAfterUpdate)
|
||||
if !ok || hook == nil {
|
||||
return nil
|
||||
}
|
||||
return lifecycleFailure(cc, hook.FormAfterUpdate(ctx, model))
|
||||
}
|
||||
|
||||
func deleteRecord(ctx context.Context, tx *gorm.DB, cc *CompiledController, model any) error {
|
||||
if hook, ok := cc.Controller.(pact.FormBeforeDelete); ok && hook != nil {
|
||||
if err := lifecycleFailure(cc, hook.FormBeforeDelete(ctx, model)); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
if err := tx.WithContext(ctx).Delete(model).Error; err != nil {
|
||||
return lifecycleFailure(cc, err)
|
||||
}
|
||||
if hook, ok := cc.Controller.(pact.FormAfterDelete); ok && hook != nil {
|
||||
if err := lifecycleFailure(cc, hook.FormAfterDelete(ctx, model)); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func decodeObject(r *http.Request) (map[string]any, error) {
|
||||
dec := json.NewDecoder(r.Body)
|
||||
dec.UseNumber()
|
||||
var body map[string]any
|
||||
if err := dec.Decode(&body); err != nil {
|
||||
return nil, &ValidationError{Details: map[string]any{"body": []string{"The request body is invalid."}}}
|
||||
}
|
||||
if body == nil {
|
||||
body = map[string]any{}
|
||||
}
|
||||
return body, nil
|
||||
}
|
||||
|
||||
func pathID(r *http.Request) (uint, error) {
|
||||
raw := strings.TrimSpace(r.PathValue("id"))
|
||||
n, err := strconv.ParseUint(raw, 10, 64)
|
||||
if raw == "" || err != nil {
|
||||
return 0, &ValidationError{Details: map[string]any{"id": []string{"The id field must be an integer."}}}
|
||||
}
|
||||
return uint(n), nil
|
||||
}
|
||||
|
||||
func projectOperation(cc *CompiledController, body map[string]any, op string) map[string]any {
|
||||
projected := ProjectWritableFields(cc, body)
|
||||
if op == "" || cc == nil {
|
||||
return projected
|
||||
}
|
||||
filtered := map[string]any{}
|
||||
for _, field := range cc.Writable {
|
||||
if !contextAllows(cc, field.Name, op) {
|
||||
continue
|
||||
}
|
||||
if val, ok := projected[field.FillKey]; ok {
|
||||
filtered[field.FillKey] = val
|
||||
}
|
||||
}
|
||||
return filtered
|
||||
}
|
||||
|
||||
func fillAllowed(cc *CompiledController, model any, op string) []string {
|
||||
fillable, ok := model.(lagoon.HasFillable)
|
||||
if !ok || fillable == nil {
|
||||
return nil
|
||||
}
|
||||
allowed := map[string]struct{}{}
|
||||
for _, key := range fillable.Fillable() {
|
||||
if !protectedFillKey(key) {
|
||||
allowed[key] = struct{}{}
|
||||
}
|
||||
}
|
||||
out := make([]string, 0, len(allowed))
|
||||
if cc == nil {
|
||||
return out
|
||||
}
|
||||
for _, field := range cc.Writable {
|
||||
if protectedFillKey(field.FillKey) {
|
||||
continue
|
||||
}
|
||||
if _, ok := allowed[field.FillKey]; !ok || !contextAllows(cc, field.Name, op) {
|
||||
continue
|
||||
}
|
||||
out = append(out, field.FillKey)
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
func mergedRules(cc *CompiledController, model any) map[string]string {
|
||||
out := map[string]string{}
|
||||
if rules, ok := model.(hasRules); ok && rules != nil {
|
||||
for key, rule := range rules.Rules() {
|
||||
out[key] = rule
|
||||
}
|
||||
}
|
||||
if cc == nil || cc.Form == nil {
|
||||
return out
|
||||
}
|
||||
for _, field := range cc.Form.Fields {
|
||||
// Relation fields are not writable columns. required stays on the
|
||||
// schema for the client, but it cannot be checked by Fill.
|
||||
if field.Required && scalarFormField(field.Type) {
|
||||
out[field.Name] = mergeRequired(out[field.Name])
|
||||
}
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
func mergeRequired(rule string) string {
|
||||
if strings.TrimSpace(rule) == "" {
|
||||
return "required"
|
||||
}
|
||||
for _, tok := range strings.Split(rule, "|") {
|
||||
name, _, _ := strings.Cut(strings.TrimSpace(tok), ":")
|
||||
if name == "required" {
|
||||
return rule
|
||||
}
|
||||
}
|
||||
return rule + "|required"
|
||||
}
|
||||
|
||||
func valuesForRules(model any, rules map[string]string) map[string]any {
|
||||
v := reflect.ValueOf(model)
|
||||
for v.Kind() == reflect.Pointer {
|
||||
if v.IsNil() {
|
||||
return map[string]any{}
|
||||
}
|
||||
v = v.Elem()
|
||||
}
|
||||
out := map[string]any{}
|
||||
for field := range rules {
|
||||
f := fieldByColumn(v, field)
|
||||
if f.IsValid() && f.CanInterface() {
|
||||
out[field] = f.Interface()
|
||||
}
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
func validationDetails(msgs map[string][]string) map[string]any {
|
||||
out := make(map[string]any, len(msgs))
|
||||
for key, messages := range msgs {
|
||||
out[key] = messages
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
func projectRecord(cc *CompiledController, model any) map[string]any {
|
||||
v := reflect.ValueOf(model)
|
||||
for v.Kind() == reflect.Pointer {
|
||||
if v.IsNil() {
|
||||
return map[string]any{}
|
||||
}
|
||||
v = v.Elem()
|
||||
}
|
||||
out := map[string]any{}
|
||||
if id := fieldByColumn(v, primaryColumn(model)); id.IsValid() && id.CanInterface() {
|
||||
out["id"] = id.Interface()
|
||||
}
|
||||
if cc == nil {
|
||||
return out
|
||||
}
|
||||
for _, field := range cc.Writable {
|
||||
if protectedFillKey(field.FillKey) {
|
||||
continue
|
||||
}
|
||||
f := fieldByColumn(v, field.FillKey)
|
||||
if f.IsValid() && f.CanInterface() {
|
||||
out[field.Name] = f.Interface()
|
||||
}
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
func modelColumns(model any) map[string]struct{} {
|
||||
t := reflect.TypeOf(model)
|
||||
for t != nil && t.Kind() == reflect.Pointer {
|
||||
t = t.Elem()
|
||||
}
|
||||
cols := map[string]struct{}{}
|
||||
if t == nil || t.Kind() != reflect.Struct {
|
||||
return cols
|
||||
}
|
||||
for i := 0; i < t.NumField(); i++ {
|
||||
field := t.Field(i)
|
||||
if field.PkgPath != "" {
|
||||
continue
|
||||
}
|
||||
name := gormColumn(field)
|
||||
if name != "" {
|
||||
cols[name] = struct{}{}
|
||||
}
|
||||
}
|
||||
return cols
|
||||
}
|
||||
|
||||
func scalarFormField(typ string) bool {
|
||||
switch typ {
|
||||
case "text", "textarea", "number", "checkbox", "switch", "dropdown":
|
||||
return true
|
||||
default:
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
func protectedFillKey(key string) bool {
|
||||
switch strings.ToLower(key) {
|
||||
case "id", "created_at", "updated_at", "deleted_at",
|
||||
"owner_id", "user_id", "collection_id", "organisation_id", "organization_id",
|
||||
"scope_id", "role_id", "permissions",
|
||||
"is_superuser", "is_system", "is_activated", "password":
|
||||
return true
|
||||
default:
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
func nestedValue(val any) bool {
|
||||
switch val.(type) {
|
||||
case map[string]any, []any:
|
||||
return true
|
||||
default:
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
func contextAllows(cc *CompiledController, name, op string) bool {
|
||||
if op == "" || cc == nil || cc.Form == nil {
|
||||
return true
|
||||
}
|
||||
for _, field := range cc.Form.Fields {
|
||||
if field.Name != name {
|
||||
continue
|
||||
}
|
||||
if field.Context == nil || len(field.Context.values) == 0 {
|
||||
return true
|
||||
}
|
||||
for _, value := range field.Context.values {
|
||||
if value == op {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
func coercePK(model any, id any) (any, error) {
|
||||
n, err := asUint(id)
|
||||
if err != nil {
|
||||
return nil, &ValidationError{Details: map[string]any{"id": []string{"The id field must be an integer."}}}
|
||||
}
|
||||
return castPK(model, n), nil
|
||||
}
|
||||
|
||||
func castPK(model any, n uint) any {
|
||||
t := reflect.TypeOf(model)
|
||||
for t != nil && t.Kind() == reflect.Pointer {
|
||||
t = t.Elem()
|
||||
}
|
||||
if t == nil || t.Kind() != reflect.Struct {
|
||||
return n
|
||||
}
|
||||
for i := 0; i < t.NumField(); i++ {
|
||||
field := t.Field(i)
|
||||
if !strings.Contains(field.Tag.Get("gorm"), "primaryKey") {
|
||||
continue
|
||||
}
|
||||
switch field.Type.Kind() {
|
||||
case reflect.Uint:
|
||||
return uint(n)
|
||||
case reflect.Uint32:
|
||||
return uint32(n)
|
||||
case reflect.Uint64:
|
||||
return uint64(n)
|
||||
case reflect.Int:
|
||||
return int(n)
|
||||
case reflect.Int64:
|
||||
return int64(n)
|
||||
case reflect.String:
|
||||
return strconv.FormatUint(uint64(n), 10)
|
||||
default:
|
||||
return n
|
||||
}
|
||||
}
|
||||
return n
|
||||
}
|
||||
|
||||
func asUint(id any) (uint, error) {
|
||||
switch n := id.(type) {
|
||||
case uint:
|
||||
return n, nil
|
||||
case uint32:
|
||||
return uint(n), nil
|
||||
case uint64:
|
||||
if uint64(uint(n)) != n {
|
||||
return 0, errBadID
|
||||
}
|
||||
return uint(n), nil
|
||||
case int:
|
||||
if n < 0 {
|
||||
return 0, errBadID
|
||||
}
|
||||
return uint(n), nil
|
||||
case int64:
|
||||
if n < 0 {
|
||||
return 0, errBadID
|
||||
}
|
||||
return uint(n), nil
|
||||
case float64:
|
||||
if n < 0 || n != math.Trunc(n) || n > math.MaxUint32 && strconv.IntSize == 32 {
|
||||
return 0, errBadID
|
||||
}
|
||||
return uint(n), nil
|
||||
case json.Number:
|
||||
i, err := n.Int64()
|
||||
if err != nil || i < 0 {
|
||||
return 0, errBadID
|
||||
}
|
||||
return uint(i), nil
|
||||
case string:
|
||||
i, err := strconv.ParseUint(n, 10, 64)
|
||||
if err != nil {
|
||||
return 0, errBadID
|
||||
}
|
||||
return uint(i), nil
|
||||
default:
|
||||
return 0, errBadID
|
||||
}
|
||||
}
|
||||
|
||||
var errBadID = errors.New("cabana: bad id")
|
||||
500
modules/cabana/crud_lifecycle_test.go
Normal file
500
modules/cabana/crud_lifecycle_test.go
Normal file
@@ -0,0 +1,500 @@
|
||||
package cabana
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"encoding/json"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"strconv"
|
||||
"strings"
|
||||
"sync/atomic"
|
||||
"testing"
|
||||
|
||||
"git.golem15.com/golem15/summercms/modules/backpack"
|
||||
"git.golem15.com/golem15/summercms/modules/bouncer"
|
||||
"git.golem15.com/golem15/summercms/modules/pact"
|
||||
"gorm.io/gorm"
|
||||
)
|
||||
|
||||
type scopeKey struct{}
|
||||
|
||||
type hookController struct {
|
||||
log *[]string
|
||||
perms []string
|
||||
trackScope bool
|
||||
fail string
|
||||
queries atomic.Int32
|
||||
allocs atomic.Int32
|
||||
}
|
||||
|
||||
func (c *hookController) ID() string { return "acme.demo.records" }
|
||||
func (c *hookController) ModelName() string { return "Record" }
|
||||
func (c *hookController) ConfigDir() string { return "controllers/records" }
|
||||
func (c *hookController) RequiredPermissions() []string {
|
||||
if c == nil || c.perms == nil {
|
||||
return nil
|
||||
}
|
||||
return c.perms
|
||||
}
|
||||
func (c *hookController) NewRecord() any {
|
||||
if c != nil {
|
||||
c.allocs.Add(1)
|
||||
}
|
||||
return &crudRow{}
|
||||
}
|
||||
func (c *hookController) ListExtendQuery(ctx context.Context, db *gorm.DB) *gorm.DB {
|
||||
return c.FormExtendQuery(ctx, db)
|
||||
}
|
||||
func (c *hookController) FormExtendQuery(ctx context.Context, db *gorm.DB) *gorm.DB {
|
||||
if c != nil {
|
||||
c.queries.Add(1)
|
||||
}
|
||||
if c == nil || !c.trackScope || db == nil {
|
||||
return db
|
||||
}
|
||||
scope, _ := ctx.Value(scopeKey{}).(uint)
|
||||
return db.Where("scope_id = ?", scope)
|
||||
}
|
||||
func (c *hookController) FormBeforeCreate(ctx context.Context, model any) error {
|
||||
recordHook(ctx, "form_before_create")
|
||||
if c.trackScope {
|
||||
if row, ok := model.(*crudRow); ok {
|
||||
if scope, ok := ctx.Value(scopeKey{}).(uint); ok {
|
||||
row.ScopeID = scope
|
||||
}
|
||||
}
|
||||
}
|
||||
return c.hookErr("form_before_create")
|
||||
}
|
||||
func (c *hookController) FormAfterCreate(ctx context.Context, model any) error {
|
||||
recordHook(ctx, "form_after_create")
|
||||
return c.hookErr("form_after_create")
|
||||
}
|
||||
func (c *hookController) FormBeforeUpdate(ctx context.Context, model any) error {
|
||||
recordHook(ctx, "form_before_update")
|
||||
return c.hookErr("form_before_update")
|
||||
}
|
||||
func (c *hookController) FormAfterUpdate(ctx context.Context, model any) error {
|
||||
recordHook(ctx, "form_after_update")
|
||||
return c.hookErr("form_after_update")
|
||||
}
|
||||
func (c *hookController) FormBeforeDelete(ctx context.Context, model any) error {
|
||||
recordHook(ctx, "form_before_delete")
|
||||
return c.hookErr("form_before_delete")
|
||||
}
|
||||
func (c *hookController) FormAfterDelete(ctx context.Context, model any) error {
|
||||
recordHook(ctx, "form_after_delete")
|
||||
return c.hookErr("form_after_delete")
|
||||
}
|
||||
func (c *hookController) hookErr(name string) error {
|
||||
if c != nil && c.fail == name {
|
||||
return errHookBoom
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
var errHookBoom = errString("secret-hook-boom")
|
||||
|
||||
type errString string
|
||||
|
||||
func (e errString) Error() string { return string(e) }
|
||||
|
||||
func TestCRUDRecordRoutes(t *testing.T) {
|
||||
cap := &captureRouter{}
|
||||
(&service{}).mount(cap)
|
||||
for _, want := range []string{
|
||||
"POST " + adminAPI("/{vendor}/{plugin}/{controller}"),
|
||||
"GET " + adminAPI("/{vendor}/{plugin}/{controller}/{id}"),
|
||||
"PUT " + adminAPI("/{vendor}/{plugin}/{controller}/{id}"),
|
||||
"DELETE " + adminAPI("/{vendor}/{plugin}/{controller}/{id}"),
|
||||
} {
|
||||
mw, ok := cap.middleware[want]
|
||||
if !ok {
|
||||
t.Fatalf("missing %s in %v", want, cap.routes)
|
||||
}
|
||||
if !containsString(mw, "backend") {
|
||||
t.Fatalf("%s middleware=%v, want backend before the handler", want, mw)
|
||||
}
|
||||
}
|
||||
|
||||
_, httpSvc, _, db, hooks := hookFixture(t)
|
||||
ctx := principalCtx(hooks, superUser())
|
||||
created := crudCall(httpSvc, http.MethodPost, "", []byte(`{"name":"Ada","note":"n"}`), ctx)
|
||||
if created.Code != http.StatusCreated {
|
||||
t.Fatalf("create status=%d body=%s", created.Code, created.Body.String())
|
||||
}
|
||||
body := decodeData(t, created.Body.Bytes())
|
||||
if body["name"] != "Ada" || body["note"] != "n" || body["id"] == nil {
|
||||
t.Fatalf("create data=%#v", body)
|
||||
}
|
||||
blank := crudCall(httpSvc, http.MethodPost, "", []byte(`{"name":""}`), ctx)
|
||||
if blank.Code != http.StatusUnprocessableEntity || !strings.Contains(blank.Body.String(), `"validation_failed"`) || !strings.Contains(blank.Body.String(), "The name field is required.") {
|
||||
t.Fatalf("blank create=%d %s", blank.Code, blank.Body.String())
|
||||
}
|
||||
id := uintString(body["id"])
|
||||
shown := crudCall(httpSvc, http.MethodGet, id, nil, ctx)
|
||||
if shown.Code != http.StatusOK || decodeData(t, shown.Body.Bytes())["name"] != "Ada" {
|
||||
t.Fatalf("show=%d %s", shown.Code, shown.Body.String())
|
||||
}
|
||||
missing := crudCall(httpSvc, http.MethodGet, "999999", nil, ctx)
|
||||
if missing.Code != http.StatusNotFound || !strings.Contains(missing.Body.String(), `"not_found"`) {
|
||||
t.Fatalf("missing show=%d %s", missing.Code, missing.Body.String())
|
||||
}
|
||||
bad := crudCall(httpSvc, http.MethodGet, "nope", nil, ctx)
|
||||
if bad.Code != http.StatusUnprocessableEntity || !strings.Contains(bad.Body.String(), `"validation_failed"`) {
|
||||
t.Fatalf("bad id=%d %s", bad.Code, bad.Body.String())
|
||||
}
|
||||
updated := crudCall(httpSvc, http.MethodPut, id, []byte(`{"name":"Bea"}`), ctx)
|
||||
if updated.Code != http.StatusOK || decodeData(t, updated.Body.Bytes())["name"] != "Bea" {
|
||||
t.Fatalf("update=%d %s", updated.Code, updated.Body.String())
|
||||
}
|
||||
*hooks.log = nil
|
||||
deleted := crudCall(httpSvc, http.MethodDelete, id, nil, ctx)
|
||||
if deleted.Code != http.StatusOK || deletedCount(t, deleted.Body.Bytes()) != 1 {
|
||||
t.Fatalf("delete=%d %s", deleted.Code, deleted.Body.String())
|
||||
}
|
||||
if strings.Join(*hooks.log, ",") != "form_before_delete,before_delete,after_delete,form_after_delete" {
|
||||
t.Fatalf("delete hooks=%v", *hooks.log)
|
||||
}
|
||||
*hooks.log = nil
|
||||
again := crudCall(httpSvc, http.MethodDelete, id, nil, ctx)
|
||||
if again.Code != http.StatusOK || deletedCount(t, again.Body.Bytes()) != 0 || len(*hooks.log) != 0 {
|
||||
t.Fatalf("repeat delete=%d %s hooks=%v", again.Code, again.Body.String(), *hooks.log)
|
||||
}
|
||||
if n := countCrud(t, db); n != 0 {
|
||||
t.Fatalf("rows=%d after delete", n)
|
||||
}
|
||||
}
|
||||
|
||||
func TestCRUDPermissions(t *testing.T) {
|
||||
_, httpSvc, _, db, hooks := hookFixture(t)
|
||||
hooks.perms = []string{"acme.demo.records"}
|
||||
denied := &bouncer.Principal{ID: 4, PermissionGrants: map[string]bool{"other.code": true}}
|
||||
|
||||
unauth := crudCall(httpSvc, http.MethodPost, "", []byte(`{`), principalCtx(hooks, nil))
|
||||
if unauth.Code != http.StatusUnauthorized || !strings.Contains(unauth.Body.String(), `"unauthenticated"`) {
|
||||
t.Fatalf("unauth=%d %s", unauth.Code, unauth.Body.String())
|
||||
}
|
||||
forbidden := crudCall(httpSvc, http.MethodPost, "", []byte(`{`), principalCtx(hooks, denied))
|
||||
if forbidden.Code != http.StatusForbidden || !strings.Contains(forbidden.Body.String(), `"forbidden"`) {
|
||||
t.Fatalf("forbidden=%d %s", forbidden.Code, forbidden.Body.String())
|
||||
}
|
||||
badID := crudCall(httpSvc, http.MethodGet, "nope", nil, principalCtx(hooks, denied))
|
||||
if badID.Code != http.StatusForbidden {
|
||||
t.Fatalf("bad id before permission=%d %s", badID.Code, badID.Body.String())
|
||||
}
|
||||
if hooks.allocs.Load() != 0 || hooks.queries.Load() != 0 {
|
||||
t.Fatalf("allocs=%d queries=%d, permission did not run first", hooks.allocs.Load(), hooks.queries.Load())
|
||||
}
|
||||
if n := countCrud(t, db); n != 0 {
|
||||
t.Fatalf("denied request persisted %d rows", n)
|
||||
}
|
||||
ok := crudCall(httpSvc, http.MethodPost, "", []byte(`{"name":"Ada"}`), principalCtx(hooks, superUser()))
|
||||
if ok.Code != http.StatusCreated {
|
||||
t.Fatalf("superuser create=%d %s", ok.Code, ok.Body.String())
|
||||
}
|
||||
}
|
||||
|
||||
func TestCRUDScope(t *testing.T) {
|
||||
_, httpSvc, _, db, hooks := hookFixture(t)
|
||||
hooks.trackScope = true
|
||||
in := &crudRow{Name: "In", ScopeID: 1}
|
||||
out := &crudRow{Name: "Out", ScopeID: 2}
|
||||
if err := db.Create(in).Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := db.Create(out).Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
ctx := principalCtx(hooks, superUser())
|
||||
ctx = context.WithValue(ctx, scopeKey{}, uint(1))
|
||||
shown := crudCall(httpSvc, http.MethodGet, idString(in.ID), nil, ctx)
|
||||
if shown.Code != http.StatusOK || decodeData(t, shown.Body.Bytes())["name"] != "In" {
|
||||
t.Fatalf("in scope show=%d %s", shown.Code, shown.Body.String())
|
||||
}
|
||||
if _, ok := decodeData(t, shown.Body.Bytes())["scope_id"]; ok {
|
||||
t.Fatalf("show leaked scope_id: %s", shown.Body.String())
|
||||
}
|
||||
missing := crudCall(httpSvc, http.MethodGet, "999999", nil, ctx)
|
||||
hidden := crudCall(httpSvc, http.MethodGet, idString(out.ID), nil, ctx)
|
||||
if missing.Code != http.StatusNotFound || hidden.Code != http.StatusNotFound || missing.Body.String() != hidden.Body.String() {
|
||||
t.Fatalf("missing=%d %s hidden=%d %s", missing.Code, missing.Body.String(), hidden.Code, hidden.Body.String())
|
||||
}
|
||||
hacked := crudCall(httpSvc, http.MethodPut, idString(out.ID), []byte(`{"name":"hacked"}`), ctx)
|
||||
if hacked.Code != http.StatusNotFound || hacked.Body.String() != missing.Body.String() {
|
||||
t.Fatalf("out of scope update=%d %s", hacked.Code, hacked.Body.String())
|
||||
}
|
||||
if got := loadCrud(t, db, "Out"); got.Name != "Out" || got.ScopeID != 2 {
|
||||
t.Fatalf("out of scope row changed: %+v", got)
|
||||
}
|
||||
*hooks.log = nil
|
||||
gone := crudCall(httpSvc, http.MethodDelete, "999999", nil, ctx)
|
||||
hiddenDelete := crudCall(httpSvc, http.MethodDelete, idString(out.ID), nil, ctx)
|
||||
if gone.Code != http.StatusOK || hiddenDelete.Code != http.StatusOK || deletedCount(t, gone.Body.Bytes()) != 0 || deletedCount(t, hiddenDelete.Body.Bytes()) != 0 || gone.Body.String() != hiddenDelete.Body.String() {
|
||||
t.Fatalf("delete missing=%d %s hidden=%d %s", gone.Code, gone.Body.String(), hiddenDelete.Code, hiddenDelete.Body.String())
|
||||
}
|
||||
if len(*hooks.log) != 0 {
|
||||
t.Fatalf("delete hooks ran for absent rows: %v", *hooks.log)
|
||||
}
|
||||
if got := loadCrud(t, db, "Out"); got.ScopeID != 2 {
|
||||
t.Fatalf("out of scope delete removed %+v", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestCRUDHooks(t *testing.T) {
|
||||
svc, _, cc, _, hooks := hookFixture(t)
|
||||
ctx := principalCtx(hooks, superUser())
|
||||
rec, err := svc.Create(ctx, cc, RecordInput{Body: map[string]any{"name": "Ada", "note": "n"}})
|
||||
if err != nil {
|
||||
t.Fatalf("create err=%v", err)
|
||||
}
|
||||
if got := strings.Join(*hooks.log, ","); got != "before_validate,form_before_create,before_save,before_create,after_create,after_save,form_after_create" {
|
||||
t.Fatalf("create hooks=%s", got)
|
||||
}
|
||||
if countHooks(*hooks.log, "form_before_create") != 1 || countHooks(*hooks.log, "before_create") != 1 || countHooks(*hooks.log, "form_after_create") != 1 {
|
||||
t.Fatalf("create hook repeated: %v", *hooks.log)
|
||||
}
|
||||
*hooks.log = nil
|
||||
if _, err := svc.Update(ctx, cc, rec["id"], RecordInput{Body: map[string]any{"name": "Bea"}}); err != nil {
|
||||
t.Fatalf("update err=%v", err)
|
||||
}
|
||||
if got := strings.Join(*hooks.log, ","); got != "before_validate,form_before_update,before_save,before_update,after_update,after_save,form_after_update" {
|
||||
t.Fatalf("update hooks=%s", got)
|
||||
}
|
||||
*hooks.log = nil
|
||||
if _, err := svc.Delete(ctx, cc, rec["id"]); err != nil {
|
||||
t.Fatalf("delete err=%v", err)
|
||||
}
|
||||
if got := strings.Join(*hooks.log, ","); got != "form_before_delete,before_delete,after_delete,form_after_delete" {
|
||||
t.Fatalf("delete hooks=%s", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestCRUDRollback(t *testing.T) {
|
||||
svc, httpSvc, cc, db, hooks := hookFixture(t)
|
||||
ctx := principalCtx(hooks, superUser())
|
||||
hooks.fail = "form_after_create"
|
||||
_, err := svc.Create(ctx, cc, RecordInput{Body: map[string]any{"name": "Ada"}})
|
||||
if err == nil {
|
||||
t.Fatal("after-create hook failure was ignored")
|
||||
}
|
||||
if strings.Contains(err.Error(), "secret-hook-boom") || !strings.Contains(err.Error(), "acme.demo.records") {
|
||||
t.Fatalf("hook error=%v, want opaque controller context", err)
|
||||
}
|
||||
rec := httptest.NewRecorder()
|
||||
writeCRUDError(rec, err)
|
||||
if rec.Code != http.StatusInternalServerError || strings.Contains(rec.Body.String(), "secret-hook-boom") || strings.Contains(rec.Body.String(), "acme.demo.records") {
|
||||
t.Fatalf("http hook error=%d %s", rec.Code, rec.Body.String())
|
||||
}
|
||||
if n := countCrud(t, db); n != 0 {
|
||||
t.Fatalf("rows=%d after failed create", n)
|
||||
}
|
||||
|
||||
hooks.fail = ""
|
||||
created, err := svc.Create(ctx, cc, RecordInput{Body: map[string]any{"name": "Ada"}})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
hooks.fail = "form_before_update"
|
||||
if _, err := svc.Update(ctx, cc, created["id"], RecordInput{Body: map[string]any{"name": "hacked"}}); err == nil || strings.Contains(err.Error(), "secret-hook-boom") {
|
||||
t.Fatalf("update hook err=%v", err)
|
||||
}
|
||||
if got := loadCrud(t, db, "Ada"); got.Name != "Ada" {
|
||||
t.Fatalf("failed update committed %+v", got)
|
||||
}
|
||||
|
||||
hooks.fail = "form_after_update"
|
||||
if _, err := svc.Update(ctx, cc, created["id"], RecordInput{Body: map[string]any{"note": "later"}}); err == nil {
|
||||
t.Fatal("after-update hook failure was ignored")
|
||||
}
|
||||
if got := loadCrud(t, db, "Ada"); got.Note != "n" && got.Note != "" {
|
||||
t.Fatalf("failed after-update committed note %q", got.Note)
|
||||
}
|
||||
if got := loadCrud(t, db, "Ada"); got.Note == "later" {
|
||||
t.Fatal("after-update wrote note")
|
||||
}
|
||||
|
||||
*hooks.log = nil
|
||||
failCtx := context.WithValue(ctx, failDeleteKey{}, true)
|
||||
if _, err := svc.Delete(failCtx, cc, created["id"]); err == nil || strings.Contains(err.Error(), "secret-hook-boom") {
|
||||
t.Fatalf("delete hook err=%v", err)
|
||||
}
|
||||
if !containsString(*hooks.log, "before_delete") {
|
||||
t.Fatalf("delete lifecycle did not run: %v", *hooks.log)
|
||||
}
|
||||
if got := loadCrud(t, db, "Ada"); got.Name != "Ada" {
|
||||
t.Fatalf("failed delete removed %+v", got)
|
||||
}
|
||||
_ = httpSvc
|
||||
}
|
||||
|
||||
type captureRouter struct {
|
||||
prefix string
|
||||
mw []string
|
||||
routes []string
|
||||
middleware map[string][]string
|
||||
}
|
||||
|
||||
func (c *captureRouter) Group(prefix string, middleware []string, fn func(pact.Router)) {
|
||||
c.GroupRaw(prefix, middleware, fn)
|
||||
}
|
||||
|
||||
func (c *captureRouter) GroupRaw(prefix string, middleware []string, fn func(pact.Router)) {
|
||||
if c.middleware == nil {
|
||||
c.middleware = map[string][]string{}
|
||||
}
|
||||
child := &captureRouter{
|
||||
prefix: c.prefix + prefix,
|
||||
mw: append(append([]string{}, c.mw...), middleware...),
|
||||
middleware: c.middleware,
|
||||
}
|
||||
fn(child)
|
||||
c.routes = append(c.routes, child.routes...)
|
||||
}
|
||||
|
||||
func (c *captureRouter) Get(path string, _ http.HandlerFunc, _ ...string) { c.add("GET", path) }
|
||||
func (c *captureRouter) Post(path string, _ http.HandlerFunc, _ ...string) {
|
||||
c.add("POST", path)
|
||||
}
|
||||
func (c *captureRouter) Put(path string, _ http.HandlerFunc, _ ...string) { c.add("PUT", path) }
|
||||
func (c *captureRouter) Patch(path string, _ http.HandlerFunc, _ ...string) {
|
||||
c.add("PATCH", path)
|
||||
}
|
||||
func (c *captureRouter) Delete(path string, _ http.HandlerFunc, _ ...string) {
|
||||
c.add("DELETE", path)
|
||||
}
|
||||
func (c *captureRouter) Where(string, string) {}
|
||||
func (c *captureRouter) WhereIn(string, ...string) {}
|
||||
|
||||
func (c *captureRouter) add(method, path string) {
|
||||
full := method + " " + c.prefix + path
|
||||
c.routes = append(c.routes, full)
|
||||
if c.middleware == nil {
|
||||
c.middleware = map[string][]string{}
|
||||
}
|
||||
c.middleware[full] = append([]string{}, c.mw...)
|
||||
}
|
||||
|
||||
func hookFixture(t *testing.T) (CRUDService, *service, *CompiledController, *gorm.DB, *hookController) {
|
||||
t.Helper()
|
||||
crudSvc, cc, db := crudFixture(t)
|
||||
hooks := &hookController{log: &[]string{}}
|
||||
cc.Controller = hooks
|
||||
app := backpack.New(nil)
|
||||
if err := app.Publish(db); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
httpSvc := &service{app: app, reg: &Registry{byID: map[string]*CompiledController{
|
||||
cc.Controller.ID(): cc,
|
||||
}}}
|
||||
return crudSvc, httpSvc, cc, db, hooks
|
||||
}
|
||||
|
||||
func principalCtx(hooks *hookController, principal *bouncer.Principal) context.Context {
|
||||
ctx := context.WithValue(context.Background(), hookSinkKey{}, hooks.log)
|
||||
if principal != nil {
|
||||
principal.Backend = true
|
||||
ctx = bouncer.WithUser(ctx, principal)
|
||||
}
|
||||
return ctx
|
||||
}
|
||||
|
||||
func superUser() *bouncer.Principal {
|
||||
return &bouncer.Principal{ID: 1, Backend: true, IsSuperuser: true}
|
||||
}
|
||||
|
||||
func crudCall(svc *service, method, id string, body []byte, ctx context.Context) *httptest.ResponseRecorder {
|
||||
req := httptest.NewRequest(method, "/", bytes.NewReader(body))
|
||||
req.SetPathValue("vendor", "acme")
|
||||
req.SetPathValue("plugin", "demo")
|
||||
req.SetPathValue("controller", "records")
|
||||
if id != "" {
|
||||
req.SetPathValue("id", id)
|
||||
}
|
||||
if ctx != nil {
|
||||
req = req.WithContext(ctx)
|
||||
}
|
||||
rec := httptest.NewRecorder()
|
||||
switch method {
|
||||
case http.MethodPost:
|
||||
svc.create(rec, req)
|
||||
case http.MethodGet:
|
||||
svc.show(rec, req)
|
||||
case http.MethodPut:
|
||||
svc.update(rec, req)
|
||||
case http.MethodDelete:
|
||||
svc.deleteRecord(rec, req)
|
||||
default:
|
||||
rec.Code = http.StatusNotImplemented
|
||||
}
|
||||
return rec
|
||||
}
|
||||
|
||||
func decodeData(t *testing.T, raw []byte) map[string]any {
|
||||
t.Helper()
|
||||
var body struct {
|
||||
Data map[string]any `json:"data"`
|
||||
Meta map[string]any `json:"meta"`
|
||||
}
|
||||
if err := jsonUnmarshal(raw, &body); err != nil {
|
||||
t.Fatalf("json: %v body=%s", err, raw)
|
||||
}
|
||||
if body.Meta == nil {
|
||||
t.Fatalf("meta is null: %s", raw)
|
||||
}
|
||||
return body.Data
|
||||
}
|
||||
|
||||
func deletedCount(t *testing.T, raw []byte) float64 {
|
||||
t.Helper()
|
||||
var body struct {
|
||||
Data struct {
|
||||
Deleted float64 `json:"deleted"`
|
||||
} `json:"data"`
|
||||
}
|
||||
if err := jsonUnmarshal(raw, &body); err != nil {
|
||||
t.Fatalf("json: %v body=%s", err, raw)
|
||||
}
|
||||
return body.Data.Deleted
|
||||
}
|
||||
|
||||
func jsonUnmarshal(raw []byte, dest any) error {
|
||||
return json.Unmarshal(raw, dest)
|
||||
}
|
||||
|
||||
func uintString(id any) string {
|
||||
switch n := id.(type) {
|
||||
case uint:
|
||||
return idString(n)
|
||||
case float64:
|
||||
return idString(uint(n))
|
||||
case int:
|
||||
return idString(uint(n))
|
||||
default:
|
||||
return ""
|
||||
}
|
||||
}
|
||||
|
||||
func idString(id uint) string {
|
||||
return strconv.FormatUint(uint64(id), 10)
|
||||
}
|
||||
|
||||
func countHooks(log []string, name string) int {
|
||||
n := 0
|
||||
for _, item := range log {
|
||||
if item == name {
|
||||
n++
|
||||
}
|
||||
}
|
||||
return n
|
||||
}
|
||||
|
||||
func containsString(items []string, want string) bool {
|
||||
for _, item := range items {
|
||||
if item == want {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
471
modules/cabana/crud_test.go
Normal file
471
modules/cabana/crud_test.go
Normal file
@@ -0,0 +1,471 @@
|
||||
package cabana
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"strings"
|
||||
"sync"
|
||||
"testing"
|
||||
"testing/fstest"
|
||||
"time"
|
||||
|
||||
"gorm.io/gorm"
|
||||
)
|
||||
|
||||
const crudFormConfig = `name: records
|
||||
form: ~/plugins/acme/demo/models/record/fields.yaml
|
||||
modelClass: Record
|
||||
`
|
||||
|
||||
const crudFields = `fields:
|
||||
name:
|
||||
label: Name
|
||||
type: text
|
||||
required: true
|
||||
note:
|
||||
label: Note
|
||||
type: text
|
||||
id:
|
||||
label: ID
|
||||
type: number
|
||||
created_at:
|
||||
label: Created
|
||||
type: text
|
||||
scope_id:
|
||||
label: Scope
|
||||
type: number
|
||||
is_system:
|
||||
label: System
|
||||
type: switch
|
||||
`
|
||||
|
||||
const crudListConfig = `modelClass: Record
|
||||
list: ~/plugins/acme/demo/models/record/columns.yaml
|
||||
recordsPerPage: 20
|
||||
showSearch: true
|
||||
`
|
||||
|
||||
const crudColumns = `columns:
|
||||
name:
|
||||
label: Name
|
||||
searchable: true
|
||||
`
|
||||
|
||||
type clearNameKey struct{}
|
||||
|
||||
var crudRuleSet = map[string]string{"name": "required"}
|
||||
|
||||
type crudRow struct {
|
||||
ID uint `gorm:"column:id;primaryKey"`
|
||||
Name string `gorm:"column:name"`
|
||||
Note string `gorm:"column:note"`
|
||||
ScopeID uint `gorm:"column:scope_id"`
|
||||
IsSystem bool `gorm:"column:is_system"`
|
||||
CreatedAt time.Time `gorm:"column:created_at"`
|
||||
UpdatedAt time.Time `gorm:"column:updated_at"`
|
||||
}
|
||||
|
||||
func (crudRow) TableName() string { return "cabana_crud_rows" }
|
||||
|
||||
func (crudRow) Fillable() []string { return []string{"name", "note"} }
|
||||
|
||||
func (crudRow) Rules() map[string]string { return crudRuleSet }
|
||||
|
||||
func (r *crudRow) BeforeValidate(tx *gorm.DB) error {
|
||||
ctx := txContext(tx)
|
||||
recordHook(ctx, "before_validate")
|
||||
if clear, _ := ctx.Value(clearNameKey{}).(bool); clear {
|
||||
if r.Name == "" {
|
||||
return errors.New("fill did not run before validate")
|
||||
}
|
||||
r.Name = ""
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (r *crudRow) BeforeSave(tx *gorm.DB) error {
|
||||
recordHook(txContext(tx), "before_save")
|
||||
return nil
|
||||
}
|
||||
|
||||
func (r *crudRow) BeforeCreate(tx *gorm.DB) error {
|
||||
recordHook(txContext(tx), "before_create")
|
||||
return nil
|
||||
}
|
||||
|
||||
func (r *crudRow) AfterCreate(tx *gorm.DB) error {
|
||||
recordHook(txContext(tx), "after_create")
|
||||
return nil
|
||||
}
|
||||
|
||||
func (r *crudRow) AfterSave(tx *gorm.DB) error {
|
||||
recordHook(txContext(tx), "after_save")
|
||||
return nil
|
||||
}
|
||||
|
||||
func (r *crudRow) BeforeUpdate(tx *gorm.DB) error {
|
||||
recordHook(txContext(tx), "before_update")
|
||||
return nil
|
||||
}
|
||||
|
||||
func (r *crudRow) AfterUpdate(tx *gorm.DB) error {
|
||||
recordHook(txContext(tx), "after_update")
|
||||
return nil
|
||||
}
|
||||
|
||||
func (r *crudRow) BeforeDelete(tx *gorm.DB) error {
|
||||
ctx := txContext(tx)
|
||||
if _, ok := ctx.Value(bulkSlowKey{}).(bool); ok {
|
||||
time.Sleep(300 * time.Millisecond)
|
||||
}
|
||||
recordHook(ctx, "before_delete")
|
||||
appendDeletedID(ctx, r.ID)
|
||||
if fail, _ := ctx.Value(failDeleteKey{}).(bool); fail {
|
||||
return errors.New("secret-hook-boom")
|
||||
}
|
||||
if ids, ok := ctx.Value(failIDsKey{}).(map[uint]bool); ok && ids[r.ID] {
|
||||
return errors.New("secret-hook-boom")
|
||||
}
|
||||
if id, ok := ctx.Value(cancelOnKey{}).(uint); ok && r.ID == id {
|
||||
if cancel, ok := ctx.Value(cancelKey{}).(context.CancelFunc); ok {
|
||||
cancel()
|
||||
}
|
||||
return context.Canceled
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (r *crudRow) AfterDelete(tx *gorm.DB) error {
|
||||
recordHook(txContext(tx), "after_delete")
|
||||
return nil
|
||||
}
|
||||
|
||||
type hookSinkKey struct{}
|
||||
type failDeleteKey struct{}
|
||||
type failIDsKey struct{}
|
||||
type idSinkKey struct{}
|
||||
type bulkSlowKey struct{}
|
||||
type cancelOnKey struct{}
|
||||
type cancelKey struct{}
|
||||
|
||||
var hookMu sync.Mutex
|
||||
|
||||
func txContext(tx *gorm.DB) context.Context {
|
||||
if tx != nil && tx.Statement != nil && tx.Statement.Context != nil {
|
||||
return tx.Statement.Context
|
||||
}
|
||||
return context.Background()
|
||||
}
|
||||
|
||||
func recordHook(ctx context.Context, name string) {
|
||||
if ctx == nil {
|
||||
return
|
||||
}
|
||||
hookMu.Lock()
|
||||
defer hookMu.Unlock()
|
||||
sink, _ := ctx.Value(hookSinkKey{}).(*[]string)
|
||||
if sink == nil {
|
||||
return
|
||||
}
|
||||
*sink = append(*sink, name)
|
||||
}
|
||||
|
||||
func appendDeletedID(ctx context.Context, id uint) {
|
||||
if ctx == nil {
|
||||
return
|
||||
}
|
||||
hookMu.Lock()
|
||||
defer hookMu.Unlock()
|
||||
sink, _ := ctx.Value(idSinkKey{}).(*[]uint)
|
||||
if sink == nil {
|
||||
return
|
||||
}
|
||||
*sink = append(*sink, id)
|
||||
}
|
||||
|
||||
type crudNoRules struct {
|
||||
ID uint `gorm:"column:id;primaryKey"`
|
||||
Name string `gorm:"column:name"`
|
||||
}
|
||||
|
||||
func (crudNoRules) TableName() string { return "cabana_crud_rows" }
|
||||
func (crudNoRules) Fillable() []string { return []string{"name", "note"} }
|
||||
|
||||
type crudNoFill struct {
|
||||
ID uint `gorm:"column:id;primaryKey"`
|
||||
Name string `gorm:"column:name"`
|
||||
}
|
||||
|
||||
func (crudNoFill) TableName() string { return "cabana_crud_rows" }
|
||||
func (crudNoFill) Rules() map[string]string { return map[string]string{"name": "required"} }
|
||||
|
||||
type crudController struct{ rec func() any }
|
||||
|
||||
func (c crudController) ID() string { return "acme.demo.records" }
|
||||
func (c crudController) ModelName() string { return "Record" }
|
||||
func (c crudController) ConfigDir() string { return "controllers/records" }
|
||||
func (c crudController) NewRecord() any {
|
||||
if c.rec != nil {
|
||||
return c.rec()
|
||||
}
|
||||
return &crudRow{}
|
||||
}
|
||||
|
||||
func TestCRUDFillValidate(t *testing.T) {
|
||||
svc, cc, db := crudFixture(t)
|
||||
ctx := context.Background()
|
||||
|
||||
t.Run("empty name is 422 and does not persist", func(t *testing.T) {
|
||||
_, err := svc.Create(ctx, cc, RecordInput{Body: map[string]any{"name": ""}})
|
||||
assertValidation(t, err, "name", "The name field is required.")
|
||||
if n := countCrud(t, db); n != 0 {
|
||||
t.Fatalf("rows=%d, validation must not persist", n)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("yaml required merges when model rules are empty", func(t *testing.T) {
|
||||
prev := crudRuleSet
|
||||
crudRuleSet = map[string]string{}
|
||||
t.Cleanup(func() { crudRuleSet = prev })
|
||||
_, err := svc.Create(ctx, cc, RecordInput{Body: map[string]any{"note": "only"}})
|
||||
assertValidation(t, err, "name", "The name field is required.")
|
||||
if n := countCrud(t, db); n != 0 {
|
||||
t.Fatalf("rows=%d, yaml required was skipped", n)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("validate runs after fill", func(t *testing.T) {
|
||||
clearCtx := context.WithValue(ctx, clearNameKey{}, true)
|
||||
_, err := svc.Create(clearCtx, cc, RecordInput{Body: map[string]any{"name": "Ada"}})
|
||||
assertValidation(t, err, "name", "The name field is required.")
|
||||
if n := countCrud(t, db); n != 0 {
|
||||
t.Fatalf("rows=%d, validate ran before BeforeValidate mutated the model", n)
|
||||
}
|
||||
})
|
||||
|
||||
rec, err := svc.Create(ctx, cc, RecordInput{Body: map[string]any{"name": "Ada", "note": "kept"}})
|
||||
if err != nil || rec["name"] != "Ada" || rec["note"] != "kept" {
|
||||
t.Fatalf("create=%#v err=%v, want filled name and note", rec, err)
|
||||
}
|
||||
stored := loadCrud(t, db, "Ada")
|
||||
if stored.Note != "kept" {
|
||||
t.Fatalf("stored note=%q, Fill did not persist the writable field", stored.Note)
|
||||
}
|
||||
|
||||
updated, err := svc.Update(ctx, cc, stored.ID, RecordInput{Body: map[string]any{"name": "Bea"}})
|
||||
if err != nil || updated["name"] != "Bea" {
|
||||
t.Fatalf("update=%#v err=%v", updated, err)
|
||||
}
|
||||
if _, err := svc.Update(ctx, cc, stored.ID, RecordInput{Body: map[string]any{"name": ""}}); err == nil {
|
||||
t.Fatal("blank update name succeeded")
|
||||
} else {
|
||||
assertValidation(t, err, "name", "The name field is required.")
|
||||
}
|
||||
if got := loadCrud(t, db, "Bea"); got.Note != "kept" || got.Name != "Bea" {
|
||||
t.Fatalf("row after rejected update = %+v", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestCRUDWritableProjection(t *testing.T) {
|
||||
cc := crudCompiled(t)
|
||||
gotKeys := map[string]bool{}
|
||||
for _, field := range cc.Writable {
|
||||
gotKeys[field.Name] = true
|
||||
if field.FillKey == "" || field.FillKey != field.Name {
|
||||
t.Fatalf("binding %+v is not an explicit model fill key", field)
|
||||
}
|
||||
}
|
||||
for _, banned := range []string{"id", "created_at", "scope_id", "is_system"} {
|
||||
if gotKeys[banned] {
|
||||
t.Fatalf("protected field %s was bound writable: %+v", banned, cc.Writable)
|
||||
}
|
||||
}
|
||||
if !gotKeys["name"] || !gotKeys["note"] {
|
||||
t.Fatalf("writable = %+v, want name and note", cc.Writable)
|
||||
}
|
||||
|
||||
body := crudBody(t, `{"name":"Ada","Name":"Nope","note":"n","id":9,"ID":8,"created_at":"1999-01-01T00:00:00Z","CreatedAt":"1999-01-01T00:00:00Z","scope_id":4,"is_system":true,"IsSystem":true,"unknown":"x","meta":{"name":"hidden","id":1,"is_system":true}}`)
|
||||
got := ProjectWritableFields(cc, body)
|
||||
if len(got) != 2 || got["name"] != "Ada" || got["note"] != "n" {
|
||||
t.Fatalf("projected = %#v, want only name and note", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestCRUDRejectsProtectedFields(t *testing.T) {
|
||||
svc, cc, db := crudFixture(t)
|
||||
body := crudBody(t, `{"name":"Ada","note":"kept","id":424242,"ID":7,"Id":7,"created_at":"1999-01-01T00:00:00Z","CreatedAt":"1999-01-01T00:00:00Z","createdAt":"1999-01-01T00:00:00Z","scope_id":9,"ScopeID":9,"is_system":true,"IsSystem":true,"isSystem":true,"meta":{"id":1,"scope_id":3,"is_system":true,"name":"hidden"},"nested":{"created_at":"1999-01-01T00:00:00Z"}}`)
|
||||
rec, err := svc.Create(context.Background(), cc, RecordInput{Body: body})
|
||||
if err != nil {
|
||||
t.Fatalf("create err=%v", err)
|
||||
}
|
||||
if rec["name"] != "Ada" {
|
||||
t.Fatalf("create=%#v", rec)
|
||||
}
|
||||
stored := loadCrud(t, db, "Ada")
|
||||
if stored.ID == 0 || stored.ID == 424242 || stored.ID == 7 || stored.ScopeID != 0 || stored.IsSystem || stored.CreatedAt.Year() == 1999 || stored.Note != "kept" {
|
||||
t.Fatalf("protected fields mutated the row: %+v", stored)
|
||||
}
|
||||
if _, err := svc.Update(context.Background(), cc, stored.ID, RecordInput{Body: crudBody(t, `{"note":"still","id":424242,"scope_id":9,"is_system":true,"created_at":"1999-01-01T00:00:00Z","meta":{"is_system":true}}`)}); err != nil {
|
||||
t.Fatalf("update err=%v", err)
|
||||
}
|
||||
stored = loadCrud(t, db, "Ada")
|
||||
if stored.ID == 424242 || stored.ScopeID != 0 || stored.IsSystem || stored.CreatedAt.Year() == 1999 || stored.Note != "still" || stored.Name != "Ada" {
|
||||
t.Fatalf("update mutated protected fields: %+v", stored)
|
||||
}
|
||||
}
|
||||
|
||||
func TestCRUDCapabilityFailure(t *testing.T) {
|
||||
svc, cc, db := crudFixture(t)
|
||||
ctx := context.Background()
|
||||
|
||||
t.Run("missing rules", func(t *testing.T) {
|
||||
bare := *cc
|
||||
bare.Controller = crudController{rec: func() any { return &crudNoRules{} }}
|
||||
_, err := svc.Create(ctx, &bare, RecordInput{Body: map[string]any{"name": "Ada"}})
|
||||
assertCapability(t, err, bare.Controller.ID())
|
||||
if n := countCrud(t, db); n != 0 {
|
||||
t.Fatalf("rows=%d, missing Rules persisted", n)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("missing fillable", func(t *testing.T) {
|
||||
bare := *cc
|
||||
bare.Controller = crudController{rec: func() any { return &crudNoFill{} }}
|
||||
_, err := svc.Create(ctx, &bare, RecordInput{Body: map[string]any{"name": "Ada"}})
|
||||
assertCapability(t, err, bare.Controller.ID())
|
||||
if n := countCrud(t, db); n != 0 {
|
||||
t.Fatalf("rows=%d, missing Fillable persisted", n)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("provider error", func(t *testing.T) {
|
||||
prev := crudRuleSet
|
||||
crudRuleSet = map[string]string{"name": "nope"}
|
||||
t.Cleanup(func() { crudRuleSet = prev })
|
||||
_, err := svc.Create(ctx, cc, RecordInput{Body: map[string]any{"name": "Ada"}})
|
||||
assertCapability(t, err, cc.Controller.ID())
|
||||
rec := httptest.NewRecorder()
|
||||
writeCRUDError(rec, err)
|
||||
if rec.Code != http.StatusInternalServerError {
|
||||
t.Fatalf("status=%d body=%s", rec.Code, rec.Body.String())
|
||||
}
|
||||
if strings.Contains(rec.Body.String(), "nope") || strings.Contains(rec.Body.String(), "unrecognized") {
|
||||
t.Fatalf("response leaked provider error: %s", rec.Body.String())
|
||||
}
|
||||
if n := countCrud(t, db); n != 0 {
|
||||
t.Fatalf("rows=%d, provider error persisted", n)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func crudFixture(t *testing.T) (CRUDService, *CompiledController, *gorm.DB) {
|
||||
t.Helper()
|
||||
crudRuleSet = map[string]string{"name": "required"}
|
||||
_, db := newListService(t)
|
||||
if err := db.Migrator().DropTable(&crudRow{}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := db.AutoMigrate(&crudRow{}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return CRUDService{DB: db}, crudCompiled(t), db
|
||||
}
|
||||
|
||||
func crudCompiled(t *testing.T) *CompiledController {
|
||||
t.Helper()
|
||||
reg, err := compileRegistry([]controllerRef{{
|
||||
plugin: formPlugin{fsys: crudFS()},
|
||||
ctl: crudController{},
|
||||
}})
|
||||
if err != nil {
|
||||
t.Fatalf("registry: %v", err)
|
||||
}
|
||||
cc, ok := reg.Get("acme.demo.records")
|
||||
if !ok || cc.Form == nil {
|
||||
t.Fatalf("compiled controller missing form: %+v", cc)
|
||||
}
|
||||
return cc
|
||||
}
|
||||
|
||||
func crudFS() fstest.MapFS {
|
||||
return fstest.MapFS{
|
||||
"controllers/records/config_list.yaml": &fstest.MapFile{Data: []byte(crudListConfig)},
|
||||
"controllers/records/config_form.yaml": &fstest.MapFile{Data: []byte(crudFormConfig)},
|
||||
"models/record/columns.yaml": &fstest.MapFile{Data: []byte(crudColumns)},
|
||||
"models/record/fields.yaml": &fstest.MapFile{Data: []byte(crudFields)},
|
||||
}
|
||||
}
|
||||
|
||||
func assertValidation(t *testing.T, err error, field, message string) {
|
||||
t.Helper()
|
||||
var ve *ValidationError
|
||||
if !errors.As(err, &ve) {
|
||||
t.Fatalf("err=%v, want validation_failed", err)
|
||||
}
|
||||
got, _ := ve.Details[field].([]string)
|
||||
if len(got) != 1 || got[0] != message {
|
||||
t.Fatalf("details[%s]=%#v, want %q", field, ve.Details[field], message)
|
||||
}
|
||||
rec := httptest.NewRecorder()
|
||||
writeCRUDError(rec, err)
|
||||
if rec.Code != http.StatusUnprocessableEntity {
|
||||
t.Fatalf("status=%d body=%s, want 422", rec.Code, rec.Body.String())
|
||||
}
|
||||
var body struct {
|
||||
Error struct {
|
||||
Code string `json:"code"`
|
||||
Message string `json:"message"`
|
||||
Details map[string]any `json:"details"`
|
||||
} `json:"error"`
|
||||
}
|
||||
if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if body.Error.Code != "validation_failed" || body.Error.Message != "Validation failed" {
|
||||
t.Fatalf("envelope=%s", rec.Body.String())
|
||||
}
|
||||
msgs, _ := body.Error.Details[field].([]any)
|
||||
if len(msgs) != 1 || msgs[0] != message {
|
||||
t.Fatalf("http details=%#v", body.Error.Details)
|
||||
}
|
||||
}
|
||||
|
||||
func assertCapability(t *testing.T, err error, controllerID string) {
|
||||
t.Helper()
|
||||
var ce *CapabilityError
|
||||
if !errors.As(err, &ce) || ce.ControllerID != controllerID || !strings.Contains(err.Error(), controllerID) {
|
||||
t.Fatalf("err=%v, want capability failure for %s", err, controllerID)
|
||||
}
|
||||
}
|
||||
|
||||
func countCrud(t *testing.T, db *gorm.DB) int64 {
|
||||
t.Helper()
|
||||
var n int64
|
||||
if err := db.Model(&crudRow{}).Count(&n).Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return n
|
||||
}
|
||||
|
||||
func loadCrud(t *testing.T, db *gorm.DB, name string) crudRow {
|
||||
t.Helper()
|
||||
var row crudRow
|
||||
if err := db.Where("name = ?", name).Take(&row).Error; err != nil {
|
||||
t.Fatalf("load %s: %v", name, err)
|
||||
}
|
||||
return row
|
||||
}
|
||||
|
||||
func crudBody(t *testing.T, raw string) map[string]any {
|
||||
t.Helper()
|
||||
dec := json.NewDecoder(strings.NewReader(raw))
|
||||
dec.UseNumber()
|
||||
var body map[string]any
|
||||
if err := dec.Decode(&body); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return body
|
||||
}
|
||||
45
modules/cabana/csrf.go
Normal file
45
modules/cabana/csrf.go
Normal file
@@ -0,0 +1,45 @@
|
||||
package cabana
|
||||
|
||||
import (
|
||||
"net/http"
|
||||
"strings"
|
||||
)
|
||||
|
||||
const (
|
||||
// requestedWithHeader is the custom header the admin SPA sends on every
|
||||
// request. A cross-site form or navigation cannot set it, and a
|
||||
// cross-origin fetch that sets it needs a CORS preflight the admin API
|
||||
// never answers (D-19).
|
||||
requestedWithHeader = "X-Requested-With"
|
||||
requestedWithAjax = "XMLHttpRequest"
|
||||
)
|
||||
|
||||
// requireAjax refuses a state-changing admin request that is not
|
||||
// Bearer-authenticated and does not carry X-Requested-With: XMLHttpRequest.
|
||||
// It runs before the wrapped handler, so a refused request is never decoded,
|
||||
// never looks up a controller and never reaches the database. The response
|
||||
// uses the fixed D-10 code forbidden.
|
||||
func requireAjax(next http.HandlerFunc) http.HandlerFunc {
|
||||
return func(w http.ResponseWriter, r *http.Request) {
|
||||
if !csrfSafe(r) {
|
||||
WriteError(w, http.StatusForbidden, "forbidden", msgForbidden)
|
||||
return
|
||||
}
|
||||
next(w, r)
|
||||
}
|
||||
}
|
||||
|
||||
func csrfSafe(r *http.Request) bool {
|
||||
switch r.Method {
|
||||
case http.MethodGet, http.MethodHead, http.MethodOptions:
|
||||
return true
|
||||
}
|
||||
if bearerToken(r) != "" {
|
||||
return true
|
||||
}
|
||||
return isAjax(r)
|
||||
}
|
||||
|
||||
func isAjax(r *http.Request) bool {
|
||||
return strings.TrimSpace(r.Header.Get(requestedWithHeader)) == requestedWithAjax
|
||||
}
|
||||
13
modules/cabana/export_test.go
Normal file
13
modules/cabana/export_test.go
Normal file
@@ -0,0 +1,13 @@
|
||||
package cabana
|
||||
|
||||
// AdminAPIRoutes exposes the admin API route inventory (method plus
|
||||
// prefix-relative path) to the external conformance test.
|
||||
func AdminAPIRoutes() []string {
|
||||
out := make([]string, 0, len(phase09Routes))
|
||||
for _, route := range phase09Routes {
|
||||
if !route.spa {
|
||||
out = append(out, route.key)
|
||||
}
|
||||
}
|
||||
return out
|
||||
}
|
||||
168
modules/cabana/filter_options_test.go
Normal file
168
modules/cabana/filter_options_test.go
Normal file
@@ -0,0 +1,168 @@
|
||||
package cabana
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/json"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"strings"
|
||||
"testing"
|
||||
"testing/fstest"
|
||||
|
||||
"git.golem15.com/golem15/summercms/modules/backpack"
|
||||
"git.golem15.com/golem15/summercms/modules/bouncer"
|
||||
"git.golem15.com/golem15/summercms/modules/phrasebook"
|
||||
"git.golem15.com/golem15/summercms/modules/towel"
|
||||
"gorm.io/gorm"
|
||||
)
|
||||
|
||||
const filterOptionsScopes = `scopes:
|
||||
grouped:
|
||||
label: Group
|
||||
modelClass: Group
|
||||
nameFrom: name
|
||||
scope: filterByGroup
|
||||
activated:
|
||||
label: Active
|
||||
type: switch
|
||||
column: active
|
||||
`
|
||||
|
||||
// panicOptionsRow proves the provider never runs for a denied principal.
|
||||
type panicOptionsRow struct {
|
||||
ID uint `gorm:"column:id;primaryKey"`
|
||||
Name string `gorm:"column:name"`
|
||||
Active bool `gorm:"column:active"`
|
||||
}
|
||||
|
||||
func (panicOptionsRow) FilterScopes() []string { return []string{"filterByGroup"} }
|
||||
func (panicOptionsRow) FilterScope(_ string, db *gorm.DB, _ any) *gorm.DB {
|
||||
return db
|
||||
}
|
||||
func (panicOptionsRow) FilterOptions(string) []Option {
|
||||
panic("FilterOptions ran for a denied request")
|
||||
}
|
||||
|
||||
// scopeOnlyRow has a filter scope but no choices source.
|
||||
type scopeOnlyRow struct {
|
||||
ID uint `gorm:"column:id;primaryKey"`
|
||||
Name string `gorm:"column:name"`
|
||||
Active bool `gorm:"column:active"`
|
||||
}
|
||||
|
||||
func (scopeOnlyRow) FilterScopes() []string { return []string{"filterByGroup"} }
|
||||
func (scopeOnlyRow) FilterScope(_ string, db *gorm.DB, _ any) *gorm.DB {
|
||||
return db
|
||||
}
|
||||
|
||||
func filterOptionsService(t *testing.T, rec any, perms []string, tr *phrasebook.Translator) *service {
|
||||
t.Helper()
|
||||
ctl := filterController{schemaController: schemaController{model: "Widget"}, rec: rec}
|
||||
list, err := CompileList("acme.demo", ctl, filterFS(filterListConfig, filterColumns, filterOptionsScopes))
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
app := backpack.New(nil)
|
||||
if tr != nil {
|
||||
if err := app.Publish(tr); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
permCtl := permissionedFilterController{filterController: ctl, perms: perms}
|
||||
return &service{app: app, reg: &Registry{byID: map[string]*CompiledController{
|
||||
"acme.demo.widgets": {Controller: permCtl, List: list},
|
||||
}}}
|
||||
}
|
||||
|
||||
type permissionedFilterController struct {
|
||||
filterController
|
||||
perms []string
|
||||
}
|
||||
|
||||
func (c permissionedFilterController) RequiredPermissions() []string { return c.perms }
|
||||
|
||||
func filterOptionsCall(svc *service, scope, locale string, principal *bouncer.Principal) *httptest.ResponseRecorder {
|
||||
req := httptest.NewRequest(http.MethodGet, adminAPI("/acme/demo/widgets/filters/"+scope+"/options"), nil)
|
||||
req.SetPathValue("vendor", "acme")
|
||||
req.SetPathValue("plugin", "demo")
|
||||
req.SetPathValue("controller", "widgets")
|
||||
req.SetPathValue("id", "filters")
|
||||
req.SetPathValue("segment", scope)
|
||||
req.SetPathValue("name", "options")
|
||||
ctx := req.Context()
|
||||
if locale != "" {
|
||||
ctx = towel.WithLocale(ctx, locale)
|
||||
}
|
||||
if principal != nil {
|
||||
principal.Backend = true
|
||||
ctx = bouncer.WithUser(ctx, principal)
|
||||
}
|
||||
rec := httptest.NewRecorder()
|
||||
svc.nestedGet(rec, req.WithContext(ctx))
|
||||
return rec
|
||||
}
|
||||
|
||||
func filterOptionsLang() fstest.MapFS {
|
||||
return fstest.MapFS{
|
||||
"lang/pl/lang.yaml": {Data: []byte("group_four: Grupa cztery\n")},
|
||||
"lang/en/lang.yaml": {Data: []byte("group_four: Group four\n")},
|
||||
}
|
||||
}
|
||||
|
||||
func TestPhase10FilterOptions(t *testing.T) {
|
||||
app := backpack.New(nil)
|
||||
demo := langPlugin{id: "demo", lang: filterOptionsLang()}
|
||||
if err := phrasebook.Activate(app, []langPlugin{demo}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
tr, _ := app.Lookup[*phrasebook.Translator]()
|
||||
svc := filterOptionsService(t, &filterRow{}, []string{"acme.demo.access"}, tr)
|
||||
granted := &bouncer.Principal{ID: 1, PermissionGrants: map[string]bool{"acme.demo.access": true}}
|
||||
|
||||
rec := filterOptionsCall(svc, "grouped", "pl", granted)
|
||||
if rec.Code != http.StatusOK {
|
||||
t.Fatalf("status=%d body=%s", rec.Code, rec.Body.String())
|
||||
}
|
||||
var body struct {
|
||||
Data []FilterOption `json:"data"`
|
||||
Meta struct {
|
||||
Locale string `json:"locale"`
|
||||
} `json:"meta"`
|
||||
}
|
||||
dec := json.NewDecoder(bytes.NewReader(rec.Body.Bytes()))
|
||||
dec.DisallowUnknownFields()
|
||||
if err := dec.Decode(&body); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if body.Meta.Locale != "pl" || len(body.Data) != 2 || body.Data[0] != (FilterOption{Value: "4", Label: "Grupa cztery"}) || body.Data[1] != (FilterOption{Value: "9", Label: "Group nine"}) {
|
||||
t.Fatalf("options=%+v locale=%q", body.Data, body.Meta.Locale)
|
||||
}
|
||||
if en := filterOptionsCall(svc, "grouped", "en", granted); !strings.Contains(en.Body.String(), `"label":"Group four"`) {
|
||||
t.Fatalf("en labels=%s", en.Body.String())
|
||||
}
|
||||
|
||||
for _, scope := range []string{"activated", "missing", "filterByGroup", "Grouped"} {
|
||||
rec := filterOptionsCall(svc, scope, "", granted)
|
||||
if rec.Code != http.StatusNotFound {
|
||||
t.Fatalf("%s status=%d body=%s", scope, rec.Code, rec.Body.String())
|
||||
}
|
||||
assertErrorCode(t, rec.Body.Bytes(), "not_found")
|
||||
}
|
||||
|
||||
locked := filterOptionsService(t, &panicOptionsRow{}, []string{"acme.demo.access"}, tr)
|
||||
denied := filterOptionsCall(locked, "grouped", "", &bouncer.Principal{ID: 2})
|
||||
if denied.Code != http.StatusForbidden {
|
||||
t.Fatalf("denied status=%d body=%s", denied.Code, denied.Body.String())
|
||||
}
|
||||
assertErrorCode(t, denied.Body.Bytes(), "forbidden")
|
||||
anonymous := filterOptionsCall(locked, "grouped", "", nil)
|
||||
if anonymous.Code != http.StatusUnauthorized {
|
||||
t.Fatalf("anonymous status=%d body=%s", anonymous.Code, anonymous.Body.String())
|
||||
}
|
||||
|
||||
ctl := filterController{schemaController: schemaController{model: "Widget"}, rec: &scopeOnlyRow{}}
|
||||
_, err := CompileList("acme.demo", ctl, filterFS(filterListConfig, filterColumns, filterOptionsScopes))
|
||||
if err == nil || !strings.Contains(err.Error(), "grouped") || !strings.Contains(err.Error(), "FilterOptions") || !strings.Contains(err.Error(), "D-27") {
|
||||
t.Fatalf("scope filter without FilterOptions err=%v", err)
|
||||
}
|
||||
}
|
||||
356
modules/cabana/filter_schema.go
Normal file
356
modules/cabana/filter_schema.go
Normal file
@@ -0,0 +1,356 @@
|
||||
package cabana
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"io/fs"
|
||||
"net/http"
|
||||
"path"
|
||||
"reflect"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"git.golem15.com/golem15/summercms/modules/pact"
|
||||
"git.golem15.com/golem15/summercms/modules/towel"
|
||||
"github.com/goccy/go-yaml/ast"
|
||||
)
|
||||
|
||||
var filterScopeKeys = map[string]struct{}{
|
||||
"label": {}, "type": {}, "column": {}, "options": {},
|
||||
"modelClass": {}, "nameFrom": {}, "scope": {},
|
||||
}
|
||||
|
||||
type filterDocument struct {
|
||||
Scopes scopeMap `yaml:"scopes"`
|
||||
}
|
||||
|
||||
type scopeMap struct {
|
||||
items []ListFilter
|
||||
}
|
||||
|
||||
func compileFilters(pluginID string, ctl pact.AdminController, fsys fs.FS, dir, ref string) ([]ListFilter, error) {
|
||||
file, err := filterAssetPath(pluginID, dir, ref)
|
||||
if err != nil {
|
||||
return nil, bootErr(pluginID, ctl.ID(), "config_filter.yaml", err)
|
||||
}
|
||||
raw, err := readAsset(fsys, file)
|
||||
if err != nil {
|
||||
return nil, bootErr(pluginID, ctl.ID(), file, err)
|
||||
}
|
||||
var doc filterDocument
|
||||
if err := decodeStrict(raw, &doc); err != nil {
|
||||
return nil, bootErr(pluginID, ctl.ID(), file, err)
|
||||
}
|
||||
filters := doc.Scopes.items
|
||||
if filters == nil {
|
||||
filters = []ListFilter{}
|
||||
}
|
||||
provider := filterProvider(ctl)
|
||||
for _, filter := range filters {
|
||||
if err := validateFilter(ctl, provider, filter); err != nil {
|
||||
return nil, bootErr(pluginID, ctl.ID(), file, err)
|
||||
}
|
||||
}
|
||||
return filters, nil
|
||||
}
|
||||
|
||||
func filterAssetPath(pluginID, dir, ref string) (string, error) {
|
||||
ref = strings.TrimSpace(ref)
|
||||
if ref == "" {
|
||||
return "", fmt.Errorf("filter file is empty")
|
||||
}
|
||||
if strings.Contains(ref, "..") {
|
||||
return "", fmt.Errorf("filter path escapes the plugin")
|
||||
}
|
||||
if strings.HasPrefix(ref, "~/") || strings.Contains(ref, "/") {
|
||||
return assetPath(pluginID, ref)
|
||||
}
|
||||
return path.Join(dir, ref), nil
|
||||
}
|
||||
|
||||
func (m *scopeMap) UnmarshalYAML(node ast.Node) error {
|
||||
node = unwrapNode(node)
|
||||
if _, ok := node.(*ast.NullNode); ok || node == nil {
|
||||
m.items = []ListFilter{}
|
||||
return nil
|
||||
}
|
||||
mapping, ok := node.(*ast.MappingNode)
|
||||
if !ok {
|
||||
return fmt.Errorf("scopes must be a mapping")
|
||||
}
|
||||
items := make([]ListFilter, 0, len(mapping.Values))
|
||||
seen := map[string]struct{}{}
|
||||
for _, entry := range mapping.Values {
|
||||
name, err := nodeString(unwrapNode(entry.Key))
|
||||
if err != nil || !identifier(name) {
|
||||
return fmt.Errorf("filter name %q is not an identifier", nodeText(entry.Key))
|
||||
}
|
||||
if _, dup := seen[name]; dup {
|
||||
return fmt.Errorf("duplicate filter %s", name)
|
||||
}
|
||||
seen[name] = struct{}{}
|
||||
filter, err := compileScopeNode(name, unwrapNode(entry.Value))
|
||||
if err != nil {
|
||||
return fmt.Errorf("filter %s: %w", name, err)
|
||||
}
|
||||
items = append(items, filter)
|
||||
}
|
||||
m.items = items
|
||||
return nil
|
||||
}
|
||||
|
||||
func compileScopeNode(name string, node ast.Node) (ListFilter, error) {
|
||||
mapping, ok := node.(*ast.MappingNode)
|
||||
if !ok {
|
||||
return ListFilter{}, fmt.Errorf("must be a mapping")
|
||||
}
|
||||
values := map[string]ast.Node{}
|
||||
for _, entry := range mapping.Values {
|
||||
key, err := nodeString(unwrapNode(entry.Key))
|
||||
if err != nil {
|
||||
return ListFilter{}, err
|
||||
}
|
||||
if key == "conditions" {
|
||||
return ListFilter{}, fmt.Errorf("conditions is not supported; use a column or a registered model scope")
|
||||
}
|
||||
if _, known := filterScopeKeys[key]; !known {
|
||||
return ListFilter{}, fmt.Errorf("unknown field %s", key)
|
||||
}
|
||||
if _, dup := values[key]; dup {
|
||||
return ListFilter{}, fmt.Errorf("duplicate field %s", key)
|
||||
}
|
||||
values[key] = unwrapNode(entry.Value)
|
||||
}
|
||||
filter := ListFilter{Name: name}
|
||||
var err error
|
||||
if node, ok := values["label"]; ok {
|
||||
filter.Label, err = nodeString(node)
|
||||
if err != nil {
|
||||
return ListFilter{}, fmt.Errorf("label: %w", err)
|
||||
}
|
||||
}
|
||||
if node, ok := values["type"]; ok {
|
||||
filter.Type, err = nodeString(node)
|
||||
if err != nil {
|
||||
return ListFilter{}, fmt.Errorf("type: %w", err)
|
||||
}
|
||||
}
|
||||
if node, ok := values["column"]; ok {
|
||||
filter.Column, err = nodeString(node)
|
||||
if err != nil || !identifier(filter.Column) {
|
||||
return ListFilter{}, fmt.Errorf("column %q is not an identifier", filter.Column)
|
||||
}
|
||||
}
|
||||
if node, ok := values["modelClass"]; ok {
|
||||
filter.ModelClass, err = nodeString(node)
|
||||
if err != nil || strings.TrimSpace(filter.ModelClass) == "" {
|
||||
return ListFilter{}, fmt.Errorf("modelClass is empty")
|
||||
}
|
||||
}
|
||||
if node, ok := values["nameFrom"]; ok {
|
||||
filter.NameFrom, err = nodeString(node)
|
||||
if err != nil || !identifier(filter.NameFrom) {
|
||||
return ListFilter{}, fmt.Errorf("nameFrom %q is not an identifier", filter.NameFrom)
|
||||
}
|
||||
}
|
||||
if node, ok := values["scope"]; ok {
|
||||
filter.Scope, err = nodeString(node)
|
||||
if err != nil || !identifier(filter.Scope) {
|
||||
return ListFilter{}, fmt.Errorf("scope %q is not an identifier", filter.Scope)
|
||||
}
|
||||
}
|
||||
if node, ok := values["options"]; ok {
|
||||
filter.Options, err = compileFilterOptions(node)
|
||||
if err != nil {
|
||||
return ListFilter{}, fmt.Errorf("options: %w", err)
|
||||
}
|
||||
}
|
||||
if filter.Type == "" && filter.Scope != "" {
|
||||
filter.Type = "scope"
|
||||
}
|
||||
switch filter.Type {
|
||||
case "switch":
|
||||
if filter.Column == "" {
|
||||
return ListFilter{}, fmt.Errorf("column is required")
|
||||
}
|
||||
if len(filter.Options) == 0 {
|
||||
on := jsonScalar{raw: []byte("true")}
|
||||
off := jsonScalar{raw: []byte("false")}
|
||||
filter.TrueValue = &on
|
||||
filter.FalseValue = &off
|
||||
}
|
||||
case "daterange":
|
||||
if filter.Column == "" {
|
||||
return ListFilter{}, fmt.Errorf("column is required")
|
||||
}
|
||||
case "scope":
|
||||
if filter.Scope == "" || filter.ModelClass == "" || filter.NameFrom == "" {
|
||||
return ListFilter{}, fmt.Errorf("scope, modelClass, and nameFrom are required")
|
||||
}
|
||||
default:
|
||||
if filter.Type == "" {
|
||||
return ListFilter{}, fmt.Errorf("type is required")
|
||||
}
|
||||
return ListFilter{}, fmt.Errorf("unsupported filter type %s", filter.Type)
|
||||
}
|
||||
return filter, nil
|
||||
}
|
||||
|
||||
func compileFilterOptions(node ast.Node) ([]FormOption, error) {
|
||||
mapping, ok := node.(*ast.MappingNode)
|
||||
if !ok {
|
||||
return nil, fmt.Errorf("must be a map")
|
||||
}
|
||||
options := make([]FormOption, 0, len(mapping.Values))
|
||||
for _, entry := range mapping.Values {
|
||||
value, err := nodeScalar(unwrapNode(entry.Key))
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("value: %w", err)
|
||||
}
|
||||
label, err := nodeString(unwrapNode(entry.Value))
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("label: %w", err)
|
||||
}
|
||||
options = append(options, FormOption{Value: value, Label: label})
|
||||
}
|
||||
return options, nil
|
||||
}
|
||||
|
||||
func validateFilter(ctl pact.AdminController, provider pact.FilterScope, filter ListFilter) error {
|
||||
switch filter.Type {
|
||||
case "switch", "daterange":
|
||||
if _, _, check := listModelContract(ctl); check {
|
||||
ft, ok := modelColumnType(ctl, filter.Column)
|
||||
if !ok {
|
||||
return fmt.Errorf("column %s is not on the model", filter.Column)
|
||||
}
|
||||
if filter.Type == "switch" && !isBoolType(ft) {
|
||||
return fmt.Errorf("column %s is not a boolean", filter.Column)
|
||||
}
|
||||
if filter.Type == "daterange" && !isTimeType(ft) {
|
||||
return fmt.Errorf("column %s is not a date", filter.Column)
|
||||
}
|
||||
}
|
||||
case "scope":
|
||||
if provider == nil {
|
||||
return fmt.Errorf("scope %s requires FilterScope", filter.Scope)
|
||||
}
|
||||
registered := false
|
||||
for _, name := range provider.FilterScopes() {
|
||||
if name == filter.Scope {
|
||||
registered = true
|
||||
break
|
||||
}
|
||||
}
|
||||
if !registered {
|
||||
return fmt.Errorf("scope %s is not registered", filter.Scope)
|
||||
}
|
||||
if _, ok := provider.(pact.FilterOptions); !ok {
|
||||
return fmt.Errorf("scope filter %s needs FilterOptions on the model to serve its choices (D-27)", filter.Name)
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// FilterOption is one model-backed filter choice (D-27). Values stay the
|
||||
// strings the model returns; they are sent back as filter[<name>].
|
||||
type FilterOption struct {
|
||||
Value string `json:"value"`
|
||||
Label string `json:"label"`
|
||||
}
|
||||
|
||||
// filterOptions serves GET /{vendor}/{plugin}/{controller}/filters/{scope}/options
|
||||
// for a declared scope filter of the controller's list. {scope} is the filter
|
||||
// name (the filter[<name>] key); the model receives the filter's scope method.
|
||||
func (s *service) filterOptions(w http.ResponseWriter, r *http.Request) {
|
||||
s.protect(w, r, func(cc *CompiledController) {
|
||||
name := r.PathValue("scope")
|
||||
var filter *ListFilter
|
||||
if cc.List != nil && identifier(name) {
|
||||
for i := range cc.List.Filters {
|
||||
if cc.List.Filters[i].Name == name && cc.List.Filters[i].Type == "scope" {
|
||||
filter = &cc.List.Filters[i]
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
if filter == nil {
|
||||
writeNotFound(w, r)
|
||||
return
|
||||
}
|
||||
provider, ok := filterProvider(cc.Controller).(pact.FilterOptions)
|
||||
if !ok || provider == nil {
|
||||
writeNotFound(w, r)
|
||||
return
|
||||
}
|
||||
tr := s.translator()
|
||||
locale := schemaLocale(r.Context(), tr)
|
||||
ctx := towel.WithLocale(r.Context(), locale)
|
||||
provided := provider.FilterOptions(filter.Scope)
|
||||
out := make([]FilterOption, 0, len(provided))
|
||||
for _, opt := range provided {
|
||||
out = append(out, FilterOption{Value: opt.Value, Label: translateKey(ctx, tr, opt.Label)})
|
||||
}
|
||||
WriteData(w, http.StatusOK, out, map[string]any{"locale": locale})
|
||||
})
|
||||
}
|
||||
|
||||
func filterProvider(ctl pact.AdminController) pact.FilterScope {
|
||||
src, ok := ctl.(pact.AdminRecordSource)
|
||||
if !ok || src == nil {
|
||||
return nil
|
||||
}
|
||||
rec := src.NewRecord()
|
||||
provider, ok := rec.(pact.FilterScope)
|
||||
if !ok || provider == nil {
|
||||
return nil
|
||||
}
|
||||
return provider
|
||||
}
|
||||
|
||||
func modelColumnType(ctl pact.AdminController, column string) (reflect.Type, bool) {
|
||||
src, ok := ctl.(pact.AdminRecordSource)
|
||||
if !ok || src == nil || src.NewRecord() == nil {
|
||||
return nil, false
|
||||
}
|
||||
t := reflect.TypeOf(src.NewRecord())
|
||||
for t != nil && t.Kind() == reflect.Pointer {
|
||||
t = t.Elem()
|
||||
}
|
||||
if t == nil || t.Kind() != reflect.Struct {
|
||||
return nil, false
|
||||
}
|
||||
for i := 0; i < t.NumField(); i++ {
|
||||
field := t.Field(i)
|
||||
if field.PkgPath != "" || isListRelation(field.Type) {
|
||||
continue
|
||||
}
|
||||
name := gormColumn(field)
|
||||
if name == "" {
|
||||
name = field.Name
|
||||
}
|
||||
if name == column {
|
||||
return field.Type, true
|
||||
}
|
||||
}
|
||||
return nil, false
|
||||
}
|
||||
|
||||
func isTimeType(t reflect.Type) bool {
|
||||
if t == nil {
|
||||
return false
|
||||
}
|
||||
for t.Kind() == reflect.Pointer {
|
||||
t = t.Elem()
|
||||
}
|
||||
return t == reflect.TypeOf(time.Time{})
|
||||
}
|
||||
|
||||
func isBoolType(t reflect.Type) bool {
|
||||
if t == nil {
|
||||
return false
|
||||
}
|
||||
for t.Kind() == reflect.Pointer {
|
||||
t = t.Elem()
|
||||
}
|
||||
return t.Kind() == reflect.Bool
|
||||
}
|
||||
632
modules/cabana/form_schema.go
Normal file
632
modules/cabana/form_schema.go
Normal file
@@ -0,0 +1,632 @@
|
||||
package cabana
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"io/fs"
|
||||
"path"
|
||||
"strconv"
|
||||
"strings"
|
||||
|
||||
"context"
|
||||
|
||||
"git.golem15.com/golem15/summercms/modules/pact"
|
||||
"git.golem15.com/golem15/summercms/modules/phrasebook"
|
||||
"git.golem15.com/golem15/summercms/modules/towel"
|
||||
"github.com/goccy/go-yaml"
|
||||
"github.com/goccy/go-yaml/ast"
|
||||
)
|
||||
|
||||
var (
|
||||
formFieldTypes = map[string]struct{}{
|
||||
"text": {}, "textarea": {}, "number": {}, "checkbox": {},
|
||||
"switch": {}, "dropdown": {}, "relation": {}, "relation-manager": {},
|
||||
}
|
||||
formSpans = map[string]struct{}{
|
||||
"left": {}, "right": {}, "full": {}, "auto": {}, "row": {},
|
||||
}
|
||||
formSizes = map[string]struct{}{
|
||||
"tiny": {}, "small": {}, "large": {}, "huge": {}, "giant": {},
|
||||
}
|
||||
formFieldKeys = map[string]struct{}{
|
||||
"label": {}, "comment": {}, "span": {}, "type": {}, "required": {},
|
||||
"tab": {}, "context": {}, "attributes": {}, "size": {}, "default": {},
|
||||
"nameFrom": {}, "emptyOption": {}, "options": {}, "relation": {},
|
||||
}
|
||||
)
|
||||
|
||||
type formConfigDocument struct {
|
||||
Name string `yaml:"name"`
|
||||
Form string `yaml:"form"`
|
||||
ModelClass string `yaml:"modelClass"`
|
||||
DefaultRedirect string `yaml:"defaultRedirect"`
|
||||
Create *formRedirects `yaml:"create"`
|
||||
Update *formRedirects `yaml:"update"`
|
||||
Messages *formMessageKeys `yaml:"messages"`
|
||||
}
|
||||
|
||||
type formRedirects struct {
|
||||
Redirect string `yaml:"redirect"`
|
||||
RedirectClose string `yaml:"redirectClose"`
|
||||
}
|
||||
|
||||
type formFieldsFile struct {
|
||||
Fields fieldMap `yaml:"fields"`
|
||||
}
|
||||
|
||||
type fieldMap struct {
|
||||
items []FormField
|
||||
}
|
||||
|
||||
// CompileForm compiles config_form.yaml and the model fields.yaml it names.
|
||||
// The returned schema is safe to cache: labels stay as source keys.
|
||||
func CompileForm(pluginID string, ctl pact.AdminController, fsys fs.FS) (*FormSchema, error) {
|
||||
if ctl == nil {
|
||||
return nil, fmt.Errorf("cabana: admin schema %s: controller is nil", pluginID)
|
||||
}
|
||||
dir := strings.Trim(path.Clean(ctl.ConfigDir()), "/")
|
||||
if dir == "." || strings.HasPrefix(dir, "..") {
|
||||
return nil, bootErr(pluginID, ctl.ID(), ctl.ConfigDir(), fmt.Errorf("config directory escapes the plugin"))
|
||||
}
|
||||
cfgPath := dir + "/config_form.yaml"
|
||||
raw, err := readAsset(fsys, cfgPath)
|
||||
if err != nil {
|
||||
return nil, bootErr(pluginID, ctl.ID(), cfgPath, err)
|
||||
}
|
||||
var doc formConfigDocument
|
||||
if err := decodeStrict(raw, &doc); err != nil {
|
||||
return nil, bootErr(pluginID, ctl.ID(), cfgPath, err)
|
||||
}
|
||||
if doc.ModelClass != ctl.ModelName() {
|
||||
return nil, bootErr(pluginID, ctl.ID(), cfgPath, fmt.Errorf("modelClass %q does not match %q", doc.ModelClass, ctl.ModelName()))
|
||||
}
|
||||
if strings.TrimSpace(doc.Form) == "" {
|
||||
return nil, bootErr(pluginID, ctl.ID(), cfgPath, fmt.Errorf("form file is empty"))
|
||||
}
|
||||
fieldsPath, err := assetPath(pluginID, doc.Form)
|
||||
if err != nil {
|
||||
return nil, bootErr(pluginID, ctl.ID(), cfgPath, err)
|
||||
}
|
||||
fieldsRaw, err := readAsset(fsys, fieldsPath)
|
||||
if err != nil {
|
||||
return nil, bootErr(pluginID, ctl.ID(), fieldsPath, err)
|
||||
}
|
||||
fields, err := decodeFields(fieldsRaw)
|
||||
if err != nil {
|
||||
return nil, bootErr(pluginID, ctl.ID(), fieldsPath, err)
|
||||
}
|
||||
if fields == nil {
|
||||
fields = []FormField{}
|
||||
}
|
||||
if err := requireDropdownProvider(ctl, fields); err != nil {
|
||||
return nil, bootErr(pluginID, ctl.ID(), fieldsPath, err)
|
||||
}
|
||||
schema := &FormSchema{
|
||||
Name: doc.Name,
|
||||
ModelClass: doc.ModelClass,
|
||||
Fields: fields,
|
||||
redirects: FormRedirects{Default: doc.DefaultRedirect},
|
||||
}
|
||||
if doc.Messages != nil {
|
||||
schema.messageKeys = *doc.Messages
|
||||
}
|
||||
if doc.Create != nil {
|
||||
schema.redirects.Create = FormRedirect{Redirect: doc.Create.Redirect, RedirectClose: doc.Create.RedirectClose}
|
||||
}
|
||||
if doc.Update != nil {
|
||||
schema.redirects.Update = FormRedirect{Redirect: doc.Update.Redirect, RedirectClose: doc.Update.RedirectClose}
|
||||
}
|
||||
return schema, nil
|
||||
}
|
||||
|
||||
// Localize copies the cached schema and resolves display strings for one request.
|
||||
// It does not mutate s. Option values keep the scalar captured at boot.
|
||||
func (s *FormSchema) Localize(ctx context.Context, tr *phrasebook.Translator, provider pact.DropdownOptionsProvider) (*FormView, error) {
|
||||
if s == nil {
|
||||
return nil, fmt.Errorf("cabana: nil form schema")
|
||||
}
|
||||
if ctx == nil {
|
||||
ctx = context.Background()
|
||||
}
|
||||
locale := schemaLocale(ctx, tr)
|
||||
ctx = towel.WithLocale(ctx, locale)
|
||||
fields := make([]FormField, len(s.Fields))
|
||||
for i, src := range s.Fields {
|
||||
field := src
|
||||
field.Label = translateKey(ctx, tr, src.Label)
|
||||
field.Comment = translateKey(ctx, tr, src.Comment)
|
||||
field.Tab = translateKey(ctx, tr, src.Tab)
|
||||
field.EmptyOption = translateKey(ctx, tr, src.EmptyOption)
|
||||
options, err := localizeOptions(ctx, tr, src, provider)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
field.Options = options
|
||||
fields[i] = field
|
||||
}
|
||||
if fields == nil {
|
||||
fields = []FormField{}
|
||||
}
|
||||
return &FormView{
|
||||
Name: translateKey(ctx, tr, s.Name),
|
||||
ModelClass: s.ModelClass,
|
||||
Fields: fields,
|
||||
Messages: localizeMessages[formMessageKeys, FormMessages](ctx, tr, s.formMessageKeySet()),
|
||||
Redirects: s.redirects,
|
||||
Meta: FormMeta{Locale: locale},
|
||||
}, nil
|
||||
}
|
||||
|
||||
// CanonicalJSON is one localized schema response.
|
||||
func (v *FormView) CanonicalJSON() ([]byte, error) {
|
||||
if v == nil {
|
||||
return nil, fmt.Errorf("cabana: nil form view")
|
||||
}
|
||||
out := *v
|
||||
if out.Fields == nil {
|
||||
out.Fields = []FormField{}
|
||||
}
|
||||
return json.Marshal(out)
|
||||
}
|
||||
|
||||
// CanonicalJSON is the stable, locale-neutral form contract.
|
||||
func (s *FormSchema) CanonicalJSON() ([]byte, error) {
|
||||
if s == nil {
|
||||
return nil, fmt.Errorf("cabana: nil form schema")
|
||||
}
|
||||
out := *s
|
||||
if out.Fields == nil {
|
||||
out.Fields = []FormField{}
|
||||
}
|
||||
return json.Marshal(out)
|
||||
}
|
||||
|
||||
func requireDropdownProvider(ctl pact.AdminController, fields []FormField) error {
|
||||
var method string
|
||||
for _, field := range fields {
|
||||
if field.optionsMethod != "" {
|
||||
method = field.optionsMethod
|
||||
break
|
||||
}
|
||||
}
|
||||
if method == "" || dropdownProvider(ctl) != nil {
|
||||
return nil
|
||||
}
|
||||
return fmt.Errorf("dropdown method %s requires DropdownOptions", method)
|
||||
}
|
||||
|
||||
func dropdownProvider(ctl pact.AdminController) pact.DropdownOptionsProvider {
|
||||
if ctl == nil {
|
||||
return nil
|
||||
}
|
||||
if p, ok := ctl.(pact.DropdownOptionsProvider); ok && p != nil {
|
||||
return p
|
||||
}
|
||||
src, ok := ctl.(pact.AdminRecordSource)
|
||||
if !ok || src == nil {
|
||||
return nil
|
||||
}
|
||||
rec := src.NewRecord()
|
||||
p, ok := rec.(pact.DropdownOptionsProvider)
|
||||
if !ok || p == nil {
|
||||
return nil
|
||||
}
|
||||
return p
|
||||
}
|
||||
|
||||
func schemaLocale(ctx context.Context, tr *phrasebook.Translator) string {
|
||||
if loc, ok := towel.Locale(ctx); ok {
|
||||
if primary := primaryLanguage(loc); primary != "" {
|
||||
return primary
|
||||
}
|
||||
}
|
||||
if tr != nil {
|
||||
if loc := strings.TrimSpace(tr.Locale()); loc != "" {
|
||||
return loc
|
||||
}
|
||||
}
|
||||
return "en"
|
||||
}
|
||||
|
||||
func primaryLanguage(header string) string {
|
||||
header = strings.TrimSpace(header)
|
||||
if header == "" {
|
||||
return ""
|
||||
}
|
||||
if i := strings.IndexAny(header, ",;"); i >= 0 {
|
||||
header = strings.TrimSpace(header[:i])
|
||||
}
|
||||
return header
|
||||
}
|
||||
|
||||
func translateKey(ctx context.Context, tr *phrasebook.Translator, key string) string {
|
||||
if key == "" || tr == nil {
|
||||
return key
|
||||
}
|
||||
return tr.Get(ctx, key, nil)
|
||||
}
|
||||
|
||||
func localizeOptions(ctx context.Context, tr *phrasebook.Translator, src FormField, provider pact.DropdownOptionsProvider) ([]FormOption, error) {
|
||||
if src.optionsMethod != "" {
|
||||
if provider == nil {
|
||||
return nil, fmt.Errorf("cabana: dropdown method %s requires DropdownOptions", src.optionsMethod)
|
||||
}
|
||||
provided := provider.DropdownOptions(src.Name)
|
||||
opts := make([]FormOption, len(provided))
|
||||
for i, opt := range provided {
|
||||
raw, err := json.Marshal(opt.Value)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
opts[i] = FormOption{Value: jsonScalar{raw: raw}, Label: translateKey(ctx, tr, opt.Label)}
|
||||
}
|
||||
return opts, nil
|
||||
}
|
||||
if len(src.Options) == 0 {
|
||||
return nil, nil
|
||||
}
|
||||
opts := make([]FormOption, len(src.Options))
|
||||
for i, opt := range src.Options {
|
||||
opt.Label = translateKey(ctx, tr, opt.Label)
|
||||
opts[i] = opt
|
||||
}
|
||||
return opts, nil
|
||||
}
|
||||
|
||||
func decodeFields(raw []byte) ([]FormField, error) {
|
||||
dec := yaml.NewDecoder(bytes.NewReader(raw), yaml.DisallowUnknownField())
|
||||
var doc formFieldsFile
|
||||
if err := dec.Decode(&doc); err != nil {
|
||||
return nil, normalizeYAMLError(err)
|
||||
}
|
||||
if doc.Fields.items == nil {
|
||||
return []FormField{}, nil
|
||||
}
|
||||
return doc.Fields.items, nil
|
||||
}
|
||||
|
||||
func (m *fieldMap) UnmarshalYAML(node ast.Node) error {
|
||||
node = unwrapNode(node)
|
||||
if _, ok := node.(*ast.NullNode); ok || node == nil {
|
||||
m.items = []FormField{}
|
||||
return nil
|
||||
}
|
||||
mapping, ok := node.(*ast.MappingNode)
|
||||
if !ok {
|
||||
return fmt.Errorf("fields must be a mapping")
|
||||
}
|
||||
items := make([]FormField, 0, len(mapping.Values))
|
||||
seen := map[string]struct{}{}
|
||||
for _, entry := range mapping.Values {
|
||||
name, err := nodeString(unwrapNode(entry.Key))
|
||||
if err != nil || !identifier(name) {
|
||||
return fmt.Errorf("field name %q is not an identifier", nodeText(entry.Key))
|
||||
}
|
||||
if _, dup := seen[name]; dup {
|
||||
return fmt.Errorf("duplicate field %s", name)
|
||||
}
|
||||
seen[name] = struct{}{}
|
||||
field, err := compileFieldNode(name, unwrapNode(entry.Value))
|
||||
if err != nil {
|
||||
return fmt.Errorf("field %s: %w", name, err)
|
||||
}
|
||||
items = append(items, field)
|
||||
}
|
||||
m.items = items
|
||||
return nil
|
||||
}
|
||||
|
||||
func compileFieldNode(name string, node ast.Node) (FormField, error) {
|
||||
mapping, ok := node.(*ast.MappingNode)
|
||||
if !ok {
|
||||
return FormField{}, fmt.Errorf("must be a mapping")
|
||||
}
|
||||
values := map[string]ast.Node{}
|
||||
for _, entry := range mapping.Values {
|
||||
key, err := nodeString(unwrapNode(entry.Key))
|
||||
if err != nil {
|
||||
return FormField{}, err
|
||||
}
|
||||
if _, known := formFieldKeys[key]; !known {
|
||||
return FormField{}, fmt.Errorf("unknown field %s", key)
|
||||
}
|
||||
if _, dup := values[key]; dup {
|
||||
return FormField{}, fmt.Errorf("duplicate field %s", key)
|
||||
}
|
||||
values[key] = unwrapNode(entry.Value)
|
||||
}
|
||||
typ, err := nodeString(values["type"])
|
||||
if err != nil || typ == "" {
|
||||
return FormField{}, fmt.Errorf("type is required")
|
||||
}
|
||||
if typ == "partial" {
|
||||
return FormField{}, fmt.Errorf("type partial is not supported")
|
||||
}
|
||||
if _, ok := formFieldTypes[typ]; !ok {
|
||||
return FormField{}, fmt.Errorf("unsupported type %s", typ)
|
||||
}
|
||||
field := FormField{Name: name, Type: typ}
|
||||
if node, ok := values["label"]; ok {
|
||||
field.Label, err = nodeString(node)
|
||||
if err != nil {
|
||||
return FormField{}, fmt.Errorf("label: %w", err)
|
||||
}
|
||||
}
|
||||
if node, ok := values["comment"]; ok {
|
||||
field.Comment, err = nodeString(node)
|
||||
if err != nil {
|
||||
return FormField{}, fmt.Errorf("comment: %w", err)
|
||||
}
|
||||
}
|
||||
if node, ok := values["span"]; ok {
|
||||
field.Span, err = nodeString(node)
|
||||
if err != nil {
|
||||
return FormField{}, fmt.Errorf("span: %w", err)
|
||||
}
|
||||
if _, ok := formSpans[field.Span]; !ok {
|
||||
return FormField{}, fmt.Errorf("unsupported span %s", field.Span)
|
||||
}
|
||||
}
|
||||
if node, ok := values["tab"]; ok {
|
||||
field.Tab, err = nodeString(node)
|
||||
if err != nil {
|
||||
return FormField{}, fmt.Errorf("tab: %w", err)
|
||||
}
|
||||
}
|
||||
if node, ok := values["size"]; ok {
|
||||
field.Size, err = nodeString(node)
|
||||
if err != nil {
|
||||
return FormField{}, fmt.Errorf("size: %w", err)
|
||||
}
|
||||
if _, ok := formSizes[field.Size]; !ok {
|
||||
return FormField{}, fmt.Errorf("unsupported size %s", field.Size)
|
||||
}
|
||||
}
|
||||
if node, ok := values["context"]; ok {
|
||||
ctx, err := compileContext(node)
|
||||
if err != nil {
|
||||
return FormField{}, err
|
||||
}
|
||||
field.Context = ctx
|
||||
}
|
||||
if node, ok := values["nameFrom"]; ok {
|
||||
field.NameFrom, err = nodeString(node)
|
||||
if err != nil || !identifier(field.NameFrom) {
|
||||
return FormField{}, fmt.Errorf("nameFrom %q is not an identifier", field.NameFrom)
|
||||
}
|
||||
}
|
||||
if node, ok := values["emptyOption"]; ok {
|
||||
field.EmptyOption, err = nodeString(node)
|
||||
if err != nil {
|
||||
return FormField{}, fmt.Errorf("emptyOption: %w", err)
|
||||
}
|
||||
}
|
||||
if node, ok := values["relation"]; ok {
|
||||
field.Relation, err = nodeString(node)
|
||||
if err != nil || !identifier(field.Relation) {
|
||||
return FormField{}, fmt.Errorf("relation %q is not an identifier", field.Relation)
|
||||
}
|
||||
}
|
||||
if typ == "relation-manager" && field.Relation == "" {
|
||||
return FormField{}, fmt.Errorf("relation is required")
|
||||
}
|
||||
if node, ok := values["required"]; ok {
|
||||
field.Required, err = nodeBool(node)
|
||||
if err != nil {
|
||||
return FormField{}, fmt.Errorf("required: %w", err)
|
||||
}
|
||||
}
|
||||
if node, ok := values["default"]; ok {
|
||||
scalar, err := nodeScalar(node)
|
||||
if err != nil {
|
||||
return FormField{}, fmt.Errorf("default: %w", err)
|
||||
}
|
||||
field.Default = &scalar
|
||||
}
|
||||
if node, ok := values["attributes"]; ok {
|
||||
attrs, err := compileAttributes(node)
|
||||
if err != nil {
|
||||
return FormField{}, fmt.Errorf("attributes: %w", err)
|
||||
}
|
||||
field.Attributes = attrs
|
||||
}
|
||||
if node, ok := values["options"]; ok {
|
||||
if err := compileOptions(node, &field); err != nil {
|
||||
return FormField{}, fmt.Errorf("options: %w", err)
|
||||
}
|
||||
}
|
||||
return field, nil
|
||||
}
|
||||
|
||||
func compileContext(node ast.Node) (*fieldContext, error) {
|
||||
switch n := node.(type) {
|
||||
case *ast.StringNode:
|
||||
if !identifier(n.Value) {
|
||||
return nil, fmt.Errorf("context %q is not an identifier", n.Value)
|
||||
}
|
||||
return &fieldContext{single: true, values: []string{n.Value}}, nil
|
||||
case *ast.SequenceNode:
|
||||
values := sequenceValues(n)
|
||||
out := make([]string, 0, len(values))
|
||||
for _, item := range values {
|
||||
text, err := nodeString(unwrapNode(item))
|
||||
if err != nil || !identifier(text) {
|
||||
return nil, fmt.Errorf("context %q is not an identifier", nodeText(item))
|
||||
}
|
||||
out = append(out, text)
|
||||
}
|
||||
return &fieldContext{values: out}, nil
|
||||
default:
|
||||
return nil, fmt.Errorf("context must be a string or a list")
|
||||
}
|
||||
}
|
||||
|
||||
func compileAttributes(node ast.Node) (map[string]jsonScalar, error) {
|
||||
mapping, ok := node.(*ast.MappingNode)
|
||||
if !ok {
|
||||
return nil, fmt.Errorf("must be a mapping")
|
||||
}
|
||||
out := make(map[string]jsonScalar, len(mapping.Values))
|
||||
for _, entry := range mapping.Values {
|
||||
key, err := nodeString(unwrapNode(entry.Key))
|
||||
if err != nil || !identifier(key) {
|
||||
return nil, fmt.Errorf("key %q is not an identifier", nodeText(entry.Key))
|
||||
}
|
||||
scalar, err := nodeScalar(unwrapNode(entry.Value))
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("%s: %w", key, err)
|
||||
}
|
||||
out[key] = scalar
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
func compileOptions(node ast.Node, field *FormField) error {
|
||||
switch n := node.(type) {
|
||||
case *ast.StringNode:
|
||||
if !identifier(n.Value) {
|
||||
return fmt.Errorf("method %q is not an identifier", n.Value)
|
||||
}
|
||||
field.optionsMethod = n.Value
|
||||
return nil
|
||||
case *ast.MappingNode:
|
||||
options := make([]FormOption, 0, len(n.Values))
|
||||
for _, entry := range n.Values {
|
||||
value, err := nodeScalar(unwrapNode(entry.Key))
|
||||
if err != nil {
|
||||
return fmt.Errorf("value: %w", err)
|
||||
}
|
||||
label, err := nodeString(unwrapNode(entry.Value))
|
||||
if err != nil {
|
||||
return fmt.Errorf("label: %w", err)
|
||||
}
|
||||
options = append(options, FormOption{Value: value, Label: label})
|
||||
}
|
||||
field.Options = options
|
||||
return nil
|
||||
default:
|
||||
return fmt.Errorf("must be a map or a method name")
|
||||
}
|
||||
}
|
||||
|
||||
func sequenceValues(n *ast.SequenceNode) []ast.Node {
|
||||
if len(n.Values) > 0 {
|
||||
return n.Values
|
||||
}
|
||||
out := make([]ast.Node, 0, len(n.Entries))
|
||||
for _, entry := range n.Entries {
|
||||
if entry != nil && entry.Value != nil {
|
||||
out = append(out, entry.Value)
|
||||
}
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
func unwrapNode(node ast.Node) ast.Node {
|
||||
for node != nil {
|
||||
switch n := node.(type) {
|
||||
case *ast.MappingKeyNode:
|
||||
node = n.Value
|
||||
case *ast.TagNode:
|
||||
node = n.Value
|
||||
case *ast.AnchorNode:
|
||||
node = n.Value
|
||||
default:
|
||||
return node
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func nodeString(node ast.Node) (string, error) {
|
||||
switch n := unwrapNode(node).(type) {
|
||||
case *ast.StringNode:
|
||||
return n.Value, nil
|
||||
case nil:
|
||||
return "", fmt.Errorf("missing string")
|
||||
default:
|
||||
return "", fmt.Errorf("want a string, got %T", n)
|
||||
}
|
||||
}
|
||||
|
||||
func nodeBool(node ast.Node) (bool, error) {
|
||||
n, ok := unwrapNode(node).(*ast.BoolNode)
|
||||
if !ok {
|
||||
return false, fmt.Errorf("want a boolean")
|
||||
}
|
||||
return n.Value, nil
|
||||
}
|
||||
|
||||
func nodeScalar(node ast.Node) (jsonScalar, error) {
|
||||
switch n := unwrapNode(node).(type) {
|
||||
case *ast.StringNode:
|
||||
raw, err := json.Marshal(n.Value)
|
||||
return jsonScalar{raw: raw}, err
|
||||
case *ast.BoolNode:
|
||||
if n.Value {
|
||||
return jsonScalar{raw: []byte("true")}, nil
|
||||
}
|
||||
return jsonScalar{raw: []byte("false")}, nil
|
||||
case *ast.IntegerNode:
|
||||
return integerScalar(n.Value)
|
||||
case *ast.FloatNode:
|
||||
if n.Value == float64(int64(n.Value)) {
|
||||
return jsonScalar{raw: []byte(strconv.FormatInt(int64(n.Value), 10))}, nil
|
||||
}
|
||||
raw, err := json.Marshal(n.Value)
|
||||
return jsonScalar{raw: raw}, err
|
||||
default:
|
||||
return jsonScalar{}, fmt.Errorf("want a scalar, got %T", n)
|
||||
}
|
||||
}
|
||||
|
||||
func integerScalar(v any) (jsonScalar, error) {
|
||||
switch n := v.(type) {
|
||||
case int64:
|
||||
return jsonScalar{raw: []byte(strconv.FormatInt(n, 10))}, nil
|
||||
case uint64:
|
||||
return jsonScalar{raw: []byte(strconv.FormatUint(n, 10))}, nil
|
||||
case int:
|
||||
return jsonScalar{raw: []byte(strconv.Itoa(n))}, nil
|
||||
default:
|
||||
return jsonScalar{}, fmt.Errorf("want an integer, got %T", v)
|
||||
}
|
||||
}
|
||||
|
||||
func nodeText(node ast.Node) string {
|
||||
if node == nil {
|
||||
return ""
|
||||
}
|
||||
if token := node.GetToken(); token != nil {
|
||||
return token.Value
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
func normalizeYAMLError(err error) error {
|
||||
if err == nil {
|
||||
return nil
|
||||
}
|
||||
msg := err.Error()
|
||||
if strings.Contains(msg, "already defined") {
|
||||
return fmt.Errorf("duplicate field: %w", err)
|
||||
}
|
||||
return err
|
||||
}
|
||||
|
||||
func compileFormIfPresent(pluginID string, ctl pact.AdminController, fsys fs.FS) (*FormSchema, error) {
|
||||
dir := strings.Trim(path.Clean(ctl.ConfigDir()), "/")
|
||||
if dir == "." || strings.HasPrefix(dir, "..") {
|
||||
return nil, bootErr(pluginID, ctl.ID(), ctl.ConfigDir(), fmt.Errorf("config directory escapes the plugin"))
|
||||
}
|
||||
cfgPath := path.Join(dir, "config_form.yaml")
|
||||
if _, err := fs.Stat(fsys, cfgPath); err != nil {
|
||||
if errors.Is(err, fs.ErrNotExist) {
|
||||
return nil, nil
|
||||
}
|
||||
return nil, bootErr(pluginID, ctl.ID(), cfgPath, err)
|
||||
}
|
||||
return CompileForm(pluginID, ctl, fsys)
|
||||
}
|
||||
566
modules/cabana/form_schema_test.go
Normal file
566
modules/cabana/form_schema_test.go
Normal file
@@ -0,0 +1,566 @@
|
||||
package cabana
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"encoding/json"
|
||||
"io/fs"
|
||||
"strings"
|
||||
"sync"
|
||||
"testing"
|
||||
"testing/fstest"
|
||||
|
||||
"git.golem15.com/golem15/summercms/modules/backpack"
|
||||
"git.golem15.com/golem15/summercms/modules/pact"
|
||||
"git.golem15.com/golem15/summercms/modules/party"
|
||||
"git.golem15.com/golem15/summercms/modules/phrasebook"
|
||||
"git.golem15.com/golem15/summercms/modules/towel"
|
||||
)
|
||||
|
||||
const formConfig = `name: demo.form
|
||||
form: ~/plugins/acme/demo/models/widget/fields.yaml
|
||||
modelClass: Widget
|
||||
defaultRedirect: acme/demo/widgets
|
||||
create:
|
||||
redirect: acme/demo/widgets/update/:id
|
||||
redirectClose: acme/demo/widgets
|
||||
update:
|
||||
redirect: acme/demo/widgets
|
||||
redirectClose: acme/demo/widgets
|
||||
`
|
||||
|
||||
const allFieldsYAML = `fields:
|
||||
title:
|
||||
label: demo.lang.title
|
||||
comment: demo.lang.title_comment
|
||||
span: left
|
||||
type: text
|
||||
required: true
|
||||
tab: demo.lang.main
|
||||
context: create
|
||||
default: Untitled
|
||||
body:
|
||||
label: demo.lang.body
|
||||
span: full
|
||||
type: textarea
|
||||
size: small
|
||||
count:
|
||||
label: demo.lang.count
|
||||
span: right
|
||||
type: number
|
||||
default: 3
|
||||
attributes:
|
||||
min: 0
|
||||
readonly: false
|
||||
step: 1
|
||||
active:
|
||||
label: demo.lang.active
|
||||
span: left
|
||||
type: checkbox
|
||||
default: false
|
||||
enabled:
|
||||
label: demo.lang.enabled
|
||||
type: switch
|
||||
default: 0
|
||||
format:
|
||||
label: demo.lang.format
|
||||
type: dropdown
|
||||
required: true
|
||||
emptyOption: demo.lang.none
|
||||
options:
|
||||
vinyl: Vinyl
|
||||
2: Two
|
||||
true: "Yes"
|
||||
artist:
|
||||
label: demo.lang.artist
|
||||
span: right
|
||||
type: relation
|
||||
nameFrom: name
|
||||
emptyOption: demo.lang.pick
|
||||
editors:
|
||||
label: demo.lang.editors
|
||||
type: relation-manager
|
||||
relation: editors
|
||||
tab: demo.lang.editors_tab
|
||||
span: full
|
||||
context:
|
||||
- update
|
||||
- create
|
||||
`
|
||||
|
||||
const allFieldsJSON = `{"name":"demo.form","modelClass":"Widget","fields":[` +
|
||||
`{"name":"title","type":"text","label":"demo.lang.title","comment":"demo.lang.title_comment","span":"left","tab":"demo.lang.main","context":"create","required":true,"default":"Untitled"},` +
|
||||
`{"name":"body","type":"textarea","label":"demo.lang.body","span":"full","size":"small"},` +
|
||||
`{"name":"count","type":"number","label":"demo.lang.count","span":"right","default":3,"attributes":{"min":0,"readonly":false,"step":1}},` +
|
||||
`{"name":"active","type":"checkbox","label":"demo.lang.active","span":"left","default":false},` +
|
||||
`{"name":"enabled","type":"switch","label":"demo.lang.enabled","default":0},` +
|
||||
`{"name":"format","type":"dropdown","label":"demo.lang.format","emptyOption":"demo.lang.none","required":true,"options":[{"value":"vinyl","label":"Vinyl"},{"value":2,"label":"Two"},{"value":true,"label":"Yes"}]},` +
|
||||
`{"name":"artist","type":"relation","label":"demo.lang.artist","span":"right","nameFrom":"name","emptyOption":"demo.lang.pick"},` +
|
||||
`{"name":"editors","type":"relation-manager","label":"demo.lang.editors","span":"full","tab":"demo.lang.editors_tab","context":["update","create"],"relation":"editors"}]}`
|
||||
|
||||
func TestFormSchemaCompile(t *testing.T) {
|
||||
got := compileFormJSON(t, schemaController{model: "Widget"}, formConfig, allFieldsYAML)
|
||||
if got != allFieldsJSON {
|
||||
t.Fatalf("compiled form =\n%s\nwant\n%s", got, allFieldsJSON)
|
||||
}
|
||||
again := compileFormJSON(t, schemaController{model: "Widget"}, formConfig, allFieldsYAML)
|
||||
if again != got {
|
||||
t.Fatalf("recompilation changed JSON:\n%s\n%s", got, again)
|
||||
}
|
||||
for _, want := range []string{`"default":false`, `"default":0`, `"value":2`, `"value":true`, `"value":"vinyl"`} {
|
||||
if !strings.Contains(got, want) {
|
||||
t.Fatalf("compiled form missing scalar %s:\n%s", want, got)
|
||||
}
|
||||
}
|
||||
if strings.Contains(got, `"value":"2"`) || strings.Contains(got, `"value":"true"`) || strings.Contains(got, `"fields":null`) {
|
||||
t.Fatalf("scalar type or null fields drifted:\n%s", got)
|
||||
}
|
||||
|
||||
t.Run("list-only controller still activates", func(t *testing.T) {
|
||||
_, err := compileRegistry([]controllerRef{{
|
||||
plugin: formPlugin{fsys: fstest.MapFS{
|
||||
"controllers/widgets/config_list.yaml": &fstest.MapFile{Data: []byte("list: ~/plugins/acme/demo/models/widget/columns.yaml\nmodelClass: Widget\nrecordsPerPage: 20\nshowSearch: true\n")},
|
||||
"models/widget/columns.yaml": &fstest.MapFile{Data: []byte("columns:\n name:\n label: Name\n searchable: true\n")},
|
||||
}},
|
||||
ctl: schemaController{model: "Widget"},
|
||||
}})
|
||||
if err != nil {
|
||||
t.Fatalf("list-only registry: %v", err)
|
||||
}
|
||||
})
|
||||
t.Run("field name case is exact", func(t *testing.T) {
|
||||
raw := compileFormJSON(t, schemaController{model: "Widget"}, formConfig, "fields:\n Name:\n label: Name\n type: text\n")
|
||||
if !strings.Contains(raw, `"name":"Name"`) || strings.Contains(raw, `"name":"name"`) {
|
||||
t.Fatalf("field name was folded: %s", raw)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func TestFormSchemaEmpty(t *testing.T) {
|
||||
cfg := strings.Replace(formConfig, "name: demo.form", "name: empty", 1)
|
||||
got := compileFormJSON(t, schemaController{model: "Widget"}, cfg, "fields: {}\n")
|
||||
if got != `{"name":"empty","modelClass":"Widget","fields":[]}` {
|
||||
t.Fatalf("empty form = %s", got)
|
||||
}
|
||||
if strings.Contains(got, `"fields":null`) {
|
||||
t.Fatal("empty fields serialized as null")
|
||||
}
|
||||
}
|
||||
|
||||
func TestFormSchemaSingle(t *testing.T) {
|
||||
cfg := strings.Replace(formConfig, "name: demo.form", "name: one", 1)
|
||||
got := compileFormJSON(t, schemaController{model: "Widget"}, cfg, "fields:\n title:\n label: Title\n type: text\n")
|
||||
want := `{"name":"one","modelClass":"Widget","fields":[{"name":"title","type":"text","label":"Title"}]}`
|
||||
if got != want {
|
||||
t.Fatalf("single form =\n%s\nwant\n%s", got, want)
|
||||
}
|
||||
}
|
||||
|
||||
func TestFormSchemaOrdering(t *testing.T) {
|
||||
fields := `fields:
|
||||
zeta:
|
||||
label: Z
|
||||
type: text
|
||||
alpha:
|
||||
label: A
|
||||
type: text
|
||||
mid:
|
||||
label: M
|
||||
type: number
|
||||
`
|
||||
first := compileFormJSON(t, schemaController{model: "Widget"}, formConfig, fields)
|
||||
second := compileFormJSON(t, schemaController{model: "Widget"}, formConfig, fields)
|
||||
if first != second {
|
||||
t.Fatalf("order changed between compiles:\n%s\n%s", first, second)
|
||||
}
|
||||
zeta := strings.Index(first, `"name":"zeta"`)
|
||||
alpha := strings.Index(first, `"name":"alpha"`)
|
||||
mid := strings.Index(first, `"name":"mid"`)
|
||||
if zeta < 0 || alpha < 0 || mid < 0 || !(zeta < alpha && alpha < mid) {
|
||||
t.Fatalf("source order lost: %s", first)
|
||||
}
|
||||
}
|
||||
|
||||
func TestFormSchemaRejects(t *testing.T) {
|
||||
cases := []struct {
|
||||
name string
|
||||
model string
|
||||
config string
|
||||
fields string
|
||||
want []string
|
||||
}{
|
||||
{
|
||||
name: "unknown key",
|
||||
config: formConfig,
|
||||
fields: "fields:\n title:\n type: text\n cssClass: bad\n",
|
||||
want: []string{"acme.demo", "acme.demo.widgets", "models/widget/fields.yaml", "cssClass"},
|
||||
},
|
||||
{
|
||||
name: "unknown type",
|
||||
config: formConfig,
|
||||
fields: "fields:\n title:\n type: widget\n label: Title\n",
|
||||
want: []string{"acme.demo", "acme.demo.widgets", "models/widget/fields.yaml", "widget"},
|
||||
},
|
||||
{
|
||||
name: "duplicate name",
|
||||
config: formConfig,
|
||||
fields: "fields:\n title:\n type: text\n label: A\n title:\n type: text\n label: B\n",
|
||||
want: []string{"acme.demo", "acme.demo.widgets", "models/widget/fields.yaml", "duplicate"},
|
||||
},
|
||||
{
|
||||
name: "path escape",
|
||||
config: strings.Replace(formConfig, "form: ~/plugins/acme/demo/models/widget/fields.yaml", "form: ../../etc/passwd", 1),
|
||||
fields: "fields: {}\n",
|
||||
want: []string{"acme.demo", "acme.demo.widgets", "config_form.yaml", "escape"},
|
||||
},
|
||||
{
|
||||
name: "mismatched modelClass",
|
||||
model: "Widget",
|
||||
config: strings.Replace(formConfig, "modelClass: Widget", "modelClass: widget", 1),
|
||||
fields: "fields: {}\n",
|
||||
want: []string{"acme.demo", "acme.demo.widgets", "config_form.yaml", "modelClass"},
|
||||
},
|
||||
{
|
||||
name: "partial",
|
||||
config: formConfig,
|
||||
fields: "fields:\n editors:\n type: partial\n tab: Editors\n span: full\n",
|
||||
want: []string{"acme.demo", "acme.demo.widgets", "models/widget/fields.yaml", "partial"},
|
||||
},
|
||||
{
|
||||
name: "partial path",
|
||||
config: formConfig,
|
||||
fields: "fields:\n editors:\n type: partial\n path: $/golem15/acme/controllers/collections/_editors.htm\n",
|
||||
want: []string{"acme.demo", "acme.demo.widgets", "models/widget/fields.yaml", "path"},
|
||||
},
|
||||
{
|
||||
name: "missing fields",
|
||||
config: strings.Replace(formConfig, "models/widget/fields.yaml", "models/widget/missing.yaml", 1),
|
||||
fields: "fields: {}\n",
|
||||
want: []string{"acme.demo", "acme.demo.widgets", "missing.yaml"},
|
||||
},
|
||||
}
|
||||
for _, tc := range cases {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
model := tc.model
|
||||
if model == "" {
|
||||
model = "Widget"
|
||||
}
|
||||
_, err := CompileForm("acme.demo", schemaController{model: model}, formFS(tc.config, tc.fields))
|
||||
if err == nil {
|
||||
t.Fatal("expected boot error")
|
||||
}
|
||||
msg := err.Error()
|
||||
for _, want := range tc.want {
|
||||
if want == "duplicate" {
|
||||
if strings.Contains(msg, "duplicate") || strings.Contains(msg, "already defined") {
|
||||
continue
|
||||
}
|
||||
t.Fatalf("error %q missing duplicate", msg)
|
||||
}
|
||||
if want == "escape" {
|
||||
if strings.Contains(msg, "escape") || strings.Contains(msg, "..") {
|
||||
continue
|
||||
}
|
||||
t.Fatalf("error %q missing escape", msg)
|
||||
}
|
||||
if !strings.Contains(msg, want) {
|
||||
t.Fatalf("error %q missing %q", msg, want)
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
t.Run("bad form fails activation", func(t *testing.T) {
|
||||
fsys := formFS(formConfig, "fields:\n editors:\n type: partial\n tab: Editors\n")
|
||||
fsys = withList(fsys)
|
||||
_, err := compileRegistry([]controllerRef{{
|
||||
plugin: &formPlugin{fsys: fsys},
|
||||
ctl: schemaController{model: "Widget"},
|
||||
}})
|
||||
if err == nil || !strings.Contains(err.Error(), "partial") {
|
||||
t.Fatalf("activation err = %v", err)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
type schemaController struct{ model string }
|
||||
|
||||
func (c schemaController) ID() string { return "acme.demo.widgets" }
|
||||
func (c schemaController) ModelName() string {
|
||||
if c.model == "" {
|
||||
return "Widget"
|
||||
}
|
||||
return c.model
|
||||
}
|
||||
func (c schemaController) ConfigDir() string { return "controllers/widgets" }
|
||||
|
||||
type formPlugin struct{ fsys fs.FS }
|
||||
|
||||
func (p formPlugin) ID() string { return "acme.demo" }
|
||||
func (p formPlugin) Requires() []string { return nil }
|
||||
func (p formPlugin) Register(*backpack.App) error { return nil }
|
||||
func (p formPlugin) Boot(*backpack.App) error { return nil }
|
||||
func (p formPlugin) AdminFS() fs.FS { return p.fsys }
|
||||
|
||||
func formFS(config, fields string) fs.FS {
|
||||
return fstest.MapFS{
|
||||
"controllers/widgets/config_form.yaml": &fstest.MapFile{Data: []byte(config)},
|
||||
"models/widget/fields.yaml": &fstest.MapFile{Data: []byte(fields)},
|
||||
}
|
||||
}
|
||||
|
||||
func withList(fsys fs.FS) fs.FS {
|
||||
base, ok := fsys.(fstest.MapFS)
|
||||
if !ok {
|
||||
return fsys
|
||||
}
|
||||
base["controllers/widgets/config_list.yaml"] = &fstest.MapFile{Data: []byte("list: ~/plugins/acme/demo/models/widget/columns.yaml\nmodelClass: Widget\nrecordsPerPage: 20\nshowSearch: true\n")}
|
||||
base["models/widget/columns.yaml"] = &fstest.MapFile{Data: []byte("columns:\n name:\n label: Name\n searchable: true\n")}
|
||||
return base
|
||||
}
|
||||
|
||||
func compileFormJSON(t *testing.T, ctl schemaController, config, fields string) string {
|
||||
t.Helper()
|
||||
schema, err := CompileForm("acme.demo", ctl, formFS(config, fields))
|
||||
if err != nil {
|
||||
t.Fatalf("compile: %v", err)
|
||||
}
|
||||
raw, err := schema.CanonicalJSON()
|
||||
if err != nil {
|
||||
t.Fatalf("json: %v", err)
|
||||
}
|
||||
var buf bytes.Buffer
|
||||
if err := json.Compact(&buf, raw); err != nil {
|
||||
t.Fatalf("compact: %v\n%s", err, raw)
|
||||
}
|
||||
return buf.String()
|
||||
}
|
||||
|
||||
func TestFormSchemaLocalization(t *testing.T) {
|
||||
schema := mustCompileForm(t, schemaController{model: "Widget"}, strings.Replace(formConfig, "name: demo.form", "name: acme.demo::lang.form", 1), localizedFieldsYAML)
|
||||
before := mustCanonical(t, schema)
|
||||
en := phrasebook.NewTranslator(formCatalog(t), phrasebook.Options{Locale: "en", Fallback: "en"})
|
||||
pl := phrasebook.NewTranslator(formCatalog(t), phrasebook.Options{Locale: "pl", Fallback: "en"})
|
||||
|
||||
enJSON := localizeJSON(t, schema, towel.WithLocale(context.Background(), "en"), en, nil)
|
||||
plJSON := localizeJSON(t, schema, towel.WithLocale(context.Background(), "pl"), pl, nil)
|
||||
if enJSON == plJSON {
|
||||
t.Fatalf("locales collapsed:\n%s", enJSON)
|
||||
}
|
||||
for _, want := range []string{`"locale":"en"`, `"label":"Title"`, `"comment":"Comment"`, `"tab":"Tab"`, `"emptyOption":"None"`, `"name":"Form"`} {
|
||||
if !strings.Contains(enJSON, want) {
|
||||
t.Fatalf("en JSON missing %s:\n%s", want, enJSON)
|
||||
}
|
||||
}
|
||||
for _, want := range []string{`"locale":"pl"`, `"label":"Tytuł"`, `"comment":"Komentarz"`, `"tab":"Zakładka"`, `"emptyOption":"Brak"`, `"name":"Formularz"`} {
|
||||
if !strings.Contains(plJSON, want) {
|
||||
t.Fatalf("pl JSON missing %s:\n%s", want, plJSON)
|
||||
}
|
||||
}
|
||||
if !strings.Contains(enJSON, `"label":"missing.label"`) || !strings.Contains(plJSON, `"label":"missing.label"`) {
|
||||
t.Fatalf("raw key fallback lost:\nen %s\npl %s", enJSON, plJSON)
|
||||
}
|
||||
after := mustCanonical(t, schema)
|
||||
if before != after {
|
||||
t.Fatalf("localization mutated the cached schema:\n%s\n%s", before, after)
|
||||
}
|
||||
|
||||
t.Run("parent and app locale", func(t *testing.T) {
|
||||
app := phrasebook.NewTranslator(formCatalog(t), phrasebook.Options{Locale: "pl", Fallback: "en"})
|
||||
parent := localizeJSON(t, schema, towel.WithLocale(context.Background(), "pl-PL,en;q=0.5"), app, nil)
|
||||
if !strings.Contains(parent, `"locale":"pl-PL"`) || !strings.Contains(parent, `"label":"Tytuł"`) {
|
||||
t.Fatalf("Accept-Language parent fallback = %s", parent)
|
||||
}
|
||||
fallback := localizeJSON(t, schema, context.Background(), app, nil)
|
||||
if !strings.Contains(fallback, `"locale":"pl"`) || !strings.Contains(fallback, `"name":"Formularz"`) {
|
||||
t.Fatalf("app.locale fallback = %s", fallback)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func TestFormSchemaDropdownOptions(t *testing.T) {
|
||||
schema := mustCompileForm(t, schemaController{model: "Widget"}, formConfig, optionMapYAML)
|
||||
tr := phrasebook.NewTranslator(formCatalog(t), phrasebook.Options{Locale: "pl", Fallback: "en"})
|
||||
got := localizeJSON(t, schema, towel.WithLocale(context.Background(), "pl"), tr, nil)
|
||||
vinyl := strings.Index(got, `{"value":"vinyl","label":"Stal"}`)
|
||||
two := strings.Index(got, `{"value":2,"label":"Dwa"}`)
|
||||
yes := strings.Index(got, `{"value":true,"label":"Yes"}`)
|
||||
if vinyl < 0 || two < 0 || yes < 0 || !(vinyl < two && two < yes) {
|
||||
t.Fatalf("option order or scalar type drifted: %s", got)
|
||||
}
|
||||
if strings.Contains(got, `"value":"2"`) || strings.Contains(got, `"value":"true"`) {
|
||||
t.Fatalf("option values became strings: %s", got)
|
||||
}
|
||||
|
||||
methodSchema := mustCompileForm(t, providerController{schemaController: schemaController{model: "Widget"}}, formConfig, methodFieldsYAML)
|
||||
methodJSON := localizeJSON(t, methodSchema, towel.WithLocale(context.Background(), "pl"), tr, providerController{})
|
||||
if !strings.Contains(methodJSON, `{"value":"vinyl","label":"Stal"}`) || !strings.Contains(methodJSON, `{"value":"cd","label":"Drewno"}`) {
|
||||
t.Fatalf("method options = %s", methodJSON)
|
||||
}
|
||||
if strings.Contains(methodJSON, "getFormatOptions") {
|
||||
t.Fatalf("method name leaked into the response: %s", methodJSON)
|
||||
}
|
||||
source := mustCanonical(t, methodSchema)
|
||||
if strings.Contains(source, "getFormatOptions") {
|
||||
t.Fatalf("cached schema stored the method name in JSON: %s", source)
|
||||
}
|
||||
|
||||
modelSchema := mustCompileForm(t, sourceController{schemaController: schemaController{model: "Widget"}, rec: modelOptions{}}, formConfig, "fields:\n format:\n type: dropdown\n options: getFormatOptions\n")
|
||||
modelJSON := localizeJSON(t, modelSchema, towel.WithLocale(context.Background(), "pl"), tr, modelOptions{})
|
||||
if !strings.Contains(modelJSON, `{"value":"lp","label":"Stal"}`) {
|
||||
t.Fatalf("model provider options = %s", modelJSON)
|
||||
}
|
||||
|
||||
for _, method := range []string{"getFormatOptions", "GetFormatOptions"} {
|
||||
_, err := CompileForm("acme.demo", schemaController{model: "Widget"}, formFS(formConfig, "fields:\n format:\n type: dropdown\n options: "+method+"\n"))
|
||||
if err == nil || !strings.Contains(err.Error(), method) || !strings.Contains(err.Error(), "acme.demo.widgets") || !strings.Contains(err.Error(), "models/widget/fields.yaml") {
|
||||
t.Fatalf("method %s err = %v", method, err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestFormSchemaLocaleIsolation(t *testing.T) {
|
||||
schema := mustCompileForm(t, schemaController{model: "Widget"}, strings.Replace(formConfig, "name: demo.form", "name: acme.demo::lang.form", 1), localizedFieldsYAML)
|
||||
before := mustCanonical(t, schema)
|
||||
tr := phrasebook.NewTranslator(formCatalog(t), phrasebook.Options{Locale: "en", Fallback: "en"})
|
||||
enWant := localizeJSON(t, schema, towel.WithLocale(context.Background(), "en"), tr, nil)
|
||||
plWant := localizeJSON(t, schema, towel.WithLocale(context.Background(), "pl"), tr, nil)
|
||||
|
||||
var wg sync.WaitGroup
|
||||
errCh := make(chan string, 32)
|
||||
for i := 0; i < 16; i++ {
|
||||
wg.Add(2)
|
||||
go func() {
|
||||
defer wg.Done()
|
||||
got := localizeJSON(t, schema, towel.WithLocale(context.Background(), "en"), tr, nil)
|
||||
if got != enWant {
|
||||
errCh <- "en drifted: " + got
|
||||
}
|
||||
}()
|
||||
go func() {
|
||||
defer wg.Done()
|
||||
got := localizeJSON(t, schema, towel.WithLocale(context.Background(), "pl"), tr, nil)
|
||||
if got != plWant {
|
||||
errCh <- "pl drifted: " + got
|
||||
}
|
||||
}()
|
||||
}
|
||||
wg.Wait()
|
||||
close(errCh)
|
||||
for msg := range errCh {
|
||||
t.Fatal(msg)
|
||||
}
|
||||
if after := mustCanonical(t, schema); after != before {
|
||||
t.Fatal("concurrent localization mutated the cache")
|
||||
}
|
||||
}
|
||||
|
||||
const localizedFieldsYAML = `fields:
|
||||
title:
|
||||
label: acme.demo::lang.title
|
||||
comment: acme.demo::lang.comment
|
||||
tab: acme.demo::lang.tab
|
||||
emptyOption: acme.demo::lang.empty
|
||||
type: dropdown
|
||||
options:
|
||||
vinyl: acme.demo::lang.vinyl
|
||||
note:
|
||||
label: missing.label
|
||||
type: text
|
||||
`
|
||||
|
||||
const optionMapYAML = `fields:
|
||||
format:
|
||||
label: acme.demo::lang.title
|
||||
type: dropdown
|
||||
emptyOption: acme.demo::lang.empty
|
||||
options:
|
||||
vinyl: acme.demo::lang.vinyl
|
||||
2: acme.demo::lang.two
|
||||
true: "Yes"
|
||||
`
|
||||
|
||||
const methodFieldsYAML = `fields:
|
||||
Format:
|
||||
label: acme.demo::lang.title
|
||||
type: dropdown
|
||||
options: getFormatOptions
|
||||
`
|
||||
|
||||
func formCatalog(t *testing.T) *phrasebook.Catalog {
|
||||
t.Helper()
|
||||
cat := phrasebook.NewCatalog()
|
||||
err := cat.Load("acme.demo", fstest.MapFS{
|
||||
"lang/en/lang.yaml": &fstest.MapFile{Data: []byte("form: Form\ntitle: Title\ncomment: Comment\ntab: Tab\nempty: None\nvinyl: Vinyl\ncd: CD\ntwo: Two\n")},
|
||||
"lang/pl/lang.yaml": &fstest.MapFile{Data: []byte("form: Formularz\ntitle: Tytuł\ncomment: Komentarz\ntab: Zakładka\nempty: Brak\nvinyl: Stal\ncd: Drewno\ntwo: Dwa\n")},
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("catalog: %v", err)
|
||||
}
|
||||
return cat
|
||||
}
|
||||
|
||||
func mustCompileForm(t *testing.T, ctl pact.AdminController, config, fields string) *FormSchema {
|
||||
t.Helper()
|
||||
schema, err := CompileForm("acme.demo", ctl, formFS(config, fields))
|
||||
if err != nil {
|
||||
t.Fatalf("compile: %v", err)
|
||||
}
|
||||
return schema
|
||||
}
|
||||
|
||||
func mustCanonical(t *testing.T, schema *FormSchema) string {
|
||||
t.Helper()
|
||||
raw, err := schema.CanonicalJSON()
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return string(raw)
|
||||
}
|
||||
|
||||
func localizeJSON(t *testing.T, schema *FormSchema, ctx context.Context, tr *phrasebook.Translator, provider pact.DropdownOptionsProvider) string {
|
||||
t.Helper()
|
||||
view, err := schema.Localize(ctx, tr, provider)
|
||||
if err != nil {
|
||||
t.Fatalf("localize: %v", err)
|
||||
}
|
||||
raw, err := view.CanonicalJSON()
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
var buf bytes.Buffer
|
||||
if err := json.Compact(&buf, raw); err != nil {
|
||||
t.Fatalf("compact: %v\n%s", err, raw)
|
||||
}
|
||||
return buf.String()
|
||||
}
|
||||
|
||||
type providerController struct{ schemaController }
|
||||
|
||||
func (providerController) DropdownOptions(field string) []pact.Option {
|
||||
if field != "Format" {
|
||||
return nil
|
||||
}
|
||||
return []pact.Option{
|
||||
{Value: "vinyl", Label: "acme.demo::lang.vinyl"},
|
||||
{Value: "cd", Label: "acme.demo::lang.cd"},
|
||||
}
|
||||
}
|
||||
|
||||
type sourceController struct {
|
||||
schemaController
|
||||
rec any
|
||||
}
|
||||
|
||||
func (s sourceController) NewRecord() any { return s.rec }
|
||||
|
||||
type modelOptions struct{}
|
||||
|
||||
func (modelOptions) DropdownOptions(field string) []pact.Option {
|
||||
if field != "format" {
|
||||
return nil
|
||||
}
|
||||
return []pact.Option{{Value: "lp", Label: "acme.demo::lang.vinyl"}}
|
||||
}
|
||||
|
||||
var _ party.Plugin = formPlugin{}
|
||||
778
modules/cabana/http.go
Normal file
778
modules/cabana/http.go
Normal file
@@ -0,0 +1,778 @@
|
||||
package cabana
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
"net/http"
|
||||
"reflect"
|
||||
"strconv"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"git.golem15.com/golem15/summercms/modules/backpack"
|
||||
"git.golem15.com/golem15/summercms/modules/boardwalk"
|
||||
"git.golem15.com/golem15/summercms/modules/bouncer"
|
||||
"git.golem15.com/golem15/summercms/modules/pact"
|
||||
"git.golem15.com/golem15/summercms/modules/party"
|
||||
"git.golem15.com/golem15/summercms/modules/phrasebook"
|
||||
"gorm.io/gorm"
|
||||
)
|
||||
|
||||
// Routes is the raw admin API and SPA mounted by surf.BuildRouter. Prefix is
|
||||
// the normalized backend.uri every admin route lives under.
|
||||
type Routes struct {
|
||||
Middleware pact.Middleware
|
||||
Mount func(r pact.Router)
|
||||
Prefix string
|
||||
}
|
||||
|
||||
type service struct {
|
||||
app *backpack.App
|
||||
reg *Registry
|
||||
secret string
|
||||
ttl time.Duration
|
||||
refreshTTL time.Duration
|
||||
grace time.Duration
|
||||
bcryptCost int
|
||||
loginMax int
|
||||
loginDecay int
|
||||
issuer string
|
||||
bl bouncer.BlacklistStore
|
||||
users bouncer.UserProvider // the backend guard's provider, reused by refresh
|
||||
prefix string
|
||||
spa http.Handler
|
||||
// insecureCookie drops Secure from the admin cookie (backend.cookie_secure
|
||||
// false, development only); the zero value keeps the cookie Secure.
|
||||
insecureCookie bool
|
||||
}
|
||||
|
||||
// adminPrefix returns the mount path; a zero service uses the default.
|
||||
func (s *service) adminPrefix() string {
|
||||
if s == nil || s.prefix == "" {
|
||||
return DefaultAdminPrefix
|
||||
}
|
||||
return s.prefix
|
||||
}
|
||||
|
||||
// apiBase is the admin API root: the prefix plus /api/v1 (D-03).
|
||||
func (s *service) apiBase() string {
|
||||
return s.adminPrefix() + adminAPIVersion
|
||||
}
|
||||
|
||||
// Activate compiles admin controllers and, when any exist, requires
|
||||
// admin.jwt.secret. No controllers means no admin routes and no secret check.
|
||||
func Activate(app *backpack.App, plugins []party.Plugin) (*Routes, error) {
|
||||
items, err := collectControllers(plugins)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if len(items) == 0 {
|
||||
return nil, nil
|
||||
}
|
||||
if err := checkReservedSegments(items); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
secret, err := adminSecret(app)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
prefix, err := AdminPrefix(app)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
secureCookie, err := adminCookieSecure(app)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
reg, err := compileRegistry(items)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if err := compileContributions(reg, plugins); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if app == nil {
|
||||
return nil, errors.New("cabana: app is nil")
|
||||
}
|
||||
if tr, ok := app.Lookup[*phrasebook.Translator](); ok && tr != nil {
|
||||
if err := validateMessageKeys(reg, tr); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
guards, ok := app.Lookup[*bouncer.Registry]()
|
||||
if !ok || guards == nil {
|
||||
guards = bouncer.NewRegistry()
|
||||
if err := app.Publish(guards); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
bl := adminBlacklist(app)
|
||||
users := lazyBackendUsers{app: app, reg: reg}
|
||||
guard := bouncer.NewBackendJWTGuard(secret, users, bl, writeUnauthenticated, AdminCookieName)
|
||||
if _, err := guards.Middleware("backend"); err != nil {
|
||||
if err := guards.Register("summercms.cabana", "backend", guard); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
mw, err := guards.Middleware("backend")
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
loginMax, loginDecay := adminLoginWindow(app)
|
||||
svc := &service{
|
||||
app: app,
|
||||
reg: reg,
|
||||
secret: secret,
|
||||
ttl: adminTTL(app),
|
||||
refreshTTL: adminRefreshTTL(app),
|
||||
grace: adminGrace(app),
|
||||
bcryptCost: adminBcryptCost(app),
|
||||
loginMax: loginMax,
|
||||
loginDecay: loginDecay,
|
||||
issuer: adminIssuer(app, prefix),
|
||||
bl: bl,
|
||||
users: users,
|
||||
prefix: prefix,
|
||||
|
||||
insecureCookie: !secureCookie,
|
||||
}
|
||||
spa, err := boardwalk.Handler(prefix, http.HandlerFunc(writeNotFound))
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("cabana: admin SPA: %w", err)
|
||||
}
|
||||
svc.spa = spa
|
||||
return &Routes{Middleware: mw, Mount: svc.mount, Prefix: prefix}, nil
|
||||
}
|
||||
|
||||
func writeNotFound(w http.ResponseWriter, _ *http.Request) {
|
||||
WriteError(w, http.StatusNotFound, "not_found", msgNotFound)
|
||||
}
|
||||
|
||||
// serveSPA answers GET {prefix} and GET {prefix}/{path...} from the embedded
|
||||
// build. API paths that no route matched fall through to it and receive the
|
||||
// D-10 not_found envelope, never index.html.
|
||||
func (s *service) serveSPA(w http.ResponseWriter, r *http.Request) {
|
||||
if s == nil || s.spa == nil {
|
||||
writeNotFound(w, r)
|
||||
return
|
||||
}
|
||||
s.spa.ServeHTTP(w, r)
|
||||
}
|
||||
|
||||
func writeUnauthenticated(w http.ResponseWriter, _ error) {
|
||||
WriteError(w, http.StatusUnauthorized, "unauthenticated", msgUnauthenticated)
|
||||
}
|
||||
|
||||
type lazyBackendUsers struct {
|
||||
app *backpack.App
|
||||
reg *Registry
|
||||
}
|
||||
|
||||
func (p lazyBackendUsers) FindByID(ctx context.Context, id uint) (*bouncer.Principal, error) {
|
||||
if p.app == nil {
|
||||
return nil, errors.New("cabana: database is not configured")
|
||||
}
|
||||
db, ok := p.app.Lookup[*gorm.DB]()
|
||||
if !ok || db == nil {
|
||||
return nil, errors.New("cabana: database is not configured")
|
||||
}
|
||||
return (BackendUsers{DB: db, Registry: p.reg}).FindByID(ctx, id)
|
||||
}
|
||||
|
||||
func (s *service) mount(r pact.Router) {
|
||||
throttle := fmt.Sprintf("throttle:%d,%d", s.loginMax, s.loginDecay)
|
||||
api := s.apiBase()
|
||||
r.GroupRaw(api+"/auth", nil, func(g pact.Router) {
|
||||
// Login is exempt from the CSRF header: without it the response is a
|
||||
// Bearer body and no cookie is set, so a cross-site post gains nothing.
|
||||
g.Post("/login", s.login, throttle)
|
||||
g.Post("/refresh", requireAjax(s.refresh))
|
||||
})
|
||||
// The string bundle is public: the login screen needs it before auth.
|
||||
r.GroupRaw(api, nil, func(g pact.Router) {
|
||||
g.Get("/lang", s.langBundle)
|
||||
})
|
||||
r.GroupRaw(api, []string{"backend"}, func(g pact.Router) {
|
||||
g.Post("/auth/logout", requireAjax(s.logout))
|
||||
g.Get("/auth/me", s.me)
|
||||
g.Get("/navigation", s.navigation)
|
||||
g.Get("/settings", s.settingsList)
|
||||
g.Get("/settings/{code}/schema", s.settingsSchema)
|
||||
constrainSetting(g)
|
||||
g.Get("/settings/{code}", s.settingsGet)
|
||||
constrainSetting(g)
|
||||
g.Put("/settings/{code}", requireAjax(s.settingsPut))
|
||||
constrainSetting(g)
|
||||
g.Get("/{vendor}/{plugin}/{controller}/schema/list", s.listSchema)
|
||||
constrainController(g)
|
||||
g.Get("/{vendor}/{plugin}/{controller}/schema/form", s.formSchema)
|
||||
constrainController(g)
|
||||
g.Get("/{vendor}/{plugin}/{controller}/schema/relation/{name}", s.relationSchema)
|
||||
constrainRelation(g)
|
||||
g.Get("/{vendor}/{plugin}/{controller}", s.list)
|
||||
constrainController(g)
|
||||
g.Post("/{vendor}/{plugin}/{controller}", requireAjax(s.create))
|
||||
constrainController(g)
|
||||
g.Post("/{vendor}/{plugin}/{controller}/bulk-delete", requireAjax(s.bulkDelete))
|
||||
constrainController(g)
|
||||
g.Get("/{vendor}/{plugin}/{controller}/{id}", s.show)
|
||||
constrainController(g)
|
||||
g.Put("/{vendor}/{plugin}/{controller}/{id}", requireAjax(s.update))
|
||||
constrainController(g)
|
||||
g.Delete("/{vendor}/{plugin}/{controller}/{id}", requireAjax(s.deleteRecord))
|
||||
constrainController(g)
|
||||
// Six-segment GET routes share one pattern: ServeMux rejects the
|
||||
// relation list next to the field options route (neither is more
|
||||
// specific), so nestedGet dispatches on the literal segments.
|
||||
g.Get("/{vendor}/{plugin}/{controller}/{id}/{segment}/{name}", s.nestedGet)
|
||||
constrainNested(g)
|
||||
g.Get("/{vendor}/{plugin}/{controller}/{id}/relations/{name}/candidates", s.relationCandidates)
|
||||
constrainRelation(g)
|
||||
g.Post("/{vendor}/{plugin}/{controller}/{id}/relations/{name}/link", requireAjax(s.relationLink))
|
||||
constrainRelation(g)
|
||||
g.Post("/{vendor}/{plugin}/{controller}/{id}/relations/{name}/unlink", requireAjax(s.relationUnlink))
|
||||
constrainRelation(g)
|
||||
})
|
||||
// The SPA shell: public, no guard. ServeMux prefers every API pattern
|
||||
// above over the {path...} wildcard.
|
||||
r.GroupRaw(s.adminPrefix(), nil, func(g pact.Router) {
|
||||
g.Get("", s.serveSPA)
|
||||
g.Get("/{path...}", s.serveSPA)
|
||||
})
|
||||
}
|
||||
|
||||
func constrainController(g pact.Router) {
|
||||
g.Where("vendor", "[A-Za-z0-9_-]+")
|
||||
g.Where("plugin", "[A-Za-z0-9_-]+")
|
||||
g.Where("controller", "[A-Za-z0-9_-]+")
|
||||
}
|
||||
|
||||
func constrainRelation(g pact.Router) {
|
||||
constrainController(g)
|
||||
g.Where("name", "[A-Za-z_][A-Za-z0-9_]*")
|
||||
}
|
||||
|
||||
func constrainNested(g pact.Router) {
|
||||
constrainController(g)
|
||||
g.Where("segment", "[A-Za-z_][A-Za-z0-9_]*")
|
||||
g.Where("name", "[A-Za-z_][A-Za-z0-9_]*")
|
||||
}
|
||||
|
||||
// nestedGet serves the logical routes
|
||||
//
|
||||
// GET /{vendor}/{plugin}/{controller}/{id}/relations/{name}
|
||||
// GET /{vendor}/{plugin}/{controller}/fields/{field}/options
|
||||
// GET /{vendor}/{plugin}/{controller}/filters/{scope}/options
|
||||
//
|
||||
// A numeric id never equals a literal segment, so the dispatch is unambiguous.
|
||||
// Anything else is the D-10 not_found envelope, as an unmatched API path.
|
||||
func (s *service) nestedGet(w http.ResponseWriter, r *http.Request) {
|
||||
id, segment, name := r.PathValue("id"), r.PathValue("segment"), r.PathValue("name")
|
||||
switch {
|
||||
case id == "fields" && name == "options":
|
||||
r.SetPathValue("field", segment)
|
||||
s.fieldOptions(w, r)
|
||||
case id == "filters" && name == "options":
|
||||
r.SetPathValue("scope", segment)
|
||||
s.filterOptions(w, r)
|
||||
case segment == "relations":
|
||||
s.relationLinked(w, r)
|
||||
default:
|
||||
writeNotFound(w, r)
|
||||
}
|
||||
}
|
||||
|
||||
func constrainSetting(g pact.Router) {
|
||||
g.Where("code", "[A-Za-z_][A-Za-z0-9_-]*")
|
||||
}
|
||||
|
||||
func (s *service) navigation(w http.ResponseWriter, r *http.Request) {
|
||||
principal, ok := bouncer.User(r.Context())
|
||||
if !ok || principal == nil || !principal.Backend {
|
||||
WriteError(w, http.StatusUnauthorized, "unauthenticated", msgUnauthenticated)
|
||||
return
|
||||
}
|
||||
navigation, _ := s.reg.Metadata(r.Context(), principal, s.translator())
|
||||
WriteData(w, http.StatusOK, navigation, map[string]any{"locale": schemaLocale(r.Context(), s.translator())})
|
||||
}
|
||||
|
||||
func (s *service) settingsList(w http.ResponseWriter, r *http.Request) {
|
||||
principal, ok := bouncer.User(r.Context())
|
||||
if !ok || principal == nil || !principal.Backend {
|
||||
WriteError(w, http.StatusUnauthorized, "unauthenticated", msgUnauthenticated)
|
||||
return
|
||||
}
|
||||
_, settings := s.reg.Metadata(r.Context(), principal, s.translator())
|
||||
WriteData(w, http.StatusOK, settings, map[string]any{"locale": schemaLocale(r.Context(), s.translator())})
|
||||
}
|
||||
|
||||
func (s *service) settingsSchema(w http.ResponseWriter, r *http.Request) {
|
||||
s.protectSetting(w, r, func(setting *CompiledSetting) {
|
||||
view, err := setting.Form.Localize(r.Context(), s.translator(), nil)
|
||||
if err != nil {
|
||||
WriteError(w, http.StatusInternalServerError, "error", msgServerError)
|
||||
return
|
||||
}
|
||||
WriteData(w, http.StatusOK, view, map[string]any{"locale": view.Meta.Locale})
|
||||
})
|
||||
}
|
||||
|
||||
func (s *service) settingsGet(w http.ResponseWriter, r *http.Request) {
|
||||
s.protectSetting(w, r, func(setting *CompiledSetting) {
|
||||
db, err := s.db()
|
||||
if err != nil {
|
||||
WriteError(w, http.StatusInternalServerError, "error", msgServerError)
|
||||
return
|
||||
}
|
||||
result, err := (SettingsService{DB: db}).Get(r.Context(), setting)
|
||||
if err != nil {
|
||||
writeCRUDError(w, err)
|
||||
return
|
||||
}
|
||||
WriteData(w, http.StatusOK, result, nil)
|
||||
})
|
||||
}
|
||||
|
||||
func (s *service) settingsPut(w http.ResponseWriter, r *http.Request) {
|
||||
s.protectSetting(w, r, func(setting *CompiledSetting) {
|
||||
body, err := decodeObject(r)
|
||||
if err != nil {
|
||||
writeCRUDError(w, err)
|
||||
return
|
||||
}
|
||||
db, err := s.db()
|
||||
if err != nil {
|
||||
WriteError(w, http.StatusInternalServerError, "error", msgServerError)
|
||||
return
|
||||
}
|
||||
result, err := (SettingsService{DB: db}).Put(r.Context(), setting, body)
|
||||
if err != nil {
|
||||
writeCRUDError(w, err)
|
||||
return
|
||||
}
|
||||
WriteData(w, http.StatusOK, result, nil)
|
||||
})
|
||||
}
|
||||
|
||||
func (s *service) protectSetting(w http.ResponseWriter, r *http.Request, fn func(*CompiledSetting)) {
|
||||
principal, ok := bouncer.User(r.Context())
|
||||
if !ok || principal == nil || !principal.Backend {
|
||||
WriteError(w, http.StatusUnauthorized, "unauthenticated", msgUnauthenticated)
|
||||
return
|
||||
}
|
||||
setting, exists := s.reg.Setting(r.PathValue("code"))
|
||||
if !exists {
|
||||
WriteError(w, http.StatusNotFound, "not_found", msgNotFound)
|
||||
return
|
||||
}
|
||||
if !Allows(principal, setting.Item.Permissions) {
|
||||
WriteError(w, http.StatusForbidden, "forbidden", msgForbidden)
|
||||
return
|
||||
}
|
||||
fn(setting)
|
||||
}
|
||||
|
||||
func (s *service) relationSchema(w http.ResponseWriter, r *http.Request) {
|
||||
s.protect(w, r, func(cc *CompiledController) {
|
||||
cr, err := relationOf(cc, r.PathValue("name"))
|
||||
if err != nil {
|
||||
writeCRUDError(w, err)
|
||||
return
|
||||
}
|
||||
tr := s.translator()
|
||||
view := cr.Schema.Localize(r.Context(), tr)
|
||||
meta := map[string]any{}
|
||||
if locale := schemaLocale(r.Context(), tr); locale != "" {
|
||||
meta["locale"] = locale
|
||||
}
|
||||
WriteData(w, http.StatusOK, view, meta)
|
||||
})
|
||||
}
|
||||
|
||||
func relationQueryFromRequest(r *http.Request) RelationQuery {
|
||||
q := r.URL.Query()
|
||||
return RelationQuery{Search: q.Get("search"), Sort: q.Get("sort"), Dir: q.Get("dir"), Page: q.Get("page"), PerPage: q.Get("per_page")}
|
||||
}
|
||||
|
||||
func (s *service) relationLinked(w http.ResponseWriter, r *http.Request) {
|
||||
s.relationList(w, r, false)
|
||||
}
|
||||
|
||||
func (s *service) relationCandidates(w http.ResponseWriter, r *http.Request) {
|
||||
s.relationList(w, r, true)
|
||||
}
|
||||
|
||||
func (s *service) relationList(w http.ResponseWriter, r *http.Request, candidates bool) {
|
||||
s.protect(w, r, func(cc *CompiledController) {
|
||||
id, err := pathID(r)
|
||||
if err != nil {
|
||||
writeCRUDError(w, err)
|
||||
return
|
||||
}
|
||||
svc, err := s.relations()
|
||||
if err != nil {
|
||||
WriteError(w, http.StatusInternalServerError, "error", msgServerError)
|
||||
return
|
||||
}
|
||||
var result *RelationResult
|
||||
if candidates {
|
||||
result, err = svc.Candidates(r.Context(), cc, r.PathValue("name"), id, relationQueryFromRequest(r))
|
||||
} else {
|
||||
result, err = svc.Linked(r.Context(), cc, r.PathValue("name"), id, relationQueryFromRequest(r))
|
||||
}
|
||||
if err != nil {
|
||||
writeCRUDError(w, err)
|
||||
return
|
||||
}
|
||||
WriteData(w, http.StatusOK, result.Data, map[string]any{"page": result.Meta.Page, "per_page": result.Meta.PerPage, "total": result.Meta.Total, "last_page": result.Meta.LastPage})
|
||||
})
|
||||
}
|
||||
|
||||
func (s *service) relationLink(w http.ResponseWriter, r *http.Request) {
|
||||
s.relationMutation(w, r, true)
|
||||
}
|
||||
|
||||
func (s *service) relationUnlink(w http.ResponseWriter, r *http.Request) {
|
||||
s.relationMutation(w, r, false)
|
||||
}
|
||||
|
||||
func (s *service) relationMutation(w http.ResponseWriter, r *http.Request, link bool) {
|
||||
s.protect(w, r, func(cc *CompiledController) {
|
||||
id, err := pathID(r)
|
||||
if err != nil {
|
||||
writeCRUDError(w, err)
|
||||
return
|
||||
}
|
||||
in, err := decodeRelationMutation(r)
|
||||
if err != nil {
|
||||
writeCRUDError(w, err)
|
||||
return
|
||||
}
|
||||
svc, err := s.relations()
|
||||
if err != nil {
|
||||
WriteError(w, http.StatusInternalServerError, "error", msgServerError)
|
||||
return
|
||||
}
|
||||
var result RelationMutationResult
|
||||
if link {
|
||||
result, err = svc.Link(r.Context(), cc, r.PathValue("name"), id, in)
|
||||
} else {
|
||||
result, err = svc.Unlink(r.Context(), cc, r.PathValue("name"), id, in)
|
||||
}
|
||||
if err != nil {
|
||||
writeCRUDError(w, err)
|
||||
return
|
||||
}
|
||||
WriteData(w, http.StatusOK, result, nil)
|
||||
})
|
||||
}
|
||||
|
||||
func decodeRelationMutation(r *http.Request) (RelationMutationInput, error) {
|
||||
dec := json.NewDecoder(r.Body)
|
||||
dec.UseNumber()
|
||||
dec.DisallowUnknownFields()
|
||||
var in RelationMutationInput
|
||||
if err := dec.Decode(&in); err != nil {
|
||||
return RelationMutationInput{}, relationInvalid("body", "The request body is invalid.")
|
||||
}
|
||||
var trailing any
|
||||
if err := dec.Decode(&trailing); err != io.EOF {
|
||||
return RelationMutationInput{}, relationInvalid("body", "The request body is invalid.")
|
||||
}
|
||||
return in, nil
|
||||
}
|
||||
|
||||
func (s *service) relations() (RelationService, error) {
|
||||
db, err := s.db()
|
||||
if err != nil {
|
||||
return RelationService{}, err
|
||||
}
|
||||
return RelationService{DB: db}, nil
|
||||
}
|
||||
|
||||
func (s *service) formSchema(w http.ResponseWriter, r *http.Request) {
|
||||
s.protect(w, r, func(cc *CompiledController) {
|
||||
if cc.Form == nil {
|
||||
WriteError(w, http.StatusNotFound, "not_found", msgNotFound)
|
||||
return
|
||||
}
|
||||
view, err := cc.Form.Localize(r.Context(), s.translator(), dropdownProvider(cc.Controller))
|
||||
if err != nil {
|
||||
WriteError(w, http.StatusInternalServerError, "error", msgServerError)
|
||||
return
|
||||
}
|
||||
meta := map[string]any{}
|
||||
if view.Meta.Locale != "" {
|
||||
meta["locale"] = view.Meta.Locale
|
||||
}
|
||||
WriteData(w, http.StatusOK, view, meta)
|
||||
})
|
||||
}
|
||||
|
||||
func (s *service) listSchema(w http.ResponseWriter, r *http.Request) {
|
||||
s.protect(w, r, func(cc *CompiledController) {
|
||||
schema := cc.List
|
||||
if schema == nil {
|
||||
schema = &ListSchema{}
|
||||
}
|
||||
view, err := schema.Localize(r.Context(), s.translator())
|
||||
if err != nil {
|
||||
WriteError(w, http.StatusInternalServerError, "error", msgServerError)
|
||||
return
|
||||
}
|
||||
meta := map[string]any{}
|
||||
if view.Meta != nil {
|
||||
meta["locale"] = view.Meta.Locale
|
||||
}
|
||||
WriteData(w, http.StatusOK, view, meta)
|
||||
})
|
||||
}
|
||||
|
||||
func (s *service) translator() *phrasebook.Translator {
|
||||
if s == nil || s.app == nil {
|
||||
return nil
|
||||
}
|
||||
tr, ok := s.app.Lookup[*phrasebook.Translator]()
|
||||
if !ok {
|
||||
return nil
|
||||
}
|
||||
return tr
|
||||
}
|
||||
|
||||
func (s *service) show(w http.ResponseWriter, r *http.Request) {
|
||||
s.protect(w, r, func(cc *CompiledController) {
|
||||
id, err := pathID(r)
|
||||
if err != nil {
|
||||
writeCRUDError(w, err)
|
||||
return
|
||||
}
|
||||
svc, err := s.crud()
|
||||
if err != nil {
|
||||
WriteError(w, http.StatusInternalServerError, "error", msgServerError)
|
||||
return
|
||||
}
|
||||
rec, err := svc.ShowRecord(r.Context(), cc, id)
|
||||
if err != nil {
|
||||
writeCRUDError(w, err)
|
||||
return
|
||||
}
|
||||
WriteData(w, http.StatusOK, rec.Data, rec.Meta)
|
||||
})
|
||||
}
|
||||
|
||||
func (s *service) create(w http.ResponseWriter, r *http.Request) {
|
||||
s.protect(w, r, func(cc *CompiledController) {
|
||||
body, err := decodeObject(r)
|
||||
if err != nil {
|
||||
writeCRUDError(w, err)
|
||||
return
|
||||
}
|
||||
svc, err := s.crud()
|
||||
if err != nil {
|
||||
WriteError(w, http.StatusInternalServerError, "error", msgServerError)
|
||||
return
|
||||
}
|
||||
rec, err := svc.CreateRecord(r.Context(), cc, RecordInput{Body: body})
|
||||
if err != nil {
|
||||
writeCRUDError(w, err)
|
||||
return
|
||||
}
|
||||
WriteData(w, http.StatusCreated, rec.Data, rec.Meta)
|
||||
})
|
||||
}
|
||||
|
||||
func (s *service) update(w http.ResponseWriter, r *http.Request) {
|
||||
s.protect(w, r, func(cc *CompiledController) {
|
||||
id, err := pathID(r)
|
||||
if err != nil {
|
||||
writeCRUDError(w, err)
|
||||
return
|
||||
}
|
||||
body, err := decodeObject(r)
|
||||
if err != nil {
|
||||
writeCRUDError(w, err)
|
||||
return
|
||||
}
|
||||
svc, err := s.crud()
|
||||
if err != nil {
|
||||
WriteError(w, http.StatusInternalServerError, "error", msgServerError)
|
||||
return
|
||||
}
|
||||
rec, err := svc.UpdateRecord(r.Context(), cc, id, RecordInput{Body: body})
|
||||
if err != nil {
|
||||
writeCRUDError(w, err)
|
||||
return
|
||||
}
|
||||
WriteData(w, http.StatusOK, rec.Data, rec.Meta)
|
||||
})
|
||||
}
|
||||
|
||||
func (s *service) bulkDelete(w http.ResponseWriter, r *http.Request) {
|
||||
s.protect(w, r, func(cc *CompiledController) {
|
||||
in, err := decodeBulk(r)
|
||||
if err != nil {
|
||||
writeCRUDError(w, err)
|
||||
return
|
||||
}
|
||||
svc, err := s.crud()
|
||||
if err != nil {
|
||||
WriteError(w, http.StatusInternalServerError, "error", msgServerError)
|
||||
return
|
||||
}
|
||||
result, err := svc.BulkDelete(r.Context(), cc, in)
|
||||
if err != nil {
|
||||
writeCRUDError(w, err)
|
||||
return
|
||||
}
|
||||
WriteData(w, http.StatusOK, result, nil)
|
||||
})
|
||||
}
|
||||
|
||||
func decodeBulk(r *http.Request) (BulkDeleteInput, error) {
|
||||
dec := json.NewDecoder(r.Body)
|
||||
dec.UseNumber()
|
||||
var in BulkDeleteInput
|
||||
if err := dec.Decode(&in); err != nil {
|
||||
return BulkDeleteInput{}, &ValidationError{Details: map[string]any{"body": []string{"The request body is invalid."}}}
|
||||
}
|
||||
return in, nil
|
||||
}
|
||||
|
||||
func (s *service) deleteRecord(w http.ResponseWriter, r *http.Request) {
|
||||
s.protect(w, r, func(cc *CompiledController) {
|
||||
id, err := pathID(r)
|
||||
if err != nil {
|
||||
writeCRUDError(w, err)
|
||||
return
|
||||
}
|
||||
svc, err := s.crud()
|
||||
if err != nil {
|
||||
WriteError(w, http.StatusInternalServerError, "error", msgServerError)
|
||||
return
|
||||
}
|
||||
result, err := svc.Delete(r.Context(), cc, id)
|
||||
if err != nil {
|
||||
writeCRUDError(w, err)
|
||||
return
|
||||
}
|
||||
WriteData(w, http.StatusOK, result, nil)
|
||||
})
|
||||
}
|
||||
|
||||
func (s *service) crud() (CRUDService, error) {
|
||||
db, err := s.db()
|
||||
if err != nil {
|
||||
return CRUDService{}, err
|
||||
}
|
||||
return CRUDService{DB: db}, nil
|
||||
}
|
||||
|
||||
func (s *service) list(w http.ResponseWriter, r *http.Request) {
|
||||
s.protect(w, r, func(cc *CompiledController) {
|
||||
db, err := s.db()
|
||||
if err != nil {
|
||||
WriteError(w, http.StatusInternalServerError, "error", msgServerError)
|
||||
return
|
||||
}
|
||||
result, err := ExecuteList(r.Context(), db, cc, listQueryFromRequest(r))
|
||||
var invalid *ListValidationError
|
||||
if errors.As(err, &invalid) {
|
||||
WriteErrorDetails(w, http.StatusUnprocessableEntity, "validation_failed", "Validation failed", invalid.Details)
|
||||
return
|
||||
}
|
||||
if err != nil {
|
||||
WriteError(w, http.StatusInternalServerError, "error", msgServerError)
|
||||
return
|
||||
}
|
||||
WriteData(w, http.StatusOK, result.Data, map[string]any{
|
||||
"page": result.Meta.Page,
|
||||
"per_page": result.Meta.PerPage,
|
||||
"total": result.Meta.Total,
|
||||
"last_page": result.Meta.LastPage,
|
||||
})
|
||||
})
|
||||
}
|
||||
|
||||
// protect runs after the backend guard. Controller lookup precedes permission
|
||||
// evaluation, and schema/SQL run only inside fn.
|
||||
func (s *service) protect(w http.ResponseWriter, r *http.Request, fn func(*CompiledController)) {
|
||||
id := r.PathValue("vendor") + "." + r.PathValue("plugin") + "." + r.PathValue("controller")
|
||||
cc, ok := s.reg.Get(id)
|
||||
if !ok {
|
||||
WriteError(w, http.StatusNotFound, "not_found", msgNotFound)
|
||||
return
|
||||
}
|
||||
principal, _ := bouncer.User(r.Context())
|
||||
if principal == nil || !principal.Backend {
|
||||
WriteError(w, http.StatusUnauthorized, "unauthenticated", msgUnauthenticated)
|
||||
return
|
||||
}
|
||||
if !Allows(principal, requiredOf(cc.Controller)) {
|
||||
s.logAuth(r, "denied", principal.ID)
|
||||
WriteError(w, http.StatusForbidden, "forbidden", msgForbidden)
|
||||
return
|
||||
}
|
||||
fn(cc)
|
||||
}
|
||||
|
||||
func projectRow(row any, controller pact.AdminController, cols []ListColumn) map[string]any {
|
||||
v := reflect.ValueOf(row)
|
||||
for v.Kind() == reflect.Pointer {
|
||||
if v.IsNil() {
|
||||
return map[string]any{}
|
||||
}
|
||||
v = v.Elem()
|
||||
}
|
||||
out := make(map[string]any, len(cols)+1)
|
||||
if id := fieldByColumn(v, "id"); id.IsValid() && id.CanInterface() {
|
||||
out["id"] = id.Interface()
|
||||
}
|
||||
for _, col := range cols {
|
||||
if col.Relation != "" {
|
||||
if value, ok := relatedSelect(v, controller, col); ok {
|
||||
out[col.Key] = value
|
||||
}
|
||||
continue
|
||||
}
|
||||
field := fieldByColumn(v, col.Key)
|
||||
if !field.IsValid() || !field.CanInterface() {
|
||||
continue
|
||||
}
|
||||
out[col.Key] = field.Interface()
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
func fieldByColumn(v reflect.Value, column string) reflect.Value {
|
||||
if v.Kind() != reflect.Struct {
|
||||
return reflect.Value{}
|
||||
}
|
||||
t := v.Type()
|
||||
for i := 0; i < t.NumField(); i++ {
|
||||
field := t.Field(i)
|
||||
if field.PkgPath != "" {
|
||||
continue
|
||||
}
|
||||
if gormColumn(field) == column || strings.EqualFold(field.Name, column) {
|
||||
return v.Field(i)
|
||||
}
|
||||
}
|
||||
return reflect.Value{}
|
||||
}
|
||||
|
||||
func gormColumn(field reflect.StructField) string {
|
||||
for _, part := range strings.Split(field.Tag.Get("gorm"), ";") {
|
||||
part = strings.TrimSpace(part)
|
||||
if name, ok := strings.CutPrefix(part, "column:"); ok {
|
||||
return name
|
||||
}
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
func uitoa(id uint) string {
|
||||
return strconv.FormatUint(uint64(id), 10)
|
||||
}
|
||||
24
modules/cabana/lang.go
Normal file
24
modules/cabana/lang.go
Normal file
@@ -0,0 +1,24 @@
|
||||
package cabana
|
||||
|
||||
import (
|
||||
"net/http"
|
||||
)
|
||||
|
||||
// adminLangPrefix is the only namespace the public bundle serves (D-20).
|
||||
const adminLangPrefix = "backend::lang."
|
||||
|
||||
// langBundle serves GET {prefix}/api/v1/lang: every backend::lang key as CLDR
|
||||
// forms for the request locale, with the fallback locale's keys underneath.
|
||||
// It is public (the login screen needs it) and never includes another
|
||||
// namespace.
|
||||
func (s *service) langBundle(w http.ResponseWriter, r *http.Request) {
|
||||
tr := s.translator()
|
||||
locale := schemaLocale(r.Context(), tr)
|
||||
data := map[string]map[string]string{}
|
||||
if tr != nil {
|
||||
locale = tr.Resolved(locale, adminLangPrefix)
|
||||
data = tr.Bundle(locale, adminLangPrefix)
|
||||
}
|
||||
w.Header().Set("Cache-Control", "no-cache")
|
||||
WriteData(w, http.StatusOK, data, map[string]any{"locale": locale})
|
||||
}
|
||||
504
modules/cabana/list_schema.go
Normal file
504
modules/cabana/list_schema.go
Normal file
@@ -0,0 +1,504 @@
|
||||
package cabana
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"io/fs"
|
||||
"path"
|
||||
"reflect"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"git.golem15.com/golem15/summercms/modules/pact"
|
||||
"git.golem15.com/golem15/summercms/modules/phrasebook"
|
||||
"git.golem15.com/golem15/summercms/modules/towel"
|
||||
"github.com/goccy/go-yaml"
|
||||
"github.com/goccy/go-yaml/ast"
|
||||
"gorm.io/gorm"
|
||||
)
|
||||
|
||||
const listSearchTerm = "search"
|
||||
|
||||
var listColumnTypes = map[string]struct{}{
|
||||
"text": {}, "datetime": {}, "switch": {},
|
||||
}
|
||||
|
||||
type listDocument struct {
|
||||
List string `yaml:"list"`
|
||||
ModelClass string `yaml:"modelClass"`
|
||||
Title string `yaml:"title"`
|
||||
RecordURL string `yaml:"recordUrl"`
|
||||
NoRecordsMessage string `yaml:"noRecordsMessage"`
|
||||
RecordsPerPage int `yaml:"recordsPerPage"`
|
||||
PerPageOptions []int `yaml:"perPageOptions"`
|
||||
ShowCheckboxes bool `yaml:"showCheckboxes"`
|
||||
ShowSetup bool `yaml:"showSetup"`
|
||||
ShowSorting *bool `yaml:"showSorting"`
|
||||
ShowSearch bool `yaml:"showSearch"`
|
||||
DefaultSort *listSortDocument `yaml:"defaultSort"`
|
||||
Toolbar *listToolbar `yaml:"toolbar"`
|
||||
Filter string `yaml:"filter"`
|
||||
Messages *listMessageKeys `yaml:"messages"`
|
||||
}
|
||||
|
||||
type listSortDocument struct {
|
||||
Column string `yaml:"column"`
|
||||
Direction string `yaml:"direction"`
|
||||
}
|
||||
|
||||
type listToolbar struct {
|
||||
Buttons toolbarButtons `yaml:"buttons"`
|
||||
Search *struct {
|
||||
Prompt string `yaml:"prompt"`
|
||||
Mode string `yaml:"mode"`
|
||||
} `yaml:"search"`
|
||||
}
|
||||
|
||||
type columnsDocument struct {
|
||||
Columns yaml.MapSlice `yaml:"columns"`
|
||||
}
|
||||
|
||||
type columnDocument struct {
|
||||
Label string `yaml:"label"`
|
||||
Searchable bool `yaml:"searchable"`
|
||||
Sortable *bool `yaml:"sortable"`
|
||||
Type string `yaml:"type"`
|
||||
Relation string `yaml:"relation"`
|
||||
Select string `yaml:"select"`
|
||||
}
|
||||
|
||||
// CompileListSchema compiles config_list.yaml and the columns.yaml it names.
|
||||
func CompileListSchema(pluginID string, ctl pact.AdminController, fsys fs.FS) (*ListSchema, error) {
|
||||
return compileList(pluginID, ctl, fsys)
|
||||
}
|
||||
|
||||
// CompileList compiles one controller's config_list.yaml and columns.yaml.
|
||||
func CompileList(pluginID string, ctl pact.AdminController, fsys fs.FS) (*ListSchema, error) {
|
||||
return compileList(pluginID, ctl, fsys)
|
||||
}
|
||||
|
||||
func compileList(pluginID string, ctl pact.AdminController, fsys fs.FS) (*ListSchema, error) {
|
||||
if ctl == nil {
|
||||
return nil, fmt.Errorf("cabana: admin schema %s: controller is nil", pluginID)
|
||||
}
|
||||
dir := strings.Trim(path.Clean(ctl.ConfigDir()), "/")
|
||||
if dir == "." || strings.HasPrefix(dir, "..") {
|
||||
return nil, bootErr(pluginID, ctl.ID(), ctl.ConfigDir(), fmt.Errorf("config directory escapes the plugin"))
|
||||
}
|
||||
cfgPath := path.Join(dir, "config_list.yaml")
|
||||
raw, err := readAsset(fsys, cfgPath)
|
||||
if err != nil {
|
||||
return nil, bootErr(pluginID, ctl.ID(), cfgPath, err)
|
||||
}
|
||||
var doc listDocument
|
||||
if err := decodeStrict(raw, &doc); err != nil {
|
||||
return nil, bootErr(pluginID, ctl.ID(), cfgPath, err)
|
||||
}
|
||||
if doc.ModelClass != ctl.ModelName() {
|
||||
return nil, bootErr(pluginID, ctl.ID(), cfgPath, fmt.Errorf("modelClass %q does not match %q", doc.ModelClass, ctl.ModelName()))
|
||||
}
|
||||
if strings.TrimSpace(doc.List) == "" {
|
||||
return nil, bootErr(pluginID, ctl.ID(), cfgPath, fmt.Errorf("list file is empty"))
|
||||
}
|
||||
colPath, err := assetPath(pluginID, doc.List)
|
||||
if err != nil {
|
||||
return nil, bootErr(pluginID, ctl.ID(), cfgPath, err)
|
||||
}
|
||||
columns, err := compileColumns(pluginID, ctl, fsys, colPath)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
per := doc.RecordsPerPage
|
||||
if per < 1 {
|
||||
per = 20
|
||||
}
|
||||
options, err := compilePageOptions(per, doc.PerPageOptions)
|
||||
if err != nil {
|
||||
return nil, bootErr(pluginID, ctl.ID(), cfgPath, err)
|
||||
}
|
||||
showSearch := doc.ShowSearch
|
||||
prompt := ""
|
||||
if doc.Toolbar != nil && doc.Toolbar.Search != nil {
|
||||
showSearch = true
|
||||
prompt = doc.Toolbar.Search.Prompt
|
||||
if mode := doc.Toolbar.Search.Mode; mode != "" && mode != "all" && mode != "any" && mode != "exact" {
|
||||
return nil, bootErr(pluginID, ctl.ID(), cfgPath, fmt.Errorf("unsupported search mode %s", mode))
|
||||
}
|
||||
}
|
||||
buttons, err := compileToolbarButtons(doc.Toolbar, doc.ShowCheckboxes)
|
||||
if err != nil {
|
||||
return nil, bootErr(pluginID, ctl.ID(), cfgPath, err)
|
||||
}
|
||||
sort, err := compileDefaultSort(doc.DefaultSort, columns)
|
||||
if err != nil {
|
||||
return nil, bootErr(pluginID, ctl.ID(), cfgPath, err)
|
||||
}
|
||||
showSorting := true
|
||||
if doc.ShowSorting != nil {
|
||||
showSorting = *doc.ShowSorting
|
||||
}
|
||||
rowActions := []RowAction{}
|
||||
if doc.RecordURL != "" {
|
||||
rowActions = append(rowActions, RowAction{
|
||||
Name: "update",
|
||||
Label: "backend::lang.form.update",
|
||||
URL: doc.RecordURL,
|
||||
})
|
||||
}
|
||||
bulk := []BulkAction{}
|
||||
if doc.ShowCheckboxes {
|
||||
bulk = append(bulk, BulkAction{Name: "delete", Label: "backend::lang.list.delete_selected"})
|
||||
}
|
||||
filters := []ListFilter{}
|
||||
if strings.TrimSpace(doc.Filter) != "" {
|
||||
filters, err = compileFilters(pluginID, ctl, fsys, dir, doc.Filter)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
schema := &ListSchema{
|
||||
Title: doc.Title,
|
||||
ModelClass: doc.ModelClass,
|
||||
RecordURL: doc.RecordURL,
|
||||
NoRecordsMessage: doc.NoRecordsMessage,
|
||||
RecordsPerPage: per,
|
||||
PerPageOptions: options,
|
||||
ShowSearch: showSearch,
|
||||
ShowSetup: doc.ShowSetup,
|
||||
ShowCheckboxes: doc.ShowCheckboxes,
|
||||
ShowSorting: showSorting,
|
||||
SearchTerm: listSearchTerm,
|
||||
SearchPrompt: prompt,
|
||||
DefaultSort: sort,
|
||||
ToolbarButtons: buttons,
|
||||
Columns: columns,
|
||||
Filters: filters,
|
||||
RowActions: rowActions,
|
||||
BulkActions: bulk,
|
||||
}
|
||||
if doc.Messages != nil {
|
||||
schema.messageKeys = *doc.Messages
|
||||
}
|
||||
keys := localizeMessages[listMessageKeys, ListMessages](context.Background(), nil, schema.listMessageKeySet())
|
||||
schema.Messages = &keys
|
||||
return schema, nil
|
||||
}
|
||||
|
||||
func compileColumns(pluginID string, ctl pact.AdminController, fsys fs.FS, colPath string) ([]ListColumn, error) {
|
||||
colRaw, err := readAsset(fsys, colPath)
|
||||
if err != nil {
|
||||
return nil, bootErr(pluginID, ctl.ID(), colPath, err)
|
||||
}
|
||||
var cols columnsDocument
|
||||
if err := decodeStrict(colRaw, &cols); err != nil {
|
||||
return nil, bootErr(pluginID, ctl.ID(), colPath, err)
|
||||
}
|
||||
modelCols, modelRels, checkModel := listModelContract(ctl)
|
||||
compiled := make([]ListColumn, 0, len(cols.Columns))
|
||||
seen := map[string]struct{}{}
|
||||
for _, item := range cols.Columns {
|
||||
key, ok := item.Key.(string)
|
||||
if !ok || !identifier(key) {
|
||||
return nil, bootErr(pluginID, ctl.ID(), colPath, fmt.Errorf("column key %v is not an identifier", item.Key))
|
||||
}
|
||||
if _, dup := seen[key]; dup {
|
||||
return nil, bootErr(pluginID, ctl.ID(), colPath, fmt.Errorf("duplicate column %s", key))
|
||||
}
|
||||
seen[key] = struct{}{}
|
||||
encoded, err := yaml.Marshal(item.Value)
|
||||
if err != nil {
|
||||
return nil, bootErr(pluginID, ctl.ID(), colPath, err)
|
||||
}
|
||||
var spec columnDocument
|
||||
if err := decodeStrict(encoded, &spec); err != nil {
|
||||
return nil, bootErr(pluginID, ctl.ID(), colPath, fmt.Errorf("column %s: %w", key, err))
|
||||
}
|
||||
if spec.Type != "" {
|
||||
if _, known := listColumnTypes[spec.Type]; !known {
|
||||
return nil, bootErr(pluginID, ctl.ID(), colPath, fmt.Errorf("unsupported column type %s", spec.Type))
|
||||
}
|
||||
}
|
||||
if spec.Relation != "" || spec.Select != "" {
|
||||
if !identifier(spec.Relation) {
|
||||
return nil, bootErr(pluginID, ctl.ID(), colPath, fmt.Errorf("relation %q is not an identifier", spec.Relation))
|
||||
}
|
||||
if !identifier(spec.Select) {
|
||||
return nil, bootErr(pluginID, ctl.ID(), colPath, fmt.Errorf("select %q is not an identifier", spec.Select))
|
||||
}
|
||||
if checkModel {
|
||||
if _, known := modelRels[spec.Relation]; !known {
|
||||
return nil, bootErr(pluginID, ctl.ID(), colPath, fmt.Errorf("relation %s is not on the model", spec.Relation))
|
||||
}
|
||||
}
|
||||
} else if checkModel {
|
||||
if _, known := modelCols[key]; !known {
|
||||
return nil, bootErr(pluginID, ctl.ID(), colPath, fmt.Errorf("column %s is not on the model", key))
|
||||
}
|
||||
}
|
||||
sortable := spec.Relation == ""
|
||||
if spec.Sortable != nil {
|
||||
sortable = *spec.Sortable
|
||||
}
|
||||
compiled = append(compiled, ListColumn{
|
||||
Key: key,
|
||||
Label: spec.Label,
|
||||
Searchable: spec.Searchable,
|
||||
Sortable: sortable,
|
||||
Type: spec.Type,
|
||||
Relation: spec.Relation,
|
||||
Select: spec.Select,
|
||||
})
|
||||
}
|
||||
return compiled, nil
|
||||
}
|
||||
|
||||
func compilePageOptions(recordsPerPage int, declared []int) ([]int, error) {
|
||||
if len(declared) == 0 {
|
||||
return []int{recordsPerPage}, nil
|
||||
}
|
||||
options := make([]int, len(declared))
|
||||
seen := map[int]struct{}{}
|
||||
found := false
|
||||
for i, n := range declared {
|
||||
if n < 1 {
|
||||
return nil, fmt.Errorf("perPageOptions must be positive")
|
||||
}
|
||||
if _, dup := seen[n]; dup {
|
||||
return nil, fmt.Errorf("duplicate perPageOptions %d", n)
|
||||
}
|
||||
seen[n] = struct{}{}
|
||||
options[i] = n
|
||||
if n == recordsPerPage {
|
||||
found = true
|
||||
}
|
||||
}
|
||||
if !found {
|
||||
return nil, fmt.Errorf("recordsPerPage %d is not in perPageOptions", recordsPerPage)
|
||||
}
|
||||
return options, nil
|
||||
}
|
||||
|
||||
// toolbarButtons is the declarative toolbar.buttons list (D-14): built-in
|
||||
// actions in display order. A scalar (Winter's partial name) is rejected
|
||||
// with a pointer at the list syntax.
|
||||
type toolbarButtons struct {
|
||||
items []string
|
||||
}
|
||||
|
||||
// toolbarActions are the built-in toolbar actions; custom actions are Phase 10.1.
|
||||
var toolbarActions = map[string]struct{}{"create": {}, "delete": {}}
|
||||
|
||||
func (b *toolbarButtons) UnmarshalYAML(node ast.Node) error {
|
||||
node = unwrapNode(node)
|
||||
switch n := node.(type) {
|
||||
case nil, *ast.NullNode:
|
||||
b.items = nil
|
||||
return nil
|
||||
case *ast.SequenceNode:
|
||||
values := sequenceValues(n)
|
||||
items := make([]string, 0, len(values))
|
||||
seen := map[string]struct{}{}
|
||||
for _, item := range values {
|
||||
action, err := nodeString(unwrapNode(item))
|
||||
if err != nil {
|
||||
return fmt.Errorf("toolbar.buttons entries must be action names (create, delete)")
|
||||
}
|
||||
if _, ok := toolbarActions[action]; !ok {
|
||||
return fmt.Errorf("toolbar.buttons: unsupported action %s (want create or delete)", action)
|
||||
}
|
||||
if _, dup := seen[action]; dup {
|
||||
return fmt.Errorf("toolbar.buttons: duplicate action %s", action)
|
||||
}
|
||||
seen[action] = struct{}{}
|
||||
items = append(items, action)
|
||||
}
|
||||
b.items = items
|
||||
return nil
|
||||
default:
|
||||
return fmt.Errorf("toolbar.buttons must be a list of actions (create, delete); the Winter partial %q is not supported", nodeText(node))
|
||||
}
|
||||
}
|
||||
|
||||
func compileToolbarButtons(toolbar *listToolbar, showCheckboxes bool) ([]string, error) {
|
||||
if toolbar == nil || len(toolbar.Buttons.items) == 0 {
|
||||
return []string{}, nil
|
||||
}
|
||||
out := append([]string(nil), toolbar.Buttons.items...)
|
||||
for _, action := range out {
|
||||
if action == "delete" && !showCheckboxes {
|
||||
return nil, fmt.Errorf("toolbar.buttons: delete needs showCheckboxes: true")
|
||||
}
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
func compileDefaultSort(doc *listSortDocument, columns []ListColumn) (*ListSort, error) {
|
||||
if doc == nil {
|
||||
return nil, nil
|
||||
}
|
||||
var match *ListColumn
|
||||
for i := range columns {
|
||||
if columns[i].Key == doc.Column {
|
||||
match = &columns[i]
|
||||
break
|
||||
}
|
||||
}
|
||||
if match == nil {
|
||||
return nil, fmt.Errorf("default sort column %s is not a list column", doc.Column)
|
||||
}
|
||||
if !match.Sortable {
|
||||
return nil, fmt.Errorf("default sort column %s is not sortable", doc.Column)
|
||||
}
|
||||
if doc.Direction != "asc" && doc.Direction != "desc" {
|
||||
return nil, fmt.Errorf("default sort direction %s must be asc or desc", doc.Direction)
|
||||
}
|
||||
return &ListSort{Column: doc.Column, Direction: doc.Direction}, nil
|
||||
}
|
||||
|
||||
func listModelContract(ctl pact.AdminController) (map[string]struct{}, map[string]struct{}, bool) {
|
||||
src, ok := ctl.(pact.AdminRecordSource)
|
||||
if !ok || src == nil {
|
||||
return nil, nil, false
|
||||
}
|
||||
model := src.NewRecord()
|
||||
if model == nil {
|
||||
return nil, nil, false
|
||||
}
|
||||
t := reflect.TypeOf(model)
|
||||
for t != nil && t.Kind() == reflect.Pointer {
|
||||
t = t.Elem()
|
||||
}
|
||||
if t == nil || t.Kind() != reflect.Struct {
|
||||
return nil, nil, false
|
||||
}
|
||||
cols := map[string]struct{}{}
|
||||
rels := map[string]struct{}{}
|
||||
for i := 0; i < t.NumField(); i++ {
|
||||
field := t.Field(i)
|
||||
if field.PkgPath != "" {
|
||||
continue
|
||||
}
|
||||
if isListRelation(field.Type) {
|
||||
rels[field.Name] = struct{}{}
|
||||
// Winter YAML spells relations in lowercase (relation: genre)
|
||||
// while the Go field is exported (Genre).
|
||||
rels[strings.ToLower(field.Name)] = struct{}{}
|
||||
continue
|
||||
}
|
||||
name := gormColumn(field)
|
||||
if name == "" {
|
||||
name = field.Name
|
||||
}
|
||||
cols[name] = struct{}{}
|
||||
}
|
||||
return cols, rels, true
|
||||
}
|
||||
|
||||
func isListRelation(t reflect.Type) bool {
|
||||
for t.Kind() == reflect.Pointer {
|
||||
t = t.Elem()
|
||||
}
|
||||
if t.Kind() == reflect.Slice {
|
||||
t = t.Elem()
|
||||
for t.Kind() == reflect.Pointer {
|
||||
t = t.Elem()
|
||||
}
|
||||
}
|
||||
if t.Kind() != reflect.Struct {
|
||||
return false
|
||||
}
|
||||
if t == reflect.TypeOf(time.Time{}) {
|
||||
return false
|
||||
}
|
||||
if t == reflect.TypeOf(gorm.DeletedAt{}) {
|
||||
return false
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
// Localize copies the cached list schema and resolves display strings for one request.
|
||||
// Column, filter, and scope identifiers and option values are not translated.
|
||||
func (s *ListSchema) Localize(ctx context.Context, tr *phrasebook.Translator) (*ListSchema, error) {
|
||||
if s == nil {
|
||||
return nil, fmt.Errorf("cabana: nil list schema")
|
||||
}
|
||||
if ctx == nil {
|
||||
ctx = context.Background()
|
||||
}
|
||||
locale := schemaLocale(ctx, tr)
|
||||
ctx = towel.WithLocale(ctx, locale)
|
||||
out := *s
|
||||
out.Title = translateKey(ctx, tr, s.Title)
|
||||
out.NoRecordsMessage = translateKey(ctx, tr, s.NoRecordsMessage)
|
||||
out.SearchPrompt = translateKey(ctx, tr, s.SearchPrompt)
|
||||
out.PerPageOptions = append([]int(nil), s.PerPageOptions...)
|
||||
out.ToolbarButtons = append([]string(nil), s.ToolbarButtons...)
|
||||
if s.DefaultSort != nil {
|
||||
sort := *s.DefaultSort
|
||||
out.DefaultSort = &sort
|
||||
}
|
||||
out.Columns = localizeListColumns(ctx, tr, s.Columns)
|
||||
out.Filters = localizeListFilters(ctx, tr, s.Filters)
|
||||
out.RowActions = localizeRowActions(ctx, tr, s.RowActions)
|
||||
out.BulkActions = localizeBulkActions(ctx, tr, s.BulkActions)
|
||||
messages := localizeMessages[listMessageKeys, ListMessages](ctx, tr, s.listMessageKeySet())
|
||||
out.Messages = &messages
|
||||
out.Meta = &FormMeta{Locale: locale}
|
||||
return &out, nil
|
||||
}
|
||||
|
||||
func localizeListColumns(ctx context.Context, tr *phrasebook.Translator, cols []ListColumn) []ListColumn {
|
||||
out := make([]ListColumn, len(cols))
|
||||
for i, col := range cols {
|
||||
col.Label = translateKey(ctx, tr, col.Label)
|
||||
out[i] = col
|
||||
}
|
||||
if out == nil {
|
||||
out = []ListColumn{}
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
func localizeListFilters(ctx context.Context, tr *phrasebook.Translator, filters []ListFilter) []ListFilter {
|
||||
out := make([]ListFilter, len(filters))
|
||||
for i, filter := range filters {
|
||||
filter.Label = translateKey(ctx, tr, filter.Label)
|
||||
if len(filter.Options) > 0 {
|
||||
opts := make([]FormOption, len(filter.Options))
|
||||
for j, opt := range filter.Options {
|
||||
opt.Label = translateKey(ctx, tr, opt.Label)
|
||||
opts[j] = opt
|
||||
}
|
||||
filter.Options = opts
|
||||
}
|
||||
out[i] = filter
|
||||
}
|
||||
if out == nil {
|
||||
out = []ListFilter{}
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
func localizeRowActions(ctx context.Context, tr *phrasebook.Translator, actions []RowAction) []RowAction {
|
||||
out := make([]RowAction, len(actions))
|
||||
for i, action := range actions {
|
||||
action.Label = translateKey(ctx, tr, action.Label)
|
||||
out[i] = action
|
||||
}
|
||||
if out == nil {
|
||||
out = []RowAction{}
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
func localizeBulkActions(ctx context.Context, tr *phrasebook.Translator, actions []BulkAction) []BulkAction {
|
||||
out := make([]BulkAction, len(actions))
|
||||
for i, action := range actions {
|
||||
action.Label = translateKey(ctx, tr, action.Label)
|
||||
out[i] = action
|
||||
}
|
||||
if out == nil {
|
||||
out = []BulkAction{}
|
||||
}
|
||||
return out
|
||||
}
|
||||
597
modules/cabana/list_schema_test.go
Normal file
597
modules/cabana/list_schema_test.go
Normal file
@@ -0,0 +1,597 @@
|
||||
package cabana
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"os"
|
||||
"strings"
|
||||
"testing"
|
||||
"testing/fstest"
|
||||
"time"
|
||||
|
||||
"git.golem15.com/golem15/summercms/modules/pact"
|
||||
"git.golem15.com/golem15/summercms/modules/phrasebook"
|
||||
"git.golem15.com/golem15/summercms/modules/towel"
|
||||
"gorm.io/gorm"
|
||||
)
|
||||
|
||||
const allColumnsConfig = `title: demo.lang.widgets
|
||||
modelClass: Widget
|
||||
list: ~/plugins/acme/demo/models/widget/columns.yaml
|
||||
recordUrl: acme/demo/widgets/update/:id
|
||||
noRecordsMessage: backend::lang.list.no_records
|
||||
recordsPerPage: 20
|
||||
perPageOptions:
|
||||
- 20
|
||||
- 50
|
||||
- 100
|
||||
showSetup: true
|
||||
showCheckboxes: true
|
||||
showSorting: true
|
||||
defaultSort:
|
||||
column: name
|
||||
direction: asc
|
||||
toolbar:
|
||||
buttons: [create, delete]
|
||||
search:
|
||||
prompt: backend::lang.list.search_prompt
|
||||
`
|
||||
|
||||
const allColumnsJSON = `{"title":"demo.lang.widgets","modelClass":"Widget","recordUrl":"acme/demo/widgets/update/:id","noRecordsMessage":"backend::lang.list.no_records","recordsPerPage":20,"perPageOptions":[20,50,100],"showSearch":true,"showSetup":true,"showCheckboxes":true,"showSorting":true,"searchTerm":"search","searchPrompt":"backend::lang.list.search_prompt","defaultSort":{"column":"name","direction":"asc"},"toolbarButtons":["create","delete"],"columns":[{"key":"name","label":"demo.lang.name","searchable":true,"sortable":true,"type":"text"},{"key":"created_at","label":"demo.lang.created","searchable":false,"sortable":true,"type":"datetime"},{"key":"active","label":"demo.lang.active","searchable":false,"sortable":false,"type":"switch"},{"key":"genre","label":"demo.lang.genre","searchable":true,"sortable":false,"relation":"genre","select":"name"}],"filters":[],"rowActions":[{"name":"update","label":"backend::lang.form.update","url":"acme/demo/widgets/update/:id"}],"bulkActions":[{"name":"delete","label":"backend::lang.list.delete_selected"}],` + defaultListMessagesJSON + `}`
|
||||
|
||||
// defaultListMessagesJSON is a compiled list's messages block when the YAML
|
||||
// declares none: every key is a framework default phrase key (D-13).
|
||||
const defaultListMessagesJSON = `"messages":{"recordCount":{"other":"backend::lang.messages.list.record_count"},"create":{"other":"backend::lang.messages.list.create"},"searchPrompt":{"other":"backend::lang.list.search_prompt"},"empty":{"other":"backend::lang.list.no_records"},"emptySearch":{"other":"backend::lang.messages.list.empty_search"},"emptySearchHint":{"other":"backend::lang.messages.list.empty_search_hint"},"selected":{"other":"backend::lang.messages.list.selected"},"deleteSelected":{"other":"backend::lang.list.delete_selected"},"deleteConfirm":{"other":"backend::lang.messages.list.delete_confirm"},"deleted":{"other":"backend::lang.messages.list.deleted"}}`
|
||||
|
||||
func TestListSchemaCompile(t *testing.T) {
|
||||
columns := readListFixture(t, "testdata/list/all_columns.yaml")
|
||||
got := compileListJSON(t, schemaController{model: "Widget"}, allColumnsConfig, columns)
|
||||
if got != allColumnsJSON {
|
||||
t.Fatalf("compiled list =\n%s\nwant\n%s", got, allColumnsJSON)
|
||||
}
|
||||
again := compileListJSON(t, schemaController{model: "Widget"}, allColumnsConfig, columns)
|
||||
if again != got {
|
||||
t.Fatalf("recompilation changed JSON:\n%s\n%s", got, again)
|
||||
}
|
||||
for _, want := range []string{
|
||||
`"searchable":false`, `"sortable":false`, `"type":"datetime"`, `"type":"switch"`,
|
||||
`"relation":"genre"`, `"select":"name"`, `"searchTerm":"search"`, `"showSetup":true`,
|
||||
`"perPageOptions":[20,50,100]`, `"toolbarButtons":["create","delete"]`, `"filters":[]`,
|
||||
} {
|
||||
if !strings.Contains(got, want) {
|
||||
t.Fatalf("compiled list missing %s:\n%s", want, got)
|
||||
}
|
||||
}
|
||||
|
||||
t.Run("winter genre list still compiles", func(t *testing.T) {
|
||||
const config = `list: ~/plugins/golem15/acme/models/genre/columns.yaml
|
||||
modelClass: Golem15\Acme\Models\Genre
|
||||
title: golem15.acme::lang.genre.label_plural
|
||||
recordUrl: golem15/acme/genres/update/:id
|
||||
noRecordsMessage: backend::lang.list.no_records
|
||||
recordsPerPage: 20
|
||||
showCheckboxes: true
|
||||
toolbar:
|
||||
buttons: [create, delete]
|
||||
search:
|
||||
prompt: backend::lang.list.search_prompt
|
||||
`
|
||||
const cols = `columns:
|
||||
name:
|
||||
label: golem15.acme::lang.genre.name
|
||||
searchable: true
|
||||
slug:
|
||||
label: golem15.acme::lang.genre.slug
|
||||
searchable: true
|
||||
`
|
||||
ctl := schemaController{model: `Golem15\Acme\Models\Genre`}
|
||||
fsys := fstest.MapFS{
|
||||
"controllers/genres/config_list.yaml": &fstest.MapFile{Data: []byte(config)},
|
||||
"models/genre/columns.yaml": &fstest.MapFile{Data: []byte(cols)},
|
||||
}
|
||||
genre := genreConfigController{schemaController: ctl}
|
||||
if _, err := CompileList("golem15.acme", genre, fsys); err != nil {
|
||||
t.Fatalf("genre list: %v", err)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func TestListSchemaEmpty(t *testing.T) {
|
||||
const config = `list: ~/plugins/acme/demo/models/widget/columns.yaml
|
||||
modelClass: Widget
|
||||
recordsPerPage: 20
|
||||
`
|
||||
got := compileListJSON(t, schemaController{model: "Widget"}, config, "columns: {}\n")
|
||||
want := `{"modelClass":"Widget","recordsPerPage":20,"perPageOptions":[20],"showSearch":false,"showSetup":false,"showCheckboxes":false,"showSorting":true,"searchTerm":"search","toolbarButtons":[],"columns":[],"filters":[],"rowActions":[],"bulkActions":[],` + defaultListMessagesJSON + `}`
|
||||
if got != want {
|
||||
t.Fatalf("empty list =\n%s\nwant\n%s", got, want)
|
||||
}
|
||||
for _, nullKey := range []string{`"columns":null`, `"filters":null`, `"rowActions":null`, `"bulkActions":null`, `"perPageOptions":null`, `"toolbarButtons":null`} {
|
||||
if strings.Contains(got, nullKey) {
|
||||
t.Fatalf("empty collection serialized as null: %s", nullKey)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestListSchemaSingle(t *testing.T) {
|
||||
const config = `list: ~/plugins/acme/demo/models/widget/columns.yaml
|
||||
modelClass: Widget
|
||||
recordsPerPage: 20
|
||||
`
|
||||
got := compileListJSON(t, schemaController{model: "Widget"}, config, "columns:\n name:\n label: Name\n searchable: true\n")
|
||||
want := `{"modelClass":"Widget","recordsPerPage":20,"perPageOptions":[20],"showSearch":false,"showSetup":false,"showCheckboxes":false,"showSorting":true,"searchTerm":"search","toolbarButtons":[],"columns":[{"key":"name","label":"Name","searchable":true,"sortable":true}],"filters":[],"rowActions":[],"bulkActions":[],` + defaultListMessagesJSON + `}`
|
||||
if got != want {
|
||||
t.Fatalf("single list =\n%s\nwant\n%s", got, want)
|
||||
}
|
||||
}
|
||||
|
||||
func TestListSchemaOrdering(t *testing.T) {
|
||||
const config = `list: ~/plugins/acme/demo/models/widget/columns.yaml
|
||||
modelClass: Widget
|
||||
recordsPerPage: 20
|
||||
perPageOptions:
|
||||
- 100
|
||||
- 20
|
||||
- 50
|
||||
`
|
||||
const columns = `columns:
|
||||
zeta:
|
||||
label: Z
|
||||
type: text
|
||||
alpha:
|
||||
label: A
|
||||
type: datetime
|
||||
mid:
|
||||
label: M
|
||||
type: switch
|
||||
`
|
||||
first := compileListJSON(t, schemaController{model: "Widget"}, config, columns)
|
||||
second := compileListJSON(t, schemaController{model: "Widget"}, config, columns)
|
||||
if first != second {
|
||||
t.Fatalf("order changed between compiles:\n%s\n%s", first, second)
|
||||
}
|
||||
zeta := strings.Index(first, `"key":"zeta"`)
|
||||
alpha := strings.Index(first, `"key":"alpha"`)
|
||||
mid := strings.Index(first, `"key":"mid"`)
|
||||
if zeta < 0 || alpha < 0 || mid < 0 || !(zeta < alpha && alpha < mid) {
|
||||
t.Fatalf("source order lost: %s", first)
|
||||
}
|
||||
if !strings.Contains(first, `"perPageOptions":[100,20,50]`) {
|
||||
t.Fatalf("perPageOptions were reordered: %s", first)
|
||||
}
|
||||
}
|
||||
|
||||
func TestListSchemaRejects(t *testing.T) {
|
||||
columns := readListFixture(t, "testdata/list/all_columns.yaml")
|
||||
cases := []struct {
|
||||
name string
|
||||
model string
|
||||
config string
|
||||
columns string
|
||||
want []string
|
||||
}{
|
||||
{
|
||||
name: "duplicate column",
|
||||
config: allColumnsConfig,
|
||||
columns: "columns:\n name:\n label: A\n name:\n label: B\n",
|
||||
want: []string{"acme.demo", "acme.demo.widgets", "models/widget/columns.yaml", "duplicate"},
|
||||
},
|
||||
{
|
||||
name: "unknown key",
|
||||
config: allColumnsConfig,
|
||||
columns: "columns:\n name:\n label: Name\n cssClass: bad\n",
|
||||
want: []string{"acme.demo", "acme.demo.widgets", "models/widget/columns.yaml", "cssClass"},
|
||||
},
|
||||
{
|
||||
name: "unsupported type",
|
||||
config: allColumnsConfig,
|
||||
columns: "columns:\n name:\n label: Name\n type: partial\n",
|
||||
want: []string{"acme.demo", "acme.demo.widgets", "models/widget/columns.yaml", "partial"},
|
||||
},
|
||||
{
|
||||
name: "sql select",
|
||||
config: allColumnsConfig,
|
||||
columns: "columns:\n genre:\n label: Genre\n relation: genre\n select: \"@.name\"\n",
|
||||
want: []string{"acme.demo", "acme.demo.widgets", "models/widget/columns.yaml", "select"},
|
||||
},
|
||||
{
|
||||
name: "invalid default column",
|
||||
config: strings.Replace(allColumnsConfig, "column: name", "column: missing", 1),
|
||||
columns: columns,
|
||||
want: []string{"acme.demo", "acme.demo.widgets", "config_list.yaml", "missing"},
|
||||
},
|
||||
{
|
||||
name: "invalid default direction",
|
||||
config: strings.Replace(allColumnsConfig, "direction: asc", "direction: ASC", 1),
|
||||
columns: columns,
|
||||
want: []string{"acme.demo", "acme.demo.widgets", "config_list.yaml", "ASC"},
|
||||
},
|
||||
{
|
||||
name: "path escape",
|
||||
config: strings.Replace(allColumnsConfig, "list: ~/plugins/acme/demo/models/widget/columns.yaml", "list: ../../etc/passwd", 1),
|
||||
columns: columns,
|
||||
want: []string{"acme.demo", "acme.demo.widgets", "config_list.yaml", "escape"},
|
||||
},
|
||||
{
|
||||
name: "mismatched modelClass",
|
||||
model: "Widget",
|
||||
config: strings.Replace(allColumnsConfig, "modelClass: Widget", "modelClass: widget", 1),
|
||||
columns: columns,
|
||||
want: []string{"acme.demo", "acme.demo.widgets", "config_list.yaml", "modelClass"},
|
||||
},
|
||||
{
|
||||
name: "unsupported action",
|
||||
config: strings.Replace(allColumnsConfig, "buttons: [create, delete]", "buttons: [create, drop_database]", 1),
|
||||
columns: columns,
|
||||
want: []string{"acme.demo", "acme.demo.widgets", "config_list.yaml", "drop_database"},
|
||||
},
|
||||
{
|
||||
name: "invalid page size",
|
||||
config: strings.Replace(allColumnsConfig, " - 100\n", " - 0\n", 1),
|
||||
columns: columns,
|
||||
want: []string{"acme.demo", "acme.demo.widgets", "config_list.yaml", "perPageOptions"},
|
||||
},
|
||||
}
|
||||
for _, tc := range cases {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
model := tc.model
|
||||
if model == "" {
|
||||
model = "Widget"
|
||||
}
|
||||
_, err := CompileList("acme.demo", schemaController{model: model}, listFS(tc.config, tc.columns))
|
||||
if err == nil {
|
||||
t.Fatal("expected boot error")
|
||||
}
|
||||
msg := err.Error()
|
||||
for _, want := range tc.want {
|
||||
if want == "duplicate" {
|
||||
if strings.Contains(msg, "duplicate") || strings.Contains(msg, "already defined") {
|
||||
continue
|
||||
}
|
||||
t.Fatalf("error %q missing duplicate", msg)
|
||||
}
|
||||
if want == "escape" {
|
||||
if strings.Contains(msg, "escape") || strings.Contains(msg, "..") {
|
||||
continue
|
||||
}
|
||||
t.Fatalf("error %q missing escape", msg)
|
||||
}
|
||||
if !strings.Contains(msg, want) {
|
||||
t.Fatalf("error %q missing %q", msg, want)
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
type genreConfigController struct{ schemaController }
|
||||
|
||||
func (c genreConfigController) ConfigDir() string { return "controllers/genres" }
|
||||
func (c genreConfigController) ID() string { return "golem15.acme.genres" }
|
||||
|
||||
func listFS(config, columns string) fstest.MapFS {
|
||||
return fstest.MapFS{
|
||||
"controllers/widgets/config_list.yaml": &fstest.MapFile{Data: []byte(config)},
|
||||
"models/widget/columns.yaml": &fstest.MapFile{Data: []byte(columns)},
|
||||
}
|
||||
}
|
||||
|
||||
func compileListJSON(t *testing.T, ctl pact.AdminController, config, columns string) string {
|
||||
t.Helper()
|
||||
schema, err := CompileList("acme.demo", ctl, listFS(config, columns))
|
||||
if err != nil {
|
||||
t.Fatalf("compile: %v", err)
|
||||
}
|
||||
raw, err := json.Marshal(schema)
|
||||
if err != nil {
|
||||
t.Fatalf("json: %v", err)
|
||||
}
|
||||
return string(raw)
|
||||
}
|
||||
|
||||
func readListFixture(t *testing.T, name string) string {
|
||||
t.Helper()
|
||||
raw, err := os.ReadFile(name)
|
||||
if err != nil {
|
||||
t.Fatalf("fixture %s: %v", name, err)
|
||||
}
|
||||
return string(raw)
|
||||
}
|
||||
|
||||
const filterListConfig = `title: demo.lang.widgets
|
||||
modelClass: Widget
|
||||
list: ~/plugins/acme/demo/models/widget/columns.yaml
|
||||
recordsPerPage: 20
|
||||
filter: config_filter.yaml
|
||||
`
|
||||
|
||||
const filterColumns = `columns:
|
||||
name:
|
||||
label: Name
|
||||
searchable: true
|
||||
`
|
||||
|
||||
const allFiltersJSON = `{"title":"demo.lang.widgets","modelClass":"Widget","recordsPerPage":20,"perPageOptions":[20],"showSearch":false,"showSetup":false,"showCheckboxes":false,"showSorting":true,"searchTerm":"search","toolbarButtons":[],"columns":[{"key":"name","label":"Name","searchable":true,"sortable":true}],"filters":[{"name":"activated","label":"demo.lang.activated","type":"switch","column":"active","options":[{"value":true,"label":"demo.lang.yes"},{"value":false,"label":"demo.lang.no"}]},{"name":"created","label":"demo.lang.created_range","type":"daterange","column":"created_at"},{"name":"grouped","label":"demo.lang.grouped","type":"scope","scope":"filterByGroup","modelClass":"Group","nameFrom":"name"}],"rowActions":[],"bulkActions":[],` + defaultListMessagesJSON + `}`
|
||||
|
||||
func TestListSchemaFilter(t *testing.T) {
|
||||
filters := readListFixture(t, "testdata/list/all_filters.yaml")
|
||||
ctl := filterController{schemaController: schemaController{model: "Widget"}, rec: &filterRow{}}
|
||||
got := compileFilterJSON(t, ctl, filterListConfig, filterColumns, filters)
|
||||
if got != allFiltersJSON {
|
||||
t.Fatalf("compiled filters =\n%s\nwant\n%s", got, allFiltersJSON)
|
||||
}
|
||||
again := compileFilterJSON(t, ctl, filterListConfig, filterColumns, filters)
|
||||
if again != got {
|
||||
t.Fatalf("recompilation changed JSON:\n%s\n%s", got, again)
|
||||
}
|
||||
if strings.Contains(got, `"value":"true"`) || strings.Contains(got, `"value":"false"`) || strings.Contains(got, "conditions") {
|
||||
t.Fatalf("filter values lost their type or carried a condition: %s", got)
|
||||
}
|
||||
yes := strings.Index(got, `{"value":true,"label":"demo.lang.yes"}`)
|
||||
no := strings.Index(got, `{"value":false,"label":"demo.lang.no"}`)
|
||||
if yes < 0 || no < 0 || yes > no {
|
||||
t.Fatalf("switch option order drifted: %s", got)
|
||||
}
|
||||
|
||||
t.Run("empty", func(t *testing.T) {
|
||||
raw := compileFilterJSON(t, ctl, filterListConfig, filterColumns, "scopes: {}\n")
|
||||
if !strings.Contains(raw, `"filters":[]`) || strings.Contains(raw, `"filters":null`) {
|
||||
t.Fatalf("empty filters = %s", raw)
|
||||
}
|
||||
})
|
||||
t.Run("single", func(t *testing.T) {
|
||||
const one = `scopes:
|
||||
activated:
|
||||
label: Activated
|
||||
type: switch
|
||||
column: active
|
||||
`
|
||||
raw := compileFilterJSON(t, ctl, filterListConfig, filterColumns, one)
|
||||
want := `"filters":[{"name":"activated","label":"Activated","type":"switch","column":"active","trueValue":true,"falseValue":false}]`
|
||||
if !strings.Contains(raw, want) {
|
||||
t.Fatalf("single filter =\n%s\nwant substring\n%s", raw, want)
|
||||
}
|
||||
})
|
||||
t.Run("labels localize", func(t *testing.T) {
|
||||
const localized = `scopes:
|
||||
activated:
|
||||
label: acme.demo::lang.activated
|
||||
type: switch
|
||||
column: active
|
||||
options:
|
||||
true: acme.demo::lang.yes
|
||||
false: acme.demo::lang.no
|
||||
grouped:
|
||||
label: acme.demo::lang.grouped
|
||||
modelClass: Group
|
||||
nameFrom: name
|
||||
scope: filterByGroup
|
||||
`
|
||||
schema, err := CompileList("acme.demo", ctl, filterFS(filterListConfig, filterColumns, localized))
|
||||
if err != nil {
|
||||
t.Fatalf("compile: %v", err)
|
||||
}
|
||||
before, err := json.Marshal(schema)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
tr := phrasebook.NewTranslator(filterCatalog(t), phrasebook.Options{Locale: "pl", Fallback: "en"})
|
||||
view, err := schema.Localize(towel.WithLocale(context.Background(), "pl"), tr)
|
||||
if err != nil {
|
||||
t.Fatalf("localize: %v", err)
|
||||
}
|
||||
raw, err := json.Marshal(view)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
got := string(raw)
|
||||
for _, want := range []string{`"locale":"pl"`, `"label":"Aktywny"`, `"label":"Tak"`, `"label":"Grupa"`, `"column":"active"`, `"scope":"filterByGroup"`, `"value":true`} {
|
||||
if !strings.Contains(got, want) {
|
||||
t.Fatalf("localized filters missing %s:\n%s", want, got)
|
||||
}
|
||||
}
|
||||
if strings.Contains(got, `"value":"true"`) || strings.Contains(got, "acme.demo::lang.activated") {
|
||||
t.Fatalf("localization changed a value or left a label key: %s", got)
|
||||
}
|
||||
after, err := json.Marshal(schema)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if string(before) != string(after) || strings.Contains(string(after), "Aktywny") {
|
||||
t.Fatalf("localization mutated the cached schema:\n%s", after)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func TestListSchemaScope(t *testing.T) {
|
||||
const scopes = `scopes:
|
||||
grouped:
|
||||
label: Group
|
||||
modelClass: Group
|
||||
nameFrom: name
|
||||
scope: filterByGroup
|
||||
`
|
||||
ctl := filterController{schemaController: schemaController{model: "Widget"}, rec: &filterRow{}}
|
||||
raw := compileFilterJSON(t, ctl, filterListConfig, filterColumns, scopes)
|
||||
if !strings.Contains(raw, `"type":"scope"`) || !strings.Contains(raw, `"scope":"filterByGroup"`) || strings.Contains(raw, "DestroyAll") {
|
||||
t.Fatalf("registered scope = %s", raw)
|
||||
}
|
||||
|
||||
t.Run("missing provider", func(t *testing.T) {
|
||||
_, err := CompileList("acme.demo", schemaController{model: "Widget"}, filterFS(filterListConfig, filterColumns, scopes))
|
||||
if err == nil || !strings.Contains(err.Error(), "filterByGroup") || !strings.Contains(err.Error(), "FilterScope") || !strings.Contains(err.Error(), "config_filter.yaml") {
|
||||
t.Fatalf("missing provider err = %v", err)
|
||||
}
|
||||
})
|
||||
t.Run("case sensitive scope", func(t *testing.T) {
|
||||
body := strings.Replace(scopes, "scope: filterByGroup", "scope: FilterByGroup", 1)
|
||||
_, err := CompileList("acme.demo", ctl, filterFS(filterListConfig, filterColumns, body))
|
||||
if err == nil || !strings.Contains(err.Error(), "FilterByGroup") {
|
||||
t.Fatalf("case variant err = %v", err)
|
||||
}
|
||||
})
|
||||
t.Run("unknown column", func(t *testing.T) {
|
||||
const body = `scopes:
|
||||
activated:
|
||||
label: Activated
|
||||
type: switch
|
||||
column: missing
|
||||
`
|
||||
_, err := CompileList("acme.demo", ctl, filterFS(filterListConfig, filterColumns, body))
|
||||
if err == nil || !strings.Contains(err.Error(), "missing") || !strings.Contains(err.Error(), "acme.demo.widgets") {
|
||||
t.Fatalf("unknown column err = %v", err)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func TestListSchemaRejectsRawCondition(t *testing.T) {
|
||||
cases := []struct {
|
||||
name string
|
||||
body string
|
||||
want []string
|
||||
}{
|
||||
{
|
||||
name: "conditions list",
|
||||
body: `scopes:
|
||||
activated:
|
||||
label: Activated
|
||||
type: switch
|
||||
column: active
|
||||
conditions:
|
||||
- "active = true"
|
||||
`,
|
||||
want: []string{"acme.demo", "acme.demo.widgets", "config_filter.yaml", "conditions"},
|
||||
},
|
||||
{
|
||||
name: "conditions string",
|
||||
body: `scopes:
|
||||
created:
|
||||
label: Created
|
||||
type: daterange
|
||||
conditions: "created_at >= ':after'"
|
||||
`,
|
||||
want: []string{"conditions", "config_filter.yaml"},
|
||||
},
|
||||
{
|
||||
name: "arbitrary method",
|
||||
body: `scopes:
|
||||
grouped:
|
||||
label: Group
|
||||
modelClass: Group
|
||||
nameFrom: name
|
||||
scope: DestroyAll
|
||||
`,
|
||||
want: []string{"DestroyAll", "config_filter.yaml"},
|
||||
},
|
||||
{
|
||||
name: "duplicate filter",
|
||||
body: `scopes:
|
||||
activated:
|
||||
label: A
|
||||
type: switch
|
||||
column: active
|
||||
activated:
|
||||
label: B
|
||||
type: switch
|
||||
column: active
|
||||
`,
|
||||
want: []string{"duplicate", "config_filter.yaml"},
|
||||
},
|
||||
{
|
||||
name: "unknown type",
|
||||
body: `scopes:
|
||||
activated:
|
||||
label: Activated
|
||||
type: checkbox
|
||||
column: active
|
||||
`,
|
||||
want: []string{"checkbox", "config_filter.yaml"},
|
||||
},
|
||||
}
|
||||
ctl := filterController{schemaController: schemaController{model: "Widget"}, rec: &filterRow{}}
|
||||
for _, tc := range cases {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
_, err := CompileList("acme.demo", ctl, filterFS(filterListConfig, filterColumns, tc.body))
|
||||
if err == nil {
|
||||
t.Fatal("expected boot error")
|
||||
}
|
||||
msg := err.Error()
|
||||
for _, want := range tc.want {
|
||||
if want == "duplicate" {
|
||||
if strings.Contains(msg, "duplicate") || strings.Contains(msg, "already defined") {
|
||||
continue
|
||||
}
|
||||
t.Fatalf("error %q missing duplicate", msg)
|
||||
}
|
||||
if !strings.Contains(msg, want) {
|
||||
t.Fatalf("error %q missing %q", msg, want)
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
type filterRow struct {
|
||||
ID uint `gorm:"column:id;primaryKey"`
|
||||
Name string `gorm:"column:name"`
|
||||
Active bool `gorm:"column:active"`
|
||||
CreatedAt time.Time `gorm:"column:created_at"`
|
||||
}
|
||||
|
||||
func (filterRow) FilterScopes() []string { return []string{"filterByGroup"} }
|
||||
|
||||
// FilterOptions serves the model-backed scope's choices (D-27).
|
||||
func (filterRow) FilterOptions(scope string) []pact.Option {
|
||||
if scope != "filterByGroup" {
|
||||
return nil
|
||||
}
|
||||
return []pact.Option{{Value: "4", Label: "demo::lang.group_four"}, {Value: "9", Label: "Group nine"}}
|
||||
}
|
||||
|
||||
func (filterRow) FilterScope(name string, db *gorm.DB, value any) *gorm.DB {
|
||||
if db == nil || name != "filterByGroup" {
|
||||
return db
|
||||
}
|
||||
return db.Where("group_id = ?", value)
|
||||
}
|
||||
|
||||
type filterController struct {
|
||||
schemaController
|
||||
rec any
|
||||
}
|
||||
|
||||
func (c filterController) NewRecord() any { return c.rec }
|
||||
|
||||
func filterFS(config, columns, filters string) fstest.MapFS {
|
||||
return fstest.MapFS{
|
||||
"controllers/widgets/config_list.yaml": &fstest.MapFile{Data: []byte(config)},
|
||||
"models/widget/columns.yaml": &fstest.MapFile{Data: []byte(columns)},
|
||||
"controllers/widgets/config_filter.yaml": &fstest.MapFile{Data: []byte(filters)},
|
||||
}
|
||||
}
|
||||
|
||||
func compileFilterJSON(t *testing.T, ctl pact.AdminController, config, columns, filters string) string {
|
||||
t.Helper()
|
||||
schema, err := CompileList("acme.demo", ctl, filterFS(config, columns, filters))
|
||||
if err != nil {
|
||||
t.Fatalf("compile: %v", err)
|
||||
}
|
||||
raw, err := json.Marshal(schema)
|
||||
if err != nil {
|
||||
t.Fatalf("json: %v", err)
|
||||
}
|
||||
return string(raw)
|
||||
}
|
||||
|
||||
func filterCatalog(t *testing.T) *phrasebook.Catalog {
|
||||
t.Helper()
|
||||
cat := phrasebook.NewCatalog()
|
||||
err := cat.Load("acme.demo", fstest.MapFS{
|
||||
"lang/en/lang.yaml": &fstest.MapFile{Data: []byte("activated: Activated\nyes: Yes\nno: No\ngrouped: Grouped\n")},
|
||||
"lang/pl/lang.yaml": &fstest.MapFile{Data: []byte("activated: Aktywny\nyes: Tak\nno: Nie\ngrouped: Grupa\n")},
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("catalog: %v", err)
|
||||
}
|
||||
return cat
|
||||
}
|
||||
257
modules/cabana/messages.go
Normal file
257
modules/cabana/messages.go
Normal file
@@ -0,0 +1,257 @@
|
||||
package cabana
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"reflect"
|
||||
"sort"
|
||||
|
||||
"git.golem15.com/golem15/summercms/modules/phrasebook"
|
||||
)
|
||||
|
||||
// MessageForms is one controller message resolved to its CLDR plural forms
|
||||
// (D-13). "other" is always present; the SPA picks a form with
|
||||
// Intl.PluralRules and interpolates :count, :name and :term (D-24).
|
||||
type MessageForms map[string]string
|
||||
|
||||
// MarshalJSON keeps an unset message an object, never null.
|
||||
func (m MessageForms) MarshalJSON() ([]byte, error) {
|
||||
if m == nil {
|
||||
return []byte("{}"), nil
|
||||
}
|
||||
return json.Marshal(map[string]string(m))
|
||||
}
|
||||
|
||||
// listMessageKeys is the config_list.yaml messages block: phrase keys.
|
||||
type listMessageKeys struct {
|
||||
RecordCount string `yaml:"recordCount"`
|
||||
Create string `yaml:"create"`
|
||||
SearchPrompt string `yaml:"searchPrompt"`
|
||||
Empty string `yaml:"empty"`
|
||||
EmptySearch string `yaml:"emptySearch"`
|
||||
EmptySearchHint string `yaml:"emptySearchHint"`
|
||||
Selected string `yaml:"selected"`
|
||||
DeleteSelected string `yaml:"deleteSelected"`
|
||||
DeleteConfirm string `yaml:"deleteConfirm"`
|
||||
Deleted string `yaml:"deleted"`
|
||||
}
|
||||
|
||||
// ListMessages is a list schema's copy, every key resolved (same field order
|
||||
// as listMessageKeys).
|
||||
type ListMessages struct {
|
||||
RecordCount MessageForms `json:"recordCount"`
|
||||
Create MessageForms `json:"create"`
|
||||
SearchPrompt MessageForms `json:"searchPrompt"`
|
||||
Empty MessageForms `json:"empty"`
|
||||
EmptySearch MessageForms `json:"emptySearch"`
|
||||
EmptySearchHint MessageForms `json:"emptySearchHint"`
|
||||
Selected MessageForms `json:"selected"`
|
||||
DeleteSelected MessageForms `json:"deleteSelected"`
|
||||
DeleteConfirm MessageForms `json:"deleteConfirm"`
|
||||
Deleted MessageForms `json:"deleted"`
|
||||
}
|
||||
|
||||
// formMessageKeys is the config_form.yaml messages block: phrase keys.
|
||||
type formMessageKeys struct {
|
||||
Create string `yaml:"create"`
|
||||
Update string `yaml:"update"`
|
||||
Saved string `yaml:"saved"`
|
||||
DeleteConfirm string `yaml:"deleteConfirm"`
|
||||
Deleted string `yaml:"deleted"`
|
||||
}
|
||||
|
||||
// FormMessages is a form's copy, every key resolved.
|
||||
type FormMessages struct {
|
||||
Create MessageForms `json:"create"`
|
||||
Update MessageForms `json:"update"`
|
||||
Saved MessageForms `json:"saved"`
|
||||
DeleteConfirm MessageForms `json:"deleteConfirm"`
|
||||
Deleted MessageForms `json:"deleted"`
|
||||
}
|
||||
|
||||
// relationMessageKeys is one config_relation.yaml relation's messages block.
|
||||
type relationMessageKeys struct {
|
||||
Link string `yaml:"link"`
|
||||
LinkHint string `yaml:"linkHint"`
|
||||
CandidateSearch string `yaml:"candidateSearch"`
|
||||
Linked string `yaml:"linked"`
|
||||
UnlinkSelected string `yaml:"unlinkSelected"`
|
||||
UnlinkConfirm string `yaml:"unlinkConfirm"`
|
||||
Unlinked string `yaml:"unlinked"`
|
||||
Empty string `yaml:"empty"`
|
||||
}
|
||||
|
||||
// RelationMessages is a relation manager's copy, every key resolved.
|
||||
type RelationMessages struct {
|
||||
Link MessageForms `json:"link"`
|
||||
LinkHint MessageForms `json:"linkHint"`
|
||||
CandidateSearch MessageForms `json:"candidateSearch"`
|
||||
Linked MessageForms `json:"linked"`
|
||||
UnlinkSelected MessageForms `json:"unlinkSelected"`
|
||||
UnlinkConfirm MessageForms `json:"unlinkConfirm"`
|
||||
Unlinked MessageForms `json:"unlinked"`
|
||||
Empty MessageForms `json:"empty"`
|
||||
}
|
||||
|
||||
// Framework defaults (D-13): every omitted key falls back to backend::lang.
|
||||
var (
|
||||
listMessageDefaults = listMessageKeys{
|
||||
RecordCount: "backend::lang.messages.list.record_count",
|
||||
Create: "backend::lang.messages.list.create",
|
||||
SearchPrompt: "backend::lang.list.search_prompt",
|
||||
Empty: "backend::lang.list.no_records",
|
||||
EmptySearch: "backend::lang.messages.list.empty_search",
|
||||
EmptySearchHint: "backend::lang.messages.list.empty_search_hint",
|
||||
Selected: "backend::lang.messages.list.selected",
|
||||
DeleteSelected: "backend::lang.list.delete_selected",
|
||||
DeleteConfirm: "backend::lang.messages.list.delete_confirm",
|
||||
Deleted: "backend::lang.messages.list.deleted",
|
||||
}
|
||||
formMessageDefaults = formMessageKeys{
|
||||
Create: "backend::lang.messages.form.create",
|
||||
Update: "backend::lang.messages.form.update",
|
||||
Saved: "backend::lang.messages.form.saved",
|
||||
DeleteConfirm: "backend::lang.messages.form.delete_confirm",
|
||||
Deleted: "backend::lang.messages.form.deleted",
|
||||
}
|
||||
relationMessageDefaults = relationMessageKeys{
|
||||
Link: "backend::lang.messages.relation.link",
|
||||
LinkHint: "backend::lang.messages.relation.link_hint",
|
||||
CandidateSearch: "backend::lang.messages.relation.candidate_search",
|
||||
Linked: "backend::lang.messages.relation.linked",
|
||||
UnlinkSelected: "backend::lang.messages.relation.unlink_selected",
|
||||
UnlinkConfirm: "backend::lang.messages.relation.unlink_confirm",
|
||||
Unlinked: "backend::lang.messages.relation.unlinked",
|
||||
Empty: "backend::lang.messages.relation.empty",
|
||||
}
|
||||
)
|
||||
|
||||
// withDefaults fills every empty key of keys from defaults.
|
||||
func withDefaults[K any](keys, defaults K) K {
|
||||
out := keys
|
||||
dst := reflect.ValueOf(&out).Elem()
|
||||
src := reflect.ValueOf(defaults)
|
||||
for i := 0; i < dst.NumField(); i++ {
|
||||
if dst.Field(i).String() == "" {
|
||||
dst.Field(i).SetString(src.Field(i).String())
|
||||
}
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
// messageKeyPairs lists (yaml name, phrase key) for every key, in field order.
|
||||
func messageKeyPairs[K any](keys K) [][2]string {
|
||||
v := reflect.ValueOf(keys)
|
||||
t := v.Type()
|
||||
out := make([][2]string, 0, t.NumField())
|
||||
for i := 0; i < t.NumField(); i++ {
|
||||
out = append(out, [2]string{t.Field(i).Tag.Get("yaml"), v.Field(i).String()})
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
// localizeMessages resolves each key of K into the same-index MessageForms
|
||||
// field of M. Without a translator, or for a key that cannot convert, the
|
||||
// form is {"other": text} where text is the translation or the key itself.
|
||||
func localizeMessages[K any, M any](ctx context.Context, tr *phrasebook.Translator, keys K) M {
|
||||
var out M
|
||||
dst := reflect.ValueOf(&out).Elem()
|
||||
src := reflect.ValueOf(keys)
|
||||
locale := schemaLocale(ctx, tr)
|
||||
for i := 0; i < src.NumField(); i++ {
|
||||
key := src.Field(i).String()
|
||||
dst.Field(i).Set(reflect.ValueOf(messageForms(tr, locale, key)))
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
func messageForms(tr *phrasebook.Translator, locale, key string) MessageForms {
|
||||
if key == "" {
|
||||
return MessageForms{"other": ""}
|
||||
}
|
||||
if tr == nil {
|
||||
return MessageForms{"other": key}
|
||||
}
|
||||
if forms, ok := tr.Forms(locale, key); ok {
|
||||
return MessageForms(forms)
|
||||
}
|
||||
return MessageForms{"other": tr.GetIn(locale, key, nil)}
|
||||
}
|
||||
|
||||
// listMessageKeySet is the list's resolved key set: declared keys over the
|
||||
// framework defaults, with searchPrompt and empty defaulting to the list's own
|
||||
// toolbar.search.prompt and noRecordsMessage when those are set.
|
||||
func (s *ListSchema) listMessageKeySet() listMessageKeys {
|
||||
defaults := listMessageDefaults
|
||||
if s.SearchPrompt != "" {
|
||||
defaults.SearchPrompt = s.SearchPrompt
|
||||
}
|
||||
if s.NoRecordsMessage != "" {
|
||||
defaults.Empty = s.NoRecordsMessage
|
||||
}
|
||||
return withDefaults(s.messageKeys, defaults)
|
||||
}
|
||||
|
||||
// formMessageKeySet is the form's resolved key set; create defaults to the
|
||||
// config_form.yaml name when it is set.
|
||||
func (s *FormSchema) formMessageKeySet() formMessageKeys {
|
||||
defaults := formMessageDefaults
|
||||
if s.Name != "" {
|
||||
defaults.Create = s.Name
|
||||
}
|
||||
return withDefaults(s.messageKeys, defaults)
|
||||
}
|
||||
|
||||
func (s *RelationSchema) relationMessageKeySet() relationMessageKeys {
|
||||
return withDefaults(s.messageKeys, relationMessageDefaults)
|
||||
}
|
||||
|
||||
// validateMessageKeys fails activation when a controller's messages block (or
|
||||
// a framework default) names a phrase key no locale defines (D-13). Defaults
|
||||
// taken from the list's own search prompt, empty message or the form name are
|
||||
// Winter strings that may be literal text, so they are not checked.
|
||||
func validateMessageKeys(reg *Registry, tr *phrasebook.Translator) error {
|
||||
if reg == nil || tr == nil {
|
||||
return nil
|
||||
}
|
||||
ids := make([]string, 0, len(reg.byID))
|
||||
for id := range reg.byID {
|
||||
ids = append(ids, id)
|
||||
}
|
||||
sort.Strings(ids)
|
||||
check := func(pluginID, id, file string, pairs [][2]string) error {
|
||||
for _, pair := range pairs {
|
||||
if pair[1] != "" && !tr.Has(pair[1]) {
|
||||
return bootErr(pluginID, id, file, fmt.Errorf("messages.%s names missing phrase key %s", pair[0], pair[1]))
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
for _, id := range ids {
|
||||
cc := reg.byID[id]
|
||||
if cc.List != nil {
|
||||
if err := check(cc.PluginID, id, "config_list.yaml", messageKeyPairs(withDefaults(cc.List.messageKeys, listMessageDefaults))); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
if cc.Form != nil {
|
||||
if err := check(cc.PluginID, id, "config_form.yaml", messageKeyPairs(withDefaults(cc.Form.messageKeys, formMessageDefaults))); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
names := make([]string, 0, len(cc.Relations))
|
||||
for name := range cc.Relations {
|
||||
names = append(names, name)
|
||||
}
|
||||
sort.Strings(names)
|
||||
for _, name := range names {
|
||||
if schema := cc.Relations[name].Schema; schema != nil {
|
||||
if err := check(cc.PluginID, id, "config_relation.yaml", messageKeyPairs(schema.relationMessageKeySet())); err != nil {
|
||||
return fmt.Errorf("relation %s: %w", name, err)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
354
modules/cabana/messages_test.go
Normal file
354
modules/cabana/messages_test.go
Normal file
@@ -0,0 +1,354 @@
|
||||
package cabana
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"io/fs"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"strings"
|
||||
"testing"
|
||||
"testing/fstest"
|
||||
|
||||
"git.golem15.com/golem15/summercms/modules/backpack"
|
||||
"git.golem15.com/golem15/summercms/modules/phrasebook"
|
||||
"git.golem15.com/golem15/summercms/modules/towel"
|
||||
)
|
||||
|
||||
type langPlugin struct {
|
||||
id string
|
||||
lang fs.FS
|
||||
}
|
||||
|
||||
func (p langPlugin) ID() string { return p.id }
|
||||
func (p langPlugin) LangFS() fs.FS { return p.lang }
|
||||
|
||||
// messagesTranslator activates phrasebook with the framework backend strings
|
||||
// and an acme.demo catalog.
|
||||
func messagesTranslator(t *testing.T) *phrasebook.Translator {
|
||||
t.Helper()
|
||||
app := backpack.New(nil)
|
||||
demo := fstest.MapFS{
|
||||
"lang/pl/lang.yaml": {Data: []byte(`widgets:
|
||||
count:
|
||||
one: ":count widżet"
|
||||
few: ":count widżety"
|
||||
many: ":count widżetów"
|
||||
other: ":count widżetu"
|
||||
create: Nowy widżet
|
||||
saved: Widżet „:name” zapisany
|
||||
link: Dodaj edytora
|
||||
`)},
|
||||
"lang/en/lang.yaml": {Data: []byte(`widgets:
|
||||
count:
|
||||
one: ":count widget"
|
||||
other: ":count widgets"
|
||||
create: New widget
|
||||
saved: Widget “:name” saved
|
||||
link: Add editor
|
||||
`)},
|
||||
}
|
||||
if err := phrasebook.Activate(app, []langPlugin{{id: "acme.demo", lang: demo}}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
tr, ok := app.Lookup[*phrasebook.Translator]()
|
||||
if !ok || tr == nil {
|
||||
t.Fatal("translator missing")
|
||||
}
|
||||
return tr
|
||||
}
|
||||
|
||||
const messagesListConfig = `modelClass: Widget
|
||||
list: ~/plugins/acme/demo/models/widget/columns.yaml
|
||||
recordsPerPage: 20
|
||||
showCheckboxes: true
|
||||
toolbar:
|
||||
buttons: [create, delete]
|
||||
search:
|
||||
prompt: backend::lang.list.search_prompt
|
||||
messages:
|
||||
recordCount: acme.demo::lang.widgets.count
|
||||
create: acme.demo::lang.widgets.create
|
||||
`
|
||||
|
||||
func localeCtx(locale string) context.Context {
|
||||
return towel.WithLocale(context.Background(), locale)
|
||||
}
|
||||
|
||||
func TestPhase10Messages(t *testing.T) {
|
||||
tr := messagesTranslator(t)
|
||||
schema, err := CompileList("acme.demo", schemaController{}, listFS(messagesListConfig, "columns: {}\n"))
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
pl, err := schema.Localize(localeCtx("pl"), tr)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
m := pl.Messages
|
||||
if m == nil {
|
||||
t.Fatal("localized list has no messages")
|
||||
}
|
||||
if len(m.RecordCount) != 4 || m.RecordCount["few"] != ":count widżety" || m.RecordCount["many"] != ":count widżetów" {
|
||||
t.Fatalf("plural recordCount=%v", m.RecordCount)
|
||||
}
|
||||
if m.Create["other"] != "Nowy widżet" {
|
||||
t.Fatalf("plugin create=%v", m.Create)
|
||||
}
|
||||
for name, got := range map[string]MessageForms{
|
||||
"deleteConfirm": m.DeleteConfirm,
|
||||
"searchPrompt": m.SearchPrompt,
|
||||
"empty": m.Empty,
|
||||
"deleteSelected": m.DeleteSelected,
|
||||
"selected": m.Selected,
|
||||
} {
|
||||
if got["other"] == "" || strings.Contains(got["other"], "::") {
|
||||
t.Fatalf("default %s did not resolve: %v", name, got)
|
||||
}
|
||||
}
|
||||
if m.DeleteConfirm["other"] != "Usunąć zaznaczone (:count)?" || m.SearchPrompt["other"] != "Szukaj…" {
|
||||
t.Fatalf("framework defaults: deleteConfirm=%v searchPrompt=%v", m.DeleteConfirm, m.SearchPrompt)
|
||||
}
|
||||
if len(m.Deleted) != 4 || m.Deleted["one"] != "Usunięto :count rekord" {
|
||||
t.Fatalf("default plural deleted=%v", m.Deleted)
|
||||
}
|
||||
en, err := schema.Localize(localeCtx("en"), tr)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if en.Messages.RecordCount["one"] != ":count widget" || len(en.Messages.RecordCount) != 2 || en.Messages.Create["other"] != "New widget" {
|
||||
t.Fatalf("en messages=%+v", en.Messages)
|
||||
}
|
||||
raw, err := json.Marshal(pl)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if !strings.Contains(string(raw), `"messages":{"recordCount":{`) {
|
||||
t.Fatalf("served list JSON has no messages: %s", raw)
|
||||
}
|
||||
if schema.Messages.RecordCount["other"] != "acme.demo::lang.widgets.count" {
|
||||
t.Fatalf("cached schema lost its keys: %v", schema.Messages.RecordCount)
|
||||
}
|
||||
|
||||
t.Run("form", func(t *testing.T) {
|
||||
config := `name: acme.demo::lang.widgets.create
|
||||
form: ~/plugins/acme/demo/models/widget/fields.yaml
|
||||
modelClass: Widget
|
||||
defaultRedirect: acme/demo/widgets
|
||||
create:
|
||||
redirect: acme/demo/widgets/update/:id
|
||||
redirectClose: acme/demo/widgets
|
||||
update:
|
||||
redirect: acme/demo/widgets
|
||||
redirectClose: acme/demo/widgets
|
||||
messages:
|
||||
saved: acme.demo::lang.widgets.saved
|
||||
`
|
||||
form, err := CompileForm("acme.demo", schemaController{}, formFS(config, "fields:\n name:\n type: text\n"))
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
view, err := form.Localize(localeCtx("pl"), tr, nil)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if view.Messages.Saved["other"] != "Widżet „:name” zapisany" || view.Messages.Create["other"] != "Nowy widżet" || view.Messages.Update["other"] != "Edycja rekordu" {
|
||||
t.Fatalf("form messages=%+v", view.Messages)
|
||||
}
|
||||
want := FormRedirects{Default: "acme/demo/widgets",
|
||||
Create: FormRedirect{Redirect: "acme/demo/widgets/update/:id", RedirectClose: "acme/demo/widgets"},
|
||||
Update: FormRedirect{Redirect: "acme/demo/widgets", RedirectClose: "acme/demo/widgets"}}
|
||||
if view.Redirects != want {
|
||||
t.Fatalf("redirects=%+v", view.Redirects)
|
||||
}
|
||||
raw, err := view.CanonicalJSON()
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if !strings.Contains(string(raw), `"redirects":{"default":"acme/demo/widgets"`) || !strings.Contains(string(raw), `"saved":{"other":`) {
|
||||
t.Fatalf("form view JSON=%s", raw)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("relation", func(t *testing.T) {
|
||||
yaml := strings.Replace(validRelationYAML, "editors:\n label: demo.editors\n", "editors:\n label: demo.editors\n messages:\n link: acme.demo::lang.widgets.link\n", 1)
|
||||
ctl := relationTestController{}
|
||||
fsys := relationTestFS(yaml)
|
||||
form, err := CompileForm("acme.demo", ctl, fsys)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
relations, err := compileRelations("acme.demo", ctl, fsys, form)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
view := relations["editors"].Schema.Localize(localeCtx("pl"), tr)
|
||||
if view.Messages.Link["other"] != "Dodaj edytora" || len(view.Messages.Linked) != 4 || view.Messages.Linked["few"] != "Dołączono :count rekordy" {
|
||||
t.Fatalf("relation messages=%+v", view.Messages)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("unknown key fails at boot", func(t *testing.T) {
|
||||
list := strings.Replace(messagesListConfig, " create: acme.demo::lang.widgets.create\n", " create: acme.demo::lang.widgets.create\n bogusKey: x\n", 1)
|
||||
if _, err := CompileList("acme.demo", schemaController{}, listFS(list, "columns: {}\n")); err == nil || !strings.Contains(err.Error(), "bogusKey") || !strings.Contains(err.Error(), "config_list.yaml") {
|
||||
t.Fatalf("list err=%v", err)
|
||||
}
|
||||
form := "form: ~/plugins/acme/demo/models/widget/fields.yaml\nmodelClass: Widget\nmessages:\n toast: x\n"
|
||||
if _, err := CompileForm("acme.demo", schemaController{}, formFS(form, "fields: {}\n")); err == nil || !strings.Contains(err.Error(), "toast") {
|
||||
t.Fatalf("form err=%v", err)
|
||||
}
|
||||
yaml := strings.Replace(validRelationYAML, " label: demo.editors\n", " label: demo.editors\n messages:\n bogusKey: x\n", 1)
|
||||
ctl := relationTestController{}
|
||||
fsys := relationTestFS(yaml)
|
||||
compiled, _ := CompileForm("acme.demo", ctl, fsys)
|
||||
if _, err := compileRelations("acme.demo", ctl, fsys, compiled); err == nil || !strings.Contains(err.Error(), "bogusKey") {
|
||||
t.Fatalf("relation err=%v", err)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("missing phrase key fails at boot", func(t *testing.T) {
|
||||
list := strings.Replace(messagesListConfig, "acme.demo::lang.widgets.count", "acme.demo::lang.widgets.missing", 1)
|
||||
reg, err := compileRegistry([]controllerRef{{plugin: formPlugin{fsys: listFS(list, "columns: {}\n")}, ctl: schemaController{}}})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
err = validateMessageKeys(reg, tr)
|
||||
if err == nil || !strings.Contains(err.Error(), "messages.recordCount") || !strings.Contains(err.Error(), "acme.demo::lang.widgets.missing") || !strings.Contains(err.Error(), "acme.demo.widgets") {
|
||||
t.Fatalf("err=%v", err)
|
||||
}
|
||||
ok, err := compileRegistry([]controllerRef{{plugin: formPlugin{fsys: listFS(messagesListConfig, "columns: {}\n")}, ctl: schemaController{}}})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := validateMessageKeys(ok, tr); err != nil {
|
||||
t.Fatalf("declared keys failed: %v", err)
|
||||
}
|
||||
if err := validateMessageKeys(reg, nil); err != nil {
|
||||
t.Fatalf("no translator must skip the check: %v", err)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func TestPhase10Toolbar(t *testing.T) {
|
||||
base := "modelClass: Widget\nlist: ~/plugins/acme/demo/models/widget/columns.yaml\nshowCheckboxes: true\ntoolbar:\n buttons: BUTTONS\n"
|
||||
compile := func(buttons string, checkboxes bool) (*ListSchema, error) {
|
||||
config := strings.Replace(base, "BUTTONS", buttons, 1)
|
||||
if !checkboxes {
|
||||
config = strings.Replace(config, "showCheckboxes: true\n", "", 1)
|
||||
}
|
||||
return CompileList("acme.demo", schemaController{}, listFS(config, "columns: {}\n"))
|
||||
}
|
||||
for _, tc := range []struct {
|
||||
buttons string
|
||||
want []string
|
||||
}{
|
||||
{"[create, delete]", []string{"create", "delete"}},
|
||||
{"[delete, create]", []string{"delete", "create"}},
|
||||
{"[create]", []string{"create"}},
|
||||
{"[]", []string{}},
|
||||
{"\n - delete\n - create", []string{"delete", "create"}},
|
||||
} {
|
||||
schema, err := compile(tc.buttons, true)
|
||||
if err != nil {
|
||||
t.Fatalf("%s: %v", tc.buttons, err)
|
||||
}
|
||||
if strings.Join(schema.ToolbarButtons, ",") != strings.Join(tc.want, ",") {
|
||||
t.Fatalf("%s compiled %v want %v", tc.buttons, schema.ToolbarButtons, tc.want)
|
||||
}
|
||||
}
|
||||
for _, tc := range []struct {
|
||||
buttons string
|
||||
checkboxes bool
|
||||
want string
|
||||
}{
|
||||
{"list_toolbar", true, "toolbar.buttons must be a list"},
|
||||
{"list_toolbar", true, `"list_toolbar" is not supported`},
|
||||
{"[create, delete]", false, "showCheckboxes"},
|
||||
{"[create, create]", true, "duplicate action create"},
|
||||
{"[create, export]", true, "unsupported action export"},
|
||||
{"[{create: true}]", true, "toolbar.buttons"},
|
||||
} {
|
||||
_, err := compile(tc.buttons, tc.checkboxes)
|
||||
if err == nil || !strings.Contains(err.Error(), tc.want) || !strings.Contains(err.Error(), "acme.demo.widgets") {
|
||||
t.Fatalf("%s err=%v want %q", tc.buttons, err, tc.want)
|
||||
}
|
||||
}
|
||||
|
||||
// A controller without a compiled form cannot create: create is dropped.
|
||||
reg, err := compileRegistry([]controllerRef{{plugin: formPlugin{fsys: listFS(strings.Replace(base, "BUTTONS", "[create, delete]", 1), "columns: {}\n")}, ctl: schemaController{}}})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
cc, _ := reg.Get("acme.demo.widgets")
|
||||
if strings.Join(cc.List.ToolbarButtons, ",") != "delete" {
|
||||
t.Fatalf("form-less toolbar=%v", cc.List.ToolbarButtons)
|
||||
}
|
||||
}
|
||||
|
||||
func TestPhase10Bundle(t *testing.T) {
|
||||
tr := messagesTranslator(t)
|
||||
app := backpack.New(nil)
|
||||
if err := app.Publish(tr); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
svc := &service{app: app}
|
||||
call := func(locale string) (map[string]map[string]string, string, *httptest.ResponseRecorder) {
|
||||
t.Helper()
|
||||
req := httptest.NewRequest(http.MethodGet, adminAPI("/lang"), nil)
|
||||
if locale != "" {
|
||||
req = req.WithContext(towel.WithLocale(req.Context(), locale))
|
||||
}
|
||||
rec := httptest.NewRecorder()
|
||||
svc.langBundle(rec, req)
|
||||
if rec.Code != http.StatusOK {
|
||||
t.Fatalf("status=%d body=%s", rec.Code, rec.Body.String())
|
||||
}
|
||||
var body struct {
|
||||
Data map[string]map[string]string `json:"data"`
|
||||
Meta struct {
|
||||
Locale string `json:"locale"`
|
||||
} `json:"meta"`
|
||||
}
|
||||
dec := json.NewDecoder(strings.NewReader(rec.Body.String()))
|
||||
dec.DisallowUnknownFields()
|
||||
if err := dec.Decode(&body); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return body.Data, body.Meta.Locale, rec
|
||||
}
|
||||
pl, locale, rec := call("pl")
|
||||
if locale != "pl" || rec.Header().Get("Cache-Control") != "no-cache" {
|
||||
t.Fatalf("locale=%q cache=%q", locale, rec.Header().Get("Cache-Control"))
|
||||
}
|
||||
if pl["backend::lang.form.save"]["other"] != "Zapisz" || len(pl["backend::lang.list.results"]) != 4 {
|
||||
t.Fatalf("pl bundle save=%v results=%v", pl["backend::lang.form.save"], pl["backend::lang.list.results"])
|
||||
}
|
||||
if len(pl) < 50 {
|
||||
t.Fatalf("pl bundle has only %d keys", len(pl))
|
||||
}
|
||||
for key := range pl {
|
||||
if !strings.HasPrefix(key, "backend::lang.") {
|
||||
t.Fatalf("bundle leaked a key outside backend::lang: %s", key)
|
||||
}
|
||||
}
|
||||
if strings.Contains(rec.Body.String(), "acme.demo::") || strings.Contains(rec.Body.String(), "lagoon::") {
|
||||
t.Fatalf("bundle leaked another namespace: %s", rec.Body.String())
|
||||
}
|
||||
en, locale, _ := call("en-GB")
|
||||
if locale != "en" || en["backend::lang.form.save"]["other"] != "Save" {
|
||||
t.Fatalf("en-GB locale=%q save=%v", locale, en["backend::lang.form.save"])
|
||||
}
|
||||
fallback, locale, _ := call("de")
|
||||
if locale != "en" || fallback["backend::lang.form.save"]["other"] != "Save" {
|
||||
t.Fatalf("de falls back to en: locale=%q save=%v", locale, fallback["backend::lang.form.save"])
|
||||
}
|
||||
// No translator: an empty bundle, still an envelope.
|
||||
empty := &service{app: backpack.New(nil)}
|
||||
req := httptest.NewRequest(http.MethodGet, adminAPI("/lang"), nil)
|
||||
out := httptest.NewRecorder()
|
||||
empty.langBundle(out, req)
|
||||
if out.Code != http.StatusOK || !strings.Contains(out.Body.String(), `"data":{}`) {
|
||||
t.Fatalf("no translator status=%d body=%s", out.Code, out.Body.String())
|
||||
}
|
||||
}
|
||||
213
modules/cabana/metadata_settings_test.go
Normal file
213
modules/cabana/metadata_settings_test.go
Normal file
@@ -0,0 +1,213 @@
|
||||
package cabana
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"io/fs"
|
||||
"reflect"
|
||||
"strings"
|
||||
"testing"
|
||||
"testing/fstest"
|
||||
"time"
|
||||
|
||||
"git.golem15.com/golem15/summercms/modules/backpack"
|
||||
"git.golem15.com/golem15/summercms/modules/bouncer"
|
||||
"git.golem15.com/golem15/summercms/modules/pact"
|
||||
"git.golem15.com/golem15/summercms/modules/party"
|
||||
"gorm.io/gorm"
|
||||
)
|
||||
|
||||
type contributionPlugin struct {
|
||||
id string
|
||||
permissions []pact.Permission
|
||||
navigation []pact.NavigationItem
|
||||
settings []pact.SettingsItem
|
||||
fsys fs.FS
|
||||
}
|
||||
|
||||
func (p contributionPlugin) ID() string { return p.id }
|
||||
func (p contributionPlugin) Requires() []string { return nil }
|
||||
func (p contributionPlugin) Register(*backpack.App) error { return nil }
|
||||
func (p contributionPlugin) Boot(*backpack.App) error { return nil }
|
||||
func (p contributionPlugin) Permissions() []pact.Permission { return p.permissions }
|
||||
func (p contributionPlugin) Navigation() []pact.NavigationItem { return p.navigation }
|
||||
func (p contributionPlugin) Settings() []pact.SettingsItem { return p.settings }
|
||||
func (p contributionPlugin) AdminFS() fs.FS { return p.fsys }
|
||||
|
||||
type metadataController struct{ id string }
|
||||
|
||||
func (c metadataController) ID() string { return c.id }
|
||||
func (metadataController) ModelName() string { return "Metadata" }
|
||||
func (metadataController) ConfigDir() string { return "controllers/metadata" }
|
||||
func (metadataController) RequiredPermissions() []string { return []string{"acme.demo.access"} }
|
||||
|
||||
type singletonSetting struct {
|
||||
ID uint `gorm:"column:id;primaryKey"`
|
||||
Enabled bool `gorm:"column:enabled"`
|
||||
CreatedAt time.Time `gorm:"column:created_at"`
|
||||
UpdatedAt time.Time `gorm:"column:updated_at"`
|
||||
}
|
||||
|
||||
func (singletonSetting) TableName() string { return "cabana_singleton_settings" }
|
||||
func (singletonSetting) Fillable() []string { return []string{"enabled"} }
|
||||
func (singletonSetting) Rules() map[string]string { return map[string]string{"enabled": "boolean"} }
|
||||
|
||||
func TestMetadataPermissionRegistry(t *testing.T) {
|
||||
plugin := metadataPlugin()
|
||||
reg := metadataRegistry()
|
||||
if err := compileContributions(reg, []party.Plugin{plugin}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
grants := reg.rolePermissions("developer")
|
||||
if !grants["acme.demo.access"] || !grants["acme.demo.manage_settings"] {
|
||||
t.Fatalf("developer grants = %#v", grants)
|
||||
}
|
||||
if grants := reg.rolePermissions("publisher"); len(grants) != 0 {
|
||||
t.Fatalf("publisher grants = %#v", grants)
|
||||
}
|
||||
|
||||
bad := metadataRegistry()
|
||||
bad.byID["acme.demo.widgets"].Controller = metadataController{id: "acme.demo.widgets"}
|
||||
bad.byID["acme.demo.widgets"].Controller = unknownPermissionController{}
|
||||
if err := compileContributions(bad, []party.Plugin{plugin}); err == nil || !strings.Contains(err.Error(), "unknown permission") {
|
||||
t.Fatalf("unknown permission error = %v", err)
|
||||
}
|
||||
|
||||
duplicate := contributionPlugin{id: "other.demo", permissions: plugin.permissions}
|
||||
if err := compileContributions(metadataRegistry(), []party.Plugin{plugin, duplicate}); err == nil || !strings.Contains(err.Error(), "duplicate permission") {
|
||||
t.Fatalf("duplicate permission error = %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestMetadataFiltering(t *testing.T) {
|
||||
plugin := metadataPlugin()
|
||||
reg := metadataRegistry()
|
||||
if err := compileContributions(reg, []party.Plugin{plugin}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
developer := &bouncer.Principal{ID: 1, Backend: true, PermissionGrants: reg.rolePermissions("developer")}
|
||||
navigation, settings := reg.Metadata(context.Background(), developer, nil)
|
||||
if len(navigation) != 1 || len(navigation[0].SideMenu) != 1 || navigation[0].Code != "demo" || navigation[0].SideMenu[0].Code != "widgets" {
|
||||
t.Fatalf("developer navigation = %#v", navigation)
|
||||
}
|
||||
if len(settings) != 1 || settings[0].Code != "demo" || !reflect.DeepEqual(settings[0].Keywords, []string{"demo", "settings"}) {
|
||||
t.Fatalf("developer settings = %#v", settings)
|
||||
}
|
||||
|
||||
denied := &bouncer.Principal{ID: 2, Backend: true, PermissionGrants: map[string]bool{}}
|
||||
navigation, settings = reg.Metadata(context.Background(), denied, nil)
|
||||
if navigation == nil || settings == nil || len(navigation) != 0 || len(settings) != 0 {
|
||||
t.Fatalf("denied metadata = %#v %#v", navigation, settings)
|
||||
}
|
||||
frontend := &bouncer.Principal{ID: 1, PermissionGrants: reg.rolePermissions("developer")}
|
||||
navigation, settings = reg.Metadata(context.Background(), frontend, nil)
|
||||
if len(navigation) != 0 || len(settings) != 0 {
|
||||
t.Fatalf("frontend principal leaked metadata = %#v %#v", navigation, settings)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSettingsSingletonLifecycle(t *testing.T) {
|
||||
_, db := newListService(t)
|
||||
if err := db.Migrator().DropTable(&singletonSetting{}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := db.AutoMigrate(&singletonSetting{}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
setting, err := compileSetting("acme.demo", metadataPlugin().settings[0], metadataFS())
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
svc := SettingsService{DB: db}
|
||||
missing, err := svc.Get(context.Background(), setting)
|
||||
if err != nil || missing.Exists || missing.Data["enabled"] != false {
|
||||
t.Fatalf("missing = %#v err=%v", missing, err)
|
||||
}
|
||||
assertSettingCount(t, db, 0)
|
||||
if _, err := svc.Put(context.Background(), setting, map[string]any{}); err == nil {
|
||||
t.Fatal("missing required setting succeeded")
|
||||
}
|
||||
created, err := svc.Put(context.Background(), setting, map[string]any{"enabled": true, "id": 99})
|
||||
if err != nil || !created.Exists || created.Data["enabled"] != true {
|
||||
t.Fatalf("created = %#v err=%v", created, err)
|
||||
}
|
||||
assertSettingCount(t, db, 1)
|
||||
var before singletonSetting
|
||||
if err := db.First(&before, 1).Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
replayed, err := svc.Put(context.Background(), setting, map[string]any{"enabled": true})
|
||||
if err != nil || replayed.Data["enabled"] != true {
|
||||
t.Fatalf("replay = %#v err=%v", replayed, err)
|
||||
}
|
||||
var after singletonSetting
|
||||
if err := db.First(&after, 1).Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if !after.UpdatedAt.Equal(before.UpdatedAt) || after.ID != 1 {
|
||||
t.Fatalf("replay mutated singleton before=%+v after=%+v", before, after)
|
||||
}
|
||||
if _, err := svc.Put(context.Background(), setting, map[string]any{"enabled": "not-bool"}); err == nil {
|
||||
t.Fatal("invalid boolean succeeded")
|
||||
} else {
|
||||
var invalid *ValidationError
|
||||
if !errors.As(err, &invalid) {
|
||||
t.Fatalf("invalid boolean error = %T %v", err, err)
|
||||
}
|
||||
}
|
||||
var preserved singletonSetting
|
||||
if err := db.First(&preserved, 1).Error; err != nil || !preserved.Enabled {
|
||||
t.Fatalf("failed update was not rolled back: %+v err=%v", preserved, err)
|
||||
}
|
||||
}
|
||||
|
||||
type unknownPermissionController struct{}
|
||||
|
||||
func (unknownPermissionController) ID() string { return "acme.demo.widgets" }
|
||||
func (unknownPermissionController) ModelName() string { return "Metadata" }
|
||||
func (unknownPermissionController) ConfigDir() string { return "controllers/metadata" }
|
||||
func (unknownPermissionController) RequiredPermissions() []string {
|
||||
return []string{"acme.demo.unknown"}
|
||||
}
|
||||
|
||||
func metadataRegistry() *Registry {
|
||||
return &Registry{byID: map[string]*CompiledController{
|
||||
"acme.demo.widgets": {Controller: metadataController{id: "acme.demo.widgets"}, Relations: map[string]*CompiledRelation{}},
|
||||
}}
|
||||
}
|
||||
|
||||
func metadataPlugin() contributionPlugin {
|
||||
return contributionPlugin{
|
||||
id: "acme.demo",
|
||||
permissions: []pact.Permission{
|
||||
{Code: "acme.demo.access", Roles: []string{"developer"}},
|
||||
{Code: "acme.demo.manage_settings", Roles: []string{"developer"}},
|
||||
},
|
||||
navigation: []pact.NavigationItem{{
|
||||
Code: "demo", Label: "Demo", Icon: "icon", Order: 20, Controller: "acme.demo.widgets",
|
||||
Permissions: []string{"acme.demo.*"},
|
||||
SideMenu: []pact.NavigationItem{{Code: "widgets", Label: "Widgets", Controller: "acme.demo.widgets", Permissions: []string{"acme.demo.access"}}},
|
||||
}},
|
||||
settings: []pact.SettingsItem{{
|
||||
Code: "demo", Label: "Settings", Description: "Description", Category: "Demo", Icon: "icon-cog",
|
||||
Model: "Settings", Order: 20, Keywords: []string{"demo", "settings"}, Permissions: []string{"acme.demo.manage_settings"},
|
||||
Form: "models/settings/fields.yaml", NewModel: func() any { return &singletonSetting{} },
|
||||
}},
|
||||
fsys: metadataFS(),
|
||||
}
|
||||
}
|
||||
|
||||
func metadataFS() fs.FS {
|
||||
return fstest.MapFS{"models/settings/fields.yaml": {Data: []byte("fields:\n enabled:\n type: switch\n default: 0\n required: true\n")}}
|
||||
}
|
||||
|
||||
func assertSettingCount(t *testing.T, db *gorm.DB, want int64) {
|
||||
t.Helper()
|
||||
var got int64
|
||||
if err := db.Model(&singletonSetting{}).Count(&got).Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if got != want {
|
||||
t.Fatalf("settings count=%d want=%d", got, want)
|
||||
}
|
||||
}
|
||||
94
modules/cabana/navigation.go
Normal file
94
modules/cabana/navigation.go
Normal file
@@ -0,0 +1,94 @@
|
||||
package cabana
|
||||
|
||||
import (
|
||||
"context"
|
||||
"sort"
|
||||
|
||||
"git.golem15.com/golem15/summercms/modules/bouncer"
|
||||
"git.golem15.com/golem15/summercms/modules/pact"
|
||||
"git.golem15.com/golem15/summercms/modules/phrasebook"
|
||||
)
|
||||
|
||||
// NavigationEntry is one permission-filtered backend navigation item.
|
||||
type NavigationEntry struct {
|
||||
Code string `json:"code"`
|
||||
Label string `json:"label"`
|
||||
Icon string `json:"icon"`
|
||||
Order int `json:"order"`
|
||||
Controller string `json:"controller"`
|
||||
SideMenu []NavigationEntry `json:"sideMenu"`
|
||||
}
|
||||
|
||||
// SettingsEntry is one permission-filtered settings-list item.
|
||||
type SettingsEntry struct {
|
||||
Code string `json:"code"`
|
||||
Label string `json:"label"`
|
||||
Description string `json:"description"`
|
||||
Category string `json:"category"`
|
||||
Icon string `json:"icon"`
|
||||
Order int `json:"order"`
|
||||
Keywords []string `json:"keywords"`
|
||||
Model string `json:"model"`
|
||||
}
|
||||
|
||||
// Metadata returns only entries the backend principal may open. Denied
|
||||
// entries are removed before any response value is constructed.
|
||||
func (r *Registry) Metadata(ctx context.Context, principal *bouncer.Principal, tr *phrasebook.Translator) ([]NavigationEntry, []SettingsEntry) {
|
||||
navigation := make([]NavigationEntry, 0)
|
||||
settings := make([]SettingsEntry, 0)
|
||||
if r == nil || principal == nil || !principal.Backend {
|
||||
return navigation, settings
|
||||
}
|
||||
for _, item := range r.navigation {
|
||||
children := make([]NavigationEntry, 0)
|
||||
for _, child := range item.SideMenu {
|
||||
if !Allows(principal, child.Permissions) {
|
||||
continue
|
||||
}
|
||||
children = append(children, navigationView(ctx, tr, child, nil))
|
||||
}
|
||||
if !Allows(principal, item.Permissions) && len(children) == 0 {
|
||||
continue
|
||||
}
|
||||
navigation = append(navigation, navigationView(ctx, tr, item, children))
|
||||
}
|
||||
sort.SliceStable(navigation, func(i, j int) bool {
|
||||
if navigation[i].Order == navigation[j].Order {
|
||||
return navigation[i].Code < navigation[j].Code
|
||||
}
|
||||
return navigation[i].Order < navigation[j].Order
|
||||
})
|
||||
for _, compiled := range r.settings {
|
||||
item := compiled.Item
|
||||
if !Allows(principal, item.Permissions) {
|
||||
continue
|
||||
}
|
||||
keywords := append([]string(nil), item.Keywords...)
|
||||
if keywords == nil {
|
||||
keywords = []string{}
|
||||
}
|
||||
settings = append(settings, SettingsEntry{
|
||||
Code: item.Code, Label: translateKey(ctx, tr, item.Label),
|
||||
Description: translateKey(ctx, tr, item.Description),
|
||||
Category: translateKey(ctx, tr, item.Category), Icon: item.Icon,
|
||||
Order: item.Order, Keywords: keywords, Model: item.Model,
|
||||
})
|
||||
}
|
||||
sort.SliceStable(settings, func(i, j int) bool {
|
||||
if settings[i].Order == settings[j].Order {
|
||||
return settings[i].Code < settings[j].Code
|
||||
}
|
||||
return settings[i].Order < settings[j].Order
|
||||
})
|
||||
return navigation, settings
|
||||
}
|
||||
|
||||
func navigationView(ctx context.Context, tr *phrasebook.Translator, item pact.NavigationItem, children []NavigationEntry) NavigationEntry {
|
||||
if children == nil {
|
||||
children = []NavigationEntry{}
|
||||
}
|
||||
return NavigationEntry{
|
||||
Code: item.Code, Label: translateKey(ctx, tr, item.Label), Icon: item.Icon,
|
||||
Order: item.Order, Controller: item.Controller, SideMenu: children,
|
||||
}
|
||||
}
|
||||
494
modules/cabana/openapi_conformance_test.go
Normal file
494
modules/cabana/openapi_conformance_test.go
Normal file
@@ -0,0 +1,494 @@
|
||||
package cabana_test
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"io/fs"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"runtime"
|
||||
"strings"
|
||||
"testing"
|
||||
"testing/fstest"
|
||||
"time"
|
||||
|
||||
"git.golem15.com/golem15/summercms/modules/backpack"
|
||||
"git.golem15.com/golem15/summercms/modules/cabana"
|
||||
"git.golem15.com/golem15/summercms/modules/compass"
|
||||
"git.golem15.com/golem15/summercms/modules/lagoon"
|
||||
"git.golem15.com/golem15/summercms/modules/pact"
|
||||
"git.golem15.com/golem15/summercms/modules/party"
|
||||
"git.golem15.com/golem15/summercms/modules/phrasebook"
|
||||
"git.golem15.com/golem15/summercms/modules/surf"
|
||||
"gorm.io/gorm"
|
||||
)
|
||||
|
||||
// conformCase is one inventoried admin route called for real through the
|
||||
// assembled router. decode must accept the body with unknown fields
|
||||
// disallowed, and ref is the success schema admin.json documents.
|
||||
type conformCase struct {
|
||||
key string
|
||||
status int
|
||||
ref string
|
||||
call func(t *testing.T, env *conformEnv) *httptest.ResponseRecorder
|
||||
decode func(dec *json.Decoder) error
|
||||
}
|
||||
|
||||
func into[T any]() func(*json.Decoder) error {
|
||||
return func(dec *json.Decoder) error {
|
||||
var out T
|
||||
return dec.Decode(&out)
|
||||
}
|
||||
}
|
||||
|
||||
// TestPhase10OpenAPIConformance calls every route of the admin inventory
|
||||
// against a PostgreSQL-backed fixture registry (acme names only), decodes
|
||||
// each real response into the Go type its annotation documents with unknown
|
||||
// fields disallowed, and checks admin/openapi/admin.json names that type for
|
||||
// the same path, method and status (D-15, D-16; Pitfall 8).
|
||||
func TestPhase10OpenAPIConformance(t *testing.T) {
|
||||
env := newConformEnv(t)
|
||||
spec := conformSpec(t)
|
||||
|
||||
cases := []conformCase{
|
||||
{"POST /auth/login", 200, "cabana.Envelope-cabana_AdminLoginData", func(t *testing.T, e *conformEnv) *httptest.ResponseRecorder {
|
||||
return e.send(t, http.MethodPost, "/auth/login", map[string]string{"login": e.login, "password": adminTestPassword}, false)
|
||||
}, into[cabana.Envelope[cabana.AdminLoginData]]()},
|
||||
{"POST /auth/refresh", 200, "cabana.Envelope-cabana_AdminLoginData", func(t *testing.T, e *conformEnv) *httptest.ResponseRecorder {
|
||||
rec := e.send(t, http.MethodPost, "/auth/refresh", nil, true)
|
||||
e.token = accessToken(t, rec.Body.Bytes())
|
||||
return rec
|
||||
}, into[cabana.Envelope[cabana.AdminLoginData]]()},
|
||||
{"GET /auth/me", 200, "cabana.Envelope-cabana_AdminProfile", func(t *testing.T, e *conformEnv) *httptest.ResponseRecorder {
|
||||
return e.send(t, http.MethodGet, "/auth/me", nil, true)
|
||||
}, into[cabana.Envelope[cabana.AdminProfile]]()},
|
||||
{"GET /lang", 200, "cabana.Envelope-cabana_LangBundle", func(t *testing.T, e *conformEnv) *httptest.ResponseRecorder {
|
||||
return e.send(t, http.MethodGet, "/lang", nil, false)
|
||||
}, into[cabana.Envelope[cabana.LangBundle]]()},
|
||||
{"GET /navigation", 200, "cabana.Envelope-array_cabana_NavigationEntry", func(t *testing.T, e *conformEnv) *httptest.ResponseRecorder {
|
||||
return e.send(t, http.MethodGet, "/navigation", nil, true)
|
||||
}, into[cabana.Envelope[[]cabana.NavigationEntry]]()},
|
||||
{"GET /settings", 200, "cabana.Envelope-array_cabana_SettingsEntry", func(t *testing.T, e *conformEnv) *httptest.ResponseRecorder {
|
||||
return e.send(t, http.MethodGet, "/settings", nil, true)
|
||||
}, into[cabana.Envelope[[]cabana.SettingsEntry]]()},
|
||||
{"GET /settings/{code}/schema", 200, "cabana.Envelope-cabana_FormView", func(t *testing.T, e *conformEnv) *httptest.ResponseRecorder {
|
||||
return e.send(t, http.MethodGet, "/settings/conform/schema", nil, true)
|
||||
}, into[cabana.Envelope[cabana.FormView]]()},
|
||||
{"GET /settings/{code}", 200, "cabana.Envelope-cabana_SettingsResult", func(t *testing.T, e *conformEnv) *httptest.ResponseRecorder {
|
||||
return e.send(t, http.MethodGet, "/settings/conform", nil, true)
|
||||
}, into[cabana.Envelope[cabana.SettingsResult]]()},
|
||||
{"PUT /settings/{code}", 200, "cabana.Envelope-cabana_SettingsResult", func(t *testing.T, e *conformEnv) *httptest.ResponseRecorder {
|
||||
return e.send(t, http.MethodPut, "/settings/conform", map[string]any{"enabled": true}, true)
|
||||
}, into[cabana.Envelope[cabana.SettingsResult]]()},
|
||||
{"GET /{vendor}/{plugin}/{controller}/schema/list", 200, "cabana.Envelope-cabana_ListSchema", func(t *testing.T, e *conformEnv) *httptest.ResponseRecorder {
|
||||
return e.send(t, http.MethodGet, "/acme/conform/gadgets/schema/list", nil, true)
|
||||
}, into[cabana.Envelope[cabana.ListSchema]]()},
|
||||
{"GET /{vendor}/{plugin}/{controller}/schema/form", 200, "cabana.Envelope-cabana_FormView", func(t *testing.T, e *conformEnv) *httptest.ResponseRecorder {
|
||||
return e.send(t, http.MethodGet, "/acme/conform/gadgets/schema/form", nil, true)
|
||||
}, into[cabana.Envelope[cabana.FormView]]()},
|
||||
{"GET /{vendor}/{plugin}/{controller}/schema/relation/{name}", 200, "cabana.Envelope-cabana_RelationSchema", func(t *testing.T, e *conformEnv) *httptest.ResponseRecorder {
|
||||
return e.send(t, http.MethodGet, "/acme/conform/gadgets/schema/relation/members", nil, true)
|
||||
}, into[cabana.Envelope[cabana.RelationSchema]]()},
|
||||
{"GET /{vendor}/{plugin}/{controller}/fields/{field}/options", 200, "cabana.ListEnvelope-array_cabana_RelationOption", func(t *testing.T, e *conformEnv) *httptest.ResponseRecorder {
|
||||
return e.send(t, http.MethodGet, "/acme/conform/gadgets/fields/group/options?search="+e.stamp, nil, true)
|
||||
}, into[cabana.ListEnvelope[[]cabana.RelationOption]]()},
|
||||
{"GET /{vendor}/{plugin}/{controller}/filters/{scope}/options", 200, "cabana.Envelope-array_cabana_FilterOption", func(t *testing.T, e *conformEnv) *httptest.ResponseRecorder {
|
||||
return e.send(t, http.MethodGet, "/acme/conform/gadgets/filters/grouped/options", nil, true)
|
||||
}, into[cabana.Envelope[[]cabana.FilterOption]]()},
|
||||
{"POST /{vendor}/{plugin}/{controller}", 201, "cabana.RecordEnvelope", func(t *testing.T, e *conformEnv) *httptest.ResponseRecorder {
|
||||
rec := e.send(t, http.MethodPost, "/acme/conform/gadgets", map[string]any{"name": "gadget-" + e.stamp, "active": true, "group": e.groupID}, true)
|
||||
e.gadgetID = dataID(t, rec.Body.Bytes())
|
||||
return rec
|
||||
}, into[cabana.RecordEnvelope]()},
|
||||
{"GET /{vendor}/{plugin}/{controller}", 200, "cabana.ListEnvelope-array_cabana_AdminRecord", func(t *testing.T, e *conformEnv) *httptest.ResponseRecorder {
|
||||
return e.send(t, http.MethodGet, "/acme/conform/gadgets?search="+e.stamp, nil, true)
|
||||
}, into[cabana.ListEnvelope[[]cabana.AdminRecord]]()},
|
||||
{"GET /{vendor}/{plugin}/{controller}/{id}", 200, "cabana.RecordEnvelope", func(t *testing.T, e *conformEnv) *httptest.ResponseRecorder {
|
||||
return e.send(t, http.MethodGet, fmt.Sprintf("/acme/conform/gadgets/%d", e.gadgetID), nil, true)
|
||||
}, into[cabana.RecordEnvelope]()},
|
||||
{"PUT /{vendor}/{plugin}/{controller}/{id}", 200, "cabana.RecordEnvelope", func(t *testing.T, e *conformEnv) *httptest.ResponseRecorder {
|
||||
return e.send(t, http.MethodPut, fmt.Sprintf("/acme/conform/gadgets/%d", e.gadgetID), map[string]any{"name": "gadget-" + e.stamp + "-renamed", "group": nil}, true)
|
||||
}, into[cabana.RecordEnvelope]()},
|
||||
{"GET /{vendor}/{plugin}/{controller}/{id}/relations/{name}/candidates", 200, "cabana.ListEnvelope-array_cabana_AdminRecord", func(t *testing.T, e *conformEnv) *httptest.ResponseRecorder {
|
||||
return e.send(t, http.MethodGet, fmt.Sprintf("/acme/conform/gadgets/%d/relations/members/candidates?search=%s", e.gadgetID, e.stamp), nil, true)
|
||||
}, into[cabana.ListEnvelope[[]cabana.AdminRecord]]()},
|
||||
{"POST /{vendor}/{plugin}/{controller}/{id}/relations/{name}/link", 200, "cabana.Envelope-cabana_RelationMutationResult", func(t *testing.T, e *conformEnv) *httptest.ResponseRecorder {
|
||||
return e.send(t, http.MethodPost, fmt.Sprintf("/acme/conform/gadgets/%d/relations/members/link", e.gadgetID), map[string]any{"ids": []uint{e.memberID}}, true)
|
||||
}, into[cabana.Envelope[cabana.RelationMutationResult]]()},
|
||||
{"GET /{vendor}/{plugin}/{controller}/{id}/relations/{name}", 200, "cabana.ListEnvelope-array_cabana_AdminRecord", func(t *testing.T, e *conformEnv) *httptest.ResponseRecorder {
|
||||
return e.send(t, http.MethodGet, fmt.Sprintf("/acme/conform/gadgets/%d/relations/members", e.gadgetID), nil, true)
|
||||
}, into[cabana.ListEnvelope[[]cabana.AdminRecord]]()},
|
||||
{"POST /{vendor}/{plugin}/{controller}/{id}/relations/{name}/unlink", 200, "cabana.Envelope-cabana_RelationMutationResult", func(t *testing.T, e *conformEnv) *httptest.ResponseRecorder {
|
||||
return e.send(t, http.MethodPost, fmt.Sprintf("/acme/conform/gadgets/%d/relations/members/unlink", e.gadgetID), map[string]any{"ids": []uint{e.memberID}}, true)
|
||||
}, into[cabana.Envelope[cabana.RelationMutationResult]]()},
|
||||
{"POST /{vendor}/{plugin}/{controller}/bulk-delete", 200, "cabana.Envelope-cabana_BulkResult", func(t *testing.T, e *conformEnv) *httptest.ResponseRecorder {
|
||||
spare := e.send(t, http.MethodPost, "/acme/conform/gadgets", map[string]any{"name": "spare-" + e.stamp}, true)
|
||||
return e.send(t, http.MethodPost, "/acme/conform/gadgets/bulk-delete", map[string]any{"ids": []uint{dataID(t, spare.Body.Bytes())}}, true)
|
||||
}, into[cabana.Envelope[cabana.BulkResult]]()},
|
||||
{"DELETE /{vendor}/{plugin}/{controller}/{id}", 200, "cabana.Envelope-cabana_BulkResult", func(t *testing.T, e *conformEnv) *httptest.ResponseRecorder {
|
||||
return e.send(t, http.MethodDelete, fmt.Sprintf("/acme/conform/gadgets/%d", e.gadgetID), nil, true)
|
||||
}, into[cabana.Envelope[cabana.BulkResult]]()},
|
||||
{"POST /auth/logout", 200, "cabana.Envelope-cabana_AdminLogoutData", func(t *testing.T, e *conformEnv) *httptest.ResponseRecorder {
|
||||
return e.send(t, http.MethodPost, "/auth/logout", nil, true)
|
||||
}, into[cabana.Envelope[cabana.AdminLogoutData]]()},
|
||||
}
|
||||
|
||||
inventory := map[string]bool{}
|
||||
for _, key := range cabana.AdminAPIRoutes() {
|
||||
inventory[key] = true
|
||||
}
|
||||
covered := map[string]bool{}
|
||||
for _, tc := range cases {
|
||||
if !inventory[tc.key] {
|
||||
t.Fatalf("conformance case %s is not an inventoried admin route", tc.key)
|
||||
}
|
||||
if covered[tc.key] {
|
||||
t.Fatalf("duplicate conformance case %s", tc.key)
|
||||
}
|
||||
covered[tc.key] = true
|
||||
}
|
||||
for key := range inventory {
|
||||
if !covered[key] {
|
||||
t.Fatalf("admin route %s has no conformance case", key)
|
||||
}
|
||||
}
|
||||
|
||||
for _, tc := range cases {
|
||||
ok := t.Run(tc.key, func(t *testing.T) {
|
||||
rec := tc.call(t, env)
|
||||
if rec.Code != tc.status {
|
||||
t.Fatalf("status=%d want %d body=%s", rec.Code, tc.status, rec.Body.String())
|
||||
}
|
||||
dec := json.NewDecoder(bytes.NewReader(rec.Body.Bytes()))
|
||||
dec.DisallowUnknownFields()
|
||||
if err := tc.decode(dec); err != nil {
|
||||
t.Fatalf("body does not match its documented type: %v\n%s", err, rec.Body.String())
|
||||
}
|
||||
method, path, _ := strings.Cut(tc.key, " ")
|
||||
got := spec.ref(path, strings.ToLower(method), fmt.Sprint(tc.status))
|
||||
if got != tc.ref {
|
||||
t.Fatalf("admin.json documents %q for %s %d, the handler writes %s", got, tc.key, tc.status, tc.ref)
|
||||
}
|
||||
})
|
||||
if !ok {
|
||||
t.FailNow()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
type conformSpecDoc struct {
|
||||
Paths map[string]map[string]struct {
|
||||
Responses map[string]struct {
|
||||
Content map[string]struct {
|
||||
Schema struct {
|
||||
Ref string `json:"$ref"`
|
||||
} `json:"schema"`
|
||||
} `json:"content"`
|
||||
} `json:"responses"`
|
||||
} `json:"paths"`
|
||||
}
|
||||
|
||||
func (d conformSpecDoc) ref(path, method, status string) string {
|
||||
ref := d.Paths[path][method].Responses[status].Content["application/json"].Schema.Ref
|
||||
return strings.TrimPrefix(ref, "#/components/schemas/")
|
||||
}
|
||||
|
||||
func conformSpec(t *testing.T) conformSpecDoc {
|
||||
t.Helper()
|
||||
_, file, _, ok := runtime.Caller(0)
|
||||
if !ok {
|
||||
t.Fatal("caller")
|
||||
}
|
||||
raw, err := os.ReadFile(filepath.Join(filepath.Dir(file), "..", "admin", "openapi", "admin.json"))
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
var doc conformSpecDoc
|
||||
if err := json.Unmarshal(raw, &doc); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return doc
|
||||
}
|
||||
|
||||
type conformEnv struct {
|
||||
h http.Handler
|
||||
login string
|
||||
token string
|
||||
stamp string
|
||||
groupID uint
|
||||
memberID uint
|
||||
gadgetID uint
|
||||
}
|
||||
|
||||
func (e *conformEnv) send(t *testing.T, method, rel string, body any, auth bool) *httptest.ResponseRecorder {
|
||||
t.Helper()
|
||||
var payload []byte
|
||||
if body != nil {
|
||||
raw, err := json.Marshal(body)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
payload = raw
|
||||
}
|
||||
req := httptest.NewRequest(method, adminAPI(rel), bytes.NewReader(payload))
|
||||
req.Header.Set("Content-Type", "application/json")
|
||||
req.Header.Set("Accept-Language", "pl")
|
||||
if auth {
|
||||
req.Header.Set("Authorization", "Bearer "+e.token)
|
||||
}
|
||||
rec := httptest.NewRecorder()
|
||||
e.h.ServeHTTP(rec, req)
|
||||
if method == http.MethodPost && rel == "/auth/login" && rec.Code == http.StatusOK {
|
||||
e.token = accessToken(t, rec.Body.Bytes())
|
||||
}
|
||||
return rec
|
||||
}
|
||||
|
||||
func dataID(t *testing.T, raw []byte) uint {
|
||||
t.Helper()
|
||||
var body struct {
|
||||
Data struct {
|
||||
ID uint `json:"id"`
|
||||
} `json:"data"`
|
||||
}
|
||||
if err := json.Unmarshal(raw, &body); err != nil || body.Data.ID == 0 {
|
||||
t.Fatalf("no data.id in %s: %v", raw, err)
|
||||
}
|
||||
return body.Data.ID
|
||||
}
|
||||
|
||||
func newConformEnv(t *testing.T) *conformEnv {
|
||||
t.Helper()
|
||||
gdb := adminGorm(t)
|
||||
models := []any{&conformGadget{}, &conformGroup{}, &conformMember{}, &conformGadgetMember{}, &conformSettings{}}
|
||||
if err := gdb.Migrator().DropTable(models...); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := gdb.AutoMigrate(models...); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
stamp := fmt.Sprintf("c%d", time.Now().UnixNano())
|
||||
group := conformGroup{Title: "Group " + stamp}
|
||||
member := conformMember{Email: "member-" + stamp + "@example.test"}
|
||||
if err := gdb.Create(&group).Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := gdb.Create(&member).Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
login := "conform-" + stamp
|
||||
insertAdmin(t, gdb, login, login+"@example.test", adminTestPassword, true, false)
|
||||
|
||||
dir := t.TempDir()
|
||||
if err := os.WriteFile(filepath.Join(dir, "app.yaml"), []byte("name: cabana-conform\nlocale: en\nfallback_locale: en\n"), 0o644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
cfg, err := compass.Open(compass.Options{Dir: dir, Environ: []string{"SUMMER_ENV=development", "SUMMER_ADMIN__JWT__SECRET=" + adminTestSecret}})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
for key, value := range map[string]any{"http.body_limits.default_bytes": 1048576, "http.body_limits.upload_bytes": 1048576} {
|
||||
if err := cfg.Set(key, value); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
app := backpack.New(cfg)
|
||||
if err := lagoon.Publish(app, adminSQL, gdb); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
plugins := []party.Plugin{conformPlugin{}}
|
||||
if err := phrasebook.Activate(app, plugins); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
h, err := surf.Assemble(app, plugins)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return &conformEnv{h: h, login: login, stamp: stamp, groupID: group.ID, memberID: member.ID}
|
||||
}
|
||||
|
||||
type conformGadget struct {
|
||||
ID uint `gorm:"column:id;primaryKey"`
|
||||
Name string `gorm:"column:name"`
|
||||
Active bool `gorm:"column:active"`
|
||||
GroupID *uint `gorm:"column:group_id"`
|
||||
Members []conformMember `gorm:"-"`
|
||||
CreatedAt time.Time `gorm:"column:created_at"`
|
||||
UpdatedAt time.Time `gorm:"column:updated_at"`
|
||||
}
|
||||
|
||||
func (conformGadget) TableName() string { return "cabana_conform_gadgets" }
|
||||
func (conformGadget) Fillable() []string { return []string{"name", "active"} }
|
||||
func (conformGadget) Rules() map[string]string { return map[string]string{"name": "required"} }
|
||||
func (conformGadget) FilterScopes() []string { return []string{"filterByGroup"} }
|
||||
func (conformGadget) FilterScope(_ string, db *gorm.DB, value any) *gorm.DB {
|
||||
return db.Where("group_id = ?", value)
|
||||
}
|
||||
func (conformGadget) FilterOptions(string) []pact.Option {
|
||||
return []pact.Option{{Value: "1", Label: "backend::lang.form.none"}, {Value: "2", Label: "Second"}}
|
||||
}
|
||||
|
||||
type conformGroup struct {
|
||||
ID uint `gorm:"column:id;primaryKey"`
|
||||
Title string `gorm:"column:title"`
|
||||
}
|
||||
|
||||
func (conformGroup) TableName() string { return "cabana_conform_groups" }
|
||||
|
||||
type conformMember struct {
|
||||
ID uint `gorm:"column:id;primaryKey"`
|
||||
Email string `gorm:"column:email"`
|
||||
}
|
||||
|
||||
func (conformMember) TableName() string { return "cabana_conform_members" }
|
||||
|
||||
type conformGadgetMember struct {
|
||||
ID uint `gorm:"column:id;primaryKey"`
|
||||
GadgetID uint `gorm:"column:gadget_id"`
|
||||
MemberID uint `gorm:"column:member_id"`
|
||||
}
|
||||
|
||||
func (conformGadgetMember) TableName() string { return "cabana_conform_gadget_members" }
|
||||
|
||||
type conformSettings struct {
|
||||
ID uint `gorm:"column:id;primaryKey"`
|
||||
Enabled bool `gorm:"column:enabled"`
|
||||
}
|
||||
|
||||
func (conformSettings) TableName() string { return "cabana_conform_settings" }
|
||||
func (conformSettings) Fillable() []string { return []string{"enabled"} }
|
||||
func (conformSettings) Rules() map[string]string { return map[string]string{} }
|
||||
|
||||
type conformPlugin struct{}
|
||||
|
||||
func (conformPlugin) ID() string { return "acme.conform" }
|
||||
func (conformPlugin) Requires() []string { return nil }
|
||||
func (conformPlugin) Register(*backpack.App) error { return nil }
|
||||
func (conformPlugin) Boot(*backpack.App) error { return nil }
|
||||
func (conformPlugin) AdminControllers() []pact.AdminController {
|
||||
return []pact.AdminController{conformController{}}
|
||||
}
|
||||
func (conformPlugin) Permissions() []pact.Permission {
|
||||
return []pact.Permission{{Code: "acme.conform.access", Roles: []string{"developer"}}}
|
||||
}
|
||||
func (conformPlugin) Navigation() []pact.NavigationItem {
|
||||
return []pact.NavigationItem{{Code: "conform", Label: "Conform", Icon: "box", Order: 10, Controller: "acme.conform.gadgets",
|
||||
Permissions: []string{"acme.conform.access"},
|
||||
SideMenu: []pact.NavigationItem{{Code: "gadgets", Label: "Gadgets", Icon: "box", Controller: "acme.conform.gadgets", Permissions: []string{"acme.conform.access"}}}}}
|
||||
}
|
||||
func (conformPlugin) Settings() []pact.SettingsItem {
|
||||
return []pact.SettingsItem{{Code: "conform", Label: "Conform", Description: "Conform settings", Category: "Acme", Icon: "settings",
|
||||
Model: "ConformSettings", Order: 10, Permissions: []string{"acme.conform.access"},
|
||||
Form: "models/settings/fields.yaml", NewModel: func() any { return &conformSettings{} }}}
|
||||
}
|
||||
func (conformPlugin) AdminFS() fs.FS { return conformFS() }
|
||||
|
||||
type conformController struct{}
|
||||
|
||||
func (conformController) ID() string { return "acme.conform.gadgets" }
|
||||
func (conformController) ModelName() string { return "Gadget" }
|
||||
func (conformController) ConfigDir() string { return "controllers/gadgets" }
|
||||
func (conformController) RequiredPermissions() []string { return []string{"acme.conform.access"} }
|
||||
func (conformController) NewRecord() any { return &conformGadget{} }
|
||||
func (conformController) AdminRelationContracts() []cabana.RelationContract {
|
||||
return []cabana.RelationContract{{
|
||||
Name: "members", NewRelated: func() any { return &conformMember{} }, NewPivot: func() any { return &conformGadgetMember{} },
|
||||
ParentForeignKey: "gadget_id", RelatedForeignKey: "member_id", Columns: map[string]string{"email": "email"},
|
||||
}}
|
||||
}
|
||||
func (conformController) AdminFieldRelations() []cabana.FieldRelationContract {
|
||||
return []cabana.FieldRelationContract{{Field: "group", Kind: "belongsTo", NewRelated: func() any { return &conformGroup{} }, ForeignKey: "group_id"}}
|
||||
}
|
||||
|
||||
func conformFS() fs.FS {
|
||||
file := func(s string) *fstest.MapFile { return &fstest.MapFile{Data: []byte(s)} }
|
||||
return fstest.MapFS{
|
||||
"controllers/gadgets/config_list.yaml": file(`list: ~/plugins/acme/conform/models/gadget/columns.yaml
|
||||
modelClass: Gadget
|
||||
title: Gadgets
|
||||
recordUrl: acme/conform/gadgets/update/:id
|
||||
recordsPerPage: 20
|
||||
showCheckboxes: true
|
||||
filter: config_filter.yaml
|
||||
toolbar:
|
||||
buttons: [create, delete]
|
||||
search:
|
||||
prompt: backend::lang.list.search_prompt
|
||||
`),
|
||||
"controllers/gadgets/config_filter.yaml": file(`scopes:
|
||||
grouped:
|
||||
label: Group
|
||||
modelClass: Group
|
||||
nameFrom: title
|
||||
scope: filterByGroup
|
||||
active:
|
||||
label: Active
|
||||
type: switch
|
||||
column: active
|
||||
`),
|
||||
"controllers/gadgets/config_form.yaml": file(`name: New gadget
|
||||
form: ~/plugins/acme/conform/models/gadget/fields.yaml
|
||||
modelClass: Gadget
|
||||
defaultRedirect: acme/conform/gadgets
|
||||
create:
|
||||
redirect: acme/conform/gadgets/update/:id
|
||||
redirectClose: acme/conform/gadgets
|
||||
update:
|
||||
redirect: acme/conform/gadgets
|
||||
redirectClose: acme/conform/gadgets
|
||||
`),
|
||||
"controllers/gadgets/config_relation.yaml": file(`members:
|
||||
label: Members
|
||||
view:
|
||||
list:
|
||||
columns:
|
||||
email:
|
||||
label: Email
|
||||
toolbarButtons: link|unlink
|
||||
showSearch: true
|
||||
manage:
|
||||
list:
|
||||
columns:
|
||||
email:
|
||||
label: Email
|
||||
showSearch: true
|
||||
`),
|
||||
"models/gadget/columns.yaml": file(`columns:
|
||||
name:
|
||||
label: Name
|
||||
searchable: true
|
||||
active:
|
||||
label: Active
|
||||
type: switch
|
||||
`),
|
||||
"models/gadget/fields.yaml": file(`fields:
|
||||
name:
|
||||
label: Name
|
||||
type: text
|
||||
required: true
|
||||
span: left
|
||||
active:
|
||||
label: Active
|
||||
type: switch
|
||||
default: false
|
||||
group:
|
||||
label: Group
|
||||
type: relation
|
||||
nameFrom: title
|
||||
emptyOption: backend::lang.form.none
|
||||
members:
|
||||
type: relation-manager
|
||||
relation: members
|
||||
context: [update]
|
||||
`),
|
||||
"models/settings/fields.yaml": file(`fields:
|
||||
enabled:
|
||||
label: Enabled
|
||||
type: switch
|
||||
default: 0
|
||||
`),
|
||||
}
|
||||
}
|
||||
116
modules/cabana/phase09_contract_test.go
Normal file
116
modules/cabana/phase09_contract_test.go
Normal file
@@ -0,0 +1,116 @@
|
||||
package cabana
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"runtime"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
// TestPhase09ContractInventory fails when the committed framework admin
|
||||
// OpenAPI document (admin/openapi/admin.json, D-15) drops an admin API route
|
||||
// or a protected route's 401 response. Paths are prefix-relative (D-03).
|
||||
func TestPhase09ContractInventory(t *testing.T) {
|
||||
_, file, _, ok := runtime.Caller(0)
|
||||
if !ok {
|
||||
t.Fatal("caller")
|
||||
}
|
||||
specPath := filepath.Clean(filepath.Join(filepath.Dir(file), "..", "admin", "openapi", "admin.json"))
|
||||
raw, err := os.ReadFile(specPath)
|
||||
if err != nil {
|
||||
t.Fatalf("read %s: %v", specPath, err)
|
||||
}
|
||||
var spec struct {
|
||||
Paths map[string]map[string]struct {
|
||||
Responses map[string]json.RawMessage `json:"responses"`
|
||||
Security []map[string]json.RawMessage `json:"security"`
|
||||
} `json:"paths"`
|
||||
Components struct {
|
||||
SecuritySchemes map[string]json.RawMessage `json:"securitySchemes"`
|
||||
} `json:"components"`
|
||||
}
|
||||
if err := json.Unmarshal(raw, &spec); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, ok := spec.Components.SecuritySchemes["BackendBearer"]; !ok {
|
||||
t.Fatal("openapi is missing the BackendBearer scheme")
|
||||
}
|
||||
public := map[string]bool{
|
||||
"POST /auth/login": true,
|
||||
"POST /auth/refresh": true,
|
||||
}
|
||||
seen := map[string]bool{}
|
||||
apiRoutes := 0
|
||||
for _, route := range phase09Routes {
|
||||
if route.spa {
|
||||
continue
|
||||
}
|
||||
apiRoutes++
|
||||
method, path, ok := splitRoute(route.key)
|
||||
if !ok {
|
||||
t.Fatalf("bad route key %s", route.key)
|
||||
}
|
||||
method = strings.ToLower(method)
|
||||
ops, ok := spec.Paths[path]
|
||||
if !ok {
|
||||
t.Fatalf("openapi missing %s", path)
|
||||
}
|
||||
op, ok := ops[method]
|
||||
if !ok {
|
||||
t.Fatalf("openapi missing %s %s", method, path)
|
||||
}
|
||||
key := route.key
|
||||
if seen[key] {
|
||||
t.Fatalf("duplicate contract route %s", key)
|
||||
}
|
||||
seen[key] = true
|
||||
_, ok200 := op.Responses["200"]
|
||||
_, ok201 := op.Responses["201"]
|
||||
if !ok200 && !ok201 {
|
||||
t.Fatalf("%s has no 200 or 201 response", key)
|
||||
}
|
||||
if route.public {
|
||||
// Login and refresh answer 401; the public string bundle does not.
|
||||
if _, ok := op.Responses["401"]; public[key] && !ok {
|
||||
t.Fatalf("%s has no 401 response", key)
|
||||
}
|
||||
continue
|
||||
}
|
||||
if len(op.Security) == 0 {
|
||||
t.Fatalf("%s has no BackendBearer security requirement", key)
|
||||
}
|
||||
if _, ok := op.Responses["401"]; !ok {
|
||||
t.Fatalf("%s has no 401 response", key)
|
||||
}
|
||||
}
|
||||
if len(seen) != apiRoutes {
|
||||
t.Fatalf("contract routes=%d want %d", len(seen), apiRoutes)
|
||||
}
|
||||
if len(spec.Paths) != len(pathsOf(phase09Routes)) {
|
||||
t.Fatalf("openapi lists %d paths, the mounted API has %d", len(spec.Paths), len(pathsOf(phase09Routes)))
|
||||
}
|
||||
}
|
||||
|
||||
func splitRoute(key string) (method, path string, ok bool) {
|
||||
for i := 0; i < len(key); i++ {
|
||||
if key[i] == ' ' {
|
||||
return key[:i], key[i+1:], key[i+1:] != ""
|
||||
}
|
||||
}
|
||||
return "", "", false
|
||||
}
|
||||
|
||||
func pathsOf(routes []adminRoute) map[string]bool {
|
||||
out := map[string]bool{}
|
||||
for _, route := range routes {
|
||||
if route.spa {
|
||||
continue
|
||||
}
|
||||
if _, path, ok := splitRoute(route.key); ok {
|
||||
out[path] = true
|
||||
}
|
||||
}
|
||||
return out
|
||||
}
|
||||
352
modules/cabana/phase10_auth_test.go
Normal file
352
modules/cabana/phase10_auth_test.go
Normal file
@@ -0,0 +1,352 @@
|
||||
package cabana_test
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"io/fs"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"testing"
|
||||
"testing/fstest"
|
||||
|
||||
"git.golem15.com/golem15/summercms/modules/backpack"
|
||||
"git.golem15.com/golem15/summercms/modules/cabana"
|
||||
"git.golem15.com/golem15/summercms/modules/compass"
|
||||
"git.golem15.com/golem15/summercms/modules/pact"
|
||||
"git.golem15.com/golem15/summercms/modules/party"
|
||||
)
|
||||
|
||||
// TestPhase10CookieAuth pins the D-19 session transport: cookie login and
|
||||
// refresh never put the JWT in a body, Bearer clients keep the Phase 9 body,
|
||||
// a cookie refresh needs the CSRF header, and logout blacklists the jti and
|
||||
// expires the cookie.
|
||||
func TestPhase10CookieAuth(t *testing.T) {
|
||||
gdb := adminGorm(t)
|
||||
h := adminHandler(t, gdb, nil)
|
||||
insertAdmin(t, gdb, "p10cookie", "p10cookie@example.test", adminTestPassword, true, false)
|
||||
creds := map[string]string{"login": "p10cookie", "password": adminTestPassword}
|
||||
|
||||
login := phase10Send(t, h, http.MethodPost, adminAPI("/auth/login"), creds, nil, true)
|
||||
if login.Code != http.StatusOK {
|
||||
t.Fatalf("cookie login status=%d body=%s", login.Code, login.Body.String())
|
||||
}
|
||||
first := phase10Cookie(t, login, cabana.DefaultAdminPrefix)
|
||||
phase10AssertCookieBody(t, login, first.Value)
|
||||
|
||||
bearer := phase10Send(t, h, http.MethodPost, adminAPI("/auth/login"), creds, nil, false)
|
||||
if bearer.Code != http.StatusOK {
|
||||
t.Fatalf("bearer login status=%d body=%s", bearer.Code, bearer.Body.String())
|
||||
}
|
||||
phase10AssertBearerBody(t, bearer)
|
||||
if got := bearer.Header().Values("Set-Cookie"); len(got) != 0 {
|
||||
t.Fatalf("bearer login set cookies: %q", got)
|
||||
}
|
||||
bearerToken := accessToken(t, bearer.Body.Bytes())
|
||||
|
||||
noHeader := phase10Send(t, h, http.MethodPost, adminAPI("/auth/refresh"), nil, first, false)
|
||||
if noHeader.Code != http.StatusForbidden || phase10ErrorCode(t, noHeader) != "forbidden" {
|
||||
t.Fatalf("cookie refresh without header status=%d body=%s", noHeader.Code, noHeader.Body.String())
|
||||
}
|
||||
if got := noHeader.Header().Values("Set-Cookie"); len(got) != 0 {
|
||||
t.Fatalf("refused refresh set cookies: %q", got)
|
||||
}
|
||||
|
||||
refreshed := phase10Send(t, h, http.MethodPost, adminAPI("/auth/refresh"), nil, first, true)
|
||||
if refreshed.Code != http.StatusOK {
|
||||
t.Fatalf("cookie refresh status=%d body=%s", refreshed.Code, refreshed.Body.String())
|
||||
}
|
||||
second := phase10Cookie(t, refreshed, cabana.DefaultAdminPrefix)
|
||||
if second.Value == first.Value {
|
||||
t.Fatal("cookie refresh did not rotate the token")
|
||||
}
|
||||
phase10AssertCookieBody(t, refreshed, second.Value)
|
||||
if stale := phase10Send(t, h, http.MethodGet, adminAPI("/auth/me"), nil, first, true); stale.Code != http.StatusUnauthorized {
|
||||
t.Fatalf("rotated-out cookie status=%d body=%s", stale.Code, stale.Body.String())
|
||||
}
|
||||
if me := phase10Send(t, h, http.MethodGet, adminAPI("/auth/me"), nil, second, true); me.Code != http.StatusOK {
|
||||
t.Fatalf("rotated cookie /auth/me status=%d body=%s", me.Code, me.Body.String())
|
||||
}
|
||||
|
||||
bearerRefresh := postAuth(t, h, http.MethodPost, adminAPI("/auth/refresh"), bearerToken, nil)
|
||||
if bearerRefresh.Code != http.StatusOK {
|
||||
t.Fatalf("bearer refresh status=%d body=%s", bearerRefresh.Code, bearerRefresh.Body.String())
|
||||
}
|
||||
phase10AssertBearerBody(t, bearerRefresh)
|
||||
if got := bearerRefresh.Header().Values("Set-Cookie"); len(got) != 0 {
|
||||
t.Fatalf("bearer refresh set cookies: %q", got)
|
||||
}
|
||||
|
||||
logout := phase10Send(t, h, http.MethodPost, adminAPI("/auth/logout"), nil, second, true)
|
||||
if logout.Code != http.StatusOK {
|
||||
t.Fatalf("cookie logout status=%d body=%s", logout.Code, logout.Body.String())
|
||||
}
|
||||
var expired *http.Cookie
|
||||
for _, c := range logout.Result().Cookies() {
|
||||
if c.Name == cabana.AdminCookieName {
|
||||
expired = c
|
||||
}
|
||||
}
|
||||
if expired == nil || expired.MaxAge >= 0 || expired.Value != "" || expired.Path != cabana.DefaultAdminPrefix {
|
||||
t.Fatalf("logout cookie = %+v, want an expiring %s with Path %s", expired, cabana.AdminCookieName, cabana.DefaultAdminPrefix)
|
||||
}
|
||||
if after := phase10Send(t, h, http.MethodGet, adminAPI("/auth/me"), nil, second, true); after.Code != http.StatusUnauthorized {
|
||||
t.Fatalf("logged-out cookie status=%d body=%s", after.Code, after.Body.String())
|
||||
}
|
||||
}
|
||||
|
||||
// TestPhase10Prefix pins backend.uri normalization and validation, moves the
|
||||
// whole admin surface with a custom prefix, rejects reserved controller
|
||||
// vendor segments and refuses an insecure admin cookie in production.
|
||||
func TestPhase10Prefix(t *testing.T) {
|
||||
t.Run("normalization", func(t *testing.T) {
|
||||
for raw, want := range map[string]string{
|
||||
" /acme-admin/ ": "/acme-admin",
|
||||
"": "/backend",
|
||||
"acme": "/acme",
|
||||
"/a/b_c/": "/a/b_c",
|
||||
} {
|
||||
got, err := cabana.AdminPrefix(phase10App(t, "development", map[string]any{"backend.uri": raw}))
|
||||
if err != nil || got != want {
|
||||
t.Fatalf("AdminPrefix(%q) = %q, %v; want %q", raw, got, err, want)
|
||||
}
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("invalid values fail activation", func(t *testing.T) {
|
||||
for _, raw := range []string{"/", "/Admin", "/a b", "/../x", "//", "/-x"} {
|
||||
app := phase10App(t, "development", map[string]any{"backend.uri": raw})
|
||||
_, err := cabana.Activate(app, []party.Plugin{demoPlugin{fsys: demoFS()}})
|
||||
if err == nil || !strings.Contains(err.Error(), "backend.uri") {
|
||||
t.Fatalf("backend.uri %q: err=%v, want an activation error naming backend.uri", raw, err)
|
||||
}
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("custom prefix moves the surface", func(t *testing.T) {
|
||||
gdb := adminGorm(t)
|
||||
h := adminHandler(t, gdb, func(cfg *compass.Config) {
|
||||
phase10Set(t, cfg, "backend.uri", "/acme-admin")
|
||||
phase10Set(t, cfg, "app.url", "https://app.test")
|
||||
})
|
||||
insertAdmin(t, gdb, "p10prefix", "p10prefix@example.test", adminTestPassword, true, false)
|
||||
creds := map[string]string{"login": "p10prefix", "password": adminTestPassword}
|
||||
api := "/acme-admin/api/v1"
|
||||
|
||||
login := phase10Send(t, h, http.MethodPost, api+"/auth/login", creds, nil, true)
|
||||
if login.Code != http.StatusOK {
|
||||
t.Fatalf("custom prefix login status=%d body=%s", login.Code, login.Body.String())
|
||||
}
|
||||
phase10Cookie(t, login, "/acme-admin")
|
||||
|
||||
bearer := phase10Send(t, h, http.MethodPost, api+"/auth/login", creds, nil, false)
|
||||
token := accessToken(t, bearer.Body.Bytes())
|
||||
if iss, _ := jwtClaims(t, token)["iss"].(string); iss != "https://app.test/acme-admin/api/v1/auth/login" {
|
||||
t.Fatalf("issuer = %q", iss)
|
||||
}
|
||||
if me := getAuth(t, h, api+"/auth/me", token); me.Code != http.StatusOK {
|
||||
t.Fatalf("custom prefix /auth/me status=%d", me.Code)
|
||||
}
|
||||
|
||||
shell := getAuth(t, h, "/acme-admin", "")
|
||||
if shell.Code != http.StatusOK || !strings.Contains(shell.Body.String(), `content="/acme-admin"`) {
|
||||
t.Fatalf("custom prefix shell status=%d body=%s", shell.Code, shell.Body.String())
|
||||
}
|
||||
deep := getAuth(t, h, "/acme-admin/acme/demo/widgets", "")
|
||||
if deep.Code != http.StatusOK || !strings.Contains(deep.Body.String(), `content="/acme-admin"`) {
|
||||
t.Fatalf("custom prefix deep link status=%d", deep.Code)
|
||||
}
|
||||
missing := getAuth(t, h, api+"/nope", "")
|
||||
if missing.Code != http.StatusNotFound || phase10ErrorCode(t, missing) != "not_found" {
|
||||
t.Fatalf("custom prefix API miss status=%d body=%s", missing.Code, missing.Body.String())
|
||||
}
|
||||
old := phase10Send(t, h, http.MethodPost, adminAPI("/auth/login"), creds, nil, false)
|
||||
if old.Code == http.StatusOK {
|
||||
t.Fatalf("default prefix still answers under a custom backend.uri: %s", old.Body.String())
|
||||
}
|
||||
if shell := getAuth(t, h, cabana.DefaultAdminPrefix, ""); shell.Code == http.StatusOK {
|
||||
t.Fatal("default prefix still serves the SPA under a custom backend.uri")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("reserved controller vendor segments", func(t *testing.T) {
|
||||
for _, vendor := range []string{"api", "assets", "login", "settings"} {
|
||||
app := phase10App(t, "development", nil)
|
||||
_, err := cabana.Activate(app, []party.Plugin{reservedPlugin{vendor: vendor}})
|
||||
if err == nil || !strings.Contains(err.Error(), vendor+".demo.widgets") || !strings.Contains(err.Error(), "reserved") {
|
||||
t.Fatalf("vendor %q: err=%v, want a reserved-segment activation error", vendor, err)
|
||||
}
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("cookie_secure", func(t *testing.T) {
|
||||
prod := phase10App(t, "production", map[string]any{"backend.cookie_secure": false})
|
||||
if _, err := cabana.Activate(prod, []party.Plugin{demoPlugin{fsys: demoFS()}}); err == nil || !strings.Contains(err.Error(), "backend.cookie_secure") {
|
||||
t.Fatalf("production cookie_secure=false: err=%v", err)
|
||||
}
|
||||
if _, err := cabana.Activate(phase10App(t, "production", nil), []party.Plugin{demoPlugin{fsys: demoFS()}}); err != nil {
|
||||
t.Fatalf("production default cookie_secure: %v", err)
|
||||
}
|
||||
|
||||
gdb := adminGorm(t)
|
||||
h := adminHandler(t, gdb, func(cfg *compass.Config) {
|
||||
phase10Set(t, cfg, "backend.cookie_secure", false)
|
||||
})
|
||||
insertAdmin(t, gdb, "p10insecure", "p10insecure@example.test", adminTestPassword, true, false)
|
||||
login := phase10Send(t, h, http.MethodPost, adminAPI("/auth/login"), map[string]string{"login": "p10insecure", "password": adminTestPassword}, nil, true)
|
||||
if login.Code != http.StatusOK {
|
||||
t.Fatalf("insecure-cookie login status=%d body=%s", login.Code, login.Body.String())
|
||||
}
|
||||
for _, c := range login.Result().Cookies() {
|
||||
if c.Name == cabana.AdminCookieName && (c.Secure || !c.HttpOnly || c.SameSite != http.SameSiteStrictMode) {
|
||||
t.Fatalf("development cookie_secure=false cookie = %+v, want HttpOnly SameSite=Strict without Secure", c)
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func phase10Send(t *testing.T, h http.Handler, method, path string, body any, cookie *http.Cookie, ajax bool) *httptest.ResponseRecorder {
|
||||
t.Helper()
|
||||
var reader *bytes.Reader
|
||||
if body != nil {
|
||||
raw, err := json.Marshal(body)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
reader = bytes.NewReader(raw)
|
||||
} else {
|
||||
reader = bytes.NewReader(nil)
|
||||
}
|
||||
req := httptest.NewRequest(method, path, reader)
|
||||
if body != nil {
|
||||
req.Header.Set("Content-Type", "application/json")
|
||||
}
|
||||
if ajax {
|
||||
req.Header.Set("X-Requested-With", "XMLHttpRequest")
|
||||
}
|
||||
if cookie != nil {
|
||||
req.AddCookie(&http.Cookie{Name: cookie.Name, Value: cookie.Value})
|
||||
}
|
||||
rec := httptest.NewRecorder()
|
||||
h.ServeHTTP(rec, req)
|
||||
return rec
|
||||
}
|
||||
|
||||
func phase10Cookie(t *testing.T, rec *httptest.ResponseRecorder, path string) *http.Cookie {
|
||||
t.Helper()
|
||||
for _, c := range rec.Result().Cookies() {
|
||||
if c.Name != cabana.AdminCookieName {
|
||||
continue
|
||||
}
|
||||
if c.Value == "" || !c.HttpOnly || !c.Secure || c.SameSite != http.SameSiteStrictMode || c.Path != path || c.MaxAge <= 0 {
|
||||
t.Fatalf("session cookie = %+v, want HttpOnly Secure SameSite=Strict Path=%s with a Max-Age", c, path)
|
||||
}
|
||||
return c
|
||||
}
|
||||
t.Fatalf("no %s cookie; Set-Cookie=%q body=%s", cabana.AdminCookieName, rec.Header().Values("Set-Cookie"), rec.Body.String())
|
||||
return nil
|
||||
}
|
||||
|
||||
func phase10AssertCookieBody(t *testing.T, rec *httptest.ResponseRecorder, token string) {
|
||||
t.Helper()
|
||||
var body struct {
|
||||
Data map[string]any `json:"data"`
|
||||
}
|
||||
if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if body.Data["token_type"] != "cookie" {
|
||||
t.Fatalf("cookie body = %s", rec.Body.String())
|
||||
}
|
||||
if n, ok := body.Data["expires_in"].(float64); !ok || n <= 0 {
|
||||
t.Fatalf("cookie body expires_in = %v", body.Data["expires_in"])
|
||||
}
|
||||
if _, ok := body.Data["access_token"]; ok || strings.Contains(rec.Body.String(), token) || strings.Contains(rec.Body.String(), "eyJ") {
|
||||
t.Fatalf("cookie body carries a token: %s", rec.Body.String())
|
||||
}
|
||||
}
|
||||
|
||||
func phase10AssertBearerBody(t *testing.T, rec *httptest.ResponseRecorder) {
|
||||
t.Helper()
|
||||
var body struct {
|
||||
Data map[string]any `json:"data"`
|
||||
Meta map[string]any `json:"meta"`
|
||||
}
|
||||
if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
token, _ := body.Data["access_token"].(string)
|
||||
if len(body.Data) != 2 || token == "" || body.Data["token_type"] != "bearer" || len(body.Meta) != 0 {
|
||||
t.Fatalf("bearer body = %s, want the Phase 9 {access_token, token_type: bearer} shape", rec.Body.String())
|
||||
}
|
||||
}
|
||||
|
||||
func phase10ErrorCode(t *testing.T, rec *httptest.ResponseRecorder) string {
|
||||
t.Helper()
|
||||
var body struct {
|
||||
Error struct {
|
||||
Code string `json:"code"`
|
||||
} `json:"error"`
|
||||
}
|
||||
if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil {
|
||||
t.Fatalf("error json: %v body=%s", err, rec.Body.String())
|
||||
}
|
||||
return body.Error.Code
|
||||
}
|
||||
|
||||
func phase10Set(t *testing.T, cfg *compass.Config, key string, value any) {
|
||||
t.Helper()
|
||||
if err := cfg.Set(key, value); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
|
||||
// phase10App is a database-free app for activation checks.
|
||||
func phase10App(t *testing.T, env string, values map[string]any) *backpack.App {
|
||||
t.Helper()
|
||||
dir := t.TempDir()
|
||||
if err := os.WriteFile(filepath.Join(dir, "app.yaml"), []byte("name: cabana-phase10\n"), 0o644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
cfg, err := compass.Open(compass.Options{
|
||||
Dir: dir,
|
||||
Environ: []string{
|
||||
"SUMMER_ENV=" + env,
|
||||
"SUMMER_ADMIN__JWT__SECRET=" + adminTestSecret,
|
||||
},
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
for key, value := range values {
|
||||
phase10Set(t, cfg, key, value)
|
||||
}
|
||||
return backpack.New(cfg)
|
||||
}
|
||||
|
||||
// reservedPlugin owns a controller whose vendor segment collides with an SPA
|
||||
// or API segment under the admin prefix.
|
||||
type reservedPlugin struct{ vendor string }
|
||||
|
||||
func (p reservedPlugin) ID() string { return p.vendor + ".demo" }
|
||||
func (p reservedPlugin) Requires() []string { return nil }
|
||||
func (p reservedPlugin) Register(*backpack.App) error { return nil }
|
||||
func (p reservedPlugin) Boot(*backpack.App) error { return nil }
|
||||
func (p reservedPlugin) AdminControllers() []pact.AdminController {
|
||||
return []pact.AdminController{reservedController{vendor: p.vendor}}
|
||||
}
|
||||
func (p reservedPlugin) AdminFS() fs.FS {
|
||||
return fstest.MapFS{
|
||||
"controllers/widgets/config_list.yaml": &fstest.MapFile{Data: []byte(fmt.Sprintf("list: ~/plugins/%s/demo/models/widget/columns.yaml\nmodelClass: Widget\nrecordsPerPage: 20\n", p.vendor))},
|
||||
"models/widget/columns.yaml": &fstest.MapFile{Data: []byte("columns:\n name:\n label: Name\n")},
|
||||
}
|
||||
}
|
||||
|
||||
type reservedController struct{ vendor string }
|
||||
|
||||
func (c reservedController) ID() string { return c.vendor + ".demo.widgets" }
|
||||
func (reservedController) ModelName() string { return "Widget" }
|
||||
func (reservedController) ConfigDir() string { return "controllers/widgets" }
|
||||
483
modules/cabana/phase10_coverage_test.go
Normal file
483
modules/cabana/phase10_coverage_test.go
Normal file
@@ -0,0 +1,483 @@
|
||||
package cabana
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"sort"
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"git.golem15.com/golem15/summercms/modules/backpack"
|
||||
"git.golem15.com/golem15/summercms/modules/bouncer"
|
||||
"git.golem15.com/golem15/summercms/modules/compass"
|
||||
"git.golem15.com/golem15/summercms/modules/pact"
|
||||
"git.golem15.com/golem15/summercms/modules/phrasebook"
|
||||
"github.com/golang-jwt/jwt/v5"
|
||||
"gorm.io/gorm"
|
||||
)
|
||||
|
||||
// refreshSubjects is a map-backed bouncer.UserProvider for refresh tests
|
||||
// that run without a database; err, when set, is returned for every lookup.
|
||||
type refreshSubjects struct {
|
||||
byID map[uint]*bouncer.Principal
|
||||
err error
|
||||
}
|
||||
|
||||
func (p refreshSubjects) FindByID(_ context.Context, id uint) (*bouncer.Principal, error) {
|
||||
if p.err != nil {
|
||||
return nil, p.err
|
||||
}
|
||||
return p.byID[id], nil
|
||||
}
|
||||
|
||||
// emptyOptionsRow is a filter source whose scope has no choices yet;
|
||||
// literalOptionsRow's choice label is a literal rather than a phrase key.
|
||||
type emptyOptionsRow struct {
|
||||
ID uint `gorm:"column:id;primaryKey"`
|
||||
Name string `gorm:"column:name"`
|
||||
Active bool `gorm:"column:active"`
|
||||
}
|
||||
|
||||
func (emptyOptionsRow) FilterScopes() []string { return []string{"filterByGroup"} }
|
||||
func (emptyOptionsRow) FilterScope(_ string, db *gorm.DB, _ any) *gorm.DB { return db }
|
||||
func (emptyOptionsRow) FilterOptions(string) []pact.Option { return []pact.Option{} }
|
||||
|
||||
type literalOptionsRow struct {
|
||||
ID uint `gorm:"column:id;primaryKey"`
|
||||
Name string `gorm:"column:name"`
|
||||
Active bool `gorm:"column:active"`
|
||||
}
|
||||
|
||||
func (literalOptionsRow) FilterScopes() []string { return []string{"filterByGroup"} }
|
||||
func (literalOptionsRow) FilterScope(_ string, db *gorm.DB, _ any) *gorm.DB { return db }
|
||||
func (literalOptionsRow) FilterOptions(string) []pact.Option {
|
||||
return []pact.Option{{Value: "x", Label: "Literal label"}}
|
||||
}
|
||||
|
||||
// TestPhase10Coverage fills the Phase 10 cabana branches the feature tests
|
||||
// left without a named case: the mounted route table against the CSRF walk,
|
||||
// relation and filter option edges, read-only relation labels, relation
|
||||
// message defaults, the bundle's configured fallback and a cookie refresh of
|
||||
// an expired access token inside the refresh window.
|
||||
func TestPhase10Coverage(t *testing.T) {
|
||||
t.Run("every unsafe mounted route is CSRF-walked", func(t *testing.T) {
|
||||
router := &handlerRouter{handlers: map[string]http.HandlerFunc{}}
|
||||
svc := phase09DeniedService()
|
||||
svc.mount(router)
|
||||
api := adminAPI("")
|
||||
var unsafe, safe []string
|
||||
for _, key := range router.order {
|
||||
method, path, _ := strings.Cut(key, " ")
|
||||
rel := strings.TrimPrefix(path, api)
|
||||
switch method {
|
||||
case http.MethodGet:
|
||||
safe = append(safe, rel)
|
||||
case http.MethodPost, http.MethodPut, http.MethodDelete:
|
||||
unsafe = append(unsafe, method+" "+rel)
|
||||
default:
|
||||
t.Fatalf("unexpected method mounted: %s", key)
|
||||
}
|
||||
}
|
||||
sort.Strings(unsafe)
|
||||
want := []string{
|
||||
"DELETE /{vendor}/{plugin}/{controller}/{id}",
|
||||
"POST /auth/login",
|
||||
"POST /auth/logout",
|
||||
"POST /auth/refresh",
|
||||
"POST /{vendor}/{plugin}/{controller}",
|
||||
"POST /{vendor}/{plugin}/{controller}/bulk-delete",
|
||||
"POST /{vendor}/{plugin}/{controller}/{id}/relations/{name}/link",
|
||||
"POST /{vendor}/{plugin}/{controller}/{id}/relations/{name}/unlink",
|
||||
"PUT /settings/{code}",
|
||||
"PUT /{vendor}/{plugin}/{controller}/{id}",
|
||||
}
|
||||
if strings.Join(unsafe, "\n") != strings.Join(want, "\n") {
|
||||
t.Fatalf("unsafe routes changed; extend TestPhase10CSRF (it expects 9 besides login):\n%s", strings.Join(unsafe, "\n"))
|
||||
}
|
||||
// The routes added in Phase 10 are safe reads: GET /lang and the shared
|
||||
// nested pattern serving field options, filter options and relation lists.
|
||||
for _, need := range []string{"/lang", "/{vendor}/{plugin}/{controller}/{id}/{segment}/{name}"} {
|
||||
found := false
|
||||
for _, rel := range safe {
|
||||
found = found || rel == need
|
||||
}
|
||||
if !found {
|
||||
t.Fatalf("GET %s is not mounted: %v", need, safe)
|
||||
}
|
||||
}
|
||||
// A safe read with only the cookie is never refused by the CSRF check.
|
||||
req := httptest.NewRequest(http.MethodGet, adminAPI("/lang"), nil)
|
||||
req.AddCookie(&http.Cookie{Name: AdminCookieName, Value: "cookie-only"})
|
||||
rec := httptest.NewRecorder()
|
||||
router.handlers[http.MethodGet+" "+adminAPI("/lang")](rec, req)
|
||||
if rec.Code != http.StatusOK {
|
||||
t.Fatalf("cookie-only GET /lang status=%d", rec.Code)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("relation option edges", func(t *testing.T) {
|
||||
svc, _, _ := p10Fixture(t)
|
||||
decode := func(rec *httptest.ResponseRecorder) ([]RelationOption, ListMeta) {
|
||||
t.Helper()
|
||||
if rec.Code != http.StatusOK {
|
||||
t.Fatalf("status=%d body=%s", rec.Code, rec.Body.String())
|
||||
}
|
||||
var body struct {
|
||||
Data []RelationOption `json:"data"`
|
||||
Meta ListMeta `json:"meta"`
|
||||
}
|
||||
if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if body.Data == nil {
|
||||
t.Fatalf("data is null: %s", rec.Body.String())
|
||||
}
|
||||
return body.Data, body.Meta
|
||||
}
|
||||
all, allMeta := decode(p10Options(svc, "tags", "", p10Principal(true)))
|
||||
for _, query := range []string{"search=", "search=%20%20"} {
|
||||
rows, meta := decode(p10Options(svc, "tags", query, p10Principal(true)))
|
||||
if len(rows) != len(all) || meta.Total != allMeta.Total {
|
||||
t.Fatalf("%s is not a no-op search: %d rows, total %d", query, len(rows), meta.Total)
|
||||
}
|
||||
}
|
||||
beyond, meta := decode(p10Options(svc, "tags", "page=9", p10Principal(true)))
|
||||
if len(beyond) != 0 || meta.Page != 9 || meta.Total != allMeta.Total || meta.LastPage != allMeta.LastPage {
|
||||
t.Fatalf("page beyond last: rows=%d meta=%+v", len(beyond), meta)
|
||||
}
|
||||
capped, cappedMeta := decode(p10Options(svc, "tags", "per_page=100", p10Principal(true)))
|
||||
if cappedMeta.PerPage != 100 || len(capped) != len(all) {
|
||||
t.Fatalf("per_page at the cap: %+v", cappedMeta)
|
||||
}
|
||||
above := p10Options(svc, "tags", "per_page=1000", p10Principal(true))
|
||||
if above.Code != http.StatusUnprocessableEntity || !strings.Contains(above.Body.String(), `"per_page"`) {
|
||||
t.Fatalf("per_page above the cap status=%d body=%s", above.Code, above.Body.String())
|
||||
}
|
||||
none, noneMeta := decode(p10Options(svc, "tags", "search=no-such-tag", p10Principal(true)))
|
||||
if len(none) != 0 || noneMeta.Total != 0 || noneMeta.LastPage < 1 {
|
||||
t.Fatalf("empty result: %d rows meta=%+v", len(none), noneMeta)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("filter option edges", func(t *testing.T) {
|
||||
granted := &bouncer.Principal{ID: 1, PermissionGrants: map[string]bool{"acme.demo.access": true}}
|
||||
empty := filterOptionsCall(filterOptionsService(t, &emptyOptionsRow{}, []string{"acme.demo.access"}, nil), "grouped", "", granted)
|
||||
if empty.Code != http.StatusOK || !strings.Contains(empty.Body.String(), `"data":[]`) {
|
||||
t.Fatalf("no choices status=%d body=%s", empty.Code, empty.Body.String())
|
||||
}
|
||||
literal := filterOptionsCall(filterOptionsService(t, &literalOptionsRow{}, []string{"acme.demo.access"}, nil), "grouped", "pl", granted)
|
||||
if literal.Code != http.StatusOK || !strings.Contains(literal.Body.String(), `{"value":"x","label":"Literal label"}`) {
|
||||
t.Fatalf("literal label status=%d body=%s", literal.Code, literal.Body.String())
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("read-only relation label outside the options scope", func(t *testing.T) {
|
||||
svc, db, seed := p10Fixture(t)
|
||||
created := p10Decode(t, p10Save(svc, http.MethodPost, "", map[string]any{"name": "labelled"}), http.StatusCreated)
|
||||
id := fmt.Sprintf("%d", p10ID(created.Data["id"]))
|
||||
// The options hook hides every person (1 = 0), yet the label shows.
|
||||
shown := p10Decode(t, p10Save(svc, http.MethodGet, id, nil), http.StatusOK)
|
||||
if p10ID(shown.Data["person"]) != seed.person || len(shown.Meta.Labels["person"]) != 1 || shown.Meta.Labels["person"][0].Label != "admin@acme.test" {
|
||||
t.Fatalf("read-only label data=%v labels=%+v", shown.Data["person"], shown.Meta.Labels["person"])
|
||||
}
|
||||
// A dangling foreign key keeps the value and gets no label.
|
||||
if err := db.Delete(&p10Person{}, seed.person).Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
dangling := p10Decode(t, p10Save(svc, http.MethodGet, id, nil), http.StatusOK)
|
||||
if labels, ok := dangling.Meta.Labels["person"]; !ok || len(labels) != 0 {
|
||||
t.Fatalf("dangling person labels=%+v", dangling.Meta.Labels)
|
||||
}
|
||||
// Saving never writes the read-only key.
|
||||
p10Decode(t, p10Save(svc, http.MethodPut, id, map[string]any{"name": "again", "person": 42}), http.StatusOK)
|
||||
if stored := p10Stored(t, db, p10ID(created.Data["id"])); stored.UserID != seed.person {
|
||||
t.Fatalf("read-only foreign key written: %+v", stored)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("relation messages default every key", func(t *testing.T) {
|
||||
tr := messagesTranslator(t)
|
||||
ctl := relationTestController{}
|
||||
fsys := relationTestFS(validRelationYAML)
|
||||
form, err := CompileForm("acme.demo", ctl, fsys)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
relations, err := compileRelations("acme.demo", ctl, fsys, form)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
for _, locale := range []string{"pl", "en"} {
|
||||
view := relations["editors"].Schema.Localize(localeCtx(locale), tr)
|
||||
raw, err := json.Marshal(view.Messages)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
var messages map[string]map[string]string
|
||||
if err := json.Unmarshal(raw, &messages); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
for _, key := range []string{"link", "linkHint", "candidateSearch", "linked", "unlinkSelected", "unlinkConfirm", "unlinked", "empty"} {
|
||||
if messages[key]["other"] == "" || strings.Contains(messages[key]["other"], "backend::") {
|
||||
t.Fatalf("%s %s default = %v", locale, key, messages[key])
|
||||
}
|
||||
}
|
||||
if locale == "pl" && len(messages["linked"]) != 4 {
|
||||
t.Fatalf("pl linked is not plural: %v", messages["linked"])
|
||||
}
|
||||
}
|
||||
if err := validateMessageKeys(&Registry{byID: map[string]*CompiledController{
|
||||
"acme.demo.owners": {Controller: ctl, PluginID: "acme.demo", Relations: relations},
|
||||
}}, tr); err != nil {
|
||||
t.Fatalf("framework defaults failed validation: %v", err)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("form-less controller drops create from any toolbar", func(t *testing.T) {
|
||||
config := "modelClass: Widget\nlist: ~/plugins/acme/demo/models/widget/columns.yaml\ntoolbar:\n buttons: [create]\n"
|
||||
reg, err := compileRegistry([]controllerRef{{plugin: formPlugin{fsys: listFS(config, "columns: {}\n")}, ctl: schemaController{}}})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
cc, _ := reg.Get("acme.demo.widgets")
|
||||
if len(cc.List.ToolbarButtons) != 0 || cc.List.ToolbarButtons == nil {
|
||||
t.Fatalf("toolbar=%#v, want an empty list", cc.List.ToolbarButtons)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("bundle falls back to app.fallback_locale", func(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
if err := os.WriteFile(filepath.Join(dir, "app.yaml"), []byte("name: coverage\nlocale: pl\nfallback_locale: pl\n"), 0o644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
cfg, err := compass.Open(compass.Options{Dir: dir, Environ: []string{"SUMMER_ENV=development"}})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
app := backpack.New(cfg)
|
||||
if err := phrasebook.Activate(app, []langPlugin{}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
svc := &service{app: app}
|
||||
for _, requested := range []string{"de", ""} {
|
||||
req := httptest.NewRequest(http.MethodGet, adminAPI("/lang"), nil)
|
||||
if requested != "" {
|
||||
req = req.WithContext(localeCtx(requested))
|
||||
}
|
||||
rec := httptest.NewRecorder()
|
||||
svc.langBundle(rec, req)
|
||||
var body struct {
|
||||
Data map[string]map[string]string `json:"data"`
|
||||
Meta struct {
|
||||
Locale string `json:"locale"`
|
||||
} `json:"meta"`
|
||||
}
|
||||
if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if body.Meta.Locale != "pl" || body.Data["backend::lang.form.save"]["other"] != "Zapisz" {
|
||||
t.Fatalf("requested %q: locale=%q save=%v", requested, body.Meta.Locale, body.Data["backend::lang.form.save"])
|
||||
}
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("cookie refresh of an expired access token inside the refresh window", func(t *testing.T) {
|
||||
const secret = "phase10-coverage-secret"
|
||||
svc := &service{
|
||||
secret: secret,
|
||||
ttl: 15 * time.Minute,
|
||||
refreshTTL: 2 * time.Hour,
|
||||
issuer: "https://app.test" + DefaultAdminPrefix,
|
||||
bl: bouncer.NewMemoryBlacklist(),
|
||||
users: refreshSubjects{byID: map[uint]*bouncer.Principal{5: {ID: 5, Backend: true}}},
|
||||
}
|
||||
sign := func(iat, exp time.Time, jti string) string {
|
||||
t.Helper()
|
||||
tok, err := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.MapClaims{
|
||||
"sub": "5", "aud": bouncer.AudienceBackend, "iss": svc.issuer, "jti": jti,
|
||||
"iat": iat.Unix(), "nbf": iat.Unix(), "exp": exp.Unix(),
|
||||
}).SignedString([]byte(secret))
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return tok
|
||||
}
|
||||
call := func(token string, cookie bool) *httptest.ResponseRecorder {
|
||||
req := httptest.NewRequest(http.MethodPost, adminAPI("/auth/refresh"), nil)
|
||||
req.Header.Set("X-Requested-With", "XMLHttpRequest")
|
||||
if cookie {
|
||||
req.AddCookie(&http.Cookie{Name: AdminCookieName, Value: token})
|
||||
} else {
|
||||
req.Header.Set("Authorization", "Bearer "+token)
|
||||
}
|
||||
rec := httptest.NewRecorder()
|
||||
requireAjax(svc.refresh)(rec, req)
|
||||
return rec
|
||||
}
|
||||
now := time.Now()
|
||||
expired := sign(now.Add(-30*time.Minute), now.Add(-15*time.Minute), "expired-in-window")
|
||||
if _, _, _, _, err := bouncer.VerifyClaimsAudience(expired, secret, bouncer.AudienceBackend); err == nil {
|
||||
t.Fatal("fixture token is not expired")
|
||||
}
|
||||
|
||||
rec := call(expired, true)
|
||||
if rec.Code != http.StatusOK {
|
||||
t.Fatalf("cookie refresh in window status=%d body=%s", rec.Code, rec.Body.String())
|
||||
}
|
||||
var next *http.Cookie
|
||||
for _, c := range rec.Result().Cookies() {
|
||||
if c.Name == AdminCookieName {
|
||||
next = c
|
||||
}
|
||||
}
|
||||
if next == nil || next.Value == "" || next.Value == expired || !next.HttpOnly || !next.Secure || next.SameSite != http.SameSiteStrictMode ||
|
||||
next.Path != DefaultAdminPrefix || next.MaxAge != int((2*time.Hour)/time.Second) {
|
||||
t.Fatalf("refreshed cookie = %+v", next)
|
||||
}
|
||||
if strings.Contains(rec.Body.String(), "access_token") || strings.Contains(rec.Body.String(), next.Value) {
|
||||
t.Fatalf("cookie refresh put the token in the body: %s", rec.Body.String())
|
||||
}
|
||||
if _, _, _, _, err := bouncer.VerifyClaimsAudience(next.Value, secret, bouncer.AudienceBackend); err != nil {
|
||||
t.Fatalf("refreshed cookie does not verify: %v", err)
|
||||
}
|
||||
// The old token is blacklisted by the rotation: a second refresh fails.
|
||||
if again := call(expired, true); again.Code != http.StatusUnauthorized {
|
||||
t.Fatalf("replayed refresh status=%d", again.Code)
|
||||
}
|
||||
|
||||
bearer := call(sign(now.Add(-30*time.Minute), now.Add(-15*time.Minute), "bearer-in-window"), false)
|
||||
if bearer.Code != http.StatusOK || !strings.Contains(bearer.Body.String(), `"access_token"`) || len(bearer.Result().Cookies()) != 0 {
|
||||
t.Fatalf("bearer refresh status=%d body=%s", bearer.Code, bearer.Body.String())
|
||||
}
|
||||
|
||||
stale := call(sign(now.Add(-3*time.Hour), now.Add(-170*time.Minute), "outside-window"), true)
|
||||
if stale.Code != http.StatusUnauthorized || len(stale.Result().Cookies()) != 0 {
|
||||
t.Fatalf("refresh outside the window status=%d cookies=%v", stale.Code, stale.Result().Cookies())
|
||||
}
|
||||
missing := call("", true)
|
||||
if missing.Code != http.StatusUnauthorized {
|
||||
t.Fatalf("refresh without a token status=%d", missing.Code)
|
||||
}
|
||||
frontend := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.MapClaims{
|
||||
"sub": "5", "aud": bouncer.AudienceUser, "jti": "frontend", "iat": now.Unix(), "exp": now.Add(time.Minute).Unix(),
|
||||
})
|
||||
frontendTok, err := frontend.SignedString([]byte(secret))
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if cross := call(frontendTok, true); cross.Code != http.StatusUnauthorized {
|
||||
t.Fatalf("frontend token refreshed through the admin cookie: %d", cross.Code)
|
||||
}
|
||||
if !bytes.Contains(rec.Body.Bytes(), []byte(`"token_type"`)) {
|
||||
t.Fatalf("cookie refresh body=%s", rec.Body.String())
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("refresh enforces the guard's subject checks", func(t *testing.T) {
|
||||
const secret = "phase10-subject-secret"
|
||||
now := time.Now()
|
||||
cutoff := now.Add(-10 * time.Minute)
|
||||
subjects := refreshSubjects{byID: map[uint]*bouncer.Principal{
|
||||
5: {ID: 5, Backend: true, TokensValidAfter: cutoff},
|
||||
}}
|
||||
newService := func(users bouncer.UserProvider) *service {
|
||||
return &service{
|
||||
secret: secret,
|
||||
ttl: 15 * time.Minute,
|
||||
refreshTTL: 2 * time.Hour,
|
||||
issuer: "https://app.test" + DefaultAdminPrefix,
|
||||
bl: bouncer.NewMemoryBlacklist(),
|
||||
users: users,
|
||||
}
|
||||
}
|
||||
sign := func(sub string, iat time.Time, jti string) string {
|
||||
t.Helper()
|
||||
tok, err := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.MapClaims{
|
||||
"sub": sub, "aud": bouncer.AudienceBackend, "jti": jti,
|
||||
"iat": iat.Unix(), "nbf": iat.Unix(), "exp": iat.Add(15 * time.Minute).Unix(),
|
||||
}).SignedString([]byte(secret))
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return tok
|
||||
}
|
||||
call := func(svc *service, token string, cookie bool) *httptest.ResponseRecorder {
|
||||
req := httptest.NewRequest(http.MethodPost, adminAPI("/auth/refresh"), nil)
|
||||
req.Header.Set("X-Requested-With", "XMLHttpRequest")
|
||||
if cookie {
|
||||
req.AddCookie(&http.Cookie{Name: AdminCookieName, Value: token})
|
||||
} else {
|
||||
req.Header.Set("Authorization", "Bearer "+token)
|
||||
}
|
||||
rec := httptest.NewRecorder()
|
||||
requireAjax(svc.refresh)(rec, req)
|
||||
return rec
|
||||
}
|
||||
errorCode := func(rec *httptest.ResponseRecorder) string {
|
||||
t.Helper()
|
||||
var body struct {
|
||||
Error struct {
|
||||
Code string `json:"code"`
|
||||
} `json:"error"`
|
||||
}
|
||||
if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil {
|
||||
t.Fatalf("error json: %v body=%s", err, rec.Body.String())
|
||||
}
|
||||
return body.Error.Code
|
||||
}
|
||||
assertExpired := func(name string, rec *httptest.ResponseRecorder) {
|
||||
t.Helper()
|
||||
if rec.Code != http.StatusUnauthorized || errorCode(rec) != "unauthenticated" {
|
||||
t.Fatalf("%s: status=%d body=%s, want 401 unauthenticated", name, rec.Code, rec.Body.String())
|
||||
}
|
||||
var expired *http.Cookie
|
||||
for _, c := range rec.Result().Cookies() {
|
||||
if c.Name == AdminCookieName {
|
||||
expired = c
|
||||
}
|
||||
}
|
||||
if expired == nil || expired.Value != "" || expired.MaxAge >= 0 || expired.Path != DefaultAdminPrefix {
|
||||
t.Fatalf("%s: cookie = %+v, want an expiring %s with Path %s", name, expired, AdminCookieName, DefaultAdminPrefix)
|
||||
}
|
||||
}
|
||||
assertNoCookies := func(name string, rec *httptest.ResponseRecorder) {
|
||||
t.Helper()
|
||||
if rec.Code != http.StatusUnauthorized || errorCode(rec) != "unauthenticated" {
|
||||
t.Fatalf("%s: status=%d body=%s, want 401 unauthenticated", name, rec.Code, rec.Body.String())
|
||||
}
|
||||
if got := rec.Header().Values("Set-Cookie"); len(got) != 0 {
|
||||
t.Fatalf("%s: set cookies %q", name, got)
|
||||
}
|
||||
}
|
||||
|
||||
svc := newService(subjects)
|
||||
assertExpired("pre-cutoff cookie", call(svc, sign("5", cutoff.Add(-time.Minute), "pre-cutoff-cookie"), true))
|
||||
assertExpired("unknown subject cookie", call(svc, sign("6", now.Add(-time.Minute), "unknown-cookie"), true))
|
||||
assertNoCookies("pre-cutoff bearer", call(svc, sign("5", cutoff.Add(-time.Minute), "pre-cutoff-bearer"), false))
|
||||
|
||||
failing := newService(refreshSubjects{err: errors.New("lookup failed")})
|
||||
assertNoCookies("provider error cookie", call(failing, sign("5", now.Add(-time.Minute), "provider-error"), true))
|
||||
|
||||
ok := call(svc, sign("5", cutoff.Add(time.Minute), "post-cutoff-cookie"), true)
|
||||
if ok.Code != http.StatusOK {
|
||||
t.Fatalf("post-cutoff cookie refresh status=%d body=%s", ok.Code, ok.Body.String())
|
||||
}
|
||||
var rotated *http.Cookie
|
||||
for _, c := range ok.Result().Cookies() {
|
||||
if c.Name == AdminCookieName {
|
||||
rotated = c
|
||||
}
|
||||
}
|
||||
if rotated == nil || rotated.Value == "" || rotated.MaxAge <= 0 || rotated.Path != DefaultAdminPrefix {
|
||||
t.Fatalf("post-cutoff rotated cookie = %+v", rotated)
|
||||
}
|
||||
})
|
||||
}
|
||||
154
modules/cabana/phase10_csrf_test.go
Normal file
154
modules/cabana/phase10_csrf_test.go
Normal file
@@ -0,0 +1,154 @@
|
||||
package cabana
|
||||
|
||||
import (
|
||||
"io"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"git.golem15.com/golem15/summercms/modules/bouncer"
|
||||
"git.golem15.com/golem15/summercms/modules/pact"
|
||||
)
|
||||
|
||||
// TestPhase10CSRF walks every state-changing route service.mount registers.
|
||||
// Except login, a request carrying only the admin cookie and no
|
||||
// X-Requested-With header is refused with 403 forbidden before the handler
|
||||
// runs: the body spy is never read and the service, which has no database,
|
||||
// never answers with a database error. The same call with the header or with
|
||||
// a Bearer token reaches the handler.
|
||||
func TestPhase10CSRF(t *testing.T) {
|
||||
router := &handlerRouter{handlers: map[string]http.HandlerFunc{}}
|
||||
svc := phase09DeniedService()
|
||||
svc.mount(router)
|
||||
super := &bouncer.Principal{ID: 1, Backend: true, IsSuperuser: true}
|
||||
login := http.MethodPost + " " + adminAPI("/auth/login")
|
||||
|
||||
unsafe := 0
|
||||
for _, key := range router.order {
|
||||
method, path, _ := strings.Cut(key, " ")
|
||||
if method != http.MethodPost && method != http.MethodPut && method != http.MethodDelete {
|
||||
continue
|
||||
}
|
||||
if key == login {
|
||||
continue
|
||||
}
|
||||
unsafe++
|
||||
handler := router.handlers[key]
|
||||
t.Run(key, func(t *testing.T) {
|
||||
refused, spy := csrfRequest(method, path, super)
|
||||
refused.AddCookie(&http.Cookie{Name: AdminCookieName, Value: "cookie-only-session"})
|
||||
rec := httptest.NewRecorder()
|
||||
handler(rec, refused)
|
||||
if rec.Code != http.StatusForbidden {
|
||||
t.Fatalf("cookie-only status=%d body=%s", rec.Code, rec.Body.String())
|
||||
}
|
||||
assertErrorCode(t, rec.Body.Bytes(), "forbidden")
|
||||
if spy.reads != 0 {
|
||||
t.Fatalf("refused request body was read %d times", spy.reads)
|
||||
}
|
||||
|
||||
withHeader, _ := csrfRequest(method, path, super)
|
||||
withHeader.AddCookie(&http.Cookie{Name: AdminCookieName, Value: "cookie-only-session"})
|
||||
withHeader.Header.Set("X-Requested-With", "XMLHttpRequest")
|
||||
rec = httptest.NewRecorder()
|
||||
handler(rec, withHeader)
|
||||
if rec.Code == http.StatusForbidden {
|
||||
t.Fatalf("request with X-Requested-With was refused: %s", rec.Body.String())
|
||||
}
|
||||
|
||||
withBearer, _ := csrfRequest(method, path, super)
|
||||
withBearer.Header.Set("Authorization", "Bearer not-a-real-token")
|
||||
rec = httptest.NewRecorder()
|
||||
handler(rec, withBearer)
|
||||
if rec.Code == http.StatusForbidden {
|
||||
t.Fatalf("Bearer request was refused: %s", rec.Body.String())
|
||||
}
|
||||
})
|
||||
}
|
||||
// refresh, logout, settings put, create, bulk-delete, update, delete, link, unlink
|
||||
if unsafe != 9 {
|
||||
t.Fatalf("walked %d state-changing routes, want 9: %v", unsafe, router.order)
|
||||
}
|
||||
|
||||
loginHandler := router.handlers[login]
|
||||
req, _ := csrfRequest(http.MethodPost, adminAPI("/auth/login"), nil)
|
||||
rec := httptest.NewRecorder()
|
||||
loginHandler(rec, req)
|
||||
if rec.Code == http.StatusForbidden {
|
||||
t.Fatalf("login without the header was refused: %s", rec.Body.String())
|
||||
}
|
||||
}
|
||||
|
||||
type readSpy struct {
|
||||
r io.Reader
|
||||
reads int
|
||||
}
|
||||
|
||||
func (s *readSpy) Read(p []byte) (int, error) {
|
||||
s.reads++
|
||||
return s.r.Read(p)
|
||||
}
|
||||
|
||||
func csrfRequest(method, path string, principal *bouncer.Principal) (*http.Request, *readSpy) {
|
||||
spy := &readSpy{r: strings.NewReader(`{"ids":[1],"name":"csrf"}`)}
|
||||
req := httptest.NewRequest(method, path, spy)
|
||||
req.Header.Set("Content-Type", "application/json")
|
||||
req.SetPathValue("vendor", "acme")
|
||||
req.SetPathValue("plugin", "demo")
|
||||
req.SetPathValue("controller", "widgets")
|
||||
req.SetPathValue("id", "1")
|
||||
req.SetPathValue("name", "editors")
|
||||
req.SetPathValue("code", "demo")
|
||||
if principal != nil {
|
||||
req = req.WithContext(bouncer.WithUser(req.Context(), principal))
|
||||
}
|
||||
return req, spy
|
||||
}
|
||||
|
||||
// handlerRouter records the handler mounted for every route, so tests can
|
||||
// call exactly what service.mount registered.
|
||||
type handlerRouter struct {
|
||||
prefix string
|
||||
handlers map[string]http.HandlerFunc
|
||||
order []string
|
||||
}
|
||||
|
||||
func (h *handlerRouter) Group(prefix string, middleware []string, fn func(pact.Router)) {
|
||||
h.GroupRaw(prefix, middleware, fn)
|
||||
}
|
||||
|
||||
func (h *handlerRouter) GroupRaw(prefix string, _ []string, fn func(pact.Router)) {
|
||||
child := &handlerRouter{prefix: h.prefix + prefix, handlers: h.handlers}
|
||||
fn(child)
|
||||
h.order = append(h.order, child.order...)
|
||||
}
|
||||
|
||||
func (h *handlerRouter) Get(path string, fn http.HandlerFunc, _ ...string) {
|
||||
h.add(http.MethodGet, path, fn)
|
||||
}
|
||||
|
||||
func (h *handlerRouter) Post(path string, fn http.HandlerFunc, _ ...string) {
|
||||
h.add(http.MethodPost, path, fn)
|
||||
}
|
||||
|
||||
func (h *handlerRouter) Put(path string, fn http.HandlerFunc, _ ...string) {
|
||||
h.add(http.MethodPut, path, fn)
|
||||
}
|
||||
|
||||
func (h *handlerRouter) Patch(path string, fn http.HandlerFunc, _ ...string) {
|
||||
h.add(http.MethodPatch, path, fn)
|
||||
}
|
||||
|
||||
func (h *handlerRouter) Delete(path string, fn http.HandlerFunc, _ ...string) {
|
||||
h.add(http.MethodDelete, path, fn)
|
||||
}
|
||||
|
||||
func (h *handlerRouter) Where(string, string) {}
|
||||
func (h *handlerRouter) WhereIn(string, ...string) {}
|
||||
|
||||
func (h *handlerRouter) add(method, path string, fn http.HandlerFunc) {
|
||||
key := method + " " + h.prefix + path
|
||||
h.handlers[key] = fn
|
||||
h.order = append(h.order, key)
|
||||
}
|
||||
49
modules/cabana/prefix.go
Normal file
49
modules/cabana/prefix.go
Normal file
@@ -0,0 +1,49 @@
|
||||
package cabana
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"regexp"
|
||||
"strings"
|
||||
|
||||
"git.golem15.com/golem15/summercms/modules/backpack"
|
||||
)
|
||||
|
||||
// DefaultAdminPrefix is the admin mount path when backend.uri is unset.
|
||||
// It matches WinterCMS's backendUri default.
|
||||
const DefaultAdminPrefix = "/backend"
|
||||
|
||||
// AdminCookieName carries the admin JWT for the embedded SPA (D-19).
|
||||
const AdminCookieName = "summer_admin"
|
||||
|
||||
// adminAPIVersion is appended to the prefix for every admin API route.
|
||||
const adminAPIVersion = "/api/v1"
|
||||
|
||||
var adminPrefixPattern = regexp.MustCompile(`^(/[a-z0-9][a-z0-9_-]*)+$`)
|
||||
|
||||
// AdminPrefix reads backend.uri and returns the normalized admin mount path.
|
||||
// Spaces are trimmed, a leading slash is added and trailing slashes are
|
||||
// removed; an empty value falls back to DefaultAdminPrefix. Every segment
|
||||
// must be lowercase letters, digits, '-' or '_' and start with a letter or
|
||||
// digit, so "/" alone, uppercase, spaces and dot segments are rejected.
|
||||
func AdminPrefix(app *backpack.App) (string, error) {
|
||||
raw := ""
|
||||
if app != nil && app.Config != nil {
|
||||
raw = app.Config.String("backend.uri")
|
||||
}
|
||||
return normalizeAdminPrefix(raw)
|
||||
}
|
||||
|
||||
func normalizeAdminPrefix(raw string) (string, error) {
|
||||
value := strings.TrimSpace(raw)
|
||||
if value == "" {
|
||||
return DefaultAdminPrefix, nil
|
||||
}
|
||||
if !strings.HasPrefix(value, "/") {
|
||||
value = "/" + value
|
||||
}
|
||||
value = strings.TrimRight(value, "/")
|
||||
if value == "" || !adminPrefixPattern.MatchString(value) {
|
||||
return "", fmt.Errorf("cabana: backend.uri %q is invalid: use one or more lowercase path segments such as /backend (set SUMMER_BACKEND__URI)", raw)
|
||||
}
|
||||
return value, nil
|
||||
}
|
||||
544
modules/cabana/query.go
Normal file
544
modules/cabana/query.go
Normal file
@@ -0,0 +1,544 @@
|
||||
package cabana
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"net/http"
|
||||
"reflect"
|
||||
"strconv"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"git.golem15.com/golem15/summercms/modules/lagoon"
|
||||
"git.golem15.com/golem15/summercms/modules/pact"
|
||||
"gorm.io/gorm"
|
||||
"gorm.io/gorm/clause"
|
||||
)
|
||||
|
||||
// ListInput is the raw admin list query. Identifiers are matched later
|
||||
// against the compiled schema; nothing here is SQL.
|
||||
type ListInput struct {
|
||||
Search string
|
||||
Sort string
|
||||
Dir string
|
||||
Page string
|
||||
PerPage string
|
||||
Filters map[string]string
|
||||
}
|
||||
|
||||
// ListMeta is the D-11 pagination block.
|
||||
type ListMeta struct {
|
||||
Page int `json:"page"`
|
||||
PerPage int `json:"per_page"`
|
||||
Total int64 `json:"total"`
|
||||
LastPage int `json:"last_page"`
|
||||
}
|
||||
|
||||
// ListResult is one page of projected rows.
|
||||
type ListResult struct {
|
||||
Data []map[string]any
|
||||
Meta ListMeta
|
||||
}
|
||||
|
||||
// ListValidationError is a D-10 validation_failed failure.
|
||||
type ListValidationError struct {
|
||||
Details map[string]any
|
||||
}
|
||||
|
||||
func (e *ListValidationError) Error() string { return "validation_failed" }
|
||||
|
||||
func listInvalid(field, message string) *ListValidationError {
|
||||
return &ListValidationError{Details: map[string]any{field: []string{message}}}
|
||||
}
|
||||
|
||||
func listQueryFromRequest(r *http.Request) ListInput {
|
||||
q := r.URL.Query()
|
||||
filters := map[string]string{}
|
||||
for key, vals := range q {
|
||||
if !strings.HasPrefix(key, "filter[") || !strings.HasSuffix(key, "]") || len(key) <= len("filter[]") {
|
||||
continue
|
||||
}
|
||||
name := key[len("filter[") : len(key)-1]
|
||||
if len(vals) == 0 {
|
||||
filters[name] = ""
|
||||
continue
|
||||
}
|
||||
filters[name] = vals[len(vals)-1]
|
||||
}
|
||||
return ListInput{
|
||||
Search: q.Get(listSearchTerm),
|
||||
Sort: q.Get("sort"),
|
||||
Dir: q.Get("dir"),
|
||||
Page: q.Get("page"),
|
||||
PerPage: q.Get("per_page"),
|
||||
Filters: filters,
|
||||
}
|
||||
}
|
||||
|
||||
// ExecuteList runs an allowlisted search, sort, filter, and page against db.
|
||||
func ExecuteList(ctx context.Context, db *gorm.DB, cc *CompiledController, in ListInput) (*ListResult, error) {
|
||||
if cc == nil || cc.List == nil {
|
||||
return nil, errors.New("cabana: list schema is missing")
|
||||
}
|
||||
if db == nil {
|
||||
return nil, errors.New("cabana: database is not configured")
|
||||
}
|
||||
src, ok := cc.Controller.(pact.AdminRecordSource)
|
||||
if !ok || src == nil || src.NewRecord() == nil {
|
||||
return nil, errors.New("cabana: admin controller has no record source")
|
||||
}
|
||||
model := src.NewRecord()
|
||||
mt := reflect.TypeOf(model)
|
||||
if mt == nil || mt.Kind() != reflect.Pointer || mt.Elem().Kind() != reflect.Struct {
|
||||
return nil, errors.New("cabana: admin model must be a pointer")
|
||||
}
|
||||
if ctx == nil {
|
||||
ctx = context.Background()
|
||||
}
|
||||
page, per, err := normalizePage(cc.List, in)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
sortCol, sortDesc, err := normalizeSort(cc.List, in)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
q := db.WithContext(ctx).Model(model)
|
||||
if ext, ok := cc.Controller.(pact.ListExtendQuery); ok && ext != nil {
|
||||
if next := ext.ListExtendQuery(ctx, q); next != nil {
|
||||
q = next
|
||||
}
|
||||
}
|
||||
q, err = applyListSearch(q, cc.Controller, cc.List, model, in.Search)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
q, err = applyListFilters(q, cc.List, model, in.Filters)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
var total int64
|
||||
if err := q.Session(&gorm.Session{}).Count(&total).Error; err != nil {
|
||||
return nil, err
|
||||
}
|
||||
q = applyListOrder(q, cc.Controller, cc.List, model, sortCol, sortDesc)
|
||||
for _, col := range cc.List.Columns {
|
||||
if col.Relation == "" {
|
||||
continue
|
||||
}
|
||||
if field, ok := relationFieldName(model, col.Relation); ok {
|
||||
q = q.Preload(field)
|
||||
}
|
||||
}
|
||||
offset := (page - 1) * per
|
||||
slice := reflect.New(reflect.SliceOf(mt.Elem()))
|
||||
if err := q.Offset(offset).Limit(per).Find(slice.Interface()).Error; err != nil {
|
||||
return nil, err
|
||||
}
|
||||
values := slice.Elem()
|
||||
data := make([]map[string]any, 0, values.Len())
|
||||
for i := 0; i < values.Len(); i++ {
|
||||
data = append(data, projectRow(values.Index(i).Addr().Interface(), cc.Controller, cc.List.Columns))
|
||||
}
|
||||
paged := lagoon.Paginate(data, page, per, total)
|
||||
return &ListResult{
|
||||
Data: paged.Data,
|
||||
Meta: ListMeta{
|
||||
Page: paged.Meta.CurrentPage,
|
||||
PerPage: paged.Meta.PerPage,
|
||||
Total: paged.Meta.Total,
|
||||
LastPage: paged.Meta.LastPage,
|
||||
},
|
||||
}, nil
|
||||
}
|
||||
|
||||
func normalizePage(schema *ListSchema, in ListInput) (int, int, error) {
|
||||
page := 1
|
||||
if in.Page != "" {
|
||||
n, err := strconv.Atoi(in.Page)
|
||||
if err != nil || n < 1 {
|
||||
return 0, 0, listInvalid("page", "must be a positive integer")
|
||||
}
|
||||
page = n
|
||||
}
|
||||
per := schema.RecordsPerPage
|
||||
if per < 1 {
|
||||
per = 20
|
||||
}
|
||||
if in.PerPage != "" {
|
||||
n, err := strconv.Atoi(in.PerPage)
|
||||
if err != nil || !pageSizeAllowed(schema, n) {
|
||||
return 0, 0, listInvalid("per_page", "is not an allowed page size")
|
||||
}
|
||||
per = n
|
||||
}
|
||||
return page, per, nil
|
||||
}
|
||||
|
||||
func pageSizeAllowed(schema *ListSchema, n int) bool {
|
||||
if n < 1 {
|
||||
return false
|
||||
}
|
||||
options := schema.PerPageOptions
|
||||
if len(options) == 0 {
|
||||
return n == schema.RecordsPerPage || (schema.RecordsPerPage < 1 && n == 20)
|
||||
}
|
||||
for _, option := range options {
|
||||
if option == n {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func normalizeSort(schema *ListSchema, in ListInput) (string, bool, error) {
|
||||
if in.Sort == "" {
|
||||
if schema.DefaultSort == nil {
|
||||
return "", false, nil
|
||||
}
|
||||
return schema.DefaultSort.Column, schema.DefaultSort.Direction == "desc", nil
|
||||
}
|
||||
if !schema.ShowSorting {
|
||||
return "", false, listInvalid("sort", "is not sortable")
|
||||
}
|
||||
var match *ListColumn
|
||||
for i := range schema.Columns {
|
||||
if schema.Columns[i].Key == in.Sort {
|
||||
match = &schema.Columns[i]
|
||||
break
|
||||
}
|
||||
}
|
||||
if match == nil || !match.Sortable {
|
||||
return "", false, listInvalid("sort", "is not a sortable column")
|
||||
}
|
||||
dir := in.Dir
|
||||
if dir == "" {
|
||||
dir = "asc"
|
||||
}
|
||||
if dir != "asc" && dir != "desc" {
|
||||
return "", false, listInvalid("dir", "must be asc or desc")
|
||||
}
|
||||
return match.Key, dir == "desc", nil
|
||||
}
|
||||
|
||||
func applyListOrder(db *gorm.DB, controller pact.AdminController, schema *ListSchema, model any, column string, desc bool) *gorm.DB {
|
||||
table := tableName(model)
|
||||
pk := primaryColumn(model)
|
||||
if column != "" {
|
||||
orderTable := table
|
||||
orderColumn := column
|
||||
for _, col := range schema.Columns {
|
||||
if col.Key != column || col.Relation == "" {
|
||||
continue
|
||||
}
|
||||
field, ok := relationFieldName(model, col.Relation)
|
||||
if !ok {
|
||||
continue
|
||||
}
|
||||
orderTable = field
|
||||
orderColumn = listRelationColumn(controller, col.Relation, col.Select)
|
||||
db = db.Joins(field)
|
||||
break
|
||||
}
|
||||
db = db.Order(clause.OrderByColumn{
|
||||
Column: clause.Column{Table: orderTable, Name: orderColumn},
|
||||
Desc: desc,
|
||||
})
|
||||
}
|
||||
if column != pk {
|
||||
db = db.Order(clause.OrderByColumn{Column: clause.Column{Table: table, Name: pk}})
|
||||
}
|
||||
return db
|
||||
}
|
||||
|
||||
func applyListSearch(db *gorm.DB, controller pact.AdminController, schema *ListSchema, model any, term string) (*gorm.DB, error) {
|
||||
term = strings.TrimSpace(term)
|
||||
if term == "" {
|
||||
return db, nil
|
||||
}
|
||||
var cols []ListColumn
|
||||
for _, col := range schema.Columns {
|
||||
if col.Searchable {
|
||||
cols = append(cols, col)
|
||||
}
|
||||
}
|
||||
if len(cols) == 0 {
|
||||
return nil, listInvalid("search", "is not searchable")
|
||||
}
|
||||
pattern := "%" + escapeLike(strings.ToLower(term)) + "%"
|
||||
joined := map[string]struct{}{}
|
||||
parts := make([]string, 0, len(cols))
|
||||
args := make([]any, 0, len(cols))
|
||||
main := tableName(model)
|
||||
for _, col := range cols {
|
||||
table := main
|
||||
column := col.Key
|
||||
if col.Relation != "" {
|
||||
field, ok := relationFieldName(model, col.Relation)
|
||||
physical := listRelationColumn(controller, col.Relation, col.Select)
|
||||
if !ok || !identifier(physical) {
|
||||
return nil, listInvalid("search", "is not searchable")
|
||||
}
|
||||
// GORM aliases the joined association with the Go field name.
|
||||
table = field
|
||||
column = physical
|
||||
if _, done := joined[field]; !done {
|
||||
db = db.Joins(field)
|
||||
joined[field] = struct{}{}
|
||||
}
|
||||
} else if !identifier(column) {
|
||||
return nil, listInvalid("search", "is not searchable")
|
||||
}
|
||||
parts = append(parts, fmt.Sprintf("LOWER(%s) LIKE ? ESCAPE '\\'", qualifiedColumn(db, table, column)))
|
||||
args = append(args, pattern)
|
||||
}
|
||||
return db.Where(strings.Join(parts, " OR "), args...), nil
|
||||
}
|
||||
|
||||
func applyListFilters(db *gorm.DB, schema *ListSchema, model any, filters map[string]string) (*gorm.DB, error) {
|
||||
if len(filters) == 0 {
|
||||
return db, nil
|
||||
}
|
||||
byName := map[string]ListFilter{}
|
||||
for _, filter := range schema.Filters {
|
||||
byName[filter.Name] = filter
|
||||
}
|
||||
table := tableName(model)
|
||||
var provider pact.FilterScope
|
||||
if scope, ok := model.(pact.FilterScope); ok {
|
||||
provider = scope
|
||||
}
|
||||
for name, raw := range filters {
|
||||
filter, ok := byName[name]
|
||||
if !ok || !identifier(name) {
|
||||
return nil, listInvalid("filter", "is not a declared filter")
|
||||
}
|
||||
switch filter.Type {
|
||||
case "switch":
|
||||
value, ok := switchArgument(filter, raw)
|
||||
if !ok {
|
||||
return nil, listInvalid("filter", "is not a declared value")
|
||||
}
|
||||
db = db.Where(clause.Eq{Column: clause.Column{Table: table, Name: filter.Column}, Value: value})
|
||||
case "daterange":
|
||||
start, end, err := parseDateRange(raw)
|
||||
if err != nil {
|
||||
return nil, listInvalid("filter", "is not a valid date range")
|
||||
}
|
||||
db = db.Where(clause.Gte{Column: clause.Column{Table: table, Name: filter.Column}, Value: start})
|
||||
db = db.Where(clause.Lt{Column: clause.Column{Table: table, Name: filter.Column}, Value: end})
|
||||
case "scope":
|
||||
arg, err := scopeArgument(raw)
|
||||
if err != nil {
|
||||
return nil, listInvalid("filter", "is not a declared value")
|
||||
}
|
||||
if provider == nil {
|
||||
return nil, errors.New("cabana: filter scope provider is missing")
|
||||
}
|
||||
next := provider.FilterScope(filter.Scope, db, arg)
|
||||
if next == nil {
|
||||
return nil, errors.New("cabana: filter scope returned nil")
|
||||
}
|
||||
db = next
|
||||
default:
|
||||
return nil, listInvalid("filter", "is not a declared filter")
|
||||
}
|
||||
}
|
||||
return db, nil
|
||||
}
|
||||
|
||||
func switchArgument(filter ListFilter, raw string) (any, bool) {
|
||||
if len(filter.Options) > 0 {
|
||||
for _, opt := range filter.Options {
|
||||
if string(opt.Value.raw) == raw {
|
||||
return scalarValue(opt.Value), true
|
||||
}
|
||||
}
|
||||
return nil, false
|
||||
}
|
||||
if filter.TrueValue != nil && string(filter.TrueValue.raw) == raw {
|
||||
return scalarValue(*filter.TrueValue), true
|
||||
}
|
||||
if filter.FalseValue != nil && string(filter.FalseValue.raw) == raw {
|
||||
return scalarValue(*filter.FalseValue), true
|
||||
}
|
||||
return nil, false
|
||||
}
|
||||
|
||||
func scalarValue(s jsonScalar) any {
|
||||
var v any
|
||||
if err := json.Unmarshal(s.raw, &v); err != nil {
|
||||
return string(s.raw)
|
||||
}
|
||||
return v
|
||||
}
|
||||
|
||||
func parseDateRange(raw string) (time.Time, time.Time, error) {
|
||||
startText, endText, ok := strings.Cut(raw, "..")
|
||||
if !ok || startText == "" || endText == "" {
|
||||
return time.Time{}, time.Time{}, errors.New("range")
|
||||
}
|
||||
start, err := time.ParseInLocation("2006-01-02", startText, time.UTC)
|
||||
if err != nil {
|
||||
return time.Time{}, time.Time{}, err
|
||||
}
|
||||
end, err := time.ParseInLocation("2006-01-02", endText, time.UTC)
|
||||
if err != nil {
|
||||
return time.Time{}, time.Time{}, err
|
||||
}
|
||||
if end.Before(start) {
|
||||
return time.Time{}, time.Time{}, errors.New("range order")
|
||||
}
|
||||
return start, end.AddDate(0, 0, 1), nil
|
||||
}
|
||||
|
||||
func scopeArgument(raw string) (any, error) {
|
||||
if raw == "" || strings.ContainsAny(raw, " \t;'\"\\") || strings.Contains(raw, "--") {
|
||||
return nil, errors.New("value")
|
||||
}
|
||||
if n, err := strconv.ParseInt(raw, 10, 64); err == nil {
|
||||
return n, nil
|
||||
}
|
||||
if !identifier(raw) {
|
||||
return nil, errors.New("value")
|
||||
}
|
||||
return raw, nil
|
||||
}
|
||||
|
||||
func escapeLike(s string) string {
|
||||
s = strings.ReplaceAll(s, `\`, `\\`)
|
||||
s = strings.ReplaceAll(s, `%`, `\%`)
|
||||
s = strings.ReplaceAll(s, `_`, `\_`)
|
||||
return s
|
||||
}
|
||||
|
||||
func qualifiedColumn(db *gorm.DB, table, column string) string {
|
||||
return quotedIdent(db, table) + "." + quotedIdent(db, column)
|
||||
}
|
||||
|
||||
func quotedIdent(db *gorm.DB, name string) string {
|
||||
if db == nil || db.Dialector == nil || !identifier(name) && !strings.Contains(name, "_") {
|
||||
return `"` + strings.ReplaceAll(name, `"`, `""`) + `"`
|
||||
}
|
||||
var b strings.Builder
|
||||
db.Dialector.QuoteTo(&b, name)
|
||||
return b.String()
|
||||
}
|
||||
|
||||
func tableName(model any) string {
|
||||
if model == nil {
|
||||
return ""
|
||||
}
|
||||
if namer, ok := model.(interface{ TableName() string }); ok {
|
||||
return namer.TableName()
|
||||
}
|
||||
t := reflect.TypeOf(model)
|
||||
for t != nil && t.Kind() == reflect.Pointer {
|
||||
t = t.Elem()
|
||||
}
|
||||
if t == nil {
|
||||
return ""
|
||||
}
|
||||
ptr := reflect.New(t)
|
||||
if namer, ok := ptr.Interface().(interface{ TableName() string }); ok {
|
||||
return namer.TableName()
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
// relationFieldName resolves a Winter relation key onto the exported Go field.
|
||||
// Exact names win; otherwise the match is case-insensitive, so relation: genre
|
||||
// selects field Genre.
|
||||
func relationFieldName(model any, relation string) (string, bool) {
|
||||
t := reflect.TypeOf(model)
|
||||
for t != nil && t.Kind() == reflect.Pointer {
|
||||
t = t.Elem()
|
||||
}
|
||||
if t == nil || t.Kind() != reflect.Struct || relation == "" {
|
||||
return "", false
|
||||
}
|
||||
if field, ok := t.FieldByName(relation); ok && isListRelation(field.Type) {
|
||||
return field.Name, true
|
||||
}
|
||||
for i := 0; i < t.NumField(); i++ {
|
||||
field := t.Field(i)
|
||||
if field.PkgPath != "" || !isListRelation(field.Type) {
|
||||
continue
|
||||
}
|
||||
if strings.EqualFold(field.Name, relation) {
|
||||
return field.Name, true
|
||||
}
|
||||
}
|
||||
return "", false
|
||||
}
|
||||
|
||||
func primaryColumn(model any) string {
|
||||
t := reflect.TypeOf(model)
|
||||
for t != nil && t.Kind() == reflect.Pointer {
|
||||
t = t.Elem()
|
||||
}
|
||||
if t == nil || t.Kind() != reflect.Struct {
|
||||
return "id"
|
||||
}
|
||||
for i := 0; i < t.NumField(); i++ {
|
||||
field := t.Field(i)
|
||||
if field.PkgPath != "" {
|
||||
continue
|
||||
}
|
||||
if strings.Contains(field.Tag.Get("gorm"), "primaryKey") {
|
||||
if name := gormColumn(field); name != "" {
|
||||
return name
|
||||
}
|
||||
return field.Name
|
||||
}
|
||||
}
|
||||
return "id"
|
||||
}
|
||||
|
||||
func relatedSelect(row reflect.Value, controller pact.AdminController, col ListColumn) (any, bool) {
|
||||
for row.Kind() == reflect.Pointer {
|
||||
if row.IsNil() {
|
||||
return nil, false
|
||||
}
|
||||
row = row.Elem()
|
||||
}
|
||||
if row.Kind() != reflect.Struct || col.Relation == "" {
|
||||
return nil, false
|
||||
}
|
||||
name, ok := relationFieldName(row.Interface(), col.Relation)
|
||||
if !ok {
|
||||
return nil, false
|
||||
}
|
||||
field := row.FieldByName(name)
|
||||
if !field.IsValid() {
|
||||
return nil, false
|
||||
}
|
||||
for field.Kind() == reflect.Pointer {
|
||||
if field.IsNil() {
|
||||
return nil, false
|
||||
}
|
||||
field = field.Elem()
|
||||
}
|
||||
if field.Kind() != reflect.Struct {
|
||||
return nil, false
|
||||
}
|
||||
selected := fieldByColumn(field, listRelationColumn(controller, col.Relation, col.Select))
|
||||
if !selected.IsValid() || !selected.CanInterface() {
|
||||
return nil, false
|
||||
}
|
||||
return selected.Interface(), true
|
||||
}
|
||||
|
||||
func listRelationColumn(controller pact.AdminController, relation, column string) string {
|
||||
mapper, ok := controller.(pact.ListRelationColumnMapper)
|
||||
if !ok || mapper == nil {
|
||||
return column
|
||||
}
|
||||
mapped, ok := mapper.ListRelationColumn(relation, column)
|
||||
if !ok || mapped == "" {
|
||||
return column
|
||||
}
|
||||
return mapped
|
||||
}
|
||||
437
modules/cabana/query_test.go
Normal file
437
modules/cabana/query_test.go
Normal file
@@ -0,0 +1,437 @@
|
||||
package cabana
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"strings"
|
||||
"sync"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"git.golem15.com/golem15/summercms/modules/backpack"
|
||||
"git.golem15.com/golem15/summercms/modules/bouncer"
|
||||
"git.golem15.com/golem15/summercms/modules/pact"
|
||||
tcpostgres "github.com/testcontainers/testcontainers-go/modules/postgres"
|
||||
pgdriver "gorm.io/driver/postgres"
|
||||
"gorm.io/gorm"
|
||||
)
|
||||
|
||||
const queryListConfig = `modelClass: Widget
|
||||
list: ~/plugins/acme/demo/models/widget/columns.yaml
|
||||
recordsPerPage: 20
|
||||
perPageOptions:
|
||||
- 2
|
||||
- 10
|
||||
- 20
|
||||
showSorting: true
|
||||
defaultSort:
|
||||
column: name
|
||||
direction: asc
|
||||
filter: config_filter.yaml
|
||||
`
|
||||
|
||||
const queryColumns = `columns:
|
||||
name:
|
||||
label: Name
|
||||
searchable: true
|
||||
sortable: true
|
||||
active:
|
||||
label: Active
|
||||
type: switch
|
||||
sortable: true
|
||||
artist:
|
||||
label: Artist
|
||||
relation: Artist
|
||||
select: name
|
||||
searchable: true
|
||||
`
|
||||
|
||||
const queryFilters = `scopes:
|
||||
active:
|
||||
label: Active
|
||||
type: switch
|
||||
column: active
|
||||
created:
|
||||
label: Created
|
||||
type: daterange
|
||||
column: created_at
|
||||
grouped:
|
||||
label: Group
|
||||
modelClass: Group
|
||||
nameFrom: name
|
||||
scope: filterByGroup
|
||||
`
|
||||
|
||||
func TestListQueryContract(t *testing.T) {
|
||||
svc, db := newListService(t)
|
||||
seedListRows(t, db)
|
||||
rec := getList(t, svc, "search=Other")
|
||||
body := decodeList(t, rec, http.StatusOK)
|
||||
if body.Meta.Total != 1 || len(body.Data) != 1 || rowID(body.Data[0]) != 4 {
|
||||
t.Fatalf("search = total %d ids %v", body.Meta.Total, rowIDs(body.Data))
|
||||
}
|
||||
sorted := decodeList(t, getList(t, svc, "sort=name&dir=desc&per_page=2&page=1"), http.StatusOK)
|
||||
if ids := rowIDs(sorted.Data); len(ids) != 2 || ids[0] != 1 || ids[1] != 2 {
|
||||
t.Fatalf("desc page = %v, want [1 2]", ids)
|
||||
}
|
||||
related := decodeList(t, getList(t, svc, "search=Beatles"), http.StatusOK)
|
||||
if related.Meta.Total != 1 || len(related.Data) != 1 || rowID(related.Data[0]) != 1 {
|
||||
t.Fatalf("relation search = total %d ids %v", related.Meta.Total, rowIDs(related.Data))
|
||||
}
|
||||
}
|
||||
|
||||
func TestListQueryEmpty(t *testing.T) {
|
||||
svc, db := newListService(t)
|
||||
if err := db.Exec("DELETE FROM cabana_list_query_rows").Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
rec := getList(t, svc, "per_page=10")
|
||||
if !json.Valid(rec.Body.Bytes()) || rec.Body.String() == "" {
|
||||
t.Fatalf("body %s", rec.Body.String())
|
||||
}
|
||||
body := decodeList(t, rec, http.StatusOK)
|
||||
if body.Data == nil || len(body.Data) != 0 || body.Meta.Page != 1 || body.Meta.PerPage != 10 || body.Meta.Total != 0 || body.Meta.LastPage != 1 {
|
||||
t.Fatalf("empty envelope = %+v data %#v", body.Meta, body.Data)
|
||||
}
|
||||
if strings.Contains(rec.Body.String(), `"data":null`) {
|
||||
t.Fatalf("empty data was null: %s", rec.Body.String())
|
||||
}
|
||||
}
|
||||
|
||||
func TestListQuerySingle(t *testing.T) {
|
||||
svc, db := newListService(t)
|
||||
resetListRows(t, db)
|
||||
if err := db.Create(&queryRow{ID: 7, Name: "Only", Active: true, CreatedAt: time.Date(2024, 1, 2, 12, 0, 0, 0, time.UTC)}).Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
body := decodeList(t, getList(t, svc, "per_page=10"), http.StatusOK)
|
||||
if len(body.Data) != 1 || body.Meta.Total != 1 || body.Meta.LastPage != 1 || body.Meta.PerPage != 10 || rowID(body.Data[0]) != 7 {
|
||||
t.Fatalf("single = %+v ids %v", body.Meta, rowIDs(body.Data))
|
||||
}
|
||||
}
|
||||
|
||||
func TestListQueryAdjacent(t *testing.T) {
|
||||
svc, db := newListService(t)
|
||||
seedListRows(t, db)
|
||||
page1 := decodeList(t, getList(t, svc, "sort=name&dir=asc&per_page=2&page=1"), http.StatusOK)
|
||||
page2 := decodeList(t, getList(t, svc, "sort=name&dir=asc&per_page=2&page=2"), http.StatusOK)
|
||||
if ids := rowIDs(page1.Data); len(ids) != 2 || ids[0] != 4 || ids[1] != 1 {
|
||||
t.Fatalf("page 1 = %v, want [4 1]", ids)
|
||||
}
|
||||
if ids := rowIDs(page2.Data); len(ids) != 2 || ids[0] != 2 || ids[1] != 3 {
|
||||
t.Fatalf("page 2 = %v, want [2 3]", ids)
|
||||
}
|
||||
seen := map[int]struct{}{}
|
||||
for _, id := range append(rowIDs(page1.Data), rowIDs(page2.Data)...) {
|
||||
if _, dup := seen[id]; dup {
|
||||
t.Fatalf("duplicate id %d across adjacent pages", id)
|
||||
}
|
||||
seen[id] = struct{}{}
|
||||
}
|
||||
}
|
||||
|
||||
func TestListQueryFilters(t *testing.T) {
|
||||
svc, db := newListService(t)
|
||||
seedListRows(t, db)
|
||||
active := decodeList(t, getList(t, svc, "filter[active]=true&per_page=10"), http.StatusOK)
|
||||
if ids := rowIDs(active.Data); !sameIDs(ids, []int{1, 3, 4}) {
|
||||
t.Fatalf("switch ids = %v", ids)
|
||||
}
|
||||
dates := decodeList(t, getList(t, svc, "filter[created]=2024-01-01..2024-01-31&per_page=10"), http.StatusOK)
|
||||
if ids := rowIDs(dates.Data); !sameIDs(ids, []int{1, 2}) {
|
||||
t.Fatalf("date ids = %v", ids)
|
||||
}
|
||||
scoped := decodeList(t, getList(t, svc, "filter[grouped]=9&per_page=10"), http.StatusOK)
|
||||
if ids := rowIDs(scoped.Data); !sameIDs(ids, []int{3}) {
|
||||
t.Fatalf("scope ids = %v", ids)
|
||||
}
|
||||
}
|
||||
|
||||
func TestListQueryRejectsInjection(t *testing.T) {
|
||||
svc, db := newListService(t)
|
||||
seedListRows(t, db)
|
||||
before := countListRows(t, db)
|
||||
cases := []struct {
|
||||
name string
|
||||
query string
|
||||
field string
|
||||
}{
|
||||
{name: "sort injection", query: "sort=name%3Bdrop", field: "sort"},
|
||||
{name: "sort case", query: "sort=Name", field: "sort"},
|
||||
{name: "direction case", query: "sort=name&dir=DESC", field: "dir"},
|
||||
{name: "unknown filter", query: "filter[missing]=1", field: "filter"},
|
||||
{name: "page zero", query: "page=0", field: "page"},
|
||||
{name: "page text", query: "page=foo", field: "page"},
|
||||
{name: "per page cap", query: "per_page=999999", field: "per_page"},
|
||||
{name: "bad switch", query: "filter[active]=maybe", field: "filter"},
|
||||
{name: "bad range", query: "filter[created]=2024-02-01..2024-01-01", field: "filter"},
|
||||
}
|
||||
for _, tc := range cases {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
rec := getList(t, svc, tc.query)
|
||||
if rec.Code != http.StatusUnprocessableEntity {
|
||||
t.Fatalf("status=%d body=%s", rec.Code, rec.Body.String())
|
||||
}
|
||||
var body listEnvelope
|
||||
if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if body.Error.Code != "validation_failed" {
|
||||
t.Fatalf("code=%s body=%s", body.Error.Code, rec.Body.String())
|
||||
}
|
||||
if _, ok := body.Error.Details[tc.field]; !ok {
|
||||
t.Fatalf("details missing %s: %s", tc.field, rec.Body.String())
|
||||
}
|
||||
if strings.Contains(rec.Body.String(), "drop table") {
|
||||
t.Fatalf("error body echoed SQL: %s", rec.Body.String())
|
||||
}
|
||||
})
|
||||
}
|
||||
payload := decodeList(t, getList(t, svc, "search=%25%27+OR+%271%27%3D%271"), http.StatusOK)
|
||||
if payload.Meta.Total != 0 {
|
||||
t.Fatalf("injected search matched %d rows", payload.Meta.Total)
|
||||
}
|
||||
if countListRows(t, db) != before {
|
||||
t.Fatalf("row count changed from %d to %d", before, countListRows(t, db))
|
||||
}
|
||||
|
||||
t.Run("permission before query", func(t *testing.T) {
|
||||
locked := *svc
|
||||
locked.reg = &Registry{byID: map[string]*CompiledController{
|
||||
"acme.demo.widgets": {
|
||||
Controller: queryController{perms: []string{"acme.demo.access"}},
|
||||
List: svc.reg.byID["acme.demo.widgets"].List,
|
||||
},
|
||||
}}
|
||||
rec := httptest.NewRecorder()
|
||||
req := controllerRequest(&bouncer.Principal{ID: 4})
|
||||
req.URL.RawQuery = "sort=name%3Bdrop"
|
||||
locked.list(rec, req)
|
||||
if rec.Code != http.StatusForbidden {
|
||||
t.Fatalf("status=%d body=%s", rec.Code, rec.Body.String())
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
type queryArtist struct {
|
||||
ID uint `gorm:"column:id;primaryKey"`
|
||||
Name string `gorm:"column:name"`
|
||||
}
|
||||
|
||||
func (queryArtist) TableName() string { return "cabana_list_query_artists" }
|
||||
|
||||
type queryRow struct {
|
||||
ID uint `gorm:"column:id;primaryKey"`
|
||||
Name string `gorm:"column:name"`
|
||||
Active bool `gorm:"column:active"`
|
||||
CreatedAt time.Time `gorm:"column:created_at"`
|
||||
GroupID uint `gorm:"column:group_id"`
|
||||
ArtistID *uint `gorm:"column:artist_id"`
|
||||
Artist queryArtist `gorm:"foreignKey:ArtistID"`
|
||||
}
|
||||
|
||||
func (queryRow) TableName() string { return "cabana_list_query_rows" }
|
||||
|
||||
func (queryRow) FilterScopes() []string { return []string{"filterByGroup"} }
|
||||
|
||||
// FilterOptions serves the grouped scope's choices (D-27).
|
||||
func (queryRow) FilterOptions(scope string) []pact.Option {
|
||||
if scope != "filterByGroup" {
|
||||
return nil
|
||||
}
|
||||
return []pact.Option{{Value: "4", Label: "demo::lang.group_four"}, {Value: "9", Label: "Group nine"}}
|
||||
}
|
||||
|
||||
func (queryRow) FilterScope(name string, db *gorm.DB, value any) *gorm.DB {
|
||||
if db == nil || name != "filterByGroup" {
|
||||
return db
|
||||
}
|
||||
return db.Where("group_id = ?", value)
|
||||
}
|
||||
|
||||
type queryController struct{ perms []string }
|
||||
|
||||
func (queryController) ID() string { return "acme.demo.widgets" }
|
||||
func (queryController) ModelName() string { return "Widget" }
|
||||
func (queryController) ConfigDir() string { return "controllers/widgets" }
|
||||
func (queryController) NewRecord() any { return &queryRow{} }
|
||||
func (c queryController) RequiredPermissions() []string {
|
||||
return c.perms
|
||||
}
|
||||
|
||||
var (
|
||||
listPGOnce sync.Once
|
||||
listPGDSN string
|
||||
listPGErr error
|
||||
)
|
||||
|
||||
func newListService(t *testing.T) (*service, *gorm.DB) {
|
||||
t.Helper()
|
||||
listPGOnce.Do(func() {
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
|
||||
defer cancel()
|
||||
ctr, err := tcpostgres.Run(ctx, "postgres:16-alpine",
|
||||
tcpostgres.WithDatabase("cabana"),
|
||||
tcpostgres.WithUsername("cabana"),
|
||||
tcpostgres.WithPassword("cabana"),
|
||||
tcpostgres.BasicWaitStrategies(),
|
||||
)
|
||||
if err != nil {
|
||||
listPGErr = err
|
||||
return
|
||||
}
|
||||
dsn, err := ctr.ConnectionString(ctx, "sslmode=disable")
|
||||
if err != nil {
|
||||
listPGErr = err
|
||||
return
|
||||
}
|
||||
listPGDSN = dsn
|
||||
})
|
||||
if listPGErr != nil {
|
||||
t.Fatalf("postgres: %v", listPGErr)
|
||||
}
|
||||
db, err := gorm.Open(pgdriver.Open(listPGDSN), &gorm.Config{})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := db.Migrator().DropTable(&queryRow{}, &queryArtist{}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := db.AutoMigrate(&queryArtist{}, &queryRow{}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
schema, err := CompileList("acme.demo", queryController{}, filterFS(queryListConfig, queryColumns, queryFilters))
|
||||
if err != nil {
|
||||
t.Fatalf("schema: %v", err)
|
||||
}
|
||||
app := backpack.New(nil)
|
||||
if err := app.Publish(db); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
svc := &service{app: app, reg: &Registry{byID: map[string]*CompiledController{
|
||||
"acme.demo.widgets": {Controller: queryController{}, List: schema},
|
||||
}}}
|
||||
return svc, db
|
||||
}
|
||||
|
||||
func seedListRows(t *testing.T, db *gorm.DB) {
|
||||
t.Helper()
|
||||
resetListRows(t, db)
|
||||
if err := db.Create(&queryArtist{ID: 8, Name: "Beatles"}).Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
artistID := uint(8)
|
||||
rows := []queryRow{
|
||||
{ID: 1, Name: "Same", Active: true, CreatedAt: time.Date(2024, 1, 2, 12, 0, 0, 0, time.UTC), GroupID: 4, ArtistID: &artistID},
|
||||
{ID: 2, Name: "Same", Active: false, CreatedAt: time.Date(2024, 1, 31, 12, 0, 0, 0, time.UTC), GroupID: 4},
|
||||
{ID: 3, Name: "Same", Active: true, CreatedAt: time.Date(2024, 2, 1, 12, 0, 0, 0, time.UTC), GroupID: 9},
|
||||
{ID: 4, Name: "Other", Active: true, CreatedAt: time.Date(2023, 12, 31, 12, 0, 0, 0, time.UTC), GroupID: 4},
|
||||
}
|
||||
if err := db.Create(&rows).Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
|
||||
func resetListRows(t *testing.T, db *gorm.DB) {
|
||||
t.Helper()
|
||||
if err := db.Exec("DELETE FROM cabana_list_query_rows").Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := db.Exec("DELETE FROM cabana_list_query_artists").Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
|
||||
func countListRows(t *testing.T, db *gorm.DB) int64 {
|
||||
t.Helper()
|
||||
var n int64
|
||||
if err := db.Model(&queryRow{}).Count(&n).Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return n
|
||||
}
|
||||
|
||||
func getList(t *testing.T, svc *service, rawQuery string) *httptest.ResponseRecorder {
|
||||
t.Helper()
|
||||
req := controllerRequest(&bouncer.Principal{ID: 1, IsSuperuser: true})
|
||||
req.URL.RawQuery = rawQuery
|
||||
rec := httptest.NewRecorder()
|
||||
svc.list(rec, req)
|
||||
return rec
|
||||
}
|
||||
|
||||
type listEnvelope struct {
|
||||
Data []map[string]any `json:"data"`
|
||||
Meta struct {
|
||||
Page int `json:"page"`
|
||||
PerPage int `json:"per_page"`
|
||||
Total int64 `json:"total"`
|
||||
LastPage int `json:"last_page"`
|
||||
} `json:"meta"`
|
||||
Error struct {
|
||||
Code string `json:"code"`
|
||||
Details map[string]any `json:"details"`
|
||||
} `json:"error"`
|
||||
}
|
||||
|
||||
func decodeList(t *testing.T, rec *httptest.ResponseRecorder, status int) listEnvelope {
|
||||
t.Helper()
|
||||
if rec.Code != status {
|
||||
t.Fatalf("status=%d body=%s", rec.Code, rec.Body.String())
|
||||
}
|
||||
var body listEnvelope
|
||||
if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil {
|
||||
t.Fatalf("json: %v body=%s", err, rec.Body.String())
|
||||
}
|
||||
return body
|
||||
}
|
||||
|
||||
func rowID(row map[string]any) int {
|
||||
switch n := row["id"].(type) {
|
||||
case float64:
|
||||
return int(n)
|
||||
case int:
|
||||
return n
|
||||
case uint:
|
||||
return int(n)
|
||||
default:
|
||||
return 0
|
||||
}
|
||||
}
|
||||
|
||||
func rowIDs(rows []map[string]any) []int {
|
||||
out := make([]int, len(rows))
|
||||
for i, row := range rows {
|
||||
out[i] = rowID(row)
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
func sameIDs(got, want []int) bool {
|
||||
if len(got) != len(want) {
|
||||
return false
|
||||
}
|
||||
seen := map[int]int{}
|
||||
for _, id := range got {
|
||||
seen[id]++
|
||||
}
|
||||
for _, id := range want {
|
||||
seen[id]--
|
||||
if seen[id] < 0 {
|
||||
return false
|
||||
}
|
||||
}
|
||||
for _, n := range seen {
|
||||
if n != 0 {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
var _ pact.AdminRecordSource = queryController{}
|
||||
var _ pact.AdminPermissioned = queryController{}
|
||||
var _ pact.FilterScope = queryRow{}
|
||||
var _ pact.FilterOptions = queryRow{}
|
||||
144
modules/cabana/refresh_revocation_test.go
Normal file
144
modules/cabana/refresh_revocation_test.go
Normal file
@@ -0,0 +1,144 @@
|
||||
package cabana_test
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"testing"
|
||||
|
||||
"git.golem15.com/golem15/summercms/modules/bonfire"
|
||||
"git.golem15.com/golem15/summercms/modules/cabana"
|
||||
)
|
||||
|
||||
// TestAdminRefreshRevocation pins CR-01: POST {prefix}/api/v1/auth/refresh
|
||||
// applies the backend guard's subject checks before minting. A token issued
|
||||
// before `summer admin:reset-password` (tokens_valid_after), or held by a
|
||||
// deactivated or soft-deleted admin, cannot be refreshed over either
|
||||
// transport, and a refused cookie refresh expires summer_admin.
|
||||
func TestAdminRefreshRevocation(t *testing.T) {
|
||||
gdb := adminGorm(t)
|
||||
|
||||
cookieLogin := func(t *testing.T, h http.Handler, login string) *http.Cookie {
|
||||
t.Helper()
|
||||
rec := phase10Send(t, h, http.MethodPost, adminAPI("/auth/login"),
|
||||
map[string]string{"login": login, "password": adminTestPassword}, nil, true)
|
||||
if rec.Code != http.StatusOK {
|
||||
t.Fatalf("cookie login status=%d body=%s", rec.Code, rec.Body.String())
|
||||
}
|
||||
return phase10Cookie(t, rec, cabana.DefaultAdminPrefix)
|
||||
}
|
||||
bearerLogin := func(t *testing.T, h http.Handler, login string) string {
|
||||
t.Helper()
|
||||
rec := phase10Send(t, h, http.MethodPost, adminAPI("/auth/login"),
|
||||
map[string]string{"login": login, "password": adminTestPassword}, nil, false)
|
||||
if rec.Code != http.StatusOK {
|
||||
t.Fatalf("bearer login status=%d body=%s", rec.Code, rec.Body.String())
|
||||
}
|
||||
return accessToken(t, rec.Body.Bytes())
|
||||
}
|
||||
resetPassword := func(t *testing.T, login string) {
|
||||
t.Helper()
|
||||
reset := commandByName(t, cabana.RuntimeCommands(commandApp(t, gdb)), "admin:reset-password")
|
||||
var buf bytes.Buffer
|
||||
if err := reset.Run(context.Background(), flagInput{
|
||||
args: []string{login},
|
||||
flags: map[string]string{"password": "rrev-replacement-password"},
|
||||
}, bonfire.NewOutput(nil, &buf, &buf)); err != nil {
|
||||
t.Fatalf("admin:reset-password: %v output=%s", err, buf.String())
|
||||
}
|
||||
}
|
||||
assertRefusedWithExpiredCookie := func(t *testing.T, rec *httptest.ResponseRecorder) {
|
||||
t.Helper()
|
||||
if rec.Code != http.StatusUnauthorized || phase10ErrorCode(t, rec) != "unauthenticated" {
|
||||
t.Fatalf("refresh status=%d body=%s, want 401 unauthenticated", rec.Code, rec.Body.String())
|
||||
}
|
||||
var expired *http.Cookie
|
||||
for _, c := range rec.Result().Cookies() {
|
||||
if c.Name == cabana.AdminCookieName {
|
||||
expired = c
|
||||
}
|
||||
}
|
||||
if expired == nil || expired.Value != "" || expired.MaxAge >= 0 || expired.Path != cabana.DefaultAdminPrefix {
|
||||
t.Fatalf("refused refresh cookie = %+v, want an expiring %s with Path %s", expired, cabana.AdminCookieName, cabana.DefaultAdminPrefix)
|
||||
}
|
||||
}
|
||||
|
||||
t.Run("pre-reset cookie is refused and expired", func(t *testing.T) {
|
||||
h := adminHandler(t, gdb, nil)
|
||||
insertAdmin(t, gdb, "rrev-cookie", "rrev-cookie@example.test", adminTestPassword, true, false)
|
||||
old := cookieLogin(t, h, "rrev-cookie")
|
||||
resetPassword(t, "rrev-cookie")
|
||||
|
||||
if me := phase10Send(t, h, http.MethodGet, adminAPI("/auth/me"), nil, old, true); me.Code != http.StatusUnauthorized {
|
||||
t.Fatalf("pre-reset cookie /auth/me status=%d body=%s", me.Code, me.Body.String())
|
||||
}
|
||||
rec := phase10Send(t, h, http.MethodPost, adminAPI("/auth/refresh"), nil, old, true)
|
||||
assertRefusedWithExpiredCookie(t, rec)
|
||||
})
|
||||
|
||||
t.Run("pre-reset bearer is refused without cookies", func(t *testing.T) {
|
||||
h := adminHandler(t, gdb, nil)
|
||||
insertAdmin(t, gdb, "rrev-bearer", "rrev-bearer@example.test", adminTestPassword, true, false)
|
||||
token := bearerLogin(t, h, "rrev-bearer")
|
||||
resetPassword(t, "rrev-bearer")
|
||||
|
||||
rec := postAuth(t, h, http.MethodPost, adminAPI("/auth/refresh"), token, nil)
|
||||
if rec.Code != http.StatusUnauthorized || phase10ErrorCode(t, rec) != "unauthenticated" {
|
||||
t.Fatalf("pre-reset bearer refresh status=%d body=%s, want 401 unauthenticated", rec.Code, rec.Body.String())
|
||||
}
|
||||
if got := rec.Header().Values("Set-Cookie"); len(got) != 0 {
|
||||
t.Fatalf("bearer refresh set cookies: %q", got)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("deactivated admin is refused", func(t *testing.T) {
|
||||
h := adminHandler(t, gdb, nil)
|
||||
user := insertAdmin(t, gdb, "rrev-deactivated", "rrev-deactivated@example.test", adminTestPassword, true, false)
|
||||
old := cookieLogin(t, h, "rrev-deactivated")
|
||||
if err := gdb.Exec(`UPDATE backend_users SET is_activated = false WHERE id = ?`, user.ID).Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
rec := phase10Send(t, h, http.MethodPost, adminAPI("/auth/refresh"), nil, old, true)
|
||||
assertRefusedWithExpiredCookie(t, rec)
|
||||
})
|
||||
|
||||
t.Run("soft-deleted admin is refused", func(t *testing.T) {
|
||||
h := adminHandler(t, gdb, nil)
|
||||
user := insertAdmin(t, gdb, "rrev-deleted", "rrev-deleted@example.test", adminTestPassword, true, false)
|
||||
old := cookieLogin(t, h, "rrev-deleted")
|
||||
if err := gdb.Delete(&user).Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
rec := phase10Send(t, h, http.MethodPost, adminAPI("/auth/refresh"), nil, old, true)
|
||||
assertRefusedWithExpiredCookie(t, rec)
|
||||
})
|
||||
|
||||
t.Run("active admin still refreshes", func(t *testing.T) {
|
||||
h := adminHandler(t, gdb, nil)
|
||||
insertAdmin(t, gdb, "rrev-active", "rrev-active@example.test", adminTestPassword, true, false)
|
||||
first := cookieLogin(t, h, "rrev-active")
|
||||
rec := phase10Send(t, h, http.MethodPost, adminAPI("/auth/refresh"), nil, first, true)
|
||||
if rec.Code != http.StatusOK {
|
||||
t.Fatalf("cookie refresh status=%d body=%s", rec.Code, rec.Body.String())
|
||||
}
|
||||
second := phase10Cookie(t, rec, cabana.DefaultAdminPrefix)
|
||||
if second.Value == first.Value {
|
||||
t.Fatal("cookie refresh did not rotate the token")
|
||||
}
|
||||
phase10AssertCookieBody(t, rec, second.Value)
|
||||
if me := phase10Send(t, h, http.MethodGet, adminAPI("/auth/me"), nil, second, true); me.Code != http.StatusOK {
|
||||
t.Fatalf("rotated cookie /auth/me status=%d body=%s", me.Code, me.Body.String())
|
||||
}
|
||||
|
||||
token := bearerLogin(t, h, "rrev-active")
|
||||
bearer := postAuth(t, h, http.MethodPost, adminAPI("/auth/refresh"), token, nil)
|
||||
if bearer.Code != http.StatusOK {
|
||||
t.Fatalf("bearer refresh status=%d body=%s", bearer.Code, bearer.Body.String())
|
||||
}
|
||||
phase10AssertBearerBody(t, bearer)
|
||||
if got := bearer.Header().Values("Set-Cookie"); len(got) != 0 {
|
||||
t.Fatalf("bearer refresh set cookies: %q", got)
|
||||
}
|
||||
})
|
||||
}
|
||||
290
modules/cabana/registry.go
Normal file
290
modules/cabana/registry.go
Normal file
@@ -0,0 +1,290 @@
|
||||
package cabana
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"strings"
|
||||
|
||||
"git.golem15.com/golem15/summercms/modules/pact"
|
||||
"git.golem15.com/golem15/summercms/modules/party"
|
||||
)
|
||||
|
||||
type controllerRef struct {
|
||||
plugin party.Plugin
|
||||
ctl pact.AdminController
|
||||
}
|
||||
|
||||
func collectControllers(plugins []party.Plugin) ([]controllerRef, error) {
|
||||
var out []controllerRef
|
||||
for _, p := range plugins {
|
||||
src, ok := p.(pact.HasAdminControllers)
|
||||
if !ok || p == nil {
|
||||
continue
|
||||
}
|
||||
for _, ctl := range src.AdminControllers() {
|
||||
if ctl == nil {
|
||||
continue
|
||||
}
|
||||
id := ctl.ID()
|
||||
if id != p.ID() && !strings.HasPrefix(id, p.ID()+".") {
|
||||
return nil, fmt.Errorf("cabana: controller %s is not owned by plugin %s", id, p.ID())
|
||||
}
|
||||
out = append(out, controllerRef{plugin: p, ctl: ctl})
|
||||
}
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
// reservedVendorSegments are the first path segments under the admin prefix
|
||||
// that the SPA and API own. A controller ID maps to /{vendor}/{plugin}/..., so
|
||||
// a vendor with one of these names would collide with them.
|
||||
var reservedVendorSegments = map[string]bool{"api": true, "assets": true, "login": true, "settings": true}
|
||||
|
||||
func checkReservedSegments(items []controllerRef) error {
|
||||
for _, item := range items {
|
||||
id := item.ctl.ID()
|
||||
vendor, _, _ := strings.Cut(id, ".")
|
||||
if reservedVendorSegments[vendor] {
|
||||
return fmt.Errorf("cabana: controller %s uses the reserved admin path segment %q (reserved: api, assets, login, settings)", id, vendor)
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func compileRegistry(items []controllerRef) (*Registry, error) {
|
||||
byID := make(map[string]*CompiledController, len(items))
|
||||
for _, item := range items {
|
||||
id := item.ctl.ID()
|
||||
if _, exists := byID[id]; exists {
|
||||
return nil, fmt.Errorf("cabana: duplicate admin controller %s", id)
|
||||
}
|
||||
assets, ok := item.plugin.(pact.AdminAssets)
|
||||
if !ok || assets == nil || assets.AdminFS() == nil {
|
||||
return nil, fmt.Errorf("cabana: plugin %s has admin controllers but no AdminFS", item.plugin.ID())
|
||||
}
|
||||
list, err := compileList(item.plugin.ID(), item.ctl, assets.AdminFS())
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
form, err := compileFormIfPresent(item.plugin.ID(), item.ctl, assets.AdminFS())
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
relations, err := compileRelations(item.plugin.ID(), item.ctl, assets.AdminFS(), form)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
fieldRelations, err := compileFieldRelations(item.plugin.ID(), item.ctl, form)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if form == nil && list != nil {
|
||||
// Without a compiled form there is nothing to create (D-14).
|
||||
list.ToolbarButtons = withoutAction(list.ToolbarButtons, "create")
|
||||
}
|
||||
compiled := &CompiledController{
|
||||
PluginID: item.plugin.ID(),
|
||||
Controller: item.ctl,
|
||||
List: list,
|
||||
Form: form,
|
||||
Relations: relations,
|
||||
FieldRelations: fieldRelations,
|
||||
}
|
||||
if err := BindWritableFields(compiled); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
byID[id] = compiled
|
||||
}
|
||||
return &Registry{byID: byID}, nil
|
||||
}
|
||||
|
||||
func withoutAction(actions []string, drop string) []string {
|
||||
out := make([]string, 0, len(actions))
|
||||
for _, action := range actions {
|
||||
if action != drop {
|
||||
out = append(out, action)
|
||||
}
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
func compileContributions(reg *Registry, plugins []party.Plugin) error {
|
||||
if reg == nil {
|
||||
return fmt.Errorf("cabana: registry is nil")
|
||||
}
|
||||
reg.permissions = map[string]pact.Permission{}
|
||||
reg.roleGrants = map[string]map[string]bool{}
|
||||
reg.settings = map[string]*CompiledSetting{}
|
||||
seenNavigation := map[string]struct{}{}
|
||||
|
||||
for _, plugin := range plugins {
|
||||
if plugin == nil {
|
||||
continue
|
||||
}
|
||||
if src, ok := plugin.(pact.HasPermissions); ok && src != nil {
|
||||
for _, permission := range src.Permissions() {
|
||||
if !permissionCode(permission.Code, false) {
|
||||
return fmt.Errorf("cabana: plugin %s registered invalid permission %q", plugin.ID(), permission.Code)
|
||||
}
|
||||
if _, exists := reg.permissions[permission.Code]; exists {
|
||||
return fmt.Errorf("cabana: duplicate permission %s", permission.Code)
|
||||
}
|
||||
reg.permissions[permission.Code] = permission
|
||||
for _, role := range permission.Roles {
|
||||
role = strings.TrimSpace(role)
|
||||
if role == "" {
|
||||
return fmt.Errorf("cabana: permission %s has an empty role", permission.Code)
|
||||
}
|
||||
if reg.roleGrants[role] == nil {
|
||||
reg.roleGrants[role] = map[string]bool{}
|
||||
}
|
||||
reg.roleGrants[role][permission.Code] = true
|
||||
}
|
||||
}
|
||||
}
|
||||
if src, ok := plugin.(pact.HasSettings); ok && src != nil {
|
||||
assets, hasAssets := plugin.(pact.AdminAssets)
|
||||
for _, item := range src.Settings() {
|
||||
if !identifier(item.Code) {
|
||||
return fmt.Errorf("cabana: plugin %s registered invalid setting %q", plugin.ID(), item.Code)
|
||||
}
|
||||
if _, exists := reg.settings[item.Code]; exists {
|
||||
return fmt.Errorf("cabana: duplicate setting %s", item.Code)
|
||||
}
|
||||
if !hasAssets || assets == nil || assets.AdminFS() == nil {
|
||||
return fmt.Errorf("cabana: plugin %s has settings but no AdminFS", plugin.ID())
|
||||
}
|
||||
compiled, err := compileSetting(plugin.ID(), item, assets.AdminFS())
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
reg.settings[item.Code] = compiled
|
||||
}
|
||||
}
|
||||
if src, ok := plugin.(pact.HasNavigation); ok && src != nil {
|
||||
for _, item := range src.Navigation() {
|
||||
if err := validateNavigationShape(plugin.ID(), item, seenNavigation); err != nil {
|
||||
return err
|
||||
}
|
||||
reg.navigation = append(reg.navigation, item)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for id, controller := range reg.byID {
|
||||
if err := reg.validatePermissions("controller "+id, requiredOf(controller.Controller)); err != nil {
|
||||
return err
|
||||
}
|
||||
for name, relation := range controller.Relations {
|
||||
if err := reg.validatePermissions("relation "+id+"."+name, relation.RequiredPermissions); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
}
|
||||
for _, item := range reg.navigation {
|
||||
if err := reg.validateNavigation(item); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
for code, setting := range reg.settings {
|
||||
if err := reg.validatePermissions("setting "+code, setting.Item.Permissions); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func permissionCode(code string, wildcard bool) bool {
|
||||
parts := strings.Split(code, ".")
|
||||
if len(parts) < 2 {
|
||||
return false
|
||||
}
|
||||
for i, part := range parts {
|
||||
if wildcard && i == len(parts)-1 && part == "*" {
|
||||
return true
|
||||
}
|
||||
if !identifier(part) {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
func (r *Registry) validatePermissions(owner string, permissions []string) error {
|
||||
for _, code := range permissions {
|
||||
if !permissionCode(code, true) || !r.permissionExists(code) {
|
||||
return fmt.Errorf("cabana: %s references unknown permission %s", owner, code)
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (r *Registry) permissionExists(code string) bool {
|
||||
if r == nil {
|
||||
return false
|
||||
}
|
||||
if _, ok := r.permissions[code]; ok {
|
||||
return true
|
||||
}
|
||||
if !strings.HasSuffix(code, ".*") {
|
||||
return false
|
||||
}
|
||||
prefix := strings.TrimSuffix(code, "*")
|
||||
for candidate := range r.permissions {
|
||||
if strings.HasPrefix(candidate, prefix) {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func validateNavigationShape(pluginID string, item pact.NavigationItem, seen map[string]struct{}) error {
|
||||
if !identifier(item.Code) {
|
||||
return fmt.Errorf("cabana: plugin %s registered invalid navigation code %q", pluginID, item.Code)
|
||||
}
|
||||
if _, exists := seen[item.Code]; exists {
|
||||
return fmt.Errorf("cabana: duplicate navigation code %s", item.Code)
|
||||
}
|
||||
seen[item.Code] = struct{}{}
|
||||
childSeen := map[string]struct{}{}
|
||||
for _, child := range item.SideMenu {
|
||||
if !identifier(child.Code) {
|
||||
return fmt.Errorf("cabana: navigation %s has invalid child code %q", item.Code, child.Code)
|
||||
}
|
||||
if _, exists := childSeen[child.Code]; exists {
|
||||
return fmt.Errorf("cabana: navigation %s has duplicate child %s", item.Code, child.Code)
|
||||
}
|
||||
childSeen[child.Code] = struct{}{}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (r *Registry) validateNavigation(item pact.NavigationItem) error {
|
||||
if _, ok := r.byID[item.Controller]; !ok {
|
||||
return fmt.Errorf("cabana: navigation %s references unknown controller %s", item.Code, item.Controller)
|
||||
}
|
||||
if err := r.validatePermissions("navigation "+item.Code, item.Permissions); err != nil {
|
||||
return err
|
||||
}
|
||||
for _, child := range item.SideMenu {
|
||||
if _, ok := r.byID[child.Controller]; !ok {
|
||||
return fmt.Errorf("cabana: navigation %s.%s references unknown controller %s", item.Code, child.Code, child.Controller)
|
||||
}
|
||||
if err := r.validatePermissions("navigation "+item.Code+"."+child.Code, child.Permissions); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (r *Registry) rolePermissions(role string) map[string]bool {
|
||||
out := map[string]bool{}
|
||||
if r == nil {
|
||||
return out
|
||||
}
|
||||
for code, allowed := range r.roleGrants[role] {
|
||||
if allowed {
|
||||
out[code] = true
|
||||
}
|
||||
}
|
||||
return out
|
||||
}
|
||||
843
modules/cabana/relation.go
Normal file
843
modules/cabana/relation.go
Normal file
@@ -0,0 +1,843 @@
|
||||
package cabana
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"io/fs"
|
||||
"reflect"
|
||||
"sort"
|
||||
"strings"
|
||||
|
||||
"git.golem15.com/golem15/summercms/modules/pact"
|
||||
"git.golem15.com/golem15/summercms/modules/phrasebook"
|
||||
"github.com/goccy/go-yaml"
|
||||
"gorm.io/gorm"
|
||||
"gorm.io/gorm/clause"
|
||||
)
|
||||
|
||||
// AdminRelationContractProvider declares model-owned relation metadata.
|
||||
// Framework code never guesses a plugin pivot table or foreign key.
|
||||
type AdminRelationContractProvider interface {
|
||||
AdminRelationContracts() []RelationContract
|
||||
}
|
||||
|
||||
// RelationContract binds one compiled relation schema to target and pivot models.
|
||||
type RelationContract struct {
|
||||
Name string
|
||||
NewRelated func() any
|
||||
NewPivot func() any
|
||||
ParentForeignKey string
|
||||
RelatedForeignKey string
|
||||
Columns map[string]string
|
||||
HookPivotColumns []string
|
||||
ExcludedRelatedIDs func(parent any) ([]uint, error)
|
||||
}
|
||||
|
||||
// RelationColumn is one source-ordered relation list column.
|
||||
type RelationColumn struct {
|
||||
Key string `json:"key"`
|
||||
Label string `json:"label"`
|
||||
Searchable bool `json:"searchable"`
|
||||
Sortable bool `json:"sortable"`
|
||||
}
|
||||
|
||||
// RelationList is one view/manage list declaration.
|
||||
type RelationList struct {
|
||||
Columns []RelationColumn `json:"columns"`
|
||||
}
|
||||
|
||||
// RelationPanel is one side of a relation manager.
|
||||
type RelationPanel struct {
|
||||
List RelationList `json:"list"`
|
||||
ToolbarButtons []string `json:"toolbarButtons"`
|
||||
ShowSearch bool `json:"showSearch"`
|
||||
}
|
||||
|
||||
// RelationSchema is the cached locale-neutral relation contract.
|
||||
type RelationSchema struct {
|
||||
Name string `json:"name"`
|
||||
Label string `json:"label"`
|
||||
View RelationPanel `json:"view"`
|
||||
Manage RelationPanel `json:"manage"`
|
||||
// Messages is the relation manager's copy (D-13); the cached schema
|
||||
// carries each phrase key as its own form.
|
||||
Messages *RelationMessages `json:"messages"`
|
||||
|
||||
messageKeys relationMessageKeys
|
||||
}
|
||||
|
||||
// CompiledRelation combines trusted YAML with model-owned metadata.
|
||||
type CompiledRelation struct {
|
||||
Schema *RelationSchema
|
||||
Contract RelationContract
|
||||
RequiredPermissions []string
|
||||
}
|
||||
|
||||
// RelationQuery is the finite linked/candidate query contract.
|
||||
type RelationQuery struct {
|
||||
Search string
|
||||
Sort string
|
||||
Dir string
|
||||
Page string
|
||||
PerPage string
|
||||
}
|
||||
|
||||
// RelationResult is a stable allocated page.
|
||||
type RelationResult struct {
|
||||
Data []map[string]any
|
||||
Meta ListMeta
|
||||
}
|
||||
|
||||
// RelationMutationInput is the only accepted relation write payload.
|
||||
type RelationMutationInput struct {
|
||||
IDs []any `json:"ids"`
|
||||
}
|
||||
|
||||
// RelationMutationResult reports inserted/deleted pivot rows.
|
||||
type RelationMutationResult struct {
|
||||
Linked int `json:"linked,omitempty"`
|
||||
Removed int `json:"removed,omitempty"`
|
||||
}
|
||||
|
||||
// RelationService executes compiled relation reads and writes.
|
||||
type RelationService struct{ DB *gorm.DB }
|
||||
|
||||
func (s RelationSchema) MarshalJSON() ([]byte, error) {
|
||||
if s.Messages == nil {
|
||||
keys := localizeMessages[relationMessageKeys, RelationMessages](context.Background(), nil, s.relationMessageKeySet())
|
||||
s.Messages = &keys
|
||||
}
|
||||
type alias RelationSchema
|
||||
out := alias(s)
|
||||
ensureRelationArrays(&out.View)
|
||||
ensureRelationArrays(&out.Manage)
|
||||
return json.Marshal(out)
|
||||
}
|
||||
|
||||
func ensureRelationArrays(p *RelationPanel) {
|
||||
if p.List.Columns == nil {
|
||||
p.List.Columns = []RelationColumn{}
|
||||
}
|
||||
if p.ToolbarButtons == nil {
|
||||
p.ToolbarButtons = []string{}
|
||||
}
|
||||
}
|
||||
|
||||
// Localize returns a request-local copy without mutating the cached keys.
|
||||
func (s *RelationSchema) Localize(ctx context.Context, tr *phrasebook.Translator) *RelationSchema {
|
||||
if s == nil {
|
||||
return nil
|
||||
}
|
||||
out := *s
|
||||
out.Label = translateKey(ctx, tr, s.Label)
|
||||
out.View = localizeRelationPanel(ctx, tr, s.View)
|
||||
out.Manage = localizeRelationPanel(ctx, tr, s.Manage)
|
||||
messages := localizeMessages[relationMessageKeys, RelationMessages](ctx, tr, s.relationMessageKeySet())
|
||||
out.Messages = &messages
|
||||
return &out
|
||||
}
|
||||
|
||||
func localizeRelationPanel(ctx context.Context, tr *phrasebook.Translator, src RelationPanel) RelationPanel {
|
||||
out := src
|
||||
out.List.Columns = append([]RelationColumn(nil), src.List.Columns...)
|
||||
for i := range out.List.Columns {
|
||||
out.List.Columns[i].Label = translateKey(ctx, tr, out.List.Columns[i].Label)
|
||||
}
|
||||
out.ToolbarButtons = append([]string(nil), src.ToolbarButtons...)
|
||||
ensureRelationArrays(&out)
|
||||
return out
|
||||
}
|
||||
|
||||
type relationRoot struct {
|
||||
Relations yaml.MapSlice `yaml:",inline"`
|
||||
}
|
||||
|
||||
type relationDocument struct {
|
||||
Label string `yaml:"label"`
|
||||
View relationPanelDocument `yaml:"view"`
|
||||
Manage relationPanelDocument `yaml:"manage"`
|
||||
Messages *relationMessageKeys `yaml:"messages"`
|
||||
}
|
||||
|
||||
type relationPanelDocument struct {
|
||||
List struct {
|
||||
Columns yaml.MapSlice `yaml:"columns"`
|
||||
} `yaml:"list"`
|
||||
ToolbarButtons string `yaml:"toolbarButtons"`
|
||||
ShowSearch bool `yaml:"showSearch"`
|
||||
}
|
||||
|
||||
type relationColumnDocument struct {
|
||||
Label string `yaml:"label"`
|
||||
Searchable *bool `yaml:"searchable"`
|
||||
Sortable *bool `yaml:"sortable"`
|
||||
}
|
||||
|
||||
func compileRelations(pluginID string, ctl pact.AdminController, fsys fs.FS, form *FormSchema) (map[string]*CompiledRelation, error) {
|
||||
fields := map[string]FormField{}
|
||||
if form != nil {
|
||||
for _, field := range form.Fields {
|
||||
if field.Type == "relation-manager" {
|
||||
fields[field.Relation] = field
|
||||
}
|
||||
}
|
||||
}
|
||||
if len(fields) == 0 {
|
||||
return map[string]*CompiledRelation{}, nil
|
||||
}
|
||||
provider, ok := ctl.(AdminRelationContractProvider)
|
||||
if !ok || provider == nil {
|
||||
return nil, bootErr(pluginID, ctl.ID(), "config_relation.yaml", errors.New("relation-manager requires AdminRelationContracts"))
|
||||
}
|
||||
contracts := map[string]RelationContract{}
|
||||
for _, contract := range provider.AdminRelationContracts() {
|
||||
if !identifier(contract.Name) {
|
||||
return nil, bootErr(pluginID, ctl.ID(), "config_relation.yaml", fmt.Errorf("relation contract name %q is not an identifier", contract.Name))
|
||||
}
|
||||
if _, dup := contracts[contract.Name]; dup {
|
||||
return nil, bootErr(pluginID, ctl.ID(), "config_relation.yaml", fmt.Errorf("duplicate relation contract %s", contract.Name))
|
||||
}
|
||||
if err := validateRelationContract(ctl, contract); err != nil {
|
||||
return nil, bootErr(pluginID, ctl.ID(), "config_relation.yaml", err)
|
||||
}
|
||||
contracts[contract.Name] = contract
|
||||
}
|
||||
dir := strings.Trim(strings.TrimSpace(ctl.ConfigDir()), "/")
|
||||
file := dir + "/config_relation.yaml"
|
||||
raw, err := readAsset(fsys, file)
|
||||
if err != nil {
|
||||
return nil, bootErr(pluginID, ctl.ID(), file, err)
|
||||
}
|
||||
var root yaml.MapSlice
|
||||
if err := decodeStrict(raw, &root); err != nil {
|
||||
return nil, bootErr(pluginID, ctl.ID(), file, err)
|
||||
}
|
||||
out := map[string]*CompiledRelation{}
|
||||
for _, item := range root {
|
||||
name, ok := item.Key.(string)
|
||||
if !ok || !identifier(name) {
|
||||
return nil, bootErr(pluginID, ctl.ID(), file, fmt.Errorf("relation name %v is not an identifier", item.Key))
|
||||
}
|
||||
if _, dup := out[name]; dup {
|
||||
return nil, bootErr(pluginID, ctl.ID(), file, fmt.Errorf("duplicate relation %s", name))
|
||||
}
|
||||
if _, declared := fields[name]; !declared {
|
||||
return nil, bootErr(pluginID, ctl.ID(), file, fmt.Errorf("relation %s has no relation-manager field", name))
|
||||
}
|
||||
contract, declared := contracts[name]
|
||||
if !declared {
|
||||
return nil, bootErr(pluginID, ctl.ID(), file, fmt.Errorf("relation %s has no model contract", name))
|
||||
}
|
||||
encoded, err := yaml.Marshal(item.Value)
|
||||
if err != nil {
|
||||
return nil, bootErr(pluginID, ctl.ID(), file, err)
|
||||
}
|
||||
var doc relationDocument
|
||||
if err := decodeStrict(encoded, &doc); err != nil {
|
||||
return nil, bootErr(pluginID, ctl.ID(), file, fmt.Errorf("relation %s: %w", name, err))
|
||||
}
|
||||
view, err := compileRelationPanel(doc.View, contract, true)
|
||||
if err != nil {
|
||||
return nil, bootErr(pluginID, ctl.ID(), file, fmt.Errorf("relation %s view: %w", name, err))
|
||||
}
|
||||
manage, err := compileRelationPanel(doc.Manage, contract, false)
|
||||
if err != nil {
|
||||
return nil, bootErr(pluginID, ctl.ID(), file, fmt.Errorf("relation %s manage: %w", name, err))
|
||||
}
|
||||
orderRelationColumns(raw, &view)
|
||||
orderRelationColumns(raw, &manage)
|
||||
schema := &RelationSchema{Name: name, Label: doc.Label, View: view, Manage: manage}
|
||||
if doc.Messages != nil {
|
||||
schema.messageKeys = *doc.Messages
|
||||
}
|
||||
keys := localizeMessages[relationMessageKeys, RelationMessages](context.Background(), nil, schema.relationMessageKeySet())
|
||||
schema.Messages = &keys
|
||||
out[name] = &CompiledRelation{
|
||||
Schema: schema,
|
||||
Contract: contract,
|
||||
RequiredPermissions: append([]string(nil), requiredOf(ctl)...),
|
||||
}
|
||||
}
|
||||
for name := range fields {
|
||||
if out[name] == nil {
|
||||
return nil, bootErr(pluginID, ctl.ID(), file, fmt.Errorf("relation %s is missing", name))
|
||||
}
|
||||
}
|
||||
for name := range contracts {
|
||||
if out[name] == nil {
|
||||
return nil, bootErr(pluginID, ctl.ID(), file, fmt.Errorf("relation contract %s is orphaned", name))
|
||||
}
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
func orderRelationColumns(raw []byte, panel *RelationPanel) {
|
||||
if panel == nil || len(panel.List.Columns) < 2 {
|
||||
return
|
||||
}
|
||||
source := string(raw)
|
||||
sort.SliceStable(panel.List.Columns, func(i, j int) bool {
|
||||
left := strings.Index(source, "\n "+panel.List.Columns[i].Key+":")
|
||||
right := strings.Index(source, "\n "+panel.List.Columns[j].Key+":")
|
||||
if left < 0 {
|
||||
left = len(source)
|
||||
}
|
||||
if right < 0 {
|
||||
right = len(source)
|
||||
}
|
||||
return left < right
|
||||
})
|
||||
}
|
||||
|
||||
func compileRelationPanel(doc relationPanelDocument, contract RelationContract, view bool) (RelationPanel, error) {
|
||||
cols := make([]RelationColumn, 0, len(doc.List.Columns))
|
||||
seen := map[string]struct{}{}
|
||||
for _, item := range doc.List.Columns {
|
||||
key, ok := item.Key.(string)
|
||||
if !ok || !identifier(key) {
|
||||
return RelationPanel{}, fmt.Errorf("column %v is not an identifier", item.Key)
|
||||
}
|
||||
if _, dup := seen[key]; dup {
|
||||
return RelationPanel{}, fmt.Errorf("duplicate column %s", key)
|
||||
}
|
||||
seen[key] = struct{}{}
|
||||
if _, ok := contract.Columns[key]; !ok {
|
||||
return RelationPanel{}, fmt.Errorf("column %s is not in the model contract", key)
|
||||
}
|
||||
encoded, err := yaml.Marshal(item.Value)
|
||||
if err != nil {
|
||||
return RelationPanel{}, err
|
||||
}
|
||||
var spec relationColumnDocument
|
||||
if err := decodeStrict(encoded, &spec); err != nil {
|
||||
return RelationPanel{}, fmt.Errorf("column %s: %w", key, err)
|
||||
}
|
||||
searchable := doc.ShowSearch
|
||||
if spec.Searchable != nil {
|
||||
searchable = *spec.Searchable
|
||||
}
|
||||
sortable := true
|
||||
if spec.Sortable != nil {
|
||||
sortable = *spec.Sortable
|
||||
}
|
||||
cols = append(cols, RelationColumn{Key: key, Label: spec.Label, Searchable: searchable, Sortable: sortable})
|
||||
}
|
||||
buttons, err := compileRelationButtons(doc.ToolbarButtons, view)
|
||||
if err != nil {
|
||||
return RelationPanel{}, err
|
||||
}
|
||||
return RelationPanel{List: RelationList{Columns: cols}, ToolbarButtons: buttons, ShowSearch: doc.ShowSearch}, nil
|
||||
}
|
||||
|
||||
func compileRelationButtons(raw string, view bool) ([]string, error) {
|
||||
if strings.TrimSpace(raw) == "" {
|
||||
return []string{}, nil
|
||||
}
|
||||
parts := strings.Split(raw, "|")
|
||||
out := make([]string, 0, len(parts))
|
||||
seen := map[string]struct{}{}
|
||||
for _, part := range parts {
|
||||
part = strings.TrimSpace(part)
|
||||
if part != "link" && part != "unlink" {
|
||||
return nil, fmt.Errorf("unsupported relation action %s", part)
|
||||
}
|
||||
if !view && part == "unlink" {
|
||||
return nil, fmt.Errorf("manage panel cannot declare unlink")
|
||||
}
|
||||
if _, dup := seen[part]; dup {
|
||||
return nil, fmt.Errorf("duplicate relation action %s", part)
|
||||
}
|
||||
seen[part] = struct{}{}
|
||||
out = append(out, part)
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
func validateRelationContract(ctl pact.AdminController, contract RelationContract) error {
|
||||
if contract.NewRelated == nil || contract.NewRelated() == nil || contract.NewPivot == nil || contract.NewPivot() == nil {
|
||||
return fmt.Errorf("relation %s requires target and pivot models", contract.Name)
|
||||
}
|
||||
if !identifier(contract.ParentForeignKey) || !identifier(contract.RelatedForeignKey) {
|
||||
return fmt.Errorf("relation %s has invalid pivot foreign keys", contract.Name)
|
||||
}
|
||||
pivotCols := modelColumns(contract.NewPivot())
|
||||
if _, ok := pivotCols[contract.ParentForeignKey]; !ok {
|
||||
return fmt.Errorf("relation %s pivot is missing %s", contract.Name, contract.ParentForeignKey)
|
||||
}
|
||||
if _, ok := pivotCols[contract.RelatedForeignKey]; !ok {
|
||||
return fmt.Errorf("relation %s pivot is missing %s", contract.Name, contract.RelatedForeignKey)
|
||||
}
|
||||
targetCols := modelColumns(contract.NewRelated())
|
||||
for logical, physical := range contract.Columns {
|
||||
if !identifier(logical) || !identifier(physical) {
|
||||
return fmt.Errorf("relation %s has invalid column mapping", contract.Name)
|
||||
}
|
||||
if _, ok := targetCols[physical]; !ok {
|
||||
return fmt.Errorf("relation %s target is missing column %s", contract.Name, physical)
|
||||
}
|
||||
}
|
||||
for _, col := range contract.HookPivotColumns {
|
||||
if !identifier(col) {
|
||||
return fmt.Errorf("relation %s has invalid hook column %s", contract.Name, col)
|
||||
}
|
||||
if _, ok := pivotCols[col]; !ok || protectedPivotColumn(col, contract) {
|
||||
return fmt.Errorf("relation %s has invalid hook column %s", contract.Name, col)
|
||||
}
|
||||
}
|
||||
src, ok := ctl.(pact.AdminRecordSource)
|
||||
if !ok || src == nil || src.NewRecord() == nil {
|
||||
return fmt.Errorf("relation %s owner has no record source", contract.Name)
|
||||
}
|
||||
fieldName, ok := relationFieldName(src.NewRecord(), contract.Name)
|
||||
if !ok {
|
||||
return fmt.Errorf("relation %s is not on the owner model", contract.Name)
|
||||
}
|
||||
ownerType := reflect.TypeOf(src.NewRecord())
|
||||
for ownerType.Kind() == reflect.Pointer {
|
||||
ownerType = ownerType.Elem()
|
||||
}
|
||||
field, _ := ownerType.FieldByName(fieldName)
|
||||
targetType := reflect.TypeOf(contract.NewRelated())
|
||||
for targetType.Kind() == reflect.Pointer {
|
||||
targetType = targetType.Elem()
|
||||
}
|
||||
fieldType := field.Type
|
||||
for fieldType.Kind() == reflect.Pointer || fieldType.Kind() == reflect.Slice {
|
||||
fieldType = fieldType.Elem()
|
||||
}
|
||||
if fieldType != targetType {
|
||||
return fmt.Errorf("relation %s target model does not match owner field", contract.Name)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func protectedPivotColumn(col string, contract RelationContract) bool {
|
||||
switch col {
|
||||
case contract.ParentForeignKey, contract.RelatedForeignKey, "id", "created_at", "updated_at", "deleted_at":
|
||||
return true
|
||||
default:
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
// Linked returns the current relation rows.
|
||||
func (s RelationService) Linked(ctx context.Context, cc *CompiledController, relation string, ownerID uint, in RelationQuery) (*RelationResult, error) {
|
||||
return s.query(ctx, cc, relation, ownerID, in, false)
|
||||
}
|
||||
|
||||
// Candidates returns target rows eligible for linking.
|
||||
func (s RelationService) Candidates(ctx context.Context, cc *CompiledController, relation string, ownerID uint, in RelationQuery) (*RelationResult, error) {
|
||||
return s.query(ctx, cc, relation, ownerID, in, true)
|
||||
}
|
||||
|
||||
func (s RelationService) query(ctx context.Context, cc *CompiledController, relation string, ownerID uint, in RelationQuery, candidates bool) (*RelationResult, error) {
|
||||
if s.DB == nil {
|
||||
return nil, errors.New("cabana: database is not configured")
|
||||
}
|
||||
cr, err := relationOf(cc, relation)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
page, per, sortKey, desc, err := normalizeRelationQuery(cr.Schema, candidates, in)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
var result *RelationResult
|
||||
err = s.DB.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
|
||||
parent, err := newWritableModel(cc)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if err := loadRecord(ctx, tx, cc, parent, ownerID); err != nil {
|
||||
return err
|
||||
}
|
||||
q, target, err := relationBaseQuery(ctx, tx, cc, cr, parent, candidates)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
panel := cr.Schema.View
|
||||
if candidates {
|
||||
panel = cr.Schema.Manage
|
||||
}
|
||||
q = applyRelationSearch(q, cr, panel.List.Columns, in.Search)
|
||||
var total int64
|
||||
if err := q.Session(&gorm.Session{}).Count(&total).Error; err != nil {
|
||||
return err
|
||||
}
|
||||
q = applyRelationOrder(q, cr, target, panel.List.Columns, sortKey, desc)
|
||||
rows := make([]map[string]any, 0)
|
||||
selects := relationSelects(tx, cr, target, panel.List.Columns)
|
||||
if err := q.Select(strings.Join(selects, ", ")).Offset((page - 1) * per).Limit(per).Scan(&rows).Error; err != nil {
|
||||
return err
|
||||
}
|
||||
last := 0
|
||||
if total > 0 {
|
||||
last = int((total + int64(per) - 1) / int64(per))
|
||||
}
|
||||
result = &RelationResult{Data: rows, Meta: ListMeta{Page: page, PerPage: per, Total: total, LastPage: last}}
|
||||
return nil
|
||||
})
|
||||
return result, err
|
||||
}
|
||||
|
||||
func relationBaseQuery(ctx context.Context, tx *gorm.DB, cc *CompiledController, cr *CompiledRelation, parent any, candidates bool) (*gorm.DB, any, error) {
|
||||
target := cr.Contract.NewRelated()
|
||||
targetTable := tableName(target)
|
||||
pivotTable := tableName(cr.Contract.NewPivot())
|
||||
pk := primaryColumn(target)
|
||||
ownerPK := pkUint(parent)
|
||||
q := tx.WithContext(ctx).Model(target)
|
||||
if candidates {
|
||||
if ext, ok := cc.Controller.(pact.RelationExtendManageQuery); ok && ext != nil {
|
||||
if next := ext.RelationExtendManageQuery(ctx, cr.Contract.Name, q); next != nil {
|
||||
q = next
|
||||
}
|
||||
}
|
||||
if cr.Contract.ExcludedRelatedIDs != nil {
|
||||
excluded, err := cr.Contract.ExcludedRelatedIDs(parent)
|
||||
if err != nil {
|
||||
return nil, nil, lifecycleFailure(cc, err)
|
||||
}
|
||||
if len(excluded) > 0 {
|
||||
q = q.Where(clause.Not(clause.IN{Column: clause.Column{Table: targetTable, Name: pk}, Values: uintValues(excluded)}))
|
||||
}
|
||||
}
|
||||
notExists := "NOT EXISTS (SELECT 1 FROM " + quotedIdent(tx, pivotTable) + " p WHERE p." + quotedIdent(tx, cr.Contract.ParentForeignKey) + " = ? AND p." + quotedIdent(tx, cr.Contract.RelatedForeignKey) + " = " + quotedIdent(tx, targetTable) + "." + quotedIdent(tx, pk) + ")"
|
||||
q = q.Where(notExists, ownerPK)
|
||||
} else {
|
||||
join := "JOIN " + quotedIdent(tx, pivotTable) + " p ON p." + quotedIdent(tx, cr.Contract.RelatedForeignKey) + " = " + quotedIdent(tx, targetTable) + "." + quotedIdent(tx, pk)
|
||||
q = q.Joins(join).Where("p."+quotedIdent(tx, cr.Contract.ParentForeignKey)+" = ?", ownerPK)
|
||||
}
|
||||
return q, target, nil
|
||||
}
|
||||
|
||||
// normalizeRelationPage applies the Phase 9 relation paging limits: page is
|
||||
// a positive integer (default 1), per_page is 1..100 (default 20).
|
||||
func normalizeRelationPage(rawPage, rawPerPage string) (int, int, error) {
|
||||
page, per := 1, 20
|
||||
var err error
|
||||
if rawPage != "" {
|
||||
page, err = parsePositive(rawPage)
|
||||
if err != nil {
|
||||
return 0, 0, relationInvalid("page", "must be a positive integer")
|
||||
}
|
||||
}
|
||||
if rawPerPage != "" {
|
||||
per, err = parsePositive(rawPerPage)
|
||||
if err != nil || per > 100 {
|
||||
return 0, 0, relationInvalid("per_page", "must be between 1 and 100")
|
||||
}
|
||||
}
|
||||
return page, per, nil
|
||||
}
|
||||
|
||||
func normalizeRelationQuery(schema *RelationSchema, candidates bool, in RelationQuery) (int, int, string, bool, error) {
|
||||
page, per, err := normalizeRelationPage(in.Page, in.PerPage)
|
||||
if err != nil {
|
||||
return 0, 0, "", false, err
|
||||
}
|
||||
panel := schema.View
|
||||
if candidates {
|
||||
panel = schema.Manage
|
||||
}
|
||||
sortKey := in.Sort
|
||||
if sortKey == "" && len(panel.List.Columns) > 0 {
|
||||
sortKey = panel.List.Columns[0].Key
|
||||
}
|
||||
if sortKey != "" {
|
||||
valid := false
|
||||
for _, col := range panel.List.Columns {
|
||||
if col.Key == sortKey && col.Sortable {
|
||||
valid = true
|
||||
break
|
||||
}
|
||||
}
|
||||
if !valid {
|
||||
return 0, 0, "", false, relationInvalid("sort", "is not a sortable column")
|
||||
}
|
||||
}
|
||||
dir := in.Dir
|
||||
if dir == "" {
|
||||
dir = "asc"
|
||||
}
|
||||
if dir != "asc" && dir != "desc" {
|
||||
return 0, 0, "", false, relationInvalid("dir", "must be asc or desc")
|
||||
}
|
||||
return page, per, sortKey, dir == "desc", nil
|
||||
}
|
||||
|
||||
func parsePositive(raw string) (int, error) {
|
||||
n := 0
|
||||
for _, r := range raw {
|
||||
if r < '0' || r > '9' {
|
||||
return 0, errors.New("not positive")
|
||||
}
|
||||
n = n*10 + int(r-'0')
|
||||
}
|
||||
if n < 1 {
|
||||
return 0, errors.New("not positive")
|
||||
}
|
||||
return n, nil
|
||||
}
|
||||
|
||||
func relationInvalid(field, message string) *ValidationError {
|
||||
return &ValidationError{Details: map[string]any{field: []string{message}}}
|
||||
}
|
||||
|
||||
func applyRelationSearch(q *gorm.DB, cr *CompiledRelation, cols []RelationColumn, term string) *gorm.DB {
|
||||
term = strings.TrimSpace(term)
|
||||
if term == "" {
|
||||
return q
|
||||
}
|
||||
targetTable := tableName(cr.Contract.NewRelated())
|
||||
parts := make([]string, 0)
|
||||
args := make([]any, 0)
|
||||
seen := map[string]struct{}{}
|
||||
for _, col := range cols {
|
||||
physical := cr.Contract.Columns[col.Key]
|
||||
if !col.Searchable || physical == "" {
|
||||
continue
|
||||
}
|
||||
if _, dup := seen[physical]; dup {
|
||||
continue
|
||||
}
|
||||
seen[physical] = struct{}{}
|
||||
parts = append(parts, quotedIdent(q, targetTable)+"."+quotedIdent(q, physical)+" ILIKE ?")
|
||||
args = append(args, "%"+term+"%")
|
||||
}
|
||||
if len(parts) == 0 {
|
||||
return q
|
||||
}
|
||||
return q.Where("("+strings.Join(parts, " OR ")+")", args...)
|
||||
}
|
||||
|
||||
func applyRelationOrder(q *gorm.DB, cr *CompiledRelation, target any, cols []RelationColumn, sortKey string, desc bool) *gorm.DB {
|
||||
table := tableName(target)
|
||||
pk := primaryColumn(target)
|
||||
if sortKey != "" {
|
||||
q = q.Order(clause.OrderByColumn{Column: clause.Column{Table: table, Name: cr.Contract.Columns[sortKey]}, Desc: desc})
|
||||
}
|
||||
if cr.Contract.Columns[sortKey] != pk {
|
||||
q = q.Order(clause.OrderByColumn{Column: clause.Column{Table: table, Name: pk}})
|
||||
}
|
||||
return q
|
||||
}
|
||||
|
||||
func relationSelects(db *gorm.DB, cr *CompiledRelation, target any, cols []RelationColumn) []string {
|
||||
table := tableName(target)
|
||||
out := []string{quotedIdent(db, table) + "." + quotedIdent(db, primaryColumn(target)) + " AS " + quotedIdent(db, "id")}
|
||||
for _, col := range cols {
|
||||
out = append(out, quotedIdent(db, table)+"."+quotedIdent(db, cr.Contract.Columns[col.Key])+" AS "+quotedIdent(db, col.Key))
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
// Link inserts only currently eligible targets and never restamps existing rows.
|
||||
func (s RelationService) Link(ctx context.Context, cc *CompiledController, relation string, ownerID uint, in RelationMutationInput) (RelationMutationResult, error) {
|
||||
ids, err := normalizeIDs(in.IDs)
|
||||
if err != nil {
|
||||
return RelationMutationResult{}, err
|
||||
}
|
||||
cr, err := relationOf(cc, relation)
|
||||
if err != nil {
|
||||
return RelationMutationResult{}, err
|
||||
}
|
||||
var result RelationMutationResult
|
||||
err = s.DB.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
|
||||
parent, err := newWritableModel(cc)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if err := loadRecord(ctx, tx, cc, parent, ownerID); err != nil {
|
||||
return err
|
||||
}
|
||||
ownerPK := pkUint(parent)
|
||||
pending, err := pendingRelationIDs(tx, cr, ownerPK, ids)
|
||||
if err != nil || len(pending) == 0 {
|
||||
return err
|
||||
}
|
||||
q, target, err := relationBaseQuery(ctx, tx, cc, cr, parent, true)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
q = q.Clauses(clause.Locking{Strength: "UPDATE"}).Where(clause.IN{Column: clause.Column{Table: tableName(target), Name: primaryColumn(target)}, Values: uintValues(pending)})
|
||||
holder := reflect.New(reflect.SliceOf(reflect.TypeOf(target).Elem()))
|
||||
if err := q.Order(clause.OrderByColumn{Column: clause.Column{Table: tableName(target), Name: primaryColumn(target)}}).Find(holder.Interface()).Error; err != nil {
|
||||
return err
|
||||
}
|
||||
if holder.Elem().Len() != len(pending) {
|
||||
return relationInvalid("ids", "contains an ineligible target")
|
||||
}
|
||||
for i := 0; i < holder.Elem().Len(); i++ {
|
||||
related := holder.Elem().Index(i).Addr().Interface()
|
||||
pivot := cr.Contract.NewPivot()
|
||||
if err := setModelColumn(pivot, cr.Contract.ParentForeignKey, ownerPK); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := setModelColumn(pivot, cr.Contract.RelatedForeignKey, pkUint(related)); err != nil {
|
||||
return err
|
||||
}
|
||||
values := map[string]any{}
|
||||
if hook, ok := cc.Controller.(pact.RelationBeforeLink); ok && hook != nil {
|
||||
if err := hook.RelationBeforeLink(ctx, relation, parent, related, values); err != nil {
|
||||
return lifecycleFailure(cc, err)
|
||||
}
|
||||
}
|
||||
for key, value := range values {
|
||||
if !stringSliceHasValue(cr.Contract.HookPivotColumns, key) || protectedPivotColumn(key, cr.Contract) {
|
||||
return lifecycleFailure(cc, fmt.Errorf("relation hook wrote protected pivot column"))
|
||||
}
|
||||
if err := setModelColumn(pivot, key, value); err != nil {
|
||||
return lifecycleFailure(cc, err)
|
||||
}
|
||||
}
|
||||
if err := tx.WithContext(ctx).Create(pivot).Error; err != nil {
|
||||
return err
|
||||
}
|
||||
result.Linked++
|
||||
}
|
||||
return nil
|
||||
})
|
||||
return result, err
|
||||
}
|
||||
|
||||
// Unlink deletes explicit pivot models so their lifecycle hooks run.
|
||||
func (s RelationService) Unlink(ctx context.Context, cc *CompiledController, relation string, ownerID uint, in RelationMutationInput) (RelationMutationResult, error) {
|
||||
ids, err := normalizeIDs(in.IDs)
|
||||
if err != nil {
|
||||
return RelationMutationResult{}, err
|
||||
}
|
||||
cr, err := relationOf(cc, relation)
|
||||
if err != nil {
|
||||
return RelationMutationResult{}, err
|
||||
}
|
||||
var result RelationMutationResult
|
||||
err = s.DB.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
|
||||
parent, err := newWritableModel(cc)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if err := loadRecord(ctx, tx, cc, parent, ownerID); err != nil {
|
||||
return err
|
||||
}
|
||||
proto := cr.Contract.NewPivot()
|
||||
t := reflect.TypeOf(proto)
|
||||
holder := reflect.New(reflect.SliceOf(t.Elem()))
|
||||
q := tx.WithContext(ctx).Model(proto).Clauses(clause.Locking{Strength: "UPDATE"}).
|
||||
Where(clause.Eq{Column: clause.Column{Name: cr.Contract.ParentForeignKey}, Value: pkUint(parent)}).
|
||||
Where(clause.IN{Column: clause.Column{Name: cr.Contract.RelatedForeignKey}, Values: uintValues(ids)}).
|
||||
Order(clause.OrderByColumn{Column: clause.Column{Name: cr.Contract.RelatedForeignKey}})
|
||||
if err := q.Find(holder.Interface()).Error; err != nil {
|
||||
return err
|
||||
}
|
||||
for i := 0; i < holder.Elem().Len(); i++ {
|
||||
if err := tx.WithContext(ctx).Delete(holder.Elem().Index(i).Addr().Interface()).Error; err != nil {
|
||||
return err
|
||||
}
|
||||
result.Removed++
|
||||
}
|
||||
return nil
|
||||
})
|
||||
return result, err
|
||||
}
|
||||
|
||||
func relationOf(cc *CompiledController, name string) (*CompiledRelation, error) {
|
||||
if cc == nil || !identifier(name) || cc.Relations == nil || cc.Relations[name] == nil {
|
||||
return nil, recordNotFound{}
|
||||
}
|
||||
return cc.Relations[name], nil
|
||||
}
|
||||
|
||||
func pendingRelationIDs(tx *gorm.DB, cr *CompiledRelation, ownerID uint, ids []uint) ([]uint, error) {
|
||||
var existing []uint
|
||||
err := tx.Table(tableName(cr.Contract.NewPivot())).
|
||||
Where(clause.Eq{Column: clause.Column{Name: cr.Contract.ParentForeignKey}, Value: ownerID}).
|
||||
Where(clause.IN{Column: clause.Column{Name: cr.Contract.RelatedForeignKey}, Values: uintValues(ids)}).
|
||||
Pluck(cr.Contract.RelatedForeignKey, &existing).Error
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
seen := map[uint]struct{}{}
|
||||
for _, id := range existing {
|
||||
seen[id] = struct{}{}
|
||||
}
|
||||
pending := make([]uint, 0, len(ids)-len(seen))
|
||||
for _, id := range ids {
|
||||
if _, ok := seen[id]; !ok {
|
||||
pending = append(pending, id)
|
||||
}
|
||||
}
|
||||
return pending, nil
|
||||
}
|
||||
|
||||
func uintValues(ids []uint) []any {
|
||||
out := make([]any, len(ids))
|
||||
for i, id := range ids {
|
||||
out[i] = id
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
func stringSliceHasValue(values []string, key string) bool {
|
||||
for _, value := range values {
|
||||
if value == key {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func setModelColumn(model any, column string, value any) error {
|
||||
v := reflect.ValueOf(model)
|
||||
if v.Kind() != reflect.Pointer || v.IsNil() {
|
||||
return errors.New("cabana: pivot model must be a pointer")
|
||||
}
|
||||
v = v.Elem()
|
||||
if v.Kind() != reflect.Struct {
|
||||
return errors.New("cabana: pivot model must be a struct pointer")
|
||||
}
|
||||
field := fieldByColumn(v, column)
|
||||
if !field.IsValid() || !field.CanSet() {
|
||||
return fmt.Errorf("cabana: pivot column %s is not writable", column)
|
||||
}
|
||||
return assignReflect(field, value)
|
||||
}
|
||||
|
||||
func assignReflect(dst reflect.Value, value any) error {
|
||||
if value == nil {
|
||||
if dst.Kind() == reflect.Pointer {
|
||||
dst.Set(reflect.Zero(dst.Type()))
|
||||
return nil
|
||||
}
|
||||
return errors.New("cabana: nil pivot value")
|
||||
}
|
||||
src := reflect.ValueOf(value)
|
||||
if src.Type().AssignableTo(dst.Type()) {
|
||||
dst.Set(src)
|
||||
return nil
|
||||
}
|
||||
if dst.Kind() == reflect.Pointer {
|
||||
if src.Kind() == reflect.Pointer && src.Type().AssignableTo(dst.Type()) {
|
||||
dst.Set(src)
|
||||
return nil
|
||||
}
|
||||
ptr := reflect.New(dst.Type().Elem())
|
||||
if src.Type().AssignableTo(dst.Type().Elem()) {
|
||||
ptr.Elem().Set(src)
|
||||
dst.Set(ptr)
|
||||
return nil
|
||||
}
|
||||
if src.Type().ConvertibleTo(dst.Type().Elem()) {
|
||||
ptr.Elem().Set(src.Convert(dst.Type().Elem()))
|
||||
dst.Set(ptr)
|
||||
return nil
|
||||
}
|
||||
}
|
||||
if src.Type().ConvertibleTo(dst.Type()) {
|
||||
dst.Set(src.Convert(dst.Type()))
|
||||
return nil
|
||||
}
|
||||
return fmt.Errorf("cabana: pivot value %T is not assignable to %s", value, dst.Type())
|
||||
}
|
||||
652
modules/cabana/relation_field.go
Normal file
652
modules/cabana/relation_field.go
Normal file
@@ -0,0 +1,652 @@
|
||||
package cabana
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"math"
|
||||
"net/http"
|
||||
"reflect"
|
||||
"sort"
|
||||
"strings"
|
||||
|
||||
"git.golem15.com/golem15/summercms/modules/pact"
|
||||
"gorm.io/gorm"
|
||||
"gorm.io/gorm/clause"
|
||||
)
|
||||
|
||||
// FieldRelationContract binds one fields.yaml `type: relation` field to its
|
||||
// related model (D-17, D-18). Framework code never guesses a plugin table,
|
||||
// pivot or foreign key: every name below comes from the controller.
|
||||
type FieldRelationContract struct {
|
||||
// Field is the fields.yaml key ("genre", "artists").
|
||||
Field string
|
||||
// Kind is "belongsTo" or "belongsToMany".
|
||||
Kind string
|
||||
// NewRelated returns a pointer to the related model.
|
||||
NewRelated func() any
|
||||
// ForeignKey is the belongsTo column on the parent model.
|
||||
ForeignKey string
|
||||
// NewPivot returns a pointer to the belongsToMany join model.
|
||||
NewPivot func() any
|
||||
// ParentForeignKey and RelatedForeignKey are the pivot columns.
|
||||
ParentForeignKey string
|
||||
RelatedForeignKey string
|
||||
// OrderColumn is an optional pivot column set to the submitted array index.
|
||||
OrderColumn string
|
||||
// LabelColumn is the physical label column on the related model. Empty
|
||||
// means the field's nameFrom, mapped through pact.ListRelationColumnMapper
|
||||
// when the controller implements it.
|
||||
LabelColumn string
|
||||
}
|
||||
|
||||
// FieldRelationProvider is implemented by admin controllers whose form
|
||||
// declares `type: relation` fields.
|
||||
type FieldRelationProvider interface {
|
||||
AdminFieldRelations() []FieldRelationContract
|
||||
}
|
||||
|
||||
// RelationOption is one relation choice or label: the related primary key and
|
||||
// its label column value.
|
||||
type RelationOption struct {
|
||||
Value uint `json:"value"`
|
||||
Label string `json:"label"`
|
||||
}
|
||||
|
||||
// RecordMeta is the record envelope meta: display labels per relation field,
|
||||
// in the same order as the ids in data.
|
||||
type RecordMeta struct {
|
||||
Labels map[string][]RelationOption `json:"labels"`
|
||||
}
|
||||
|
||||
// RecordEnvelope is the show, create and update response.
|
||||
type RecordEnvelope struct {
|
||||
Data AdminRecord `json:"data"`
|
||||
Meta RecordMeta `json:"meta"`
|
||||
}
|
||||
|
||||
// RecordResult is one projected record plus its relation labels.
|
||||
type RecordResult struct {
|
||||
Data map[string]any
|
||||
Meta RecordMeta
|
||||
}
|
||||
|
||||
// CompiledFieldRelation is one relation field after activation checks.
|
||||
type CompiledFieldRelation struct {
|
||||
Contract FieldRelationContract
|
||||
// LabelColumn is the resolved physical label column.
|
||||
LabelColumn string
|
||||
// Multiple is true for belongsToMany.
|
||||
Multiple bool
|
||||
// ReadOnly is true for a belongsTo whose foreign key is a protected fill
|
||||
// key (D-26): it is shown with its label but never written and has no
|
||||
// options endpoint.
|
||||
ReadOnly bool
|
||||
// Nullable is true when a belongsTo foreign key accepts null.
|
||||
Nullable bool
|
||||
}
|
||||
|
||||
const (
|
||||
relationKindBelongsTo = "belongsTo"
|
||||
relationKindBelongsToMany = "belongsToMany"
|
||||
)
|
||||
|
||||
// compileFieldRelations binds every `type: relation` field to exactly one
|
||||
// controller contract and marks the compiled form fields multiple or
|
||||
// read-only. Any mismatch is a boot error naming plugin, controller and field.
|
||||
func compileFieldRelations(pluginID string, ctl pact.AdminController, form *FormSchema) (map[string]*CompiledFieldRelation, error) {
|
||||
out := map[string]*CompiledFieldRelation{}
|
||||
fail := func(field string, err error) error {
|
||||
return bootErr(pluginID, ctl.ID(), "config_form.yaml", fmt.Errorf("field %s: %w", field, err))
|
||||
}
|
||||
indexes := map[string]int{}
|
||||
var order []string
|
||||
if form != nil {
|
||||
for i, field := range form.Fields {
|
||||
if field.Type == "relation" {
|
||||
indexes[field.Name] = i
|
||||
order = append(order, field.Name)
|
||||
}
|
||||
}
|
||||
}
|
||||
provider, hasProvider := ctl.(FieldRelationProvider)
|
||||
var contracts []FieldRelationContract
|
||||
if hasProvider && provider != nil {
|
||||
contracts = provider.AdminFieldRelations()
|
||||
}
|
||||
if len(order) == 0 && len(contracts) == 0 {
|
||||
return out, nil
|
||||
}
|
||||
byField := map[string]FieldRelationContract{}
|
||||
for _, contract := range contracts {
|
||||
if _, dup := byField[contract.Field]; dup {
|
||||
return nil, fail(contract.Field, errors.New("duplicate relation contract"))
|
||||
}
|
||||
byField[contract.Field] = contract
|
||||
if _, ok := indexes[contract.Field]; !ok {
|
||||
return nil, fail(contract.Field, errors.New("relation contract names a field that is not a relation field in fields.yaml"))
|
||||
}
|
||||
}
|
||||
src, ok := ctl.(pact.AdminRecordSource)
|
||||
if !ok || src == nil || src.NewRecord() == nil {
|
||||
return nil, fail(order[0], errors.New("relation fields require an AdminRecordSource"))
|
||||
}
|
||||
parent := src.NewRecord()
|
||||
for _, name := range order {
|
||||
contract, declared := byField[name]
|
||||
if !declared {
|
||||
if !hasProvider {
|
||||
return nil, fail(name, errors.New("type relation requires AdminFieldRelations on the controller"))
|
||||
}
|
||||
return nil, fail(name, errors.New("has no relation contract"))
|
||||
}
|
||||
field := &form.Fields[indexes[name]]
|
||||
compiled, err := compileFieldRelation(ctl, *field, contract, parent)
|
||||
if err != nil {
|
||||
return nil, fail(name, err)
|
||||
}
|
||||
field.Multiple = compiled.Multiple
|
||||
field.ReadOnly = compiled.ReadOnly
|
||||
out[name] = compiled
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
func compileFieldRelation(ctl pact.AdminController, field FormField, contract FieldRelationContract, parent any) (*CompiledFieldRelation, error) {
|
||||
if contract.NewRelated == nil || contract.NewRelated() == nil {
|
||||
return nil, errors.New("relation contract requires a related model")
|
||||
}
|
||||
related := contract.NewRelated()
|
||||
relatedCols := modelColumns(related)
|
||||
if _, ok := relatedCols[primaryColumn(related)]; !ok {
|
||||
return nil, fmt.Errorf("related model has no primary key column %s", primaryColumn(related))
|
||||
}
|
||||
label := strings.TrimSpace(contract.LabelColumn)
|
||||
if label == "" {
|
||||
label = field.NameFrom
|
||||
if mapper, ok := ctl.(pact.ListRelationColumnMapper); ok && mapper != nil && label != "" {
|
||||
if mapped, ok := mapper.ListRelationColumn(field.Name, label); ok && mapped != "" {
|
||||
label = mapped
|
||||
}
|
||||
}
|
||||
}
|
||||
if !identifier(label) {
|
||||
return nil, errors.New("relation needs nameFrom or a LabelColumn")
|
||||
}
|
||||
if _, ok := relatedCols[label]; !ok {
|
||||
return nil, fmt.Errorf("related model is missing label column %s", label)
|
||||
}
|
||||
out := &CompiledFieldRelation{Contract: contract, LabelColumn: label}
|
||||
parentCols := modelColumns(parent)
|
||||
switch contract.Kind {
|
||||
case relationKindBelongsTo:
|
||||
if contract.NewPivot != nil || contract.ParentForeignKey != "" || contract.RelatedForeignKey != "" || contract.OrderColumn != "" {
|
||||
return nil, errors.New("belongsTo cannot declare pivot columns")
|
||||
}
|
||||
if !identifier(contract.ForeignKey) {
|
||||
return nil, errors.New("belongsTo requires a ForeignKey")
|
||||
}
|
||||
if _, ok := parentCols[contract.ForeignKey]; !ok {
|
||||
return nil, fmt.Errorf("parent model is missing foreign key column %s", contract.ForeignKey)
|
||||
}
|
||||
fk, ok := structFieldByColumn(parent, contract.ForeignKey)
|
||||
if !ok || !uintLike(fk.Type) {
|
||||
return nil, fmt.Errorf("foreign key %s must be an unsigned integer column", contract.ForeignKey)
|
||||
}
|
||||
out.Nullable = fk.Type.Kind() == reflect.Pointer
|
||||
out.ReadOnly = protectedFillKey(contract.ForeignKey)
|
||||
case relationKindBelongsToMany:
|
||||
if contract.ForeignKey != "" {
|
||||
return nil, errors.New("belongsToMany cannot declare a ForeignKey")
|
||||
}
|
||||
if contract.NewPivot == nil || contract.NewPivot() == nil {
|
||||
return nil, errors.New("belongsToMany requires a pivot model")
|
||||
}
|
||||
pivot := contract.NewPivot()
|
||||
if reflect.TypeOf(pivot).Kind() != reflect.Pointer || reflect.TypeOf(pivot).Elem().Kind() != reflect.Struct {
|
||||
return nil, errors.New("pivot model must be a struct pointer")
|
||||
}
|
||||
pivotCols := modelColumns(pivot)
|
||||
for _, col := range []string{contract.ParentForeignKey, contract.RelatedForeignKey} {
|
||||
if !identifier(col) {
|
||||
return nil, errors.New("belongsToMany requires ParentForeignKey and RelatedForeignKey")
|
||||
}
|
||||
if _, ok := pivotCols[col]; !ok {
|
||||
return nil, fmt.Errorf("pivot model is missing column %s", col)
|
||||
}
|
||||
}
|
||||
if contract.ParentForeignKey == contract.RelatedForeignKey {
|
||||
return nil, errors.New("pivot foreign keys must differ")
|
||||
}
|
||||
if contract.OrderColumn != "" {
|
||||
if !identifier(contract.OrderColumn) {
|
||||
return nil, fmt.Errorf("order column %q is not an identifier", contract.OrderColumn)
|
||||
}
|
||||
if _, ok := pivotCols[contract.OrderColumn]; !ok {
|
||||
return nil, fmt.Errorf("pivot model is missing order column %s", contract.OrderColumn)
|
||||
}
|
||||
if contract.OrderColumn == contract.ParentForeignKey || contract.OrderColumn == contract.RelatedForeignKey {
|
||||
return nil, errors.New("order column must not be a pivot foreign key")
|
||||
}
|
||||
}
|
||||
out.Multiple = true
|
||||
default:
|
||||
return nil, fmt.Errorf("unknown relation kind %s (want belongsTo or belongsToMany)", contract.Kind)
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
func structFieldByColumn(model any, column string) (reflect.StructField, bool) {
|
||||
t := reflect.TypeOf(model)
|
||||
for t != nil && t.Kind() == reflect.Pointer {
|
||||
t = t.Elem()
|
||||
}
|
||||
if t == nil || t.Kind() != reflect.Struct {
|
||||
return reflect.StructField{}, false
|
||||
}
|
||||
for i := 0; i < t.NumField(); i++ {
|
||||
field := t.Field(i)
|
||||
if field.PkgPath == "" && gormColumn(field) == column {
|
||||
return field, true
|
||||
}
|
||||
}
|
||||
return reflect.StructField{}, false
|
||||
}
|
||||
|
||||
func uintLike(t reflect.Type) bool {
|
||||
if t.Kind() == reflect.Pointer {
|
||||
t = t.Elem()
|
||||
}
|
||||
switch t.Kind() {
|
||||
case reflect.Uint, reflect.Uint32, reflect.Uint64, reflect.Int, reflect.Int32, reflect.Int64:
|
||||
return true
|
||||
default:
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
// writableFieldRelation returns a relation field that offers options and
|
||||
// accepts values. Read-only and unknown fields are not found.
|
||||
func writableFieldRelation(cc *CompiledController, name string) (*CompiledFieldRelation, bool) {
|
||||
if cc == nil || !identifier(name) {
|
||||
return nil, false
|
||||
}
|
||||
fr, ok := cc.FieldRelations[name]
|
||||
if !ok || fr == nil || fr.ReadOnly {
|
||||
return nil, false
|
||||
}
|
||||
return fr, true
|
||||
}
|
||||
|
||||
// scopedRelationQuery is the one query that both serves options and
|
||||
// revalidates submitted ids, so the options hook is never only cosmetic.
|
||||
func scopedRelationQuery(ctx context.Context, db *gorm.DB, cc *CompiledController, field string, fr *CompiledFieldRelation) *gorm.DB {
|
||||
q := db.WithContext(ctx).Model(fr.Contract.NewRelated())
|
||||
if ext, ok := cc.Controller.(pact.RelationExtendOptionsQuery); ok && ext != nil {
|
||||
if next := ext.RelationExtendOptionsQuery(ctx, field, q); next != nil {
|
||||
q = next
|
||||
}
|
||||
}
|
||||
return q
|
||||
}
|
||||
|
||||
func labelExpression(db *gorm.DB, table, column string) string {
|
||||
return "COALESCE(CAST(" + quotedIdent(db, table) + "." + quotedIdent(db, column) + " AS TEXT), '')"
|
||||
}
|
||||
|
||||
// RelationOptions serves one page of a relation field's choices (D-17):
|
||||
// scoped by RelationExtendOptionsQuery, searched case-insensitively on the
|
||||
// label column, ordered by label then primary key.
|
||||
func (s CRUDService) RelationOptions(ctx context.Context, cc *CompiledController, field string, in RelationQuery) ([]RelationOption, ListMeta, error) {
|
||||
if s.DB == nil {
|
||||
return nil, ListMeta{}, errors.New("cabana: database is not configured")
|
||||
}
|
||||
if ctx == nil {
|
||||
ctx = context.Background()
|
||||
}
|
||||
fr, ok := writableFieldRelation(cc, field)
|
||||
if !ok {
|
||||
return nil, ListMeta{}, recordNotFound{}
|
||||
}
|
||||
page, per, err := normalizeRelationPage(in.Page, in.PerPage)
|
||||
if err != nil {
|
||||
return nil, ListMeta{}, err
|
||||
}
|
||||
related := fr.Contract.NewRelated()
|
||||
table := tableName(related)
|
||||
pk := primaryColumn(related)
|
||||
q := scopedRelationQuery(ctx, s.DB, cc, field, fr)
|
||||
label := labelExpression(q, table, fr.LabelColumn)
|
||||
if term := strings.TrimSpace(in.Search); term != "" {
|
||||
q = q.Where(label+" ILIKE ? ESCAPE '\\'", "%"+escapeLike(term)+"%")
|
||||
}
|
||||
var total int64
|
||||
if err := q.Session(&gorm.Session{}).Count(&total).Error; err != nil {
|
||||
return nil, ListMeta{}, lifecycleFailure(cc, err)
|
||||
}
|
||||
rows := make([]RelationOption, 0)
|
||||
err = q.Select(quotedIdent(q, table) + "." + quotedIdent(q, pk) + " AS value, " + label + " AS label").
|
||||
Order(label).
|
||||
Order(clause.OrderByColumn{Column: clause.Column{Table: table, Name: pk}}).
|
||||
Offset((page - 1) * per).Limit(per).
|
||||
Scan(&rows).Error
|
||||
if err != nil {
|
||||
return nil, ListMeta{}, lifecycleFailure(cc, err)
|
||||
}
|
||||
last := 1
|
||||
if total > 0 {
|
||||
last = int((total + int64(per) - 1) / int64(per))
|
||||
}
|
||||
return rows, ListMeta{Page: page, PerPage: per, Total: total, LastPage: last}, nil
|
||||
}
|
||||
|
||||
// relationValue is one present, writable relation key lifted from a body.
|
||||
type relationValue struct {
|
||||
field string
|
||||
fr *CompiledFieldRelation
|
||||
ids []uint
|
||||
null bool
|
||||
}
|
||||
|
||||
// liftRelationValues takes the writable relation keys present in body. Read
|
||||
// only fields, fields outside the operation's context and absent keys are
|
||||
// skipped. Shape errors are one validation_failed with every bad field.
|
||||
func liftRelationValues(cc *CompiledController, body map[string]any, op string) ([]relationValue, error) {
|
||||
if cc == nil || len(cc.FieldRelations) == 0 || body == nil {
|
||||
return nil, nil
|
||||
}
|
||||
names := make([]string, 0, len(cc.FieldRelations))
|
||||
for name := range cc.FieldRelations {
|
||||
names = append(names, name)
|
||||
}
|
||||
sort.Strings(names)
|
||||
details := map[string]any{}
|
||||
var out []relationValue
|
||||
for _, name := range names {
|
||||
fr := cc.FieldRelations[name]
|
||||
if fr == nil || fr.ReadOnly || !contextAllows(cc, name, op) {
|
||||
continue
|
||||
}
|
||||
raw, present := body[name]
|
||||
if !present {
|
||||
continue
|
||||
}
|
||||
value := relationValue{field: name, fr: fr}
|
||||
if fr.Multiple {
|
||||
items, ok := raw.([]any)
|
||||
if !ok {
|
||||
details[name] = []string{"The " + name + " field must be a list of ids."}
|
||||
continue
|
||||
}
|
||||
seen := map[uint]struct{}{}
|
||||
ids := make([]uint, 0, len(items))
|
||||
bad := ""
|
||||
for _, item := range items {
|
||||
id, err := relationID(item)
|
||||
if err != nil {
|
||||
bad = "The " + name + " field must be a list of integer ids."
|
||||
break
|
||||
}
|
||||
if _, dup := seen[id]; dup {
|
||||
bad = "The " + name + " field contains a duplicate id."
|
||||
break
|
||||
}
|
||||
seen[id] = struct{}{}
|
||||
ids = append(ids, id)
|
||||
}
|
||||
if bad != "" {
|
||||
details[name] = []string{bad}
|
||||
continue
|
||||
}
|
||||
value.ids = ids
|
||||
} else if raw == nil {
|
||||
if !fr.Nullable {
|
||||
details[name] = []string{"The " + name + " field cannot be empty."}
|
||||
continue
|
||||
}
|
||||
value.null = true
|
||||
} else {
|
||||
id, err := relationID(raw)
|
||||
if err != nil {
|
||||
details[name] = []string{"The " + name + " field must be an integer id."}
|
||||
continue
|
||||
}
|
||||
value.ids = []uint{id}
|
||||
}
|
||||
out = append(out, value)
|
||||
}
|
||||
if len(details) > 0 {
|
||||
return nil, &ValidationError{Details: details}
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
// relationID accepts a JSON integer only: no strings, booleans or fractions.
|
||||
func relationID(v any) (uint, error) {
|
||||
switch n := v.(type) {
|
||||
case json.Number:
|
||||
return asUint(n)
|
||||
case float64:
|
||||
if n != math.Trunc(n) {
|
||||
return 0, errBadID
|
||||
}
|
||||
return asUint(n)
|
||||
case int, int64, uint, uint32, uint64:
|
||||
return asUint(n)
|
||||
default:
|
||||
return 0, errBadID
|
||||
}
|
||||
}
|
||||
|
||||
// checkRelationScope re-runs the scoped options query for every submitted id
|
||||
// inside the save transaction. An id the query does not return (unknown or
|
||||
// out of scope) is validation_failed on that field and rolls the save back.
|
||||
func checkRelationScope(ctx context.Context, tx *gorm.DB, cc *CompiledController, values []relationValue) error {
|
||||
details := map[string]any{}
|
||||
for _, value := range values {
|
||||
if len(value.ids) == 0 {
|
||||
continue
|
||||
}
|
||||
related := value.fr.Contract.NewRelated()
|
||||
table := tableName(related)
|
||||
pk := primaryColumn(related)
|
||||
var found []uint
|
||||
err := scopedRelationQuery(ctx, tx, cc, value.field, value.fr).
|
||||
Where(clause.IN{Column: clause.Column{Table: table, Name: pk}, Values: uintValues(value.ids)}).
|
||||
Pluck(quotedIdent(tx, table)+"."+quotedIdent(tx, pk), &found).Error
|
||||
if err != nil {
|
||||
return lifecycleFailure(cc, err)
|
||||
}
|
||||
have := map[uint]struct{}{}
|
||||
for _, id := range found {
|
||||
have[id] = struct{}{}
|
||||
}
|
||||
for _, id := range value.ids {
|
||||
if _, ok := have[id]; !ok {
|
||||
details[value.field] = []string{"The selected " + value.field + " is invalid."}
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
if len(details) > 0 {
|
||||
return &ValidationError{Details: details}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// assignBelongsTo writes validated belongsTo ids (or null) onto the parent's
|
||||
// foreign key before the row write. Read-only keys never reach this point.
|
||||
func assignBelongsTo(cc *CompiledController, model any, values []relationValue) error {
|
||||
for _, value := range values {
|
||||
if value.fr.Multiple || value.fr.ReadOnly || protectedFillKey(value.fr.Contract.ForeignKey) {
|
||||
continue
|
||||
}
|
||||
var id any
|
||||
if !value.null {
|
||||
id = value.ids[0]
|
||||
}
|
||||
if err := setModelColumn(model, value.fr.Contract.ForeignKey, id); err != nil {
|
||||
return lifecycleFailure(cc, err)
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// syncBelongsToMany replaces the parent's pivot rows in submitted order: an
|
||||
// explicit delete, then one bulk insert (Phase 5 join-table contract).
|
||||
func syncBelongsToMany(ctx context.Context, tx *gorm.DB, cc *CompiledController, model any, values []relationValue) error {
|
||||
parentPK := pkUint(model)
|
||||
for _, value := range values {
|
||||
if !value.fr.Multiple {
|
||||
continue
|
||||
}
|
||||
c := value.fr.Contract
|
||||
proto := c.NewPivot()
|
||||
err := tx.WithContext(ctx).Unscoped().
|
||||
Where(clause.Eq{Column: clause.Column{Name: c.ParentForeignKey}, Value: parentPK}).
|
||||
Delete(proto).Error
|
||||
if err != nil {
|
||||
return lifecycleFailure(cc, err)
|
||||
}
|
||||
if len(value.ids) == 0 {
|
||||
continue
|
||||
}
|
||||
rows := reflect.MakeSlice(reflect.SliceOf(reflect.TypeOf(proto).Elem()), 0, len(value.ids))
|
||||
for i, id := range value.ids {
|
||||
pivot := c.NewPivot()
|
||||
if err := setModelColumn(pivot, c.ParentForeignKey, parentPK); err != nil {
|
||||
return lifecycleFailure(cc, err)
|
||||
}
|
||||
if err := setModelColumn(pivot, c.RelatedForeignKey, id); err != nil {
|
||||
return lifecycleFailure(cc, err)
|
||||
}
|
||||
if c.OrderColumn != "" {
|
||||
if err := setModelColumn(pivot, c.OrderColumn, i); err != nil {
|
||||
return lifecycleFailure(cc, err)
|
||||
}
|
||||
}
|
||||
rows = reflect.Append(rows, reflect.ValueOf(pivot).Elem())
|
||||
}
|
||||
holder := reflect.New(rows.Type())
|
||||
holder.Elem().Set(rows)
|
||||
if err := tx.WithContext(ctx).Create(holder.Interface()).Error; err != nil {
|
||||
return lifecycleFailure(cc, err)
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// projectRelationFields adds every relation field's value to data (belongsTo
|
||||
// id or null; belongsToMany ids in pivot order, then related id) and returns
|
||||
// the labels in the same order. Read-only fields are included.
|
||||
func projectRelationFields(ctx context.Context, tx *gorm.DB, cc *CompiledController, model any, data map[string]any) (RecordMeta, error) {
|
||||
meta := RecordMeta{Labels: map[string][]RelationOption{}}
|
||||
if cc == nil || len(cc.FieldRelations) == 0 {
|
||||
return meta, nil
|
||||
}
|
||||
v := reflect.ValueOf(model)
|
||||
for v.Kind() == reflect.Pointer {
|
||||
v = v.Elem()
|
||||
}
|
||||
for name, fr := range cc.FieldRelations {
|
||||
c := fr.Contract
|
||||
var ids []uint
|
||||
if fr.Multiple {
|
||||
ids = []uint{}
|
||||
q := tx.WithContext(ctx).Model(c.NewPivot()).
|
||||
Where(clause.Eq{Column: clause.Column{Name: c.ParentForeignKey}, Value: pkUint(model)})
|
||||
if c.OrderColumn != "" {
|
||||
q = q.Order(clause.OrderByColumn{Column: clause.Column{Name: c.OrderColumn}})
|
||||
}
|
||||
if err := q.Order(clause.OrderByColumn{Column: clause.Column{Name: c.RelatedForeignKey}}).Pluck(c.RelatedForeignKey, &ids).Error; err != nil {
|
||||
return RecordMeta{}, lifecycleFailure(cc, err)
|
||||
}
|
||||
data[name] = ids
|
||||
} else {
|
||||
data[name] = nil
|
||||
if id, ok := foreignKeyValue(v, c.ForeignKey); ok {
|
||||
data[name] = id
|
||||
ids = []uint{id}
|
||||
}
|
||||
}
|
||||
labels, err := relationLabels(ctx, tx, fr, ids)
|
||||
if err != nil {
|
||||
return RecordMeta{}, lifecycleFailure(cc, err)
|
||||
}
|
||||
meta.Labels[name] = labels
|
||||
}
|
||||
return meta, nil
|
||||
}
|
||||
|
||||
func foreignKeyValue(v reflect.Value, column string) (uint, bool) {
|
||||
field := fieldByColumn(v, column)
|
||||
if !field.IsValid() {
|
||||
return 0, false
|
||||
}
|
||||
for field.Kind() == reflect.Pointer {
|
||||
if field.IsNil() {
|
||||
return 0, false
|
||||
}
|
||||
field = field.Elem()
|
||||
}
|
||||
if !field.CanInterface() {
|
||||
return 0, false
|
||||
}
|
||||
id, err := asUint(field.Interface())
|
||||
if err != nil || id == 0 {
|
||||
return 0, false
|
||||
}
|
||||
return id, true
|
||||
}
|
||||
|
||||
func relationLabels(ctx context.Context, tx *gorm.DB, fr *CompiledFieldRelation, ids []uint) ([]RelationOption, error) {
|
||||
out := make([]RelationOption, 0, len(ids))
|
||||
if len(ids) == 0 {
|
||||
return out, nil
|
||||
}
|
||||
related := fr.Contract.NewRelated()
|
||||
table := tableName(related)
|
||||
pk := primaryColumn(related)
|
||||
var rows []RelationOption
|
||||
err := tx.WithContext(ctx).Model(related).
|
||||
Select(quotedIdent(tx, table) + "." + quotedIdent(tx, pk) + " AS value, " + labelExpression(tx, table, fr.LabelColumn) + " AS label").
|
||||
Where(clause.IN{Column: clause.Column{Table: table, Name: pk}, Values: uintValues(ids)}).
|
||||
Scan(&rows).Error
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
byID := make(map[uint]string, len(rows))
|
||||
for _, row := range rows {
|
||||
byID[row.Value] = row.Label
|
||||
}
|
||||
for _, id := range ids {
|
||||
if label, ok := byID[id]; ok {
|
||||
out = append(out, RelationOption{Value: id, Label: label})
|
||||
}
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
// fieldOptions serves GET /{vendor}/{plugin}/{controller}/fields/{field}/options.
|
||||
func (s *service) fieldOptions(w http.ResponseWriter, r *http.Request) {
|
||||
s.protect(w, r, func(cc *CompiledController) {
|
||||
field := r.PathValue("field")
|
||||
if _, ok := writableFieldRelation(cc, field); !ok {
|
||||
writeNotFound(w, r)
|
||||
return
|
||||
}
|
||||
svc, err := s.crud()
|
||||
if err != nil {
|
||||
WriteError(w, http.StatusInternalServerError, "error", msgServerError)
|
||||
return
|
||||
}
|
||||
q := r.URL.Query()
|
||||
rows, meta, err := svc.RelationOptions(r.Context(), cc, field, RelationQuery{Search: q.Get("search"), Page: q.Get("page"), PerPage: q.Get("per_page")})
|
||||
if err != nil {
|
||||
writeCRUDError(w, err)
|
||||
return
|
||||
}
|
||||
WriteData(w, http.StatusOK, rows, meta)
|
||||
})
|
||||
}
|
||||
732
modules/cabana/relation_field_test.go
Normal file
732
modules/cabana/relation_field_test.go
Normal file
@@ -0,0 +1,732 @@
|
||||
package cabana
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"strings"
|
||||
"testing"
|
||||
"testing/fstest"
|
||||
"time"
|
||||
|
||||
"git.golem15.com/golem15/summercms/modules/backpack"
|
||||
"git.golem15.com/golem15/summercms/modules/bouncer"
|
||||
"gorm.io/gorm"
|
||||
)
|
||||
|
||||
const p10FormConfig = `name: records
|
||||
form: ~/plugins/acme/demo/models/record/fields.yaml
|
||||
modelClass: Record
|
||||
`
|
||||
|
||||
const p10ListConfig = `modelClass: Record
|
||||
list: ~/plugins/acme/demo/models/record/columns.yaml
|
||||
recordsPerPage: 20
|
||||
`
|
||||
|
||||
const p10Columns = `columns:
|
||||
name:
|
||||
label: Name
|
||||
searchable: true
|
||||
`
|
||||
|
||||
const p10Fields = `fields:
|
||||
name:
|
||||
label: Name
|
||||
type: text
|
||||
required: true
|
||||
group:
|
||||
label: Group
|
||||
type: relation
|
||||
nameFrom: title
|
||||
emptyOption: None
|
||||
tags:
|
||||
label: Tags
|
||||
type: relation
|
||||
nameFrom: label
|
||||
person:
|
||||
label: Person
|
||||
type: relation
|
||||
nameFrom: username
|
||||
`
|
||||
|
||||
type p10Record struct {
|
||||
ID uint `gorm:"column:id;primaryKey"`
|
||||
Name string `gorm:"column:name"`
|
||||
GroupID *uint `gorm:"column:group_id"`
|
||||
UserID uint `gorm:"column:user_id"`
|
||||
CreatedAt time.Time `gorm:"column:created_at"`
|
||||
UpdatedAt time.Time `gorm:"column:updated_at"`
|
||||
}
|
||||
|
||||
func (p10Record) TableName() string { return "cabana_p10_records" }
|
||||
func (p10Record) Fillable() []string { return []string{"name"} }
|
||||
func (p10Record) Rules() map[string]string { return map[string]string{"name": "required"} }
|
||||
func (p10Group) TableName() string { return "cabana_p10_groups" }
|
||||
func (p10Tag) TableName() string { return "cabana_p10_tags" }
|
||||
func (p10RecordTag) TableName() string { return "cabana_p10_record_tags" }
|
||||
func (p10Person) TableName() string { return "cabana_p10_people" }
|
||||
func (p10Controller) ID() string { return "acme.demo.records" }
|
||||
func (p10Controller) ModelName() string { return "Record" }
|
||||
func (p10Controller) ConfigDir() string { return "controllers/records" }
|
||||
func (p10Controller) NewRecord() any { return &p10Record{} }
|
||||
func (c p10Controller) RequiredPermissions() []string { return c.perms }
|
||||
|
||||
type p10Group struct {
|
||||
ID uint `gorm:"column:id;primaryKey"`
|
||||
Title string `gorm:"column:title"`
|
||||
Scope string `gorm:"column:scope"`
|
||||
}
|
||||
|
||||
type p10Tag struct {
|
||||
ID uint `gorm:"column:id;primaryKey"`
|
||||
Label *string `gorm:"column:label"`
|
||||
Scope string `gorm:"column:scope"`
|
||||
}
|
||||
|
||||
type p10RecordTag struct {
|
||||
RecordID uint `gorm:"column:record_id;primaryKey"`
|
||||
TagID uint `gorm:"column:tag_id;primaryKey"`
|
||||
Position int `gorm:"column:position"`
|
||||
}
|
||||
|
||||
type p10Person struct {
|
||||
ID uint `gorm:"column:id;primaryKey"`
|
||||
Email string `gorm:"column:email"`
|
||||
}
|
||||
|
||||
// p10Controller serves the acme fixtures. Options are scoped to rows whose
|
||||
// scope is "visible"; the person relation writes the protected user_id and is
|
||||
// therefore read-only (D-26).
|
||||
type p10Controller struct {
|
||||
perms []string
|
||||
mutate func([]FieldRelationContract) []FieldRelationContract
|
||||
}
|
||||
|
||||
func (c p10Controller) AdminFieldRelations() []FieldRelationContract {
|
||||
out := []FieldRelationContract{
|
||||
{Field: "group", Kind: "belongsTo", NewRelated: func() any { return &p10Group{} }, ForeignKey: "group_id"},
|
||||
{Field: "tags", Kind: "belongsToMany", NewRelated: func() any { return &p10Tag{} }, NewPivot: func() any { return &p10RecordTag{} },
|
||||
ParentForeignKey: "record_id", RelatedForeignKey: "tag_id", OrderColumn: "position"},
|
||||
{Field: "person", Kind: "belongsTo", NewRelated: func() any { return &p10Person{} }, ForeignKey: "user_id", LabelColumn: "email"},
|
||||
}
|
||||
if c.mutate != nil {
|
||||
out = c.mutate(out)
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
func (p10Controller) RelationExtendOptionsQuery(_ context.Context, field string, db *gorm.DB) *gorm.DB {
|
||||
switch field {
|
||||
case "group", "tags":
|
||||
return db.Where("scope = ?", "visible")
|
||||
default:
|
||||
return db.Where("1 = 0")
|
||||
}
|
||||
}
|
||||
|
||||
func (p10Controller) FormBeforeCreate(ctx context.Context, model any) error {
|
||||
record, ok := model.(*p10Record)
|
||||
if !ok {
|
||||
return fmt.Errorf("unexpected model %T", model)
|
||||
}
|
||||
principal, _ := bouncer.User(ctx)
|
||||
if principal != nil {
|
||||
record.UserID = principal.ID
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func p10FS() fstest.MapFS {
|
||||
return fstest.MapFS{
|
||||
"controllers/records/config_list.yaml": &fstest.MapFile{Data: []byte(p10ListConfig)},
|
||||
"controllers/records/config_form.yaml": &fstest.MapFile{Data: []byte(p10FormConfig)},
|
||||
"models/record/columns.yaml": &fstest.MapFile{Data: []byte(p10Columns)},
|
||||
"models/record/fields.yaml": &fstest.MapFile{Data: []byte(p10Fields)},
|
||||
}
|
||||
}
|
||||
|
||||
func p10Compile(ctl p10Controller) (*Registry, error) {
|
||||
return compileRegistry([]controllerRef{{plugin: formPlugin{fsys: p10FS()}, ctl: ctl}})
|
||||
}
|
||||
|
||||
type p10Seed struct {
|
||||
groups map[string]uint
|
||||
tags map[string]uint
|
||||
person uint
|
||||
}
|
||||
|
||||
func p10Fixture(t *testing.T) (*service, *gorm.DB, p10Seed) {
|
||||
t.Helper()
|
||||
_, db := newListService(t)
|
||||
models := []any{&p10Record{}, &p10Group{}, &p10Tag{}, &p10RecordTag{}, &p10Person{}}
|
||||
if err := db.Migrator().DropTable(models...); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := db.AutoMigrate(models...); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
reg, err := p10Compile(p10Controller{perms: []string{"acme.demo.access"}})
|
||||
if err != nil {
|
||||
t.Fatalf("registry: %v", err)
|
||||
}
|
||||
app := backpack.New(nil)
|
||||
if err := app.Publish(db); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
seed := p10Seed{groups: map[string]uint{}, tags: map[string]uint{}}
|
||||
for _, g := range []p10Group{{Title: "Alpha", Scope: "visible"}, {Title: "Beta", Scope: "visible"}, {Title: "Hidden", Scope: "hidden"}} {
|
||||
if err := db.Create(&g).Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
seed.groups[g.Title] = g.ID
|
||||
}
|
||||
for _, spec := range []struct{ label, scope string }{{"one", "visible"}, {"two", "visible"}, {"three", "visible"}, {"hidden", "hidden"}} {
|
||||
label := spec.label
|
||||
tag := p10Tag{Label: &label, Scope: spec.scope}
|
||||
if err := db.Create(&tag).Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
seed.tags[spec.label] = tag.ID
|
||||
}
|
||||
person := p10Person{ID: 1, Email: "admin@acme.test"}
|
||||
if err := db.Create(&person).Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
seed.person = person.ID
|
||||
return &service{app: app, reg: reg}, db, seed
|
||||
}
|
||||
|
||||
func p10Principal(granted bool) *bouncer.Principal {
|
||||
p := &bouncer.Principal{ID: 1, Backend: true, PermissionGrants: map[string]bool{}}
|
||||
if granted {
|
||||
p.PermissionGrants["acme.demo.access"] = true
|
||||
}
|
||||
return p
|
||||
}
|
||||
|
||||
func p10Request(method, id, field, query string, body any, principal *bouncer.Principal) *http.Request {
|
||||
var reader *bytes.Reader
|
||||
if body != nil {
|
||||
raw, _ := json.Marshal(body)
|
||||
reader = bytes.NewReader(raw)
|
||||
} else {
|
||||
reader = bytes.NewReader(nil)
|
||||
}
|
||||
req := httptest.NewRequest(method, "/", reader)
|
||||
req.URL.RawQuery = query
|
||||
req.SetPathValue("vendor", "acme")
|
||||
req.SetPathValue("plugin", "demo")
|
||||
req.SetPathValue("controller", "records")
|
||||
if id != "" {
|
||||
req.SetPathValue("id", id)
|
||||
}
|
||||
if field != "" {
|
||||
req.SetPathValue("field", field)
|
||||
}
|
||||
if principal != nil {
|
||||
req = req.WithContext(bouncer.WithUser(req.Context(), principal))
|
||||
}
|
||||
return req
|
||||
}
|
||||
|
||||
func p10Save(svc *service, method, id string, body any) *httptest.ResponseRecorder {
|
||||
rec := httptest.NewRecorder()
|
||||
req := p10Request(method, id, "", "", body, p10Principal(true))
|
||||
switch method {
|
||||
case http.MethodPost:
|
||||
svc.create(rec, req)
|
||||
case http.MethodPut:
|
||||
svc.update(rec, req)
|
||||
case http.MethodGet:
|
||||
svc.show(rec, req)
|
||||
}
|
||||
return rec
|
||||
}
|
||||
|
||||
func p10Options(svc *service, field, query string, principal *bouncer.Principal) *httptest.ResponseRecorder {
|
||||
rec := httptest.NewRecorder()
|
||||
svc.fieldOptions(rec, p10Request(http.MethodGet, "", field, query, nil, principal))
|
||||
return rec
|
||||
}
|
||||
|
||||
type p10Envelope struct {
|
||||
Data map[string]any `json:"data"`
|
||||
Meta struct {
|
||||
Labels map[string][]RelationOption `json:"labels"`
|
||||
} `json:"meta"`
|
||||
}
|
||||
|
||||
func p10Decode(t *testing.T, rec *httptest.ResponseRecorder, status int) p10Envelope {
|
||||
t.Helper()
|
||||
if rec.Code != status {
|
||||
t.Fatalf("status=%d want %d body=%s", rec.Code, status, rec.Body.String())
|
||||
}
|
||||
var body p10Envelope
|
||||
dec := json.NewDecoder(bytes.NewReader(rec.Body.Bytes()))
|
||||
dec.UseNumber()
|
||||
if err := dec.Decode(&body); err != nil {
|
||||
t.Fatalf("decode %s: %v", rec.Body.String(), err)
|
||||
}
|
||||
if body.Meta.Labels == nil {
|
||||
t.Fatalf("meta.labels missing: %s", rec.Body.String())
|
||||
}
|
||||
return body
|
||||
}
|
||||
|
||||
func p10ID(v any) uint {
|
||||
n, ok := v.(json.Number)
|
||||
if !ok {
|
||||
return 0
|
||||
}
|
||||
i, err := n.Int64()
|
||||
if err != nil || i < 0 {
|
||||
return 0
|
||||
}
|
||||
return uint(i)
|
||||
}
|
||||
|
||||
func p10IDs(v any) []uint {
|
||||
items, ok := v.([]any)
|
||||
if !ok {
|
||||
return nil
|
||||
}
|
||||
out := make([]uint, 0, len(items))
|
||||
for _, item := range items {
|
||||
out = append(out, p10ID(item))
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
func p10Pivot(t *testing.T, db *gorm.DB, recordID uint) []uint {
|
||||
t.Helper()
|
||||
var rows []p10RecordTag
|
||||
if err := db.Where("record_id = ?", recordID).Order("position, tag_id").Find(&rows).Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
out := make([]uint, len(rows))
|
||||
for i, row := range rows {
|
||||
if row.Position != i {
|
||||
t.Fatalf("pivot positions=%+v", rows)
|
||||
}
|
||||
out[i] = row.TagID
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
func p10Stored(t *testing.T, db *gorm.DB, id uint) p10Record {
|
||||
t.Helper()
|
||||
var row p10Record
|
||||
if err := db.First(&row, id).Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return row
|
||||
}
|
||||
|
||||
func sameUintSeq(got, want []uint) bool {
|
||||
if len(got) != len(want) {
|
||||
return false
|
||||
}
|
||||
for i := range got {
|
||||
if got[i] != want[i] {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
func TestPhase10RelationOptions(t *testing.T) {
|
||||
svc, db, seed := p10Fixture(t)
|
||||
extra := []struct{ label, scope string }{
|
||||
{"alpha first", "visible"}, {"ALPHA second", "visible"}, {"alpha hidden", "hidden"},
|
||||
{"100%_off", "visible"}, {"100 off", "visible"}, {"same", "visible"}, {"same", "visible"},
|
||||
}
|
||||
ids := map[string][]uint{}
|
||||
for _, spec := range extra {
|
||||
label := spec.label
|
||||
tag := p10Tag{Label: &label, Scope: spec.scope}
|
||||
if err := db.Create(&tag).Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
ids[spec.label] = append(ids[spec.label], tag.ID)
|
||||
}
|
||||
for i := 0; i < 25; i++ {
|
||||
label := fmt.Sprintf("bulk %02d", i)
|
||||
if err := db.Create(&p10Tag{Label: &label, Scope: "visible"}).Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
if err := db.Create(&p10Tag{Scope: "visible"}).Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
visible := int64(3 + 6 + 25 + 1)
|
||||
|
||||
decode := func(rec *httptest.ResponseRecorder) ([]RelationOption, ListMeta) {
|
||||
t.Helper()
|
||||
if rec.Code != http.StatusOK {
|
||||
t.Fatalf("status=%d body=%s", rec.Code, rec.Body.String())
|
||||
}
|
||||
var body struct {
|
||||
Data []RelationOption `json:"data"`
|
||||
Meta ListMeta `json:"meta"`
|
||||
}
|
||||
dec := json.NewDecoder(bytes.NewReader(rec.Body.Bytes()))
|
||||
dec.DisallowUnknownFields()
|
||||
if err := dec.Decode(&body); err != nil {
|
||||
t.Fatalf("decode %s: %v", rec.Body.String(), err)
|
||||
}
|
||||
return body.Data, body.Meta
|
||||
}
|
||||
|
||||
all := p10Options(svc, "tags", "", p10Principal(true))
|
||||
rows, meta := decode(all)
|
||||
if meta.Page != 1 || meta.PerPage != 20 || meta.Total != visible || meta.LastPage != 2 || len(rows) != 20 {
|
||||
t.Fatalf("default page meta=%+v rows=%d", meta, len(rows))
|
||||
}
|
||||
if !strings.Contains(all.Body.String(), `"value":`) || strings.Contains(all.Body.String(), `"value":"`) {
|
||||
t.Fatalf("option values are not numbers: %s", all.Body.String())
|
||||
}
|
||||
// Label order follows the database collation; the "bulk NN" labels sort
|
||||
// the same under every collation.
|
||||
bulk, _ := decode(p10Options(svc, "tags", "search=bulk&per_page=100", p10Principal(true)))
|
||||
if len(bulk) != 25 {
|
||||
t.Fatalf("bulk rows=%d", len(bulk))
|
||||
}
|
||||
for i, row := range bulk {
|
||||
if row.Label != fmt.Sprintf("bulk %02d", i) {
|
||||
t.Fatalf("options not ordered by label: %+v", bulk)
|
||||
}
|
||||
}
|
||||
if rows[0].Label != "" {
|
||||
t.Fatalf("a null label must sort first as an empty string: %+v", rows[0])
|
||||
}
|
||||
for _, row := range rows {
|
||||
if strings.Contains(row.Label, "hidden") {
|
||||
t.Fatalf("scoped options leaked a hidden row: %+v", rows)
|
||||
}
|
||||
}
|
||||
page2, meta2 := decode(p10Options(svc, "tags", "page=2", p10Principal(true)))
|
||||
if meta2.Page != 2 || len(page2) != int(visible)-20 {
|
||||
t.Fatalf("page 2 meta=%+v rows=%d", meta2, len(page2))
|
||||
}
|
||||
big, bigMeta := decode(p10Options(svc, "tags", "per_page=100", p10Principal(true)))
|
||||
if bigMeta.PerPage != 100 || len(big) != int(visible) || bigMeta.LastPage != 1 {
|
||||
t.Fatalf("per_page=100 meta=%+v rows=%d", bigMeta, len(big))
|
||||
}
|
||||
|
||||
caseless, _ := decode(p10Options(svc, "tags", "search=Alpha", p10Principal(true)))
|
||||
if len(caseless) != 2 || caseless[0].Value != ids["ALPHA second"][0] && caseless[0].Value != ids["alpha first"][0] {
|
||||
t.Fatalf("case-insensitive search=%+v", caseless)
|
||||
}
|
||||
literal, _ := decode(p10Options(svc, "tags", "search=%25_", p10Principal(true)))
|
||||
if len(literal) != 1 || literal[0].Label != "100%_off" {
|
||||
t.Fatalf("LIKE metacharacters were not escaped: %+v", literal)
|
||||
}
|
||||
same, _ := decode(p10Options(svc, "tags", "search=same", p10Principal(true)))
|
||||
if len(same) != 2 || same[0].Value != ids["same"][0] || same[1].Value != ids["same"][1] {
|
||||
t.Fatalf("equal labels not ordered by id: %+v want %v", same, ids["same"])
|
||||
}
|
||||
groups, _ := decode(p10Options(svc, "group", "", p10Principal(true)))
|
||||
if len(groups) != 2 || groups[0].Value != seed.groups["Alpha"] || groups[0].Label != "Alpha" || groups[1].Label != "Beta" {
|
||||
t.Fatalf("group options=%+v", groups)
|
||||
}
|
||||
|
||||
for _, tc := range []struct{ query, field string }{
|
||||
{"per_page=101", "per_page"}, {"per_page=0", "per_page"}, {"page=0", "page"}, {"page=x", "page"},
|
||||
} {
|
||||
rec := p10Options(svc, "tags", tc.query, p10Principal(true))
|
||||
if rec.Code != http.StatusUnprocessableEntity || !strings.Contains(rec.Body.String(), `"`+tc.field+`"`) {
|
||||
t.Fatalf("%s status=%d body=%s", tc.query, rec.Code, rec.Body.String())
|
||||
}
|
||||
}
|
||||
for _, field := range []string{"name", "person", "nope", "Tags"} {
|
||||
rec := p10Options(svc, field, "", p10Principal(true))
|
||||
if rec.Code != http.StatusNotFound {
|
||||
t.Fatalf("field %s status=%d body=%s", field, rec.Code, rec.Body.String())
|
||||
}
|
||||
assertErrorCode(t, rec.Body.Bytes(), "not_found")
|
||||
if strings.Contains(rec.Body.String(), "admin@acme.test") {
|
||||
t.Fatalf("read-only options disclosed a label: %s", rec.Body.String())
|
||||
}
|
||||
}
|
||||
|
||||
// Permission is checked before any SQL: this service has no database, so
|
||||
// reaching a query would be a 500, not a 403.
|
||||
denied := &service{reg: svc.reg}
|
||||
rec := p10Options(denied, "tags", "search=one", p10Principal(false))
|
||||
if rec.Code != http.StatusForbidden {
|
||||
t.Fatalf("denied status=%d body=%s", rec.Code, rec.Body.String())
|
||||
}
|
||||
assertErrorCode(t, rec.Body.Bytes(), "forbidden")
|
||||
frontend := p10Principal(true)
|
||||
frontend.Backend = false
|
||||
rec = httptest.NewRecorder()
|
||||
req := p10Request(http.MethodGet, "", "tags", "", nil, nil)
|
||||
req = req.WithContext(bouncer.WithUser(req.Context(), frontend))
|
||||
denied.fieldOptions(rec, req)
|
||||
if rec.Code != http.StatusUnauthorized {
|
||||
t.Fatalf("frontend principal status=%d body=%s", rec.Code, rec.Body.String())
|
||||
}
|
||||
}
|
||||
|
||||
func TestPhase10RelationSave(t *testing.T) {
|
||||
svc, db, seed := p10Fixture(t)
|
||||
one, two, three := seed.tags["one"], seed.tags["two"], seed.tags["three"]
|
||||
alpha, beta := seed.groups["Alpha"], seed.groups["Beta"]
|
||||
|
||||
created := p10Decode(t, p10Save(svc, http.MethodPost, "", map[string]any{
|
||||
"name": "record", "group": alpha, "tags": []uint{three, one}, "person": 99, "user_id": 99,
|
||||
}), http.StatusCreated)
|
||||
id := p10ID(created.Data["id"])
|
||||
if p10ID(created.Data["group"]) != alpha || !sameUintSeq(p10IDs(created.Data["tags"]), []uint{three, one}) {
|
||||
t.Fatalf("created data=%v", created.Data)
|
||||
}
|
||||
if p10ID(created.Data["person"]) != seed.person {
|
||||
t.Fatalf("read-only person value=%v want %d", created.Data["person"], seed.person)
|
||||
}
|
||||
if _, leaked := created.Data["user_id"]; leaked {
|
||||
t.Fatalf("protected foreign key leaked: %v", created.Data)
|
||||
}
|
||||
labels := created.Meta.Labels
|
||||
if len(labels["group"]) != 1 || labels["group"][0] != (RelationOption{Value: alpha, Label: "Alpha"}) {
|
||||
t.Fatalf("group labels=%+v", labels["group"])
|
||||
}
|
||||
if len(labels["tags"]) != 2 || labels["tags"][0] != (RelationOption{Value: three, Label: "three"}) || labels["tags"][1].Value != one {
|
||||
t.Fatalf("tag labels=%+v", labels["tags"])
|
||||
}
|
||||
if len(labels["person"]) != 1 || labels["person"][0] != (RelationOption{Value: seed.person, Label: "admin@acme.test"}) {
|
||||
t.Fatalf("person labels=%+v", labels["person"])
|
||||
}
|
||||
stored := p10Stored(t, db, id)
|
||||
if stored.GroupID == nil || *stored.GroupID != alpha || stored.UserID != seed.person {
|
||||
t.Fatalf("stored=%+v", stored)
|
||||
}
|
||||
if got := p10Pivot(t, db, id); !sameUintSeq(got, []uint{three, one}) {
|
||||
t.Fatalf("pivot=%v", got)
|
||||
}
|
||||
|
||||
idText := fmt.Sprintf("%d", id)
|
||||
p10Decode(t, p10Save(svc, http.MethodPut, idText, map[string]any{"name": "renamed"}), http.StatusOK)
|
||||
stored = p10Stored(t, db, id)
|
||||
if stored.Name != "renamed" || stored.GroupID == nil || *stored.GroupID != alpha {
|
||||
t.Fatalf("absent keys changed the relation: %+v", stored)
|
||||
}
|
||||
if got := p10Pivot(t, db, id); !sameUintSeq(got, []uint{three, one}) {
|
||||
t.Fatalf("absent key changed the pivot: %v", got)
|
||||
}
|
||||
|
||||
cleared := p10Decode(t, p10Save(svc, http.MethodPut, idText, map[string]any{"name": "renamed", "group": nil, "tags": []uint{two, one}}), http.StatusOK)
|
||||
if cleared.Data["group"] != nil || len(cleared.Meta.Labels["group"]) != 0 || cleared.Meta.Labels["group"] == nil {
|
||||
t.Fatalf("cleared group data=%v labels=%v", cleared.Data["group"], cleared.Meta.Labels)
|
||||
}
|
||||
if stored := p10Stored(t, db, id); stored.GroupID != nil {
|
||||
t.Fatalf("null did not clear group_id: %+v", stored)
|
||||
}
|
||||
if got := p10Pivot(t, db, id); !sameUintSeq(got, []uint{two, one}) {
|
||||
t.Fatalf("replaced pivot=%v", got)
|
||||
}
|
||||
|
||||
p10Decode(t, p10Save(svc, http.MethodPut, idText, map[string]any{"name": "renamed", "group": beta}), http.StatusOK)
|
||||
shown := p10Decode(t, p10Save(svc, http.MethodGet, idText, nil), http.StatusOK)
|
||||
if p10ID(shown.Data["group"]) != beta || !sameUintSeq(p10IDs(shown.Data["tags"]), []uint{two, one}) {
|
||||
t.Fatalf("show data=%v", shown.Data)
|
||||
}
|
||||
if len(shown.Meta.Labels["tags"]) != 2 || shown.Meta.Labels["tags"][0].Label != "two" || shown.Meta.Labels["group"][0].Label != "Beta" {
|
||||
t.Fatalf("show labels=%+v", shown.Meta.Labels)
|
||||
}
|
||||
|
||||
emptied := p10Decode(t, p10Save(svc, http.MethodPut, idText, map[string]any{"name": "renamed", "tags": []uint{}}), http.StatusOK)
|
||||
if tags, ok := emptied.Data["tags"].([]any); !ok || len(tags) != 0 {
|
||||
t.Fatalf("emptied tags=%#v", emptied.Data["tags"])
|
||||
}
|
||||
if got := p10Pivot(t, db, id); len(got) != 0 {
|
||||
t.Fatalf("empty list left pivot rows %v", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestPhase10RelationForgedID(t *testing.T) {
|
||||
svc, db, seed := p10Fixture(t)
|
||||
one := seed.tags["one"]
|
||||
created := p10Decode(t, p10Save(svc, http.MethodPost, "", map[string]any{"name": "keep", "group": seed.groups["Alpha"], "tags": []uint{one}}), http.StatusCreated)
|
||||
id := p10ID(created.Data["id"])
|
||||
idText := fmt.Sprintf("%d", id)
|
||||
|
||||
for _, tc := range []struct {
|
||||
name string
|
||||
body map[string]any
|
||||
field string
|
||||
}{
|
||||
{"out of scope tag", map[string]any{"tags": []uint{seed.tags["hidden"]}}, "tags"},
|
||||
{"unknown tag", map[string]any{"tags": []uint{999999}}, "tags"},
|
||||
{"text tag", map[string]any{"tags": []any{"x"}}, "tags"},
|
||||
{"fractional tag", map[string]any{"tags": []any{1.5}}, "tags"},
|
||||
{"negative tag", map[string]any{"tags": []any{-1}}, "tags"},
|
||||
{"duplicate tag", map[string]any{"tags": []uint{one, one}}, "tags"},
|
||||
{"scalar for many", map[string]any{"tags": one}, "tags"},
|
||||
{"out of scope group", map[string]any{"group": seed.groups["Hidden"]}, "group"},
|
||||
{"list for one", map[string]any{"group": []uint{seed.groups["Beta"]}}, "group"},
|
||||
{"text group", map[string]any{"group": "abc"}, "group"},
|
||||
} {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
body := map[string]any{"name": "changed"}
|
||||
for key, value := range tc.body {
|
||||
body[key] = value
|
||||
}
|
||||
rec := p10Save(svc, http.MethodPut, idText, body)
|
||||
if rec.Code != http.StatusUnprocessableEntity {
|
||||
t.Fatalf("status=%d body=%s", rec.Code, rec.Body.String())
|
||||
}
|
||||
assertErrorCode(t, rec.Body.Bytes(), "validation_failed")
|
||||
var envelope struct {
|
||||
Error struct {
|
||||
Details map[string][]string `json:"details"`
|
||||
} `json:"error"`
|
||||
}
|
||||
if err := json.Unmarshal(rec.Body.Bytes(), &envelope); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if len(envelope.Error.Details[tc.field]) == 0 {
|
||||
t.Fatalf("details missing %s: %s", tc.field, rec.Body.String())
|
||||
}
|
||||
stored := p10Stored(t, db, id)
|
||||
if stored.Name != "keep" || stored.GroupID == nil || *stored.GroupID != seed.groups["Alpha"] {
|
||||
t.Fatalf("rejected save committed: %+v", stored)
|
||||
}
|
||||
if got := p10Pivot(t, db, id); !sameUintSeq(got, []uint{one}) {
|
||||
t.Fatalf("rejected save changed the pivot: %v", got)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
var before int64
|
||||
if err := db.Model(&p10Record{}).Count(&before).Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
rec := p10Save(svc, http.MethodPost, "", map[string]any{"name": "forged", "tags": []uint{one, seed.tags["hidden"]}})
|
||||
if rec.Code != http.StatusUnprocessableEntity {
|
||||
t.Fatalf("forged create status=%d body=%s", rec.Code, rec.Body.String())
|
||||
}
|
||||
var after int64
|
||||
if err := db.Model(&p10Record{}).Count(&after).Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
var pivots int64
|
||||
if err := db.Model(&p10RecordTag{}).Count(&pivots).Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if after != before || pivots != 1 {
|
||||
t.Fatalf("forged create committed rows=%d->%d pivots=%d", before, after, pivots)
|
||||
}
|
||||
}
|
||||
|
||||
func TestPhase10RelationBoot(t *testing.T) {
|
||||
reg, err := p10Compile(p10Controller{})
|
||||
if err != nil {
|
||||
t.Fatalf("valid contracts: %v", err)
|
||||
}
|
||||
cc, _ := reg.Get("acme.demo.records")
|
||||
raw, err := json.Marshal(cc.Form.Fields)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
fields := map[string]map[string]any{}
|
||||
var list []map[string]any
|
||||
if err := json.Unmarshal(raw, &list); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
for _, field := range list {
|
||||
fields[field["name"].(string)] = field
|
||||
}
|
||||
if fields["tags"]["multiple"] != true || fields["tags"]["readOnly"] != nil {
|
||||
t.Fatalf("tags field=%v", fields["tags"])
|
||||
}
|
||||
if fields["group"]["multiple"] != nil || fields["group"]["readOnly"] != nil {
|
||||
t.Fatalf("group field=%v", fields["group"])
|
||||
}
|
||||
if fields["person"]["readOnly"] != true || fields["person"]["multiple"] != nil {
|
||||
t.Fatalf("person field=%v", fields["person"])
|
||||
}
|
||||
|
||||
for _, tc := range []struct {
|
||||
name string
|
||||
mutate func([]FieldRelationContract) []FieldRelationContract
|
||||
want []string
|
||||
}{
|
||||
{"missing contract", func(in []FieldRelationContract) []FieldRelationContract { return in[1:] }, []string{"field group", "no relation contract"}},
|
||||
{"missing foreign key column", func(in []FieldRelationContract) []FieldRelationContract {
|
||||
in[0].ForeignKey = "missing_id"
|
||||
return in
|
||||
}, []string{"field group", "missing_id"}},
|
||||
{"missing pivot column", func(in []FieldRelationContract) []FieldRelationContract {
|
||||
in[1].OrderColumn = "rank"
|
||||
return in
|
||||
}, []string{"field tags", "rank"}},
|
||||
{"missing label column", func(in []FieldRelationContract) []FieldRelationContract {
|
||||
in[2].LabelColumn = "username"
|
||||
return in
|
||||
}, []string{"field person", "username"}},
|
||||
{"unknown kind", func(in []FieldRelationContract) []FieldRelationContract {
|
||||
in[0].Kind = "hasMany"
|
||||
return in
|
||||
}, []string{"field group", "unknown relation kind hasMany"}},
|
||||
{"missing related model", func(in []FieldRelationContract) []FieldRelationContract {
|
||||
in[0].NewRelated = nil
|
||||
return in
|
||||
}, []string{"field group", "related model"}},
|
||||
{"duplicate contract", func(in []FieldRelationContract) []FieldRelationContract { return append(in, in[0]) }, []string{"field group", "duplicate"}},
|
||||
{"orphan contract", func(in []FieldRelationContract) []FieldRelationContract {
|
||||
return append(in, FieldRelationContract{Field: "extra", Kind: "belongsTo", NewRelated: func() any { return &p10Group{} }, ForeignKey: "group_id"})
|
||||
}, []string{"field extra", "not a relation field"}},
|
||||
} {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
_, err := p10Compile(p10Controller{mutate: tc.mutate})
|
||||
if err == nil {
|
||||
t.Fatal("activation accepted a broken relation contract")
|
||||
}
|
||||
for _, want := range append([]string{"acme.demo", "acme.demo.records"}, tc.want...) {
|
||||
if !strings.Contains(err.Error(), want) {
|
||||
t.Fatalf("err=%v missing %q", err, want)
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
_, err = compileRegistry([]controllerRef{{plugin: formPlugin{fsys: p10FS()}, ctl: crudControllerLike{}}})
|
||||
if err == nil || !strings.Contains(err.Error(), "field group") || !strings.Contains(err.Error(), "AdminFieldRelations") {
|
||||
t.Fatalf("controller without contracts err=%v", err)
|
||||
}
|
||||
}
|
||||
|
||||
// crudControllerLike has the relation form but declares no contracts.
|
||||
type crudControllerLike struct{}
|
||||
|
||||
func (crudControllerLike) ID() string { return "acme.demo.records" }
|
||||
func (crudControllerLike) ModelName() string { return "Record" }
|
||||
func (crudControllerLike) ConfigDir() string { return "controllers/records" }
|
||||
func (crudControllerLike) NewRecord() any { return &p10Record{} }
|
||||
|
||||
func TestPhase10NestedGetDispatch(t *testing.T) {
|
||||
svc, _, seed := p10Fixture(t)
|
||||
call := func(id, segment, name string) *httptest.ResponseRecorder {
|
||||
req := p10Request(http.MethodGet, id, "", "", nil, p10Principal(true))
|
||||
req.SetPathValue("segment", segment)
|
||||
req.SetPathValue("name", name)
|
||||
rec := httptest.NewRecorder()
|
||||
svc.nestedGet(rec, req)
|
||||
return rec
|
||||
}
|
||||
options := call("fields", "group", "options")
|
||||
if options.Code != http.StatusOK || !strings.Contains(options.Body.String(), fmt.Sprintf(`"value":%d`, seed.groups["Alpha"])) {
|
||||
t.Fatalf("fields dispatch status=%d body=%s", options.Code, options.Body.String())
|
||||
}
|
||||
for _, tc := range [][3]string{{"fields", "group", "choices"}, {"5", "other", "x"}, {"filters", "group", "list"}} {
|
||||
rec := call(tc[0], tc[1], tc[2])
|
||||
if rec.Code != http.StatusNotFound {
|
||||
t.Fatalf("%v status=%d body=%s", tc, rec.Code, rec.Body.String())
|
||||
}
|
||||
assertErrorCode(t, rec.Body.Bytes(), "not_found")
|
||||
}
|
||||
}
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user