Live Queries

This package attempts to add a basic version of live queries to Ponzu. By interacting with the database hooks provided with the item.Hookable interface, the live package (import "github.com/ponzu-cms/live") enables users to publish and subscribe to the hookable events throughout the content package.

Usage:

package content

import (
	"fmt"
	"log"
	"net/http"

	"github.com/ponzu-cms/live"
	"github.com/ponzu-cms/ponzu/management/editor"
	"github.com/ponzu-cms/ponzu/system/item"
)

// typical generated ponzu content type
type Customer struct {
	item.Item

	Name  string `json:"name"`
	Email string `json:"email"`
}

// declare a package-level subscriptions container (could be in it's own file 
// within the content package)
var subs live.Subscriptions

func init() {
    item.Types["Customer"] = func() interface{} { return new(Customer) }

    // create the new subscriptions container to Subscribe / Emit
    subs = live.New()

    // create a subscriber to handle AdminUpdate events on a Customer
    go func() {
        adminUpdates := subs.Subscribe("Customer", live.AdminUpdate)
        for event := range adminUpdates {
            log.Println("<g1> UPDATE:", event.Content().(*Customer))
        }
    }()

    // NOTE: any number of subscriptions can be made to the same content type for
    // any event type.

    // create another subscriber for AdminDelete events on a Customer
    go func() {
        adminDeletes := subs.Subscribe("Customer", live.AdminDelete)
        for event := range adminDeletes {
            log.Println("<g2> DELETE:", event.Content().(*Customer))
        }
    }()
}

// emit content events from within the item.Hookable methods provided by Ponzu 
// to broadcast a change (hookable constants are defined in `live` for event types)
func (c *Customer) AfterAdminUpdate(res http.ResponseWriter, req *http.Request) error {
	err := subs.Emit(req.Context(), "Customer", c, live.AdminUpdate)
	if err != nil {
		if liveErr, ok := err.(live.QueryError); ok {
			// handle live error in specific manner
			fmt.Println(liveErr)
			return nil
		}

		return err
	}

	return nil
}

func (c *Customer) BeforeAdminDelete(res http.ResponseWriter, req *http.Request) error {
	err := subs.Emit(req.Context(), "Customer", c, live.AdminDelete)
	if err != nil {
		return err
	}

	return nil
}

// MarshalEditor writes a buffer of html to edit a Customer within the CMS
// and implements editor.Editable
func (c *Customer) MarshalEditor() ([]byte, error) {
	view, err := editor.Form(c,
		// Take note that the first argument to these Input-like functions
		// is the string version of each Customer field, and must follow
		// this pattern for auto-decoding and auto-encoding reasons:
		editor.Field{
			View: editor.Input("Name", c, map[string]string{
				"label":       "Name",
				"type":        "text",
				"placeholder": "Enter the Name here",
			}),
		},
		editor.Field{
			View: editor.Input("Email", c, map[string]string{
				"label":       "Email",
				"type":        "text",
				"placeholder": "Enter the Email here",
			}),
		},
	)

	if err != nil {
		return nil, fmt.Errorf("Failed to render Customer editor view: %s", err.Error())
	}

	return view, nil
}

// String defines how a Customer is printed. Update it using more descriptive
// fields from the Customer struct type
func (c *Customer) String() string {
	return fmt.Sprintf("Customer: %s", c.UUID)
}