[Play 2.6 Scala] action builder based action composition example?

[Chris Nappin]

Hi,

  I must admit I'm a bit confused by "Action" being deprecated and replaced by injected ActionBuilders, as all of the examples in the Play 2.6 documentation on action composition etc still use an Action case class, as does the CSRF implementation.

  Is there an example of the "Play 2.6 idiomatic way" of doing action composition please?

Cheers,

  Chris

[Chris Nappin]

So far I have created the following code - it doesn't use Action and it works when composing with other injected action builders (e.g. MessagesActionBuilder) but not with legacy Actions:

class MyActionBuilder @Inject()(parser: BodyParsers.Default)(implicit ec: ExecutionContext)

      extends ActionBuilderImpl(parser) {

  def apply[A](action: Action[A]) = async(action.parser) { request =>

    action(request)

  }

  override def invokeBlock[A](request: Request[A], block: (Request[A]) => Future[Result]) = {

    // my own logic here, delegating to block(request)

  }

}

[Will Sargent]

Action in a controller is an instance of an ActionBuilder, and if you look into the Controller logic you can see you can actually swap it out.  Custom action builders are covered here:

https://www.playframework.com/documentation/2.6.x/ScalaActionsComposition#Custom-action-builders

and there's an example here:

https://github.com/playframework/play-scala-rest-api-example/blob/2.6.x/app/v1/post/PostActionBuilder.scala

[Chris Nappin]

Thanks Will, in my use case I'm after a custom action builder that others can mix in with their controllers, which could involve other custom actions and any base controller.

Extending ActionBuilderImpl and implementing "invokeBlock" results in an action builder that can be used directly on its own, but not composed with other Actions.

For example:

  def method1 = myAction {
     Ok("hello")
 }

But not:

def method2 = myAction {
  Action {
    Ok("hello")
  }
}

Adding an explicit apply(Action[A]) method to my action builder allows composition like above, but is that correct? Is there a way to use "ActionFunction.compose(..)" that I'm missing perhaps?

The latest docs you linked to still include using a case class to wrap the deprecated Action - I assume this is really a deprecated approach (and of no use when you need dependency injection, which I do in this scenario).

[Jevin G]

A little late, but you can use andThen to compose composite actions.