mongo

README

REST Layer MongoDB Backend

This REST Layer resource storage backend stores data in a MongoDB cluster using mgo.

Usage

import "github.com/cool-rest/rest-layer-mongo"

Create a mgo master session:

session, err := mgo.Dial(url)

Create a resource storage handler with a given DB/collection:

s := mongo.NewHandler(session, "the_db", "the_collection")

Use this handler with a resource:

index.Bind("foo", foo, s, resource.DefaultConf)

You may want to create a many mongo handlers as you have resources as long as you want each resources in a different collection. You can share the same mgo session across all you handlers.

Object ID

This package also provides a REST Layer schema.Validator for MongoDB ObjectIDs. This validator ensures proper binary serialization of the Object ID in the database for space efficiency.

You may reference this validator using mongo.ObjectID as schema.Field.

A mongo.NewObjectID field hook and mongo.ObjectIDField helper are also provided.

Documentation

Overview

Package mongo is a REST Layer resource storage handler for MongoDB using mgo

Example

package main

import (
	"log"
	"net/http"

	"github.com/cool-rest/cors"
	"github.com/cool-rest/rest-layer-mongo"
	"github.com/cool-rest/rest-layer/resource"
	"github.com/cool-rest/rest-layer/rest"
	"github.com/cool-rest/rest-layer/schema"
	"gopkg.in/mgo.v2"
)

var (
	user = schema.Schema{
		Fields: schema.Fields{
			"id":      schema.IDField,
			"created": schema.CreatedField,
			"updated": schema.UpdatedField,
			"name": {
				Required:   true,
				Filterable: true,
				Sortable:   true,
				Validator: &schema.String{
					MaxLen: 150,
				},
			},
		},
	}

	// Define a post resource schema
	post = schema.Schema{
		Fields: schema.Fields{
			"id":      schema.IDField,
			"created": schema.CreatedField,
			"updated": schema.UpdatedField,
			"user": {
				Required:   true,
				Filterable: true,
				Validator: &schema.Reference{
					Path: "users",
				},
			},
			"public": {
				Filterable: true,
				Validator:  &schema.Bool{},
			},
			"meta": {
				Schema: &schema.Schema{
					Fields: schema.Fields{
						"title": {
							Required: true,
							Validator: &schema.String{
								MaxLen: 150,
							},
						},
						"body": {
							Validator: &schema.String{
								MaxLen: 100000,
							},
						},
					},
				},
			},
		},
	}
)

func main() {
	session, err := mgo.Dial("")
	if err != nil {
		log.Fatalf("Can't connect to MongoDB: %s", err)
	}
	db := "test_rest_layer"

	index := resource.NewIndex()

	users := index.Bind("users", user, mongo.NewHandler(session, db, "users"), resource.Conf{
		AllowedModes: resource.ReadWrite,
	})

	users.Bind("posts", "user", post, mongo.NewHandler(session, db, "posts"), resource.Conf{
		AllowedModes: resource.ReadWrite,
	})

	api, err := rest.NewHandler(index)
	if err != nil {
		log.Fatalf("Invalid API configuration: %s", err)
	}

	http.Handle("/", cors.New(cors.Options{OptionsPassthrough: true}).Handler(api))

	log.Print("Serving API on http://localhost:8080")
	if err := http.ListenAndServe(":8080", nil); err != nil {
		log.Fatal(err)
	}
}

Index

• Variables
• type Handler
  • func NewHandler(s *mgo.Session, db, collection string) *Handler
  • func (m *Handler) Clear(ctx context.Context, lookup *resource.Lookup) (int, error)
  • func (m *Handler) Delete(ctx context.Context, item *resource.Item) error
  • func (m *Handler) Find(ctx context.Context, lookup *resource.Lookup, page, perPage int) (*resource.ItemList, error)
  • func (m *Handler) Insert(ctx context.Context, items []*resource.Item) error
  • func (m *Handler) Update(ctx context.Context, item *resource.Item, original *resource.Item) error
• type ObjectID
  • func (v ObjectID) Validate(value interface{}) (interface{}, error)

Examples

• Package

Variables

var (
	// NewObjectID is a field hook handler that generates a new Mongo ObjectID hex if
	// value is nil to be used in schema with OnInit.
	NewObjectID = func(ctx context.Context, value interface{}) interface{} {
		if value == nil {
			value = bson.NewObjectId().Hex()
		}
		return value
	}

	// ObjectIDField is a common schema field configuration that generate an Object ID
	// for new item id.
	ObjectIDField = schema.Field{
		Required:   true,
		ReadOnly:   true,
		OnInit:     NewObjectID,
		Filterable: true,
		Sortable:   true,
		Validator:  &ObjectID{},
	}
)

Types

type Handler

type Handler struct {
	// contains filtered or unexported fields
}

Handler handles resource storage in a MongoDB collection.

func NewHandler

func NewHandler(s *mgo.Session, db, collection string) *Handler

NewHandler creates an new mongo handler

func (*Handler) Clear

func (m *Handler) Clear(ctx context.Context, lookup *resource.Lookup) (int, error)

Clear clears all items from the mongo collection matching the lookup

func (*Handler) Delete

func (m *Handler) Delete(ctx context.Context, item *resource.Item) error

Delete deletes an item from the mongo collection

func (*Handler) Find

func (m *Handler) Find(ctx context.Context, lookup *resource.Lookup, page, perPage int) (*resource.ItemList, error)

Find items from the mongo collection matching the provided lookup

func (*Handler) Insert

func (m *Handler) Insert(ctx context.Context, items []*resource.Item) error

Insert inserts new items in the mongo collection

func (*Handler) Update

func (m *Handler) Update(ctx context.Context, item *resource.Item, original *resource.Item) error

Update replace an item by a new one in the mongo collection

type ObjectID

type ObjectID struct{}

ObjectID validates and serialize unique id

func (ObjectID) Validate

func (v ObjectID) Validate(value interface{}) (interface{}, error)

Validate implements FieldValidator interface