resource

type ClearEventHandler interface {
	OnClear(ctx context.Context, q *query.Query) error
}

type ClearEventHandlerFunc func(ctx context.Context, q *query.Query) error

type ClearedEventHandler interface {
	OnCleared(ctx context.Context, q *query.Query, deleted *int, err *error)
}

type ClearedEventHandlerFunc func(ctx context.Context, q *query.Query, deleted *int, err *error)

type Compiler interface {
	Compile() error
}

type Conf struct {
	// AllowedModes is the list of Mode allowed for the resource.
	AllowedModes []Mode
	// DefaultPageSize defines a default number of items per page. By default,
	// no default page size is set resulting in no pagination if no `limit`
	// parameter is provided.
	PaginationDefaultLimit int
	// ForceTotal controls how total number of items on list request is
	// computed. By default (TotalOptIn), if the total cannot be computed by the
	// storage handler for free, no total metadata is returned until the user
	// explicitly request it using the total=1 query-string parameter. Note that
	// if the storage cannot compute the total and does not implement the
	// resource.Counter interface, a "not implemented" error is returned.
	//
	// The TotalAlways mode always force the computation of the total (make sure
	// the storage either compute the total on Find or implement the
	// resource.Counter interface.
	//
	// TotalDenied prevents the user from requesting the total.
	ForceTotal ForceTotalMode
}

type Counter interface {
	// Count returns the total number of item in the collection given the
	// provided query filter.
	Count(ctx context.Context, q *query.Query) (int, error)
}

type DeleteEventHandler interface {
	OnDelete(ctx context.Context, item *Item) error
}

type DeleteEventHandlerFunc func(ctx context.Context, item *Item) error

type DeletedEventHandler interface {
	OnDeleted(ctx context.Context, item *Item, err *error)
}

type DeletedEventHandlerFunc func(ctx context.Context, item *Item, err *error)

type FindEventHandler interface {
	OnFind(ctx context.Context, q *query.Query) error
}

type FindEventHandlerFunc func(ctx context.Context, q *query.Query) error

type ForceTotalMode int

type FoundEventHandler interface {
	OnFound(ctx context.Context, query *query.Query, list **ItemList, err *error)
}

type FoundEventHandlerFunc func(ctx context.Context, q *query.Query, list **ItemList, err *error)

type GetEventHandler interface {
	OnGet(ctx context.Context, id interface{}) error
}

type GetEventHandlerFunc func(ctx context.Context, id interface{}) error

type GotEventHandler interface {
	OnGot(ctx context.Context, item **Item, err *error)
}

type GotEventHandlerFunc func(ctx context.Context, item **Item, err *error)

type Index interface {
	// Bind a new resource at the "name" endpoint
	Bind(name string, s schema.Schema, h Storer, c Conf) *Resource
	// GetResource retrieves a given resource by it's path. For instance if a
	// resource "user" has a sub-resource "posts", a "users.posts" path can be
	// use to retrieve the posts resource.
	//
	// If a parent is given and the path starts with a dot, the lookup is
	// started at the parent's location instead of root's.
	GetResource(path string, parent *Resource) (*Resource, bool)
	// GetResources returns first level resources.
	GetResources() []*Resource
}

type InsertEventHandler interface {
	OnInsert(ctx context.Context, items []*Item) error
}

type InsertEventHandlerFunc func(ctx context.Context, items []*Item) error

type InsertedEventHandler interface {
	OnInserted(ctx context.Context, items []*Item, err *error)
}

type InsertedEventHandlerFunc func(ctx context.Context, items []*Item, err *error)

type Item struct {
	// ID is used to uniquely identify the item in the resource collection.
	ID interface{}
	// ETag is an opaque identifier assigned by REST Layer to a specific version
	// of the item.
	//
	// This ETag is used perform conditional requests and to ensure storage
	// handler doesn't update an outdated version of the resource.
	ETag string
	// Updated stores the last time the item was updated. This field is used to
	// populate the Last-Modified header and to handle conditional requests.
	Updated time.Time
	// Payload the actual data of the item
	Payload map[string]interface{}
}

type ItemList struct {
	// Total defines the total number of items in the collection matching the
	// current context. If the storage handler cannot compute this value, -1 is
	// set.
	Total int
	// Offset is the index of the first item of the list in the global
	// collection.
	Offset int
	// Limit is the max number of items requested.
	Limit int
	// Items is the list of items contained in the current page given the
	// current context.
	Items []*Item
}

type LogLevel int

type Mode int

type MultiGetter interface {
	// MultiGet retrieves items by their ids and return them an a list. If one or more
	// item(s) cannot be found, the method must not return a resource.ErrNotFound but
	// must just omit the item in the result.
	//
	// The items in the result are expected to match the order of the requested ids.
	MultiGet(ctx context.Context, ids []interface{}) ([]*Item, error)
}

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

type Storer interface {
	// Find searches for items in the backend store matching the q argument. The
	// Window of the query must be respected. If no items are found, an empty
	// list should be returned with no error.
	//
	// If the total number of item can't be computed for free, ItemList.Total
	// must be set to -1. Your Storer may implement the Counter interface to let
	// the user explicitly request the total.
	//
	// The whole query must be treated. If a query predicate operation or sort
	// is not implemented by the storage handler, a resource.ErrNotImplemented
	// must be returned.
	//
	// A storer must ignore the Projection part of the query and always return
	// the document in its entirety. Documents matching a given predicate might
	// be reused (i.e.: cached) with a different projection.
	//
	// If the fetching of the data is not immediate, the method must listen for
	// cancellation on the passed ctx. If the operation is stopped due to
	// context cancellation, the function must return the result of the
	// ctx.Err() method.
	Find(ctx context.Context, q *query.Query) (*ItemList, error)
	// Insert stores new items in the backend store. If any of the items does
	// already exist, no item should be inserted and a resource.ErrConflict must
	// be returned. The insertion of the items must be performed atomically. If
	// more than one item is provided and the backend store doesn't support
	// atomical insertion of several items, a resource.ErrNotImplemented must be
	// returned.
	//
	// If the storage of the data is not immediate, the method must listen for
	// cancellation on the passed ctx. If the operation is stopped due to
	// context cancellation, the function must return the result of the
	// ctx.Err() method.
	Insert(ctx context.Context, items []*Item) error
	// Update replace an item in the backend store by a new version. The
	// ResourceHandler must ensure that the original item exists in the database
	// and has the same Etag field. This check should be performed atomically.
	// If the original item is not found, a resource.ErrNotFound must be
	// returned. If the etags don't match, a resource.ErrConflict must be
	// returned.
	//
	// The item payload must be stored together with the etag and the updated
	// field. The item.ID and the payload["id"] is guarantied to be identical,
	// so there's not need to store both.
	//
	// If the storage of the data is not immediate, the method must listen for
	// cancellation on the passed ctx. If the operation is stopped due to
	// context cancellation, the function must return the result of the
	// ctx.Err() method.
	Update(ctx context.Context, item *Item, original *Item) error
	// Delete deletes the provided item by its ID. The Etag of the item stored
	// in the backend store must match the Etag of the provided item or a
	// resource.ErrConflict must be returned. This check should be performed
	// atomically.
	//
	// If the provided item were not present in the backend store, a
	// resource.ErrNotFound must be returned.
	//
	// If the removal of the data is not immediate, the method must listen for
	// cancellation on the passed ctx. If the operation is stopped due to
	// context cancellation, the function must return the result of the
	// ctx.Err() method.
	Delete(ctx context.Context, item *Item) error
	// Clear removes all items matching the query. When possible, the number of
	// items removed is returned, otherwise -1 is return as the first value.
	//
	// The whole query must be treated. If a query predicate operation or sort
	// is not implemented by the storage handler, a resource.ErrNotImplemented
	// must be returned.
	//
	// If the removal of the data is not immediate, the method must listen for
	// cancellation on the passed ctx. If the operation is stopped due to
	// context cancellation, the function must return the result of the
	// ctx.Err() method.
	Clear(ctx context.Context, q *query.Query) (int, error)
}

type UpdateEventHandler interface {
	OnUpdate(ctx context.Context, item *Item, original *Item) error
}

type UpdateEventHandlerFunc func(ctx context.Context, item *Item, original *Item) error

type UpdatedEventHandler interface {
	OnUpdated(ctx context.Context, item *Item, original *Item, err *error)
}

type UpdatedEventHandlerFunc func(ctx context.Context, item *Item, original *Item, err *error)