PocketBase

# Linux AMD64
wget https://github.com/pocketbase/pocketbase/releases/download/v0.22.0/pocketbase_0.22.0_linux_amd64.zip
unzip pocketbase_0.22.0_linux_amd64.zip

# macOS ARM64 (Apple Silicon)
wget https://github.com/pocketbase/pocketbase/releases/download/v0.22.0/pocketbase_0.22.0_darwin_arm64.zip
unzip pocketbase_0.22.0_darwin_arm64.zip

# macOS AMD64 (Intel)
wget https://github.com/pocketbase/pocketbase/releases/download/v0.22.0/pocketbase_0.22.0_darwin_amd64.zip
unzip pocketbase_0.22.0_darwin_amd64.zip

# Windows
# Pobierz pocketbase_0.22.0_windows_amd64.zip z GitHub Releases

# Uruchomienie serwera
./pocketbase serve

# Z custom portem
./pocketbase serve --http="127.0.0.1:8080"

# Z publicznym dostępem
./pocketbase serve --http="0.0.0.0:8090"

my-app/
├── pocketbase           # Plik wykonywalny
├── pb_data/
│   ├── data.db         # Baza danych SQLite
│   ├── storage/        # Przechowywane pliki
│   └── backups/        # Automatyczne backupy
└── pb_migrations/       # Opcjonalne migracje

http://127.0.0.1:8090/_/

Kolekcja: posts
├── title (Text, required)
├── slug (Text, unique)
├── content (Editor)
├── excerpt (Text)
├── cover (File, single)
├── published (Bool, default: false)
├── author (Relation -> users)
├── categories (Relation -> categories, multiple)
├── tags (JSON)
└── created, updated (auto)

Kolekcja: categories
├── name (Text, required)
├── slug (Text, unique)
└── description (Text)

Kolekcja: comments (Base)
├── content (Text, required)
├── post (Relation -> posts)
├── author (Relation -> users)
└── approved (Bool, default: false)

List/Search Rule:   published = true || @request.auth.id != ""
View Rule:          published = true || @request.auth.id = author.id
Create Rule:        @request.auth.id != ""
Update Rule:        @request.auth.id = author.id
Delete Rule:        @request.auth.id = author.id

# Sprawdzenie czy użytkownik zalogowany
@request.auth.id != ""

# Sprawdzenie pola rekordu
published = true

# Sprawdzenie właściciela
@request.auth.id = author.id

# Sprawdzenie roli użytkownika (custom field w users)
@request.auth.role = "admin"

# Łączenie warunków
(published = true) || (@request.auth.id = author.id)

# Sprawdzenie relacji
@request.auth.id ?= members.id

# Dostęp do danych z request body
@request.data.status = "draft"

# npm
npm install pocketbase

# yarn
yarn add pocketbase

# pnpm
pnpm add pocketbase

import PocketBase from 'pocketbase'

// Inicjalizacja klienta
const pb = new PocketBase('http://127.0.0.1:8090')

// Opcjonalnie: automatyczne odświeżanie tokenu
pb.autoCancellation(false)

// Eksport dla użycia w całej aplikacji
export default pb

// lib/pocketbase.ts
import PocketBase from 'pocketbase'

// Singleton pattern dla server-side
let pb: PocketBase | null = null

export function getPocketBase(): PocketBase {
  if (!pb) {
    pb = new PocketBase(process.env.NEXT_PUBLIC_POCKETBASE_URL)
  }
  return pb
}

// Hook dla client-side z auth state
// hooks/usePocketBase.ts
import PocketBase from 'pocketbase'
import { useEffect, useState } from 'react'

export function usePocketBase() {
  const [pb] = useState(() => new PocketBase(
    process.env.NEXT_PUBLIC_POCKETBASE_URL
  ))
  const [user, setUser] = useState(pb.authStore.model)

  useEffect(() => {
    // Nasłuchuj zmian auth state
    const unsubscribe = pb.authStore.onChange((token, model) => {
      setUser(model)
    })

    return () => unsubscribe()
  }, [pb])

  return { pb, user }
}

// types/pocketbase.ts
import PocketBase, { RecordModel } from 'pocketbase'

// Definicja typów dla kolekcji
export interface User extends RecordModel {
  email: string
  name: string
  avatar?: string
  role: 'user' | 'admin'
}

export interface Post extends RecordModel {
  title: string
  slug: string
  content: string
  excerpt?: string
  cover?: string
  published: boolean
  author: string // ID użytkownika
  categories: string[] // IDs kategorii
  tags?: string[]
  // Expanded relations
  expand?: {
    author?: User
    categories?: Category[]
  }
}

export interface Category extends RecordModel {
  name: string
  slug: string
  description?: string
}

// Typed PocketBase client
export type TypedPocketBase = PocketBase & {
  collection(name: 'users'): ReturnType<PocketBase['collection']>
  collection(name: 'posts'): ReturnType<PocketBase['collection']>
  collection(name: 'categories'): ReturnType<PocketBase['collection']>
}

import PocketBase from 'pocketbase'

const pb = new PocketBase('http://127.0.0.1:8090')

// Rejestracja nowego użytkownika
async function register(email: string, password: string, name: string) {
  try {
    const user = await pb.collection('users').create({
      email,
      password,
      passwordConfirm: password,
      name,
      emailVisibility: true
    })

    // Opcjonalnie: wyślij email weryfikacyjny
    await pb.collection('users').requestVerification(email)

    return user
  } catch (error) {
    console.error('Registration failed:', error)
    throw error
  }
}

// Logowanie
async function login(email: string, password: string) {
  try {
    const authData = await pb.collection('users').authWithPassword(
      email,
      password
    )

    console.log('Logged in user:', authData.record)
    console.log('Auth token:', authData.token)

    // Token jest automatycznie przechowywany w pb.authStore
    return authData
  } catch (error) {
    console.error('Login failed:', error)
    throw error
  }
}

// Wylogowanie
function logout() {
  pb.authStore.clear()
}

// Sprawdzenie czy zalogowany
function isLoggedIn(): boolean {
  return pb.authStore.isValid
}

// Pobranie aktualnego użytkownika
function getCurrentUser() {
  return pb.authStore.model
}

// Odświeżenie tokenu
async function refreshAuth() {
  if (pb.authStore.isValid) {
    await pb.collection('users').authRefresh()
  }
}

// Dostępni providerzy (konfiguracja w Admin Panel > Settings > Auth providers)
// Google, Facebook, GitHub, GitLab, Discord, Twitter, Microsoft, Spotify, etc.

// Lista dostępnych metod OAuth
async function getOAuthProviders() {
  const methods = await pb.collection('users').listAuthMethods()
  console.log('Available providers:', methods.authProviders)
  return methods.authProviders
}

// Logowanie przez OAuth (np. Google)
async function loginWithGoogle() {
  try {
    const authData = await pb.collection('users').authWithOAuth2({
      provider: 'google',
      // Opcjonalnie: custom scopes
      scopes: ['email', 'profile']
    })

    console.log('OAuth user:', authData.record)
    return authData
  } catch (error) {
    console.error('OAuth login failed:', error)
    throw error
  }
}

// OAuth z przekierowaniem (dla SSR)
async function loginWithOAuth2Redirect(provider: string) {
  const authMethods = await pb.collection('users').listAuthMethods()
  const providerConfig = authMethods.authProviders.find(p => p.name === provider)

  if (!providerConfig) {
    throw new Error(`Provider ${provider} not found`)
  }

  // Przekieruj użytkownika do providera
  const redirectUrl = `${window.location.origin}/auth/callback`

  // Zapisz state do weryfikacji
  localStorage.setItem('oauth_state', providerConfig.state)
  localStorage.setItem('oauth_verifier', providerConfig.codeVerifier)

  // Przekierowanie
  window.location.href = providerConfig.authUrl + redirectUrl
}

// Callback handler
async function handleOAuthCallback(code: string, state: string) {
  const savedState = localStorage.getItem('oauth_state')
  const codeVerifier = localStorage.getItem('oauth_verifier')

  if (state !== savedState) {
    throw new Error('Invalid OAuth state')
  }

  const authData = await pb.collection('users').authWithOAuth2Code(
    'google',
    code,
    codeVerifier!,
    `${window.location.origin}/auth/callback`
  )

  localStorage.removeItem('oauth_state')
  localStorage.removeItem('oauth_verifier')

  return authData
}

// Wysłanie emaila z linkiem do resetu
async function requestPasswordReset(email: string) {
  await pb.collection('users').requestPasswordReset(email)
}

// Potwierdzenie resetu (z tokenu w URL)
async function confirmPasswordReset(
  token: string,
  newPassword: string
) {
  await pb.collection('users').confirmPasswordReset(
    token,
    newPassword,
    newPassword
  )
}

// Zmiana hasła zalogowanego użytkownika
async function changePassword(
  oldPassword: string,
  newPassword: string
) {
  const userId = pb.authStore.model?.id
  if (!userId) throw new Error('Not logged in')

  await pb.collection('users').update(userId, {
    oldPassword,
    password: newPassword,
    passwordConfirm: newPassword
  })
}

// Wysłanie emaila weryfikacyjnego
async function requestEmailVerification(email: string) {
  await pb.collection('users').requestVerification(email)
}

// Potwierdzenie weryfikacji (z tokenu w URL)
async function confirmEmailVerification(token: string) {
  await pb.collection('users').confirmVerification(token)
}

// Tworzenie pojedynczego rekordu
async function createPost(data: {
  title: string
  content: string
  author: string
}) {
  const post = await pb.collection('posts').create({
    title: data.title,
    content: data.content,
    author: data.author,
    slug: slugify(data.title),
    published: false
  })

  return post
}

// Tworzenie z plikiem
async function createPostWithCover(
  data: {
    title: string
    content: string
    author: string
  },
  coverFile: File
) {
  const formData = new FormData()
  formData.append('title', data.title)
  formData.append('content', data.content)
  formData.append('author', data.author)
  formData.append('cover', coverFile)

  const post = await pb.collection('posts').create(formData)
  return post
}

// Pobierz pojedynczy rekord po ID
async function getPostById(id: string) {
  const post = await pb.collection('posts').getOne(id, {
    expand: 'author,categories'
  })
  return post
}

// Pobierz pierwszy pasujący rekord
async function getPostBySlug(slug: string) {
  const post = await pb.collection('posts').getFirstListItem(
    `slug = "${slug}"`,
    { expand: 'author,categories' }
  )
  return post
}

// Lista z paginacją
async function getPosts(page = 1, perPage = 20) {
  const posts = await pb.collection('posts').getList(page, perPage, {
    filter: 'published = true',
    sort: '-created',
    expand: 'author,categories'
  })

  return {
    items: posts.items,
    page: posts.page,
    perPage: posts.perPage,
    totalItems: posts.totalItems,
    totalPages: posts.totalPages
  }
}

// Pobierz wszystkie rekordy (uwaga na performance!)
async function getAllPosts() {
  const posts = await pb.collection('posts').getFullList({
    filter: 'published = true',
    sort: '-created',
    expand: 'author'
  })
  return posts
}

// Pobierz tylko ID dla statycznych ścieżek
async function getAllPostSlugs() {
  const posts = await pb.collection('posts').getFullList({
    fields: 'slug'
  })
  return posts.map(p => p.slug)
}

// Aktualizacja całego rekordu
async function updatePost(id: string, data: Partial<Post>) {
  const post = await pb.collection('posts').update(id, data)
  return post
}

// Aktualizacja z nowym plikiem (zastąpi stary)
async function updatePostCover(id: string, coverFile: File) {
  const formData = new FormData()
  formData.append('cover', coverFile)

  const post = await pb.collection('posts').update(id, formData)
  return post
}

// Usunięcie pliku (ustaw na null)
async function removePostCover(id: string) {
  const post = await pb.collection('posts').update(id, {
    cover: null
  })
  return post
}

// Usunięcie pojedynczego rekordu
async function deletePost(id: string) {
  await pb.collection('posts').delete(id)
}

// Usunięcie wielu rekordów (batch)
async function deleteMultiplePosts(ids: string[]) {
  await Promise.all(
    ids.map(id => pb.collection('posts').delete(id))
  )
}

// Podstawowe porównania
await pb.collection('posts').getList(1, 20, {
  filter: 'published = true'
})

// Porównanie liczb
await pb.collection('products').getList(1, 20, {
  filter: 'price >= 100 && price <= 500'
})

// Wyszukiwanie tekstowe (LIKE)
await pb.collection('posts').getList(1, 20, {
  filter: 'title ~ "JavaScript"'
})

// Wyszukiwanie case-insensitive
await pb.collection('posts').getList(1, 20, {
  filter: 'title ~ "%react%"'
})

// Sprawdzenie czy pole nie jest puste
await pb.collection('posts').getList(1, 20, {
  filter: 'cover != ""'
})

// Sprawdzenie daty
await pb.collection('posts').getList(1, 20, {
  filter: 'created >= "2024-01-01 00:00:00"'
})

// Sprawdzenie obecności w tablicy (dla relacji many)
await pb.collection('posts').getList(1, 20, {
  filter: 'categories ?~ "abc123"'  // zawiera kategorię o ID
})

// Kombinacja filtrów
await pb.collection('posts').getList(1, 20, {
  filter: `
    published = true &&
    (title ~ "${searchTerm}" || content ~ "${searchTerm}") &&
    author = "${authorId}"
  `
})

// Sortowanie rosnąco
await pb.collection('posts').getList(1, 20, {
  sort: 'created'
})

// Sortowanie malejąco (prefix -)
await pb.collection('posts').getList(1, 20, {
  sort: '-created'
})

// Wielokrotne sortowanie
await pb.collection('posts').getList(1, 20, {
  sort: '-published,created'  // najpierw published (desc), potem created (asc)
})

// Sortowanie po relacji
await pb.collection('posts').getList(1, 20, {
  sort: 'author.name'
})

// Losowe sortowanie
await pb.collection('posts').getList(1, 20, {
  sort: '@random'
})

// Tylko wybrane pola (oszczędność bandwidth)
await pb.collection('posts').getList(1, 20, {
  fields: 'id,title,slug,created'
})

// Expand relacji (dodaj dane z powiązanych kolekcji)
await pb.collection('posts').getList(1, 20, {
  expand: 'author,categories'
})

// Dostęp do expanded data
const posts = await pb.collection('posts').getList(1, 20, {
  expand: 'author'
})

posts.items.forEach(post => {
  console.log('Author name:', post.expand?.author?.name)
})

// Nested expand (relacja w relacji)
await pb.collection('comments').getList(1, 20, {
  expand: 'post.author'  // komentarz -> post -> autor
})

// Indirect expand (back-relations)
await pb.collection('users').getList(1, 20, {
  expand: 'posts_via_author'  // posty gdzie user jest autorem
})

// Subskrybuj wszystkie zmiany w kolekcji
pb.collection('posts').subscribe('*', (e) => {
  console.log('Action:', e.action)  // create, update, delete
  console.log('Record:', e.record)

  switch (e.action) {
    case 'create':
      addPostToUI(e.record)
      break
    case 'update':
      updatePostInUI(e.record)
      break
    case 'delete':
      removePostFromUI(e.record.id)
      break
  }
})

// Subskrybuj konkretny rekord
pb.collection('posts').subscribe('RECORD_ID', (e) => {
  console.log('Post updated:', e.record)
})

// Subskrypcja z filtrem (client-side)
pb.collection('posts').subscribe('*', (e) => {
  if (e.record.published) {
    handlePublishedPost(e.record)
  }
})

// Anuluj subskrypcję dla konkretnej kolekcji
pb.collection('posts').unsubscribe('*')
pb.collection('posts').unsubscribe('RECORD_ID')

// Anuluj wszystkie subskrypcje
pb.realtime.unsubscribe()

// React Hook dla realtime
function useRealtimePosts() {
  const [posts, setPosts] = useState<Post[]>([])
  const pb = usePocketBase()

  useEffect(() => {
    // Pobierz początkowe dane
    pb.collection('posts').getFullList({
      filter: 'published = true',
      sort: '-created'
    }).then(setPosts)

    // Subskrybuj zmiany
    pb.collection('posts').subscribe('*', (e) => {
      setPosts(current => {
        switch (e.action) {
          case 'create':
            if (e.record.published) {
              return [e.record as Post, ...current]
            }
            return current
          case 'update':
            return current.map(p =>
              p.id === e.record.id ? e.record as Post : p
            )
          case 'delete':
            return current.filter(p => p.id !== e.record.id)
          default:
            return current
        }
      })
    })

    // Cleanup
    return () => {
      pb.collection('posts').unsubscribe('*')
    }
  }, [pb])

  return posts
}

// Subskrypcje działają tylko dla rekordów,
// do których użytkownik ma dostęp (zgodnie z API rules)

// Przykład: prywatne wiadomości
pb.collection('messages').subscribe('*', (e) => {
  // Otrzymasz tylko wiadomości, gdzie:
  // sender = @request.auth.id || receiver = @request.auth.id
  console.log('New message:', e.record)
})

// Upload pojedynczego pliku
async function uploadAvatar(userId: string, file: File) {
  const formData = new FormData()
  formData.append('avatar', file)

  const user = await pb.collection('users').update(userId, formData)
  return user
}

// Upload wielu plików
async function uploadGalleryImages(postId: string, files: FileList) {
  const formData = new FormData()

  // Dla pola typu File z opcją "multiple"
  for (let i = 0; i < files.length; i++) {
    formData.append('gallery', files[i])
  }

  const post = await pb.collection('posts').update(postId, formData)
  return post
}

// Upload z progress tracking (fetch API)
async function uploadWithProgress(
  collectionName: string,
  recordId: string,
  fieldName: string,
  file: File,
  onProgress: (percent: number) => void
) {
  return new Promise((resolve, reject) => {
    const xhr = new XMLHttpRequest()
    const formData = new FormData()
    formData.append(fieldName, file)

    xhr.upload.addEventListener('progress', (e) => {
      if (e.lengthComputable) {
        onProgress(Math.round((e.loaded / e.total) * 100))
      }
    })

    xhr.addEventListener('load', () => {
      if (xhr.status >= 200 && xhr.status < 300) {
        resolve(JSON.parse(xhr.responseText))
      } else {
        reject(new Error(xhr.statusText))
      }
    })

    xhr.addEventListener('error', () => reject(new Error('Upload failed')))

    xhr.open('PATCH', `${pb.baseUrl}/api/collections/${collectionName}/records/${recordId}`)
    xhr.setRequestHeader('Authorization', pb.authStore.token)
    xhr.send(formData)
  })
}

// Pobierz URL do pliku
const avatarUrl = pb.files.getUrl(user, user.avatar)

// Z thumbnailem (dla obrazów)
const thumbUrl = pb.files.getUrl(user, user.avatar, {
  thumb: '100x100'
})

// Dostępne opcje thumb:
// - '100x100' - resize do dokładnie 100x100
// - '100x0' - resize zachowując proporcje (szerokość 100)
// - '0x100' - resize zachowując proporcje (wysokość 100)
// - '100x100t' - crop do środka
// - '100x100b' - crop od dołu
// - '100x100f' - fit (zmieść w 100x100 zachowując proporcje)

// Dla wielu plików (pole z multiple)
const galleryUrls = post.gallery.map(filename =>
  pb.files.getUrl(post, filename)
)

// Helper dla Next.js Image
function getPocketBaseImageUrl(
  record: RecordModel,
  filename: string,
  thumb?: string
): string {
  if (!filename) return '/placeholder.png'

  const url = pb.files.getUrl(record, filename, { thumb })
  return url
}

// Użycie w komponencie
<Image
  src={getPocketBaseImageUrl(user, user.avatar, '200x200')}
  alt={user.name}
  width={200}
  height={200}
/>

// Usuń konkretny plik (ustaw na null lub pusty string)
await pb.collection('users').update(userId, {
  avatar: null
})

// Dla pola z wieloma plikami - usuń jeden
await pb.collection('posts').update(postId, {
  'gallery-': 'filename-to-remove.jpg'  // prefix - oznacza usunięcie
})

// Dodaj nowy plik do istniejącej kolekcji
const formData = new FormData()
formData.append('gallery+', newFile)  // prefix + oznacza dodanie
await pb.collection('posts').update(postId, formData)

// main.go
package main

import (
    "log"
    "net/http"

    "github.com/labstack/echo/v5"
    "github.com/pocketbase/pocketbase"
    "github.com/pocketbase/pocketbase/core"
    "github.com/pocketbase/pocketbase/apis"
)

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

    // Custom route - publiczny endpoint
    app.OnBeforeServe().Add(func(e *core.ServeEvent) error {
        e.Router.GET("/api/hello", func(c echo.Context) error {
            return c.JSON(http.StatusOK, map[string]string{
                "message": "Hello from PocketBase!",
            })
        })
        return nil
    })

    // Custom route - chroniony (wymaga auth)
    app.OnBeforeServe().Add(func(e *core.ServeEvent) error {
        e.Router.GET("/api/protected", func(c echo.Context) error {
            authRecord, _ := c.Get(apis.ContextAuthRecordKey).(*models.Record)

            if authRecord == nil {
                return apis.NewForbiddenError("Unauthorized", nil)
            }

            return c.JSON(http.StatusOK, map[string]any{
                "user": authRecord.Email(),
                "message": "Welcome!",
            })
        }, apis.RequireRecordAuth())
        return nil
    })

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

package main

import (
    "log"

    "github.com/pocketbase/pocketbase"
    "github.com/pocketbase/pocketbase/core"
)

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

    // Hook przed utworzeniem rekordu
    app.OnRecordBeforeCreateRequest("posts").Add(func(e *core.RecordCreateEvent) error {
        // Automatycznie ustaw autora na zalogowanego użytkownika
        if authRecord := e.HttpContext.Get(apis.ContextAuthRecordKey); authRecord != nil {
            e.Record.Set("author", authRecord.(*models.Record).Id)
        }

        // Generuj slug z tytułu
        title := e.Record.GetString("title")
        slug := slugify(title)
        e.Record.Set("slug", slug)

        return nil
    })

    // Hook po utworzeniu rekordu
    app.OnRecordAfterCreateRequest("posts").Add(func(e *core.RecordCreateEvent) error {
        // Wyślij notyfikację
        log.Printf("New post created: %s", e.Record.GetString("title"))

        // Wyślij email do adminów
        // sendEmailToAdmins(e.Record)

        return nil
    })

    // Hook przed aktualizacją
    app.OnRecordBeforeUpdateRequest("posts").Add(func(e *core.RecordUpdateEvent) error {
        // Sprawdź czy użytkownik może edytować
        authRecord := e.HttpContext.Get(apis.ContextAuthRecordKey).(*models.Record)

        if e.Record.GetString("author") != authRecord.Id {
            // Sprawdź czy admin
            if authRecord.GetString("role") != "admin" {
                return apis.NewForbiddenError("You can only edit your own posts", nil)
            }
        }

        return nil
    })

    // Hook na uwierzytelnienie
    app.OnRecordAuthRequest("users").Add(func(e *core.RecordAuthEvent) error {
        log.Printf("User logged in: %s", e.Record.Email())
        return nil
    })

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

package main

import (
    "github.com/pocketbase/pocketbase"
    "github.com/pocketbase/pocketbase/tools/cron"
)

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

    // Scheduler uruchamiany co godzinę
    app.OnBeforeServe().Add(func(e *core.ServeEvent) error {
        scheduler := cron.New()

        // Co godzinę - cleanup starych sesji
        scheduler.MustAdd("cleanup", "0 * * * *", func() {
            log.Println("Running cleanup...")
            // Implementacja cleanup
        })

        // Codziennie o północy - backup
        scheduler.MustAdd("backup", "0 0 * * *", func() {
            log.Println("Running backup...")
            // app.CreateBackup("backup_" + time.Now().Format("2006-01-02"))
        })

        // Co 5 minut - sprawdź zaplanowane posty
        scheduler.MustAdd("publish", "*/5 * * * *", func() {
            publishScheduledPosts(app)
        })

        scheduler.Start()

        return nil
    })

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

func publishScheduledPosts(app *pocketbase.PocketBase) {
    records, err := app.Dao().FindRecordsByFilter(
        "posts",
        "published = false && scheduled_at <= {:now}",
        "-scheduled_at",
        100,
        0,
        dbx.Params{"now": time.Now().UTC().Format(time.RFC3339)},
    )

    if err != nil {
        log.Printf("Error finding scheduled posts: %v", err)
        return
    }

    for _, record := range records {
        record.Set("published", true)
        if err := app.Dao().SaveRecord(record); err != nil {
            log.Printf("Error publishing post %s: %v", record.Id, err)
        }
    }
}

# Dockerfile
FROM alpine:latest

ARG PB_VERSION=0.22.0

RUN apk add --no-cache \
    unzip \
    ca-certificates

# Download 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/

# Create data directory
RUN mkdir -p /pb/pb_data

EXPOSE 8090

# Start PocketBase
CMD ["/pb/pocketbase", "serve", "--http=0.0.0.0:8090"]

# docker-compose.yml
version: '3.8'

services:
  pocketbase:
    build: .
    container_name: pocketbase
    restart: unless-stopped
    ports:
      - "8090:8090"
    volumes:
      - pocketbase_data:/pb/pb_data
      - ./pb_migrations:/pb/pb_migrations
    healthcheck:
      test: ["CMD", "wget", "--no-verbose", "--tries=1", "--spider", "http://localhost:8090/api/health"]
      interval: 30s
      timeout: 10s
      retries: 3

volumes:
  pocketbase_data:

# railway.toml
[build]
builder = "dockerfile"

[deploy]
startCommand = "/pb/pocketbase serve --http=0.0.0.0:$PORT"
healthcheckPath = "/api/health"
healthcheckTimeout = 100
restartPolicyType = "ON_FAILURE"
restartPolicyMaxRetries = 10

# fly.toml
app = "my-pocketbase-app"
primary_region = "waw"

[build]
  dockerfile = "Dockerfile"

[http_service]
  internal_port = 8090
  force_https = true
  auto_stop_machines = false
  auto_start_machines = true
  min_machines_running = 1

[mounts]
  source = "pb_data"
  destination = "/pb/pb_data"

[[vm]]
  cpu_kind = "shared"
  cpus = 1
  memory_mb = 256

# Deploy na Fly.io
fly launch
fly volumes create pb_data --region waw --size 1
fly deploy

# /etc/systemd/system/pocketbase.service
[Unit]
Description=PocketBase
After=network.target

[Service]
Type=simple
User=pocketbase
Group=pocketbase
LimitNOFILE=4096
Restart=always
RestartSec=5s
WorkingDirectory=/home/pocketbase
ExecStart=/home/pocketbase/pocketbase serve --http="0.0.0.0:8090"

[Install]
WantedBy=multi-user.target

# Instalacja
sudo useradd -r -s /bin/false pocketbase
sudo mkdir -p /home/pocketbase
sudo chown pocketbase:pocketbase /home/pocketbase

# Skopiuj pocketbase do /home/pocketbase/

# Uruchom
sudo systemctl enable pocketbase
sudo systemctl start pocketbase
sudo systemctl status pocketbase

# /etc/nginx/sites-available/pocketbase
server {
    listen 80;
    server_name api.example.com;

    # Redirect HTTP to HTTPS
    return 301 https://$server_name$request_uri;
}

server {
    listen 443 ssl http2;
    server_name api.example.com;

    ssl_certificate /etc/letsencrypt/live/api.example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/api.example.com/privkey.pem;

    # Security headers
    add_header X-Frame-Options "SAMEORIGIN" always;
    add_header X-Content-Type-Options "nosniff" always;

    # Max upload size
    client_max_body_size 50M;

    location / {
        proxy_pass http://127.0.0.1:8090;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;

        # WebSocket support
        proxy_read_timeout 86400;
    }
}

// Konfiguracja backupów w Go
package main

import (
    "github.com/pocketbase/pocketbase"
    "github.com/pocketbase/pocketbase/tools/cron"
)

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

    app.OnBeforeServe().Add(func(e *core.ServeEvent) error {
        scheduler := cron.New()

        // Backup codziennie o 3:00
        scheduler.MustAdd("backup", "0 3 * * *", func() {
            name := fmt.Sprintf("backup_%s.zip", time.Now().Format("2006-01-02"))

            if err := app.CreateBackup(name); err != nil {
                log.Printf("Backup failed: %v", err)
                return
            }

            log.Printf("Backup created: %s", name)

            // Opcjonalnie: upload do S3
            // uploadToS3(name)
        })

        scheduler.Start()
        return nil
    })

    app.Start()
}