Utilities - PocketBase

PocketBase provides various utility packages and helpers for common tasks.

Security utilities

Random string generation

import "github.com/pocketbase/pocketbase/tools/security"

// Generate random string with default alphabet
randomStr := security.RandomString(32)

// Generate with custom alphabet
customStr := security.RandomStringWithAlphabet(16, "0123456789ABCDEF")

// Pseudorandom (not cryptographically secure, but faster)
pseudoStr := security.PseudorandomString(32)

Hashing

import "github.com/pocketbase/pocketbase/tools/security"

// MD5 hash
hash := security.MD5("text to hash")

// SHA256 hash  
hash := security.SHA256("text to hash")

// SHA512 hash
hash := security.SHA512("text to hash")

Password hashing

import "github.com/pocketbase/pocketbase/tools/security"

// Hash a password (uses bcrypt)
hashed, err := security.HashPassword("mypassword123")
if err != nil {
    log.Fatal(err)
}

// Verify password
if security.CompareHashAndPassword(hashed, "mypassword123") {
    log.Println("Password is correct")
}

JWT tokens

Creating tokens

import (
    "time"
    "github.com/pocketbase/pocketbase/tools/security"
)

// Create a JWT token
token, err := security.NewJWT(
    map[string]any{
        "userId": "123",
        "email":  "user@example.com",
    },
    "your-secret-key",
    time.Now().Add(24 * time.Hour).Unix(), // expiry
)
if err != nil {
    log.Fatal(err)
}

log.Println("Token:", token)

Parsing tokens

import "github.com/pocketbase/pocketbase/tools/security"

tokenString := "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."

token, err := security.ParseUnverifiedJWT(tokenString)
if err != nil {
    log.Fatal(err)
}

// Access claims
userId := token.Get("userId")
email := token.Get("email")

Verifying tokens

import "github.com/pocketbase/pocketbase/tools/security"

token, err := security.ParseJWT(tokenString, "your-secret-key")
if err != nil {
    log.Fatal("Invalid or expired token")
}

log.Println("Valid token for:", token.Get("userId"))

List utilities

Working with slices

import "github.com/pocketbase/pocketbase/tools/list"

// Check if item exists in slice
slice := []string{"apple", "banana", "orange"}
if list.ExistInSlice("banana", slice) {
    log.Println("Found banana")
}

// Convert to unique string slice
data := []any{"a", "b", "a", "c", "b"}
unique := list.ToUniqueStringSlice(data)
// Result: ["a", "b", "c"]

// Subtract slices
slice1 := []string{"a", "b", "c"}
slice2 := []string{"b", "d"}
result := list.SubtractSlice(slice1, slice2)
// Result: ["a", "c"]

Type utilities

DateTime

import "github.com/pocketbase/pocketbase/tools/types"

// Create DateTime from string
dt, err := types.ParseDateTime("2024-01-15 14:30:00.000Z")
if err != nil {
    log.Fatal(err)
}

// Current DateTime
now := types.NowDateTime()

// Convert to time.Time
timeObj := dt.Time()

// Format as string
str := dt.String()

JSON types

import "github.com/pocketbase/pocketbase/tools/types"

// JSONArray
jsonArray := types.JSONArray[string]{"a", "b", "c"}

// JSONMap
jsonMap := types.JSONMap[any]{
    "key1": "value1",
    "key2": 123,
}

// JSONRaw (for storing raw JSON)
raw := types.JSONRaw(`{"custom": "data"}`)

Pointer helper

import "github.com/pocketbase/pocketbase/tools/types"

// Create pointer to value
strPtr := types.Pointer("hello")
intPtr := types.Pointer(123)
boolPtr := types.Pointer(true)

// Useful for optional fields
collection.ListRule = types.Pointer("@request.auth.id != ''")

Store

Thread-safe in-memory key-value store:

import "github.com/pocketbase/pocketbase/tools/store"

// Create store
s := store.New[string, any](nil)

// Set values
s.Set("key1", "value1")
s.Set("key2", 123)

// Get value
value := s.Get("key1")

// Get with existence check
value, exists := s.GetOk("key1")
if exists {
    log.Println("Found:", value)
}

// Get all
allData := s.GetAll()

// Has key
if s.Has("key1") {
    log.Println("Key exists")
}

// Remove
s.Remove("key1")

// Reset with new data
s.Reset(map[string]any{
    "new_key": "new_value",
})

Filesystem utilities

File upload from URL

import "github.com/pocketbase/pocketbase/tools/filesystem"

file, err := filesystem.NewFileFromURL(
    "https://example.com/image.jpg",
)
if err != nil {
    log.Fatal(err)
}

// Use with record
record.Set("avatar", file)
app.Save(record)

Template utilities

Template rendering

import "github.com/pocketbase/pocketbase/tools/template"

registry := template.NewRegistry()

// Load templates
tpl, err := registry.LoadFiles(
    "templates/welcome.html",
    "templates/footer.html",
)
if err != nil {
    log.Fatal(err)
}

// Render with data
html, err := tpl.Render(map[string]any{
    "name":  "John",
    "title": "Welcome",
})
if err != nil {
    log.Fatal(err)
}

Template from string

import "github.com/pocketbase/pocketbase/tools/template"

registry := template.NewRegistry()

tpl, err := registry.LoadString("Hello {{.name}}!")
if err != nil {
    log.Fatal(err)
}

result, _ := tpl.Render(map[string]any{
    "name": "World",
})
// Result: "Hello World!"

Inflector

String manipulation utilities:

import "github.com/pocketbase/pocketbase/tools/inflector"

// Columnify - format for SQL column names
colName := inflector.Columnify("UserName")
// Result: "userName"

// Sentenize - convert to sentence
sentence := inflector.Sentenize("hello_world")
// Result: "Hello world"

// Pluralize
plural := inflector.Pluralize("post")
// Result: "posts"

// Singularize  
singular := inflector.Singularize("users")
// Result: "user"

Search utilities

Building search providers

import "github.com/pocketbase/pocketbase/tools/search"

// Create search provider
provider := search.NewProvider(fieldResolver)

// Parse search/filter string
result, err := provider.Parse("title ~ 'test' && status = 'active'")
if err != nil {
    log.Fatal(err)
}

// Apply to query
app.DB().Select("*").From("posts").AndWhere(result.BuildExpr())

Cron utilities

Scheduling tasks

// Add cron job
app.Cron().Add("daily_cleanup", "0 0 * * *", func() {
    log.Println("Running daily cleanup")
    // Cleanup logic
})

// Remove job
app.Cron().Remove("daily_cleanup")

// Check if job exists
if app.Cron().Has("daily_cleanup") {
    log.Println("Job is scheduled")
}

Cron expression format:

┌───────────── minute (0 - 59)
│ ┌───────────── hour (0 - 23)
│ │ ┌───────────── day of month (1 - 31)
│ │ │ ┌───────────── month (1 - 12)
│ │ │ │ ┌───────────── day of week (0 - 6) (Sunday = 0)
│ │ │ │ │
* * * * *

Common cron patterns

// Every minute
app.Cron().Add("task", "* * * * *", handler)

// Every hour
app.Cron().Add("task", "0 * * * *", handler)

// Every day at midnight
app.Cron().Add("task", "0 0 * * *", handler)

// Every Monday at 9 AM
app.Cron().Add("task", "0 9 * * 1", handler)

// First day of month
app.Cron().Add("task", "0 0 1 * *", handler)

Routine utilities

Background task execution:

import "github.com/pocketbase/pocketbase/tools/routine"

// Fire and forget
routine.FireAndForget(func() {
    // Long-running task
    time.Sleep(5 * time.Second)
    log.Println("Background task completed")
})

Archive utilities

Create and extract archives:

import "github.com/pocketbase/pocketbase/tools/archive"

// Create ZIP archive
err := archive.Create(
    []string{"file1.txt", "file2.txt"},
    "archive.zip",
)
if err != nil {
    log.Fatal(err)
}

// Extract archive
err = archive.Extract("archive.zip", "./destination")
if err != nil {
    log.Fatal(err)
}

Tokenizer

Parse and tokenize strings:

import "github.com/pocketbase/pocketbase/tools/tokenizer"

tokenizer := tokenizer.NewFromString("hello world test")

for {
    token := tokenizer.Scan()
    if token.Type == tokenizer.EOF {
        break
    }
    log.Println("Token:", token.Literal)
}

Best practices

Use appropriate utilities

// Good - use list utilities
if list.ExistInSlice(item, slice) {
    // ...
}

// Bad - manual loop
found := false
for _, v := range slice {
    if v == item {
        found = true
        break
    }
}

Cache expensive operations

// Cache in app store
key := "expensive_result"
if !app.Store().Has(key) {
    result := expensiveOperation()
    app.Store().Set(key, result)
}

result := app.Store().Get(key)

Use type-safe stores

// Good - type-safe
type UserCache struct {
    *store.Store[string, *core.Record]
}

cache := &UserCache{
    Store: store.New[string, *core.Record](nil),
}

cache.Set("user_123", userRecord)

​Security utilities

​Random string generation

​Hashing

​Password hashing

​JWT tokens

​Creating tokens

​Parsing tokens

​Verifying tokens

​List utilities

​Working with slices

​Type utilities

​DateTime

​JSON types

​Pointer helper

​Store

​Filesystem utilities

​File upload from URL

​Template utilities

​Template rendering

​Template from string

​Inflector

​Search utilities

​Building search providers

​Cron utilities

​Scheduling tasks

​Common cron patterns

​Routine utilities

​Archive utilities

​Tokenizer

​Best practices

​Use appropriate utilities

​Cache expensive operations

​Use type-safe stores