feat: improvements in structures

domain/repository/book/interface.go

@@ -1,25 +0,0 @@
-package book
-
-import (
-	"github.com/eminetto/clean-architecture-go-v2/domain/entity"
-)
-
-//Reader interface
-type Reader interface {
-	Get(id entity.ID) (*entity.Book, error)
-	Search(query string) ([]*entity.Book, error)
-	List() ([]*entity.Book, error)
-}
-
-//Writer book writer
-type Writer interface {
-	Create(e *entity.Book) (entity.ID, error)
-	Update(e *entity.Book) error
-	Delete(id entity.ID) error
-}
-
-//repository interface
-type Repository interface {
-	Reader
-	Writer
-}

domain/repository/book/repository_inmem.go

@@ -1,76 +0,0 @@
-package book
-
-import (
-	"strings"
-
-	"github.com/eminetto/clean-architecture-go-v2/domain"
-	"github.com/eminetto/clean-architecture-go-v2/domain/entity"
-)
-
-//InmemRepo in memory repo
-type InmemRepo struct {
-	m map[entity.ID]*entity.Book
-}
-
-//NewInmemRepository create new repository
-func NewInmemRepository() *InmemRepo {
-	var m = map[entity.ID]*entity.Book{}
-	return &InmemRepo{
-		m: m,
-	}
-}
-
-//Create a book
-func (r *InmemRepo) Create(e *entity.Book) (entity.ID, error) {
-	r.m[e.ID] = e
-	return e.ID, nil
-}
-
-//Get a book
-func (r *InmemRepo) Get(id entity.ID) (*entity.Book, error) {
-	if r.m[id] == nil {
-		// return nil, fmt.Errorf("not found")
-		return nil, domain.ErrNotFound
-	}
-	return r.m[id], nil
-}
-
-//Update a book
-func (r *InmemRepo) Update(e *entity.Book) error {
-	_, err := r.Get(e.ID)
-	if err != nil {
-		return err
-	}
-	r.m[e.ID] = e
-	return nil
-}
-
-//Search books
-func (r *InmemRepo) Search(query string) ([]*entity.Book, error) {
-	var d []*entity.Book
-	for _, j := range r.m {
-		if strings.Contains(strings.ToLower(j.Title), query) {
-			d = append(d, j)
-		}
-	}
-	return d, nil
-}
-
-//List books
-func (r *InmemRepo) List() ([]*entity.Book, error) {
-	var d []*entity.Book
-	for _, j := range r.m {
-		d = append(d, j)
-	}
-	return d, nil
-}
-
-//Delete a book
-func (r *InmemRepo) Delete(id entity.ID) error {
-	if r.m[id] == nil {
-		// return fmt.Errorf("not found")
-		return domain.ErrNotFound
-	}
-	r.m[id] = nil
-	return nil
-}

domain/repository/book/repository_mysql.go

@@ -1,127 +0,0 @@
-package book
-
-import (
-	"database/sql"
-	"time"
-
-	"github.com/eminetto/clean-architecture-go-v2/domain/entity"
-)
-
-//MySQLRepo mysql repo
-type MySQLRepo struct {
-	db *sql.DB
-}
-
-//NewMySQLRepository create new repository
-func NewMySQLRepository(db *sql.DB) *MySQLRepo {
-	return &MySQLRepo{
-		db: db,
-	}
-}
-
-//Create a book
-func (r *MySQLRepo) Create(e *entity.Book) (entity.ID, error) {
-	stmt, err := r.db.Prepare(`
-		insert into book (id, title, author, pages, quantity, created_at) 
-		values(?,?,?,?,?,?)`)
-	if err != nil {
-		return e.ID, err
-	}
-	_, err = stmt.Exec(
-		e.ID,
-		e.Title,
-		e.Author,
-		e.Pages,
-		e.Quantity,
-		time.Now().Format("2006-01-02"),
-	)
-	if err != nil {
-		return e.ID, err
-	}
-	err = stmt.Close()
-	if err != nil {
-		return e.ID, err
-	}
-	return e.ID, nil
-}
-
-//Get a book
-func (r *MySQLRepo) Get(id entity.ID) (*entity.Book, error) {
-	stmt, err := r.db.Prepare(`select id, title, author, pages, quantity, created_at from book where id = ?`)
-	if err != nil {
-		return nil, err
-	}
-	var b entity.Book
-	rows, err := stmt.Query(id)
-	if err != nil {
-		return nil, err
-	}
-	for rows.Next() {
-		err = rows.Scan(&b.ID, &b.Title, &b.Author, &b.Pages, &b.Quantity, &b.CreatedAt)
-	}
-	return &b, nil
-}
-
-//Update a book
-func (r *MySQLRepo) Update(e *entity.Book) error {
-	e.UpdatedAt = time.Now()
-	_, err := r.db.Exec("update book set title = ?, author = ?, pages = ?, quantity = ?, updated_at = ? where id = ?", e.Title, e.Author, e.Pages, e.Quantity, e.UpdatedAt.Format("2006-01-02"), e.ID)
-	if err != nil {
-		return err
-	}
-	return nil
-}
-
-//Search books
-func (r *MySQLRepo) Search(query string) ([]*entity.Book, error) {
-	stmt, err := r.db.Prepare(`select id, title, author, pages, quantity, created_at from book where title like ?`)
-	if err != nil {
-		return nil, err
-	}
-	var books []*entity.Book
-	rows, err := stmt.Query("%" + query + "%")
-	if err != nil {
-		return nil, err
-	}
-	for rows.Next() {
-		var b entity.Book
-		err = rows.Scan(&b.ID, &b.Title, &b.Author, &b.Pages, &b.Quantity, &b.CreatedAt)
-		if err != nil {
-			return nil, err
-		}
-		books = append(books, &b)
-	}
-
-	return books, nil
-}
-
-//List books
-func (r *MySQLRepo) List() ([]*entity.Book, error) {
-	stmt, err := r.db.Prepare(`select id, title, author, pages, quantity, created_at from book`)
-	if err != nil {
-		return nil, err
-	}
-	var books []*entity.Book
-	rows, err := stmt.Query()
-	if err != nil {
-		return nil, err
-	}
-	for rows.Next() {
-		var b entity.Book
-		err = rows.Scan(&b.ID, &b.Title, &b.Author, &b.Pages, &b.Quantity, &b.CreatedAt)
-		if err != nil {
-			return nil, err
-		}
-		books = append(books, &b)
-	}
-	return books, nil
-}
-
-//Delete a book
-func (r *MySQLRepo) Delete(id entity.ID) error {
-	_, err := r.db.Exec("delete from book where id = ?", id)
-	if err != nil {
-		return err
-	}
-	return nil
-}

domain/repository/user/interface.go

@@ -1,25 +0,0 @@
-package user
-
-import (
-	"github.com/eminetto/clean-architecture-go-v2/domain/entity"
-)
-
-//Reader interface
-type Reader interface {
-	Get(id entity.ID) (*entity.User, error)
-	Search(query string) ([]*entity.User, error)
-	List() ([]*entity.User, error)
-}
-
-//Writer user writer
-type Writer interface {
-	Create(e *entity.User) (entity.ID, error)
-	Update(e *entity.User) error
-	Delete(id entity.ID) error
-}
-
-//Repository interface
-type Repository interface {
-	Reader
-	Writer
-}

domain/repository/user/repository_inmem.go

@@ -1,81 +0,0 @@
-package user
-
-import (
-	"fmt"
-	"strings"
-
-	"github.com/eminetto/clean-architecture-go-v2/domain"
-	"github.com/eminetto/clean-architecture-go-v2/domain/entity"
-)
-
-//IRepo in memory repo
-type IRepo struct {
-	m map[entity.ID]*entity.User
-}
-
-//NewInmemRepository create new repository
-func NewInmemRepository() *IRepo {
-	var m = map[entity.ID]*entity.User{}
-	return &IRepo{
-		m: m,
-	}
-}
-
-//Create an user
-func (r *IRepo) Create(e *entity.User) (entity.ID, error) {
-	r.m[e.ID] = e
-	return e.ID, nil
-}
-
-//Get an user
-func (r *IRepo) Get(id entity.ID) (*entity.User, error) {
-	if r.m[id] == nil {
-		// return nil, fmt.Errorf("not found")
-		return nil, domain.ErrNotFound
-	}
-	return r.m[id], nil
-}
-
-//Update an user
-func (r *IRepo) Update(e *entity.User) error {
-	_, err := r.Get(e.ID)
-	if err != nil {
-		return err
-	}
-	r.m[e.ID] = e
-	return nil
-}
-
-//Search users
-func (r *IRepo) Search(query string) ([]*entity.User, error) {
-	var d []*entity.User
-	for _, j := range r.m {
-		if strings.Contains(strings.ToLower(j.FirstName), query) {
-			d = append(d, j)
-		}
-	}
-	if len(d) == 0 {
-		// return nil, fmt.Errorf("not found")
-		return nil, domain.ErrNotFound
-	}
-
-	return d, nil
-}
-
-//List users
-func (r *IRepo) List() ([]*entity.User, error) {
-	var d []*entity.User
-	for _, j := range r.m {
-		d = append(d, j)
-	}
-	return d, nil
-}
-
-//Delete an user
-func (r *IRepo) Delete(id entity.ID) error {
-	if r.m[id] == nil {
-		return fmt.Errorf("not found")
-	}
-	r.m[id] = nil
-	return nil
-}

domain/repository/user/repository_mysql.go

@@ -1,178 +0,0 @@
-package user
-
-import (
-	"database/sql"
-	"fmt"
-	"time"
-
-	"github.com/eminetto/clean-architecture-go-v2/domain/entity"
-)
-
-//MySQLRepo mysql repo
-type MySQLRepo struct {
-	db *sql.DB
-}
-
-//NewMySQLRepoRepository create new repository
-func NewMySQLRepoRepository(db *sql.DB) *MySQLRepo {
-	return &MySQLRepo{
-		db: db,
-	}
-}
-
-//Create an user
-func (r *MySQLRepo) Create(e *entity.User) (entity.ID, error) {
-	stmt, err := r.db.Prepare(`
-		insert into user (id, email, password, first_name, last_name, created_at) 
-		values(?,?,?,?,?,?)`)
-	if err != nil {
-		return e.ID, err
-	}
-	_, err = stmt.Exec(
-		e.ID,
-		e.Email,
-		e.Password,
-		e.FirstName,
-		e.LastName,
-		time.Now().Format("2006-01-02"),
-	)
-	if err != nil {
-		return e.ID, err
-	}
-	err = stmt.Close()
-	if err != nil {
-		return e.ID, err
-	}
-	return e.ID, nil
-}
-
-//Get an user
-func (r *MySQLRepo) Get(id entity.ID) (*entity.User, error) {
-	return getUser(id, r.db)
-}
-
-func getUser(id entity.ID, db *sql.DB) (*entity.User, error) {
-	stmt, err := db.Prepare(`select id, email, first_name, last_name, created_at from user where id = ?`)
-	if err != nil {
-		return nil, err
-	}
-	var u entity.User
-	rows, err := stmt.Query(id)
-	if err != nil {
-		return nil, err
-	}
-	for rows.Next() {
-		err = rows.Scan(&u.ID, &u.Email, &u.FirstName, &u.LastName, &u.CreatedAt)
-	}
-	stmt, err = db.Prepare(`select book_id from book_user where user_id = ?`)
-	if err != nil {
-		return nil, err
-	}
-	rows, err = stmt.Query(id)
-	if err != nil {
-		return nil, err
-	}
-	for rows.Next() {
-		var i entity.ID
-		err = rows.Scan(&i)
-		u.Books = append(u.Books, i)
-	}
-	return &u, nil
-}
-
-//Update an user
-func (r *MySQLRepo) Update(e *entity.User) error {
-	e.UpdatedAt = time.Now()
-	_, err := r.db.Exec("update user set email = ?, password = ?, first_name = ?, last_name = ?, updated_at = ? where id = ?", e.Email, e.Password, e.FirstName, e.LastName, e.UpdatedAt.Format("2006-01-02"), e.ID)
-	if err != nil {
-		return err
-	}
-	_, err = r.db.Exec("delete from book_user where user_id = ?", e.ID)
-	if err != nil {
-		return err
-	}
-	for _, b := range e.Books {
-		_, err := r.db.Exec("insert into book_user values(?,?,?)", e.ID, b, time.Now().Format("2006-01-02"))
-		if err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-//Search users
-func (r *MySQLRepo) Search(query string) ([]*entity.User, error) {
-	stmt, err := r.db.Prepare(`select id from user where name like ?`)
-	if err != nil {
-		return nil, err
-	}
-	defer stmt.Close()
-	var ids []entity.ID
-	rows, err := stmt.Query()
-	if err != nil {
-		return nil, err
-	}
-	for rows.Next() {
-		var i entity.ID
-		err = rows.Scan(&i)
-		if err != nil {
-			return nil, err
-		}
-		ids = append(ids, i)
-	}
-	if len(ids) == 0 {
-		return nil, fmt.Errorf("not found")
-	}
-	var users []*entity.User
-	for _, id := range ids {
-		u, err := getUser(id, r.db)
-		if err != nil {
-			return nil, err
-		}
-		users = append(users, u)
-	}
-	return users, nil
-}
-
-//List users
-func (r *MySQLRepo) List() ([]*entity.User, error) {
-	stmt, err := r.db.Prepare(`select id from user`)
-	if err != nil {
-		return nil, err
-	}
-	defer stmt.Close()
-	var ids []entity.ID
-	rows, err := stmt.Query()
-	if err != nil {
-		return nil, err
-	}
-	for rows.Next() {
-		var i entity.ID
-		err = rows.Scan(&i)
-		if err != nil {
-			return nil, err
-		}
-		ids = append(ids, i)
-	}
-	if len(ids) == 0 {
-		return nil, fmt.Errorf("not found")
-	}
-	var users []*entity.User
-	for _, id := range ids {
-		u, err := getUser(id, r.db)
-		if err != nil {
-			return nil, err
-		}
-		users = append(users, u)
-	}
-	return users, nil
-}
-
-//Delete an user
-func (r *MySQLRepo) Delete(id entity.ID) error {
-	_, err := r.db.Exec("delete from user where id = ?", id)
-	if err != nil {
-		return err
-	}
-	return nil
-}

domain/usecase/book/interface.go

@@ -4,6 +4,26 @@ import (
 	"github.com/eminetto/clean-architecture-go-v2/domain/entity"
 )
 
+//Reader interface
+type Reader interface {
+	Get(id entity.ID) (*entity.Book, error)
+	Search(query string) ([]*entity.Book, error)
+	List() ([]*entity.Book, error)
+}
+
+//Writer book writer
+type Writer interface {
+	Create(e *entity.Book) (entity.ID, error)
+	Update(e *entity.Book) error
+	Delete(id entity.ID) error
+}
+
+//Repository interface
+type Repository interface {
+	Reader
+	Writer
+}
+
 //UseCase interface
 type UseCase interface {
 	GetBook(id entity.ID) (*entity.Book, error)

domain/usecase/book/mock/book.go

@@ -5,12 +5,256 @@
 package mock
 
 import (
-	reflect "reflect"
-
 	entity "github.com/eminetto/clean-architecture-go-v2/domain/entity"
 	gomock "github.com/golang/mock/gomock"
+	reflect "reflect"
 )
 
+// MockReader is a mock of Reader interface
+type MockReader struct {
+	ctrl     *gomock.Controller
+	recorder *MockReaderMockRecorder
+}
+
+// MockReaderMockRecorder is the mock recorder for MockReader
+type MockReaderMockRecorder struct {
+	mock *MockReader
+}
+
+// NewMockReader creates a new mock instance
+func NewMockReader(ctrl *gomock.Controller) *MockReader {
+	mock := &MockReader{ctrl: ctrl}
+	mock.recorder = &MockReaderMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (m *MockReader) EXPECT() *MockReaderMockRecorder {
+	return m.recorder
+}
+
+// Get mocks base method
+func (m *MockReader) Get(id entity.ID) (*entity.Book, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Get", id)
+	ret0, _ := ret[0].(*entity.Book)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Get indicates an expected call of Get
+func (mr *MockReaderMockRecorder) Get(id interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockReader)(nil).Get), id)
+}
+
+// Search mocks base method
+func (m *MockReader) Search(query string) ([]*entity.Book, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Search", query)
+	ret0, _ := ret[0].([]*entity.Book)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Search indicates an expected call of Search
+func (mr *MockReaderMockRecorder) Search(query interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Search", reflect.TypeOf((*MockReader)(nil).Search), query)
+}
+
+// List mocks base method
+func (m *MockReader) List() ([]*entity.Book, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "List")
+	ret0, _ := ret[0].([]*entity.Book)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// List indicates an expected call of List
+func (mr *MockReaderMockRecorder) List() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockReader)(nil).List))
+}
+
+// MockWriter is a mock of Writer interface
+type MockWriter struct {
+	ctrl     *gomock.Controller
+	recorder *MockWriterMockRecorder
+}
+
+// MockWriterMockRecorder is the mock recorder for MockWriter
+type MockWriterMockRecorder struct {
+	mock *MockWriter
+}
+
+// NewMockWriter creates a new mock instance
+func NewMockWriter(ctrl *gomock.Controller) *MockWriter {
+	mock := &MockWriter{ctrl: ctrl}
+	mock.recorder = &MockWriterMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (m *MockWriter) EXPECT() *MockWriterMockRecorder {
+	return m.recorder
+}
+
+// Create mocks base method
+func (m *MockWriter) Create(e *entity.Book) (entity.ID, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Create", e)
+	ret0, _ := ret[0].(entity.ID)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Create indicates an expected call of Create
+func (mr *MockWriterMockRecorder) Create(e interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockWriter)(nil).Create), e)
+}
+
+// Update mocks base method
+func (m *MockWriter) Update(e *entity.Book) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Update", e)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// Update indicates an expected call of Update
+func (mr *MockWriterMockRecorder) Update(e interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockWriter)(nil).Update), e)
+}
+
+// Delete mocks base method
+func (m *MockWriter) Delete(id entity.ID) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Delete", id)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// Delete indicates an expected call of Delete
+func (mr *MockWriterMockRecorder) Delete(id interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockWriter)(nil).Delete), id)
+}
+
+// MockRepository is a mock of Repository interface
+type MockRepository struct {
+	ctrl     *gomock.Controller
+	recorder *MockRepositoryMockRecorder
+}
+
+// MockRepositoryMockRecorder is the mock recorder for MockRepository
+type MockRepositoryMockRecorder struct {
+	mock *MockRepository
+}
+
+// NewMockRepository creates a new mock instance
+func NewMockRepository(ctrl *gomock.Controller) *MockRepository {
+	mock := &MockRepository{ctrl: ctrl}
+	mock.recorder = &MockRepositoryMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (m *MockRepository) EXPECT() *MockRepositoryMockRecorder {
+	return m.recorder
+}
+
+// Get mocks base method
+func (m *MockRepository) Get(id entity.ID) (*entity.Book, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Get", id)
+	ret0, _ := ret[0].(*entity.Book)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Get indicates an expected call of Get
+func (mr *MockRepositoryMockRecorder) Get(id interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockRepository)(nil).Get), id)
+}
+
+// Search mocks base method
+func (m *MockRepository) Search(query string) ([]*entity.Book, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Search", query)
+	ret0, _ := ret[0].([]*entity.Book)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Search indicates an expected call of Search
+func (mr *MockRepositoryMockRecorder) Search(query interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Search", reflect.TypeOf((*MockRepository)(nil).Search), query)
+}
+
+// List mocks base method
+func (m *MockRepository) List() ([]*entity.Book, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "List")
+	ret0, _ := ret[0].([]*entity.Book)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// List indicates an expected call of List
+func (mr *MockRepositoryMockRecorder) List() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockRepository)(nil).List))
+}
+
+// Create mocks base method
+func (m *MockRepository) Create(e *entity.Book) (entity.ID, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Create", e)
+	ret0, _ := ret[0].(entity.ID)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Create indicates an expected call of Create
+func (mr *MockRepositoryMockRecorder) Create(e interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockRepository)(nil).Create), e)
+}
+
+// Update mocks base method
+func (m *MockRepository) Update(e *entity.Book) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Update", e)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// Update indicates an expected call of Update
+func (mr *MockRepositoryMockRecorder) Update(e interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockRepository)(nil).Update), e)
+}
+
+// Delete mocks base method
+func (m *MockRepository) Delete(id entity.ID) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Delete", id)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// Delete indicates an expected call of Delete
+func (mr *MockRepositoryMockRecorder) Delete(id interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockRepository)(nil).Delete), id)
+}
+
 // MockUseCase is a mock of UseCase interface
 type MockUseCase struct {
 	ctrl     *gomock.Controller

domain/usecase/book/service.go

@@ -4,8 +4,6 @@ import (
 	"strings"
 	"time"
 
-	repo "github.com/eminetto/clean-architecture-go-v2/domain/repository/book"
-
 	"github.com/eminetto/clean-architecture-go-v2/domain"
 
 	"github.com/eminetto/clean-architecture-go-v2/domain/entity"
@@ -13,24 +11,24 @@ import (
 
 //Service book usecase
 type Service struct {
-	repo repo.Repository
+	repo Repository
 }
 
 //NewService create new service
-func NewService(r repo.Repository) *Service {
+func NewService(r Repository) *Service {
 	return &Service{
 		repo: r,
 	}
 }
 
-//Create a book
+//CreateBook create a book
 func (s *Service) CreateBook(e *entity.Book) (entity.ID, error) {
 	e.ID = entity.NewID()
 	e.CreatedAt = time.Now()
 	return s.repo.Create(e)
 }
 
-//Get a book
+//GetBook get a book
 func (s *Service) GetBook(id entity.ID) (*entity.Book, error) {
 	b, err := s.repo.Get(id)
 	if b == nil {
@@ -43,7 +41,7 @@ func (s *Service) GetBook(id entity.ID) (*entity.Book, error) {
 	return b, nil
 }
 
-//Search books
+//SearchBooks search books
 func (s *Service) SearchBooks(query string) ([]*entity.Book, error) {
 	books, err := s.repo.Search(strings.ToLower(query))
 	if err != nil {
@@ -55,7 +53,7 @@ func (s *Service) SearchBooks(query string) ([]*entity.Book, error) {
 	return books, nil
 }
 
-//List books
+//ListBooks list books
 func (s *Service) ListBooks() ([]*entity.Book, error) {
 	books, err := s.repo.List()
 	if err != nil {
@@ -67,7 +65,7 @@ func (s *Service) ListBooks() ([]*entity.Book, error) {
 	return books, nil
 }
 
-//Delete a book
+//DeleteBook Delete a book
 func (s *Service) DeleteBook(id entity.ID) error {
 	_, err := s.GetBook(id)
 	if err != nil {
@@ -76,7 +74,7 @@ func (s *Service) DeleteBook(id entity.ID) error {
 	return s.repo.Delete(id)
 }
 
-//Update a book
+//UpdateBook Update a book
 func (s *Service) UpdateBook(e *entity.Book) error {
 	return s.repo.Update(e)
 }

domain/usecase/book/service_test.go

@@ -5,7 +5,7 @@ import (
 
 	"github.com/eminetto/clean-architecture-go-v2/domain/entity"
 
-	"github.com/eminetto/clean-architecture-go-v2/domain/repository/book"
+	"github.com/eminetto/clean-architecture-go-v2/infra/repository/book"
 
 	"github.com/eminetto/clean-architecture-go-v2/domain"
 

domain/usecase/loan/mock/loan.go

@@ -5,10 +5,9 @@
 package mock
 
 import (
-	reflect "reflect"
-
 	entity "github.com/eminetto/clean-architecture-go-v2/domain/entity"
 	gomock "github.com/golang/mock/gomock"
+	reflect "reflect"
 )
 
 // MockUseCase is a mock of UseCase interface

domain/usecase/user/interface.go

@@ -4,6 +4,26 @@ import (
 	"github.com/eminetto/clean-architecture-go-v2/domain/entity"
 )
 
+//Reader interface
+type Reader interface {
+	Get(id entity.ID) (*entity.User, error)
+	Search(query string) ([]*entity.User, error)
+	List() ([]*entity.User, error)
+}
+
+//Writer user writer
+type Writer interface {
+	Create(e *entity.User) (entity.ID, error)
+	Update(e *entity.User) error
+	Delete(id entity.ID) error
+}
+
+//Repository interface
+type Repository interface {
+	Reader
+	Writer
+}
+
 //UseCase interface
 type UseCase interface {
 	GetUser(id entity.ID) (*entity.User, error)

domain/usecase/user/mock/user.go

@@ -5,12 +5,256 @@
 package mock
 
 import (
-	reflect "reflect"
-
 	entity "github.com/eminetto/clean-architecture-go-v2/domain/entity"
 	gomock "github.com/golang/mock/gomock"
+	reflect "reflect"
 )
 
+// MockReader is a mock of Reader interface
+type MockReader struct {
+	ctrl     *gomock.Controller
+	recorder *MockReaderMockRecorder
+}
+
+// MockReaderMockRecorder is the mock recorder for MockReader
+type MockReaderMockRecorder struct {
+	mock *MockReader
+}
+
+// NewMockReader creates a new mock instance
+func NewMockReader(ctrl *gomock.Controller) *MockReader {
+	mock := &MockReader{ctrl: ctrl}
+	mock.recorder = &MockReaderMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (m *MockReader) EXPECT() *MockReaderMockRecorder {
+	return m.recorder
+}
+
+// Get mocks base method
+func (m *MockReader) Get(id entity.ID) (*entity.User, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Get", id)
+	ret0, _ := ret[0].(*entity.User)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Get indicates an expected call of Get
+func (mr *MockReaderMockRecorder) Get(id interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockReader)(nil).Get), id)
+}
+
+// Search mocks base method
+func (m *MockReader) Search(query string) ([]*entity.User, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Search", query)
+	ret0, _ := ret[0].([]*entity.User)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Search indicates an expected call of Search
+func (mr *MockReaderMockRecorder) Search(query interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Search", reflect.TypeOf((*MockReader)(nil).Search), query)
+}
+
+// List mocks base method
+func (m *MockReader) List() ([]*entity.User, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "List")
+	ret0, _ := ret[0].([]*entity.User)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// List indicates an expected call of List
+func (mr *MockReaderMockRecorder) List() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockReader)(nil).List))
+}
+
+// MockWriter is a mock of Writer interface
+type MockWriter struct {
+	ctrl     *gomock.Controller
+	recorder *MockWriterMockRecorder
+}
+
+// MockWriterMockRecorder is the mock recorder for MockWriter
+type MockWriterMockRecorder struct {
+	mock *MockWriter
+}
+
+// NewMockWriter creates a new mock instance
+func NewMockWriter(ctrl *gomock.Controller) *MockWriter {
+	mock := &MockWriter{ctrl: ctrl}
+	mock.recorder = &MockWriterMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (m *MockWriter) EXPECT() *MockWriterMockRecorder {
+	return m.recorder
+}
+
+// Create mocks base method
+func (m *MockWriter) Create(e *entity.User) (entity.ID, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Create", e)
+	ret0, _ := ret[0].(entity.ID)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Create indicates an expected call of Create
+func (mr *MockWriterMockRecorder) Create(e interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockWriter)(nil).Create), e)
+}
+
+// Update mocks base method
+func (m *MockWriter) Update(e *entity.User) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Update", e)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// Update indicates an expected call of Update
+func (mr *MockWriterMockRecorder) Update(e interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockWriter)(nil).Update), e)
+}
+
+// Delete mocks base method
+func (m *MockWriter) Delete(id entity.ID) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Delete", id)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// Delete indicates an expected call of Delete
+func (mr *MockWriterMockRecorder) Delete(id interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockWriter)(nil).Delete), id)
+}
+
+// MockRepository is a mock of Repository interface
+type MockRepository struct {
+	ctrl     *gomock.Controller
+	recorder *MockRepositoryMockRecorder
+}
+
+// MockRepositoryMockRecorder is the mock recorder for MockRepository
+type MockRepositoryMockRecorder struct {
+	mock *MockRepository
+}
+
+// NewMockRepository creates a new mock instance
+func NewMockRepository(ctrl *gomock.Controller) *MockRepository {
+	mock := &MockRepository{ctrl: ctrl}
+	mock.recorder = &MockRepositoryMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (m *MockRepository) EXPECT() *MockRepositoryMockRecorder {
+	return m.recorder
+}
+
+// Get mocks base method
+func (m *MockRepository) Get(id entity.ID) (*entity.User, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Get", id)
+	ret0, _ := ret[0].(*entity.User)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Get indicates an expected call of Get
+func (mr *MockRepositoryMockRecorder) Get(id interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockRepository)(nil).Get), id)
+}
+
+// Search mocks base method
+func (m *MockRepository) Search(query string) ([]*entity.User, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Search", query)
+	ret0, _ := ret[0].([]*entity.User)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Search indicates an expected call of Search
+func (mr *MockRepositoryMockRecorder) Search(query interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Search", reflect.TypeOf((*MockRepository)(nil).Search), query)
+}
+
+// List mocks base method
+func (m *MockRepository) List() ([]*entity.User, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "List")
+	ret0, _ := ret[0].([]*entity.User)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// List indicates an expected call of List
+func (mr *MockRepositoryMockRecorder) List() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockRepository)(nil).List))
+}
+
+// Create mocks base method
+func (m *MockRepository) Create(e *entity.User) (entity.ID, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Create", e)
+	ret0, _ := ret[0].(entity.ID)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Create indicates an expected call of Create
+func (mr *MockRepositoryMockRecorder) Create(e interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockRepository)(nil).Create), e)
+}
+
+// Update mocks base method
+func (m *MockRepository) Update(e *entity.User) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Update", e)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// Update indicates an expected call of Update
+func (mr *MockRepositoryMockRecorder) Update(e interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockRepository)(nil).Update), e)
+}
+
+// Delete mocks base method
+func (m *MockRepository) Delete(id entity.ID) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Delete", id)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// Delete indicates an expected call of Delete
+func (mr *MockRepositoryMockRecorder) Delete(id interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockRepository)(nil).Delete), id)
+}
+
 // MockUseCase is a mock of UseCase interface
 type MockUseCase struct {
 	ctrl     *gomock.Controller

domain/usecase/user/service.go

@@ -4,8 +4,6 @@ import (
 	"strings"
 	"time"
 
-	repo "github.com/eminetto/clean-architecture-go-v2/domain/repository/user"
-
 	"github.com/eminetto/clean-architecture-go-v2/domain"
 
 	"github.com/eminetto/clean-architecture-go-v2/pkg/password"
@@ -15,19 +13,19 @@ import (
 
 //Service  interface
 type Service struct {
-	repo repo.Repository
+	repo Repository
 	pwd  password.Service
 }
 
 //NewService create new use case
-func NewService(r repo.Repository, pwd password.Service) *Service {
+func NewService(r Repository, pwd password.Service) *Service {
 	return &Service{
 		repo: r,
 		pwd:  pwd,
 	}
 }
 
-//Create an user
+//CreateUser Create an user
 func (s *Service) CreateUser(e *entity.User) (entity.ID, error) {
 	e.ID = entity.NewID()
 	e.CreatedAt = time.Now()
@@ -39,22 +37,22 @@ func (s *Service) CreateUser(e *entity.User) (entity.ID, error) {
 	return s.repo.Create(e)
 }
 
-//Get an user
+//GetUser Get an user
 func (s *Service) GetUser(id entity.ID) (*entity.User, error) {
 	return s.repo.Get(id)
 }
 
-//Search users
+//SearchUsers Search users
 func (s *Service) SearchUsers(query string) ([]*entity.User, error) {
 	return s.repo.Search(strings.ToLower(query))
 }
 
-//List users
+//ListUsers List users
 func (s *Service) ListUsers() ([]*entity.User, error) {
 	return s.repo.List()
 }
 
-//Delete an user
+//DeleteUser Delete an user
 func (s *Service) DeleteUser(id entity.ID) error {
 	u, err := s.GetUser(id)
 	if u == nil {
@@ -69,7 +67,7 @@ func (s *Service) DeleteUser(id entity.ID) error {
 	return s.repo.Delete(id)
 }
 
-//Update an user
+//UpdateUser Update an user
 func (s *Service) UpdateUser(e *entity.User) error {
 	e.UpdatedAt = time.Now()
 	return s.repo.Update(e)

domain/usecase/user/service_test.go

@@ -3,7 +3,7 @@ package user
 import (
 	"testing"
 
-	"github.com/eminetto/clean-architecture-go-v2/domain/repository/user"
+	"github.com/eminetto/clean-architecture-go-v2/infra/repository/user"
 
 	"github.com/eminetto/clean-architecture-go-v2/pkg/password"