# Retrieving All Books - Implementation

## 1 - Route Name

`GET /api/v1/books`

For the route version prefix, we can do the following.

*File: src/server.js*

```javascript
const getRouter = require('./routes')
const router = getRouter()
app.use('/api/v1', router) // add the prefix '/api/v1' to all our URIs
```

We will then proceed to include all of the book routes.

*File: src/routes/index.js*

```javascript
const express = require('express')
const router = express.Router()

const bookRoutes = require('./book.route') // all our book routes

function getRouter() {
  router.use('/books', bookRoutes) // we prefix it here as 'books'
  
  return router
}

module.exports = getRouter
```

Here, we specify and create a controller method, let's call it `getAllBooks`.

*File: src/routes/book.route.js*

```javascript
const express = require('express')
const router = express.Router()

const {
  getAllBooks
} = require('../controllers/book')

router.get('/', getAllBooks)

module.exports = router
```

This is where we will put the service layer and the response output.

*File: src/controllers/book/getAllBooks.js*

```javascript
const catchException = require('../utils/catchExceptions')

const getAllBooks = catchException(async (req, res, next) => {
  // our code goes here...
})

module.exports = getAllBooks
```

Now that all the setup is done, we can proceed with the other layers in our application.

## 2 - Input Request

None.

## 3 - Middleware

None.

## 4 - Validation

None.

## 5 - Domain

The domain layer is quite simple, we want to first create a model that satisfies all our business requirements from the user stories we have in the previous chapter. We are going to create the book model as follows.

*File: src/domain/models/book.model.js*

```javascript
const mongoose = require('mongoose')
const Schema = mongoose.Schema

const BookSchema = new mongoose.Schema({
  userId: {
    type: Schema.Types.ObjectId,
    ref: 'user'
  },
  title: {
    type: String,
    required: true
  },
  description: {
    type: String
  },
  price: {
    type: Number,
    required: true
  },
  author: {
    type: String
  },
  datePublished: {
    type: String
  },
  createdAt: {
    type: Date,
    default: Date.now
  }
})

module.exports = mongoose.model('book', BookSchema)
```

Then, we will wrap it in a repository. Remember why we are using repositories, we want to be able to create an abstraction layer between the concrete implementation of the model and our service layer so that we may swap out database types any time we want. In our case, we are using MongoDB. If for some reason in the future we decide to use something like MySQL, PostgresQL, or OracleDB, it would be much easier to swap out.

*File: src/domain/repositories/book.repository.js*

```javascript
const Model = require('../models/book.model')

// Retrieve - all
const getAll = async () => {
  return await Model.find({})
}

module.exports = {
  getAll
}
```

And finally, our service layer.

*File src/domain/services/book.service.js*

```javascript
const bookRepository = require('../repositories/book.repository')
const ApiException = require('../../utils/ApiException')
const mongoose = require('mongoose')

// Retrieve - all books
const getAllBooks = async () => {
  return bookRepository.getAll()
}

module.exports = {
  getAllBooks
}
```

## 6 - Events

None.

## 7 - Response

Here is what we will do to our controller in order to return a list of books

*File: src/controllers/book.controller.js*

```javascript
const globalResponseDto = require('../../responses/globalResponseDto')
const booksResponseDto = require('../../responses/booksResponseDto')
const catchException = require('../../utils/catchExceptions')
const bookService = require('../../domain/services/book.service')

/**
 * Gets all book listings from the database.
 */
const getAllBooks = catchException(async (req, res) => {
  const books = await bookService.getAllBooks()

  res.json(
    globalResponseDto({
      status: 'success',
      code: 200,
      message: `List of all books in the database.`,
      data: booksResponseDto(books),
      errors: null
    })
  )
})

module.exports = getAllBooks
```

*File: src/responses/bookResponseDTO.js*

```javascript
function bookResponseDTO(book) {
  return {
    id: book['id'],
    title: book['title'],
    description: book['description'],
    price: book['price'],
    author: book['author'],
    datePublished: book['datePublished']
  }
}

module.exports = bookResponseDTO
```

*File: src/responses/booksResponseDTO.js*

```javascript
const bookResponseDTO = require('./bookResponseDTO')

function booksResponseDTO(books) {
  return books.map((book) => bookResponseDTO(book))
}

module.exports = booksResponseDTO
```