How to replace template method pattern with functional style?

Question

You can see the code here

The concrete problem that I'm trying to solve is this. Say that I need to provide REST interface to some entities modeled (sqlalchemy in my case) with some tool stored in database. Say that this collection is called parents.

I would need handlers like this

GET /parents
GET /parents/some_id
POST /parents
DELETE /parents/some_id

Conceptually all this handlers are very similar. They all take ids from url, then create appropriate query. Then they fetching data with that query, then turn this data into dict and then call jsonify to create correct http response.

So with OOP I could design this like that.

class AbstractHandler():
   def __init__(serializer, **specs):
       self.specs = specs

   def handle_request(self, spec_data, *_ids):
       q = self.create_query(_ids)
       d = self.fetch_data(self.specs[spec_data['name']](**(spec_data['args'] + (query, ))
       out = serializer(d)
       return jsonify(out)

The spec is a function that takes some parameters and query and produce more refined query based of this parameters.

So for example GET /parents?spec={'name': 'by_name', 'args': ['adam'} would return parent named Adam from collection.

This code has some flaws but I hope you see the point how template method makes flow of control here and subclasses can change how they would create query, how they would fetch data (item handler would need to call query.one() and collection handler would need to call query.all() for example)

So I can replace create_query, fetch_data with dependency injection instead. But that would create a problem that someone could create wrong configuration by giving the wrong dependency. That's basically what I've done, but with using partial functions instead.

So what I'm thinking right now is that I can solve this problem by creating factory functions for every type of handler that I need, that would give appropriate dependency to handler.

That's very much alike with template method solution I think. The difference basically is that in template method correctness dependencies is guarantied by object type and in my solution it's guarantied by type of factory function.

So enough with what I think, I'd like to know what you think about that? How people in functional world solve this kinds of problem?