Quickstart

package main

import (
    "flag"
    "log"

    app "github.com/magooney-loon/pb-ext/core"
    "github.com/pocketbase/pocketbase/core"
)

func main() {
    devMode := flag.Bool("dev", false, "Run in developer mode")
    flag.Parse()

    initApp(*devMode)
}

func initApp(devMode bool) {
    var opts []app.Option

    if devMode {
        opts = append(opts, app.InDeveloperMode())
    } else {
        opts = append(opts, app.InNormalMode())
    }

    srv := app.New(opts...)

    app.SetupLogging(srv)

    registerCollections(srv.App())
    registerRoutes(srv.App())
    registerJobs(srv.App())

    srv.App().OnServe().BindFunc(func(e *core.ServeEvent) error {
        app.SetupRecovery(srv.App(), e)
        return e.Next()
    })

    if err := srv.Start(); err != nil {
        srv.App().Logger().Error("Fatal application error",
            "error", err,
            "uptime", srv.Stats().StartTime,
            "total_requests", srv.Stats().TotalRequests.Load(),
        )
        log.Fatal(err)
    }
}

func registerCollections(app core.App) {
    // We'll add collections later
}

func registerRoutes(app core.App) {
    // We'll add routes later
}

func registerJobs(app core.App) {
    // We'll add jobs later
}

package main

// API_SOURCE

import (
    "time"
    
    "github.com/magooney-loon/pb-ext/core/server/api"
    "github.com/pocketbase/pocketbase/core"
)

func registerRoutes(app core.App) {
    versionManager := initVersionedSystem()
    
    app.OnServe().BindFunc(func(e *core.ServeEvent) error {
        if err := versionManager.RegisterAllVersionRoutes(e); err != nil {
            return err
        }
        return e.Next()
    })
    
    versionManager.RegisterWithServer(app)
}

func initVersionedSystem() *api.APIVersionManager {
    v1Config := &api.APIDocsConfig{
        Title:       "My API",
        Description: "My first pb-ext API",
        Version:     "1.0.0",
        Status:      "stable",
        BaseURL:     "http://127.0.0.1:8090/",
        Enabled:     true,
        PublicSwagger: true,
    }
    
    return api.InitializeVersionedSystemWithRoutes(map[string]*api.VersionSetup{
        "v1": {
            Config: v1Config,
            Routes: registerV1Routes,
        },
    }, "v1")
}

// API_DESC Returns the current server time
// API_TAGS utilities
func timeHandler(e *core.RequestEvent) error {
    return e.JSON(200, map[string]string{
        "time": time.Now().Format(time.RFC3339),
    })
}

func registerV1Routes(router *api.VersionedAPIRouter) {
    router.GET("/api/v1/time", timeHandler)
}

package main

import (
    "fmt"
    "time"
    
    "github.com/magooney-loon/pb-ext/core/jobs"
    "github.com/pocketbase/pocketbase/core"
)

func registerJobs(app core.App) {
    app.OnServe().BindFunc(func(e *core.ServeEvent) error {
        if err := helloJob(app); err != nil {
            app.Logger().Error("Failed to register hello job", "error", err)
            return err
        }
        
        app.Logger().Info("Cron jobs registered successfully")
        return e.Next()
    })
}

func helloJob(app core.App) error {
    jm := jobs.GetManager()
    if jm == nil {
        return fmt.Errorf("job manager not initialized")
    }
    
    return jm.RegisterJob(
        "helloWorld",
        "Hello World Job",
        "A demonstration job that runs every minute",
        "*/1 * * * *", // Every minute
        func(el *jobs.ExecutionLogger) {
            el.Start("Hello World Job")
            el.Info("Current time: %s", time.Now().Format("2006-01-02 15:04:05"))
            el.Progress("Processing task...")
            
            // Simulate work
            time.Sleep(100 * time.Millisecond)
            
            el.Success("Task completed successfully")
            el.Complete("Job finished")
        },
    )
}

package main

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

func registerCollections(app core.App) {
    app.OnServe().BindFunc(func(e *core.ServeEvent) error {
        if err := todoCollection(e.App); err != nil {
            app.Logger().Error("Failed to create todo collection", "error", err)
        }
        return e.Next()
    })
}

func todoCollection(app core.App) error {
    existingCollection, _ := app.FindCollectionByNameOrId("todos")
    if existingCollection != nil {
        return nil // Already exists
    }
    
    collection := core.NewBaseCollection("todos")
    
    collection.Fields.Add(&core.TextField{
        Name:     "title",
        Required: true,
        Max:      200,
    })
    
    collection.Fields.Add(&core.BoolField{
        Name: "completed",
    })
    
    collection.Fields.Add(&core.AutodateField{
        Name:     "created",
        OnCreate: true,
    })
    
    // Public access for demo
    collection.ViewRule = nil
    collection.CreateRule = nil
    collection.UpdateRule = nil
    collection.DeleteRule = nil
    
    if err := app.Save(collection); err != nil {
        return err
    }
    
    app.Logger().Info("Created todos collection")
    return nil
}