What's the correct place to query DTO projections?

Question

For different reasons (separation of concerns, performance), I want to stop sending domain entities to my views, and use DTO projections instead.

I want to use ORM queries to create my DTOs, selecting only the fields I need from one or more entities.

What's the correct place to do that?

• Repositories: no, they should not return DTOs
• Controllers: I'd like to keep them as thin as possible, and avoid having them perform queries and/or mapping

I feel like there should be a centralized place (similar to repositories for entities) to query and create DTOs, but I failed to find a pattern or naming for this practice.

I've come across the term DTO assembler, but it looks like this pattern is for mapping one or more domain entities to a DTO, whereas in my case, I want to skip loading full entities and directly translate database queries to DTOs.

Is there a pattern for this?

Answer 1

Your DTOs represent a read model. For this I typically use a query "layer" (although I tend to think more in terms of concerns rather than layers). I typically use I{Aggregate}Query in the same way that I have I{Aggregate}Repository.

The interface would return the data in as simple a format as possible:

namespace Company.Project.DataAccess
{
    public interface ICustomerQuery
    {
        int CountMatching(Query.Customer.Specification specification);
        int Count();
        IEnumerable<DataRow> RowsMatching(Query.Customer.Specification specification); // perhaps OK for simple cases
        IEnumerable<Query.Customer> Matching(Query.Customer.Specification specification); // for something more complex
    }
}   

I also create a Query namespace that contains my DTOs. This means that the domain would, for instance, contain the Customer AR and the Query namespace would also contain a Customer but since it is in the Query namespace there is no ambiguity and I don't have to add a DTO suffix:

namespace Company.Project.DataAccess.Query
{
    public class Customer
    {
        public class Specification
        {
            public string Name { get; private set; }

            public Specification WithName(string name)
            {
                Name = name;

                return this;
            }
        }

        public string Name { get; set; }
        public string Address { get; set; }
    }
}

Answer 2

A dto is an object of the application layer. What you want is to populate it directly from the db. It is the query side of cqrs, where you don't have a rich domain model like the command side, you just have projections (dtos) suitable for the client. They are the query(read) model.

UPDATE:

These are the objects of the pattern I use, similar to command, but a query has a result:

public interface QueryResult {}

Plain DTO (or a list of them), with the output data for the clients.

public interface Query<QR extends QueryResult> {}

Plain DTO with the input data (search criteria) for executing the query.

public interface QueryHandler <QR extends QueryResult, Q extends Query<QR>> {
    public QR handle ( Q query );
}

The object that executes the query.

EXAMPLE:

• App managing data about Employees, Departments, etc. of a Company.
• Use Case: Give me a list of employees (just the name, email, depart, salary) of the employees younger than 30 years with salary greater than 2,000 euros.

Code:

class EmployeeDto {
    private String name;
    private String email;
    private String departmentName;
    private double salary;
    ...
    <<getters and setters>>
    ...
}

class EmployeeDtoList implements QueryResult {
    private List<EmployeeDto> employeeDtos;
    ...
    <<getter and setter>>
    ...
}

class EmployeesByAgeAndSalary implements Query<EmployeeDtoList> {
    private Calendar maxAge;
    private double minSalary;
    ...
    <<getters and setters>>
    ...
}

class EmployeesByAgeAndSalaryHandler implements QueryHandler<EmployeeDtoList,EmployeesByAgeAndSalary> {
    ...
    @Override
    public EmployeeDtoList handle(EmployeesByAgeAndSalary query) {
        ...
        <<retrieve from the database the data we need to return,
        applying the criteria for the age and salary given in the "query" arg>>
        ...
    }
}

-- The facade that the client uses is a mediator (interface with this method):

public <QR extends QueryResult,Q extends Query<QR>> QR executeQuery(Q query);

The mediator would be implemented by a class that manages a query handler registry, so that it redirects the request to the query handler associated to the given query.

It is similar to the command pattern, but with queries.

Answer 3

That's an excellent question,

You put them in the application layer. The pattern you seek is called a Query Service.

Look at how Vaughn Vernon (the author of Implementing Domain Driven Design) did in his github repo:

https://github.com/VaughnVernon/IDDD_Samples/tree/master/iddd_collaboration/src/main/java/com/saasovation/collaboration/application/forum/data

Then he populates them directly from the DB in a query service (CQRS):

public ForumDiscussionsData forumDiscussionsDataOfId(String aTenantId, String aForumId) {
    return this.queryObject(
            ForumDiscussionsData.class,
            "select "
            +  "forum.closed, forum.creator_email_address, forum.creator_identity, "
            +  "forum.creator_name, forum.description, forum.exclusive_owner, forum.forum_id, "
            +  "forum.moderator_email_address, forum.moderator_identity, forum.moderator_name, "
            +  "forum.subject, forum.tenant_id, "
            +  "disc.author_email_address as o_discussions_author_email_address, "
            +  "disc.author_identity as o_discussions_author_identity, "
            +  "disc.author_name as o_discussions_author_name, "
            +  "disc.closed as o_discussions_closed, "
            +  "disc.discussion_id as o_discussions_discussion_id, "
            +  "disc.exclusive_owner as o_discussions_exclusive_owner, "
            +  "disc.forum_id as o_discussions_forum_id, "
            +  "disc.subject as o_discussions_subject, "
            +  "disc.tenant_id as o_discussions_tenant_id "
            + "from tbl_vw_forum as forum left outer join tbl_vw_discussion as disc "
            + " on forum.forum_id = disc.forum_id "
            + "where (forum.tenant_id = ? and forum.forum_id = ?)",
            new JoinOn("forum_id", "o_discussions_forum_id"),
            aTenantId,
            aForumId);
}