tags are used. -func html2Text(htmlDocument string) (string, error) { - var builder strings.Builder - - doc, err := html.Parse(strings.NewReader(htmlDocument)) - if err != nil { - return "", err - } - - tagsToSkip := []string{ - "style", "script", "iframe", "applet", "object", "svg", "img", - "button", "form", "textarea", "input", "select", "option", "template", - } - - inlineTags := []string{ - "a", "span", "small", "strike", "strong", - "sub", "sup", "em", "b", "u", "i", - } - - var canAddNewLine bool - - // see https://pkg.go.dev/golang.org/x/net/html#Parse - var f func(*html.Node) - f = func(n *html.Node) { - // start link wrapping for producing "[text](link)" formatted string - isLink := n.Type == html.ElementNode && n.Data == "a" - if isLink { - builder.WriteString("[") - } - - switch n.Type { - case html.TextNode: - txt := whitespaceRegex.ReplaceAllString(n.Data, " ") - - // the prev node has new line so it is safe to trim the indentation - if !canAddNewLine { - txt = strings.TrimLeft(txt, " ") - } - - if txt != "" { - builder.WriteString(txt) - canAddNewLine = true - } - case html.ElementNode: - if n.Data == "br" { - // always write new lines when
tag is used - builder.WriteString("\r\n") - canAddNewLine = false - } else if canAddNewLine && !list.ExistInSlice(n.Data, inlineTags) { - builder.WriteString("\r\n") - canAddNewLine = false - } - - // prefix list items with dash - if n.Data == "li" { - builder.WriteString("- ") - } - } - - for c := n.FirstChild; c != nil; c = c.NextSibling { - if c.Type != html.ElementNode || !list.ExistInSlice(c.Data, tagsToSkip) { - f(c) - } - } - - // end link wrapping - if isLink { - builder.WriteString("]") - for _, a := range n.Attr { - if a.Key == "href" { - if a.Val != "" { - builder.WriteString("(") - builder.WriteString(a.Val) - builder.WriteString(")") - } - break - } - } - } - } - - f(doc) - - return strings.TrimSpace(builder.String()), nil -} diff --git a/tools/mailer/html2text_test.go b/tools/mailer/html2text_test.go deleted file mode 100644 index eb8f4d44289c93bb38309eda4f73fec4c030f033..0000000000000000000000000000000000000000 --- a/tools/mailer/html2text_test.go +++ /dev/null @@ -1,131 +0,0 @@ -package mailer - -import ( - "testing" -) - -func TestHtml2Text(t *testing.T) { - scenarios := []struct { - html string - expected string - }{ - { - "", - "", - }, - { - "ab c", - "ab c", - }, - { - "", - "", - }, - { - " a ", - "a", - }, - { - "abc", - "abc", - }, - { - `test`, - "[test](a/b/c)", - }, - { - `test`, - "[test]", - }, - { - "a b", - "a b", - }, - { - "a b c", - "a b c", - }, - { - "a b
c
",
- "a b \r\nc",
- },
- {
- `
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- `,
- "Lorem ipsum \r\nDolor sit amet \r\n[Verify](a/b/c) \r\n[Verify2.1 Verify2.2](a/b/c) \r\n\r\n- ul.test1 \r\n- ul.test2 \r\n- ul.test3 \r\n- ol.test1 \r\n- ol.test2 \r\n- ol.test3 \r\nThanks,\r\nPocketBase team",
- },
- }
-
- for i, s := range scenarios {
- result, err := html2Text(s.html)
- if err != nil {
- t.Errorf("(%d) Unexpected error %v", i, err)
- }
-
- if result != s.expected {
- t.Errorf("(%d) Expected \n(%q)\n%v,\n\ngot:\n\n(%q)\n%v", i, s.expected, s.expected, result, result)
- }
- }
-}
diff --git a/tools/mailer/mailer.go b/tools/mailer/mailer.go
deleted file mode 100644
index d46ac4ea6103be792405da5fe4a7f689b47f6201..0000000000000000000000000000000000000000
--- a/tools/mailer/mailer.go
+++ /dev/null
@@ -1,25 +0,0 @@
-package mailer
-
-import (
- "io"
- "net/mail"
-)
-
-// Message defines a generic email message struct.
-type Message struct {
- From mail.Address
- To mail.Address
- Bcc []string
- Cc []string
- Subject string
- HTML string
- Text string
- Headers map[string]string
- Attachments map[string]io.Reader
-}
-
-// Mailer defines a base mail client interface.
-type Mailer interface {
- // Send sends an email with the provided Message.
- Send(message *Message) error
-}
diff --git a/tools/mailer/sendmail.go b/tools/mailer/sendmail.go
deleted file mode 100644
index e56e53f15d3f9d4d438c91837eb1f9d73512fef4..0000000000000000000000000000000000000000
--- a/tools/mailer/sendmail.go
+++ /dev/null
@@ -1,75 +0,0 @@
-package mailer
-
-import (
- "bytes"
- "errors"
- "mime"
- "net/http"
- "os/exec"
-)
-
-var _ Mailer = (*Sendmail)(nil)
-
-// Sendmail implements `mailer.Mailer` interface and defines a mail
-// client that sends emails via the `sendmail` *nix command.
-//
-// This client is usually recommended only for development and testing.
-type Sendmail struct {
-}
-
-// Send implements `mailer.Mailer` interface.
-func (c *Sendmail) Send(m *Message) error {
- headers := make(http.Header)
- headers.Set("Subject", mime.QEncoding.Encode("utf-8", m.Subject))
- headers.Set("From", m.From.String())
- headers.Set("To", m.To.String())
- headers.Set("Content-Type", "text/html; charset=UTF-8")
-
- cmdPath, err := findSendmailPath()
- if err != nil {
- return err
- }
-
- var buffer bytes.Buffer
-
- // write
- // ---
- if err := headers.Write(&buffer); err != nil {
- return err
- }
- if _, err := buffer.Write([]byte("\r\n")); err != nil {
- return err
- }
- if m.HTML != "" {
- if _, err := buffer.Write([]byte(m.HTML)); err != nil {
- return err
- }
- } else {
- if _, err := buffer.Write([]byte(m.Text)); err != nil {
- return err
- }
- }
- // ---
-
- sendmail := exec.Command(cmdPath, m.To.Address)
- sendmail.Stdin = &buffer
-
- return sendmail.Run()
-}
-
-func findSendmailPath() (string, error) {
- options := []string{
- "/usr/sbin/sendmail",
- "/usr/bin/sendmail",
- "sendmail",
- }
-
- for _, option := range options {
- path, err := exec.LookPath(option)
- if err == nil {
- return path, err
- }
- }
-
- return "", errors.New("Failed to locate a sendmail executable path.")
-}
diff --git a/tools/mailer/smtp.go b/tools/mailer/smtp.go
deleted file mode 100644
index 56fc862df57c7e6563a93972baa0bee4e44620de..0000000000000000000000000000000000000000
--- a/tools/mailer/smtp.go
+++ /dev/null
@@ -1,110 +0,0 @@
-package mailer
-
-import (
- "fmt"
- "net/smtp"
- "strings"
-
- "github.com/domodwyer/mailyak/v3"
- "github.com/pocketbase/pocketbase/tools/security"
-)
-
-var _ Mailer = (*SmtpClient)(nil)
-
-// NewSmtpClient creates new `SmtpClient` with the provided configuration.
-func NewSmtpClient(
- host string,
- port int,
- username string,
- password string,
- tls bool,
-) *SmtpClient {
- return &SmtpClient{
- host: host,
- port: port,
- username: username,
- password: password,
- tls: tls,
- }
-}
-
-// SmtpClient defines a SMTP mail client structure that implements
-// `mailer.Mailer` interface.
-type SmtpClient struct {
- host string
- port int
- username string
- password string
- tls bool
-}
-
-// Send implements `mailer.Mailer` interface.
-func (c *SmtpClient) Send(m *Message) error {
- var smtpAuth smtp.Auth
- if c.username != "" || c.password != "" {
- smtpAuth = smtp.PlainAuth("", c.username, c.password, c.host)
- }
-
- // create mail instance
- var yak *mailyak.MailYak
- if c.tls {
- var tlsErr error
- yak, tlsErr = mailyak.NewWithTLS(fmt.Sprintf("%s:%d", c.host, c.port), smtpAuth, nil)
- if tlsErr != nil {
- return tlsErr
- }
- } else {
- yak = mailyak.New(fmt.Sprintf("%s:%d", c.host, c.port), smtpAuth)
- }
-
- if m.From.Name != "" {
- yak.FromName(m.From.Name)
- }
- yak.From(m.From.Address)
- yak.To(m.To.Address)
- yak.Subject(m.Subject)
- yak.HTML().Set(m.HTML)
-
- if m.Text == "" {
- // try to generate a plain text version of the HTML
- if plain, err := html2Text(m.HTML); err == nil {
- yak.Plain().Set(plain)
- }
- } else {
- yak.Plain().Set(m.Text)
- }
-
- if len(m.Bcc) > 0 {
- yak.Bcc(m.Bcc...)
- }
-
- if len(m.Cc) > 0 {
- yak.Cc(m.Cc...)
- }
-
- // add attachements (if any)
- for name, data := range m.Attachments {
- yak.Attach(name, data)
- }
-
- // add custom headers (if any)
- var hasMessageId bool
- for k, v := range m.Headers {
- if strings.EqualFold(k, "Message-ID") {
- hasMessageId = true
- }
- yak.AddHeader(k, v)
- }
- if !hasMessageId {
- // add a default message id if missing
- fromParts := strings.Split(m.From.Address, "@")
- if len(fromParts) == 2 {
- yak.AddHeader("Message-ID", fmt.Sprintf("<%s@%s>",
- security.PseudorandomString(15),
- fromParts[1],
- ))
- }
- }
-
- return yak.Send()
-}
diff --git a/tools/migrate/list.go b/tools/migrate/list.go
deleted file mode 100644
index 65d249920c69dbb63e34b18565ee53ae107b44b7..0000000000000000000000000000000000000000
--- a/tools/migrate/list.go
+++ /dev/null
@@ -1,59 +0,0 @@
-package migrate
-
-import (
- "path/filepath"
- "runtime"
- "sort"
-
- "github.com/pocketbase/dbx"
-)
-
-type Migration struct {
- File string
- Up func(db dbx.Builder) error
- Down func(db dbx.Builder) error
-}
-
-// MigrationsList defines a list with migration definitions
-type MigrationsList struct {
- list []*Migration
-}
-
-// Item returns a single migration from the list by its index.
-func (l *MigrationsList) Item(index int) *Migration {
- return l.list[index]
-}
-
-// Items returns the internal migrations list slice.
-func (l *MigrationsList) Items() []*Migration {
- return l.list
-}
-
-// Register adds new migration definition to the list.
-//
-// If `optFilename` is not provided, it will try to get the name from its .go file.
-//
-// The list will be sorted automatically based on the migrations file name.
-func (l *MigrationsList) Register(
- up func(db dbx.Builder) error,
- down func(db dbx.Builder) error,
- optFilename ...string,
-) {
- var file string
- if len(optFilename) > 0 {
- file = optFilename[0]
- } else {
- _, path, _, _ := runtime.Caller(1)
- file = filepath.Base(path)
- }
-
- l.list = append(l.list, &Migration{
- File: file,
- Up: up,
- Down: down,
- })
-
- sort.Slice(l.list, func(i int, j int) bool {
- return l.list[i].File < l.list[j].File
- })
-}
diff --git a/tools/migrate/list_test.go b/tools/migrate/list_test.go
deleted file mode 100644
index 5030e882db4f6b7f09581f35a12c63a0df41d051..0000000000000000000000000000000000000000
--- a/tools/migrate/list_test.go
+++ /dev/null
@@ -1,33 +0,0 @@
-package migrate
-
-import (
- "testing"
-)
-
-func TestMigrationsList(t *testing.T) {
- l := MigrationsList{}
-
- l.Register(nil, nil, "3_test.go")
- l.Register(nil, nil, "1_test.go")
- l.Register(nil, nil, "2_test.go")
- l.Register(nil, nil /* auto detect file name */)
-
- expected := []string{
- "1_test.go",
- "2_test.go",
- "3_test.go",
- "list_test.go",
- }
-
- items := l.Items()
- if len(items) != len(expected) {
- t.Fatalf("Expected %d items, got %d: \n%#v", len(expected), len(items), items)
- }
-
- for i, name := range expected {
- item := l.Item(i)
- if item.File != name {
- t.Fatalf("Expected name %s for index %d, got %s", name, i, item.File)
- }
- }
-}
diff --git a/tools/migrate/runner.go b/tools/migrate/runner.go
deleted file mode 100644
index 7485e5e266d11144738ca4cefc8f77a228809f37..0000000000000000000000000000000000000000
--- a/tools/migrate/runner.go
+++ /dev/null
@@ -1,220 +0,0 @@
-package migrate
-
-import (
- "fmt"
- "time"
-
- "github.com/AlecAivazis/survey/v2"
- "github.com/fatih/color"
- "github.com/pocketbase/dbx"
- "github.com/spf13/cast"
-)
-
-const DefaultMigrationsTable = "_migrations"
-
-// Runner defines a simple struct for managing the execution of db migrations.
-type Runner struct {
- db *dbx.DB
- migrationsList MigrationsList
- tableName string
-}
-
-// NewRunner creates and initializes a new db migrations Runner instance.
-func NewRunner(db *dbx.DB, migrationsList MigrationsList) (*Runner, error) {
- runner := &Runner{
- db: db,
- migrationsList: migrationsList,
- tableName: DefaultMigrationsTable,
- }
-
- if err := runner.createMigrationsTable(); err != nil {
- return nil, err
- }
-
- return runner, nil
-}
-
-// Run interactively executes the current runner with the provided args.
-//
-// The following commands are supported:
-// - up - applies all migrations
-// - down [n] - reverts the last n applied migrations
-func (r *Runner) Run(args ...string) error {
- cmd := "up"
- if len(args) > 0 {
- cmd = args[0]
- }
-
- switch cmd {
- case "up":
- applied, err := r.Up()
- if err != nil {
- color.Red(err.Error())
- return err
- }
-
- if len(applied) == 0 {
- color.Green("No new migrations to apply.")
- } else {
- for _, file := range applied {
- color.Green("Applied %s", file)
- }
- }
-
- return nil
- case "down":
- toRevertCount := 1
- if len(args) > 1 {
- toRevertCount = cast.ToInt(args[1])
- if toRevertCount < 0 {
- // revert all applied migrations
- toRevertCount = len(r.migrationsList.Items())
- }
- }
-
- confirm := false
- prompt := &survey.Confirm{
- Message: fmt.Sprintf("Do you really want to revert the last %d applied migration(s)?", toRevertCount),
- }
- survey.AskOne(prompt, &confirm)
- if !confirm {
- fmt.Println("The command has been cancelled")
- return nil
- }
-
- reverted, err := r.Down(toRevertCount)
- if err != nil {
- color.Red(err.Error())
- return err
- }
-
- if len(reverted) == 0 {
- color.Green("No migrations to revert.")
- } else {
- for _, file := range reverted {
- color.Green("Reverted %s", file)
- }
- }
-
- return nil
- default:
- return fmt.Errorf("Unsupported command: %q\n", cmd)
- }
-}
-
-// Up executes all unapplied migrations for the provided runner.
-//
-// On success returns list with the applied migrations file names.
-func (r *Runner) Up() ([]string, error) {
- applied := []string{}
-
- err := r.db.Transactional(func(tx *dbx.Tx) error {
- for _, m := range r.migrationsList.Items() {
- // skip applied
- if r.isMigrationApplied(tx, m.File) {
- continue
- }
-
- // ignore empty Up action
- if m.Up != nil {
- if err := m.Up(tx); err != nil {
- return fmt.Errorf("Failed to apply migration %s: %w", m.File, err)
- }
- }
-
- if err := r.saveAppliedMigration(tx, m.File); err != nil {
- return fmt.Errorf("Failed to save applied migration info for %s: %w", m.File, err)
- }
-
- applied = append(applied, m.File)
- }
-
- return nil
- })
-
- if err != nil {
- return nil, err
- }
- return applied, nil
-}
-
-// Down reverts the last `toRevertCount` applied migrations.
-//
-// On success returns list with the reverted migrations file names.
-func (r *Runner) Down(toRevertCount int) ([]string, error) {
- reverted := make([]string, 0, toRevertCount)
-
- err := r.db.Transactional(func(tx *dbx.Tx) error {
- for i := len(r.migrationsList.Items()) - 1; i >= 0; i-- {
- m := r.migrationsList.Item(i)
-
- // skip unapplied
- if !r.isMigrationApplied(tx, m.File) {
- continue
- }
-
- // revert limit reached
- if toRevertCount-len(reverted) <= 0 {
- break
- }
-
- // ignore empty Down action
- if m.Down != nil {
- if err := m.Down(tx); err != nil {
- return fmt.Errorf("Failed to revert migration %s: %w", m.File, err)
- }
- }
-
- if err := r.saveRevertedMigration(tx, m.File); err != nil {
- return fmt.Errorf("Failed to save reverted migration info for %s: %w", m.File, err)
- }
-
- reverted = append(reverted, m.File)
- }
-
- return nil
- })
-
- if err != nil {
- return nil, err
- }
- return reverted, nil
-}
-
-func (r *Runner) createMigrationsTable() error {
- rawQuery := fmt.Sprintf(
- "CREATE TABLE IF NOT EXISTS %v (file VARCHAR(255) PRIMARY KEY NOT NULL, applied INTEGER NOT NULL)",
- r.db.QuoteTableName(r.tableName),
- )
-
- _, err := r.db.NewQuery(rawQuery).Execute()
-
- return err
-}
-
-func (r *Runner) isMigrationApplied(tx dbx.Builder, file string) bool {
- var exists bool
-
- err := tx.Select("count(*)").
- From(r.tableName).
- Where(dbx.HashExp{"file": file}).
- Limit(1).
- Row(&exists)
-
- return err == nil && exists
-}
-
-func (r *Runner) saveAppliedMigration(tx dbx.Builder, file string) error {
- _, err := tx.Insert(r.tableName, dbx.Params{
- "file": file,
- "applied": time.Now().Unix(),
- }).Execute()
-
- return err
-}
-
-func (r *Runner) saveRevertedMigration(tx dbx.Builder, file string) error {
- _, err := tx.Delete(r.tableName, dbx.HashExp{"file": file}).Execute()
-
- return err
-}
diff --git a/tools/migrate/runner_test.go b/tools/migrate/runner_test.go
deleted file mode 100644
index bd579ab039da35cfa3eb14ea56ab9980d4ee105d..0000000000000000000000000000000000000000
--- a/tools/migrate/runner_test.go
+++ /dev/null
@@ -1,150 +0,0 @@
-package migrate
-
-import (
- "context"
- "database/sql"
- "testing"
- "time"
-
- "github.com/pocketbase/dbx"
- "github.com/pocketbase/pocketbase/tools/list"
- _ "modernc.org/sqlite"
-)
-
-func TestNewRunner(t *testing.T) {
- testDB, err := createTestDB()
- if err != nil {
- t.Fatal(err)
- }
- defer testDB.Close()
-
- l := MigrationsList{}
- l.Register(nil, nil, "1_test.go")
- l.Register(nil, nil, "2_test.go")
- l.Register(nil, nil, "3_test.go")
-
- r, err := NewRunner(testDB.DB, l)
- if err != nil {
- t.Fatal(err)
- }
-
- if len(r.migrationsList.Items()) != len(l.Items()) {
- t.Fatalf("Expected the same migrations list to be assigned, got \n%#v", r.migrationsList)
- }
-
- expectedQueries := []string{
- "CREATE TABLE IF NOT EXISTS `_migrations` (file VARCHAR(255) PRIMARY KEY NOT NULL, applied INTEGER NOT NULL)",
- }
- if len(expectedQueries) != len(testDB.CalledQueries) {
- t.Fatalf("Expected %d queries, got %d: \n%v", len(expectedQueries), len(testDB.CalledQueries), testDB.CalledQueries)
- }
- for _, q := range expectedQueries {
- if !list.ExistInSlice(q, testDB.CalledQueries) {
- t.Fatalf("Query %s was not found in \n%v", q, testDB.CalledQueries)
- }
- }
-}
-
-func TestRunnerUpAndDown(t *testing.T) {
- testDB, err := createTestDB()
- if err != nil {
- t.Fatal(err)
- }
- defer testDB.Close()
-
- var test1UpCalled bool
- var test1DownCalled bool
- var test2UpCalled bool
- var test2DownCalled bool
-
- l := MigrationsList{}
- l.Register(func(db dbx.Builder) error {
- test1UpCalled = true
- return nil
- }, func(db dbx.Builder) error {
- test1DownCalled = true
- return nil
- }, "1_test")
- l.Register(func(db dbx.Builder) error {
- test2UpCalled = true
- return nil
- }, func(db dbx.Builder) error {
- test2DownCalled = true
- return nil
- }, "2_test")
-
- r, err := NewRunner(testDB.DB, l)
- if err != nil {
- t.Fatal(err)
- }
-
- // simulate partially run migration
- r.saveAppliedMigration(testDB, r.migrationsList.Item(0).File)
-
- // Up()
- // ---
- if _, err := r.Up(); err != nil {
- t.Fatal(err)
- }
-
- if test1UpCalled {
- t.Fatalf("Didn't expect 1_test to be called")
- }
-
- if !test2UpCalled {
- t.Fatalf("Expected 2_test to be called")
- }
-
- // simulate unrun migration
- var test3DownCalled bool
- r.migrationsList.Register(nil, func(db dbx.Builder) error {
- test3DownCalled = true
- return nil
- }, "3_test")
-
- // Down()
- // ---
- // revert one migration
- if _, err := r.Down(1); err != nil {
- t.Fatal(err)
- }
-
- if test3DownCalled {
- t.Fatal("Didn't expect 3_test to be reverted.")
- }
-
- if !test2DownCalled {
- t.Fatal("Expected 2_test to be reverted.")
- }
-
- if test1DownCalled {
- t.Fatal("Didn't expect 1_test to be reverted.")
- }
-}
-
-// -------------------------------------------------------------------
-// Helpers
-// -------------------------------------------------------------------
-
-type testDB struct {
- *dbx.DB
- CalledQueries []string
-}
-
-// NB! Don't forget to call `db.Close()` at the end of the test.
-func createTestDB() (*testDB, error) {
- sqlDB, err := sql.Open("sqlite", ":memory:")
- if err != nil {
- return nil, err
- }
-
- db := testDB{DB: dbx.NewFromDB(sqlDB, "sqlite")}
- db.QueryLogFunc = func(ctx context.Context, t time.Duration, sql string, rows *sql.Rows, err error) {
- db.CalledQueries = append(db.CalledQueries, sql)
- }
- db.ExecLogFunc = func(ctx context.Context, t time.Duration, sql string, result sql.Result, err error) {
- db.CalledQueries = append(db.CalledQueries, sql)
- }
-
- return &db, nil
-}
diff --git a/tools/rest/multi_binder.go b/tools/rest/multi_binder.go
deleted file mode 100644
index 5467909adf3757def237c50e10eebb3373d054a2..0000000000000000000000000000000000000000
--- a/tools/rest/multi_binder.go
+++ /dev/null
@@ -1,59 +0,0 @@
-package rest
-
-import (
- "bytes"
- "encoding/json"
- "io"
- "net/http"
- "strings"
-
- "github.com/labstack/echo/v5"
-)
-
-// BindBody binds request body content to i.
-//
-// This is similar to `echo.BindBody()`, but for JSON requests uses
-// custom json reader that **copies** the request body, allowing multiple reads.
-func BindBody(c echo.Context, i interface{}) error {
- req := c.Request()
- if req.ContentLength == 0 {
- return nil
- }
-
- ctype := req.Header.Get(echo.HeaderContentType)
- switch {
- case strings.HasPrefix(ctype, echo.MIMEApplicationJSON):
- err := CopyJsonBody(c.Request(), i)
- if err != nil {
- return echo.NewHTTPErrorWithInternal(http.StatusBadRequest, err, err.Error())
- }
- return nil
- default:
- // fallback to the default binder
- return echo.BindBody(c, i)
- }
-}
-
-// CopyJsonBody reads the request body into i by
-// creating a copy of `r.Body` to allow multiple reads.
-func CopyJsonBody(r *http.Request, i interface{}) error {
- body := r.Body
-
- // this usually shouldn't be needed because the Server calls close for us
- // but we are changing the request body with a new reader
- defer body.Close()
-
- limitReader := io.LimitReader(body, DefaultMaxMemory)
-
- bodyBytes, readErr := io.ReadAll(limitReader)
- if readErr != nil {
- return readErr
- }
-
- err := json.NewDecoder(bytes.NewReader(bodyBytes)).Decode(i)
-
- // set new body reader
- r.Body = io.NopCloser(bytes.NewReader(bodyBytes))
-
- return err
-}
diff --git a/tools/rest/multi_binder_test.go b/tools/rest/multi_binder_test.go
deleted file mode 100644
index 853e21911d756870f0a7f4766062c47677382671..0000000000000000000000000000000000000000
--- a/tools/rest/multi_binder_test.go
+++ /dev/null
@@ -1,102 +0,0 @@
-package rest_test
-
-import (
- "io"
- "net/http"
- "net/http/httptest"
- "net/url"
- "strings"
- "testing"
-
- "github.com/labstack/echo/v5"
- "github.com/pocketbase/pocketbase/tools/rest"
-)
-
-func TestBindBody(t *testing.T) {
- scenarios := []struct {
- body io.Reader
- contentType string
- result map[string]string
- expectError bool
- }{
- {
- strings.NewReader(""),
- echo.MIMEApplicationJSON,
- map[string]string{},
- false,
- },
- {
- strings.NewReader(`{"test":"invalid`),
- echo.MIMEApplicationJSON,
- map[string]string{},
- true,
- },
- {
- strings.NewReader(`{"test":"test123"}`),
- echo.MIMEApplicationJSON,
- map[string]string{"test": "test123"},
- false,
- },
- {
- strings.NewReader(url.Values{"test": []string{"test123"}}.Encode()),
- echo.MIMEApplicationForm,
- map[string]string{"test": "test123"},
- false,
- },
- }
-
- for i, scenario := range scenarios {
- e := echo.New()
- req := httptest.NewRequest(http.MethodPost, "/", scenario.body)
- req.Header.Set(echo.HeaderContentType, scenario.contentType)
- rec := httptest.NewRecorder()
- c := e.NewContext(req, rec)
-
- result := map[string]string{}
- err := rest.BindBody(c, &result)
-
- if err == nil && scenario.expectError {
- t.Errorf("(%d) Expected error, got nil", i)
- }
-
- if err != nil && !scenario.expectError {
- t.Errorf("(%d) Expected nil, got error %v", i, err)
- }
-
- if len(result) != len(scenario.result) {
- t.Errorf("(%d) Expected %v, got %v", i, scenario.result, result)
- }
-
- for k, v := range result {
- if sv, ok := scenario.result[k]; !ok || v != sv {
- t.Errorf("(%d) Expected value %v for key %s, got %v", i, sv, k, v)
- }
- }
- }
-}
-
-func TestCopyJsonBody(t *testing.T) {
- req := httptest.NewRequest(http.MethodGet, "/", strings.NewReader(`{"test":"test123"}`))
-
- // simulate multiple reads from the same request
- result1 := map[string]string{}
- rest.CopyJsonBody(req, &result1)
- result2 := map[string]string{}
- rest.CopyJsonBody(req, &result2)
-
- if len(result1) == 0 {
- t.Error("Expected result1 to be filled")
- }
-
- if len(result2) == 0 {
- t.Error("Expected result2 to be filled")
- }
-
- if v, ok := result1["test"]; !ok || v != "test123" {
- t.Errorf("Expected result1.test to be %q, got %q", "test123", v)
- }
-
- if v, ok := result2["test"]; !ok || v != "test123" {
- t.Errorf("Expected result2.test to be %q, got %q", "test123", v)
- }
-}
diff --git a/tools/rest/uploaded_file.go b/tools/rest/uploaded_file.go
deleted file mode 100644
index 8376f2b3768d3dc6271e46056e639b6167e1ad76..0000000000000000000000000000000000000000
--- a/tools/rest/uploaded_file.go
+++ /dev/null
@@ -1,100 +0,0 @@
-package rest
-
-import (
- "fmt"
- "mime/multipart"
- "net/http"
- "path/filepath"
- "regexp"
- "strings"
-
- "github.com/gabriel-vasile/mimetype"
- "github.com/pocketbase/pocketbase/tools/inflector"
- "github.com/pocketbase/pocketbase/tools/security"
-)
-
-// DefaultMaxMemory defines the default max memory bytes that
-// will be used when parsing a form request body.
-const DefaultMaxMemory = 32 << 20 // 32mb
-
-var extensionInvalidCharsRegex = regexp.MustCompile(`[^\w\.\*\-\+\=\#]+`)
-
-// UploadedFile defines a single multipart uploaded file instance.
-type UploadedFile struct {
- name string
- header *multipart.FileHeader
-}
-
-// Name returns an assigned unique name to the uploaded file.
-func (f *UploadedFile) Name() string {
- return f.name
-}
-
-// Header returns the file header that comes with the multipart request.
-func (f *UploadedFile) Header() *multipart.FileHeader {
- return f.header
-}
-
-// FindUploadedFiles extracts all form files of `key` from a http request
-// and returns a slice with `UploadedFile` instances (if any).
-func FindUploadedFiles(r *http.Request, key string) ([]*UploadedFile, error) {
- if r.MultipartForm == nil {
- err := r.ParseMultipartForm(DefaultMaxMemory)
- if err != nil {
- return nil, err
- }
- }
-
- if r.MultipartForm == nil || r.MultipartForm.File == nil || len(r.MultipartForm.File[key]) == 0 {
- return nil, http.ErrMissingFile
- }
-
- result := make([]*UploadedFile, 0, len(r.MultipartForm.File[key]))
-
- for _, fh := range r.MultipartForm.File[key] {
- file, err := fh.Open()
- if err != nil {
- return nil, err
- }
- defer file.Close()
-
- // extension
- // ---
- originalExt := filepath.Ext(fh.Filename)
- sanitizedExt := extensionInvalidCharsRegex.ReplaceAllString(originalExt, "")
- if sanitizedExt == "" {
- // try to detect the extension from the mime type
- mt, err := mimetype.DetectReader(file)
- if err != nil {
- return nil, err
- }
- sanitizedExt = mt.Extension()
- }
-
- // name
- // ---
- originalName := strings.TrimSuffix(fh.Filename, originalExt)
- sanitizedName := inflector.Snakecase(originalName)
- if length := len(sanitizedName); length < 3 {
- // the name is too short so we concatenate an additional random part
- sanitizedName += security.RandomString(10)
- } else if length > 100 {
- // keep only the first 100 characters (it is multibyte safe after Snakecase)
- sanitizedName = sanitizedName[:100]
- }
-
- uploadedFilename := fmt.Sprintf(
- "%s_%s%s",
- sanitizedName,
- security.RandomString(10), // ensure that there is always a random part
- sanitizedExt,
- )
-
- result = append(result, &UploadedFile{
- name: uploadedFilename,
- header: fh,
- })
- }
-
- return result, nil
-}
diff --git a/tools/rest/uploaded_file_test.go b/tools/rest/uploaded_file_test.go
deleted file mode 100644
index b11ebde34b5101dbfcb84ff056185de318d62555..0000000000000000000000000000000000000000
--- a/tools/rest/uploaded_file_test.go
+++ /dev/null
@@ -1,80 +0,0 @@
-package rest_test
-
-import (
- "bytes"
- "mime/multipart"
- "net/http"
- "net/http/httptest"
- "regexp"
- "strings"
- "testing"
-
- "github.com/pocketbase/pocketbase/tools/rest"
-)
-
-func TestFindUploadedFiles(t *testing.T) {
- scenarios := []struct {
- filename string
- expectedPattern string
- }{
- {"ab.png", `^ab\w{10}_\w{10}\.png$`},
- {"test", `^test_\w{10}\.txt$`},
- {"a b c d!@$.j!@$pg", `^a_b_c_d_\w{10}\.jpg$`},
- {strings.Repeat("a", 150), `^a{100}_\w{10}\.txt$`},
- }
-
- for i, s := range scenarios {
- // create multipart form file body
- body := new(bytes.Buffer)
- mp := multipart.NewWriter(body)
- w, err := mp.CreateFormFile("test", s.filename)
- if err != nil {
- t.Fatal(err)
- }
- w.Write([]byte("test"))
- mp.Close()
- // ---
-
- req := httptest.NewRequest(http.MethodPost, "/", body)
- req.Header.Add("Content-Type", mp.FormDataContentType())
-
- result, err := rest.FindUploadedFiles(req, "test")
- if err != nil {
- t.Fatal(err)
- }
-
- if len(result) != 1 {
- t.Errorf("[%d] Expected 1 file, got %d", i, len(result))
- }
-
- if result[0].Header().Size != 4 {
- t.Errorf("[%d] Expected the file size to be 4 bytes, got %d", i, result[0].Header().Size)
- }
-
- pattern, err := regexp.Compile(s.expectedPattern)
- if err != nil {
- t.Errorf("[%d] Invalid filename pattern %q: %v", i, s.expectedPattern, err)
- }
- if !pattern.MatchString(result[0].Name()) {
- t.Fatalf("Expected filename to match %s, got filename %s", s.expectedPattern, result[0].Name())
- }
- }
-}
-
-func TestFindUploadedFilesMissing(t *testing.T) {
- body := new(bytes.Buffer)
- mp := multipart.NewWriter(body)
- mp.Close()
-
- req := httptest.NewRequest(http.MethodPost, "/", body)
- req.Header.Add("Content-Type", mp.FormDataContentType())
-
- result, err := rest.FindUploadedFiles(req, "test")
- if err == nil {
- t.Error("Expected error, got nil")
- }
-
- if result != nil {
- t.Errorf("Expected result to be nil, got %v", result)
- }
-}
diff --git a/tools/rest/url.go b/tools/rest/url.go
deleted file mode 100644
index 87dd6b21c14f099c2358d61e225186c02dfbc1ad..0000000000000000000000000000000000000000
--- a/tools/rest/url.go
+++ /dev/null
@@ -1,29 +0,0 @@
-package rest
-
-import (
- "net/url"
- "path"
- "strings"
-)
-
-// NormalizeUrl removes duplicated slashes from a url path.
-func NormalizeUrl(originalUrl string) (string, error) {
- u, err := url.Parse(originalUrl)
- if err != nil {
- return "", err
- }
-
- hasSlash := strings.HasSuffix(u.Path, "/")
-
- // clean up path by removing duplicated /
- u.Path = path.Clean(u.Path)
- u.RawPath = path.Clean(u.RawPath)
-
- // restore original trailing slash
- if hasSlash && !strings.HasSuffix(u.Path, "/") {
- u.Path += "/"
- u.RawPath += "/"
- }
-
- return u.String(), nil
-}
diff --git a/tools/rest/url_test.go b/tools/rest/url_test.go
deleted file mode 100644
index 091d5bc4e18f3aeacd7595b2c824190f90fa285e..0000000000000000000000000000000000000000
--- a/tools/rest/url_test.go
+++ /dev/null
@@ -1,40 +0,0 @@
-package rest_test
-
-import (
- "testing"
-
- "github.com/pocketbase/pocketbase/tools/rest"
-)
-
-func TestNormalizeUrl(t *testing.T) {
- scenarios := []struct {
- url string
- expectError bool
- expectUrl string
- }{
- {":/", true, ""},
- {"./", false, "./"},
- {"../../test////", false, "../../test/"},
- {"/a/b/c", false, "/a/b/c"},
- {"a/////b//c/", false, "a/b/c/"},
- {"/a/////b//c", false, "/a/b/c"},
- {"///a/b/c", false, "/a/b/c"},
- {"//a/b/c", false, "//a/b/c"}, // preserve "auto-schema"
- {"http://a/b/c", false, "http://a/b/c"},
- {"a//bc?test=1//dd", false, "a/bc?test=1//dd"}, // only the path is normalized
- {"a//bc?test=1#12///3", false, "a/bc?test=1#12///3"}, // only the path is normalized
- }
-
- for i, s := range scenarios {
- result, err := rest.NormalizeUrl(s.url)
-
- hasErr := err != nil
- if hasErr != s.expectError {
- t.Errorf("(%d) Expected hasErr %v, got %v", i, s.expectError, hasErr)
- }
-
- if result != s.expectUrl {
- t.Errorf("(%d) Expected url %q, got %q", i, s.expectUrl, result)
- }
- }
-}
diff --git a/tools/routine/routine.go b/tools/routine/routine.go
deleted file mode 100644
index 7974d58b7464ce7bf0f9ba748e4614260fc3cc0e..0000000000000000000000000000000000000000
--- a/tools/routine/routine.go
+++ /dev/null
@@ -1,32 +0,0 @@
-package routine
-
-import (
- "log"
- "runtime/debug"
- "sync"
-)
-
-// FireAndForget executes `f()` in a new go routine and auto recovers if panic.
-//
-// **Note:** Use this only if you are not interested in the result of `f()`
-// and don't want to block the parent go routine.
-func FireAndForget(f func(), wg ...*sync.WaitGroup) {
- if len(wg) > 0 && wg[0] != nil {
- wg[0].Add(1)
- }
-
- go func() {
- if len(wg) > 0 && wg[0] != nil {
- defer wg[0].Done()
- }
-
- defer func() {
- if err := recover(); err != nil {
- log.Printf("RECOVERED FROM PANIC: %v", err)
- log.Printf("%s\n", string(debug.Stack()))
- }
- }()
-
- f()
- }()
-}
diff --git a/tools/routine/routine_test.go b/tools/routine/routine_test.go
deleted file mode 100644
index dcb6ace60ba4ed7bff80a013b2999907d8228b85..0000000000000000000000000000000000000000
--- a/tools/routine/routine_test.go
+++ /dev/null
@@ -1,27 +0,0 @@
-package routine_test
-
-import (
- "sync"
- "testing"
-
- "github.com/pocketbase/pocketbase/tools/routine"
-)
-
-func TestFireAndForget(t *testing.T) {
- called := false
-
- fn := func() {
- called = true
- panic("test")
- }
-
- wg := &sync.WaitGroup{}
-
- routine.FireAndForget(fn, wg)
-
- wg.Wait()
-
- if !called {
- t.Error("Expected fn to be called.")
- }
-}
diff --git a/tools/search/filter.go b/tools/search/filter.go
deleted file mode 100644
index 516a79946f8ae00a56c1a7d893938714da0691ab..0000000000000000000000000000000000000000
--- a/tools/search/filter.go
+++ /dev/null
@@ -1,211 +0,0 @@
-package search
-
-import (
- "errors"
- "fmt"
- "strings"
-
- "github.com/ganigeorgiev/fexpr"
- "github.com/pocketbase/dbx"
- "github.com/pocketbase/pocketbase/tools/security"
- "github.com/pocketbase/pocketbase/tools/store"
- "github.com/pocketbase/pocketbase/tools/types"
- "github.com/spf13/cast"
-)
-
-// FilterData is a filter expression string following the `fexpr` package grammar.
-//
-// Example:
-//
-// var filter FilterData = "id = null || (name = 'test' && status = true)"
-// resolver := search.NewSimpleFieldResolver("id", "name", "status")
-// expr, err := filter.BuildExpr(resolver)
-type FilterData string
-
-// parsedFilterData holds a cache with previously parsed filter data expressions
-// (initialized with some preallocated empty data map)
-var parsedFilterData = store.New(make(map[string][]fexpr.ExprGroup, 50))
-
-// BuildExpr parses the current filter data and returns a new db WHERE expression.
-func (f FilterData) BuildExpr(fieldResolver FieldResolver) (dbx.Expression, error) {
- raw := string(f)
- if parsedFilterData.Has(raw) {
- return f.build(parsedFilterData.Get(raw), fieldResolver)
- }
- data, err := fexpr.Parse(raw)
- if err != nil {
- return nil, err
- }
- // store in cache
- // (the limit size is arbitrary and it is there to prevent the cache growing too big)
- parsedFilterData.SetIfLessThanLimit(raw, data, 500)
- return f.build(data, fieldResolver)
-}
-
-func (f FilterData) build(data []fexpr.ExprGroup, fieldResolver FieldResolver) (dbx.Expression, error) {
- if len(data) == 0 {
- return nil, errors.New("Empty filter expression.")
- }
-
- var result dbx.Expression
-
- for _, group := range data {
- var expr dbx.Expression
- var exprErr error
-
- switch item := group.Item.(type) {
- case fexpr.Expr:
- expr, exprErr = f.resolveTokenizedExpr(item, fieldResolver)
- case fexpr.ExprGroup:
- expr, exprErr = f.build([]fexpr.ExprGroup{item}, fieldResolver)
- case []fexpr.ExprGroup:
- expr, exprErr = f.build(item, fieldResolver)
- default:
- exprErr = errors.New("Unsupported expression item.")
- }
-
- if exprErr != nil {
- return nil, exprErr
- }
-
- if group.Join == fexpr.JoinAnd {
- result = dbx.And(result, expr)
- } else {
- result = dbx.Or(result, expr)
- }
- }
-
- return result, nil
-}
-
-func (f FilterData) resolveTokenizedExpr(expr fexpr.Expr, fieldResolver FieldResolver) (dbx.Expression, error) {
- lName, lParams, lErr := f.resolveToken(expr.Left, fieldResolver)
- if lName == "" || lErr != nil {
- return nil, fmt.Errorf("Invalid left operand %q - %v.", expr.Left.Literal, lErr)
- }
-
- rName, rParams, rErr := f.resolveToken(expr.Right, fieldResolver)
- if rName == "" || rErr != nil {
- return nil, fmt.Errorf("Invalid right operand %q - %v.", expr.Right.Literal, rErr)
- }
-
- switch expr.Op {
- case fexpr.SignEq:
- return dbx.NewExp(fmt.Sprintf("COALESCE(%s, '') = COALESCE(%s, '')", lName, rName), mergeParams(lParams, rParams)), nil
- case fexpr.SignNeq:
- return dbx.NewExp(fmt.Sprintf("COALESCE(%s, '') != COALESCE(%s, '')", lName, rName), mergeParams(lParams, rParams)), nil
- case fexpr.SignLike:
- // the right side is a column and therefor wrap it with "%" for contains like behavior
- if len(rParams) == 0 {
- return dbx.NewExp(fmt.Sprintf("%s LIKE ('%%' || %s || '%%')", lName, rName), lParams), nil
- }
-
- return dbx.NewExp(fmt.Sprintf("%s LIKE %s", lName, rName), mergeParams(lParams, wrapLikeParams(rParams))), nil
- case fexpr.SignNlike:
- // the right side is a column and therefor wrap it with "%" for not-contains like behavior
- if len(rParams) == 0 {
- return dbx.NewExp(fmt.Sprintf("%s NOT LIKE ('%%' || %s || '%%')", lName, rName), lParams), nil
- }
-
- // normalize operands and switch sides if the left operand is a number/text, but the right one is a column
- // (usually this shouldn't be needed, but it's kept for backward compatibility)
- if len(lParams) > 0 && len(rParams) == 0 {
- return dbx.NewExp(fmt.Sprintf("%s NOT LIKE %s", rName, lName), wrapLikeParams(lParams)), nil
- }
-
- return dbx.NewExp(fmt.Sprintf("%s NOT LIKE %s", lName, rName), mergeParams(lParams, wrapLikeParams(rParams))), nil
- case fexpr.SignLt:
- return dbx.NewExp(fmt.Sprintf("%s < %s", lName, rName), mergeParams(lParams, rParams)), nil
- case fexpr.SignLte:
- return dbx.NewExp(fmt.Sprintf("%s <= %s", lName, rName), mergeParams(lParams, rParams)), nil
- case fexpr.SignGt:
- return dbx.NewExp(fmt.Sprintf("%s > %s", lName, rName), mergeParams(lParams, rParams)), nil
- case fexpr.SignGte:
- return dbx.NewExp(fmt.Sprintf("%s >= %s", lName, rName), mergeParams(lParams, rParams)), nil
- }
-
- return nil, fmt.Errorf("Unknown expression operator %q", expr.Op)
-}
-
-func (f FilterData) resolveToken(token fexpr.Token, fieldResolver FieldResolver) (name string, params dbx.Params, err error) {
- switch token.Type {
- case fexpr.TokenIdentifier:
- // current datetime constant
- // ---
- if token.Literal == "@now" {
- placeholder := "t" + security.PseudorandomString(8)
- name := fmt.Sprintf("{:%s}", placeholder)
- params := dbx.Params{placeholder: types.NowDateTime().String()}
-
- return name, params, nil
- }
-
- // custom resolver
- // ---
- name, params, err := fieldResolver.Resolve(token.Literal)
-
- if name == "" || err != nil {
- m := map[string]string{
- // if `null` field is missing, treat `null` identifier as NULL token
- "null": "NULL",
- // if `true` field is missing, treat `true` identifier as TRUE token
- "true": "1",
- // if `false` field is missing, treat `false` identifier as FALSE token
- "false": "0",
- }
- if v, ok := m[strings.ToLower(token.Literal)]; ok {
- return v, nil, nil
- }
- return "", nil, err
- }
-
- return name, params, err
- case fexpr.TokenText:
- placeholder := "t" + security.PseudorandomString(8)
- name := fmt.Sprintf("{:%s}", placeholder)
- params := dbx.Params{placeholder: token.Literal}
-
- return name, params, nil
- case fexpr.TokenNumber:
- placeholder := "t" + security.PseudorandomString(8)
- name := fmt.Sprintf("{:%s}", placeholder)
- params := dbx.Params{placeholder: cast.ToFloat64(token.Literal)}
-
- return name, params, nil
- }
-
- return "", nil, errors.New("Unresolvable token type.")
-}
-
-// mergeParams returns new dbx.Params where each provided params item
-// is merged in the order they are specified.
-func mergeParams(params ...dbx.Params) dbx.Params {
- result := dbx.Params{}
-
- for _, p := range params {
- for k, v := range p {
- result[k] = v
- }
- }
-
- return result
-}
-
-// wrapLikeParams wraps each provided param value string with `%`
-// if the string doesn't contains the `%` char (including its escape sequence).
-func wrapLikeParams(params dbx.Params) dbx.Params {
- result := dbx.Params{}
-
- for k, v := range params {
- vStr := cast.ToString(v)
- if !strings.Contains(vStr, "%") {
- for i := 0; i < len(dbx.DefaultLikeEscape); i += 2 {
- vStr = strings.ReplaceAll(vStr, dbx.DefaultLikeEscape[i], dbx.DefaultLikeEscape[i+1])
- }
- vStr = "%" + vStr + "%"
- }
- result[k] = vStr
- }
-
- return result
-}
diff --git a/tools/search/filter_test.go b/tools/search/filter_test.go
deleted file mode 100644
index 98a8c23c7d755bd0e9f8045a9b9006fed17328a4..0000000000000000000000000000000000000000
--- a/tools/search/filter_test.go
+++ /dev/null
@@ -1,156 +0,0 @@
-package search_test
-
-import (
- "regexp"
- "testing"
-
- "github.com/pocketbase/dbx"
- "github.com/pocketbase/pocketbase/tools/search"
-)
-
-func TestFilterDataBuildExpr(t *testing.T) {
- resolver := search.NewSimpleFieldResolver("test1", "test2", "test3", "test4.sub")
-
- scenarios := []struct {
- filterData search.FilterData
- expectError bool
- expectPattern string
- }{
- // empty
- {"", true, ""},
- // invalid format
- {"(test1 > 1", true, ""},
- // invalid operator
- {"test1 + 123", true, ""},
- // unknown field
- {"test1 = 'example' && unknown > 1", true, ""},
- // simple expression
- {"test1 > 1", false,
- "^" +
- regexp.QuoteMeta("[[test1]] > {:") +
- ".+" +
- regexp.QuoteMeta("}") +
- "$",
- },
- // like with 2 columns
- {"test1 ~ test2", false,
- "^" +
- regexp.QuoteMeta("[[test1]] LIKE ('%' || [[test2]] || '%')") +
- "$",
- },
- // like with right column operand
- {"'lorem' ~ test1", false,
- "^" +
- regexp.QuoteMeta("{:") +
- ".+" +
- regexp.QuoteMeta("} LIKE ('%' || [[test1]] || '%')") +
- "$",
- },
- // like with left column operand and text as right operand
- {"test1 ~ 'lorem'", false,
- "^" +
- regexp.QuoteMeta("[[test1]] LIKE {:") +
- ".+" +
- regexp.QuoteMeta("}") +
- "$",
- },
- // not like with 2 columns
- {"test1 !~ test2", false,
- "^" +
- regexp.QuoteMeta("[[test1]] NOT LIKE ('%' || [[test2]] || '%')") +
- "$",
- },
- // not like with right column operand
- {"'lorem' !~ test1", false,
- "^" +
- regexp.QuoteMeta("{:") +
- ".+" +
- regexp.QuoteMeta("} NOT LIKE ('%' || [[test1]] || '%')") +
- "$",
- },
- // like with left column operand and text as right operand
- {"test1 !~ 'lorem'", false,
- "^" +
- regexp.QuoteMeta("[[test1]] NOT LIKE {:") +
- ".+" +
- regexp.QuoteMeta("}") +
- "$",
- },
- // current datetime constant
- {"test1 > @now", false,
- "^" +
- regexp.QuoteMeta("[[test1]] > {:") +
- ".+" +
- regexp.QuoteMeta("}") +
- "$",
- },
- // complex expression
- {
- "((test1 > 1) || (test2 != 2)) && test3 ~ '%%example' && test4.sub = null",
- false,
- "^" +
- regexp.QuoteMeta("((([[test1]] > {:") +
- ".+" +
- regexp.QuoteMeta("}) OR (COALESCE([[test2]], '') != COALESCE({:") +
- ".+" +
- regexp.QuoteMeta("}, ''))) AND ([[test3]] LIKE {:") +
- ".+" +
- regexp.QuoteMeta("})) AND (COALESCE([[test4.sub]], '') = COALESCE(NULL, ''))") +
- "$",
- },
- // combination of special literals (null, true, false)
- {
- "test1=true && test2 != false && test3 = null || test4.sub != null",
- false,
- "^" + regexp.QuoteMeta("(((COALESCE([[test1]], '') = COALESCE(1, '')) AND (COALESCE([[test2]], '') != COALESCE(0, ''))) AND (COALESCE([[test3]], '') = COALESCE(NULL, ''))) OR (COALESCE([[test4.sub]], '') != COALESCE(NULL, ''))") + "$",
- },
- // all operators
- {
- "(test1 = test2 || test2 != test3) && (test2 ~ 'example' || test2 !~ '%%abc') && 'switch1%%' ~ test1 && 'switch2' !~ test2 && test3 > 1 && test3 >= 0 && test3 <= 4 && 2 < 5",
- false,
- "^" +
- regexp.QuoteMeta("((((((((COALESCE([[test1]], '') = COALESCE([[test2]], '')) OR (COALESCE([[test2]], '') != COALESCE([[test3]], ''))) AND (([[test2]] LIKE {:") +
- ".+" +
- regexp.QuoteMeta("}) OR ([[test2]] NOT LIKE {:") +
- ".+" +
- regexp.QuoteMeta("}))) AND ({:") +
- ".+" +
- regexp.QuoteMeta("} LIKE ('%' || [[test1]] || '%'))) AND ({:") +
- ".+" +
- regexp.QuoteMeta("} NOT LIKE ('%' || [[test2]] || '%'))) AND ([[test3]] > {:") +
- ".+" +
- regexp.QuoteMeta("})) AND ([[test3]] >= {:") +
- ".+" +
- regexp.QuoteMeta("})) AND ([[test3]] <= {:") +
- ".+" +
- regexp.QuoteMeta("})) AND ({:") +
- ".+" +
- regexp.QuoteMeta("} < {:") +
- ".+" +
- regexp.QuoteMeta("})") +
- "$",
- },
- }
-
- for i, s := range scenarios {
- expr, err := s.filterData.BuildExpr(resolver)
-
- hasErr := err != nil
- if hasErr != s.expectError {
- t.Errorf("(%d) Expected hasErr %v, got %v (%v)", i, s.expectError, hasErr, err)
- continue
- }
-
- if hasErr {
- continue
- }
-
- dummyDB := &dbx.DB{}
- rawSql := expr.Build(dummyDB, map[string]any{})
-
- pattern := regexp.MustCompile(s.expectPattern)
- if !pattern.MatchString(rawSql) {
- t.Errorf("(%d) Pattern %v don't match with expression: \n%v", i, s.expectPattern, rawSql)
- }
- }
-}
diff --git a/tools/search/provider.go b/tools/search/provider.go
deleted file mode 100644
index f8d728fb13ce263b5417049d93e88ef841946ed7..0000000000000000000000000000000000000000
--- a/tools/search/provider.go
+++ /dev/null
@@ -1,251 +0,0 @@
-package search
-
-import (
- "errors"
- "math"
- "net/url"
- "strconv"
- "strings"
-
- "github.com/pocketbase/dbx"
-)
-
-// DefaultPerPage specifies the default returned search result items.
-const DefaultPerPage int = 30
-
-// MaxPerPage specifies the maximum allowed search result items returned in a single page.
-const MaxPerPage int = 500
-
-// url search query params
-const (
- PageQueryParam string = "page"
- PerPageQueryParam string = "perPage"
- SortQueryParam string = "sort"
- FilterQueryParam string = "filter"
-)
-
-// Result defines the returned search result structure.
-type Result struct {
- Page int `json:"page"`
- PerPage int `json:"perPage"`
- TotalItems int `json:"totalItems"`
- TotalPages int `json:"totalPages"`
- Items any `json:"items"`
-}
-
-// Provider represents a single configured search provider instance.
-type Provider struct {
- fieldResolver FieldResolver
- query *dbx.SelectQuery
- page int
- perPage int
- sort []SortField
- filter []FilterData
-}
-
-// NewProvider creates and returns a new search provider.
-//
-// Example:
-//
-// baseQuery := db.Select("*").From("user")
-// fieldResolver := search.NewSimpleFieldResolver("id", "name")
-// models := []*YourDataStruct{}
-//
-// result, err := search.NewProvider(fieldResolver).
-// Query(baseQuery).
-// ParseAndExec("page=2&filter=id>0&sort=-email", &models)
-func NewProvider(fieldResolver FieldResolver) *Provider {
- return &Provider{
- fieldResolver: fieldResolver,
- page: 1,
- perPage: DefaultPerPage,
- sort: []SortField{},
- filter: []FilterData{},
- }
-}
-
-// Query sets the base query that will be used to fetch the search items.
-func (s *Provider) Query(query *dbx.SelectQuery) *Provider {
- s.query = query
- return s
-}
-
-// Page sets the `page` field of the current search provider.
-//
-// Normalization on the `page` value is done during `Exec()`.
-func (s *Provider) Page(page int) *Provider {
- s.page = page
- return s
-}
-
-// PerPage sets the `perPage` field of the current search provider.
-//
-// Normalization on the `perPage` value is done during `Exec()`.
-func (s *Provider) PerPage(perPage int) *Provider {
- s.perPage = perPage
- return s
-}
-
-// Sort sets the `sort` field of the current search provider.
-func (s *Provider) Sort(sort []SortField) *Provider {
- s.sort = sort
- return s
-}
-
-// AddSort appends the provided SortField to the existing provider's sort field.
-func (s *Provider) AddSort(field SortField) *Provider {
- s.sort = append(s.sort, field)
- return s
-}
-
-// Filter sets the `filter` field of the current search provider.
-func (s *Provider) Filter(filter []FilterData) *Provider {
- s.filter = filter
- return s
-}
-
-// AddFilter appends the provided FilterData to the existing provider's filter field.
-func (s *Provider) AddFilter(filter FilterData) *Provider {
- if filter != "" {
- s.filter = append(s.filter, filter)
- }
- return s
-}
-
-// Parse parses the search query parameter from the provided query string
-// and assigns the found fields to the current search provider.
-//
-// The data from the "sort" and "filter" query parameters are appended
-// to the existing provider's `sort` and `filter` fields
-// (aka. using `AddSort` and `AddFilter`).
-func (s *Provider) Parse(urlQuery string) error {
- params, err := url.ParseQuery(urlQuery)
- if err != nil {
- return err
- }
-
- if rawPage := params.Get(PageQueryParam); rawPage != "" {
- page, err := strconv.Atoi(rawPage)
- if err != nil {
- return err
- }
- s.Page(page)
- }
-
- if rawPerPage := params.Get(PerPageQueryParam); rawPerPage != "" {
- perPage, err := strconv.Atoi(rawPerPage)
- if err != nil {
- return err
- }
- s.PerPage(perPage)
- }
-
- if rawSort := params.Get(SortQueryParam); rawSort != "" {
- for _, sortField := range ParseSortFromString(rawSort) {
- s.AddSort(sortField)
- }
- }
-
- if rawFilter := params.Get(FilterQueryParam); rawFilter != "" {
- s.AddFilter(FilterData(rawFilter))
- }
-
- return nil
-}
-
-// Exec executes the search provider and fills/scans
-// the provided `items` slice with the found models.
-func (s *Provider) Exec(items any) (*Result, error) {
- if s.query == nil {
- return nil, errors.New("Query is not set.")
- }
-
- // clone provider's query
- modelsQuery := *s.query
-
- // build filters
- for _, f := range s.filter {
- expr, err := f.BuildExpr(s.fieldResolver)
- if err != nil {
- return nil, err
- }
- if expr != nil {
- modelsQuery.AndWhere(expr)
- }
- }
-
- // apply sorting
- for _, sortField := range s.sort {
- expr, err := sortField.BuildExpr(s.fieldResolver)
- if err != nil {
- return nil, err
- }
- if expr != "" {
- modelsQuery.AndOrderBy(expr)
- }
- }
-
- // apply field resolver query modifications (if any)
- if err := s.fieldResolver.UpdateQuery(&modelsQuery); err != nil {
- return nil, err
- }
-
- queryInfo := modelsQuery.Info()
-
- // count
- var totalCount int64
- var baseTable string
- if len(queryInfo.From) > 0 {
- baseTable = queryInfo.From[0]
- }
- countQuery := modelsQuery
- rawCountQuery := countQuery.Select(strings.Join([]string{baseTable, "id"}, ".")).OrderBy().Build().SQL()
- wrappedCountQuery := queryInfo.Builder.NewQuery("SELECT COUNT(*) FROM (" + rawCountQuery + ")")
- wrappedCountQuery.Bind(countQuery.Build().Params())
- if err := wrappedCountQuery.Row(&totalCount); err != nil {
- return nil, err
- }
-
- // normalize perPage
- if s.perPage <= 0 {
- s.perPage = DefaultPerPage
- } else if s.perPage > MaxPerPage {
- s.perPage = MaxPerPage
- }
-
- totalPages := int(math.Ceil(float64(totalCount) / float64(s.perPage)))
-
- // normalize page according to the total count
- if s.page <= 0 || totalCount == 0 {
- s.page = 1
- } else if s.page > totalPages {
- s.page = totalPages
- }
-
- // apply pagination
- modelsQuery.Limit(int64(s.perPage))
- modelsQuery.Offset(int64(s.perPage * (s.page - 1)))
-
- // fetch models
- if err := modelsQuery.All(items); err != nil {
- return nil, err
- }
-
- return &Result{
- Page: s.page,
- PerPage: s.perPage,
- TotalItems: int(totalCount),
- TotalPages: totalPages,
- Items: items,
- }, nil
-}
-
-// ParseAndExec is a short convenient method to trigger both
-// `Parse()` and `Exec()` in a single call.
-func (s *Provider) ParseAndExec(urlQuery string, modelsSlice any) (*Result, error) {
- if err := s.Parse(urlQuery); err != nil {
- return nil, err
- }
-
- return s.Exec(modelsSlice)
-}
diff --git a/tools/search/provider_test.go b/tools/search/provider_test.go
deleted file mode 100644
index c65fe7c33102a8b9c2968a75970f5b67c8986578..0000000000000000000000000000000000000000
--- a/tools/search/provider_test.go
+++ /dev/null
@@ -1,505 +0,0 @@
-package search
-
-import (
- "context"
- "database/sql"
- "encoding/json"
- "errors"
- "fmt"
- "testing"
- "time"
-
- "github.com/pocketbase/dbx"
- "github.com/pocketbase/pocketbase/tools/list"
- _ "modernc.org/sqlite"
-)
-
-func TestNewProvider(t *testing.T) {
- r := &testFieldResolver{}
- p := NewProvider(r)
-
- if p.page != 1 {
- t.Fatalf("Expected page %d, got %d", 1, p.page)
- }
-
- if p.perPage != DefaultPerPage {
- t.Fatalf("Expected perPage %d, got %d", DefaultPerPage, p.perPage)
- }
-}
-
-func TestProviderQuery(t *testing.T) {
- db := dbx.NewFromDB(nil, "")
- query := db.Select("id").From("test")
- querySql := query.Build().SQL()
-
- r := &testFieldResolver{}
- p := NewProvider(r).Query(query)
-
- expected := p.query.Build().SQL()
-
- if querySql != expected {
- t.Fatalf("Expected %v, got %v", expected, querySql)
- }
-}
-
-func TestProviderPage(t *testing.T) {
- r := &testFieldResolver{}
- p := NewProvider(r).Page(10)
-
- if p.page != 10 {
- t.Fatalf("Expected page %v, got %v", 10, p.page)
- }
-}
-
-func TestProviderPerPage(t *testing.T) {
- r := &testFieldResolver{}
- p := NewProvider(r).PerPage(456)
-
- if p.perPage != 456 {
- t.Fatalf("Expected perPage %v, got %v", 456, p.perPage)
- }
-}
-
-func TestProviderSort(t *testing.T) {
- initialSort := []SortField{{"test1", SortAsc}, {"test2", SortAsc}}
- r := &testFieldResolver{}
- p := NewProvider(r).
- Sort(initialSort).
- AddSort(SortField{"test3", SortDesc})
-
- encoded, _ := json.Marshal(p.sort)
- expected := `[{"name":"test1","direction":"ASC"},{"name":"test2","direction":"ASC"},{"name":"test3","direction":"DESC"}]`
-
- if string(encoded) != expected {
- t.Fatalf("Expected sort %v, got \n%v", expected, string(encoded))
- }
-}
-
-func TestProviderFilter(t *testing.T) {
- initialFilter := []FilterData{"test1", "test2"}
- r := &testFieldResolver{}
- p := NewProvider(r).
- Filter(initialFilter).
- AddFilter("test3")
-
- encoded, _ := json.Marshal(p.filter)
- expected := `["test1","test2","test3"]`
-
- if string(encoded) != expected {
- t.Fatalf("Expected filter %v, got \n%v", expected, string(encoded))
- }
-}
-
-func TestProviderParse(t *testing.T) {
- initialPage := 2
- initialPerPage := 123
- initialSort := []SortField{{"test1", SortAsc}, {"test2", SortAsc}}
- initialFilter := []FilterData{"test1", "test2"}
-
- scenarios := []struct {
- query string
- expectError bool
- expectPage int
- expectPerPage int
- expectSort string
- expectFilter string
- }{
- // empty
- {
- "",
- false,
- initialPage,
- initialPerPage,
- `[{"name":"test1","direction":"ASC"},{"name":"test2","direction":"ASC"}]`,
- `["test1","test2"]`,
- },
- // invalid query
- {
- "invalid;",
- true,
- initialPage,
- initialPerPage,
- `[{"name":"test1","direction":"ASC"},{"name":"test2","direction":"ASC"}]`,
- `["test1","test2"]`,
- },
- // invalid page
- {
- "page=a",
- true,
- initialPage,
- initialPerPage,
- `[{"name":"test1","direction":"ASC"},{"name":"test2","direction":"ASC"}]`,
- `["test1","test2"]`,
- },
- // invalid perPage
- {
- "perPage=a",
- true,
- initialPage,
- initialPerPage,
- `[{"name":"test1","direction":"ASC"},{"name":"test2","direction":"ASC"}]`,
- `["test1","test2"]`,
- },
- // valid query parameters
- {
- "page=3&perPage=456&filter=test3&sort=-a,b,+c&other=123",
- false,
- 3,
- 456,
- `[{"name":"test1","direction":"ASC"},{"name":"test2","direction":"ASC"},{"name":"a","direction":"DESC"},{"name":"b","direction":"ASC"},{"name":"c","direction":"ASC"}]`,
- `["test1","test2","test3"]`,
- },
- }
-
- for i, s := range scenarios {
- r := &testFieldResolver{}
- p := NewProvider(r).
- Page(initialPage).
- PerPage(initialPerPage).
- Sort(initialSort).
- Filter(initialFilter)
-
- err := p.Parse(s.query)
-
- hasErr := err != nil
- if hasErr != s.expectError {
- t.Errorf("(%d) Expected hasErr %v, got %v (%v)", i, s.expectError, hasErr, err)
- continue
- }
-
- if p.page != s.expectPage {
- t.Errorf("(%d) Expected page %v, got %v", i, s.expectPage, p.page)
- }
-
- if p.perPage != s.expectPerPage {
- t.Errorf("(%d) Expected perPage %v, got %v", i, s.expectPerPage, p.perPage)
- }
-
- encodedSort, _ := json.Marshal(p.sort)
- if string(encodedSort) != s.expectSort {
- t.Errorf("(%d) Expected sort %v, got \n%v", i, s.expectSort, string(encodedSort))
- }
-
- encodedFilter, _ := json.Marshal(p.filter)
- if string(encodedFilter) != s.expectFilter {
- t.Errorf("(%d) Expected filter %v, got \n%v", i, s.expectFilter, string(encodedFilter))
- }
- }
-}
-
-func TestProviderExecEmptyQuery(t *testing.T) {
- p := NewProvider(&testFieldResolver{}).
- Query(nil)
-
- _, err := p.Exec(&[]testTableStruct{})
- if err == nil {
- t.Fatalf("Expected error with empty query, got nil")
- }
-}
-
-func TestProviderExecNonEmptyQuery(t *testing.T) {
- testDB, err := createTestDB()
- if err != nil {
- t.Fatal(err)
- }
- defer testDB.Close()
-
- query := testDB.Select("*").
- From("test").
- Where(dbx.Not(dbx.HashExp{"test1": nil})).
- OrderBy("test1 ASC")
-
- scenarios := []struct {
- page int
- perPage int
- sort []SortField
- filter []FilterData
- expectError bool
- expectResult string
- expectQueries []string
- }{
- // page normalization
- {
- -1,
- 10,
- []SortField{},
- []FilterData{},
- false,
- `{"page":1,"perPage":10,"totalItems":2,"totalPages":1,"items":[{"test1":1,"test2":"test2.1","test3":""},{"test1":2,"test2":"test2.2","test3":""}]}`,
- []string{
- "SELECT COUNT(*) FROM (SELECT `test`.`id` FROM `test` WHERE NOT (`test1` IS NULL))",
- "SELECT * FROM `test` WHERE NOT (`test1` IS NULL) ORDER BY `test1` ASC LIMIT 10",
- },
- },
- // perPage normalization
- {
- 10, // will be capped by total count
- 0, // fallback to default
- []SortField{},
- []FilterData{},
- false,
- `{"page":1,"perPage":30,"totalItems":2,"totalPages":1,"items":[{"test1":1,"test2":"test2.1","test3":""},{"test1":2,"test2":"test2.2","test3":""}]}`,
- []string{
- "SELECT COUNT(*) FROM (SELECT `test`.`id` FROM `test` WHERE NOT (`test1` IS NULL))",
- "SELECT * FROM `test` WHERE NOT (`test1` IS NULL) ORDER BY `test1` ASC LIMIT 30",
- },
- },
- // invalid sort field
- {
- 1,
- 10,
- []SortField{{"unknown", SortAsc}},
- []FilterData{},
- true,
- "",
- nil,
- },
- // invalid filter
- {
- 1,
- 10,
- []SortField{},
- []FilterData{"test2 = 'test2.1'", "invalid"},
- true,
- "",
- nil,
- },
- // valid sort and filter fields
- {
- 1,
- 5555, // will be limited by MaxPerPage
- []SortField{{"test2", SortDesc}},
- []FilterData{"test2 != null", "test1 >= 2"},
- false,
- `{"page":1,"perPage":` + fmt.Sprint(MaxPerPage) + `,"totalItems":1,"totalPages":1,"items":[{"test1":2,"test2":"test2.2","test3":""}]}`,
- []string{
- "SELECT COUNT(*) FROM (SELECT `test`.`id` FROM `test` WHERE ((NOT (`test1` IS NULL)) AND (COALESCE(test2, '') != COALESCE(null, ''))) AND (test1 >= 2))",
- "SELECT * FROM `test` WHERE ((NOT (`test1` IS NULL)) AND (COALESCE(test2, '') != COALESCE(null, ''))) AND (test1 >= 2) ORDER BY `test1` ASC, `test2` DESC LIMIT 500",
- },
- },
- // valid sort and filter fields (zero results)
- {
- 1,
- 10,
- []SortField{{"test3", SortAsc}},
- []FilterData{"test3 != ''"},
- false,
- `{"page":1,"perPage":10,"totalItems":0,"totalPages":0,"items":[]}`,
- []string{
- "SELECT COUNT(*) FROM (SELECT `test`.`id` FROM `test` WHERE (NOT (`test1` IS NULL)) AND (COALESCE(test3, '') != COALESCE('', '')))",
- "SELECT * FROM `test` WHERE (NOT (`test1` IS NULL)) AND (COALESCE(test3, '') != COALESCE('', '')) ORDER BY `test1` ASC, `test3` ASC LIMIT 10",
- },
- },
- // pagination test
- {
- 3,
- 1,
- []SortField{},
- []FilterData{},
- false,
- `{"page":2,"perPage":1,"totalItems":2,"totalPages":2,"items":[{"test1":2,"test2":"test2.2","test3":""}]}`,
- []string{
- "SELECT COUNT(*) FROM (SELECT `test`.`id` FROM `test` WHERE NOT (`test1` IS NULL))",
- "SELECT * FROM `test` WHERE NOT (`test1` IS NULL) ORDER BY `test1` ASC LIMIT 1 OFFSET 1",
- },
- },
- }
-
- for i, s := range scenarios {
- testDB.CalledQueries = []string{} // reset
-
- testResolver := &testFieldResolver{}
- p := NewProvider(testResolver).
- Query(query).
- Page(s.page).
- PerPage(s.perPage).
- Sort(s.sort).
- Filter(s.filter)
-
- result, err := p.Exec(&[]testTableStruct{})
-
- hasErr := err != nil
- if hasErr != s.expectError {
- t.Errorf("(%d) Expected hasErr %v, got %v (%v)", i, s.expectError, hasErr, err)
- continue
- }
-
- if hasErr {
- continue
- }
-
- if testResolver.UpdateQueryCalls != 1 {
- t.Errorf("(%d) Expected resolver.Update to be called %d, got %d", i, 1, testResolver.UpdateQueryCalls)
- }
-
- encoded, _ := json.Marshal(result)
- if string(encoded) != s.expectResult {
- t.Errorf("(%d) Expected result %v, got \n%v", i, s.expectResult, string(encoded))
- }
-
- if len(s.expectQueries) != len(testDB.CalledQueries) {
- t.Errorf("(%d) Expected %d queries, got %d: \n%v", i, len(s.expectQueries), len(testDB.CalledQueries), testDB.CalledQueries)
- continue
- }
-
- for _, q := range testDB.CalledQueries {
- if !list.ExistInSliceWithRegex(q, s.expectQueries) {
- t.Errorf("(%d) Didn't expect query \n%v in \n%v", i, q, testDB.CalledQueries)
- }
- }
- }
-}
-
-func TestProviderParseAndExec(t *testing.T) {
- testDB, err := createTestDB()
- if err != nil {
- t.Fatal(err)
- }
- defer testDB.Close()
-
- query := testDB.Select("*").
- From("test").
- Where(dbx.Not(dbx.HashExp{"test1": nil})).
- OrderBy("test1 ASC")
-
- scenarios := []struct {
- queryString string
- expectError bool
- expectResult string
- }{
- // empty
- {
- "",
- false,
- `{"page":1,"perPage":123,"totalItems":2,"totalPages":1,"items":[{"test1":1,"test2":"test2.1","test3":""},{"test1":2,"test2":"test2.2","test3":""}]}`,
- },
- // invalid query
- {
- "invalid;",
- true,
- "",
- },
- // invalid page
- {
- "page=a",
- true,
- "",
- },
- // invalid perPage
- {
- "perPage=a",
- true,
- "",
- },
- // invalid sorting field
- {
- "sort=-unknown",
- true,
- "",
- },
- // invalid filter field
- {
- "filter=unknown>1",
- true,
- "",
- },
- // valid query params
- {
- "page=3&perPage=9999&filter=test1>1&sort=-test2,test3",
- false,
- `{"page":1,"perPage":500,"totalItems":1,"totalPages":1,"items":[{"test1":2,"test2":"test2.2","test3":""}]}`,
- },
- }
-
- for i, s := range scenarios {
- testDB.CalledQueries = []string{} // reset
-
- testResolver := &testFieldResolver{}
- provider := NewProvider(testResolver).
- Query(query).
- Page(2).
- PerPage(123).
- Sort([]SortField{{"test2", SortAsc}}).
- Filter([]FilterData{"test1 > 0"})
-
- result, err := provider.ParseAndExec(s.queryString, &[]testTableStruct{})
-
- hasErr := err != nil
- if hasErr != s.expectError {
- t.Errorf("(%d) Expected hasErr %v, got %v (%v)", i, s.expectError, hasErr, err)
- continue
- }
-
- if hasErr {
- continue
- }
-
- if testResolver.UpdateQueryCalls != 1 {
- t.Errorf("(%d) Expected resolver.Update to be called %d, got %d", i, 1, testResolver.UpdateQueryCalls)
- }
-
- if len(testDB.CalledQueries) != 2 {
- t.Errorf("(%d) Expected %d db queries, got %d: \n%v", i, 2, len(testDB.CalledQueries), testDB.CalledQueries)
- }
-
- encoded, _ := json.Marshal(result)
- if string(encoded) != s.expectResult {
- t.Errorf("(%d) Expected result %v, got \n%v", i, s.expectResult, string(encoded))
- }
- }
-}
-
-// -------------------------------------------------------------------
-// Helpers
-// -------------------------------------------------------------------
-
-type testTableStruct struct {
- Test1 int `db:"test1" json:"test1"`
- Test2 string `db:"test2" json:"test2"`
- Test3 string `db:"test3" json:"test3"`
-}
-
-type testDB struct {
- *dbx.DB
- CalledQueries []string
-}
-
-// NB! Don't forget to call `db.Close()` at the end of the test.
-func createTestDB() (*testDB, error) {
- sqlDB, err := sql.Open("sqlite", ":memory:")
- if err != nil {
- return nil, err
- }
-
- db := testDB{DB: dbx.NewFromDB(sqlDB, "sqlite")}
- db.CreateTable("test", map[string]string{"id": "int default 0", "test1": "int default 0", "test2": "text default ''", "test3": "text default ''"}).Execute()
- db.Insert("test", dbx.Params{"id": 1, "test1": 1, "test2": "test2.1"}).Execute()
- db.Insert("test", dbx.Params{"id": 2, "test1": 2, "test2": "test2.2"}).Execute()
- db.QueryLogFunc = func(ctx context.Context, t time.Duration, sql string, rows *sql.Rows, err error) {
- db.CalledQueries = append(db.CalledQueries, sql)
- }
-
- return &db, nil
-}
-
-// ---
-
-type testFieldResolver struct {
- UpdateQueryCalls int
- ResolveCalls int
-}
-
-func (t *testFieldResolver) UpdateQuery(query *dbx.SelectQuery) error {
- t.UpdateQueryCalls++
- return nil
-}
-
-func (t *testFieldResolver) Resolve(field string) (name string, placeholderParams dbx.Params, err error) {
- t.ResolveCalls++
-
- if field == "unknown" {
- return "", nil, errors.New("test error")
- }
-
- return field, nil, nil
-}
diff --git a/tools/search/simple_field_resolver.go b/tools/search/simple_field_resolver.go
deleted file mode 100644
index 4e07fb4ab63266f050ea78fd1769df37d9268a71..0000000000000000000000000000000000000000
--- a/tools/search/simple_field_resolver.go
+++ /dev/null
@@ -1,58 +0,0 @@
-package search
-
-import (
- "fmt"
-
- "github.com/pocketbase/dbx"
- "github.com/pocketbase/pocketbase/tools/inflector"
- "github.com/pocketbase/pocketbase/tools/list"
-)
-
-// FieldResolver defines an interface for managing search fields.
-type FieldResolver interface {
- // UpdateQuery allows to updated the provided db query based on the
- // resolved search fields (eg. adding joins aliases, etc.).
- //
- // Called internally by `search.Provider` before executing the search request.
- UpdateQuery(query *dbx.SelectQuery) error
-
- // Resolve parses the provided field and returns a properly
- // formatted db identifier (eg. NULL, quoted column, placeholder parameter, etc.).
- Resolve(field string) (name string, placeholderParams dbx.Params, err error)
-}
-
-// NewSimpleFieldResolver creates a new `SimpleFieldResolver` with the
-// provided `allowedFields`.
-//
-// Each `allowedFields` could be a plain string (eg. "name")
-// or a regexp pattern (eg. `^\w+[\w\.]*$`).
-func NewSimpleFieldResolver(allowedFields ...string) *SimpleFieldResolver {
- return &SimpleFieldResolver{
- allowedFields: allowedFields,
- }
-}
-
-// SimpleFieldResolver defines a generic search resolver that allows
-// only its listed fields to be resolved and take part in a search query.
-//
-// If `allowedFields` are empty no fields filtering is applied.
-type SimpleFieldResolver struct {
- allowedFields []string
-}
-
-// UpdateQuery implements `search.UpdateQuery` interface.
-func (r *SimpleFieldResolver) UpdateQuery(query *dbx.SelectQuery) error {
- // nothing to update...
- return nil
-}
-
-// Resolve implements `search.Resolve` interface.
-//
-// Returns error if `field` is not in `r.allowedFields`.
-func (r *SimpleFieldResolver) Resolve(field string) (resultName string, placeholderParams dbx.Params, err error) {
- if !list.ExistInSliceWithRegex(field, r.allowedFields) {
- return "", nil, fmt.Errorf("Failed to resolve field %q.", field)
- }
-
- return fmt.Sprintf("[[%s]]", inflector.Columnify(field)), nil, nil
-}
diff --git a/tools/search/simple_field_resolver_test.go b/tools/search/simple_field_resolver_test.go
deleted file mode 100644
index f3f0f8ff5d7fb87727d146ab396f12df6d6f7c3f..0000000000000000000000000000000000000000
--- a/tools/search/simple_field_resolver_test.go
+++ /dev/null
@@ -1,81 +0,0 @@
-package search_test
-
-import (
- "testing"
-
- "github.com/pocketbase/dbx"
- "github.com/pocketbase/pocketbase/tools/search"
-)
-
-func TestSimpleFieldResolverUpdateQuery(t *testing.T) {
- r := search.NewSimpleFieldResolver("test")
-
- scenarios := []struct {
- fieldName string
- expectQuery string
- }{
- // missing field (the query shouldn't change)
- {"", `SELECT "id" FROM "test"`},
- // unknown field (the query shouldn't change)
- {"unknown", `SELECT "id" FROM "test"`},
- // allowed field (the query shouldn't change)
- {"test", `SELECT "id" FROM "test"`},
- }
-
- for i, s := range scenarios {
- db := dbx.NewFromDB(nil, "")
- query := db.Select("id").From("test")
-
- r.Resolve(s.fieldName)
-
- if err := r.UpdateQuery(nil); err != nil {
- t.Errorf("(%d) UpdateQuery failed with error %v", i, err)
- continue
- }
-
- rawQuery := query.Build().SQL()
- // rawQuery := s.expectQuery
-
- if rawQuery != s.expectQuery {
- t.Errorf("(%d) Expected query %v, got \n%v", i, s.expectQuery, rawQuery)
- }
- }
-}
-
-func TestSimpleFieldResolverResolve(t *testing.T) {
- r := search.NewSimpleFieldResolver("test", `^test_regex\d+$`, "Test columnify!")
-
- scenarios := []struct {
- fieldName string
- expectError bool
- expectName string
- }{
- {"", true, ""},
- {" ", true, ""},
- {"unknown", true, ""},
- {"test", false, "[[test]]"},
- {"test.sub", true, ""},
- {"test_regex", true, ""},
- {"test_regex1", false, "[[test_regex1]]"},
- {"Test columnify!", false, "[[Testcolumnify]]"},
- }
-
- for i, s := range scenarios {
- name, params, err := r.Resolve(s.fieldName)
-
- hasErr := err != nil
- if hasErr != s.expectError {
- t.Errorf("(%d) Expected hasErr %v, got %v (%v)", i, s.expectError, hasErr, err)
- continue
- }
-
- if name != s.expectName {
- t.Errorf("(%d) Expected name %q, got %q", i, s.expectName, name)
- }
-
- // params should be empty
- if len(params) != 0 {
- t.Errorf("(%d) Expected 0 params, got %v", i, params)
- }
- }
-}
diff --git a/tools/search/sort.go b/tools/search/sort.go
deleted file mode 100644
index f3e46524e53d0557dea16fe87bbb92b3393b4d04..0000000000000000000000000000000000000000
--- a/tools/search/sort.go
+++ /dev/null
@@ -1,51 +0,0 @@
-package search
-
-import (
- "fmt"
- "strings"
-)
-
-// sort field directions
-const (
- SortAsc string = "ASC"
- SortDesc string = "DESC"
-)
-
-// SortField defines a single search sort field.
-type SortField struct {
- Name string `json:"name"`
- Direction string `json:"direction"`
-}
-
-// BuildExpr resolves the sort field into a valid db sort expression.
-func (s *SortField) BuildExpr(fieldResolver FieldResolver) (string, error) {
- name, params, err := fieldResolver.Resolve(s.Name)
-
- // invalidate empty fields and non-column identifiers
- if err != nil || len(params) > 0 || name == "" || strings.ToLower(name) == "null" {
- return "", fmt.Errorf("Invalid sort field %q.", s.Name)
- }
-
- return fmt.Sprintf("%s %s", name, s.Direction), nil
-}
-
-// ParseSortFromString parses the provided string expression
-// into a slice of SortFields.
-//
-// Example:
-// fields := search.ParseSortFromString("-name,+created")
-func ParseSortFromString(str string) (fields []SortField) {
- data := strings.Split(str, ",")
-
- for _, field := range data {
- // trim whitespaces
- field = strings.TrimSpace(field)
- if strings.HasPrefix(field, "-") {
- fields = append(fields, SortField{strings.TrimPrefix(field, "-"), SortDesc})
- } else {
- fields = append(fields, SortField{strings.TrimPrefix(field, "+"), SortAsc})
- }
- }
-
- return
-}
diff --git a/tools/search/sort_test.go b/tools/search/sort_test.go
deleted file mode 100644
index 83323624ad490c7ed0c795e740d7d9f8ff7698b4..0000000000000000000000000000000000000000
--- a/tools/search/sort_test.go
+++ /dev/null
@@ -1,67 +0,0 @@
-package search_test
-
-import (
- "encoding/json"
- "testing"
-
- "github.com/pocketbase/pocketbase/tools/search"
-)
-
-func TestSortFieldBuildExpr(t *testing.T) {
- resolver := search.NewSimpleFieldResolver("test1", "test2", "test3", "test4.sub")
-
- scenarios := []struct {
- sortField search.SortField
- expectError bool
- expectExpression string
- }{
- // empty
- {search.SortField{"", search.SortDesc}, true, ""},
- // unknown field
- {search.SortField{"unknown", search.SortAsc}, true, ""},
- // placeholder field
- {search.SortField{"'test'", search.SortAsc}, true, ""},
- // null field
- {search.SortField{"null", search.SortAsc}, true, ""},
- // allowed field - asc
- {search.SortField{"test1", search.SortAsc}, false, "[[test1]] ASC"},
- // allowed field - desc
- {search.SortField{"test1", search.SortDesc}, false, "[[test1]] DESC"},
- }
-
- for i, s := range scenarios {
- result, err := s.sortField.BuildExpr(resolver)
-
- hasErr := err != nil
- if hasErr != s.expectError {
- t.Errorf("(%d) Expected hasErr %v, got %v (%v)", i, s.expectError, hasErr, err)
- continue
- }
-
- if result != s.expectExpression {
- t.Errorf("(%d) Expected expression %v, got %v", i, s.expectExpression, result)
- }
- }
-}
-
-func TestParseSortFromString(t *testing.T) {
- scenarios := []struct {
- value string
- expectedJson string
- }{
- {"", `[{"name":"","direction":"ASC"}]`},
- {"test", `[{"name":"test","direction":"ASC"}]`},
- {"+test", `[{"name":"test","direction":"ASC"}]`},
- {"-test", `[{"name":"test","direction":"DESC"}]`},
- {"test1,-test2,+test3", `[{"name":"test1","direction":"ASC"},{"name":"test2","direction":"DESC"},{"name":"test3","direction":"ASC"}]`},
- }
-
- for i, s := range scenarios {
- result := search.ParseSortFromString(s.value)
- encoded, _ := json.Marshal(result)
-
- if string(encoded) != s.expectedJson {
- t.Errorf("(%d) Expected expression %v, got %v", i, s.expectedJson, string(encoded))
- }
- }
-}
diff --git a/tools/security/encrypt.go b/tools/security/encrypt.go
deleted file mode 100644
index 2d15b7032a8df7df54cf76c2076b91b55b8443f4..0000000000000000000000000000000000000000
--- a/tools/security/encrypt.go
+++ /dev/null
@@ -1,70 +0,0 @@
-package security
-
-import (
- "crypto/aes"
- "crypto/cipher"
- crand "crypto/rand"
- "crypto/sha256"
- "encoding/base64"
- "io"
- "strings"
-)
-
-// S256Challenge creates base64 encoded sha256 challenge string derived from code.
-// The padding of the result base64 string is stripped per [RFC 7636].
-//
-// [RFC 7636]: https://datatracker.ietf.org/doc/html/rfc7636#section-4.2
-func S256Challenge(code string) string {
- h := sha256.New()
- h.Write([]byte(code))
- return strings.TrimRight(base64.URLEncoding.EncodeToString(h.Sum(nil)), "=")
-}
-
-// Encrypt encrypts data with key (must be valid 32 char aes key).
-func Encrypt(data []byte, key string) (string, error) {
- block, err := aes.NewCipher([]byte(key))
- if err != nil {
- return "", err
- }
-
- gcm, err := cipher.NewGCM(block)
- if err != nil {
- return "", err
- }
-
- nonce := make([]byte, gcm.NonceSize())
-
- // populates the nonce with a cryptographically secure random sequence
- if _, err := io.ReadFull(crand.Reader, nonce); err != nil {
- return "", err
- }
-
- cipherByte := gcm.Seal(nonce, nonce, data, nil)
-
- result := base64.StdEncoding.EncodeToString(cipherByte)
-
- return result, nil
-}
-
-// Decrypt decrypts encrypted text with key (must be valid 32 chars aes key).
-func Decrypt(cipherText string, key string) ([]byte, error) {
- block, err := aes.NewCipher([]byte(key))
- if err != nil {
- return nil, err
- }
-
- gcm, err := cipher.NewGCM(block)
- if err != nil {
- return nil, err
- }
-
- nonceSize := gcm.NonceSize()
-
- cipherByte, err := base64.StdEncoding.DecodeString(cipherText)
- if err != nil {
- return nil, err
- }
-
- nonce, cipherByteClean := cipherByte[:nonceSize], cipherByte[nonceSize:]
- return gcm.Open(nil, nonce, cipherByteClean, nil)
-}
diff --git a/tools/security/encrypt_test.go b/tools/security/encrypt_test.go
deleted file mode 100644
index 614601daca60e28bc6556d47cb5af4d356c7b42f..0000000000000000000000000000000000000000
--- a/tools/security/encrypt_test.go
+++ /dev/null
@@ -1,93 +0,0 @@
-package security_test
-
-import (
- "testing"
-
- "github.com/pocketbase/pocketbase/tools/security"
-)
-
-func TestS256Challenge(t *testing.T) {
- scenarios := []struct {
- code string
- expected string
- }{
- {"", "47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU"},
- {"123", "pmWkWSBCL51Bfkhn79xPuKBKHz__H6B-mY6G9_eieuM"},
- }
-
- for i, scenario := range scenarios {
- result := security.S256Challenge(scenario.code)
-
- if result != scenario.expected {
- t.Errorf("(%d) Expected %q, got %q", i, scenario.expected, result)
- }
- }
-}
-
-func TestEncrypt(t *testing.T) {
- scenarios := []struct {
- data string
- key string
- expectError bool
- }{
- {"", "", true},
- {"123", "test", true}, // key must be valid 32 char aes string
- {"123", "abcdabcdabcdabcdabcdabcdabcdabcd", false},
- }
-
- for i, scenario := range scenarios {
- result, err := security.Encrypt([]byte(scenario.data), scenario.key)
-
- if scenario.expectError && err == nil {
- t.Errorf("(%d) Expected error got nil", i)
- }
- if !scenario.expectError && err != nil {
- t.Errorf("(%d) Expected nil got error %v", i, err)
- }
-
- if scenario.expectError && result != "" {
- t.Errorf("(%d) Expected empty string, got %q", i, result)
- }
- if !scenario.expectError && result == "" {
- t.Errorf("(%d) Expected non empty encrypted result string", i)
- }
-
- // try to decrypt
- if result != "" {
- decrypted, _ := security.Decrypt(result, scenario.key)
- if string(decrypted) != scenario.data {
- t.Errorf("(%d) Expected decrypted value to match with the data input, got %q", i, decrypted)
- }
- }
- }
-}
-
-func TestDecrypt(t *testing.T) {
- scenarios := []struct {
- cipher string
- key string
- expectError bool
- expectedData string
- }{
- {"", "", true, ""},
- {"123", "test", true, ""}, // key must be valid 32 char aes string
- {"8kcEqilvvYKYcfnSr0aSC54gmnQCsB02SaB8ATlnA==", "abcdabcdabcdabcdabcdabcdabcdabcd", true, ""}, // illegal base64 encoded cipherText
- {"8kcEqilvv+YKYcfnSr0aSC54gmnQCsB02SaB8ATlnA==", "abcdabcdabcdabcdabcdabcdabcdabcd", false, "123"},
- }
-
- for i, scenario := range scenarios {
- result, err := security.Decrypt(scenario.cipher, scenario.key)
-
- if scenario.expectError && err == nil {
- t.Errorf("(%d) Expected error got nil", i)
- }
- if !scenario.expectError && err != nil {
- t.Errorf("(%d) Expected nil got error %v", i, err)
- }
-
- resultStr := string(result)
- if resultStr != scenario.expectedData {
- t.Errorf("(%d) Expected %q, got %q", i, scenario.expectedData, resultStr)
- }
- }
-}
diff --git a/tools/security/jwt.go b/tools/security/jwt.go
deleted file mode 100644
index 4f6e2b46c439a47e2e3c44773e008ea1d216e54a..0000000000000000000000000000000000000000
--- a/tools/security/jwt.go
+++ /dev/null
@@ -1,58 +0,0 @@
-package security
-
-import (
- "errors"
- "time"
-
- "github.com/golang-jwt/jwt/v4"
-)
-
-// ParseUnverifiedJWT parses JWT token and returns its claims
-// but DOES NOT verify the signature.
-//
-// It verifies only the exp, iat and nbf claims.
-func ParseUnverifiedJWT(token string) (jwt.MapClaims, error) {
- claims := jwt.MapClaims{}
-
- parser := &jwt.Parser{}
- _, _, err := parser.ParseUnverified(token, claims)
-
- if err == nil {
- err = claims.Valid()
- }
-
- return claims, err
-}
-
-// ParseJWT verifies and parses JWT token and returns its claims.
-func ParseJWT(token string, verificationKey string) (jwt.MapClaims, error) {
- parser := jwt.NewParser(jwt.WithValidMethods([]string{"HS256"}))
-
- parsedToken, err := parser.Parse(token, func(t *jwt.Token) (any, error) {
- return []byte(verificationKey), nil
- })
- if err != nil {
- return nil, err
- }
-
- if claims, ok := parsedToken.Claims.(jwt.MapClaims); ok && parsedToken.Valid {
- return claims, nil
- }
-
- return nil, errors.New("Unable to parse token.")
-}
-
-// NewToken generates and returns new HS256 signed JWT token.
-func NewToken(payload jwt.MapClaims, signingKey string, secondsDuration int64) (string, error) {
- seconds := time.Duration(secondsDuration) * time.Second
-
- claims := jwt.MapClaims{
- "exp": time.Now().Add(seconds).Unix(),
- }
-
- for k, v := range payload {
- claims[k] = v
- }
-
- return jwt.NewWithClaims(jwt.SigningMethodHS256, claims).SignedString([]byte(signingKey))
-}
diff --git a/tools/security/jwt_test.go b/tools/security/jwt_test.go
deleted file mode 100644
index a523ad1ad6b9dccf04ad397347d290f14ec132c0..0000000000000000000000000000000000000000
--- a/tools/security/jwt_test.go
+++ /dev/null
@@ -1,179 +0,0 @@
-package security_test
-
-import (
- "testing"
-
- "github.com/golang-jwt/jwt/v4"
- "github.com/pocketbase/pocketbase/tools/security"
-)
-
-func TestParseUnverifiedJWT(t *testing.T) {
- // invalid formatted JWT token
- result1, err1 := security.ParseUnverifiedJWT("eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJuYW1lIjoidGVzdCJ9")
- if err1 == nil {
- t.Error("Expected error got nil")
- }
- if len(result1) > 0 {
- t.Error("Expected no parsed claims, got", result1)
- }
-
- // properly formatted JWT token with INVALID claims
- // {"name": "test", "exp": 1516239022}
- result2, err2 := security.ParseUnverifiedJWT("eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJuYW1lIjoidGVzdCIsImV4cCI6MTUxNjIzOTAyMn0.xYHirwESfSEW3Cq2BL47CEASvD_p_ps3QCA54XtNktU")
- if err2 == nil {
- t.Error("Expected error got nil")
- }
- if len(result2) != 2 || result2["name"] != "test" {
- t.Errorf("Expected to have 2 claims, got %v", result2)
- }
-
- // properly formatted JWT token with VALID claims
- // {"name": "test"}
- result3, err3 := security.ParseUnverifiedJWT("eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJuYW1lIjoidGVzdCJ9.ml0QsTms3K9wMygTu41ZhKlTyjmW9zHQtoS8FUsCCjU")
- if err3 != nil {
- t.Error("Expected nil, got", err3)
- }
- if len(result3) != 1 || result3["name"] != "test" {
- t.Errorf("Expected to have 2 claims, got %v", result3)
- }
-}
-
-func TestParseJWT(t *testing.T) {
- scenarios := []struct {
- token string
- secret string
- expectError bool
- expectClaims jwt.MapClaims
- }{
- // invalid formatted JWT token
- {
- "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJuYW1lIjoidGVzdCJ9",
- "test",
- true,
- nil,
- },
- // properly formatted JWT token with INVALID claims and INVALID secret
- // {"name": "test", "exp": 1516239022}
- {
- "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJuYW1lIjoidGVzdCIsImV4cCI6MTUxNjIzOTAyMn0.xYHirwESfSEW3Cq2BL47CEASvD_p_ps3QCA54XtNktU",
- "invalid",
- true,
- nil,
- },
- // properly formatted JWT token with INVALID claims and VALID secret
- // {"name": "test", "exp": 1516239022}
- {
- "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJuYW1lIjoidGVzdCIsImV4cCI6MTUxNjIzOTAyMn0.xYHirwESfSEW3Cq2BL47CEASvD_p_ps3QCA54XtNktU",
- "test",
- true,
- nil,
- },
- // properly formatted JWT token with VALID claims and INVALID secret
- // {"name": "test", "exp": 1898636137}
- {
- "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJuYW1lIjoidGVzdCIsImV4cCI6MTg5ODYzNjEzN30.gqRkHjpK5s1PxxBn9qPaWEWxTbpc1PPSD-an83TsXRY",
- "invalid",
- true,
- nil,
- },
- // properly formatted EXPIRED JWT token with VALID secret
- // {"name": "test", "exp": 1652097610}
- {
- "eyJhbGciOiJIUzI1NiJ9.eyJuYW1lIjoidGVzdCIsImV4cCI6OTU3ODczMzc0fQ.0oUUKUnsQHs4nZO1pnxQHahKtcHspHu4_AplN2sGC4A",
- "test",
- true,
- nil,
- },
- // properly formatted JWT token with VALID claims and VALID secret
- // {"name": "test", "exp": 1898636137}
- {
- "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJuYW1lIjoidGVzdCIsImV4cCI6MTg5ODYzNjEzN30.gqRkHjpK5s1PxxBn9qPaWEWxTbpc1PPSD-an83TsXRY",
- "test",
- false,
- jwt.MapClaims{"name": "test", "exp": 1898636137.0},
- },
- // properly formatted JWT token with VALID claims (without exp) and VALID secret
- // {"name": "test"}
- {
- "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJuYW1lIjoidGVzdCJ9.ml0QsTms3K9wMygTu41ZhKlTyjmW9zHQtoS8FUsCCjU",
- "test",
- false,
- jwt.MapClaims{"name": "test"},
- },
- }
-
- for i, scenario := range scenarios {
- result, err := security.ParseJWT(scenario.token, scenario.secret)
- if scenario.expectError && err == nil {
- t.Errorf("(%d) Expected error got nil", i)
- }
- if !scenario.expectError && err != nil {
- t.Errorf("(%d) Expected nil got error %v", i, err)
- }
- if len(result) != len(scenario.expectClaims) {
- t.Errorf("(%d) Expected %v got %v", i, scenario.expectClaims, result)
- }
- for k, v := range scenario.expectClaims {
- v2, ok := result[k]
- if !ok {
- t.Errorf("(%d) Missing expected claim %q", i, k)
- }
- if v != v2 {
- t.Errorf("(%d) Expected %v for %q claim, got %v", i, v, k, v2)
- }
- }
- }
-}
-
-func TestNewToken(t *testing.T) {
- scenarios := []struct {
- claims jwt.MapClaims
- key string
- duration int64
- expectError bool
- }{
- // empty, zero duration
- {jwt.MapClaims{}, "", 0, true},
- // empty, 10 seconds duration
- {jwt.MapClaims{}, "", 10, false},
- // non-empty, 10 seconds duration
- {jwt.MapClaims{"name": "test"}, "test", 10, false},
- }
-
- for i, scenario := range scenarios {
- token, tokenErr := security.NewToken(scenario.claims, scenario.key, scenario.duration)
- if tokenErr != nil {
- t.Errorf("(%d) Expected NewToken to succeed, got error %v", i, tokenErr)
- continue
- }
-
- claims, parseErr := security.ParseJWT(token, scenario.key)
-
- hasParseErr := parseErr != nil
- if hasParseErr != scenario.expectError {
- t.Errorf("(%d) Expected hasParseErr to be %v, got %v (%v)", i, scenario.expectError, hasParseErr, parseErr)
- continue
- }
-
- if scenario.expectError {
- continue
- }
-
- if _, ok := claims["exp"]; !ok {
- t.Errorf("(%d) Missing required claim exp, got %v", i, claims)
- }
-
- // clear exp claim to match with the scenario ones
- delete(claims, "exp")
-
- if len(claims) != len(scenario.claims) {
- t.Errorf("(%d) Expected %v claims, got %v", i, scenario.claims, claims)
- }
-
- for j, k := range claims {
- if claims[j] != scenario.claims[j] {
- t.Errorf("(%d) Expected %v for %q claim, got %v", i, claims[j], k, scenario.claims[j])
- }
- }
- }
-}
diff --git a/tools/security/random.go b/tools/security/random.go
deleted file mode 100644
index 10663d467f2095351e1564c5bc338466fbed39e4..0000000000000000000000000000000000000000
--- a/tools/security/random.go
+++ /dev/null
@@ -1,64 +0,0 @@
-package security
-
-import (
- cryptoRand "crypto/rand"
- "math/big"
- mathRand "math/rand"
- "time"
-)
-
-const defaultRandomAlphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"
-
-func init() {
- mathRand.Seed(time.Now().UnixNano())
-}
-
-// RandomString generates a cryptographically random string with the specified length.
-//
-// The generated string matches [A-Za-z0-9]+ and it's transparent to URL-encoding.
-func RandomString(length int) string {
- return RandomStringWithAlphabet(length, defaultRandomAlphabet)
-}
-
-// RandomStringWithAlphabet generates a cryptographically random string
-// with the specified length and characters set.
-//
-// It panics if for some reason rand.Int returns a non-nil error.
-func RandomStringWithAlphabet(length int, alphabet string) string {
- b := make([]byte, length)
- max := big.NewInt(int64(len(alphabet)))
-
- for i := range b {
- n, err := cryptoRand.Int(cryptoRand.Reader, max)
- if err != nil {
- panic(err)
- }
- b[i] = alphabet[n.Int64()]
- }
-
- return string(b)
-}
-
-// PseudorandomString generates a pseudorandom string with the specified length.
-//
-// The generated string matches [A-Za-z0-9]+ and it's transparent to URL-encoding.
-//
-// For a cryptographically random string (but a little bit slower) use RandomString instead.
-func PseudorandomString(length int) string {
- return PseudorandomStringWithAlphabet(length, defaultRandomAlphabet)
-}
-
-// PseudorandomStringWithAlphabet generates a pseudorandom string
-// with the specified length and characters set.
-//
-// For a cryptographically random (but a little bit slower) use RandomStringWithAlphabet instead.
-func PseudorandomStringWithAlphabet(length int, alphabet string) string {
- b := make([]byte, length)
- max := len(alphabet)
-
- for i := range b {
- b[i] = alphabet[mathRand.Intn(max)]
- }
-
- return string(b)
-}
diff --git a/tools/security/random_test.go b/tools/security/random_test.go
deleted file mode 100644
index 2130903e4e8b38295eb8e5121239d313cc8063f8..0000000000000000000000000000000000000000
--- a/tools/security/random_test.go
+++ /dev/null
@@ -1,89 +0,0 @@
-package security_test
-
-import (
- "regexp"
- "testing"
-
- "github.com/pocketbase/pocketbase/tools/security"
-)
-
-func TestRandomString(t *testing.T) {
- testRandomString(t, security.RandomString)
-}
-
-func TestRandomStringWithAlphabet(t *testing.T) {
- testRandomStringWithAlphabet(t, security.RandomStringWithAlphabet)
-}
-
-func TestPseudorandomString(t *testing.T) {
- testRandomString(t, security.PseudorandomString)
-}
-
-func TestPseudorandomStringWithAlphabet(t *testing.T) {
- testRandomStringWithAlphabet(t, security.PseudorandomStringWithAlphabet)
-}
-
-// -------------------------------------------------------------------
-
-func testRandomStringWithAlphabet(t *testing.T, randomFunc func(n int, alphabet string) string) {
- scenarios := []struct {
- alphabet string
- expectPattern string
- }{
- {"0123456789_", `[0-9_]+`},
- {"abcdef", `[abcdef]+`},
- {"!@#$%^&*()", `[\!\@\#\$\%\^\&\*\(\)]+`},
- }
-
- for i, s := range scenarios {
- generated := make([]string, 0, 1000)
- length := 10
-
- for j := 0; j < 1000; j++ {
- result := randomFunc(length, s.alphabet)
-
- if len(result) != length {
- t.Fatalf("(%d:%d) Expected the length of the string to be %d, got %d", i, j, length, len(result))
- }
-
- reg := regexp.MustCompile(s.expectPattern)
- if match := reg.MatchString(result); !match {
- t.Fatalf("(%d:%d) The generated string should have only %s characters, got %q", i, j, s.expectPattern, result)
- }
-
- for _, str := range generated {
- if str == result {
- t.Fatalf("(%d:%d) Repeating random string - found %q in %q", i, j, result, generated)
- }
- }
-
- generated = append(generated, result)
- }
- }
-}
-
-func testRandomString(t *testing.T, randomFunc func(n int) string) {
- generated := make([]string, 0, 1000)
- reg := regexp.MustCompile(`[a-zA-Z0-9]+`)
- length := 10
-
- for i := 0; i < 1000; i++ {
- result := randomFunc(length)
-
- if len(result) != length {
- t.Fatalf("(%d) Expected the length of the string to be %d, got %d", i, length, len(result))
- }
-
- if match := reg.MatchString(result); !match {
- t.Fatalf("(%d) The generated string should have only [a-zA-Z0-9]+ characters, got %q", i, result)
- }
-
- for _, str := range generated {
- if str == result {
- t.Fatalf("(%d) Repeating random string - found %q in \n%v", i, result, generated)
- }
- }
-
- generated = append(generated, result)
- }
-}
diff --git a/tools/store/store.go b/tools/store/store.go
deleted file mode 100644
index e2a290d3309c31cb982722effbe20df83aa4c9a7..0000000000000000000000000000000000000000
--- a/tools/store/store.go
+++ /dev/null
@@ -1,92 +0,0 @@
-package store
-
-import "sync"
-
-// Store defines a concurrent safe in memory key-value data store.
-type Store[T any] struct {
- mux sync.RWMutex
- data map[string]T
-}
-
-// New creates a new Store[T] instance.
-func New[T any](data map[string]T) *Store[T] {
- return &Store[T]{data: data}
-}
-
-// RemoveAll removes all the existing store entries.
-func (s *Store[T]) RemoveAll() {
- s.mux.Lock()
- defer s.mux.Unlock()
-
- s.data = make(map[string]T)
-}
-
-// Remove removes a single entry from the store.
-//
-// Remove does nothing if key doesn't exist in the store.
-func (s *Store[T]) Remove(key string) {
- s.mux.Lock()
- defer s.mux.Unlock()
-
- delete(s.data, key)
-}
-
-// Has checks if element with the specified key exist or not.
-func (s *Store[T]) Has(key string) bool {
- s.mux.RLock()
- defer s.mux.RUnlock()
-
- _, ok := s.data[key]
-
- return ok
-}
-
-// Get returns a single element value from the store.
-//
-// If key is not set, the zero T value is returned.
-func (s *Store[T]) Get(key string) T {
- s.mux.RLock()
- defer s.mux.RUnlock()
-
- return s.data[key]
-}
-
-// Set sets (or overwrite if already exist) a new value for key.
-func (s *Store[T]) Set(key string, value T) {
- s.mux.Lock()
- defer s.mux.Unlock()
-
- if s.data == nil {
- s.data = make(map[string]T)
- }
-
- s.data[key] = value
-}
-
-// SetIfLessThanLimit sets (or overwrite if already exist) a new value for key.
-//
-// This method is similar to Set() but **it will skip adding new elements**
-// to the store if the store length has reached the specified limit.
-// `false` is returned if maxAllowedElements limit is reached.
-func (s *Store[T]) SetIfLessThanLimit(key string, value T, maxAllowedElements int) bool {
- s.mux.Lock()
- defer s.mux.Unlock()
-
- // init map if not already
- if s.data == nil {
- s.data = make(map[string]T)
- }
-
- // check for existing item
- _, ok := s.data[key]
-
- if !ok && len(s.data) >= maxAllowedElements {
- // cannot add more items
- return false
- }
-
- // add/overwrite item
- s.data[key] = value
-
- return true
-}
diff --git a/tools/store/store_test.go b/tools/store/store_test.go
deleted file mode 100644
index d19cfbdaf93a5a6e4e5afc4ae36e5306482fae82..0000000000000000000000000000000000000000
--- a/tools/store/store_test.go
+++ /dev/null
@@ -1,140 +0,0 @@
-package store_test
-
-import (
- "testing"
-
- "github.com/pocketbase/pocketbase/tools/store"
-)
-
-func TestNew(t *testing.T) {
- s := store.New(map[string]int{"test": 1})
-
- if s.Get("test") != 1 {
- t.Error("Expected the initizialized store map to be loaded")
- }
-}
-
-func TestRemoveAll(t *testing.T) {
- s := store.New(map[string]bool{"test1": true, "test2": true})
-
- keys := []string{"test1", "test2"}
-
- s.RemoveAll()
-
- for i, key := range keys {
- if s.Has(key) {
- t.Errorf("(%d) Expected %q to be removed", i, key)
- }
- }
-}
-
-func TestRemove(t *testing.T) {
- s := store.New(map[string]bool{"test": true})
-
- keys := []string{"test", "missing"}
-
- for i, key := range keys {
- s.Remove(key)
- if s.Has(key) {
- t.Errorf("(%d) Expected %q to be removed", i, key)
- }
- }
-}
-
-func TestHas(t *testing.T) {
- s := store.New(map[string]int{"test1": 0, "test2": 1})
-
- scenarios := []struct {
- key string
- exist bool
- }{
- {"test1", true},
- {"test2", true},
- {"missing", false},
- }
-
- for i, scenario := range scenarios {
- exist := s.Has(scenario.key)
- if exist != scenario.exist {
- t.Errorf("(%d) Expected %v, got %v", i, scenario.exist, exist)
- }
- }
-}
-
-func TestGet(t *testing.T) {
- s := store.New(map[string]int{"test1": 0, "test2": 1})
-
- scenarios := []struct {
- key string
- expect int
- }{
- {"test1", 0},
- {"test2", 1},
- {"missing", 0}, // should auto fallback to the zero value
- }
-
- for i, scenario := range scenarios {
- val := s.Get(scenario.key)
- if val != scenario.expect {
- t.Errorf("(%d) Expected %v, got %v", i, scenario.expect, val)
- }
- }
-}
-
-func TestSet(t *testing.T) {
- s := store.New[int](nil)
-
- data := map[string]int{"test1": 0, "test2": 1, "test3": 3}
-
- // set values
- for k, v := range data {
- s.Set(k, v)
- }
-
- // verify that the values are set
- for k, v := range data {
- if !s.Has(k) {
- t.Errorf("Expected key %q", k)
- }
-
- val := s.Get(k)
- if val != v {
- t.Errorf("Expected %v, got %v for key %q", v, val, k)
- }
- }
-}
-
-func TestSetIfLessThanLimit(t *testing.T) {
- s := store.New[int](nil)
-
- limit := 2
-
- // set values
- scenarios := []struct {
- key string
- value int
- expected bool
- }{
- {"test1", 1, true},
- {"test2", 2, true},
- {"test3", 3, false},
- {"test2", 4, true}, // overwrite
- }
-
- for i, scenario := range scenarios {
- result := s.SetIfLessThanLimit(scenario.key, scenario.value, limit)
-
- if result != scenario.expected {
- t.Errorf("(%d) Expected result %v, got %v", i, scenario.expected, result)
- }
-
- if !scenario.expected && s.Has(scenario.key) {
- t.Errorf("(%d) Expected key %q to not be set", i, scenario.key)
- }
-
- val := s.Get(scenario.key)
- if scenario.expected && val != scenario.value {
- t.Errorf("(%d) Expected value %v, got %v", i, scenario.value, val)
- }
- }
-}
diff --git a/tools/subscriptions/broker.go b/tools/subscriptions/broker.go
deleted file mode 100644
index bdee3552cfdefe9bd9441c885f6c6ad6f762fd4b..0000000000000000000000000000000000000000
--- a/tools/subscriptions/broker.go
+++ /dev/null
@@ -1,64 +0,0 @@
-package subscriptions
-
-import (
- "fmt"
- "sync"
-)
-
-// Broker defines a struct for managing subscriptions clients.
-type Broker struct {
- mux sync.RWMutex
- clients map[string]Client
-}
-
-// NewBroker initializes and returns a new Broker instance.
-func NewBroker() *Broker {
- return &Broker{
- clients: make(map[string]Client),
- }
-}
-
-// Clients returns all registered clients.
-func (b *Broker) Clients() map[string]Client {
- b.mux.RLock()
- defer b.mux.RUnlock()
-
- return b.clients
-}
-
-// ClientById finds a registered client by its id.
-//
-// Returns non-nil error when client with clientId is not registered.
-func (b *Broker) ClientById(clientId string) (Client, error) {
- b.mux.RLock()
- defer b.mux.RUnlock()
-
- client, ok := b.clients[clientId]
- if !ok {
- return nil, fmt.Errorf("No client associated with connection ID %q", clientId)
- }
-
- return client, nil
-}
-
-// Register adds a new client to the broker instance.
-func (b *Broker) Register(client Client) {
- b.mux.Lock()
- defer b.mux.Unlock()
-
- b.clients[client.Id()] = client
-}
-
-// Unregister removes a single client by its id.
-//
-// If client with clientId doesn't exist, this method does nothing.
-func (b *Broker) Unregister(clientId string) {
- b.mux.Lock()
- defer b.mux.Unlock()
-
- // Note:
- // There is no need to explicitly close the client's channel since it will be GC-ed anyway.
- // Addinitionally, closing the channel explicitly could panic when there are several
- // subscriptions attached to the client that needs to receive the same event.
- delete(b.clients, clientId)
-}
diff --git a/tools/subscriptions/broker_test.go b/tools/subscriptions/broker_test.go
deleted file mode 100644
index 87774a61ec9302028c28a3d3609d2ffd898baef4..0000000000000000000000000000000000000000
--- a/tools/subscriptions/broker_test.go
+++ /dev/null
@@ -1,86 +0,0 @@
-package subscriptions_test
-
-import (
- "testing"
-
- "github.com/pocketbase/pocketbase/tools/subscriptions"
-)
-
-func TestNewBroker(t *testing.T) {
- b := subscriptions.NewBroker()
-
- if b.Clients() == nil {
- t.Fatal("Expected clients map to be initialized")
- }
-}
-
-func TestClients(t *testing.T) {
- b := subscriptions.NewBroker()
-
- if total := len(b.Clients()); total != 0 {
- t.Fatalf("Expected no clients, got %v", total)
- }
-
- b.Register(subscriptions.NewDefaultClient())
- b.Register(subscriptions.NewDefaultClient())
-
- if total := len(b.Clients()); total != 2 {
- t.Fatalf("Expected 2 clients, got %v", total)
- }
-}
-
-func TestClientById(t *testing.T) {
- b := subscriptions.NewBroker()
-
- clientA := subscriptions.NewDefaultClient()
- clientB := subscriptions.NewDefaultClient()
- b.Register(clientA)
- b.Register(clientB)
-
- resultClient, err := b.ClientById(clientA.Id())
- if err != nil {
- t.Fatalf("Expected client with id %s, got error %v", clientA.Id(), err)
- }
- if resultClient.Id() != clientA.Id() {
- t.Fatalf("Expected client %s, got %s", clientA.Id(), resultClient.Id())
- }
-
- if c, err := b.ClientById("missing"); err == nil {
- t.Fatalf("Expected error, found client %v", c)
- }
-}
-
-func TestRegister(t *testing.T) {
- b := subscriptions.NewBroker()
-
- client := subscriptions.NewDefaultClient()
- b.Register(client)
-
- if _, err := b.ClientById(client.Id()); err != nil {
- t.Fatalf("Expected client with id %s, got error %v", client.Id(), err)
- }
-}
-
-func TestUnregister(t *testing.T) {
- b := subscriptions.NewBroker()
-
- clientA := subscriptions.NewDefaultClient()
- clientB := subscriptions.NewDefaultClient()
- b.Register(clientA)
- b.Register(clientB)
-
- if _, err := b.ClientById(clientA.Id()); err != nil {
- t.Fatalf("Expected client with id %s, got error %v", clientA.Id(), err)
- }
-
- b.Unregister(clientA.Id())
-
- if c, err := b.ClientById(clientA.Id()); err == nil {
- t.Fatalf("Expected error, found client %v", c)
- }
-
- // clientB shouldn't have been removed
- if _, err := b.ClientById(clientB.Id()); err != nil {
- t.Fatalf("Expected client with id %s, got error %v", clientB.Id(), err)
- }
-}
diff --git a/tools/subscriptions/client.go b/tools/subscriptions/client.go
deleted file mode 100644
index c948a530a675bb57240460ce04f58aad438ad615..0000000000000000000000000000000000000000
--- a/tools/subscriptions/client.go
+++ /dev/null
@@ -1,141 +0,0 @@
-package subscriptions
-
-import (
- "sync"
-
- "github.com/pocketbase/pocketbase/tools/security"
-)
-
-// Message defines a client's channel data.
-type Message struct {
- Name string
- Data string
-}
-
-// Client is an interface for a generic subscription client.
-type Client interface {
- // Id Returns the unique id of the client.
- Id() string
-
- // Channel returns the client's communication channel.
- Channel() chan Message
-
- // Subscriptions returns all subscriptions to which the client has subscribed to.
- Subscriptions() map[string]struct{}
-
- // Subscribe subscribes the client to the provided subscriptions list.
- Subscribe(subs ...string)
-
- // Unsubscribe unsubscribes the client from the provided subscriptions list.
- Unsubscribe(subs ...string)
-
- // HasSubscription checks if the client is subscribed to `sub`.
- HasSubscription(sub string) bool
-
- // Set stores any value to the client's context.
- Set(key string, value any)
-
- // Get retrieves the key value from the client's context.
- Get(key string) any
-}
-
-// ensures that DefaultClient satisfies the Client interface
-var _ Client = (*DefaultClient)(nil)
-
-// DefaultClient defines a generic subscription client.
-type DefaultClient struct {
- mux sync.RWMutex
- id string
- store map[string]any
- channel chan Message
- subscriptions map[string]struct{}
-}
-
-// NewDefaultClient creates and returns a new DefaultClient instance.
-func NewDefaultClient() *DefaultClient {
- return &DefaultClient{
- id: security.RandomString(40),
- store: map[string]any{},
- channel: make(chan Message),
- subscriptions: make(map[string]struct{}),
- }
-}
-
-// Id implements the [Client.Id] interface method.
-func (c *DefaultClient) Id() string {
- return c.id
-}
-
-// Channel implements the [Client.Channel] interface method.
-func (c *DefaultClient) Channel() chan Message {
- return c.channel
-}
-
-// Subscriptions implements the [Client.Subscriptions] interface method.
-func (c *DefaultClient) Subscriptions() map[string]struct{} {
- c.mux.RLock()
- defer c.mux.RUnlock()
-
- return c.subscriptions
-}
-
-// Subscribe implements the [Client.Subscribe] interface method.
-//
-// Empty subscriptions (aka. "") are ignored.
-func (c *DefaultClient) Subscribe(subs ...string) {
- c.mux.Lock()
- defer c.mux.Unlock()
-
- for _, s := range subs {
- if s == "" {
- continue // skip empty
- }
-
- c.subscriptions[s] = struct{}{}
- }
-}
-
-// Unsubscribe implements the [Client.Unsubscribe] interface method.
-//
-// If subs is not set, this method removes all registered client's subscriptions.
-func (c *DefaultClient) Unsubscribe(subs ...string) {
- c.mux.Lock()
- defer c.mux.Unlock()
-
- if len(subs) > 0 {
- for _, s := range subs {
- delete(c.subscriptions, s)
- }
- } else {
- // unsubscribe all
- for s := range c.subscriptions {
- delete(c.subscriptions, s)
- }
- }
-}
-
-// HasSubscription implements the [Client.HasSubscription] interface method.
-func (c *DefaultClient) HasSubscription(sub string) bool {
- c.mux.RLock()
- defer c.mux.RUnlock()
-
- _, ok := c.subscriptions[sub]
-
- return ok
-}
-
-// Get implements the [Client.Get] interface method.
-func (c *DefaultClient) Get(key string) any {
- c.mux.RLock()
- defer c.mux.RUnlock()
-
- return c.store[key]
-}
-
-// Set implements the [Client.Set] interface method.
-func (c *DefaultClient) Set(key string, value any) {
- c.mux.Lock()
- defer c.mux.Unlock()
-
- c.store[key] = value
-}
diff --git a/tools/subscriptions/client_test.go b/tools/subscriptions/client_test.go
deleted file mode 100644
index b26ae68581865698960497408f20bb194dbbe60f..0000000000000000000000000000000000000000
--- a/tools/subscriptions/client_test.go
+++ /dev/null
@@ -1,131 +0,0 @@
-package subscriptions_test
-
-import (
- "testing"
-
- "github.com/pocketbase/pocketbase/tools/subscriptions"
-)
-
-func TestNewDefaultClient(t *testing.T) {
- c := subscriptions.NewDefaultClient()
-
- if c.Channel() == nil {
- t.Errorf("Expected channel to be initialized")
- }
-
- if c.Subscriptions() == nil {
- t.Errorf("Expected subscriptions map to be initialized")
- }
-
- if c.Id() == "" {
- t.Errorf("Expected unique id to be set")
- }
-}
-
-func TestId(t *testing.T) {
- clients := []*subscriptions.DefaultClient{
- subscriptions.NewDefaultClient(),
- subscriptions.NewDefaultClient(),
- subscriptions.NewDefaultClient(),
- subscriptions.NewDefaultClient(),
- }
-
- ids := map[string]struct{}{}
- for i, c := range clients {
- // check uniqueness
- if _, ok := ids[c.Id()]; ok {
- t.Errorf("(%d) Expected unique id, got %v", i, c.Id())
- } else {
- ids[c.Id()] = struct{}{}
- }
-
- // check length
- if len(c.Id()) != 40 {
- t.Errorf("(%d) Expected unique id to have 40 chars length, got %v", i, c.Id())
- }
- }
-}
-
-func TestChannel(t *testing.T) {
- c := subscriptions.NewDefaultClient()
-
- if c.Channel() == nil {
- t.Errorf("Expected channel to be initialized, got")
- }
-}
-
-func TestSubscriptions(t *testing.T) {
- c := subscriptions.NewDefaultClient()
-
- if len(c.Subscriptions()) != 0 {
- t.Errorf("Expected subscriptions to be empty")
- }
-
- c.Subscribe("sub1", "sub2", "sub3")
-
- if len(c.Subscriptions()) != 3 {
- t.Errorf("Expected 3 subscriptions, got %v", c.Subscriptions())
- }
-}
-
-func TestSubscribe(t *testing.T) {
- c := subscriptions.NewDefaultClient()
-
- subs := []string{"", "sub1", "sub2", "sub3"}
- expected := []string{"sub1", "sub2", "sub3"}
-
- c.Subscribe(subs...) // empty string should be skipped
-
- if len(c.Subscriptions()) != 3 {
- t.Errorf("Expected 3 subscriptions, got %v", c.Subscriptions())
- }
-
- for i, s := range expected {
- if !c.HasSubscription(s) {
- t.Errorf("(%d) Expected sub %s", i, s)
- }
- }
-}
-
-func TestUnsubscribe(t *testing.T) {
- c := subscriptions.NewDefaultClient()
-
- c.Subscribe("sub1", "sub2", "sub3")
-
- c.Unsubscribe("sub1")
-
- if c.HasSubscription("sub1") {
- t.Error("Expected sub1 to be removed")
- }
-
- c.Unsubscribe( /* all */ )
- if len(c.Subscriptions()) != 0 {
- t.Errorf("Expected all subscriptions to be removed, got %v", c.Subscriptions())
- }
-}
-
-func TestHasSubscription(t *testing.T) {
- c := subscriptions.NewDefaultClient()
-
- if c.HasSubscription("missing") {
- t.Error("Expected false, got true")
- }
-
- c.Subscribe("sub")
-
- if !c.HasSubscription("sub") {
- t.Error("Expected true, got false")
- }
-}
-
-func TestSetAndGet(t *testing.T) {
- c := subscriptions.NewDefaultClient()
-
- c.Set("demo", 1)
-
- result, _ := c.Get("demo").(int)
-
- if result != 1 {
- t.Errorf("Expected 1, got %v", result)
- }
-}
diff --git a/tools/types/datetime.go b/tools/types/datetime.go
deleted file mode 100644
index 27036dd3c60685b71f662e0fadf5aefe6cd6cd21..0000000000000000000000000000000000000000
--- a/tools/types/datetime.go
+++ /dev/null
@@ -1,93 +0,0 @@
-package types
-
-import (
- "database/sql/driver"
- "encoding/json"
- "time"
-
- "github.com/spf13/cast"
-)
-
-// DefaultDateLayout specifies the default app date strings layout.
-const DefaultDateLayout = "2006-01-02 15:04:05.000Z"
-
-// NowDateTime returns new DateTime instance with the current local time.
-func NowDateTime() DateTime {
- return DateTime{t: time.Now()}
-}
-
-// ParseDateTime creates a new DateTime from the provided value
-// (could be [cast.ToTime] supported string, [time.Time], etc.).
-func ParseDateTime(value any) (DateTime, error) {
- d := DateTime{}
- err := d.Scan(value)
- return d, err
-}
-
-// DateTime represents a [time.Time] instance in UTC that is wrapped
-// and serialized using the app default date layout.
-type DateTime struct {
- t time.Time
-}
-
-// Time returns the internal [time.Time] instance.
-func (d DateTime) Time() time.Time {
- return d.t
-}
-
-// IsZero checks whether the current DateTime instance has zero time value.
-func (d DateTime) IsZero() bool {
- return d.Time().IsZero()
-}
-
-// String serializes the current DateTime instance into a formatted
-// UTC date string.
-//
-// The zero value is serialized to an empty string.
-func (d DateTime) String() string {
- if d.IsZero() {
- return ""
- }
- return d.Time().UTC().Format(DefaultDateLayout)
-}
-
-// MarshalJSON implements the [json.Marshaler] interface.
-func (d DateTime) MarshalJSON() ([]byte, error) {
- return json.Marshal(d.String())
-}
-
-// UnmarshalJSON implements the [json.Unmarshaler] interface.
-func (d *DateTime) UnmarshalJSON(b []byte) error {
- var raw string
- if err := json.Unmarshal(b, &raw); err != nil {
- return err
- }
- return d.Scan(raw)
-}
-
-// Value implements the [driver.Valuer] interface.
-func (d DateTime) Value() (driver.Value, error) {
- return d.String(), nil
-}
-
-// Scan implements [sql.Scanner] interface to scan the provided value
-// into the current DateTime instance.
-func (d *DateTime) Scan(value any) error {
- switch v := value.(type) {
- case DateTime:
- d.t = v.Time()
- case time.Time:
- d.t = v
- case int:
- d.t = cast.ToTime(v)
- default:
- str := cast.ToString(v)
- if str == "" {
- d.t = time.Time{}
- } else {
- d.t = cast.ToTime(str)
- }
- }
-
- return nil
-}
diff --git a/tools/types/datetime_test.go b/tools/types/datetime_test.go
deleted file mode 100644
index 3091518031cf5f9754f7ef3f266673e5e4f957b5..0000000000000000000000000000000000000000
--- a/tools/types/datetime_test.go
+++ /dev/null
@@ -1,199 +0,0 @@
-package types_test
-
-import (
- "strings"
- "testing"
- "time"
-
- "github.com/pocketbase/pocketbase/tools/types"
-)
-
-func TestNowDateTime(t *testing.T) {
- now := time.Now().UTC().Format("2006-01-02 15:04:05") // without ms part for test consistency
- dt := types.NowDateTime()
-
- if !strings.Contains(dt.String(), now) {
- t.Fatalf("Expected %q, got %q", now, dt.String())
- }
-}
-
-func TestParseDateTime(t *testing.T) {
- nowTime := time.Now().UTC()
- nowDateTime, _ := types.ParseDateTime(nowTime)
- nowStr := nowTime.Format(types.DefaultDateLayout)
-
- scenarios := []struct {
- value any
- expected string
- }{
- {nil, ""},
- {"", ""},
- {"invalid", ""},
- {nowDateTime, nowStr},
- {nowTime, nowStr},
- {1641024040, "2022-01-01 08:00:40.000Z"},
- {"2022-01-01 11:23:45.678", "2022-01-01 11:23:45.678Z"},
- }
-
- for i, s := range scenarios {
- dt, err := types.ParseDateTime(s.value)
- if err != nil {
- t.Errorf("(%d) Failed to parse %v: %v", i, s.value, err)
- continue
- }
-
- if dt.String() != s.expected {
- t.Errorf("(%d) Expected %q, got %q", i, s.expected, dt.String())
- }
- }
-}
-
-func TestDateTimeTime(t *testing.T) {
- str := "2022-01-01 11:23:45.678Z"
-
- expected, err := time.Parse(types.DefaultDateLayout, str)
- if err != nil {
- t.Fatal(err)
- }
-
- dt, err := types.ParseDateTime(str)
- if err != nil {
- t.Fatal(err)
- }
-
- result := dt.Time()
-
- if !expected.Equal(result) {
- t.Errorf("Expected time %v, got %v", expected, result)
- }
-}
-
-func TestDateTimeIsZero(t *testing.T) {
- dt0 := types.DateTime{}
- if !dt0.IsZero() {
- t.Fatalf("Expected zero datatime, got %v", dt0)
- }
-
- dt1 := types.NowDateTime()
- if dt1.IsZero() {
- t.Fatalf("Expected non-zero datatime, got %v", dt1)
- }
-}
-
-func TestDateTimeString(t *testing.T) {
- dt0 := types.DateTime{}
- if dt0.String() != "" {
- t.Fatalf("Expected empty string for zer datetime, got %q", dt0.String())
- }
-
- expected := "2022-01-01 11:23:45.678Z"
- dt1, _ := types.ParseDateTime(expected)
- if dt1.String() != expected {
- t.Fatalf("Expected %q, got %v", expected, dt1)
- }
-}
-
-func TestDateTimeMarshalJSON(t *testing.T) {
- scenarios := []struct {
- date string
- expected string
- }{
- {"", `""`},
- {"2022-01-01 11:23:45.678", `"2022-01-01 11:23:45.678Z"`},
- }
-
- for i, s := range scenarios {
- dt, err := types.ParseDateTime(s.date)
- if err != nil {
- t.Errorf("(%d) %v", i, err)
- }
-
- result, err := dt.MarshalJSON()
- if err != nil {
- t.Errorf("(%d) %v", i, err)
- }
-
- if string(result) != s.expected {
- t.Errorf("(%d) Expected %q, got %q", i, s.expected, string(result))
- }
- }
-}
-
-func TestDateTimeUnmarshalJSON(t *testing.T) {
- scenarios := []struct {
- date string
- expected string
- }{
- {"", ""},
- {"invalid_json", ""},
- {"'123'", ""},
- {"2022-01-01 11:23:45.678", ""},
- {`"2022-01-01 11:23:45.678"`, "2022-01-01 11:23:45.678Z"},
- }
-
- for i, s := range scenarios {
- dt := types.DateTime{}
- dt.UnmarshalJSON([]byte(s.date))
-
- if dt.String() != s.expected {
- t.Errorf("(%d) Expected %q, got %q", i, s.expected, dt.String())
- }
- }
-}
-
-func TestDateTimeValue(t *testing.T) {
- scenarios := []struct {
- value any
- expected string
- }{
- {"", ""},
- {"invalid", ""},
- {1641024040, "2022-01-01 08:00:40.000Z"},
- {"2022-01-01 11:23:45.678", "2022-01-01 11:23:45.678Z"},
- {types.NowDateTime(), types.NowDateTime().String()},
- }
-
- for i, s := range scenarios {
- dt, _ := types.ParseDateTime(s.value)
- result, err := dt.Value()
- if err != nil {
- t.Errorf("(%d) %v", i, err)
- continue
- }
-
- if result != s.expected {
- t.Errorf("(%d) Expected %q, got %q", i, s.expected, result)
- }
- }
-}
-
-func TestDateTimeScan(t *testing.T) {
- now := time.Now().UTC().Format("2006-01-02 15:04:05") // without ms part for test consistency
-
- scenarios := []struct {
- value any
- expected string
- }{
- {nil, ""},
- {"", ""},
- {"invalid", ""},
- {types.NowDateTime(), now},
- {time.Now(), now},
- {1641024040, "2022-01-01 08:00:40.000Z"},
- {"2022-01-01 11:23:45.678", "2022-01-01 11:23:45.678Z"},
- }
-
- for i, s := range scenarios {
- dt := types.DateTime{}
-
- err := dt.Scan(s.value)
- if err != nil {
- t.Errorf("(%d) Failed to parse %v: %v", i, s.value, err)
- continue
- }
-
- if !strings.Contains(dt.String(), s.expected) {
- t.Errorf("(%d) Expected %q, got %q", i, s.expected, dt.String())
- }
- }
-}
diff --git a/tools/types/json_array.go b/tools/types/json_array.go
deleted file mode 100644
index 2b555268d17d149bb442568f459c36ddf93ac6f2..0000000000000000000000000000000000000000
--- a/tools/types/json_array.go
+++ /dev/null
@@ -1,51 +0,0 @@
-package types
-
-import (
- "database/sql/driver"
- "encoding/json"
- "fmt"
-)
-
-// JsonArray defines a slice that is safe for json and db read/write.
-type JsonArray []any
-
-// MarshalJSON implements the [json.Marshaler] interface.
-func (m JsonArray) MarshalJSON() ([]byte, error) {
- type alias JsonArray // prevent recursion
-
- // initialize an empty map to ensure that `[]` is returned as json
- if m == nil {
- m = JsonArray{}
- }
-
- return json.Marshal(alias(m))
-}
-
-// Value implements the [driver.Valuer] interface.
-func (m JsonArray) Value() (driver.Value, error) {
- data, err := json.Marshal(m)
-
- return string(data), err
-}
-
-// Scan implements [sql.Scanner] interface to scan the provided value
-// into the current `JsonArray` instance.
-func (m *JsonArray) Scan(value any) error {
- var data []byte
- switch v := value.(type) {
- case nil:
- // no cast needed
- case []byte:
- data = v
- case string:
- data = []byte(v)
- default:
- return fmt.Errorf("Failed to unmarshal JsonArray value: %q.", value)
- }
-
- if len(data) == 0 {
- data = []byte("[]")
- }
-
- return json.Unmarshal(data, m)
-}
diff --git a/tools/types/json_array_test.go b/tools/types/json_array_test.go
deleted file mode 100644
index bbe239a020f8dd5c9f93044f3140c8433564d2ba..0000000000000000000000000000000000000000
--- a/tools/types/json_array_test.go
+++ /dev/null
@@ -1,95 +0,0 @@
-package types_test
-
-import (
- "database/sql/driver"
- "testing"
-
- "github.com/pocketbase/pocketbase/tools/types"
-)
-
-func TestJsonArrayMarshalJSON(t *testing.T) {
- scenarios := []struct {
- json types.JsonArray
- expected string
- }{
- {nil, "[]"},
- {types.JsonArray{}, `[]`},
- {types.JsonArray{1, 2, 3}, `[1,2,3]`},
- {types.JsonArray{"test1", "test2", "test3"}, `["test1","test2","test3"]`},
- {types.JsonArray{1, "test"}, `[1,"test"]`},
- }
-
- for i, s := range scenarios {
- result, err := s.json.MarshalJSON()
- if err != nil {
- t.Errorf("(%d) %v", i, err)
- continue
- }
- if string(result) != s.expected {
- t.Errorf("(%d) Expected %s, got %s", i, s.expected, string(result))
- }
- }
-}
-
-func TestJsonArrayValue(t *testing.T) {
- scenarios := []struct {
- json types.JsonArray
- expected driver.Value
- }{
- {nil, `[]`},
- {types.JsonArray{}, `[]`},
- {types.JsonArray{1, 2, 3}, `[1,2,3]`},
- {types.JsonArray{"test1", "test2", "test3"}, `["test1","test2","test3"]`},
- {types.JsonArray{1, "test"}, `[1,"test"]`},
- }
-
- for i, s := range scenarios {
- result, err := s.json.Value()
- if err != nil {
- t.Errorf("(%d) %v", i, err)
- continue
- }
- if result != s.expected {
- t.Errorf("(%d) Expected %s, got %v", i, s.expected, result)
- }
- }
-}
-
-func TestJsonArrayScan(t *testing.T) {
- scenarios := []struct {
- value any
- expectError bool
- expectJson string
- }{
- {``, false, `[]`},
- {[]byte{}, false, `[]`},
- {nil, false, `[]`},
- {123, true, `[]`},
- {`""`, true, `[]`},
- {`invalid_json`, true, `[]`},
- {`"test"`, true, `[]`},
- {`1,2,3`, true, `[]`},
- {`[1, 2, 3`, true, `[]`},
- {`[1, 2, 3]`, false, `[1,2,3]`},
- {[]byte(`[1, 2, 3]`), false, `[1,2,3]`},
- {`[1, "test"]`, false, `[1,"test"]`},
- {`[]`, false, `[]`},
- }
-
- for i, s := range scenarios {
- arr := types.JsonArray{}
- scanErr := arr.Scan(s.value)
-
- hasErr := scanErr != nil
- if hasErr != s.expectError {
- t.Errorf("(%d) Expected %v, got %v (%v)", i, s.expectError, hasErr, scanErr)
- continue
- }
-
- result, _ := arr.MarshalJSON()
-
- if string(result) != s.expectJson {
- t.Errorf("(%d) Expected %s, got %v", i, s.expectJson, string(result))
- }
- }
-}
diff --git a/tools/types/json_map.go b/tools/types/json_map.go
deleted file mode 100644
index 6358959cd91d57172c2e094042e4f0a494175510..0000000000000000000000000000000000000000
--- a/tools/types/json_map.go
+++ /dev/null
@@ -1,51 +0,0 @@
-package types
-
-import (
- "database/sql/driver"
- "encoding/json"
- "fmt"
-)
-
-// JsonMap defines a map that is safe for json and db read/write.
-type JsonMap map[string]any
-
-// MarshalJSON implements the [json.Marshaler] interface.
-func (m JsonMap) MarshalJSON() ([]byte, error) {
- type alias JsonMap // prevent recursion
-
- // initialize an empty map to ensure that `{}` is returned as json
- if m == nil {
- m = JsonMap{}
- }
-
- return json.Marshal(alias(m))
-}
-
-// Value implements the [driver.Valuer] interface.
-func (m JsonMap) Value() (driver.Value, error) {
- data, err := json.Marshal(m)
-
- return string(data), err
-}
-
-// Scan implements [sql.Scanner] interface to scan the provided value
-// into the current `JsonMap` instance.
-func (m *JsonMap) Scan(value any) error {
- var data []byte
- switch v := value.(type) {
- case nil:
- // no cast needed
- case []byte:
- data = v
- case string:
- data = []byte(v)
- default:
- return fmt.Errorf("Failed to unmarshal JsonMap value: %q.", value)
- }
-
- if len(data) == 0 {
- data = []byte("{}")
- }
-
- return json.Unmarshal(data, m)
-}
diff --git a/tools/types/json_map_test.go b/tools/types/json_map_test.go
deleted file mode 100644
index c0e5628d3cf01365e5a600261009d34b09938db2..0000000000000000000000000000000000000000
--- a/tools/types/json_map_test.go
+++ /dev/null
@@ -1,92 +0,0 @@
-package types_test
-
-import (
- "database/sql/driver"
- "testing"
-
- "github.com/pocketbase/pocketbase/tools/types"
-)
-
-func TestJsonMapMarshalJSON(t *testing.T) {
- scenarios := []struct {
- json types.JsonMap
- expected string
- }{
- {nil, "{}"},
- {types.JsonMap{}, `{}`},
- {types.JsonMap{"test1": 123, "test2": "lorem"}, `{"test1":123,"test2":"lorem"}`},
- {types.JsonMap{"test": []int{1, 2, 3}}, `{"test":[1,2,3]}`},
- }
-
- for i, s := range scenarios {
- result, err := s.json.MarshalJSON()
- if err != nil {
- t.Errorf("(%d) %v", i, err)
- continue
- }
- if string(result) != s.expected {
- t.Errorf("(%d) Expected %s, got %s", i, s.expected, string(result))
- }
- }
-}
-
-func TestJsonMapValue(t *testing.T) {
- scenarios := []struct {
- json types.JsonMap
- expected driver.Value
- }{
- {nil, `{}`},
- {types.JsonMap{}, `{}`},
- {types.JsonMap{"test1": 123, "test2": "lorem"}, `{"test1":123,"test2":"lorem"}`},
- {types.JsonMap{"test": []int{1, 2, 3}}, `{"test":[1,2,3]}`},
- }
-
- for i, s := range scenarios {
- result, err := s.json.Value()
- if err != nil {
- t.Errorf("(%d) %v", i, err)
- continue
- }
- if result != s.expected {
- t.Errorf("(%d) Expected %s, got %v", i, s.expected, result)
- }
- }
-}
-
-func TestJsonArrayMapScan(t *testing.T) {
- scenarios := []struct {
- value any
- expectError bool
- expectJson string
- }{
- {``, false, `{}`},
- {nil, false, `{}`},
- {[]byte{}, false, `{}`},
- {`{}`, false, `{}`},
- {123, true, `{}`},
- {`""`, true, `{}`},
- {`invalid_json`, true, `{}`},
- {`"test"`, true, `{}`},
- {`1,2,3`, true, `{}`},
- {`{"test": 1`, true, `{}`},
- {`{"test": 1}`, false, `{"test":1}`},
- {[]byte(`{"test": 1}`), false, `{"test":1}`},
- }
-
- for i, s := range scenarios {
- arr := types.JsonMap{}
- scanErr := arr.Scan(s.value)
-
- hasErr := scanErr != nil
- if hasErr != s.expectError {
- t.Errorf("(%d) Expected %v, got %v (%v)", i, s.expectError, hasErr, scanErr)
- continue
- }
-
- result, _ := arr.MarshalJSON()
-
- if string(result) != s.expectJson {
- t.Errorf("(%d) Expected %s, got %v", i, s.expectJson, string(result))
- }
- }
-}
diff --git a/tools/types/json_raw.go b/tools/types/json_raw.go
deleted file mode 100644
index 7f5defe54ef025734b18c2978cd98c21b7c43fb3..0000000000000000000000000000000000000000
--- a/tools/types/json_raw.go
+++ /dev/null
@@ -1,83 +0,0 @@
-package types
-
-import (
- "database/sql/driver"
- "encoding/json"
- "errors"
-)
-
-// JsonRaw defines a json value type that is safe for db read/write.
-type JsonRaw []byte
-
-// ParseJsonRaw creates a new JsonRaw instance from the provided value
-// (could be JsonRaw, int, float, string, []byte, etc.).
-func ParseJsonRaw(value any) (JsonRaw, error) {
- result := JsonRaw{}
- err := result.Scan(value)
- return result, err
-}
-
-// String returns the current JsonRaw instance as a json encoded string.
-func (j JsonRaw) String() string {
- return string(j)
-}
-
-// MarshalJSON implements the [json.Marshaler] interface.
-func (j JsonRaw) MarshalJSON() ([]byte, error) {
- if len(j) == 0 {
- return []byte("null"), nil
- }
-
- return j, nil
-}
-
-// UnmarshalJSON implements the [json.Unmarshaler] interface.
-func (j *JsonRaw) UnmarshalJSON(b []byte) error {
- if j == nil {
- return errors.New("JsonRaw: UnmarshalJSON on nil pointer")
- }
-
- *j = append((*j)[0:0], b...)
-
- return nil
-}
-
-// Value implements the [driver.Valuer] interface.
-func (j JsonRaw) Value() (driver.Value, error) {
- if len(j) == 0 {
- return nil, nil
- }
-
- return j.String(), nil
-}
-
-// Scan implements [sql.Scanner] interface to scan the provided value
-// into the current JsonRaw instance.
-func (j *JsonRaw) Scan(value interface{}) error {
- var data []byte
-
- switch v := value.(type) {
- case nil:
- // no cast is needed
- case []byte:
- if len(v) != 0 {
- data = v
- }
- case string:
- if v != "" {
- data = []byte(v)
- }
- case JsonRaw:
- if len(v) != 0 {
- data = []byte(v)
- }
- default:
- bytes, err := json.Marshal(v)
- if err != nil {
- return err
- }
- data = bytes
- }
-
- return j.UnmarshalJSON(data)
-}
diff --git a/tools/types/json_raw_test.go b/tools/types/json_raw_test.go
deleted file mode 100644
index 6683b3ff1833dc3ed70afca8e5dadf11f4c11e38..0000000000000000000000000000000000000000
--- a/tools/types/json_raw_test.go
+++ /dev/null
@@ -1,178 +0,0 @@
-package types_test
-
-import (
- "database/sql/driver"
- "testing"
-
- "github.com/pocketbase/pocketbase/tools/types"
-)
-
-func TestParseJsonRaw(t *testing.T) {
- scenarios := []struct {
- value any
- expectError bool
- expectJson string
- }{
- {nil, false, `null`},
- {``, false, `null`},
- {[]byte{}, false, `null`},
- {types.JsonRaw{}, false, `null`},
- {`{}`, false, `{}`},
- {`[]`, false, `[]`},
- {123, false, `123`},
- {`""`, false, `""`},
- {`test`, false, `test`},
- {`{"invalid"`, false, `{"invalid"`}, // treated as a byte casted string
- {`{"test":1}`, false, `{"test":1}`},
- {[]byte(`[1,2,3]`), false, `[1,2,3]`},
- {[]int{1, 2, 3}, false, `[1,2,3]`},
- {map[string]int{"test": 1}, false, `{"test":1}`},
- }
-
- for i, s := range scenarios {
- raw, parseErr := types.ParseJsonRaw(s.value)
- hasErr := parseErr != nil
- if hasErr != s.expectError {
- t.Errorf("(%d) Expected %v, got %v (%v)", i, s.expectError, hasErr, parseErr)
- continue
- }
-
- result, _ := raw.MarshalJSON()
-
- if string(result) != s.expectJson {
- t.Errorf("(%d) Expected %s, got %v", i, s.expectJson, string(result))
- }
- }
-}
-
-func TestJsonRawString(t *testing.T) {
- scenarios := []struct {
- json types.JsonRaw
- expected string
- }{
- {nil, ``},
- {types.JsonRaw{}, ``},
- {types.JsonRaw([]byte(`123`)), `123`},
- {types.JsonRaw(`{"demo":123}`), `{"demo":123}`},
- }
-
- for i, s := range scenarios {
- result := s.json.String()
- if result != s.expected {
- t.Errorf("(%d) Expected %q, got %q", i, s.expected, result)
- }
- }
-}
-
-func TestJsonRawMarshalJSON(t *testing.T) {
- scenarios := []struct {
- json types.JsonRaw
- expected string
- }{
- {nil, `null`},
- {types.JsonRaw{}, `null`},
- {types.JsonRaw([]byte(`123`)), `123`},
- {types.JsonRaw(`{"demo":123}`), `{"demo":123}`},
- }
-
- for i, s := range scenarios {
- result, err := s.json.MarshalJSON()
- if err != nil {
- t.Errorf("(%d) %v", i, err)
- continue
- }
-
- if string(result) != s.expected {
- t.Errorf("(%d) Expected %q, got %q", i, s.expected, string(result))
- }
- }
-}
-
-func TestJsonRawUnmarshalJSON(t *testing.T) {
- scenarios := []struct {
- json []byte
- expectString string
- }{
- {nil, ""},
- {[]byte{0, 1, 2}, "\x00\x01\x02"},
- {[]byte("123"), "123"},
- {[]byte("test"), "test"},
- {[]byte(`{"test":123}`), `{"test":123}`},
- }
-
- for i, s := range scenarios {
- raw := types.JsonRaw{}
- err := raw.UnmarshalJSON(s.json)
- if err != nil {
- t.Errorf("(%d) %v", i, err)
- continue
- }
-
- if raw.String() != s.expectString {
- t.Errorf("(%d) Expected %q, got %q", i, s.expectString, raw.String())
- }
- }
-}
-
-func TestJsonRawValue(t *testing.T) {
- scenarios := []struct {
- json types.JsonRaw
- expected driver.Value
- }{
- {nil, nil},
- {types.JsonRaw{}, nil},
- {types.JsonRaw(``), nil},
- {types.JsonRaw(`test`), `test`},
- }
-
- for i, s := range scenarios {
- result, err := s.json.Value()
- if err != nil {
- t.Errorf("(%d) %v", i, err)
- continue
- }
- if result != s.expected {
- t.Errorf("(%d) Expected %s, got %v", i, s.expected, result)
- }
- }
-}
-
-func TestJsonRawScan(t *testing.T) {
- scenarios := []struct {
- value any
- expectError bool
- expectJson string
- }{
- {nil, false, `null`},
- {``, false, `null`},
- {[]byte{}, false, `null`},
- {types.JsonRaw{}, false, `null`},
- {types.JsonRaw(`test`), false, `test`},
- {`{}`, false, `{}`},
- {`[]`, false, `[]`},
- {123, false, `123`},
- {`""`, false, `""`},
- {`test`, false, `test`},
- {`{"invalid"`, false, `{"invalid"`}, // treated as a byte casted string
- {`{"test":1}`, false, `{"test":1}`},
- {[]byte(`[1,2,3]`), false, `[1,2,3]`},
- {[]int{1, 2, 3}, false, `[1,2,3]`},
- {map[string]int{"test": 1}, false, `{"test":1}`},
- }
-
- for i, s := range scenarios {
- raw := types.JsonRaw{}
- scanErr := raw.Scan(s.value)
- hasErr := scanErr != nil
- if hasErr != s.expectError {
- t.Errorf("(%d) Expected %v, got %v (%v)", i, s.expectError, hasErr, scanErr)
- continue
- }
-
- result, _ := raw.MarshalJSON()
-
- if string(result) != s.expectJson {
- t.Errorf("(%d) Expected %s, got %v", i, s.expectJson, string(result))
- }
- }
-}
diff --git a/tools/types/types.go b/tools/types/types.go
deleted file mode 100644
index c07d80541dd1f2223fe0d2be11d5d749ad31095b..0000000000000000000000000000000000000000
--- a/tools/types/types.go
+++ /dev/null
@@ -1,8 +0,0 @@
-// Package types implements some commonly used db serializable types
-// like datetime, json, etc.
-package types
-
-// Pointer is a generic helper that returns val as *T.
-func Pointer[T any](val T) *T {
- return &val
-}
diff --git a/tools/types/types_test.go b/tools/types/types_test.go
deleted file mode 100644
index 615ac4c61ea9696637a60dce77d4ee817405def3..0000000000000000000000000000000000000000
--- a/tools/types/types_test.go
+++ /dev/null
@@ -1,24 +0,0 @@
-package types_test
-
-import (
- "testing"
-
- "github.com/pocketbase/pocketbase/tools/types"
-)
-
-func TestPointer(t *testing.T) {
- s1 := types.Pointer("")
- if s1 == nil || *s1 != "" {
- t.Fatalf("Expected empty string pointer, got %#v", s1)
- }
-
- s2 := types.Pointer("test")
- if s2 == nil || *s2 != "test" {
- t.Fatalf("Expected 'test' string pointer, got %#v", s2)
- }
-
- s3 := types.Pointer(123)
- if s3 == nil || *s3 != 123 {
- t.Fatalf("Expected 123 string pointer, got %#v", s3)
- }
-}
diff --git a/tools/types/untitled.js.erb b/tools/types/untitled.js.erb
deleted file mode 100644
index 93939fcfa02ab3f037fadb721b77c43186918aea..0000000000000000000000000000000000000000
--- a/tools/types/untitled.js.erb
+++ /dev/null
@@ -1,27 +0,0 @@
-const { exec } = require('node:child_process');
-
-// you can use any other library for copying directories recursively
-const fse = require('fs-extra');
-
-let controller; // this will be used to terminate the PocketBase process
-
-const srcTestDirPath = "./test_pb_data";
-const tempTestDirPath = "./temp_test_pb_data";
-
-beforeEach(() => {
- // copy test_pb_date to a temp location
- fse.copySync(srcTestDirPath, tempTestDirPath);
-
- controller = new AbortController();
-
- // start PocketBase with the test_pb_data
- exec('./pocketbase serve --dir=' + tempTestDirPath, { signal: controller.signal});
-});
-
-afterEach(() => {
- // stop the PocketBase process
- controller.abort();
-
- // clean up the temp test directory
- fse.removeSync(tempTestDirPath);
-});
diff --git a/types.go b/types.go
new file mode 100644
index 0000000000000000000000000000000000000000..20e62b3ca92e90805bd87c7ccd2fc0fc01af5883
--- /dev/null
+++ b/types.go
@@ -0,0 +1,51 @@
+package main
+
+import "github.com/pocketbase/pocketbase/tools/types"
+
+type Response struct {
+ Status int64 `json:"status"`
+ Message map[string]interface{} `json:"message"`
+}
+
+type ErrorResponse struct {
+ Status int64 `json:"status"`
+ Error error `json:"error"`
+}
+
+type DistInfo struct {
+ Integrity string `json:"integrity"`
+ Tarball string `json:"tarball"`
+ FileCount int64 `json:"fileCount"`
+ UnpackedSize int64 `json:"unpackedSize"`
+}
+
+type VersionInfo struct {
+ Id string `json:"_id"`
+ Access []string `json:"_maintainers"`
+ Version string `json:"version"`
+ Published types.DateTime `json:"published"`
+ Description string `json:"description"`
+ Author string `json:"author"`
+ License string `json:"license"`
+ Private bool `json:"private"`
+ Dependencies map[string]string `json:"dependencies"`
+ Dist DistInfo `json:"dist"`
+}
+
+type PackageInfo struct {
+ Id string `json:"_id"`
+ Name string `json:"name"`
+ License string `json:"license"`
+ Description string `json:"description"`
+ Versions map[string]VersionInfo `json:"versions"`
+ Times map[string]types.DateTime `json:"times"`
+ Dist DistInfo `json:"dist"`
+}
+
+type Result struct {
+ Page int `json:"page"`
+ PerPage int `json:"perPage"`
+ TotalItems int `json:"totalItems"`
+ TotalPages int `json:"totalPages"`
+ Packages any `json:"packages"`
+}
diff --git a/ui/.env b/ui/.env
deleted file mode 100644
index 6b4723356611560efb383d3c8bbd7fb30b6e031c..0000000000000000000000000000000000000000
--- a/ui/.env
+++ /dev/null
@@ -1,10 +0,0 @@
-# all environments should start with 'PB_' prefix
-PB_BACKEND_URL = "../"
-PB_INSTALLER_PARAM = "installer"
-PB_OAUTH2_EXAMPLE = "https://pocketbase.io/docs/authentication/#web-oauth2-integration"
-PB_RULES_SYNTAX_DOCS = "https://pocketbase.io/docs/api-rules-and-filters/"
-PB_FILE_UPLOAD_DOCS = "https://pocketbase.io/docs/files-handling/"
-PB_JS_SDK_URL = "https://github.com/pocketbase/js-sdk"
-PB_DART_SDK_URL = "https://github.com/pocketbase/dart-sdk"
-PB_RELEASES = "https://github.com/pocketbase/pocketbase/releases"
-PB_VERSION = "v0.9.0"
diff --git a/ui/.env.development b/ui/.env.development
deleted file mode 100644
index d00088b5ceb7223ae39eee6a51bab1e2128b7311..0000000000000000000000000000000000000000
--- a/ui/.env.development
+++ /dev/null
@@ -1 +0,0 @@
-PB_BACKEND_URL = "http://127.0.0.1:8090"
diff --git a/ui/.gitignore b/ui/.gitignore
deleted file mode 100644
index 631b5f8662a3ff1d7b9d781ced189a2a649dcc66..0000000000000000000000000000000000000000
--- a/ui/.gitignore
+++ /dev/null
@@ -1,7 +0,0 @@
-/node_modules/
-/.vscode/
-.DS_Store
-
-# exclude local env files
-.env.local
-.env.*.local
diff --git a/ui/README.md b/ui/README.md
deleted file mode 100644
index a0e650efd002a93222e617f2f84ec45cbefd517b..0000000000000000000000000000000000000000
--- a/ui/README.md
+++ /dev/null
@@ -1,24 +0,0 @@
-PocketBase Admin dashboard UI
-======================================================================
-
-This is the PocketBase Admin dashboard UI (built with Svelte and Vite).
-
-Although it could be used independently, it is mainly intended to be embedded
-as part of a PocketBase app executable (hence the `embed.go` file).
-
-The used admins avatars are from https://boringavatars.com/.
-
-## Development
-
-Download the repo and run the appropriate console commands:
-
-```sh
-# install dependencies
-npm install
-
-# start a dev server with hot reload at localhost:3000
-npm run dev
-
-# or generate production ready bundle in dist/ directory
-npm run build
-```
diff --git a/ui/dist/assets/AuthMethodsDocs.a60349f6.js b/ui/dist/assets/AuthMethodsDocs.a60349f6.js
deleted file mode 100644
index e8f970603b591256673fa5935ae18ad3b738bf6c..0000000000000000000000000000000000000000
--- a/ui/dist/assets/AuthMethodsDocs.a60349f6.js
+++ /dev/null
@@ -1,64 +0,0 @@
-import{S as ke,i as be,s as ge,e as r,w as b,b as g,c as _e,f as k,g as h,h as n,m as me,x as G,N as re,O as we,k as ve,P as Ce,n as Pe,t as L,a as Y,o as _,d as pe,Q as Me,C as Se,p as $e,r as H,u as je,M as Ae}from"./index.662e825a.js";import{S as Be}from"./SdkTabs.1e98a608.js";function ue(a,l,o){const s=a.slice();return s[5]=l[o],s}function de(a,l,o){const s=a.slice();return s[5]=l[o],s}function fe(a,l){let o,s=l[5].code+"",m,f,i,u;function d(){return l[4](l[5])}return{key:a,first:null,c(){o=r("button"),m=b(s),f=g(),k(o,"class","tab-item"),H(o,"active",l[1]===l[5].code),this.first=o},m(v,C){h(v,o,C),n(o,m),n(o,f),i||(u=je(o,"click",d),i=!0)},p(v,C){l=v,C&4&&s!==(s=l[5].code+"")&&G(m,s),C&6&&H(o,"active",l[1]===l[5].code)},d(v){v&&_(o),i=!1,u()}}}function he(a,l){let o,s,m,f;return s=new Ae({props:{content:l[5].body}}),{key:a,first:null,c(){o=r("div"),_e(s.$$.fragment),m=g(),k(o,"class","tab-item"),H(o,"active",l[1]===l[5].code),this.first=o},m(i,u){h(i,o,u),me(s,o,null),n(o,m),f=!0},p(i,u){l=i;const d={};u&4&&(d.content=l[5].body),s.$set(d),(!f||u&6)&&H(o,"active",l[1]===l[5].code)},i(i){f||(L(s.$$.fragment,i),f=!0)},o(i){Y(s.$$.fragment,i),f=!1},d(i){i&&_(o),pe(s)}}}function Oe(a){var ae,ne;let l,o,s=a[0].name+"",m,f,i,u,d,v,C,F=a[0].name+"",U,X,q,P,D,j,W,M,K,R,Q,A,Z,V,y=a[0].name+"",I,x,E,B,J,S,O,w=[],ee=new Map,te,T,p=[],le=new Map,$;P=new Be({props:{js:`
- import PocketBase from 'pocketbase';
-
- const pb = new PocketBase('${a[3]}');
-
- ...
-
- const result = await pb.collection('${(ae=a[0])==null?void 0:ae.name}').listAuthMethods();
- `,dart:`
- import 'package:pocketbase/pocketbase.dart';
-
- final pb = PocketBase('${a[3]}');
-
- ...
-
- final result = await pb.collection('${(ne=a[0])==null?void 0:ne.name}').listAuthMethods();
- `}});let z=a[2];const oe=e=>e[5].code;for(let e=0;e
-
- -
-
-
- Lorem ipsum
-Dolor sit amet
-- Verify -
-- -
-
-
-
-
-
-
-
-
-
-
-
- -
-
- ul.test1 -
- ul.test2 -
- ul.test3 -
-
-
- ol.test1 -
- ol.test2 -
- ol.test3 -
- Thanks,
- PocketBase team
-
This method is usually called by users on page/screen reload to ensure that the previously stored
- data in pb.authStore is still valid and up-to-date.
Authorization:TOKEN header",Q=p(),D=a("div"),D.textContent="Query parameters",W=p(),T=a("table"),G=a("thead"),G.innerHTML=`This action usually should be called right after the provider login page redirect.
-You could also check the - OAuth2 web integration example - .
`,g=p(),re(k.$$.fragment),y=p(),C=s("h6"),C.textContent="API details",N=p(),O=s("div"),L=s("strong"),L.textContent="POST",pe=p(),M=s("div"),D=s("p"),he=v("/api/collections/"),Q=s("strong"),z=v(x),be=v("/auth-with-oauth2"),K=p(),q=s("div"),q.textContent="Body Parameters",Y=p(),I=s("table"),I.innerHTML=`Required
- provider
Required
- code
Required
- codeVerifier
Required
- redirectUrl
Optional
- createData
Optional data that will be used when creating the auth record on OAuth2 sign-up.
-The created auth record must comply with the same requirements and validations in the
- regular create action.
-
- The data can only be in json, aka. multipart/form-data and files
- upload currently are not supported during OAuth2 sign-ups.
Required
- identity
`,Bt=u(),ft=s("td"),ft.innerHTML='String',Ht=u(),g=s("td"),Yt=f(`The
- `),v&&v.c(),pt=u(),w&&w.c(),bt=u(),y&&y.c(),mt=f(`
- of the record to authenticate.`),qt=u(),ht=s("tr"),ht.innerHTML=`Required
- password
Required
- token
Required
- password
Required
- token
Required
- password
Required
- passwordConfirm
Required
- token
Authorization:TOKEN header",h(e,"class","txt-hint txt-sm txt-right")},m(l,s){r(l,e,s)},d(l){l&&d(e)}}}function Tt(o){let e,l,s,b,p,c,f,y,T,w,M,g,D,V,L,I,j,F,S,N,q,C,_;function O(u,$){var ee,K;return(K=(ee=u[0])==null?void 0:ee.options)!=null&&K.requireEmail?It:Vt}let z=O(o),P=z(o);return{c(){e=a("tr"),e.innerHTML='Optional
- username
- If not set, it will be auto generated.
Optional
- emailVisibility
Required
- password
Required
- passwordConfirm
Optional
- verified
- This field can be set only by admins or auth records with "Manage" access.
multipart/form-data.`,I=m(),j=a("p"),j.innerHTML=`File upload is supported only via multipart/form-data.
- - For more info and examples you could check the detailed - Files upload and handling docs - .`,F=m(),Pe(S.$$.fragment),N=m(),q=a("h6"),q.textContent="API details",C=m(),_=a("div"),O=a("strong"),O.textContent="POST",z=m(),P=a("div"),u=a("p"),$=k("/api/collections/"),ee=a("strong"),me=k(K),Re=k("/records"),ge=m(),B&&B.c(),be=m(),ne=a("div"),ne.textContent="Body Parameters",_e=m(),W=a("table"),ke=a("thead"),ke.innerHTML=`
Optional
- id
- If not set, it will be auto generated.
Authorization:TOKEN header",m(l,"class","txt-hint txt-sm txt-right")},m(s,a){d(s,l,a)},d(s){s&&f(l)}}}function ye(o,l){let s,a=l[6].code+"",h,i,r,u;function $(){return l[5](l[6])}return{key:o,first:null,c(){s=c("button"),h=D(a),i=k(),m(s,"class","tab-item"),N(s,"active",l[2]===l[6].code),this.first=s},m(b,g){d(b,s,g),n(s,h),n(s,i),r||(u=Se(s,"click",$),r=!0)},p(b,g){l=b,g&20&&N(s,"active",l[2]===l[6].code)},d(b){b&&f(s),r=!1,u()}}}function De(o,l){let s,a,h,i;return a=new qe({props:{content:l[6].body}}),{key:o,first:null,c(){s=c("div"),$e(a.$$.fragment),h=k(),m(s,"class","tab-item"),N(s,"active",l[2]===l[6].code),this.first=s},m(r,u){d(r,s,u),we(a,s,null),n(s,h),i=!0},p(r,u){l=r,(!i||u&20)&&N(s,"active",l[2]===l[6].code)},i(r){i||(ee(a.$$.fragment,r),i=!0)},o(r){te(a.$$.fragment,r),i=!1},d(r){r&&f(s),ge(a)}}}function Le(o){var ue,pe;let l,s,a=o[0].name+"",h,i,r,u,$,b,g,q=o[0].name+"",z,le,F,C,K,O,Q,y,H,se,L,E,oe,G,U=o[0].name+"",J,ae,V,ne,W,T,X,B,Y,I,Z,R,M,w=[],ie=new Map,re,A,v=[],ce=new Map,P;C=new He({props:{js:`
- import PocketBase from 'pocketbase';
-
- const pb = new PocketBase('${o[3]}');
-
- ...
-
- await pb.collection('${(ue=o[0])==null?void 0:ue.name}').delete('RECORD_ID');
- `,dart:`
- import 'package:pocketbase/pocketbase.dart';
-
- final pb = PocketBase('${o[3]}');
-
- ...
-
- await pb.collection('${(pe=o[0])==null?void 0:pe.name}').delete('RECORD_ID');
- `}});let _=o[1]&&ve(),j=o[4];const de=e=>e[6].code;for(let e=0;eOPERAND
- OPERATOR
- OPERAND, where:`,n=a(),i=l("ul"),c=l("li"),c.innerHTML=`OPERAND - could be any of the above field literal, string (single
- or double quoted), number, null, true, false`,f=a(),m=l("li"),_=l("code"),_.textContent="OPERATOR",w=k(` - is one of:
- `),b=l("br"),$=a(),h=l("ul"),M=l("li"),W=l("code"),W.textContent="=",fe=a(),T=l("span"),T.textContent="Equal",pe=a(),O=l("li"),G=l("code"),G.textContent="!=",C=a(),H=l("span"),H.textContent="NOT equal",Fe=a(),A=l("li"),E=l("code"),E.textContent=">",Ce=a(),U=l("span"),U.textContent="Greater than",X=a(),q=l("li"),Y=l("code"),Y.textContent=">=",xe=a(),j=l("span"),j.textContent="Greater than or equal",Q=a(),D=l("li"),P=l("code"),P.textContent="<",ue=a(),Z=l("span"),Z.textContent="Less than or equal",v=a(),I=l("li"),ee=l("code"),ee.textContent="<=",me=a(),te=l("span"),te.textContent="Less than or equal",N=a(),B=l("li"),le=l("code"),le.textContent="~",be=a(),se=l("span"),se.textContent=`Like/Contains (if not specified auto wraps the right string OPERAND in a "%" for
- wildcard match)`,x=a(),J=l("li"),ne=l("code"),ne.textContent="!~",Le=a(),K=l("span"),K.textContent=`NOT Like/Contains (if not specified auto wraps the right string OPERAND in a "%" for
- wildcard match)`,he=a(),V=l("p"),V.innerHTML=`To group and combine several expressions you could use brackets
- (...), && (AND) and || (OR) tokens.`,d(_,"class","txt-danger"),d(W,"class","filter-op svelte-1w7s5nw"),d(T,"class","txt-hint"),d(G,"class","filter-op svelte-1w7s5nw"),d(H,"class","txt-hint"),d(E,"class","filter-op svelte-1w7s5nw"),d(U,"class","txt-hint"),d(Y,"class","filter-op svelte-1w7s5nw"),d(j,"class","txt-hint"),d(P,"class","filter-op svelte-1w7s5nw"),d(Z,"class","txt-hint"),d(ee,"class","filter-op svelte-1w7s5nw"),d(te,"class","txt-hint"),d(le,"class","filter-op svelte-1w7s5nw"),d(se,"class","txt-hint"),d(ne,"class","filter-op svelte-1w7s5nw"),d(K,"class","txt-hint")},m(F,R){p(F,s,R),p(F,n,R),p(F,i,R),e(i,c),e(i,f),e(i,m),e(m,_),e(m,w),e(m,b),e(m,$),e(m,h),e(h,M),e(M,W),e(M,fe),e(M,T),e(h,pe),e(h,O),e(O,G),e(O,C),e(O,H),e(h,Fe),e(h,A),e(A,E),e(A,Ce),e(A,U),e(h,X),e(h,q),e(q,Y),e(q,xe),e(q,j),e(h,Q),e(h,D),e(D,P),e(D,ue),e(D,Z),e(h,v),e(h,I),e(I,ee),e(I,me),e(I,te),e(h,N),e(h,B),e(B,le),e(B,be),e(B,se),e(h,x),e(h,J),e(J,ne),e(J,Le),e(J,K),p(F,he,R),p(F,V,R)},d(F){F&&u(s),F&&u(n),F&&u(i),F&&u(he),F&&u(V)}}}function Kt(r){let s,n,i,c,f;function m($,h){return $[0]?Jt:Qt}let _=m(r),w=_(r),b=r[0]&&Tt();return{c(){s=l("button"),w.c(),n=a(),b&&b.c(),i=qt(),d(s,"class","btn btn-sm btn-secondary m-t-5")},m($,h){p($,s,h),w.m(s,null),p($,n,h),b&&b.m($,h),p($,i,h),c||(f=Ht(s,"click",r[1]),c=!0)},p($,[h]){_!==(_=m($))&&(w.d(1),w=_($),w&&(w.c(),w.m(s,null))),$[0]?b||(b=Tt(),b.c(),b.m(i.parentNode,i)):b&&(b.d(1),b=null)},i:xt,o:xt,d($){$&&u(s),w.d(),$&&u(n),b&&b.d($),$&&u(i),c=!1,f()}}}function Vt(r,s,n){let i=!1;function c(){n(0,i=!i)}return[i,c]}class Wt extends Et{constructor(s){super(),Nt(this,s,Vt,Kt,Mt,{})}}function Pt(r,s,n){const i=r.slice();return i[6]=s[n],i}function Rt(r,s,n){const i=r.slice();return i[6]=s[n],i}function St(r){let s;return{c(){s=l("p"),s.innerHTML="Requires admin Authorization:TOKEN header",d(s,"class","txt-hint txt-sm txt-right")},m(n,i){p(n,s,i)},d(n){n&&u(s)}}}function Ot(r,s){let n,i=s[6].code+"",c,f,m,_;function w(){return s[5](s[6])}return{key:r,first:null,c(){n=l("div"),c=k(i),f=a(),d(n,"class","tab-item"),Ee(n,"active",s[2]===s[6].code),this.first=n},m(b,$){p(b,n,$),e(n,c),e(n,f),m||(_=Ht(n,"click",w),m=!0)},p(b,$){s=b,$&20&&Ee(n,"active",s[2]===s[6].code)},d(b){b&&u(n),m=!1,_()}}}function At(r,s){let n,i,c,f;return i=new Ae({props:{content:s[6].body}}),{key:r,first:null,c(){n=l("div"),ge(i.$$.fragment),c=a(),d(n,"class","tab-item"),Ee(n,"active",s[2]===s[6].code),this.first=n},m(m,_){p(m,n,_),ye(i,n,null),e(n,c),f=!0},p(m,_){s=m,(!f||_&20)&&Ee(n,"active",s[2]===s[6].code)},i(m){f||(ce(i.$$.fragment,m),f=!0)},o(m){de(i.$$.fragment,m),f=!1},d(m){m&&u(n),ve(i)}}}function Xt(r){var mt,bt,ht,_t,$t,kt;let s,n,i=r[0].name+"",c,f,m,_,w,b,$,h=r[0].name+"",M,W,fe,T,pe,O,G,C,H,Fe,A,E,Ce,U,X=r[0].name+"",q,Y,xe,j,Q,D,P,ue,Z,v,I,ee,me,te,N,B,le,be,se,x,J,ne,Le,K,he,V,F,R,Qe,ie,Ne,Je,Me,Ke,_e,Ve,$e,We,ke,Xe,oe,He,Ye,qe,Ze,y,et,we,tt,lt,st,De,nt,Ie,it,ot,at,Be,rt,ze,Te,Ge,ae,Pe,z=[],ct=new Map,dt,Re,S=[],ft=new Map,re;T=new jt({props:{js:`
- import PocketBase from 'pocketbase';
-
- const pb = new PocketBase('${r[3]}');
-
- ...
-
- // fetch a paginated records list
- const resultList = await pb.collection('${(mt=r[0])==null?void 0:mt.name}').getList(1, 50, {
- filter: 'created >= "2022-01-01 00:00:00" && someFiled1 != someField2',
- });
-
- // you can also fetch all records at once via getFullList
- const records = await pb.collection('${(bt=r[0])==null?void 0:bt.name}').getFullList(200 /* batch size */, {
- sort: '-created',
- });
-
- // or fetch only the first record that matches the specified filter
- const record = await pb.collection('${(ht=r[0])==null?void 0:ht.name}').getFirstListItem('someField="test"', {
- expand: 'relField1,relField2.subRelField',
- });
- `,dart:`
- import 'package:pocketbase/pocketbase.dart';
-
- final pb = PocketBase('${r[3]}');
-
- ...
-
- // fetch a paginated records list
- final resultList = await pb.collection('${(_t=r[0])==null?void 0:_t.name}').getList(
- page: 1,
- perPage: 50,
- filter: 'created >= "2022-01-01 00:00:00" && someFiled1 != someField2',
- );
-
- // you can also fetch all records at once via getFullList
- final records = await pb.collection('${($t=r[0])==null?void 0:$t.name}').getFullList(
- batch: 200,
- sort: '-created',
- );
-
- // or fetch only the first record that matches the specified filter
- final record = await pb.collection('${(kt=r[0])==null?void 0:kt.name}').getFirstListItem(
- 'someField="test"',
- expand: 'relField1,relField2.subRelField',
- );
- `}});let L=r[1]&&St();R=new Ae({props:{content:`
- // DESC by created and ASC by id
- ?sort=-created,id
- `}}),$e=new Ae({props:{content:`
- ?filter=(id='abc' && created>'2022-01-01')
- `}}),ke=new Wt({}),we=new Ae({props:{content:"?expand=relField1,relField2.subRelField"}});let Oe=r[4];const pt=t=>t[6].code;for(let t=0;tForgotten admin password
-Enter the email associated with your account and we\u2019ll send you a recovery link:
`,n=g(),H(l.$$.fragment),t=g(),o=_("button"),f=_("i"),m=g(),i=_("span"),i.textContent="Send recovery link",p(s,"class","content txt-center m-b-sm"),p(f,"class","ri-mail-send-line"),p(i,"class","txt"),p(o,"type","submit"),p(o,"class","btn btn-lg btn-block"),o.disabled=c[1],F(o,"btn-loading",c[1]),p(e,"class","m-b-base")},m(r,$){k(r,e,$),d(e,s),d(e,n),L(l,e,null),d(e,t),d(e,o),d(o,f),d(o,m),d(o,i),a=!0,b||(u=E(e,"submit",I(c[3])),b=!0)},p(r,$){const q={};$&97&&(q.$$scope={dirty:$,ctx:r}),l.$set(q),(!a||$&2)&&(o.disabled=r[1]),(!a||$&2)&&F(o,"btn-loading",r[1])},i(r){a||(w(l.$$.fragment,r),a=!0)},o(r){y(l.$$.fragment,r),a=!1},d(r){r&&v(e),S(l),b=!1,u()}}}function O(c){let e,s,n,l,t,o,f,m,i;return{c(){e=_("div"),s=_("div"),s.innerHTML='',n=g(),l=_("div"),t=_("p"),o=h("Check "),f=_("strong"),m=h(c[0]),i=h(" for the recovery link."),p(s,"class","icon"),p(f,"class","txt-nowrap"),p(l,"class","content"),p(e,"class","alert alert-success")},m(a,b){k(a,e,b),d(e,s),d(e,n),d(e,l),d(l,t),d(t,o),d(t,f),d(f,m),d(t,i)},p(a,b){b&1&&J(m,a[0])},i:P,o:P,d(a){a&&v(e)}}}function Q(c){let e,s,n,l,t,o,f,m;return{c(){e=_("label"),s=h("Email"),l=g(),t=_("input"),p(e,"for",n=c[5]),p(t,"type","email"),p(t,"id",o=c[5]),t.required=!0,t.autofocus=!0},m(i,a){k(i,e,a),d(e,s),k(i,l,a),k(i,t,a),R(t,c[0]),t.focus(),f||(m=E(t,"input",c[4]),f=!0)},p(i,a){a&32&&n!==(n=i[5])&&p(e,"for",n),a&32&&o!==(o=i[5])&&p(t,"id",o),a&1&&t.value!==i[0]&&R(t,i[0])},d(i){i&&v(e),i&&v(l),i&&v(t),f=!1,m()}}}function U(c){let e,s,n,l,t,o,f,m;const i=[O,K],a=[];function b(u,r){return u[2]?0:1}return e=b(c),s=a[e]=i[e](c),{c(){s.c(),n=g(),l=_("div"),t=_("a"),t.textContent="Back to login",p(t,"href","/login"),p(t,"class","link-hint"),p(l,"class","content txt-center")},m(u,r){a[e].m(u,r),k(u,n,r),k(u,l,r),d(l,t),o=!0,f||(m=A(B.call(null,t)),f=!0)},p(u,r){let $=e;e=b(u),e===$?a[e].p(u,r):(N(),y(a[$],1,1,()=>{a[$]=null}),D(),s=a[e],s?s.p(u,r):(s=a[e]=i[e](u),s.c()),w(s,1),s.m(n.parentNode,n))},i(u){o||(w(s),o=!0)},o(u){y(s),o=!1},d(u){a[e].d(u),u&&v(n),u&&v(l),f=!1,m()}}}function V(c){let e,s;return e=new z({props:{$$slots:{default:[U]},$$scope:{ctx:c}}}),{c(){H(e.$$.fragment)},m(n,l){L(e,n,l),s=!0},p(n,[l]){const t={};l&71&&(t.$$scope={dirty:l,ctx:n}),e.$set(t)},i(n){s||(w(e.$$.fragment,n),s=!0)},o(n){y(e.$$.fragment,n),s=!1},d(n){S(e,n)}}}function W(c,e,s){let n="",l=!1,t=!1;async function o(){if(!l){s(1,l=!0);try{await C.admins.requestPasswordReset(n),s(2,t=!0)}catch(m){C.errorResponseHandler(m)}s(1,l=!1)}}function f(){n=this.value,s(0,n)}return[n,l,t,o,f]}class Y extends M{constructor(e){super(),T(this,e,W,V,j,{})}}export{Y as default}; diff --git a/ui/dist/assets/PageRecordConfirmEmailChange.824a9bd8.js b/ui/dist/assets/PageRecordConfirmEmailChange.824a9bd8.js deleted file mode 100644 index dddb58619443e3b7314dbc3fc96ff73021bbd03f..0000000000000000000000000000000000000000 --- a/ui/dist/assets/PageRecordConfirmEmailChange.824a9bd8.js +++ /dev/null @@ -1,4 +0,0 @@ -import{S as z,i as G,s as I,F as J,c as S,m as T,t as v,a as y,d as L,C as M,E as N,g as _,k as W,n as Y,o as b,R as j,G as A,p as B,q as D,e as m,w as C,b as h,f as d,r as F,h as k,u as q,v as K,y as E,x as O,z as H}from"./index.662e825a.js";function Q(r){let e,t,l,s,n,o,c,i,a,u,g,$,p=r[3]&&R(r);return o=new D({props:{class:"form-field required",name:"password",$$slots:{default:[V,({uniqueId:f})=>({8:f}),({uniqueId:f})=>f?256:0]},$$scope:{ctx:r}}}),{c(){e=m("form"),t=m("div"),l=m("h5"),s=C(`Type your password to confirm changing your email address - `),p&&p.c(),n=h(),S(o.$$.fragment),c=h(),i=m("button"),a=m("span"),a.textContent="Confirm new email",d(t,"class","content txt-center m-b-base"),d(a,"class","txt"),d(i,"type","submit"),d(i,"class","btn btn-lg btn-block"),i.disabled=r[1],F(i,"btn-loading",r[1])},m(f,w){_(f,e,w),k(e,t),k(t,l),k(l,s),p&&p.m(l,null),k(e,n),T(o,e,null),k(e,c),k(e,i),k(i,a),u=!0,g||($=q(e,"submit",K(r[4])),g=!0)},p(f,w){f[3]?p?p.p(f,w):(p=R(f),p.c(),p.m(l,null)):p&&(p.d(1),p=null);const P={};w&769&&(P.$$scope={dirty:w,ctx:f}),o.$set(P),(!u||w&2)&&(i.disabled=f[1]),(!u||w&2)&&F(i,"btn-loading",f[1])},i(f){u||(v(o.$$.fragment,f),u=!0)},o(f){y(o.$$.fragment,f),u=!1},d(f){f&&b(e),p&&p.d(),L(o),g=!1,$()}}}function U(r){let e,t,l,s,n;return{c(){e=m("div"),e.innerHTML=`
-
Successfully changed the user email address.
-You can now sign in with your new email address.
-
Successfully changed the user password.
-You can now sign in with your new password.
-
Invalid or expired verification token.
-
Successfully verified email address.
Please wait...
',f(t,"class","txt-center")},m(s,e){r(s,t,e)},p,d(s){s&&a(t)}}}function R(o){let t;function s(l,i){return l[1]?I:l[0]?F:T}let e=s(o),n=e(o);return{c(){n.c(),t=S()},m(l,i){n.m(l,i),r(l,t,i)},p(l,i){e===(e=s(l))&&n?n.p(l,i):(n.d(1),n=e(l),n&&(n.c(),n.m(t.parentNode,t)))},d(l){n.d(l),l&&a(t)}}}function V(o){let t,s;return t=new x({props:{nobranding:!0,$$slots:{default:[R]},$$scope:{ctx:o}}}),{c(){C(t.$$.fragment)},m(e,n){g(t,e,n),s=!0},p(e,[n]){const l={};n&67&&(l.$$scope={dirty:n,ctx:e}),t.$set(l)},i(e){s||($(t.$$.fragment,e),s=!0)},o(e){L(t.$$.fragment,e),s=!1},d(e){H(t,e)}}}function q(o,t,s){let{params:e}=t,n=!1,l=!1;i();async function i(){s(1,l=!0);const d=new M("../");try{const m=P(e==null?void 0:e.token);await d.collection(m.collectionId).confirmVerification(e==null?void 0:e.token),s(0,n=!0)}catch{s(0,n=!1)}s(1,l=!1)}const c=()=>window.close(),k=()=>window.close();return o.$$set=d=>{"params"in d&&s(2,e=d.params)},[n,l,e,c,k]}class G extends v{constructor(t){super(),y(this,t,q,V,w,{params:2})}}export{G as default};
diff --git a/ui/dist/assets/RealtimeApiDocs.09f1a44d.js b/ui/dist/assets/RealtimeApiDocs.09f1a44d.js
deleted file mode 100644
index 82276337dda9ecf779c6c031cd4a221d99059e12..0000000000000000000000000000000000000000
--- a/ui/dist/assets/RealtimeApiDocs.09f1a44d.js
+++ /dev/null
@@ -1,107 +0,0 @@
-import{S as re,i as ae,s as be,M as ue,C as P,e as u,w as y,b as a,c as te,f as p,g as t,h as I,m as ne,x as pe,t as ie,a as le,o as n,d as ce,Q as me,p as de}from"./index.662e825a.js";import{S as fe}from"./SdkTabs.1e98a608.js";function $e(o){var B,U,W,A,H,L,M,T,q,j,J,N;let i,m,l=o[0].name+"",b,d,h,f,_,$,k,c,S,v,w,R,C,g,E,r,D;return c=new fe({props:{js:`
- import PocketBase from 'pocketbase';
-
- const pb = new PocketBase('${o[1]}');
-
- ...
-
- // (Optionally) authenticate
- await pb.collection('users').authWithPassword('test@example.com', '123456');
-
- // Subscribe to changes in any ${(B=o[0])==null?void 0:B.name} record
- pb.collection('${(U=o[0])==null?void 0:U.name}').subscribe('*', function (e) {
- console.log(e.record);
- });
-
- // Subscribe to changes only in the specified record
- pb.collection('${(W=o[0])==null?void 0:W.name}').subscribe('RECORD_ID', function (e) {
- console.log(e.record);
- });
-
- // Unsubscribe
- pb.collection('${(A=o[0])==null?void 0:A.name}').unsubscribe('RECORD_ID'); // remove all 'RECORD_ID' subscriptions
- pb.collection('${(H=o[0])==null?void 0:H.name}').unsubscribe('*'); // remove all '*' topic subscriptions
- pb.collection('${(L=o[0])==null?void 0:L.name}').unsubscribe(); // remove all subscriptions in the collection
- `,dart:`
- import 'package:pocketbase/pocketbase.dart';
-
- final pb = PocketBase('${o[1]}');
-
- ...
-
- // (Optionally) authenticate
- await pb.collection('users').authWithPassword('test@example.com', '123456');
-
- // Subscribe to changes in any ${(M=o[0])==null?void 0:M.name} record
- pb.collection('${(T=o[0])==null?void 0:T.name}').subscribe('*', (e) {
- console.log(e.record);
- });
-
- // Subscribe to changes only in the specified record
- pb.collection('${(q=o[0])==null?void 0:q.name}').subscribe('RECORD_ID', (e) {
- console.log(e.record);
- });
-
- // Unsubscribe
- pb.collection('${(j=o[0])==null?void 0:j.name}').unsubscribe('RECORD_ID'); // remove all 'RECORD_ID' subscriptions
- pb.collection('${(J=o[0])==null?void 0:J.name}').unsubscribe('*'); // remove all '*' topic subscriptions
- pb.collection('${(N=o[0])==null?void 0:N.name}').unsubscribe(); // remove all subscriptions in the collection
- `}}),r=new ue({props:{content:JSON.stringify({action:"create",record:P.dummyCollectionRecord(o[0])},null,2).replace('"action": "create"','"action": "create" // create, update or delete')}}),{c(){i=u("h3"),m=y("Realtime ("),b=y(l),d=y(")"),h=a(),f=u("div"),f.innerHTML=`Subscribe to realtime changes via Server-Sent Events (SSE).
-Events are sent for create, update - and delete record operations (see "Event data format" section below).
`,_=a(),$=u("div"),$.innerHTML=`
-
You could subscribe to a single record or to an entire collection.
-When you subscribe to a single record, the collection's - ViewRule will be used to determine whether the subscriber has access to receive the - event message.
-When you subscribe to an entire collection, the collection's - ListRule will be used to determine whether the subscriber has access to receive the - event message.
/api/realtime
Required
- newEmail
Required
- email
Required
- email
google, twitter,
- github, etc.Authorization:TOKEN header",T(t,"class","txt-hint txt-sm txt-right")},m(l,s){a(l,t,s)},d(l){l&&o(t)}}}function kt(p){let t,l,s,b,u,d,f,k,C,v,O,H,A,F,M,N,B;return{c(){t=r("tr"),t.innerHTML='Optional
- username
Optional
- email
- This field can be updated only by admins or auth records with "Manage" access. -
- Regular accounts can update their email by calling "Request email change".
Optional
- emailVisibility
Optional
- oldPassword
- This field is required only when changing the record password. Admins and auth records with - "Manage" access can skip this field.
Optional
- password
Optional
- passwordConfirm
Optional
- verified
- This field can be set only by admins or auth records with "Manage" access.
multipart/form-data.`,N=m(),B=r("p"),B.innerHTML=`File upload is supported only via multipart/form-data.
- - For more info and examples you could check the detailed - Files upload and handling docs - .`,c=m(),Ae(_.$$.fragment),K=m(),R=r("h6"),R.textContent="API details",S=m(),h=r("div"),L=r("strong"),L.textContent="PATCH",Ne=m(),ae=r("div"),W=r("p"),je=y("/api/collections/"),ue=r("strong"),be=y(oe),Ee=y("/records/"),me=r("strong"),me.textContent=":id",Ie=m(),q&&q.c(),_e=m(),X=r("div"),X.textContent="Path parameters",ye=m(),Z=r("table"),Z.innerHTML=`
Authorization:TOKEN header",_(s,"class","txt-hint txt-sm txt-right")},m(n,a){r(n,s,a)},d(n){n&&d(s)}}}function We(i,s){let n,a=s[6].code+"",w,c,p,u;function C(){return s[5](s[6])}return{key:i,first:null,c(){n=o("button"),w=m(a),c=f(),_(n,"class","tab-item"),J(n,"active",s[2]===s[6].code),this.first=n},m(h,R){r(h,n,R),l(n,w),l(n,c),p||(u=rt(n,"click",C),p=!0)},p(h,R){s=h,R&20&&J(n,"active",s[2]===s[6].code)},d(h){h&&d(n),p=!1,u()}}}function Xe(i,s){let n,a,w,c;return a=new Ye({props:{content:s[6].body}}),{key:i,first:null,c(){n=o("div"),_e(a.$$.fragment),w=f(),_(n,"class","tab-item"),J(n,"active",s[2]===s[6].code),this.first=n},m(p,u){r(p,n,u),ke(a,n,null),l(n,w),c=!0},p(p,u){s=p,(!c||u&20)&&J(n,"active",s[2]===s[6].code)},i(p){c||(z(a.$$.fragment,p),c=!0)},o(p){G(a.$$.fragment,p),c=!1},d(p){p&&d(n),he(a)}}}function ct(i){var Ne,Ue;let s,n,a=i[0].name+"",w,c,p,u,C,h,R,N=i[0].name+"",K,ve,W,g,X,B,Y,$,U,we,j,E,ye,Z,Q=i[0].name+"",ee,$e,te,Ce,le,I,se,M,ne,x,oe,O,ie,Fe,ae,D,re,Re,de,ge,k,Oe,S,De,Pe,Te,ce,Ee,pe,Se,Be,Ie,fe,Me,ue,A,be,P,H,F=[],xe=new Map,Ae,q,y=[],He=new Map,T;g=new dt({props:{js:`
- import PocketBase from 'pocketbase';
-
- const pb = new PocketBase('${i[3]}');
-
- ...
-
- const record = await pb.collection('${(Ne=i[0])==null?void 0:Ne.name}').getOne('RECORD_ID', {
- expand: 'relField1,relField2.subRelField',
- });
- `,dart:`
- import 'package:pocketbase/pocketbase.dart';
-
- final pb = PocketBase('${i[3]}');
-
- ...
-
- final record = await pb.collection('${(Ue=i[0])==null?void 0:Ue.name}').getOne('RECORD_ID',
- 'expand': 'relField1,relField2.subRelField',
- );
- `}});let v=i[1]&&Ke();S=new Ye({props:{content:"?expand=relField1,relField2.subRelField"}});let V=i[4];const qe=e=>e[6].code;for(let e=0;e
- PocketBase