@x47base/pocketbase-addon 0.1.0

package/edge/policy.go

@@ -0,0 +1,150 @@
+// Package edge rejects public requests before they reach PocketBase.
+package edge
+
+import (
+	"encoding/json"
+	"errors"
+	"io"
+	"net/netip"
+	"os"
+	"strings"
+	"time"
+
+	"github.com/spink-dev/pocketbase-extension/security"
+)
+
+type Policy struct {
+	Collections      []string `json:"collections"`
+	BlockedCIDRs     []string `json:"blockedCIDRs"`
+	BlockedPaths     []string `json:"blockedPaths"`
+	TrustedProxies   []string `json:"trustedProxies"`
+	Rate             int      `json:"rate"`
+	Burst            int      `json:"burst"`
+	ClientRate       int      `json:"clientRate"`
+	ClientBurst      int      `json:"clientBurst"`
+	MaxClients       int      `json:"maxClients"`
+	MaxConcurrent    int      `json:"maxConcurrent"`
+	MaxBodyBytes     int64    `json:"maxBodyBytes"`
+	blocked, trusted []netip.Prefix
+}
+
+func (p *Policy) Validate() error {
+	if p.Rate < 1 || p.Rate > 100000 || p.Burst < 1 || p.Burst > 100000 || p.ClientRate < 1 || p.ClientRate > 10000 || p.ClientBurst < 1 || p.ClientBurst > 10000 || p.MaxClients < 1 || p.MaxClients > 100000 || p.MaxConcurrent < 1 || p.MaxConcurrent > 1024 || p.MaxBodyBytes < 1 || p.MaxBodyBytes > 32<<20 {
+		return errors.New("invalid edge limits")
+	}
+	if int64(p.MaxConcurrent)*p.MaxBodyBytes > 128<<20 {
+		return errors.New("body buffering budget exceeds 128 MiB")
+	}
+	if len(p.Collections) > 256 || len(p.BlockedPaths) > 256 {
+		return errors.New("too many rules")
+	}
+	for _, c := range p.Collections {
+		if c == "" || len(c) > 128 || c == "_superusers" || c == "pbc_3142635823" || strings.ContainsAny(c, "/%\\. \t\r\n") {
+			return errors.New("invalid public collection")
+		}
+	}
+	for _, path := range p.BlockedPaths {
+		if !strings.HasPrefix(path, "/") || len(path) > 1024 {
+			return errors.New("invalid blocked path")
+		}
+	}
+	var err error
+	if p.blocked, err = prefixes(p.BlockedCIDRs); err != nil {
+		return err
+	}
+	p.trusted, err = prefixes(p.TrustedProxies)
+	return err
+}
+func prefixes(values []string) ([]netip.Prefix, error) {
+	if len(values) > 256 {
+		return nil, errors.New("too many CIDRs")
+	}
+	result := make([]netip.Prefix, 0, len(values))
+	for _, v := range values {
+		p, e := netip.ParsePrefix(v)
+		if e != nil {
+			return nil, e
+		}
+		result = append(result, p)
+	}
+	return result, nil
+}
+func contains(list []netip.Prefix, ip netip.Addr) bool {
+	for _, p := range list {
+		if p.Contains(ip) {
+			return true
+		}
+	}
+	return false
+}
+func readJSON(path string, dest any, strict bool) error {
+	f, err := os.Open(path)
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+	b, err := io.ReadAll(io.LimitReader(f, (1<<20)+1))
+	if err != nil {
+		return err
+	}
+	if len(b) > 1<<20 {
+		return errors.New("configuration too large")
+	}
+	d := json.NewDecoder(strings.NewReader(string(b)))
+	if strict {
+		d.DisallowUnknownFields()
+	}
+	if err = d.Decode(dest); err != nil {
+		return err
+	}
+	if d.Decode(new(any)) != io.EOF {
+		return errors.New("trailing configuration data")
+	}
+	return nil
+}
+func LoadPolicy(path string) (Policy, error) {
+	var p Policy
+	err := readJSON(path, &p, true)
+	if err == nil {
+		err = p.Validate()
+	}
+	return p, err
+}
+
+type Snapshot struct {
+	Version  int                        `json:"version"`
+	Revision uint64                     `json:"revision"`
+	Policy   security.Config            `json:"policy"`
+	Actions  map[string]security.Action `json:"actions"`
+}
+
+func LoadSnapshot(path string) (Snapshot, error) {
+	var s Snapshot
+	info, err := os.Stat(path)
+	if err != nil {
+		return s, err
+	}
+	if time.Since(info.ModTime()) > 30*time.Second {
+		return s, errors.New("security checkpoint is stale")
+	}
+	if err := readJSON(path, &s, false); err != nil {
+		return s, err
+	}
+	if s.Version != 1 || s.Revision == 0 || len(s.Actions) > 6 {
+		return s, errors.New("invalid security checkpoint")
+	}
+	if err := s.Policy.Validate(); err != nil {
+		return s, err
+	}
+	for key, a := range s.Actions {
+		switch key {
+		case "auth", "reads", "writes", "files", "realtime", "other":
+		default:
+			return s, errors.New("invalid action family")
+		}
+		if key != a.Family || len(a.Reason) > 200 || a.ExpiresAt.IsZero() || a.ExpiresAt.After(time.Now().Add(15*time.Minute)) {
+			return s, errors.New("invalid action")
+		}
+	}
+	return s, nil
+}

package/features/collection_singleton.go

@@ -0,0 +1,13 @@
+package features
+
+import "github.com/pocketbase/pocketbase/core"
+
+const SingletonRecordID = "singleton000001"
+
+func NewSingletonCollection(name string, optId ...string) *core.Collection {
+	collection := core.NewBaseCollection(name, optId...)
+	field := collection.Fields.GetByName(core.FieldNameId).(*core.TextField)
+	field.Pattern = "^" + SingletonRecordID + "$"
+	field.AutogeneratePattern = SingletonRecordID
+	return collection
+}

package/features/collection_singleton_test.go

@@ -0,0 +1,46 @@
+package features_test
+
+import (
+	"github.com/pocketbase/pocketbase/core"
+	"github.com/pocketbase/pocketbase/tests"
+	"github.com/spink-dev/pocketbase-extension/features"
+	"testing"
+)
+
+func TestSingletonCollection(t *testing.T) {
+	app, err := tests.NewTestApp()
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer app.Cleanup()
+	c := features.NewSingletonCollection("homepage")
+	c.Fields.Add(&core.TextField{Name: "title", Required: true})
+	if err := app.Save(c); err != nil {
+		t.Fatal(err)
+	}
+	invalid := core.NewRecord(c)
+	if err := app.Save(invalid); err == nil {
+		t.Fatal("created invalid placeholder")
+	}
+	first := core.NewRecord(c)
+	first.Set("title", "Home")
+	if err := app.Save(first); err != nil {
+		t.Fatal(err)
+	}
+	if first.Id != features.SingletonRecordID {
+		t.Fatal("wrong id")
+	}
+	second := core.NewRecord(c)
+	second.Set("title", "Second")
+	if err := app.Save(second); err == nil {
+		t.Fatal("accepted second record")
+	}
+	second.Id = "another00000001"
+	if err := app.Save(second); err == nil {
+		t.Fatal("accepted different id")
+	}
+	first.Set("title", "Updated")
+	if err := app.Save(first); err != nil {
+		t.Fatal(err)
+	}
+}

package/features/dimensions_test.go

@@ -0,0 +1,65 @@
+package features_test
+
+import (
+	"bytes"
+	"github.com/pocketbase/pocketbase/apis"
+	"github.com/pocketbase/pocketbase/core"
+	"github.com/pocketbase/pocketbase/tests"
+	"github.com/pocketbase/pocketbase/tools/filesystem"
+	"github.com/pocketbase/pocketbase/tools/types"
+	"github.com/spink-dev/pocketbase-extension/features"
+	"image"
+	"image/png"
+	"net/http/httptest"
+	"testing"
+)
+
+func TestFileDimensions(t *testing.T) {
+	app, err := tests.NewTestApp()
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer app.Cleanup()
+	c := core.NewBaseCollection("dimensions_test")
+	c.ViewRule = types.Pointer("")
+	c.Fields.Add(&core.FileField{Name: "image", MaxSelect: 1, Protected: true})
+	if err := app.Save(c); err != nil {
+		t.Fatal(err)
+	}
+	var buffer bytes.Buffer
+	if err := png.Encode(&buffer, image.NewRGBA(image.Rect(0, 0, 20, 10))); err != nil {
+		t.Fatal(err)
+	}
+	file, err := filesystem.NewFileFromBytes(buffer.Bytes(), "image.png")
+	if err != nil {
+		t.Fatal(err)
+	}
+	record := core.NewRecord(c)
+	record.Set("image", file)
+	if err := app.Save(record); err != nil {
+		t.Fatal(err)
+	}
+	features.Register(app)
+	router, _ := apis.NewRouter(app)
+	handler, err := router.BuildMux()
+	if err != nil {
+		t.Fatal(err)
+	}
+	path := "/api/files/" + c.Id + "/" + record.Id + "/" + record.GetString("image")
+	for _, method := range []string{"GET", "HEAD"} {
+		w := httptest.NewRecorder()
+		handler.ServeHTTP(w, httptest.NewRequest(method, path+"?dimensions=1", nil))
+		if w.Code != 200 || w.Header().Get("X-Image-Width") != "20" || w.Header().Get("X-Image-Height") != "10" {
+			t.Fatalf("missing dimensions %d", w.Code)
+		}
+	}
+	c.ViewRule = nil
+	if err := app.Save(c); err != nil {
+		t.Fatal(err)
+	}
+	w := httptest.NewRecorder()
+	handler.ServeHTTP(w, httptest.NewRequest("GET", path+"?dimensions=1", nil))
+	if w.Code == 200 || w.Header().Get("X-Image-Width") != "" {
+		t.Fatal("metadata leaked without file access")
+	}
+}

package/features/duplicate.go

@@ -0,0 +1,178 @@
+package features
+
+import (
+	"bytes"
+	"encoding/json"
+	"github.com/pocketbase/pocketbase/core"
+	"github.com/pocketbase/pocketbase/tools/filesystem"
+	"io"
+	"mime/multipart"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"sync"
+)
+
+const maxDuplicateBytes = 32 << 20
+
+func registerDuplicate(app core.App) {
+	app.OnServe().BindFunc(func(se *core.ServeEvent) error {
+		var once sync.Once
+		var handler http.Handler
+		var buildErr error
+		se.Router.POST("/api/collections/{collection}/records/{id}/duplicate", func(e *core.RequestEvent) error {
+			once.Do(func() { handler, buildErr = se.Router.BuildMux() })
+			if buildErr != nil {
+				return buildErr
+			}
+			collection, err := e.App.FindCachedCollectionByNameOrId(e.Request.PathValue("collection"))
+			if err != nil || !collection.IsBase() {
+				return e.BadRequestError("Only base collections support duplication", nil)
+			}
+			path := "/api/collections/" + collection.Id + "/records/" + e.Request.PathValue("id")
+			view := e.Request.Clone(e.Request.Context())
+			u := *view.URL
+			view.URL = &u
+			view.Method = "GET"
+			view.URL.Path = path
+			view.URL.RawQuery = ""
+			view.Body = http.NoBody
+			view.ContentLength = 0
+			check := httptest.NewRecorder()
+			handler.ServeHTTP(check, view)
+			if check.Code == 403 || check.Code == 404 {
+				return e.NotFoundError("Source unavailable", nil)
+			}
+			if check.Code != 200 {
+				return e.Blob(check.Code, "application/json", check.Body.Bytes())
+			}
+			source, err := e.App.FindRecordById(collection, e.Request.PathValue("id"))
+			if err != nil {
+				return e.NotFoundError("Missing source", err)
+			}
+			info, err := e.RequestInfo()
+			if err != nil {
+				return err
+			}
+			allowed, err := e.App.CanAccessRecord(source, info, collection.ViewRule)
+			if err != nil || !allowed {
+				return e.NotFoundError("Source unavailable", nil)
+			}
+			overrides := map[string]any{}
+			if e.Request.ContentLength != 0 {
+				if err = e.BindBody(&overrides); err != nil {
+					return e.BadRequestError("Invalid overrides", err)
+				}
+			}
+			var buf bytes.Buffer
+			writer := multipart.NewWriter(&buf)
+			var fs *filesystem.System
+			defer func() {
+				if fs != nil {
+					fs.Close()
+				}
+			}()
+			for _, field := range collection.Fields {
+				name := field.GetName()
+				if name == core.FieldNameId || field.Type() == core.FieldTypeAutodate || field.GetHidden() && !info.HasSuperuserAuth() {
+					continue
+				}
+				value, overridden := overrides[name]
+				if f, ok := field.(*core.FileField); ok && !overridden {
+					names := source.GetStringSlice(name)
+					if len(names) == 0 {
+						continue
+					}
+					if f.Protected {
+						protected := info.Clone()
+						protected.Context = core.RequestInfoContextProtectedFile
+						ok, err := e.App.CanAccessRecord(source, protected, collection.ViewRule)
+						if err != nil || !ok {
+							return e.NotFoundError("Source attachment unavailable", nil)
+						}
+					}
+					if fs == nil {
+						fs, err = e.App.NewFilesystem()
+						if err != nil {
+							return err
+						}
+						fs.SetContext(e.Request.Context())
+					}
+					for _, filename := range names {
+						file, err := fs.GetReuploadableFile(source.BaseFilesPath()+"/"+filename, true)
+						if err != nil {
+							return err
+						}
+						part, err := writer.CreateFormFile(name, file.OriginalName)
+						if err != nil {
+							return err
+						}
+						r, err := file.Reader.Open()
+						if err != nil {
+							return err
+						}
+						_, err = io.Copy(part, io.LimitReader(r, int64(maxDuplicateBytes-buf.Len()+1)))
+						r.Close()
+						if err != nil {
+							return err
+						}
+						if buf.Len() > maxDuplicateBytes {
+							return e.Error(413, "Duplicate exceeds 32 MiB", nil)
+						}
+					}
+					continue
+				}
+				if !overridden {
+					value = source.GetRaw(name)
+				}
+				text, ok := value.(string)
+				if !ok {
+					raw, err := json.Marshal(value)
+					if err != nil {
+						return err
+					}
+					text = string(raw)
+				}
+				if len(text)+buf.Len() > maxDuplicateBytes {
+					return e.Error(413, "Duplicate exceeds 32 MiB", nil)
+				}
+				if err = writer.WriteField(name, text); err != nil {
+					return err
+				}
+			}
+			// Preserve modifier overrides such as relation additions for the native create pipeline.
+			for k, v := range overrides {
+				if collection.Fields.GetByName(k) != nil {
+					continue
+				}
+				if strings.ContainsAny(k, "+-") {
+					raw, _ := json.Marshal(v)
+					if len(raw)+buf.Len() > maxDuplicateBytes {
+						return e.Error(413, "Duplicate exceeds 32 MiB", nil)
+					}
+					if err = writer.WriteField(k, string(raw)); err != nil {
+						return err
+					}
+				}
+			}
+			if err = writer.Close(); err != nil {
+				return err
+			}
+			req := e.Request.Clone(e.Request.Context())
+			url := *req.URL
+			req.URL = &url
+			req.URL.Path = "/api/collections/" + collection.Id + "/records"
+			req.Header = req.Header.Clone()
+			req.Header.Set("Content-Type", writer.FormDataContentType())
+			req.Body = io.NopCloser(bytes.NewReader(buf.Bytes()))
+			req.ContentLength = int64(buf.Len())
+			req.GetBody = nil
+			req.Form = nil
+			req.PostForm = nil
+			req.MultipartForm = nil
+			handler.ServeHTTP(e.Response, req)
+			return nil
+		})
+		return se.Next()
+	})
+}

package/features/duplicate_test.go

@@ -0,0 +1,128 @@
+package features_test
+
+import (
+	"encoding/json"
+	"github.com/pocketbase/pocketbase/apis"
+	"github.com/pocketbase/pocketbase/core"
+	"github.com/pocketbase/pocketbase/tests"
+	"github.com/pocketbase/pocketbase/tools/filesystem"
+	"github.com/pocketbase/pocketbase/tools/types"
+	"github.com/spink-dev/pocketbase-extension/features"
+	"io"
+	"net/http/httptest"
+	"strings"
+	"testing"
+)
+
+func TestRecordDuplicate(t *testing.T) {
+	app, err := tests.NewTestApp()
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer app.Cleanup()
+	c := core.NewBaseCollection("duplicate_test")
+	c.ViewRule = types.Pointer("")
+	c.CreateRule = types.Pointer(`title != "denied"`)
+	c.Fields.Add(&core.TextField{Name: "title"}, &core.FileField{Name: "attachment", MaxSelect: 2, Protected: true}, &core.TextField{Name: "secret", Hidden: true})
+	if err := app.Save(c); err != nil {
+		t.Fatal(err)
+	}
+	file, err := filesystem.NewFileFromBytes([]byte("attachment contents"), "sample.txt")
+	if err != nil {
+		t.Fatal(err)
+	}
+	source := core.NewRecord(c)
+	source.Set("title", "original")
+	source.Set("attachment", file)
+	source.Set("secret", "private")
+	if err := app.Save(source); err != nil {
+		t.Fatal(err)
+	}
+	features.Register(app)
+	r, _ := apis.NewRouter(app)
+	if err := app.OnServe().Trigger(&core.ServeEvent{App: app, Router: r}); err != nil {
+		t.Fatal(err)
+	}
+	r.BindFunc(func(e *core.RequestEvent) error {
+		err := e.Next()
+		if err != nil {
+			t.Logf("route error: %+v", err)
+		}
+		return err
+	})
+	handler, err := r.BuildMux()
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, tc := range []struct {
+		body   string
+		status int
+	}{{`{"title":"copy"}`, 200}, {`{"title":"denied"}`, 400}} {
+		req := httptest.NewRequest("POST", "/api/collections/"+c.Id+"/records/"+source.Id+"/duplicate", strings.NewReader(tc.body))
+		req.Header.Set("Content-Type", "application/json")
+		w := httptest.NewRecorder()
+		handler.ServeHTTP(w, req)
+		if w.Code != tc.status {
+			t.Fatalf("expected %d got %d: %s", tc.status, w.Code, w.Body.String())
+		}
+		if tc.status == 200 {
+			var data struct {
+				Id         string
+				Attachment []string
+				Secret     string
+			}
+			if err := json.Unmarshal(w.Body.Bytes(), &data); err != nil {
+				t.Fatal(err)
+			}
+			if data.Id == source.Id || data.Secret != "" || len(data.Attachment) != 1 {
+				t.Fatalf("invalid duplicate response: %+v source=%v", data, source.GetStringSlice("attachment"))
+			}
+			copy, err := app.FindRecordById(c, data.Id)
+			if err != nil {
+				t.Fatal(err)
+			}
+			fsys, err := app.NewFilesystem()
+			if err != nil {
+				t.Fatal(err)
+			}
+			exists, err := fsys.Exists(copy.BaseFilesPath() + "/" + data.Attachment[0])
+			reader, readErr := fsys.GetReader(copy.BaseFilesPath() + "/" + data.Attachment[0])
+			if readErr != nil {
+				t.Fatal(readErr)
+			}
+			contents, _ := io.ReadAll(reader)
+			reader.Close()
+			if string(contents) != "attachment contents" {
+				t.Fatal("copied attachment contents differ")
+			}
+			fsys.Close()
+			if err != nil || !exists {
+				t.Fatal("missing copied file")
+			}
+		}
+	}
+	c.ViewRule = types.Pointer(`@request.context != "protectedFile"`)
+	if err := app.Save(c); err != nil {
+		t.Fatal(err)
+	}
+	protectedReq := httptest.NewRequest("POST", "/api/collections/"+c.Id+"/records/"+source.Id+"/duplicate", nil)
+	protectedWriter := httptest.NewRecorder()
+	handler.ServeHTTP(protectedWriter, protectedReq)
+	if protectedWriter.Code != 404 {
+		t.Fatalf("protected attachment rule bypass: %d", protectedWriter.Code)
+	}
+	c.ViewRule = nil
+	if err := app.Save(c); err != nil {
+		t.Fatal(err)
+	}
+	req := httptest.NewRequest("POST", "/api/collections/"+c.Id+"/records/"+source.Id+"/duplicate", nil)
+	w := httptest.NewRecorder()
+	handler.ServeHTTP(w, req)
+	if w.Code != 404 {
+		t.Fatalf("view rule bypass: %d", w.Code)
+	}
+	count, err := app.CountRecords(c.Id)
+	if err != nil || count != 2 {
+		t.Fatalf("unexpected record count %d %v", count, err)
+	}
+}

package/features/field_color.go

@@ -0,0 +1,46 @@
+package features
+
+import (
+	"context"
+	"errors"
+	validation "github.com/pocketbase/ozzo-validation/v4"
+	"github.com/pocketbase/pocketbase/core"
+	"github.com/spf13/cast"
+	"regexp"
+	"strings"
+)
+
+const FieldTypeColor = "color"
+
+var colorPattern = regexp.MustCompile(`^#(?:[0-9a-f]{3}|[0-9a-f]{4}|[0-9a-f]{6}|[0-9a-f]{8})$`)
+
+type ColorField struct{ core.TextField }
+
+func init()                        { core.Fields[FieldTypeColor] = func() core.Field { return &ColorField{} } }
+func (f *ColorField) Type() string { return FieldTypeColor }
+func (f *ColorField) PrepareValue(_ *core.Record, raw any) (any, error) {
+	return strings.ToLower(cast.ToString(raw)), nil
+}
+func (f *ColorField) ValidateValue(ctx context.Context, app core.App, r *core.Record) error {
+	if err := f.TextField.ValidateValue(ctx, app, r); err != nil {
+		return err
+	}
+	value := r.GetString(f.Name)
+	if value != "" && !colorPattern.MatchString(value) {
+		return validation.NewError("validation_color", "Must be a hex color (#RGB, #RGBA, #RRGGBB or #RRGGBBAA)")
+	}
+	return nil
+}
+func (f *ColorField) ValidateSettings(ctx context.Context, app core.App, c *core.Collection) error {
+	if f.PrimaryKey || f.AutogeneratePattern != "" {
+		return errors.New("color fields cannot be primary keys or autogenerated")
+	}
+	return f.TextField.ValidateSettings(ctx, app, c)
+}
+
+func (f *ColorField) FindSetter(key string) core.SetterFunc {
+	if key != f.Name {
+		return nil
+	}
+	return func(r *core.Record, raw any) { value, _ := f.PrepareValue(r, raw); r.SetRaw(f.Name, value) }
+}

package/features/field_date_only.go

@@ -0,0 +1,39 @@
+package features
+
+import (
+	"context"
+	"errors"
+	validation "github.com/pocketbase/ozzo-validation/v4"
+	"github.com/pocketbase/pocketbase/core"
+	"github.com/spf13/cast"
+	"time"
+)
+
+const FieldTypeDateOnly = "dateOnly"
+
+type DateOnlyField struct{ core.TextField }
+
+func init()                           { core.Fields[FieldTypeDateOnly] = func() core.Field { return &DateOnlyField{} } }
+func (f *DateOnlyField) Type() string { return FieldTypeDateOnly }
+func (f *DateOnlyField) PrepareValue(_ *core.Record, raw any) (any, error) {
+	return cast.ToString(raw), nil
+}
+func (f *DateOnlyField) ValidateValue(ctx context.Context, app core.App, r *core.Record) error {
+	if err := f.TextField.ValidateValue(ctx, app, r); err != nil {
+		return err
+	}
+	value := r.GetString(f.Name)
+	if value != "" {
+		parsed, err := time.Parse(time.DateOnly, value)
+		if err != nil || parsed.Format(time.DateOnly) != value {
+			return validation.NewError("validation_date_only", "Must be a calendar date in YYYY-MM-DD format")
+		}
+	}
+	return nil
+}
+func (f *DateOnlyField) ValidateSettings(ctx context.Context, app core.App, c *core.Collection) error {
+	if f.PrimaryKey || f.AutogeneratePattern != "" {
+		return errors.New("calendar dates cannot be primary keys or autogenerated")
+	}
+	return f.TextField.ValidateSettings(ctx, app, c)
+}