services

type AfterCreate ¶

type AfterCreate[Entity database.Mutator] func(
	ctx context.Context, tx database.Tx, entity Entity,
) (Entity, error)

AfterCreate is a function that is called after a create operation.

type AfterDelete ¶

type AfterDelete func(
	ctx context.Context, tx database.Tx, count int64,
) (*int64, error)

AfterDelete is a function that is called after a delete operation.

type AfterGet ¶

type AfterGet[Entity database.Getter] func(
	ctx context.Context, tx database.Tx, count int,
) ([]Entity, int, error)

AfterGet is a function that is called after a get operation.

type AfterUpdate ¶

type AfterUpdate[Entity database.Mutator] func(
	ctx context.Context, tx database.Tx, count int64,
) (*int64, error)

AfterUpdate is a function that is called after an update operation.

type BeforeCreateCallback ¶

type BeforeCreateCallback[Entity database.Mutator] func(
	w http.ResponseWriter,
	r *http.Request,
	entity Entity,
	input CreateInputer[Entity],
) (Entity, error)

BeforeCreateCallback is the function that runs before the create operation. It can be used to modify the entity before it is created.

type BeforeDeleteCallback ¶

type BeforeDeleteCallback[Entity database.Mutator] func(
	w http.ResponseWriter,
	r *http.Request,
	parsedInput *ParsedDeleteEndpointInput,
	entity Entity,
	input DeleteInputer,
) (*ParsedDeleteEndpointInput, Entity, error)

BeforeDeleteCallback is the function that runs before the delete operation. It can be used to modify the parsed input and entity before they are used.

type BeforeGetCallback ¶

type BeforeGetCallback func(
	w http.ResponseWriter,
	r *http.Request,
	parsedInput *ParsedGetEndpointInput,
	input *GetInputer,
) (*ParsedGetEndpointInput, error)

BeforeGetCallback is the function that runs before the get operation. It can be used to modify the parsed input before it is used.

type BeforeUpdateCallback ¶

type BeforeUpdateCallback[Entity database.Mutator] func(
	w http.ResponseWriter,
	r *http.Request,
	parsedInput *ParsedUpdateEndpointInput,
	entity Entity,
	input *UpdateInputer,
) (*ParsedUpdateEndpointInput, Entity, error)

BeforeUpdateCallback is the function that runs before the update operation. It can be used to modify the parsed input and entity before they are used.

type CreateEntityFactoryFn ¶

type CreateEntityFactoryFn[Entity database.Mutator] func(
	ctx context.Context, input *CreateInputer[Entity],
) (Entity, error)

CreateEntityFactoryFn is the function that creates a new entity.

type CreateHandler ¶

type CreateHandler[Entity database.Mutator] struct {
	// contains filtered or unexported fields
}

CreateHandler is the handler implementation for the create endpoint.

func NewCreateHandler[Entity database.Mutator](
	entityFactoryFn CreateEntityFactoryFn[Entity],
	createInvokeFn CreateInvokeFn[Entity],
	toOutputFn ToCreateOutputFn[Entity],
	beforeCallback BeforeCreateCallback[Entity],
) *CreateHandler[Entity]

func (h *CreateHandler[Entity]) Handle(
	w http.ResponseWriter, r *http.Request, i *CreateInputer[Entity],
) (any, error)

func (h *CreateHandler[Entity]) WithBeforeCallback(
	beforeCallback BeforeCreateCallback[Entity],
) *CreateHandler[Entity]

func (h *CreateHandler[Entity]) WithCreateInvokeFn(
	createInvokeFn CreateInvokeFn[Entity],
) *CreateHandler[Entity]

func (h *CreateHandler[Entity]) WithEntityFactoryFn(
	entityFactoryFn CreateEntityFactoryFn[Entity],
) *CreateHandler[Entity]

func (h *CreateHandler[Entity]) WithToOutputFn(
	toOutputFn ToCreateOutputFn[Entity],
) *CreateHandler[Entity]

type CreateInputer ¶

type CreateInputer[Entity any] interface {
	GetEntity() Entity
}

CreateInputer is the input interface for the create endpoint.

type CreateInvokeFn ¶

type CreateInvokeFn[Entity database.Mutator] func(
	ctx context.Context, entity Entity,
) (Entity, error)

CreateInvokeFn is the function invokes the create endpoint.

type CreateOutputer ¶

type CreateOutputer[Entity any] interface {
	SetEntities(entities []Entity)
}

CreateOutputer is the output interface for the create endpoint.

type DeleteEntityFactoryFn ¶

type DeleteEntityFactoryFn[Entity database.Mutator] func() Entity

DeleteEntityFactoryFn is the function that creates a new entity.

type DeleteHandler ¶

type DeleteHandler[Entity database.Mutator] struct {
	// contains filtered or unexported fields
}

DeleteHandler is the handler implementation for the delete endpoint.

func NewDeleteHandler[Entity database.Mutator](
	parseInputFn func(
		input DeleteInputer,
	) (*ParsedDeleteEndpointInput, error),
	deleteInvokeFn DeleteInvokeFn[Entity],
	toOutputFn ToDeleteOutputFn,
	entityFactoryFn DeleteEntityFactoryFn[Entity],
	beforeCallback BeforeDeleteCallback[Entity],
) *DeleteHandler[Entity]

func (h *DeleteHandler[Entity]) Handle(
	w http.ResponseWriter, r *http.Request, i *DeleteInputer,
) (any, error)

func (h *DeleteHandler[Entity]) WithBeforeDeleteCallback(
	beforeCallback BeforeDeleteCallback[Entity],
) *DeleteHandler[Entity]

func (h *DeleteHandler[Entity]) WithDeleteInvokeFn(
	deleteInvokeFn DeleteInvokeFn[Entity],
) *DeleteHandler[Entity]

func (h *DeleteHandler[Entity]) WithEntityFactoryFn(
	entityFactoryFn DeleteEntityFactoryFn[Entity],
) *DeleteHandler[Entity]

func (h *DeleteHandler[Entity]) WithParseInputFn(
	parseInputFn func(
		input DeleteInputer,
	) (*ParsedDeleteEndpointInput, error),
) *DeleteHandler[Entity]

func (h *DeleteHandler[Entity]) WithToOutputFn(
	toOutputFn ToDeleteOutputFn,
) *DeleteHandler[Entity]

type DeleteInputer ¶

type DeleteInputer interface {
	GetSelectors() apidb.APISelectors
}

type DeleteInvokeFn ¶

type DeleteInvokeFn[Entity database.Mutator] func(
	ctx context.Context,
	parsedInput *ParsedDeleteEndpointInput,
	entity Entity,
) (int64, error)

DeleteInvokeFn is the function that invokes the delete endpoint.

type DeleteOutputer ¶

type DeleteOutputer interface {
	SetCount(count int64)
}

type GetHandler ¶

type GetHandler[Entity database.Getter] struct {
	// contains filtered or unexported fields
}

GetHandler is the handler for the get endpoint.

func NewGetHandler[Entity database.Getter](
	parseInputFn func(
		input *GetInputer,
	) (*ParsedGetEndpointInput, error),
	getInvokeFn GetInvokeFn[Entity],
	toOutputFn ToGetOutputFn[Entity],
	entityFactoryFn db.GetterFactoryFn[Entity],
	beforeCallback BeforeGetCallback,
) *GetHandler[Entity]

func (h *GetHandler[Entity]) Handle(
	w http.ResponseWriter, r *http.Request, i *GetInputer,
) (any, error)

func (h *GetHandler[Entity]) WithBeforeCallback(
	beforeCallback BeforeGetCallback,
) *GetHandler[Entity]

func (h *GetHandler[Entity]) WithEntityFactoryFn(
	entityFactoryFn db.GetterFactoryFn[Entity],
) *GetHandler[Entity]

func (h *GetHandler[Entity]) WithGetInvokeFn(
	getInvokeFn GetInvokeFn[Entity],
) *GetHandler[Entity]

func (h *GetHandler[Entity]) WithParseInputFn(
	parseInputFn func(input *GetInputer) (*ParsedGetEndpointInput, error),
) *GetHandler[Entity]

func (h *GetHandler[Entity]) WithToOutputFn(
	toOutputFn ToGetOutputFn[Entity],
) *GetHandler[Entity]

type GetInputer ¶

type GetInputer interface {
	GetSelectors() apidb.APISelectors
	GetOrders() apidb.Orders
	GetPage() *apidb.Page
	GetCount() bool
}

type GetInvokeFn ¶

type GetInvokeFn[Entity database.Getter] func(
	ctx context.Context,
	parsedInput *ParsedGetEndpointInput,
	entityFactoryFn db.GetterFactoryFn[Entity],
) ([]Entity, int, error)

GetInvokeFn is the function that invokes the get endpoint.

type GetOutputer ¶

type GetOutputer[Entity any] interface {
	SetEntities(entities []Entity)
	SetCount(count int)
}

type ParsedDeleteEndpointInput ¶

type ParsedDeleteEndpointInput struct {
	Selectors  db.Selectors
	DeleteOpts *db.DeleteOptions
}

ParsedDeleteEndpointInput represents a parsed delete endpoint db.

func ParseDeleteInput(
	apiToDBFields inpututil.APIToDBFields,
	selectors apidb.APISelectors,
	orders apidb.Orders,
	limit int,
) (*ParsedDeleteEndpointInput, error)

type ParsedGetEndpointInput ¶

type ParsedGetEndpointInput struct {
	Selectors db.Selectors
	Orders    []db.Order
	Page      *db.Page
	Count     bool
}

ParsedGetEndpointInput represents a parsed get endpoint db.

func ParseGetInput(
	apiToDBFields inpututil.APIToDBFields,
	selectors apidb.APISelectors,
	orders apidb.Orders,
	inputPage *apidb.Page,
	maxPage int,
	count bool,
) (*ParsedGetEndpointInput, error)

type ParsedUpdateEndpointInput ¶

type ParsedUpdateEndpointInput struct {
	Selectors db.Selectors
	Updates   []db.Update
	Upsert    bool
}

ParsedUpdateEndpointInput represents a parsed update endpoint db.

func ParseUpdateInput(
	apiToDBFields inpututil.APIToDBFields,
	selectors apidb.APISelectors,
	updates apidb.APIUpdates,
	upsert bool,
) (*ParsedUpdateEndpointInput, error)

type ToCreateOutputFn ¶

type ToCreateOutputFn[Entity database.Mutator] func(
	entity Entity,
) (CreateOutputer[Entity], error)

ToCreateOutputFn is the function that converts the entity to the endpoint output.

type ToDeleteOutputFn ¶

type ToDeleteOutputFn func(count int64) (DeleteOutputer, error)

DeleteInvokeFn is the function that invokes the delete endpoint.

type ToGetOutputFn ¶

type ToGetOutputFn[Entity database.Getter] func(
	entities []Entity, count int,
) (GetOutputer[Entity], error)

ToGetOutputFn is the function that converts the entities to the endpoint output.

type ToUpdateOutputFn ¶

type ToUpdateOutputFn func(count int64) (UpdateOutputer, error)

UpdateInvokeFn is the function that invokes the update endpoint.

type UpdateEntityFactoryFn ¶

type UpdateEntityFactoryFn[Entity database.Mutator] func() Entity

UpdateEntityFactoryFn is the function that creates a new entity.

type UpdateHandler ¶

type UpdateHandler[Entity database.Mutator] struct {
	// contains filtered or unexported fields
}

UpdateHandler is the handler implementation for the update endpoint.

func NewUpdateHandler[Entity database.Mutator](
	parseInputFn func(
		input *UpdateInputer,
	) (*ParsedUpdateEndpointInput, error),
	updateInvokeFn UpdateInvokeFn[Entity],
	toOutputFn ToUpdateOutputFn,
	entityFactoryFn UpdateEntityFactoryFn[Entity],
	beforeCallback BeforeUpdateCallback[Entity],
) *UpdateHandler[Entity]

func (h *UpdateHandler[Entity]) Handle(
	w http.ResponseWriter, r *http.Request, i *UpdateInputer,
) (any, error)

func (h *UpdateHandler[Entity]) WithBeforeUpdateCallback(
	beforeCallback BeforeUpdateCallback[Entity],
) *UpdateHandler[Entity]

func (h *UpdateHandler[Entity]) WithEntityFactoryFn(
	entityFactoryFn UpdateEntityFactoryFn[Entity],
) *UpdateHandler[Entity]

func (h *UpdateHandler[Entity]) WithParseInputFn(
	parseInputFn func(input *UpdateInputer,
	) (*ParsedUpdateEndpointInput, error),
) *UpdateHandler[Entity]

func (h *UpdateHandler[Entity]) WithToOutputFn(
	toOutputFn ToUpdateOutputFn,
) *UpdateHandler[Entity]

func (h *UpdateHandler[Entity]) WithUpdateInvokeFn(
	updateInvokeFn UpdateInvokeFn[Entity],
) *UpdateHandler[Entity]

type UpdateInputer ¶

type UpdateInputer interface {
	GetSelectors() apidb.APISelectors
	GetUpdates() apidb.APIUpdates
	GetUpsert() bool
}

type UpdateInvokeFn ¶

type UpdateInvokeFn[Entity database.Mutator] func(
	ctx context.Context,
	parsedInput *ParsedUpdateEndpointInput,
	updater Entity,
) (int64, error)

UpdateInvokeFn is the function that invokes the update endpoint.

type UpdateOutputer ¶

type UpdateOutputer interface {
	SetCount(count int64)
}