effe

func Before ¶

func Before(fn interface{}) StepFunc

This directive helps to declare a function which executes before other steps in a directive Wrap. This directive can be used only in Wrap.

func Case ¶

func Case(key CaseKey, funcs ...StepFunc) StepFunc

This directive can be used only in Decision. Case declares the steps which will execute.

func Decision ¶

func Decision(tag interface{}, cases ...StepFunc) StepFunc

Decision directive helps to organize branching of our business logic. First argument can be a type or a field from the type. Golang doesn't provide an opportunity to pass types to function argument. For that you need to create an empty object with your type. If you want branching your logic by field from type you can declare it. For that you need to create an empty object with your type and get field from it. Other arguments declare handlers for every case. Every case can be declared with Case directive. Failure directive works here too. With Failure you can declare an error handler for case.

Examples:

func BuildMyBusinessFlow(){
    effe.BuildFlow(
        effe.Step(tryLock),
        effe.Decision(new(Lock),
            effe.Case(true, effe.Step(step1)),
            effe.Case(false, effe.Step(step2)),
        ),
    )
}

func BuildMyBusinessFlow2(){
    effe.BuildFlow(
        effe.Step(tryLock),
            effe.Decision(Locker{}.Lock,
            effe.Case(true, effe.Step(step1)),
            effe.Case(false, effe.Step(step2)),
        ),
    )
}

func Failure ¶

func Failure(fn interface{}) StepFunc

A Failure works the same way as Step, but with one exception: a function executes only if one of steps returns an error.

func Step ¶

func Step(fn interface{}) StepFunc

A Step declares a function which will be executed in this place. The function should have the following format:

Format:

func step1(dep1 FirstDependency, dep2 SecondDependency) func(req *httpRequest) error {
    return func(req *httpRequest) error {
        return dep1.Send(dep2, req)
    }
}

Function arguments should be dependencies for your step. It is necessary to separate dependencies between steps. You don't need to create big service objects. Effe code generation tool calculates all dependencies for your flow and Effe generates a service object with dependecies automatically. Function return value should be the function which executes here. Also, you can call another business flow here. It helps to split and reuse existing business logic.

Examples:

func BuildMyFirstBusinessFlow(){
    effe.BuldFlow(
        effe.Step(step1),
    )
}

func BuildMySecondBusinessFlow(){
    effe.BuildFlow(
        effe.Step(BuildMyFirstBusinessFlow),
    )
}

func Success ¶

func Success(fn interface{}) StepFunc

This directive helps to declare a function which executes after other steps in a directive Wrap and if not one step returned an error. This directive can be used only in Wrap.

func Wrap ¶

func Wrap(beforeFunc StepFunc, afterFunc StepFunc, steps ...StepFunc) StepFunc

Wrap helps to declare a block of steps which is executed in the following sequence. If we declare a function with Before directive, then it will be executed first. After that, all functions declared with Step directive will be executed. Lastly a function declared with Success directive will be executed. Also, we can declare an error handler here with Failure directive.

Examples:

func BuildMyBusinessFlow() {
    effe.BuildFlow(
        effe.Step(step1),
        effe.Step(step2),
        effe.Wrap(effe.Before(lock), effe.Success(unlock), effe.Failure(catchErrAndUnlock),
            effe.Step(step3),
            effe.Step(step4),
        ),
    )
}