func (tr *taskRepository)FetchTaskById(userRepository *userRepository, id int) (map[string]interface{}, error) {
	// タスクを取得
	t, _ := tr.FindById(id)
	// ユーザーを取得
	u, _ := userRepository.FindById(t.UserID)

    // オブジェクトに詰め替えて返す
}

func (tqs *taskQueryService) FetchTaskById(ctx context.Context, id string) (*taskUsecase.FetchTaskDTO, error) {
    // JOIN句を使ってクエリを実行
	r, _ := tqs.querier.FetchTaskById(ctx, id)

	// Stateをint→strにする必要があり、
	// State型のメソッドを使用するために再構成する
	t := taskDomain.ReconstructTask(
		r.ID,
		r.UserID,
		r.Content,
		int(r.State),
	)
	return &taskUsecase.FetchTaskDTO{
		ID:       t.GetID(),
		UserName: r.Name,
		UserId:   t.GetUserId(),
		Content:  t.GetContent().Value(),
		State:    t.GetState().StrValue(),
	}, nil
}

sqlcが生成した querier.FetchTaskById(ctx, id) の元になったSQLクエリは以下の通り。

-- name: FetchTaskById :one
select t.id,u.name,t.user_id,t.content,t.state
from tasks as t inner join users as u
on t.user_id = u.id
where t.id = sqlc.arg(id);

// app/adapter/queryservice/interface_querier.go
package queryservice

import "context"

// ORMはこのインターフェースを満たすように設計する
type Querier interface {
	FetchTaskById(ctx context.Context, id string) (FetchTaskByIdRow, error)
	FetchAllTasks(ctx context.Context) ([]FetchAllTasksRow, error)
	FetchUserTasks(ctx context.Context, userID string) ([]FetchUserTasksRow, error)
}

type FetchTaskByIdRow struct {
	ID      string
	Name    string
	UserID  string
	Content string
	State   int32
}

type FetchAllTasksRow struct {
	ID      string
	Name    string
	UserID  string
	Content string
	State   int32
}

type FetchUserTasksRow struct {
	ID      string
	Name    string
	UserID  string
	Content string
	State   int32
}

// app/adapter/queryservice/task_queryservice.go
package queryservice

import (
	"context"
	"database/sql"

	taskUsecase "github.com/kakkky/app/application/usecase/task"
	"github.com/kakkky/app/domain/errors"
	taskDomain "github.com/kakkky/app/domain/task"
)

type taskQueryService struct {
	querier Querier
}

func NewTaskQueryService(querier Querier) taskUsecase.TaskQueryService {
	return &taskQueryService{
		querier: querier,
	}
}

func (tqs *taskQueryService) FetchTaskById(ctx context.Context, id string) (*taskUsecase.FetchTaskDTO, error) {
	r, err := tqs.querier.FetchTaskById(ctx, id)
	if err != nil && errors.Is(err, sql.ErrNoRows) {
		return nil, errors.ErrNotFoundTask
	}
	if err != nil {
		return nil, err
	}
	// Stateをint→strにする必要があり、
	// State型のメソッドを使用するために再構成する
	t := taskDomain.ReconstructTask(
		r.ID,
		r.UserID,
		r.Content,
		int(r.State),
	)
	return &taskUsecase.FetchTaskDTO{
		ID:       t.GetID(),
		UserName: r.Name,
		UserId:   t.GetUserId(),
		Content:  t.GetContent().Value(),
		State:    t.GetState().StrValue(),
	}, nil

}

func (tqs *taskQueryService) FetchUserTasks(ctx context.Context, userId string) ([]*taskUsecase.FetchTaskDTO, error) {

	rs, err := tqs.querier.FetchUserTasks(ctx, userId)
	if err != nil {
		return nil, err
	}
	dtos := make([]*taskUsecase.FetchTaskDTO, 0, len(rs))
	for _, r := range rs {
		t := taskDomain.ReconstructTask(
			r.ID,
			r.UserID,
			r.Content,
			int(r.State),
		)
		dtos = append(dtos, &taskUsecase.FetchTaskDTO{
			ID:       t.GetID(),
			UserName: r.Name,
			UserId:   t.GetUserId(),
			Content:  t.GetContent().Value(),
			State:    t.GetState().StrValue(),
		})
	}
	return dtos, nil
}

func (tqs *taskQueryService) FetchAllTasks(ctx context.Context) ([]*taskUsecase.FetchTaskDTO, error) {
	rs, err := tqs.querier.FetchAllTasks(ctx)
	if err != nil {
		return nil, err
	}
	dtos := make([]*taskUsecase.FetchTaskDTO, 0, len(rs))
	for _, r := range rs {
		t := taskDomain.ReconstructTask(
			r.ID,
			r.UserID,
			r.Content,
			int(r.State),
		)
		dtos = append(dtos, &taskUsecase.FetchTaskDTO{
			ID:       t.GetID(),
			UserName: r.Name,
			UserId:   t.GetUserId(),
			Content:  t.GetContent().Value(),
			State:    t.GetState().StrValue(),
		})
	}
	return dtos, nil
}

// app/infrastructure/db/sqlc/sqlc_querier.go

// 追加

func (sq *SqlcQuerier) FetchTaskById(ctx context.Context, id string) (queryservice.FetchTaskByIdRow, error) {
	row, err := sq.queries.FetchTaskById(ctx, id)
	return queryservice.FetchTaskByIdRow(row), err
}

func (sq *SqlcQuerier) FetchAllTasks(ctx context.Context) ([]queryservice.FetchAllTasksRow, error) {
	rows, err := sq.queries.FetchAllTasks(ctx)
	var r []queryservice.FetchAllTasksRow
	for _, row := range rows {
		r = append(r, queryservice.FetchAllTasksRow(row))
	}
	return r, err
}

func (sq *SqlcQuerier) FetchUserTasks(ctx context.Context, userID string) ([]queryservice.FetchUserTasksRow, error) {
	rows, err := sq.queries.FetchUserTasks(ctx, userID)
	var r []queryservice.FetchUserTasksRow
	for _, row := range rows {
		r = append(r, queryservice.FetchUserTasksRow(row))
	}
	return r, err
}

// app/infrastructure/queryservice_test/queryservice_test.go
package queryservice

import (
	"log"
	"testing"

	"github.com/kakkky/app/infrastructure/db"
	"github.com/kakkky/app/infrastructure/db/container"
)

func TestMain(m *testing.M) {
	//dockertestコンテナを起動
	pool, resource := container.NewDockertestContainer()
	log.Println("success to start dockertest container")
	defer func() {
		container.RemoveDockertestContainer(pool, resource)
		log.Println("success to remove dockertest container")
	}()
	// DBに接続
	testDB := container.NewDB(pool, resource)
	log.Println("success to connect test-db")
	defer testDB.Close()
	// マイグレーションを適用させる
	container.SetupDB()
	log.Println("success to apply migrations")
	// dbパッケージ変数にテスト用DBをセット
	db.SetDB(testDB)
	log.Println("dockertest & test-db settings complete")

	m.Run()
}

// app/infrastructure/queryservice_test/task_queryservice_test.go
package queryservice

import (
	"context"
	"testing"

	"github.com/google/go-cmp/cmp"
	"github.com/kakkky/app/adapter/queryservice"
	"github.com/kakkky/app/application/usecase/task"
	"github.com/kakkky/app/domain/errors"
	"github.com/kakkky/app/infrastructure/db/sqlc"
	"github.com/kakkky/app/infrastructure/db/testhelper"
)

func TestTaskQueryService_FetchTaskById(t *testing.T) {
	taskQueryService := queryservice.NewTaskQueryService(sqlc.NewSqlcQuerier())
	type args struct {
		id string
	}
	tests := []struct {
		name    string
		args    args
		want    *task.FetchTaskDTO
		errType error
		wantErr bool
	}{
		{
			name: "正常系",
			args: args{
				id: "1",
			},
			want: &task.FetchTaskDTO{
				ID:       "1",
				UserName: "user1",
				UserId:   "1",
				Content:  "content",
				State:    "todo",
			},
			wantErr: false,
		},
		{
			name: "準正常系：指定idのタスクが見つからない",
			args: args{
				id: "invalid",
			},
			errType: errors.ErrNotFoundTask,
			wantErr: true,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			testhelper.SetupFixtures(t,"testdata/fixtures/users.yml", "testdata/fixtures/tasks.yml")
			ctx := context.Background()
			got, err := taskQueryService.FetchTaskById(ctx, tt.args.id)
			if (err != nil) != tt.wantErr && tt.errType != nil && errors.Is(err, tt.errType) {
				t.Errorf("taskQueryService.FetchTaskById = error %v, want errType %v", err, tt.errType)
				return
			}
			if (err != nil) != tt.wantErr {
				t.Errorf("taskQueryService.FetchTaskById = error %v, wantErr %v", err, tt.wantErr)
				return
			}
			if diff := cmp.Diff(got, tt.want); diff != "" {
				t.Errorf("taskQueryService.FetchTaskById() -got,+want : %v", diff)
			}
		})
	}
}

func TestTaskQueryService_FetchUserTasks(t *testing.T) {
	taskQueryService := queryservice.NewTaskQueryService(sqlc.NewSqlcQuerier())
	type args struct {
		user_id string
	}
	tests := []struct {
		name    string
		args    args
		want    []*task.FetchTaskDTO
		wantErr bool
	}{
		{
			name: "正常系",
			args: args{
				user_id: "1",
			},
			want: []*task.FetchTaskDTO{
				{
					ID:       "1",
					UserName: "user1",
					UserId:   "1",
					Content:  "content",
					State:    "todo",
				},
				{
					ID:       "2",
					UserName: "user1",
					UserId:   "1",
					Content:  "content",
					State:    "todo",
				},
				{
					ID:       "3",
					UserName: "user1",
					UserId:   "1",
					Content:  "content",
					State:    "doing",
				},
			},
			wantErr: false,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			testhelper.SetupFixtures(t,"testdata/fixtures/users.yml", "testdata/fixtures/tasks.yml")
			ctx := context.Background()
			got, err := taskQueryService.FetchUserTasks(ctx, tt.args.user_id)
			if (err != nil) != tt.wantErr {
				t.Errorf("taskQueryService.FetchUserTasks = error %v, wantErr %v", err, tt.wantErr)
				return
			}
			if diff := cmp.Diff(got, tt.want); diff != "" {
				t.Errorf("taskQueryService.FetchUserTasks) -got,+want : %v", diff)
			}
		})
	}
}

func TestTaskQueryService_FetchTasks(t *testing.T) {
	taskQueryService := queryservice.NewTaskQueryService(sqlc.NewSqlcQuerier())
	tests := []struct {
		name    string
		want    []*task.FetchTaskDTO
		wantErr bool
	}{
		{
			name: "正常系",
			want: []*task.FetchTaskDTO{
				{
					ID:       "1",
					UserName: "user1",
					UserId:   "1",
					Content:  "content",
					State:    "todo",
				},
				{
					ID:       "2",
					UserName: "user1",
					UserId:   "1",
					Content:  "content",
					State:    "todo",
				},
				{
					ID:       "3",
					UserName: "user1",
					UserId:   "1",
					Content:  "content",
					State:    "doing",
				},
				{
					ID:       "4",
					UserName: "user2",
					UserId:   "2",
					Content:  "content",
					State:    "doing",
				},
				{
					ID:       "5",
					UserName: "user2",
					UserId:   "2",
					Content:  "content",
					State:    "done",
				},
			},
			wantErr: false,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			testhelper.SetupFixtures(t,"testdata/fixtures/users.yml", "testdata/fixtures/tasks.yml")
			ctx := context.Background()
			got, err := taskQueryService.FetchAllTasks(ctx)
			if (err != nil) != tt.wantErr {
				t.Errorf("taskQueryService.FetchUserTasks = error %v, wantErr %v", err, tt.wantErr)
				return
			}
			if diff := cmp.Diff(got, tt.want); diff != "" {
				t.Errorf("taskQueryService.FetchUserTasks) -got,+want : %v", diff)
			}
		})
	}
}

# app/infrastructure/queryservice_test/testdata/fixtures/tasks.yml
- id: 1
  user_id: 1
  content: content
  state: 0

- id: 2
  user_id: 1
  content: content
  state: 0

- id: 3
  user_id: 1
  content: content
  state: 1

- id: 4
  user_id: 2
  content: content
  state: 1

- id: 5
  user_id: 2
  content: content
  state: 2

# app/infrastructure/queryservice_test/testdata/fixtures/users.yml
- id: 1
  name: user1
  email: [email protected]
  hashed_password: password

- id: 2
  name: user2
  email: [email protected]
  hashed_password: password

- id: 3
  name: user3
  email: [email protected]
  hashed_password: password