New to Claude Skills? Learn how to install them →

davila7 on GitHub

PocketBase Collections

Free

Streamline your PocketBase schema and collection design.

Get this skill

Free · Opens the source repo

What PocketBase Collections does

PocketBase Collections is a skill designed to assist developers and designers in creating and managing collections and schemas within PocketBase. This skill provides a comprehensive guide on the various collection types available, including Base, Auth, and View collections, along with their specific system fields and constraints. Users can easily understand how to set up their collections to meet their application needs, whether it's for standard data storage, user authentication, or read-only data views.

The skill also details the different field types supported by PocketBase, such as text, number, email, and relation fields, along with their properties and zero-default behaviors. This ensures that developers can make informed decisions when defining their data structures, preventing common mistakes such as using incorrect field types or overlooking default behaviors that could lead to data integrity issues.

Additionally, the skill covers important aspects of relation patterns, indexing, and best practices for schema design. By following these guidelines, users can optimize their collections for performance and maintainability, ensuring that their applications can scale effectively as they grow. The focus on relation patterns, including one-to-many and many-to-many relationships, helps users design their data models with clarity and efficiency.

Overall, PocketBase Collections is a valuable resource for anyone looking to leverage PocketBase for their applications, providing structured guidance to streamline the collection and schema design process.

When to use it

Use this skill when setting up new collections or modifying existing schemas in PocketBase to ensure best practices are followed.

When not to use it

This skill may not be necessary for experienced developers familiar with PocketBase's collection and schema design, as they may already understand these concepts.

What you can build with it

Creating a New Auth Collection

Use this skill to set up a new Auth collection, ensuring proper authentication fields and settings are configured.

Designing a View Collection for Reporting

Leverage the skill to create a View collection that aggregates data from multiple sources, optimizing for read-only access.

Implementing Relationships Between Collections

Utilize this skill to define and manage relationships between collections, ensuring data integrity and proper cascading behavior.

How to install PocketBase Collections

View source

1. Install with the skills CLI

npx skills add davila7/claude-code-templates/pb-collections --agent claude-code

2. Or install it manually

Download the skill folder and drop it into ~/.claude/skills/ for all projects, or .claude/skills/ to scope it to one repo. Restart Claude Code so it picks up the new skill.

Anthropic's agentic coding CLI, and the reference implementation of Agent Skills. Drop a skill folder into ~/.claude/skills and Claude Code loads it automatically whenever a task matches the skill's description. Claude Code docs

Inside SKILL.md

Written by davila7

PocketBase Collection & Schema Design

Collection Types

Base Collection

Standard data collection. System fields: id, created, updated.

Auth Collection

Extends base with authentication. Additional system fields: email, emailVisibility, verified, password, tokenKey.

Cannot delete system fields. Can disable email/password auth in collection options.

View Collection

Read-only, backed by a SQL SELECT query. No create/update/delete. Fields are auto-detected from the query. Useful for aggregations, joins, and computed views.

-- Example: view collection query
SELECT p.id, p.title, COUNT(c.id) as comments_count
FROM posts p LEFT JOIN comments c ON c.post = p.id
GROUP BY p.id

View collections support API rules (list/view only) and can be used in relations.

Field Types

TypeGo typeZero defaultNotes
textstring""min/max length, regex pattern
editorstring""Rich text (sanitized HTML)
numberfloat640min/max, noDecimal option
boolboolfalse
emailstring""Auto-validated format
urlstring""Auto-validated format
datestring""ISO 8601 (2024-01-01 00:00:00.000Z)
selectstring/[]string""/[]values list, maxSelect
filestring/[]string""/[]maxSelect, maxSize, mimeTypes
relationstring/[]string""/[]collectionId, cascadeDelete, maxSelect
jsonanynullOnly type that can be null! maxSize
autodatestringautoonCreate/onUpdate modifiers
passwordstring""Stored hashed, never returned in API

Critical: all types default to their zero value, NOT null. Only json fields can be null.

Field Modifiers

Use in collection schema definitions:

  • required — field cannot be empty/zero
  • unique — unique constraint (composite via unique indexes)
  • presentable — included in relation display
  • hidden — excluded from API responses unless explicitly requested
  • :autogenerate — for text fields: auto-generate value (e.g., slug from other field)

Relation Patterns

One-to-many

posts.author -> users (maxSelect: 1)

Each post has one author. Query posts by author: author = "USER_ID".

Many-to-many

posts.tags -> tags (maxSelect: 0, meaning unlimited)

Multi-select relation. Filter: tags ?= "TAG_ID" (contains).

Back-relations

No explicit back-relation field needed. Use @collection.posts.author in API rules or expand from either side:

GET /api/collections/users/records/USER_ID?expand=posts_via_author

Cascade Delete

Set cascadeDelete: true on the relation field. When the referenced record is deleted, all records pointing to it are also deleted. Default is false (sets to empty string).

Self-referencing

A collection can reference itself:

categories.parent -> categories (maxSelect: 1)

Indexes

  • Created in the collection settings (not field-level)
  • Format: CREATE [UNIQUE] INDEX idx_name ON collection (field1, field2)
  • Unique indexes enforce composite uniqueness
  • Partial indexes: CREATE INDEX ... WHERE condition
  • Indexes on relation fields improve join performance

Auth Collection Specifics

OAuth2

Enable per-provider in collection settings. Each provider needs client ID + secret. PocketBase handles the full OAuth2 flow.

OTP (One-Time Password)

Enable in auth collection settings. Sends code via email. Configure otp.enabled, otp.duration, otp.length.

MFA (Multi-Factor Authentication)

Enable in auth collection settings. Requires a second factor after primary auth. mfa.enabled, mfa.duration, mfa.rule (filter to determine which users need MFA).

Password Auth

Enabled by default. Can customize minPasswordLength. Can disable entirely if using only OAuth2/OTP.

Auth Options

  • authToken.duration — token lifetime (seconds)
  • passwordAuth.enabled — toggle email/password
  • passwordAuth.identityFields — fields used for login (default: email; can add username)
  • oauth2.enabled — toggle OAuth2
  • otp.enabled — toggle OTP

Best Practices

  1. Prefer select over bool when there might be more than 2 states in the future
  2. Use relation not text for foreign keys — you get cascade, expand, and type safety
  3. json fields are schemaless — use sparingly, prefer typed fields
  4. Name collections in lowercase snake_case (e.g., blog_posts, user_profiles)
  5. Index early — add indexes for any field used in filters or sorts
  6. maxSelect: 1 on relations returns a string ID; maxSelect: >1 or 0 returns an array

Frequently asked questions about PocketBase Collections

Similar skills