PocketBase Skill - Comprehensive Reference

Overview

This skill provides modular, searchable documentation for PocketBase development. Use the table of contents below to navigate to specific topics. The researcher-pocketbase agent can efficiently search and extract information from the reference files based on your query. PocketBase is an open source backend in 1 file. It provides a realtime database, authentication, file storage, an admin dashboard and is extendable to much more.

Quick Navigation

For Newcomers

→ Start with Getting Started for initial setup and basic concepts → Review Collections to understand data modeling → See Authentication for user management → Check API Rules & Filters for security

For Implementation

→ Browse Schema Templates for pre-built data models → Use Records API for CRUD operations → Implement Real-time for live updates → Follow Files Handling for file uploads → Read Working with Relations for data relationships

For Production

→ See Going to Production for deployment → Review Security Rules for access control → Check API Reference for complete API documentation

For Advanced Users

→ Explore Go Extensions for custom functionality → Study Event Hooks for automation → Learn Database Operations for advanced queries → Plan data migrations with Data Migration Workflows

Table of Contents

Core Concepts & Setup

API Reference

SDKs & Development Tools

Go Extension Framework

Reference Materials

Development Resources

How to Use This Skill

For the Researcher-Pocketbase Agent

This skill is designed for efficient information retrieval. When researching PocketBase topics:

1. •Start with Core Concepts - Review references/core/ for foundational knowledge
2. •Find API Details - Use references/api/ for specific API endpoints
3. •Look up Go Extensions - Check references/go/ for custom functionality
4. •Find Examples - Reference references/templates/ and references/security_rules.md

Topic Categories

Setup & Configuration

• •Getting Started → Initial setup and basic concepts
• •CLI Commands → Development workflow, server management
• •Going to Production → Deployment and production configuration
• •Collections → Data model design

Data Management

• •Collections → Creating and managing collections
• •Working with Relations → Linking data across collections
• •Files Handling → File uploads and storage

Security & Access Control

• •Authentication → User management
• •API Rules & Filters → Access control and queries
• •Security Rules → Comprehensive security patterns

API Integration

• •Records API → CRUD operations
• •Realtime API → Live updates
• •Files API → File management
• •Other API endpoints → Settings, logs, backups, health

Frontend Development

• •JavaScript SDK → Web integration
• •Schema Templates → Pre-built data models
• •Frontend Template → Integration example

Backend Development

• •Go SDK → Server-side integration
• •Go Extensions → Custom functionality
• •Console Commands → CLI tools

Common Query Patterns

"How do I..."

• •How do I create a blog? → Schema Templates
• •How do I set up authentication? → Authentication
• •How do I upload files? → Files Handling
• •How do I add real-time updates? → Realtime API

"How to configure..."

• •How to configure production? → Going to Production
• •How to set up security rules? → API Rules & Filters, Security Rules
• •How to create custom endpoints? → Go Routing
• •How to schedule jobs? → Jobs & Scheduling

"What's the best way to..."

• •What's the best way to structure my data? → Collections, Working with Relations
• •What's the best way to secure my API? → API Rules & Filters, Security Rules
• •What's the best way to optimize queries? → API Rules & Filters
• •What's the best way to handle files? → Files Handling

"Error:..."

• •CORS errors → Authentication, Going to Production
• •Permission errors → API Rules & Filters, Security Rules
• •File upload errors → Files Handling
• •Slow queries → API Rules & Filters (indexing)

"Need to implement..."

• •Need user roles? → Authentication, Security Rules
• •Need file uploads? → Files Handling
• •Need real-time chat? → Realtime API
• •Need custom logic? → Go Extensions

Quick Reference Index

Common Tasks

• •Set up PocketBase
• •Master the CLI
• •Create collection
• •Add authentication
• •Write security rules
• •Upload files
• •Create relations
• •Query data
• •Set up real-time
• •Deploy to production

Code Examples

• •React integration
• •Vue.js integration
• •Create record
• •Filter queries
• •File upload
• •Custom endpoint
• •Event hook

Best Practices

• •Schema design
• •Security rules
• •Query optimization
• •Production deployment

File Locations

Core Documentation

/references/core/
├── getting_started.md          # Initial setup and concepts
├── cli_commands.md             # CLI commands and server management
├── collections.md              # Data modeling and collections
├── authentication.md           # User management
├── api_rules_filters.md        # Security and querying
├── files_handling.md           # File uploads and storage
├── working_with_relations.md   # Data relationships
└── going_to_production.md      # Deployment guide

API Reference

/references/api/
├── api_records.md              # CRUD operations
├── api_realtime.md             # WebSocket subscriptions
├── api_files.md                # File management
├── api_collections.md          # Collection operations
├── api_settings.md             # App configuration
├── api_logs.md                 # Logging
├── api_crons.md                # Background jobs
├── api_backups.md              # Backups
└── api_health.md               # Health checks

Go Extensions

/references/go/
├── go_overview.md              # Getting started
├── go_event_hooks.md           # Event system
├── go_routing.md               # Custom routes
├── go_database.md              # Database operations
├── go_records.md               # Record management
├── go_collections.md           # Collection management
├── go_migrations.md            # Schema changes
├── go_jobs_scheduling.md       # Background tasks
├── go_sending_emails.md        # Email integration
├── go_rendering_templates.md   # Templates
├── go_console_commands.md      # CLI tools
├── go_realtime.md              # Custom realtime
├── go_filesystem.md            # File storage
├── go_logging.md               # Logging
├── go_testing.md               # Testing
├── go_miscellaneous.md         # Advanced topics
└── go_record_proxy.md          # Dynamic behavior

SDKs

/references/sdk/
├── js_sdk.md                   # JavaScript
├── go_sdk.md                   # Go
└── dart_sdk.md                 # Dart

Templates & Security

/references/
├── security_rules.md           # Security patterns
├── templates/
│   └── schema_templates.md     # Pre-built schemas
└── api_reference.md            # Complete API docs

Information Architecture

This skill follows a modular architecture designed for progressive disclosure:

1. •Quick Access - SKILL.md provides immediate overview and navigation
2. •Focused Topics - Each reference file covers one specific area
3. •Cross-References - Files link to related topics
4. •Examples First - Practical code examples in each file
5. •Searchable - Clear titles and descriptions for quick lookup

When to Use Each Section

references/core/

• •New users starting with PocketBase
• •Understanding fundamental concepts
• •Basic implementation tasks

references/api/

• •Implementing specific API features
• •Looking up endpoint details
• •API integration examples

references/go/

• •Building custom PocketBase extensions
• •Advanced functionality
• •Custom business logic

references/sdk/

• •Frontend or mobile integration
• •SDK-specific features
• •Language-specific examples

references/security_rules.md

• •Complex access control scenarios
• •Security best practices
• •Multi-tenant applications

references/templates/

• •Rapid prototyping
• •Common application patterns
• •Pre-built data models

Notes for Researchers

This skill contains over 30 reference files covering all aspects of PocketBase development. The researcher-pocketbase agent should:

1. •Match queries to appropriate topic areas
2. •Extract specific information from relevant files
3. •Provide comprehensive answers using multiple references
4. •Suggest related topics for further reading
5. •Identify best practices and common pitfalls

Each reference file is self-contained with examples, explanations, and best practices. Use the table of contents above to quickly navigate to the most relevant information for any PocketBase-related question.