PocketBase: JavaScript Overview

https://pocketbase.io/docs/js-overview
Admin
Open Source backend in 1 file with realtime database, authentication, file storage and admin...
Tokens:110,091
Snippets:637
Trust Score:9.6
Update:1 year ago
Show doc for...
Tokens:
Raw
### Start PocketBase Server

Source: https://pocketbase.io/docs/js-overview/index

Execute this command in the extracted PocketBase directory to start the application server. The first run will automatically open an installer link in your browser for initial setup.

```Shell
./pocketbase serve
```

--------------------------------

### Initialize and Start PocketBase Go Application

Source: https://pocketbase.io/docs/js-overview/go-overview

This Go code snippet demonstrates the minimal setup for a PocketBase application. It initializes a new PocketBase instance, registers an OnServe event hook to serve static files from a pb_public directory, and starts the application, handling potential errors.

```Go
package main
import (
   "log"
   "os"
   "github.com/pocketbase/pocketbase"
   "github.com/pocketbase/pocketbase/apis"
   "github.com/pocketbase/pocketbase/core"
)
func main() {
   app := pocketbase.New()
   app.OnServe().BindFunc(func(se *core.ServeEvent) error {
      // serves static files from the provided public dir (if exists)
      se.Router.GET("/{path...}", apis.Static(os.DirFS("./pb_public"), false))
      return se.Next()
   })
   if err := app.Start(); err != nil {
      log.Fatal(err)
   }
}
```

--------------------------------

### Start PocketBase Production HTTPS Server

Source: https://pocketbase.io/docs/js-overview/going-to-production

Command to start the PocketBase executable, binding to privileged ports and automatically managing TLS with Let's Encrypt for a specified domain.

```Shell
[root@dev ~]$ /root/pb/pocketbase serve yourdomain.com
```

--------------------------------

### Configure PocketBase Systemd Service

Source: https://pocketbase.io/docs/js-overview/going-to-production

Example Systemd service file to manage PocketBase as a background service, ensuring it starts on boot and restarts automatically on failure.

```Systemd
[Unit]
Description = pocketbase
[Service]
Type = simple
User = root
Group = root
LimitNOFILE = 4096
Restart = always
RestartSec = 5s
StandardOutput = append:/root/pb/std.log
StandardError = append:/root/pb/std.log
WorkingDirectory = /root/pb
ExecStart = /root/pb/pocketbase serve yourdomain.com
[Install]
WantedBy = multi-user.target
```

--------------------------------

### Enable and Start PocketBase Systemd Service

Source: https://pocketbase.io/docs/js-overview/going-to-production

Commands to enable the PocketBase Systemd service for automatic startup and to immediately start it.

```Shell
[root@dev ~]$ systemctl enable pocketbase.service
[root@dev ~]$ systemctl start pocketbase
```

--------------------------------

### Registering new Go routes with handlers and middlewares

Source: https://pocketbase.io/docs/js-overview/go-routing

This example demonstrates how to register new GET and POST routes in PocketBase's Go backend. It shows a public GET route for '/hello/{name}' and an authenticated POST route for '/api/myapp/settings', illustrating the use of `e.String` and `e.JSON` for responses and `apis.RequireAuth()` for middleware.

```Go
app.OnServe().BindFunc(func(se *core.ServeEvent) error {
	// register "GET /hello/{name}" route (allowed for everyone)
	se.Router.GET("/hello/{name}", func(e *core.RequestEvent) error {
		name := e.Request.PathValue("name")
		return e.String(http.StatusOK, "Hello " + name)
	})
	// register "POST /api/myapp/settings" route (allowed only for authenticated users)
	se.Router.POST("/api/myapp/settings", func(e *core.RequestEvent) error {
		// do something ...
		return e.JSON(http.StatusOK, map[string]bool{"success": true})
	}).Bind(apis.RequireAuth())
	return se.Next()
})
```

--------------------------------

### Registering Custom HTTP Routes in PocketBase (Go, JavaScript)

Source: https://pocketbase.io/docs/js-overview/use-as-framework

This snippet demonstrates how to add custom HTTP GET routes to your PocketBase application. It shows examples for both Go and JavaScript, defining a '/hello' endpoint that returns a 'Hello world!' string. This allows extending the built-in API with custom logic.

```Go
app.OnServe().BindFunc(func(se *core.ServeEvent) error {
  se.Router.GET("/hello", func(e *core.RequestEvent) error {
    return e.String(http.StatusOK, "Hello world!")
  })
  return se.Next()
})
```

```JavaScript
routerAdd("GET", "/hello", (e) => {
  return e.string(200, "Hello world!")
})
```

--------------------------------

### Examples of PocketBase JavaScript Route Path Matching Rules

Source: https://pocketbase.io/docs/js-overview/js-routing

This section provides various examples of route path patterns in PocketBase JavaScript, illustrating how to match specific hosts, use anonymous wildcards (`/static/`), named wildcards (`/static/{path...}`), and exact path matching with `{$}`.

```JavaScript
// match "GET example.com/index.html"
routerAdd("GET", "example.com/index.html", ...)
// match "GET /index.html" (for any host)
routerAdd("GET", "/index.html", ...)
// match "GET /static/", "GET /static/a/b/c", etc.
routerAdd("GET", "/static/", ...)
// match "GET /static/", "GET /static/a/b/c", etc.
// (similar to the above but with a named wildcard parameter)
routerAdd("GET", "/static/{path...}", ...)
// match only "GET /static/" (if no "/static" is registered, it is 301 redirected)
routerAdd("GET", "/static/{$}", ...)
// match "GET /customers/john", "GET /customer/jane", etc.
routerAdd("GET", "/customers/{name}", ...)
```

--------------------------------

### Logging Info Messages in Go

Source: https://pocketbase.io/docs/js-overview/go-logging

Shows how to use `app.Logger().Info()` to log informational messages, including examples for a basic message and one with custom attributes.

```Go
app.Logger().Info("Info message!")
app.Logger().Info(
"Info message with attributes!",
"name", "John Doe",
"id", 123,
)
```

--------------------------------

### Configure PocketBase with ncruces/go-sqlite3 custom driver

Source: https://pocketbase.io/docs/js-overview/go-overview

This example illustrates how to integrate the `github.com/ncruces/go-sqlite3` driver with PocketBase. It demonstrates applying PRAGMAs directly through URL parameters when opening the database connection, providing a concise way to configure the SQLite database.

```Go
package main

import (
	"log"

	"github.com/pocketbase/dbx"
	"github.com/pocketbase/pocketbase"
	_ "github.com/ncruces/go-sqlite3/driver"
	_ "github.com/ncruces/go-sqlite3/embed"
)

func main() {
	app := pocketbase.NewWithConfig(pocketbase.Config{
		DBConnect: func(dbPath string) (*dbx.DB, error) {
			const pragmas = "?_pragma=busy_timeout(10000)&_pragma=journal_mode(WAL)&_pragma=journal_size_limit(200000000)&_pragma=synchronous(NORMAL)&_pragma=foreign_keys(ON)&_pragma=temp_store(MEMORY)&_pragma=cache_size(-16000)"
			return dbx.Open("sqlite3", "file:"+dbPath+pragmas)
		},
	})

	// custom hooks and plugins...
	if err := app.Start(); err != nil {
		log.Fatal(err)
	}
}
```

--------------------------------

### Get Collection Scaffolds with PocketBase Client

Source: https://pocketbase.io/docs/js-overview/api-collections

Demonstrates how to fetch collection scaffolds using the PocketBase client library. The example shows initializing the client, authenticating as a superuser, and then calling the `getScaffolds()` method to retrieve the collection types and default fields.

```JavaScript
import PocketBase from 'pocketbase';
const pb = new PocketBase('http://127.0.0.1:8090');
...
await pb.collection("_superusers").authWithPassword('test@example.com', '1234567890');
const scaffolds = await pb.collections.getScaffolds();
```

```Dart
import 'package:pocketbase/pocketbase.dart';
final pb = PocketBase('http://127.0.0.1:8090');
...
await pb.collection("_superusers").authWithPassword('test@example.com', '1234567890');
final scaffolds = await pb.collections.getScaffolds();
```

--------------------------------

### Configure PocketBase with mattn/go-sqlite3 custom driver

Source: https://pocketbase.io/docs/js-overview/go-overview

This example demonstrates how to register and use the `github.com/mattn/go-sqlite3` driver with PocketBase. It shows how to initialize default PRAGMAs for each new connection using a `ConnectHook` and how to configure PocketBase's `DBConnect` function to use the custom driver.

```Go
package main

import (
	"database/sql"
	"log"

	"github.com/mattn/go-sqlite3"
	"github.com/pocketbase/dbx"
	"github.com/pocketbase/pocketbase"
)

// register a new driver with default PRAGMAs and the same query
// builder implementation as the already existing sqlite3 builder
func init() {
	// initialize default PRAGMAs for each new connection
	sql.Register("pb_sqlite3",
		&sqlite3.SQLiteDriver{
			ConnectHook: func(conn *sqlite3.SQLiteConn) error {
				_, err := conn.Exec(`
PRAGMA busy_timeout = 10000;
PRAGMA journal_mode = WAL;
PRAGMA journal_size_limit = 200000000;
PRAGMA synchronous = NORMAL;
PRAGMA foreign_keys = ON;
PRAGMA temp_store = MEMORY;
PRAGMA cache_size = -16000;
`, nil)
				return err
			},
		},
	)
	dbx.BuilderFuncMap["pb_sqlite3"] = dbx.BuilderFuncMap["sqlite3"]
}

func main() {
	app := pocketbase.NewWithConfig(pocketbase.Config{
		DBConnect: func(dbPath string) (*dbx.DB, error) {
			return dbx.Open("pb_sqlite3", dbPath)
		},
	})

	// any custom hooks or plugins...
	if err := app.Start(); err != nil {
		log.Fatal(err)
	}
}
```

--------------------------------

### Logging Warning Messages in Go

Source: https://pocketbase.io/docs/js-overview/go-logging

Illustrates how to use `app.Logger().Warn()` to log warning-level messages, with examples for a simple warning and a warning including additional attributes.

```Go
app.Logger().Warn("Warning message!")
app.Logger().Warn(
"Warning message with attributes!",
"name", "John Doe",
"id", 123,
)
```

--------------------------------

### Initialize PocketBase Client and Authenticate (Dart)

Source: https://pocketbase.io/docs/js-overview/api-realtime

Demonstrates how to initialize the PocketBase client in Dart and optionally authenticate a user with a username and password. This setup is required before performing other operations like subscriptions.

```dart
import 'package:pocketbase/pocketbase.dart';
final pb = PocketBase('http://127.0.0.1:8090');
...
// (Optionally) authenticate
await pb.collection('users').authWithPassword('test@example.com', '1234567890');
```

--------------------------------

### Minimal Dockerfile for PocketBase Deployment

Source: https://pocketbase.io/docs/js-overview/going-to-production

Provides a basic Dockerfile to create a Docker image for PocketBase. It downloads a specific version of PocketBase, sets up necessary dependencies, and defines the command to start the PocketBase server, with options to include local migrations and hooks.

```Dockerfile
FROM alpine:latest
ARG PB_VERSION=0.28.3
RUN apk add --no-cache \
unzip \
ca-certificates
# download and unzip PocketBase
ADD https://github.com/pocketbase/pocketbase/releases/download/v${PB_VERSION}/pocketbase_${PB_VERSION}_linux_amd64.zip /tmp/pb.zip
RUN unzip /tmp/pb.zip -d /pb/
# uncomment to copy the local pb_migrations dir into the image
# COPY ./pb_migrations /pb/pb_migrations
# uncomment to copy the local pb_hooks dir into the image
# COPY ./pb_hooks /pb/pb_hooks
EXPOSE 8080
# start PocketBase
CMD ["/pb/pocketbase", "serve", "--http=0.0.0.0:8080"]
```

--------------------------------

### PocketBase JS: Loading and Using a CommonJS Utility Module

Source: https://pocketbase.io/docs/js-overview/js-overview

Shows how to load the previously defined `utils.js` module into a `main.pb.js` handler using `require()` and the `__hooks` global variable. The example then calls the `hello` function from the loaded module.

```JavaScript
// pb_hooks/main.pb.js
onBootstrap((e) => {
e.next()
const utils = require(`${__hooks}/utils.js`)
utils.hello("world")
})
```

--------------------------------

### PocketBase DB JSON Field Helpers: get() and set()

Source: https://pocketbase.io/docs/js-overview/js-overview

API documentation for the `get()` and `set()` helper methods required for interacting with `json` field values in PocketBase's embedded JavaScript engine. These methods are necessary due to how Go structural types are wrapped.

```APIDOC
DB JSON Field Values:
  get(): any
    Description: Retrieves the value of a JSON field.
  set(value: any): void
    Description: Sets the value of a JSON field.
```

--------------------------------

### Prepare PocketBase test data via CLI

Source: https://pocketbase.io/docs/js-overview/go-testing

This command shows how to start a PocketBase application with a custom data directory (`test_pb_data`) for testing purposes. The `--automigrate=0` flag prevents automatic migrations, allowing manual data preparation via the dashboard.

```Shell
./pocketbase serve --dir="./test_pb_data" --automigrate=0
```

--------------------------------

### Logging Debug Messages in Go

Source: https://pocketbase.io/docs/js-overview/go-logging

Demonstrates how to use `app.Logger().Debug()` to log debug-level messages, with examples showing logging a simple message and a message with additional key-value attributes.

```Go
app.Logger().Debug("Debug message!")
app.Logger().Debug(
"Debug message with attributes!",
"name", "John Doe",
"id", 123,
)
```

--------------------------------

### Go: Create Custom PocketBase Record Queries

Source: https://pocketbase.io/docs/js-overview/go-records

This snippet demonstrates how to construct custom record queries using PocketBase's `RecordQuery(collection)` method. This method returns a SELECT DB builder, allowing for flexible and complex queries with `dbx` expressions, similar to the general Database guide. An example function to find active articles is provided.

```Go
import (
"github.com/pocketbase/dbx"
"github.com/pocketbase/pocketbase/core"
)
...
func FindActiveArticles(app core.App) ([]*core.Record, error) {
records := []*core.Record{}
err := app.RecordQuery("articles").
AndWhere(dbx.HashExp{"status": "active"}).
OrderBy("published DESC").
Limit(10).
All(&records)
if err != nil {
return nil, err
}
return records, nil
}
```

--------------------------------

### Grant Port Binding Privileges for Non-root User

Source: https://pocketbase.io/docs/js-overview/going-to-production

Example using `setcap` to allow a non-root user to bind to privileged ports (80/443) for the PocketBase executable.

```Shell
[myuser@dev ~]$ sudo setcap 'cap_net_bind_service=+ep' /root/pb/pocketbase
```

--------------------------------

### PocketBase JS: Defining a CommonJS Utility Module

Source: https://pocketbase.io/docs/js-overview/js-overview

Example of creating a `utils.js` file within the `pb_hooks` directory, exporting a helper function using CommonJS `module.exports`. This module can then be loaded and reused by other handlers.

```JavaScript
// pb_hooks/utils.js
module.exports = {
hello: (name) => {
console.log("Hello " + name)
}
}
```

--------------------------------

### Log Info Messages in PocketBase JavaScript

Source: https://pocketbase.io/docs/js-overview/js-logging

Shows how to log informational messages using `$app.logger().info()`. Examples include logging a simple message and a message with additional key-value attributes for structured data.

```JavaScript
$app.logger().info("Info message!")
$app.logger().info(
"Info message with attributes!",
"name", "John Doe",
"id", 123,
)
```

--------------------------------

### SDK: Get PocketBase Backup Download URL

Source: https://pocketbase.io/docs/js-overview/api-backups

Demonstrates how to authenticate as a superuser and obtain a file token to generate a download URL for a PocketBase backup file. This functionality is shown using both JavaScript and Dart SDKs.

```JavaScript
import PocketBase from 'pocketbase';
const pb = new PocketBase('http://127.0.0.1:8090');
...
await pb.collection("_superusers").authWithPassword('test@example.com', '1234567890');
const token = await pb.files.getToken();
const url = pb.backups.getDownloadUrl(token, 'pb_data_backup.zip');
```

```Dart
import 'package:pocketbase/pocketbase.dart';
final pb = PocketBase('http://127.0.0.1:8090');
...
await pb.collection("_superusers").authWithPassword('test@example.com', '1234567890');
final token = await pb.files.getToken();
final url = pb.backups.getDownloadUrl(token, 'pb_data_backup.zip');
```

--------------------------------

### Log Warning Messages in PocketBase JavaScript

Source: https://pocketbase.io/docs/js-overview/js-logging

Illustrates how to log warning messages using `$app.logger().warn()`. Examples include logging a simple warning and a warning with additional key-value attributes for detailed context.

```JavaScript
$app.logger().warn("Warning message!")
$app.logger().warn(
"Warning message with attributes!",
"name", "John Doe",
"id", 123,
)
```

--------------------------------

### GET /api/collections API Endpoint Details

Source: https://pocketbase.io/docs/js-overview/api-collections

Provides comprehensive documentation for the PocketBase GET /api/collections endpoint, detailing query parameters for pagination, sorting, filtering, and field selection, along with an example JSON response structure.

```APIDOC
GET /api/collections
Requires: Authorization:TOKEN

Query Parameters:
- page (Number): The page (aka. offset) of the paginated list (default to 1).
- perPage (Number): The max returned collections per page (default to 30).
- sort (String): Specify the ORDER BY fields. Add - / + (default) in front of the attribute for DESC / ASC order.
  Example: // DESC by created and ASC by id ?sort=-created,id
  Supported collection sort fields: @random, id, created, updated, name, type, system
- filter (String): Filter expression to filter/search the returned collections list.
  Example: ?filter=(name~'abc' && created>'2022-01-01')
  Supported collection filter fields: id, created, updated, name, type, system
  Syntax: OPERAND OPERATOR OPERAND
    OPERAND: any field literal, string (single or double quoted), number, null, true, false
    OPERATOR:
      = Equal
      != NOT equal
      > Greater than
      >= Greater than or equal
      < Less than
      <= Less than or equal
      ~ Like/Contains (auto wraps in "%" for wildcard match)
      !~ NOT Like/Contains (auto wraps in "%" for wildcard match)
      ?= Any/At least one of Equal
      ?!= Any/At least one of NOT equal
      ?> Any/At least one of Greater than
      ?>= Any/At least one of Greater than or equal
      ?< Any/At least one of Less than
      ?<= Any/At least one of Less than or equal
      ?~ Any/At least one of Like/Contains (auto wraps in "%" for wildcard match)
      ?!~ Any/At least one of NOT Like/Contains (auto wraps in "%" for wildcard match)
    Grouping: (...)
    Combining: && (AND), || (OR) 
    Comments: // Example comment
- fields (String): Comma separated string of the fields to return in the JSON response (by default returns all fields).
  Example: ?fields=*,expand.relField.name
  * targets all keys from the specific depth level.
  Field modifiers:
    :excerpt(maxLength, withEllipsis?): Returns a short plain text version of the field string value.
      Example: ?fields=*,description:excerpt(200,true)
- skipTotal (Boolean): If set, total counts query will be skipped. totalItems and totalPages will be -1.
  Speeds up queries when total counters are not needed or cursor based pagination is used.
  Default for getFirstListItem() and getFullList() SDKs methods.

Responses:
- 200 OK
- 400 Bad Request
- 401 Unauthorized
- 403 Forbidden
```

```JSON
{
"page": 1,
"perPage": 2,
"totalItems": 10,
"totalPages": 5,
"items": [
{
"id": "_pbc_344172009",
"listRule": null,
"viewRule": null,
"createRule": null,
"updateRule": null,
"deleteRule": null,
"name": "users",
"type": "auth",
"fields": [
{
"autogeneratePattern": "[a-z0-9]{15}",
"hidden": false,
"id": "text3208210256",
"max": 15,
"min": 15,
"name": "id",
"pattern": "^[a-z0-9]+$",
"presentable": false,
"primaryKey": true,
"required": true,
"system": true,
"type": "text"
},
{
"cost": 0,
"hidden": true,
"id": "password901924565",
"max": 0,
"min": 8,
"name": "password",
"pattern": "",
"presentable": false,
"required": true,
"system": true,
"type": "password"
},
{
"autogeneratePattern": "[a-zA-Z0-9]{50}",
"hidden": true,
"id": "text2504183744",
"max": 60,
"min": 30,
"name": "tokenKey",
"pattern": "",
"presentable": false,
"primaryKey": false,
"required": true,
"system": true,
"type": "text"
},
{
"exceptDomains": null,
"hidden": false,
"id": "email3885137012",
"name": "email",
"onlyDomains": null,
"presentable": false,
"required": true,
"system": true,
"type": "email"
},
{
"hidden": false,
"id": "bool1547992806",
"name": "emailVisibility",
"presentable": false,
"required": false,
"system": true,
"type": "bool"
},
{
"hidden": false,
"id": "bool256245529",
"name": "verified",
"presentable": false,
"required": false,
"system": true,
"type": "bool"
},
{
"autogeneratePattern": "",
"hidden": false,
"id": "text1579384326",
"max": 255,
"min": 0,
"name": "name",
"pattern": "",
"presentable": false,
"primaryKey": false,
"required": false,
"system": false,
"type": "text"
},
{
"hidden": false,
"id": "file376926767",
"maxSelect": 1,
"maxSize": 0,
"mimeTypes": [
"image/jpeg",
"image/png",
"image/svg+xml",
"image/gif",
"image/webp"
],
"name": "avatar",
"presentable": false,
"protected": false,
"required": false,
"system": false,
"thumbs": null,
"type": "file"
},
{
"hidden": false,
"id": "autodate2990389176",
"name": "created",
"onCreate": true,
"onUpdate": false,
"presentable": false,
"system": false,
"type": "date"
}
]
}
]
}
```

--------------------------------

### GET Collection API Details

Source: https://pocketbase.io/docs/js-overview/api-collections

Describes the GET endpoint for retrieving information about a specific PocketBase collection. It details required authentication, path and query parameters, and provides example response schemas for success (200) and common error codes (401, 403, 404).

```APIDOC
GET /api/collections/`collectionIdOrName`

Authentication: Requires Authorization:TOKEN

Path Parameters:
  collectionIdOrName: String - ID or name of the collection to view.

Query Parameters:
  fields: String - Comma separated string of the fields to return in the JSON response (by default returns all fields). Ex.: ?fields=*,expand.relField.name
    * targets all keys from the specific depth level.
    Supported field modifiers:
      :excerpt(maxLength, withEllipsis?) - Returns a short plain text version of the field string value. Ex.: ?fields=*,description:excerpt(200,true)

Responses:
  200 OK:
    {
      "id": "_pbc_2287844090",
      "listRule": null,
      "viewRule": null,
      "createRule": null,
      "updateRule": null,
      "deleteRule": null,
      "name": "posts",
      "type": "base",
      "fields": [
        {
          "autogeneratePattern": "[a-z0-9]{15}",
          "hidden": false,
          "id": "text3208210256",
          "max": 15,
          "min": 15,
          "name": "id",
          "pattern": "^[a-z0-9]+$",
          "presentable": false,
          "primaryKey": true,
          "required": true,
          "system": true,
          "type": "text"
        },
        {
          "autogeneratePattern": "",
          "hidden": false,
          "id": "text724990059",
          "max": 0,
          "min": 0,
          "name": "title",
          "pattern": "",
          "presentable": false,
          "primaryKey": false,
          "required": false,
          "system": false,
          "type": "text"
        },
        {
          "hidden": false,
          "id": "autodate2990389176",
          "name": "created",
          "onCreate": true,
          "onUpdate": false,
          "presentable": false,
          "system": false,
          "type": "autodate"
        },
        {
          "hidden": false,
          "id": "autodate3332085495",
          "name": "updated",
          "onCreate": true,
          "onUpdate": true,
          "presentable": false,
          "system": false,
          "type": "autodate"
        }
      ],
      "indexes": [],
      "system": false
    }
  401 Unauthorized:
    {
      "status": 401,
      "message": "The request requires valid record authorization token.",
      "data": {}
    }
  403 Forbidden:
    {
      "status": 403,
      "message": "The authorized record is not allowed to perform this action.",
      "data": {}
    }
  404 Not Found:
    {
      "status": 404,
      "message": "The requested resource wasn't found.",
      "data": {}
    }
```

--------------------------------

### Load and Render Templates with PocketBase Go Wrapper

Source: https://pocketbase.io/docs/js-overview/go-rendering-templates

This Go code snippet demonstrates how to use PocketBase's `tools/template` package to load multiple template files and render them with provided data. It initializes a new template registry, loads specified HTML files, and then renders them, passing a map as data. This is useful for generating dynamic HTML output in custom routes or emails.

```Go
import "github.com/pocketbase/pocketbase/tools/template"
data := map[string]any{"name": "John"}
html, err := template.NewRegistry().LoadFiles(
"views/base.html",
"views/partial1.html",
"views/partial2.html",
).Render(data)
```

--------------------------------

### API: Get Collection Authentication Methods

Source: https://pocketbase.io/docs/js-overview/api-records

Documents the GET endpoint for retrieving available authentication methods for a specific PocketBase collection. It details path and query parameters, including field selection and modification options, and provides a comprehensive example of the JSON response structure for password, OAuth2, MFA, and OTP configurations.

```APIDOC
GET /api/collections/`collectionIdOrName`/auth-methods

Path parameters:
  collectionIdOrName: String - ID or name of the auth collection.

Query parameters:
  fields: String - Comma separated string of the fields to return in the JSON response (by default returns all fields).
    Ex.: ?fields=*,expand.relField.name
    * targets all keys from the specific depth level.
    Supported field modifiers:
      :excerpt(maxLength, withEllipsis?) - Returns a short plain text version of the field string value.
        Ex.: ?fields=*,description:excerpt(200,true)

Responses:
  200:
    {
      "password": {
        "enabled": true,
        "identityFields": ["email"]
      },
      "oauth2": {
        "enabled": true,
        "providers": [
          {
            "name": "github",
            "displayName": "GitHub",
            "state": "nT7SLxzXKAVMeRQJtxSYj9kvnJAvGk",
            "authURL": "https://github.com/login/oauth/authorize?client_id=test&code_challenge=fcf8WAhNI6uCLJYgJubLyWXHvfs8xghoLe3zksBvxjE&code_challenge_method=S256&response_type=code&scope=read%3Auser+user%3Aemail&state=nT7SLxzXKAVMeRQJtxSYj9kvnJAvGk&redirect_uri=",
            "codeVerifier": "PwBG5OKR2IyQ7siLrrcgWHFwLLLAeUrz7PS1nY4AneG",
            "codeChallenge": "fcf8WAhNI6uCLJYgJubLyWXHvfs8xghoLe3zksBvxjE",
            "codeChallengeMethod": "S256"
          }
        ]
      },
      "mfa": {
        "enabled": false,
        "duration": 0
      },
      "otp": {
        "enabled": false,
        "duration": 0
      }
    }
```

--------------------------------

### Serve HTML Templates with PocketBase Go

Source: https://pocketbase.io/docs/js-overview/go-rendering-templates

This Go code demonstrates how to set up a PocketBase application to serve HTML templates. It registers a custom `/hello/:name` route, loads `layout.html` and `hello.html` using `template.NewRegistry()`, renders them with dynamic data, and returns the generated HTML. It also handles potential errors by returning a 404.

```Go
package main

import (
	"log"
	"net/http"
	"github.com/pocketbase/pocketbase"
	"github.com/pocketbase/pocketbase/core"
	"github.com/pocketbase/pocketbase/tools/template"
)

func main() {
	app := pocketbase.New()

	app.OnServe().BindFunc(func(se *core.ServeEvent) error {
		// this is safe to be used by multiple goroutines
		// (it acts as store for the parsed templates)
		registry := template.NewRegistry()

		se.Router.GET("/hello/{name}", func(e *core.RequestEvent) error {
			name := e.Request.PathValue("name")
			html, err := registry.LoadFiles(
				"views/layout.html",
				"views/hello.html",
			).Render(map[string]any{
				"name": name,
			})
			if err != nil {
				// or redirect to a dedicated 404 HTML page
				return e.NotFoundError("", err)
			}

			return e.HTML(http.StatusOK, html)
		})

		return se.Next()
	})

	if err := app.Start(); err != nil {
		log.Fatal(err)
	}
}
```

--------------------------------

### PocketBase Application Directory Structure

Source: https://pocketbase.io/docs/js-overview/going-to-production

Illustrates the recommended directory structure for a PocketBase application, including migrations, hooks, and the executable.

```Text
myapp/
pb_migrations/
pb_hooks/
pocketbase
```

--------------------------------

### Execute Raw SQL in PocketBase Migration (Go)

Source: https://pocketbase.io/docs/js-overview/go-migrations

This Go code snippet demonstrates how to execute raw SQL statements within a PocketBase migration. The example shows updating the 'status' field of 'articles' to 'pending' where the status is currently empty.

```go
// migrations/1687801090_set_pending_status.go
package migrations
import (
"github.com/pocketbase/pocketbase/core"
m "github.com/pocketbase/pocketbase/migrations"
)
// set a default "pending" status to all empty status articles
func init() {
m.Register(func(app core.App) error {
_, err := app.DB().NewQuery("UPDATE articles SET status = 'pending' WHERE status = ''").Execute()
return err
}, nil)
}
```

--------------------------------

### Initialize Default PocketBase Application Settings (Go)

Source: https://pocketbase.io/docs/js-overview/go-migrations

This Go migration example illustrates how to programmatically set up default application settings for a PocketBase instance. It covers configuring metadata like app name and URL, and log settings such as max days, auth ID logging, and IP logging.

```go
// migrations/1687801090_initial_settings.go
package migrations
import (
"github.com/pocketbase/pocketbase/core"
m "github.com/pocketbase/pocketbase/migrations"
)
func init() {
m.Register(func(app core.App) error {
settings := app.Settings()
// for all available settings fields you could check
// https://github.com/pocketbase/pocketbase/blob/develop/core/settings_model.go#L121-L130
settings.Meta.AppName = "test"
settings.Meta.AppURL = "https://example.com"
settings.Logs.MaxDays = 2
settings.Logs.LogAuthId = true
settings.Logs.LogIP = false
return app.Save(settings)
}, nil)
}
```

--------------------------------

### GET /api/logs/stats API Endpoint

Source: https://pocketbase.io/docs/js-overview/api-logs

Documents the API endpoint for retrieving aggregated log statistics. This endpoint requires an authorization token and supports filtering and selecting specific fields in the response. It provides examples for successful data retrieval and various error scenarios.

```APIDOC
GET /api/logs/stats

Requires Authorization:TOKEN

Query parameters:
  filter:
    Type: String
    Description: Filter expression to filter/search the logs, e.g.: `?filter=(data.url~'test.com' && level>0)`
    Supported log filter fields: `rowid`, `id`, `created`, `updated`, `level`, `message` and any `data.*` attribute.
    Syntax: Basically follows the format `OPERAND OPERATOR OPERAND`
      OPERAND: could be any field literal, string (single or double quoted), number, null, true, false
      OPERATOR: is one of: `=`, `!=`, `>`, `>=`, `<`, `<=`, `~`, `!~`, `?=`, `?!=`, `?>`, `?>=`, `?<`, `?<=`, `?~`, `?!~`
        (`~` and `!~` auto wraps the right string OPERAND in a "%" for wildcard match if not specified)
      Grouping: To group and combine several expressions you can use parenthesis `(...)`, `&&` (AND) and `||` (OR) tokens.
      Comments: Single line comments are also supported: `// Example comment`.
  fields:
    Type: String
    Description: Comma separated string of the fields to return in the JSON response (by default returns all fields).
    Example: `?fields=*,expand.relField.name`
    Wildcard: `*` targets all keys from the specific depth level.
    Field Modifiers:
      :excerpt(maxLength, withEllipsis?): Returns a short plain text version of the field string value.
        Example: `?fields=*,description:excerpt(200,true)`

Responses:
  200 OK:
    Description: Successful response with an array of log statistics.
    Example Body:
      [
        {
          "total": 4,
          "date": "2022-06-01 19:00:00.000"
        },
        {
          "total": 1,
          "date": "2022-06-02 12:00:00.000"
        },
        {
          "total": 8,
          "date": "2022-06-02 13:00:00.000"
        }
      ]
  400 Bad Request:
    Description: Indicates an invalid filter or malformed request.
    Example Body:
      {
        "status": 400,
        "message": "Something went wrong while processing your request. Invalid filter.",
        "data": {}
      }
  401 Unauthorized:
    Description: Occurs when the request lacks a valid authorization token.
    Example Body:
      {
        "status": 401,
        "message": "The request requires valid record authorization token.",
        "data": {}
      }
  403 Forbidden:
    Description: Indicates that the authorized record does not have permission to perform the action.
    Example Body:
      {
        "status": 403,
        "message": "The authorized record is not allowed to perform this action.",
        "data": {}
      }
```

--------------------------------

### Initialize PocketBase SDK and Authenticate

Source: https://pocketbase.io/docs/js-overview/api-realtime

This JavaScript snippet demonstrates how to initialize the PocketBase SDK by creating a new PocketBase instance with the specified API endpoint. It also shows an optional step to authenticate a user using their email and password. This setup is crucial for interacting with PocketBase services, including managing real-time subscriptions.

```JavaScript
import PocketBase from 'pocketbase';
const pb = new PocketBase('http://127.0.0.1:8090');
...
// (Optionally) authenticate
await pb.collection('users').authWithPassword('test@example.com', '1234567890');
```

--------------------------------

### API Details: GET PocketBase Record by ID

Source: https://pocketbase.io/docs/js-overview/api-records

Documents the API endpoint for retrieving a single record from a PocketBase collection by its ID or name. It details path and query parameters, including options for expanding relations and selecting specific fields, along with example success and error responses.

```APIDOC
GET /api/collections/`collectionIdOrName`/records/`recordId`

Path parameters:
  collectionIdOrName: String - ID or name of the record's collection.
  recordId: String - ID of the record to view.

Query parameters:
  expand: String - Auto expand record relations. Ex.: `?expand=relField1,relField2.subRelField`. Supports up to 6-levels depth nested relations expansion. The expanded relations will be appended to the record under the `expand` property (e.g. "expand": {"relField1": {...}, ...}). Only the relations to which the request user has permissions to view will be expanded.
  fields: String - Comma separated string of the fields to return in the JSON response (by default returns all fields). Ex.: `?fields=*,expand.relField.name`. `*` targets all keys from the specific depth level.
    Supported field modifiers:
      :excerpt(maxLength, withEllipsis?): Returns a short plain text version of the field string value. Ex.: `?fields=*,description:excerpt(200,true)`

Responses:
  200 OK:
    {
      "id": "ae40239d2bc4477",
      "collectionId": "a98f514eb05f454",
      "collectionName": "posts",
      "updated": "2022-06-25 11:03:50.052",
      "created": "2022-06-25 11:03:35.163",
      "title": "test1"
    }
  403 Forbidden:
    {
      "status": 403,
      "message": "Only superusers can perform this action.",
      "data": {}
    }
  404 Not Found:
    {
      "status": 404,
      "message": "The requested resource wasn't found.",
      "data": {}
    }
```

--------------------------------

### API Reference: List PocketBase Cron Jobs (GET /api/crons)

Source: https://pocketbase.io/docs/js-overview/api-crons

Detailed API specification for retrieving a list of all registered application-level cron jobs. This endpoint is accessible only by superusers. It supports a 'fields' query parameter for selective field retrieval and provides examples of various HTTP responses.

```APIDOC
GET /api/crons

Query parameters:
- Param: fields
  Type: String
  Description: Comma separated string of the fields to return in the JSON response (by default returns all fields). Ex.: `?fields=*,expand.relField.name`. `*` targets all keys from the specific depth level. In addition, the following field modifiers are also supported: `:excerpt(maxLength, withEllipsis?)` Returns a short plain text version of the field string value. Ex.: `?fields=*,description:excerpt(200,true)`

Responses:
- 200 OK:
  [
    {
      "id": "__pbDBOptimize__",
      "expression": "0 0 * * *"
    },
    {
      "id": "__pbMFACleanup__",
      "expression": "0 * * * *"
    },
    {
      "id": "__pbOTPCleanup__",
      "expression": "0 * * * *"
    },
    {
      "id": "__pbLogsCleanup__",
      "expression": "0 */6 * * *"
    }
  ]
- 400 Bad Request:
  {
    "status": 400,
    "message": "Failed to load backups filesystem.",
    "data": {}
  }
- 401 Unauthorized:
  {
    "status": 401,
    "message": "The request requires valid record authorization token.",
    "data": {}
  }
- 403 Forbidden:
  {
    "status": 403,
    "message": "Only superusers can perform this action.",
    "data": {}
  }
```

--------------------------------

### Update Existing PocketBase Collection in Go

Source: https://pocketbase.io/docs/js-overview/go-collections

This Go example illustrates how to retrieve an existing PocketBase collection by name or ID, modify its deletion rule, add a new 'EditorField', and update properties of an existing field like 'titleField' by getting a pointer to it. It also demonstrates adding a new index and saving the changes to the database.

```Go
import (
"github.com/pocketbase/pocketbase/core"
"github.com/pocketbase/pocketbase/tools/types"
)
...
collection, err := app.FindCollectionByNameOrId("example")
if err != nil {
return err
}
// change rule
collection.DeleteRule = types.Pointer("@request.auth.id != ''")
// add new editor field
collection.Fields.Add(&core.EditorField{
Name: "description",
Required: true,
})
// change existing field
// (returns a pointer and direct modifications are allowed without the need of reinsert)
titleField := collection.Fields.GetByName("title")
titleField.Min = 10
// or: collection.Indexes = append(collection.Indexes, "CREATE INDEX idx_example_title ON example (title)")
collection.AddIndex("idx_example_title", false, "title", "")
// validate and persist
// (use SaveNoValidate to skip fields validation)
err = app.Save(collection)
if err != nil {
return err
}
```

--------------------------------

### Schedule Periodic Task with PocketBase Go Cron

Source: https://pocketbase.io/docs/js-overview/go-jobs-scheduling

This example demonstrates how to schedule a periodic task using PocketBase's built-in `app.Cron()` functionality in Go. It registers a job with a unique ID, a cron expression (e.g., `*/2 * * * *` for every 2 minutes), and a handler function that executes the desired logic. The scheduler starts automatically on app `serve`.

```Go
// main.go
package main
import (
"log"
"github.com/pocketbase/pocketbase"
)
func main() {
app := pocketbase.New()
// prints "Hello!" every 2 minutes
app.Cron().MustAdd("hello", "*/2 * * * *", func() {
log.Println("Hello!")
})
if err := app.Start(); err != nil {
log.Fatal(err)
}
}
```

--------------------------------

### PocketBase JavaScript Filesystem API Reference

Source: https://pocketbase.io/docs/js-overview/js-filesystem

Reference for key methods and interfaces related to file system operations in PocketBase's JavaScript environment, including initialization and file factories.

```APIDOC
$app.newFilesystem():
  Description: Initializes and returns a new filesystem instance.

filesystem.System interface:
  Description: Provides methods for interacting with the PocketBase filesystem.
  Methods:
    getReader(key: string):
      Description: Retrieves a file reader for a specific file key.
      Parameters:
        key: The unique identifier for the file.
    list(prefix: string):
      Description: Retrieves multiple files matching a specific prefix.
      Parameters:
        prefix: The path prefix to filter files.
    upload(content: any, key: string):
      Description: Uploads generic content to a specified file key.
      Parameters:
        content: The content to upload (e.g., string, buffer).
        key: The unique identifier for the file.
    uploadFile(file: File, key: string):
      Description: Uploads a File object to a specified file key.
      Parameters:
        file: The File object to upload.
        key: The unique identifier for the file.
    uploadMultipart(mfh: MultipartFileHeader, key: string):
      Description: Uploads a multipart file header to a specified file key.
      Parameters:
        mfh: The MultipartFileHeader object.
        key: The unique identifier for the file.

$filesystem (File Factories):
  Description: Provides utility methods to create File objects from various sources.
  Methods:
    fileFromBytes(content: Uint8Array, name: string):
      Description: Creates a File object from a byte array.
      Parameters:
        content: The byte content of the file.
        name: The name of the file.
    fileFromURL(url: string):
      Description: Creates a File object from a URL.
      Parameters:
        url: The URL pointing to the file content.
    fileFromMultipart(mfh: MultipartFileHeader):
      Description: Creates a File object from a multipart file header.
      Parameters:
        mfh: The MultipartFileHeader object.
```

--------------------------------

### Advanced PocketBase Middleware Registration and Execution Order in Go

Source: https://pocketbase.io/docs/js-overview/go-routing

This example illustrates advanced middleware registration in PocketBase Go, showing how to attach middlewares globally, to a router group, and to a single route. It demonstrates using `Bind` with `hook.Handler` to specify an `Id` and `Priority`, and highlights the execution sequence of multiple middlewares.

```Go
app.OnServe().BindFunc(func(se *core.ServeEvent) error {
// attach global middleware
se.Router.BindFunc(func(e *core.RequestEvent) error {
println(0)
return e.Next()
})
g := se.Router.Group("/sub")
// attach group middleware
g.BindFunc(func(e *core.RequestEvent) error {
println(1)
return e.Next()
})
// attach group middleware with an id and custom priority
g.Bind(&hook.Handler[*core.RequestEvent]{
Id: "something",
Func: func(e *core.RequestEvent) error {
println(2)
return e.Next()
},
Priority: -1,
})
// attach middleware to a single route
//
// "GET /sub/hello" should print the sequence: 2,0,1,3,4
g.GET("/hello", func(e *core.RequestEvent) error {
println(4)
return e.String(200, "Hello!")
}).BindFunc(func(e *core.RequestEvent) error {
println(3)
return e.Next()
})
return se.Next()
})
```

--------------------------------

### Registering Custom Console Commands in PocketBase (Go, JavaScript)

Source: https://pocketbase.io/docs/js-overview/use-as-framework

This snippet demonstrates how to extend the PocketBase CLI by registering custom console commands. It provides examples for both Go and JavaScript, showing how to define a simple 'hello' command that prints 'Hello world!' when executed from the command line. This is useful for custom administrative tasks.

```Go
app.RootCmd.AddCommand(&cobra.Command{
  Use: "hello",
  Run: func(cmd *cobra.Command, args []string) {
    print("Hello world!")
  },
})
```

```JavaScript
$app.rootCmd.addCommand(new Command({
  use: "hello",
  run: (cmd, args) => {
    console.log("Hello world!")
  },
}))
```

--------------------------------

### Registering Custom GET and POST Routes with routerAdd

Source: https://pocketbase.io/docs/js-overview/js-routing

This snippet demonstrates how to register custom HTTP GET and POST routes in PocketBase JavaScript. It shows how to define path parameters like `{name}` and how to apply middleware, such as `$apis.requireAuth()`, to secure routes.

```JavaScript
// register "GET /hello/{name}" route (allowed for everyone)
routerAdd("GET", "/hello/{name}", (e) => {
let name = e.request.pathValue("name")
return e.json(200, { "message": "Hello " + name })
})
// register "POST /api/myapp/settings" route (allowed only for authenticated users)
routerAdd("POST", "/api/myapp/settings", (e) => {
// do something ...
return e.json(200, {"success": true})
}, $apis.requireAuth())
```

--------------------------------

### PocketBase JS Handler Scope: Variable Isolation Example

Source: https://pocketbase.io/docs/js-overview/js-overview

Demonstrates that JavaScript handler functions in PocketBase are executed in an isolated context, preventing access to variables declared outside their scope. This example shows `name` becoming undefined inside the `onBootstrap` handler.

```JavaScript
const name = "test"
onBootstrap((e) => {
e.next()
console.log(name) // <-- name will be undefined inside the handler
})
```
Tokens:
Raw